Delete line action, plus undo implemented for various commands

GUI/Command.py

@@ -20,15 +20,16 @@ def __init__(self, datamodel : ProjectDataModel = None):
         QRunnable.__init__(self)
         QObject.__init__(self)
         self.datamodel = datamodel
+        self.can_undo : bool = True
         self.is_blocking : bool = True
         self.started : bool = False
         self.executed : bool = False
         self.aborted : bool = False
         self.terminal : bool = False
         self.callback = None
         self.undo_callback = None
-        self.model_update = ModelUpdate()
-        self.commands_to_queue : list = []
+        self.model_updates : list[ModelUpdate] = []
+        self.commands_to_queue : list[Command] = []
 
     def SetDataModel(self, datamodel):
         self.datamodel = datamodel
@@ -44,6 +45,14 @@ def Abort(self):
             self.aborted = True
             self.on_abort()
 
+    def AddModelUpdate(self) -> ModelUpdate:
+        update = ModelUpdate()
+        self.model_updates.append(update)
+        return update
+
+    def ClearModelUpdates(self):
+        self.model_updates = []
+
     @Slot()
     def run(self):
         if self.aborted:
@@ -98,3 +107,6 @@ def __init__(self, command : Command, *args: object) -> None:
         super().__init__(*args)
         self.command = command
 
+class UndoError(CommandError):
+    pass
+

GUI/CommandQueue.py

@@ -1,6 +1,6 @@
 import logging
 
-from PySide6.QtCore import QObject, Signal, QThreadPool, QRecursiveMutex, QMutexLocker
+from PySide6.QtCore import Qt, QObject, Signal, QThreadPool, QRecursiveMutex, QMutexLocker
 
 from GUI.Command import Command
 from GUI.ProjectDataModel import ProjectDataModel
@@ -25,18 +25,21 @@ class CommandQueue(QObject):
     """
     commandAdded = Signal(object)
     commandExecuted = Signal(object, bool)
-
+    commandUndone = Signal(object)
+
     def __init__(self, parent):
         super().__init__(parent)
 
         self.logger = logging.getLogger("CommandQueue")
 
-        self.queue = []
-        self.undo_stack = []
+        self.queue : list[Command] = []
+        self.undo_stack : list[Command] = []
+        self.redo_stack : list[Command] = []
 
         self.mutex = QRecursiveMutex()
 
         self.command_pool = QThreadPool(self)
+
         self.SetMaxThreadCount(1)
 
     def SetMaxThreadCount(self, count):
@@ -46,16 +49,43 @@ def SetMaxThreadCount(self, count):
         self.command_pool.setMaxThreadCount(count)
 
     @property
-    def queue_size(self):
+    def queue_size(self) -> int:
+        """
+        Number of commands in the queue
+        """
         with QMutexLocker(self.mutex):
             return len(self.queue)
 
+    @property
+    def has_commands(self) -> bool:
+        """
+        Check if the queue has any commands
+        """
+        with QMutexLocker(self.mutex):
+            return len(self.queue) > 0
+
+    @property
+    def has_blocking_commands(self) -> bool:
+        with QMutexLocker(self.mutex):
+            return any( command.is_blocking for command in self.queue )
+
+    @property
+    def can_undo(self) -> bool:
+        with QMutexLocker(self.mutex):
+            return len(self.undo_stack) > 0 and self.undo_stack[-1].can_undo
+
+    @property
+    def can_redo(self) -> bool:
+        with QMutexLocker(self.mutex):
+            return len(self.redo_stack) > 0
+
     def Stop(self):
         """
         Shut the background thread down
         """
         if self.queue_size > 0:
             self._clear_command_queue()
+
         self.command_pool.waitForDone()
 
     def AddCommand(self, command: Command, datamodel: ProjectDataModel = None, callback=None, undo_callback=None):
@@ -67,18 +97,53 @@ def AddCommand(self, command: Command, datamodel: ProjectDataModel = None, callb
 
         self.logger.debug(f"Adding a {type(command).__name__} command to the queue")
         command.setParent(self)
+        command.setAutoDelete(False)
 
         with QMutexLocker(self.mutex):
             if isinstance(command, ClearCommandQueue):
                 command.execute()
                 self._clear_command_queue()
             else:
                 self._queue_command(command, datamodel, callback, undo_callback)
+                self._clear_redo_stack()
 
         self.commandAdded.emit(command)
 
         self._start_command_queue()
 
+    def UndoLastCommand(self):
+        """
+        Undo the last command in the undo stack
+        """
+        with QMutexLocker(self.mutex):
+            command = self.undo_stack.pop()
+            if not command.can_undo:
+                self.logger.error(f"Cannot undo the last {type(command).__name__} command")
+                return
+
+            self.redo_stack.append(command)
+
+        self.logger.info(f"Undoing {type(command).__name__}")
+        command.undo()
+
+        self.commandUndone.emit(command)
+
+    def RedoLastCommand(self):
+        """
+        Redo the last command in the redo stack
+        """
+        with QMutexLocker(self.mutex):
+            command = self.redo_stack.pop()
+            if not command:
+                self.logger.warning("No commands to redo")
+                return
+
+            self._queue_command(command)
+
+        self.logger.info(f"Redoing {type(command).__name__}")
+        self.commandAdded.emit(command)
+        self._start_command_queue()
+
     def Contains(self, command_type: type = None, type_list : list[type] = None):
         """
         Check if the queue contains a command type(s)
@@ -89,32 +154,39 @@ def Contains(self, command_type: type = None, type_list : list[type] = None):
         if type_list:
             if any( self.Contains(type) for type in type_list ):
                 return True
-
-        return command_type and any( [ isinstance(command, command_type) ] for command in self.queue )
-
-    def AnyCommands(self):
-        """
-        Any commands in the queue?
-        """
-        return True if self.queue else False
-
-    def AnyBlocking(self):
+
+        with QMutexLocker(self.mutex):
+            return command_type and any( [ isinstance(command, command_type) ] for command in self.queue )
+
+    def ClearUndoStack(self):
         """
-        Any blocking commands in the queue?
+        Clear the undo stack
         """
-        return any( command.is_blocking for command in self.queue )
+        with QMutexLocker(self.mutex):
+            for command in self.undo_stack:
+                command.deleteLater()
+            for command in self.redo_stack:
+                command.deleteLater()
+
+            self.undo_stack = []
+            self.redo_stack = []
 
     def _on_command_executed(self, command: Command, success: bool):
         """
         Handle command callbacks, and queuing further actions
         """
         if not command.aborted:
             self.logger.debug(f"A {type(command).__name__} command was completed")
-
+
+        command.commandExecuted.disconnect(self._on_command_executed)
+
         with QMutexLocker(self.mutex):
             self.undo_stack.append(command)
             self.queue.remove(command)
 
+        if not command.can_undo:
+            self.ClearUndoStack()
+
         self.commandExecuted.emit(command, success)
 
         can_proceed = not command.aborted and not command.terminal
@@ -128,7 +200,7 @@ def _on_command_executed(self, command: Command, success: bool):
 
         if not command.aborted:
             self._start_command_queue()
-            
+
     def _queue_command(self, command: Command, datamodel: ProjectDataModel = None, callback=None, undo_callback=None):
         """
         Add a command to the worker thread queue
@@ -142,9 +214,13 @@ def _queue_command(self, command: Command, datamodel: ProjectDataModel = None, c
         if undo_callback:
             command.SetUndoCallback(undo_callback)
 
-        command.commandExecuted.connect(self._on_command_executed)
+        command.started = False
+        command.commandExecuted.connect(self._on_command_executed, Qt.ConnectionType.QueuedConnection)
 
     def _start_command_queue(self):
+        """
+        Start the command queue
+        """
         if not self.queue:
             return
 
@@ -160,12 +236,31 @@ def _start_command_queue(self):
                     break
 
     def _clear_command_queue(self):
+        """
+        Abort any running commands and clear the command queue
+        """
         self.logger.debug(f"Clearing command queue")
 
-        # Remove commands that haven't been started
-        self.queue = [command for command in self.queue if command.started]
+        with QMutexLocker(self.mutex):
+            # Remove commands that haven't been started
+            self.queue = [command for command in self.queue if command.started]
+
+        # Pop the remaining commands from the queue and abort
+        while True:
+            with QMutexLocker(self.mutex):
+                if not self.queue:
+                    break
+
+                command = self.queue.pop(0)
 
-        # Request termination of remaining commands
-        for command in self.queue:
             command.Abort()
 
+    def _clear_redo_stack(self):
+        """
+        Remove commands from the redo stack and delete them
+        """
+        with QMutexLocker(self.mutex):
+            for command in self.redo_stack:
+                command.deleteLater()
+
+            self.redo_stack = []

GUI/Commands/AutoSplitBatchCommand.py

@@ -11,6 +11,7 @@ def __init__(self, scene_number : int, batch_number : int, datamodel: ProjectDat
         super().__init__(datamodel)
         self.scene_number = scene_number
         self.batch_number = batch_number
+        self.split_line = None
 
     def execute(self):
         logging.info(f"Auto-splitting batch {str(self.scene_number)} batch {str(self.batch_number)}")
@@ -38,13 +39,40 @@ def execute(self):
         validator.ValidateBatch(new_batch)
 
         # Remove lines from the original batch that are in the new batch now
+        model_update = self.AddModelUpdate()
         for line_removed in range(new_batch.first_line_number, new_batch.last_line_number + 1):
-            self.model_update.lines.remove((self.scene_number, self.batch_number, line_removed))
+            model_update.lines.remove((self.scene_number, self.batch_number, line_removed))
 
         for batch_number in range(self.batch_number + 1, len(scene.batches)):
-             self.model_update.batches.update((self.scene_number, batch_number), { 'number' : batch_number + 1})
+             model_update.batches.update((self.scene_number, batch_number), { 'number' : batch_number + 1})
 
-        self.model_update.batches.update((self.scene_number, self.batch_number), { 'errors' : split_batch.errors })
-        self.model_update.batches.add((self.scene_number, new_batch_number), scene.GetBatch(new_batch_number))
+        model_update.batches.update((self.scene_number, self.batch_number), { 'errors' : split_batch.errors })
+        model_update.batches.add((self.scene_number, new_batch_number), scene.GetBatch(new_batch_number))
+
+        self.split_line = new_batch.first_line_number
+        return True
+
+    def undo(self):
+        project: SubtitleProject = self.datamodel.project
+
+        scene = project.subtitles.GetScene(self.scene_number)
+
+        if not scene or not scene.GetBatch(self.batch_number):
+            raise CommandError(f"Cannot find scene {self.scene_number} batch {self.batch_number}", command=self)
+
+        scene.MergeBatches([self.batch_number, self.batch_number + 1])
+
+        merged_batch = scene.GetBatch(self.batch_number)
+
+        model_update = self.AddModelUpdate()
+        model_update.batches.remove((self.scene_number, self.batch_number + 1))
+        model_update.batches.update((self.scene_number, self.batch_number), { 'errors' : merged_batch.errors })
+
+        model_update = self.AddModelUpdate()
+        for line_number in range(self.split_line, merged_batch.last_line_number + 1):
+            key = (self.scene_number, self.batch_number, line_number)
+            line = merged_batch.GetOriginalLine(line_number)
+            line.translated = merged_batch.GetTranslatedLine(line_number)
+            model_update.lines.add(key, line)
 
         return True

GUI/Commands/BatchSubtitlesCommand.py

@@ -18,6 +18,7 @@ def __init__(self, project : SubtitleProject, options : Options):
         self.project : SubtitleProject = project
         self.options : Options = options
         self.preprocess_subtitles = options.get('preprocess_subtitles', False)
+        self.can_undo = False
 
     def execute(self):
         logging.info("Executing BatchSubtitlesCommand")
@@ -42,12 +43,10 @@ def execute(self):
         batcher : SubtitleBatcher = SubtitleBatcher(self.options)
         project.subtitles.AutoBatch(batcher)
 
-        project.WriteProjectFile()
+        if project.write_project:
+            project.WriteProjectFile()
 
         self.datamodel : ProjectDataModel = ProjectDataModel(project, self.options)
         self.datamodel.CreateViewModel()
         return True
 
-    def undo(self):
-        # Do we flatten, or do we cache the previous batches?
-        pass