shinestacker 1.8.0__py3-none-any.whl → 1.8.1__py3-none-any.whl

shinestacker/config/settings.py

@@ -39,23 +39,26 @@ DEFAULT_SETTINGS = {
     'cursor_update_time': gui_constants.DEFAULT_CURSOR_UPDATE_TIME,
     'min_mouse_step_brush_fraction': gui_constants.DEFAULT_MIN_MOUSE_STEP_BRUSH_FRACTION,
     'combined_actions_params': {
-        'max_threads': constants.DEFAULT_MAX_FWK_THREADS
+        'max_threads': constants.DEFAULT_FWK_MAX_THREADS
     },
     'align_frames_params': {
+        'memory_limit': constants.DEFAULT_ALIGN_MEMORY_LIMIT_GB,
         'max_threads': constants.DEFAULT_ALIGN_MAX_THREADS,
         'detector': constants.DEFAULT_DETECTOR,
         'descriptor': constants.DEFAULT_DESCRIPTOR,
         'match_method': constants.DEFAULT_MATCHING_METHOD
     },
     'focus_stack_params': {
+        'memory_limit': constants.DEFAULT_PY_MEMORY_LIMIT_GB,
         'max_threads': constants.DEFAULT_PY_MAX_THREADS
     },
     'focus_stack_bunch_params': {
+        'memory_limit': constants.DEFAULT_ALIGN_MEMORY_LIMIT_GB,
         'max_threads': constants.DEFAULT_PY_MAX_THREADS
     }
 }
 
-CURRENT_VERSION = 1
+CURRENT_SETTINGS_FILE_VERSION = 1
 
 
 class Settings(StdPathFile):
@@ -66,18 +69,30 @@ class Settings(StdPathFile):
         if Settings._instance is not None:
             raise RuntimeError("Settings is a singleton.")
         super().__init__(filename)
-        self.settings = DEFAULT_SETTINGS
+        self.settings = self._deep_copy_defaults()
         file_path = self.get_file_path()
         if os.path.isfile(file_path):
             try:
                 with open(file_path, 'r', encoding="utf-8") as file:
                     json_data = json.load(file)
-                    settings = json_data['settings']
+                    file_settings = json_data['settings']
+                    self._deep_merge_settings(file_settings)
             except Exception as e:
                 traceback.print_tb(e.__traceback__)
                 print(f"Can't read file from path {file_path}. Default settings ignored.")
-                settings = {}
-            self.settings = {**self.settings, **settings}
+
+    def _deep_copy_defaults(self):
+        return json.loads(json.dumps(DEFAULT_SETTINGS))
+
+    def _deep_merge_settings(self, file_settings):
+        for key, value in file_settings.items():
+            if key in self.settings:
+                if isinstance(value, dict) and isinstance(self.settings[key], dict):
+                    for sub_key, sub_value in value.items():
+                        if sub_key in self.settings[key]:
+                            self.settings[key][sub_key] = sub_value
+                else:
+                    self.settings[key] = value
 
     @classmethod
     def instance(cls, filename="shinestacker-settings.txt"):
@@ -99,7 +114,10 @@ class Settings(StdPathFile):
         try:
             config_dir = self.get_config_dir()
             os.makedirs(config_dir, exist_ok=True)
-            json_data = {'version': CURRENT_VERSION, 'settings': self.settings}
+            json_data = {
+                'version': CURRENT_SETTINGS_FILE_VERSION,
+                'settings': self.settings
+            }
             json_obj = jsonpickle.encode(json_data)
             with open(self.get_file_path(), 'w', encoding="utf-8") as f:
                 f.write(json_obj)

shinestacker/core/exceptions.py

@@ -30,7 +30,7 @@ class AlignmentError(FocusStackError):
     def __init__(self, index, details):
         self.index = index
         self.details = details
-        super().__init__(f"Alignment failed for image {index}: {details}")
+        super().__init__(f"Alignment failed for frame {index}: {details}")
 
 
 class BitDepthError(FocusStackError):

shinestacker/core/framework.py

@@ -197,8 +197,8 @@ class Job(TaskBase):
 
 class SequentialTask(TaskBase):
     def __init__(self, name, enabled=True, **kwargs):
-        self.max_threads = kwargs.pop('max_threads', constants.DEFAULT_MAX_FWK_THREADS)
-        self.chunk_submit = kwargs.pop('chunk_submit', constants.DEFAULT_MAX_FWK_CHUNK_SUBMIT)
+        self.max_threads = kwargs.pop('max_threads', constants.DEFAULT_FWK_MAX_THREADS)
+        self.chunk_submit = kwargs.pop('chunk_submit', constants.DEFAULT_FWK_CHUNK_SUBMIT)
         TaskBase.__init__(self, name, enabled, **kwargs)
         self.total_action_counts = None
         self.current_action_count = None

shinestacker/gui/action_config.py

@@ -416,6 +416,29 @@ class FieldBuilder:
         return checkbox
 
 
+def create_tab_layout():
+    tab_layout = QFormLayout()
+    tab_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
+    tab_layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
+    tab_layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
+    tab_layout.setLabelAlignment(Qt.AlignLeft)
+    return tab_layout
+
+
+def add_tab(tab_widget, title):
+    tab = QWidget()
+    tab_layout = create_tab_layout()
+    tab.setLayout(tab_layout)
+    tab_widget.addTab(tab, title)
+    return tab_layout
+
+
+def create_tab_widget(main_layout):
+    tab_widget = QTabWidget()
+    main_layout.addRow(tab_widget)
+    return tab_widget
+
+
 class NoNameActionConfigurator(ActionConfigurator):
     def __init__(self, current_wd):
         super().__init__(current_wd)
@@ -457,26 +480,6 @@ class NoNameActionConfigurator(ActionConfigurator):
     def add_labelled_row(self, label, widget):
         self.add_row(self.labelled_widget(label, widget))
 
-    def create_tab_widget(self, main_layout):
-        tab_widget = QTabWidget()
-        main_layout.addRow(tab_widget)
-        return tab_widget
-
-    def create_tab_layout(self):
-        tab_layout = QFormLayout()
-        tab_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
-        tab_layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
-        tab_layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
-        tab_layout.setLabelAlignment(Qt.AlignLeft)
-        return tab_layout
-
-    def add_tab(self, tab_widget, title):
-        tab = QWidget()
-        tab_layout = self.create_tab_layout()
-        tab.setLayout(tab_layout)
-        tab_widget.addTab(tab, title)
-        return tab_layout
-
     def add_field_to_layout(self, main_layout, tag, field_type, label, required=False, **kwargs):
         return self.add_field(tag, field_type, label, required, add_to_layout=main_layout, **kwargs)
 

shinestacker/gui/action_config_dialog.py

@@ -8,7 +8,7 @@ from .. config.constants import constants
 from .. config.app_config import AppConfig
 from .. algorithms.align import validate_align_config
 from . action_config import (
-    DefaultActionConfigurator,
+    DefaultActionConfigurator, add_tab, create_tab_layout, create_tab_widget,
     FIELD_TEXT, FIELD_ABS_PATH, FIELD_REL_PATH, FIELD_FLOAT,
     FIELD_INT, FIELD_INT_TUPLE, FIELD_BOOL, FIELD_COMBO, FIELD_REF_IDX
 )
@@ -76,10 +76,15 @@ class JobConfigurator(DefaultActionConfigurator):
             input_filepaths = input_filepaths.split(constants.PATH_SEPARATOR)
         self.working_path_label = QLabel(working_path or "Not set")
         self.input_path_label = QLabel(input_path or "Not set")
-        self.input_widget.path_edit.setText('')
         if input_filepaths:
+            full_input_dir = os.path.join(working_path, input_path)
+            self.input_widget.selected_files = [os.path.join(full_input_dir, f)
+                                                for f in input_filepaths]
+            self.input_widget.path_edit.setText(full_input_dir)
             self.input_widget.files_mode_radio.setChecked(True)
         else:
+            full_input_dir = os.path.join(working_path, input_path)
+            self.input_widget.path_edit.setText(full_input_dir)
             self.input_widget.folder_mode_radio.setChecked(False)
         self.input_widget.text_changed_connect(self.update_paths_and_frames)
         self.input_widget.folder_mode_radio.toggled.connect(self.update_paths_and_frames)
@@ -195,10 +200,10 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
 
     def create_form(self, layout, action):
         super().create_form(layout, action)
-        self.tab_widget = self.create_tab_widget(layout)
-        self.general_tab_layout = self.add_tab(self.tab_widget, "General Parameters")
+        self.tab_widget = create_tab_widget(layout)
+        self.general_tab_layout = add_tab(self.tab_widget, "General Parameters")
         self.create_general_tab(self.general_tab_layout)
-        self.algorithm_tab_layout = self.add_tab(self.tab_widget, "Stacking Algorithm")
+        self.algorithm_tab_layout = add_tab(self.tab_widget, "Stacking Algorithm")
         self.create_algorithm_tab(self.algorithm_tab_layout)
 
     def create_general_tab(self, layout):
@@ -225,7 +230,7 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
             default=constants.STACK_ALGO_DEFAULT)
         q_pyramid, q_depthmap = QWidget(), QWidget()
         for q in [q_pyramid, q_depthmap]:
-            q.setLayout(self.create_tab_layout())
+            q.setLayout(create_tab_layout())
         stacked = QStackedWidget()
         stacked.addWidget(q_pyramid)
         stacked.addWidget(q_depthmap)
@@ -267,7 +272,7 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
             q_pyramid.layout(), 'pyramid_memory_limit', FIELD_FLOAT,
             'Memory limit (approx., GBytes)',
             expert=True,
-            required=False, default=constants.DEFAULT_PY_MEMORY_LIMIT_GB,
+            required=False, default=AppConfig.get('focus_stack_params')['memory_limit'],
             min_val=1.0, max_val=64.0)
         max_threads = self.add_field_to_layout(
             q_pyramid.layout(), 'pyramid_max_threads', FIELD_INT, 'Max num. of cores',
@@ -440,8 +445,7 @@ class CombinedActionsConfigurator(DefaultActionConfigurator):
             default=0)
         self.add_field(
             'step_process', FIELD_BOOL, 'Step process', required=False,
-            expert=True,
-            default=True)
+            expert=True, default=constants.DEFAULT_COMBINED_ACTIONS_STEP_PROCESS)
         self.add_field(
             'max_threads', FIELD_INT, 'Max num. of cores',
             required=False, default=AppConfig.get('combined_actions_params')['max_threads'],
@@ -450,7 +454,7 @@ class CombinedActionsConfigurator(DefaultActionConfigurator):
         self.add_field(
             'chunk_submit', FIELD_BOOL, 'Submit in chunks',
             expert=True,
-            required=False, default=constants.DEFAULT_MAX_FWK_CHUNK_SUBMIT)
+            required=False, default=constants.DEFAULT_FWK_CHUNK_SUBMIT)
 
 
 class MaskNoiseConfigurator(DefaultActionConfigurator):
@@ -575,14 +579,14 @@ class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase
         self.detector_field = None
         self.descriptor_field = None
         self.matching_method_field = None
-        self.tab_widget = self.create_tab_widget(layout)
-        feature_layout = self.add_tab(self.tab_widget, "Feature extraction")
+        self.tab_widget = create_tab_widget(layout)
+        feature_layout = add_tab(self.tab_widget, "Feature extraction")
         self.create_feature_tab(feature_layout)
-        transform_layout = self.add_tab(self.tab_widget, "Transform")
+        transform_layout = add_tab(self.tab_widget, "Transform")
         self.create_transform_tab(transform_layout)
-        border_layout = self.add_tab(self.tab_widget, "Border")
+        border_layout = add_tab(self.tab_widget, "Border")
         self.create_border_tab(border_layout)
-        misc_layout = self.add_tab(self.tab_widget, "Miscellanea")
+        misc_layout = add_tab(self.tab_widget, "Miscellanea")
         self.create_miscellanea_tab(misc_layout)
 
     def create_feature_tab(self, layout):
@@ -591,7 +595,6 @@ class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase
             self.change_match_config(
                 self.detector_field, self.descriptor_field,
                 self. matching_method_field, self.show_info)
-
         self.add_bold_label_to_layout(layout, "Feature identification:")
         self.detector_field = self.add_field_to_layout(
             layout, 'detector', FIELD_COMBO, 'Detector', required=False,
@@ -642,9 +645,9 @@ class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase
             options=self.TRANSFORM_OPTIONS, values=constants.VALID_TRANSFORMS,
             default=constants.DEFAULT_TRANSFORM)
         method = self.add_field_to_layout(
-            layout, 'align_method', FIELD_COMBO, 'Align method', required=False,
-            options=self.METHOD_OPTIONS, values=constants.VALID_ALIGN_METHODS,
-            default=constants.DEFAULT_ALIGN_METHOD)
+            layout, 'align_method', FIELD_COMBO, 'Estimation method', required=False,
+            options=self.METHOD_OPTIONS, values=constants.VALID_ESTIMATION_METHODS,
+            default=constants.DEFAULT_ESTIMATION_METHOD)
         rans_threshold = self.add_field_to_layout(
             layout, 'rans_threshold', FIELD_FLOAT, 'RANSAC threshold (px)', required=False,
             expert=True,
@@ -689,6 +692,14 @@ class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase
 
         transform.currentIndexChanged.connect(change_transform)
         change_transform()
+        phase_corr_fallback = self.add_field_to_layout(
+            layout, 'phase_corr_fallback', FIELD_BOOL, "Phase correlation as fallback",
+            required=False, expert=True, default=constants.DEFAULT_PHASE_CORR_FALLBACK)
+        phase_corr_fallback.setToolTip(
+            "Align using phase correlation algorithm if the number of matches\n"
+            "is too low to determine the transformation.\n"
+            "This algorithm is not very precise,\n"
+            "and may help only in case of blurred images.")
         self.add_field_to_layout(
             layout, 'abort_abnormal', FIELD_BOOL, 'Abort on abnormal transf.',
             expert=True,
@@ -723,7 +734,7 @@ class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase
                              self.MODE_OPTIONS))[constants.DEFAULT_ALIGN_MODE])
         memory_limit = self.add_field_to_layout(
             layout, 'memory_limit', FIELD_FLOAT, 'Memory limit (approx., GBytes)',
-            required=False, default=constants.DEFAULT_ALIGN_MEMORY_LIMIT_GB,
+            required=False, default=AppConfig.get('align_frames_params')['memory_limit'],
             min_val=1.0, max_val=64.0)
         max_threads = self.add_field_to_layout(
             layout, 'max_threads', FIELD_INT, 'Max num. of cores',
@@ -737,6 +748,10 @@ class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase
             layout, 'bw_matching', FIELD_BOOL, 'Match using black & white',
             expert=True,
             required=False, default=constants.DEFAULT_ALIGN_BW_MATCHING)
+        delta_max = self.add_field_to_layout(
+            layout, 'delta_max', FIELD_INT, 'Max frames skip',
+            required=False, default=constants.DEFAULT_ALIGN_DELTA_MAX,
+            min_val=1, max_val=128)
 
         def change_mode():
             text = mode.currentText()
@@ -745,6 +760,7 @@ class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase
             max_threads.setEnabled(enabled)
             chunk_submit.setEnabled(enabled)
             bw_matching.setEnabled(enabled)
+            delta_max.setEnabled(enabled)
 
         mode.currentIndexChanged.connect(change_mode)
 

shinestacker/gui/gui_images.py

@@ -1,14 +1,17 @@
-# pylint: disable=C0114, C0115, C0116, E0611, W0718, E1101, C0103
+# pylint: disable=C0114, C0115, C0116, E0611, W0718, E1101, C0103, R0914
 import webbrowser
 import subprocess
 import os
+import numpy as np
+import cv2
 from PySide6.QtWidgets import QSizePolicy, QVBoxLayout, QWidget, QLabel, QStackedWidget
 from PySide6.QtPdf import QPdfDocument
 from PySide6.QtPdfWidgets import QPdfView
 from PySide6.QtCore import Qt, QMargins
-from PySide6.QtGui import QPixmap
+from PySide6.QtGui import QPixmap, QImage
 from .. config.gui_constants import gui_constants
 from .. core.core_utils import running_under_windows, running_under_macos
+from .. algorithms.utils import read_img
 
 
 def open_file(file_path):
@@ -74,7 +77,28 @@ class GuiImageView(QWidget):
         self.image_label.setAlignment(Qt.AlignCenter)
         self.main_layout.addWidget(self.image_label)
         self.setLayout(self.main_layout)
-        pixmap = QPixmap(file_path)
+        try:
+            img = read_img(file_path)
+            height, width = img.shape[:2]
+            scale_factor = gui_constants.GUI_IMG_WIDTH / width
+            new_height = int(height * scale_factor)
+            img = cv2.resize(img, (gui_constants.GUI_IMG_WIDTH, new_height),
+                             interpolation=cv2.INTER_LINEAR)
+        except Exception as e:
+            raise RuntimeError(f"Can't load file: {file_path}.") from e
+        if img.dtype == np.uint16:
+            img = (img // 256).astype(np.uint8)
+        if len(img.shape) == 3:
+            h, w, ch = img.shape
+            bytes_per_line = ch * w
+            rgb_image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+            q_img = QImage(rgb_image.data, w, h, bytes_per_line, QImage.Format_RGB888)
+        else:
+            h, w = img.shape
+            bytes_per_line = w
+            q_img = QImage(img.data, w, h, bytes_per_line, QImage.Format_Grayscale8)
+        pixmap = QPixmap.fromImage(q_img)
+        self.image_label.setPixmap(pixmap)
         if pixmap:
             scaled_pixmap = pixmap.scaledToWidth(
                 gui_constants.GUI_IMG_WIDTH, Qt.SmoothTransformation)

shinestacker/gui/new_project.py

@@ -76,21 +76,32 @@ class NewProjectDialog(BaseFormDialog):
         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)
+
         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)
+        input_layout = QHBoxLayout()
+        input_layout.setContentsMargins(0, 0, 0, 0)
+        input_layout.setSpacing(10)
+        input_label = QLabel("Input:")
+        input_label.setFixedWidth(60)
         self.input_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
+        input_layout.addWidget(input_label)
+        input_layout.addWidget(self.input_widget)
+        frames_layout = QHBoxLayout()
+        frames_layout.setContentsMargins(0, 0, 0, 0)
+        frames_layout.setSpacing(10)
+        frames_label = QLabel("Number of selected frames:")
+        frames_label.setFixedWidth(180)
         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)
+        frames_layout.addWidget(frames_label)
+        frames_layout.addWidget(self.frames_label)
+        frames_layout.addStretch()
+        step1_layout.addLayout(input_layout)
+        step1_layout.addLayout(frames_layout)
         step1_group.setLayout(step1_layout)
         self.form_layout.addRow(step1_group)
         step2_group = QGroupBox("2) Basic Options")

shinestacker/gui/project_controller.py

@@ -14,6 +14,9 @@ from .project_model import Project
 from .project_editor import ProjectEditor
 
 
+CURRENT_PROJECT_FILE_VERSION = 1
+
+
 class ProjectController(QObject):
     update_title_requested = Signal()
     refresh_ui_requested = Signal(int, int)
@@ -162,14 +165,15 @@ class ProjectController(QObject):
             if dialog.get_noise_detection():
                 job_noise = ActionConfig(
                     constants.ACTION_JOB,
-                    {'name': f'{input_path}-detect-noise', 'working_path': working_path,
+                    {'name': f'{input_path}-noise-job', 'working_path': working_path,
                      'input_path': input_path})
+                noise_detection_name = f'{input_path}-detect-noise'
                 noise_detection = ActionConfig(constants.ACTION_NOISEDETECTION,
-                                               {'name': f'{input_path}-detect-noise'})
+                                               {'name': noise_detection_name})
                 job_noise.add_sub_action(noise_detection)
                 self.add_job_to_project(job_noise)
             job_params = {
-                'name': f'{input_path}-focus-stack',
+                'name': f'{input_path}-stack-job',
                 'working_path': working_path,
                 'input_path': input_path
             }
@@ -184,7 +188,10 @@ class ProjectController(QObject):
                     constants.ACTION_COMBO, {'name': preprocess_name})
                 if dialog.get_noise_detection():
                     mask_noise = ActionConfig(
-                        constants.ACTION_MASKNOISE, {'name': 'mask-noise'})
+                        constants.ACTION_MASKNOISE,
+                        {'name': 'mask-noise',
+                         'noise_mask': os.path.join(noise_detection_name,
+                                                    constants.DEFAULT_NOISE_MAP_FILENAME)})
                     combo_action.add_sub_action(mask_noise)
                 if dialog.get_vignetting_correction():
                     vignetting = ActionConfig(
@@ -251,7 +258,7 @@ class ProjectController(QObject):
                 self.set_current_file_path(file_path)
                 with open(self.current_file_path(), 'r', encoding="utf-8") as file:
                     json_obj = json.load(file)
-                project = Project.from_dict(json_obj['project'])
+                project = Project.from_dict(json_obj['project'], json_obj['version'])
                 if project is None:
                     raise RuntimeError(f"Project from file {file_path} produced a null project.")
                 self.set_enabled_file_open_close_actions_requested.emit(True)
@@ -313,7 +320,7 @@ class ProjectController(QObject):
     def do_save(self, file_path):
         try:
             json_obj = jsonpickle.encode({
-                'project': self.project().to_dict(), 'version': 1
+                'project': self.project().to_dict(), 'version': CURRENT_PROJECT_FILE_VERSION
             })
             with open(file_path, 'w', encoding="utf-8") as f:
                 f.write(json_obj)

shinestacker/gui/project_editor.py

@@ -1,8 +1,9 @@
 # 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, QEvent
+from PySide6.QtWidgets import (QListWidget, QMessageBox, QDialog, QListWidgetItem, QLabel,
+                               QSizePolicy)
+from PySide6.QtCore import Qt, QObject, Signal, QEvent, QSize
 from .. config.constants import constants
 from .colors import ColorPalette
 from .action_config_dialog import ActionConfigDialog
@@ -105,6 +106,8 @@ class HandCursorListWidget(QListWidget):
         super().__init__(parent)
         self.setMouseTracking(True)
         self.viewport().setMouseTracking(True)
+        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+        self.setWordWrap(False)
 
     def event(self, event):
         if event.type() == QEvent.HoverMove:
@@ -503,6 +506,13 @@ class ProjectEditor(QObject):
                     if action.enabled() \
                     else f"🚫 <span style='color:#{ColorPalette.DARK_RED.hex()};'>{text}</span>"
         label = QLabel(html_text)
+        label.setTextFormat(Qt.RichText)
+        label.setWordWrap(False)
+        label.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
+        label.adjustSize()
+        ideal_width = label.sizeHint().width()
+        widget_list.setItemWidget(item, label)
+        item.setSizeHint(QSize(ideal_width, label.sizeHint().height()))
         widget_list.setItemWidget(item, label)
 
     def add_sub_action(self, type_name):

shinestacker/gui/project_model.py

@@ -62,10 +62,10 @@ class ActionConfig:
         return project_dict
 
     @classmethod
-    def from_dict(cls, data):
+    def from_dict(cls, data, version):
         a = ActionConfig(data['type_name'], data['params'])
         if 'sub_actions' in data.keys():
-            a.sub_actions = [ActionConfig.from_dict(s) for s in data['sub_actions']]
+            a.sub_actions = [ActionConfig.from_dict(s, version) for s in data['sub_actions']]
             for s in a.sub_actions:
                 s.parent = a
         return a
@@ -84,9 +84,9 @@ class Project:
         return [j.to_dict() for j in self.jobs]
 
     @classmethod
-    def from_dict(cls, data):
+    def from_dict(cls, data, version):
         p = Project()
-        p.jobs = [ActionConfig.from_dict(j) for j in data]
+        p.jobs = [ActionConfig.from_dict(j, version) for j in data]
         for j in p.jobs:
             for s in j.sub_actions:
                 s.parent = j