#include "gphotocam.h"
#include "stopmotion.h"
#include "tapp.h"

#include "toonz/tscenehandle.h"
#include "toonz/tcamera.h"
#include "toonz/toonzscene.h"
#include "toonz/stage.h"

#include <QCoreApplication>
#include <QFile>

#if defined(_WIN32)
#include <io.h>
#else
#include <unistd.h>
#endif
#include <fcntl.h>

#define EVENTTIMER_INTERVAL 40
#define DOGPSLEEP_INTERVAL 100

void doGPSleep(int ms) {
  if (ms <= 0) return;

#ifdef Q_OS_WIN
  Sleep(uint(ms));
#else
  struct timespec ts = {ms / 1000, (ms % 1000) * 1000 * 1000};
  nanosleep(&ts, NULL);
#endif
}

#ifdef WITH_GPHOTO2
#include <QDebug>

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

static void logdump(GPLogLevel level, const char *domain, const char *str,
                    void *data) {
  if (level == GP_LOG_ERROR)
    qDebug() << "[GP_ERROR] " << QString(str);
  else if (level == GP_LOG_VERBOSE) {
    qDebug() << "[GP_VERBOSE] " << QString(str);
  } else if (level == GP_LOG_DEBUG) {
    qDebug() << "[GP_DEBUG] " << QString(str);
  } else if (level == GP_LOG_DATA) {
    qDebug() << "[GP_DATA] " << QString(str);
  } else
    qDebug() << "[GP_UNKNOWN] " << QString(str);
}
#endif

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

GPhotoCam::GPhotoCam() {
  m_count       = 0;
  m_gphotoIndex = -1;
  m_sessionOpen = false;

  m_eventTimer        = new QTimer(this);
  m_capturePreview    = false;
  m_captureImage      = false;
  m_previewImageReady = false;

#ifdef WITH_GPHOTO2
  m_cameraListMaster    = NULL;
  m_portInfoList        = NULL;
  m_cameraListDetected  = NULL;
  m_camera              = NULL;
  m_cameraImageFilePath = new CameraFilePath;

  m_gpContext = gp_context_new();
  gp_log_add_func(GP_LOG_ERROR, logdump, NULL);

  // Load all the camera drivers we have...
  int retVal = gp_abilities_list_new(&m_cameraListMaster);
  if (retVal >= GP_OK) gp_abilities_list_load(m_cameraListMaster, m_gpContext);

  // Load all the port drivers we have...
  retVal = gp_port_info_list_new(&m_portInfoList);
  if (retVal >= GP_OK) gp_port_info_list_load(m_portInfoList);

  gp_file_new(&m_previewFile);
  connect(m_eventTimer, SIGNAL(timeout()), this, SLOT(onTimeout()));
#endif
}

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

GPhotoCam::~GPhotoCam() {
#ifdef WITH_GPHOTO2
  gp_file_unref(m_previewFile);
#endif
}

int GPhotoCam::getCameraCount() {
  m_count = 0;

#ifdef WITH_GPHOTO2
  if (m_cameraListDetected == NULL)
    gp_list_new(&m_cameraListDetected);
  else
    gp_list_reset(m_cameraListDetected);

  if (m_cameraListDetected != NULL) {
    m_count = gp_camera_autodetect(m_cameraListDetected, m_gpContext);
    if (m_count < 0) m_count = 0;
  }
#endif

  return m_count;
}

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

void GPhotoCam::resetGphotocam(bool liveViewOpen) {
#ifdef WITH_GPHOTO2
  m_proxyImageDimensions = TDimension(0, 0);

  if (m_sessionOpen && getCameraCount() > 0) {
    if (liveViewOpen) {
      endLiveView();
    }
    closeCameraSession();
  }

#endif
}

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

void GPhotoCam::loadCameraConfigKeys(QString manufacturer) {
  int i = sizeof(cameraConfigKeys) - 1;

  if (manufacturer.contains("Canon"))
    i = 0;
  else if (manufacturer.contains("Nikon"))
    i = 1;

  m_configKeys.modeKey         = cameraConfigKeys[i].keys.modeKey;
  m_configKeys.batteryLevelKey = cameraConfigKeys[i].keys.batteryLevelKey;
  m_configKeys.shutterSpeedKey = cameraConfigKeys[i].keys.shutterSpeedKey;
  m_configKeys.apertureKey     = cameraConfigKeys[i].keys.apertureKey;
  m_configKeys.isoKey          = cameraConfigKeys[i].keys.isoKey;
  m_configKeys.whiteBalanceKey = cameraConfigKeys[i].keys.whiteBalanceKey;
  m_configKeys.pictureStyleKey = cameraConfigKeys[i].keys.pictureStyleKey;
  m_configKeys.imageQualityKey = cameraConfigKeys[i].keys.imageQualityKey;
  m_configKeys.imageSizeKey    = cameraConfigKeys[i].keys.imageSizeKey;
  m_configKeys.exposureCompensationKey =
      cameraConfigKeys[i].keys.exposureCompensationKey;
  m_configKeys.colorTemperatureKey =
      cameraConfigKeys[i].keys.colorTemperatureKey;
  m_configKeys.manualFocusDriveKey =
      cameraConfigKeys[i].keys.manualFocusDriveKey;
  m_configKeys.afPositionKey = cameraConfigKeys[i].keys.afPositionKey;
  m_configKeys.viewfinderKey = cameraConfigKeys[i].keys.viewfinderKey;
  m_configKeys.focusInfoKey  = cameraConfigKeys[i].keys.focusInfoKey;
}

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

enum EventTrigger {
  NoTrigger = 0,
  BatteryLevel,
  ImageSize,
  ImageQuality,
  Whitebalance,
  Aperture,
  ShutterSpeed,
  Mode,
  ISO,
  ExposureCompensation,
  PictureStyle,
  ColorTemperature
};

EventTrigger checkEventCode(QString manufacturer, char *evtdata) {
  // Generic
  if (strstr(evtdata, "5001")) return EventTrigger::BatteryLevel;
  if (strstr(evtdata, "5003")) return EventTrigger::ImageSize;
  if (strstr(evtdata, "5004")) return EventTrigger::ImageQuality;
  if (strstr(evtdata, "5005")) return EventTrigger::Whitebalance;
  if (strstr(evtdata, "5007")) return EventTrigger::Aperture;
  if (strstr(evtdata, "500d")) return EventTrigger::ShutterSpeed;
  if (strstr(evtdata, "500e")) return EventTrigger::Mode;
  if (strstr(evtdata, "500f")) return EventTrigger::ISO;
  if (strstr(evtdata, "5010")) return EventTrigger::ExposureCompensation;

  if (manufacturer.contains("Canon")) {
    if (strstr(evtdata, "d005") || strstr(evtdata, "d105") ||
        strstr(evtdata, "d138"))
      return EventTrigger::Mode;
    if (strstr(evtdata, "d006") || strstr(evtdata, "d120"))
      return EventTrigger::ImageQuality;
    if (strstr(evtdata, "d008")) return EventTrigger::ImageSize;
    if (strstr(evtdata, "d013") || strstr(evtdata, "d109"))
      return EventTrigger::Whitebalance;
    if (strstr(evtdata, "d01c") || strstr(evtdata, "d103"))
      return EventTrigger::ISO;
    if (strstr(evtdata, "d01d") || strstr(evtdata, "d101"))
      return EventTrigger::Aperture;
    if (strstr(evtdata, "d01e") || strstr(evtdata, "d102"))
      return EventTrigger::ShutterSpeed;
    if (strstr(evtdata, "d01f") || strstr(evtdata, "d104"))
      return EventTrigger::ExposureCompensation;
    if (strstr(evtdata, "d10a")) return EventTrigger::ColorTemperature;
    if (strstr(evtdata, "d110")) return EventTrigger::PictureStyle;
    if (strstr(evtdata, "d111") || strstr(evtdata, "d1a6"))
      return EventTrigger::BatteryLevel;
  } else if (manufacturer.contains("Nikon")) {
    if (strstr(evtdata, "d038")) return EventTrigger::Mode;
    if (strstr(evtdata, "d058")) return EventTrigger::ExposureCompensation;
    if (strstr(evtdata, "f002") || strstr(evtdata, "d100"))
      return EventTrigger::ISO;
    if (strstr(evtdata, "f003") || strstr(evtdata, "d087"))
      return EventTrigger::Aperture;
    if (strstr(evtdata, "f004")) return EventTrigger::ShutterSpeed;
    if (strstr(evtdata, "f009") || strstr(evtdata, "d031"))
      return EventTrigger::ImageQuality;
    if (strstr(evtdata, "f00a")) return EventTrigger::ImageSize;
    if (strstr(evtdata, "f00c")) return EventTrigger::Whitebalance;
  } else if (manufacturer.contains("Kodak")) {
    if (strstr(evtdata, "d001")) return EventTrigger::ColorTemperature;
  } else if (manufacturer.contains("Fuji")) {
    if (strstr(evtdata, "d218")) return EventTrigger::Aperture;
    if (strstr(evtdata, "d242")) return EventTrigger::BatteryLevel;
    if (strstr(evtdata, "d017")) return EventTrigger::ColorTemperature;
    if (strstr(evtdata, "d018")) return EventTrigger::ImageQuality;
    if (strstr(evtdata, "d219")) return EventTrigger::ShutterSpeed;
  } else if (manufacturer.contains("Olympus")) {
    if (strstr(evtdata, "d002")) return EventTrigger::Aperture;
    if (strstr(evtdata, "d008")) return EventTrigger::ExposureCompensation;
    if (strstr(evtdata, "d00d")) return EventTrigger::ImageQuality;
    if (strstr(evtdata, "d007")) return EventTrigger::ISO;
    if (strstr(evtdata, "d01c")) return EventTrigger::ShutterSpeed;
    if (strstr(evtdata, "d01e")) return EventTrigger::Whitebalance;
  } else if (manufacturer.contains("Panasonic")) {
    if (strstr(evtdata, "02000040")) return EventTrigger::Aperture;
    if (strstr(evtdata, "02000080")) return EventTrigger::Mode;
    if (strstr(evtdata, "02000060")) return EventTrigger::ExposureCompensation;
    if (strstr(evtdata, "020000a2")) return EventTrigger::ImageQuality;
    if (strstr(evtdata, "02000020")) return EventTrigger::ISO;
    if (strstr(evtdata, "02000030")) return EventTrigger::ShutterSpeed;
    if (strstr(evtdata, "02000050")) return EventTrigger::Whitebalance;
  } else if (manufacturer.contains("RICOH")) {
    if (strstr(evtdata, "d00f")) return EventTrigger::ShutterSpeed;
  } else if (manufacturer.contains("Sigma")) {
    if (strstr(evtdata, "d002")) return EventTrigger::Aperture;
    if (strstr(evtdata, "d006")) return EventTrigger::BatteryLevel;
    if (strstr(evtdata, "d005")) return EventTrigger::ExposureCompensation;
    if (strstr(evtdata, "d004")) return EventTrigger::ISO;
    if (strstr(evtdata, "d001")) return EventTrigger::ShutterSpeed;
  } else if (manufacturer.contains("Sony")) {
    if (strstr(evtdata, "d6c5")) return EventTrigger::Aperture;
    if (strstr(evtdata, "d218") || strstr(evtdata, "d6f1"))
      return EventTrigger::BatteryLevel;
    if (strstr(evtdata, "d20f") || strstr(evtdata, "d6f0"))
      return EventTrigger::ColorTemperature;
    if (strstr(evtdata, "d224") || strstr(evtdata, "d6c3"))
      return EventTrigger::ExposureCompensation;
    if (strstr(evtdata, "d6b7")) return EventTrigger::ImageSize;
    if (strstr(evtdata, "d203")) return EventTrigger::ImageQuality;
    if (strstr(evtdata, "d21e") || strstr(evtdata, "d6f2"))
      return EventTrigger::ISO;
    if (strstr(evtdata, "d20d") || strstr(evtdata, "d6ea"))
      return EventTrigger::ShutterSpeed;
    if (strstr(evtdata, "d6b8")) return EventTrigger::Whitebalance;
  }

  return EventTrigger::NoTrigger;
}

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

void GPhotoCam::onTimeout() {
#ifdef WITH_GPHOTO2
  bool debug = false;
#ifdef _MSC_VER
  debug = true;
#endif

  CameraEventType evttype;
  CameraFilePath *path;
  void *evtdata;
  int retVal;

  if (!m_gpContext || !m_camera || m_exitRequested) return;

  if (m_captureImage) {
    m_captureImage = false;

    if (!isCanon() || m_cameraName.contains("450D") ||
        m_cameraName.contains("1000D") || m_cameraName.contains("40D")) {
      // Nikon: Turn off autofocus from a libgphoto2 point of view.
      // Does not work for Canon but may work for others.
      retVal = gp_setting_set("ptp2", "autofocus", "off");
      retVal = gp_camera_trigger_capture(m_camera, m_gpContext);
    } else {
      retVal = setCameraConfigValue("eosremoterelease", "Immediate");
      if (retVal >= GP_OK)
        setCameraConfigValue("eosremoterelease", "Release Full");
    }
  }

  // Capture preview when enabled
  if (m_capturePreview && !m_previewImageReady) {
    retVal = gp_camera_capture_preview(m_camera, m_previewFile, m_gpContext);
    m_previewImageReady = true;
  }

  while (1) {
    if (!m_gpContext || !m_camera || m_exitRequested) break;

    retVal =
        gp_camera_wait_for_event(m_camera, 1, &evttype, &evtdata, m_gpContext);
    if (retVal < GP_OK) break;
    if (m_exitRequested) break;

    switch (evttype) {
    case GP_EVENT_FILE_ADDED:
      path = (CameraFilePath *)evtdata;
      if (debug)
        qDebug() << "[GphotoCamEventHandler] FILE ADDED ON CAMERA: "
                 << path->folder << "/" << path->name;

      m_cameraImageFilePath = path;
      downloadImage();
      free(evtdata);
      break;
#ifdef GP_EVENT_FILE_CHANGED
    case GP_EVENT_FILE_CHANGED:
      path = (CameraFilePath *)evtdata;
      if (debug)
        qDebug() << "[GphotoCamEventHandler] File CHANGED on the camera: "
                 << path->folder << "/" << path->name;
      free(evtdata);
      break;
#endif
    case GP_EVENT_FOLDER_ADDED:
      path = (CameraFilePath *)evtdata;
      if (debug)
        qDebug() << "[GphotoCamEventHandler] FOLDER ADDED ON CAMERA: "
                 << path->folder << "/" << path->name;
      free(evtdata);
      break;
    case GP_EVENT_CAPTURE_COMPLETE:
      if (debug) qDebug() << "[GphotoCamEventHandler] CAPTURE COMPLETE";
      break;
    case GP_EVENT_TIMEOUT:
      // if (debug) qDebug() << "[GphotoCamEventHandler] TIMEOUT";
      break;
    case GP_EVENT_UNKNOWN:
      if (evtdata) {
        if (debug)
          qDebug() << "[GphotoCamEventHandler] UNKNOWN EVENT: "
                   << (char *)evtdata;

        EventTrigger event =
            checkEventCode(m_cameraManufacturer, (char *)evtdata);

        switch (event) {
        case EventTrigger::BatteryLevel: {
          QString value = getCameraConfigValue(m_configKeys.batteryLevelKey);
          emit batteryChanged();
          break;
        }
        case EventTrigger::ImageSize: {
          QString value = getCameraConfigValue(m_configKeys.imageQualityKey);
          emit imageSizeChangedSignal(value);
          break;
        }
        case EventTrigger::ImageQuality: {
          QString value = getCameraConfigValue(m_configKeys.imageQualityKey);
          emit imageQualityChangedSignal(value);
          break;
        }
        case EventTrigger::Whitebalance: {
          QString value = getCameraConfigValue(m_configKeys.whiteBalanceKey);
          emit whiteBalanceChangedSignal(value);
          break;
        }
        case EventTrigger::Aperture: {
          QString value = getCameraConfigValue(m_configKeys.apertureKey);
          emit apertureChangedSignal(value);
          break;
        }
        case EventTrigger::ShutterSpeed: {
          QString value = getCameraConfigValue(m_configKeys.shutterSpeedKey);
          emit shutterSpeedChangedSignal(value);
          break;
        }
        case EventTrigger::Mode: {
          QString value = getCameraConfigValue(m_configKeys.modeKey);
          emit modeChanged();
          break;
        }
        case EventTrigger::ISO: {
          QString value = getCameraConfigValue(m_configKeys.isoKey);
          emit isoChangedSignal(value);
          break;
        }
        case EventTrigger::ExposureCompensation: {
          QString value =
              getCameraConfigValue(m_configKeys.exposureCompensationKey);
          emit exposureChangedSignal(value);
          break;
        }
        case EventTrigger::PictureStyle: {
          QString value = getCameraConfigValue(m_configKeys.pictureStyleKey);
          emit pictureStyleChangedSignal(value);
          break;
        }
        case EventTrigger::ColorTemperature: {
          QString value =
              getCameraConfigValue(m_configKeys.colorTemperatureKey);
          emit colorTemperatureChangedSignal(value);
          break;
        }
        default:
          break;
        }

        free(evtdata);
      } else if (debug)
        qDebug() << "[GphotoCamEventHandler] UNKNOWN EVENT (no data).";
      break;
    default:
      if (debug)
        qDebug() << "[GphotoCamEventHandler] DEFAULT EVENT - Type:" << evttype;
      break;
    }
    if (evttype == GP_EVENT_TIMEOUT) break;
  }
#endif
}

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

void GPhotoCam::onImageReady(const bool &status) {
  m_converterSucceeded = status;
}

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

void GPhotoCam::onFinished() { l_quitLoop = true; }

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

#ifdef WITH_GPHOTO2

QString GPhotoCam::getCameraName(int index) {
  if (!m_count) return 0;

  const char *name;

  gp_list_get_name(m_cameraListDetected, index, &name);

  m_cameraName = QString(name);
  return m_cameraName;
}

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

bool GPhotoCam::getCamera(int index) {
  if (!m_count) return false;

  int retVal = gp_camera_new(&m_camera);

  if (retVal < GP_OK) return false;

  const char *cameraName, *cameraPort;
  gp_list_get_name(m_cameraListDetected, index, &cameraName);
  gp_list_get_value(m_cameraListDetected, index, &cameraPort);

  // Set camera abilities
  CameraAbilities abilities;
  int abilityIndex =
      gp_abilities_list_lookup_model(m_cameraListMaster, cameraName);
  if (abilityIndex < 0) return false;

  retVal = gp_abilities_list_get_abilities(m_cameraListMaster, abilityIndex,
                                           &abilities);
  if (retVal < GP_OK) return false;

  retVal = gp_camera_set_abilities(m_camera, abilities);
  if (retVal < GP_OK) {
    gp_camera_unref(m_camera);
    return false;
  }

  // Set camera port
  // Reload port list in case something changed
  if (m_portInfoList) {
    gp_port_info_list_free(m_portInfoList);
    gp_port_info_list_new(&m_portInfoList);
  }

  retVal = gp_port_info_list_load(m_portInfoList);
  if (retVal < GP_OK) {
    gp_camera_unref(m_camera);
    return false;
  }

  int portIndex = gp_port_info_list_lookup_path(m_portInfoList, cameraPort);
  if (portIndex == GP_ERROR_UNKNOWN_PORT) {
    gp_camera_unref(m_camera);
    return false;
  }

  retVal = gp_port_info_list_get_info(m_portInfoList, portIndex, &m_portInfo);
  if (retVal < GP_OK) {
    gp_camera_unref(m_camera);
    return false;
  }

  retVal = gp_camera_set_port_info(m_camera, m_portInfo);
  if (retVal < GP_OK) {
    gp_camera_unref(m_camera);
    return false;
  }

  return true;
}

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

bool GPhotoCam::initializeCamera() {
  if (!m_camera) return false;

  int retVal = gp_camera_init(m_camera, m_gpContext);
  if (retVal < GP_OK) return false;

  m_cameraManufacturer = getCameraConfigValue("manufacturer");
  m_cameraModel        = getCameraConfigValue("cameramodel");

  loadCameraConfigKeys(m_cameraManufacturer);

  return true;
}
  
//-----------------------------------------------------------------------------

bool GPhotoCam::releaseCamera() {
  int retVal = GP_OK;

  if (!m_camera) return retVal;

  if (m_eventTimer->isActive()) {
    m_exitRequested = true;
    // Give time for handler to stop
    doGPSleep(DOGPSLEEP_INTERVAL);

    m_eventTimer->stop();
  }

  retVal = gp_camera_exit(m_camera, m_gpContext);

  m_exitRequested = false;

  m_camera      = 0;
  m_gphotoIndex = -1;

  return (retVal >= GP_OK);
}

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

bool GPhotoCam::openCameraSession() {
  if (!m_camera) return false;

  m_sessionOpen = true;

  m_eventTimer->start(EVENTTIMER_INTERVAL);

  return true;
}

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

bool GPhotoCam::closeCameraSession() {

  m_sessionOpen = false;

  if (!m_camera) return true;

  if (m_liveViewExposureOffset != 0) {
    setShutterSpeed(m_displayedShutterSpeed, false);
    doGPSleep(DOGPSLEEP_INTERVAL);
  }

  m_eventTimer->stop();

  return true;
}

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

void GPhotoCam::closeAll() {
#ifdef WITH_GPHOTO2
  if (m_camera) releaseCamera();
#endif
}

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

bool GPhotoCam::startLiveView() {
  if (!m_camera || !m_sessionOpen) return false;

  int retVal = gp_camera_capture_preview(m_camera, m_previewFile, m_gpContext);
  if (retVal < GP_OK) return false;

  m_capturePreview = true;

  m_previewImageReady = true;

  StopMotion::instance()->m_liveViewStatus = 1;

  return true;
}

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

bool GPhotoCam::endLiveView() {
  StopMotion::instance()->m_liveViewStatus = 0;

  m_capturePreview = false;

  bool status = setCameraConfigValue(m_configKeys.viewfinderKey, "0");

  return status;
}

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

bool GPhotoCam::getGPhotocamImage() {
  if (!m_camera || !m_capturePreview) return false;

  int retVal;
  CameraFile *file = m_previewFile;

  if (!file || !m_previewImageReady) return false;

  const char *dataPtr;
  unsigned long dataSize;
  retVal = gp_file_get_data_and_size(file, &dataPtr, &dataSize);
  if (retVal < GP_OK) {
    m_previewImageReady = false;
    return false;
  }

  JpgConverter *converter = new JpgConverter;
  converter->setDataPtr((unsigned char *)dataPtr, dataSize);

  connect(converter, SIGNAL(imageReady(bool)), this, SLOT(onImageReady(bool)),
          Qt::QueuedConnection);
  connect(converter, SIGNAL(finished()), this, SLOT(onFinished()),
          Qt::QueuedConnection);

  converter->start();

  while (!l_quitLoop)
    QCoreApplication::processEvents(QEventLoop::AllEvents |
                                    QEventLoop::WaitForMoreEvents);

  l_quitLoop = false;
  StopMotion::instance()->m_liveViewImage = converter->getImage();
  StopMotion::instance()->m_hasLiveViewImage = true;

  m_previewImageReady = false;

  if (!m_converterSucceeded) return false;

  uchar *imgBuf = StopMotion::instance()->m_liveViewImage->getRawData();
  int height    = StopMotion::instance()->m_liveViewImage->getLy();
  int width     = StopMotion::instance()->m_liveViewImage->getLx();

  cv::Mat imgData(height, width, CV_8UC4, (void *)imgBuf);

  // perform calibration
  if (m_useCalibration) {
    cv::remap(imgData, imgData, m_calibrationMapX, m_calibrationMapY,
              cv::INTER_LINEAR);
  }

  m_gPhotoImage = imgData;

  delete converter;

  QString focusAreaSize = getCameraConfigValue(m_configKeys.focusInfoKey);
  if (focusAreaSize != "-" && m_configKeys.focusInfoKey == "focusinfo") {
    int i = focusAreaSize.indexOf("size2=");
    i += 6;
    int j         = focusAreaSize.indexOf(",", i);
    focusAreaSize = focusAreaSize.mid(i, (j - i));
  }

  // If no focus area info, let's use image size configuration
  // Use the largest size available, assume it is the 1st in the list
  if (focusAreaSize == "-" && !m_imageSizeOptions.isEmpty())
    focusAreaSize = m_imageQualityOptions.at(0);

  // If no focus area or size information found, let's default it.
  // The "Pick" point may be offset depending on what the camera's
  // actual focus area is.
  if (focusAreaSize == "-") focusAreaSize = "6000x4000";

  QStringList sizeDimensions = focusAreaSize.split("x");
  if (sizeDimensions.size() > 1) {
    m_fullImageDimensions =
        TDimension(sizeDimensions.at(0).toInt(), sizeDimensions.at(1).toInt());
    m_zoomRectDimensions =
        TPoint((m_fullImageDimensions.lx / 5), (m_fullImageDimensions.ly / 5));
    if (m_zoomRect == TRect(0, 0, 0, 0)) {
      m_zoomRect = TRect(0, m_zoomRectDimensions.y, m_zoomRectDimensions.x, 0);
      calculateZoomPoint();
    }
  }

  return true;
}

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

bool GPhotoCam::takePicture() {
  if (m_liveViewExposureOffset != 0) {
    bool status = setShutterSpeed(m_displayedShutterSpeed, false);
    if (!status) {
      DVGui::error(tr("An error occurred.  Please try again."));
      return status;
    }
    doGPSleep(DOGPSLEEP_INTERVAL);
  }

  m_captureImage = true;
  return true;
}

bool GPhotoCam::downloadImage() {
  int fd, retVal;
  CameraFile *file;

  QString imageFilename = m_cameraImageFilePath->name;
  bool isRaw            = (imageFilename.at(imageFilename.length() - 1) == '2');

  QString filename = isRaw ? StopMotion::instance()->m_tempRaw
                           : StopMotion::instance()->m_tempFile;

  // Get image off the camera
  QByteArray ba  = filename.toLocal8Bit();
  const char *fn = ba.data();
#ifdef WIN32
  fd = _open(fn, O_CREAT | O_WRONLY | O_BINARY, 0644);
#else
  fd = open(fn, O_CREAT | O_WRONLY, 0644);
#endif

  retVal = gp_file_new_from_fd(&file, fd);
  if (retVal < GP_OK) return false;

  retVal = gp_camera_file_get(m_camera, m_cameraImageFilePath->folder,
                              m_cameraImageFilePath->name, GP_FILE_TYPE_NORMAL,
                              file, m_gpContext);
  if (retVal < GP_OK) return false;

  retVal = gp_file_unref(file);

  retVal = gp_camera_file_delete(m_camera, m_cameraImageFilePath->folder,
                                 m_cameraImageFilePath->name, m_gpContext);

  // Currently does not support creating images from Raw files
  if (isRaw) {
    return true;
  }

  // Open file and process
  retVal = gp_file_new(&file);
  if (retVal < GP_OK) return false;

#ifdef WIN32
  fd = _open(fn, O_RDONLY | O_BINARY);
#else
  fd = open(fn, O_RDONLY);
#endif

  retVal = gp_file_new_from_fd(&file, fd);
  if (retVal < GP_OK) return false;

  const char *dataPtr;
  unsigned long dataSize;

  retVal = gp_file_get_data_and_size(file, &dataPtr, &dataSize);
  if (retVal < GP_OK) return false;

  JpgConverter *converter = new JpgConverter;
  converter->setDataPtr((unsigned char *)dataPtr, dataSize);

  connect(converter, SIGNAL(imageReady(bool)), this, SLOT(onImageReady(bool)),
          Qt::QueuedConnection);
  connect(converter, SIGNAL(finished()), this, SLOT(onFinished()),
          Qt::QueuedConnection);

  converter->start();

  while (!l_quitLoop)
    QCoreApplication::processEvents(QEventLoop::AllEvents |
                                    QEventLoop::WaitForMoreEvents);

  l_quitLoop           = false;
  TRaster32P tempImage = converter->getImage();

  if (!m_converterSucceeded || !tempImage || tempImage->isEmpty()) return false;

  uchar *imgBuf = tempImage->getRawData();
  int height    = tempImage->getLy();
  int width     = tempImage->getLx();

  // Get camera size info
  TCamera *camera =
      TApp::instance()->getCurrentScene()->getScene()->getCurrentCamera();
  TDimension res = camera->getRes();
  if (m_proxyImageDimensions == TDimension(0, 0)) {
    m_proxyImageDimensions = res;
  }

  cv::Mat imgData(height, width, CV_8UC4, (void *)imgBuf);

  // perform calibration
  if (m_useCalibration) {
    cv::remap(imgData, imgData, m_calibrationMapX, m_calibrationMapY,
              cv::INTER_LINEAR);
  }

  m_gPhotoImage = imgData;

  // calculate the size of the new image
  // and resize it down
  double r = (double)width / (double)height;
  cv::Size dim(m_proxyImageDimensions.lx, m_proxyImageDimensions.lx / r);
  int newWidth  = dim.width;
  int newHeight = dim.height;
  cv::Mat imgResized(dim, CV_8UC4);
  cv::resize(imgData, imgResized, dim);
  int newSize       = imgResized.total() * imgResized.elemSize();
  uchar *resizedBuf = imgResized.data;

  // copy the image to m_newImage
  StopMotion::instance()->m_newImage = TRaster32P(newWidth, newHeight);
  StopMotion::instance()->m_newImage->lock();
  uchar *rawData = StopMotion::instance()->m_newImage->getRawData();
  memcpy(rawData, resizedBuf, newSize);
  StopMotion::instance()->m_newImage->unlock();

  gp_file_unref(file);

  emit(newGPhotocamImageReady());

  delete converter;

  return true;
}

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

QStringList GPhotoCam::getCameraConfigList(const char *key) {
  QStringList configList;
  CameraWidget *widget = NULL, *child = NULL;
  CameraWidgetType widgetType;
  int retVal;

  if (!key) return configList;

  retVal = gp_camera_get_config(m_camera, &widget, m_gpContext);
  if (retVal < GP_OK) return configList;

  retVal = gp_widget_get_child_by_name(widget, key, &child);
  if (retVal < GP_OK)
    retVal = gp_widget_get_child_by_label(widget, key, &child);
  if (retVal < GP_OK) {
    gp_widget_free(widget);
    return configList;
  }

  retVal = gp_widget_get_type(child, &widgetType);
  if (retVal < GP_OK) {
    gp_widget_free(widget);
    return configList;
  }

  switch (widgetType) {
  case GP_WIDGET_MENU:
  case GP_WIDGET_RADIO: {
    int choices = gp_widget_count_choices(child);
    for (int i = 0; i < choices; i++) {
      const char *choice;
      retVal = gp_widget_get_choice(child, i, &choice);
      if (retVal < GP_OK) continue;

      configList.push_back(choice);
    }
    break;
  }
  case GP_WIDGET_RANGE: {
    float rmin, rmax, rstep;
    retVal = gp_widget_get_range(child, &rmin, &rmax, &rstep);
    if (retVal < GP_OK) break;

    configList.push_back(QString::number(rmin));
    configList.push_back(QString::number(rmax));
    configList.push_back(QString::number(rstep));
    break;
  }
  default:
    break;
  }

  gp_widget_free(widget);

  return configList;
}

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

QString GPhotoCam::getCameraConfigValue(const char *key) {
  CameraWidget *widget = NULL, *child = NULL;
  CameraWidgetType widgetType;
  int retVal;

  QString currentValue = "-";

  if (!key) return currentValue;

  retVal = gp_camera_get_single_config(m_camera, key, &child, m_gpContext);
  if (retVal == GP_OK)
    widget = child;
  else {
    retVal = gp_camera_get_config(m_camera, &widget, m_gpContext);
    if (retVal < GP_OK) return currentValue;

    retVal = gp_widget_get_child_by_name(widget, key, &child);
    if (retVal < GP_OK)
      retVal = gp_widget_get_child_by_label(widget, key, &child);
    if (retVal < GP_OK) {
      gp_widget_free(widget);
      return currentValue;
    }
  }

  retVal = gp_widget_get_type(child, &widgetType);
  if (retVal < GP_OK) {
    gp_widget_free(widget);
    return currentValue;
  }

  switch (widgetType) {
  case GP_WIDGET_MENU:
  case GP_WIDGET_RADIO:
  case GP_WIDGET_TEXT: {
    char *cvalue;
    retVal                            = gp_widget_get_value(child, &cvalue);
    if (retVal >= GP_OK) currentValue = cvalue;
    break;
  }
  case GP_WIDGET_RANGE: {
    float fvalue;
    retVal                            = gp_widget_get_value(child, &fvalue);
    if (retVal >= GP_OK) currentValue = QString::number(fvalue);
    break;
  }
  case GP_WIDGET_TOGGLE: {
    int ivalue;
    retVal                            = gp_widget_get_value(child, &ivalue);
    if (retVal >= GP_OK) currentValue = QString::number(ivalue);
    break;
  }
  case GP_WIDGET_DATE:
  case GP_WIDGET_BUTTON:
  case GP_WIDGET_SECTION:
  case GP_WIDGET_WINDOW:
  default:
    break;
  }

  gp_widget_free(widget);

  return currentValue;
}

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

bool GPhotoCam::setCameraConfigValue(const char *key, QString value) {
  CameraWidget *widget = NULL, *child = NULL;
  CameraWidgetType widgetType;
  int retVal;

  if (!key) return false;

  retVal = gp_camera_get_single_config(m_camera, key, &child, m_gpContext);
  if (retVal == GP_OK)
    widget = child;
  else {
    retVal = gp_camera_get_config(m_camera, &widget, m_gpContext);
    if (retVal < GP_OK) return false;

    retVal = gp_widget_get_child_by_name(widget, key, &child);
    if (retVal < GP_OK)
      retVal = gp_widget_get_child_by_label(widget, key, &child);
    if (retVal < GP_OK) {
      gp_widget_free(widget);
      return false;
    }
  }

  retVal = gp_widget_get_type(child, &widgetType);
  if (retVal < GP_OK) {
    gp_widget_free(widget);
    return false;
  }

  switch (widgetType) {
  case GP_WIDGET_MENU:
  case GP_WIDGET_RADIO: {
    bool found  = false;
    int choices = gp_widget_count_choices(child);
    for (int i = 0; i < choices; i++) {
      const char *choice;
      retVal = gp_widget_get_choice(child, i, &choice);
      if (retVal < GP_OK) continue;
      if (choice != value) continue;
      found = true;
      break;
    }

    retVal = !found ? GP_ERROR
                    : gp_widget_set_value(child, value.toStdString().c_str());
    break;
  }
  case GP_WIDGET_TEXT:
    retVal = gp_widget_set_value(child, value.toStdString().c_str());
    break;
  case GP_WIDGET_RANGE: {
    float fvalue = value.toFloat();
    retVal       = gp_widget_set_value(child, &fvalue);
    break;
  }
  case GP_WIDGET_TOGGLE: {
    int ivalue = value.toInt();
    retVal     = gp_widget_set_value(child, &ivalue);
    break;
  }
  case GP_WIDGET_DATE:
  case GP_WIDGET_BUTTON:
  case GP_WIDGET_SECTION:
  case GP_WIDGET_WINDOW:
  default:
    retVal = GP_ERROR;
    break;
  }

  if (retVal >= GP_OK)
    retVal = gp_camera_set_single_config(m_camera, key, child, m_gpContext);

  gp_widget_free(widget);

  return (retVal >= GP_OK);
}

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

bool GPhotoCam::getAvailableApertures() {
  m_apertureOptions.clear();

  m_apertureOptions = getCameraConfigList(m_configKeys.apertureKey);

  return true;
}

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

bool GPhotoCam::getAvailableShutterSpeeds() {
  m_shutterSpeedOptions.clear();

  m_shutterSpeedOptions = getCameraConfigList(m_configKeys.shutterSpeedKey);

  return true;
}

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

bool GPhotoCam::getAvailableIso() {
  m_isoOptions.clear();

  m_isoOptions = getCameraConfigList(m_configKeys.isoKey);

  return true;
}

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

bool GPhotoCam::getAvailableExposureCompensations() {
  m_exposureOptions.clear();

  m_exposureOptions = getCameraConfigList(m_configKeys.exposureCompensationKey);

  return true;
}

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

bool GPhotoCam::getAvailableWhiteBalances() {
  m_whiteBalanceOptions.clear();

  m_whiteBalanceOptions = getCameraConfigList(m_configKeys.whiteBalanceKey);

  return true;
}

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

bool GPhotoCam::getAvailableImageQualities() {
  m_imageQualityOptions.clear();

  m_imageQualityOptions = getCameraConfigList(m_configKeys.imageQualityKey);

  return true;
}

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

bool GPhotoCam::getAvailableImageSizes() {
  m_imageSizeOptions.clear();

  m_imageSizeOptions = getCameraConfigList(m_configKeys.imageSizeKey);

  return true;
}

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

bool GPhotoCam::getAvailablePictureStyles() {
  m_pictureStyleOptions.clear();

  m_pictureStyleOptions = getCameraConfigList(m_configKeys.pictureStyleKey);

  return true;
}

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

bool GPhotoCam::getAvailableColorTemperatures() {
  m_colorTempOptions.clear();

  m_colorTempOptions = getCameraConfigList(m_configKeys.colorTemperatureKey);

  return true;
}

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

bool GPhotoCam::getManualFocusRangeData() {
  m_manualFocusRange.clear();

  m_manualFocusRange = getCameraConfigList(m_configKeys.manualFocusDriveKey);

  return true;
}

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

QString GPhotoCam::getCurrentAperture() {
  QString currentValue = getCameraConfigValue(m_configKeys.apertureKey);

  m_displayedAperture = currentValue;

  return currentValue;
}

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

QString GPhotoCam::getCurrentShutterSpeed() {
  QString currentValue = getCameraConfigValue(m_configKeys.shutterSpeedKey);

  m_realShutterSpeed = currentValue;

  if (m_liveViewExposureOffset == 0) {
    m_displayedShutterSpeed = m_realShutterSpeed;
    currentValue            = m_realShutterSpeed;
  } else
    currentValue = m_displayedShutterSpeed;

  return currentValue;
}

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

QString GPhotoCam::getCurrentIso() {
  QString currentValue = getCameraConfigValue(m_configKeys.isoKey);

  m_displayedIso = currentValue;

  return currentValue;
}

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

QString GPhotoCam::getCurrentExposureCompensation() {
  QString currentValue =
      getCameraConfigValue(m_configKeys.exposureCompensationKey);

  return currentValue;
}

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

QString GPhotoCam::getCurrentWhiteBalance() {
  QString currentValue = getCameraConfigValue(m_configKeys.whiteBalanceKey);

  return currentValue;
}

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

QString GPhotoCam::getCurrentColorTemperature() {
  QString currentValue = getCameraConfigValue(m_configKeys.colorTemperatureKey);

  return currentValue;
}

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

QString GPhotoCam::getCurrentImageQuality() {
  QString currentValue = getCameraConfigValue(m_configKeys.imageQualityKey);

  return currentValue;
}

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

QString GPhotoCam::getCurrentImageSize() {
  QString currentValue = getCameraConfigValue(m_configKeys.imageSizeKey);

  return currentValue;
}

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

QString GPhotoCam::getCurrentPictureStyle() {
  QString currentValue = getCameraConfigValue(m_configKeys.pictureStyleKey);

  return currentValue;
}

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

int GPhotoCam::getCurrentLiveViewOffset() { return m_liveViewExposureOffset; }

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

QString GPhotoCam::getMode() {
  QString value = getCameraConfigValue(m_configKeys.modeKey);

  return value;
}

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

QString GPhotoCam::getCurrentBatteryLevel() {
  QString value = getCameraConfigValue(m_configKeys.batteryLevelKey);

  return value;
}

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

bool GPhotoCam::setAperture(QString aperture) {
  bool status = setCameraConfigValue(m_configKeys.apertureKey, aperture);

  if (status) m_displayedAperture = aperture;

  return status;
}

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

bool GPhotoCam::setShutterSpeed(QString shutterSpeed, bool withOffset) {
  if (withOffset) {
    m_realShutterSpeed      = shutterSpeed;
    m_displayedShutterSpeed = shutterSpeed;
    if (m_liveViewExposureOffset != 0) {
      int index = m_shutterSpeedOptions.indexOf(shutterSpeed);
      // brighter goes down in shutter speed, so subtract

      if (m_liveViewExposureOffset > 0) {
        int newValue = index - m_liveViewExposureOffset;
        // get brighter, go down
        if (newValue >= 0) {
          m_realShutterSpeed = m_shutterSpeedOptions.at(newValue);
        } else
          m_realShutterSpeed = m_shutterSpeedOptions.at(0);
      } else {
        // get darker, go up
        int newValue = index - m_liveViewExposureOffset;
        if (newValue < m_shutterSpeedOptions.size()) {
          m_realShutterSpeed = m_shutterSpeedOptions.at(newValue);
        } else
          m_realShutterSpeed =
              m_shutterSpeedOptions.at(m_shutterSpeedOptions.size() - 1);
      }
    }
  }

  QString usedSpeed = withOffset ? m_realShutterSpeed : shutterSpeed;

  bool status = setCameraConfigValue(m_configKeys.shutterSpeedKey, usedSpeed);

  return status;
}

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

bool GPhotoCam::setIso(QString iso) {
  bool status                = setCameraConfigValue(m_configKeys.isoKey, iso);
  if (status) m_displayedIso = iso;

  return status;
}

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

bool GPhotoCam::setExposureCompensation(QString exposure) {
  bool status =
      setCameraConfigValue(m_configKeys.exposureCompensationKey, exposure);

  return status;
}

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

bool GPhotoCam::setWhiteBalance(QString whiteBalance) {
  bool status =
      setCameraConfigValue(m_configKeys.whiteBalanceKey, whiteBalance);

  return status;
}

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

bool GPhotoCam::setColorTemperature(QString colorTemp) {
  bool status =
      setCameraConfigValue(m_configKeys.colorTemperatureKey, colorTemp);

  return status;
}

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

bool GPhotoCam::setImageQuality(QString imageQuality) {
  bool status =
      setCameraConfigValue(m_configKeys.imageQualityKey, imageQuality);

  return status;
}

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

bool GPhotoCam::setImageSize(QString imageSize) {
  bool status = setCameraConfigValue(m_configKeys.imageSizeKey, imageSize);

  return status;
}

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

bool GPhotoCam::setPictureStyle(QString pictureStyle) {
  bool status =
      setCameraConfigValue(m_configKeys.pictureStyleKey, pictureStyle);

  return status;
}

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

bool GPhotoCam::setManualFocus(int value){
  QString strvalue = QString::number(value);

  bool status =
      setCameraConfigValue(m_configKeys.manualFocusDriveKey, strvalue);

  return status;
}

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

void GPhotoCam::setLiveViewOffset(int compensation) {
  m_liveViewExposureOffset = compensation;
  emit(liveViewOffsetChangedSignal(m_liveViewExposureOffset));
}

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

bool GPhotoCam::zoomLiveView() {
  if (!m_sessionOpen || !StopMotion::instance()->m_liveViewStatus)
    return false;

  if (m_pickLiveViewZoom) toggleZoomPicking();

  if (m_liveViewZoom == 1) {
    m_liveViewZoom = 5;
    m_zooming      = true;
    StopMotion::instance()->toggleNumpadForFocusCheck(true);
  } else if (m_liveViewZoom == 5) {
    m_liveViewZoom = 1;
    m_zooming      = false;
    StopMotion::instance()->toggleNumpadForFocusCheck(false);
  }

  bool status =
      setCameraConfigValue("eoszoom", QString::number(m_liveViewZoom));
  if (status) {
    if (m_liveViewZoom == 5) setZoomPoint();
    emit(focusCheckToggled(m_liveViewZoom > 1));
  }

  return status;
}

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

void GPhotoCam::calculateZoomPoint() {
  double minimumDpi = 0.0;

  if (m_proxyImageDimensions == TDimension(0, 0)) {
    TCamera *camera =
        TApp::instance()->getCurrentScene()->getScene()->getCurrentCamera();
    TDimensionD size = camera->getSize();
    minimumDpi       = std::min(m_fullImageDimensions.lx / size.lx,
                          m_fullImageDimensions.ly / size.ly);
  } else {
    TDimensionD size =
        TDimensionD((double)m_proxyImageDimensions.lx / Stage::standardDpi,
                    (double)m_proxyImageDimensions.ly / Stage::standardDpi);
    minimumDpi = std::min(m_fullImageDimensions.lx / size.lx,
                          m_fullImageDimensions.ly / size.ly);
  }
  TPointD fullImageDpi = TPointD(minimumDpi, minimumDpi);

  bool outOfBounds = false;
  if (m_liveViewZoomPickPoint == TPointD(0.0, 0.0)) {
    m_calculatedZoomPoint =
        TPoint(m_fullImageDimensions.lx / 2, m_fullImageDimensions.ly / 2);
    m_finalZoomPoint.x = m_calculatedZoomPoint.x - (m_zoomRectDimensions.x / 2);
    m_finalZoomPoint.y = m_calculatedZoomPoint.y - (m_zoomRectDimensions.y / 2);
  } else {
    // get the image size in Tahoma2D dimensions
    double maxFullWidth =
        (double)m_fullImageDimensions.lx / fullImageDpi.x * Stage::inch;
    double maxFullHeight =
        (double)m_fullImageDimensions.ly / fullImageDpi.y * Stage::inch;
    // Tahoma2D coordinates are based on center at 0, 0
    // convert that to top left based coordinates
    double newX = m_liveViewZoomPickPoint.x + maxFullWidth / 2.0;
    double newY = -m_liveViewZoomPickPoint.y + maxFullHeight / 2.0;
    // convert back to the normal image dimensions to talk to the camera
    m_calculatedZoomPoint.x = newX / Stage::inch * fullImageDpi.x;
    m_calculatedZoomPoint.y = newY / Stage::inch * fullImageDpi.x;
    // the Canon SDK wants the top left corner of the zoom rect, not the center
    m_finalZoomPoint.x = m_calculatedZoomPoint.x - (m_zoomRectDimensions.x / 2);
    m_finalZoomPoint.y = m_calculatedZoomPoint.y - (m_zoomRectDimensions.y / 2);
    // finally make sure everything actually fits on the image
    if (m_finalZoomPoint.x < 0) {
      m_finalZoomPoint.x = 0;
      outOfBounds        = true;
    }
    if (m_finalZoomPoint.y < 0) {
      m_finalZoomPoint.y = 0;
      outOfBounds        = true;
    }
    if (m_finalZoomPoint.x >
        m_fullImageDimensions.lx - (m_zoomRectDimensions.x)) {
      m_finalZoomPoint.x = m_fullImageDimensions.lx - (m_zoomRectDimensions.x);
      outOfBounds        = true;
    }
    if (m_finalZoomPoint.y >
        m_fullImageDimensions.ly - (m_zoomRectDimensions.y)) {
      m_finalZoomPoint.y = m_fullImageDimensions.ly - (m_zoomRectDimensions.y);
      outOfBounds        = true;
    }

    // if out of bounds, recalculate backwards to get the correct location
    if (outOfBounds) {
      TPoint tempCalculated;
      // recenter the point in the rect
      tempCalculated.x = m_finalZoomPoint.x + (m_zoomRectDimensions.x / 2);
      tempCalculated.y = m_finalZoomPoint.y + (m_zoomRectDimensions.y / 2);
      // convert to Tahoma2D Dimensions
      newX = tempCalculated.x / fullImageDpi.x * Stage::inch;
      newY = tempCalculated.y / fullImageDpi.y * Stage::inch;
      // get center based coordinates
      m_liveViewZoomPickPoint.x = newX - (maxFullWidth / 2.0);
      m_liveViewZoomPickPoint.y = (newY - (maxFullHeight / 2.0)) * -1;
    }
  }

  // calculate the zoom rectangle position on screen

  // get the image size in Tahoma2D dimensions
  double maxFullWidth =
      (double)m_fullImageDimensions.lx / fullImageDpi.x * Stage::inch;
  double maxFullHeight =
      (double)m_fullImageDimensions.ly / fullImageDpi.y * Stage::inch;
  m_zoomRect =
      TRect(m_finalZoomPoint.x, m_finalZoomPoint.y + m_zoomRectDimensions.y,
            m_finalZoomPoint.x + m_zoomRectDimensions.x, m_finalZoomPoint.y);
  TRect tempCalculated;

  // convert to Tahoma2D Dimensions
  tempCalculated.x0 = m_zoomRect.x0 / fullImageDpi.x * Stage::inch;
  tempCalculated.y0 = m_zoomRect.y0 / fullImageDpi.y * Stage::inch;
  tempCalculated.x1 = m_zoomRect.x1 / fullImageDpi.x * Stage::inch;
  tempCalculated.y1 = m_zoomRect.y1 / fullImageDpi.y * Stage::inch;
  // get center based coordinates
  m_zoomRect.x0 = tempCalculated.x0 - (maxFullWidth / 2.0);
  m_zoomRect.y0 = (tempCalculated.y0 - (maxFullHeight / 2.0)) * -1;
  m_zoomRect.x1 = tempCalculated.x1 - (maxFullWidth / 2.0);
  m_zoomRect.y1 = (tempCalculated.y1 - (maxFullHeight / 2.0)) * -1;
}

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

void GPhotoCam::makeZoomPoint(TPointD pos) {
  m_liveViewZoomPickPoint = pos;
  calculateZoomPoint();
}

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

void GPhotoCam::toggleZoomPicking() {
  if (m_sessionOpen && StopMotion::instance()->m_liveViewStatus > 0 &&
      !m_zooming) {
    if (m_pickLiveViewZoom) {
      m_pickLiveViewZoom = false;
      StopMotion::instance()->toggleNumpadForFocusCheck(false);
    } else {
      m_pickLiveViewZoom = true;
      if (m_liveViewZoomPickPoint == TPointD(0.0, 0.0)) {
        makeZoomPoint(m_liveViewZoomPickPoint);
      }
      StopMotion::instance()->toggleNumpadForFocusCheck(true);
    }
  }
  emit(pickFocusCheckToggled(m_pickLiveViewZoom));
}

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

bool GPhotoCam::setZoomPoint() {
  // make sure this is set AFTER starting zoom
  m_liveViewZoomReadyToPick = false;

  calculateZoomPoint();

  TPoint zoomPoint;
  zoomPoint.x = m_finalZoomPoint.x;
  zoomPoint.y = m_finalZoomPoint.y;

  QString zoomPointVal = QString("%1,%2").arg(zoomPoint.x).arg(zoomPoint.y);

  bool status = setCameraConfigValue(m_configKeys.afPositionKey, zoomPointVal);

  m_liveViewZoomReadyToPick = true;

  return status;
}

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

bool GPhotoCam::focusNear() {
  bool status =
      setCameraConfigValue(m_configKeys.manualFocusDriveKey, "Near 1");

  return status;
}

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

bool GPhotoCam::focusFar() {
  bool status = setCameraConfigValue(m_configKeys.manualFocusDriveKey, "Far 1");

  return status;
}

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

bool GPhotoCam::focusNear2() {
  bool status =
      setCameraConfigValue(m_configKeys.manualFocusDriveKey, "Near 2");

  return status;
}

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

bool GPhotoCam::focusFar2() {
  bool status = setCameraConfigValue(m_configKeys.manualFocusDriveKey, "Far 2");

  return status;
}

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

bool GPhotoCam::focusNear3() {
  bool status =
      setCameraConfigValue(m_configKeys.manualFocusDriveKey, "Near 3");

  return status;
}

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

bool GPhotoCam::focusFar3() {
  bool status = setCameraConfigValue(m_configKeys.manualFocusDriveKey, "Far 3");

  return status;
}
#endif