shinestacker 1.0.4.post2__py3-none-any.whl → 1.2.0__py3-none-any.whl

shinestacker/gui/base_form_dialog.py

@@ -3,16 +3,21 @@ from PySide6.QtWidgets import QFormLayout, QDialog
 from PySide6.QtCore import Qt
 
 
+def create_form_layout(parent):
+    layout = QFormLayout(parent)
+    layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
+    layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
+    layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
+    layout.setLabelAlignment(Qt.AlignLeft)
+    return layout
+
+
 class BaseFormDialog(QDialog):
     def __init__(self, title, parent=None):
         super().__init__(parent)
         self.setWindowTitle(title)
         self.resize(500, self.height())
-        self.layout = QFormLayout(self)
-        self.layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
-        self.layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
-        self.layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
-        self.layout.setLabelAlignment(Qt.AlignLeft)
+        self.form_layout = create_form_layout(self)
 
     def add_row_to_layout(self, item):
-        self.layout.addRow(item)
+        self.form_layout.addRow(item)

shinestacker/gui/flow_layout.py

@@ -0,0 +1,105 @@
+# pylint: disable=C0114, C0115, C0116, E0611, C0103, R0914
+from PySide6.QtWidgets import QLayout
+from PySide6.QtCore import Qt, QRect, QSize, QPoint
+
+
+class FlowLayout(QLayout):
+    def __init__(self, parent=None, margin=0, spacing=-1, justify=True):
+        super().__init__(parent)
+        self._item_list = []
+        self._justify = justify
+        self.setContentsMargins(margin, margin, margin, margin)
+        self.setSpacing(spacing)
+
+    def addItem(self, item):
+        self._item_list.append(item)
+
+    def count(self):
+        return len(self._item_list)
+
+    def itemAt(self, index):
+        if 0 <= index < len(self._item_list):
+            return self._item_list[index]
+        return None
+
+    def takeAt(self, index):
+        if 0 <= index < len(self._item_list):
+            return self._item_list.pop(index)
+        return None
+
+    def expandingDirections(self):
+        return Qt.Orientations(0)
+
+    def hasHeightForWidth(self):
+        return True
+
+    def heightForWidth(self, width):
+        return self._do_layout(QRect(0, 0, width, 0), True)
+
+    def setGeometry(self, rect):
+        super().setGeometry(rect)
+        self._do_layout(rect, False)
+
+    def sizeHint(self):
+        return self.minimumSize()
+
+    def minimumSize(self):
+        size = QSize()
+        for item in self._item_list:
+            size = size.expandedTo(item.minimumSize())
+        margins = self.contentsMargins()
+        size += QSize(margins.left() + margins.right(), margins.top() + margins.bottom())
+        return size
+
+    def setJustify(self, justify):
+        self._justify = justify
+        self.invalidate()
+
+    def justify(self):
+        return self._justify
+
+    def _do_layout(self, rect, test_only):
+        x = rect.x()
+        y = rect.y()
+        line_height = 0
+        spacing = self.spacing()
+        lines = []
+        current_line = []
+        current_line_width = 0
+        for item in self._item_list:
+            space_x = spacing
+            next_x = x + item.sizeHint().width() + space_x
+            if next_x - space_x > rect.right() and line_height > 0:
+                lines.append((current_line, current_line_width, line_height))
+                x = rect.x()
+                y = y + line_height + spacing
+                next_x = x + item.sizeHint().width() + space_x
+                current_line = []
+                current_line_width = 0
+                line_height = 0
+            current_line.append(item)
+            current_line_width += item.sizeHint().width()
+            x = next_x
+            line_height = max(line_height, item.sizeHint().height())
+        if current_line:
+            lines.append((current_line, current_line_width, line_height))
+        y_offset = rect.y()
+        for line, line_width, line_height in lines:
+            if not test_only:
+                available_width = rect.width() - (len(line) - 1) * spacing
+                if self._justify and len(line) > 1:
+                    stretch_factor = available_width / line_width if line_width > 0 else 1
+                    x_offset = rect.x()
+                    for item in line:
+                        item_width = int(item.sizeHint().width() * stretch_factor)
+                        item.setGeometry(QRect(QPoint(x_offset, y_offset),
+                                               QSize(item_width, line_height)))
+                        x_offset += item_width + spacing
+                else:
+                    x_offset = rect.x()
+                    for item in line:
+                        item.setGeometry(QRect(QPoint(x_offset, y_offset),
+                                         item.sizeHint()))
+                        x_offset += item.sizeHint().width() + spacing
+            y_offset += line_height + spacing
+        return y_offset - spacing - rect.y()

shinestacker/gui/gui_run.py

@@ -1,5 +1,6 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0903, R0915, R0914, R0917, R0913, R0902
 import os
+import traceback
 from PySide6.QtWidgets import (QWidget, QPushButton, QVBoxLayout, QHBoxLayout,
                                QMessageBox, QScrollArea, QSizePolicy, QFrame, QLabel, QComboBox)
 from PySide6.QtGui import QColor
@@ -16,6 +17,7 @@ from .colors import (
     ACTION_RUNNING_COLOR, ACTION_COMPLETED_COLOR,
     ACTION_STOPPED_COLOR, ACTION_FAILED_COLOR)
 from .time_progress_bar import TimerProgressBar
+from .flow_layout import FlowLayout
 
 
 class ColorButton(QPushButton):
@@ -55,12 +57,12 @@ class RunWindow(QTextEditLogger):
             for label_row in labels:
                 self.color_widgets.append([])
                 row = QWidget(self)
-                h_layout = QHBoxLayout(row)
+                h_layout = FlowLayout(row)  # QHBoxLayout(row)
                 h_layout.setContentsMargins(0, 0, 0, 0)
                 h_layout.setSpacing(2)
                 for label, enabled in label_row:
                     widget = ColorButton(label, enabled)
-                    h_layout.addWidget(widget, stretch=1)
+                    h_layout.addWidget(widget)  # addWidget(widget, stretch=1)
                     self.color_widgets[-1].append(widget)
                 layout.addWidget(row)
         self.progress_bar = TimerProgressBar()
@@ -202,23 +204,26 @@ class RunWindow(QTextEditLogger):
         label = QLabel(name, self)
         label.setStyleSheet("QLabel {margin-top: 5px; font-weight: bold;}")
         self.image_layout.addWidget(label)
-        if extension_pdf(path):
-            image_view = GuiPdfView(path, self)
-        elif extension_tif_jpg(path):
-            image_view = GuiImageView(path, self)
-        else:
-            raise RuntimeError(f"Can't visualize file type {os.path.splitext(path)[1]}.")
-        self.image_views.append(image_view)
-        self.image_layout.addWidget(image_view)
-        max_width = max(pv.size().width() for pv in self.image_views) if self.image_views else 0
-        needed_width = max_width + 20
-        self.right_area.setFixedWidth(needed_width)
-        self.image_area_widget.setFixedWidth(needed_width)
-        self.right_area.updateGeometry()
-        self.image_area_widget.updateGeometry()
-        QTimer.singleShot(
-            0, lambda: self.right_area.verticalScrollBar().setValue(
-                self.right_area.verticalScrollBar().maximum()))
+        try:
+            if extension_pdf(path):
+                image_view = GuiPdfView(path, self)
+            elif extension_tif_jpg(path):
+                image_view = GuiImageView(path, self)
+            else:
+                raise RuntimeError(f"Can't visualize file type {os.path.splitext(path)[1]}.")
+            self.image_views.append(image_view)
+            self.image_layout.addWidget(image_view)
+            max_width = max(pv.size().width() for pv in self.image_views) if self.image_views else 0
+            needed_width = max_width + 20
+            self.right_area.setFixedWidth(needed_width)
+            self.image_area_widget.setFixedWidth(needed_width)
+            self.right_area.updateGeometry()
+            self.image_area_widget.updateGeometry()
+            QTimer.singleShot(
+                0, lambda: self.right_area.verticalScrollBar().setValue(
+                    self.right_area.verticalScrollBar().maximum()))
+        except RuntimeError as e:
+            traceback.print_tb(e.__traceback__)
 
     @Slot(int, str, str, str)
     def handle_open_app(self, _run_id, name, app, path):

shinestacker/gui/main_window.py

@@ -135,6 +135,8 @@ class MainWindow(QMainWindow, LogManager):
         self.project_editor.refresh_ui_signal.connect(self.refresh_ui)
         self.project_editor.enable_delete_action_signal.connect(
             self.menu_manager.delete_element_action.setEnabled)
+        self.project_editor.undo_manager.set_enabled_undo_action_requested.connect(
+            self.menu_manager.undo_action.setEnabled)
         self.project_controller.update_title_requested.connect(self.update_title)
         self.project_controller.refresh_ui_requested.connect(self.refresh_ui)
         self.project_controller.activate_window_requested.connect(self.activateWindow)
@@ -406,14 +408,13 @@ class MainWindow(QMainWindow, LogManager):
         if self.job_list_count() == 0:
             self.menu_manager.add_action_entry_action.setEnabled(False)
             self.menu_manager.action_selector.setEnabled(False)
-            self.run_job_action.setEnabled(False)
-            self.run_all_jobs_action.setEnabled(False)
+            self.menu_manager.run_job_action.setEnabled(False)
         else:
             self.menu_manager.add_action_entry_action.setEnabled(True)
             self.menu_manager.action_selector.setEnabled(True)
             self.menu_manager.delete_element_action.setEnabled(True)
             self.menu_manager.run_job_action.setEnabled(True)
-            self.menu_manager.run_all_jobs_action.setEnabled(True)
+        self.menu_manager.set_enabled_run_all_jobs(self.job_list_count() > 1)
 
     def quit(self):
         if self.project_controller.check_unsaved_changes():

shinestacker/gui/menu_manager.py

@@ -82,7 +82,10 @@ class MenuManager:
 
     def add_edit_menu(self):
         menu = self.menubar.addMenu("&Edit")
-        for name in ["&Undo", "&Cut", "Cop&y", "&Paste", "Duplicate"]:
+        self.undo_action = self.action("&Undo")
+        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")
         self.delete_element_action.setEnabled(False)
@@ -113,7 +116,7 @@ class MenuManager:
         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.setEnabled(False)
+        self.set_enabled_run_all_jobs(False)
         menu.addAction(self.run_all_jobs_action)
 
     def add_actions_menu(self):
@@ -234,3 +237,10 @@ class MenuManager:
         self.sub_action_selector.setEnabled(enabled)
         for a in self.sub_action_menu_entries:
             a.setEnabled(enabled)
+
+    def set_enabled_run_all_jobs(self, enabled):
+        tooltip = self.tooltips["Run All Jobs"]
+        self.run_all_jobs_action.setEnabled(enabled)
+        if not enabled:
+            tooltip += " (requires more tha one job)"
+        self.run_all_jobs_action.setToolTip(tooltip)

shinestacker/gui/new_project.py

@@ -36,11 +36,11 @@ class NewProjectDialog(BaseFormDialog):
     def add_bold_label(self, label):
         label = QLabel(label)
         label.setStyleSheet("font-weight: bold")
-        self.layout.addRow(label)
+        self.form_layout.addRow(label)
 
     def add_label(self, label):
         label = QLabel(label)
-        self.layout.addRow(label)
+        self.form_layout.addRow(label)
 
     def create_form(self):
         icon_path = f"{os.path.dirname(__file__)}/ico/shinestacker.png"
@@ -49,10 +49,10 @@ class NewProjectDialog(BaseFormDialog):
         icon_label = QLabel()
         icon_label.setPixmap(icon_pixmap)
         icon_label.setAlignment(Qt.AlignCenter)
-        self.layout.addRow(icon_label)
+        self.form_layout.addRow(icon_label)
         spacer = QLabel("")
         spacer.setFixedHeight(10)
-        self.layout.addRow(spacer)
+        self.form_layout.addRow(spacer)
 
         self.input_folder, container = create_select_file_paths_widget(
             '', 'input files folder', 'input files folder')
@@ -92,25 +92,26 @@ class NewProjectDialog(BaseFormDialog):
         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.layout.addRow("Input folder:", container)
-        self.layout.addRow("Number of frames: ", self.frames_label)
+        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.")
         if self.expert():
-            self.layout.addRow("Automatic noise detection:", self.noise_detection)
-            self.layout.addRow("Vignetting correction:", self.vignetting_correction)
-        self.layout.addRow("Align layers:", self.align_frames)
-        self.layout.addRow("Balance layers:", self.balance_frames)
-        self.layout.addRow("Bunch stack:", self.bunch_stack)
-        self.layout.addRow("Bunch frames:", self.bunch_frames)
-        self.layout.addRow("Bunch overlap:", self.bunch_overlap)
-        self.layout.addRow("Number of bunches: ", self.bunches_label)
+            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)
         if self.expert():
-            self.layout.addRow("Focus stack (pyramid):", self.focus_stack_pyramid)
-            self.layout.addRow("Focus stack (depth map):", self.focus_stack_depth_map)
+            self.form_layout.addRow("Focus stack (pyramid):", self.focus_stack_pyramid)
+            self.form_layout.addRow("Focus stack (depth map):", self.focus_stack_depth_map)
         else:
-            self.layout.addRow("Focus stack:", self.focus_stack_pyramid)
-            self.layout.addRow("Save multi layer TIFF:", self.multi_layer)
+            self.form_layout.addRow("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("")
@@ -181,8 +182,9 @@ class NewProjectDialog(BaseFormDialog):
             height, width = img.shape[:2]
             n_bytes = 1 if img.dtype == np.uint8 else 2
             n_bits = 8 if img.dtype == np.uint8 else 16
-            n_mbytes = float(n_bytes * height * width * self.n_image_files) / 10**6
-            if n_mbytes > 500 and not self.bunch_stack.isChecked():
+            n_gbytes = float(n_bytes * height * width * self.n_image_files) / constants.ONE_GIGA
+            print("GBytes: ", n_gbytes)
+            if n_gbytes > 1 and not self.bunch_stack.isChecked():
                 msg = QMessageBox()
                 msg.setStyleSheet("""
                     QMessageBox {
@@ -200,11 +202,15 @@ class NewProjectDialog(BaseFormDialog):
                 msg.setWindowTitle("Too many frames")
                 msg.setText(f"You selected {self.n_image_files} images "
                             f"with resolution {width}×{height} pixels, {n_bits} bits depth. "
-                            "Processing may require a significant amount of memory.\n\n"
+                            "Processing may require a significant amount "
+                            "of memory or I/O buffering.\n\n"
                             "Continue anyway?")
                 msg.setInformativeText("You may consider to split the processing "
                                        " using a bunch stack to reduce memory usage.\n\n"
-                                       '✅ Check the option "Bunch stack".')
+                                       '✅ Check the option "Bunch stack".\n\n'
+                                       "➡️ Check expert options for the stacking algorithm."
+                                       'Go to "View" > "Expert Options".'
+                                       )
                 msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
                 msg.setDefaultButton(QMessageBox.Cancel)
                 if msg.exec_() != QMessageBox.Ok:

shinestacker/gui/project_controller.py

@@ -136,6 +136,7 @@ class ProjectController(QObject):
             self.clear_job_list()
             self.clear_action_list()
             self.mark_as_modified(False)
+            self.project_editor.reset_undo()
 
     def new_project(self):
         if not self.check_unsaved_changes():
@@ -151,65 +152,79 @@ class ProjectController(QObject):
         dialog = NewProjectDialog(self.parent)
         if dialog.exec() == QDialog.Accepted:
             self.save_actions_set_enabled(True)
+            self.project_editor.reset_undo()
             input_folder = dialog.get_input_folder().split('/')
             working_path = '/'.join(input_folder[:-1])
             input_path = input_folder[-1]
             if dialog.get_noise_detection():
-                job_noise = ActionConfig(constants.ACTION_JOB,
-                                         {'name': 'detect-noise', 'working_path': working_path,
-                                          'input_path': input_path})
+                job_noise = ActionConfig(
+                    constants.ACTION_JOB,
+                    {'name': f'{input_path}-detect-noise', 'working_path': working_path,
+                     'input_path': input_path})
                 noise_detection = ActionConfig(constants.ACTION_NOISEDETECTION,
-                                               {'name': 'detect-noise'})
+                                               {'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': 'focus-stack', 'working_path': working_path,
+                               {'name': f'{input_path}-focus-stack',
+                                'working_path': working_path,
                                 'input_path': input_path})
+            preprocess_name = ''
             if dialog.get_noise_detection() or dialog.get_vignetting_correction() or \
                dialog.get_align_frames() or dialog.get_balance_frames():
-                combo_action = ActionConfig(constants.ACTION_COMBO, {'name': 'align'})
+                preprocess_name = f'{input_path}-preprocess'
+                combo_action = ActionConfig(
+                    constants.ACTION_COMBO, {'name': preprocess_name})
                 if dialog.get_noise_detection():
-                    mask_noise = ActionConfig(constants.ACTION_MASKNOISE, {'name': 'mask-noise'})
+                    mask_noise = ActionConfig(
+                        constants.ACTION_MASKNOISE, {'name': 'mask-noise'})
                     combo_action.add_sub_action(mask_noise)
                 if dialog.get_vignetting_correction():
-                    vignetting = ActionConfig(constants.ACTION_VIGNETTING, {'name': 'vignetting'})
+                    vignetting = ActionConfig(
+                        constants.ACTION_VIGNETTING, {'name': 'vignetting'})
                     combo_action.add_sub_action(vignetting)
                 if dialog.get_align_frames():
-                    align = ActionConfig(constants.ACTION_ALIGNFRAMES, {'name': 'align'})
+                    align = ActionConfig(
+                        constants.ACTION_ALIGNFRAMES, {'name': 'align'})
                     combo_action.add_sub_action(align)
                 if dialog.get_balance_frames():
-                    balance = ActionConfig(constants.ACTION_BALANCEFRAMES, {'name': 'balance'})
+                    balance = ActionConfig(
+                        constants.ACTION_BALANCEFRAMES, {'name': 'balance'})
                     combo_action.add_sub_action(balance)
                 job.add_sub_action(combo_action)
             if dialog.get_bunch_stack():
-                bunch_stack = ActionConfig(constants.ACTION_FOCUSSTACKBUNCH,
-                                           {'name': 'bunches', 'frames': dialog.get_bunch_frames(),
-                                            'overlap': dialog.get_bunch_overlap()})
+                bunch_stack_name = f'{input_path}-bunches'
+                bunch_stack = ActionConfig(
+                    constants.ACTION_FOCUSSTACKBUNCH,
+                    {'name': bunch_stack_name, 'frames': dialog.get_bunch_frames(),
+                     'overlap': dialog.get_bunch_overlap()})
                 job.add_sub_action(bunch_stack)
             if dialog.get_focus_stack_pyramid():
+                focus_pyramid_name = f'{input_path}-focus-stack-pyramid'
                 focus_pyramid = ActionConfig(constants.ACTION_FOCUSSTACK,
-                                             {'name': 'focus-stack-pyramid',
+                                             {'name': focus_pyramid_name,
                                               'stacker': constants.STACK_ALGO_PYRAMID})
                 job.add_sub_action(focus_pyramid)
             if dialog.get_focus_stack_depth_map():
+                focus_depth_map_name = f'{input_path}-focus-stack-depth-map'
                 focus_depth_map = ActionConfig(constants.ACTION_FOCUSSTACK,
-                                               {'name': 'focus-stack-depth-map',
+                                               {'name': focus_depth_map_name,
                                                 'stacker': constants.STACK_ALGO_DEPTH_MAP})
                 job.add_sub_action(focus_depth_map)
             if dialog.get_multi_layer():
-                input_path = []
+                multi_input_path = []
                 if dialog.get_focus_stack_pyramid():
-                    input_path.append("focus-stack-pyramid")
+                    multi_input_path.append(focus_pyramid_name)
                 if dialog.get_focus_stack_depth_map():
-                    input_path.append("focus-stack-depth-map")
+                    multi_input_path.append(focus_depth_map_name)
                 if dialog.get_bunch_stack():
-                    input_path.append("bunches")
+                    multi_input_path.append(bunch_stack_name)
+                elif preprocess_name:
+                    multi_input_path.append(preprocess_name)
                 multi_layer = ActionConfig(
                     constants.ACTION_MULTILAYER,
-                    {
-                        'name': 'multi-layer',
-                        'input_path': constants.PATH_SEPARATOR.join(input_path)
-                    })
+                    {'name': f'{input_path}-multi-layer',
+                        '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)
@@ -231,6 +246,7 @@ class ProjectController(QObject):
                     raise RuntimeError(f"Project from file {file_path} produced a null project.")
                 self.set_project(project)
                 self.mark_as_modified(False)
+                self.project_editor.reset_undo()
                 self.refresh_ui(0, -1)
                 if self.job_list_count() > 0:
                     self.set_current_job(0)
@@ -290,6 +306,7 @@ class ProjectController(QObject):
             with open(file_path, 'w', encoding="utf-8") as f:
                 f.write(json_obj)
             self.mark_as_modified(False)
+            self.update_title_requested.emit()
         except Exception as e:
             QMessageBox.critical(self.parent, "Error", f"Cannot save file:\n{str(e)}")
 

shinestacker/gui/project_converter.py

@@ -9,7 +9,7 @@ from .. algorithms.vignetting import Vignetting
 from .. algorithms.align import AlignFrames
 from .. algorithms.balance import BalanceFrames
 from .. algorithms.stack import FocusStack, FocusStackBunch
-from .. algorithms.pyramid import PyramidStack
+from .. algorithms.pyramid_auto import PyramidAutoStack
 from .. algorithms.depth_map import DepthMapStack
 from .. algorithms.multilayer import MultiLayer
 from .project_model import Project, ActionConfig
@@ -104,10 +104,12 @@ class ProjectConverter:
                                        constants.ACTION_FOCUSSTACKBUNCH):
             stacker = action_config.params.get('stacker', constants.STACK_ALGO_DEFAULT)
             if stacker == constants.STACK_ALGO_PYRAMID:
-                algo_dict, module_dict = self.filter_dict_keys(action_config.params, 'pyramid_')
-                stack_algo = PyramidStack(**algo_dict)
+                algo_dict, module_dict = self.filter_dict_keys(
+                    action_config.params, 'pyramid_')
+                stack_algo = PyramidAutoStack(**algo_dict)
             elif stacker == constants.STACK_ALGO_DEPTH_MAP:
-                algo_dict, module_dict = self.filter_dict_keys(action_config.params, 'depthmap_')
+                algo_dict, module_dict = self.filter_dict_keys(
+                    action_config.params, 'depthmap_')
                 stack_algo = DepthMapStack(**algo_dict)
             else:
                 raise InvalidOptionError('stacker', stacker, f"valid options are: "
@@ -117,8 +119,6 @@ class ProjectConverter:
                 return FocusStack(**module_dict, stack_algo=stack_algo)
             if action_config.type_name == constants.ACTION_FOCUSSTACKBUNCH:
                 return FocusStackBunch(**module_dict, stack_algo=stack_algo)
-            raise InvalidOptionError(
-                "stracker", stacker, details="valid values are: Pyramid, Depth map.")
         if action_config.type_name == constants.ACTION_MULTILAYER:
             input_path = list(filter(lambda p: p != '',
                               action_config.params.get('input_path', '').split(";")))

shinestacker/gui/project_editor.py

@@ -74,19 +74,30 @@ def new_row_after_clone(job, action_row, is_sub_action, cloned):
             for action in job.sub_actions[:job.sub_actions.index(cloned)])
 
 
-class ProjectUndoManager:
-    def __init__(self):
+class ProjectUndoManager(QObject):
+    set_enabled_undo_action_requested = Signal(bool)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
         self._undo_buffer = []
 
     def add(self, item):
         self._undo_buffer.append(item)
+        self.set_enabled_undo_action_requested.emit(True)
 
     def pop(self):
-        return self._undo_buffer.pop()
+        last = self._undo_buffer.pop()
+        if len(self._undo_buffer) == 0:
+            self.set_enabled_undo_action_requested.emit(False)
+        return last
 
     def filled(self):
         return len(self._undo_buffer) != 0
 
+    def reset(self):
+        self._undo_buffer = []
+        self.set_enabled_undo_action_requested.emit(False)
+
 
 class ProjectEditor(QObject):
     INDENT_SPACE = "   ↪   "
@@ -99,7 +110,7 @@ class ProjectEditor(QObject):
 
     def __init__(self, parent=None):
         super().__init__(parent)
-        self._undo_manager = ProjectUndoManager()
+        self.undo_manager = ProjectUndoManager()
         self._modified = False
         self._project = None
         self._copy_buffer = None
@@ -108,14 +119,17 @@ class ProjectEditor(QObject):
         self._action_list = QListWidget()
         self.dialog = None
 
+    def reset_undo(self):
+        self.undo_manager.reset()
+
     def add_undo(self, item):
-        self._undo_manager.add(item)
+        self.undo_manager.add(item)
 
     def pop_undo(self):
-        return self._undo_manager.pop()
+        return self.undo_manager.pop()
 
     def filled_undo(self):
-        return self._undo_manager.filled()
+        return self.undo_manager.filled()
 
     def mark_as_modified(self, modified=True):
         self._modified = modified

shinestacker/gui/time_progress_bar.py

@@ -39,8 +39,8 @@ class TimerProgressBar(QProgressBar):
         """)
 
     def time_str(self, secs):
-        ss = int(secs)
-        x = secs - ss
+        x = secs % 1
+        ss = int(secs // 1)
         s = ss % 60
         mm = ss // 60
         m = mm % 60

shinestacker/retouch/exif_data.py

@@ -25,14 +25,14 @@ class ExifData(BaseFormDialog):
     def add_bold_label(self, label):
         label = QLabel(label)
         label.setStyleSheet("font-weight: bold")
-        self.layout.addRow(label)
+        self.form_layout.addRow(label)
 
     def create_form(self):
-        self.layout.addRow(icon_container())
+        self.form_layout.addRow(icon_container())
 
         spacer = QLabel("")
         spacer.setFixedHeight(10)
-        self.layout.addRow(spacer)
+        self.form_layout.addRow(spacer)
         self.add_bold_label("EXIF data")
         shortcuts = {}
         if self.exif is None:
@@ -47,6 +47,6 @@ class ExifData(BaseFormDialog):
                 else:
                     d = f"{d}"
                 if "<<<" not in d and k != 'IPTCNAA':
-                    self.layout.addRow(f"<b>{k}:</b>", QLabel(d))
+                    self.form_layout.addRow(f"<b>{k}:</b>", QLabel(d))
         else:
-            self.layout.addRow("-", QLabel("Empty EXIF dictionary"))
+            self.form_layout.addRow("-", QLabel("Empty EXIF dictionary"))