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

shinestacker/gui/{actions_window.py → project_controller.py}

@@ -1,60 +1,153 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0914, R0912, R0915, W0718
-import os.path
+# pylint: disable=C0114, C0115, C0116, E0611, R0913, R0917, R0914, R0912, R0904, R0915, W0718
 import os
-# import traceback
+import os.path
+import traceback
 import json
 import jsonpickle
+from PySide6.QtCore import Signal, QObject
 from PySide6.QtWidgets import QMessageBox, QFileDialog, QDialog
-from .. core.core_utils import get_app_base_path
 from .. config.constants import constants
+from .. core.core_utils import get_app_base_path
 from .project_model import ActionConfig
-from .project_editor import ProjectEditor
 from .new_project import NewProjectDialog
 from .project_model import Project
+from .project_editor import ProjectEditor
 
 
-class ActionsWindow(ProjectEditor):
-    def __init__(self):
-        super().__init__()
-        self.update_title()
+class ProjectController(QObject):
+    update_title_requested = Signal()
+    refresh_ui_requested = Signal(int, int)
+    activate_window_requested = Signal()
+    enable_save_actions_requested = Signal(bool)
+
+    def __init__(self, parent):
+        super().__init__(parent)
+        self.parent = parent
+        self.project_editor = ProjectEditor(parent)
+
+    def refresh_ui(self, job_row=-1, action_row=-1):
+        self.refresh_ui_requested.emit(job_row, action_row)
+
+    def mark_as_modified(self, modified=True):
+        self.project_editor.mark_as_modified(modified)
+
+    def modified(self):
+        return self.project_editor.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 save_actions_set_enabled(self, enabled):
+        self.enable_save_actions_requested.emit(enabled)
+
+    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 on_job_selected(self, index):
+        return self.project_editor.on_job_selected(index)
 
     def update_title(self):
-        title = constants.APP_TITLE
-        file_name = self.current_file_name()
-        if file_name:
-            title += f" - {file_name}"
-            if self._modified_project:
-                title += " *"
-        self.window().setWindowTitle(title)
-
-    def mark_as_modified(self):
-        self._modified_project = True
-        self.project_buffer.append(self.project.clone())
-        self.save_actions_set_enabled(True)
-        self.update_title()
+        self.update_title_requested.emit()
 
     def close_project(self):
-        if self._check_unsaved_changes():
+        if self.check_unsaved_changes():
             self.set_project(Project())
             self.set_current_file_path('')
             self.update_title()
-            self.job_list.clear()
-            self.action_list.clear()
-            self._modified_project = False
-            self.save_actions_set_enabled(False)
+            self.clear_job_list()
+            self.clear_action_list()
+            self.mark_as_modified(False)
 
     def new_project(self):
-        if not self._check_unsaved_changes():
+        if not self.check_unsaved_changes():
             return
         os.chdir(get_app_base_path())
         self.set_current_file_path('')
-        self._modified_project = False
+        self.mark_as_modified(False)
         self.update_title()
-        self.job_list.clear()
-        self.action_list.clear()
+        self.clear_job_list()
+        self.clear_action_list()
         self.set_project(Project())
         self.save_actions_set_enabled(False)
-        dialog = NewProjectDialog(self)
+        dialog = NewProjectDialog(self.parent)
         if dialog.exec() == QDialog.Accepted:
             self.save_actions_set_enabled(True)
             input_folder = dialog.get_input_folder().split('/')
@@ -67,7 +160,7 @@ class ActionsWindow(ProjectEditor):
                 noise_detection = ActionConfig(constants.ACTION_NOISEDETECTION,
                                                {'name': 'detect-noise'})
                 job_noise.add_sub_action(noise_detection)
-                self.project.jobs.append(job_noise)
+                self.add_job_to_project(job_noise)
             job = ActionConfig(constants.ACTION_JOB,
                                {'name': 'focus-stack', 'working_path': working_path,
                                 'input_path': input_path})
@@ -116,16 +209,16 @@ class ActionsWindow(ProjectEditor):
                                            {'name': 'multi-layer',
                                             'input_path': ','.join(input_path)})
                 job.add_sub_action(multi_layer)
-            self.project.jobs.append(job)
-            self._modified_project = True
+            self.add_job_to_project(job)
+            self.mark_as_modified(True)
             self.refresh_ui(0, -1)
 
     def open_project(self, file_path=False):
-        if not self._check_unsaved_changes():
+        if not self.check_unsaved_changes():
             return
         if file_path is False:
             file_path, _ = QFileDialog.getOpenFileName(
-                self, "Open Project", "", "Project Files (*.fsp);;All Files (*)")
+                self.parent, "Open Project", "", "Project Files (*.fsp);;All Files (*)")
         if file_path:
             try:
                 self.set_current_file_path(file_path)
@@ -135,24 +228,24 @@ class ActionsWindow(ProjectEditor):
                 if project is None:
                     raise RuntimeError(f"Project from file {file_path} produced a null project.")
                 self.set_project(project)
-                self._modified_project = False
-                self.update_title()
+                self.mark_as_modified(False)
                 self.refresh_ui(0, -1)
-                if self.job_list.count() > 0:
-                    self.job_list.setCurrentRow(0)
+                if self.job_list_count() > 0:
+                    self.set_current_job(0)
             except Exception as e:
-                # traceback.print_tb(e.__traceback__)
-                QMessageBox.critical(self, "Error", f"Cannot open file {file_path}:\n{str(e)}")
-            if len(self.project.jobs) > 0:
-                self.job_list.setCurrentRow(0)
-                self.activateWindow()
+                traceback.print_tb(e.__traceback__)
+                QMessageBox.critical(
+                    self.parent, "Error", f"Cannot open file {file_path}:\n{str(e)}")
+            if self.num_project_jobs() > 0:
+                self.set_current_job(0)
+                self.activate_window_requested.emit()
                 self.save_actions_set_enabled(True)
-            for job in self.project.jobs:
+            for job in self.project_jobs():
                 if 'working_path' in job.params.keys():
                     working_path = job.params['working_path']
                     if not os.path.isdir(working_path):
                         QMessageBox.warning(
-                            self, "Working path not found",
+                            self.parent, "Working path not found",
                             f'''The working path specified in the project file for the job:
                                 "{job.params['name']}"
                                 was not found.\n
@@ -163,7 +256,7 @@ class ActionsWindow(ProjectEditor):
                         working_path = job.params['working_path']
                         if working_path != '' and not os.path.isdir(working_path):
                             QMessageBox.warning(
-                                self, "Working path not found",
+                                self.parent, "Working path not found",
                                 f'''The working path specified in the project file for the job:
                                 "{job.params['name']}"
                                 was not found.\n
@@ -179,32 +272,29 @@ class ActionsWindow(ProjectEditor):
 
     def save_project_as(self):
         file_path, _ = QFileDialog.getSaveFileName(
-            self, "Save Project As", "", "Project Files (*.fsp);;All Files (*)")
+            self.parent, "Save Project As", "", "Project Files (*.fsp);;All Files (*)")
         if file_path:
             if not file_path.endswith('.fsp'):
                 file_path += '.fsp'
             self.do_save(file_path)
             self.set_current_file_path(file_path)
-            self._modified_project = False
-            self.update_title()
             os.chdir(os.path.dirname(file_path))
 
     def do_save(self, file_path):
         try:
             json_obj = jsonpickle.encode({
-                'project': self.project.to_dict(),
-                'version': 1
+                'project': self.project().to_dict(), 'version': 1
             })
             with open(file_path, 'w', encoding="utf-8") as f:
                 f.write(json_obj)
-            self._modified_project = False
+            self.mark_as_modified(False)
         except Exception as e:
-            QMessageBox.critical(self, "Error", f"Cannot save file:\n{str(e)}")
+            QMessageBox.critical(self.parent, "Error", f"Cannot save file:\n{str(e)}")
 
-    def _check_unsaved_changes(self) -> bool:
-        if self._modified_project:
+    def check_unsaved_changes(self) -> bool:
+        if self.modified():
             reply = QMessageBox.question(
-                self, "Unsaved Changes",
+                self.parent, "Unsaved Changes",
                 "The project has unsaved changes. Do you want to continue?",
                 QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel
             )
@@ -215,21 +305,21 @@ class ActionsWindow(ProjectEditor):
         return True
 
     def on_job_edit(self, item):
-        index = self.job_list.row(item)
-        if 0 <= index < len(self.project.jobs):
-            job = self.project.jobs[index]
+        index = self.job_list().row(item)
+        if 0 <= index < self.num_project_jobs():
+            job = self.project_job(index)
             dialog = self.action_config_dialog(job)
             if dialog.exec() == QDialog.Accepted:
-                current_row = self.job_list.currentRow()
+                current_row = self.current_job_index()
                 if current_row >= 0:
-                    self.job_list.item(current_row).setText(job.params['name'])
+                    self.job_list_item(current_row).setText(job.params['name'])
                 self.refresh_ui()
 
     def on_action_edit(self, item):
-        job_index = self.job_list.currentRow()
-        if 0 <= job_index < len(self.project.jobs):
-            job = self.project.jobs[job_index]
-            action_index = self.action_list.row(item)
+        job_index = self.current_job_index()
+        if 0 <= job_index < self.num_project_jobs():
+            job = self.project_job(job_index)
+            action_index = self.action_list().row(item)
             current_action, is_sub_action = self.get_current_action_at(job, action_index)
             if current_action:
                 if not is_sub_action:
@@ -239,17 +329,17 @@ class ActionsWindow(ProjectEditor):
                 if dialog.exec() == QDialog.Accepted:
                     self.on_job_selected(job_index)
                     self.refresh_ui()
-                    self.job_list.setCurrentRow(job_index)
-                    self.action_list.setCurrentRow(action_index)
+                    self.set_current_job(job_index)
+                    self.set_current_action(action_index)
 
     def edit_current_action(self):
         current_action = None
-        job_row = self.job_list.currentRow()
-        if 0 <= job_row < len(self.project.jobs):
-            job = self.project.jobs[job_row]
-            if self.job_list.hasFocus():
+        job_row = self.current_job_index()
+        if 0 <= job_row < self.num_project_jobs():
+            job = self.project_job(job_row)
+            if self.job_list_has_focus():
                 current_action = job
-            elif self.action_list.hasFocus():
+            elif self.action_list_has_focus():
                 job_row, _action_row, pos = self.get_current_action()
                 if pos.actions is not None:
                     current_action = pos.action if not pos.is_sub_action else pos.sub_action
@@ -259,8 +349,5 @@ class ActionsWindow(ProjectEditor):
     def edit_action(self, action):
         dialog = self.action_config_dialog(action)
         if dialog.exec() == QDialog.Accepted:
-            self.on_job_selected(self.job_list.currentRow())
+            self.on_job_selected(self.current_job_index())
             self.mark_as_modified()
-
-    def save_actions_set_enabled(self, enabled):
-        pass

shinestacker/gui/project_converter.py

@@ -36,10 +36,10 @@ class ProjectConverter:
             logger.error(f"=== job: {job.name} failed: {msg} ===")
             return constants.RUN_FAILED, msg
 
-    def run_project(self, project: Project, logger_name=None, callbacks=None):
+    def run_project(self, proj: Project, logger_name=None, callbacks=None):
         logger = self.get_logger(logger_name)
         try:
-            jobs = self.project(project, logger_name, callbacks)
+            jobs = self.project(proj, logger_name, callbacks)
         except Exception as e:
             traceback.print_tb(e.__traceback__)
             return constants.RUN_FAILED, str(e)
@@ -60,12 +60,12 @@ class ProjectConverter:
         status = self.run(job, logger)
         return status
 
-    def project(self, project: Project, logger_name=None, callbacks=None):
+    def project(self, proj: Project, logger_name=None, callbacks=None):
         jobs = []
-        for j in project.jobs:
+        for j in proj.jobs:
             job = self.job(j, logger_name, callbacks)
             if job is None:
-                raise RuntimeError("Job instantiation failed.")
+                raise RuntimeError("Job creation failed.")
             jobs.append(job)
         return jobs
 
@@ -143,6 +143,6 @@ class ProjectConverter:
         except Exception as e:
             msg = str(e)
             logger = self.get_logger(logger_name)
-            logger.error(msg=f"=== can't instantiate job: {name}: {msg} ===")
+            logger.error(msg=f"=== can't create job: {name}: {msg} ===")
             traceback.print_tb(e.__traceback__)
             raise e