shinestacker 1.5.1__tar.gz → 1.5.3__tar.gz

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

@@ -2,11 +2,35 @@
 
 This page reports the main releases only and the main changes therein.
 
-## [V1.5.1] - 2025-09-20
+## [v1.5.3] - 2025-09-21
+**Bug fixes**
+
+### Fixed
+- fixed brush preview visiblity in cursor style transitions
+- fixed relative import in main app scripts
+
+### Changed
+- implemenrted cursor dynamic color based on background image luminosity
+
+---
+
+## [v1.5.2] - 2025-09-21
+**Bug fixes**
+
+### Fixed
+- fixed white balance filter functionality
+- fixed brush preview visiblity in view mode transitions
+
+### Changed
+- code refactoring and cleanup
+
+---
+
+## [v1.5.1] - 2025-09-20
 **Several bug fixes**
 
 ### Added
-- new command-line parameters -v1, -v2, -v3, allow different view modes at startup
+- new command-line arguments -v1, -v2, -v3, allow different view modes at startup
 
 ### Fixed
 - consistent and restyled cursor for current layer view

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

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

shinestacker-1.5.3/src/shinestacker/_version.py

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

{shinestacker-1.5.1 → shinestacker-1.5.3}/src/shinestacker/app/main.py

@@ -20,7 +20,7 @@ from shinestacker.app.gui_utils import (
     disable_macos_special_menu_items, fill_app_menu, set_css_style)
 from shinestacker.app.help_menu import add_help_action
 from shinestacker.app.open_frames import open_frames
-from .args import add_project_arguments, add_retouch_arguments
+from shinestacker.app.args_parser_opts import add_project_arguments, add_retouch_arguments
 
 
 class SelectionDialog(QDialog):

{shinestacker-1.5.1 → shinestacker-1.5.3}/src/shinestacker/app/project.py

@@ -17,7 +17,7 @@ from shinestacker.gui.main_window import MainWindow
 from shinestacker.app.gui_utils import (
     disable_macos_special_menu_items, fill_app_menu, set_css_style)
 from shinestacker.app.help_menu import add_help_action
-from .args import add_project_arguments
+from shinestacker.app.args_parser_opts import add_project_arguments
 
 
 class ProjectApp(MainWindow):

{shinestacker-1.5.1 → shinestacker-1.5.3}/src/shinestacker/app/retouch.py

@@ -13,7 +13,7 @@ from shinestacker.app.gui_utils import (
     disable_macos_special_menu_items, fill_app_menu, set_css_style)
 from shinestacker.app.help_menu import add_help_action
 from shinestacker.app.open_frames import open_frames
-from .args import add_retouch_arguments
+from shinestacker.app.args_parser_opts import add_retouch_arguments
 
 
 class RetouchApp(ImageEditorUI):

{shinestacker-1.5.1 → shinestacker-1.5.3}/src/shinestacker/config/gui_constants.py

@@ -26,7 +26,7 @@ class _GuiConstants:
         'outer': (255, 0, 0, 200),
         'inner': (255, 0, 0, 150),
         'gradient_end': (255, 0, 0, 0),
-        'pen': (255, 0, 0, 200),
+        'pen': (255, 255, 255, 200),
         'preview': (255, 180, 180),
         'cursor_inner': (255, 0, 0, 120),
         'preview_inner': (255, 255, 255, 150)

{shinestacker-1.5.1 → shinestacker-1.5.3}/src/shinestacker/retouch/base_filter.py

@@ -1,16 +1,25 @@
 # pylint: disable=C0114, C0115, C0116, E0611, W0718, R0915, R0903, R0913, R0917, R0902, R0914
 import traceback
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 import numpy as np
+from PySide6.QtCore import Qt, QThread, QTimer, QObject, Signal
 from PySide6.QtWidgets import (
     QHBoxLayout, QLabel, QSlider, QDialog, QVBoxLayout, QCheckBox, QDialogButtonBox)
-from PySide6.QtCore import Qt, Signal, QThread, QTimer
+from .layer_collection import LayerCollectionHandler
 
 
-class BaseFilter(ABC):
-    def __init__(self, name, editor, allow_partial_preview=True,
+class BaseFilter(QObject, LayerCollectionHandler):
+    update_master_thumbnail_requested = Signal()
+    mark_as_modified_requested = Signal()
+    filter_gui_set_enabled_requested = Signal(bool)
+
+    def __init__(self, name, parent, image_viewer, layer_collection, undo_manager,
+                 allow_partial_preview=True,
                  partial_preview_threshold=0.75, preview_at_startup=False):
-        self.editor = editor
+        QObject.__init__(self, parent)
+        LayerCollectionHandler.__init__(self, layer_collection)
+        self.image_viewer = image_viewer
+        self.undo_manager = undo_manager
         self.name = name
         self.allow_partial_preview = allow_partial_preview
         self.partial_preview_threshold = partial_preview_threshold
@@ -31,11 +40,16 @@ class BaseFilter(ABC):
     def apply(self, image, *params):
         pass
 
+    def connect_signals(self, update_master_thumbnail, mark_as_modified, filter_gui_set_enabled):
+        self.update_master_thumbnail_requested.connect(update_master_thumbnail)
+        self.mark_as_modified_requested.connect(mark_as_modified)
+        self.filter_gui_set_enabled_requested.connect(filter_gui_set_enabled)
+
     def run_with_preview(self, **kwargs):
-        if self.editor.has_no_master_layer():
+        if self.has_no_master_layer():
             return
-        self.editor.copy_master_layer()
-        dlg = QDialog(self.editor)
+        self.copy_master_layer()
+        dlg = QDialog(self.parent())
         layout = QVBoxLayout(dlg)
         active_worker = None
         last_request_id = 0
@@ -46,8 +60,8 @@ class BaseFilter(ABC):
         def cleanup():
             nonlocal active_worker, dialog_closed  # noqa
             dialog_closed = True
-            self.editor.restore_master_layer()
-            self.editor.image_viewer.update_master_display()
+            self.restore_master_layer()
+            self.image_viewer.update_master_display()
             if active_worker and active_worker.isRunning():
                 active_worker.wait()
             initial_timer.stop()
@@ -58,13 +72,13 @@ class BaseFilter(ABC):
             if dialog_closed or request_id != expected_id:
                 return
             if region:
-                current_region = self.editor.image_viewer.get_visible_image_portion()[1]
+                current_region = self.image_viewer.get_visible_image_portion()[1]
                 if current_region == region:
-                    self.editor.set_master_layer(img)
-                    self.editor.image_viewer.update_master_display()
+                    self.set_master_layer(img)
+                    self.image_viewer.update_master_display()
             else:
-                self.editor.set_master_layer(img)
-                self.editor.image_viewer.update_master_display()
+                self.set_master_layer(img)
+                self.image_viewer.update_master_display()
             try:
                 dlg.activateWindow()
             except Exception:
@@ -84,10 +98,10 @@ class BaseFilter(ABC):
             current_id = last_request_id
             visible_region = None
             if kwargs.get('partial_preview', self.allow_partial_preview):
-                visible_data = self.editor.image_viewer.get_visible_image_portion()
+                visible_data = self.image_viewer.get_visible_image_portion()
                 if visible_data:
                     visible_img, visible_region = visible_data
-                    master_img = self.editor.master_layer_copy()
+                    master_img = self.master_layer_copy()
                     if visible_img.size < master_img.size * self.partial_preview_threshold:
                         params = tuple(self.get_params() or ())
                         worker = self.PreviewWorker(
@@ -107,14 +121,14 @@ class BaseFilter(ABC):
                     params = tuple(self.get_params() or ())
                     worker = self.PreviewWorker(
                         self.apply,
-                        args=(self.editor.master_layer_copy(), *params),
+                        args=(self.master_layer_copy(), *params),
                         request_id=current_id
                     )
             else:
                 params = tuple(self.get_params() or ())
                 worker = self.PreviewWorker(
                     self.apply,
-                    args=(self.editor.master_layer_copy(), *params),
+                    args=(self.master_layer_copy(), *params),
                     request_id=current_id
                 )
             active_worker = worker
@@ -123,8 +137,8 @@ class BaseFilter(ABC):
             active_worker.start()
 
         def restore_original():
-            self.editor.restore_master_layer()
-            self.editor.image_viewer.update_master_display()
+            self.restore_master_layer()
+            self.image_viewer.update_master_display()
             try:
                 dlg.activateWindow()
             except Exception:
@@ -139,26 +153,34 @@ class BaseFilter(ABC):
         if accepted:
             params = tuple(self.get_params() or ())
             try:
-                h, w = self.editor.master_layer().shape[:2]
+                h, w = self.master_layer().shape[:2]
             except Exception:
-                h, w = self.editor.master_layer_copy().shape[:2]
+                h, w = self.master_layer_copy().shape[:2]
             try:
-                self.editor.undo_manager.extend_undo_area(0, 0, w, h)
-                self.editor.undo_manager.save_undo_state(
-                    self.editor.master_layer_copy(),
+                self.undo_manager.extend_undo_area(0, 0, w, h)
+                self.undo_manager.save_undo_state(
+                    self.master_layer_copy(),
                     self.name
                 )
             except Exception:
                 pass
-            final_img = self.apply(self.editor.master_layer_copy(), *params)
-            self.editor.set_master_layer(final_img)
-            self.editor.copy_master_layer()
-            self.editor.image_viewer.update_master_display()
-            self.editor.display_manager.update_master_thumbnail()
-            self.editor.mark_as_modified()
+            final_img = self.apply(self.master_layer_copy(), *params)
+            self.set_master_layer(final_img)
+            self.copy_master_layer()
+            self.image_viewer.update_master_display()
+            self.update_master_thumbnail_requested.emit()
+            self.mark_as_modified_requested.emit()
         else:
             restore_original()
 
+    def connect_preview_toggle(self, preview_check, do_preview, restore_original):
+        def on_toggled(checked):
+            if checked:
+                do_preview()
+            else:
+                restore_original()
+        preview_check.toggled.connect(on_toggled)
+
     def create_base_widgets(self, layout, buttons, preview_latency, parent):
         self.preview_check = QCheckBox("Preview")
         self.preview_check.setChecked(self.preview_at_startup)
@@ -199,10 +221,12 @@ class BaseFilter(ABC):
 
 
 class OneSliderBaseFilter(BaseFilter):
-    def __init__(self, name, editor, max_value, initial_value, title,
+    def __init__(self, name, parent, image_viewer, layer_collection, undo_manager,
+                 max_value, initial_value, title,
                  allow_partial_preview=True, partial_preview_threshold=0.5,
                  preview_at_startup=True):
-        super().__init__(name, editor, allow_partial_preview,
+        super().__init__(name, parent, image_viewer, layer_collection, undo_manager,
+                         allow_partial_preview,
                          partial_preview_threshold, preview_at_startup)
         self.max_range = 500
         self.max_value = max_value
@@ -234,7 +258,7 @@ class OneSliderBaseFilter(BaseFilter):
         self.preview_timer.timeout.connect(do_preview)
 
         slider_local.valueChanged.connect(self.config_changed)
-        self.editor.connect_preview_toggle(
+        self.connect_preview_toggle(
             self.preview_check, self.do_preview_delayed, restore_original)
         self.button_box.accepted.connect(dlg.accept)
         self.button_box.rejected.connect(dlg.reject)

{shinestacker-1.5.1 → shinestacker-1.5.3}/src/shinestacker/retouch/denoise_filter.py

@@ -1,11 +1,12 @@
-# pylint: disable=C0114, C0115, C0116, E0611, W0221
+# pylint: disable=C0114, C0115, C0116, E0611, W0221, R0913, R0917
 from .base_filter import OneSliderBaseFilter
 from .. algorithms.denoise import denoise
 
 
 class DenoiseFilter(OneSliderBaseFilter):
-    def __init__(self, name, editor):
-        super().__init__(name, editor, 10.0, 2.5, "Denoise",
+    def __init__(self, name, parent, image_viewer, layer_collection, undo_manager):
+        super().__init__(name, parent, image_viewer, layer_collection, undo_manager,
+                         10.0, 2.5, "Denoise",
                          allow_partial_preview=True, preview_at_startup=False)
 
     def apply(self, image, strength):

{shinestacker-1.5.1 → shinestacker-1.5.3}/src/shinestacker/retouch/display_manager.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0903, R0913, R0917, E1121, R0902
+# pylint: disable=C0114, C0115, C0116, E0611, R0903, R0913, R0917, E1121, R0902, R0914
 import numpy as np
 from PySide6.QtWidgets import (QWidget, QListWidgetItem, QVBoxLayout, QLabel, QInputDialog,
                                QAbstractItemView)
@@ -38,7 +38,6 @@ class DisplayManager(QObject, LayerCollectionHandler):
         self.update_timer = QTimer()
         self.update_timer.setInterval(gui_constants.PAINT_REFRESH_TIMER)
         self.update_timer.timeout.connect(self.process_pending_updates)
-        self.thumbnail_highlight = gui_constants.THUMB_LO_COLOR
 
     def process_pending_updates(self):
         if self.needs_update:
@@ -110,14 +109,15 @@ class DisplayManager(QObject, LayerCollectionHandler):
                 self.thumbnail_list, "Rename Label", "New label name:", text=old_label)
             if ok and new_label and new_label != old_label:
                 label_widget.setText(new_label)
-                self.set_layer_labels(i, new_label)
+                self.set_layer_label(i, new_label)
+                self.status_message_requested.emit("Label renamed.")
 
         label_widget.double_clicked.connect(lambda: rename_label(label_widget, label, i))
         content_layout.addWidget(label_widget)
         container_layout.addWidget(content_widget)
         if is_current:
             container.setStyleSheet(
-                f"#thumbnailContainer{{ border: 2px solid {self.thumbnail_highlight}; }}")
+                f"#thumbnailContainer{{ border: 2px solid {gui_constants.THUMB_HI_COLOR}; }}")
         else:
             container.setStyleSheet("#thumbnailContainer{ border: 2px solid transparent; }")
         item = QListWidgetItem()
@@ -128,7 +128,7 @@ class DisplayManager(QObject, LayerCollectionHandler):
         if is_current:
             self.thumbnail_list.setCurrentItem(item)
 
-    def highlight_thumbnail(self, index):
+    def highlight_thumbnail(self, index, color=gui_constants.THUMB_HI_COLOR):
         for i in range(self.thumbnail_list.count()):
             item = self.thumbnail_list.item(i)
             widget = self.thumbnail_list.itemWidget(item)
@@ -139,7 +139,7 @@ class DisplayManager(QObject, LayerCollectionHandler):
             widget = self.thumbnail_list.itemWidget(current_item)
             if widget:
                 widget.setStyleSheet(
-                    f"#thumbnailContainer{{ border: 2px solid {self.thumbnail_highlight}; }}")
+                    f"#thumbnailContainer{{ border: 2px solid {color}; }}")
         self.thumbnail_list.setCurrentRow(index)
         self.thumbnail_list.scrollToItem(
             self.thumbnail_list.item(index), QAbstractItemView.PositionAtCenter)
@@ -147,28 +147,26 @@ class DisplayManager(QObject, LayerCollectionHandler):
     def _master_refresh_and_thumb(self):
         self.image_viewer.show_master()
         self.refresh_master_view()
-        self.thumbnail_highlight = gui_constants.THUMB_LO_COLOR
-        self.highlight_thumbnail(self.current_layer_idx())
+        self.highlight_thumbnail(self.current_layer_idx(), gui_constants.THUMB_LO_COLOR)
 
     def _current_refresh_and_thumb(self):
         self.image_viewer.show_current()
         self.refresh_current_view()
-        self.thumbnail_highlight = gui_constants.THUMB_HI_COLOR
-        self.highlight_thumbnail(self.current_layer_idx())
+        self.highlight_thumbnail(self.current_layer_idx(), gui_constants.THUMB_HI_COLOR)
 
     def set_view_master(self):
         if self.has_no_master_layer():
             return
         self.view_mode = 'master'
         self._master_refresh_and_thumb()
-        self.status_message_requested.emit("View mode: Master")
+        self.status_message_requested.emit("View: Master.")
 
     def set_view_individual(self):
         if self.has_no_master_layer():
             return
         self.view_mode = 'individual'
         self._current_refresh_and_thumb()
-        self.status_message_requested.emit("View mode: Individual layers")
+        self.status_message_requested.emit("View: Individual layers.")
 
     def refresh_master_view(self):
         if self.has_no_master_layer():
@@ -186,19 +184,16 @@ class DisplayManager(QObject, LayerCollectionHandler):
     def start_temp_view(self):
         if self.view_mode == 'master':
             self._current_refresh_and_thumb()
-            self.status_message_requested.emit("Temporary view: Individual layer")
+            self.status_message_requested.emit("Temporary view: Individual layer.")
         else:
             self._master_refresh_and_thumb()
             self.image_viewer.strategy.brush_preview.hide()
-            self.status_message_requested.emit("Temporary view: Master")
+            self.status_message_requested.emit("Temporary view: Master.")
 
     def end_temp_view(self):
         if self.view_mode == 'master':
             self._master_refresh_and_thumb()
-            self.status_message_requested.emit("View mode: Master")
+            self.status_message_requested.emit("View mode: Master.")
         else:
             self._current_refresh_and_thumb()
-            self.status_message_requested.emit("View: Individual layer")
-
-    def allow_cursor_preview(self):
-        return self.view_mode == 'master'
+            self.status_message_requested.emit("View: Individual layer.")

shinestacker-1.5.3/src/shinestacker/retouch/filter_manager.py

@@ -0,0 +1,20 @@
+# pylint: disable=C0114, C0115, C0116, R0913, R0917
+class FilterManager:
+    def __init__(self, editor):
+        self.editor = editor
+        self.image_viewer = editor.image_viewer
+        self.layer_collection = editor.layer_collection
+        self.undo_manager = editor.undo_manager
+        self.filters = {}
+
+    def register_filter(self, name, filter_class,
+                        update_master_thumbnail, mark_as_modified, filter_gui_set_enabled):
+        filter_obj = filter_class(
+            name, self.editor, self.image_viewer, self.layer_collection, self.undo_manager)
+        self.filters[name] = filter_obj
+        filter_obj.connect_signals(
+            update_master_thumbnail, mark_as_modified, filter_gui_set_enabled)
+
+    def apply(self, name, **kwargs):
+        if name in self.filters:
+            self.filters[name].run_with_preview(**kwargs)

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

@@ -1,6 +1,5 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0902, R0914, R0915, R0904, W0108
 from functools import partial
-import numpy as np
 from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QFrame, QLabel, QMenu,
                                QListWidget, QSlider, QMainWindow, QMessageBox)
 from PySide6.QtGui import QShortcut, QKeySequence, QAction, QActionGroup
@@ -31,9 +30,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         QMainWindow.__init__(self)
         LayerCollectionHandler.__init__(self, LayerCollection())
         self._recent_file_manager = RecentFileManager("shinestacker-recent-images-files.txt")
-        self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
         self.io_gui_handler = None
-        self.display_manager = None
         self.brush = Brush()
         self.brush_tool = BrushTool()
         self.modified = False
@@ -43,11 +40,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.undo_action = None
         self.redo_action = None
         self.undo_manager.stack_changed.connect(self.update_undo_redo_actions)
-        self.filter_manager = FilterManager(self)
-        self.filter_manager.register_filter("Denoise", DenoiseFilter)
-        self.filter_manager.register_filter("Unsharp Mask", UnsharpMaskFilter)
-        self.filter_manager.register_filter("White Balance", WhiteBalanceFilter)
-        self.filter_manager.register_filter("Vignetting Correction", VignettingFilter)
         self.shortcuts_help_dialog = None
         self.update_title()
         self.resize(1400, 900)
@@ -144,7 +136,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.master_thumbnail_frame = QFrame()
         self.master_thumbnail_frame.setObjectName("thumbnailContainer")
         self.master_thumbnail_frame.setStyleSheet(
-            f"#thumbnailContainer{{ border: 2px solid {self.thumbnail_highlight}; }}")
+            f"#thumbnailContainer{{ border: 2px solid {gui_constants.THUMB_MASTER_HI_COLOR}; }}")
         self.master_thumbnail_frame.setFrameShape(QFrame.StyledPanel)
         master_thumbnail_layout = QVBoxLayout(self.master_thumbnail_frame)
         master_thumbnail_layout.setContentsMargins(8, 8, 8, 8)
@@ -229,6 +221,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.display_manager = DisplayManager(
             self.layer_collection, self.image_viewer,
             self.master_thumbnail_label, self.thumbnail_list, parent=self)
+        self.filter_manager = FilterManager(self)
         self.io_gui_handler = IOGuiHandler(self.layer_collection, self.undo_manager, parent=self)
         self.display_manager.status_message_requested.connect(self.show_status_message)
         self.io_gui_handler.status_message_requested.connect(self.show_status_message)
@@ -243,8 +236,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.image_viewer.set_preview_brush(self.brush_tool.brush)
         self.brush_tool.update_brush_thumb()
         self.io_gui_handler.setup_ui(self.display_manager, self.image_viewer)
-        self.image_viewer.set_display_manager(self.display_manager)
-
         menubar = self.menuBar()
         file_menu = menubar.addMenu("&File")
         file_menu.addAction("&Open...", self.io_gui_handler.open_file, "Ctrl+O")
@@ -313,7 +304,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
         view_menu.addSeparator()
 
-        view_strategy_menu = QMenu("View &Mode", view_menu)
+        self.view_strategy_menu = QMenu("View &Mode", view_menu)
 
         self.view_mode_actions = {
             'overlaid': QAction("Overlaid", self),
@@ -324,18 +315,32 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         overlaid_mode.setShortcut("Ctrl+1")
         overlaid_mode.setCheckable(True)
         overlaid_mode.triggered.connect(lambda: self.set_strategy('overlaid'))
-        view_strategy_menu.addAction(overlaid_mode)
+        self.view_strategy_menu.addAction(overlaid_mode)
         side_by_side_mode = self.view_mode_actions['sidebyside']
         side_by_side_mode.setShortcut("Ctrl+2")
         side_by_side_mode.setCheckable(True)
         side_by_side_mode.triggered.connect(lambda: self.set_strategy('sidebyside'))
-        view_strategy_menu.addAction(side_by_side_mode)
+        self.view_strategy_menu.addAction(side_by_side_mode)
         side_by_side_mode = self.view_mode_actions['topbottom']
         side_by_side_mode.setShortcut("Ctrl+3")
         side_by_side_mode.setCheckable(True)
         side_by_side_mode.triggered.connect(lambda: self.set_strategy('topbottom'))
-        view_strategy_menu.addAction(side_by_side_mode)
-        view_menu.addMenu(view_strategy_menu)
+        self.view_strategy_menu.addAction(side_by_side_mode)
+        view_menu.addMenu(self.view_strategy_menu)
+
+        filter_handles = (
+            self.display_manager.update_master_thumbnail,
+            self.mark_as_modified,
+            self.view_strategy_menu.setEnabled
+        )
+        self.filter_manager.register_filter(
+            "Denoise", DenoiseFilter, *filter_handles)
+        self.filter_manager.register_filter(
+            "Unsharp Mask", UnsharpMaskFilter, *filter_handles)
+        self.filter_manager.register_filter(
+            "White Balance", WhiteBalanceFilter, *filter_handles)
+        self.filter_manager.register_filter(
+            "Vignetting Correction", VignettingFilter, *filter_handles)
 
         cursor_menu = view_menu.addMenu("Cursor Style")
 
@@ -462,6 +467,8 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
     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)
@@ -584,7 +591,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
     def copy_brush_area_to_master(self, view_pos):
         if self.layer_stack() is None or self.number_of_layers() == 0 \
-           or not self.display_manager.allow_cursor_preview():
+           or self.display_manager.view_mode != 'master':
             return
         area = self.brush_tool.apply_brush_operation(
             self.master_layer_copy(),
@@ -594,7 +601,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.undo_manager.extend_undo_area(*area)
 
     def begin_copy_brush_area(self, pos):
-        if self.display_manager.allow_cursor_preview():
+        if self.display_manager.view_mode == 'master':
             self.mask_layer = self.io_gui_handler.blank_layer.copy()
             self.copy_master_layer()
             self.undo_manager.reset_undo_area()
@@ -605,7 +612,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             self.mark_as_modified()
 
     def continue_copy_brush_area(self, pos):
-        if self.display_manager.allow_cursor_preview():
+        if self.display_manager.view_mode == 'master':
             self.copy_brush_area_to_master(pos)
             self.display_manager.needs_update = True
             if not self.display_manager.update_timer.isActive():
@@ -647,53 +654,9 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
     def vignetting_correction(self):
         self.filter_manager.apply("Vignetting Correction")
 
-    def connect_preview_toggle(self, preview_check, do_preview, restore_original):
-        def on_toggled(checked):
-            if checked:
-                do_preview()
-            else:
-                restore_original()
-        preview_check.toggled.connect(on_toggled)
-
-    def get_pixel_color_at(self, pos, radius=None):
-        item_pos = self.image_viewer.position_on_image(pos)
-        x = int(item_pos.x())
-        y = int(item_pos.y())
-        master_layer = self.master_layer()
-        if (0 <= x < self.master_layer().shape[1]) and \
-           (0 <= y < self.master_layer().shape[0]):
-            if radius is None:
-                radius = int(self.brush.size)
-            if radius > 0:
-                y_indices, x_indices = np.ogrid[-radius:radius + 1, -radius:radius + 1]
-                mask = x_indices**2 + y_indices**2 <= radius**2
-                x0 = max(0, x - radius)
-                x1 = min(master_layer.shape[1], x + radius + 1)
-                y0 = max(0, y - radius)
-                y1 = min(master_layer.shape[0], y + radius + 1)
-                mask = mask[radius - (y - y0): radius + (y1 - y),
-                            radius - (x - x0): radius + (x1 - x)]
-                region = master_layer[y0:y1, x0:x1]
-                if region.size == 0:
-                    pixel = master_layer[y, x]
-                else:
-                    if region.ndim == 3:
-                        pixel = [region[:, :, c][mask].mean() for c in range(region.shape[2])]
-                    else:
-                        pixel = region[mask].mean()
-            else:
-                pixel = self.master_layer()[y, x]
-            if np.isscalar(pixel):
-                pixel = [pixel, pixel, pixel]
-            pixel = [np.float32(x) for x in pixel]
-            if master_layer.dtype == np.uint16:
-                pixel = [x / 256.0 for x in pixel]
-            return tuple(int(v) for v in pixel)
-        return (0, 0, 0)
-
-    def highlight_master_thumbnail(self):
+    def highlight_master_thumbnail(self, color):
         self.master_thumbnail_frame.setStyleSheet(
-            f"#thumbnailContainer{{ border: 2px solid {self.thumbnail_highlight}; }}")
+            f"#thumbnailContainer{{ border: 2px solid {color}; }}")
 
     def save_actions_set_enabled(self, enabled):
         self.save_action.setEnabled(enabled)
@@ -709,13 +672,11 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
     def set_view_master(self):
         self.display_manager.set_view_master()
-        self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
-        self.highlight_master_thumbnail()
+        self.highlight_master_thumbnail(gui_constants.THUMB_MASTER_HI_COLOR)
 
     def set_view_individual(self):
         self.display_manager.set_view_individual()
-        self.thumbnail_highlight = gui_constants.THUMB_MASTER_LO_COLOR
-        self.highlight_master_thumbnail()
+        self.highlight_master_thumbnail(gui_constants.THUMB_MASTER_LO_COLOR)
 
     def toggle_view_master_individual(self):
         if self.display_manager.view_mode == 'master':
@@ -750,12 +711,10 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
     def handle_temp_view(self, start):
         if start:
             self.display_manager.start_temp_view()
-            self.thumbnail_highlight = gui_constants.THUMB_MASTER_LO_COLOR
-            self.highlight_master_thumbnail()
+            self.highlight_master_thumbnail(gui_constants.THUMB_MASTER_LO_COLOR)
         else:
             self.display_manager.end_temp_view()
-            self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
-            self.highlight_master_thumbnail()
+            self.highlight_master_thumbnail(gui_constants.THUMB_MASTER_HI_COLOR)
 
     def handle_brush_size_change(self, delta):
         if delta > 0: