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

shinestacker/retouch/image_editor_ui.py

@@ -1,6 +1,5 @@
 # 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,
                                QListWidget, QSlider, QMainWindow, QMessageBox)
 from PySide6.QtGui import QShortcut, QKeySequence, QAction, QActionGroup
@@ -31,9 +30,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         QMainWindow.__init__(self)
         LayerCollectionHandler.__init__(self, LayerCollection())
         self._recent_file_manager = RecentFileManager("shinestacker-recent-images-files.txt")
-        self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
         self.io_gui_handler = None
-        self.display_manager = None
         self.brush = Brush()
         self.brush_tool = BrushTool()
         self.modified = False
@@ -43,13 +40,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         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()
@@ -68,18 +59,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)
 
@@ -94,7 +82,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)
@@ -102,7 +89,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)
@@ -110,7 +96,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)
@@ -118,7 +103,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)
@@ -135,7 +119,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 {
@@ -153,7 +136,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.master_thumbnail_frame = QFrame()
         self.master_thumbnail_frame.setObjectName("thumbnailContainer")
         self.master_thumbnail_frame.setStyleSheet(
-            f"#thumbnailContainer{{ border: 2px solid {self.thumbnail_highlight}; }}")
+            f"#thumbnailContainer{{ border: 2px solid {gui_constants.THUMB_MASTER_HI_COLOR}; }}")
         self.master_thumbnail_frame.setFrameShape(QFrame.StyledPanel)
         master_thumbnail_layout = QVBoxLayout(self.master_thumbnail_frame)
         master_thumbnail_layout.setContentsMargins(8, 8, 8, 8)
@@ -238,6 +221,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.display_manager = DisplayManager(
             self.layer_collection, self.image_viewer,
             self.master_thumbnail_label, self.thumbnail_list, parent=self)
+        self.filter_manager = FilterManager(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.io_gui_handler.status_message_requested.connect(self.show_status_message)
@@ -252,8 +236,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.image_viewer.set_preview_brush(self.brush_tool.brush)
         self.brush_tool.update_brush_thumb()
         self.io_gui_handler.setup_ui(self.display_manager, self.image_viewer)
-        self.image_viewer.set_display_manager(self.display_manager)
-
         menubar = self.menuBar()
         file_menu = menubar.addMenu("&File")
         file_menu.addAction("&Open...", self.io_gui_handler.open_file, "Ctrl+O")
@@ -322,7 +304,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
         view_menu.addSeparator()
 
-        view_strategy_menu = QMenu("View &Mode", view_menu)
+        self.view_strategy_menu = QMenu("View &Mode", view_menu)
 
         self.view_mode_actions = {
             'overlaid': QAction("Overlaid", self),
@@ -332,29 +314,33 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         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)
+        overlaid_mode.triggered.connect(lambda: self.set_strategy('overlaid'))
+        self.view_strategy_menu.addAction(overlaid_mode)
         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.triggered.connect(lambda: self.set_strategy('sidebyside'))
+        self.view_strategy_menu.addAction(side_by_side_mode)
         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'))
-        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_mode_actions.items():
-                mode.setEnabled(label != strategy)
-                mode.setChecked(label == strategy)
+        side_by_side_mode.triggered.connect(lambda: self.set_strategy('topbottom'))
+        self.view_strategy_menu.addAction(side_by_side_mode)
+        view_menu.addMenu(self.view_strategy_menu)
+
+        filter_handles = (
+            self.display_manager.update_master_thumbnail,
+            self.mark_as_modified,
+            self.view_strategy_menu.setEnabled
+        )
+        self.filter_manager.register_filter(
+            "Denoise", DenoiseFilter, *filter_handles)
+        self.filter_manager.register_filter(
+            "Unsharp Mask", UnsharpMaskFilter, *filter_handles)
+        self.filter_manager.register_filter(
+            "White Balance", WhiteBalanceFilter, *filter_handles)
+        self.filter_manager.register_filter(
+            "Vignetting Correction", VignettingFilter, *filter_handles)
 
         cursor_menu = view_menu.addMenu("Cursor Style")
 
@@ -432,7 +418,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'))
@@ -463,6 +449,8 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         help_menu.setObjectName("Help")
         shortcuts_help_action = QAction("Shortcuts and Mouse", self)
 
+        self.statusBar().showMessage("Shine Stacker ready.", 2000)
+
         def shortcuts_help():
             self.shortcuts_help_dialog = ShortcutsHelp(self)
             self.shortcuts_help_dialog.exec()
@@ -476,6 +464,18 @@ 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.display_manager.view_mode = 'master'
+        self.highlight_master_thumbnail(gui_constants.THUMB_MASTER_HI_COLOR)
+        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:
@@ -591,7 +591,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
     def copy_brush_area_to_master(self, view_pos):
         if self.layer_stack() is None or self.number_of_layers() == 0 \
-           or not self.display_manager.allow_cursor_preview():
+           or self.display_manager.view_mode != 'master':
             return
         area = self.brush_tool.apply_brush_operation(
             self.master_layer_copy(),
@@ -601,7 +601,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.undo_manager.extend_undo_area(*area)
 
     def begin_copy_brush_area(self, pos):
-        if self.display_manager.allow_cursor_preview():
+        if self.display_manager.view_mode == 'master':
             self.mask_layer = self.io_gui_handler.blank_layer.copy()
             self.copy_master_layer()
             self.undo_manager.reset_undo_area()
@@ -612,7 +612,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             self.mark_as_modified()
 
     def continue_copy_brush_area(self, pos):
-        if self.display_manager.allow_cursor_preview():
+        if self.display_manager.view_mode == 'master':
             self.copy_brush_area_to_master(pos)
             self.display_manager.needs_update = True
             if not self.display_manager.update_timer.isActive():
@@ -654,53 +654,9 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
     def vignetting_correction(self):
         self.filter_manager.apply("Vignetting Correction")
 
-    def connect_preview_toggle(self, preview_check, do_preview, restore_original):
-        def on_toggled(checked):
-            if checked:
-                do_preview()
-            else:
-                restore_original()
-        preview_check.toggled.connect(on_toggled)
-
-    def get_pixel_color_at(self, pos, radius=None):
-        item_pos = self.image_viewer.position_on_image(pos)
-        x = int(item_pos.x())
-        y = int(item_pos.y())
-        master_layer = self.master_layer()
-        if (0 <= x < self.master_layer().shape[1]) and \
-           (0 <= y < self.master_layer().shape[0]):
-            if radius is None:
-                radius = int(self.brush.size)
-            if radius > 0:
-                y_indices, x_indices = np.ogrid[-radius:radius + 1, -radius:radius + 1]
-                mask = x_indices**2 + y_indices**2 <= radius**2
-                x0 = max(0, x - radius)
-                x1 = min(master_layer.shape[1], x + radius + 1)
-                y0 = max(0, y - radius)
-                y1 = min(master_layer.shape[0], y + radius + 1)
-                mask = mask[radius - (y - y0): radius + (y1 - y),
-                            radius - (x - x0): radius + (x1 - x)]
-                region = master_layer[y0:y1, x0:x1]
-                if region.size == 0:
-                    pixel = master_layer[y, x]
-                else:
-                    if region.ndim == 3:
-                        pixel = [region[:, :, c][mask].mean() for c in range(region.shape[2])]
-                    else:
-                        pixel = region[mask].mean()
-            else:
-                pixel = self.master_layer()[y, x]
-            if np.isscalar(pixel):
-                pixel = [pixel, pixel, pixel]
-            pixel = [np.float32(x) for x in pixel]
-            if master_layer.dtype == np.uint16:
-                pixel = [x / 256.0 for x in pixel]
-            return tuple(int(v) for v in pixel)
-        return (0, 0, 0)
-
-    def highlight_master_thumbnail(self):
+    def highlight_master_thumbnail(self, color):
         self.master_thumbnail_frame.setStyleSheet(
-            f"#thumbnailContainer{{ border: 2px solid {self.thumbnail_highlight}; }}")
+            f"#thumbnailContainer{{ border: 2px solid {color}; }}")
 
     def save_actions_set_enabled(self, enabled):
         self.save_action.setEnabled(enabled)
@@ -716,13 +672,11 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
     def set_view_master(self):
         self.display_manager.set_view_master()
-        self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
-        self.highlight_master_thumbnail()
+        self.highlight_master_thumbnail(gui_constants.THUMB_MASTER_HI_COLOR)
 
     def set_view_individual(self):
         self.display_manager.set_view_individual()
-        self.thumbnail_highlight = gui_constants.THUMB_MASTER_LO_COLOR
-        self.highlight_master_thumbnail()
+        self.highlight_master_thumbnail(gui_constants.THUMB_MASTER_LO_COLOR)
 
     def toggle_view_master_individual(self):
         if self.display_manager.view_mode == 'master':
@@ -757,12 +711,10 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
     def handle_temp_view(self, start):
         if start:
             self.display_manager.start_temp_view()
-            self.thumbnail_highlight = gui_constants.THUMB_MASTER_LO_COLOR
-            self.highlight_master_thumbnail()
+            self.highlight_master_thumbnail(gui_constants.THUMB_MASTER_LO_COLOR)
         else:
             self.display_manager.end_temp_view()
-            self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
-            self.highlight_master_thumbnail()
+            self.highlight_master_thumbnail(gui_constants.THUMB_MASTER_HI_COLOR)
 
     def handle_brush_size_change(self, delta):
         if delta > 0:

shinestacker/retouch/image_viewer.py

@@ -20,7 +20,6 @@ class ImageViewer(QWidget):
         self.strategy = self._strategies['overlaid']
         self.layout = QVBoxLayout(self)
         self.layout.setContentsMargins(0, 0, 0, 0)
-        self.strategy = self._strategies['overlaid']
         self.layout.addWidget(self.strategy)
         self.strategy.show()
 
@@ -35,7 +34,6 @@ 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()
@@ -50,10 +48,6 @@ class ImageViewer(QWidget):
     def set_master_image_np(self, img):
         self.strategy.set_master_image_np(img)
 
-    def clear_image(self):
-        for st in self._strategies.values():
-            st.clear_image()
-
     def show_master(self):
         self.strategy.show_master()
 
@@ -72,24 +66,6 @@ class ImageViewer(QWidget):
     def refresh_display(self):
         self.strategy.refresh_display()
 
-    def set_brush(self, brush):
-        for st in self._strategies.values():
-            st.set_brush(brush)
-
-    def set_preview_brush(self, brush):
-        for st in self._strategies.values():
-            st.set_preview_brush(brush)
-
-    def set_display_manager(self, dm):
-        for st in self._strategies.values():
-            st.set_display_manager(dm)
-
-    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()
 
@@ -102,21 +78,49 @@ class ImageViewer(QWidget):
     def actual_size(self):
         self.strategy.actual_size()
 
+    def get_brush(self):
+        return self.strategy.brush
+
     def get_current_scale(self):
         return self.strategy.get_current_scale()
 
     def get_cursor_style(self):
         return self.strategy.get_cursor_style()
 
-    def set_cursor_style(self, style):
-        self.strategy.set_cursor_style(style)
-
     def position_on_image(self, pos):
         return self.strategy.position_on_image(pos)
 
     def get_visible_image_portion(self):
         return self.strategy.get_visible_image_portion()
 
+    def hide_brush_cursor(self):
+        self.strategy.hide_brush_cursor()
+
+    def show_brush_cursor(self):
+        self.strategy.show_brush_cursor()
+
+    def hide_brush_preview(self):
+        self.strategy.hide_brush_preview()
+
+    def show_brush_preview(self):
+        self.strategy.show_brush_preview()
+
+    def clear_image(self):
+        for st in self._strategies.values():
+            st.clear_image()
+
+    def set_brush(self, brush):
+        for st in self._strategies.values():
+            st.set_brush(brush)
+
+    def set_preview_brush(self, brush):
+        for st in self._strategies.values():
+            st.set_preview_brush(brush)
+
+    def set_cursor_style(self, style):
+        for st in self._strategies.values():
+            st.set_cursor_style(style)
+
     def connect_signals(
             self, handle_temp_view, begin_copy_brush_area, continue_copy_brush_area,
             end_copy_brush_area, handle_brush_size_change):

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/overlaid_view.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, E0611, E1101, R0904, R0912, R0914, R0902
+# pylint: disable=C0114, C0115, C0116, E0611, E1101, R0904, R0912, R0914, R0902, E0202
 from PySide6.QtCore import Qt, QPointF, QEvent, QRectF
 from .. config.gui_constants import gui_constants
 from .view_strategy import ViewStrategy, ImageGraphicsViewBase, ViewSignals
@@ -107,6 +107,16 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
             if self.brush_cursor:
                 self.brush_cursor.show()
         super().enterEvent(event)
+
+    def get_mouse_callbacks(self):
+        return self.mousePressEvent
+
+    def set_mouse_callbacks(self, callbacks):
+        self.mousePressEvent = callbacks
+
+    def show(self):
+        self.show_master()
+        super().show()
     # pylint: enable=C0103
 
     def event(self, event):
@@ -114,27 +124,31 @@ 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
+    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)
-        self.set_zoom_factor(1.0)
+        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.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.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.setSceneRect(QRectF(self.status.pixmap_current.rect()))
-        self.update_cursor_pen_width()
+            self.setup_scene_image(self.status.pixmap_current, self.pixmap_item_current)
 
     def setup_brush_cursor(self):
         super().setup_brush_cursor()
@@ -143,12 +157,20 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
     def show_master(self):
         self.pixmap_item_master.setVisible(True)
         self.pixmap_item_current.setVisible(False)
-        self.brush_preview.show()
+        self.show_brush_preview()
+        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()
+        self.hide_brush_preview()
+        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():
@@ -199,8 +221,7 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
             handled = True
         if handled:
             event.accept()
-            return True
-        return False
+        return handled
 
     def handle_pan_gesture(self, pan_gesture):
         if pan_gesture.state() == Qt.GestureStarted:
@@ -209,7 +230,7 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
         elif pan_gesture.state() == Qt.GestureUpdated:
             delta = pan_gesture.delta() - self.last_scroll_pos
             self.last_scroll_pos = pan_gesture.delta()
-            scaled_delta = delta * (1.0 / self.get_current_scale())
+            scaled_delta = delta / self.get_current_scale()
             self.scroll_view(self, int(scaled_delta.x()), int(scaled_delta.y()))
         elif pan_gesture.state() == Qt.GestureFinished:
             self.gesture_active = False

shinestacker/retouch/shortcuts_help.py

@@ -39,7 +39,7 @@ class ShortcutsHelp(QDialog):
         ok_button.clicked.connect(self.accept)
 
     def add_bold_label(self, layout, label):
-        label = QLabel(label)
+        label = QLabel(f"{label}:")
         label.setStyleSheet("font-weight: bold")
         layout.addRow(label)
 
@@ -47,21 +47,21 @@ class ShortcutsHelp(QDialog):
         self.main_layout.insertWidget(0, icon_container())
 
         shortcuts = {
-            "M": "show master layer",
-            "L": "show selected layer",
-            "T": "toggle master/selected layer",
-            "X": "temp. toggle between master and source layer",
-            "↑": "select one layer up",
-            "↓": "selcet one layer down",
-            "Ctrl + O": "open file",
-            "Ctrl + S": "save multilayer tiff",
-            "Crtl + Z": "undo brush draw",
-            "Ctrl + M": "copy selected layer to master",
-            "Ctrl + Cmd + F": "full screen mode",
-            "Ctrl + +": "zoom in",
-            "Ctrl + -": "zoom out",
-            "Ctrl + 0": "adapt to screen",
-            "Ctrl + R": "actual size"
+            "M": "Show master layer",
+            "L": "Show selected layer",
+            "T": "Toggle master/selected layer",
+            "X": "Temporarily toggle between master and source layer",
+            "↑": "Select one layer up",
+            "↓": "Select one layer down",
+            "Ctrl + O": "Open file",
+            "Ctrl + S": "Save multilayer tiff",
+            "Ctrl + Z": "Undo brush draw",
+            "Ctrl + M": "Copy selected layer to master",
+            "Ctrl + Cmd + F": "Full screen mode",
+            "Ctrl + +": "Zoom in",
+            "Ctrl + -": "Zoom out",
+            "Ctrl + 0": "Fit to screen",
+            "Ctrl + R": "Actual size"
         }
 
         self.add_bold_label(left_layout, "Keyboard Shortcuts")
@@ -69,13 +69,13 @@ class ShortcutsHelp(QDialog):
             left_layout.addRow(f"<b>{k}</b>", QLabel(v))
 
         shortcuts = {
-            "Ctrl + 1": "view mode: overlaid",
-            "Ctrl + 2": "view mode: side by side",
-            "Ctrl + 3": "view mode: top-bottom",
-            "[": "increase brush size",
-            "]": "decrease brush size",
-            "{": "increase brush hardness",
-            "}": "decrease brush hardness"
+            "Ctrl + 1": "View: overlaid",
+            "Ctrl + 2": "View: side by side",
+            "Ctrl + 3": "View: top-bottom",
+            "[": "Increase brush size",
+            "]": "Decrease brush size",
+            "{": "Increase brush hardness",
+            "}": "Decrease brush hardness"
         }
 
         self.add_bold_label(right_layout, "Keyboard Shortcuts")
@@ -83,22 +83,26 @@ class ShortcutsHelp(QDialog):
             right_layout.addRow(f"<b>{k}</b>", QLabel(v))
 
         mouse_controls = {
-            "Space + Drag": "pan",
-            "Wheel": "zoom in/out",
-            "Ctrl + Wheel": "adjust brush size",
-            "Left Click": "brush action",
+            "Space + Drag": "Move",
+            "Wheel": "Zoom in/out",
+            "Ctrl + Wheel": "Adjust brush size",
+            "Left Click": "Use brush to copy from selected layer to master",
         }
 
+        spacer = QLabel("")
+        spacer.setFixedHeight(10)
+        right_layout.addWidget(spacer)
         self.add_bold_label(right_layout, "Mouse Controls")
         for k, v in mouse_controls.items():
             right_layout.addRow(f"<b>{k}</b>", QLabel(v))
 
         touchpad_controls = {
-            "Two fingers": "pan",
-            "Pinch": "zoom in/out",
-            "Ctrl + two fingers": "zoom in/out",
+            "Two-finger drag": "Move",
+            "Pinch two fingers": "Zoom in/out"
         }
-        self.add_bold_label(right_layout, " ")
+        spacer = QLabel("")
+        spacer.setFixedHeight(10)
+        right_layout.addWidget(spacer)
         self.add_bold_label(right_layout, "Touchpad Controls")
         for k, v in touchpad_controls.items():
             right_layout.addRow(f"<b>{k}</b>", QLabel(v))