shinestacker 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

shinestacker/gui/new_project.py

@@ -1,15 +1,15 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0915, R0902
+# pylint: disable=C0114, C0115, C0116, E0611, R0915, R0902, R0914, R0911, R0912, R0904
 import os
 import numpy as np
 from PySide6.QtWidgets import (QHBoxLayout, QPushButton, QLabel, QCheckBox, QSpinBox,
-                               QMessageBox)
+                               QMessageBox, QGroupBox, QVBoxLayout, QFormLayout, QSizePolicy)
 from PySide6.QtGui import QIcon
 from PySide6.QtCore import Qt
 from .. config.gui_constants import gui_constants
 from .. config.constants import constants
 from .. algorithms.utils import read_img, extension_tif_jpg
 from .. algorithms.stack import get_bunches
-from .select_path_widget import create_select_file_paths_widget
+from .folder_file_selection import FolderFileSelectionWidget
 from .base_form_dialog import BaseFormDialog
 
 DEFAULT_NO_COUNT_LABEL = " - "
@@ -17,18 +17,18 @@ DEFAULT_NO_COUNT_LABEL = " - "
 
 class NewProjectDialog(BaseFormDialog):
     def __init__(self, parent=None):
-        super().__init__("New Project", parent)
+        super().__init__("New Project", 600, parent)
         self.create_form()
         button_box = QHBoxLayout()
-        ok_button = QPushButton("OK")
-        ok_button.setFocus()
+        self.ok_button = QPushButton("OK")
         cancel_button = QPushButton("Cancel")
-        button_box.addWidget(ok_button)
+        button_box.addWidget(self.ok_button)
         button_box.addWidget(cancel_button)
         self.add_row_to_layout(button_box)
-        ok_button.clicked.connect(self.accept)
+        self.ok_button.clicked.connect(self.accept)
         cancel_button.clicked.connect(self.reject)
         self.n_image_files = 0
+        self.selected_filenames = []
 
     def expert(self):
         return self.parent().expert_options
@@ -43,20 +43,8 @@ class NewProjectDialog(BaseFormDialog):
         self.form_layout.addRow(label)
 
     def create_form(self):
-        icon_path = f"{os.path.dirname(__file__)}/ico/shinestacker.png"
-        app_icon = QIcon(icon_path)
-        icon_pixmap = app_icon.pixmap(128, 128)
-        icon_label = QLabel()
-        icon_label.setPixmap(icon_pixmap)
-        icon_label.setAlignment(Qt.AlignCenter)
-        self.form_layout.addRow(icon_label)
-        spacer = QLabel("")
-        spacer.setFixedHeight(10)
-        self.form_layout.addRow(spacer)
-
-        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.input_widget = FolderFileSelectionWidget()
+        self.input_widget.text_changed_connect(self.input_submitted)
         self.noise_detection = QCheckBox()
         self.noise_detection.setChecked(gui_constants.NEW_PROJECT_NOISE_DETECTION)
         self.vignetting_correction = QCheckBox()
@@ -65,7 +53,6 @@ class NewProjectDialog(BaseFormDialog):
         self.align_frames.setChecked(gui_constants.NEW_PROJECT_ALIGN_FRAMES)
         self.balance_frames = QCheckBox()
         self.balance_frames.setChecked(gui_constants.NEW_PROJECT_BALANCE_FRAMES)
-
         self.bunch_stack = QCheckBox()
         self.bunch_stack.setChecked(gui_constants.NEW_PROJECT_BUNCH_STACK)
         self.bunch_frames = QSpinBox()
@@ -78,46 +65,121 @@ class NewProjectDialog(BaseFormDialog):
         self.bunch_overlap.setValue(constants.DEFAULT_OVERLAP)
         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)
         self.bunch_frames.valueChanged.connect(self.update_bunches_label)
         self.bunch_overlap.valueChanged.connect(self.update_bunches_label)
-
         self.focus_stack_pyramid = QCheckBox()
         self.focus_stack_pyramid.setChecked(gui_constants.NEW_PROJECT_FOCUS_STACK_PYRAMID)
         self.focus_stack_depth_map = QCheckBox()
         self.focus_stack_depth_map.setChecked(gui_constants.NEW_PROJECT_FOCUS_STACK_DEPTH_MAP)
         self.multi_layer = QCheckBox()
         self.multi_layer.setChecked(gui_constants.NEW_PROJECT_MULTI_LAYER)
-
-        self.add_bold_label("1️⃣ Select input folder, all images therein will be merged. ")
-        self.form_layout.addRow("Input folder:", container)
-        self.form_layout.addRow("Number of frames: ", self.frames_label)
-        self.add_label("")
-        self.add_bold_label("2️⃣ Select basic options.")
+        step1_group = QGroupBox("1️⃣ Select Input")
+        step1_layout = QVBoxLayout()
+        step1_layout.setContentsMargins(15, 0, 15, 15)
+        step1_layout.addWidget(
+            QLabel("Select a folder containing "
+                   "all your images, or specific image files."))
+        input_form = QFormLayout()
+        input_form.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
+        input_form.setFormAlignment(Qt.AlignLeft)
+        input_form.setLabelAlignment(Qt.AlignLeft)
+        self.input_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
+        self.frames_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
+        input_form.addRow("Input:", self.input_widget)
+        input_form.addRow("Number of frames: ", self.frames_label)
+        step1_layout.addLayout(input_form)
+        step1_group.setLayout(step1_layout)
+        self.form_layout.addRow(step1_group)
+        step2_group = QGroupBox("2️⃣ Basic Options")
+        step2_layout = QFormLayout()
+        step2_layout.setContentsMargins(15, 0, 15, 15)
+        step2_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
+        step2_layout.setFormAlignment(Qt.AlignLeft)
+        step2_layout.setLabelAlignment(Qt.AlignLeft)
+        for widget in [self.noise_detection, self.vignetting_correction, self.align_frames,
+                       self.balance_frames, self.bunch_stack, self.bunch_frames,
+                       self.bunch_overlap, self.focus_stack_pyramid,
+                       self.focus_stack_depth_map, self.multi_layer]:
+            widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
         if self.expert():
-            self.form_layout.addRow("Automatic noise detection:", self.noise_detection)
-            self.form_layout.addRow("Vignetting correction:", self.vignetting_correction)
-        self.form_layout.addRow("Align layers:", self.align_frames)
-        self.form_layout.addRow("Balance layers:", self.balance_frames)
-        self.form_layout.addRow("Bunch stack:", self.bunch_stack)
-        self.form_layout.addRow("Bunch frames:", self.bunch_frames)
-        self.form_layout.addRow("Bunch overlap:", self.bunch_overlap)
-        self.form_layout.addRow("Number of bunches: ", self.bunches_label)
+            step2_layout.addRow("Automatic noise detection:", self.noise_detection)
+            step2_layout.addRow("Vignetting correction:", self.vignetting_correction)
+        step2_layout.addRow(
+            # f" {constants.ACTION_ICONS[constants.ACTION_ALIGNFRAMES]} "
+            "Align layers:", self.align_frames)
+        step2_layout.addRow(
+            # f" {constants.ACTION_ICONS[constants.ACTION_BALANCEFRAMES]} "
+            "Balance layers:", self.balance_frames)
+        step2_layout.addRow(
+            # f" {constants.ACTION_ICONS[constants.ACTION_FOCUSSTACKBUNCH]} "
+            "Bunch stack:", self.bunch_stack)
+        step2_layout.addRow("Bunch frames:", self.bunch_frames)
+        step2_layout.addRow("Bunch overlap:", self.bunch_overlap)
+        self.bunches_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
+        step2_layout.addRow("Number of bunches: ", self.bunches_label)
         if self.expert():
-            self.form_layout.addRow("Focus stack (pyramid):", self.focus_stack_pyramid)
-            self.form_layout.addRow("Focus stack (depth map):", self.focus_stack_depth_map)
+            step2_layout.addRow(
+                f" {constants.ACTION_ICONS[constants.ACTION_FOCUSSTACK]} "
+                "Focus stack (pyramid):", self.focus_stack_pyramid)
+            step2_layout.addRow(
+                f" {constants.ACTION_ICONS[constants.ACTION_FOCUSSTACK]} "
+                "Focus stack (depth map):", self.focus_stack_depth_map)
         else:
-            self.form_layout.addRow("Focus stack:", self.focus_stack_pyramid)
+            step2_layout.addRow(
+                f" {constants.ACTION_ICONS[constants.ACTION_FOCUSSTACK]} "
+                "Focus stack:", self.focus_stack_pyramid)
         if self.expert():
-            self.form_layout.addRow("Save multi layer TIFF:", self.multi_layer)
-        self.add_label("")
-        self.add_bold_label("3️⃣ Push 🆗 for further options, then press ▶️ to run.")
-        self.add_label("")
-        self.add_label("4️⃣ "
-                       "Select: <b>View</b> > <b>Expert options</b> "
-                       "to unlock advanced configuration.")
+            step2_layout.addRow(
+                f" {constants.ACTION_ICONS[constants.ACTION_MULTILAYER]} "
+                "Save multi layer TIFF:", self.multi_layer)
+        step2_group.setLayout(step2_layout)
+        self.form_layout.addRow(step2_group)
+        step3_group = QGroupBox("3️⃣ Confirmation")
+        step3_layout = QVBoxLayout()
+        step3_layout.setContentsMargins(15, 0, 15, 15)
+        step3_layout.addWidget(
+            QLabel("Click 🆗 to confirm and prepare the job."))
+        step3_layout.addWidget(
+            QLabel("Select: <b>View</b> > <b>Expert options</b> for advanced configuration."))
+        step3_group.setLayout(step3_layout)
+        self.form_layout.addRow(step3_group)
+        step4_group = QGroupBox("4️⃣ Execution")
+        step4_layout = QHBoxLayout()
+        step4_layout.setContentsMargins(15, 0, 15, 15)
+        step4_layout.addWidget(QLabel("Press ▶️ to run your job."))
+        icon_path = f"{os.path.dirname(__file__)}/ico/shinestacker.png"
+        app_icon = QIcon(icon_path)
+        icon_pixmap = app_icon.pixmap(80, 80)
+        icon_label = QLabel()
+        icon_label.setPixmap(icon_pixmap)
+        icon_label.setAlignment(Qt.AlignRight)
+        step4_layout.addWidget(icon_label)
+        step4_group.setLayout(step4_layout)
+        self.form_layout.addRow(step4_group)
+        group_style = """
+            QGroupBox {
+                font-weight: bold;
+                border: 2px solid #cccccc;
+                border-radius: 5px;
+                margin-top: 10px;
+                padding-top: 15px;
+                background-color: #f8f8f8;
+            }
+            QGroupBox::title {
+                subcontrol-origin: margin;
+                left: 10px;
+                padding: 0 5px 0 5px;
+                background-color: #f8f8f8;
+            }
+        """
+        for group in [step1_group, step2_group, step3_group, step4_group]:
+            group.setStyleSheet(group_style)
+            group.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
+        self.form_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
+        self.form_layout.setFormAlignment(Qt.AlignLeft)
+        self.form_layout.setLabelAlignment(Qt.AlignLeft)
 
     def update_bunch_options(self, checked):
         self.bunch_frames.setEnabled(checked)
@@ -125,7 +187,7 @@ class NewProjectDialog(BaseFormDialog):
         self.update_bunches_label()
 
     def update_bunches_label(self):
-        if not self.input_folder.text():
+        if not self.input_widget.get_path():
             return
 
         def count_image_files(path):
@@ -136,8 +198,13 @@ class NewProjectDialog(BaseFormDialog):
                 if extension_tif_jpg(filename):
                     count += 1
             return count
-
-        self.n_image_files = count_image_files(self.input_folder.text())
+        if self.input_widget.get_selection_mode() == 'files' and \
+                self.input_widget.get_selected_files():
+            self.n_image_files = len(self.input_widget.get_selected_files())
+            self.selected_filenames = self.input_widget.get_selected_filenames()
+        else:
+            self.n_image_files = count_image_files(self.input_widget.get_path())
+            self.selected_filenames = []
         if self.n_image_files == 0:
             self.bunches_label.setText(DEFAULT_NO_COUNT_LABEL)
             self.frames_label.setText(DEFAULT_NO_COUNT_LABEL)
@@ -147,36 +214,58 @@ class NewProjectDialog(BaseFormDialog):
             bunches = get_bunches(list(range(self.n_image_files)),
                                   self.bunch_frames.value(),
                                   self.bunch_overlap.value())
-            self.bunches_label.setText(f"{len(bunches)}")
+            self.bunches_label.setText(f"{max(1, len(bunches))}")
         else:
             self.bunches_label.setText(DEFAULT_NO_COUNT_LABEL)
 
+    def input_submitted(self):
+        self.update_bunches_label()
+        self.ok_button.setFocus()
+
     def accept(self):
-        input_folder = self.input_folder.text()
-        if not input_folder:
-            QMessageBox.warning(self, "Input Required", "Please select an input folder")
-            return
-        if not os.path.exists(input_folder):
-            QMessageBox.warning(self, "Invalid Path", "The specified folder does not exist")
+        input_path = self.input_widget.get_path()
+        selection_mode = self.input_widget.get_selection_mode()
+        selected_files = self.input_widget.get_selected_files()
+        if not input_path:
+            QMessageBox.warning(self, "Input Required", "Please select an input folder or files")
             return
-        if not os.path.isdir(input_folder):
-            QMessageBox.warning(self, "Invalid Path", "The specified path is not a folder")
-            return
-        if len(input_folder.split('/')) < 2:
+        if selection_mode == 'files':
+            if not selected_files:
+                QMessageBox.warning(self, "Invalid Selection", "No files selected")
+                return
+            for file_path in selected_files:
+                if not os.path.exists(file_path):
+                    QMessageBox.warning(self, "Invalid Path",
+                                        f"The file {file_path} does not exist")
+                    return
+        else:
+            if not os.path.exists(input_path):
+                QMessageBox.warning(self, "Invalid Path", "The specified folder does not exist")
+                return
+            if not os.path.isdir(input_path):
+                QMessageBox.warning(self, "Invalid Path", "The specified path is not a folder")
+                return
+        parent_dir = os.path.dirname(input_path)
+        if not parent_dir:
+            parent_dir = input_path
+        if len(parent_dir.split('/')) < 2:
             QMessageBox.warning(self, "Invalid Path", "The path must have a parent folder")
             return
         if self.n_image_files > 0 and not self.bunch_stack.isChecked():
-            path = self.input_folder.text()
-            files = os.listdir(path)
-            file_path = None
-            for filename in files:
-                full_path = os.path.join(path, filename)
-                if extension_tif_jpg(full_path):
-                    file_path = full_path
-                    break
+            if selection_mode == 'files' and selected_files:
+                file_path = selected_files[0]
+            else:
+                path = self.input_widget.get_path()
+                files = os.listdir(path)
+                file_path = None
+                for filename in files:
+                    full_path = os.path.join(path, filename)
+                    if extension_tif_jpg(full_path):
+                        file_path = full_path
+                        break
             if file_path is None:
                 QMessageBox.warning(
-                    self, "Invalid input", "Could not find images now in the selected path")
+                    self, "Invalid input", "Could not find images in the selected path")
                 return
             img = read_img(file_path)
             height, width = img.shape[:2]
@@ -217,7 +306,16 @@ class NewProjectDialog(BaseFormDialog):
         super().accept()
 
     def get_input_folder(self):
-        return self.input_folder.text()
+        return self.input_widget.get_path()
+
+    def get_selected_files(self):
+        return self.input_widget.get_selected_files()
+
+    def get_selected_filenames(self):
+        return self.input_widget.get_selected_filenames()
+
+    def get_selection_mode(self):
+        return self.input_widget.get_selection_mode()
 
     def get_noise_detection(self):
         return self.noise_detection.isChecked()

shinestacker/gui/project_controller.py

@@ -143,7 +143,6 @@ class ProjectController(QObject):
             return
         os.chdir(get_app_base_path())
         self.set_current_file_path('')
-        self.mark_as_modified(False)
         self.update_title()
         self.clear_job_list()
         self.clear_action_list()
@@ -156,6 +155,7 @@ class ProjectController(QObject):
             input_folder = dialog.get_input_folder().split('/')
             working_path = '/'.join(input_folder[:-1])
             input_path = input_folder[-1]
+            selected_filenames = dialog.get_selected_filenames()
             if dialog.get_noise_detection():
                 job_noise = ActionConfig(
                     constants.ACTION_JOB,
@@ -165,10 +165,14 @@ class ProjectController(QObject):
                                                {'name': f'{input_path}-detect-noise'})
                 job_noise.add_sub_action(noise_detection)
                 self.add_job_to_project(job_noise)
-            job = ActionConfig(constants.ACTION_JOB,
-                               {'name': f'{input_path}-focus-stack',
-                                'working_path': working_path,
-                                'input_path': input_path})
+            job_params = {
+                'name': f'{input_path}-focus-stack',
+                'working_path': working_path,
+                'input_path': input_path
+            }
+            if len(selected_filenames) > 0:
+                job_params['input_filepaths'] = selected_filenames
+            job = ActionConfig(constants.ACTION_JOB, job_params)
             preprocess_name = ''
             if dialog.get_noise_detection() or dialog.get_vignetting_correction() or \
                dialog.get_align_frames() or dialog.get_balance_frames():
@@ -227,7 +231,7 @@ class ProjectController(QObject):
                         'input_path': constants.PATH_SEPARATOR.join(multi_input_path)})
                 job.add_sub_action(multi_layer)
             self.add_job_to_project(job)
-            self.mark_as_modified(True, "New Project")
+            self.project_editor.set_modified(True)
             self.refresh_ui(0, -1)
 
     def open_project(self, file_path=False):

shinestacker/gui/project_converter.py

@@ -6,7 +6,7 @@ from .. core.exceptions import InvalidOptionError, RunStopException
 from .. algorithms.stack_framework import StackJob, CombinedActions
 from .. algorithms.noise_detection import NoiseDetection, MaskNoise
 from .. algorithms.vignetting import Vignetting
-from .. algorithms.align import AlignFrames
+from .. algorithms.align_auto import AlignFramesAuto
 from .. algorithms.balance import BalanceFrames
 from .. algorithms.stack import FocusStack, FocusStackBunch
 from .. algorithms.pyramid_auto import PyramidAutoStack
@@ -93,7 +93,7 @@ class ProjectConverter:
             return Vignetting(**params)
         if action_config.type_name == constants.ACTION_ALIGNFRAMES:
             params = {k: v for k, v in action_config.params.items() if k != 'name'}
-            return AlignFrames(**params)
+            return AlignFramesAuto(**params)
         if action_config.type_name == constants.ACTION_BALANCEFRAMES:
             params = {k: v for k, v in action_config.params.items() if k != 'name'}
             if 'intensity_interval' in params.keys():
@@ -133,7 +133,9 @@ class ProjectConverter:
             enabled = action_config.params.get('enabled', True)
             working_path = action_config.params.get('working_path', '')
             input_path = action_config.params.get('input_path', '')
+            input_filepaths = action_config.params.get('input_filepaths', [])
             stack_job = StackJob(name, working_path, enabled=enabled, input_path=input_path,
+                                 input_filepaths=input_filepaths,
                                  logger_name=logger_name, callbacks=callbacks)
             for sub in action_config.sub_actions:
                 action = self.action(sub)

shinestacker/gui/project_editor.py

@@ -1,9 +1,8 @@
-# pylint: disable=C0114, C0115, C0116, R0904, R1702, R0917, R0913, R0902, E0611, E1131, E1121
+# pylint: disable=C0114, C0115, C0116, R0903, R0904, R1702, R0917, R0913, R0902, E0611, E1131, E1121
 import os
 from dataclasses import dataclass
-from PySide6.QtWidgets import (QListWidget, QMessageBox,
-                               QDialog, QListWidgetItem, QLabel)
-from PySide6.QtCore import Qt, QObject, Signal
+from PySide6.QtWidgets import QListWidget, QMessageBox, QDialog, QListWidgetItem, QLabel
+from PySide6.QtCore import Qt, QObject, Signal, QEvent
 from .. config.constants import constants
 from .colors import ColorPalette
 from .action_config_dialog import ActionConfigDialog
@@ -101,6 +100,25 @@ class ProjectUndoManager(QObject):
         self.set_enabled_undo_action_requested.emit(False, '')
 
 
+class HandCursorListWidget(QListWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setMouseTracking(True)
+        self.viewport().setMouseTracking(True)
+
+    def event(self, event):
+        if event.type() == QEvent.HoverMove:
+            pos = event.position().toPoint()
+            item = self.itemAt(pos)
+            if item:
+                self.viewport().setCursor(Qt.PointingHandCursor)
+            else:
+                self.viewport().setCursor(Qt.ArrowCursor)
+        elif event.type() == QEvent.Leave:
+            self.viewport().setCursor(Qt.ArrowCursor)
+        return super().event(event)
+
+
 class ProjectEditor(QObject):
     INDENT_SPACE = "   ↪   "
     CLONE_POSTFIX = " (clone)"
@@ -117,8 +135,8 @@ class ProjectEditor(QObject):
         self._project = None
         self._copy_buffer = None
         self._current_file_path = ''
-        self._job_list = QListWidget()
-        self._action_list = QListWidget()
+        self._job_list = HandCursorListWidget()
+        self._action_list = HandCursorListWidget()
         self.dialog = None
 
     def reset_undo(self):
@@ -246,37 +264,29 @@ class ProjectEditor(QObject):
         txt = f"{job.params.get('name', '(job)')}"
         if html:
             txt = f"<b>{txt}</b>"
-        in_path = get_action_input_path(job)
-        return txt + (f" [⚙️ Job: 📁 {in_path[0]} → 📂 ...]" if long_name else "")
+        in_path = get_action_input_path(job)[0]
+        if os.path.isabs(in_path):
+            in_path = ".../" + os.path.basename(in_path)
+        ico = constants.ACTION_ICONS[constants.ACTION_JOB]
+        return txt + (f" [{ico}Job: 📁 {in_path} → 📂 ...]" if long_name else "")
 
     def action_text(self, action, is_sub_action=False, indent=True, long_name=False, html=False):
-        icon_map = {
-            constants.ACTION_COMBO: '⚡',
-            constants.ACTION_NOISEDETECTION: '🌫',
-            constants.ACTION_FOCUSSTACK: '🎯',
-            constants.ACTION_FOCUSSTACKBUNCH: '🖇',
-            constants.ACTION_MULTILAYER: '🎞️',
-            constants.ACTION_MASKNOISE: '🎭',
-            constants.ACTION_VIGNETTING: '⭕️',
-            constants.ACTION_ALIGNFRAMES: '📐',
-            constants.ACTION_BALANCEFRAMES: '🌈'
-        }
-        ico = icon_map.get(action.type_name, '')
+        ico = constants.ACTION_ICONS.get(action.type_name, '')
         if is_sub_action and indent:
             txt = self.INDENT_SPACE
-            if ico == '':
-                ico = '🟣'
         else:
             txt = ''
-            if ico == '':
-                ico = '🔵'
         if action.params.get('name', '') != '':
             txt += f"{action.params['name']}"
             if html:
                 txt = f"<b>{txt}</b>"
-        in_path, out_path = get_action_input_path(action), get_action_output_path(action)
-        return f"{txt} [{ico} {action.type_name}" + \
-               (f": 📁 <i>{in_path[0]}</i> → 📂 <i>{out_path[0]}</i>]"
+        in_path, out_path = get_action_input_path(action)[0], get_action_output_path(action)[0]
+        if os.path.isabs(in_path):
+            in_path = ".../" + os.path.basename(in_path)
+        if os.path.isabs(out_path):
+            out_path = ".../" + os.path.basename(out_path)
+        return f"{txt} [{ico}{action.type_name}" + \
+               (f": 📁 <i>{in_path}</i> → 📂 <i>{out_path}</i>]"
                 if long_name and not is_sub_action else "]")
 
     def get_job_at(self, index):

shinestacker/gui/select_path_widget.py

@@ -29,4 +29,4 @@ def create_select_file_paths_widget(value, placeholder, tag):
         if path:
             edit.setText(path)
 
-    return edit, create_layout_widget_and_connect(button, edit, browse)
+    return create_layout_widget_and_connect(button, edit, browse)

shinestacker/gui/sys_mon.py

@@ -0,0 +1,96 @@
+# pylint: disable=C0114, C0115, C0116, E0611
+import psutil
+from PySide6.QtWidgets import QWidget, QHBoxLayout, QLabel, QProgressBar, QSizePolicy
+from PySide6.QtCore import QTimer, Qt
+
+
+class StatusBarSystemMonitor(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setup_ui()
+        self.setup_timer()
+        self.setFixedHeight(28)
+
+    def setup_ui(self):
+        bar_width = 100
+        bar_height = 20
+        layout = QHBoxLayout()
+        layout.setSpacing(10)
+        layout.setContentsMargins(0, 2, 0, 0)
+        layout.setAlignment(Qt.AlignLeft)
+        layout.setAlignment(Qt.AlignCenter)
+        cpu_widget = QWidget()
+        cpu_widget.setFixedSize(bar_width, bar_height)
+        self.cpu_bar = QProgressBar(cpu_widget)
+        self.cpu_bar.setRange(0, 100)
+        self.cpu_bar.setTextVisible(False)
+        self.cpu_bar.setGeometry(0, 0, bar_width, bar_height)
+        self.cpu_bar.setStyleSheet("""
+            QProgressBar {
+                border: 1px solid #cccccc;
+                border-radius: 5px;
+                background: #f0f0f0;
+            }
+            QProgressBar::chunk {
+                background-color: #3498db;
+                border-radius: 5px;
+            }
+        """)
+        self.cpu_label = QLabel("CPU: --%", cpu_widget)
+        self.cpu_label.setAlignment(Qt.AlignCenter)
+        self.cpu_label.setGeometry(0, 0, bar_width, bar_height)
+        self.cpu_label.setStyleSheet("""
+            QLabel {
+                color: #2c3e50;
+                font-weight: bold;
+                background: transparent;
+                font-size: 12px;
+            }
+        """)
+        mem_widget = QWidget()
+        mem_widget.setFixedSize(bar_width, bar_height)
+        self.mem_bar = QProgressBar(mem_widget)
+        self.mem_bar.setRange(0, 100)
+        self.mem_bar.setTextVisible(False)
+        self.mem_bar.setGeometry(0, 0, bar_width, bar_height)
+        self.mem_bar.setStyleSheet("""
+            QProgressBar {
+                border: 1px solid #cccccc;
+                border-radius: 5px;
+                background: #f0f0f0;
+            }
+            QProgressBar::chunk {
+                background-color: #2ecc71;
+                border-radius: 5px;
+            }
+        """)
+        self.mem_label = QLabel("MEM: --%", mem_widget)
+        self.mem_label.setAlignment(Qt.AlignCenter)
+        self.mem_label.setGeometry(0, 0, bar_width, bar_height)
+        self.mem_label.setStyleSheet("""
+            QLabel {
+                color: #2c3e50;
+                font-weight: bold;
+                background: transparent;
+                font-size: 12px;
+            }
+        """)
+        layout.addWidget(cpu_widget)
+        layout.addWidget(mem_widget)
+        layout.addStretch()
+        self.setLayout(layout)
+        self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+    def setup_timer(self):
+        self.timer = QTimer()
+        self.timer.timeout.connect(self.update_stats)
+        self.timer.start(1000)
+
+    def update_stats(self):
+        cpu_percent = psutil.cpu_percent()
+        memory = psutil.virtual_memory()
+        mem_percent = memory.percent
+        self.cpu_bar.setValue(int(cpu_percent))
+        self.cpu_label.setText(f"CPU: {cpu_percent:.1f}%")
+        self.mem_bar.setValue(int(mem_percent))
+        self.mem_label.setText(f"MEM: {mem_percent:.1f}%")

shinestacker/gui/time_progress_bar.py

@@ -39,13 +39,14 @@ class TimerProgressBar(QProgressBar):
         """)
 
     def time_str(self, secs):
-        x = secs % 1
-        ss = int(secs // 1)
+        xsecs = int(secs * 10)
+        x = xsecs % 10
+        ss = xsecs // 10
         s = ss % 60
         mm = ss // 60
         m = mm % 60
         h = mm // 60
-        t_str = f"{s:02d}" + f"{x:.1f}s".lstrip('0')
+        t_str = f"{s:02d}.{x:1d}s"
         if m > 0:
             t_str = f"{m:02d}:{t_str}"
         if h > 0:

shinestacker/retouch/exif_data.py

@@ -9,7 +9,7 @@ from .. gui.base_form_dialog import BaseFormDialog
 
 class ExifData(BaseFormDialog):
     def __init__(self, exif, parent=None):
-        super().__init__("EXIF data", parent)
+        super().__init__("EXIF data", parent=parent)
         self.exif = exif
         self.create_form()
         button_container = QWidget()

shinestacker/retouch/image_editor_ui.py

@@ -658,6 +658,8 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
     def quit(self):
         if self.check_unsaved_changes():
             self.close()
+            return True
+        return False
 
     def undo(self):
         if self.undo_manager.undo(self.master_layer()):