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

shinestacker/gui/main_window.py

@@ -1,19 +1,22 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0902, R0915, R0904, R0914, R0912, E1101, W0201
+# pylint: disable=C0114, C0115, C0116, E0611, R0902, R0915, R0904, R0914
+# pylint: disable=R0912, E1101, W0201, E1121, R0913, R0917
 import os
 import subprocess
-from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QTabWidget, QLabel, QMessageBox,
-                               QSplitter, QToolBar, QMenu, QComboBox, QStackedWidget)
-from PySide6.QtCore import Qt, Signal
-from PySide6.QtGui import QGuiApplication, QAction, QIcon, QPixmap
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QGuiApplication, QAction, QIcon
+from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QLabel, QMessageBox,
+                               QSplitter, QToolBar, QMenu, QMainWindow)
 from .. config.constants import constants
-from .. core.core_utils import running_under_windows, running_under_macos, get_app_base_path
+from .. core.core_utils import running_under_windows, running_under_macos
 from .colors import ColorPalette
 from .project_model import Project
-from .actions_window import ActionsWindow
 from .gui_logging import LogManager
 from .gui_run import RunWindow, RunWorker
 from .project_converter import ProjectConverter
 from .project_model import get_action_working_path, get_action_input_path, get_action_output_path
+from .menu_manager import MenuManager
+from .project_controller import ProjectController
+from .tab_widget import TabWidgetWithPlaceholder
 
 
 class JobLogWorker(RunWorker):
@@ -45,105 +48,50 @@ LIST_STYLE_SHEET = f"""
 """
 
 
-class TabWidgetWithPlaceholder(QWidget):
-    # Segnali aggiuntivi per mantenere la compatibilità
-    currentChanged = Signal(int)
-    tabCloseRequested = Signal(int)
-
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.layout = QVBoxLayout(self)
-        self.layout.setContentsMargins(0, 0, 0, 0)
-        self.stacked_widget = QStackedWidget()
-        self.layout.addWidget(self.stacked_widget)
-        self.tab_widget = QTabWidget()
-        self.stacked_widget.addWidget(self.tab_widget)
-        self.placeholder = QLabel()
-        self.placeholder.setAlignment(Qt.AlignmentFlag.AlignCenter)
-        rel_path = 'ico/focus_stack_bkg.png'
-        icon_path = f'{get_app_base_path()}/{rel_path}'
-        if not os.path.exists(icon_path):
-            icon_path = f'{get_app_base_path()}/../{rel_path}'
-        if os.path.exists(icon_path):
-            pixmap = QPixmap(icon_path)
-            # Ridimensiona mantenendo le proporzioni (es. max 400x400)
-            pixmap = pixmap.scaled(250, 250, Qt.AspectRatioMode.KeepAspectRatio,
-                                   Qt.TransformationMode.SmoothTransformation)
-            self.placeholder.setPixmap(pixmap)
-        else:
-            self.placeholder.setText("Run logs will appear here.")
-        self.stacked_widget.addWidget(self.placeholder)
-        self.tab_widget.currentChanged.connect(self._on_current_changed)
-        self.tab_widget.tabCloseRequested.connect(self._on_tab_close_requested)
-        self.update_placeholder_visibility()
-
-    def _on_current_changed(self, index):
-        self.currentChanged.emit(index)
-        self.update_placeholder_visibility()
-
-    def _on_tab_close_requested(self, index):
-        self.tabCloseRequested.emit(index)
-        self.update_placeholder_visibility()
-
-    def update_placeholder_visibility(self):
-        if self.tab_widget.count() == 0:
-            self.stacked_widget.setCurrentIndex(1)
-        else:
-            self.stacked_widget.setCurrentIndex(0)
-
-    # pylint: disable=C0103
-    def addTab(self, widget, label):
-        result = self.tab_widget.addTab(widget, label)
-        self.update_placeholder_visibility()
-        return result
-
-    def removeTab(self, index):
-        result = self.tab_widget.removeTab(index)
-        self.update_placeholder_visibility()
-        return result
-
-    def count(self):
-        return self.tab_widget.count()
-
-    def setCurrentIndex(self, index):
-        return self.tab_widget.setCurrentIndex(index)
-
-    def currentIndex(self):
-        return self.tab_widget.currentIndex()
-
-    def currentWidget(self):
-        return self.tab_widget.currentWidget()
-
-    def widget(self, index):
-        return self.tab_widget.widget(index)
-
-    def indexOf(self, widget):
-        return self.tab_widget.indexOf(widget)
-    # pylint: enable=C0103
-
-
-class MainWindow(ActionsWindow, LogManager):
+class MainWindow(QMainWindow, LogManager):
     def __init__(self):
-        ActionsWindow.__init__(self)
+        QMainWindow.__init__(self)
         LogManager.__init__(self)
+        self.project_controller = ProjectController(self)
+        self.project_editor = self.project_controller.project_editor
+        actions = {
+            "&New...": self.project_controller.new_project,
+            "&Open...": self.project_controller.open_project,
+            "&Close": self.project_controller.close_project,
+            "&Save": self.project_controller.save_project,
+            "Save &As...": self.project_controller.save_project_as,
+            "&Undo": self.project_editor.undo,
+            "&Cut": self.project_editor.cut_element,
+            "Cop&y": self.project_editor.copy_element,
+            "&Paste": self.project_editor.paste_element,
+            "Duplicate": self.project_editor.clone_element,
+            "Delete": self.delete_element,
+            "Move &Up": self.project_editor.move_element_up,
+            "Move &Down": self.project_editor.move_element_down,
+            "E&nable": self.project_editor.enable,
+            "Di&sable": self.project_editor.disable,
+            "Enable All": self.project_editor.enable_all,
+            "Disable All": self.project_editor.disable_all,
+            "Expert Options": self.toggle_expert_options,
+            "Add Job": self.project_editor.add_job,
+            "Run Job": self.run_job,
+            "Run All Jobs": self.run_all_jobs,
+        }
+        self.menu_manager = MenuManager(self.menuBar(), actions, self.project_editor, self)
+        self.script_dir = os.path.dirname(__file__)
         self._windows = []
         self._workers = []
         self.retouch_callback = None
-        self.job_list.setStyleSheet(LIST_STYLE_SHEET)
-        self.action_list.setStyleSheet(LIST_STYLE_SHEET)
-        menubar = self.menuBar()
-        self.add_file_menu(menubar)
-        self.add_edit_menu(menubar)
-        self.add_view_menu(menubar)
-        self.add_job_menu(menubar)
-        self.add_actions_menu(menubar)
-        self.add_help_menu(menubar)
+        self.expert_options = False
+        self.job_list().setStyleSheet(LIST_STYLE_SHEET)
+        self.action_list().setStyleSheet(LIST_STYLE_SHEET)
+        self.menu_manager.add_menus()
         toolbar = QToolBar(self)
         self.addToolBar(Qt.TopToolBarArea, toolbar)
-        self.fill_toolbar(toolbar)
+        self.menu_manager.fill_toolbar(toolbar)
         self.resize(1200, 800)
-        center = QGuiApplication.primaryScreen().geometry().center()
-        self.move(center - self.rect().center())
+        self.move(QGuiApplication.primaryScreen().geometry().center() -
+                  self.rect().center())
         self.set_project(Project())
         self.central_widget = QWidget()
         self.setCentralWidget(self.central_widget)
@@ -158,243 +106,181 @@ class MainWindow(ActionsWindow, LogManager):
         self.tab_widget = TabWidgetWithPlaceholder()
         self.tab_widget.resize(1000, 500)
         h_splitter.addWidget(self.tab_widget)
-        self.job_list.currentRowChanged.connect(self.on_job_selected)
-        self.job_list.itemDoubleClicked.connect(self.on_job_edit)
-        self.action_list.itemDoubleClicked.connect(self.on_action_edit)
+        self.job_list().currentRowChanged.connect(self.project_editor.on_job_selected)
+        self.job_list().itemDoubleClicked.connect(self.on_job_edit)
+        self.action_list().itemDoubleClicked.connect(self.on_action_edit)
         vbox_left = QVBoxLayout()
         vbox_left.setSpacing(4)
         vbox_left.addWidget(QLabel("Job"))
-        vbox_left.addWidget(self.job_list)
+        vbox_left.addWidget(self.job_list())
         vbox_right = QVBoxLayout()
         vbox_right.setSpacing(4)
         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)
+        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)
         h_layout.addLayout(vbox_left)
         h_layout.addLayout(vbox_right)
         layout.addWidget(h_splitter)
         self.central_widget.setLayout(layout)
+        self.update_title()
+
+        def handle_modified(modified):
+            self.save_actions_set_enabled(modified)
+            self.update_title()
+
+        self.project_editor.modified_signal.connect(handle_modified)
+        self.project_editor.select_signal.connect(self.update_delete_action_state)
+        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_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)
+        self.project_controller.enable_save_actions_requested.connect(
+            self.menu_manager.save_actions_set_enabled)
+
+    def modified(self):
+        return self.project_editor.modified()
+
+    def mark_as_modified(self, modified=True):
+        self.project_editor.mark_as_modified(modified)
+
+    def set_project(self, project):
+        self.project_editor.set_project(project)
+
+    def project(self):
+        return self.project_editor.project()
+
+    def project_jobs(self):
+        return self.project_editor.project_jobs()
+
+    def project_job(self, i):
+        return self.project_editor.project_job(i)
+
+    def add_job_to_project(self, job):
+        self.project_editor.add_job_to_project(job)
+
+    def num_project_jobs(self):
+        return self.project_editor.num_project_jobs()
+
+    def current_file_path(self):
+        return self.project_editor.current_file_path()
+
+    def current_file_directory(self):
+        return self.project_editor.current_file_directory()
+
+    def current_file_name(self):
+        return self.project_editor.current_file_name()
+
+    def set_current_file_path(self, path):
+        self.project_editor.set_current_file_path(path)
+
+    def job_list(self):
+        return self.project_editor.job_list()
+
+    def action_list(self):
+        return self.project_editor.action_list()
+
+    def current_job_index(self):
+        return self.project_editor.current_job_index()
+
+    def current_action_index(self):
+        return self.project_editor.current_action_index()
+
+    def set_current_job(self, index):
+        return self.project_editor.set_current_job(index)
+
+    def set_current_action(self, index):
+        return self.project_editor.set_current_action(index)
+
+    def job_list_count(self):
+        return self.project_editor.job_list_count()
+
+    def action_list_count(self):
+        return self.project_editor.action_list_count()
+
+    def job_list_item(self, index):
+        return self.project_editor.job_list_item(index)
+
+    def action_list_item(self, index):
+        return self.project_editor.action_list_item(index)
+
+    def job_list_has_focus(self):
+        return self.project_editor.job_list_has_focus()
+
+    def action_list_has_focus(self):
+        return self.project_editor.action_list_has_focus()
+
+    def clear_job_list(self):
+        self.project_editor.clear_job_list()
+
+    def clear_action_list(self):
+        self.project_editor.clear_action_list()
+
+    def num_selected_jobs(self):
+        return self.project_editor.num_selected_jobs()
+
+    def num_selected_actions(self):
+        return self.project_editor.num_selected_actions()
+
+    def get_current_action_at(self, job, action_index):
+        return self.project_editor.get_current_action_at(job, action_index)
+
+    def action_config_dialog(self, action):
+        return self.project_editor.action_config_dialog(action)
+
+    def action_text(self, action, is_sub_action=False, indent=True, long_name=False, html=False):
+        return self.project_editor.action_text(action, is_sub_action, indent, long_name, html)
+
+    def job_text(self, job, long_name=False, html=False):
+        return self.project_editor.job_text(job, long_name, html)
+
+    def on_job_selected(self, index):
+        return self.project_editor.on_job_selected(index)
+
+    def get_action_at(self, action_row):
+        return self.project_editor.get_action_at(action_row)
+
+    def on_job_edit(self, item):
+        self.project_controller.on_job_edit(item)
+
+    def on_action_edit(self, item):
+        self.project_controller.on_action_edit(item)
+
+    def edit_current_action(self):
+        self.project_controller.edit_current_action()
+
+    def edit_action(self, action):
+        self.project_controller.edit_action(action)
 
     def set_retouch_callback(self, callback):
         self.retouch_callback = callback
 
-    def add_file_menu(self, menubar):
-        menu = menubar.addMenu("&File")
-        new_action = QAction("&New...", self)
-        new_action.setShortcut("Ctrl+N")
-        new_action.triggered.connect(self.new_project)
-        menu.addAction(new_action)
-        open_action = QAction("&Open...", self)
-        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)
-        close_action = QAction("&Close", self)
-        close_action.setShortcut("Ctrl+W")
-        close_action.triggered.connect(self.close_project)
-        menu.addAction(close_action)
-
-    def add_edit_menu(self, menubar):
-        menu = menubar.addMenu("&Edit")
-        undo_action = QAction("&Undo", self)
-        undo_action.setShortcut("Ctrl+Z")
-        undo_action.triggered.connect(self.undo)
-        menu.addAction(undo_action)
-        menu.addSeparator()
-        cut_action = QAction("&Cut", self)
-        cut_action.setShortcut("Ctrl+X")
-        cut_action.triggered.connect(self.cut_element)
-        menu.addAction(cut_action)
-        copy_action = QAction("Cop&y", self)
-        copy_action.setShortcut("Ctrl+C")
-        copy_action.triggered.connect(self.copy_element)
-        menu.addAction(copy_action)
-        paste_action = QAction("&Paste", self)
-        paste_action.setShortcut("Ctrl+V")
-        paste_action.triggered.connect(self.paste_element)
-        menu.addAction(paste_action)
-        clone_action = QAction("Duplicate", self)
-        clone_action.setShortcut("Ctrl+D")
-        clone_action.triggered.connect(self.clone_element)
-        menu.addAction(clone_action)
-        self.delete_element_action = QAction("Delete", self)
-        self.delete_element_action.setShortcut("Del")  # Qt.Key_Backspace
-        self.delete_element_action.setIcon(self.get_icon("close-round-line-icon"))
-        self.delete_element_action.setToolTip("delete")
-        self.delete_element_action.triggered.connect(self.delete_element)
-        self.delete_element_action.setEnabled(False)
-        menu.addAction(self.delete_element_action)
-        menu.addSeparator()
-        up_action = QAction("Move &Up", self)
-        up_action.setShortcut("Ctrl+Up")
-        up_action.triggered.connect(self.move_element_up)
-        menu.addAction(up_action)
-        down_action = QAction("Move &Down", self)
-        down_action.setShortcut("Ctrl+Down")
-        down_action.triggered.connect(self.move_element_down)
-        menu.addAction(down_action)
-        menu.addSeparator()
-        self.enable_action = QAction("E&nable", self)
-        self.enable_action.setShortcut("Ctrl+E")
-        self.enable_action.triggered.connect(self.enable)
-        menu.addAction(self.enable_action)
-        self.disable_action = QAction("Di&sable", self)
-        self.disable_action.setShortcut("Ctrl+B")
-        self.disable_action.triggered.connect(self.disable)
-        menu.addAction(self.disable_action)
-        enable_all_action = QAction("Enable All", self)
-        enable_all_action.setShortcut("Ctrl+Shift+E")
-        enable_all_action.triggered.connect(self.enable_all)
-        menu.addAction(enable_all_action)
-        disable_all_action = QAction("Disable All", self)
-        disable_all_action.setShortcut("Ctrl+Shift+B")
-        disable_all_action.triggered.connect(self.disable_all)
-        menu.addAction(disable_all_action)
-
-    def add_view_menu(self, menubar):
-        menu = menubar.addMenu("&View")
-        self.expert_options_action = QAction("Expert Options", self)
-        self.expert_options_action.setShortcut("Ctrl+Shift+X")
-        self.expert_options_action.triggered.connect(self.toggle_expert_options)
-        self.expert_options_action.setCheckable(True)
-        self.expert_options_action.setChecked(self.expert_options)
-        menu.addAction(self.expert_options_action)
-
-    def add_job_menu(self, menubar):
-        menu = menubar.addMenu("&Jobs")
-        self.add_job_action = QAction("Add Job", self)
-        self.add_job_action.setShortcut("Ctrl+P")
-        self.add_job_action.setIcon(self.get_icon("plus-round-line-icon"))
-        self.add_job_action.setToolTip("Add job")
-        self.add_job_action.triggered.connect(self.add_job)
-        menu.addAction(self.add_job_action)
-        menu.addSeparator()
-        self.run_job_action = QAction("Run Job", self)
-        self.run_job_action.setShortcut("Ctrl+J")
-        self.run_job_action.setIcon(self.get_icon("play-button-round-icon"))
-        self.run_job_action.setToolTip("Run job")
-        self.run_job_action.setEnabled(False)
-        self.run_job_action.triggered.connect(self.run_job)
-        menu.addAction(self.run_job_action)
-        self.run_all_jobs_action = QAction("Run All Jobs", self)
-        self.run_all_jobs_action.setShortcut("Ctrl+Shift+J")
-        self.run_all_jobs_action.setIcon(self.get_icon("forward-button-icon"))
-        self.run_all_jobs_action.setToolTip("Run all jobs")
-        self.run_all_jobs_action.setEnabled(False)
-        self.run_all_jobs_action.triggered.connect(self.run_all_jobs)
-        menu.addAction(self.run_all_jobs_action)
-
-    def add_action_combined_actions(self):
-        self.add_action(constants.ACTION_COMBO)
-
-    def add_action_noise_detection(self):
-        self.add_action(constants.ACTION_NOISEDETECTION)
-
-    def add_action_focus_stack(self):
-        self.add_action(constants.ACTION_FOCUSSTACK)
-
-    def add_action_focus_stack_bunch(self):
-        self.add_action(constants.ACTION_FOCUSSTACKBUNCH)
-
-    def add_action_multilayer(self):
-        self.add_action(constants.ACTION_MULTILAYER)
-
-    def add_sub_action_make_noise(self):
-        self.add_sub_action(constants.ACTION_MASKNOISE)
-
-    def add_sub_action_vignetting(self):
-        self.add_sub_action(constants.ACTION_VIGNETTING)
-
-    def add_sub_action_align_frames(self):
-        self.add_sub_action(constants.ACTION_ALIGNFRAMES)
-
-    def add_sub_action_balance_frames(self):
-        self.add_sub_action(constants.ACTION_BALANCEFRAMES)
-
-    def add_actions_menu(self, menubar):
-        menu = menubar.addMenu("&Actions")
-        add_action_menu = QMenu("Add Action", self)
-        for action in constants.ACTION_TYPES:
-            entry_action = QAction(action, self)
-            entry_action.triggered.connect({
-                constants.ACTION_COMBO: self.add_action_combined_actions,
-                constants.ACTION_NOISEDETECTION: self.add_action_noise_detection,
-                constants.ACTION_FOCUSSTACK: self.add_action_focus_stack,
-                constants.ACTION_FOCUSSTACKBUNCH: self.add_action_focus_stack_bunch,
-                constants.ACTION_MULTILAYER: self.add_action_multilayer
-            }[action])
-            add_action_menu.addAction(entry_action)
-        menu.addMenu(add_action_menu)
-        add_sub_action_menu = QMenu("Add Sub Action", self)
-        self.sub_action_menu_entries = []
-        for action in constants.SUB_ACTION_TYPES:
-            entry_action = QAction(action, self)
-            entry_action.triggered.connect({
-                constants.ACTION_MASKNOISE: self.add_sub_action_make_noise,
-                constants.ACTION_VIGNETTING: self.add_sub_action_vignetting,
-                constants.ACTION_ALIGNFRAMES: self.add_sub_action_align_frames,
-                constants.ACTION_BALANCEFRAMES: self.add_sub_action_balance_frames
-            }[action])
-            entry_action.setEnabled(False)
-            self.sub_action_menu_entries.append(entry_action)
-            add_sub_action_menu.addAction(entry_action)
-        menu.addMenu(add_sub_action_menu)
-
-    def add_help_menu(self, menubar):
-        menu = menubar.addMenu("&Help")
-        menu.setObjectName("Help")
-
-    def fill_toolbar(self, toolbar):
-        toolbar.addAction(self.add_job_action)
-        toolbar.addSeparator()
-        self.action_selector = QComboBox()
-        self.action_selector.addItems(constants.ACTION_TYPES)
-        self.action_selector.setEnabled(False)
-        toolbar.addWidget(self.action_selector)
-        self.add_action_entry_action = QAction("Add Action", self)
-        self.add_action_entry_action.setIcon(
-            QIcon(os.path.join(self.script_dir, "img/plus-round-line-icon.png")))
-        self.add_action_entry_action.setToolTip("Add action")
-        self.add_action_entry_action.triggered.connect(self.add_action)
-        self.add_action_entry_action.setEnabled(False)
-        toolbar.addAction(self.add_action_entry_action)
-        self.sub_action_selector = QComboBox()
-        self.sub_action_selector.addItems(constants.SUB_ACTION_TYPES)
-        self.sub_action_selector.setEnabled(False)
-        toolbar.addWidget(self.sub_action_selector)
-        self.add_sub_action_entry_action = QAction("Add Sub Action", self)
-        self.add_sub_action_entry_action.setIcon(
-            QIcon(os.path.join(self.script_dir, "img/plus-round-line-icon.png")))
-        self.add_sub_action_entry_action.setToolTip("Add sub action")
-        self.add_sub_action_entry_action.triggered.connect(self.add_sub_action)
-        self.add_sub_action_entry_action.setEnabled(False)
-        toolbar.addAction(self.add_sub_action_entry_action)
-        toolbar.addSeparator()
-        toolbar.addAction(self.delete_element_action)
-        toolbar.addSeparator()
-        toolbar.addAction(self.run_job_action)
-        toolbar.addAction(self.run_all_jobs_action)
+    def save_actions_set_enabled(self, enabled):
+        self.menu_manager.save_actions_set_enabled(enabled)
+
+    def update_title(self):
+        title = constants.APP_TITLE
+        file_name = self.current_file_name()
+        if file_name:
+            title += f" - {file_name}"
+            if self.modified():
+                title += " *"
+        self.window().setWindowTitle(title)
 
     # pylint: disable=C0103
     def contextMenuEvent(self, event):
-        item = self.job_list.itemAt(self.job_list.viewport().mapFrom(self, event.pos()))
+        item = self.job_list().itemAt(self.job_list().viewport().mapFrom(self, event.pos()))
         current_action = None
         if item:
-            index = self.job_list.row(item)
+            index = self.job_list().row(item)
             current_action = self.get_job_at(index)
-            self.job_list.setCurrentRow(index)
-        item = self.action_list.itemAt(self.action_list.viewport().mapFrom(self, event.pos()))
+            self.set_current_job(index)
+        item = self.action_list().itemAt(self.action_list().viewport().mapFrom(self, event.pos()))
         if item:
-            index = self.action_list.row(item)
-            self.action_list.setCurrentRow(index)
+            index = self.action_list().row(item)
+            self.set_current_action(index)
             _job_row, _action_row, pos = self.get_action_at(index)
             current_action = pos.action if not pos.is_sub_action else pos.sub_action
         if current_action:
@@ -412,7 +298,7 @@ class MainWindow(ActionsWindow, LogManager):
                     os.path.exists(self.current_action_working_path):
                 action_name = "Browse Working Path" + (f" > {name}" if name != '' else '')
                 self.browse_working_path_action = QAction(action_name)
-                self.browse_working_path_action.triggered.connect(self.browse_working_path_path)
+                self.browse_working_path_action.triggered.connect(self.browse_working_path)
                 menu.addAction(self.browse_working_path_action)
             ip, name = get_action_input_path(current_action)
             if ip != '':
@@ -426,16 +312,24 @@ class MainWindow(ActionsWindow, LogManager):
                         break
                 if p_exists:
                     action_name = "Browse Input Path" + (f" > {name}" if name != '' else '')
+                    n_files = [f"{len(next(os.walk(p))[2])}"
+                               for p in
+                               self.current_action_input_path.split(constants.PATH_SEPARATOR)]
+                    s = "" if len(n_files) == 1 and n_files[0] == 1 else "s"
+                    action_name += " (" + ", ".join(n_files) + f" file{s})"
                     self.browse_input_path_action = QAction(action_name)
-                    self.browse_input_path_action.triggered.connect(self.browse_input_path_path)
+                    self.browse_input_path_action.triggered.connect(self.browse_input_path)
                     menu.addAction(self.browse_input_path_action)
             op, name = get_action_output_path(current_action)
             if op != '':
                 self.current_action_output_path = f"{self.current_action_working_path}/{op}"
                 if os.path.exists(self.current_action_output_path):
                     action_name = "Browse Output Path" + (f" > {name}" if name != '' else '')
+                    n_files = len(next(os.walk(op))[2])
+                    s = "" if n_files == 1 else "s"
+                    action_name += f" ({n_files} file{s})"
                     self.browse_output_path_action = QAction(action_name)
-                    self.browse_output_path_action.triggered.connect(self.browse_output_path_path)
+                    self.browse_output_path_action.triggered.connect(self.browse_output_path)
                     menu.addAction(self.browse_output_path_action)
             menu.addSeparator()
             menu.addAction(self.run_job_action)
@@ -483,58 +377,57 @@ class MainWindow(ActionsWindow, LogManager):
             if os.path.exists(p):
                 if running_under_windows():
                     os.startfile(os.path.normpath(p))
-                elif running_under_macos():
-                    subprocess.run(['open', p], check=True)
                 else:
-                    subprocess.run(['xdg-open', p], check=True)
+                    cmd = 'open' if running_under_macos() else 'xdg-open'
+                    subprocess.run([cmd, p], check=True)
 
-    def browse_working_path_path(self):
+    def browse_working_path(self):
         self.browse_path(self.current_action_working_path)
 
-    def browse_input_path_path(self):
+    def browse_input_path(self):
         self.browse_path(self.current_action_input_path)
 
-    def browse_output_path_path(self):
+    def browse_output_path(self):
         self.browse_path(self.current_action_output_path)
 
     def refresh_ui(self, job_row=-1, action_row=-1):
-        self.job_list.clear()
-        for job in self.project.jobs:
-            self.add_list_item(self.job_list, job, False)
-        if self.project.jobs:
-            self.job_list.setCurrentRow(0)
+        self.clear_job_list()
+        for job in self.project_jobs():
+            self.project_editor.add_list_item(self.job_list(), job, False)
+        if self.project_jobs():
+            self.set_current_job(0)
         if job_row >= 0:
-            self.job_list.setCurrentRow(job_row)
+            self.set_current_job(job_row)
         if action_row >= 0:
-            self.action_list.setCurrentRow(action_row)
-        if self.job_list.count() == 0:
-            self.add_action_entry_action.setEnabled(False)
-            self.action_selector.setEnabled(False)
+            self.set_current_action(action_row)
+        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)
         else:
-            self.add_action_entry_action.setEnabled(True)
-            self.action_selector.setEnabled(True)
-            self.delete_element_action.setEnabled(True)
-            self.run_job_action.setEnabled(True)
-            self.run_all_jobs_action.setEnabled(True)
+            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)
 
     def quit(self):
-        if self._check_unsaved_changes():
+        if self.project_controller.check_unsaved_changes():
             for worker in self._workers:
                 worker.stop()
             self.close()
 
     def toggle_expert_options(self):
-        self.expert_options = self.expert_options_action.isChecked()
+        self.expert_options = self.menu_manager.expert_options_action.isChecked()
 
     def set_expert_options(self):
         self.expert_options_action.setChecked(True)
         self.expert_options = True
 
     def before_thread_begins(self):
-        self.run_job_action.setEnabled(False)
-        self.run_all_jobs_action.setEnabled(False)
+        self.menu_manager.run_job_action.setEnabled(False)
+        self.menu_manager.run_all_jobs_action.setEnabled(False)
 
     def get_tab_and_position(self, id_str):
         for i in range(self.tab_widget.count()):
@@ -552,8 +445,8 @@ class MainWindow(ActionsWindow, LogManager):
         return i
 
     def do_handle_end_message(self, status, id_str, message):
-        self.run_job_action.setEnabled(True)
-        self.run_all_jobs_action.setEnabled(True)
+        self.menu_manager.run_job_action.setEnabled(True)
+        self.menu_manager.run_all_jobs_action.setEnabled(True)
         tab = self.get_tab_at_position(id_str)
         tab.close_button.setEnabled(True)
         tab.stop_button.setEnabled(False)
@@ -564,8 +457,7 @@ class MainWindow(ActionsWindow, LogManager):
         new_window = RunWindow(labels,
                                lambda id_str: self.stop_worker(self.get_tab_position(id_str)),
                                lambda id_str: self.close_window(self.get_tab_position(id_str)),
-                               retouch_paths,
-                               self)
+                               retouch_paths, self)
         self.tab_widget.addTab(new_window, title)
         self.tab_widget.setCurrentIndex(self.tab_widget.count() - 1)
         if title is not None:
@@ -584,7 +476,7 @@ class MainWindow(ActionsWindow, LogManager):
         worker = self._workers[tab_position]
         worker.stop()
 
-    def connect_signals(self, worker, window):
+    def connect_worker_signals(self, worker, window):
         worker.before_action_signal.connect(window.handle_before_action)
         worker.after_action_signal.connect(window.handle_after_action)
         worker.step_counts_signal.connect(window.handle_step_counts)
@@ -593,23 +485,18 @@ class MainWindow(ActionsWindow, LogManager):
         worker.after_step_signal.connect(window.handle_after_step)
         worker.save_plot_signal.connect(window.handle_save_plot)
         worker.open_app_signal.connect(window.handle_open_app)
-
-    def set_enabled_sub_actions_gui(self, enabled):
-        self.add_sub_action_entry_action.setEnabled(enabled)
-        self.sub_action_selector.setEnabled(enabled)
-        for a in self.sub_action_menu_entries:
-            a.setEnabled(enabled)
+        worker.run_completed_signal.connect(window.handle_run_completed)
+        worker.run_stopped_signal.connect(window.handle_run_stopped)
+        worker.run_failed_signal.connect(window.handle_run_failed)
 
     def run_job(self):
-        current_index = self.job_list.currentRow()
+        current_index = self.current_job_index()
         if current_index < 0:
-            if len(self.project.jobs) > 0:
-                QMessageBox.warning(self, "No Job Selected", "Please select a job first.")
-            else:
-                QMessageBox.warning(self, "No Job Added", "Please add a job first.")
+            msg = "No Job Selected" if self.num_project_jobs() > 0 else "No Job Added"
+            QMessageBox.warning(self, msg, "Please select a job first.")
             return
         if current_index >= 0:
-            job = self.project.jobs[current_index]
+            job = self.project_job(current_index)
             if job.enabled():
                 job_name = job.params["name"]
                 labels = [[(self.action_text(a), a.enabled()) for a in job.sub_actions]]
@@ -618,29 +505,51 @@ class MainWindow(ActionsWindow, LogManager):
                 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)
+                self.connect_worker_signals(worker, new_window)
                 self.start_thread(worker)
                 self._workers.append(worker)
             else:
-                QMessageBox.warning(
-                    self, "Can't run Job",
-                    "Job " + job.params["name"] + " is disabled.")
+                QMessageBox.warning(self, "Can't run Job",
+                                    "Job " + job.params["name"] + " is disabled.")
                 return
 
     def run_all_jobs(self):
         labels = [[(self.action_text(a), a.enabled() and
-                    job.enabled()) for a in job.sub_actions] for job in self.project.jobs]
+                    job.enabled()) for a in job.sub_actions] for job in self.project_jobs()]
         project_name = ".".join(self.current_file_name().split(".")[:-1])
         if project_name == '':
             project_name = '[new]'
         retouch_paths = []
-        for job in self.project.jobs:
+        for job in self.project_jobs():
             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(f"{project_name} [Project 📚]",
                                                     labels, retouch_paths)
-        worker = ProjectLogWorker(self.project, id_str)
-        self.connect_signals(worker, new_window)
+        worker = ProjectLogWorker(self.project(), id_str)
+        self.connect_worker_signals(worker, new_window)
         self.start_thread(worker)
         self._workers.append(worker)
+
+    def delete_element(self):
+        self.project_editor.delete_element()
+        if self.job_list_count() > 0:
+            self.menu_manager.delete_element_action.setEnabled(True)
+
+    def update_delete_action_state(self):
+        has_job_selected = self.num_selected_jobs() > 0
+        has_action_selected = self.num_selected_actions() > 0
+        self.menu_manager.delete_element_action.setEnabled(
+            has_job_selected or has_action_selected)
+        if has_action_selected and has_job_selected:
+            job_index = min(self.current_job_index(), self.num_project_jobs() - 1)
+            action_index = self.current_action_index()
+            if job_index >= 0:
+                job = self.project_job(job_index)
+                current_action, is_sub_action = \
+                    self.get_current_action_at(job, action_index)
+                enable_sub_actions = current_action is not None and \
+                    not is_sub_action and current_action.type_name == constants.ACTION_COMBO
+                self.menu_manager.set_enabled_sub_actions_gui(enable_sub_actions)
+        else:
+            self.menu_manager.set_enabled_sub_actions_gui(False)