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

shinestacker/gui/project_editor.py

@@ -1,22 +1,19 @@
-# pylint: disable=C0114, C0115, C0116, R0904, R1702, R0917, R0913, R0902, E0611, E1131
+# pylint: disable=C0114, C0115, C0116, R0904, R1702, R0917, R0913, R0902, E0611, E1131, E1121
 import os
 from dataclasses import dataclass
-from PySide6.QtWidgets import (QMainWindow, QListWidget, QMessageBox,
+from PySide6.QtWidgets import (QListWidget, QMessageBox,
                                QDialog, QListWidgetItem, QLabel)
-from PySide6.QtCore import Qt
+from PySide6.QtCore import Qt, QObject, Signal
 from .. config.constants import constants
 from .colors import ColorPalette
-from .action_config import ActionConfig, ActionConfigDialog
-from .project_model import get_action_input_path, get_action_output_path
-
-INDENT_SPACE = "   ↪   "
-CLONE_POSTFIX = " (clone)"
+from .action_config_dialog import ActionConfigDialog
+from .project_model import ActionConfig, get_action_input_path, get_action_output_path
 
 
 @dataclass
 class ActionPosition:
     actions: list
-    sub_actions: list | None
+    sub_actions: list
     action_index: int
     sub_action_index: int = -1
 
@@ -77,20 +74,81 @@ def new_row_after_clone(job, action_row, is_sub_action, cloned):
             for action in job.sub_actions[:job.sub_actions.index(cloned)])
 
 
-class ProjectEditor(QMainWindow):
+class ProjectUndoManager:
     def __init__(self):
-        super().__init__()
+        self._undo_buffer = []
+
+    def add(self, item):
+        self._undo_buffer.append(item)
+
+    def pop(self):
+        return self._undo_buffer.pop()
+
+    def filled(self):
+        return len(self._undo_buffer) != 0
+
+
+class ProjectEditor(QObject):
+    INDENT_SPACE = "   ↪   "
+    CLONE_POSTFIX = " (clone)"
+
+    modified_signal = Signal(int)
+    select_signal = Signal()
+    refresh_ui_signal = Signal(int, int)
+    enable_delete_action_signal = Signal(bool)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._undo_manager = ProjectUndoManager()
+        self._modified = False
+        self._project = None
         self._copy_buffer = None
-        self.project_buffer = []
-        self.job_list = QListWidget()
-        self.action_list = QListWidget()
-        self.project = None
-        self.job_list_model = None
-        self.expert_options = False
-        self.script_dir = os.path.dirname(__file__)
-        self.dialog = None
         self._current_file_path = ''
-        self._modified_project = False
+        self._job_list = QListWidget()
+        self._action_list = QListWidget()
+        self.dialog = None
+
+    def add_undo(self, item):
+        self._undo_manager.add(item)
+
+    def pop_undo(self):
+        return self._undo_manager.pop()
+
+    def filled_undo(self):
+        return self._undo_manager.filled()
+
+    def mark_as_modified(self, modified=True):
+        self._modified = modified
+        if modified:
+            self.add_undo(self._project.clone())
+        self.modified_signal.emit(modified)
+
+    def modified(self):
+        return self._modified
+
+    def set_project(self, project):
+        self._project = project
+
+    def project(self):
+        return self._project
+
+    def project_jobs(self):
+        return self._project.jobs
+
+    def add_job_to_project(self, job):
+        self._project.jobs.append(job)
+
+    def num_project_jobs(self):
+        return len(self.project().jobs)
+
+    def copy_buffer(self):
+        return self._copy_buffer
+
+    def set_copy_buffer(self, item):
+        self._copy_buffer = item
+
+    def has_copy_buffer(self):
+        return self._copy_buffer is not None
 
     def current_file_path(self):
         return self._current_file_path
@@ -111,8 +169,59 @@ class ProjectEditor(QMainWindow):
         self._current_file_path = os.path.abspath(path)
         os.chdir(self.current_file_directory())
 
-    def set_project(self, project):
-        self.project = project
+    def project_job(self, index):
+        return self._project.jobs[index]
+
+    def job_list(self):
+        return self._job_list
+
+    def action_list(self):
+        return self._action_list
+
+    def current_job_index(self):
+        return self._job_list.currentRow()
+
+    def current_action_index(self):
+        return self._action_list.currentRow()
+
+    def set_current_job(self, index):
+        self._job_list.setCurrentRow(index)
+
+    def set_current_action(self, index):
+        self._action_list.setCurrentRow(index)
+
+    def job_list_count(self):
+        return self._job_list.count()
+
+    def action_list_count(self):
+        return self._action_list.count()
+
+    def job_list_item(self, index):
+        return self._job_list.item(index)
+
+    def action_list_item(self, index):
+        return self._action_list.item(index)
+
+    def job_list_has_focus(self):
+        return self._job_list.hasFocus()
+
+    def action_list_has_focus(self):
+        return self._action_list.hasFocus()
+
+    def take_job(self, index):
+        return self._job_list.takeItem(index)
+
+    def clear_job_list(self):
+        self._job_list.clear()
+
+    def clear_action_list(self):
+        self._action_list.clear()
+
+    def num_selected_jobs(self):
+        return len(self._job_list.selectedItems())
+
+    def num_selected_actions(self):
+        return len(self._action_list.selectedItems())
 
     def job_text(self, job, long_name=False, html=False):
         txt = f"{job.params.get('name', '(job)')}"
@@ -135,7 +244,7 @@ class ProjectEditor(QMainWindow):
         }
         ico = icon_map.get(action.type_name, '')
         if is_sub_action and indent:
-            txt = INDENT_SPACE
+            txt = self.INDENT_SPACE
             if ico == '':
                 ico = '🟣'
         else:
@@ -152,22 +261,22 @@ class ProjectEditor(QMainWindow):
                 if long_name and not is_sub_action else "]")
 
     def get_job_at(self, index):
-        return None if index < 0 else self.project.jobs[index]
+        return None if index < 0 else self.project_job(index)
 
     def get_current_job(self):
-        return self.get_job_at(self.job_list.currentRow())
+        return self.get_job_at(self.current_job_index())
 
     def get_current_action(self):
-        return self.get_action_at(self.action_list.currentRow())
+        return self.get_action_at(self.current_action_index())
 
     def get_action_at(self, action_row):
-        job_row = self.job_list.currentRow()
+        job_row = self.current_job_index()
         if job_row < 0 or action_row < 0:
             return (job_row, action_row, None)
         action, sub_action, sub_action_index = self.find_action_position(job_row, action_row)
         if not action:
             return (job_row, action_row, None)
-        job = self.project.jobs[job_row]
+        job = self.project_job(job_row)
         if sub_action:
             return (job_row, action_row,
                     ActionPosition(job.sub_actions, action.sub_actions,
@@ -176,9 +285,9 @@ class ProjectEditor(QMainWindow):
                 ActionPosition(job.sub_actions, None, job.sub_actions.index(action)))
 
     def find_action_position(self, job_index, ui_index):
-        if not 0 <= job_index < len(self.project.jobs):
+        if not 0 <= job_index < self.num_project_jobs():
             return (None, None, -1)
-        actions = self.project.jobs[job_index].sub_actions
+        actions = self.project_job(job_index).sub_actions
         counter = -1
         for action in actions:
             counter += 1
@@ -190,19 +299,16 @@ class ProjectEditor(QMainWindow):
                     return (action, sub_action, sub_action_index)
         return (None, None, -1)
 
-    def refresh_ui(self, job_row=-1, action_row=-1):
-        pass
-
     def shift_job(self, delta):
-        job_index = self.job_list.currentRow()
+        job_index = self.current_job_index()
         if job_index < 0:
             return
         new_index = job_index + delta
-        if 0 <= new_index < len(self.project.jobs):
-            jobs = self.project.jobs
+        if 0 <= new_index < self.num_project_jobs():
+            jobs = self.project_jobs()
             self.mark_as_modified()
             jobs.insert(new_index, jobs.pop(job_index))
-            self.refresh_ui(new_index, -1)
+            self.refresh_ui_signal.emit(new_index, -1)
 
     def shift_action(self, delta):
         job_row, action_row, pos = self.get_current_action()
@@ -218,70 +324,70 @@ class ProjectEditor(QMainWindow):
                     self.mark_as_modified()
                     pos.sub_actions.insert(new_index, pos.sub_actions.pop(pos.sub_action_index))
             new_row = new_row_after_insert(action_row, pos, delta)
-            self.refresh_ui(job_row, new_row)
+            self.refresh_ui_signal.emit(job_row, new_row)
 
     def move_element_up(self):
-        if self.job_list.hasFocus():
+        if self.job_list_has_focus():
             self.shift_job(-1)
-        elif self.action_list.hasFocus():
+        elif self.action_list_has_focus():
             self.shift_action(-1)
 
     def move_element_down(self):
-        if self.job_list.hasFocus():
+        if self.job_list_has_focus():
             self.shift_job(+1)
-        elif self.action_list.hasFocus():
+        elif self.action_list_has_focus():
             self.shift_action(+1)
 
     def clone_job(self):
-        job_index = self.job_list.currentRow()
-        if 0 <= job_index < len(self.project.jobs):
-            job_clone = self.project.jobs[job_index].clone(CLONE_POSTFIX)
+        job_index = self.current_job_index()
+        if 0 <= job_index < self.num_project_jobs():
+            job_clone = self.project_job(job_index).clone(self.CLONE_POSTFIX)
             new_job_index = job_index + 1
             self.mark_as_modified()
-            self.project.jobs.insert(new_job_index, job_clone)
-            self.job_list.setCurrentRow(new_job_index)
-            self.action_list.setCurrentRow(new_job_index)
-            self.refresh_ui(new_job_index, -1)
+            self.project_jobs().insert(new_job_index, job_clone)
+            self.set_current_job(new_job_index)
+            self.set_current_action(new_job_index)
+            self.refresh_ui_signal.emit(new_job_index, -1)
 
     def clone_action(self):
         job_row, action_row, pos = self.get_current_action()
         if not pos.actions:
             return
         self.mark_as_modified()
-        job = self.project.jobs[job_row]
+        job = self.project_job(job_row)
         if pos.is_sub_action:
-            cloned = pos.sub_action.clone(CLONE_POSTFIX)
+            cloned = pos.sub_action.clone(self.CLONE_POSTFIX)
             pos.sub_actions.insert(pos.sub_action_index + 1, cloned)
         else:
-            cloned = pos.action.clone(CLONE_POSTFIX)
+            cloned = pos.action.clone(self.CLONE_POSTFIX)
             job.sub_actions.insert(pos.action_index + 1, cloned)
         new_row = new_row_after_clone(job, action_row, pos.is_sub_action, cloned)
-        self.refresh_ui(job_row, new_row)
+        self.refresh_ui_signal.emit(job_row, new_row)
 
     def clone_element(self):
-        if self.job_list.hasFocus():
+        if self.job_list_has_focus():
             self.clone_job()
-        elif self.action_list.hasFocus():
+        elif self.action_list_has_focus():
             self.clone_action()
 
     def delete_job(self, confirm=True):
-        current_index = self.job_list.currentRow()
-        if 0 <= current_index < len(self.project.jobs):
+        current_index = self.current_job_index()
+        if 0 <= current_index < self.num_project_jobs():
             if confirm:
                 reply = QMessageBox.question(
-                    self, "Confirm Delete",
+                    self.parent(), "Confirm Delete",
                     "Are you sure you want to delete job "
-                    f"'{self.project.jobs[current_index].params.get('name', '')}'?",
+                    f"'{self.project_job(current_index).params.get('name', '')}'?",
                     QMessageBox.Yes | QMessageBox.No
                 )
             else:
                 reply = None
             if not confirm or reply == QMessageBox.Yes:
-                self.job_list.takeItem(current_index)
+                self.take_job(current_index)
                 self.mark_as_modified()
-                current_job = self.project.jobs.pop(current_index)
-                self.action_list.clear()
-                self.refresh_ui()
+                current_job = self.project_jobs().pop(current_index)
+                self.clear_action_list()
+                self.refresh_ui_signal.emit(-1, -1)
                 return current_job
         return None
 
@@ -291,7 +397,7 @@ class ProjectEditor(QMainWindow):
             current_action = pos.action if not pos.is_sub_action else pos.sub_action
             if confirm:
                 reply = QMessageBox.question(
-                    self,
+                    self.parent(),
                     "Confirm Delete",
                     "Are you sure you want to delete action "
                     f"'{self.action_text(current_action, pos.is_sub_action, indent=False)}'?",
@@ -304,55 +410,53 @@ class ProjectEditor(QMainWindow):
                 if pos.is_sub_action:
                     pos.action.pop_sub_action(pos.sub_action_index)
                 else:
-                    self.project.jobs[job_row].pop_sub_action(pos.action_index)
+                    self.project_job(job_row).pop_sub_action(pos.action_index)
                 new_row = new_row_after_delete(action_row, pos)
-                self.refresh_ui(job_row, new_row)
+                self.refresh_ui_signal.emit(job_row, new_row)
             return current_action
         return None
 
     def delete_element(self, confirm=True):
-        if self.job_list.hasFocus():
+        if self.job_list_has_focus():
             element = self.delete_job(confirm)
-        elif self.action_list.hasFocus():
+        elif self.action_list_has_focus():
             element = self.delete_action(confirm)
         else:
             element = None
-        if self.job_list.count() > 0:
-            self.delete_element_action.setEnabled(True)
         return element
 
     def action_config_dialog(self, action):
-        return ActionConfigDialog(action, self.current_file_directory(), self)
+        return ActionConfigDialog(action, self.current_file_directory(), self.parent())
 
     def add_job(self):
         job_action = ActionConfig("Job")
         self.dialog = self.action_config_dialog(job_action)
         if self.dialog.exec() == QDialog.Accepted:
             self.mark_as_modified()
-            self.project.jobs.append(job_action)
-            self.add_list_item(self.job_list, job_action, False)
-            self.job_list.setCurrentRow(self.job_list.count() - 1)
-            self.job_list.item(self.job_list.count() - 1).setSelected(True)
-            self.refresh_ui()
-
-    def add_action(self, type_name=False):
-        current_index = self.job_list.currentRow()
+            self.project_jobs().append(job_action)
+            self.add_list_item(self.job_list(), job_action, False)
+            self.set_current_job(self.job_list_count() - 1)
+            self.job_list_item(self.job_list_count() - 1).setSelected(True)
+            self.refresh_ui_signal.emit(-1, -1)
+
+    def add_action(self, type_name):
+        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.")
+            if self.num_project_jobs() > 0:
+                QMessageBox.warning(self.parent(),
+                                    "No Job Selected", "Please select a job first.")
             else:
-                QMessageBox.warning(self, "No Job Added", "Please add a job first.")
+                QMessageBox.warning(self.parent(),
+                                    "No Job Added", "Please add a job first.")
             return
-        if type_name is False:
-            type_name = self.action_selector.currentText()
         action = ActionConfig(type_name)
         action.parent = self.get_current_job()
         self.dialog = self.action_config_dialog(action)
         if self.dialog.exec() == QDialog.Accepted:
             self.mark_as_modified()
-            self.project.jobs[current_index].add_sub_action(action)
-            self.add_list_item(self.action_list, action, False)
-            self.delete_element_action.setEnabled(False)
+            self.project_job(current_index).add_sub_action(action)
+            self.add_list_item(self.action_list(), action, False)
+            self.enable_delete_action_signal.emit(False)
 
     def add_list_item(self, widget_list, action, is_sub_action):
         if action.type_name == constants.ACTION_JOB:
@@ -369,13 +473,13 @@ class ProjectEditor(QMainWindow):
         label = QLabel(html_text)
         widget_list.setItemWidget(item, label)
 
-    def add_sub_action(self, type_name=False):
-        current_job_index = self.job_list.currentRow()
-        current_action_index = self.action_list.currentRow()
+    def add_sub_action(self, type_name):
+        current_job_index = self.current_job_index()
+        current_action_index = self.current_action_index()
         if current_job_index < 0 or current_action_index < 0 or \
-           current_job_index >= len(self.project.jobs):
+           current_job_index >= self.num_project_jobs():
             return
-        job = self.project.jobs[current_job_index]
+        job = self.project_job(current_job_index)
         action = None
         action_counter = -1
         for act in job.sub_actions:
@@ -386,96 +490,93 @@ class ProjectEditor(QMainWindow):
             action_counter += len(act.sub_actions)
         if not action or action.type_name != constants.ACTION_COMBO:
             return
-        if type_name is False:
-            type_name = self.sub_action_selector.currentText()
         sub_action = ActionConfig(type_name)
         self.dialog = self.action_config_dialog(sub_action)
         if self.dialog.exec() == QDialog.Accepted:
             self.mark_as_modified()
             action.add_sub_action(sub_action)
             self.on_job_selected(current_job_index)
-            self.action_list.setCurrentRow(current_action_index)
+            self.set_current_action(current_action_index)
 
     def copy_job(self):
-        current_index = self.job_list.currentRow()
-        if 0 <= current_index < len(self.project.jobs):
-            self._copy_buffer = self.project.jobs[current_index].clone()
+        current_index = self.current_job_index()
+        if 0 <= current_index < self.num_project_jobs():
+            self.set_copy_buffer(self.project_job(current_index).clone())
 
     def copy_action(self):
         _job_row, _action_row, pos = self.get_current_action()
         if pos.actions is not None:
-            self._copy_buffer = pos.sub_action.clone() if pos.is_sub_action else pos.action.clone()
+            self.set_copy_buffer(pos.sub_action.clone()
+                                 if pos.is_sub_action else pos.action.clone())
 
     def copy_element(self):
-        if self.job_list.hasFocus():
+        if self.job_list_has_focus():
             self.copy_job()
-        elif self.action_list.hasFocus():
+        elif self.action_list_has_focus():
             self.copy_action()
 
     def paste_job(self):
-        if self._copy_buffer.type_name != constants.ACTION_JOB:
+        if self.copy_buffer().type_name != constants.ACTION_JOB:
             return
-        job_index = self.job_list.currentRow()
-        if 0 <= job_index < len(self.project.jobs):
+        job_index = self.current_job_index()
+        if 0 <= job_index < self.num_project_jobs():
             new_job_index = job_index
             self.mark_as_modified()
-            self.project.jobs.insert(new_job_index, self._copy_buffer)
-            self.job_list.setCurrentRow(new_job_index)
-            self.action_list.setCurrentRow(new_job_index)
-            self.refresh_ui(new_job_index, -1)
+            self.project_jobs().insert(new_job_index, self.copy_buffer())
+            self.set_current_job(new_job_index)
+            self.set_current_action(new_job_index)
+            self.refresh_ui_signal.emit(new_job_index, -1)
 
     def paste_action(self):
         job_row, action_row, pos = self.get_current_action()
         if pos.actions is not None:
             if not pos.is_sub_action:
-                if self._copy_buffer.type_name not in constants.ACTION_TYPES:
+                if self.copy_buffer().type_name not in constants.ACTION_TYPES:
                     return
                 self.mark_as_modified()
-                pos.actions.insert(pos.action_index, self._copy_buffer)
+                pos.actions.insert(pos.action_index, self.copy_buffer())
             else:
                 if pos.action.type_name != constants.ACTION_COMBO or \
-                   self._copy_buffer.type_name not in constants.SUB_ACTION_TYPES:
+                   self.copy_buffer().type_name not in constants.SUB_ACTION_TYPES:
                     return
                 self.mark_as_modified()
-                pos.sub_actions.insert(pos.sub_action_index, self._copy_buffer)
+                pos.sub_actions.insert(pos.sub_action_index, self.copy_buffer())
             new_row = new_row_after_paste(action_row, pos)
-            self.refresh_ui(job_row, new_row)
+            self.refresh_ui_signal.emit(job_row, new_row)
 
     def paste_element(self):
-        if self._copy_buffer is None:
-            return
-        if self.job_list.hasFocus():
-            self.paste_job()
-        elif self.action_list.hasFocus():
-            self.paste_action()
+        if self.has_copy_buffer():
+            if self.job_list_has_focus():
+                self.paste_job()
+            elif self.action_list_has_focus():
+                self.paste_action()
 
     def cut_element(self):
-        self._copy_buffer = self.delete_element(False)
+        self.set_copy_buffer(self.delete_element(False))
 
     def undo(self):
-        job_row = self.job_list.currentRow()
-        action_row = self.action_list.currentRow()
-        if len(self.project_buffer) > 0:
-            self.set_project(self.project_buffer.pop())
-            self.refresh_ui()
-            len_jobs = len(self.project.jobs)
+        job_row = self.current_job_index()
+        action_row = self.current_action_index()
+        if self.filled_undo():
+            self.set_project(self.pop_undo())
+            self.refresh_ui_signal.emit(-1, -1)
+            len_jobs = self.num_project_jobs()
             if len_jobs > 0:
-                if job_row >= len_jobs:
-                    job_row = len_jobs - 1
-                self.job_list.setCurrentRow(job_row)
-                len_actions = self.action_list.count()
+                job_row = min(job_row, len_jobs - 1)
+                self.set_current_job(job_row)
+                len_actions = self.action_list_count()
                 if len_actions > 0:
                     action_row = min(action_row, len_actions)
-                    self.action_list.setCurrentRow(action_row)
+                    self.set_current_action(action_row)
 
     def set_enabled(self, enabled):
         current_action = None
-        if self.job_list.hasFocus():
-            job_row = self.job_list.currentRow()
-            if 0 <= job_row < len(self.project.jobs):
-                current_action = self.project.jobs[job_row]
+        if self.job_list_has_focus():
+            job_row = self.current_job_index()
+            if 0 <= job_row < self.num_project_jobs():
+                current_action = self.project_job(job_row)
             action_row = -1
-        elif self.action_list.hasFocus():
+        elif self.action_list_has_focus():
             job_row, action_row, pos = self.get_current_action()
             current_action = pos.sub_action if pos.is_sub_action else pos.action
         else:
@@ -484,7 +585,7 @@ class ProjectEditor(QMainWindow):
             if current_action.enabled() != enabled:
                 self.mark_as_modified()
                 current_action.set_enabled(enabled)
-                self.refresh_ui(job_row, action_row)
+                self.refresh_ui_signal.emit(job_row, action_row)
 
     def enable(self):
         self.set_enabled(True)
@@ -494,11 +595,11 @@ class ProjectEditor(QMainWindow):
 
     def set_enabled_all(self, enable=True):
         self.mark_as_modified()
-        job_row = self.job_list.currentRow()
-        action_row = self.action_list.currentRow()
-        for j in self.project.jobs:
+        job_row = self.current_job_index()
+        action_row = self.current_action_index()
+        for j in self.project_jobs():
             j.set_enabled_all(enable)
-        self.refresh_ui(job_row, action_row)
+        self.refresh_ui_signal.emit(job_row, action_row)
 
     def enable_all(self):
         self.set_enabled_all(True)
@@ -507,15 +608,15 @@ class ProjectEditor(QMainWindow):
         self.set_enabled_all(False)
 
     def on_job_selected(self, index):
-        self.action_list.clear()
-        if 0 <= index < len(self.project.jobs):
-            job = self.project.jobs[index]
+        self.clear_action_list()
+        if 0 <= index < self.num_project_jobs():
+            job = self.project_job(index)
             for action in job.sub_actions:
-                self.add_list_item(self.action_list, action, False)
+                self.add_list_item(self.action_list(), action, False)
                 if len(action.sub_actions) > 0:
                     for sub_action in action.sub_actions:
-                        self.add_list_item(self.action_list, sub_action, True)
-            self.update_delete_action_state()
+                        self.add_list_item(self.action_list(), sub_action, True)
+            self.select_signal.emit()
 
     def get_current_action_at(self, job, action_index):
         action_counter = -1
@@ -537,21 +638,3 @@ class ProjectEditor(QMainWindow):
                     break
 
         return current_action, is_sub_action
-
-    def update_delete_action_state(self):
-        has_job_selected = len(self.job_list.selectedItems()) > 0
-        has_action_selected = len(self.action_list.selectedItems()) > 0
-        self.delete_element_action.setEnabled(has_job_selected or has_action_selected)
-        if has_action_selected and has_job_selected:
-            job_index = self.job_list.currentRow()
-            if job_index >= len(self.project.jobs):
-                job_index = len(self.project.jobs) - 1
-            action_index = self.action_list.currentRow()
-            if job_index >= 0:
-                job = self.project.jobs[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.set_enabled_sub_actions_gui(enable_sub_actions)
-        else:
-            self.set_enabled_sub_actions_gui(False)