[*] refactor: video editor

Author: heng30

Cargo.lock

@@ -104,9 +104,8 @@ fn main() -> Result<()> {
     // 撤销添加轨道
     println!("\n操作: 撤销 2 次");
     for _i in 0..2 {
-        if let Some(desc) = history.undo(&mut manager)? {
-            println!("  ↻ 撤销: {}", desc);
-        }
+        let result = history.undo(&mut manager)?;
+        println!("  ↻ 撤销: {}", result.description);
     }
 
     println!("\n当前状态:");
@@ -115,9 +114,8 @@ fn main() -> Result<()> {
 
     // 重做
     println!("\n操作: 重做 1 次");
-    if let Some(desc) = history.redo(&mut manager)? {
-        println!("  ↻ 重做: {}", desc);
-    }
+    let result = history.redo(&mut manager)?;
+    println!("  ↻ 重做: {}", result.description);
 
     println!("\n当前状态:");
     println!("  轨道数: {}", manager.len());
@@ -164,19 +162,17 @@ fn main() -> Result<()> {
 
     // 撤销和重做
     println!("\n操作: 撤销移除");
-    if let Some(desc) = history.undo(&mut manager)? {
-        println!("  ↻ 撤销: {}", desc);
-    }
+    let result = history.undo(&mut manager)?;
+    println!("  ↻ 撤销: {}", result.description);
 
     println!("\n当前状态:");
     if let Some(Track::Video(track)) = manager.get(0) {
         println!("  轨道 0 片段数: {}", track.track.segments.len());
     }
 
     println!("\n操作: 重做");
-    if let Some(desc) = history.redo(&mut manager)? {
-        println!("  ↻ 重做: {}", desc);
-    }
+    let result = history.redo(&mut manager)?;
+    println!("  ↻ 重做: {}", result.description);
 
     println!("\n当前状态:");
     if let Some(Track::Video(track)) = manager.get(0) {
@@ -236,9 +232,8 @@ fn main() -> Result<()> {
 
     // 撤销
     println!("\n操作: 撤销隐藏");
-    if let Some(desc) = history.undo(&mut manager)? {
-        println!("  ↻ 撤销: {}", desc);
-    }
+    let result = history.undo(&mut manager)?;
+    println!("  ↻ 撤销: {}", result.description);
 
     println!("\n当前轨道状态:");
     if let Some(track) = manager.get(0) {

lib/video-editor/examples/undo_redo_demo.rs

@@ -8,10 +8,10 @@ pub mod subtitle;
 pub mod track;
 
 pub use batch::BatchCommand;
-pub use command::Command;
+pub use command::{AffectedSegment, AffectedSegments, Command};
 pub use export::*;
 pub use filter::*;
-pub use history::HistoryManager;
+pub use history::{ExecuteResult, HistoryManager, UndoRedoResult};
 pub use segment::*;
 pub use subtitle::*;
 pub use track::*;

lib/video-editor/src/commands.rs

@@ -1,4 +1,4 @@
-use super::command::Command;
+use super::command::{AffectedSegments, Command};
 use crate::{Result, tracks::manager::Manager};
 
 // 批量命令 - 将多个命令组合成一个原子操作
@@ -64,4 +64,20 @@ impl Command for BatchCommand {
     fn can_undo(&self) -> bool {
         self.commands.iter().all(|c| c.can_undo())
     }
+
+    fn affected_segments_after_execute(&self) -> AffectedSegments {
+        let mut result = AffectedSegments::new();
+        for command in &self.commands {
+            result.merge(command.affected_segments_after_execute());
+        }
+        result
+    }
+
+    fn affected_segments_after_undo(&self) -> AffectedSegments {
+        let mut result = AffectedSegments::new();
+        for command in &self.commands {
+            result.merge(command.affected_segments_after_undo());
+        }
+        result
+    }
 }

lib/video-editor/src/commands/batch.rs

@@ -1,5 +1,118 @@
 use crate::{Result, tracks::manager::Manager};
 
+#[derive(Clone, Debug, Default, derive_setters::Setters)]
+#[setters(prefix = "with_")]
+pub struct AffectedSegment {
+    pub track_index: usize,
+    pub segment_index: usize,
+    // (left_thumbnail, right_thumbnail) - which thumbnails need refresh
+    pub update_thumbnail: (bool, bool),
+    // Whether audio sample preview needs refresh
+    pub update_audio_sample: bool,
+}
+
+impl AffectedSegment {
+    pub fn new(track_index: usize, segment_index: usize) -> Self {
+        Self {
+            track_index,
+            segment_index,
+            update_thumbnail: (false, false),
+            update_audio_sample: false,
+        }
+    }
+
+    pub fn with_left_thumbnail(track_index: usize, segment_index: usize) -> Self {
+        Self {
+            track_index,
+            segment_index,
+            update_thumbnail: (true, false),
+            update_audio_sample: true,
+        }
+    }
+
+    pub fn with_right_thumbnail(track_index: usize, segment_index: usize) -> Self {
+        Self {
+            track_index,
+            segment_index,
+            update_thumbnail: (false, true),
+            update_audio_sample: true,
+        }
+    }
+
+    pub fn with_both_thumbnails(track_index: usize, segment_index: usize) -> Self {
+        Self {
+            track_index,
+            segment_index,
+            update_thumbnail: (true, true),
+            update_audio_sample: true,
+        }
+    }
+
+    pub fn with_audio_only(track_index: usize, segment_index: usize) -> Self {
+        Self {
+            track_index,
+            segment_index,
+            update_thumbnail: (false, false),
+            update_audio_sample: true,
+        }
+    }
+
+    pub fn should_update(&self) -> bool {
+        !matches!(self.update_thumbnail, (false, false)) || self.update_audio_sample
+    }
+}
+
+// Information about segments that need preview refresh after a command
+#[derive(Clone, Debug, Default)]
+pub struct AffectedSegments {
+    pub segments: Vec<AffectedSegment>,
+}
+
+impl AffectedSegments {
+    pub fn new() -> Self {
+        Self { segments: vec![] }
+    }
+
+    pub fn add(&mut self, track_index: usize, segment_index: usize) {
+        self.segments
+            .push(AffectedSegment::new(track_index, segment_index));
+    }
+
+    pub fn add_left_thumbnail(&mut self, track_index: usize, segment_index: usize) {
+        self.segments.push(AffectedSegment::with_left_thumbnail(
+            track_index,
+            segment_index,
+        ));
+    }
+
+    pub fn add_right_thumbnail(&mut self, track_index: usize, segment_index: usize) {
+        self.segments.push(AffectedSegment::with_right_thumbnail(
+            track_index,
+            segment_index,
+        ));
+    }
+
+    pub fn add_both_thumbnails(&mut self, track_index: usize, segment_index: usize) {
+        self.segments.push(AffectedSegment::with_both_thumbnails(
+            track_index,
+            segment_index,
+        ));
+    }
+
+    pub fn add_audio_only(&mut self, track_index: usize, segment_index: usize) {
+        self.segments
+            .push(AffectedSegment::with_audio_only(track_index, segment_index));
+    }
+
+    pub fn merge(&mut self, other: AffectedSegments) {
+        self.segments.extend(other.segments);
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.segments.is_empty()
+    }
+}
+
 pub trait Command: Send + Sync {
     fn describe(&self) -> String;
     fn execute(&mut self, manager: &mut Manager) -> Result<()>;
@@ -8,12 +121,23 @@ pub trait Command: Send + Sync {
         true
     }
 
-    /// Optional: Merge with another command (for optimization)
-    ///
-    /// If this command can be merged with another (e.g., multiple small
-    /// adjustments of the same property), return true and modify self.
-    /// By default, commands don't merge.
+    // Optional: Merge with another command (for optimization)
+    //
+    // If this command can be merged with another (e.g., multiple small
+    // adjustments of the same property), return true and modify self.
+    // By default, commands don't merge.
     fn merge(&mut self, _other: Box<dyn Command>) -> Result<bool> {
         Ok(false)
     }
+
+    // Returns segments that need preview refresh after execute()
+    // Used by UI layer to reload thumbnails/audio previews after undo/redo
+    fn affected_segments_after_execute(&self) -> AffectedSegments {
+        AffectedSegments::default()
+    }
+
+    // Returns segments that need preview refresh after undo()
+    fn affected_segments_after_undo(&self) -> AffectedSegments {
+        AffectedSegments::default()
+    }
 }

lib/video-editor/src/commands/command.rs

@@ -1,4 +1,7 @@
-use super::{batch::BatchCommand, command::Command};
+use super::{
+    batch::BatchCommand,
+    command::{AffectedSegments, Command},
+};
 use crate::{Error, Result, tracks::manager::Manager};
 
 #[derive(derivative::Derivative)]
@@ -14,6 +17,15 @@ pub struct HistoryManager {
     current_batch: Option<BatchCommand>,
 }
 
+pub struct UndoRedoResult {
+    pub description: String,
+    pub affected_segments: AffectedSegments,
+}
+
+pub struct ExecuteResult {
+    pub affected_segments: AffectedSegments,
+}
+
 impl HistoryManager {
     pub fn new() -> Self {
         Self::default()
@@ -29,47 +41,60 @@ impl HistoryManager {
     // Execute a command and add it to history
     // If the command executes successfully, it's added to the undo stack
     // and the redo stack is cleared (since a new command invalidates redo history).
-    pub fn execute(&mut self, manager: &mut Manager, mut command: Box<dyn Command>) -> Result<()> {
+    pub fn execute(
+        &mut self,
+        manager: &mut Manager,
+        mut command: Box<dyn Command>,
+    ) -> Result<ExecuteResult> {
         command.execute(manager)?;
+        let affected_segments = command.affected_segments_after_execute();
         self.redo_stack.clear();
 
         if let Some(ref mut batch) = self.current_batch {
             batch.add_command(command);
-            return Ok(());
+            return Ok(ExecuteResult { affected_segments });
         }
 
         if self.max_history_size > 0 && self.undo_stack.len() >= self.max_history_size {
             self.undo_stack.remove(0);
         }
 
         self.undo_stack.push(command);
-        Ok(())
+        Ok(ExecuteResult { affected_segments })
     }
 
-    pub fn undo(&mut self, manager: &mut Manager) -> Result<Option<String>> {
+    pub fn undo(&mut self, manager: &mut Manager) -> Result<UndoRedoResult> {
         let mut command = self
             .undo_stack
             .pop()
             .ok_or_else(|| Error::CannotUndo("No commands to undo".into()))?;
 
         let description = command.describe();
         command.undo(manager)?;
+        let affected_segments = command.affected_segments_after_undo();
         self.redo_stack.push(command);
 
-        Ok(Some(description))
+        Ok(UndoRedoResult {
+            description,
+            affected_segments,
+        })
     }
 
-    pub fn redo(&mut self, manager: &mut Manager) -> Result<Option<String>> {
+    pub fn redo(&mut self, manager: &mut Manager) -> Result<UndoRedoResult> {
         let mut command = self
             .redo_stack
             .pop()
             .ok_or_else(|| Error::CannotRedo("No commands to redo".into()))?;
 
         let description = command.describe();
         command.execute(manager)?;
+        let affected_segments = command.affected_segments_after_execute();
         self.undo_stack.push(command);
 
-        Ok(Some(description))
+        Ok(UndoRedoResult {
+            description,
+            affected_segments,
+        })
     }
 
     /// Start a batch operation (multiple commands treated as one)