#include "imageviewer.h"

// Tnz6 includes

#include "tapp.h"

#include "menubarcommandids.h"

#include "flipbook.h"

#include "histogrampopup.h"

#include "sceneviewer.h"  // ToggleCommandHandler

#include "mainwindow.h"   //RecentFiles

// TnzTools includes

#include "tools/toolcommandids.h"

#include "tools/cursors.h"

#include "tools/cursormanager.h"

#include "tools/stylepicker.h"

// TnzQt includes

#include "toonzqt/menubarcommand.h"

#include "toonzqt/viewcommandids.h"

#include "toonzqt/imageutils.h"

#include "toonzqt/lutcalibrator.h"

// TnzLib includes

#include "toonz/tscenehandle.h"

#include "toonz/toonzscene.h"

#include "toonz/sceneproperties.h"

#include "toonz/palettecontroller.h"

#include "toonz/tpalettehandle.h"

#include "toonz/preferences.h"

// TnzCore includes

#include "tgl.h"

// Qt includes

#include <qmenu></qmenu>

#include <qaction></qaction>

#include <qmouseevent></qmouseevent>

#include <qwheelevent></qwheelevent>

#include <qopenglframebufferobject></qopenglframebufferobject>

#include <qgestureevent></qgestureevent>

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

extern ToggleCommandHandler safeAreaToggle;

extern void getSafeAreaData(double &_smallSize, double &_largeSize);

// enable to choose safe area from a list, and enable to draw multiple lines

extern void getSafeAreaSizeList(QList<qlist<double>> &_sizeList);</qlist<double>

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

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

//    Local namespace stuff

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

namespace {

// enable to choose safe area from a list, and enable to draw multiple lines

void drawSafeArea(const TRectD box) {

  glPushMatrix();

  glLoadIdentity();

  tglColor(TPixel32::Red);

  glLineStipple(1, 0xCCCC);

  glEnable(GL_LINE_STIPPLE);

  tglDrawRect(box);

  QList<qlist<double>> sizeList;</qlist<double>

  getSafeAreaSizeList(sizeList);

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

    QList<double> curSize = sizeList.at(i);</double>

    if (curSize.size() == 5)

      tglColor(

          TPixel((int)curSize.at(2), (int)curSize.at(3), (int)curSize.at(4)));

    else

      tglColor(TPixel32::Red);

    double facX = -0.5 * (1 - curSize.at(0) / 100.0);

    double facY = -0.5 * (1 - curSize.at(1) / 100.0);

    tglDrawRect(box.enlarge(facX * box.getLx(), facY * box.getLy()));

  }

  glDisable(GL_LINE_STIPPLE);

  glPopMatrix();

}

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

inline TRect getImageBounds(const TImageP &img) {

  if (TRasterImageP ri = img)

    return ri->getRaster()->getBounds();

  else if (TToonzImageP ti = img)

    return ti->getRaster()->getBounds();

  else {

    TVectorImageP vi = img;

    return convert(vi->getBBox());

  }

}

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

inline TRectD getImageBoundsD(const TImageP &img) {

  if (TRasterImageP ri = img)

    return TRectD(0, 0, ri->getRaster()->getLx(), ri->getRaster()->getLy());

  else if (TToonzImageP ti = img)

    return TRectD(0, 0, ti->getSize().lx, ti->getSize().ly);

  else {

    TVectorImageP vi = img;

    return vi->getBBox();

  }

}

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

class FlipZoomer final : public ImageUtils::ShortcutZoomer {

public:

  FlipZoomer(ImageViewer *parent) : ShortcutZoomer(parent) {}

  bool zoom(bool zoomin, bool resetView) override {

    static_cast<imageviewer *="">(getWidget())->zoomQt(zoomin, resetView);</imageviewer>

    return true;

  }

  bool fit() override {

    static_cast<imageviewer *="">(getWidget())->fitView();</imageviewer>

    return true;

  }

  bool resetZoom() override {

    static_cast<imageviewer *="">(getWidget())->resetZoom();</imageviewer>

    return true;

  }

  bool toggleFullScreen(bool quit) override {

    if (ImageUtils::FullScreenWidget *fsWidget =

            dynamic_cast<imageutils::fullscreenwidget *="">(</imageutils::fullscreenwidget>

                getWidget()->parentWidget()))

      return fsWidget->toggleFullScreen(quit);

    return false;

  }

};

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

class ImageViewerShortcutReceiver {

  FlipBook *m_flipbook;

public:

  ImageViewerShortcutReceiver(FlipBook *flipbook) : m_flipbook(flipbook) {}

  ~ImageViewerShortcutReceiver() {}

  bool exec(QKeyEvent *event) {

    CommandManager *cManager = CommandManager::instance();

    if (event->key() == cManager->getKeyFromId(MI_FreezePreview)) {

      m_flipbook->isFreezed() ? m_flipbook->unfreezePreview()

                              : m_flipbook->freezePreview();

      return true;

    }

    if (event->key() == cManager->getKeyFromId(MI_ClonePreview)) {

      m_flipbook->clonePreview();

      return true;

    }

    if (event->key() == cManager->getKeyFromId(MI_RegeneratePreview)) {

      m_flipbook->regenerate();

      return true;

    }

    if (event->key() == cManager->getKeyFromId(MI_RegenerateFramePr)) {

      m_flipbook->regenerateFrame();

      return true;

    }

    return false;

  }

};

}  // namespace

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

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

//    ImageViewer class

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

/*! \class ImageViewer

                \brief The ImageViewer class provides to view an image.

                Inherits \b QOpenGLWidget.

                The object allows also to manage pan and zoom event. It's

   possible to set a

                color mask TRop::ColorMask to image view.

*/

/*! \fn void ImageViewer::setColorMask(UCHAR colorMask)

                Set current TRop::ColorMask color mask to \b colorMask.

*/

/*! \fn TImageP ImageViewer::getImage()

                Return current image viewer.

*/

/*! \fn TAffine ImageViewer::getViewAff()

                Return current viewer matrix transformation.

*/

ImageViewer::ImageViewer(QWidget *parent, FlipBook *flipbook,

                         bool showHistogram)

    : GLWidgetForHighDpi(parent)

    , m_pressedMousePos(0, 0)

    , m_mouseButton(Qt::NoButton)

    , m_draggingZoomSelection(false)

    , m_image()

    , m_orgImage()

    , m_FPS(0)

    , m_viewAff()

    , m_pos(0, 0)

    , m_visualSettings()

    , m_compareSettings()

    , m_isHistogramEnable(showHistogram)

    , m_flipbook(flipbook)

    , m_isColorModel(false)

    , m_histogramPopup(0)

    , m_isRemakingPreviewFx(false)

    , m_rectRGBPick(false)

    , m_firstImage(true)

    , m_timer(nullptr) {

  m_visualSettings.m_sceneProperties =

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

  m_visualSettings.m_drawExternalBG = true;

  setAttribute(Qt::WA_KeyCompression);

  setFocusPolicy(Qt::StrongFocus);

  setMouseTracking(true);

  setAttribute(Qt::WA_AcceptTouchEvents);

  grabGesture(Qt::SwipeGesture);

  grabGesture(Qt::PanGesture);

  grabGesture(Qt::PinchGesture);

  if (m_isHistogramEnable)

    m_histogramPopup = new HistogramPopup(tr("Flipbook Histogram"));

  if (Preferences::instance()->isColorCalibrationEnabled())

    m_lutCalibrator = new LutCalibrator();

  if (Preferences::instance()->is30bitDisplayEnabled())

    setTextureFormat(TGL_TexFmt10);

}

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

void ImageViewer::contextMenuEvent(QContextMenuEvent *event) {

  QAction *action;

  if (m_isColorModel) {

    event->ignore();

    return;

  }

  QMenu *menu = new QMenu(this);

  if (m_flipbook) {

    if (m_flipbook->getPreviewedFx()) {

      if (!(windowState() & Qt::WindowFullScreen)) {

        action = menu->addAction(tr("Clone Preview"));

        action->setShortcut(QKeySequence(

            CommandManager::instance()->getKeyFromId(MI_ClonePreview)));

        connect(action, SIGNAL(triggered()), m_flipbook, SLOT(clonePreview()));

      }

      if (m_flipbook->isFreezed()) {

        action = menu->addAction(tr("Unfreeze Preview"));

        action->setShortcut(QKeySequence(

            CommandManager::instance()->getKeyFromId(MI_FreezePreview)));

        connect(action, SIGNAL(triggered()), m_flipbook,

                SLOT(unfreezePreview()));

      } else {

        action = menu->addAction(tr("Freeze Preview"));

        action->setShortcut(QKeySequence(

            CommandManager::instance()->getKeyFromId(MI_FreezePreview)));

        connect(action, SIGNAL(triggered()), m_flipbook, SLOT(freezePreview()));

      }

      action = menu->addAction(tr("Regenerate Preview"));

      action->setShortcut(QKeySequence(

          CommandManager::instance()->getKeyFromId(MI_RegeneratePreview)));

      connect(action, SIGNAL(triggered()), m_flipbook, SLOT(regenerate()));

      action = menu->addAction(tr("Regenerate Frame Preview"));

      action->setShortcut(QKeySequence(

          CommandManager::instance()->getKeyFromId(MI_RegenerateFramePr)));

      connect(action, SIGNAL(triggered()), m_flipbook, SLOT(regenerateFrame()));

      menu->addSeparator();

    }

    action = menu->addAction(tr("Load / Append Images"));

    connect(action, SIGNAL(triggered()), m_flipbook, SLOT(loadImages()));

    // history of the loaded paths of flipbook

    action = CommandManager::instance()->getAction(MI_LoadRecentImage);

    menu->addAction(action);

    action->setParent(m_flipbook);

    menu->addSeparator();

  }

  QAction *reset = menu->addAction(tr("Reset View"));

  reset->setShortcut(

      QKeySequence(CommandManager::instance()->getKeyFromId(V_ViewReset)));

  connect(reset, SIGNAL(triggered()), SLOT(resetView()));

  QAction *fit = menu->addAction(tr("Fit To Window"));

  fit->setShortcut(

      QKeySequence(CommandManager::instance()->getKeyFromId(V_ZoomFit)));

  connect(fit, SIGNAL(triggered()), SLOT(fitView()));

  if (m_flipbook) {

#ifdef _WIN32

    if (ImageUtils::FullScreenWidget *fsWidget =

            dynamic_cast<imageutils::fullscreenwidget *="">(parentWidget())) {</imageutils::fullscreenwidget>

      bool isFullScreen = (fsWidget->windowState() & Qt::WindowFullScreen) != 0;

      action = menu->addAction(isFullScreen ? tr("Exit Full Screen Mode")

                                            : tr("Full Screen Mode"));

      action->setShortcut(QKeySequence(

          CommandManager::instance()->getKeyFromId(V_ShowHideFullScreen)));

      connect(action, SIGNAL(triggered()), fsWidget, SLOT(toggleFullScreen()));

    }

#endif

    bool addedSep = false;

    if (m_isHistogramEnable &&

        visibleRegion().contains(event->pos() * getDevPixRatio())) {

      menu->addSeparator();

      addedSep = true;

      action   = menu->addAction(tr("Show Histogram"));

      connect(action, SIGNAL(triggered()), SLOT(showHistogram()));

    }

    if (m_visualSettings.m_doCompare) {

      if (!addedSep) {

        menu->addSeparator();

        addedSep = true;

      }

      action = menu->addAction(tr("Swap Compared Images"));

      connect(action, SIGNAL(triggered()), SLOT(swapCompared()));

    }

    if (m_flipbook->isSavable()) {

      if (!addedSep) menu->addSeparator();

      action = menu->addAction(tr("Save Images"));

      connect(action, SIGNAL(triggered()), m_flipbook, SLOT(saveImages()));

    }

  }

  menu->exec(event->globalPos());

  if (m_flipbook) {

    action = CommandManager::instance()->getAction(MI_LoadRecentImage);

    action->setParent(0);

  }

  delete menu;

  update();

}

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

void ImageViewer::setVisual(const ImagePainter::VisualSettings &settings) {

  if (m_isHistogramEnable && m_histogramPopup &&

      settings.m_doCompare != m_visualSettings.m_doCompare) {

    m_histogramPopup->setShowCompare(settings.m_doCompare);

  }

  m_visualSettings = settings;

  m_visualSettings.m_sceneProperties =

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

  m_visualSettings.m_drawExternalBG = true;

}

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

ImageViewer::~ImageViewer() {

  // iwsw commented out temporarily

  /*

  if (m_ghibli3DLutUtil)

  {

          m_ghibli3DLutUtil->onEnd();

          delete m_ghibli3DLutUtil;

  }

  */

  if (m_fbo) delete m_fbo;

}

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

/*! Set current image to \b image and update. If Histogram is visible set its

 * image.

 */

void ImageViewer::setImage(TImageP image, TImageP orgImage) {

  m_image    = image;

  m_orgImage = orgImage;

  if (m_image && m_firstImage) {

    m_firstImage = false;

    fitView();

    // when the viewer size is large enough, limit the zoom ratio to 100% so

    // that the image is shown in actual pixel size without jaggies due to

    // resampling.

    if (fabs(m_viewAff.det()) > 1.0) resetView();

  }

  if (m_isHistogramEnable && m_histogramPopup->isVisible())

    m_histogramPopup->setImage((orgImage) ? orgImage : image);

  // make sure to redraw the frame here.

  // repaint() does NOT immediately redraw the frame for QOpenGLWidget

  update();

  if (!isColorModel()) qApp->processEvents();

}

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

void ImageViewer::setHistogramTitle(QString levelName) {

  if (m_isHistogramEnable && m_histogramPopup->isVisible()) {

    QString histogramTitle = QString("Histogram  ::  ") + levelName;

    m_histogramPopup->setTitle(histogramTitle);

  }

}

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

void ImageViewer::setHistogramEnable(bool enable) {

  m_isHistogramEnable = enable;

  if (m_isHistogramEnable && !m_histogramPopup)

    m_histogramPopup = new HistogramPopup(tr("Flipbook Histogram"));

}

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

void ImageViewer::hideHistogram() {

  if (!m_isHistogramEnable) return;

  m_histogramPopup->setImage(TImageP());

  if (m_histogramPopup->isVisible()) {

    m_histogramPopup->hide();

    m_histogramPopup->setTitle(tr("Flipbook Histogram"));

  }

}

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

void ImageViewer::initializeGL() {

  initializeOpenGLFunctions();

  // to be computed once through the software

  if (m_lutCalibrator && !m_lutCalibrator->isInitialized()) {

    m_lutCalibrator->initialize();

    connect(context(), SIGNAL(aboutToBeDestroyed()), this,

            SLOT(onContextAboutToBeDestroyed()));

  }

  // glClearColor(1.0,1.0,1.0,1);

  glClear(GL_COLOR_BUFFER_BIT);

  if (m_firstInitialized)

    m_firstInitialized = false;

  else {

    resizeGL(width(), height());

    update();

  }

}

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

void ImageViewer::resizeGL(int w, int h) {

  w *= getDevPixRatio();

  h *= getDevPixRatio();

  glViewport(0, 0, w, h);

  glMatrixMode(GL_PROJECTION);

  glLoadIdentity();

  double nearPlane   = 100;

  double farPlane    = 2500;

  double centerPlane = 1100;

  glOrtho(0, w, 0, h, -4000, 4000);

  glMatrixMode(GL_MODELVIEW);

  glLoadIdentity();

  glTranslatef(0.375, 0.375, 0.0);

  glTranslated(w * 0.5, h * 0.5, 0);

  // remake fbo with new size

  if (m_lutCalibrator && m_lutCalibrator->isValid()) {

    if (m_fbo) delete m_fbo;

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

      QOpenGLFramebufferObjectFormat format;

      format.setInternalTextureFormat(TGL_TexFmt10);

      m_fbo = new QOpenGLFramebufferObject(w, h, format);

    } else  // normally, initialize with GL_RGBA8 format

      m_fbo = new QOpenGLFramebufferObject(w, h);

  }

}

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

void ImageViewer::paintGL() {

  initializeOpenGLFunctions();

  if (m_lutCalibrator && m_lutCalibrator->isValid()) m_fbo->bind();

  TDimension viewerSize(width(), height());

  TAffine aff = m_viewAff;

  // if (!m_visualSettings.m_defineLoadbox && m_flipbook &&

  // m_flipbook->getLoadbox()!=TRect())

  //  offs =

  //  convert(m_flipbook->getLoadbox().getP00())-TPointD(m_flipbook->getImageSize().lx/2.0,

  //  m_flipbook->getImageSize().ly/2.0);

  TDimension imageSize;

  TRect loadbox;

  if (m_flipbook) {

    QString title =

        (!m_image)

            ? m_flipbook->getTitle() + tr("  ::  Zoom : ") +

                  QString::number(tround(sqrt(m_viewAff.det()) * 100)) + " %"

            : m_flipbook->getLevelZoomTitle() + tr("  ::  Zoom : ") +

                  QString::number(tround(sqrt(m_viewAff.det()) * 100)) + " %";

    m_flipbook->parentWidget()->setWindowTitle(title);

    imageSize = m_flipbook->getImageSize();

    if (m_visualSettings.m_useLoadbox && m_flipbook->getLoadbox() != TRect())

      loadbox = m_flipbook->getLoadbox();

  }

  m_visualSettings.m_sceneProperties =

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

  // enable checks only in the color model

  m_visualSettings.m_useChecks = m_isColorModel;

  ImagePainter::paintImage(m_image, imageSize, viewerSize, aff,

                           m_visualSettings, m_compareSettings, loadbox);

  // when fx parameter is modified with showing the fx preview,

  // a flipbook shows a red border line before the rendered result is shown.

  if (m_isRemakingPreviewFx) {

    glPushMatrix();

    glLoadIdentity();

    glColor3d(1.0, 0.0, 0.0);

    glBegin(GL_LINE_LOOP);

    glVertex2d(5, 5);

    glVertex2d(5, height() - 5);

    glVertex2d(width() - 5, height() - 5);

    glVertex2d(width() - 5, 5);

    glEnd();

    glBegin(GL_LINE_LOOP);

    glVertex2d(10, 10);

    glVertex2d(10, height() - 10);

    glVertex2d(width() - 10, height() - 10);

    glVertex2d(width() - 10, 10);

    glEnd();

    glPopMatrix();

  }

  if (!m_image) {

    if (m_lutCalibrator && m_lutCalibrator->isValid())

      m_lutCalibrator->onEndDraw(m_fbo);

    if (m_timer && m_timer->isValid()) {

      qint64 currentInstant = m_timer->nsecsElapsed();

      while (currentInstant < m_targetInstant) {

        currentInstant = m_timer->nsecsElapsed();

      }

    }

    return;

  }

  if (safeAreaToggle.getStatus() && !m_isColorModel) {

    TRasterImageP rimg = (TRasterImageP)m_image;

    TVectorImageP vimg = (TVectorImageP)m_image;

    TToonzImageP timg  = (TToonzImageP)m_image;

    TRect bbox;

    TPointD centerD;

    TRect bounds;

    if (rimg) {

      centerD = rimg->getRaster()->getCenterD();

      bounds  = rimg->getRaster()->getBounds();

    } else if (timg) {

      centerD = timg->getRaster()->getCenterD();

      bounds  = timg->getRaster()->getBounds();

    }

    if (!vimg) {

      TAffine aff = TTranslation(viewerSize.lx * 0.5, viewerSize.ly * 0.5) *

                    m_viewAff * TTranslation(-centerD);

      TRectD bbox = aff * TRectD(0, 0, bounds.getLx() - 1, bounds.getLy() - 1);

      drawSafeArea(bbox);

    }

  }

  TPoint fromPos, toPos;

  if (m_visualSettings.m_defineLoadbox && m_flipbook) {

    TRect loadbox =

        convert(getImgToWidgetAffine() * convert(m_flipbook->getLoadbox()));

    if (loadbox != TRect()) {

      TPoint p00 = loadbox.getP00();

      TPoint p11 = loadbox.getP11();

      fromPos =

          TPoint(p00.x - width() * 0.5,

                 height() * 0.5 - p00.y);  // m_flipbook->getLoadbox().getP00();

      toPos =

          TPoint(p11.x - width() * 0.5,

                 height() * 0.5 - p11.y);  // m_flipbook->getLoadbox().getP11();

    }

  } else if (m_draggingZoomSelection || m_rectRGBPick) {

    fromPos = TPoint(m_pressedMousePos.x - width() * 0.5,

                     height() * 0.5 - m_pressedMousePos.y);

    toPos   = TPoint(m_pos.x() - width() * 0.5, height() * 0.5 - m_pos.y());

  }

  if (fromPos != TPoint() || toPos != TPoint()) {

    if (m_rectRGBPick) {

      tglColor(TPixel32::Red);

      // TODO: glLineStipple is deprecated in the latest OpenGL. Need to be

      // replaced. (shun_iwasawa 2015/12/25)

      glLineStipple(1, 0x3F33);

      glEnable(GL_LINE_STIPPLE);

      glBegin(GL_LINE_STRIP);

      // do not draw the rect around the mouse cursor

      int margin = (fromPos.y < toPos.y) ? -3 : 3;

      glVertex2i(toPos.x, toPos.y + margin);

      glVertex2i(toPos.x, fromPos.y);

      glVertex2i(fromPos.x, fromPos.y);

      glVertex2i(fromPos.x, toPos.y);

      margin = (fromPos.x < toPos.x) ? -3 : 3;

      glVertex2i(toPos.x + margin, toPos.y);

      glEnd();

      glDisable(GL_LINE_STIPPLE);

    } else {

      tglColor(m_draggingZoomSelection ? TPixel32::Red : TPixel32::Blue);

      glBegin(GL_LINE_STRIP);

      glVertex2i(fromPos.x, fromPos.y);

      glVertex2i(fromPos.x, toPos.y);

      glVertex2i(toPos.x, toPos.y);

      glVertex2i(toPos.x, fromPos.y);

      glVertex2i(fromPos.x, fromPos.y);

      glEnd();

    }

  }

  if (m_lutCalibrator && m_lutCalibrator->isValid())

    m_lutCalibrator->onEndDraw(m_fbo);

  // wait to achieve precise fps

  if (m_timer && m_timer->isValid()) {

    qint64 currentInstant = m_timer->nsecsElapsed();

    while (currentInstant < m_targetInstant) {

      currentInstant = m_timer->nsecsElapsed();

    }

  }

}

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

/*! Add to current transformation matrix a \b delta translation.

 */

void ImageViewer::panQt(const QPoint &delta) {

  if (delta == QPoint()) return;

  // stop panning when the image is at the edge of window

  QPoint delta_(delta.x(), delta.y());

  TToonzImageP timg  = (TToonzImageP)m_image;

  TRasterImageP rimg = (TRasterImageP)m_image;

  if (timg || rimg) {

    bool isXPlus = delta.x() > 0;

    bool isYPlus = delta.y() > 0;

    TDimension imgSize((timg) ? timg->getSize() : rimg->getRaster()->getSize());

    int subSampling = (timg) ? timg->getSubsampling() : rimg->getSubsampling();

    TPointD cornerPos = TPointD(imgSize.lx * ((isXPlus) ? -1 : 1),

                                imgSize.ly * ((isYPlus) ? 1 : -1)) *

                        (0.5 / (double)subSampling);

    cornerPos = m_viewAff * cornerPos;

    if ((cornerPos.x > 0) == isXPlus) delta_.setX(0);

    if ((cornerPos.y < 0) == isYPlus) delta_.setY(0);

  }

  setViewAff(TTranslation(delta_.x(), -delta_.y()) * m_viewAff);

  update();

}

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

/*! Add to current transformation matrix a \b center translation matched with a

                scale of factor \b factor. Apply a zoom of factor \b factor with

   center

                \b center.

*/

void ImageViewer::zoomQt(const QPoint ¢er, double factor) {

  if (factor == 1.0) return;

  TPointD delta(center.x(), center.y());

  double scale2 = fabs(m_viewAff.det());

  if ((scale2 < 100000 || factor < 1) && (scale2 > 0.001 * 0.05 || factor > 1))

    setViewAff(TTranslation(delta) * TScale(factor) * TTranslation(-delta) *

               m_viewAff);

  update();

}

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

void ImageViewer::zoomQt(bool forward, bool reset) {

  double scale2 = m_viewAff.det();

  if (reset)

    setViewAff(TAffine());

  else if (((scale2 < 100000 || !forward) &&

            (scale2 > 0.001 * 0.05 || forward))) {

    double oldZoomScale = sqrt(scale2);

    double zoomScale =

        reset ? 1 : ImageUtils::getQuantizedZoomFactor(oldZoomScale, forward);

    setViewAff(TScale(zoomScale / oldZoomScale) * m_viewAff);

  }

  update();

}

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

void ImageViewer::resetZoom() {

  double oldZoomScale = sqrt(m_viewAff.det());

  setViewAff(TScale(1.0 / oldZoomScale) * m_viewAff);

  update();

}

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

void ImageViewer::dragCompare(const QPoint &dp) {

  if (m_compareSettings.m_dragCompareX)

    m_compareSettings.m_compareX += ((double)dp.x()) / width();

  else if (m_compareSettings.m_dragCompareY)

    m_compareSettings.m_compareY -= ((double)dp.y()) / height();

  m_compareSettings.m_compareX = tcrop(m_compareSettings.m_compareX, 0.0, 1.0);

  m_compareSettings.m_compareY = tcrop(m_compareSettings.m_compareY, 0.0, 1.0);

  update();

}

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

void ImageViewer::updateLoadbox(const TPoint &curPos) {

  TAffine aff = getImgToWidgetAffine();

  TRect r =

      m_flipbook

          ->getLoadbox();  // convert(aff*convert(m_flipbook->getLoadbox()));

  if (m_dragType == eDrawRect)

    r = convert(aff.inv() *

                convert(TRect(m_pressedMousePos,

                              curPos)));  // TRect(m_pressedMousePos, curPos);

  else if (m_dragType == eMoveRect)

    r = r + (TPoint(curPos.x, -curPos.y) - TPoint(m_pos.x(), -m_pos.y()));

  else {

    double fac = sqrt(1.0 / fabs(aff.det()));

    if (m_dragType & eMoveLeft) r.x0 += fac * (curPos.x - m_pos.x());

    if (m_dragType & eMoveRight) r.x1 += fac * (curPos.x - m_pos.x());

    if (m_dragType & eMoveDown) r.y1 -= fac * (curPos.y - m_pos.y());

    if (m_dragType & eMoveUp) r.y0 -= fac * (curPos.y - m_pos.y());

  }

  m_flipbook->setLoadbox(r);  // convert(aff.inv() * convert(r)));

}

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

void ImageViewer::updateCursor(const TPoint &curPos) {

  int dragType = getDragType(

      curPos,

      convert(getImgToWidgetAffine() * convert(m_flipbook->getLoadbox())));

  switch (dragType) {

  case eMoveRect:

    setCursor(Qt::SizeAllCursor);

    break;

  case eMoveLeft:

  case eMoveRight:

    setCursor(Qt::SizeHorCursor);

    break;

  case eMoveDown:

  case eMoveUp:

    setCursor(Qt::SizeVerCursor);

    break;

  case eMoveLeft | eMoveUp:

  case eMoveRight | eMoveDown:

    setCursor(Qt::SizeBDiagCursor);

    break;

  case eMoveLeft | eMoveDown:

  case eMoveRight | eMoveUp:

    setCursor(Qt::SizeFDiagCursor);

    break;

  default:

    setCursor(Qt::ArrowCursor);

    break;

  }

}

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

void ImageViewer::showEvent(QShowEvent *) {

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

  bool ret = connect(sceneHandle, SIGNAL(preferenceChanged(const QString &)),

                     this, SLOT(onPreferenceChanged(const QString &)));

  onPreferenceChanged("ColorCalibration");

  assert(ret);

}

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

void ImageViewer::hideEvent(QHideEvent *) {

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

  if (sceneHandle) sceneHandle->disconnect(this);

}

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

/*! If middle button is pressed pan the image. Update current mouse position.

 */

void ImageViewer::mouseMoveEvent(QMouseEvent *event) {

  if (!m_image) return;

  if (m_gestureActive && m_touchDevice == QTouchDevice::TouchScreen &&

      !m_stylusUsed) {

    return;

  }

  QPoint curQPos = event->pos() * getDevPixRatio();

  TPoint curPos = TPoint(curQPos.x(), curQPos.y());

  if (m_visualSettings.m_defineLoadbox && m_flipbook) {

    if (m_mouseButton == Qt::LeftButton)

      updateLoadbox(curPos);

    else if (m_mouseButton == Qt::MidButton)

      panQt(curQPos - m_pos);

    else

      updateCursor(curPos);

    update();

    event->ignore();

    m_pos = curQPos;

    return;

  }

  // setting the cursors

  if (!m_isColorModel) {

    // when the histogram window is opened, switch to the RGB picker tool

    if (m_isHistogramEnable && m_histogramPopup->isVisible())

      setToolCursor(this, ToolCursor::PickerRGB);

    else

      setCursor(Qt::ArrowCursor);

  }

  if (m_visualSettings.m_doCompare && m_mouseButton == Qt::NoButton) {

    if (fabs(curPos.x - width() * m_compareSettings.m_compareX) < 20)

      setToolCursor(this, ToolCursor::ScaleHCursor);

    else if (fabs((height() - curPos.y) -

                  height() * m_compareSettings.m_compareY) < 20)

      setToolCursor(this, ToolCursor::ScaleVCursor);

  }

  if (m_compareSettings.m_dragCompareX || m_compareSettings.m_dragCompareY)

    dragCompare(curQPos - m_pos);

  else if (m_mouseButton == Qt::MidButton)

    panQt(curQPos - m_pos);

  m_pos = curQPos;

  // pick the color if the histogram popup is opened

  if (m_isHistogramEnable && m_histogramPopup->isVisible() && !m_isColorModel) {

    // Rect Pick