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

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,23 +32,23 @@ 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)
         self.filter_manager.register_filter("White Balance", WhiteBalanceFilter)
         self.filter_manager.register_filter("Vignetting Correction", VignettingFilter)
         self.shortcuts_help_dialog = None
-
         self.update_title()
         self.resize(1400, 900)
         center = QGuiApplication.primaryScreen().geometry().center()
@@ -66,18 +67,15 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         side_layout = QVBoxLayout(side_panel)
         side_layout.setContentsMargins(0, 0, 0, 0)
         side_layout.setSpacing(2)
-
         brush_panel = QFrame()
         brush_panel.setFrameShape(QFrame.StyledPanel)
         brush_panel.setContentsMargins(0, 0, 0, 0)
         brush_layout = QVBoxLayout(brush_panel)
         brush_layout.setContentsMargins(0, 0, 0, 0)
         brush_layout.setSpacing(2)
-
         brush_label = QLabel("Brush Size")
         brush_label.setAlignment(Qt.AlignCenter)
         brush_layout.addWidget(brush_label)
-
         self.brush_size_slider = QSlider(Qt.Horizontal)
         self.brush_size_slider.setRange(0, gui_constants.BRUSH_SIZE_SLIDER_MAX)
 
@@ -92,7 +90,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
         self.brush_size_slider.setValue(brush_size_to_slider(self.brush.size))
         brush_layout.addWidget(self.brush_size_slider)
-
         hardness_label = QLabel("Brush Hardness")
         hardness_label.setAlignment(Qt.AlignCenter)
         brush_layout.addWidget(hardness_label)
@@ -100,7 +97,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.hardness_slider.setRange(0, 100)
         self.hardness_slider.setValue(self.brush.hardness)
         brush_layout.addWidget(self.hardness_slider)
-
         opacity_label = QLabel("Brush Opacity")
         opacity_label.setAlignment(Qt.AlignCenter)
         brush_layout.addWidget(opacity_label)
@@ -108,7 +104,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.opacity_slider.setRange(0, 100)
         self.opacity_slider.setValue(self.brush.opacity)
         brush_layout.addWidget(self.opacity_slider)
-
         flow_label = QLabel("Brush Flow")
         flow_label.setAlignment(Qt.AlignCenter)
         brush_layout.addWidget(flow_label)
@@ -116,7 +111,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.flow_slider.setRange(1, 100)
         self.flow_slider.setValue(self.brush.flow)
         brush_layout.addWidget(self.flow_slider)
-
         side_layout.addWidget(brush_panel)
         self.brush_preview_widget = QLabel()
         self.brush_preview_widget.setContentsMargins(0, 0, 0, 0)
@@ -133,7 +127,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.brush_preview_widget.setFixedHeight(100)
         brush_layout.addWidget(self.brush_preview_widget)
         side_layout.addWidget(brush_panel)
-
         master_label = QLabel("Master")
         master_label.setStyleSheet("""
             QLabel {
@@ -238,8 +231,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 +268,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 +284,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,59 +315,58 @@ 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'))
+        overlaid_mode.triggered.connect(lambda: self.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'))
+        side_by_side_mode.triggered.connect(lambda: self.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'))
+        side_by_side_mode.triggered.connect(lambda: self.set_strategy('topbottom'))
         view_strategy_menu.addAction(side_by_side_mode)
         view_menu.addMenu(view_strategy_menu)
 
-        def set_strategy(strategy):
-            self.image_viewer.set_strategy(strategy)
-            enable_shortcuts = strategy == 'overlaid'
-            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():
-                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)
@@ -409,7 +413,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         view_menu.addAction(self.toggle_view_master_individual_action)
         view_menu.addSeparator()
 
-        set_strategy('overlaid')
+        self.set_strategy('overlaid')
 
         sort_asc_action = QAction("Sort Layers A-Z", self)
         sort_asc_action.triggered.connect(lambda: self.sort_layers('asc'))
@@ -432,13 +436,15 @@ 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)
+
+        self.statusBar().showMessage("Shine Stacker ready.", 2000)
 
         def shortcuts_help():
             self.shortcuts_help_dialog = ShortcutsHelp(self)
@@ -453,6 +459,16 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         next_layer.activated.connect(self.next_layer)
         self.installEventFilter(self)
 
+    def set_strategy(self, strategy):
+        self.image_viewer.set_strategy(strategy)
+        enable_shortcuts = strategy == 'overlaid'
+        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_mode_actions.items():
+            mode.setEnabled(label != strategy)
+            mode.setChecked(label == strategy)
+
     def update_title(self):
         title = constants.APP_TITLE
         if self.io_gui_handler is not None:
@@ -693,13 +709,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()
@@ -81,9 +87,6 @@ class ImageViewer(QWidget):
     def set_allow_cursor_preview(self, state):
         self.strategy.set_allow_cursor_preview(state)
 
-    def setup_brush_cursor(self):
-        self.strategy.setup_brush_cursor()
-
     def zoom_in(self):
         self.strategy.zoom_in()
 
@@ -103,7 +106,8 @@ class ImageViewer(QWidget):
         return self.strategy.get_cursor_style()
 
     def set_cursor_style(self, style):
-        self.strategy.set_cursor_style(style)
+        for st in self._strategies.values():
+            st.set_cursor_style(style)
 
     def position_on_image(self, pos):
         return self.strategy.position_on_image(pos)

shinestacker/retouch/io_gui_handler.py

@@ -56,8 +56,6 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
             self.set_layer_labels(labels)
         self.set_master_layer(master_layer)
         self.image_viewer.set_master_image_np(master_layer)
-        self.image_viewer.show_master()
-        self.image_viewer.update_master_display()
         self.undo_manager.reset()
         self.blank_layer = np.zeros(master_layer.shape[:2])
         self.finish_loading_setup(f"Loaded: {self.current_file_path()}")
@@ -165,7 +163,6 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.display_manager.update_thumbnails()
         self.mark_as_modified_requested.emit(True)
         self.change_layer_requested.emit(0)
-        self.image_viewer.setup_brush_cursor()
         self.status_message_requested.emit(message)
         self.update_title_requested.emit()
         self.add_recent_file_requested.emit(self.current_file_path_master)

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,89 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
             return self.handle_gesture_event(event)
         return super().event(event)
 
+    def setup_scene_image(self, pixmap, pixmap_item):
+        self.setSceneRect(QRectF(pixmap.rect()))
+        img_width, img_height = pixmap.width(), pixmap.height()
+        self.set_max_min_scales(img_width, img_height)
+        view_rect = self.viewport().rect()
+        scale_x = view_rect.width() / img_width
+        scale_y = view_rect.height() / img_height
+        scale_factor = min(scale_x, scale_y)
+        scale_factor = max(self.min_scale(), min(scale_factor, self.max_scale()))
+        self.set_zoom_factor(scale_factor)
+        self.resetTransform()
+        self.scale(scale_factor, scale_factor)
+        self.centerOn(pixmap_item)
+        self.center_image(self)
+        self.update_cursor_pen_width()
+
+    def set_master_image(self, qimage):
+        self.status.set_master_image(qimage)
+        self.setup_scene_image(self.status.pixmap_master, self.pixmap_item_master)
+        self.update_master_display()
+
+    def set_current_image(self, qimage):
+        self.status.set_current_image(qimage)
+        if self.empty():
+            self.setup_scene_image(self.status.pixmap_current, self.pixmap_item_current)
+
+    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()
+        if self.brush_cursor:
+            self.scene.removeItem(self.brush_cursor)
+            self.brush_cursor = self.create_circle(self.scene)
+            self.update_brush_cursor()
+
+    def show_current(self):
+        self.pixmap_item_master.setVisible(False)
+        self.pixmap_item_current.setVisible(True)
+        self.brush_preview.hide()
+        if self.brush_cursor:
+            self.scene.removeItem(self.brush_cursor)
+            self.brush_cursor = self.create_alt_circle(self.scene)
+            self.update_brush_cursor()
+
+    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 +225,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