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

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))

shinestacker/retouch/sidebyside_view.py

@@ -1,8 +1,7 @@
 # pylint: disable=C0114, C0115, C0116, R0904, R0915, E0611, R0902, R0911, R0914, E1003
 from PySide6.QtCore import Qt, Signal, QEvent, QRectF
-from PySide6.QtGui import QPixmap, QPen, QColor, QCursor
-from PySide6.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout, QFrame, QGraphicsEllipseItem
-from .. config.gui_constants import gui_constants
+from PySide6.QtGui import QCursor
+from PySide6.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout, QFrame
 from .view_strategy import ViewStrategy, ImageGraphicsViewBase, ViewSignals
 
 
@@ -11,6 +10,7 @@ class ImageGraphicsView(ImageGraphicsViewBase):
     mouse_moved = Signal(QEvent)
     mouse_released = Signal(QEvent)
     gesture_event = Signal(QEvent)
+    wheel_event = Signal(QEvent)
 
     # pylint: disable=C0103
     def event(self, event):
@@ -29,6 +29,10 @@ class ImageGraphicsView(ImageGraphicsViewBase):
     def mouseReleaseEvent(self, event):
         self.mouse_released.emit(event)
         super().mouseReleaseEvent(event)
+
+    def wheelEvent(self, event):
+        self.wheel_event.emit(event)
+        event.accept()
     # pylint: enable=C0103
 
 
@@ -46,7 +50,6 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self._connect_signals()
         self.panning_current = False
         self.brush_cursor = None
-        self.setup_brush_cursor()
         self.setFocusPolicy(Qt.StrongFocus)
         self.pan_start = None
         self.pinch_start_scale = None
@@ -55,15 +58,13 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self.current_view.setFocusPolicy(Qt.NoFocus)
         self.master_view.setFocusPolicy(Qt.NoFocus)
         self.current_brush_cursor = None
-        self.setup_current_brush_cursor()
 
     def setup_layout(self):
-        """To be implemented by subclasses - creates layout and adds widgets"""
         raise NotImplementedError("Subclasses must implement setup_layout")
 
     def create_pixmaps(self):
-        self.current_pixmap_item = self.create_pixmap(self.current_scene)
-        self.master_pixmap_item = self.create_pixmap(self.master_scene)
+        self.pixmap_item_current = self.create_pixmap(self.current_scene)
+        self.pixmap_item_master = self.create_pixmap(self.master_scene)
 
     def _connect_signals(self):
         self.current_view.mouse_pressed.connect(self.handle_current_mouse_press)
@@ -82,6 +83,8 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             self.current_view.horizontalScrollBar().setValue)
         self.master_view.verticalScrollBar().valueChanged.connect(
             self.current_view.verticalScrollBar().setValue)
+        self.current_view.wheel_event.connect(self.handle_wheel_event)
+        self.master_view.wheel_event.connect(self.handle_wheel_event)
         # pylint: disable=C0103, W0201
         self.current_view.enterEvent = self.current_view_enter_event
         self.current_view.leaveEvent = self.current_view_leave_event
@@ -92,31 +95,44 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
     def current_view_enter_event(self, event):
         self.activateWindow()
         self.setFocus()
-        self.update_brush_cursor()
+        if not self.empty():
+            self.update_brush_cursor()
         super(ImageGraphicsView, self.current_view).enterEvent(event)
 
     def current_view_leave_event(self, event):
-        self.update_brush_cursor()
+        if not self.empty():
+            self.update_brush_cursor()
         super(ImageGraphicsView, self.current_view).leaveEvent(event)
 
     def master_view_enter_event(self, event):
         self.activateWindow()
         self.setFocus()
-        self.update_brush_cursor()
+        if not self.empty():
+            self.update_brush_cursor()
         super(ImageGraphicsView, self.master_view).enterEvent(event)
 
     def master_view_leave_event(self, event):
-        self.update_brush_cursor()
+        if not self.empty():
+            self.update_brush_cursor()
         super(ImageGraphicsView, self.master_view).leaveEvent(event)
 
     def get_master_view(self):
         return self.master_view
 
+    def get_current_view(self):
+        return self.current_view
+
     def get_master_scene(self):
         return self.master_scene
 
+    def get_current_scene(self):
+        return self.current_scene
+
     def get_master_pixmap(self):
-        return self.master_pixmap_item
+        return self.pixmap_item_master
+
+    def get_current_pixmap(self):
+        return self.pixmap_item_current
 
     def get_views(self):
         return [self.master_view, self.current_view]
@@ -126,8 +142,8 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
 
     def get_pixmaps(self):
         return {
-            self.master_pixmap_item: self.master_view,
-            self.current_pixmap_item: self.current_view
+            self.pixmap_item_master: self.master_view,
+            self.pixmap_item_current: self.current_view
         }
 
     # pylint: disable=C0103
@@ -153,22 +169,34 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
     def enterEvent(self, event):
         self.activateWindow()
         self.setFocus()
-        if not self.empty():
+        if self.empty():
+            self.setCursor(Qt.ArrowCursor)
+            self.master_view.setCursor(Qt.ArrowCursor)
+            self.current_view.setCursor(Qt.ArrowCursor)
+        else:
             if self.space_pressed:
                 self.master_view.setCursor(Qt.OpenHandCursor)
+                self.current_view.setCursor(Qt.OpenHandCursor)
             else:
+                if self.brush_cursor is None or self.current_brush_cursor is None:
+                    self.setup_brush_cursor()
                 self.master_view.setCursor(Qt.BlankCursor)
-                if self.brush_cursor:
-                    self.brush_cursor.show()
+                self.current_view.setCursor(Qt.BlankCursor)
+                self.brush_cursor.show()
         super().enterEvent(event)
 
     def leaveEvent(self, event):
-        if self.brush_cursor:
+        if self.empty():
+            self.setCursor(Qt.ArrowCursor)
+            self.master_view.setCursor(Qt.ArrowCursor)
+            self.current_view.setCursor(Qt.ArrowCursor)
+        else:
+            if self.brush_cursor is None or self.current_brush_cursor is None:
+                self.setup_brush_cursor()
             self.brush_cursor.hide()
-        if self.current_brush_cursor:
             self.current_brush_cursor.hide()
-        self.master_view.setCursor(Qt.ArrowCursor)
-        self.current_view.setCursor(Qt.ArrowCursor)
+            self.master_view.setCursor(Qt.ArrowCursor)
+            self.current_view.setCursor(Qt.ArrowCursor)
         super().leaveEvent(event)
 
     def keyPressEvent(self, event):
@@ -182,97 +210,98 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             self.update_brush_cursor()
     # 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 _apply_zoom_to_view(self, view, factor):
+        view.scale(factor, factor)
+        other_view = self.current_view if view == self.master_view else self.master_view
+        other_view.resetTransform()
+        other_view.scale(self.zoom_factor(), self.zoom_factor())
+
+    def show_master(self):
+        self.pixmap_item_master.setVisible(True)
+        self.pixmap_item_current.setVisible(True)
+
+    def show_current(self):
+        self.pixmap_item_master.setVisible(True)
+        self.pixmap_item_current.setVisible(True)
+
     def setup_brush_cursor(self):
         super().setup_brush_cursor()
         self.setup_current_brush_cursor()
-        self.update_cursor_pen_width()
 
     def setup_current_brush_cursor(self):
         if not self.brush:
             return
-        for item in self.current_scene.items():
-            if isinstance(item, QGraphicsEllipseItem) and item != self.brush_preview:
-                self.current_scene.removeItem(item)
-        pen_width = gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
-        pen = QPen(QColor(255, 0, 0), pen_width)
-        brush = Qt.NoBrush
-        self.current_brush_cursor = self.current_scene.addEllipse(
-            0, 0, self.brush.size, self.brush.size, pen, brush)
-        self.current_brush_cursor.setZValue(1000)
-        self.current_brush_cursor.hide()
-
-    def update_current_brush_cursor(self, scene_pos):
-        if not self.current_brush_cursor or not self.isVisible():
-            return
-        size = self.brush.size
-        radius = size / 2
-        self.current_brush_cursor.setRect(
-            scene_pos.x() - radius, scene_pos.y() - radius, size, size)
-        if self.brush_cursor and self.brush_cursor.isVisible():
-            self.current_brush_cursor.show()
-        else:
-            self.current_brush_cursor.hide()
+        self.current_brush_cursor = self.create_alt_circle(
+            self.get_current_scene(), line_style=Qt.SolidLine)
 
     def update_cursor_pen_width(self):
-        if not self.brush_cursor or not self.current_brush_cursor:
-            return
-        pen_width = gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
-        master_pen = self.brush_cursor.pen()
-        master_pen.setWidthF(pen_width)
-        self.brush_cursor.setPen(master_pen)
-        current_pen = self.current_brush_cursor.pen()
-        current_pen.setWidthF(pen_width)
-        self.current_brush_cursor.setPen(current_pen)
+        pen_width = super().update_cursor_pen_width()
+        if self.current_brush_cursor:
+            current_pen = self.current_brush_cursor.pen()
+            current_pen.setWidthF(pen_width)
+            self.current_brush_cursor.setPen(current_pen)
+        return pen_width
 
     def update_brush_cursor(self):
         if self.empty():
             return
+        if self.brush_cursor is None or self.current_brush_cursor is None:
+            self.setup_brush_cursor()
         self.update_cursor_pen_width()
+        if self.space_pressed:
+            cursor_style = Qt.OpenHandCursor if not self.scrolling else Qt.ClosedHandCursor
+            self.master_view.setCursor(cursor_style)
+            self.current_view.setCursor(cursor_style)
+            self.brush_cursor.hide()
+            self.current_brush_cursor.hide()
+            return
+        self.master_view.setCursor(Qt.BlankCursor)
+        self.current_view.setCursor(Qt.BlankCursor)
         mouse_pos_global = QCursor.pos()
         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)
+        self.current_brush_cursor.hide()
         if master_has_mouse:
+            if self.cursor_style == 'preview':
+                self.brush_preview.show()
             super().update_brush_cursor()
             self.sync_current_cursor_with_master()
-            if self.space_pressed:
-                cursor_style = Qt.OpenHandCursor if not self.scrolling else Qt.ClosedHandCursor
-                self.master_view.setCursor(cursor_style)
-                self.current_view.setCursor(cursor_style)
-            else:
-                self.master_view.setCursor(Qt.BlankCursor)
-                self.current_view.setCursor(Qt.BlankCursor)
         elif current_has_mouse:
+            self.brush_preview.hide()
             scene_pos = self.current_view.mapToScene(mouse_pos_current)
             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)
             self.current_brush_cursor.show()
-            if self.brush_cursor:
-                self.brush_cursor.setRect(
-                    scene_pos.x() - radius,
-                    scene_pos.y() - radius,
-                    size, size
-                )
-                self.brush_cursor.show()
-            if self.space_pressed:
-                cursor_style = Qt.OpenHandCursor \
-                    if not self.panning_current else Qt.ClosedHandCursor
-                self.current_view.setCursor(cursor_style)
-                self.master_view.setCursor(cursor_style)
-            else:
-                self.current_view.setCursor(Qt.BlankCursor)
-                self.master_view.setCursor(Qt.BlankCursor)
+            self.brush_cursor.setRect(
+                scene_pos.x() - radius, scene_pos.y() - radius, size, size)
+            self.brush_cursor.show()
         else:
-            if self.brush_cursor:
-                self.brush_cursor.hide()
-            if self.current_brush_cursor:
-                self.current_brush_cursor.hide()
+            self.brush_cursor.hide()
+            self.current_brush_cursor.hide()
             self.master_view.setCursor(Qt.ArrowCursor)
             self.current_view.setCursor(Qt.ArrowCursor)
 
@@ -316,103 +345,55 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             self.handle_pinch_gesture(pinch_gesture)
             event.accept()
 
-    def handle_pinch_gesture(self, pinch):
-        if pinch.state() == Qt.GestureStarted:
-            self.pinch_start_scale = self.zoom_factor()
-            self.pinch_center_view = pinch.centerPoint()
-            self.pinch_center_scene = self.master_view.mapToScene(self.pinch_center_view.toPoint())
-        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.zoom_factor()) > 0.01:
-                self.set_zoom_factor(new_scale)
-                self._apply_zoom()
-                new_center = self.master_view.mapToScene(self.pinch_center_view.toPoint())
-                delta = self.pinch_center_scene - new_center
-                h_scroll = self.master_view.horizontalScrollBar().value()
-                v_scroll = self.master_view.verticalScrollBar().value()
-                self.master_view.horizontalScrollBar().setValue(
-                    h_scroll + int(delta.x() * self.zoom_factor()))
-                self.master_view.verticalScrollBar().setValue(
-                    v_scroll + int(delta.y() * self.zoom_factor()))
-
     def set_master_image(self, qimage):
         self.status.set_master_image(qimage)
         pixmap = self.status.pixmap_master
-        img_width, img_height = pixmap.width(), pixmap.height()
         self.master_view.setSceneRect(QRectF(pixmap.rect()))
-        self.master_pixmap_item.setPixmap(pixmap)
-        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.master_view.fitInView(self.master_pixmap_item, 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.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)
         self.master_view.resetTransform()
-        self.master_scene.scale(self.zoom_factor(), self.zoom_factor())
-        self.master_view.centerOn(self.master_pixmap_item)
+        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.master_pixmap_item.boundingRect()))
+        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()))
-        self.current_pixmap_item.setPixmap(pixmap)
+        self.pixmap_item_current.setPixmap(pixmap)
         self.current_view.resetTransform()
-        self.current_scene.scale(self.zoom_factor(), self.zoom_factor())
-        # self.current_view.centerOn(self.current_pixmap_item)
-        self.current_scene.setSceneRect(QRectF(self.current_pixmap_item.boundingRect()))
+        self.master_view.scale(self.zoom_factor(), self.zoom_factor())
+        self.current_scene.setSceneRect(QRectF(self.pixmap_item_current.boundingRect()))
+        self.center_image(self.current_view)
 
-    def _arrange_images(self):
+    def arrange_images(self):
         if self.status.empty():
             return
-        if self.master_pixmap_item.pixmap().height() == 0:
+        if self.pixmap_item_master.pixmap().height() == 0:
             self.update_master_display()
             self.update_current_display()
             self.reset_zoom()
-        self._apply_zoom()
-
-    def update_master_display(self):
-        if not self.status.empty():
-            master_qimage = self.numpy_to_qimage(self.master_layer())
-            if master_qimage:
-                pixmap = QPixmap.fromImage(master_qimage)
-                self.master_pixmap_item.setPixmap(pixmap)
-                self.master_scene.setSceneRect(QRectF(pixmap.rect()))
-                self._arrange_images()
-
-    def update_current_display(self):
-        if not self.status.empty() and self.number_of_layers() > 0:
-            current_qimage = self.numpy_to_qimage(self.current_layer())
-            if current_qimage:
-                pixmap = QPixmap.fromImage(current_qimage)
-                self.current_pixmap_item.setPixmap(pixmap)
-                self.current_scene.setSceneRect(QRectF(pixmap.rect()))
-                self._arrange_images()
-
-    def _apply_zoom(self):
-        if not self.current_pixmap_item.pixmap().isNull():
-            self.current_view.resetTransform()
-            self.current_view.scale(self.zoom_factor(), self.zoom_factor())
-            # self.current_view.centerOn(self.current_pixmap_item)
-        if not self.master_pixmap_item.pixmap().isNull():
-            self.master_view.resetTransform()
-            self.master_view.scale(self.zoom_factor(), self.zoom_factor())
-            # self.master_view.centerOn(self.master_pixmap_item)
-
-    def set_brush(self, brush):
-        super().set_brush(brush)
-        if self.brush_cursor:
-            self.master_scene.removeItem(self.brush_cursor)
-        self.setup_brush_cursor()
-        self.setup_current_brush_cursor()
+        else:
+            self.center_image(self.master_view)
+        self.apply_zoom()
 
     def clear_image(self):
         super().clear_image()
+        self.setCursor(Qt.ArrowCursor)
+        self.master_view.setCursor(Qt.ArrowCursor)
+        self.current_view.setCursor(Qt.ArrowCursor)
         if self.current_brush_cursor:
             self.current_scene.removeItem(self.current_brush_cursor)
             self.current_brush_cursor = None
@@ -425,31 +406,13 @@ 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.current_brush_cursor.show()
         else:
             self.current_brush_cursor.hide()
 
-    def zoom_in(self):
-        super().zoom_in()
-        self.update_cursor_pen_width()
-
-    def zoom_out(self):
-        super().zoom_out()
-        self.update_cursor_pen_width()
-
-    def reset_zoom(self):
-        super().reset_zoom()
-        self.update_cursor_pen_width()
-
-    def actual_size(self):
-        super().actual_size()
-        self.update_cursor_pen_width()
-
 
 class SideBySideView(DoubleViewBase):
     def setup_layout(self):

shinestacker/retouch/transformation_manager.py

@@ -0,0 +1,43 @@
+# pylint: disable=C0114, C0115, C0116, E1101, W0718
+import traceback
+import cv2
+from .. config.gui_constants import gui_constants
+from .layer_collection import LayerCollectionHandler
+
+
+class TransfromationManager(LayerCollectionHandler):
+    def __init__(self, editor):
+        super().__init__(editor.layer_collection)
+        self.editor = editor
+
+    def transform(self, transf_func, label, undoable=True):
+        if self.has_no_master_layer():
+            return
+        if undoable:
+            try:
+                undo = self.editor.undo_manager
+                undo.x_start, undo.x_stop = 0, 1
+                undo.y_start, undo.y_stop = 0, 1
+                undo.save_undo_state(self.editor.master_layer(), label)
+            except Exception as e:
+                traceback.print_tb(e.__traceback__)
+        self.set_master_layer(transf_func(self.master_layer()))
+        self.set_layer_stack([transf_func(layer) for layer in self.layer_stack()])
+        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()
+
+    def rotate_90_cw(self, undoable=True):
+        self.transform(lambda img: cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE),
+                       gui_constants.ROTATE_90_CW_LABEL, undoable)
+
+    def rotate_90_ccw(self, undoable=True):
+        self.transform(lambda img: cv2.rotate(img, cv2.ROTATE_90_COUNTERCLOCKWISE),
+                       gui_constants.ROTATE_90_CCW_LABEL, undoable)
+
+    def rotate_180(self, undoable=True):
+        self.transform(lambda img: cv2.rotate(img, cv2.ROTATE_180),
+                       gui_constants.ROTATE_180_LABEL, undoable)