shinestacker 1.5.3__py3-none-any.whl → 1.6.0__py3-none-any.whl

shinestacker/retouch/image_editor_ui.py

@@ -6,6 +6,7 @@ from PySide6.QtGui import QShortcut, QKeySequence, QAction, QActionGroup
 from PySide6.QtCore import Qt
 from PySide6.QtGui import QGuiApplication
 from .. config.constants import constants
+from .. config.app_config import AppConfig
 from .. config.gui_constants import gui_constants
 from .. gui.recent_file_manager import RecentFileManager
 from .image_viewer import ImageViewer
@@ -184,6 +185,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         def change_layer_item(item):
             layer_idx = self.thumbnail_list.row(item)
             self.change_layer(layer_idx)
+            self.display_manager.highlight_thumbnail(layer_idx)
 
         self.thumbnail_list.itemClicked.connect(change_layer_item)
         self.thumbnail_list.setStyleSheet("""
@@ -229,11 +231,14 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.io_gui_handler.mark_as_modified_requested.connect(self.mark_as_modified)
         self.io_gui_handler.change_layer_requested.connect(self.change_layer)
         self.io_gui_handler.add_recent_file_requested.connect(self.add_recent_file)
+        self.io_gui_handler.set_enabled_file_open_close_actions_requested.connect(
+            self.set_enabled_file_open_close_actions)
         self.brush_tool.setup_ui(self.brush, self.brush_preview_widget, self.image_viewer,
                                  self.brush_size_slider, self.hardness_slider, self.opacity_slider,
                                  self.flow_slider)
         self.image_viewer.set_brush(self.brush_tool.brush)
         self.image_viewer.set_preview_brush(self.brush_tool.brush)
+        self.image_viewer.status.set_zoom_factor_requested.connect(self.handle_set_zoom_factor)
         self.brush_tool.update_brush_thumb()
         self.io_gui_handler.setup_ui(self.display_manager, self.image_viewer)
         menubar = self.menuBar()
@@ -277,22 +282,26 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
         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.setProperty("requires_file", True)
         rotate_90_cw_action.triggered.connect(lambda: self.transformation_manager.rotate_90_cw())
+        transf_menu.addAction(rotate_90_cw_action)
         rotate_90_ccw_action = QAction(gui_constants.ROTATE_90_CCW_LABEL, self)
-        transf_menu.addAction(rotate_90_ccw_action)
+        rotate_90_ccw_action.setProperty("requires_file", True)
         rotate_90_ccw_action.triggered.connect(lambda: self.transformation_manager.rotate_90_ccw())
+        transf_menu.addAction(rotate_90_ccw_action)
         rotate_180_action = QAction(gui_constants.ROTATE_180_LABEL, self)
         rotate_180_action.triggered.connect(lambda: self.transformation_manager.rotate_180())
+        rotate_180_action.setProperty("requires_file", True)
         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)
+        copy_current_to_master_action = QAction("Copy Current Layer to Master", self)
+        copy_current_to_master_action.setShortcut("Ctrl+M")
+        copy_current_to_master_action.setProperty("requires_file", True)
+        copy_current_to_master_action.triggered.connect(self.copy_layer_to_master)
+        edit_menu.addAction(copy_current_to_master_action)
 
         view_menu = menubar.addMenu("&View")
 
@@ -351,15 +360,18 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         }
         brush_action = self.cursor_style_actions['brush']
         brush_action.setCheckable(True)
+        brush_action.setProperty("requires_file", True)
         brush_action.triggered.connect(lambda: set_cursor_style('brush'))
         cursor_menu.addAction(brush_action)
 
         preview_action = self.cursor_style_actions['preview']
+        preview_action.setProperty("requires_file", True)
         preview_action.setCheckable(True)
         preview_action.triggered.connect(lambda: set_cursor_style('preview'))
         cursor_menu.addAction(preview_action)
 
         outline_action = self.cursor_style_actions['outline']
+        outline_action.setProperty("requires_file", True)
         outline_action.setCheckable(True)
         outline_action.triggered.connect(lambda: set_cursor_style('outline'))
         cursor_menu.addAction(outline_action)
@@ -382,50 +394,59 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
         zoom_in_action = QAction("Zoom In", self)
         zoom_in_action.setShortcut("Ctrl++")
+        zoom_in_action.setProperty("requires_file", True)
         zoom_in_action.triggered.connect(self.image_viewer.zoom_in)
         view_menu.addAction(zoom_in_action)
 
         zoom_out_action = QAction("Zoom Out", self)
         zoom_out_action.setShortcut("Ctrl+-")
+        zoom_out_action.setProperty("requires_file", True)
         zoom_out_action.triggered.connect(self.image_viewer.zoom_out)
         view_menu.addAction(zoom_out_action)
 
         adapt_action = QAction("Adapt to Screen", self)
         adapt_action.setShortcut("Ctrl+0")
+        adapt_action.setProperty("requires_file", True)
         adapt_action.triggered.connect(self.image_viewer.reset_zoom)
         view_menu.addAction(adapt_action)
 
         actual_size_action = QAction("Actual Size", self)
         actual_size_action.setShortcut("Ctrl+R")
+        actual_size_action.setProperty("requires_file", True)
         actual_size_action.triggered.connect(self.image_viewer.actual_size)
         view_menu.addAction(actual_size_action)
         view_menu.addSeparator()
 
         self.view_master_action = QAction("View Master", self)
         self.view_master_action.setShortcut("M")
+        self.view_master_action.setProperty("requires_file", True)
         self.view_master_action.triggered.connect(self.set_view_master)
         view_menu.addAction(self.view_master_action)
 
         self.view_individual_action = QAction("View Individual", self)
         self.view_individual_action.setShortcut("L")
+        self.view_individual_action.setProperty("requires_file", True)
         self.view_individual_action.triggered.connect(self.set_view_individual)
         view_menu.addAction(self.view_individual_action)
 
         self.toggle_view_master_individual_action = QAction("Toggle Master/Individual", self)
         self.toggle_view_master_individual_action.setShortcut("T")
+        self.toggle_view_master_individual_action.setProperty("requires_file", True)
         self.toggle_view_master_individual_action.triggered.connect(
             self.toggle_view_master_individual)
         view_menu.addAction(self.toggle_view_master_individual_action)
         view_menu.addSeparator()
 
-        self.set_strategy('overlaid')
+        self.set_strategy(AppConfig.get('view_strategy'))
 
         sort_asc_action = QAction("Sort Layers A-Z", self)
-        sort_asc_action.triggered.connect(lambda: self.sort_layers('asc'))
+        sort_asc_action.setProperty("requires_file", True)
+        sort_asc_action.triggered.connect(lambda: self.sort_layers_ui('asc'))
         view_menu.addAction(sort_asc_action)
 
         sort_desc_action = QAction("Sort Layers Z-A", self)
-        sort_desc_action.triggered.connect(lambda: self.sort_layers('desc'))
+        sort_desc_action.setProperty("requires_file", True)
+        sort_desc_action.triggered.connect(lambda: self.sort_layers_ui('desc'))
         view_menu.addAction(sort_desc_action)
 
         view_menu.addSeparator()
@@ -433,15 +454,19 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         filter_menu = menubar.addMenu("&Filter")
         filter_menu.setObjectName("Filter")
         denoise_action = QAction("Denoise", self)
+        denoise_action.setProperty("requires_file", True)
         denoise_action.triggered.connect(self.denoise_filter)
         filter_menu.addAction(denoise_action)
         unsharp_mask_action = QAction("Unsharp Mask", self)
+        unsharp_mask_action.setProperty("requires_file", True)
         unsharp_mask_action.triggered.connect(self.unsharp_mask)
         filter_menu.addAction(unsharp_mask_action)
         white_balance_action = QAction("White Balance", self)
+        white_balance_action.setProperty("requires_file", True)
         white_balance_action.triggered.connect(self.white_balance)
         filter_menu.addAction(white_balance_action)
         vignetting_action = QAction("Vignetting Correction", self)
+        vignetting_action.setProperty("requires_file", True)
         vignetting_action.triggered.connect(self.vignetting_correction)
         filter_menu.addAction(vignetting_action)
 
@@ -449,6 +474,8 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         help_menu.setObjectName("Help")
         shortcuts_help_action = QAction("Shortcuts and Mouse", self)
 
+        self.zoom_factor_label = QLabel("")
+        self.statusBar().addPermanentWidget(self.zoom_factor_label)
         self.statusBar().showMessage("Shine Stacker ready.", 2000)
 
         def shortcuts_help():
@@ -462,20 +489,33 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         prev_layer.activated.connect(self.prev_layer)
         next_layer = QShortcut(QKeySequence(Qt.Key_Down), self, context=Qt.ApplicationShortcut)
         next_layer.activated.connect(self.next_layer)
+
+        self.set_enabled_file_open_close_actions(False)
         self.installEventFilter(self)
 
+    def handle_config(self):
+        self.set_strategy(AppConfig.get('view_strategy'))
+        self.display_manager.update_timer.setInterval(AppConfig.get('display_refresh_time'))
+
+    def set_enabled_view_toggles(self, enabled):
+        self.view_master_action.setEnabled(enabled)
+        self.view_individual_action.setEnabled(enabled)
+        self.toggle_view_master_individual_action.setEnabled(enabled)
+
     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)
+        self.set_enabled_view_toggles(strategy == 'overlaid')
         for label, mode in self.view_mode_actions.items():
             mode.setEnabled(label != strategy)
             mode.setChecked(label == strategy)
 
+    def set_enabled_file_open_close_actions(self, enabled):
+        for action in self.findChildren(QAction):
+            if action.property("requires_file"):
+                action.setEnabled(enabled)
+
     def update_title(self):
         title = constants.APP_TITLE
         if self.io_gui_handler is not None:
@@ -544,10 +584,10 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
     def save_master_only(self, _checked):
         self.update_title()
 
-    def sort_layers(self, order):
+    def sort_layers_ui(self, order):
         self.sort_layers(order)
         self.display_manager.update_thumbnails()
-        self.change_layer(self.current_layer())
+        self.change_layer(self.current_layer_idx())
 
     def change_layer(self, layer_idx):
         if 0 <= layer_idx < self.number_of_layers():
@@ -669,6 +709,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             self.io_gui_handler.close_file()
             self.set_master_layer(None)
             self.mark_as_modified(False)
+            self.zoom_factor_label.setText("")
 
     def set_view_master(self):
         self.display_manager.set_view_master()
@@ -721,3 +762,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             self.brush_tool.increase_brush_size()
         else:
             self.brush_tool.decrease_brush_size()
+
+    def handle_set_zoom_factor(self, zoom_factor):
+        self.zoom_factor_label.setText(f"zoom: {zoom_factor:.1%}")

shinestacker/retouch/image_view_status.py

@@ -1,9 +1,11 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0902
-from PySide6.QtCore import QObject, QRectF
+from PySide6.QtCore import QObject, QRectF, Signal
 from PySide6.QtGui import QPixmap
 
 
 class ImageViewStatus(QObject):
+    set_zoom_factor_requested = Signal(float)
+
     def __init__(self, parent=None):
         super().__init__(parent)
         self.pixmap_master = QPixmap()
@@ -53,6 +55,7 @@ class ImageViewStatus(QObject):
 
     def set_zoom_factor(self, zoom_factor):
         self.zoom_factor = zoom_factor
+        self.set_zoom_factor_requested.emit(zoom_factor)
 
     def set_min_scale(self, min_scale):
         self.min_scale = min_scale

shinestacker/retouch/io_gui_handler.py

@@ -17,6 +17,7 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
     mark_as_modified_requested = Signal(bool)
     change_layer_requested = Signal(int)
     add_recent_file_requested = Signal(str)
+    set_enabled_file_open_close_actions_requested = Signal(bool)
 
     def __init__(self, layer_collection, undo_manager, parent):
         QObject.__init__(self, parent)
@@ -165,6 +166,7 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.change_layer_requested.emit(0)
         self.status_message_requested.emit(message)
         self.update_title_requested.emit()
+        self.set_enabled_file_open_close_actions_requested.emit(True)
         self.add_recent_file_requested.emit(self.current_file_path_master)
 
     def save_file(self):
@@ -277,4 +279,5 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.display_manager.thumbnail_list.clear()
         self.display_manager.update_thumbnails()
         self.update_title_requested.emit()
+        self.set_enabled_file_open_close_actions_requested.emit(False)
         self.status_message_requested.emit("File closed")

shinestacker/retouch/overlaid_view.py

@@ -1,6 +1,5 @@
 # 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
 
 
@@ -61,41 +60,9 @@ 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
-        if event.source() == Qt.MouseEventNotSynthesized:  # Physical mouse
-            if self.control_pressed:
-                self.brush_size_change_requested.emit(1 if event.angleDelta().y() > 0 else -1)
-            else:
-                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
-                    if new_scale <= self.max_scale():
-                        self.scale(zoom_in_factor, zoom_in_factor)
-                        self.set_zoom_factor(new_scale)
-                else:  # Zoom out
-                    new_scale = current_scale * zoom_out_factor
-                    if new_scale >= self.min_scale():
-                        self.scale(zoom_out_factor, zoom_out_factor)
-                        self.set_zoom_factor(new_scale)
-            self.update_brush_cursor()
-        else:  # Touchpad event - fallback for systems without gesture recognition
-            if not self.control_pressed:
-                delta = event.pixelDelta() or event.angleDelta() / 8
-                if delta:
-                    self.scroll_view(self, delta.x(), delta.y())
-            else:  # Control + touchpad scroll for zoom
-                zoom_in = event.angleDelta().y() > 0
-                if zoom_in:
-                    self.zoom_in()
-                else:
-                    self.zoom_out()
+        self.handle_wheel_event(event)
         event.accept()
-        # pylint: disable=R0801
 
     def enterEvent(self, event):
         self.activateWindow()
@@ -114,10 +81,13 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
     def set_mouse_callbacks(self, callbacks):
         self.mousePressEvent = callbacks
 
+    def get_view_with_mouse(self, event=None):
+        return self
+
+    # pylint: enable=C0103
     def show(self):
         self.show_master()
         super().show()
-    # pylint: enable=C0103
 
     def event(self, event):
         if event.type() == QEvent.Gesture:
@@ -126,14 +96,7 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
 
     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)
+        _img_width, _img_height, scale_factor = self.setup_view_image(self, pixmap)
         self.resetTransform()
         self.scale(scale_factor, scale_factor)
         self.centerOn(pixmap_item)

shinestacker/retouch/sidebyside_view.py

@@ -3,6 +3,7 @@ import time
 from PySide6.QtCore import Qt, Signal, QEvent, QRectF
 from PySide6.QtGui import QCursor
 from PySide6.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout, QFrame
+
 from .view_strategy import ViewStrategy, ImageGraphicsViewBase, ViewSignals
 
 
@@ -60,6 +61,7 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self.master_view.setFocusPolicy(Qt.NoFocus)
         self.current_brush_cursor = None
         self.last_color_update_time_current = 0
+        self._updating_scrollbars = False
 
     def setup_layout(self):
         raise NotImplementedError("Subclasses must implement setup_layout")
@@ -77,14 +79,25 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self.master_view.mouse_moved.connect(self.handle_master_mouse_move)
         self.master_view.mouse_released.connect(self.handle_master_mouse_release)
         self.master_view.gesture_event.connect(self.handle_gesture_event)
+
+        def sync_scrollbars(source, target):
+            if not self._updating_scrollbars:
+                self._updating_scrollbars = True
+                target.setValue(source.value())
+                self._updating_scrollbars = False
+
         self.current_view.horizontalScrollBar().valueChanged.connect(
-            self.master_view.horizontalScrollBar().setValue)
+            lambda value: sync_scrollbars(self.current_view.horizontalScrollBar(),
+                                          self.master_view.horizontalScrollBar()))
         self.current_view.verticalScrollBar().valueChanged.connect(
-            self.master_view.verticalScrollBar().setValue)
+            lambda value: sync_scrollbars(self.current_view.verticalScrollBar(),
+                                          self.master_view.verticalScrollBar()))
         self.master_view.horizontalScrollBar().valueChanged.connect(
-            self.current_view.horizontalScrollBar().setValue)
+            lambda value: sync_scrollbars(self.master_view.horizontalScrollBar(),
+                                          self.current_view.horizontalScrollBar()))
         self.master_view.verticalScrollBar().valueChanged.connect(
-            self.current_view.verticalScrollBar().setValue)
+            lambda value: sync_scrollbars(self.master_view.verticalScrollBar(),
+                                          self.current_view.verticalScrollBar()))
         self.current_view.wheel_event.connect(self.handle_wheel_event)
         self.master_view.wheel_event.connect(self.handle_wheel_event)
         # pylint: disable=C0103, W0201
@@ -229,25 +242,20 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             self.current_view.mousePressEvent = callbacks
     # pylint: enable=C0103
 
-    # pylint: enable=R0801
-    def handle_wheel_event(self, event):
-        if self.empty() or self.gesture_active:
-            return
-        if event.source() == Qt.MouseEventNotSynthesized:  # Physical mouse
-            if self.control_pressed:
-                self.brush_size_change_requested.emit(1 if event.angleDelta().y() > 0 else -1)
-            else:
-                if event.angleDelta().y() > 0:  # Zoom in
-                    self.zoom_in()
-                else:  # Zoom out
-                    self.zoom_out()
-        else:  # Touchpad event - handle scrolling
-            if not self.control_pressed:
-                delta = event.pixelDelta() or event.angleDelta() / 8
-                if delta:
-                    self.scroll_view(self.master_view, delta.x(), delta.y())
-                    self.scroll_view(self.current_view, delta.x(), delta.y())
-    # pylint: disable=R0801
+    def get_view_with_mouse(self, event=None):
+        if event is None:
+            mouse_pos_global = QCursor.pos()
+        else:
+            mouse_pos_global = event.globalPosition().toPoint()
+        mouse_pos_current = self.current_view.mapFromGlobal(mouse_pos_global)
+        mouse_pos_master = self.master_view.mapFromGlobal(mouse_pos_global)
+        current_has_mouse = self.current_view.rect().contains(mouse_pos_current)
+        master_has_mouse = self.master_view.rect().contains(mouse_pos_master)
+        if master_has_mouse:
+            return self.master_view
+        if current_has_mouse:
+            return self.current_view
+        return None
 
     def _apply_zoom_to_view(self, view, factor):
         view.scale(factor, factor)
@@ -381,35 +389,32 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
     def set_master_image(self, qimage):
         self.status.set_master_image(qimage)
         pixmap = self.status.pixmap_master
-        self.master_view.setSceneRect(QRectF(pixmap.rect()))
+        pixmap_rect = QRectF(pixmap.rect())
+        self.pixmap_item_master.setPos(0, 0)
+        self.master_view.setSceneRect(pixmap_rect)
+        self.master_scene.setSceneRect(pixmap_rect)
         self.pixmap_item_master.setPixmap(pixmap)
-        img_width, img_height = pixmap.width(), pixmap.height()
-        self.set_max_min_scales(img_width, img_height)
-        view_rect = self.master_view.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)
+        _img_width, _img_height, scale_factor = self.setup_view_image(self.master_view, pixmap)
         self.master_view.resetTransform()
         self.master_view.scale(scale_factor, scale_factor)
         self.master_view.centerOn(self.pixmap_item_master)
-        center = self.master_scene.sceneRect().center()
-        self.brush_preview.setPos(max(0, min(center.x(), img_width)),
-                                  max(0, min(center.y(), img_height)))
-        self.master_scene.setSceneRect(QRectF(self.pixmap_item_master.boundingRect()))
         self.center_image(self.master_view)
         self.update_cursor_pen_width()
 
     def set_current_image(self, qimage):
         self.status.set_current_image(qimage)
         pixmap = self.status.pixmap_current
-        self.current_scene.setSceneRect(QRectF(pixmap.rect()))
+        pixmap_rect = QRectF(pixmap.rect())
+        self.pixmap_item_current.setPos(0, 0)
+        self.current_view.setSceneRect(pixmap_rect)
+        self.current_scene.setSceneRect(pixmap_rect)
         self.pixmap_item_current.setPixmap(pixmap)
+        _img_width, _img_height, scale_factor = self.setup_view_image(self.current_view, pixmap)
         self.current_view.resetTransform()
-        self.master_view.scale(self.zoom_factor(), self.zoom_factor())
-        self.current_scene.setSceneRect(QRectF(self.pixmap_item_current.boundingRect()))
+        self.current_view.scale(scale_factor, scale_factor)
+        self.current_view.centerOn(self.pixmap_item_current)
         self.center_image(self.current_view)
+        self.update_cursor_pen_width()
 
     def arrange_images(self):
         if self.status.empty():
@@ -439,8 +444,7 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         size = self.brush.size
         radius = size / 2
         self.current_brush_cursor.setRect(
-            scene_pos.x() - radius, scene_pos.y() - radius,
-            size, size)
+            scene_pos.x() - radius, scene_pos.y() - radius, size, size)
         if self.brush_cursor.isVisible():
             self.update_current_cursor_color()
             self.current_brush_cursor.show()

shinestacker/retouch/transformation_manager.py

@@ -26,7 +26,6 @@ class TransfromationManager(LayerCollectionHandler):
         self.copy_master_layer()
         self.editor.image_viewer.update_master_display()
         self.editor.image_viewer.update_current_display()
-        self.editor.image_viewer.refresh_display()
         self.editor.display_manager.update_thumbnails()
         self.editor.mark_as_modified()
 

shinestacker/retouch/undo_manager.py

@@ -38,7 +38,7 @@ class UndoManager(QObject):
             return
         self.redo_stack = []
         undo_state = {
-            'master': layer[self.y_start:self.y_end, self.x_start:self.x_end],
+            'master': layer[self.y_start:self.y_end, self.x_start:self.x_end].copy(),
             'area': (self.x_start, self.y_start, self.x_end, self.y_end),
             'description': description
         }