[*] refactor: video-editor

Author: heng30

wayshot/src/logic.rs

@@ -102,6 +102,13 @@ macro_rules! global_util {
     };
 }
 
+#[macro_export]
+macro_rules! global_ve_filter {
+    ($ui:expr) => {
+        $ui.global::<crate::slint_generatedAppWindow::VEFilter>()
+    };
+}
+
 #[macro_export]
 macro_rules! logic_cb {
     ($callback_name:ident, $ui:expr, $($arg:ident),*) => {

wayshot/src/logic/popup_action.rs

@@ -277,19 +277,19 @@ pub fn init(ui: &AppWindow) {
                 }
                 "video-editor-up-filter" => {
                     let index = user_data.parse::<i32>().unwrap();
-                    global_ve_filter!(ui).invoke_filter_up(&ui, index);
+                    global_ve_filter!(ui).invoke_up_filter(index);
                 }
                 "video-editor-down-filter" => {
                     let index = user_data.parse::<i32>().unwrap();
-                    global_ve_filter!(ui).invoke_filter_down(&ui, index);
+                    global_ve_filter!(ui).invoke_down_filter(index);
                 }
                 "video-editor-remove-filter" => {
                     let index = user_data.parse::<i32>().unwrap();
-                    global_ve_filter!(ui).invoke_filter_remove(&ui, index);
+                    global_ve_filter!(ui).invoke_remove_filter(index);
                 }
                 "video-editor-copy-filter" => {
                     let index = user_data.parse::<i32>().unwrap();
-                    global_ve_filter!(ui).filter_copy(&ui, index);
+                    global_ve_filter!(ui).invoke_copy_filter(index);
                 }
                 _ => log::warn!("Unknown popup action: {action}"),
             }

wayshot/src/logic/video_editor/filter.rs

@@ -3,8 +3,11 @@ use super::{
     segment::refresh_affected_segments,
     track::get_selected_segment_indices,
 };
-use crate::{global_store, slint_generatedAppWindow::AppWindow};
-use slint::ComponentHandle;
+use crate::{global_store, global_ve_filter, slint_generatedAppWindow::{
+    AppWindow, BrightnessDetail as UIBrightnessDetail, PresetFilter as UIPresetFilter,
+    SegmentFilter as UISegmentFilter,
+}};
+use slint::{ComponentHandle, Model, SharedString, VecModel};
 use video_editor::filters::{
     audio::{
         CompressorFilter, FadeInFilter as AudioFadeInFilter, FadeOutFilter as AudioFadeOutFilter,
@@ -45,12 +48,6 @@ use video_editor::{
     tracks::track::Track,
 };
 
-macro_rules! global_ve_filter {
-    ($ui:expr) => {
-        $ui.global::<crate::slint_generatedAppWindow::VEFilter>()
-    };
-}
-
 #[macro_export]
 macro_rules! ve_filter_cb {
     ($callback_name:ident, $ui:expr, $($arg:ident),*) => {
@@ -78,26 +75,18 @@ macro_rules! ve_filter_cb {
 }
 
 pub fn init(ui: &AppWindow) {
-    // ve_filter_cb!(up_filter, ui, index);
-    // ve_filter_cb!(down_filter, ui, index);
-    // ve_filter_cb!(remove_filter, ui, index);
-    // ve_filter_cb!(toggle_filter, ui, index);
-    // ve_filter_cb!(copy_filter, ui, index);
-    // ve_filter_cb!(add_filter, ui, filter_name);
-
-    // Register add-filter callback
-    let ui_weak = ui.as_weak();
-    global_ve_filter!(ui).on_add_filter(move |filter_name| {
-        let ui = ui_weak.unwrap();
-        video_editor_filter_add(&ui, filter_name.to_string());
-    });
-
-    // Register toggle-filter callback
-    let ui_weak = ui.as_weak();
-    global_ve_filter!(ui).on_toggle_filter(move |index| {
-        let ui = ui_weak.unwrap();
-        video_editor_filter_toggle(&ui, index);
-    });
+    ve_filter_cb!(up_filter, ui, index);
+    ve_filter_cb!(down_filter, ui, index);
+    ve_filter_cb!(remove_filter, ui, index);
+    ve_filter_cb!(toggle_filter, ui, index);
+    ve_filter_cb!(copy_filter, ui, index);
+    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!(add_cache_preset_filter, ui, filter);
+    ve_filter_cb!(remove_cache_preset_filter, ui, filter);
+    ve_filter_cb!(from_brightness_json, ui, json);
+    ve_filter_cb!(modify_brightness_filter, ui, index, config);
 }
 
 /// Get the current filter type based on the current track type
@@ -125,7 +114,7 @@ fn get_current_filter_type(ui: &AppWindow) -> FilterType {
 }
 
 /// Move filter up in order
-pub fn filter_up(ui: &AppWindow, index: i32) {
+pub fn up_filter(ui: &AppWindow, index: i32) {
     let filter_index = index as usize;
     let filter_type = get_current_filter_type(ui);
 
@@ -169,7 +158,7 @@ pub fn filter_up(ui: &AppWindow, index: i32) {
 }
 
 /// Move filter down in order
-pub fn filter_down(ui: &AppWindow, index: i32) {
+pub fn down_filter(ui: &AppWindow, index: i32) {
     let filter_index = index as usize;
     let filter_type = get_current_filter_type(ui);
 
@@ -209,7 +198,7 @@ pub fn filter_down(ui: &AppWindow, index: i32) {
 }
 
 /// Remove a filter from selected segments
-pub fn filter_remove(ui: &AppWindow, index: i32) {
+pub fn remove_filter(ui: &AppWindow, index: i32) {
     let filter_index = index as usize;
     let filter_type = get_current_filter_type(ui);
 
@@ -265,7 +254,7 @@ pub fn filter_remove(ui: &AppWindow, index: i32) {
 }
 
 /// Toggle filter enabled state
-fn video_editor_filter_toggle(ui: &AppWindow, index: i32) {
+fn toggle_filter(ui: &AppWindow, index: i32) {
     let filter_index = index as usize;
     let filter_type = get_current_filter_type(ui);
 
@@ -300,7 +289,7 @@ fn video_editor_filter_toggle(ui: &AppWindow, index: i32) {
 }
 
 /// Copy filter to clipboard (for later pasting)
-pub fn filter_copy(ui: &AppWindow, index: i32) {
+pub fn copy_filter(ui: &AppWindow, index: i32) {
     let filter_index = index as usize;
     let filter_type = get_current_filter_type(ui);
 
@@ -348,7 +337,8 @@ pub fn filter_copy(ui: &AppWindow, index: i32) {
 }
 
 /// Add a filter to selected segments
-fn video_editor_filter_add(ui: &AppWindow, filter_name: String) {
+fn add_filter(ui: &AppWindow, filter_name: SharedString) {
+    let filter_name = filter_name.to_string();
     let filter_type = get_current_filter_type(ui);
     let selected_segments = get_selected_segment_indices(ui);
 
@@ -384,6 +374,139 @@ fn video_editor_filter_add(ui: &AppWindow, filter_name: String) {
     }
 }
 
+/// Create a preset filter from cached filters
+fn create_preset_filter(ui: &AppWindow, name: slint::SharedString) {
+    let cache_filters = global_ve_filter!(ui).get_cache_preset_filters();
+
+    if cache_filters.row_count() == 0 {
+        crate::toast_warn!(ui, "No filters selected for preset");
+        return;
+    }
+
+    // Collect all SegmentFilters from the cached PresetFilters
+    let mut all_filters: Vec<UISegmentFilter> = Vec::new();
+    for preset in cache_filters.iter() {
+        for seg_filter in preset.filters.iter() {
+            all_filters.push(seg_filter);
+        }
+    }
+
+    let preset_filter = UIPresetFilter {
+        name,
+        filters: slint::ModelRc::from(std::rc::Rc::new(VecModel::from(all_filters))),
+    };
+
+    // Add to video preset filters by default (can be extended for other types)
+    let current_filters = global_ve_filter!(ui).get_video_preset_filters();
+    let mut new_filters: Vec<UIPresetFilter> = current_filters.iter().collect();
+    new_filters.push(preset_filter);
+
+    global_ve_filter!(ui).set_video_preset_filters(slint::ModelRc::from(std::rc::Rc::new(VecModel::from(new_filters))));
+
+    // Clear cache after creating preset
+    global_ve_filter!(ui).set_cache_preset_filters(slint::ModelRc::default());
+
+    crate::toast_success!(ui, "Preset filter created");
+}
+
+/// Add a preset filter to selected segments
+fn add_preset_filter(ui: &AppWindow, filter: UIPresetFilter) {
+    let filter_type = get_current_filter_type(ui);
+    let selected_segments = get_selected_segment_indices(ui);
+
+    if selected_segments.is_empty() {
+        crate::toast_warn!(ui, "No segments selected");
+        return;
+    }
+
+    let mut batch_command = BatchCommand::new(format!("Add preset filter: {}", filter.name));
+
+    for segment_filter in filter.filters.iter() {
+        let filter_name = segment_filter.name.to_string();
+
+        for (track_idx, seg_idx) in &selected_segments {
+            let command =
+                create_filter_command(*track_idx, *seg_idx, filter_type.clone(), &filter_name);
+            if let Some(cmd) = command {
+                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);
+            crate::toast_success!(ui, format!("Added preset filter: {}", filter.name));
+        }
+        Err(e) => crate::toast_warn!(ui, format!("Failed to add preset filter: {}", e)),
+    }
+}
+
+/// Add filter to cache for preset creation
+fn add_cache_preset_filter(ui: &AppWindow, filter: UISegmentFilter) {
+    // Wrap the SegmentFilter in a PresetFilter for storage in cache-preset-filters
+    let preset = UIPresetFilter {
+        name: slint::SharedString::new(),
+        filters: slint::ModelRc::from(std::rc::Rc::new(VecModel::from(vec![filter]))),
+    };
+
+    let current_cache = global_ve_filter!(ui).get_cache_preset_filters();
+    let mut new_cache: Vec<UIPresetFilter> = current_cache.iter().collect();
+    new_cache.push(preset);
+    global_ve_filter!(ui).set_cache_preset_filters(slint::ModelRc::from(std::rc::Rc::new(VecModel::from(new_cache))));
+}
+
+/// Remove filter from cache for preset creation
+fn remove_cache_preset_filter(ui: &AppWindow, filter: UISegmentFilter) {
+    let current_cache = global_ve_filter!(ui).get_cache_preset_filters();
+    // Remove PresetFilters that contain a matching SegmentFilter
+    let new_cache: Vec<UIPresetFilter> = current_cache
+        .iter()
+        .filter(|preset| {
+            // Keep the preset if none of its filters match
+            preset.filters.iter().all(|f| f.name != filter.name || f.detail != filter.detail)
+        })
+        .collect();
+    global_ve_filter!(ui).set_cache_preset_filters(slint::ModelRc::from(std::rc::Rc::new(VecModel::from(new_cache))));
+}
+
+/// Deserialize brightness config from JSON (pure callback)
+fn from_brightness_json(_ui: &AppWindow, json: slint::SharedString) -> UIBrightnessDetail {
+    // Parse JSON and return BrightnessDetail
+    match serde_json::from_str::<serde_json::Value>(json.as_str()) {
+        Ok(value) => {
+            let adjustment = value
+                .get("adjustment")
+                .and_then(|v| v.as_f64())
+                .unwrap_or(0.0) as f32;
+            UIBrightnessDetail { adjustment }
+        }
+        Err(_) => UIBrightnessDetail { adjustment: 0.0 },
+    }
+}
+
+/// Modify brightness filter configuration
+fn modify_brightness_filter(ui: &AppWindow, index: i32, config: UIBrightnessDetail) {
+    // TODO: Implement proper filter modification through command pattern
+    // This requires adding as_any_mut() to the VideoFilter trait or implementing
+    // a ModifyFilterCommand in the video-editor library.
+    log::warn!(
+        "modify_brightness_filter called with index={}, adjustment={}",
+        index,
+        config.adjustment
+    );
+    // Refresh UI to reflect current state
+    sync_manager_to_ui(ui);
+}
+
 /// Get available video filter names
 #[allow(dead_code)]
 fn video_editor_filter_get_video_filters(_ui: &AppWindow, _flag: bool) -> Vec<String> {