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

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '1.5.2'
+__version__ = '1.5.4'

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/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/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/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/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/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/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/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/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/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/retouch/sidebyside_view.py

@@ -1,7 +1,9 @@
 # pylint: disable=C0114, C0115, C0116, R0904, R0915, E0611, R0902, R0911, R0914, E1003
+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
 
 
@@ -58,6 +60,7 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self.current_view.setFocusPolicy(Qt.NoFocus)
         self.master_view.setFocusPolicy(Qt.NoFocus)
         self.current_brush_cursor = None
+        self.last_color_update_time_current = 0
 
     def setup_layout(self):
         raise NotImplementedError("Subclasses must implement setup_layout")
@@ -227,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)
@@ -311,9 +309,11 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             radius = size / 2
             self.current_brush_cursor.setRect(
                 scene_pos.x() - radius, scene_pos.y() - radius, size, size)
+            self.update_current_cursor_color()
             self.current_brush_cursor.show()
             self.brush_cursor.setRect(
                 scene_pos.x() - radius, scene_pos.y() - radius, size, size)
+            self.update_master_cursor_color()
             self.brush_cursor.show()
         else:
             self.brush_cursor.hide()
@@ -321,6 +321,19 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             self.master_view.setCursor(Qt.ArrowCursor)
             self.current_view.setCursor(Qt.ArrowCursor)
 
+    def update_current_cursor_color(self):
+        self.update_cursor_color_based_on_background(
+            self.current_brush_cursor, self.current_layer(),
+            self.get_visible_current_image_region, self.get_current_pixmap,
+            self.update_color_time_current)
+
+    def update_color_time_current(self):
+        current_time = time.time()
+        if current_time - self.last_color_update_time_current < 0.2:
+            return False
+        self.last_color_update_time_current = current_time
+        return True
+
     def handle_master_mouse_press(self, event):
         self.setFocus()
         self.mouse_press_event(event)
@@ -366,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)
@@ -422,9 +428,9 @@ 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()
         else:
             self.current_brush_cursor.hide()

shinestacker/retouch/view_strategy.py

@@ -1,5 +1,6 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0904, R0903, R0902, E1101, R0914, R0913, R0917
 import math
+import time
 from abc import abstractmethod
 import numpy as np
 from PySide6.QtCore import Qt, QPointF, QTime, QPoint, Signal, QRectF
@@ -67,6 +68,7 @@ class BrushCursor(QGraphicsItemGroup):
 
     def setRect(self, x, y, w, h):
         self._rect = QRectF(x, y, w, h)
+        self._radius = min(w, h) / 2
         self._create_arcs()
 
     def rect(self):
@@ -95,6 +97,8 @@ class ImageGraphicsViewBase(QGraphicsView):
         self.setRenderHint(QPainter.Antialiasing)
         self.setRenderHint(QPainter.SmoothPixmapTransform)
         self.setCursor(Qt.BlankCursor)
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
+        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
 
 
 class ViewStrategy(LayerCollectionHandler):
@@ -116,6 +120,7 @@ class ViewStrategy(LayerCollectionHandler):
         self.last_brush_pos = None
         self.last_mouse_pos = None
         self.last_update_time = QTime.currentTime()
+        self.last_color_update_time = 0
 
     @abstractmethod
     def create_pixmaps(self):
@@ -185,6 +190,10 @@ class ViewStrategy(LayerCollectionHandler):
     def set_mouse_callbacks(self, callbacks):
         pass
 
+    @abstractmethod
+    def get_view_with_mouse(self, event=None):
+        pass
+
     def hide_brush_cursor(self):
         if self.brush_cursor:
             self.brush_cursor.hide()
@@ -236,6 +245,8 @@ class ViewStrategy(LayerCollectionHandler):
 
     def set_cursor_style(self, style):
         self.cursor_style = style
+        if style == 'preview':
+            self.show_brush_preview()
         self.update_brush_cursor()
 
     def get_cursor_style(self):
@@ -315,6 +326,17 @@ class ViewStrategy(LayerCollectionHandler):
             return QImage(memoryview(array), width, height, 3 * width, QImage.Format_RGB888)
         return QImage()
 
+    def setup_view_image(self, view, pixmap):
+        img_width, img_height = pixmap.width(), pixmap.height()
+        self.set_max_min_scales(img_width, img_height)
+        view_rect = 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)
+        return img_width, img_height, scale_factor
+
     def create_scene(self, view):
         scene = QGraphicsScene()
         view.setScene(scene)
@@ -336,21 +358,6 @@ class ViewStrategy(LayerCollectionHandler):
                                gui_constants.MIN_ZOOMED_IMG_HEIGHT / img_height))
         self.set_max_scale(gui_constants.MAX_ZOOMED_IMG_PX_SIZE)
 
-    def zoom_in(self):
-        if self.empty():
-            return
-        master_view = self.get_master_view()
-        old_center = master_view.mapToScene(master_view.viewport().rect().center())
-        current_scale = self.get_current_scale()
-        new_scale = current_scale * gui_constants.ZOOM_IN_FACTOR
-        if new_scale <= self.max_scale():
-            for view in self.get_views():
-                view.scale(gui_constants.ZOOM_IN_FACTOR, gui_constants.ZOOM_IN_FACTOR)
-            self.set_zoom_factor(new_scale)
-            master_view.centerOn(old_center)
-            self.update_brush_cursor()
-            self.update_cursor_pen_width()
-
     def apply_zoom(self):
         if self.empty():
             return
@@ -359,20 +366,98 @@ class ViewStrategy(LayerCollectionHandler):
             scale_factor = self.zoom_factor() / current_scale
             view.scale(scale_factor, scale_factor)
 
-    def zoom_out(self):
+    def center_image(self, view):
+        view.horizontalScrollBar().setValue(self.status.h_scroll)
+        view.verticalScrollBar().setValue(self.status.v_scroll)
+
+    def set_scroll_and_center(self, view, delta):
+        self.status.set_scroll(
+            view.horizontalScrollBar().value() + int(delta.x() * self.zoom_factor()),
+            view.verticalScrollBar().value() + int(delta.y() * self.zoom_factor()))
+        self.center_image(view)
+
+    def apply_zoom_and_center(self, view, new_scale, ref_pos, old_center):
+        self.set_zoom_factor(new_scale)
+        self.apply_zoom()
+        new_center = view.mapToScene(ref_pos)
+        delta = old_center - new_center
+        self.set_scroll_and_center(view, delta)
+
+    def handle_pinch_gesture(self, pinch):
+        master_view = self.get_master_view()
+        if pinch.state() == Qt.GestureStarted:
+            self.pinch_start_scale = self.zoom_factor()
+            self.pinch_center_view = pinch.centerPoint()
+            self.pinch_center_scene = master_view.mapToScene(self.pinch_center_view.toPoint())
+            self.gesture_active = True
+        elif pinch.state() == Qt.GestureUpdated:
+            new_scale = self.pinch_start_scale * pinch.totalScaleFactor()
+            new_scale = max(self.min_scale(), min(new_scale, self.max_scale()))
+            if abs(new_scale - self.zoom_factor()) > 0.01:
+                old_center = self.pinch_center_scene
+                ref_pos = self.pinch_center_view.toPoint()
+                self.apply_zoom_and_center(master_view, new_scale, ref_pos, old_center)
+        elif pinch.state() in (Qt.GestureFinished, Qt.GestureCanceled):
+            self.gesture_active = False
+        self.update_cursor_pen_width()
+
+    def do_zoom(self, new_scale, view):
         if self.empty():
             return
-        master_view = self.get_master_view()
-        old_center = master_view.mapToScene(master_view.viewport().rect().center())
-        current_scale = self.get_current_scale()
-        new_scale = current_scale * gui_constants.ZOOM_OUT_FACTOR
-        if new_scale >= self.min_scale():
-            for view in self.get_views():
-                view.scale(gui_constants.ZOOM_OUT_FACTOR, gui_constants.ZOOM_OUT_FACTOR)
-            self.set_zoom_factor(new_scale)
-            master_view.centerOn(old_center)
+        if not self.min_scale() <= new_scale <= self.max_scale():
+            return
+        if view is None:
+            view = self.get_master_view()
+        global_pos = QCursor.pos()
+        ref_pos = view.mapFromGlobal(global_pos)
+        old_center = view.mapToScene(ref_pos)
+        self.apply_zoom_and_center(view, new_scale, ref_pos, old_center)
+        self.update_cursor_pen_width()
+
+    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:
+                self.handle_zoom_wheel(self.get_view_with_mouse(event), event)
             self.update_brush_cursor()
-            self.update_cursor_pen_width()
+        else:
+            self.handle_wheel_touchpad_event(event)
+
+    def handle_wheel_touchpad_event(self, event):
+        if not self.control_pressed:
+            delta = event.pixelDelta() or event.angleDelta() / 8
+            if delta:
+                self.scroll_view(self.get_view_with_mouse(event), delta.x(), delta.y())
+        else:
+            zoom_in = event.angleDelta().y() > 0
+            if zoom_in:
+                self.zoom_in()
+            else:
+                self.zoom_out()
+
+    def handle_zoom_wheel(self, view, event):
+        if view is None:
+            return
+        current_scale = self.get_current_scale()
+        if event.angleDelta().y() > 0:
+            new_scale = current_scale * gui_constants.ZOOM_IN_FACTOR
+        else:
+            new_scale = current_scale * gui_constants.ZOOM_OUT_FACTOR
+        new_scale = max(self.min_scale(), min(new_scale, self.max_scale()))
+        self.do_zoom(new_scale, view)
+
+    def zoom_in(self):
+        self.do_zoom(
+            self.get_current_scale() * gui_constants.ZOOM_IN_FACTOR,
+            self.get_view_with_mouse())
+
+    def zoom_out(self):
+        self.do_zoom(
+            self.get_current_scale() * gui_constants.ZOOM_OUT_FACTOR,
+            self.get_view_with_mouse())
 
     def reset_zoom(self):
         if self.empty():
@@ -402,9 +487,12 @@ class ViewStrategy(LayerCollectionHandler):
         self.update_cursor_pen_width()
 
     def setup_simple_brush_style(self, center_x, center_y, radius):
+        if self.brush_cursor:
+            pen = self.brush_cursor.pen()
+        else:
+            pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), self.current_line_width())
         gradient = create_default_brush_gradient(center_x, center_y, radius, self.brush)
-        self.brush_cursor.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['pen']),
-                                      self.current_line_width()))
+        self.brush_cursor.setPen(pen)
         self.brush_cursor.setBrush(QBrush(gradient))
 
     def create_circle(self, scene, line_style=Qt.SolidLine):
@@ -469,9 +557,58 @@ class ViewStrategy(LayerCollectionHandler):
                 self.brush_preview.update(scene_pos, int(size))
         else:
             self.hide_brush_preview()
-            if self.cursor_style != 'outline':
-                self.setup_simple_brush_style(scene_pos.x(), scene_pos.y(), radius)
-        self.show_brush_cursor()
+        self.update_master_cursor_color()
+        if self.cursor_style == 'brush':
+            self.setup_simple_brush_style(scene_pos.x(), scene_pos.y(), radius)
+        if not self.scrolling:
+            self.show_brush_cursor()
+
+    def update_color_time(self):
+        current_time = time.time()
+        if current_time - self.last_color_update_time < 0.2:
+            return False
+        self.last_color_update_time = current_time
+        return True
+
+    def update_master_cursor_color(self):
+        self.update_cursor_color_based_on_background(
+            self.brush_cursor, self.master_layer(),
+            self.get_visible_image_region, self.get_master_pixmap,
+            self.update_color_time)
+
+    def update_cursor_color_based_on_background(
+            self, cursor, layer,
+            visible_region, get_pixmap, update_timer):
+        if not update_timer():
+            return
+        cursor_rect = cursor.rect()
+        image_region = visible_region()
+        if image_region and cursor_rect.intersects(image_region):
+            intersect_rect = cursor_rect.intersected(image_region)
+            top_left = get_pixmap().mapFromScene(intersect_rect.topLeft())
+            bottom_right = get_pixmap().mapFromScene(intersect_rect.bottomRight())
+            x1, y1 = max(0, int(top_left.x())), max(0, int(top_left.y()))
+            x2, y2 = min(layer.shape[1], int(bottom_right.x())), \
+                min(layer.shape[0], int(bottom_right.y()))
+            if x2 > x1 and y2 > y1:
+                region = layer[y1:y2, x1:x2]
+                if region.size > 10000:
+                    step = int(math.sqrt(region.size / 100))
+                    region = region[::step, ::step]
+                if region.ndim == 3:
+                    luminosity = np.dot(region[..., :3], [0.299, 0.587, 0.114])
+                    avg_luminosity = np.mean(luminosity)
+                else:
+                    avg_luminosity = np.mean(region)
+                if region.dtype == np.uint16:
+                    avg_luminosity /= 256.0
+                if avg_luminosity < 128:
+                    new_color = QColor(255, 255, 255)
+                else:
+                    new_color = QColor(0, 0, 0)
+                current_pen = cursor.pen()
+                current_pen.setColor(new_color)
+                cursor.setPen(current_pen)
 
     def position_on_image(self, pos):
         master_view = self.get_master_view()
@@ -485,11 +622,20 @@ class ViewStrategy(LayerCollectionHandler):
             return None
         master_view = self.get_master_view()
         master_pixmap = self.get_master_pixmap()
-        pixmap = self.get_master_pixmap()
         view_rect = master_view.viewport().rect()
         scene_rect = master_view.mapToScene(view_rect).boundingRect()
         image_rect = master_pixmap.mapFromScene(scene_rect).boundingRect().toRect()
-        return image_rect.intersected(pixmap.boundingRect().toRect())
+        return image_rect.intersected(master_pixmap.boundingRect().toRect())
+
+    def get_visible_current_image_region(self):
+        if self.empty():
+            return None
+        current_view = self.get_current_view()
+        current_pixmap = self.get_current_pixmap()
+        view_rect = current_view.viewport().rect()
+        scene_rect = current_view.mapToScene(view_rect).boundingRect()
+        image_rect = current_pixmap.mapFromScene(scene_rect).boundingRect().toRect()
+        return image_rect.intersected(current_pixmap.boundingRect().toRect())
 
     def get_visible_image_portion(self):
         if self.has_no_master_layer():
@@ -548,10 +694,6 @@ class ViewStrategy(LayerCollectionHandler):
         self.status.set_scroll(view.horizontalScrollBar().value(),
                                view.verticalScrollBar().value())
 
-    def center_image(self, view):
-        view.horizontalScrollBar().setValue(self.status.h_scroll)
-        view.verticalScrollBar().setValue(self.status.v_scroll)
-
     def mouse_move_event(self, event):
         if self.empty():
             return
@@ -598,7 +740,8 @@ class ViewStrategy(LayerCollectionHandler):
                 self.last_brush_pos = event.position()
                 self.brush_operation_started.emit(event.position().toPoint())
                 self.dragging = True
-            self.show_brush_cursor()
+            if not self.scrolling:
+                self.show_brush_cursor()
 
     def mouse_release_event(self, event):
         if self.empty():
@@ -617,28 +760,3 @@ class ViewStrategy(LayerCollectionHandler):
             elif self.dragging:
                 self.dragging = False
                 self.brush_operation_ended.emit()
-
-    def handle_pinch_gesture(self, pinch):
-        master_view = self.get_master_view()
-        if pinch.state() == Qt.GestureStarted:
-            self.pinch_start_scale = self.zoom_factor()
-            self.pinch_center_view = pinch.centerPoint()
-            self.pinch_center_scene = master_view.mapToScene(self.pinch_center_view.toPoint())
-            self.gesture_active = True
-        elif pinch.state() == Qt.GestureUpdated:
-            new_scale = self.pinch_start_scale * pinch.totalScaleFactor()
-            new_scale = max(self.min_scale(), min(new_scale, self.max_scale()))
-            if abs(new_scale - self.zoom_factor()) > 0.01:
-                self.set_zoom_factor(new_scale)
-                self.apply_zoom()
-                new_center = master_view.mapToScene(self.pinch_center_view.toPoint())
-                delta = self.pinch_center_scene - new_center
-                h_scroll = master_view.horizontalScrollBar().value() + \
-                    int(delta.x() * self.zoom_factor())
-                v_scroll = master_view.verticalScrollBar().value() + \
-                    int(delta.y() * self.zoom_factor())
-                self.status.set_scroll(h_scroll, v_scroll)
-                self.center_image(master_view)
-        elif pinch.state() in (Qt.GestureFinished, Qt.GestureCanceled):
-            self.gesture_active = False
-        self.update_cursor_pen_width()

shinestacker/retouch/white_balance_filter.py

@@ -49,7 +49,6 @@ class WhiteBalanceFilter(BaseFilter):
             self.value_labels[name] = val_label
         row_layout.addLayout(sliders_layout)
         layout.addLayout(row_layout)
-
         rbg_layout = QHBoxLayout()
         rbg_layout.addWidget(QLabel("RBG hex:"))
         self.rgb_hex = QLineEdit(self.hex_color(self.initial_val))
@@ -58,7 +57,6 @@ class WhiteBalanceFilter(BaseFilter):
         rbg_layout.addWidget(self.rgb_hex)
         rbg_layout.addStretch(1)
         layout.addLayout(rbg_layout)
-
         pick_button = QPushButton("Pick Color")
         layout.addWidget(pick_button)
         self.create_base_widgets(
@@ -126,17 +124,18 @@ class WhiteBalanceFilter(BaseFilter):
             bgr = self.get_pixel_color_at(
                 pos, radius=int(self.image_viewer.get_brush().size))
             rgb = (bgr[2], bgr[1], bgr[0])
+            QApplication.restoreOverrideCursor()
+            self.image_viewer.unsetCursor()
+            self.image_viewer.strategy.set_mouse_callbacks(self.original_mouse_press)
+            self.filter_gui_set_enabled_requested.emit(True)
+            self.image_viewer.hide_brush_preview()
             new_filter = WhiteBalanceFilter(
                 self.name, self.parent(), self.image_viewer, self.layer_collection,
                 self.undo_manager)
             new_filter.run_with_preview(init_val=rgb)
-            QApplication.restoreOverrideCursor()
-            self.image_viewer.unsetCursor()
-            self.image_viewer.strategy.set_mouse_callbacks(self.original_mouse_press)
             self.image_viewer.set_cursor_style(self.original_cursor_style)
             self.image_viewer.show_brush_cursor()
             self.image_viewer.show_brush_preview()
-            self.filter_gui_set_enabled_requested.emit(True)
 
     def reset_rgb(self):
         for name, slider in self.sliders.items():

{shinestacker-1.5.2.dist-info → shinestacker-1.5.4.dist-info}/METADATA

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

{shinestacker-1.5.2.dist-info → shinestacker-1.5.4.dist-info}/RECORD

@@ -1,5 +1,5 @@
 shinestacker/__init__.py,sha256=uq2fjAw2z_6TpH3mOcWFZ98GoEPRsNhTAK8N0MMm_e8,448
-shinestacker/_version.py,sha256=7jrl0OaiREGeLqi1Vco5z6ma0w6Mxq8kDBXuswywlc8,21
+shinestacker/_version.py,sha256=HfPNw49U2WWQOQlRuPSUUE8x8nkPx62dtjaGJfbhyTk,21
 shinestacker/algorithms/__init__.py,sha256=1FwVJ3w9GGbFFkjYJRUedTvcdE4j0ieSgaH9RC9iCY4,877
 shinestacker/algorithms/align.py,sha256=mb44u-YxZI1TTSHz81nRpX_2c8awlOhnGrK0LyfTQeQ,33543
 shinestacker/algorithms/align_auto.py,sha256=pJetw6zZEWQLouzcelkI8gD4cPiOp887ePXzVbm0E6Q,3800
@@ -22,17 +22,17 @@ shinestacker/algorithms/vignetting.py,sha256=gJOv-FN3GnTgaVn70W_6d-qbw3WmqinDiO9
 shinestacker/algorithms/white_balance.py,sha256=PMKsBtxOSn5aRr_Gkx1StHS4eN6kBN2EhNnhg4UG24g,501
 shinestacker/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shinestacker/app/about_dialog.py,sha256=pkH7nnxUP8yc0D3vRGd1jRb5cwi1nDVbQRk_OC9yLk8,4144
-shinestacker/app/args.py,sha256=TlfMR5GBd6Zz9wZNrN7CGJ1_hm1FnLZn5EoP5mkRHrk,776
+shinestacker/app/args_parser_opts.py,sha256=TlfMR5GBd6Zz9wZNrN7CGJ1_hm1FnLZn5EoP5mkRHrk,776
 shinestacker/app/gui_utils.py,sha256=fSpkwPXTON_l676UHdAnJNrGq7BPbSlPOiHpOF_LZaI,2519
 shinestacker/app/help_menu.py,sha256=g8lKG_xZmXtNQaC3SIRzyROKVWva_PLEgZsQWh6zUcQ,499
-shinestacker/app/main.py,sha256=dcitc5vwIIyIXeDfZwQnC7KHRCdd3FaVJWyaU8mK86c,10935
+shinestacker/app/main.py,sha256=UkWz4jvaBPH4Fs-arHe8H0NqKVTA4B_1e9BRn9S5oFo,10963
 shinestacker/app/open_frames.py,sha256=bsu32iJSYJQLe_tQQbvAU5DuMDVX6MRuNdE7B5lojZc,1488
-shinestacker/app/project.py,sha256=X98pK_mMtE_NefTUZfebEaP1YCsVY97hcQD4bSxuNyY,2777
-shinestacker/app/retouch.py,sha256=wlk-tHaei5YAFinGZWyzBopUhUqyxMT6jSH-4DMEwo8,2659
+shinestacker/app/project.py,sha256=_kopeyb8e5JAA3XjNXoCshlYBfT5Avw-kTqiJN4GVlo,2805
+shinestacker/app/retouch.py,sha256=On2oV2QonfMziQAvRkO6qw-h6E6wWQE0svKzZQKHeyg,2687
 shinestacker/config/__init__.py,sha256=aXxi-LmAvXd0daIFrVnTHE5OCaYeK1uf1BKMr7oaXQs,197
 shinestacker/config/config.py,sha256=eBko2D3ADhLTIm9X6hB_a_WsIjwgfE-qmBVkhP1XSvc,1636
 shinestacker/config/constants.py,sha256=EEdr7pZg4JpbIjUWaP7kJQfTuBB85FN739myDNAfn8A,8301
-shinestacker/config/gui_constants.py,sha256=Aqan-AdUjtlARXpsefQvWW2uKVv1tvwc0gfKyo7xud4,2787
+shinestacker/config/gui_constants.py,sha256=55Qr0KzrTx8eQHCkT-EVabSiD59VvLZIh5o2cA9028s,2791
 shinestacker/core/__init__.py,sha256=IUEIx6SQ3DygDEHN3_E6uKpHjHtUa4a_U_1dLd_8yEU,484
 shinestacker/core/colors.py,sha256=kr_tJA1iRsdck2JaYDb2lS-codZ4Ty9gdu3kHfiWvuM,1340
 shinestacker/core/core_utils.py,sha256=1LYj19Dfc9jZN9-4dlf1paximDH5WZYa7DXvKr7R7QY,1719
@@ -49,10 +49,10 @@ shinestacker/gui/folder_file_selection.py,sha256=IYWfZQFkoD5iO7zJ7BxVVDP9F3Dc0EX
 shinestacker/gui/gui_images.py,sha256=k39DpdsxcmYoRdHNNZj6OpFAas0GOHS4JSG542wfheg,5728
 shinestacker/gui/gui_logging.py,sha256=kiZcrC2AFYCWgPZo0O5SKw-E5cFrezwf4anS3HjPuNw,8168
 shinestacker/gui/gui_run.py,sha256=zr7x4BVmM0n_ZRsSEaJVVKvHSWHuwhftgkUvgeg90gU,15767
-shinestacker/gui/main_window.py,sha256=5k_9TiZT9idKCmovUFYpUTSEQQj-DMQrlyq9dAgY1MU,24800
-shinestacker/gui/menu_manager.py,sha256=b5Cxh6uddOlio8i7fRISbGDJI-oe0ds6LIF5dWM7leI,11263
+shinestacker/gui/main_window.py,sha256=zOxIRn6urmnmfDOR1JJ3n6xsT1qryOt1s7kZxwh-qYI,25202
+shinestacker/gui/menu_manager.py,sha256=legmYEpQxuzEQoDhxMUWiwCcYTXwd-uRfAju-Nymy8g,11664
 shinestacker/gui/new_project.py,sha256=z8e3EhRMB-KtoPwYQSiKLSOQ2dS0-Okm7zVw21B7zy8,16391
-shinestacker/gui/project_controller.py,sha256=W4sbBGEPVtfF9F1rC-6Y0oKLq_y94HuFBvZRj87xNKQ,16272
+shinestacker/gui/project_controller.py,sha256=7vSyoxepplJrf0VsbPrZkMqtHW6rtPgEOZgdPsOPVoQ,16490
 shinestacker/gui/project_converter.py,sha256=Gmna0HwbvACcXiX74TaQYumif8ZV8sZ2APLTMM-L1mU,7436
 shinestacker/gui/project_editor.py,sha256=lSgQ42IoaobHs-NQQWT88Qhg5l7nu5ejxAO5VgIupr8,25498
 shinestacker/gui/project_model.py,sha256=eRUmH3QmRzDtPtZoxgT6amKzN8_5XzwjHgEJeL-_JOE,4263
@@ -82,24 +82,24 @@ shinestacker/retouch/exif_data.py,sha256=LF-fRXW-reMq-xJ_QRE5j8DC2LVGKIlC6MR3QbC
 shinestacker/retouch/file_loader.py,sha256=z02-A8_uDZxayI1NFTxT2GVUvEBWStchX9hlN1o5-0U,4784
 shinestacker/retouch/filter_manager.py,sha256=tOGIWj5HjViL1-iXHkd91X-sZ1c1G531pDmLO0x6zx0,866
 shinestacker/retouch/icon_container.py,sha256=6gw1HO1bC2FrdB4dc_iH81DQuLjzuvRGksZ2hKLT9yA,585
-shinestacker/retouch/image_editor_ui.py,sha256=wvsYmS7cXt61KJlv7b3X9EbymMLgdUfeEOzi8jEuR3g,31662
+shinestacker/retouch/image_editor_ui.py,sha256=-UVWeFSnXyHOG7XEIl9wNhiCjH5R0UFeM2VOg5R6ozs,33435
 shinestacker/retouch/image_view_status.py,sha256=bdIhsXiYXm7eyjkTGWkw5PRShzaF_by-g7daqgmhwjM,1858
 shinestacker/retouch/image_viewer.py,sha256=H8w-ORug1aKf7X3FeSX4lQV-a0IewZ9OVG1-50BK4cE,4452
-shinestacker/retouch/io_gui_handler.py,sha256=BRQ5eSt1tCMDYtOqxfdYGhx2BLCrncfNrNLGuWIy5Rk,11873
+shinestacker/retouch/io_gui_handler.py,sha256=UOnrFT00s0075Ng_yJACJX9TP8UT9mQOWXwQwNAfpMw,12079
 shinestacker/retouch/io_manager.py,sha256=JUAA--AK0mVa1PTErJTnBFjaXIle5Qs7Ow0Wkd8at0o,2437
 shinestacker/retouch/layer_collection.py,sha256=fZlGrkm9-Ycc7AOzFSpImhafiTieBeCZRk-UlvlFHbo,5819
-shinestacker/retouch/overlaid_view.py,sha256=uIMolD1984uQPWXpd27tMvGBTcSrYT-4vxO0pWVlEO4,8686
+shinestacker/retouch/overlaid_view.py,sha256=KBwuzC2OQsK7rdtFAKrSvXrHrEV1SiOoZhxPCQLGkvg,6734
 shinestacker/retouch/shortcuts_help.py,sha256=BFWTT5QvodqMhqa_9LI25hZqjICfckgyWG4fGrGzvnM,4283
-shinestacker/retouch/sidebyside_view.py,sha256=dN5uDG0ioFvYcbmZbx97slh4cOLmJ2T14jtTshg5F9w,17918
+shinestacker/retouch/sidebyside_view.py,sha256=Ipx5ckaAuEv6fnxg4RpENj00ew6-M2jLsnTKUcYKcAk,18055
 shinestacker/retouch/transformation_manager.py,sha256=NSHGUF-JFv4Y81gSvizjQCTp49TLo1so7c0WoUElO08,1812
 shinestacker/retouch/undo_manager.py,sha256=cKUkqnJtnJ-Hq-LQs5Bv49FC6qkG6XSw9oCVySJ8jS0,4312
 shinestacker/retouch/unsharp_mask_filter.py,sha256=Iapc8UmSVpj3V0LcJq_38P5qerRqTevMynbbk5Rk6iE,3634
-shinestacker/retouch/view_strategy.py,sha256=_Zo-SU2hlVVSv1g5eWgp72njcmfMpAlkkPggd89XJFo,23326
+shinestacker/retouch/view_strategy.py,sha256=u9oOB-fxap_ijNJ3O3Ev5OMLH-bDZNGj4hyBkJUDeeo,27993
 shinestacker/retouch/vignetting_filter.py,sha256=JhFr6OVIripQzSJrZEG4lxq7wBsmpofLqJQ-aP2bKw8,3789
-shinestacker/retouch/white_balance_filter.py,sha256=QlMnzWmBYqUQqckY8XTH3dWPdqo7mz4gTwTZafxldPw,8237
-shinestacker-1.5.2.dist-info/licenses/LICENSE,sha256=pWgb-bBdsU2Gd2kwAXxketnm5W_2u8_fIeWEgojfrxs,7651
-shinestacker-1.5.2.dist-info/METADATA,sha256=AuETmZdF7h5LSior9SUBcdWaiSmCxenl_9bECasvSLk,6978
-shinestacker-1.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-shinestacker-1.5.2.dist-info/entry_points.txt,sha256=SY6g1LqtMmp23q1DGwLUDT_dhLX9iss8DvWkiWLyo_4,166
-shinestacker-1.5.2.dist-info/top_level.txt,sha256=MhijwnBVX5psfsyX8JZjqp3SYiWPsKe69f3Gnyze4Fw,13
-shinestacker-1.5.2.dist-info/RECORD,,
+shinestacker/retouch/white_balance_filter.py,sha256=UaH4yxG3fU4vPutBAkV5oTXIQyUTN09x0uTywAzv3sY,8286
+shinestacker-1.5.4.dist-info/licenses/LICENSE,sha256=pWgb-bBdsU2Gd2kwAXxketnm5W_2u8_fIeWEgojfrxs,7651
+shinestacker-1.5.4.dist-info/METADATA,sha256=1cFUICQsSTKF1T8L7sNiT7XQ_UkwXlIMRr64bym9TvA,6978
+shinestacker-1.5.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shinestacker-1.5.4.dist-info/entry_points.txt,sha256=SY6g1LqtMmp23q1DGwLUDT_dhLX9iss8DvWkiWLyo_4,166
+shinestacker-1.5.4.dist-info/top_level.txt,sha256=MhijwnBVX5psfsyX8JZjqp3SYiWPsKe69f3Gnyze4Fw,13
+shinestacker-1.5.4.dist-info/RECORD,,