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

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 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
 
 
@@ -59,7 +58,6 @@ 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):
         raise NotImplementedError("Subclasses must implement setup_layout")
@@ -148,6 +146,14 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             self.pixmap_item_current: self.current_view
         }
 
+    def hide_brush_cursor(self):
+        super().hide_brush_cursor()
+        self.current_brush_cursor.hide()
+
+    def show_brush_cursor(self):
+        super().show_brush_cursor()
+        self.current_brush_cursor.show()
+
     # pylint: disable=C0103
     def focusInEvent(self, event):
         super().focusInEvent(event)
@@ -180,10 +186,11 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
                 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)
                 self.current_view.setCursor(Qt.BlankCursor)
-                if self.brush_cursor:
-                    self.brush_cursor.show()
+                self.brush_cursor.show()
         super().enterEvent(event)
 
     def leaveEvent(self, event):
@@ -192,10 +199,9 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             self.master_view.setCursor(Qt.ArrowCursor)
             self.current_view.setCursor(Qt.ArrowCursor)
         else:
-            if self.brush_cursor is not None:
-                self.brush_cursor.hide()
-            if self.current_brush_cursor is not None:
-                self.current_brush_cursor.hide()
+            if self.brush_cursor is None or self.current_brush_cursor is None:
+                self.setup_brush_cursor()
+            self.hide_brush_cursor()
             self.master_view.setCursor(Qt.ArrowCursor)
             self.current_view.setCursor(Qt.ArrowCursor)
         super().leaveEvent(event)
@@ -209,6 +215,16 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         super().keyReleaseEvent(event)
         if event.key() == Qt.Key_Space:
             self.update_brush_cursor()
+
+    def get_mouse_callbacks(self):
+        return self.master_view.mousePressEvent, self.current_view.mousePressEvent
+
+    def set_mouse_callbacks(self, callbacks):
+        if isinstance(callbacks, tuple):
+            self.master_view.mousePressEvent, self.current_view.mousePressEvent = callbacks
+        else:
+            self.master_view.mousePressEvent = callbacks
+            self.current_view.mousePressEvent = callbacks
     # pylint: enable=C0103
 
     # pylint: enable=R0801
@@ -248,33 +264,12 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
     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, Qt.DotLine)
-        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):
         pen_width = super().update_cursor_pen_width()
@@ -287,48 +282,42 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
     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.hide_brush_cursor()
+            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:
-            self.brush_preview.show()
+            if self.cursor_style == 'preview':
+                self.show_brush_preview()
             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()
+            self.hide_brush_preview()
             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)
             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)
 
@@ -379,12 +368,14 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self.pixmap_item_master.setPixmap(pixmap)
         img_width, img_height = pixmap.width(), pixmap.height()
         self.set_max_min_scales(img_width, img_height)
-        self.set_zoom_factor(1.0)
-        self.master_view.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())))
+        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.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)),
@@ -399,10 +390,9 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self.current_scene.setSceneRect(QRectF(pixmap.rect()))
         self.pixmap_item_current.setPixmap(pixmap)
         self.current_view.resetTransform()
-        self.current_scene.scale(self.zoom_factor(), self.zoom_factor())
+        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)
-        self.update_cursor_pen_width()
 
     def arrange_images(self):
         if self.status.empty():
@@ -415,13 +405,6 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             self.center_image(self.master_view)
         self.apply_zoom()
 
-    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()
-
     def clear_image(self):
         super().clear_image()
         self.setCursor(Qt.ArrowCursor)
@@ -439,10 +422,8 @@ 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:

shinestacker/retouch/unsharp_mask_filter.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, E0611, W0221, R0902, R0914
+# pylint: disable=C0114, C0115, C0116, E0611, W0221, R0902, R0914, R0913, R0917
 from PySide6.QtWidgets import QHBoxLayout, QLabel, QSlider, QDialogButtonBox
 from PySide6.QtCore import Qt, QTimer
 from .. algorithms.sharpen import unsharp_mask
@@ -6,8 +6,9 @@ from .base_filter import BaseFilter
 
 
 class UnsharpMaskFilter(BaseFilter):
-    def __init__(self, name, editor):
-        super().__init__(name, editor, preview_at_startup=True)
+    def __init__(self, name, parent, image_viewer, layer_collection, undo_manager):
+        super().__init__(name, parent, image_viewer, layer_collection, undo_manager,
+                         preview_at_startup=True)
         self.max_range = 500.0
         self.max_radius = 4.0
         self.max_amount = 3.0
@@ -62,7 +63,7 @@ class UnsharpMaskFilter(BaseFilter):
         self.threshold_slider.valueChanged.connect(
             lambda v: update_value("Threshold", v, self.max_threshold, params["Threshold"][2]))
         self.preview_timer.timeout.connect(do_preview)
-        self.editor.connect_preview_toggle(self.preview_check, do_preview, restore_original)
+        self.connect_preview_toggle(self.preview_check, do_preview, restore_original)
         self.button_box.accepted.connect(dlg.accept)
         self.button_box.rejected.connect(dlg.reject)
         QTimer.singleShot(0, do_preview)

shinestacker/retouch/view_strategy.py

@@ -1,17 +1,79 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0904, R0903, R0902, E1101, R0914
+# pylint: disable=C0114, C0115, C0116, E0611, R0904, R0903, R0902, E1101, R0914, R0913, R0917
 import math
 from abc import abstractmethod
 import numpy as np
 from PySide6.QtCore import Qt, QPointF, QTime, QPoint, Signal, QRectF
-from PySide6.QtGui import QImage, QPainter, QColor, QBrush, QPen, QCursor, QPixmap
+from PySide6.QtGui import QImage, QPainter, QColor, QBrush, QPen, QCursor, QPixmap, QPainterPath
 from PySide6.QtWidgets import (
-    QGraphicsEllipseItem, QGraphicsView, QGraphicsScene, QGraphicsPixmapItem)
+    QGraphicsEllipseItem, QGraphicsView, QGraphicsScene, QGraphicsPixmapItem,
+    QGraphicsItemGroup, QGraphicsPathItem)
 from .. config.gui_constants import gui_constants
 from .layer_collection import LayerCollectionHandler
 from .brush_gradient import create_default_brush_gradient
 from .brush_preview import BrushPreviewItem
 
 
+class BrushCursor(QGraphicsItemGroup):
+    def __init__(self, x0, y0, size, pen, brush):
+        super().__init__()
+        self._pen = pen
+        self._radius = size / 2
+        self._brush = brush
+        self._rect = QRectF(x0 - self._radius, y0 - self._radius, size, size)
+        self._arc_items = []
+        self._create_arcs()
+
+    def _point_on_circle(self, phi_deg):
+        phi = phi_deg / 180.0 * math.pi
+        x0 = self._rect.x() + self._radius
+        y0 = self._rect.y() + self._radius
+        return x0 + self._radius * math.cos(phi), y0 - self._radius * math.sin(phi)
+
+    def _create_arcs(self):
+        for item in self._arc_items:
+            self.removeFromGroup(item)
+            if item.scene():
+                item.scene().removeItem(item)
+        self._arc_items = []
+        half_gap = 20
+        arcs = [half_gap, 90 + half_gap, 180 + half_gap, 270 + half_gap]
+        span_angle = 90 - 2 * half_gap
+        for start_angle in arcs:
+            path = QPainterPath()
+            path.moveTo(*self._point_on_circle(start_angle))
+            path.arcTo(self._rect, start_angle, span_angle)
+            arc_item = QGraphicsPathItem(path)
+            arc_item.setPen(self._pen)
+            arc_item.setBrush(Qt.NoBrush)
+            self.addToGroup(arc_item)
+            self._arc_items.append(arc_item)
+
+    # pylint: disable=C0103
+    def setPen(self, pen):
+        self._pen = pen
+        for item in self._arc_items:
+            item.setPen(pen)
+
+    def pen(self):
+        return self._pen
+
+    def setBrush(self, brush):
+        self._brush = brush
+        for item in self._arc_items:
+            item.setBrush(Qt.NoBrush)
+
+    def brush(self):
+        return self._brush
+
+    def setRect(self, x, y, w, h):
+        self._rect = QRectF(x, y, w, h)
+        self._create_arcs()
+
+    def rect(self):
+        return self._rect
+    # pylint: enable=C0103
+
+
 class ViewSignals:
     temp_view_requested = Signal(bool)
     brush_operation_started = Signal(QPoint)
@@ -38,14 +100,11 @@ class ImageGraphicsViewBase(QGraphicsView):
 class ViewStrategy(LayerCollectionHandler):
     def __init__(self, layer_collection, status):
         LayerCollectionHandler.__init__(self, layer_collection)
-        self.display_manager = None
         self.status = status
         self.brush = None
         self.brush_cursor = None
-        self.display_manager = None
         self.brush_preview = BrushPreviewItem(layer_collection)
         self.cursor_style = gui_constants.DEFAULT_CURSOR_STYLE
-        self.allow_cursor_preview = True
         self.control_pressed = False
         self.space_pressed = False
         self.gesture_active = False
@@ -118,38 +177,32 @@ class ViewStrategy(LayerCollectionHandler):
     def arrange_images(self):
         pass
 
-    def update_master_display(self):
-        if not self.empty():
-            master_qimage = self.numpy_to_qimage(self.master_layer())
-            if master_qimage:
-                pixmap = QPixmap.fromImage(master_qimage)
-                self.get_master_pixmap().setPixmap(pixmap)
-                self.get_master_scene().setSceneRect(QRectF(pixmap.rect()))
-                self.get_master_view().horizontalScrollBar().setValue(self.status.h_scroll)
-                self.get_master_view().verticalScrollBar().setValue(self.status.v_scroll)
-                self.arrange_images()
+    @abstractmethod
+    def get_mouse_callbacks(self):
+        pass
 
-    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:
-                pixmap = QPixmap.fromImage(current_qimage)
-                self.get_current_pixmap().setPixmap(pixmap)
-                self.get_current_scene().setSceneRect(QRectF(pixmap.rect()))
-                self.get_current_view().horizontalScrollBar().setValue(self.status.h_scroll)
-                self.get_current_view().verticalScrollBar().setValue(self.status.v_scroll)
-                self.arrange_images()
+    @abstractmethod
+    def set_mouse_callbacks(self, callbacks):
+        pass
 
-    def update_cursor_pen_width(self):
-        pen_width = gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
-        if self.brush_cursor is not None:
-            master_pen = self.brush_cursor.pen()
-            master_pen.setWidthF(pen_width)
-            self.brush_cursor.setPen(master_pen)
-        return pen_width
+    def hide_brush_cursor(self):
+        if self.brush_cursor:
+            self.brush_cursor.hide()
+
+    def show_brush_cursor(self):
+        if self.brush_cursor:
+            self.brush_cursor.show()
+
+    def hide_brush_preview(self):
+        if self.brush_preview:
+            self.brush_preview.hide()
+
+    def show_brush_preview(self):
+        if self.brush_preview:
+            self.brush_preview.show()
 
-    def set_allow_cursor_preview(self, state):
-        self.allow_cursor_preview = state
+    def current_line_width(self):
+        return gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
 
     def zoom_factor(self):
         return self.status.zoom_factor
@@ -181,13 +234,9 @@ class ViewStrategy(LayerCollectionHandler):
     def set_preview_brush(self, brush):
         self.brush_preview.brush = brush
 
-    def set_display_manager(self, dm):
-        self.display_manager = dm
-
     def set_cursor_style(self, style):
         self.cursor_style = style
-        if self.brush_cursor:
-            self.update_brush_cursor()
+        self.update_brush_cursor()
 
     def get_cursor_style(self):
         return self.cursor_style
@@ -198,6 +247,42 @@ class ViewStrategy(LayerCollectionHandler):
     def handle_key_release_event(self, _event):
         return True
 
+    def update_view_display(self, layer, pixmap_item, scene, view):
+        if self.empty():
+            return
+        qimage = self.numpy_to_qimage(layer)
+        if qimage:
+            pixmap = QPixmap.fromImage(qimage)
+            pixmap_item.setPixmap(pixmap)
+            scene.setSceneRect(QRectF(pixmap.rect()))
+            view.horizontalScrollBar().setValue(self.status.h_scroll)
+            view.verticalScrollBar().setValue(self.status.v_scroll)
+            self.arrange_images()
+
+    def update_master_display(self):
+        self.update_view_display(
+            self.master_layer(),
+            self.get_master_pixmap(),
+            self.get_master_scene(),
+            self.get_master_view())
+
+    def update_current_display(self):
+        if self.number_of_layers() <= 0:
+            return
+        self.update_view_display(
+            self.current_layer(),
+            self.get_current_pixmap(),
+            self.get_current_view(),
+            self.get_current_view())
+
+    def update_cursor_pen_width(self):
+        width = self.current_line_width()
+        if self.brush_cursor is not None:
+            pen = self.brush_cursor.pen()
+            pen.setWidthF(width)
+            self.brush_cursor.setPen(pen)
+        return width
+
     def clear_image(self):
         for scene in self.get_scenes():
             scene.clear()
@@ -207,16 +292,13 @@ class ViewStrategy(LayerCollectionHandler):
         self.brush_preview = BrushPreviewItem(self.layer_collection)
         self.get_master_scene().addItem(self.brush_preview)
         self.setCursor(Qt.ArrowCursor)
-        if self.brush_cursor:
-            self.brush_cursor.hide()
-
-    def cleanup_brush_preview(self):
-        if self.brush_cursor:
-            self.brush_cursor.hide()
-        self.brush_preview.hide()
+        self.hide_brush_cursor()
 
     def set_master_image_np(self, img):
         self.set_master_image(self.numpy_to_qimage(img))
+        if self.brush_cursor is None:
+            self.setup_brush_cursor()
+        self.show_master()
 
     def numpy_to_qimage(self, array):
         if array is None:
@@ -319,49 +401,65 @@ class ViewStrategy(LayerCollectionHandler):
         self.update_brush_cursor()
         self.update_cursor_pen_width()
 
-    def setup_outline_style(self):
-        self.brush_cursor.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['pen']),
-                                      gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()))
-        self.brush_cursor.setBrush(Qt.NoBrush)
-
     def setup_simple_brush_style(self, center_x, center_y, radius):
         gradient = create_default_brush_gradient(center_x, center_y, radius, self.brush)
         self.brush_cursor.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['pen']),
-                                      gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()))
+                                      self.current_line_width()))
         self.brush_cursor.setBrush(QBrush(gradient))
 
-    def setup_brush_cursor(self):
-        if not self.brush:
-            return
-        scene = self.get_master_scene()
+    def create_circle(self, scene, line_style=Qt.SolidLine):
         for item in scene.items():
             if isinstance(item, QGraphicsEllipseItem) and item != self.brush_preview:
                 scene.removeItem(item)
-        pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), 1)
+        pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']),
+                   self.current_line_width(), line_style)
+        brush = Qt.NoBrush
+        scene_center = scene.sceneRect().center()
+        brush_cursor = scene.addEllipse(
+            scene_center.x(), scene_center.y(),
+            self.brush.size, self.brush.size, pen, brush)
+        brush_cursor.setZValue(1000)
+        brush_cursor.hide()
+        return brush_cursor
+
+    def create_alt_circle(self, scene, line_style=Qt.SolidLine):
+        for item in scene.items():
+            if isinstance(item, BrushCursor) and item != self.brush_preview:
+                scene.removeItem(item)
+        pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']),
+                   self.current_line_width(), line_style)
         brush = Qt.NoBrush
-        self.brush_cursor = scene.addEllipse(
-            0, 0, self.brush.size, self.brush.size, pen, brush)
-        self.brush_cursor.setZValue(1000)
-        self.brush_cursor.hide()
+        scene_center = scene.sceneRect().center()
+        brush_cursor = BrushCursor(
+            scene_center.x(), scene_center.y(),
+            self.brush.size, pen, brush
+        )
+        brush_cursor.setZValue(1000)
+        brush_cursor.hide()
+        scene.addItem(brush_cursor)
+        return brush_cursor
+
+    def setup_brush_cursor(self):
+        if not self.brush:
+            return
+        self.brush_cursor = self.create_circle(self.get_master_scene())
 
     def update_brush_cursor(self):
-        if self.empty() or not self.brush_cursor or not self.isVisible():
+        if self.empty() or self.brush_cursor is None or not self.isVisible():
             return
         self.update_cursor_pen_width()
         master_view = self.get_master_view()
         mouse_pos = master_view.mapFromGlobal(QCursor.pos())
         if not master_view.rect().contains(mouse_pos):
-            self.brush_cursor.hide()
+            self.hide_brush_cursor()
             return
         scene_pos = master_view.mapToScene(mouse_pos)
         size = self.brush.size
         radius = size / 2
         self.brush_cursor.setRect(scene_pos.x() - radius, scene_pos.y() - radius, size, size)
-        allow_cursor_preview = self.display_manager.allow_cursor_preview()
         if self.cursor_style == 'preview':
-            self.setup_outline_style()
-            if allow_cursor_preview:
-                self.brush_cursor.hide()
+            if self.brush_preview.isVisible():
+                self.hide_brush_cursor()
                 pos = QCursor.pos()
                 if isinstance(pos, QPointF):
                     scene_pos = pos
@@ -370,13 +468,10 @@ class ViewStrategy(LayerCollectionHandler):
                     scene_pos = master_view.mapToScene(cursor_pos)
                 self.brush_preview.update(scene_pos, int(size))
         else:
-            self.brush_preview.hide()
-            if self.cursor_style == 'outline':
-                self.setup_outline_style()
-            else:
+            self.hide_brush_preview()
+            if self.cursor_style != 'outline':
                 self.setup_simple_brush_style(scene_pos.x(), scene_pos.y(), radius)
-        if not self.brush_cursor.isVisible():
-            self.brush_cursor.show()
+        self.show_brush_cursor()
 
     def position_on_image(self, pos):
         master_view = self.get_master_view()
@@ -417,8 +512,7 @@ class ViewStrategy(LayerCollectionHandler):
         if event.key() == Qt.Key_Space and not self.scrolling:
             self.space_pressed = True
             self.get_master_view().setCursor(Qt.OpenHandCursor)
-            if self.brush_cursor:
-                self.brush_cursor.hide()
+            self.hide_brush_cursor()
         if self.handle_key_press_event(event):
             if event.key() == Qt.Key_Control and not self.scrolling:
                 self.control_pressed = True
@@ -427,13 +521,11 @@ class ViewStrategy(LayerCollectionHandler):
     def keyReleaseEvent(self, event):
         if self.empty():
             return
-        self.update_brush_cursor()
         if event.key() == Qt.Key_Space:
             self.space_pressed = False
             if not self.scrolling:
                 self.get_master_view().setCursor(Qt.BlankCursor)
-                if self.brush_cursor:
-                    self.brush_cursor.show()
+                self.show_brush_cursor()
         if self.handle_key_release_event(event):
             if event.key() == Qt.Key_Control:
                 self.control_pressed = False
@@ -444,8 +536,7 @@ class ViewStrategy(LayerCollectionHandler):
             self.setCursor(Qt.ArrowCursor)
         else:
             self.get_master_view().setCursor(Qt.ArrowCursor)
-            if self.brush_cursor:
-                self.brush_cursor.hide()
+            self.hide_brush_cursor()
         super().leaveEvent(event)
     # pylint: enable=C0103
 
@@ -490,8 +581,7 @@ class ViewStrategy(LayerCollectionHandler):
             master_view = self.get_master_view()
             if self.space_pressed:
                 master_view.setCursor(Qt.ClosedHandCursor)
-                if self.brush_cursor:
-                    self.brush_cursor.hide()
+                self.hide_brush_cursor()
             delta = position - self.last_mouse_pos
             self.last_mouse_pos = position
             self.scroll_view(master_view, delta.x(), delta.y())
@@ -508,8 +598,7 @@ class ViewStrategy(LayerCollectionHandler):
                 self.last_brush_pos = event.position()
                 self.brush_operation_started.emit(event.position().toPoint())
                 self.dragging = True
-            if self.brush_cursor:
-                self.brush_cursor.show()
+            self.show_brush_cursor()
 
     def mouse_release_event(self, event):
         if self.empty():
@@ -517,12 +606,10 @@ class ViewStrategy(LayerCollectionHandler):
         master_view = self.get_master_view()
         if self.space_pressed:
             master_view.setCursor(Qt.OpenHandCursor)
-            if self.brush_cursor:
-                self.brush_cursor.hide()
+            self.hide_brush_cursor()
         else:
             master_view.setCursor(Qt.BlankCursor)
-            if self.brush_cursor:
-                self.brush_cursor.show()
+            self.show_brush_cursor()
         if event.button() == Qt.LeftButton:
             if self.scrolling:
                 self.scrolling = False