#include "stopmotion.h"

#ifdef WIN32

#include <windows.h></windows.h>

#include <mfobjects.h></mfobjects.h>

#include <mfapi.h></mfapi.h>

#include <mfidl.h></mfidl.h>

#pragma comment(lib, "Mfplat.lib")

#pragma comment(lib, "Mf.lib")

#pragma comment(lib, "Mfreadwrite.lib")

#pragma comment(lib, "mfuuid.lib")

#pragma comment(lib, "shlwapi.lib")

#endif

// 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 "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/txshsimplelevel.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>

// Connected camera

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

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

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

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

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

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

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

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

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

// Connected camera

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

// Camera resolution

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

namespace {

bool l_quitLoop = false;

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

//=============================================================================

//=============================================================================

JpgConverter::JpgConverter() {}

JpgConverter::~JpgConverter() {}

void JpgConverter::setStream(EdsStreamRef stream) { m_stream = stream; }

void JpgConverter::convertFromJpg() {

  unsigned __int64 mySize = 0;

  unsigned char *data     = NULL;

  EdsError err            = EdsGetPointer(m_stream, (EdsVoid **)&data);

  err                     = EdsGetLength(m_stream, &mySize);

  int width, height, pixelFormat;

  int inSubsamp, inColorspace;

  tjhandle tjInstance   = NULL;

  unsigned char *imgBuf = NULL;

  tjInstance            = tjInitDecompress();

  tjDecompressHeader3(tjInstance, data, mySize, &width, &height, &inSubsamp,

                      &inColorspace);

  if (width < 0 || height < 0) {

    emit(imageReady(false));

    return;

  }

  pixelFormat = TJPF_BGRX;

  imgBuf = (unsigned char *)tjAlloc(width * height * tjPixelSize[pixelFormat]);

  int flags = 0;

#ifdef WIN32

  flags |= TJFLAG_BOTTOMUP;

#endif

  int factorsNum;

  tjscalingfactor scalingFactor = {1, 1};

  tjscalingfactor *factor       = tjGetScalingFactors(&factorsNum);

  int i                         = 0;

  int tempWidth, tempHeight;

  while (i < factorsNum) {

    scalingFactor = factor[i];

    i++;

    tempWidth  = TJSCALED(width, scalingFactor);

    tempHeight = TJSCALED(height, scalingFactor);

  }

  tjDecompress2(tjInstance, data, mySize, imgBuf, width,

                width * tjPixelSize[pixelFormat], height, pixelFormat, flags);

  m_finalImage = TRaster32P(width, height);

  m_finalImage->lock();

  uchar *rawData = m_finalImage->getRawData();

  memcpy(rawData, imgBuf, width * height * tjPixelSize[pixelFormat]);

  m_finalImage->unlock();

  tjFree(imgBuf);

  imgBuf = NULL;

  tjDestroy(tjInstance);

  tjInstance = NULL;

  if (m_stream != NULL) {

    EdsRelease(m_stream);

    m_stream = NULL;

  }

  data = NULL;

  emit(imageReady(true));

}

void JpgConverter::run() { convertFromJpg(); }

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

StopMotion::StopMotion() {

  m_opacity         = StopMotionOpacity;

  m_useScaledImages = StopMotionUseScaledImages;

  buildAvMap();

  buildIsoMap();

  buildTvMap();

  buildModeMap();

  buildExposureMap();

  buildWhiteBalanceMap();

  buildColorTemperatures();

  buildImageQualityMap();

  buildPictureStyleMap();

  m_useDirectShow      = StopMotionUseDirectShow;

  m_useMjpg            = StopMotionUseMjpg;

  m_alwaysLiveView     = StopMotionAlwaysLiveView;

  m_blackCapture       = StopMotionBlackCapture;

  m_placeOnXSheet      = StopMotionPlaceOnXSheet;

  m_reviewTime         = StopMotionReviewTime;

  m_useNumpadShortcuts = StopMotionUseNumpad;

  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_fullScreen1 = new QDialog();

  m_fullScreen1->setModal(false);

  m_fullScreen1->setStyleSheet("background-color:black;");

  m_screenCount = QApplication::desktop()->screenCount();

  if (m_screenCount > 1) {

    m_fullScreen2 = new QDialog();

    m_fullScreen2->setModal(false);

    m_fullScreen2->setStyleSheet("background-color:black;");

    if (m_screenCount == 3) {

      m_fullScreen3 = new QDialog();

      m_fullScreen3->setModal(false);

      m_fullScreen3->setStyleSheet("background-color:black;");

    }

  }

  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(this, SIGNAL(newImageReady()), this, SLOT(importImage()));

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

                       SLOT(onSceneSwitched()));

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

                       SLOT(onPlaybackChanged()));

  assert(ret);

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

  setToNextNewLevel();

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

                   .getParentDir()

                   .getQString();

  // set handler for a camera detected

  initializeCanonSDK();

  if (!m_error)

    m_error = EdsSetCameraAddedHandler(StopMotion::handleCameraAddedEvent,

                                       (EdsVoid *)this);

}

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

StopMotion::~StopMotion() {

  if (m_liveViewStatus != LiveViewClosed) endLiveView();

  if (m_sessionOpen) closeCameraSession();

  if (m_camera) releaseCamera();

  if (m_cameraList != NULL) releaseCameraList();

  if (m_isSDKLoaded) closeCanonSDK();

  setUseNumpadShortcuts(false);

}

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

void StopMotion::onSceneSwitched() {

  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_xSheetFrameNumber = 0;

  TLevelSet *levelSet = scene->getLevelSet();

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

  levelSet->listLevels(levels);

  int size = levels.size();

  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);

        break;

      }

    }

  }

  emit(levelNameChanged(m_levelName));

  emit(filePathChanged(m_filePath));

  emit(frameNumberChanged(m_frameNumber));

  emit(xSheetFrameNumberChanged(m_xSheetFrameNumber));

  refreshFrameInfo();

}

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

void StopMotion::onPlaybackChanged() {

  if (TApp::instance()->getCurrentFrame()->isPlaying() || m_liveViewStatus == 0)

    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 (frame == 0 || frame == lastFrame) {

    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::setUseScaledImages(bool on) {

  m_useScaledImages         = on;

  StopMotionUseScaledImages = int(on);

  emit(scaleFullSizeImagesSignal(on));

}

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

void StopMotion::setAlwaysLiveView(bool on) {

  m_alwaysLiveView         = on;

  StopMotionAlwaysLiveView = int(on);

  emit(liveViewOnAllFramesSignal(on));

}

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

void StopMotion::setBlackCapture(bool on) {

  m_blackCapture         = on;

  StopMotionBlackCapture = int(on);

  emit(blackCaptureSignal(on));

}

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

void StopMotion::setPlaceOnXSheet(bool on) {

  m_placeOnXSheet         = on;

  StopMotionPlaceOnXSheet = int(on);

  emit(placeOnXSheetSignal(on));

}

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

void StopMotion::setReviewTime(int time) {

  m_reviewTime         = time;

  StopMotionReviewTime = time;

  emit(reviewTimeChangedSignal(time));

}

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

void StopMotion::setUseMjpg(bool on) {

  m_useMjpg         = on;

  StopMotionUseMjpg = int(on);

  emit(useMjpgSignal(on));

}

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

void StopMotion::jumpToCameraFrame() {

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

}

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

void StopMotion::setUseNumpadShortcuts(bool on) {

  m_useNumpadShortcuts = on;

  StopMotionUseNumpad  = int(on);

  emit(useNumpadSignal(on));

}

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) {

    // 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 = NULL;

    }

    shortcut = "-";

    action   = comm->getActionFromShortcut(shortcut);

    if (action) {

      m_oldActionMap.insert(

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

      action = NULL;

    }

    shortcut = "Return";

    action   = comm->getActionFromShortcut(shortcut);

    if (action) {

      m_oldActionMap.insert(

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

      action = NULL;

    }

    shortcut = "*";

    action   = comm->getActionFromShortcut(shortcut);

    if (action) {

      m_oldActionMap.insert(

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

      action = NULL;

    }

    // now set all new shortcuts

    action = comm->getAction(MI_PrevDrawing);

    if (action) {

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

      action = NULL;

    }

    action = comm->getAction(MI_NextDrawing);

    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("Enter"));

      action = NULL;

    }

    action = comm->getAction(MI_StopMotionToggleLiveView);

    if (action) {

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

      action = NULL;

    }

    action = comm->getAction(MI_StopMotionToggleZoom);

    if (action) {

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

      action = NULL;

    }

  } else {

    // unset the new shortcuts first

    QAction *action;

    action = comm->getAction(MI_PrevDrawing);

    if (action) {

      action->setShortcut(

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

      action = NULL;

    }

    action = comm->getAction(MI_NextDrawing);

    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_StopMotionToggleZoom);

    if (action) {

      action->setShortcut(

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

      action = NULL;

    }

    // now put back the old shortcuts

    auto it = m_oldActionMap.begin();

    while (it != m_oldActionMap.end()) {

      it->second->setShortcut(QKeySequence(it->first.c_str()));

      it++;

    }

    if (m_numpadForStyleSwitching) {

      std::string shortcut;

      QAction *action;

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

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

        action   = comm->getActionFromShortcut(shortcut);

        if (action) {

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

          action = NULL;

        }

      }

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

    }

  }

}

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

void StopMotion::setXSheetFrameNumber(int frameNumber) {

  m_xSheetFrameNumber = frameNumber;

  loadLineUpImage();

  emit(xSheetFrameNumberChanged(m_xSheetFrameNumber));

  TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

}

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

bool StopMotion::loadLineUpImage() {

  if (m_liveViewStatus < 1) return false;

  m_hasLineUpImage = false;

  // first see if the level exists in the current level set

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

  TLevelSet *levelSet      = currentScene->getLevelSet();

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

  // level with the same name

  TXshLevel *level_sameName = levelSet->getLevel(levelName);

  TFilePath levelFp = TFilePath(m_filePath) +

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

  // level with the same path

  TXshLevel *level_samePath = levelSet->getLevel(*(currentScene), levelFp);

  TFilePath actualLevelFp = currentScene->decodeFilePath(levelFp);

  TXshSimpleLevelP sl;

  if (level_sameName && level_samePath && level_sameName == level_samePath) {

    sl                 = dynamic_cast<txshsimplelevel *="">(level_sameName);</txshsimplelevel>

    bool isRasterLevel = sl && (sl->getType() == OVL_XSHLEVEL);

    if (!isRasterLevel) {

      return false;

    }

  } else

    return false;

  // next we need to find the column the level is on

  TApp *app    = TApp::instance();

  TXsheet *xsh = currentScene->getXsheet();

  int row;

  if (m_xSheetFrameNumber == 1) {

    row = 0;

  } else {

    row = m_xSheetFrameNumber - 2;

  }

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

  int foundCol = -1;

  // most possibly, it's in the current column

  int rowCheck;

  findCell(xsh, col, TXshCell(level_sameName, TFrameId(1)), rowCheck);

  if (rowCheck >= 0) {

    foundCol = col;

  } else {

    // search entire xsheet

    for (int c = 0; c < xsh->getColumnCount(); c++) {

      if (c == col) continue;

      findCell(xsh, c, TXshCell(level_sameName, TFrameId(1)), rowCheck);

      if (rowCheck >= 0) {

        foundCol = c;

      }

    }

  }

  if (rowCheck < 0) return false;

  // note found row represents the last row found that uses

  // the active level

  TFrameId frameId = xsh->getCell(row, foundCol).getFrameId();

  int frameNumber = frameId.getNumber();

  if (m_usingWebcam) {

    if (frameNumber > 0) {

      m_lineUpImage    = sl->getFrame(frameId, false)->raster();

      m_hasLineUpImage = true;

      return true;

    } else

      return false;

  }

  // now check to see if a file actually exists there

  TFilePath liveViewFolder = currentScene->decodeFilePath(

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

  TFilePath liveViewFp = currentScene->decodeFilePath(

      liveViewFolder + TFilePath(levelName + L"..jpg"));

  TFilePath liveViewFile(liveViewFp.withFrame(frameNumber));

  if (TFileStatus(liveViewFile).doesExist()) {

    if (loadJpg(liveViewFile, m_lineUpImage)) {

      m_hasLineUpImage = true;

      return true;

    }

  }

  return false;

}

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

void StopMotion::setFrameNumber(int frameNumber) {

  m_frameNumber = frameNumber;

  emit(frameNumberChanged(m_frameNumber));

}

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

void StopMotion::nextFrame() {

  if (Preferences::instance()->isShowFrameNumberWithLettersEnabled()) {

    int f = m_frameNumber;

    if (f % 10 == 0)  // next number

      m_frameNumber = ((int)(f / 10) + 1) * 10;

    else  // next alphabet

      m_frameNumber = f + 1;

  } else

    m_frameNumber = m_frameNumber + 1;

  emit(frameNumberChanged(m_frameNumber));

  refreshFrameInfo();

}

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

void StopMotion::lastFrame() {}

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

void StopMotion::previousFrame() {

  int f = m_frameNumber;

  if (f > 1) {

    if (Preferences::instance()->isShowFrameNumberWithLettersEnabled()) {

      if (f % 10 == 0)  // next number

        m_frameNumber = ((int)(f / 10) - 1) * 10;

      else  // next alphabet

        m_frameNumber = f - 1;

    } else

      m_frameNumber = f - 1;

    emit(frameNumberChanged(m_frameNumber));

    refreshFrameInfo();

  }

}

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

void StopMotion::setLevelName(QString levelName) { m_levelName = levelName; }

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

void StopMotion::nextName() {

  std::unique_ptr<flexiblenamecreator> nameCreator(new FlexibleNameCreator());</flexiblenamecreator>

  if (!nameCreator->setCurrent(m_levelName.toStdWString())) {

    setToNextNewLevel();

    return;

  }

  std::wstring levelName = nameCreator->getNext();

  updateLevelNameAndFrame(levelName);

}

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

void StopMotion::previousName() {

  std::unique_ptr<flexiblenamecreator> nameCreator(new FlexibleNameCreator());</flexiblenamecreator>