[*] refactor

Author: heng30

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

@@ -2,8 +2,8 @@ use super::command::Command;
 use crate::{
     Error, Result,
     filters::traits::{
-        AudioFilter, AudioFilterWrapper, ImageFilterWrapper, SubtitleFilter,
-        SubtitleFilterWrapper, VideoFilter, VideoFilterWrapper,
+        AudioFilter, AudioFilterWrapper, ImageFilterWrapper, SubtitleFilter, SubtitleFilterWrapper,
+        VideoFilter, VideoFilterWrapper,
     },
     tracks::manager::Manager,
 };
@@ -78,11 +78,7 @@ impl AddFilterCommand {
         }
     }
 
-    pub fn new_image(
-        track_index: usize,
-        segment_index: usize,
-        filter: ImageFilterWrapper,
-    ) -> Self {
+    pub fn new_image(track_index: usize, segment_index: usize, filter: ImageFilterWrapper) -> Self {
         Self {
             track_index,
             segment_index,

todo.md

@@ -1,4 +1,5 @@
 ## 问题
+- 轨道中粘贴filter到所有segment，没有更新右边的滤镜列表
 
 ## 待验证
 - 视频轨道分离字幕

wayshot/src/logic/popup_action.rs

@@ -303,6 +303,16 @@ pub fn init(ui: &AppWindow) {
                     let index = user_data.parse::<i32>().unwrap();
                     global_ve_filter!(ui).invoke_copy_filter(index);
                 }
+                "video-editor-cut-filter" => {
+                    let index = user_data.parse::<i32>().unwrap();
+                    global_ve_filter!(ui).invoke_cut_filter(index);
+                }
+                "video-editor-paste-filter" => {
+                    global_ve_filter!(ui).invoke_paste_filter();
+                }
+                "video-editor-refresh-filter-list" => {
+                    global_ve_filter!(ui).invoke_refresh_filter_list();
+                }
                 _ => log::warn!("Unknown popup action: {action}"),
             }
         });

wayshot/src/logic/video_editor/filters/filter.rs

@@ -10,7 +10,7 @@ use crate::{
             },
             conversion::{
                 audio_filter_to_json_detail, image_filter_to_json_detail,
-                subtitle_filter_to_json_detail, video_filter_to_json_detail,
+                subtitle_filter_to_json_detail, track_to_filter_type, video_filter_to_json_detail,
             },
             project::{MARKED_FILTERS_ID, PRESET_FILTERS_ID},
             segment::refresh_affected_segments,
@@ -130,13 +130,16 @@ pub fn init(ui: &AppWindow) {
     ve_filter_cb!(remove_filter, ui, index);
     ve_filter_cb!(toggle_filter, ui, index);
     ve_filter_cb!(copy_filter, ui, index);
+    ve_filter_cb!(cut_filter, ui, index);
+    ve_filter_cb!(paste_filter, ui);
     ve_filter_cb!(add_filter, ui, filter_name);
     ve_filter_cb!(create_preset_filter, ui, name);
     ve_filter_cb!(add_preset_filter, ui, filter);
     ve_filter_cb!(remove_preset_filter, ui, index, filter_type);
     ve_filter_cb!(add_cache_preset_filter, ui, filter);
     ve_filter_cb!(remove_cache_preset_filter, ui, filter);
     ve_filter_cb!(toggle_mark_filter, ui, filter);
+    ve_filter_cb!(refresh_filter_list, ui);
 }
 
 fn inner_init(ui: &AppWindow) {
@@ -533,6 +536,198 @@ pub fn copy_filter(ui: &AppWindow, index: i32) {
     }
 }
 
+pub fn cut_filter(ui: &AppWindow, index: i32) {
+    let merged_index = index as usize;
+    let selected_segments = get_selected_segment_indices(ui);
+    let Some((track_idx, seg_idx)) = selected_segments.last() else {
+        return;
+    };
+
+    let Some((filter_type, filter_index)) =
+        get_filter_type_and_local_index(*track_idx, *seg_idx, merged_index)
+    else {
+        return;
+    };
+
+    let filter_data: Option<(bool, String, String)> = with_history_manager(|state| {
+        let track = state.tracks_manager.get(*track_idx)?;
+        let segment = track.get_segment(*seg_idx).ok()?;
+
+        match filter_type {
+            FilterType::Video => segment.video_filters.get(filter_index).map(|f| {
+                let detail = video_filter_to_json_detail(&f.inner);
+                (f.enabled(), f.inner.name().to_string(), detail)
+            }),
+            FilterType::Audio => segment.audio_filters.get(filter_index).map(|f| {
+                let detail = audio_filter_to_json_detail(&f.inner);
+                (f.enabled(), f.inner.name().to_string(), detail)
+            }),
+            FilterType::Subtitle => segment.subtitle_filters.get(filter_index).map(|f| {
+                let detail = subtitle_filter_to_json_detail(&f.inner);
+                (f.enabled(), f.inner.name().to_string(), detail)
+            }),
+            FilterType::Image => segment.image_filters.get(filter_index).map(|f| {
+                let detail = image_filter_to_json_detail(&f.inner);
+                (f.enabled(), f.inner.name().to_string(), detail)
+            }),
+        }
+    });
+
+    let filter_name = match filter_data {
+        Some((enabled, name, detail)) => {
+            let segment_filter = UISegmentFilter {
+                ty: filter_type.into(),
+                enabled,
+                name: SharedString::from(name.clone()),
+                detail: SharedString::from(detail),
+            };
+            global_ve_filter!(ui).set_cache_copied_filter(segment_filter);
+            name
+        }
+        None => return,
+    };
+
+    let mut batch_command = BatchCommand::new(format!("Cut filter '{}'", filter_name));
+
+    for (track_idx, seg_idx) in &selected_segments {
+        let Some((ft, fi)) = get_filter_type_and_local_index(*track_idx, *seg_idx, merged_index)
+        else {
+            continue;
+        };
+
+        if ft != filter_type {
+            continue;
+        }
+
+        let command = match ft {
+            FilterType::Video => Box::new(RemoveFilterCommand::new_video(*track_idx, *seg_idx, fi)),
+            FilterType::Audio => Box::new(RemoveFilterCommand::new_audio(*track_idx, *seg_idx, fi)),
+            FilterType::Subtitle => {
+                Box::new(RemoveFilterCommand::new_subtitle(*track_idx, *seg_idx, fi))
+            }
+            FilterType::Image => Box::new(RemoveFilterCommand::new_image(*track_idx, *seg_idx, fi)),
+        };
+        batch_command.add_command(command);
+    }
+
+    let result = with_history_manager(|state| {
+        state
+            .history_manager
+            .execute(&mut state.tracks_manager, Box::new(batch_command))
+    });
+
+    match result {
+        Ok(execute_result) => {
+            sync_manager_to_ui(ui);
+            refresh_affected_segments(ui, execute_result.affected_segments);
+            refresh_preview(ui);
+
+            global_ve_filter!(ui).set_selected_filter_index(-1);
+            global_store!(ui).set_video_editor_segment_filter_flag(
+                !global_store!(ui).get_video_editor_segment_filter_flag(),
+            );
+            crate::toast_success!(ui, format!("Cut filter: {}", filter_name));
+        }
+        Err(e) => crate::toast_warn!(ui, format!("Failed to cut filter: {}", e)),
+    }
+}
+
+pub fn paste_filter(ui: &AppWindow) {
+    let cached_filter = global_ve_filter!(ui).get_cache_copied_filter();
+    let filter_name = cached_filter.name.to_string();
+
+    if filter_name.is_empty() {
+        crate::toast_warn!(ui, "No filter copied to paste");
+        return;
+    }
+
+    let selected_segments = get_selected_segment_indices(ui);
+    let Some((track_idx, _seg_idx)) = selected_segments.last() else {
+        return;
+    };
+
+    let track_type: Option<FilterType> = with_history_manager(|state| {
+        let track = state.tracks_manager.get(*track_idx)?;
+        Some(track_to_filter_type(&track))
+    });
+
+    let Some(track_type) = track_type else {
+        return;
+    };
+
+    let copied_type: FilterType = cached_filter.ty.into();
+
+    // Validate compatibility between copied filter type and track type
+    if !is_filter_compatible(&copied_type, &track_type) {
+        crate::toast_warn!(
+            ui,
+            format!(
+                "Cannot paste {} filter to {} track",
+                copied_type.to_string(),
+                track_type.to_string()
+            )
+        );
+        return;
+    }
+
+    let paste_type = copied_type;
+    let filter_detail = cached_filter.detail.to_string();
+    let enabled = cached_filter.enabled;
+
+    let mut batch_command = BatchCommand::new(format!("Paste filter '{}'", filter_name));
+
+    for (track_idx, seg_idx) in &selected_segments {
+        if let Some(cmd) = create_filter_command_with_detail(
+            *track_idx,
+            *seg_idx,
+            paste_type.clone(),
+            &filter_name,
+            &filter_detail,
+            enabled,
+        ) {
+            batch_command.add_command(cmd);
+        }
+    }
+
+    let result = with_history_manager(|state| {
+        state
+            .history_manager
+            .execute(&mut state.tracks_manager, Box::new(batch_command))
+    });
+
+    match result {
+        Ok(execute_result) => {
+            sync_manager_to_ui(ui);
+            refresh_affected_segments(ui, execute_result.affected_segments);
+            refresh_preview(ui);
+
+            global_ve_filter!(ui).set_selected_filter_index(-1);
+            global_ve_filter!(ui).invoke_refresh_filter_list();
+            crate::toast_success!(ui, format!("Pasted filter: {}", filter_name));
+        }
+        Err(e) => crate::toast_warn!(ui, format!("Failed to paste filter: {}", e)),
+    }
+}
+
+pub fn refresh_filter_list(ui: &AppWindow) {
+    global_store!(ui).set_video_editor_segment_filter_flag(
+        !global_store!(ui).get_video_editor_segment_filter_flag(),
+    );
+}
+
+fn is_filter_compatible(filter_type: &FilterType, track_type: &FilterType) -> bool {
+    match (filter_type, track_type) {
+        (FilterType::Video, FilterType::Video) => true,
+        (FilterType::Video, FilterType::Image) => true,
+        (FilterType::Image, FilterType::Image) => true,
+        (FilterType::Image, FilterType::Video) => true,
+        (FilterType::Audio, FilterType::Audio) => true,
+        (FilterType::Audio, FilterType::Video) => true,
+        (FilterType::Subtitle, FilterType::Subtitle) => true,
+        _ => false,
+    }
+}
+
 fn add_filter(ui: &AppWindow, entry: UIFilterEntry) {
     let filter_name = entry.name.to_string();
     let filter_type: FilterType = entry.ty.into();

wayshot/src/logic/video_editor/track.rs

@@ -702,12 +702,11 @@ fn video_editor_paste_filter_to_track(ui: &AppWindow, index: i32) {
             sync_manager_to_ui(ui);
             refresh_affected_segments(ui, execute_result.affected_segments);
             refresh_preview(ui);
+
+            global_ve_filter!(ui).invoke_refresh_filter_list();
             crate::toast_success!(
                 ui,
-                format!(
-                    "Pasted filter '{}' to {} segments",
-                    filter_name, segment_count
-                )
+                format!("Pasted filter '{filter_name}' to {segment_count} segments")
             );
         }
         Err(e) => crate::toast_warn!(ui, format!("Failed to paste filter: {}", e)),
@@ -742,6 +741,10 @@ fn video_editor_remove_all_filters_from_track(ui: &AppWindow, index: i32) {
     match result {
         Ok(_execute_result) => {
             sync_manager_to_ui(ui);
+            refresh_preview(ui);
+            global_store!(ui).set_video_editor_segment_filter_flag(
+                !global_store!(ui).get_video_editor_segment_filter_flag(),
+            );
             crate::toast_success!(ui, format!("Removed all filters from track {}", index));
         }
         Err(e) => crate::toast_warn!(ui, format!("Failed to remove filters: {}", e)),
@@ -1049,9 +1052,6 @@ pub fn is_track_locked(ui: &AppWindow, track_index: i32) -> bool {
         .unwrap_or(false)
 }
 
-/// Reset all editor selection state when adding/removing tracks.
-/// This clears the current edited track index, selected filter index,
-/// selected tracks list, and selected segments list.
 pub fn reset_editor_selection_state(ui: &AppWindow) {
     global_store!(ui).set_video_editor_current_edited_track_index(-1);
     global_ve_filter!(ui).set_selected_filter_index(-1);

wayshot/ui/panel/desktop/video-editor/filter.slint

@@ -292,7 +292,10 @@ export global VEFilter {
     callback remove-filter(index: int);
     callback toggle-filter(index: int);
     callback copy-filter(index: int);
+    callback cut-filter(index: int);
+    callback paste-filter();
     callback add-filter(entry: FilterEntry);
+    callback refresh-filter-list();
 
     callback create-preset-filter(name: string);
     callback add-preset-filter(filter: PresetFilter);
@@ -301,7 +304,6 @@ export global VEFilter {
     callback remove-cache-preset-filter(filter: SegmentFilter);
 
     callback toggle-mark-filter(filter: FilterEntry); // 收藏和取消收藏滤镜
-
     callback video-editor-update-font-style-from-track(track-index: int);
 
     // Video/Image shared filter callbacks - filter-type as last parameter

wayshot/ui/panel/desktop/video-editor/right-panel/filter/filter.slint

@@ -214,14 +214,37 @@ component SegmentFilterList inherits Rectangle {
                     }
                 }
 
-                IconBtn {
-                    icon: Icons.preset-light;
-                    icon-size: Theme.icon-size * 0.8;
-                    tip: Logic.tr("create preset filter");
-                    is-show-tip: true;
+                HorizontalLayout {
+                    spacing: Theme.spacing * 2;
 
-                    clicked => {
-                        preset-mode = !preset-mode;
+                    IconBtn {
+                        icon: Icons.preset-light;
+                        icon-size: Theme.icon-size * 0.8;
+                        tip: Logic.tr("create preset filter");
+                        is-show-tip: true;
+
+                        clicked => {
+                            preset-mode = !preset-mode;
+                        }
+                    }
+
+                    IconBtn {
+                        icon: Icons.more-v-light;
+
+                        clicked => {
+                            PopupActionSetting.show(self.absolute-position.x, self.absolute-position.y + self.preferred-height, [
+                                {
+                                    icon: Icons.paste-light,
+                                    text: Logic.tr("Paste"),
+                                    action: "video-editor-paste-filter",
+                                },
+                                {
+                                    icon: Icons.arrow-up-light,
+                                    text: Logic.tr("refresh"),
+                                    action: "video-editor-refresh-filter-list",
+                                },
+                            ]);
+                        }
                     }
                 }
             }
@@ -355,6 +378,12 @@ component SegmentFilterList inherits Rectangle {
                                         action: "video-editor-copy-filter",
                                         user-data: index,
                                     },
+                                    {
+                                        icon: Icons.cut-light,
+                                        text: Logic.tr("Cut"),
+                                        action: "video-editor-cut-filter",
+                                        user-data: index,
+                                    },
                                     {
                                         icon: Icons.clear-light,
                                         text: Logic.tr("Remove"),