[*] refactor: video-editor

Author: heng30

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

@@ -1,6 +1,9 @@
 use super::command::Command;
-use crate::{Error, Result, tracks::manager::Manager, tracks::track::Track};
-use std::sync::Arc;
+use crate::{
+    Error, Result,
+    tracks::{manager::Manager, track::Track},
+};
+use std::{sync::Arc, time::Duration};
 
 pub struct AddTrackCommand {
     track: Track,
@@ -257,3 +260,263 @@ impl Command for SetTrackVisibilityCommand {
         format!("{} track {}", action, self.track_index)
     }
 }
+
+pub struct TrimGapCommand {
+    track_index: usize,
+    segment_index: usize,
+    start_gap: Option<Duration>,
+    end_gap: Option<Duration>,
+}
+
+impl TrimGapCommand {
+    pub fn new(track_index: usize, segment_index: usize) -> Self {
+        Self {
+            track_index,
+            segment_index,
+            start_gap: None,
+            end_gap: None,
+        }
+    }
+}
+
+impl Command for TrimGapCommand {
+    fn execute(&mut self, manager: &mut Manager) -> Result<()> {
+        let manager_len = manager.len();
+        let track = manager
+            .get(self.track_index)
+            .ok_or_else(|| Error::IndexOutOfBounds(self.track_index, manager_len))?;
+
+        let segments = track.segments();
+
+        if self.segment_index == 0 {
+            self.start_gap = segments.first().map(|s| s.timeline_offset);
+        } else {
+            let prev_segment = &segments[self.segment_index - 1];
+            let target_segment = &segments[self.segment_index];
+            let prev_end = prev_segment.timeline_offset + prev_segment.duration;
+            self.start_gap = Some(target_segment.timeline_offset.saturating_sub(prev_end));
+        }
+
+        if self.segment_index == segments.len() - 1 {
+            let target_segment = &segments[self.segment_index];
+            let segment_end = target_segment.timeline_offset + target_segment.duration;
+            self.end_gap = Some(track.duration().saturating_sub(segment_end));
+        } else {
+            let target_segment = &segments[self.segment_index];
+            let next_segment = &segments[self.segment_index + 1];
+            let segment_end = target_segment.timeline_offset + target_segment.duration;
+            self.end_gap = Some(next_segment.timeline_offset.saturating_sub(segment_end));
+        }
+
+        let track = manager
+            .get_mut(self.track_index)
+            .ok_or_else(|| Error::IndexOutOfBounds(self.track_index, manager_len))?;
+
+        track.trim_gap(self.segment_index)
+    }
+
+    fn undo(&mut self, manager: &mut Manager) -> Result<()> {
+        let start_gap = self.start_gap.unwrap_or(Duration::ZERO);
+        let end_gap = self.end_gap.unwrap_or(Duration::ZERO);
+
+        if start_gap.is_zero() && end_gap.is_zero() {
+            return Ok(());
+        }
+
+        let manager_len = manager.len();
+        let track = manager
+            .get_mut(self.track_index)
+            .ok_or_else(|| Error::IndexOutOfBounds(self.track_index, manager_len))?;
+
+        let segments_count = track.segments_count();
+
+        if start_gap > Duration::ZERO {
+            let start_index = if self.segment_index == 0 {
+                0
+            } else {
+                self.segment_index
+            };
+
+            for i in start_index..segments_count {
+                track.shift_segment_timeline(i, start_gap)?;
+            }
+        }
+
+        if end_gap > Duration::ZERO {
+            let end_index = if self.segment_index == segments_count - 1 {
+                self.segment_index + 1
+            } else {
+                self.segment_index + 2
+            };
+
+            if end_index <= segments_count {
+                for i in end_index..segments_count {
+                    track.shift_segment_timeline(i, end_gap)?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn describe(&self) -> String {
+        format!(
+            "Trim gap from segment {} in track {}",
+            self.segment_index, self.track_index
+        )
+    }
+}
+
+pub struct TrimStartGapCommand {
+    track_index: usize,
+    segment_index: usize,
+    removed_gap: Option<Duration>,
+}
+
+impl TrimStartGapCommand {
+    pub fn new(track_index: usize, segment_index: usize) -> Self {
+        Self {
+            track_index,
+            segment_index,
+            removed_gap: None,
+        }
+    }
+}
+
+impl Command for TrimStartGapCommand {
+    fn execute(&mut self, manager: &mut Manager) -> Result<()> {
+        let manager_len = manager.len();
+        let track = manager
+            .get(self.track_index)
+            .ok_or_else(|| Error::IndexOutOfBounds(self.track_index, manager_len))?;
+
+        let segments = track.segments();
+        if self.segment_index == 0 {
+            self.removed_gap = segments.first().map(|s| s.timeline_offset);
+        } else {
+            let prev_segment = &segments[self.segment_index - 1];
+            let target_segment = &segments[self.segment_index];
+            let prev_end = prev_segment.timeline_offset + prev_segment.duration;
+            self.removed_gap = Some(target_segment.timeline_offset.saturating_sub(prev_end));
+        }
+
+        let track = manager
+            .get_mut(self.track_index)
+            .ok_or_else(|| Error::IndexOutOfBounds(self.track_index, manager_len))?;
+        track.trim_start_gap(self.segment_index)
+    }
+
+    fn undo(&mut self, manager: &mut Manager) -> Result<()> {
+        let removed_gap = self
+            .removed_gap
+            .ok_or_else(|| Error::InvalidConfig("Command not yet executed".into()))?;
+
+        if removed_gap.is_zero() {
+            return Ok(());
+        }
+
+        let manager_len = manager.len();
+        let track = manager
+            .get_mut(self.track_index)
+            .ok_or_else(|| Error::IndexOutOfBounds(self.track_index, manager_len))?;
+
+        let start_index = if self.segment_index == 0 {
+            0
+        } else {
+            self.segment_index
+        };
+        for i in start_index..track.segments_count() {
+            track.shift_segment_timeline(i, removed_gap)?;
+        }
+
+        Ok(())
+    }
+
+    fn describe(&self) -> String {
+        format!(
+            "Trim start gap from segment {} in track {}",
+            self.segment_index, self.track_index
+        )
+    }
+}
+
+pub struct TrimEndGapCommand {
+    track_index: usize,
+    segment_index: usize,
+    removed_gap: Option<Duration>,
+}
+
+impl TrimEndGapCommand {
+    pub fn new(track_index: usize, segment_index: usize) -> Self {
+        Self {
+            track_index,
+            segment_index,
+            removed_gap: None,
+        }
+    }
+}
+
+impl Command for TrimEndGapCommand {
+    fn execute(&mut self, manager: &mut Manager) -> Result<()> {
+        let manager_len = manager.len();
+        let track = manager
+            .get(self.track_index)
+            .ok_or_else(|| Error::IndexOutOfBounds(self.track_index, manager_len))?;
+
+        let segments = track.segments();
+        if self.segment_index == segments.len() - 1 {
+            let target_segment = &segments[self.segment_index];
+            let segment_end = target_segment.timeline_offset + target_segment.duration;
+            self.removed_gap = Some(track.duration().saturating_sub(segment_end));
+        } else {
+            let target_segment = &segments[self.segment_index];
+            let next_segment = &segments[self.segment_index + 1];
+            let segment_end = target_segment.timeline_offset + target_segment.duration;
+            self.removed_gap = Some(next_segment.timeline_offset.saturating_sub(segment_end));
+        }
+
+        let track = manager
+            .get_mut(self.track_index)
+            .ok_or_else(|| Error::IndexOutOfBounds(self.track_index, manager_len))?;
+
+        track.trim_end_gap(self.segment_index)
+    }
+
+    fn undo(&mut self, manager: &mut Manager) -> Result<()> {
+        let removed_gap = self
+            .removed_gap
+            .ok_or_else(|| Error::InvalidConfig("Command not yet executed".into()))?;
+
+        if removed_gap.is_zero() {
+            return Ok(());
+        }
+
+        let manager_len = manager.len();
+        let track = manager
+            .get_mut(self.track_index)
+            .ok_or_else(|| Error::IndexOutOfBounds(self.track_index, manager_len))?;
+
+        let segments = track.segments();
+
+        let end_index = if self.segment_index == segments.len() - 1 {
+            self.segment_index + 1
+        } else {
+            self.segment_index + 2
+        };
+
+        if end_index <= track.segments_count() {
+            for i in end_index..track.segments_count() {
+                track.shift_segment_timeline(i, removed_gap)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn describe(&self) -> String {
+        format!(
+            "Trim end gap from segment {} in track {}",
+            self.segment_index, self.track_index
+        )
+    }
+}

lib/video-editor/src/tracks/track.rs

@@ -479,6 +479,90 @@ impl Track {
         }
     }
 
+    pub fn trim_gap(&mut self, segment_index: usize) -> Result<()> {
+        self.trim_start_gap(segment_index)?;
+        self.trim_end_gap(segment_index)
+    }
+
+    pub fn trim_start_gap(&mut self, segment_index: usize) -> Result<()> {
+        if segment_index >= self.segments_count() {
+            return Err(Error::IndexOutOfBounds(
+                segment_index,
+                self.segments_count(),
+            ));
+        }
+
+        if segment_index == 0 {
+            let segments = self.segments();
+            let first_segment = &segments[0];
+            let gap_to_remove = first_segment.timeline_offset;
+
+            if gap_to_remove.is_zero() {
+                return Ok(());
+            }
+
+            for i in 0..self.segments_count() {
+                self.shift_segment_timeline_backward(i, gap_to_remove)?;
+            }
+        } else {
+            // Remove gap between segment_index-1 and segment_index
+            let segments = self.segments();
+            let prev_segment = &segments[segment_index - 1];
+            let target_segment = &segments[segment_index];
+
+            let prev_end = prev_segment.timeline_offset + prev_segment.duration;
+            let gap = target_segment.timeline_offset.saturating_sub(prev_end);
+
+            if gap.is_zero() {
+                return Ok(());
+            }
+
+            for i in segment_index..self.segments_count() {
+                self.shift_segment_timeline_backward(i, gap)?;
+            }
+        }
+
+        Self::update_track_duration(self);
+        Ok(())
+    }
+
+    pub fn trim_end_gap(&mut self, segment_index: usize) -> Result<()> {
+        if segment_index >= self.segments_count() {
+            return Err(Error::IndexOutOfBounds(
+                segment_index,
+                self.segments_count(),
+            ));
+        }
+
+        let segments = self.segments();
+        let target_segment = &segments[segment_index];
+
+        if segment_index == self.segments_count() - 1 {
+            let segment_end = target_segment.timeline_offset + target_segment.duration;
+            let current_duration = self.duration();
+
+            if segment_end >= current_duration {
+                return Ok(());
+            }
+        } else {
+            // Remove gap between segment_index and segment_index+1
+            let next_segment = &segments[segment_index + 1];
+            let segment_end = target_segment.timeline_offset + target_segment.duration;
+            let gap = next_segment.timeline_offset.saturating_sub(segment_end);
+
+            if gap.is_zero() {
+                return Ok(());
+            }
+
+            for i in (segment_index + 1)..self.segments_count() {
+                self.shift_segment_timeline_backward(i, gap)?;
+            }
+        }
+
+        Self::update_track_duration(self);
+        Ok(())
+    }
+
     pub fn remove_all_gaps(&mut self) -> Result<()> {
         let segments = self.segments().to_vec();