shinestacker 1.5.3__tar.gz → 1.5.4__tar.gz

{shinestacker-1.5.3 → shinestacker-1.5.4}/CHANGELOG.md

@@ -2,11 +2,25 @@
 
 This page reports the main releases only and the main changes therein.
 
+## [v1.5.4] - 2025-09-23
+**Bug fixes**
+
+### Fixed
+- fixed functionality of layer alphabetic sorting
+- fixed image centering in zoom operations
+- fixed color picker reuse in white-balance filter
+- minor fixes and code cleanup
+
+### Changed
+- menu actions that require a file are disabled when no file is open 
+
+----
+
 ## [v1.5.3] - 2025-09-21
 **Bug fixes**
 
 ### Fixed
-- fixed brush preview visiblity in cursor style transitions
+- fixed a critical bug that caused crash at startup in distrubution package due to a relative import in main app scripts
 - fixed relative import in main app scripts
 
 ### Changed
@@ -14,7 +28,7 @@ This page reports the main releases only and the main changes therein.
 
 ---
 
-## [v1.5.2] - 2025-09-21
+## [v1.5.2] - 2025-09-21 (⚠️ DEPRECATED — use 1.5.3)
 **Bug fixes**
 
 ### Fixed
@@ -26,7 +40,7 @@ This page reports the main releases only and the main changes therein.
 
 ---
 
-## [v1.5.1] - 2025-09-20
+## [v1.5.1] - 2025-09-20 (⚠️ DEPRECATED — use 1.5.3)
 **Several bug fixes**
 
 ### Added

{shinestacker-1.5.3/src/shinestacker.egg-info → shinestacker-1.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 1.5.3
+Version: 1.5.4
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0

{shinestacker-1.5.3 → shinestacker-1.5.4}/requirements.txt

@@ -1,5 +1,4 @@
 matplotlib
-matplotlib
 imagecodecs
 jsonpickle
 numpy

shinestacker-1.5.4/src/shinestacker/_version.py

@@ -0,0 +1 @@
+__version__ = '1.5.4'

{shinestacker-1.5.3 → shinestacker-1.5.4}/src/shinestacker/gui/main_window.py

@@ -154,9 +154,14 @@ class MainWindow(QMainWindow, LogManager):
             self.menu_manager.set_enabled_sub_actions_gui)
         self.project_controller.add_recent_file_requested.connect(
             self.menu_manager.add_recent_file)
+        self.project_controller.set_enabled_file_open_close_actions_requested.connect(
+            self.set_enabled_file_open_close_actions)
+
         self.menu_manager.open_file_requested.connect(
             self.project_controller.open_project)
 
+        self.set_enabled_file_open_close_actions(False)
+
     def modified(self):
         return self.project_editor.modified()
 
@@ -571,3 +576,8 @@ class MainWindow(QMainWindow, LogManager):
                 self.menu_manager.set_enabled_sub_actions_gui(enable_sub_actions)
         else:
             self.menu_manager.set_enabled_sub_actions_gui(False)
+
+    def set_enabled_file_open_close_actions(self, enabled):
+        for action in self.findChildren(QAction):
+            if action.property("requires_file"):
+                action.setEnabled(enabled)

{shinestacker-1.5.3 → shinestacker-1.5.4}/src/shinestacker/gui/menu_manager.py

@@ -60,8 +60,10 @@ class MenuManager(QObject):
     def get_icon(self, icon):
         return QIcon(os.path.join(self.script_dir, f"img/{icon}.png"))
 
-    def action(self, name):
+    def action(self, name, requires_file=False):
         action = QAction(name, self.parent)
+        if requires_file:
+            action.setProperty("requires_file", True)
         shortcut = self.shortcuts.get(name, '')
         if shortcut:
             action.setShortcut(shortcut)
@@ -110,20 +112,20 @@ class MenuManager(QObject):
         self.undo_action.setEnabled(False)
         menu.addAction(self.undo_action)
         for name in ["&Cut", "Cop&y", "&Paste", "Duplicate"]:
-            menu.addAction(self.action(name))
-        self.delete_element_action = self.action("Delete")
+            menu.addAction(self.action(name, requires_file=True))
+        self.delete_element_action = self.action("Delete", requires_file=True)
         self.delete_element_action.setEnabled(False)
         menu.addAction(self.delete_element_action)
         menu.addSeparator()
         for name in ["Move &Up", "Move &Down"]:
-            menu.addAction(self.action(name))
+            menu.addAction(self.action(name, requires_file=True))
         menu.addSeparator()
-        self.enable_action = self.action("E&nable")
+        self.enable_action = self.action("E&nable", requires_file=True)
         menu.addAction(self.enable_action)
-        self.disable_action = self.action("Di&sable")
+        self.disable_action = self.action("Di&sable", requires_file=True)
         menu.addAction(self.disable_action)
         for name in ["Enable All", "Disable All"]:
-            menu.addAction(self.action(name))
+            menu.addAction(self.action(name, requires_file=True))
 
     def add_view_menu(self):
         menu = self.menubar.addMenu("&View")
@@ -133,13 +135,13 @@ class MenuManager(QObject):
 
     def add_job_menu(self):
         menu = self.menubar.addMenu("&Jobs")
-        self.add_job_action = self.action("Add Job")
+        self.add_job_action = self.action("Add Job", requires_file=True)
         menu.addAction(self.add_job_action)
         menu.addSeparator()
-        self.run_job_action = self.action("Run Job")
+        self.run_job_action = self.action("Run Job", requires_file=True)
         self.run_job_action.setEnabled(False)
         menu.addAction(self.run_job_action)
-        self.run_all_jobs_action = self.action("Run All Jobs")
+        self.run_all_jobs_action = self.action("Run All Jobs", requires_file=True)
         self.set_enabled_run_all_jobs(False)
         menu.addAction(self.run_all_jobs_action)
 
@@ -148,6 +150,7 @@ class MenuManager(QObject):
         add_action_menu = QMenu("Add Action", self.parent)
         for action in constants.ACTION_TYPES:
             entry_action = QAction(action, self.parent)
+            entry_action.setProperty("requires_file", True)
             entry_action.triggered.connect({
                 constants.ACTION_COMBO: self.add_action_combined_actions,
                 constants.ACTION_NOISEDETECTION: self.add_action_noise_detection,
@@ -161,6 +164,7 @@ class MenuManager(QObject):
         self.sub_action_menu_entries = []
         for action in constants.SUB_ACTION_TYPES:
             entry_action = QAction(action, self.parent)
+            entry_action.setProperty("requires_file", True)
             entry_action.triggered.connect({
                 constants.ACTION_MASKNOISE: self.add_sub_action_make_noise,
                 constants.ACTION_VIGNETTING: self.add_sub_action_vignetting,

{shinestacker-1.5.3 → shinestacker-1.5.4}/src/shinestacker/gui/project_controller.py

@@ -21,6 +21,7 @@ class ProjectController(QObject):
     enable_save_actions_requested = Signal(bool)
     enable_sub_actions_requested = Signal(bool)
     add_recent_file_requested = Signal(str)
+    set_enabled_file_open_close_actions_requested = Signal(bool)
 
     def __init__(self, parent):
         super().__init__(parent)
@@ -138,6 +139,7 @@ class ProjectController(QObject):
             self.clear_action_list()
             self.mark_as_modified(False)
             self.project_editor.reset_undo()
+            self.set_enabled_file_open_close_actions_requested.emit(False)
 
     def new_project(self):
         if not self.check_unsaved_changes():
@@ -250,6 +252,7 @@ class ProjectController(QObject):
                 project = Project.from_dict(json_obj['project'])
                 if project is None:
                     raise RuntimeError(f"Project from file {file_path} produced a null project.")
+                self.set_enabled_file_open_close_actions_requested.emit(True)
                 self.set_project(project)
                 self.mark_as_modified(False)
                 self.add_recent_file_requested.emit(abs_file_path)

{shinestacker-1.5.3 → shinestacker-1.5.4}/src/shinestacker/retouch/image_editor_ui.py

@@ -229,6 +229,8 @@ 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)
@@ -277,22 +279,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 +357,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,37 +391,44 @@ 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)
@@ -421,11 +437,13 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.set_strategy('overlaid')
 
         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 +451,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)
 
@@ -462,20 +484,29 @@ 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 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 +575,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():

{shinestacker-1.5.3 → shinestacker-1.5.4}/src/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-1.5.3 → shinestacker-1.5.4}/src/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-1.5.3 → shinestacker-1.5.4}/src/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
 
 
@@ -229,25 +230,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)
@@ -383,14 +379,7 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         pixmap = self.status.pixmap_master
         self.master_view.setSceneRect(QRectF(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)
@@ -439,8 +428,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()