shinestacker 1.5.4__py3-none-any.whl → 1.6.1__py3-none-any.whl

shinestacker/gui/action_config_dialog.py

@@ -2,87 +2,29 @@
 # pylint: disable=E0606, W0718, R1702, W0102, W0221, R0914, C0302
 import os
 import traceback
-from PySide6.QtCore import Qt, QTimer
-from PySide6.QtWidgets import (QWidget, QPushButton, QHBoxLayout, QLabel, QScrollArea, QMessageBox,
-                               QStackedWidget, QFormLayout, QDialog)
+from PySide6.QtCore import QTimer
+from PySide6.QtWidgets import QWidget, QLabel, QMessageBox, QStackedWidget
 from .. config.constants import constants
+from .. config.app_config import AppConfig
 from .. algorithms.align import validate_align_config
-from .base_form_dialog import create_form_layout
 from . action_config import (
     DefaultActionConfigurator,
     FIELD_TEXT, FIELD_ABS_PATH, FIELD_REL_PATH, FIELD_FLOAT,
     FIELD_INT, FIELD_INT_TUPLE, FIELD_BOOL, FIELD_COMBO, FIELD_REF_IDX
 )
 from .folder_file_selection import FolderFileSelectionWidget
+from .config_dialog import ConfigDialog
 
 
-class ActionConfigDialog(QDialog):
+class ActionConfigDialog(ConfigDialog):
     def __init__(self, action, current_wd, parent=None):
-        super().__init__(parent)
-        self.setWindowTitle(f"Configure {action.type_name}")
-        self.form_layout = create_form_layout(self)
-        self.current_wd = current_wd
         self.action = action
-        scroll_area = QScrollArea()
-        scroll_area.setWidgetResizable(True)
-        container_widget = QWidget()
-        self.container_layout = QFormLayout(container_widget)
-        self.container_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
-        self.container_layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
-        self.container_layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
-        self.container_layout.setLabelAlignment(Qt.AlignLeft)
-        self.configurator = self.get_configurator(action.type_name)
-        self.configurator.create_form(self.container_layout, action)
-        scroll_area.setWidget(container_widget)
-        button_box = QHBoxLayout()
-        ok_button = QPushButton("OK")
-        ok_button.setFocus()
-        cancel_button = QPushButton("Cancel")
-        reset_button = QPushButton("Reset")
-        button_box.addWidget(ok_button)
-        button_box.addWidget(cancel_button)
-        button_box.addWidget(reset_button)
-        reset_button.clicked.connect(self.reset_to_defaults)
-        self.form_layout.addRow(scroll_area)
-        self.form_layout.addRow(button_box)
-        QTimer.singleShot(0, self.adjust_dialog_size)
-        ok_button.clicked.connect(self.accept)
-        cancel_button.clicked.connect(self.reject)
-
-    def adjust_dialog_size(self):
-        screen_geometry = self.screen().availableGeometry()
-        screen_height = screen_geometry.height()
-        screen_width = screen_geometry.width()
-        scroll_area = self.findChild(QScrollArea)
-        container_widget = scroll_area.widget()
-        container_size = container_widget.sizeHint()
-        container_height = container_size.height()
-        container_width = container_size.width()
-        button_row_height = 50  # Approx height of button row
-        margins_height = 40  # Approx. height of margins
-        total_height_needed = container_height + button_row_height + margins_height
-        if total_height_needed < screen_height * 0.8:
-            width = max(container_width + 40, 600)
-            height = total_height_needed
-            self.resize(width, height)
-            scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
-        else:
-            max_height = int(screen_height * 0.9)
-            width = max(container_width + 40, 600)
-            width = min(width, int(screen_width * 0.9))
-            self.resize(width, max_height)
-            self.setMaximumHeight(max_height)
-            scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
-            self.setMinimumHeight(min(max_height, 500))
-            self.setMinimumWidth(width)
-        self.center_on_screen()
-
-    def center_on_screen(self):
-        screen_geometry = self.screen().availableGeometry()
-        center_point = screen_geometry.center()
-        frame_geometry = self.frameGeometry()
-        frame_geometry.moveCenter(center_point)
-        self.move(frame_geometry.topLeft())
+        self.current_wd = current_wd
+        super().__init__(f"Configure {action.type_name}", parent)
+
+    def create_form_content(self):
+        self.configurator = self.get_configurator(self.action.type_name)
+        self.configurator.create_form(self.container_layout, self.action)
 
     def get_configurator(self, action_type):
         configurators = {
@@ -102,7 +44,8 @@ class ActionConfigDialog(QDialog):
 
     def accept(self):
         if self.configurator.update_params(self.action.params):
-            self.parent().mark_as_modified(True, "Modify Configuration")
+            if hasattr(self.parent(), 'mark_as_modified'):
+                self.parent().mark_as_modified(True, "Modify Configuration")
             super().accept()
 
     def reset_to_defaults(self):
@@ -111,7 +54,7 @@ class ActionConfigDialog(QDialog):
             builder.reset_to_defaults()
 
     def expert(self):
-        return self.parent().expert_options
+        return AppConfig.get('expert_options')
 
 
 class JobConfigurator(DefaultActionConfigurator):
@@ -329,7 +272,7 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
         max_threads = self.add_field_to_layout(
             q_pyramid.layout(), 'pyramid_max_threads', FIELD_INT, 'Max num. of cores',
             expert=True,
-            required=False, default=constants.DEFAULT_PY_MAX_THREADS,
+            required=False, default=AppConfig.get('focus_stack_params')['max_threads'],
             min_val=1, max_val=64)
         tile_size = self.add_field_to_layout(
             q_pyramid.layout(), 'pyramid_tile_size', FIELD_INT, 'Tile size (px)',
@@ -490,7 +433,7 @@ class CombinedActionsConfigurator(DefaultActionConfigurator):
             default=True)
         self.add_field(
             'max_threads', FIELD_INT, 'Max num. of cores',
-            required=False, default=constants.DEFAULT_MAX_FWK_THREADS,
+            required=False, default=AppConfig.get('combined_actions_params')['max_threads'],
             expert=True,
             min_val=1, max_val=64)
         self.add_field(
@@ -757,7 +700,7 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
             min_val=1.0, max_val=64.0)
         max_threads = self.add_field_to_layout(
             layout, 'max_threads', FIELD_INT, 'Max num. of cores',
-            required=False, default=constants.DEFAULT_ALIGN_MAX_THREADS,
+            required=False, default=AppConfig.get('align_frames_params')['max_threads'],
             min_val=1, max_val=64)
         chunk_submit = self.add_field_to_layout(
             layout, 'chunk_submit', FIELD_BOOL, 'Submit in chunks',

shinestacker/gui/config_dialog.py

@@ -0,0 +1,78 @@
+# pylint: disable=C0114, C0115, C0116, E0611
+from abc import abstractmethod
+from PySide6.QtCore import Qt, QTimer
+from PySide6.QtWidgets import QWidget, QPushButton, QHBoxLayout, QScrollArea, QFormLayout, QDialog
+from .base_form_dialog import create_form_layout
+
+
+class ConfigDialog(QDialog):
+    def __init__(self, title, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle(title)
+        self.form_layout = create_form_layout(self)
+        scroll_area = QScrollArea()
+        scroll_area.setWidgetResizable(True)
+        container_widget = QWidget()
+        self.container_layout = QFormLayout(container_widget)
+        self.container_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
+        self.container_layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
+        self.container_layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.container_layout.setLabelAlignment(Qt.AlignLeft)
+        scroll_area.setWidget(container_widget)
+        button_box = QHBoxLayout()
+        self.ok_button = QPushButton("OK")
+        self.ok_button.setFocus()
+        self.cancel_button = QPushButton("Cancel")
+        self.reset_button = QPushButton("Reset")
+        button_box.addWidget(self.ok_button)
+        button_box.addWidget(self.cancel_button)
+        button_box.addWidget(self.reset_button)
+        self.reset_button.clicked.connect(self.reset_to_defaults)
+        self.ok_button.clicked.connect(self.accept)
+        self.cancel_button.clicked.connect(self.reject)
+        self.form_layout.addRow(scroll_area)
+        self.form_layout.addRow(button_box)
+        QTimer.singleShot(0, self.adjust_dialog_size)
+        self.create_form_content()
+
+    @abstractmethod
+    def create_form_content(self):
+        pass
+
+    def adjust_dialog_size(self):
+        screen_geometry = self.screen().availableGeometry()
+        screen_height = screen_geometry.height()
+        screen_width = screen_geometry.width()
+        scroll_area = self.findChild(QScrollArea)
+        container_widget = scroll_area.widget()
+        container_size = container_widget.sizeHint()
+        container_height = container_size.height()
+        container_width = container_size.width()
+        button_row_height = 50  # Approx height of button row
+        margins_height = 40  # Approx. height of margins
+        total_height_needed = container_height + button_row_height + margins_height
+        if total_height_needed < screen_height * 0.8:
+            width = max(container_width + 40, 600)
+            height = total_height_needed
+            self.resize(width, height)
+            scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        else:
+            max_height = int(screen_height * 0.9)
+            width = max(container_width + 40, 600)
+            width = min(width, int(screen_width * 0.9))
+            self.resize(width, max_height)
+            self.setMaximumHeight(max_height)
+            scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+            self.setMinimumHeight(min(max_height, 500))
+            self.setMinimumWidth(width)
+        self.center_on_screen()
+
+    def center_on_screen(self):
+        screen_geometry = self.screen().availableGeometry()
+        center_point = screen_geometry.center()
+        frame_geometry = self.frameGeometry()
+        frame_geometry.moveCenter(center_point)
+        self.move(frame_geometry.topLeft())
+
+    def reset_to_defaults(self):
+        pass

shinestacker/gui/main_window.py

@@ -7,6 +7,7 @@ from PySide6.QtGui import QGuiApplication, QAction, QIcon
 from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QLabel, QMessageBox,
                                QSplitter, QToolBar, QMenu, QMainWindow)
 from .. config.constants import constants
+from .. config.app_config import AppConfig
 from .. core.core_utils import running_under_windows, running_under_macos
 from .colors import ColorPalette
 from .project_model import Project
@@ -86,7 +87,6 @@ class MainWindow(QMainWindow, LogManager):
         self._windows = []
         self._workers = []
         self.retouch_callback = None
-        self.expert_options = False
         self.job_list().setStyleSheet(LIST_STYLE_SHEET)
         self.action_list().setStyleSheet(LIST_STYLE_SHEET)
         self.menu_manager.add_menus()
@@ -441,12 +441,12 @@ class MainWindow(QMainWindow, LogManager):
             return True
         return False
 
-    def toggle_expert_options(self):
-        self.expert_options = self.menu_manager.expert_options_action.isChecked()
+    def handle_config(self):
+        self.menu_manager.expert_options_action.setChecked(
+            AppConfig.get('expert_options'))
 
-    def set_expert_options(self):
-        self.menu_manager.expert_options_action.setChecked(True)
-        self.expert_options = True
+    def toggle_expert_options(self):
+        AppConfig.set('expert_options', self.menu_manager.expert_options_action.isChecked())
 
     def before_thread_begins(self):
         self.menu_manager.run_job_action.setEnabled(False)

shinestacker/gui/menu_manager.py

@@ -5,6 +5,7 @@ from PySide6.QtCore import Signal, QObject
 from PySide6.QtGui import QAction, QIcon
 from PySide6.QtWidgets import QMenu, QComboBox
 from .. config.constants import constants
+from .. config.app_config import AppConfig
 from .recent_file_manager import RecentFileManager
 
 
@@ -131,6 +132,7 @@ class MenuManager(QObject):
         menu = self.menubar.addMenu("&View")
         self.expert_options_action = self.action("Expert Options")
         self.expert_options_action.setCheckable(True)
+        self.expert_options_action.setChecked(AppConfig.get('expert_options'))
         menu.addAction(self.expert_options_action)
 
     def add_job_menu(self):

shinestacker/gui/new_project.py

@@ -7,6 +7,7 @@ from PySide6.QtGui import QIcon
 from PySide6.QtCore import Qt
 from .. config.gui_constants import gui_constants
 from .. config.constants import constants
+from .. config.app_config import AppConfig
 from .. algorithms.utils import read_img, extension_tif_jpg
 from .. algorithms.stack import get_bunches
 from .folder_file_selection import FolderFileSelectionWidget
@@ -31,7 +32,7 @@ class NewProjectDialog(BaseFormDialog):
         self.selected_filenames = []
 
     def expert(self):
-        return self.parent().expert_options
+        return AppConfig.get('expert_options')
 
     def add_bold_label(self, label):
         label = QLabel(label)

shinestacker/gui/project_controller.py

@@ -155,9 +155,9 @@ class ProjectController(QObject):
         if dialog.exec() == QDialog.Accepted:
             self.save_actions_set_enabled(True)
             self.project_editor.reset_undo()
-            input_folder = dialog.get_input_folder().split('/')
-            working_path = '/'.join(input_folder[:-1])
-            input_path = input_folder[-1]
+            input_folder = dialog.get_input_folder()
+            working_path = os.path.dirname(input_folder)
+            input_path = os.path.basename(input_folder)
             selected_filenames = dialog.get_selected_filenames()
             if dialog.get_noise_detection():
                 job_noise = ActionConfig(
@@ -210,13 +210,15 @@ class ProjectController(QObject):
                 focus_pyramid_name = f'{input_path}-focus-stack-pyramid'
                 focus_pyramid = ActionConfig(constants.ACTION_FOCUSSTACK,
                                              {'name': focus_pyramid_name,
-                                              'stacker': constants.STACK_ALGO_PYRAMID})
+                                              'stacker': constants.STACK_ALGO_PYRAMID,
+                                              'exif_path': input_path})
                 job.add_sub_action(focus_pyramid)
             if dialog.get_focus_stack_depth_map():
                 focus_depth_map_name = f'{input_path}-focus-stack-depth-map'
                 focus_depth_map = ActionConfig(constants.ACTION_FOCUSSTACK,
                                                {'name': focus_depth_map_name,
-                                                'stacker': constants.STACK_ALGO_DEPTH_MAP})
+                                                'stacker': constants.STACK_ALGO_DEPTH_MAP,
+                                                'exif_path': input_path})
                 job.add_sub_action(focus_depth_map)
             if dialog.get_multi_layer():
                 multi_input_path = []
@@ -231,7 +233,7 @@ class ProjectController(QObject):
                 multi_layer = ActionConfig(
                     constants.ACTION_MULTILAYER,
                     {'name': f'{input_path}-multi-layer',
-                        'input_path': constants.PATH_SEPARATOR.join(multi_input_path)})
+                     'input_path': constants.PATH_SEPARATOR.join(multi_input_path)})
                 job.add_sub_action(multi_layer)
             self.add_job_to_project(job)
             self.project_editor.set_modified(True)

shinestacker/gui/project_model.py

@@ -1,12 +1,27 @@
 # pylint: disable=C0114, C0115, C0116, R0911
 from copy import deepcopy
 from .. config.constants import constants
+from .. config.app_config import AppConfig
+
+
+TYPE_NAME_APP_CONFIG_MAP = {
+    constants.ACTION_COMBO: 'combined_actions_params',
+    constants.ACTION_ALIGNFRAMES: 'align_frames_params',
+    constants.ACTION_FOCUSSTACK: 'focus_stack_params',
+    constants.ACTION_FOCUSSTACKBUNCH: 'focus_stack_bunch_params'
+}
 
 
 class ActionConfig:
     def __init__(self, type_name: str, params=None, parent=None):
         self.type_name = type_name
-        self.params = params or {}
+        app_config_params_key = TYPE_NAME_APP_CONFIG_MAP.get(type_name, '')
+        if app_config_params_key != '':
+            self.params = AppConfig.get(app_config_params_key, {})
+        else:
+            self.params = {}
+        if params:
+            self.params = {**self.params, **params}
         self.parent = parent
         self.sub_actions: list[ActionConfig] = []
 

shinestacker/gui/recent_file_manager.py

@@ -1,30 +1,12 @@
 # pylint: disable=C0114, C0115, C0116, E0611
 import os
-from PySide6.QtCore import QStandardPaths
+from .. config.settings import StdPathFile
 
 
-class RecentFileManager:
+class RecentFileManager(StdPathFile):
     def __init__(self, filename, max_entries=10):
-        self.filename = filename
+        super().__init__(filename)
         self.max_entries = max_entries
-        self._config_dir = None
-
-    def get_config_dir(self):
-        if self._config_dir is None:
-            config_dir = QStandardPaths.writableLocation(QStandardPaths.AppConfigLocation)
-            if not config_dir:
-                if os.name == 'nt':  # Windows
-                    config_dir = os.path.join(os.environ.get('APPDATA', ''), 'ShineStacker')
-                elif os.name == 'posix':  # macOS and Linux
-                    config_dir = os.path.expanduser('~/.config/shinestacker')
-                else:
-                    config_dir = os.path.join(os.path.expanduser('~'), '.shinestacker')
-            os.makedirs(config_dir, exist_ok=True)
-            self._config_dir = config_dir
-        return self._config_dir
-
-    def get_file_path(self):
-        return os.path.join(self.get_config_dir(), self.filename)
 
     def get_files(self):
         file_path = self.get_file_path()

shinestacker/retouch/base_filter.py

@@ -157,7 +157,7 @@ class BaseFilter(QObject, LayerCollectionHandler):
             except Exception:
                 h, w = self.master_layer_copy().shape[:2]
             try:
-                self.undo_manager.extend_undo_area(0, 0, w, h)
+                self.undo_manager.set_paint_area(0, 0, w, h)
                 self.undo_manager.save_undo_state(
                     self.master_layer_copy(),
                     self.name

shinestacker/retouch/display_manager.py

@@ -3,8 +3,9 @@ import numpy as np
 from PySide6.QtWidgets import (QWidget, QListWidgetItem, QVBoxLayout, QLabel, QInputDialog,
                                QAbstractItemView)
 from PySide6.QtGui import QPixmap, QImage
-from PySide6.QtCore import Qt, QObject, QTimer, QSize, Signal
+from PySide6.QtCore import Qt, QObject, QTimer, QSize, Signal, QThread
 from .. config.gui_constants import gui_constants
+from .. config.app_config import AppConfig
 from .layer_collection import LayerCollectionHandler
 
 
@@ -23,6 +24,32 @@ class ClickableLabel(QLabel):
     # pylint: enable=C0103
 
 
+class ThumbnailWorker(QThread):
+    thumbnail_ready = Signal(object)
+
+    def __init__(self, layer_data):
+        super().__init__()
+        self.layer_data = layer_data
+
+    def run(self):
+        if self.layer_data is None:
+            self.thumbnail_ready.emit(None)
+            return
+        source_layer = (self.layer_data // 256).astype(np.uint8) \
+            if self.layer_data.dtype == np.uint16 else self.layer_data
+        if not source_layer.flags.c_contiguous:
+            source_layer = np.ascontiguousarray(source_layer)
+        height, width = source_layer.shape[:2]
+        if self.layer_data.ndim == 3 and source_layer.shape[-1] == 3:
+            qimg = QImage(source_layer.data, width, height, 3 * width, QImage.Format_RGB888)
+        else:
+            qimg = QImage(source_layer.data, width, height, width, QImage.Format_Grayscale8)
+        thumbnail = QPixmap.fromImage(
+            qimg.scaledToWidth(
+                gui_constants.UI_SIZES['thumbnail_width'], Qt.SmoothTransformation))
+        self.thumbnail_ready.emit(thumbnail)
+
+
 class DisplayManager(QObject, LayerCollectionHandler):
     status_message_requested = Signal(str)
 
@@ -36,8 +63,10 @@ class DisplayManager(QObject, LayerCollectionHandler):
         self.view_mode = 'master'
         self.needs_update = False
         self.update_timer = QTimer()
-        self.update_timer.setInterval(gui_constants.PAINT_REFRESH_TIMER)
+        self.update_timer.setInterval(AppConfig.get('display_refresh_time'))
         self.update_timer.timeout.connect(self.process_pending_updates)
+        self.thumbnail_worker = None
+        self.thumbnail_update_pending = False
 
     def process_pending_updates(self):
         if self.needs_update:
@@ -77,7 +106,22 @@ class DisplayManager(QObject, LayerCollectionHandler):
         if self.has_no_master_layer():
             self._clear_master_thumbnail()
         else:
-            self._set_master_thumbnail(self.create_thumbnail(self.master_layer()))
+            self._start_async_thumbnail_generation()
+
+    def _start_async_thumbnail_generation(self):
+        if self.thumbnail_worker and self.thumbnail_worker.isRunning():
+            self.thumbnail_update_pending = True
+            return
+        self.thumbnail_worker = ThumbnailWorker(self.master_layer())
+        self.thumbnail_worker.thumbnail_ready.connect(self._on_thumbnail_ready)
+        self.thumbnail_worker.start()
+
+    def _on_thumbnail_ready(self, thumbnail):
+        if thumbnail is not None:
+            self._set_master_thumbnail(thumbnail)
+        if self.thumbnail_update_pending:
+            self.thumbnail_update_pending = False
+            self._start_async_thumbnail_generation()
 
     def _clear_master_thumbnail(self):
         self.master_thumbnail_label.clear()
@@ -171,15 +215,13 @@ class DisplayManager(QObject, LayerCollectionHandler):
     def refresh_master_view(self):
         if self.has_no_master_layer():
             return
-        self.image_viewer.update_master_display()
-        self.image_viewer.refresh_display()
+        self.image_viewer.update_master_display_area()
         self.update_master_thumbnail()
 
     def refresh_current_view(self):
         if self.number_of_layers() == 0:
             return
         self.image_viewer.update_current_display()
-        self.image_viewer.refresh_display()
 
     def start_temp_view(self):
         if self.view_mode == 'master':
@@ -187,7 +229,6 @@ class DisplayManager(QObject, LayerCollectionHandler):
             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.")
 
     def end_temp_view(self):

shinestacker/retouch/image_editor_ui.py

@@ -6,6 +6,7 @@ from PySide6.QtGui import QShortcut, QKeySequence, QAction, QActionGroup
 from PySide6.QtCore import Qt
 from PySide6.QtGui import QGuiApplication
 from .. config.constants import constants
+from .. config.app_config import AppConfig
 from .. config.gui_constants import gui_constants
 from .. gui.recent_file_manager import RecentFileManager
 from .image_viewer import ImageViewer
@@ -13,6 +14,7 @@ from .shortcuts_help import ShortcutsHelp
 from .brush import Brush
 from .brush_tool import BrushTool
 from .layer_collection import LayerCollectionHandler
+from .paint_area_manager import PaintAreaManager
 from .undo_manager import UndoManager
 from .layer_collection import LayerCollection
 from .io_gui_handler import IOGuiHandler
@@ -34,9 +36,9 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.brush = Brush()
         self.brush_tool = BrushTool()
         self.modified = False
-        self.mask_layer = None
         self.transformation_manager = TransfromationManager(self)
-        self.undo_manager = UndoManager(self.transformation_manager)
+        self.paint_area_manager = PaintAreaManager()
+        self.undo_manager = UndoManager(self.transformation_manager, self.paint_area_manager)
         self.undo_action = None
         self.redo_action = None
         self.undo_manager.stack_changed.connect(self.update_undo_redo_actions)
@@ -48,13 +50,13 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         central_widget = QWidget()
         self.setCentralWidget(central_widget)
         layout = QHBoxLayout(central_widget)
-        self.image_viewer = ImageViewer(self.layer_collection)
+        self.image_viewer = ImageViewer(
+            self.layer_collection, self.brush_tool, self.paint_area_manager)
         self.image_viewer.connect_signals(
             self.handle_temp_view,
-            self.begin_copy_brush_area,
-            self.continue_copy_brush_area,
             self.end_copy_brush_area,
-            self.handle_brush_size_change)
+            self.handle_brush_size_change,
+            self.handle_needs_update)
         side_panel = QWidget()
         side_layout = QVBoxLayout(side_panel)
         side_layout.setContentsMargins(0, 0, 0, 0)
@@ -184,6 +186,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         def change_layer_item(item):
             layer_idx = self.thumbnail_list.row(item)
             self.change_layer(layer_idx)
+            self.display_manager.highlight_thumbnail(layer_idx)
 
         self.thumbnail_list.itemClicked.connect(change_layer_item)
         self.thumbnail_list.setStyleSheet("""
@@ -236,6 +239,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
                                  self.flow_slider)
         self.image_viewer.set_brush(self.brush_tool.brush)
         self.image_viewer.set_preview_brush(self.brush_tool.brush)
+        self.image_viewer.status.set_zoom_factor_requested.connect(self.handle_set_zoom_factor)
         self.brush_tool.update_brush_thumb()
         self.io_gui_handler.setup_ui(self.display_manager, self.image_viewer)
         menubar = self.menuBar()
@@ -434,7 +438,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         view_menu.addAction(self.toggle_view_master_individual_action)
         view_menu.addSeparator()
 
-        self.set_strategy('overlaid')
+        self.set_strategy(AppConfig.get('view_strategy'))
 
         sort_asc_action = QAction("Sort Layers A-Z", self)
         sort_asc_action.setProperty("requires_file", True)
@@ -471,6 +475,8 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         help_menu.setObjectName("Help")
         shortcuts_help_action = QAction("Shortcuts and Mouse", self)
 
+        self.zoom_factor_label = QLabel("")
+        self.statusBar().addPermanentWidget(self.zoom_factor_label)
         self.statusBar().showMessage("Shine Stacker ready.", 2000)
 
         def shortcuts_help():
@@ -488,6 +494,10 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.set_enabled_file_open_close_actions(False)
         self.installEventFilter(self)
 
+    def handle_config(self):
+        self.set_strategy(AppConfig.get('view_strategy'))
+        self.display_manager.update_timer.setInterval(AppConfig.get('display_refresh_time'))
+
     def set_enabled_view_toggles(self, enabled):
         self.view_master_action.setEnabled(enabled)
         self.view_individual_action.setEnabled(enabled)
@@ -620,35 +630,11 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             self.mark_as_modified()
             self.statusBar().showMessage(f"Copied layer {self.current_layer_idx() + 1} to master")
 
-    def copy_brush_area_to_master(self, view_pos):
-        if self.layer_stack() is None or self.number_of_layers() == 0 \
-           or self.display_manager.view_mode != 'master':
-            return
-        area = self.brush_tool.apply_brush_operation(
-            self.master_layer_copy(),
-            self.current_layer(),
-            self.master_layer(), self.mask_layer,
-            view_pos)
-        self.undo_manager.extend_undo_area(*area)
-
-    def begin_copy_brush_area(self, pos):
-        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()
-            self.copy_brush_area_to_master(pos)
-            self.display_manager.needs_update = True
-            if not self.display_manager.update_timer.isActive():
-                self.display_manager.update_timer.start()
-            self.mark_as_modified()
-
-    def continue_copy_brush_area(self, pos):
-        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():
-                self.display_manager.update_timer.start()
-            self.mark_as_modified()
+    def handle_needs_update(self):
+        self.display_manager.needs_update = True
+        if not self.display_manager.update_timer.isActive():
+            self.display_manager.update_timer.start()
+        self.mark_as_modified()
 
     def end_copy_brush_area(self):
         if self.display_manager.update_timer.isActive():
@@ -658,6 +644,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             self.mark_as_modified()
 
     def update_undo_redo_actions(self, has_undo, undo_desc, has_redo, redo_desc):
+        self.image_viewer.update_brush_cursor()
         if self.undo_action:
             if has_undo:
                 self.undo_action.setText(f"Undo {undo_desc}")
@@ -700,6 +687,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             self.io_gui_handler.close_file()
             self.set_master_layer(None)
             self.mark_as_modified(False)
+            self.zoom_factor_label.setText("")
 
     def set_view_master(self):
         self.display_manager.set_view_master()
@@ -752,3 +740,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             self.brush_tool.increase_brush_size()
         else:
             self.brush_tool.decrease_brush_size()
+
+    def handle_set_zoom_factor(self, zoom_factor):
+        self.zoom_factor_label.setText(f"zoom: {zoom_factor:.1%}")