dupeguru/qt/pe/image_viewer.py

# This software is licensed under the "GPLv3" License as described in the "LICENSE" file,
# which should be included with this package. The terms are also available at
# http://www.gnu.org/licenses/gpl-3.0.html

from PyQt5.QtCore import (
    QObject, Qt, QSize, QRectF, QPointF, QPoint, pyqtSlot, pyqtSignal, QEvent)
from PyQt5.QtGui import QPixmap, QPainter, QPalette, QCursor, QIcon, QKeySequence
from PyQt5.QtWidgets import (
    QGraphicsView, QGraphicsScene, QGraphicsPixmapItem,
    QToolBar, QToolButton, QAction, QWidget, QScrollArea,
    QApplication, QAbstractScrollArea, QStyle)
from hscommon.trans import trget
from hscommon.plat import ISLINUX
tr = trget("ui")

MAX_SCALE = 12.0
MIN_SCALE = 0.1


def createActions(actions, target):
    # actions = [(name, shortcut, icon, desc, func)]
    for name, shortcut, icon, desc, func in actions:
        action = QAction(target)
        if icon:
            action.setIcon(icon)
        if shortcut:
            action.setShortcut(shortcut)
        action.setText(desc)
        action.triggered.connect(func)
        setattr(target, name, action)


class ViewerToolBar(QToolBar):
    def __init__(self, parent, controller):
        super().__init__(parent)
        self.parent = parent
        self.controller = controller
        self.setupActions(controller)
        self.createButtons()
        self.buttonImgSwap.setEnabled(False)
        self.buttonZoomIn.setEnabled(False)
        self.buttonZoomOut.setEnabled(False)
        self.buttonNormalSize.setEnabled(False)
        self.buttonBestFit.setEnabled(False)

    def setupActions(self, controller):
        # actions = [(name, shortcut, icon, desc, func)]
        ACTIONS = [
            (
                "actionZoomIn",
                QKeySequence.ZoomIn,
                QIcon.fromTheme("zoom-in") if ISLINUX
                else QIcon(QPixmap(":/" + "zoom_in")),
                tr("Increase zoom"),
                controller.zoomIn,
            ),
            (
                "actionZoomOut",
                QKeySequence.ZoomOut,
                QIcon.fromTheme("zoom-out") if ISLINUX
                else QIcon(QPixmap(":/" + "zoom_out")),
                tr("Decrease zoom"),
                controller.zoomOut,
            ),
            (
                "actionNormalSize",
                tr("Ctrl+/"),
                QIcon.fromTheme("zoom-original") if ISLINUX
                else QIcon(QPixmap(":/" + "zoom_original")),
                tr("Normal size"),
                controller.zoomNormalSize,
            ),
            (
                "actionBestFit",
                tr("Ctrl+*"),
                QIcon.fromTheme("zoom-best-fit") if ISLINUX
                else QIcon(QPixmap(":/" + "zoom_best_fit")),
                tr("Best fit"),
                controller.zoomBestFit,
            )
        ]
        # TODO try with QWidgetAction() instead in order to have
        # the popup menu work in the toolbar (if resized below minimum height)
        createActions(ACTIONS, self)

    def createButtons(self):
        self.buttonImgSwap = QToolButton(self)
        self.buttonImgSwap.setToolButtonStyle(Qt.ToolButtonIconOnly)
        self.buttonImgSwap.setIcon(
            QIcon.fromTheme('view-refresh',
                            self.style().standardIcon(QStyle.SP_BrowserReload))
            if ISLINUX
            else QIcon(QPixmap(":/" + "exchange")))
        self.buttonImgSwap.setText('Swap images')
        self.buttonImgSwap.setToolTip('Swap images')
        self.buttonImgSwap.pressed.connect(self.controller.swapImages)
        self.buttonImgSwap.released.connect(self.controller.swapImages)

        self.buttonZoomIn = QToolButton(self)
        self.buttonZoomIn.setToolButtonStyle(Qt.ToolButtonIconOnly)
        self.buttonZoomIn.setDefaultAction(self.actionZoomIn)
        # self.buttonZoomIn.setText('ZoomIn')
        # self.buttonZoomIn.setIcon(QIcon.fromTheme('zoom-in'))
        self.buttonZoomIn.setEnabled(False)

        self.buttonZoomOut = QToolButton(self)
        self.buttonZoomOut.setToolButtonStyle(Qt.ToolButtonIconOnly)
        self.buttonZoomOut.setDefaultAction(self.actionZoomOut)
        # self.buttonZoomOut.setText('ZoomOut')
        # self.buttonZoomOut.setIcon(QIcon.fromTheme('zoom-out'))
        self.buttonZoomOut.setEnabled(False)

        self.buttonNormalSize = QToolButton(self)
        self.buttonNormalSize.setToolButtonStyle(Qt.ToolButtonIconOnly)
        self.buttonNormalSize.setDefaultAction(self.actionNormalSize)
        # self.buttonNormalSize.setText('Normal Size')
        # self.buttonNormalSize.setIcon(QIcon.fromTheme('zoom-original'))
        self.buttonNormalSize.setEnabled(True)

        self.buttonBestFit = QToolButton(self)
        self.buttonBestFit.setToolButtonStyle(Qt.ToolButtonIconOnly)
        self.buttonBestFit.setDefaultAction(self.actionBestFit)
        # self.buttonBestFit.setText('BestFit')
        # self.buttonBestFit.setIcon(QIcon.fromTheme('zoom-best-fit'))
        self.buttonBestFit.setEnabled(False)

        self.addWidget(self.buttonImgSwap)
        self.addWidget(self.buttonZoomIn)
        self.addWidget(self.buttonZoomOut)
        self.addWidget(self.buttonNormalSize)
        self.addWidget(self.buttonBestFit)


class BaseController(QObject):
    """Abstract Base class. Singleton.
    Base proxy interface to keep image viewers synchronized.
    Relays function calls, keep tracks of things."""

    def __init__(self, parent):
        super().__init__()
        self.selectedViewer = None
        self.referenceViewer = None
        # cached pixmaps
        self.selectedPixmap = QPixmap()
        self.referencePixmap = QPixmap()
        self.scaledSelectedPixmap = QPixmap()
        self.scaledReferencePixmap = QPixmap()
        self.current_scale = 1.0
        self.bestFit = True
        self.parent = parent  # To change buttons' states
        self.cached_group = None
        self.same_dimensions = True

    def setupViewers(self, selectedViewer, referenceViewer):
        self.selectedViewer = selectedViewer
        self.referenceViewer = referenceViewer
        self.selectedViewer.controller = self
        self.referenceViewer.controller = self
        self._setupConnections()

    def _setupConnections(self):
        self.selectedViewer.connectMouseSignals()
        self.referenceViewer.connectMouseSignals()

    def updateView(self, ref, dupe, group):
        # To keep current scale accross dupes from the same group
        previous_same_dimensions = self.same_dimensions
        self.same_dimensions = True
        same_group = True
        if group != self.cached_group:
            same_group = False
            self.resetState()
        self.cached_group = group

        self.selectedPixmap = QPixmap(str(dupe.path))
        if ref is dupe:  # currently selected file is the actual reference file
            # self.same_dimensions = False
            self.referencePixmap = QPixmap()
            self.scaledReferencePixmap = QPixmap()
            self.parent.verticalToolBar.buttonImgSwap.setEnabled(False)
            self.parent.verticalToolBar.buttonNormalSize.setEnabled(True)
        else:
            self.referencePixmap = QPixmap(str(ref.path))
            self.parent.verticalToolBar.buttonImgSwap.setEnabled(True)
            if ref.dimensions != dupe.dimensions:
                self.same_dimensions = False
            self.parent.verticalToolBar.buttonNormalSize.setEnabled(True)
        self.updateButtonsAsPerDimensions(previous_same_dimensions)
        self.updateBothImages(same_group)
        self.centerViews(same_group and self.referencePixmap.isNull())

    def updateBothImages(self, same_group=False):
        # WARNING this is called on every resize event,
        ignore_update = self.referencePixmap.isNull()
        if ignore_update:
            self.selectedViewer.ignore_signal = True
        # the SelectedImageViewer widget sometimes ends up being bigger
        # than the ReferenceImageViewer by one pixel, which distorts the
        # scaled down pixmap for the reference, hence we'll reuse its size here.
        selected_size = self._updateImage(
            self.selectedPixmap, self.scaledSelectedPixmap,
            self.selectedViewer, None, same_group)
        self._updateImage(
            self.referencePixmap, self.scaledReferencePixmap,
            self.referenceViewer, selected_size, same_group)
        if ignore_update:
            self.selectedViewer.ignore_signal = False

    def _updateImage(self, pixmap, scaledpixmap, viewer, target_size=None, same_group=False):
        # WARNING this is called on every resize event, might need to split
        # into a separate function depending on the implementation used
        if pixmap.isNull():
            # This should disable the blank widget
            viewer.setImage(pixmap)
            return
        target_size = viewer.size()
        if not viewer.bestFit:
            if same_group:
                viewer.setImage(pixmap)
                return target_size
            # zoomed in state, expand
            # only if not same_group, we need full update
            scaledpixmap = pixmap.scaled(
                target_size, Qt.KeepAspectRatioByExpanding, Qt.FastTransformation)
        else:
            # best fit, keep ratio always
            scaledpixmap = pixmap.scaled(
                target_size, Qt.KeepAspectRatio, Qt.FastTransformation)
        viewer.setImage(scaledpixmap)
        return target_size

    def resetState(self):
        """Only called when the group of dupes has changed. We reset our
        controller internal state and buttons, center view on viewers."""
        self.selectedPixmap = QPixmap()
        self.scaledSelectedPixmap = QPixmap()
        self.referencePixmap = QPixmap()
        self.scaledReferencePixmap = QPixmap()
        self.setBestFit(True)
        self.current_scale = 1.0
        self.selectedViewer.current_scale = 1.0
        self.referenceViewer.current_scale = 1.0
        self.selectedViewer.resetCenter()
        self.referenceViewer.resetCenter()
        self.selectedViewer.scaleAt(1.0)
        self.referenceViewer.scaleAt(1.0)
        self.centerViews()
        self.parent.verticalToolBar.buttonZoomIn.setEnabled(False)
        self.parent.verticalToolBar.buttonZoomOut.setEnabled(False)
        self.parent.verticalToolBar.buttonNormalSize.setEnabled(True)
        self.parent.verticalToolBar.buttonBestFit.setEnabled(False)  # active mode by default

    def resetViewersState(self):
        """No item from the model, disable and clear everything."""
        # only called by the details dialog
        self.selectedPixmap = QPixmap()
        self.scaledSelectedPixmap = QPixmap()
        self.referencePixmap = QPixmap()
        self.scaledReferencePixmap = QPixmap()
        self.setBestFit(True)
        self.current_scale = 1.0
        self.selectedViewer.current_scale = 1.0
        self.referenceViewer.current_scale = 1.0
        self.selectedViewer.resetCenter()
        self.referenceViewer.resetCenter()
        self.selectedViewer.scaleAt(1.0)
        self.referenceViewer.scaleAt(1.0)
        self.centerViews()

        self.parent.verticalToolBar.buttonImgSwap.setEnabled(False)
        self.parent.verticalToolBar.buttonZoomIn.setEnabled(False)
        self.parent.verticalToolBar.buttonZoomOut.setEnabled(False)
        self.parent.verticalToolBar.buttonNormalSize.setEnabled(False)
        self.parent.verticalToolBar.buttonBestFit.setEnabled(False)  # active mode by default

        self.selectedViewer.setImage(self.selectedPixmap)  # null
        self.selectedViewer.setEnabled(False)
        self.referenceViewer.setImage(self.referencePixmap)  # null
        self.referenceViewer.setEnabled(False)

    @pyqtSlot()
    def zoomIn(self):
        self.scaleImagesBy(1.25)

    @pyqtSlot()
    def zoomOut(self):
        self.scaleImagesBy(0.8)

    @pyqtSlot(float)
    def scaleImagesBy(self, factor):
        """Compute new scale from factor and scale."""
        self.current_scale *= factor
        self.selectedViewer.scaleBy(factor)
        self.referenceViewer.scaleBy(factor)
        self.updateButtons()

    @pyqtSlot(float)
    def scaleImagesAt(self, scale):
        """Scale at a pre-computed scale."""
        self.current_scale = scale
        self.selectedViewer.scaleAt(scale)
        self.referenceViewer.scaleAt(scale)
        self.updateButtons()

    def updateButtons(self):
        self.parent.verticalToolBar.buttonZoomIn.setEnabled(self.current_scale < MAX_SCALE)
        self.parent.verticalToolBar.buttonZoomOut.setEnabled(self.current_scale > MIN_SCALE)
        self.parent.verticalToolBar.buttonNormalSize.setEnabled(round(self.current_scale, 1) != 1.0)
        self.parent.verticalToolBar.buttonBestFit.setEnabled(self.bestFit is False)

    def updateButtonsAsPerDimensions(self, previous_same_dimensions):
        if not self.same_dimensions:
            self.parent.verticalToolBar.buttonZoomIn.setEnabled(False)
            self.parent.verticalToolBar.buttonZoomOut.setEnabled(False)
            if not self.bestFit:
                self.zoomBestFit()
                self.parent.verticalToolBar.buttonNormalSize.setEnabled(True)
                if not self.referencePixmap.isNull():
                    self.parent.verticalToolBar.buttonImgSwap.setEnabled(True)
            return
        if not self.bestFit and not previous_same_dimensions:
            self.zoomBestFit()
            self.parent.verticalToolBar.buttonNormalSize.setEnabled(True)
            if self.referencePixmap.isNull():
                self.parent.verticalToolBar.buttonImgSwap.setEnabled(False)

    @pyqtSlot()
    def zoomBestFit(self):
        """Setup before scaling to bestfit"""
        self.setBestFit(True)
        self.current_scale = 1.0
        self.selectedViewer.current_scale = 1.0
        self.referenceViewer.current_scale = 1.0

        self.selectedViewer.scaleAt(1.0)
        self.referenceViewer.scaleAt(1.0)

        self.selectedViewer.resetCenter()
        self.referenceViewer.resetCenter()

        target_size = self._updateImage(
            self.selectedPixmap, self.scaledSelectedPixmap,
            self.selectedViewer, None, True)
        self._updateImage(
            self.referencePixmap, self.scaledReferencePixmap,
            self.referenceViewer, target_size, True)
        self.centerViews()

        self.parent.verticalToolBar.buttonZoomIn.setEnabled(False)
        self.parent.verticalToolBar.buttonZoomOut.setEnabled(False)
        self.parent.verticalToolBar.buttonNormalSize.setEnabled(True)
        self.parent.verticalToolBar.buttonBestFit.setEnabled(False)
        self.parent.verticalToolBar.buttonImgSwap.setEnabled(True)

    def setBestFit(self, value):
        self.bestFit = value
        self.selectedViewer.bestFit = value
        self.referenceViewer.bestFit = value

    @pyqtSlot()
    def zoomNormalSize(self):
        self.setBestFit(False)
        self.current_scale = 1.0

        self.selectedViewer.setImage(self.selectedPixmap)
        self.referenceViewer.setImage(self.referencePixmap)

        self.centerViews()

        self.selectedViewer.scaleToNormalSize()
        self.referenceViewer.scaleToNormalSize()

        if self.same_dimensions:
            self.parent.verticalToolBar.buttonZoomIn.setEnabled(True)
            self.parent.verticalToolBar.buttonZoomOut.setEnabled(True)
        else:
            # we can't allow swapping pixmaps of different dimensions
            self.parent.verticalToolBar.buttonImgSwap.setEnabled(False)
        self.parent.verticalToolBar.buttonNormalSize.setEnabled(False)
        self.parent.verticalToolBar.buttonBestFit.setEnabled(True)

    def centerViews(self, only_selected=False):
        self.selectedViewer.centerViewAndUpdate()
        if only_selected:
            return
        self.referenceViewer.centerViewAndUpdate()

    @pyqtSlot()
    def swapImages(self):
        # swap the columns in the details table as well
        self.parent.tableView.horizontalHeader().swapSections(1, 2)


class QWidgetController(BaseController):
    """Specialized version for QWidget-based viewers."""
    def __init__(self, parent):
        super().__init__(parent)

    def _updateImage(self, *args):
        ret = super()._updateImage(*args)
        # Fix alignment when resizing window
        self.centerViews()
        return ret

    @pyqtSlot(QPointF)
    def onDraggedMouse(self, delta):
        if not self.same_dimensions:
            return
        if self.sender() is self.referenceViewer:
            self.selectedViewer.onDraggedMouse(delta)
        else:
            self.referenceViewer.onDraggedMouse(delta)

    @pyqtSlot()
    def swapImages(self):
        self.selectedViewer._pixmap.swap(self.referenceViewer._pixmap)
        self.selectedViewer.centerViewAndUpdate()
        self.referenceViewer.centerViewAndUpdate()
        super().swapImages()


class ScrollAreaController(BaseController):
    """Specialized version fro QLabel-based viewers."""
    def __init__(self, parent):
        super().__init__(parent)

    def _setupConnections(self):
        super()._setupConnections()
        self.selectedViewer.connectScrollBars()
        self.referenceViewer.connectScrollBars()

    def updateBothImages(self, same_group=False):
        super().updateBothImages(same_group)
        if not self.referenceViewer.isEnabled():
            return
        self.referenceViewer._horizontalScrollBar.setValue(
            self.selectedViewer._horizontalScrollBar.value())
        self.referenceViewer._verticalScrollBar.setValue(
            self.selectedViewer._verticalScrollBar.value())

    @pyqtSlot(QPoint)
    def onDraggedMouse(self, delta):
        self.selectedViewer.ignore_signal = True
        self.referenceViewer.ignore_signal = True

        if self.same_dimensions:
            self.selectedViewer.onDraggedMouse(delta)
            self.referenceViewer.onDraggedMouse(delta)
        else:
            if self.sender() is self.selectedViewer:
                self.selectedViewer.onDraggedMouse(delta)
            else:
                self.referenceViewer.onDraggedMouse(delta)

        self.selectedViewer.ignore_signal = False
        self.referenceViewer.ignore_signal = False

    @pyqtSlot()
    def swapImages(self):
        self.referenceViewer._pixmap.swap(self.selectedViewer._pixmap)
        self.referenceViewer.setCachedPixmap()
        self.selectedViewer.setCachedPixmap()
        super().swapImages()

    @pyqtSlot(float, QPointF)
    def onMouseWheel(self, scale, delta):
        self.scaleImagesAt(scale)
        self.selectedViewer.adjustScrollBarsScaled(delta)
        # Signal from scrollbars will automatically change the other:
        # self.referenceViewer.adjustScrollBarsScaled(delta)

    @pyqtSlot(int)
    def onVScrollBarChanged(self, value):
        if not self.same_dimensions:
            return
        if self.sender() is self.referenceViewer._verticalScrollBar:
            if not self.selectedViewer.ignore_signal:
                self.selectedViewer._verticalScrollBar.setValue(value)
        else:
            if not self.referenceViewer.ignore_signal:
                self.referenceViewer._verticalScrollBar.setValue(value)

    @pyqtSlot(int)
    def onHScrollBarChanged(self, value):
        if not self.same_dimensions:
            return
        if self.sender() is self.referenceViewer._horizontalScrollBar:
            if not self.selectedViewer.ignore_signal:
                self.selectedViewer._horizontalScrollBar.setValue(value)
        else:
            if not self.referenceViewer.ignore_signal:
                self.referenceViewer._horizontalScrollBar.setValue(value)

    @pyqtSlot(float)
    def scaleImagesBy(self, factor):
        super().scaleImagesBy(factor)
        # The other is automatically updated via sigals
        self.selectedViewer.adjustScrollBarsFactor(factor)

    @pyqtSlot()
    def zoomBestFit(self):
        # Disable scrollbars to avoid GridLayout size rounding glitch
        super().zoomBestFit()
        if self.referencePixmap.isNull():
            self.parent.verticalToolBar.buttonImgSwap.setEnabled(False)
        self.selectedViewer.toggleScrollBars()
        self.referenceViewer.toggleScrollBars()


class GraphicsViewController(BaseController):
    """Specialized version fro QGraphicsView-based viewers."""
    def __init__(self, parent):
        super().__init__(parent)

    def _setupConnections(self):
        super()._setupConnections()
        self.selectedViewer.connectScrollBars()
        self.referenceViewer.connectScrollBars()
        # Special case for mouse wheel event conflicting with scrollbar adjustments
        self.selectedViewer.other_viewer = self.referenceViewer
        self.referenceViewer.other_viewer = self.selectedViewer

    @pyqtSlot()
    def syncCenters(self):
        if self.sender() is self.referenceViewer:
            self.selectedViewer.setCenter(self.referenceViewer._centerPoint)
        else:
            self.referenceViewer.setCenter(self.selectedViewer._centerPoint)

    @pyqtSlot(float, QPointF)
    def onMouseWheel(self, factor, newCenter):
        self.current_scale *= factor
        if self.sender() is self.referenceViewer:
            self.selectedViewer.scaleBy(factor)
            self.selectedViewer.setCenter(newCenter)
        else:
            self.referenceViewer.scaleBy(factor)
            self.referenceViewer.setCenter(newCenter)

    @pyqtSlot(int)
    def onVScrollBarChanged(self, value):
        if not self.same_dimensions:
            return
        if self.sender() is self.referenceViewer._verticalScrollBar:
            if not self.selectedViewer.ignore_signal:
                self.selectedViewer._verticalScrollBar.setValue(value)
        else:
            if not self.referenceViewer.ignore_signal:
                self.referenceViewer._verticalScrollBar.setValue(value)

    @pyqtSlot(int)
    def onHScrollBarChanged(self, value):
        if not self.same_dimensions:
            return
        if self.sender() is self.referenceViewer._horizontalScrollBar:
            if not self.selectedViewer.ignore_signal:
                self.selectedViewer._horizontalScrollBar.setValue(value)
        else:
            if not self.referenceViewer.ignore_signal:
                self.referenceViewer._horizontalScrollBar.setValue(value)

    @pyqtSlot()
    def swapImages(self):
        self.referenceViewer._pixmap.swap(self.selectedViewer._pixmap)
        self.referenceViewer.setCachedPixmap()
        self.selectedViewer.setCachedPixmap()
        super().swapImages()

    @pyqtSlot()
    def zoomBestFit(self):
        """Setup before scaling to bestfit"""
        self.setBestFit(True)
        self.current_scale = 1.0
        self.selectedViewer.fitScale()
        self.referenceViewer.fitScale()
        self.parent.verticalToolBar.buttonBestFit.setEnabled(False)
        self.parent.verticalToolBar.buttonZoomOut.setEnabled(False)
        self.parent.verticalToolBar.buttonZoomIn.setEnabled(False)
        self.parent.verticalToolBar.buttonNormalSize.setEnabled(True)
        if not self.referencePixmap.isNull():
            self.parent.verticalToolBar.buttonImgSwap.setEnabled(True)
        # else:
        #     self.referenceViewer.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        #     self.referenceViewer.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

    def updateView(self, ref, dupe, group):
        # Keep current scale accross dupes from the same group
        previous_same_dimensions = self.same_dimensions
        self.same_dimensions = True
        same_group = True
        if group != self.cached_group:
            same_group = False
            self.resetState()
        self.cached_group = group

        self.selectedPixmap = QPixmap(str(dupe.path))
        if ref is dupe:  # currently selected file is the actual reference file
            self.same_dimensions = False
            self.referencePixmap = QPixmap()
            self.parent.verticalToolBar.buttonImgSwap.setEnabled(False)
            self.parent.verticalToolBar.buttonNormalSize.setEnabled(True)
        else:
            self.referencePixmap = QPixmap(str(ref.path))
            self.parent.verticalToolBar.buttonImgSwap.setEnabled(True)
            if ref.dimensions != dupe.dimensions:
                self.same_dimensions = False
            self.parent.verticalToolBar.buttonNormalSize.setEnabled(True)
        # self.selectedViewer.setImage(self.selectedPixmap)
        # self.referenceViewer.setImage(self.referencePixmap)
        self.updateButtonsAsPerDimensions(previous_same_dimensions)
        self.updateBothImages(same_group)

    def updateBothImages(self, same_group=False):
        """This is called only during resize events and while bestFit."""
        ignore_update = self.referencePixmap.isNull()
        if ignore_update:
            self.selectedViewer.ignore_signal = True

        self._updateFitImage(
            self.selectedPixmap, self.selectedViewer)
        self._updateFitImage(
            self.referencePixmap, self.referenceViewer)

        if ignore_update:
            self.selectedViewer.ignore_signal = False

    def _updateFitImage(self, pixmap, viewer):
        # If not same_group, we need full update"""
        viewer.setImage(pixmap)
        if pixmap.isNull():
            # viewer._item = None
            return
        if viewer.bestFit:
            viewer.fitScale()

    def resetState(self):
        """Only called when the group of dupes has changed. We reset our
        controller internal state and buttons, center view on viewers."""
        self.selectedPixmap = QPixmap()
        self.referencePixmap = QPixmap()
        self.setBestFit(True)
        self.current_scale = 1.0
        self.selectedViewer.current_scale = 1.0
        self.referenceViewer.current_scale = 1.0

        self.selectedViewer.resetCenter()
        self.referenceViewer.resetCenter()

        self.selectedViewer.fitScale()
        self.referenceViewer.fitScale()
        # self.centerViews()
        self.parent.verticalToolBar.buttonZoomIn.setEnabled(False)
        self.parent.verticalToolBar.buttonZoomOut.setEnabled(False)
        self.parent.verticalToolBar.buttonBestFit.setEnabled(False)
        self.parent.verticalToolBar.buttonNormalSize.setEnabled(True)

    def resetViewersState(self):
        """No item from the model, disable and clear everything."""
        # only called by the details dialog
        self.selectedPixmap = QPixmap()
        self.scaledSelectedPixmap = QPixmap()
        self.referencePixmap = QPixmap()
        self.scaledReferencePixmap = QPixmap()
        self.setBestFit(True)
        self.current_scale = 1.0
        self.selectedViewer.current_scale = 1.0
        self.referenceViewer.current_scale = 1.0
        self.selectedViewer.resetCenter()
        self.referenceViewer.resetCenter()
        # self.centerViews()
        self.parent.verticalToolBar.buttonZoomIn.setEnabled(False)
        self.parent.verticalToolBar.buttonZoomOut.setEnabled(False)
        self.parent.verticalToolBar.buttonBestFit.setEnabled(False)
        self.parent.verticalToolBar.buttonImgSwap.setEnabled(False)
        self.parent.verticalToolBar.buttonNormalSize.setEnabled(False)

        self.selectedViewer.setImage(self.selectedPixmap)  # null
        self.selectedViewer.setEnabled(False)
        self.referenceViewer.setImage(self.referencePixmap)  # null
        self.referenceViewer.setEnabled(False)

    @pyqtSlot(float)
    def scaleImagesBy(self, factor):
        self.selectedViewer.updateCenterPoint()
        self.referenceViewer.updateCenterPoint()
        super().scaleImagesBy(factor)
        self.selectedViewer.centerOn(self.selectedViewer._centerPoint)
        # Scrollbars sync themselves here


class QWidgetImageViewer(QWidget):
    """Use a QPixmap, but no scrollbars and no keyboard key sequence for navigation."""
    # FIXME: panning while zoomed-in is broken (due to delta not interpolated right?
    mouseDragged = pyqtSignal(QPointF)
    mouseWheeled = pyqtSignal(float)

    def __init__(self, parent, name=""):
        super().__init__(parent)
        self._app = QApplication
        self._pixmap = QPixmap()
        self._rect = QRectF()
        self._lastMouseClickPoint = QPointF()
        self._mousePanningDelta = QPointF()
        self.current_scale = 1.0
        self._drag = False
        self._dragConnection = None
        self._wheelConnection = None
        self._instance_name = name
        self.bestFit = True
        self.controller = None
        self.setMouseTracking(False)

    def __repr__(self):
        return f'{self._instance_name}'

    def connectMouseSignals(self):
        if not self._dragConnection:
            self._dragConnection = self.mouseDragged.connect(
                self.controller.onDraggedMouse)
        if not self._wheelConnection:
            self._wheelConnection = self.mouseWheeled.connect(
                self.controller.scaleImagesBy)

    def disconnectMouseSignals(self):
        if self._dragConnection:
            self.mouseDragged.disconnect()
            self._dragConnection = None
        if self._wheelConnection:
            self.mouseWheeled.disconnect()
            self._wheelConnection = None

    def paintEvent(self, event):
        painter = QPainter(self)
        painter.translate(self.rect().center())
        painter.scale(self.current_scale, self.current_scale)
        painter.translate(self._mousePanningDelta)
        painter.drawPixmap(self._rect.topLeft(), self._pixmap)

    def resetCenter(self):
        """ Resets origin """
        # Make sure we are not still panning around
        self._mousePanningDelta = QPointF()
        self.update()

    def changeEvent(self, event):
        if event.type() == QEvent.EnabledChange:
            if self.isEnabled():
                self.connectMouseSignals()
                return
            self.disconnectMouseSignals()

    def mousePressEvent(self, event):
        if self.bestFit or not self.isEnabled():
            event.ignore()
            return
        if event.button() == Qt.LeftButton:
            self._drag = True
        else:
            self._drag = False
            event.ignore()
            return

        self._lastMouseClickPoint = event.pos()
        self._app.setOverrideCursor(Qt.ClosedHandCursor)
        self.setMouseTracking(True)
        event.accept()

    def mouseMoveEvent(self, event):
        if self.bestFit or not self.isEnabled():
            event.ignore()
            return

        self._mousePanningDelta += (
            event.pos() - self._lastMouseClickPoint) * 1.0 / self.current_scale
        self._lastMouseClickPoint = event.pos()
        if self._drag:
            self.mouseDragged.emit(self._mousePanningDelta)
            self.update()

    def mouseReleaseEvent(self, event):
        if self.bestFit or not self.isEnabled():
            event.ignore()
            return
        if event.button() == Qt.LeftButton:
            self._drag = False

        self._app.restoreOverrideCursor()
        self.setMouseTracking(False)

    def wheelEvent(self, event):
        if self.bestFit or not self.controller.same_dimensions or not self.isEnabled():
            event.ignore()
            return

        if event.angleDelta().y() > 0:
            if self.current_scale > MAX_SCALE:
                return
            self.mouseWheeled.emit(1.25)  # zoom-in
        else:
            if self.current_scale < MIN_SCALE:
                return
            self.mouseWheeled.emit(0.8)  # zoom-out

    def setImage(self, pixmap):
        if pixmap.isNull():
            if not self._pixmap.isNull():
                self._pixmap = pixmap
            self.disconnectMouseSignals()
            self.setEnabled(False)
            self.update()
            return
        elif not self.isEnabled():
            self.setEnabled(True)
            self.connectMouseSignals()
        self._pixmap = pixmap

    def centerViewAndUpdate(self):
        self._rect = self._pixmap.rect()
        self._rect.translate(-self._rect.center())
        self.update()

    def shouldBeActive(self):
        return True if not self.pixmap.isNull() else False

    def scaleBy(self, factor):
        self.current_scale *= factor
        self.update()

    def scaleAt(self, scale):
        self.current_scale = scale
        self.update()

    def sizeHint(self):
        return QSize(400, 400)

    @pyqtSlot()
    def scaleToNormalSize(self):
        """Called when the pixmap is set back to original size."""
        self.current_scale = 1.0
        self.update()

    @pyqtSlot(QPointF)
    def onDraggedMouse(self, delta):
        self._mousePanningDelta = delta
        self.update()


class ScalablePixmap(QWidget):
    """Container for a pixmap that scales up very fast, used in ScrollAreaImageViewer."""
    def __init__(self, parent):
        super().__init__(parent)
        self._pixmap = QPixmap()
        self.current_scale = 1.0

    def paintEvent(self, event):
        painter = QPainter(self)
        painter.scale(self.current_scale, self.current_scale)
        # painter.drawPixmap(self.rect().topLeft(), self._pixmap)
        # should be the same as:
        painter.drawPixmap(0, 0, self._pixmap)

    def sizeHint(self):
        return self._pixmap.size() * self.current_scale

    def minimumSizeHint(self):
        return self.sizeHint()


class ScrollAreaImageViewer(QScrollArea):
    """Implementation using a pixmap container in a simple scroll area."""
    mouseDragged = pyqtSignal(QPoint)
    mouseWheeled = pyqtSignal(float, QPointF)

    def __init__(self, parent, name=""):
        super().__init__(parent)
        self._parent = parent
        self._app = QApplication
        self._pixmap = QPixmap()
        self._scaledpixmap = None
        self._rect = QRectF()
        self._lastMouseClickPoint = QPointF()
        self._mousePanningDelta = QPoint()
        self.current_scale = 1.0
        self._drag = False
        self._dragConnection = None
        self._wheelConnection = None
        self._instance_name = name
        self.wantScrollBars = True
        self.bestFit = True
        self.controller = None
        self.label = ScalablePixmap(self)
        # This is to avoid sending signals twice on scrollbar updates
        self.ignore_signal = False
        self.setBackgroundRole(QPalette.Dark)
        self.setWidgetResizable(False)
        self.setSizeAdjustPolicy(QAbstractScrollArea.AdjustToContents)
        self.setAlignment(Qt.AlignCenter)
        self._verticalScrollBar = self.verticalScrollBar()
        self._horizontalScrollBar = self.horizontalScrollBar()
        if self.wantScrollBars:
            self.toggleScrollBars()
        else:
            self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
            self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setWidget(self.label)
        self.setVisible(True)

    def __repr__(self):
        return f'{self._instance_name}'

    def toggleScrollBars(self, forceOn=False):
        if not self.wantScrollBars:
            return
        # Ensure that it's off on the first run
        if self.horizontalScrollBarPolicy() == Qt.ScrollBarAsNeeded:
            if forceOn:
                return
            self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
            self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        else:
            self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
            self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)

    def connectMouseSignals(self):
        if not self._dragConnection:
            self._dragConnection = self.mouseDragged.connect(
                self.controller.onDraggedMouse)
        if not self._wheelConnection:
            self._wheelConnection = self.mouseWheeled.connect(
                self.controller.onMouseWheel)

    def disconnectMouseSignals(self):
        if self._dragConnection:
            self.mouseDragged.disconnect()
            self._dragConnection = None
        if self._wheelConnection:
            self.mouseWheeled.disconnect()
            self._wheelConnection = None

    def connectScrollBars(self):
        """Only call once controller is connected."""
        # Cyclic connections are handled by Qt
        self._verticalScrollBar.valueChanged.connect(
            self.controller.onVScrollBarChanged, Qt.UniqueConnection)
        self._horizontalScrollBar.valueChanged.connect(
            self.controller.onHScrollBarChanged, Qt.UniqueConnection)

    def mousePressEvent(self, event):
        if self.bestFit:
            event.ignore()
            return
        if event.button() == Qt.LeftButton:
            self._drag = True
        else:
            self._drag = False
            event.ignore()
            return
        self._lastMouseClickPoint = event.pos()
        self._app.setOverrideCursor(Qt.ClosedHandCursor)
        self.setMouseTracking(True)
        super().mousePressEvent(event)

    def mouseMoveEvent(self, event):
        if self.bestFit:
            event.ignore()
            return
        if self._drag:
            delta = (event.pos() - self._lastMouseClickPoint)
            self._lastMouseClickPoint = event.pos()
            self.mouseDragged.emit(delta)
        super().mouseMoveEvent(event)

    def mouseReleaseEvent(self, event):
        if self.bestFit:
            event.ignore()
            return
        if event.button() == Qt.LeftButton:
            self._drag = False
        self._app.restoreOverrideCursor()
        self.setMouseTracking(False)
        super().mouseReleaseEvent(event)

    def wheelEvent(self, event):
        if self.bestFit or not self.controller.same_dimensions:
            event.ignore()
            return
        oldScale = self.current_scale
        if event.angleDelta().y() > 0:  # zoom-in
            if oldScale < MAX_SCALE:
                self.current_scale *= 1.25
        else:
            if oldScale > MIN_SCALE:  # zoom-out
                self.current_scale *= 0.8
        if oldScale == self.current_scale:
            return

        deltaToPos = (event.position() / oldScale) - (self.label.pos() / oldScale)
        delta = (deltaToPos * self.current_scale) - (deltaToPos * oldScale)
        self.mouseWheeled.emit(self.current_scale, delta)

    def setImage(self, pixmap):
        self._pixmap = pixmap
        self.label._pixmap = pixmap
        self.label.update()
        self.label.adjustSize()
        if pixmap.isNull():
            self.setEnabled(False)
            self.disconnectMouseSignals()
        elif not self.isEnabled():
            self.setEnabled(True)
            self.connectMouseSignals()

    def centerViewAndUpdate(self):
        self._rect = self.label.rect()
        self.label.rect().translate(-self._rect.center())
        self.label.current_scale = self.current_scale
        self.label.update()
        # self.viewport().update()

    def setCachedPixmap(self):
        """In case we have changed the cached pixmap, reset it."""
        self.label._pixmap = self._pixmap
        self.label.update()

    def shouldBeActive(self):
        return True if not self.pixmap.isNull() else False

    def scaleBy(self, factor):
        self.current_scale *= factor
        # factor has to be either 1.25 or 0.8 here
        self.label.resize(self.label.size().__imul__(factor))
        self.label.current_scale = self.current_scale
        self.label.update()

    def scaleAt(self, scale):
        self.current_scale = scale
        self.label.resize(self._pixmap.size().__imul__(scale))
        self.label.current_scale = scale
        self.label.update()
        # self.label.adjustSize()

    def adjustScrollBarsFactor(self, factor):
        """After scaling, no mouse position, default to center."""
        # scrollBar.setMaximum(scrollBar.maximum() - scrollBar.minimum() + scrollBar.pageStep())
        self._horizontalScrollBar.setValue(
            int(factor * self._horizontalScrollBar.value()
                + ((factor - 1) * self._horizontalScrollBar.pageStep() / 2)))
        self._verticalScrollBar.setValue(
            int(factor * self._verticalScrollBar.value()
                + ((factor - 1) * self._verticalScrollBar.pageStep() / 2)))

    def adjustScrollBarsScaled(self, delta):
        """After scaling with the mouse, update relative to mouse position."""
        self._horizontalScrollBar.setValue(
            self._horizontalScrollBar.value() + delta.x())
        self._verticalScrollBar.setValue(
            self._verticalScrollBar.value() + delta.y())

    def adjustScrollBarsAuto(self):
        """After panning, update accordingly."""
        self.horizontalScrollBar().setValue(
            self.horizontalScrollBar().value() - self._mousePanningDelta.x())
        self.verticalScrollBar().setValue(
            self.verticalScrollBar().value() - self._mousePanningDelta.y())

    def adjustScrollBarCentered(self):
        """Just center in the middle."""
        self._horizontalScrollBar.setValue(
            int(self._horizontalScrollBar.maximum() / 2))
        self._verticalScrollBar.setValue(
            int(self._verticalScrollBar.maximum() / 2))

    def resetCenter(self):
        """ Resets origin """
        self._mousePanningDelta = QPoint()
        self.current_scale = 1.0
        # self.scaleAt(1.0)

    def setCenter(self, point):
        self._lastMouseClickPoint = point

    def sizeHint(self):
        return self.viewport().rect().size()

    @pyqtSlot()
    def scaleToNormalSize(self):
        """Called when the pixmap is set back to original size."""
        self.scaleAt(1.0)
        self.ensureWidgetVisible(self.label)  # needed for centering
        self.toggleScrollBars(True)

    @pyqtSlot(QPoint)
    def onDraggedMouse(self, delta):
        """Update position from mouse delta sent by the other panel."""
        self._mousePanningDelta = delta
        # Signal from scrollbars had already synced the values here
        self.adjustScrollBarsAuto()

    # def viewportSizeHint(self):
    #     return self.viewport().rect().size()

    # def changeEvent(self, event):
    #     if event.type() == QEvent.EnabledChange:
    #         print(f"{self} is now {'enabled' if self.isEnabled() else 'disabled'}")


class GraphicsViewViewer(QGraphicsView):
    """Re-Implementation a full-fledged GraphicsView but is a bit buggy."""
    mouseDragged = pyqtSignal()
    mouseWheeled = pyqtSignal(float, QPointF)

    def __init__(self, parent, name=""):
        super().__init__(parent)
        self._parent = parent
        self._app = QApplication
        self._pixmap = QPixmap()
        self._scaledpixmap = None
        self._rect = QRectF()
        self._lastMouseClickPoint = QPointF()
        self._mousePanningDelta = QPointF()
        self._scaleFactor = 1.3
        self.zoomInFactor = self._scaleFactor
        self.zoomOutFactor = 1.0 / self._scaleFactor
        self.current_scale = 1.0
        self._drag = False
        self._dragConnection = None
        self._wheelConnection = None
        self._instance_name = name
        self.wantScrollBars = True
        self.bestFit = True
        self.controller = None
        self._centerPoint = QPointF()
        self.centerOn(self._centerPoint)
        self.other_viewer = None
        # specific to this class
        self._scene = QGraphicsScene()
        self._scene.setBackgroundBrush(Qt.black)
        self._item = QGraphicsPixmapItem()
        self.setScene(self._scene)
        self._scene.addItem(self._item)
        self.setDragMode(QGraphicsView.DragMode.ScrollHandDrag)
        # self.matrix = QTransform()
        self._horizontalScrollBar = self.horizontalScrollBar()
        self._verticalScrollBar = self.verticalScrollBar()
        self.ignore_signal = False

        if self.wantScrollBars:
            self.toggleScrollBars()
        else:
            self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
            self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

        self.setResizeAnchor(QGraphicsView.AnchorViewCenter)
        self.setAlignment(Qt.AlignCenter)
        self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
        self.setMouseTracking(True)

    def connectMouseSignals(self):
        if not self._dragConnection:
            self._dragConnection = self.mouseDragged.connect(
                self.controller.syncCenters)
        if not self._wheelConnection:
            self._wheelConnection = self.mouseWheeled.connect(
                self.controller.onMouseWheel)

    def disconnectMouseSignals(self):
        if self._dragConnection:
            self.mouseDragged.disconnect()
            self._dragConnection = None
        if self._wheelConnection:
            self.mouseWheeled.disconnect()
            self._wheelConnection = None

    def connectScrollBars(self):
        """Only call once controller is connected."""
        # Cyclic connections are handled by Qt
        self._verticalScrollBar.valueChanged.connect(
            self.controller.onVScrollBarChanged, Qt.UniqueConnection)
        self._horizontalScrollBar.valueChanged.connect(
            self.controller.onHScrollBarChanged, Qt.UniqueConnection)

    def toggleScrollBars(self, forceOn=False):
        if not self.wantScrollBars:
            return
        # Ensure that it's off on the first run
        if self.horizontalScrollBarPolicy() == Qt.ScrollBarAsNeeded:
            if forceOn:
                return
            self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
            self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        else:
            self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
            self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)

    def mousePressEvent(self, event):
        if self.bestFit:
            event.ignore()
            return
        if event.button() == Qt.LeftButton:
            self._drag = True
        else:
            self._drag = False
            event.ignore()
            return
        self._lastMouseClickPoint = event.pos()
        self._app.setOverrideCursor(Qt.ClosedHandCursor)
        self.setMouseTracking(True)
        # We need to propagate to scrollbars, so we send back up
        super().mousePressEvent(event)

    def mouseReleaseEvent(self, event):
        if self.bestFit:
            event.ignore()
            return
        if event.button() == Qt.LeftButton:
            self._drag = False
        self._app.restoreOverrideCursor()
        self.setMouseTracking(False)
        self.updateCenterPoint()
        super().mouseReleaseEvent(event)

    def mouseMoveEvent(self, event):
        if self.bestFit:
            event.ignore()
            return
        if self._drag:
            self._lastMouseClickPoint = event.pos()
            # We can simply rely on the scrollbar updating each other here
            # self.mouseDragged.emit()
            self.updateCenterPoint()
            super().mouseMoveEvent(event)

    def updateCenterPoint(self):
        self._centerPoint = self.mapToScene(self.rect().center())

    def wheelEvent(self, event):
        if self.bestFit or MIN_SCALE > self.current_scale > MAX_SCALE or not self.controller.same_dimensions:
            event.ignore()
            return
        pointBeforeScale = QPointF(self.mapToScene(self.mapFromGlobal(QCursor.pos())))
        # Get the original screen centerpoint
        screenCenter = QPointF(self.mapToScene(self.rect().center()))
        if event.angleDelta().y() > 0:
            factor = self.zoomInFactor
        else:
            factor = self.zoomOutFactor
        # Avoid scrollbars conflict:
        self.other_viewer.ignore_signal = True
        self.scaleBy(factor)
        pointAfterScale = QPointF(self.mapToScene(self.mapFromGlobal(QCursor.pos())))
        # Get the offset of how the screen moved
        offset = pointBeforeScale - pointAfterScale
        # Adjust to the new center for correct zooming
        newCenter = screenCenter + offset
        self.setCenter(newCenter)
        self.mouseWheeled.emit(factor, newCenter)
        self.other_viewer.ignore_signal = False

    def setImage(self, pixmap):
        if pixmap.isNull():
            self.ignore_signal = True
        elif self.ignore_signal:
            self.ignore_signal = False
        self._pixmap = pixmap
        self._item.setPixmap(pixmap)
        self.translate(1, 1)

    def centerViewAndUpdate(self):
        # Called from the base controller for Normal Size
        pass

    def setCenter(self, point):
        self._centerPoint = point
        self.centerOn(self._centerPoint)

    def resetCenter(self):
        """ Resets origin """
        self._mousePanningDelta = QPointF()
        self.current_scale = 1.0

    def setNewCenter(self, position):
        self._centerPoint = position
        self.centerOn(self._centerPoint)

    def setCachedPixmap(self):
        """In case we have changed the cached pixmap, reset it."""
        self._item.setPixmap(self._pixmap)
        self._item.update()

    def scaleAt(self, scale):
        # self.current_scale = scale
        if scale == 1.0:
            self.resetScale()
        # self.setTransform( QTransform() )
        self.scale(scale, scale)

    def getScale(self):
        return self.transform().m22()

    def scaleBy(self, factor):
        self.current_scale *= factor
        super().scale(factor, factor)

    def resetScale(self):
        # self.setTransform( QTransform() )
        self.resetTransform()  # probably same as above
        self.setCenter(self.scene().sceneRect().center())

    def fitScale(self):
        self.bestFit = True
        super().fitInView(self._scene.sceneRect(), Qt.KeepAspectRatio)
        self.setNewCenter(self._scene.sceneRect().center())

    @pyqtSlot()
    def scaleToNormalSize(self):
        """Called when the pixmap is set back to original size."""
        self.bestFit = False
        self.scaleAt(1.0)
        self.toggleScrollBars(True)
        self.update()

    def adjustScrollBarsScaled(self, delta):
        """After scaling with the mouse, update relative to mouse position."""
        self._horizontalScrollBar.setValue(
            self._horizontalScrollBar.value() + delta.x())
        self._verticalScrollBar.setValue(
            self._verticalScrollBar.value() + delta.y())

    def sizeHint(self):
        return self.viewport().rect().size()

    def adjustScrollBarsFactor(self, factor):
        """After scaling, no mouse position, default to center."""
        self._horizontalScrollBar.setValue(
            int(factor * self._horizontalScrollBar.value()
                + ((factor - 1) * self._horizontalScrollBar.pageStep() / 2)))
        self._verticalScrollBar.setValue(
            int(factor * self._verticalScrollBar.value()
                + ((factor - 1) * self._verticalScrollBar.pageStep() / 2)))

    def adjustScrollBarsAuto(self):
        """After panning, update accordingly."""
        self.horizontalScrollBar().setValue(
            self.horizontalScrollBar().value() - self._mousePanningDelta.x())
        self.verticalScrollBar().setValue(
            self.verticalScrollBar().value() - self._mousePanningDelta.y())