[*] refactor

Author: heng30

lib/video-editor/src/font.rs

@@ -22,3 +22,20 @@ pub fn get_fonts_info() -> Result<Vec<(String, PathBuf)>> {
 
     Ok(fonts)
 }
+
+pub fn get_font_family_from_file(path: &PathBuf) -> Result<String> {
+    let mut db = fontdb::Database::new();
+    db.load_font_file(path.clone())?;
+
+    for face in db.faces() {
+        if let Some(family) = face.families.first() {
+            return Ok(family.0.clone());
+        }
+    }
+
+    Ok(path
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("Unknown")
+        .to_string())
+}

wayshot/src/db.rs

@@ -1,6 +1,6 @@
 use crate::slint_generatedAppWindow::{
-    FileType as UIFileType, HistoryEntry as UIHistoryEntry, SettingPlayer as UISettingPlayer,
-    Subtitle as UISubtitle, Transcribe as UITranscribe,
+    FileType as UIFileType, FontEntry as UIFontEntry, HistoryEntry as UIHistoryEntry,
+    SettingPlayer as UISettingPlayer, Subtitle as UISubtitle, Transcribe as UITranscribe,
 };
 use pmacro::SlintFromConvert;
 use serde::{Deserialize, Serialize};
@@ -10,6 +10,7 @@ pub const HISTORY_TABLE: &str = "history";
 pub const PLAYER_SETTING_TABLE: &str = "player_setting";
 pub const TRANSCRIBE_TABLE: &str = "transcribe";
 pub const VIDEO_EDITOR_TABLE: &str = "video_editor";
+pub const FONT_TABLE: &str = "font";
 
 pub async fn init(db_path: &str) {
     sqldb::create_db(db_path).await.expect("create db");
@@ -29,6 +30,10 @@ pub async fn init(db_path: &str) {
     sqldb::entry::new(VIDEO_EDITOR_TABLE)
         .await
         .expect("video editor table failed");
+
+    sqldb::entry::new(FONT_TABLE)
+        .await
+        .expect("font table failed");
 }
 
 #[macro_export]
@@ -207,3 +212,14 @@ pub struct Transcribe {
     #[vec(from = "subtitles")]
     pub subtitles: Vec<Subtitle>,
 }
+
+#[derive(Serialize, Deserialize, Debug, Clone, Derivative, SlintFromConvert)]
+#[derivative(Default)]
+#[serde(default)]
+#[from("UIFontEntry")]
+pub struct FontEntry {
+    pub id: String,
+    pub family: String,
+    pub path: String,
+    pub marked: bool,
+}

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

@@ -7,6 +7,7 @@ use crate::{
         project::FONT_STYLE_ID,
         segment::refresh_affected_segments,
     },
+    logic_cb,
     slint_generatedAppWindow::{
         AppWindow, BackgroundColorDetail as UIBackgroundColorDetail,
         BorderRadiusDetail as UIBorderRadiusDetail, FontPathDetail as UIFontPathDetail,
@@ -18,18 +19,25 @@ use crate::{
     ve_filter_cb,
 };
 use slint::{ComponentHandle, SharedString};
+use std::sync::Arc;
 use video_editor::{
     commands::{BatchCommand, filter::InsertFilterCommand},
-    filters::subtitle::style::{
-        BackgroundColorFilter, BorderRadiusFilter, FontPathFilter, FontSizeFilter,
-        MarginHorizontalFilter, MarginVerticalFilter, OutlineColorFilter, OutlineWidthFilter,
-        PaddingFilter, PrimaryColorFilter,
+    filters::{
+        subtitle::style::{
+            BackgroundColorFilter, BorderRadiusFilter, FontPathFilter, FontSizeFilter,
+            MarginHorizontalFilter, MarginVerticalFilter, OutlineColorFilter, OutlineWidthFilter,
+            PaddingFilter, PrimaryColorFilter,
+        },
+        traits::SubtitleFilterWrapper,
     },
+    tracks::track::Track,
 };
 
 pub fn init(ui: &AppWindow) {
     load_font_style_from_db(ui);
 
+    logic_cb!(video_editor_update_font_style_from_track, ui, track_index);
+
     ve_filter_cb!(from_font_size_json, ui, json);
     ve_filter_cb!(from_padding_json, ui, json);
     ve_filter_cb!(from_margin_vertical_json, ui, json);
@@ -244,3 +252,107 @@ fn load_font_style_from_db(ui: &AppWindow) {
         });
     });
 }
+
+fn video_editor_update_font_style_from_track(ui: &AppWindow, track_index: i32) {
+    if track_index < 0 {
+        return;
+    }
+
+    let track_idx = track_index as usize;
+    let is_subtitle = with_history_manager(|state| {
+        state
+            .tracks_manager
+            .get(track_idx)
+            .map(|t| matches!(t, Track::Subtitle(_)))
+            .unwrap_or(false)
+    });
+
+    if !is_subtitle {
+        return;
+    }
+
+    let font_style = with_history_manager(|state| {
+        state.tracks_manager.get(track_idx).and_then(|track| {
+            if let Track::Subtitle(inner) = track {
+                inner
+                    .track
+                    .segments
+                    .first()
+                    .map(|seg| extract_font_style_from_filters(&seg.subtitle_filters))
+            } else {
+                None
+            }
+        })
+    })
+    .unwrap_or_default();
+
+    crate::global_ve_filter!(ui).set_font_style(font_style.into());
+}
+
+fn extract_font_style_from_filters(filters: &[Arc<SubtitleFilterWrapper>]) -> FontStyleConfig {
+    let mut config = FontStyleConfig::default();
+
+    for filter_wrapper in filters {
+        let filter = &filter_wrapper.inner;
+        let filter_name = filter.name();
+
+        if filter_name == FontPathFilter::NAME {
+            if let Some(f) = filter.as_any().downcast_ref::<FontPathFilter>() {
+                config.font_path = f.font_path.to_string_lossy().to_string();
+            }
+        } else if filter_name == FontSizeFilter::NAME {
+            if let Some(f) = filter.as_any().downcast_ref::<FontSizeFilter>() {
+                config.font_size = f.font_size as i32;
+            }
+        } else if filter_name == PaddingFilter::NAME {
+            if let Some(f) = filter.as_any().downcast_ref::<PaddingFilter>() {
+                config.padding = f.padding.unwrap_or(4) as i32;
+            }
+        } else if filter_name == MarginVerticalFilter::NAME {
+            if let Some(f) = filter.as_any().downcast_ref::<MarginVerticalFilter>() {
+                config.margin_vertical = f.margin.unwrap_or(30) as i32;
+            }
+        } else if filter_name == MarginHorizontalFilter::NAME {
+            if let Some(f) = filter.as_any().downcast_ref::<MarginHorizontalFilter>() {
+                config.margin_horizontal = f.margin.unwrap_or(0) as i32;
+            }
+        } else if filter_name == OutlineWidthFilter::NAME {
+            if let Some(f) = filter.as_any().downcast_ref::<OutlineWidthFilter>() {
+                config.outline_width = f.width.unwrap_or(2) as i32;
+            }
+        } else if filter_name == BorderRadiusFilter::NAME {
+            if let Some(f) = filter.as_any().downcast_ref::<BorderRadiusFilter>() {
+                config.border_radius = f.radius.unwrap_or(0) as i32;
+            }
+        } else if filter_name == PrimaryColorFilter::NAME {
+            if let Some(f) = filter.as_any().downcast_ref::<PrimaryColorFilter>()
+                && let Some(color) = f.color
+            {
+                config.primary_color_r = color[0] as i32;
+                config.primary_color_g = color[1] as i32;
+                config.primary_color_b = color[2] as i32;
+                config.primary_color_a = color[3] as i32;
+            }
+        } else if filter_name == OutlineColorFilter::NAME {
+            if let Some(f) = filter.as_any().downcast_ref::<OutlineColorFilter>()
+                && let Some(color) = f.color
+            {
+                config.outline_color_r = color[0] as i32;
+                config.outline_color_g = color[1] as i32;
+                config.outline_color_b = color[2] as i32;
+                config.outline_color_a = color[3] as i32;
+            }
+        } else if filter_name == BackgroundColorFilter::NAME {
+            if let Some(f) = filter.as_any().downcast_ref::<BackgroundColorFilter>()
+                && let Some(color) = f.color
+            {
+                config.background_color_r = color[0] as i32;
+                config.background_color_g = color[1] as i32;
+                config.background_color_b = color[2] as i32;
+                config.background_color_a = color[3] as i32;
+            }
+        }
+    }
+
+    config
+}

wayshot/src/logic/video_editor/font.rs

@@ -1,19 +1,173 @@
 use crate::{
-    global_store, global_ve_filter,
-    logic::{toast, tr::tr},
+    db::{FONT_TABLE as DB_TABLE, FontEntry},
+    db_add, db_remove_all, db_select_all, db_update,
+    logic::{toast, tr::tr, video_editor::playlist::picker_files},
     logic_cb,
-    slint_generatedAppWindow::{AppWindow, FontInfo as UIFontInfo},
+    slint_generatedAppWindow::{AppWindow, FontEntry as UIFontEntry},
 };
+use slint::{ComponentHandle, Model, VecModel, Weak};
+use std::{collections::HashSet, path::PathBuf};
+use video_editor::font::get_font_family_from_file;
+
+db_add!(DB_TABLE, FontEntry);
+db_remove_all!(DB_TABLE);
+db_update!(DB_TABLE, FontEntry);
 
 #[macro_export]
-macro_rules! store_font_infos {
+macro_rules! store_font_entries {
     ($ui:expr) => {
-        crate::global_store!($ui)
-            .get_font_infos()
+        $ui.global::<crate::slint_generatedAppWindow::Store>()
+            .get_font_entries()
             .as_any()
-            .downcast_ref::<VecModel<UIFontInfo>>()
-            .expect("We know we set a VecModel<UIFontInfo> earlier")
+            .downcast_ref::<VecModel<UIFontEntry>>()
+            .expect("We know we set a VecModel<UIFontEntry> earlier")
     };
 }
 
-fn init(ui: &AppWindow) {}
+pub fn init(ui: &AppWindow) {
+    store_font_entries!(ui).set_vec(vec![]);
+
+    logic_cb!(init_font_dialog, ui);
+    logic_cb!(refresh_font_entries, ui);
+    logic_cb!(import_font_files, ui);
+    logic_cb!(toggle_font_marked, ui, index);
+}
+
+fn init_font_dialog(ui: &AppWindow) {
+    let ui_weak = ui.as_weak();
+    tokio::spawn(async move {
+        let db_fonts = db_select_all!(DB_TABLE, FontEntry);
+        if db_fonts.is_empty() {
+            refresh_font_entries_impl(ui_weak.clone()).await;
+        } else {
+            sync_fonts_to_ui(ui_weak, db_fonts);
+        }
+    });
+}
+
+fn refresh_font_entries(ui: &AppWindow) {
+    let ui_weak = ui.as_weak();
+    tokio::spawn(async move {
+        refresh_font_entries_impl(ui_weak).await;
+    });
+}
+
+async fn refresh_font_entries_impl(ui_weak: Weak<AppWindow>) {
+    let marked_fonts: HashSet<String> = {
+        let db_fonts = db_select_all!(DB_TABLE, FontEntry);
+        db_fonts
+            .into_iter()
+            .filter(|f| f.marked)
+            .map(|f| f.path)
+            .collect()
+    };
+
+    if let Err(e) = sqldb::entry::delete_all(DB_TABLE).await {
+        log::warn!("Failed to clear font table: {}", e);
+    }
+
+    let system_fonts = match video_editor::font::get_fonts_info() {
+        Ok(fonts) => fonts,
+        Err(e) => {
+            toast::async_toast_warn(ui_weak.clone(), format!("Failed to get fonts: {}", e));
+            return;
+        }
+    };
+
+    let mut font_entries: Vec<FontEntry> = Vec::new();
+    for (family, path) in system_fonts {
+        let path_str = path.to_string_lossy().to_string();
+        let marked = marked_fonts.contains(&path_str);
+
+        let entry = FontEntry {
+            id: path_str.clone(),
+            family,
+            path: path_str,
+            marked,
+        };
+
+        let data = serde_json::to_string(&entry).expect("Serialize font entry");
+        if let Err(e) = sqldb::entry::insert(DB_TABLE, entry.id.as_str(), &data).await {
+            log::warn!("Failed to insert font {}: {}", entry.family, e);
+        }
+
+        font_entries.push(entry);
+    }
+
+    sync_fonts_to_ui(ui_weak, font_entries);
+}
+
+// todo: 需要排序，marked在前
+fn sync_fonts_to_ui(ui_weak: Weak<AppWindow>, fonts: Vec<FontEntry>) {
+    let ui_fonts: Vec<UIFontEntry> = fonts.into_iter().map(|f| f.into()).collect();
+    _ = ui_weak.upgrade_in_event_loop(move |ui| {
+        store_font_entries!(ui).set_vec(ui_fonts);
+    });
+}
+
+fn import_font_files(ui: &AppWindow) {
+    let ui_weak = ui.as_weak();
+    tokio::spawn(async move {
+        let file_paths = match picker_files(
+            ui_weak.clone(),
+            &tr("Select font files"),
+            &tr("Font Files"),
+            &["ttf", "otf", "woff", "woff2"],
+        ) {
+            Some(paths) => paths,
+            None => return,
+        };
+
+        for file_path in file_paths {
+            import_font_to_db(ui_weak.clone(), file_path).await;
+        }
+
+        refresh_font_entries_impl(ui_weak).await;
+    });
+}
+
+async fn import_font_to_db(ui_weak: Weak<AppWindow>, file_path: PathBuf) {
+    let family = match get_font_family_from_file(&file_path) {
+        Ok(f) => f,
+        Err(e) => {
+            toast::async_toast_warn(
+                ui_weak.clone(),
+                format!("Failed to read font file {}: {}", file_path.display(), e),
+            );
+            return;
+        }
+    };
+
+    let path_str = file_path.to_string_lossy().to_string();
+
+    let entry = FontEntry {
+        id: path_str.clone(),
+        family,
+        path: path_str,
+        marked: true,
+    };
+
+    let data = serde_json::to_string(&entry).expect("Serialize font entry");
+    if let Err(e) = sqldb::entry::insert(DB_TABLE, entry.id.as_str(), &data).await {
+        toast::async_toast_warn(
+            ui_weak.clone(),
+            format!("Failed to import font {}: {}", entry.family, e),
+        );
+        return;
+    }
+
+    toast::async_toast_success(ui_weak.clone(), format!("Imported font: {}", entry.family));
+}
+
+// TODO: 需要重新排序
+fn toggle_font_marked(ui: &AppWindow, index: i32) {
+    let idx = index as usize;
+
+    if idx < store_font_entries!(ui).row_count()
+        && let Some(mut font_info) = store_font_entries!(ui).row_data(idx)
+    {
+        font_info.marked = !font_info.marked;
+        store_font_entries!(ui).set_row_data(idx, font_info.clone());
+        db_update(ui.as_weak(), font_info.into());
+    }
+}