#include "stopmotion.h"

// TnzCore includes

#include "menubarcommandids.h"

#include "tapp.h"

#include "tenv.h"

#include "tsystem.h"

#include "filebrowsermodel.h"

#include "penciltestpopup.h"

#include "tlevel_io.h"

#include "toutputproperties.h"

#include "filebrowserpopup.h"

#include "tunit.h"

#include "toonz/namebuilder.h"

#include "toonz/preferences.h"

#include "toonz/tcamera.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tframehandle.h"

#include "toonz/levelset.h"

#include "toonz/sceneproperties.h"

#include "toonz/toonzscene.h"

#include "toonz/tscenehandle.h"

#include "toonz/stage.h"

#include "toonz/txsheethandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/levelproperties.h"

#include "toonz/tstageobjecttree.h"

#include "toonzqt/menubarcommand.h"

#include <qapplication></qapplication>

#include <qcamera></qcamera>

#include <qcamerainfo></qcamerainfo>

#include <qcoreapplication></qcoreapplication>

#include <qdesktopwidget></qdesktopwidget>

#include <qdialog></qdialog>

#include <qfile></qfile>

#include <qstring></qstring>

#include <qtimer></qtimer>

#include <qxmlstreamwriter></qxmlstreamwriter>

#include <qxmlstreamreader></qxmlstreamreader>

// Connected camera

TEnv::IntVar StopMotionOpacity("StopMotionOpacity", 100);

TEnv::IntVar StopMotionAlwaysLiveView("StopMotionAlwaysLiveView", 0);

TEnv::IntVar StopMotionPlaceOnXSheet("StopMotionPlaceOnXSheet", 1);

TEnv::IntVar StopMotionReviewDSec("StopMotionReviewDSec", 10);

TEnv::IntVar StopMotionIntervalDSec("StopMotionIntervalDSec", 100);

TEnv::IntVar StopMotionUseNumpad("StopMotionUseNumpad", 0);

TEnv::IntVar StopMotionDrawBeneathLevels("StopMotionDrawBeneathLevels", 1);

TEnv::IntVar StopMotionPlayCaptureSound("StopMotionPlayCaptureSound", 0);

// Connected camera

TEnv::StringVar StopMotionCameraName("CamCapCameraName", "");

// Camera resolution

TEnv::StringVar StopMotionCameraResolution("CamCapCameraResolution", "");

namespace {

TPointD getCurrentCameraDpi() {

  TCamera *camera =

      TApp::instance()->getCurrentScene()->getScene()->getCurrentCamera();

  TDimensionD size = camera->getSize();

  TDimension res   = camera->getRes();

  return TPointD(res.lx / size.lx, res.ly / size.ly);

}

//-----------------------------------------------------------------------------

bool findCell(TXsheet *xsh, int col, const TXshCell &targetCell,

              int &bottomRowWithTheSameLevel) {

  bottomRowWithTheSameLevel = -1;

  TXshColumnP column        = const_cast<txsheet *="">(xsh)->getColumn(col);</txsheet>

  if (!column) return false;

  TXshCellColumn *cellColumn = column->getCellColumn();

  if (!cellColumn) return false;

  int r0, r1;

  if (!cellColumn->getRange(r0, r1)) return false;

  for (int r = r0; r <= r1; r++) {

    TXshCell cell = cellColumn->getCell(r);

    if (cell == targetCell) {

      bottomRowWithTheSameLevel = r;

      return true;

    }

    if (cell.m_level == targetCell.m_level) bottomRowWithTheSameLevel = r;

  }

  return false;

}

//-----------------------------------------------------------------------------

QChar numToLetter(int letterNum) {

  switch (letterNum) {

  case 0:

    return QChar();

    break;

  case 1:

    return 'A';

    break;

  case 2:

    return 'B';

    break;

  case 3:

    return 'C';

    break;

  case 4:

    return 'D';

    break;

  case 5:

    return 'E';

    break;

  case 6:

    return 'F';

    break;

  case 7:

    return 'G';

    break;

  case 8:

    return 'H';

    break;

  case 9:

    return 'I';

    break;

  default:

    return QChar();

    break;

  }

}

//-----------------------------------------------------------------------------

QString convertToFrameWithLetter(int value, int length = -1) {

  QString str;

  str.setNum((int)(value / 10));

  while (str.length() < length) str.push_front("0");

  QChar letter = numToLetter(value % 10);

  if (!letter.isNull()) str.append(letter);

  return str;

}

//-----------------------------------------------------------------------------

QString fidsToString(const std::vector<tframeid> &fids,</tframeid>

                     bool letterOptionEnabled) {

  if (fids.empty()) return StopMotion::tr("No", "frame id");

  QString retStr("");

  if (letterOptionEnabled) {

    bool beginBlock = true;

    for (int f = 0; f < fids.size() - 1; f++) {

      int num      = fids[f].getNumber();

      int next_num = fids[f + 1].getNumber();

      if (num % 10 == 0 && num + 10 == next_num) {

        if (beginBlock) {

          retStr += convertToFrameWithLetter(num) + " - ";

          beginBlock = false;

        }

      } else {

        retStr += convertToFrameWithLetter(num) + ", ";

        beginBlock = true;

      }

    }

    retStr += convertToFrameWithLetter(fids.back().getNumber());

  } else {

    bool beginBlock = true;

    for (int f = 0; f < fids.size() - 1; f++) {

      int num      = fids[f].getNumber();

      int next_num = fids[f + 1].getNumber();

      if (num + 1 == next_num) {

        if (beginBlock) {

          retStr += QString::number(num) + " - ";

          beginBlock = false;

        }

      } else {

        retStr += QString::number(num) + ", ";

        beginBlock = true;

      }

    }

    retStr += QString::number(fids.back().getNumber());

  }

  return retStr;

}

//-----------------------------------------------------------------------------

bool getRasterLevelSize(TXshLevel *level, TDimension &dim) {

  std::vector<tframeid> fids;</tframeid>

  level->getFids(fids);

  if (fids.empty()) return false;

  TXshSimpleLevel *simpleLevel = level->getSimpleLevel();

  if (!simpleLevel) return false;

  TRasterImageP rimg = (TRasterImageP)simpleLevel->getFrame(fids[0], false);

  if (!rimg || rimg->isEmpty()) return false;

  dim = rimg->getRaster()->getSize();

  return true;

}

};  // namespace

//-----------------------------------------------------------------------------

StopMotion::StopMotion() {

  m_opacity = StopMotionOpacity;

  m_webcam = new Webcam();

  m_canon  = Canon::instance();

  m_serial = new StopMotionSerial();

  m_light  = new StopMotionLight();

  m_alwaysLiveView = StopMotionAlwaysLiveView;

  m_placeOnXSheet      = StopMotionPlaceOnXSheet;

  m_reviewTimeDSec     = StopMotionReviewDSec;

  m_intervalDSec       = StopMotionIntervalDSec;

  m_useNumpadShortcuts = StopMotionUseNumpad;

  m_drawBeneathLevels  = StopMotionDrawBeneathLevels;

  m_playCaptureSound   = StopMotionPlayCaptureSound;

  m_numpadForStyleSwitching =

      Preferences::instance()->isUseNumpadForSwitchingStylesEnabled();

  setUseNumpadShortcuts(m_useNumpadShortcuts);

  m_turnOnRewind = Preferences::instance()->rewindAfterPlaybackEnabled();

  m_timer        = new QTimer(this);

  m_reviewTimer  = new QTimer(this);

  m_reviewTimer->setSingleShot(true);

  m_intervalTimer      = new QTimer(this);

  m_countdownTimer     = new QTimer(this);

  m_webcamOverlayTimer = new QTimer(this);

  m_camSnapSound       = new QSound(":Resources/camera_snap.wav");

  // Make the interval timer single-shot. When the capture finished, restart

  // timer for next frame.

  // This is because capturing and saving the image needs some time.

  m_intervalTimer->setSingleShot(true);

  m_webcamOverlayTimer->setSingleShot(true);

  TXsheetHandle *xsheetHandle = TApp::instance()->getCurrentXsheet();

  TSceneHandle *sceneHandle   = TApp::instance()->getCurrentScene();

  TFrameHandle *frameHandle   = TApp::instance()->getCurrentFrame();

  bool ret                    = true;

  ret = ret &&

        connect(xsheetHandle, SIGNAL(xsheetSwitched()), this, SLOT(update()));

  ret = ret && connect(m_reviewTimer, SIGNAL(timeout()), this,

                       SLOT(onReviewTimeout()));

  ret = ret && connect(m_timer, SIGNAL(timeout()), this, SLOT(onTimeout()));

  ret = ret && connect(sceneHandle, SIGNAL(sceneSwitched()), this,

                       SLOT(onSceneSwitched()));

  ret = ret && connect(frameHandle, SIGNAL(isPlayingStatusChanged()), this,

                       SLOT(onPlaybackChanged()));

  ret = ret && connect(m_intervalTimer, SIGNAL(timeout()), this,

                       SLOT(onIntervalCaptureTimerTimeout()));

  ret = ret && connect(m_webcamOverlayTimer, SIGNAL(timeout()), this,

                       SLOT(captureWebcamOnTimeout()));

  ret = ret && connect(m_canon, SIGNAL(newCanonImageReady()), this,

                       SLOT(importImage()));

  assert(ret);

  ret = ret && connect(m_canon, SIGNAL(canonCameraChanged(QString)), this,

                       SLOT(onCanonCameraChanged(QString)));

  assert(ret);

  ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();

  setToNextNewLevel();

  m_filePath = scene->getDefaultLevelPath(OVL_TYPE, m_levelName.toStdWString())

                   .getParentDir()

                   .getQString();

}

//-----------------------------------------------------------------

StopMotion::~StopMotion() {

  disconnectAllCameras();

#ifdef WITH_CANON

  m_canon->closeAll();

#endif

}

//-----------------------------------------------------------------------------

void StopMotion::onSceneSwitched() {

  disconnectAllCameras();

  TApp *app         = TApp::instance();

  ToonzScene *scene = app->getCurrentScene()->getScene();

  TXsheet *xsh      = TApp::instance()->getCurrentXsheet()->getXsheet();

  setToNextNewLevel();

  m_filePath = scene->getDefaultLevelPath(OVL_TYPE, m_levelName.toStdWString())

                   .getParentDir()

                   .getQString();

  m_frameNumber = 1;

  m_liveViewImageMap.clear();

  TLevelSet *levelSet = scene->getLevelSet();

  std::vector<txshlevel *=""> levels;</txshlevel>

  levelSet->listLevels(levels);

  int size   = levels.size();

  bool found = false;

  for (int i = 0; i < size; i++) {

    TXshLevel *level = levels[i];

    if (level->getType() == OVL_XSHLEVEL) {

      TXshSimpleLevel *sl    = 0;

      sl                     = level->getSimpleLevel();

      bool isStopMotionLevel = sl->getProperties()->isStopMotionLevel();

      if (isStopMotionLevel) {

        m_filePath    = sl->getPath().getParentDir().getQString();

        m_levelName   = QString::fromStdWString(sl->getName());

        m_frameNumber = sl->getFrameCount() + 1;

        setXSheetFrameNumber(xsh->getFrameCount() + 1);

        loadXmlFile();

        buildLiveViewMap(sl);

        m_sl  = sl;

        found = true;

        break;

      }

    }

  }

  if (!found) {

    setXSheetFrameNumber(1);

  }

  emit(levelNameChanged(m_levelName));

  emit(filePathChanged(m_filePath));

  emit(frameNumberChanged(m_frameNumber));

  emit(xSheetFrameNumberChanged(m_xSheetFrameNumber));

  refreshFrameInfo();

}

//-----------------------------------------------------------------

bool StopMotion::buildLiveViewMap(TXshSimpleLevel *sl) {

  m_liveViewImageMap.clear();

  TApp *app         = TApp::instance();

  ToonzScene *scene = app->getCurrentScene()->getScene();

  TXsheet *xsh      = scene->getXsheet();

  std::wstring levelName = m_levelName.toStdWString();

  if (levelName.empty()) {

    return false;

  }

  if (m_usingWebcam) {

    return false;

  }

  TFilePath liveViewFolder = scene->decodeFilePath(

      TFilePath(m_filePath) + TFilePath(levelName + L"_LiveView"));

  TFilePath levelFp = TFilePath(m_filePath) +

                      TFilePath(levelName + L".." + m_fileType.toStdWString());

  TFilePath actualLevelFp = scene->decodeFilePath(levelFp);

  TFilePath liveViewFp =

      scene->decodeFilePath(liveViewFolder + TFilePath(levelName + L"..jpg"));

  if (!TSystem::doesExistFileOrLevel(liveViewFolder)) return false;

  int count = sl->getFrameCount();

  std::vector<tframeid> fids;</tframeid>

  sl->getFids(fids);

  for (TFrameId id : fids) {

    int frameNumber = id.getNumber();

    if (TSystem::doesExistFileOrLevel(liveViewFp.withFrame(frameNumber))) {

      TRaster32P image;

      JpgConverter::loadJpg(liveViewFp.withFrame(frameNumber), image);

      m_liveViewImageMap.insert(std::pair<int, traster32p="">(frameNumber, image));</int,>

    }

  }

  if (m_liveViewImageMap.size() > 0) {

    return true;

  } else

    return false;

}

//-----------------------------------------------------------------

void StopMotion::disconnectAllCameras() {

#ifdef WITH_CANON

  if (m_liveViewStatus > LiveViewClosed) {

    m_canon->resetCanon(true);

  } else {

    m_canon->resetCanon(false);

  }

#endif

  if (m_usingWebcam) {

    m_webcam->releaseWebcam();

    m_usingWebcam = false;

  }

  m_webcam->clearWebcam();

  m_liveViewStatus = LiveViewClosed;

  setTEnvCameraName("");

  m_isTimeLapse     = false;

  m_intervalStarted = false;

  m_intervalTimer->stop();

  m_countdownTimer->stop();

  emit(intervalToggled(false));

  emit(liveViewChanged(false));

  emit(liveViewStopped());

  emit(newCameraSelected(0, false));

  toggleNumpadShortcuts(false);

}

//-----------------------------------------------------------------

void StopMotion::onPlaybackChanged() {

  if (TApp::instance()->getCurrentFrame()->isPlaying() ||

      m_liveViewStatus == LiveViewClosed)

    return;

  int r0, r1, step;

  ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();

  scene->getProperties()->getPreviewProperties()->getRange(r0, r1, step);

  if (r1 > -1) return;

  int frame     = TApp::instance()->getCurrentFrame()->getFrame();

  int lastFrame = TApp::instance()->getCurrentFrame()->getMaxFrameIndex();

  if (m_xSheetFrameNumber - 1 == frame + 1) {

    TApp::instance()->getCurrentFrame()->setFrame(m_xSheetFrameNumber - 1);

  }

}

//-----------------------------------------------------------------

void StopMotion::setOpacity(int opacity) {

  m_opacity         = opacity;

  StopMotionOpacity = m_opacity;

  emit(opacityChanged(m_opacity));

}

//-----------------------------------------------------------------

void StopMotion::lowerOpacity() {

  int opacity = round((double)m_opacity / 255.0 * 10.0);

  opacity *= 10;

  opacity -= 10;

  m_opacity         = double(opacity) / 100.0 * 255.0;

  m_opacity         = std::max(0, m_opacity);

  StopMotionOpacity = m_opacity;

  emit(opacityChanged(m_opacity));

}

//-----------------------------------------------------------------

void StopMotion::raiseOpacity() {

  int opacity = round((double)m_opacity / 255.0 * 10.0);

  opacity *= 10;

  opacity += 10;

  m_opacity         = double(opacity) / 100.0 * 255.0;

  m_opacity         = std::min(255, m_opacity);

  StopMotionOpacity = m_opacity;

  emit(opacityChanged(m_opacity));

}

//-----------------------------------------------------------------

void StopMotion::setAlwaysLiveView(bool on) {

  m_alwaysLiveView         = on;

  StopMotionAlwaysLiveView = int(on);

  emit(liveViewOnAllFramesSignal(on));

}

//-----------------------------------------------------------------

void StopMotion::setPlaceOnXSheet(bool on) {

  m_placeOnXSheet         = on;

  StopMotionPlaceOnXSheet = int(on);

  emit(placeOnXSheetSignal(on));

}

//-----------------------------------------------------------------

void StopMotion::setReviewTimeDSec(int timeDSec) {

  m_reviewTimeDSec     = timeDSec;

  StopMotionReviewDSec = timeDSec;

  emit(reviewTimeChangedSignal(timeDSec));

}

//-----------------------------------------------------------------

void StopMotion::jumpToCameraFrame() {

  if (m_liveViewStatus == LiveViewPaused && !m_userCalledPause) {

    m_liveViewStatus = LiveViewOpen;

  }

  if (m_hasLineUpImage) m_showLineUpImage = true;

  TApp::instance()->getCurrentFrame()->setFrame(m_xSheetFrameNumber - 1);

}

//-----------------------------------------------------------------

void StopMotion::removeStopMotionFrame() {

  if (m_xSheetFrameNumber == 1) return;

  TApp *app         = TApp::instance();

  ToonzScene *scene = app->getCurrentScene()->getScene();

  TXsheet *xsh      = scene->getXsheet();

  int row = m_xSheetFrameNumber - 2;

  // find which column the level is on.

  // check with the current column first

  int col       = app->getCurrentColumn()->getColumnIndex();

  TXshCell cell = xsh->getCell(row, col);

  TXshSimpleLevelP sl;

  bool found = false;

  if (!cell.isEmpty()) {

    if (cell.getSimpleLevel() != 0) {

      sl = cell.getSimpleLevel();

      if (sl.getPointer()->getName() == m_levelName.toStdWString()) {

        found = true;

      }

    }

  }

  if (!found) {

    int cols = xsh->getColumnCount();

    for (int i = 0; i < cols; i++) {

      cell = xsh->getCell(row, i);

      if (!cell.isEmpty()) {

        if (cell.getSimpleLevel() != 0) {

          sl = cell.getSimpleLevel();

          if (sl.getPointer()->getName() == m_levelName.toStdWString()) {

            found = true;

            col   = i;

            break;

          }

        }

      }

    }

  }

  if (!found) {

    // DVGui::error(tr("Could not find an xsheet level with  the current

    // level"));

    return;

  }

  TXshCellColumn *xshCellColumn = xsh->getColumn(col)->getCellColumn();

  if (!xshCellColumn) return;

  xshCellColumn->removeCells(row, 1);

  app->getCurrentScene()->getScene()->getXsheet()->updateFrameCount();

  setXSheetFrameNumber(m_xSheetFrameNumber - 1);

  app->getCurrentFrame()->prevFrame();

  app->getCurrentScene()->notifySceneChanged();

  app->getCurrentXsheet()->notifyXsheetChanged();

}

//-----------------------------------------------------------------

void StopMotion::setUseNumpadShortcuts(bool on) {

  m_useNumpadShortcuts = on;

  StopMotionUseNumpad  = int(on);

  emit(useNumpadSignal(on));

}

//-----------------------------------------------------------------

void StopMotion::setDrawBeneathLevels(bool on) {

  m_drawBeneathLevels         = on;

  StopMotionDrawBeneathLevels = int(on);

  emit(drawBeneathLevelsSignal(on));

}

//-----------------------------------------------------------------

void StopMotion::toggleInterval(bool on) {

  m_isTimeLapse = on;

  emit(intervalToggled(on));

}

//-----------------------------------------------------------------

void StopMotion::startInterval() {

  if (m_liveViewStatus > 1) {

    m_intervalTimer->start(m_intervalDSec * 100);

    if (m_intervalDSec != 0) m_countdownTimer->start(100);

    m_intervalStarted = true;

    emit(intervalStarted());

  } else {

    DVGui::warning(tr("Please start live view before using time lapse."));

    m_intervalStarted = false;

    emit(intervalStopped());

  }

}

//-----------------------------------------------------------------

void StopMotion::stopInterval() {

  m_intervalTimer->stop();

  m_countdownTimer->stop();

  m_intervalStarted = false;

  emit(intervalStopped());

}

//-----------------------------------------------------------------

void StopMotion::setIntervalDSec(int value) {

  m_intervalDSec         = value;

  StopMotionIntervalDSec = value;

  emit(intervalAmountChanged(value));

}

//-----------------------------------------------------------------

void StopMotion::onIntervalCaptureTimerTimeout() {

  if (m_liveViewStatus > 0) {

    captureImage();

  } else {

    DVGui::warning(tr("Please start live view before using time lapse."));

    m_intervalStarted = false;

    emit(intervalStopped());

  }

}

//-----------------------------------------------------------------

void StopMotion::restartInterval() {

  // restart interval timer for capturing next frame (it is single shot)

  if (m_isTimeLapse && m_intervalStarted) {

    m_intervalTimer->start(m_intervalDSec * 100);

    // restart the count down as well (for aligning the timing. It is not

    // single shot)

    if (m_intervalDSec != 0) m_countdownTimer->start(100);

  }

}

//-----------------------------------------------------------------

void StopMotion::toggleNumpadShortcuts(bool on) {

  // can't just return if this feature is off

  // it could have been toggled while the camera was active

  if (!m_useNumpadShortcuts) on = false;

  CommandManager *comm = CommandManager::instance();

  if (on) {

    m_oldActionMap.clear();

    // if turning it on, get all old shortcuts

    if (m_numpadForStyleSwitching) {

      Preferences::instance()->setValue(useNumpadForSwitchingStyles, false);

    }

    std::string shortcut;

    QAction *action;

    for (int i = 0; i <= 9; i++) {

      shortcut = QString::number(i).toStdString();

      action   = comm->getActionFromShortcut(shortcut);

      if (action) {

        m_oldActionMap.insert(

            std::pair<std::string, *="" qaction="">(shortcut, action));</std::string,>

        action->setShortcut(QKeySequence(""));

        action = NULL;

      }

    }

    shortcut = "+";

    action   = comm->getActionFromShortcut(shortcut);

    if (action) {

      m_oldActionMap.insert(

          std::pair<std::string, *="" qaction="">(shortcut, action));</std::string,>

      action->setShortcut(QKeySequence(""));

      action = NULL;

    }

    shortcut = "-";

    action   = comm->getActionFromShortcut(shortcut);

    if (action) {

      m_oldActionMap.insert(

          std::pair<std::string, *="" qaction="">(shortcut, action));</std::string,>

      action->setShortcut(QKeySequence(""));

      action = NULL;

    }

    shortcut = "Enter";

    action   = comm->getActionFromShortcut(shortcut);

    if (action) {

      m_oldActionMap.insert(

          std::pair<std::string, *="" qaction="">(shortcut, action));</std::string,>

      action->setShortcut(QKeySequence(""));

      action = NULL;

    }

    shortcut = "Backspace";

    action   = comm->getActionFromShortcut(shortcut);

    if (action) {

      m_oldActionMap.insert(

          std::pair<std::string, *="" qaction="">(shortcut, action));</std::string,>

      action->setShortcut(QKeySequence(""));

      action = NULL;

    }

    shortcut = "Return";

    action   = comm->getActionFromShortcut(shortcut);

    if (action) {

      m_oldActionMap.insert(

          std::pair<std::string, *="" qaction="">(shortcut, action));</std::string,>

      action->setShortcut(QKeySequence(""));

      action = NULL;

    }

    shortcut = "*";

    action   = comm->getActionFromShortcut(shortcut);

    if (action) {

      m_oldActionMap.insert(

          std::pair<std::string, *="" qaction="">(shortcut, action));</std::string,>

      action->setShortcut(QKeySequence(""));

      action = NULL;

    }

    shortcut = ".";

    action   = comm->getActionFromShortcut(shortcut);

    if (action) {

      m_oldActionMap.insert(

          std::pair<std::string, *="" qaction="">(shortcut, action));</std::string,>

      action->setShortcut(QKeySequence(""));

      action = NULL;

    }

    shortcut = "/";

    action   = comm->getActionFromShortcut(shortcut);

    if (action) {

      m_oldActionMap.insert(

          std::pair<std::string, *="" qaction="">(shortcut, action));</std::string,>

      action->setShortcut(QKeySequence(""));

      action = NULL;

    }

    // now set all new shortcuts

    action = comm->getAction(MI_PrevFrame);

    if (action) {

      action->setShortcut(QKeySequence("1"));

      action = NULL;

    }

    action = comm->getAction(MI_StopMotionNextFrame);

    if (action) {

      action->setShortcut(QKeySequence("2"));

      action = NULL;

    }

    action = comm->getAction(MI_StopMotionJumpToCamera);

    if (action) {

      action->setShortcut(QKeySequence("3"));

      action = NULL;

    }

    action = comm->getAction(MI_Loop);

    if (action) {

      action->setShortcut(QKeySequence("8"));

      action = NULL;

    }

    action = comm->getAction(MI_Play);

    if (action) {

      action->setShortcut(QKeySequence("0"));

      action = NULL;

    }

    action = comm->getAction(MI_StopMotionRaiseOpacity);

    if (action) {

      action->setShortcut(QKeySequence("+"));

      action = NULL;

    }

    action = comm->getAction(MI_StopMotionLowerOpacity);

    if (action) {

      action->setShortcut(QKeySequence("-"));

      action = NULL;

    }

    action = comm->getAction(MI_StopMotionCapture);

    if (action) {

      action->setShortcut(QKeySequence("Return"));

      action = NULL;

    }

    action = comm->getAction(MI_StopMotionRemoveFrame);

    if (action) {

      action->setShortcut(QKeySequence("Backspace"));

      action = NULL;

    }

    action = comm->getAction(MI_StopMotionToggleLiveView);

    if (action) {

      action->setShortcut(QKeySequence("5"));

      action = NULL;

    }

    action = comm->getAction(MI_StopMotionToggleUseLiveViewImages);

    if (action) {

      action->setShortcut(QKeySequence("."));

      action = NULL;

    }

    action = comm->getAction(MI_StopMotionToggleZoom);

    if (action) {

      action->setShortcut(QKeySequence("*"));

      action = NULL;

    }

    action = comm->getAction(MI_StopMotionPickFocusCheck);

    if (action) {

      action->setShortcut(QKeySequence("/"));

      action = NULL;

    }

    action = comm->getAction(MI_ShortPlay);

    if (action) {

      action->setShortcut(QKeySequence("6"));

      action = NULL;

    }

  } else {

    // unset the new shortcuts first

    if (m_oldActionMap.size() > 0) {

      QAction *action;

      action = comm->getAction(MI_PrevFrame);

      if (action) {

        action->setShortcut(

            QKeySequence(comm->getShortcutFromAction(action).c_str()));

        action = NULL;

      }

      action = comm->getAction(MI_StopMotionNextFrame);

      if (action) {

        action->setShortcut(

            QKeySequence(comm->getShortcutFromAction(action).c_str()));

        action = NULL;

      }

      action = comm->getAction(MI_StopMotionJumpToCamera);

      if (action) {

        action->setShortcut(

            QKeySequence(comm->getShortcutFromAction(action).c_str()));

        action = NULL;

      }

      action = comm->getAction(MI_Loop);

      if (action) {

        action->setShortcut(

            QKeySequence(comm->getShortcutFromAction(action).c_str()));

        action = NULL;

      }

      action = comm->getAction(MI_Play);

      if (action) {

        action->setShortcut(

            QKeySequence(comm->getShortcutFromAction(action).c_str()));

        action = NULL;

      }

      action = comm->getAction(MI_StopMotionCapture);

      if (action) {

        action->setShortcut(

            QKeySequence(comm->getShortcutFromAction(action).c_str()));

        action = NULL;

      }

      action = comm->getAction(MI_StopMotionLowerOpacity);

      if (action) {

        action->setShortcut(

            QKeySequence(comm->getShortcutFromAction(action).c_str()));

        action = NULL;

      }

      action = comm->getAction(MI_StopMotionRaiseOpacity);

      if (action) {

        action->setShortcut(

            QKeySequence(comm->getShortcutFromAction(action).c_str()));

        action = NULL;

      }

      action = comm->getAction(MI_StopMotionToggleLiveView);

      if (action) {

        action->setShortcut(

            QKeySequence(comm->getShortcutFromAction(action).c_str()));

        action = NULL;

      }

      action = comm->getAction(MI_StopMotionToggleUseLiveViewImages);

      if (action) {

        action->setShortcut(

            QKeySequence(comm->getShortcutFromAction(action).c_str()));

        action = NULL;

      }

      action = comm->getAction(MI_StopMotionToggleZoom);

      if (action) {

        action->setShortcut(

            QKeySequence(comm->getShortcutFromAction(action).c_str()));

        action = NULL;

      }

      action = comm->getAction(MI_ShortPlay);

      if (action) {

        action->setShortcut(

            QKeySequence(comm->getShortcutFromAction(action).c_str()));

        action = NULL;

      }

      action = comm->getAction(MI_StopMotionPickFocusCheck);

      if (action) {

        action->setShortcut(

            QKeySequence(comm->getShortcutFromAction(action).c_str()));

        action = NULL;