shinestacker 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '1.4.0'
+__version__ = '1.5.0'

shinestacker/app/main.py

@@ -102,7 +102,7 @@ class MainApp(QMainWindow):
                 file_menu = action.menu()
                 break
         if file_menu is not None:
-            import_action = QAction("Import From Current Project", self)
+            import_action = QAction("Import from Current Project", self)
             import_action.triggered.connect(self.import_from_project)
             file_menu.addAction(import_action)
         else:

shinestacker/config/gui_constants.py

@@ -66,6 +66,11 @@ class _GuiConstants:
     ZOOM_IN_FACTOR = 1.10
     ZOOM_OUT_FACTOR = 1 / ZOOM_IN_FACTOR
 
+    ROTATE_LABEL = "Rotate"
+    ROTATE_90_CW_LABEL = f"{ROTATE_LABEL} 90° Clockwise"
+    ROTATE_90_CCW_LABEL = f"{ROTATE_LABEL} 90° Anticlockwise"
+    ROTATE_180_LABEL = f"{ROTATE_LABEL} 180°"
+
     def calculate_gamma(self):
         if self.BRUSH_SIZES['mid'] <= self.BRUSH_SIZES['min'] or self.BRUSH_SIZES['max'] <= 0:
             return 1.0

shinestacker/retouch/base_filter.py

@@ -34,7 +34,6 @@ class BaseFilter(ABC):
     def run_with_preview(self, **kwargs):
         if self.editor.has_no_master_layer():
             return
-
         self.editor.copy_master_layer()
         dlg = QDialog(self.editor)
         layout = QVBoxLayout(dlg)
@@ -143,15 +142,14 @@ class BaseFilter(ABC):
                 h, w = self.editor.master_layer().shape[:2]
             except Exception:
                 h, w = self.editor.master_layer_copy().shape[:2]
-            if hasattr(self.editor, "undo_manager"):
-                try:
-                    self.editor.undo_manager.extend_undo_area(0, 0, w, h)
-                    self.editor.undo_manager.save_undo_state(
-                        self.editor.master_layer_copy(),
-                        self.name
-                    )
-                except Exception:
-                    pass
+            try:
+                self.editor.undo_manager.extend_undo_area(0, 0, w, h)
+                self.editor.undo_manager.save_undo_state(
+                    self.editor.master_layer_copy(),
+                    self.name
+                )
+            except Exception:
+                pass
             final_img = self.apply(self.editor.master_layer_copy(), *params)
             self.editor.set_master_layer(final_img)
             self.editor.copy_master_layer()

shinestacker/retouch/brush_preview.py

@@ -113,7 +113,6 @@ class BrushPreviewItem(QGraphicsPixmapItem, LayerCollectionHandler):
             self.setPixmap(final_pixmap)
             x_start, y_start = max(0, x), max(0, y)
             self.setPos(x_start, y_start)
-            self.show()
         except Exception:
             traceback.print_exc()
             self.hide()

shinestacker/retouch/display_manager.py

@@ -25,7 +25,6 @@ class ClickableLabel(QLabel):
 
 class DisplayManager(QObject, LayerCollectionHandler):
     status_message_requested = Signal(str)
-    cursor_preview_state_changed = Signal(bool)
 
     def __init__(self, layer_collection, image_viewer, master_thumbnail_label,
                  thumbnail_list, parent=None):
@@ -35,7 +34,6 @@ class DisplayManager(QObject, LayerCollectionHandler):
         self.master_thumbnail_label = master_thumbnail_label
         self.thumbnail_list = thumbnail_list
         self.view_mode = 'master'
-        self.temp_view_individual = False
         self.needs_update = False
         self.update_timer = QTimer()
         self.update_timer.setInterval(gui_constants.PAINT_REFRESH_TIMER)
@@ -47,21 +45,10 @@ class DisplayManager(QObject, LayerCollectionHandler):
             self.refresh_master_view()
             self.needs_update = False
 
-    def refresh_master_view(self):
-        if self.has_no_master_layer():
-            return
-        self.image_viewer.update_master_display()
-        self.update_master_thumbnail()
-        self.image_viewer.refresh_display()
-
-    def refresh_current_view(self):
-        if self.number_of_layers() == 0:
-            return
-        self.image_viewer.update_current_display()
-        self.image_viewer.refresh_display()
-
     def create_thumbnail(self, layer):
         source_layer = (layer // 256).astype(np.uint8) if layer.dtype == np.uint16 else layer
+        if not source_layer.flags.c_contiguous:
+            source_layer = np.ascontiguousarray(source_layer)
         height, width = source_layer.shape[:2]
         if layer.ndim == 3 and source_layer.shape[-1] == 3:
             qimg = QImage(source_layer.data, width, height, 3 * width, QImage.Format_RGB888)
@@ -157,48 +144,61 @@ class DisplayManager(QObject, LayerCollectionHandler):
         self.thumbnail_list.scrollToItem(
             self.thumbnail_list.item(index), QAbstractItemView.PositionAtCenter)
 
+    def _master_refresh_and_thumb(self):
+        self.image_viewer.show_master()
+        self.refresh_master_view()
+        self.thumbnail_highlight = gui_constants.THUMB_LO_COLOR
+        self.highlight_thumbnail(self.current_layer_idx())
+
+    def _current_refresh_and_thumb(self):
+        self.image_viewer.show_current()
+        self.refresh_current_view()
+        self.thumbnail_highlight = gui_constants.THUMB_HI_COLOR
+        self.highlight_thumbnail(self.current_layer_idx())
+
     def set_view_master(self):
         if self.has_no_master_layer():
             return
         self.view_mode = 'master'
-        self.temp_view_individual = False
-        self.refresh_master_view()
-        self.thumbnail_highlight = gui_constants.THUMB_LO_COLOR
-        self.highlight_thumbnail(self.current_layer_idx())
+        self._master_refresh_and_thumb()
         self.status_message_requested.emit("View mode: Master")
-        self.cursor_preview_state_changed.emit(True)
 
     def set_view_individual(self):
         if self.has_no_master_layer():
             return
         self.view_mode = 'individual'
-        self.temp_view_individual = False
-        self.refresh_current_view()
-        self.thumbnail_highlight = gui_constants.THUMB_HI_COLOR
-        self.highlight_thumbnail(self.current_layer_idx())
+        self._current_refresh_and_thumb()
         self.status_message_requested.emit("View mode: Individual layers")
-        self.cursor_preview_state_changed.emit(False)
+
+    def refresh_master_view(self):
+        if self.has_no_master_layer():
+            return
+        self.image_viewer.update_master_display()
+        self.image_viewer.refresh_display()
+        self.update_master_thumbnail()
+
+    def refresh_current_view(self):
+        if self.number_of_layers() == 0:
+            return
+        self.image_viewer.update_current_display()
+        self.image_viewer.refresh_display()
 
     def start_temp_view(self):
-        if not self.temp_view_individual and self.view_mode == 'master':
-            self.temp_view_individual = True
-            self.image_viewer.update_brush_cursor()
-            self.thumbnail_highlight = gui_constants.THUMB_HI_COLOR
-            self.highlight_thumbnail(self.current_layer_idx())
-            self.image_viewer.show_current()
-            self.refresh_current_view()
-            self.status_message_requested.emit("Temporary view: Individual layer (hold X)")
+        if self.view_mode == 'master':
+            self._current_refresh_and_thumb()
+            self.status_message_requested.emit("Temporary view: Individual layer")
+        else:
+            self._master_refresh_and_thumb()
+            self.image_viewer.strategy.brush_preview.hide()
+            self.status_message_requested.emit("Temporary view: Master")
 
     def end_temp_view(self):
-        if self.temp_view_individual:
-            self.temp_view_individual = False
-            self.image_viewer.update_brush_cursor()
-            self.thumbnail_highlight = gui_constants.THUMB_LO_COLOR
-            self.highlight_thumbnail(self.current_layer_idx())
-            self.image_viewer.show_master()
-            self.refresh_master_view()
+        if self.view_mode == 'master':
+            self._master_refresh_and_thumb()
             self.status_message_requested.emit("View mode: Master")
-            self.cursor_preview_state_changed.emit(True)
+        else:
+            self._current_refresh_and_thumb()
+            self.status_message_requested.emit("View: Individual layer")
 
     def allow_cursor_preview(self):
-        return self.view_mode == 'master' and not self.temp_view_individual
+        return self.view_mode == 'master'

shinestacker/retouch/image_editor_ui.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0902, R0914, R0915, R0904
+# pylint: disable=C0114, C0115, C0116, E0611, R0902, R0914, R0915, R0904, W0108
 from functools import partial
 import numpy as np
 from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QFrame, QLabel, QMenu,
@@ -8,6 +8,7 @@ from PySide6.QtCore import Qt
 from PySide6.QtGui import QGuiApplication
 from .. config.constants import constants
 from .. config.gui_constants import gui_constants
+from .. gui.recent_file_manager import RecentFileManager
 from .image_viewer import ImageViewer
 from .shortcuts_help import ShortcutsHelp
 from .brush import Brush
@@ -22,7 +23,7 @@ from .denoise_filter import DenoiseFilter
 from .unsharp_mask_filter import UnsharpMaskFilter
 from .white_balance_filter import WhiteBalanceFilter
 from .vignetting_filter import VignettingFilter
-from .. gui.recent_file_manager import RecentFileManager
+from .transformation_manager import TransfromationManager
 
 
 class ImageEditorUI(QMainWindow, LayerCollectionHandler):
@@ -31,16 +32,17 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         LayerCollectionHandler.__init__(self, LayerCollection())
         self._recent_file_manager = RecentFileManager("shinestacker-recent-images-files.txt")
         self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
-        self.undo_manager = UndoManager()
-        self.undo_action = None
-        self.redo_action = None
-        self.undo_manager.stack_changed.connect(self.update_undo_redo_actions)
         self.io_gui_handler = None
         self.display_manager = None
         self.brush = Brush()
         self.brush_tool = BrushTool()
         self.modified = False
         self.mask_layer = None
+        self.transformation_manager = TransfromationManager(self)
+        self.undo_manager = UndoManager(self.transformation_manager)
+        self.undo_action = None
+        self.redo_action = None
+        self.undo_manager.stack_changed.connect(self.update_undo_redo_actions)
         self.filter_manager = FilterManager(self)
         self.filter_manager.register_filter("Denoise", DenoiseFilter)
         self.filter_manager.register_filter("Unsharp Mask", UnsharpMaskFilter)
@@ -238,8 +240,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             self.master_thumbnail_label, self.thumbnail_list, parent=self)
         self.io_gui_handler = IOGuiHandler(self.layer_collection, self.undo_manager, parent=self)
         self.display_manager.status_message_requested.connect(self.show_status_message)
-        self.display_manager.cursor_preview_state_changed.connect(
-            self.image_viewer.set_allow_cursor_preview)
         self.io_gui_handler.status_message_requested.connect(self.show_status_message)
         self.io_gui_handler.update_title_requested.connect(self.update_title)
         self.io_gui_handler.mark_as_modified_requested.connect(self.mark_as_modified)
@@ -277,8 +277,8 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
         file_menu.addAction("&Close", self.close_file, "Ctrl+W")
         file_menu.addSeparator()
-        file_menu.addAction("&Import frames", self.io_gui_handler.import_frames)
-        file_menu.addAction("Import &EXIF data", self.io_gui_handler.select_exif_path)
+        file_menu.addAction("&Import Frames", self.io_gui_handler.import_frames)
+        file_menu.addAction("Import &EXIF Data", self.io_gui_handler.select_exif_path)
 
         edit_menu = menubar.addMenu("&Edit")
         self.undo_action = QAction("Undo", self)
@@ -293,7 +293,21 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         edit_menu.addAction(self.redo_action)
         edit_menu.addSeparator()
 
-        copy_action = QAction("Copy Layer to Master", self)
+        transf_menu = QMenu("&Transform")
+        rotate_90_cw_action = QAction(gui_constants.ROTATE_90_CW_LABEL, self)
+        transf_menu.addAction(rotate_90_cw_action)
+        rotate_90_cw_action.triggered.connect(lambda: self.transformation_manager.rotate_90_cw())
+        rotate_90_ccw_action = QAction(gui_constants.ROTATE_90_CCW_LABEL, self)
+        transf_menu.addAction(rotate_90_ccw_action)
+        rotate_90_ccw_action.triggered.connect(lambda: self.transformation_manager.rotate_90_ccw())
+        rotate_180_action = QAction(gui_constants.ROTATE_180_LABEL, self)
+        rotate_180_action.triggered.connect(lambda: self.transformation_manager.rotate_180())
+        transf_menu.addAction(rotate_180_action)
+        edit_menu.addMenu(transf_menu)
+
+        edit_menu.addSeparator()
+
+        copy_action = QAction("Copy Current Layer to Master", self)
         copy_action.setShortcut("Ctrl+M")
         copy_action.triggered.connect(self.copy_layer_to_master)
         edit_menu.addAction(copy_action)
@@ -310,22 +324,22 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
         view_strategy_menu = QMenu("View &Mode", view_menu)
 
-        self.view_action_modes = {
+        self.view_mode_actions = {
             'overlaid': QAction("Overlaid", self),
-            'sidebyside': QAction("Side By Side", self),
+            'sidebyside': QAction("Side by Side", self),
             'topbottom': QAction("Top-Bottom", self)
         }
-        overlaid_mode = self.view_action_modes['overlaid']
+        overlaid_mode = self.view_mode_actions['overlaid']
         overlaid_mode.setShortcut("Ctrl+1")
         overlaid_mode.setCheckable(True)
         overlaid_mode.triggered.connect(lambda: set_strategy('overlaid'))
         view_strategy_menu.addAction(overlaid_mode)
-        side_by_side_mode = self.view_action_modes['sidebyside']
+        side_by_side_mode = self.view_mode_actions['sidebyside']
         side_by_side_mode.setShortcut("Ctrl+2")
         side_by_side_mode.setCheckable(True)
         side_by_side_mode.triggered.connect(lambda: set_strategy('sidebyside'))
         view_strategy_menu.addAction(side_by_side_mode)
-        side_by_side_mode = self.view_action_modes['topbottom']
+        side_by_side_mode = self.view_mode_actions['topbottom']
         side_by_side_mode.setShortcut("Ctrl+3")
         side_by_side_mode.setCheckable(True)
         side_by_side_mode.triggered.connect(lambda: set_strategy('topbottom'))
@@ -338,31 +352,40 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             self.view_master_action.setEnabled(enable_shortcuts)
             self.view_individual_action.setEnabled(enable_shortcuts)
             self.toggle_view_master_individual_action.setEnabled(enable_shortcuts)
-            for label, mode in self.view_action_modes.items():
+            for label, mode in self.view_mode_actions.items():
                 mode.setEnabled(label != strategy)
                 mode.setChecked(label == strategy)
 
         cursor_menu = view_menu.addMenu("Cursor Style")
 
-        cursor_stype = self.image_viewer.get_cursor_style()
-        brush_action = QAction("Simple Brush", self)
+        self.cursor_style_actions = {
+            'brush': QAction("Simple Brush", self),
+            'preview': QAction("Brush Preview", self),
+            'outline': QAction("Outline Only", self)
+        }
+        brush_action = self.cursor_style_actions['brush']
         brush_action.setCheckable(True)
-        brush_action.setChecked(cursor_stype == 'brush')
-        brush_action.triggered.connect(lambda: self.image_viewer.set_cursor_style('brush'))
+        brush_action.triggered.connect(lambda: set_cursor_style('brush'))
         cursor_menu.addAction(brush_action)
 
-        preview_action = QAction("Brush Preview", self)
+        preview_action = self.cursor_style_actions['preview']
         preview_action.setCheckable(True)
-        preview_action.setChecked(cursor_stype == 'preview')
-        preview_action.triggered.connect(lambda: self.image_viewer.set_cursor_style('preview'))
+        preview_action.triggered.connect(lambda: set_cursor_style('preview'))
         cursor_menu.addAction(preview_action)
 
-        outline_action = QAction("Outline Only", self)
+        outline_action = self.cursor_style_actions['outline']
         outline_action.setCheckable(True)
-        outline_action.setChecked(cursor_stype == 'outline')
-        outline_action.triggered.connect(lambda: self.image_viewer.set_cursor_style('outline'))
+        outline_action.triggered.connect(lambda: set_cursor_style('outline'))
         cursor_menu.addAction(outline_action)
 
+        def set_cursor_style(cursor_style):
+            self.image_viewer.set_cursor_style(cursor_style)
+            for label, style in self.cursor_style_actions.items():
+                style.setEnabled(label != cursor_style)
+                style.setChecked(label == cursor_style)
+
+        set_cursor_style(self.image_viewer.get_cursor_style())
+
         cursor_group = QActionGroup(self)
         cursor_group.addAction(preview_action)
         cursor_group.addAction(outline_action)
@@ -432,13 +455,13 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         white_balance_action = QAction("White Balance", self)
         white_balance_action.triggered.connect(self.white_balance)
         filter_menu.addAction(white_balance_action)
-        vignetting_action = QAction("Vignetting correction", self)
+        vignetting_action = QAction("Vignetting Correction", self)
         vignetting_action.triggered.connect(self.vignetting_correction)
         filter_menu.addAction(vignetting_action)
 
         help_menu = menubar.addMenu("&Help")
         help_menu.setObjectName("Help")
-        shortcuts_help_action = QAction("Shortcuts and mouse", self)
+        shortcuts_help_action = QAction("Shortcuts and Mouse", self)
 
         def shortcuts_help():
             self.shortcuts_help_dialog = ShortcutsHelp(self)
@@ -693,13 +716,11 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
     def set_view_master(self):
         self.display_manager.set_view_master()
-        self.display_manager.refresh_master_view()
         self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
         self.highlight_master_thumbnail()
 
     def set_view_individual(self):
         self.display_manager.set_view_individual()
-        self.display_manager.refresh_current_view()
         self.thumbnail_highlight = gui_constants.THUMB_MASTER_LO_COLOR
         self.highlight_master_thumbnail()
 

shinestacker/retouch/image_view_status.py

@@ -59,3 +59,7 @@ class ImageViewStatus(QObject):
 
     def set_max_scale(self, min_scale):
         self.max_scale = min_scale
+
+    def set_scroll(self, h_scroll, v_scroll):
+        self.h_scroll = h_scroll
+        self.v_scroll = v_scroll

shinestacker/retouch/image_viewer.py

@@ -35,8 +35,14 @@ class ImageViewer(QWidget):
         self.strategy.show()
         self.strategy.resize(self.size())
         if not self.strategy.empty():
+            self.strategy.cleanup_brush_preview()
             self.strategy.update_master_display()
             self.strategy.update_current_display()
+            self.strategy.setup_brush_cursor()
+            self.strategy.update_brush_cursor()
+            self.strategy.show_master()
+            self.strategy.setFocus()
+            self.strategy.activateWindow()
 
     def empty(self):
         return self.strategy.empty()

shinestacker/retouch/layer_collection.py

@@ -143,6 +143,9 @@ class LayerCollectionHandler:
     def has_master_layer(self):
         return self.layer_collection.has_master_layer()
 
+    def set_layer(self, idx, img):
+        self.layer_collection.layer_stack[idx] = img
+
     def set_layer_stack(self, stk):
         self.layer_collection.set_layer_stack(stk)
 

shinestacker/retouch/overlaid_view.py

@@ -1,5 +1,4 @@
 # pylint: disable=C0114, C0115, C0116, E0611, E1101, R0904, R0912, R0914, R0902
-from PySide6.QtGui import QPixmap
 from PySide6.QtCore import Qt, QPointF, QEvent, QRectF
 from .. config.gui_constants import gui_constants
 from .view_strategy import ViewStrategy, ImageGraphicsViewBase, ViewSignals
@@ -23,12 +22,21 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
     def get_master_view(self):
         return self
 
+    def get_current_view(self):
+        return self
+
     def get_master_scene(self):
         return self.scene
 
+    def get_current_scene(self):
+        return self.scene
+
     def get_master_pixmap(self):
         return self.pixmap_item_master
 
+    def get_current_pixmap(self):
+        return self.pixmap_item_current
+
     def get_views(self):
         return [self]
 
@@ -41,66 +49,6 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
             self.pixmap_item_current: self
         }
 
-    def set_master_image(self, qimage):
-        self.status.set_master_image(qimage)
-        pixmap = self.status.pixmap_master
-        self.setSceneRect(QRectF(pixmap.rect()))
-
-        img_width, img_height = pixmap.width(), pixmap.height()
-        self.set_min_scale(min(gui_constants.MIN_ZOOMED_IMG_WIDTH / img_width,
-                               gui_constants.MIN_ZOOMED_IMG_HEIGHT / img_height))
-        self.set_max_scale(gui_constants.MAX_ZOOMED_IMG_PX_SIZE)
-        self.set_zoom_factor(1.0)
-        self.fitInView(self.pixmap_item_master, Qt.KeepAspectRatio)
-        self.set_zoom_factor(self.get_current_scale())
-        self.set_zoom_factor(max(self.min_scale(), min(self.max_scale(), self.zoom_factor())))
-        self.scale(self.zoom_factor(), self.zoom_factor())
-
-    def set_current_image(self, qimage):
-        self.status.set_current_image(qimage)
-        if self.empty():
-            self.setSceneRect(QRectF(self.status.pixmap_current.rect()))
-
-    def show_master(self):
-        self.pixmap_item_master.setVisible(True)
-        self.pixmap_item_current.setVisible(False)
-
-    def show_current(self):
-        self.pixmap_item_master.setVisible(False)
-        self.pixmap_item_current.setVisible(True)
-
-    def update_master_display(self):
-        if not self.empty():
-            master_qimage = self.numpy_to_qimage(
-                self.master_layer())
-            if master_qimage:
-                self.pixmap_item_master.setPixmap(QPixmap.fromImage(master_qimage))
-
-    def update_current_display(self):
-        if not self.empty() and self.number_of_layers() > 0:
-            current_qimage = self.numpy_to_qimage(
-                self.current_layer())
-            if current_qimage:
-                self.pixmap_item_current.setPixmap(QPixmap.fromImage(current_qimage))
-
-    def set_view_state(self, state):
-        self.status.set_state(state)
-        if state:
-            self.resetTransform()
-            self.scale(state['zoom'], state['zoom'])
-            self.horizontalScrollBar().setValue(state['h_scroll'])
-            self.verticalScrollBar().setValue(state['v_scroll'])
-            self.set_zoom_factor(state['zoom'])
-
-    def handle_key_press_event(self, event):
-        if event.key() == Qt.Key_X:
-            self.temp_view_requested.emit(True)
-            self.update_brush_cursor()
-
-    def handle_key_release_event(self, event):
-        if event.key() == Qt.Key_X:
-            self.temp_view_requested.emit(False)
-
     # pylint: disable=C0103
     def mousePressEvent(self, event):
         self.mouse_press_event(event)
@@ -113,6 +61,7 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
         self.mouse_release_event(event)
         super().mouseReleaseEvent(event)
 
+    # pylint: enable=R0801
     def wheelEvent(self, event):
         if self.empty() or self.gesture_active:
             return
@@ -120,8 +69,8 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
             if self.control_pressed:
                 self.brush_size_change_requested.emit(1 if event.angleDelta().y() > 0 else -1)
             else:
-                zoom_in_factor = 1.10
-                zoom_out_factor = 1 / zoom_in_factor
+                zoom_in_factor = gui_constants.ZOOM_IN_FACTOR
+                zoom_out_factor = gui_constants.ZOOM_OUT_FACTOR
                 current_scale = self.get_current_scale()
                 if event.angleDelta().y() > 0:  # Zoom in
                     new_scale = current_scale * zoom_in_factor
@@ -146,11 +95,14 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
                 else:
                     self.zoom_out()
         event.accept()
+        # pylint: disable=R0801
 
     def enterEvent(self, event):
         self.activateWindow()
         self.setFocus()
-        if not self.empty():
+        if self.empty():
+            self.setCursor(Qt.ArrowCursor)
+        else:
             self.setCursor(Qt.BlankCursor)
             if self.brush_cursor:
                 self.brush_cursor.show()
@@ -162,6 +114,77 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
             return self.handle_gesture_event(event)
         return super().event(event)
 
+    def set_master_image(self, qimage):
+        self.status.set_master_image(qimage)
+        pixmap = self.status.pixmap_master
+        self.setSceneRect(QRectF(pixmap.rect()))
+        img_width, img_height = pixmap.width(), pixmap.height()
+        self.set_max_min_scales(img_width, img_height)
+        self.set_zoom_factor(1.0)
+        self.resetTransform()
+        self.fitInView(self.pixmap_item_master, Qt.KeepAspectRatio)
+        self.set_zoom_factor(self.get_current_scale())
+        self.set_zoom_factor(max(self.min_scale(), min(self.max_scale(), self.zoom_factor())))
+        self.scale(self.zoom_factor(), self.zoom_factor())
+        self.centerOn(self.pixmap_item_master)
+        self.center_image(self)
+        self.update_cursor_pen_width()
+
+    def set_current_image(self, qimage):
+        self.status.set_current_image(qimage)
+        if self.empty():
+            self.setSceneRect(QRectF(self.status.pixmap_current.rect()))
+        self.update_cursor_pen_width()
+
+    def setup_brush_cursor(self):
+        super().setup_brush_cursor()
+        self.update_cursor_pen_width()
+
+    def show_master(self):
+        self.pixmap_item_master.setVisible(True)
+        self.pixmap_item_current.setVisible(False)
+        self.brush_preview.show()
+
+    def show_current(self):
+        self.pixmap_item_master.setVisible(False)
+        self.pixmap_item_current.setVisible(True)
+        self.brush_preview.hide()
+
+    def arrange_images(self):
+        if self.empty():
+            return
+        if self.pixmap_item_master.isVisible():
+            pixmap = self.pixmap_item_master.pixmap()
+            if not pixmap.isNull():
+                self.setSceneRect(QRectF(pixmap.rect()))
+                self.centerOn(self.pixmap_item_master)
+                self.center_image(self)
+        elif self.pixmap_item_current.isVisible():
+            pixmap = self.pixmap_item_current.pixmap()
+            if not pixmap.isNull():
+                self.setSceneRect(QRectF(pixmap.rect()))
+                self.centerOn(self.pixmap_item_current)
+                self.center_image(self)
+        current_scale = self.get_current_scale()
+        scale_factor = self.zoom_factor() / current_scale
+        self.scale(scale_factor, scale_factor)
+
+    def handle_key_press_event(self, event):
+        if event.key() in [Qt.Key_Up, Qt.Key_Down]:
+            return False
+        if event.key() == Qt.Key_X:
+            self.temp_view_requested.emit(True)
+            return False
+        return True
+
+    def handle_key_release_event(self, event):
+        if event.key() in [Qt.Key_Up, Qt.Key_Down]:
+            return False
+        if event.key() == Qt.Key_X:
+            self.temp_view_requested.emit(False)
+            return False
+        return True
+
     def handle_gesture_event(self, event):
         if self.empty():
             return False
@@ -190,23 +213,3 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
             self.scroll_view(self, int(scaled_delta.x()), int(scaled_delta.y()))
         elif pan_gesture.state() == Qt.GestureFinished:
             self.gesture_active = False
-
-    def handle_pinch_gesture(self, pinch):
-        if pinch.state() == Qt.GestureStarted:
-            self.pinch_start_scale = self.get_current_scale()
-            self.pinch_center_view = pinch.centerPoint()
-            self.pinch_center_scene = self.mapToScene(self.pinch_center_view.toPoint())
-            self.gesture_active = True
-        elif pinch.state() == Qt.GestureUpdated:
-            new_scale = self.pinch_start_scale * pinch.totalScaleFactor()
-            new_scale = max(self.min_scale(), min(new_scale, self.max_scale()))
-            if abs(new_scale - self.get_current_scale()) > 0.01:
-                self.resetTransform()
-                self.scale(new_scale, new_scale)
-                self.set_zoom_factor(new_scale)
-                new_center = self.mapToScene(self.pinch_center_view.toPoint())
-                delta = self.pinch_center_scene - new_center
-                self.translate(delta.x(), delta.y())
-                self.update_brush_cursor()
-        elif pinch.state() in (Qt.GestureFinished, Qt.GestureCanceled):
-            self.gesture_active = False