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

shinestacker/gui/actions_window.py

@@ -30,6 +30,7 @@ class ActionsWindow(ProjectEditor):
     def mark_as_modified(self):
         self._modified_project = True
         self.project_buffer.append(self.project.clone())
+        self.save_actions_set_enabled(True)
         self.update_title()
 
     def close_project(self):
@@ -40,6 +41,7 @@ class ActionsWindow(ProjectEditor):
             self.job_list.clear()
             self.action_list.clear()
             self._modified_project = False
+            self.save_actions_set_enabled(False)
 
     def new_project(self):
         if not self._check_unsaved_changes():
@@ -51,8 +53,10 @@ class ActionsWindow(ProjectEditor):
         self.job_list.clear()
         self.action_list.clear()
         self.set_project(Project())
+        self.save_actions_set_enabled(False)
         dialog = NewProjectDialog(self)
         if dialog.exec() == QDialog.Accepted:
+            self.save_actions_set_enabled(True)
             input_folder = dialog.get_input_folder().split('/')
             working_path = '/'.join(input_folder[:-1])
             input_path = input_folder[-1]
@@ -142,6 +146,7 @@ class ActionsWindow(ProjectEditor):
             if len(self.project.jobs) > 0:
                 self.job_list.setCurrentRow(0)
                 self.activateWindow()
+                self.save_actions_set_enabled(True)
             for job in self.project.jobs:
                 if 'working_path' in job.params.keys():
                     working_path = job.params['working_path']
@@ -256,3 +261,6 @@ class ActionsWindow(ProjectEditor):
         if dialog.exec() == QDialog.Accepted:
             self.on_job_selected(self.job_list.currentRow())
             self.mark_as_modified()
+
+    def save_actions_set_enabled(self, enabled):
+        pass

shinestacker/gui/gui_logging.py

@@ -17,6 +17,7 @@ class SimpleHtmlFormatter(logging.Formatter):
     FF = '80'
     OO = '00'
     MM = '40'
+    GG = 'FF'
     ANSI_COLORS = {
         # Reset
         '\x1b[0m': '</span>',
@@ -32,13 +33,13 @@ class SimpleHtmlFormatter(logging.Formatter):
         '\x1b[37m': f'<span style="color:#{FF}{FF}{FF}">',  # white
         # Brilliant colors (90-97)
         '\x1b[90m': f'<span style="color:#{MM}{MM}{MM}">',
-        '\x1b[91m': f'<span style="color:#{FF}{MM}{MM}">',
-        '\x1b[92m': f'<span style="color:#{MM}{FF}{MM}">',
-        '\x1b[93m': f'<span style="color:#{FF}{FF}{MM}">',
-        '\x1b[94m': f'<span style="color:#{MM}{MM}{FF}">',
-        '\x1b[95m': f'<span style="color:#{FF}{MM}{FF}">',
-        '\x1b[96m': f'<span style="color:#{MM}{FF}{FF}">',
-        '\x1b[97m': f'<span style="color:#{FF}{FF}{FF}">',
+        '\x1b[91m': f'<span style="color:#{GG}{MM}{MM}">',
+        '\x1b[92m': f'<span style="color:#{MM}{GG}{MM}">',
+        '\x1b[93m': f'<span style="color:#{GG}{GG}{MM}">',
+        '\x1b[94m': f'<span style="color:#{MM}{MM}{GG}">',
+        '\x1b[95m': f'<span style="color:#{GG}{MM}{GG}">',
+        '\x1b[96m': f'<span style="color:#{MM}{GG}{GG}">',
+        '\x1b[97m': f'<span style="color:#{GG}{GG}{GG}">',
         # Background (40-47)
         '\x1b[40m': f'<span style="background-color:#{OO}{OO}{OO}">',
         '\x1b[41m': f'<span style="background-color:#{FF}{OO}{OO}">',

shinestacker/gui/gui_run.py

@@ -13,6 +13,10 @@ from .gui_images import GuiPdfView, GuiImageView, GuiOpenApp
 from .colors import ColorPalette
 
 
+ACTION_RUNNING_COLOR = ColorPalette.MEDIUM_BLUE
+ACTION_DONE_COLOR = ColorPalette.MEDIUM_GREEN
+
+
 class ColorButton(QPushButton):
     def __init__(self, text, enabled, parent=None):
         super().__init__(text.replace(gui_constants.DISABLED_TAG, ''), parent)
@@ -36,10 +40,6 @@ class ColorButton(QPushButton):
         """)
 
 
-action_running_color = ColorPalette.MEDIUM_BLUE
-action_done_color = ColorPalette.MEDIUM_GREEN
-
-
 class TimerProgressBar(QProgressBar):
     light_background_color = ColorPalette.LIGHT_BLUE
     border_color = ColorPalette.DARK_BLUE
@@ -123,10 +123,10 @@ class TimerProgressBar(QProgressBar):
     # pylint: enable=C0103
 
     def set_running_style(self):
-        self.set_style(action_running_color)
+        self.set_style(ACTION_RUNNING_COLOR)
 
     def set_done_style(self):
-        self.set_style(action_done_color)
+        self.set_style(ACTION_DONE_COLOR)
 
 
 class RunWindow(QTextEditLogger):
@@ -246,7 +246,7 @@ class RunWindow(QTextEditLogger):
     @Slot(int, str)
     def handle_before_action(self, run_id, _name):
         if 0 <= run_id < len(self.color_widgets[self.row_widget_id]):
-            self.color_widgets[self.row_widget_id][run_id].set_color(*action_running_color.tuple())
+            self.color_widgets[self.row_widget_id][run_id].set_color(*ACTION_RUNNING_COLOR.tuple())
             self.progress_bar.start(1)
         if run_id == -1:
             self.progress_bar.set_running_style()
@@ -254,7 +254,7 @@ class RunWindow(QTextEditLogger):
     @Slot(int, str)
     def handle_after_action(self, run_id, _name):
         if 0 <= run_id < len(self.color_widgets[self.row_widget_id]):
-            self.color_widgets[self.row_widget_id][run_id].set_color(*action_done_color.tuple())
+            self.color_widgets[self.row_widget_id][run_id].set_color(*ACTION_DONE_COLOR.tuple())
             self.progress_bar.stop()
         if run_id == -1:
             self.row_widget_id += 1

shinestacker/gui/main_window.py

@@ -163,11 +163,11 @@ class MainWindow(ActionsWindow, LogManager):
         self.action_list.itemDoubleClicked.connect(self.on_action_edit)
         vbox_left = QVBoxLayout()
         vbox_left.setSpacing(4)
-        vbox_left.addWidget(QLabel("Jobs"))
+        vbox_left.addWidget(QLabel("Job"))
         vbox_left.addWidget(self.job_list)
         vbox_right = QVBoxLayout()
         vbox_right.setSpacing(4)
-        vbox_right.addWidget(QLabel("Actions"))
+        vbox_right.addWidget(QLabel("Action"))
         vbox_right.addWidget(self.action_list)
         self.job_list.itemSelectionChanged.connect(self.update_delete_action_state)
         self.action_list.itemSelectionChanged.connect(self.update_delete_action_state)
@@ -189,19 +189,24 @@ class MainWindow(ActionsWindow, LogManager):
         open_action.setShortcut("Ctrl+O")
         open_action.triggered.connect(self.open_project)
         menu.addAction(open_action)
-        save_action = QAction("&Save", self)
-        save_action.setShortcut("Ctrl+S")
-        save_action.triggered.connect(self.save_project)
-        menu.addAction(save_action)
-        save_as_action = QAction("Save &As...", self)
-        save_as_action.setShortcut("Ctrl+Shift+S")
-        save_as_action.triggered.connect(self.save_project_as)
-        menu.addAction(save_as_action)
+        self.save_action = QAction("&Save", self)
+        self.save_action.setShortcut("Ctrl+S")
+        self.save_action.triggered.connect(self.save_project)
+        menu.addAction(self.save_action)
+        self.save_as_action = QAction("Save &As...", self)
+        self.save_as_action.setShortcut("Ctrl+Shift+S")
+        self.save_as_action.triggered.connect(self.save_project_as)
+        menu.addAction(self.save_as_action)
+        self.save_actions_set_enabled(False)
         close_action = QAction("&Close", self)
         close_action.setShortcut("Ctrl+W")
         close_action.triggered.connect(self.close_project)
         menu.addAction(close_action)
 
+    def save_actions_set_enabled(self, enabled):
+        self.save_action.setEnabled(enabled)
+        self.save_as_action.setEnabled(enabled)
+
     def add_edit_menu(self, menubar):
         menu = menubar.addMenu("&Edit")
         undo_action = QAction("&Undo", self)
@@ -615,7 +620,7 @@ class MainWindow(ActionsWindow, LogManager):
                 labels = [[(self.action_text(a), a.enabled()) for a in job.sub_actions]]
                 r = self.get_retouch_path(job)
                 retouch_paths = [] if len(r) == 0 else [(job_name, r)]
-                new_window, id_str = self.create_new_window("Job: " + job_name,
+                new_window, id_str = self.create_new_window(f"{job_name} [⚙️ Job]",
                                                             labels, retouch_paths)
                 worker = JobLogWorker(job, id_str)
                 self.connect_signals(worker, new_window)
@@ -638,7 +643,7 @@ class MainWindow(ActionsWindow, LogManager):
             r = self.get_retouch_path(job)
             if len(r) > 0:
                 retouch_paths.append((job.params["name"], r))
-        new_window, id_str = self.create_new_window("Project: " + project_name,
+        new_window, id_str = self.create_new_window(f"{project_name} [Project 📚]",
                                                     labels, retouch_paths)
         worker = ProjectLogWorker(self.project, id_str)
         self.connect_signals(worker, new_window)

shinestacker/gui/new_project.py

@@ -9,6 +9,8 @@ from .. config.constants import constants
 from .. algorithms.stack import get_bunches
 from .select_path_widget import create_select_file_paths_widget
 
+DEFAULT_NO_COUNT_LABEL = " - "
+
 
 class NewProjectDialog(QDialog):
     def __init__(self, parent=None):
@@ -51,8 +53,9 @@ class NewProjectDialog(QDialog):
         spacer.setFixedHeight(10)
         self.layout.addRow(spacer)
 
-        container = create_select_file_paths_widget('', 'input files folder', 'input files folder')
-
+        self.input_folder, container = create_select_file_paths_widget(
+            '', 'input files folder', 'input files folder')
+        self.input_folder.textChanged.connect(self.update_bunches_label)
         self.noise_detection = QCheckBox()
         self.noise_detection.setChecked(gui_constants.NEW_PROJECT_NOISE_DETECTION)
         self.vignetting_correction = QCheckBox()
@@ -72,7 +75,8 @@ class NewProjectDialog(QDialog):
         bunch_overlap_range = gui_constants.NEW_PROJECT_BUNCH_OVERLAP
         self.bunch_overlap.setRange(bunch_overlap_range['min'], bunch_overlap_range['max'])
         self.bunch_overlap.setValue(constants.DEFAULT_OVERLAP)
-        self.bunches_label = QLabel("")
+        self.bunches_label = QLabel(DEFAULT_NO_COUNT_LABEL)
+        self.frames_label = QLabel(DEFAULT_NO_COUNT_LABEL)
 
         self.update_bunch_options(gui_constants.NEW_PROJECT_BUNCH_STACK)
         self.bunch_stack.toggled.connect(self.update_bunch_options)
@@ -88,6 +92,7 @@ class NewProjectDialog(QDialog):
 
         self.add_bold_label("Select input:")
         self.layout.addRow("Input folder:", container)
+        self.layout.addRow("Number of frames: ", self.frames_label)
         self.add_bold_label("Select actions:")
         if self.expert():
             self.layout.addRow("Automatic noise detection:", self.noise_detection)
@@ -111,25 +116,34 @@ class NewProjectDialog(QDialog):
         self.update_bunches_label()
 
     def update_bunches_label(self):
+        if not self.input_folder.text():
+            return
+
+        def count_image_files(path):
+            if path == '' or not os.path.isdir(path):
+                return 0
+            extensions = ['jpg', 'jpeg', 'tif', 'tiff']
+            count = 0
+            for filename in os.listdir(path):
+                if '.' in filename:
+                    ext = filename.lower().split('.')[-1]
+                    if ext in extensions:
+                        count += 1
+            return count
+
+        n_image_files = count_image_files(self.input_folder.text())
+        if n_image_files == 0:
+            self.bunches_label.setText(DEFAULT_NO_COUNT_LABEL)
+            self.frames_label.setText(DEFAULT_NO_COUNT_LABEL)
+            return
+        self.frames_label.setText(f"{n_image_files}")
         if self.bunch_stack.isChecked():
-            def count_image_files(path):
-                if path == '' or not os.path.isdir(path):
-                    return 0
-                extensions = ['jpg', 'jpeg', 'tif', 'tiff']
-                count = 0
-                for filename in os.listdir(path):
-                    if '.' in filename:
-                        ext = filename.lower().split('.')[-1]
-                        if ext in extensions:
-                            count += 1
-                return count
-
-            bunches = get_bunches(list(range(count_image_files(self.input_folder.text()))),
+            bunches = get_bunches(list(range(n_image_files)),
                                   self.bunch_frames.value(),
                                   self.bunch_overlap.value())
             self.bunches_label.setText(f"{len(bunches)}")
         else:
-            self.bunches_label.setText(" - ")
+            self.bunches_label.setText(DEFAULT_NO_COUNT_LABEL)
 
     def accept(self):
         input_folder = self.input_folder.text()

shinestacker/gui/project_converter.py

@@ -112,7 +112,6 @@ class ProjectConverter:
             else:
                 raise InvalidOptionError('stacker', stacker, f"valid options are: "
                                          f"{constants.STACK_ALGO_PYRAMID}, "
-                                         f"{constants.STACK_ALGO_PYRAMID_BLOCK}, "
                                          f"{constants.STACK_ALGO_DEPTH_MAP}")
             if action_config.type_name == constants.ACTION_FOCUSSTACK:
                 return FocusStack(**module_dict, stack_algo=stack_algo)

shinestacker/gui/select_path_widget.py

@@ -9,6 +9,7 @@ def create_layout_widget_no_margins(layout):
     container.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
     return container
 
+
 def create_layout_widget_and_connect(button, edit, browse):
     button.clicked.connect(browse)
     button.setAutoDefault(False)
@@ -17,6 +18,7 @@ def create_layout_widget_and_connect(button, edit, browse):
     layout.addWidget(button)
     return create_layout_widget_no_margins(layout)
 
+
 def create_select_file_paths_widget(value, placeholder, tag):
     edit = QLineEdit(value)
     edit.setPlaceholderText(placeholder)
@@ -27,4 +29,4 @@ def create_select_file_paths_widget(value, placeholder, tag):
         if path:
             edit.setText(path)
 
-    return create_layout_widget_and_connect(button, edit, browse)
+    return edit, create_layout_widget_and_connect(button, edit, browse)

shinestacker/retouch/brush_tool.py

@@ -1,6 +1,7 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0902, R0913, R0917, R0914
 import numpy as np
-from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush
+from PySide6.QtWidgets import QApplication, QLabel
+from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush, QFont
 from PySide6.QtCore import Qt, QPoint
 from .brush_gradient import create_default_brush_gradient
 from .. config.gui_constants import gui_constants
@@ -18,11 +19,16 @@ class BrushTool:
         self.opacity_slider = None
         self.flow_slider = None
         self._brush_mask_cache = {}
+        self.brush_text = None
 
     def setup_ui(self, brush, brush_preview, image_viewer, size_slider, hardness_slider,
                  opacity_slider, flow_slider):
         self.brush = brush
         self.brush_preview = brush_preview
+        self.brush_text = QLabel(brush_preview.parent())
+        self.brush_text.setStyleSheet("color: navy; background: transparent;")
+        self.brush_text.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.brush_text.raise_()
         self.image_viewer = image_viewer
         self.size_slider = size_slider
         self.hardness_slider = hardness_slider
@@ -86,7 +92,7 @@ class BrushTool:
         pixmap = QPixmap(width, height)
         pixmap.fill(Qt.transparent)
         painter = QPainter(pixmap)
-        painter.setRenderHint(QPainter.Antialiasing)
+        painter.setRenderHint(QPainter.TextAntialiasing, True)
         preview_size = min(self.brush.size, width + 30, height + 30)
         center_x, center_y = width // 2, height // 2
         radius = preview_size // 2
@@ -109,10 +115,21 @@ class BrushTool:
         painter.drawEllipse(QPoint(center_x, center_y), radius, radius)
         if self.image_viewer.cursor_style == 'preview':
             painter.setPen(QPen(QColor(0, 0, 160)))
-            painter.drawText(0, 10, f"Size: {int(self.brush.size)}px")
-            painter.drawText(0, 25, f"Hardness: {self.brush.hardness}%")
-            painter.drawText(0, 40, f"Opacity: {self.brush.opacity}%")
-            painter.drawText(0, 55, f"Flow: {self.brush.flow}%")
+            font = QApplication.font()
+            painter.setFont(font)
+            font.setHintingPreference(QFont.PreferFullHinting)
+            painter.setFont(font)
+            self.brush_text.setText(
+                f"Size: {int(self.brush.size)}px\n"
+                f"Hardness: {self.brush.hardness}%\n"
+                f"Opacity: {self.brush.opacity}%\n"
+                f"Flow: {self.brush.flow}%"
+            )
+            self.brush_text.adjustSize()
+            self.brush_text.move(10, self.brush_preview.height() // 2 + 125)
+            self.brush_text.show()
+        else:
+            self.brush_text.hide()
         painter.end()
         self.brush_preview.setPixmap(pixmap)
         self.image_viewer.update_brush_cursor()

shinestacker/retouch/display_manager.py

@@ -1,6 +1,7 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0903, R0913, R0917, E1121
+# pylint: disable=C0114, C0115, C0116, E0611, R0903, R0913, R0917, E1121, R0902
 import numpy as np
-from PySide6.QtWidgets import QWidget, QListWidgetItem, QVBoxLayout, QLabel, QInputDialog
+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 .. config.gui_constants import gui_constants
@@ -39,6 +40,7 @@ class DisplayManager(QObject, LayerCollectionHandler):
         self.update_timer = QTimer()
         self.update_timer.setInterval(gui_constants.PAINT_REFRESH_TIMER)
         self.update_timer.timeout.connect(self.process_pending_updates)
+        self.thumbnail_highlight = gui_constants.THUMB_LO_COLOR
 
     def process_pending_updates(self):
         if self.needs_update:
@@ -64,15 +66,15 @@ class DisplayManager(QObject, LayerCollectionHandler):
             self.display_master_layer()
 
     def create_thumbnail(self, layer):
-        if layer.dtype == np.uint16:
-            layer = (layer // 256).astype(np.uint8)
-        height, width = layer.shape[:2]
-        if layer.ndim == 3 and layer.shape[-1] == 3:
-            qimg = QImage(layer.data, width, height, 3 * width, QImage.Format_RGB888)
+        source_layer = (layer // 256).astype(np.uint8) if layer.dtype == np.uint16 else layer
+        height, width = source_layer.shape[:2]
+        if layer.ndim == 3 and source_layer.shape[-1] == 3:
+            qimg = QImage(source_layer.data, width, height, 3 * width, QImage.Format_RGB888)
         else:
-            qimg = QImage(layer.data, width, height, width, QImage.Format_Grayscale8)
+            qimg = QImage(source_layer.data, width, height, width, QImage.Format_Grayscale8)
         return QPixmap.fromImage(
-            qimg.scaled(*gui_constants.UI_SIZES['thumbnail'], Qt.KeepAspectRatio))
+            qimg.scaledToWidth(
+                gui_constants.UI_SIZES['thumbnail_width'], Qt.SmoothTransformation))
 
     def update_thumbnails(self):
         self.update_master_thumbnail()
@@ -103,17 +105,22 @@ class DisplayManager(QObject, LayerCollectionHandler):
         self.master_thumbnail_label.setPixmap(pixmap)
 
     def add_thumbnail_item(self, thumbnail, label, i, is_current):
-        item_widget = QWidget()
-        layout = QVBoxLayout(item_widget)
-        layout.setContentsMargins(0, 0, 0, 0)
-        layout.setSpacing(0)
-
+        container = QWidget()
+        container.setFixedWidth(gui_constants.UI_SIZES['thumbnail_width'] + 4)
+        container.setObjectName("thumbnailContainer")
+        container_layout = QVBoxLayout(container)
+        container_layout.setContentsMargins(2, 2, 2, 2)
+        container_layout.setSpacing(0)
+        content_widget = QWidget()
+        content_layout = QVBoxLayout(content_widget)
+        content_layout.setContentsMargins(0, 0, 0, 0)
+        content_layout.setSpacing(0)
         thumbnail_label = QLabel()
         thumbnail_label.setPixmap(thumbnail)
         thumbnail_label.setAlignment(Qt.AlignCenter)
-        layout.addWidget(thumbnail_label)
-
+        content_layout.addWidget(thumbnail_label)
         label_widget = ClickableLabel(label)
+        label_widget.setFixedHeight(gui_constants.UI_SIZES['label_height'])
         label_widget.setAlignment(Qt.AlignCenter)
 
         def rename_label(label_widget, old_label, i):
@@ -124,21 +131,45 @@ class DisplayManager(QObject, LayerCollectionHandler):
                 self.set_layer_labels(i, new_label)
 
         label_widget.double_clicked.connect(lambda: rename_label(label_widget, label, i))
-        layout.addWidget(label_widget)
+        content_layout.addWidget(label_widget)
+        container_layout.addWidget(content_widget)
+        if is_current:
+            container.setStyleSheet(
+                f"#thumbnailContainer{{ border: 2px solid {self.thumbnail_highlight}; }}")
+        else:
+            container.setStyleSheet("#thumbnailContainer{ border: 2px solid transparent; }")
         item = QListWidgetItem()
-        item.setSizeHint(QSize(gui_constants.IMG_WIDTH, gui_constants.IMG_HEIGHT))
+        item.setSizeHint(QSize(gui_constants.UI_SIZES['thumbnail_width'] + 4,
+                               thumbnail.height() + label_widget.height() + 4))
         self.thumbnail_list.addItem(item)
-        self.thumbnail_list.setItemWidget(item, item_widget)
-
+        self.thumbnail_list.setItemWidget(item, container)
         if is_current:
             self.thumbnail_list.setCurrentItem(item)
 
+    def highlight_thumbnail(self, index):
+        for i in range(self.thumbnail_list.count()):
+            item = self.thumbnail_list.item(i)
+            widget = self.thumbnail_list.itemWidget(item)
+            if widget:
+                widget.setStyleSheet("#thumbnailContainer{ border: 2px solid transparent; }")
+        current_item = self.thumbnail_list.item(index)
+        if current_item:
+            widget = self.thumbnail_list.itemWidget(current_item)
+            if widget:
+                widget.setStyleSheet(
+                    f"#thumbnailContainer{{ border: 2px solid {self.thumbnail_highlight}; }}")
+        self.thumbnail_list.setCurrentRow(index)
+        self.thumbnail_list.scrollToItem(
+            self.thumbnail_list.item(index), QAbstractItemView.PositionAtCenter)
+
     def set_view_master(self):
         if self.has_no_master_layer():
             return
         self.view_mode = 'master'
         self.temp_view_individual = False
         self.display_master_layer()
+        self.thumbnail_highlight = gui_constants.THUMB_LO_COLOR
+        self.highlight_thumbnail(self.current_layer_idx())
         self.status_message_requested.emit("View mode: Master")
         self.cursor_preview_state_changed.emit(True)  # True = allow preview
 
@@ -148,6 +179,8 @@ class DisplayManager(QObject, LayerCollectionHandler):
         self.view_mode = 'individual'
         self.temp_view_individual = False
         self.display_current_layer()
+        self.thumbnail_highlight = gui_constants.THUMB_HI_COLOR
+        self.highlight_thumbnail(self.current_layer_idx())
         self.status_message_requested.emit("View mode: Individual layers")
         self.cursor_preview_state_changed.emit(False)  # False = no preview
 
@@ -155,6 +188,8 @@ class DisplayManager(QObject, LayerCollectionHandler):
         if not self.temp_view_individual and self.view_mode == 'master':
             self.temp_view_individual = True
             self.image_viewer.update_brush_cursor()
+            self.thumbnail_highlight = gui_constants.THUMB_HI_COLOR
+            self.highlight_thumbnail(self.current_layer_idx())
             self.display_current_layer()
             self.status_message_requested.emit("Temporary view: Individual layer (hold X)")
 
@@ -162,6 +197,8 @@ class DisplayManager(QObject, LayerCollectionHandler):
         if self.temp_view_individual:
             self.temp_view_individual = False
             self.image_viewer.update_brush_cursor()
+            self.thumbnail_highlight = gui_constants.THUMB_LO_COLOR
+            self.highlight_thumbnail(self.current_layer_idx())
             self.display_master_layer()
             self.status_message_requested.emit("View mode: Master")
             self.cursor_preview_state_changed.emit(True)  # Restore preview

shinestacker/retouch/image_editor.py

@@ -1,5 +1,5 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0902
-from PySide6.QtWidgets import QMainWindow, QMessageBox, QAbstractItemView
+from PySide6.QtWidgets import QMainWindow, QMessageBox
 from .. config.constants import constants
 from .undo_manager import UndoManager
 from .layer_collection import LayerCollection
@@ -87,7 +87,7 @@ class ImageEditor(QMainWindow, LayerCollectionHandler):
     def update_title(self):
         title = constants.APP_TITLE
         if self.io_gui_handler is not None:
-            path = self.io_gui_handler.io_manager.current_file_path
+            path = self.io_gui_handler.current_file_path()
             if path != '':
                 title += f" - {path.split('/')[-1]}"
                 if self.modified:
@@ -96,6 +96,7 @@ class ImageEditor(QMainWindow, LayerCollectionHandler):
 
     def mark_as_modified(self):
         self.modified = True
+        self.save_actions_set_enabled(True)
         self.update_title()
 
     def change_layer(self, layer_idx):
@@ -114,19 +115,14 @@ class ImageEditor(QMainWindow, LayerCollectionHandler):
             new_idx = max(0, self.current_layer_idx() - 1)
             if new_idx != self.current_layer_idx():
                 self.change_layer(new_idx)
-                self.highlight_thumbnail(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.highlight_thumbnail(new_idx)
-
-    def highlight_thumbnail(self, index):
-        self.thumbnail_list.setCurrentRow(index)
-        self.thumbnail_list.scrollToItem(
-            self.thumbnail_list.item(index), QAbstractItemView.PositionAtCenter)
+                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: