shinestacker 0.5.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

shinestacker/retouch/image_editor_ui.py

@@ -1,43 +1,50 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0902, R0914, R0915
+# pylint: disable=C0114, C0115, C0116, E0611, R0902, R0914, R0915, R0904
+import numpy as np
 from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QFrame, QLabel,
-                               QListWidget, QSlider)
+                               QListWidget, QSlider, QMainWindow, QMessageBox)
 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.gui_constants import gui_constants
-from .image_filters import ImageFilters
 from .image_viewer import ImageViewer
 from .shortcuts_help import ShortcutsHelp
 from .brush import Brush
-
-
-def brush_size_to_slider(size):
-    if size <= gui_constants.BRUSH_SIZES['min']:
-        return 0
-    if size >= gui_constants.BRUSH_SIZES['max']:
-        return gui_constants.BRUSH_SIZE_SLIDER_MAX
-    normalized = ((size - gui_constants.BRUSH_SIZES['min']) /
-                  gui_constants.BRUSH_SIZES['max']) ** (1 / gui_constants.BRUSH_GAMMA)
-    return int(normalized * gui_constants.BRUSH_SIZE_SLIDER_MAX)
-
-
-class ImageEditorUI(ImageFilters):
+from .brush_tool import BrushTool
+from .layer_collection import LayerCollectionHandler
+from .undo_manager import UndoManager
+from .layer_collection import LayerCollection
+from .io_gui_handler import IOGuiHandler
+from .display_manager import DisplayManager
+from .filter_manager import FilterManager
+from .denoise_filter import DenoiseFilter
+from .unsharp_mask_filter import UnsharpMaskFilter
+from .white_balance_filter import WhiteBalanceFilter
+from .vignetting_filter import VignettingFilter
+
+
+class ImageEditorUI(QMainWindow, LayerCollectionHandler):
     def __init__(self):
+        QMainWindow.__init__(self)
+        LayerCollectionHandler.__init__(self, LayerCollection())
         self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
-        super().__init__()
+        self.undo_manager = UndoManager()
+        self.undo_action = None
+        self.redo_action = None
+        self.undo_manager.stack_changed.connect(self.update_undo_redo_actions)
+        self.io_gui_handler = None
+        self.display_manager = None
         self.brush = Brush()
-        self.setup_ui()
-        self.setup_menu()
-        self.setup_shortcuts()
-        self._dialog = None
+        self.brush_tool = BrushTool()
+        self.modified = False
+        self.mask_layer = None
+        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
 
-    def setup_shortcuts(self):
-        prev_layer = QShortcut(QKeySequence(Qt.Key_Up), self, context=Qt.ApplicationShortcut)
-        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)
-
-    def setup_ui(self):
         self.update_title()
         self.resize(1400, 900)
         center = QGuiApplication.primaryScreen().geometry().center()
@@ -70,6 +77,16 @@ class ImageEditorUI(ImageFilters):
 
         self.brush_size_slider = QSlider(Qt.Horizontal)
         self.brush_size_slider.setRange(0, gui_constants.BRUSH_SIZE_SLIDER_MAX)
+
+        def brush_size_to_slider(size):
+            if size <= gui_constants.BRUSH_SIZES['min']:
+                return 0
+            if size >= gui_constants.BRUSH_SIZES['max']:
+                return gui_constants.BRUSH_SIZE_SLIDER_MAX
+            normalized = ((size - gui_constants.BRUSH_SIZES['min']) /
+                          gui_constants.BRUSH_SIZES['max']) ** (1 / gui_constants.BRUSH_GAMMA)
+            return int(normalized * gui_constants.BRUSH_SIZE_SLIDER_MAX)
+
         self.brush_size_slider.setValue(brush_size_to_slider(self.brush.size))
         brush_layout.addWidget(self.brush_size_slider)
 
@@ -141,6 +158,13 @@ class ImageEditorUI(ImageFilters):
             gui_constants.UI_SIZES['thumbnail_width'])
         self.master_thumbnail_label.mousePressEvent = \
             lambda e: self.display_manager.set_view_master()
+        self.master_thumbnail_label.setMouseTracking(True)
+
+        def label_clicked(event):
+            if event.button() == Qt.LeftButton:
+                self.toggle_view_master_individual()
+
+        self.master_thumbnail_label.mousePressEvent = label_clicked
         master_thumbnail_layout.addWidget(self.master_thumbnail_label)
         side_layout.addWidget(self.master_thumbnail_frame)
         side_layout.addSpacing(10)
@@ -206,13 +230,25 @@ class ImageEditorUI(ImageFilters):
         layout.addWidget(control_panel, 0)
         layout.setContentsMargins(0, 0, 0, 0)
         layout.setSpacing(2)
-        super().setup_ui()
+        self.display_manager = DisplayManager(
+            self.layer_collection, self.image_viewer,
+            self.master_thumbnail_label, self.thumbnail_list, parent=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.display_manager.cursor_preview_state_changed.connect(
+            lambda state: setattr(self.image_viewer, 'allow_cursor_preview', state))
+        self.io_gui_handler.status_message_requested.connect(self.show_status_message)
+        self.io_gui_handler.update_title_requested.connect(self.update_title)
+        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.brush_tool.setup_ui(self.brush, self.brush_preview, self.image_viewer,
+                                 self.brush_size_slider, self.hardness_slider, self.opacity_slider,
+                                 self.flow_slider)
+        self.image_viewer.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.display_manager = self.display_manager
 
-    def highlight_master_thumbnail(self):
-        self.master_thumbnail_frame.setStyleSheet(
-            f"#thumbnailContainer{{ border: 2px solid {self.thumbnail_highlight}; }}")
-
-    def setup_menu(self):
         menubar = self.menuBar()
         file_menu = menubar.addMenu("&File")
         file_menu.addAction("&Open...", self.io_gui_handler.open_file, "Ctrl+O")
@@ -227,6 +263,7 @@ class ImageEditorUI(ImageFilters):
         self.io_gui_handler.save_master_only = QAction("Save Master &Only", self)
         self.io_gui_handler.save_master_only.setCheckable(True)
         self.io_gui_handler.save_master_only.setChecked(True)
+        self.io_gui_handler.save_master_only.triggered.connect(self.save_master_only)
         file_menu.addAction(self.io_gui_handler.save_master_only)
         self.save_actions_set_enabled(False)
 
@@ -295,6 +332,12 @@ class ImageEditorUI(ImageFilters):
         view_menu.addAction(view_individual_action)
         view_menu.addSeparator()
 
+        toggle_view_master_individual_action = QAction("View Individual", self)
+        toggle_view_master_individual_action.setShortcut("T")
+        toggle_view_master_individual_action.triggered.connect(self.toggle_view_master_individual)
+        view_menu.addAction(toggle_view_master_individual_action)
+        view_menu.addSeparator()
+
         sort_asc_action = QAction("Sort Layers A-Z", self)
         sort_asc_action.triggered.connect(lambda: self.sort_layers('asc'))
         view_menu.addAction(sort_asc_action)
@@ -342,21 +385,254 @@ class ImageEditorUI(ImageFilters):
         white_balance_action = QAction("White Balance", self)
         white_balance_action.triggered.connect(self.white_balance)
         filter_menu.addAction(white_balance_action)
+        vignetting_action = QAction("Vignetting correction", self)
+        vignetting_action.triggered.connect(self.vignetting_correction)
+        filter_menu.addAction(vignetting_action)
 
         help_menu = menubar.addMenu("&Help")
         help_menu.setObjectName("Help")
         shortcuts_help_action = QAction("Shortcuts and mouse", self)
-        shortcuts_help_action.triggered.connect(self.shortcuts_help)
+
+        def shortcuts_help():
+            self.shortcuts_help_dialog = ShortcutsHelp(self)
+            self.shortcuts_help_dialog.exec()
+
+        shortcuts_help_action.triggered.connect(shortcuts_help)
         help_menu.addAction(shortcuts_help_action)
 
+        prev_layer = QShortcut(QKeySequence(Qt.Key_Up), self, context=Qt.ApplicationShortcut)
+        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.installEventFilter(self)
+
+    def update_title(self):
+        title = constants.APP_TITLE
+        if self.io_gui_handler is not None:
+            path = self.io_gui_handler.current_file_path()
+            if path != '':
+                title += f" - {path.split('/')[-1]}"
+                if self.modified:
+                    title += " *"
+        self.window().setWindowTitle(title)
+
+    def show_status_message(self, message):
+        self.statusBar().showMessage(message)
+
+    def mark_as_modified(self, value=True):
+        self.modified = value
+        self.save_actions_set_enabled(value)
+        self.update_title()
+
+    def check_unsaved_changes(self) -> bool:
+        if self.modified:
+            reply = QMessageBox.question(
+                self, "Unsaved Changes",
+                "The image stack has unsaved changes. Do you want to continue?",
+                QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel
+            )
+            if reply == QMessageBox.Save:
+                self.io_gui_handler.save_file()
+                return True
+            if reply == QMessageBox.Discard:
+                return True
+            return False
+        return True
+
+    # pylint: disable=C0103
+    def keyPressEvent(self, event):
+        if self.image_viewer.empty:
+            return
+        if event.text() == '[':
+            self.brush_tool.decrease_brush_size()
+            return
+        if event.text() == ']':
+            self.brush_tool.increase_brush_size()
+            return
+        if event.text() == '{':
+            self.brush_tool.decrease_brush_hardness()
+            return
+        if event.text() == '}':
+            self.brush_tool.increase_brush_hardness()
+            return
+        super().keyPressEvent(event)
+    # pylint: enable=C0103
+
+    def save_master_only(self, _checked):
+        self.update_title()
+
+    def sort_layers(self, order):
+        self.sort_layers(order)
+        self.display_manager.update_thumbnails()
+        self.change_layer(self.current_layer())
+
+    def change_layer(self, layer_idx):
+        if 0 <= layer_idx < self.number_of_layers():
+            view_state = self.image_viewer.get_view_state()
+            self.set_current_layer_idx(layer_idx)
+            self.display_manager.display_current_view()
+            self.image_viewer.set_view_state(view_state)
+            self.thumbnail_list.setCurrentRow(layer_idx)
+            self.thumbnail_list.setFocus()
+            self.image_viewer.update_brush_cursor()
+            self.image_viewer.setFocus()
+
+    def prev_layer(self):
+        if self.layer_stack() is not None:
+            new_idx = max(0, self.current_layer_idx() - 1)
+            if new_idx != self.current_layer_idx():
+                self.change_layer(new_idx)
+                self.display_manager.highlight_thumbnail(new_idx)
+
+    def next_layer(self):
+        if self.layer_stack() is not None:
+            new_idx = min(self.number_of_layers() - 1, self.current_layer_idx() + 1)
+            if new_idx != self.current_layer_idx():
+                self.change_layer(new_idx)
+                self.display_manager.highlight_thumbnail(new_idx)
+
+    def copy_layer_to_master(self):
+        if self.layer_stack() is None or self.master_layer() is None:
+            return
+        reply = QMessageBox.question(
+            self,
+            "Confirm Copy",
+            "Warning: the current master layer will be erased.\n\nDo you want to continue?",
+            QMessageBox.Yes | QMessageBox.No,
+            QMessageBox.No
+        )
+        if reply == QMessageBox.Yes:
+            self.set_master_layer(self.current_layer().copy())
+            self.master_layer().setflags(write=True)
+            self.display_manager.display_current_view()
+            self.display_manager.update_thumbnails()
+            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 not self.display_manager.allow_cursor_preview():
+            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.allow_cursor_preview():
+            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.allow_cursor_preview():
+            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 end_copy_brush_area(self):
+        if self.display_manager.update_timer.isActive():
+            self.display_manager.display_master_layer()
+            self.display_manager.update_master_thumbnail()
+            self.undo_manager.save_undo_state(self.master_layer_copy(), 'Brush Stroke')
+            self.display_manager.update_timer.stop()
+            self.mark_as_modified()
+
+    def update_undo_redo_actions(self, has_undo, undo_desc, has_redo, redo_desc):
+        if self.undo_action:
+            if has_undo:
+                self.undo_action.setText(f"Undo {undo_desc}")
+                self.undo_action.setEnabled(True)
+            else:
+                self.undo_action.setText("Undo")
+                self.undo_action.setEnabled(False)
+        if self.redo_action:
+            if has_redo:
+                self.redo_action.setText(f"Redo {redo_desc}")
+                self.redo_action.setEnabled(True)
+            else:
+                self.redo_action.setText("Redo")
+                self.redo_action.setEnabled(False)
+
+    def denoise_filter(self):
+        self.filter_manager.apply("Denoise")
+
+    def unsharp_mask(self):
+        self.filter_manager.apply("Unsharp Mask")
+
+    def white_balance(self, init_val=None):
+        self.filter_manager.apply("White Balance", init_val=init_val or (128, 128, 128))
+
+    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):
+        self.master_thumbnail_frame.setStyleSheet(
+            f"#thumbnailContainer{{ border: 2px solid {self.thumbnail_highlight}; }}")
+
     def save_actions_set_enabled(self, enabled):
         self.save_action.setEnabled(enabled)
         self.save_as_action.setEnabled(enabled)
         self.io_gui_handler.save_master_only.setEnabled(enabled)
 
     def close_file(self):
-        self.io_gui_handler.close_file()
-        self.save_actions_set_enabled(False)
+        if self.check_unsaved_changes():
+            self.io_gui_handler.close_file()
+            self.set_master_layer(None)
+            self.mark_as_modified(False)
 
     def set_view_master(self):
         self.display_manager.set_view_master()
@@ -368,9 +644,11 @@ class ImageEditorUI(ImageFilters):
         self.thumbnail_highlight = gui_constants.THUMB_MASTER_LO_COLOR
         self.highlight_master_thumbnail()
 
-    def shortcuts_help(self):
-        self._dialog = ShortcutsHelp(self)
-        self._dialog.exec()
+    def toggle_view_master_individual(self):
+        if self.display_manager.view_mode == 'master':
+            self.set_view_individual()
+        else:
+            self.set_view_master()
 
     def toggle_fullscreen(self, checked):
         if checked:

shinestacker/retouch/image_viewer.py

@@ -1,7 +1,8 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0904, R0902, R0914, R0912
 import math
-from PySide6.QtWidgets import QGraphicsView, QGraphicsScene, QGraphicsPixmapItem
-from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush, QCursor, QShortcut, QKeySequence
+from PySide6.QtWidgets import (QGraphicsView, QGraphicsScene, QGraphicsPixmapItem,
+                               QGraphicsEllipseItem)
+from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush, QCursor
 from PySide6.QtCore import Qt, QRectF, QTime, QPoint, QPointF, Signal, QEvent
 from .. config.gui_constants import gui_constants
 from .brush_preview import BrushPreviewItem
@@ -64,8 +65,9 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
         pixmap = QPixmap.fromImage(qimage)
         self.pixmap_item.setPixmap(pixmap)
         self.setSceneRect(QRectF(pixmap.rect()))
-        img_width = pixmap.width()
-        self.min_scale = gui_constants.MIN_ZOOMED_IMG_WIDTH / img_width
+        img_width, img_height = pixmap.width(), pixmap.height()
+        self.min_scale = min(gui_constants.MIN_ZOOMED_IMG_WIDTH / img_width,
+                             gui_constants.MIN_ZOOMED_IMG_HEIGHT / img_height)
         self.max_scale = gui_constants.MAX_ZOOMED_IMG_PX_SIZE
         if self.zoom_factor == 1.0:
             self.fitInView(self.pixmap_item, Qt.KeepAspectRatio)
@@ -221,7 +223,6 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
                         self.zoom_factor = new_scale
             self.update_brush_cursor()
         else:  # Touchpad event - fallback for systems without gesture recognition
-            # Handle touchpad panning (two-finger scroll)
             if not self.control_pressed:
                 delta = event.pixelDelta() or event.angleDelta() / 8
                 if delta:
@@ -318,6 +319,9 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
         self.setCursor(Qt.BlankCursor)
         pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), 1)
         brush = QBrush(QColor(*gui_constants.BRUSH_COLORS['cursor_inner']))
+        for item in self.scene.items():
+            if isinstance(item, QGraphicsEllipseItem):
+                self.scene.removeItem(item)
         self.brush_cursor = self.scene.addEllipse(
             0, 0, self.brush.size, self.brush.size, pen, brush)
         self.brush_cursor.setZValue(1000)
@@ -369,12 +373,6 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
                                       gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor))
         self.brush_cursor.setBrush(QBrush(gradient))
 
-    def setup_shortcuts(self):
-        prev_layer = QShortcut(QKeySequence(Qt.Key_Up), self, context=Qt.ApplicationShortcut)
-        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)
-
     def zoom_in(self):
         if self.empty:
             return
@@ -398,6 +396,11 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
     def reset_zoom(self):
         if self.empty:
             return
+        self.pinch_start_scale = 1.0
+        self.last_scroll_pos = QPointF()
+        self.gesture_active = False
+        self.pinch_center_view = None
+        self.pinch_center_scene = None
         self.fitInView(self.pixmap_item, Qt.KeepAspectRatio)
         self.zoom_factor = self.get_current_scale()
         self.zoom_factor = max(self.min_scale, min(self.max_scale, self.zoom_factor))
@@ -440,3 +443,23 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
         scene_pos = self.mapToScene(pos)
         item_pos = self.pixmap_item.mapFromScene(scene_pos)
         return item_pos
+
+    def get_visible_image_region(self):
+        if self.empty:
+            return None
+        view_rect = self.viewport().rect()
+        scene_rect = self.mapToScene(view_rect).boundingRect()
+        image_rect = self.pixmap_item.mapFromScene(scene_rect).boundingRect()
+        image_rect = image_rect.intersected(self.pixmap_item.boundingRect().toRect())
+        return image_rect
+
+    def get_visible_image_portion(self):
+        if self.has_no_master_layer():
+            return None
+        visible_rect = self.get_visible_image_region()
+        if not visible_rect:
+            return self.master_layer()
+        x, y = int(visible_rect.x()), int(visible_rect.y())
+        w, h = int(visible_rect.width()), int(visible_rect.height())
+        master_img = self.master_layer()
+        return master_img[y:y + h, x:x + w], (x, y, w, h)

shinestacker/retouch/io_gui_handler.py

@@ -14,6 +14,8 @@ from .layer_collection import LayerCollectionHandler
 class IOGuiHandler(QObject, LayerCollectionHandler):
     status_message_requested = Signal(str)
     update_title_requested = Signal()
+    mark_as_modified_requested = Signal(bool)
+    change_layer_requested = Signal(int)
 
     def __init__(self, layer_collection, undo_manager, parent):
         QObject.__init__(self, parent)
@@ -54,16 +56,8 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.set_master_layer(master_layer)
         self.undo_manager.reset()
         self.blank_layer = np.zeros(master_layer.shape[:2])
-        self.display_manager.update_thumbnails()
-        self.image_viewer.setup_brush_cursor()
-        self.image_viewer.reset_zoom()
-        self.status_message_requested.emit(f"Loaded: {self.current_file_path()}")
-        self.update_title_requested.emit()
-        self.current_file_path_master = ''
-        self.current_file_path_multi = ''
-        self.parent().mark_as_modified()
-        self.parent().change_layer(0)
-        self.parent().thumbnail_list.setFocus()
+        self.finish_loading_setup(stack, None, master_layer,
+                                  f"Loaded: {self.current_file_path()}")
 
     def on_file_error(self, error_msg):
         QApplication.restoreOverrideCursor()
@@ -71,6 +65,8 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.loading_dialog.accept()
         self.loading_dialog.deleteLater()
         QMessageBox.critical(self.parent(), "Error", error_msg)
+        self.current_file_path_master = ''
+        self.current_file_path_multi = ''
         self.status_message_requested.emit(f"Error loading: {self.current_file_path()}")
 
     def on_multilayer_save_success(self):
@@ -78,7 +74,7 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.saving_timer.stop()
         self.saving_dialog.hide()
         self.saving_dialog.deleteLater()
-        self.parent().modified = False
+        self.mark_as_modified_requested.emit(False)
         self.update_title_requested.emit()
         self.status_message_requested.emit(f"Saved multilayer to: {self.current_file_path_multi}")
 
@@ -140,20 +136,30 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
             msg.setText(str(e))
             msg.exec()
             return
+        self.finish_loading_setup(stack, labels, master, "Selected frames imported")
+
+    def finish_loading_setup(self, stack, labels, master, message):
         if self.layer_stack() is None and len(stack) > 0:
             self.set_layer_stack(np.array(stack))
-            self.set_layer_labels(labels)
+            if labels is None:
+                labels = self.layer_labels()
+            else:
+                self.set_layer_labels(labels)
             self.set_master_layer(master)
             self.blank_layer = np.zeros(master.shape[:2])
         else:
+            if labels is None:
+                labels = self.layer_labels()
             for img, label in zip(stack, labels):
                 self.add_layer_label(label)
                 self.add_layer(img)
-        self.parent().mark_as_modified()
-        self.parent().change_layer(0)
-        self.image_viewer.reset_zoom()
-        self.parent().thumbnail_list.setFocus()
         self.display_manager.update_thumbnails()
+        self.mark_as_modified_requested.emit(True)
+        self.change_layer_requested.emit(0)
+        self.image_viewer.setup_brush_cursor()
+        self.image_viewer.reset_zoom()
+        self.status_message_requested.emit(message)
+        self.update_title_requested.emit()
 
     def save_file(self):
         if self.save_master_only.isChecked():
@@ -239,7 +245,7 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         try:
             self.io_manager.save_master(path)
             self.current_file_path_master = os.path.abspath(path)
-            self.parent().modified = False
+            self.mark_as_modified_requested.emit(False)
             self.update_title_requested.emit()
             self.status_message_requested.emit(f"Saved master layer to: {path}")
         except Exception as e:
@@ -255,16 +261,14 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.exif_dialog.exec()
 
     def close_file(self):
-        if self.parent().check_unsaved_changes():
-            self.set_master_layer(None)
-            self.blank_layer = None
-            self.layer_collection.reset()
-            self.current_file_path_master = ''
-            self.current_file_path_multi = ''
-            self.parent().modified = False
-            self.undo_manager.reset()
-            self.image_viewer.clear_image()
-            self.display_manager.thumbnail_list.clear()
-            self.display_manager.update_thumbnails()
-            self.update_title_requested.emit()
-            self.status_message_requested.emit("File closed")
+        self.mark_as_modified_requested.emit(False)
+        self.blank_layer = None
+        self.layer_collection.reset()
+        self.current_file_path_master = ''
+        self.current_file_path_multi = ''
+        self.undo_manager.reset()
+        self.image_viewer.clear_image()
+        self.display_manager.thumbnail_list.clear()
+        self.display_manager.update_thumbnails()
+        self.update_title_requested.emit()
+        self.status_message_requested.emit("File closed")

shinestacker/retouch/layer_collection.py

@@ -32,6 +32,8 @@ class LayerCollection:
         return self.master_layer_copy is None
 
     def number_of_layers(self):
+        if self.layer_stack is None:
+            return 0
         return len(self.layer_stack)
 
     def layer_label(self, i):

shinestacker/retouch/shortcuts_help.py

@@ -32,6 +32,7 @@ class ShortcutsHelp(QDialog):
         self.create_form(left_layout, right_layout)
         button_box = QHBoxLayout()
         ok_button = QPushButton("OK")
+        ok_button.setFixedWidth(100)
         ok_button.setFocus()
         button_box.addWidget(ok_button)
         self.layout.addLayout(button_box)
@@ -48,6 +49,7 @@ class ShortcutsHelp(QDialog):
         shortcuts = {
             "M": "show master layer",
             "L": "show selected layer",
+            "T": "toggle master/selected layer",
             "X": "temp. toggle between master and source layer",
             "↑": "select one layer up",
             "↓": "selcet one layer down",
@@ -80,3 +82,13 @@ class ShortcutsHelp(QDialog):
         self.add_bold_label(right_layout, "Mouse Controls")
         for k, v in mouse_controls.items():
             right_layout.addRow(f"<b>{k}</b>", QLabel(v))
+
+        touchpad_controls = {
+            "Two fingers": "pan",
+            "Pinch": "zoom in/out",
+            "Ctrl + two fingers": "zoom in/out",
+        }
+        self.add_bold_label(right_layout, " ")
+        self.add_bold_label(right_layout, "Touchpad Controls")
+        for k, v in touchpad_controls.items():
+            right_layout.addRow(f"<b>{k}</b>", QLabel(v))