[*] refactor: video-editor

Author: heng30

wayshot/src/logic/video_editor/segment.rs

@@ -1,6 +1,8 @@
 use super::command::{sync_manager_to_ui, with_history_manager};
 use crate::{
-    logic::toast, logic_cb,
+    global_store,
+    logic::toast,
+    logic_cb,
     slint_generatedAppWindow::{
         AppWindow, SelectedSegmentIndex as UISelectedSegmentIndex,
         VideoEditorTrackSegment as UIVideoEditorTrackSegment,
@@ -10,28 +12,65 @@ use crate::{
 use slint::{ComponentHandle, Model, VecModel};
 use std::time::Duration;
 use video_editor::{
+    Error,
     commands::{
         batch::BatchCommand,
         segment::{
             MoveSegmentToTimeCommand, RemoveSegmentCommand, ShrinkSegmentLeftCommand,
-            ShrinkSegmentRightCommand, StretchSegmentLeftCommand, StretchSegmentRightCommand,
+            ShrinkSegmentRightCommand, SplitSegmentCommand, StretchSegmentLeftCommand,
+            StretchSegmentRightCommand,
         },
     },
     tracks::track::Track,
-    Error,
 };
 
 pub fn init(ui: &AppWindow) {
     logic_cb!(video_editor_add_selected_segment, ui, index);
-    logic_cb!(video_editor_stretch_segment_left, ui, index, diff_duration_ms);
-    logic_cb!(video_editor_shrink_segment_left, ui, index, diff_duration_ms);
-    logic_cb!(video_editor_stretch_segment_right, ui, index, diff_duration_ms);
-    logic_cb!(video_editor_shrink_segment_right, ui, index, diff_duration_ms);
-    logic_cb!(video_editor_move_segment_to_left_timeoffet, ui, index, diff_duration_ms);
-    logic_cb!(video_editor_move_segment_to_right_timeoffset, ui, index, diff_duration_ms);
-    logic_cb!(video_editor_is_selected_segment, ui, selected_segment, index);
+    logic_cb!(
+        video_editor_stretch_segment_left,
+        ui,
+        index,
+        diff_duration_ms
+    );
+    logic_cb!(
+        video_editor_shrink_segment_left,
+        ui,
+        index,
+        diff_duration_ms
+    );
+    logic_cb!(
+        video_editor_stretch_segment_right,
+        ui,
+        index,
+        diff_duration_ms
+    );
+    logic_cb!(
+        video_editor_shrink_segment_right,
+        ui,
+        index,
+        diff_duration_ms
+    );
+    logic_cb!(
+        video_editor_move_segment_to_left_timeoffet,
+        ui,
+        index,
+        diff_duration_ms
+    );
+    logic_cb!(
+        video_editor_move_segment_to_right_timeoffset,
+        ui,
+        index,
+        diff_duration_ms
+    );
+    logic_cb!(
+        video_editor_is_selected_segment,
+        ui,
+        selected_segment,
+        index
+    );
     logic_cb!(video_editor_selected_segment, ui);
     logic_cb!(video_editor_remove_segments, ui);
+    logic_cb!(video_editor_split_segment, ui);
 }
 
 fn video_editor_add_selected_segment(ui: &AppWindow, index: UISelectedSegmentIndex) {
@@ -46,7 +85,8 @@ fn video_editor_add_selected_segment(ui: &AppWindow, index: UISelectedSegmentInd
 
     if index.modifiers.control {
         if is_selected {
-            selected_indices.retain(|s| !(s.track_index == index.track_index && s.index == index.index));
+            selected_indices
+                .retain(|s| !(s.track_index == index.track_index && s.index == index.index));
         } else {
             selected_indices.push(index.clone());
         }
@@ -58,7 +98,10 @@ fn video_editor_add_selected_segment(ui: &AppWindow, index: UISelectedSegmentInd
                 let start = last.index.min(index.index);
                 let end = last.index.max(index.index);
                 for i in start..=end {
-                    if !selected_indices.iter().any(|s| s.track_index == index.track_index && s.index == i) {
+                    if !selected_indices
+                        .iter()
+                        .any(|s| s.track_index == index.track_index && s.index == i)
+                    {
                         selected_indices.push(UISelectedSegmentIndex {
                             track_index: index.track_index,
                             index: i,
@@ -149,14 +192,15 @@ fn video_editor_selected_segment(ui: &AppWindow) -> UIVideoEditorTrackSegment {
 
     if let Some((track_idx, seg_idx)) = selected_indices.first() {
         if let Some(segment_arc) = with_history_manager(|state| {
-            state.tracks_manager.get(*track_idx).and_then(|track| {
-                match track {
+            state
+                .tracks_manager
+                .get(*track_idx)
+                .and_then(|track| match track {
                     Track::Video(inner) => inner.track.segments.get(*seg_idx).cloned(),
                     Track::Audio(inner) => inner.track.segments.get(*seg_idx).cloned(),
                     Track::Subtitle(inner) => inner.track.segments.get(*seg_idx).cloned(),
                     Track::Overlay(inner) => inner.track.segments.get(*seg_idx).cloned(),
-                }
-            })
+                })
         }) {
             let ui_segment: UIVideoEditorTrackSegment = segment_arc.into();
             return ui_segment;
@@ -196,9 +240,7 @@ fn video_editor_remove_segments(ui: &AppWindow) {
         for (track_idx, mut seg_indices) in segments_per_track {
             seg_indices.sort_by(|a, b| b.cmp(a)); // Sort descending
             for seg_idx in seg_indices {
-                batch_command.add_command(Box::new(RemoveSegmentCommand::new(
-                    track_idx, seg_idx,
-                )));
+                batch_command.add_command(Box::new(RemoveSegmentCommand::new(track_idx, seg_idx)));
             }
         }
 
@@ -221,11 +263,68 @@ fn video_editor_remove_segments(ui: &AppWindow) {
                 });
             }
             Err(e) => {
-                toast::async_toast_warn(
-                    ui_weak,
-                    format!("Failed to remove segments: {}", e),
-                );
+                toast::async_toast_warn(ui_weak, format!("Failed to remove segments: {}", e));
+            }
+        }
+    });
+}
+
+fn video_editor_split_segment(ui: &AppWindow) {
+    let ui_weak = ui.as_weak();
+    let timeline_offset_ms = global_store!(ui).get_video_editor_timeline_offset();
+    let selected_segments = get_selected_segment_indices(&ui);
+
+    if selected_segments.len() != 1 {
+        crate::toast_warn!(ui, "Please select exactly one segment to split".to_string());
+        return;
+    }
+
+    tokio::spawn(async move {
+        let (track_index, segment_index) = selected_segments[0];
+
+        let result: Result<(), String> = with_history_manager(|state| {
+            if track_index >= state.tracks_manager.len() {
+                return Err(format!("Invalid track index: {}", track_index));
+            }
+
+            if let Some(track) = state.tracks_manager.get(track_index) {
+                let segments = match track {
+                    Track::Video(inner) => &inner.track.segments,
+                    Track::Audio(inner) => &inner.track.segments,
+                    Track::Subtitle(inner) => &inner.track.segments,
+                    Track::Overlay(inner) => &inner.track.segments,
+                };
+
+                if segment_index >= segments.len() {
+                    return Err(format!("Invalid segment index: {}", segment_index));
+                }
+
+                let seg = &segments[segment_index];
+
+                let segment_start = seg.timeline_offset.as_millis() as i32;
+                let split_position = timeline_offset_ms - segment_start;
+
+                if split_position <= 0 || split_position >= seg.duration.as_millis() as i32 {
+                    return Err("Timeline cursor must be within the segment".to_string());
+                }
+
+                let split_duration = Duration::from_millis(split_position as u64);
+                let command = SplitSegmentCommand::new(track_index, segment_index, split_duration);
+                state
+                    .history_manager
+                    .execute(&mut state.tracks_manager, Box::new(command))
+                    .map_err(|e| e.to_string())
+            } else {
+                Err("Track not found".to_string())
+            }
+        });
+
+        match result {
+            Ok(_) => {
+                sync_manager_to_ui(ui_weak.clone());
+                toast::async_toast_success(ui_weak, "Segment split successfully".to_string());
             }
+            Err(e) => toast::async_toast_warn(ui_weak, e.to_string()),
         }
     });
 }
@@ -246,7 +345,10 @@ fn modify_segment_duration(
 
         let result = with_history_manager(|state| {
             if track_idx >= state.tracks_manager.len() {
-                return Err(Error::IndexOutOfBounds(track_idx, state.tracks_manager.len()));
+                return Err(Error::IndexOutOfBounds(
+                    track_idx,
+                    state.tracks_manager.len(),
+                ));
             }
 
             let track = state
@@ -274,12 +376,8 @@ fn modify_segment_duration(
                         .history_manager
                         .execute(&mut state.tracks_manager, Box::new(command))
                 } else {
-                    let command = ShrinkSegmentLeftCommand::new(
-                        track_idx,
-                        seg_idx,
-                        duration,
-                        shift_timeline,
-                    );
+                    let command =
+                        ShrinkSegmentLeftCommand::new(track_idx, seg_idx, duration, shift_timeline);
                     state
                         .history_manager
                         .execute(&mut state.tracks_manager, Box::new(command))
@@ -335,7 +433,10 @@ fn move_segment(ui: &AppWindow, index: UISelectedSegmentIndex, diff_ms: i32) {
 
         let result = with_history_manager(|state| {
             if track_idx >= state.tracks_manager.len() {
-                return Err(Error::IndexOutOfBounds(track_idx, state.tracks_manager.len()));
+                return Err(Error::IndexOutOfBounds(
+                    track_idx,
+                    state.tracks_manager.len(),
+                ));
             }
 
             let track = state
@@ -358,8 +459,7 @@ fn move_segment(ui: &AppWindow, index: UISelectedSegmentIndex, diff_ms: i32) {
                 current_offset + duration
             };
 
-            let command =
-                MoveSegmentToTimeCommand::new(track_idx, seg_idx, new_offset, false);
+            let command = MoveSegmentToTimeCommand::new(track_idx, seg_idx, new_offset, false);
 
             state
                 .history_manager
@@ -389,4 +489,5 @@ fn get_selected_segment_indices(ui: &AppWindow) -> Vec<(usize, usize)> {
             }
         })
         .collect()
-}
+}
+

wayshot/src/logic/video_editor/track.rs

@@ -13,7 +13,6 @@ use video_editor::{
     Error,
     commands::{
         BatchCommand,
-        segment::SplitSegmentCommand,
         track::{
             AddTrackCommand, DetachAudioTracksCommand, DetachSubtitleTracksCommand,
             InsertTrackCommand, MoveTrackCommand, RemoveTrackCommand, ToggleTrackMutedCommand,
@@ -41,7 +40,6 @@ macro_rules! store_video_editor_selected_tracks_index {
 pub fn init(ui: &AppWindow) {
     logic_cb!(video_editor_add_track, ui, ty);
     logic_cb!(video_editor_remove_tracks, ui);
-    logic_cb!(video_editor_split_segment, ui);
     logic_cb!(video_editor_track_move_up, ui, index);
     logic_cb!(video_editor_track_move_down, ui, index);
     logic_cb!(video_editor_insert_video_track, ui, index);
@@ -136,66 +134,6 @@ fn video_editor_remove_tracks(ui: &AppWindow) {
     });
 }
 
-fn video_editor_split_segment(ui: &AppWindow) {
-    let ui_weak = ui.as_weak();
-    let timeline_offset_ms = global_store!(ui).get_video_editor_timeline_offset();
-    let selected_segments = get_selected_segment_indices(&ui);
-
-    if selected_segments.len() != 1 {
-        crate::toast_warn!(ui, "Please select exactly one segment to split".to_string());
-        return;
-    }
-
-    tokio::spawn(async move {
-        let (track_index, segment_index) = selected_segments[0];
-
-        let result: Result<(), String> = with_history_manager(|state| {
-            if track_index >= state.tracks_manager.len() {
-                return Err(format!("Invalid track index: {}", track_index));
-            }
-
-            if let Some(track) = state.tracks_manager.get(track_index) {
-                let segments = match track {
-                    Track::Video(inner) => &inner.track.segments,
-                    Track::Audio(inner) => &inner.track.segments,
-                    Track::Subtitle(inner) => &inner.track.segments,
-                    Track::Overlay(inner) => &inner.track.segments,
-                };
-
-                if segment_index >= segments.len() {
-                    return Err(format!("Invalid segment index: {}", segment_index));
-                }
-
-                let seg = &segments[segment_index];
-
-                let segment_start = seg.timeline_offset.as_millis() as i32;
-                let split_position = timeline_offset_ms - segment_start;
-
-                if split_position <= 0 || split_position >= seg.duration.as_millis() as i32 {
-                    return Err("Timeline cursor must be within the segment".to_string());
-                }
-
-                let split_duration = Duration::from_millis(split_position as u64);
-                let command = SplitSegmentCommand::new(track_index, segment_index, split_duration);
-                state
-                    .history_manager
-                    .execute(&mut state.tracks_manager, Box::new(command))
-                    .map_err(|e| e.to_string())
-            } else {
-                Err("Track not found".to_string())
-            }
-        });
-
-        match result {
-            Ok(_) => {
-                sync_manager_to_ui(ui_weak.clone());
-                toast::async_toast_success(ui_weak, "Segment split successfully".to_string());
-            }
-            Err(e) => toast::async_toast_warn(ui_weak, e.to_string()),
-        }
-    });
-}
-
 fn video_editor_track_move_up(ui: &AppWindow, index: i32) {
     if index <= 0 {
         return;

wayshot/ui/logic.slint

@@ -304,7 +304,6 @@ export global Logic {
 
     callback video-editor-remove-segments();
     callback video-editor-split-segment();
-
     callback video-editor-add-selected-segment(index: SelectedSegmentIndex);
     callback video-editor-update-segment-duration(index: SelectedSegmentIndex);
     callback video-editor-stretch-segment-left(index: SelectedSegmentIndex, diff-duration-ms: int);