Launch: {}
", decoded_key); + + Ok(build_response(StatusCode::OK, "text/html; charset=utf-8", response_html.into_bytes())) + } +} + +/// Sound处理器 +pub struct SoundHandler; + +impl ActionHandler for SoundHandler { + fn handle(&self, url: &Url, _action: MdxAction) -> Result {
+ if letter.len() == 1 {
+ let ch = letter.chars().next().unwrap().to_ascii_uppercase();
+ match ch {
+ 'A'..='Z' => {
+ let offset = (ch as u32 - 'A' as u32) as usize;
+ let codes = [
+ Code::KeyA, Code::KeyB, Code::KeyC, Code::KeyD, Code::KeyE,
+ Code::KeyF, Code::KeyG, Code::KeyH, Code::KeyI, Code::KeyJ,
+ Code::KeyK, Code::KeyL, Code::KeyM, Code::KeyN, Code::KeyO,
+ Code::KeyP, Code::KeyQ, Code::KeyR, Code::KeyS, Code::KeyT,
+ Code::KeyU, Code::KeyV, Code::KeyW, Code::KeyX, Code::KeyY,
+ Code::KeyZ,
+ ];
+ codes.get(offset).copied()
+ }
+ '0'..='9' => {
+ let offset = (ch as u32 - '0' as u32) as usize;
+ let codes = [
+ Code::Digit0, Code::Digit1, Code::Digit2, Code::Digit3, Code::Digit4,
+ Code::Digit5, Code::Digit6, Code::Digit7, Code::Digit8, Code::Digit9,
+ ];
+ codes.get(offset).copied()
+ }
+ _ => None,
+ }
+ } else {
+ None
+ }
+}
+
+/// Initialize the hotkey manager
+pub fn init_hotkey_manager(app_handle: AppHandle) -> Result<(), String> {
+ let mut manager = HOTKEY_MANAGER.lock().unwrap();
+ if manager.is_none() {
+ *manager = Some(SendableHotKeyManager::new().map_err(|e| format!("Failed to create GlobalHotKeyManager: {}", e))?);
+ info!("GlobalHotKeyManager initialized");
+ }
+
+ // Store app handle
+ let mut handle = APP_HANDLE.lock().unwrap();
+ *handle = Some(app_handle);
+
+ Ok(())
+}
+
+/// Register a global hotkey
+pub fn register_hotkey(app_handle: AppHandle, letter: &str, modifier: &str) -> Result<(), String> {
+ // Initialize if not already done
+ init_hotkey_manager(app_handle)?;
+
+ // Unregister existing hotkey if any
+ unregister_hotkey()?;
+
+ // Check if both letter and modifier are empty
+ if letter.is_empty() || modifier.is_empty() {
+ info!("Hotkey is empty, skipping registration");
+ return Ok(());
+ }
+
+ // Parse modifier and key code
+ let modifiers = parse_modifier(modifier)
+ .ok_or_else(|| format!("Invalid modifier: {}", modifier))?;
+ let code = parse_key_code(letter)
+ .ok_or_else(|| format!("Invalid key letter: {}", letter))?;
+
+ info!("Registering hotkey: {} + {:?}", modifier, letter);
+
+ // Create hotkey
+ let hotkey = HotKey::new(Some(modifiers), code);
+
+ // Register the hotkey
+ let manager = HOTKEY_MANAGER.lock().unwrap();
+ if let Some(mgr) = manager.as_ref() {
+ mgr.register(hotkey).map_err(|e| format!("Failed to register hotkey: {}", e))?;
+ info!("Hotkey registered successfully");
+
+ // Store the registered hotkey
+ let mut registered = REGISTERED_HOTKEY.lock().unwrap();
+ *registered = Some(hotkey);
+
+ Ok(())
+ } else {
+ Err("GlobalHotKeyManager not initialized".to_string())
+ }
+}
+
+/// Unregister the current global hotkey
+pub fn unregister_hotkey() -> Result<(), String> {
+ let mut registered = REGISTERED_HOTKEY.lock().unwrap();
+
+ if let Some(hotkey) = registered.take() {
+ info!("Unregistering hotkey");
+ let manager = HOTKEY_MANAGER.lock().unwrap();
+ if let Some(mgr) = manager.as_ref() {
+ mgr.unregister(hotkey).map_err(|e| format!("Failed to unregister hotkey: {}", e))?;
+ info!("Hotkey unregistered successfully");
+ Ok(())
+ } else {
+ Err("GlobalHotKeyManager not initialized".to_string())
+ }
+ } else {
+ // No hotkey registered, nothing to do
+ Ok(())
+ }
+}
+
+/// Check for hotkey events and handle them
+/// This should be called from a loop or event handler
+pub fn check_hotkey_events() {
+ if let Ok(event) = GlobalHotKeyEvent::receiver().try_recv() {
+ info!("Hotkey event received: {:?}", event);
+
+ // Get the app handle
+ let app_handle_lock = APP_HANDLE.lock().unwrap();
+ if let Some(app_handle) = app_handle_lock.as_ref() {
+ info!("Hotkey pressed, bringing window to front");
+
+ // Get the main window and bring it to front
+ if let Some(window) = app_handle.get_webview_window("main") {
+ if let Err(e) = window.set_focus() {
+ error!("Failed to focus window: {}", e);
+ }
+ if let Err(e) = window.show() {
+ error!("Failed to show window: {}", e);
+ }
+ if let Err(e) = window.unminimize() {
+ error!("Failed to unminimize window: {}", e);
+ }
+
+ // Emit window-focus event to frontend
+ if let Err(e) = app_handle.emit("window-focus", ()) {
+ error!("Failed to emit window-focus event: {}", e);
+ }
+ } else {
+ error!("Failed to get main window");
+ }
+ }
+ }
+}
+
diff --git a/rust/src-tauri/src/lib.rs b/rust/src-tauri/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ec27c710888e63f3e91eef75cf8c33d21e3644c1
--- /dev/null
+++ b/rust/src-tauri/src/lib.rs
@@ -0,0 +1,276 @@
+// Error types module
+pub mod error;
+// Error printer module
+pub mod error_printer;
+// App configuration module
+pub mod app_config;
+// MDict app singleton module
+pub mod mdict_app;
+// Library manager module
+pub mod library_mgr;
+// Commands module - contains all Tauri command implementations (deprecated, use plugins instead)
+// Commented out to avoid conflicts with plugin commands
+// pub mod commands;
+// History management module
+pub mod history;
+// History commands plugin
+mod history_cmd;
+// Favorites management module
+pub mod favorites;
+// Favorites commands plugin
+mod favorites_cmd;
+// Config commands plugin
+mod config_cmd;
+// Library commands plugin
+mod library_cmd;
+// Conversion commands plugin
+mod conversion_cmd;
+// Search commands plugin
+mod search_cmd;
+// System commands plugin
+mod system_cmd;
+mod mdx_profile;
+mod mdx_db;
+mod mdx_db_group;
+mod request_handler;
+mod mdx_url_parser;
+mod action_handlers;
+// Hotkey manager and commands are only available on desktop platforms
+#[cfg(all(not(target_os = "android"), not(target_os = "ios"), feature = "global-hotkey"))]
+mod hotkey_manager;
+#[cfg(all(not(target_os = "android"), not(target_os = "ios"), feature = "global-hotkey"))]
+mod hotkey_cmd;
+mod utils;
+
+use humantime::format_rfc3339;
+use log::{LevelFilter, error, info, debug};
+use tauri::Manager;
+use tauri::http::{Response, StatusCode};
+
+use crate::utils::log_if_err;
+
+// Import all command functions
+use crate::config_cmd::*;
+use crate::conversion_cmd::*;
+use crate::favorites_cmd::*;
+use crate::history_cmd::*;
+#[cfg(all(not(target_os = "android"), not(target_os = "ios"), feature = "global-hotkey"))]
+use crate::hotkey_cmd::*;
+use crate::library_cmd::*;
+use crate::search_cmd::*;
+use crate::system_cmd::*;
+
+/// Macro to generate the invoke handler with all commands
+///
+/// This macro centralizes all command registration by including all command functions
+/// from all modules. When adding new commands, you need to:
+/// 1. Add the command function to the appropriate module
+/// 2. Add the command name to the module's COMMANDS array
+/// 3. Add the function name to this macro
+///
+/// The macro ensures that all commands are registered consistently and makes it
+/// easy to see all available commands in one place.
+macro_rules! generate_all_commands_handler {
+ () => {
+ tauri::generate_handler![
+ // Search commands
+ search_search_incremental,
+ search_get_content_url,
+ search_get_entry_count,
+ search_find_index,
+ search_fulltext_search,
+ search_get_result_key_list,
+ search_get_group_indexes,
+ // History commands
+ history_add_to_history,
+ history_get_all_history,
+ history_get_history_entry_by_id,
+ history_remove_from_history,
+ history_clear_history,
+ history_get_history_count,
+ history_set_max_history_size,
+ history_get_max_history_size,
+ history_import_history,
+ // Favorites commands
+ favorites_add_favorite,
+ favorites_remove_favorite,
+ favorites_toggle_favorite,
+ favorites_is_favorited,
+ favorites_get_sorted_and_filtered_favorites,
+ favorites_get_all_favorites,
+ favorites_clear_all_favorites,
+ favorites_import_favorites,
+ favorites_get_favorites_count,
+ // Config commands - Generic interface
+ config_get_app_config,
+ config_get_value,
+ config_set_value,
+ config_get_global_settings,
+ config_get_view_settings,
+ config_update_view_settings,
+ config_list_fonts_in_directory,
+ config_save_app_config,
+ config_reload_app_config,
+ config_reload_resources,
+ // Library commands
+ library_create_dict_group,
+ library_delete_dict_group,
+ library_rename_dict_group,
+ library_refresh_library,
+ library_get_group,
+ library_get_profile,
+ library_list_groups,
+ library_update_profile_disabled_status,
+ library_adjust_profile_order,
+ library_adjust_group_order,
+ library_open_main_database,
+ library_get_current_main_profile_id,
+ library_get_main_db_profile,
+ library_rebuild_index,
+ // Conversion commands
+ library_convert_db,
+ library_create_fts_index,
+ library_cancel_conversion,
+ // System commands
+ system_set_base_url,
+ // Hotkey commands (desktop only)
+ #[cfg(all(not(target_os = "android"), not(target_os = "ios"), feature = "global-hotkey"))]
+ hotkey_register,
+ #[cfg(all(not(target_os = "android"), not(target_os = "ios"), feature = "global-hotkey"))]
+ hotkey_unregister,
+ ]
+ };
+}
+
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+ unsafe { std::env::set_var("RUST_BACKTRACE", "1"); }
+
+ tauri::Builder::default()
+ .setup(|app| {
+ let app_handle = app.handle();
+ let data_dir = app_handle.path().app_data_dir().map_err(|e| e.to_string())?;
+
+ // Setup logging
+ fern::Dispatch::new()
+ .format(|out, message, record| {
+ out.finish(format_args!(
+ "[{} {} {}] {}",
+ format_rfc3339(std::time::SystemTime::now()),
+ record.level(),
+ record.target(),
+ message
+ ))
+ })
+ .level(LevelFilter::Debug)
+ .chain(std::io::stdout())
+ .apply().unwrap();
+
+ // Initialize main app (includes history and favorites managers)
+ log_if_err(&mdict_app::init_mdict_app(data_dir.clone(), Vec::new(), &app_handle));
+
+ // Setup window event handler for focus detection
+ let window = app.get_webview_window("main").expect("Failed to get main window");
+ let app_handle_clone = app_handle.clone();
+ window.on_window_event(move |event| {
+ if let tauri::WindowEvent::Focused(focused) = event {
+ if *focused {
+ info!("Window gained focus, notifying frontend");
+ // Emit event to frontend
+ // Frontend will check autoLookupSelection setting and handle clipboard accordingly
+ use tauri::Emitter;
+ if let Err(e) = app_handle_clone.emit("window-focus", ()) {
+ error!("Failed to emit window-focus event: {}", e);
+ }
+ }
+ }
+ });
+
+ // Initialize hotkey manager (desktop only)
+ #[cfg(all(not(target_os = "android"), not(target_os = "ios"), feature = "global-hotkey"))]
+ {
+ if let Err(e) = hotkey_manager::init_hotkey_manager(app_handle.clone()) {
+ error!("Failed to initialize hotkey manager: {}", e);
+ }
+
+ // Load hotkey configuration from settings
+ let app_handle_for_hotkey = app_handle.clone();
+ tauri::async_runtime::spawn(async move {
+ if let Ok(config) = mdict_app::with_config_read(|config| Ok(config.clone())) {
+ let hotkey_letter = config.global_settings.get("hotkey_letter")
+ .and_then(|v| v.as_str())
+ .unwrap_or("");
+ let hotkey_modifier = config.global_settings.get("hotkey_modifier")
+ .and_then(|v| v.as_str())
+ .unwrap_or("");
+
+ if !hotkey_letter.is_empty() && !hotkey_modifier.is_empty() {
+ info!("Registering hotkey from config: {} + {}", hotkey_modifier, hotkey_letter);
+ if let Err(e) = hotkey_manager::register_hotkey(app_handle_for_hotkey, hotkey_letter, hotkey_modifier) {
+ error!("Failed to register hotkey on startup: {}", e);
+ }
+ } else {
+ info!("No hotkey configured");
+ }
+ }
+ });
+
+ // Spawn a task to check for hotkey events periodically
+ let _hotkey_task = std::thread::spawn(move || {
+ loop {
+ hotkey_manager::check_hotkey_events();
+ std::thread::sleep(std::time::Duration::from_millis(100));
+ }
+ });
+ }
+
+ Ok(())
+ })
+ // Register protocol scheme based on platform
+ // Windows: use "http" scheme
+ // Non-Windows (macOS, Linux): use "mdx" scheme
+ .register_asynchronous_uri_scheme_protocol(
+ #[cfg(target_os = "windows")]
+ "http",
+ #[cfg(not(target_os = "windows"))]
+ "mdx",
+ |_app, request, responder| {
+ tauri::async_runtime::spawn(async move {
+ let uri = request.uri().to_string();
+
+ // Check if the request matches the configured base_url
+ // Only handle requests that start with base_url, otherwise let webview handle them
+ let base_url = mdict_app::with_read_access(|app| {
+ Ok(app.get_base_url().to_string())
+ }).unwrap_or("mdx://mdict.cn/service/".to_string());
+
+ if !uri.starts_with(&base_url.replace("http.localhost", "localhost")) {
+ if uri.contains("/service/") {
+ debug!("Request does not match base_url, skipping: {}", uri);
+ }
+ return;
+ }
+
+ // Handle the request using our custom handler
+ match request_handler::handle_request(&request, &base_url) {
+ Ok(response) => responder.respond(response),
+ Err(err) => {
+ error!("Error in protocol handler: {}", err);
+ let error_html = format!("Protocol Error
{}
", err);
+ let mut error_response = Response::new(error_html.into_bytes());
+ *error_response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ error_response.headers_mut().insert("Content-Type", "text/html; charset=utf-8".parse().unwrap());
+ responder.respond(error_response);
+ }
+ }
+ });
+ }
+ )
+ .plugin(tauri_plugin_opener::init())
+ .plugin(tauri_plugin_dialog::init())
+ .plugin(tauri_plugin_clipboard_manager::init())
+ .invoke_handler(generate_all_commands_handler!())
+ .run(tauri::generate_context!())
+ .expect("error while running tauri application");
+}
\ No newline at end of file
diff --git a/rust/src-tauri/src/library_cmd.rs b/rust/src-tauri/src/library_cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..082c57797547f1dd8106e0260266a59abf348993
--- /dev/null
+++ b/rust/src-tauri/src/library_cmd.rs
@@ -0,0 +1,257 @@
+// Library commands module - Tauri command implementations for library and group management
+use serde::{Deserialize, Serialize};
+use tauri::command;
+
+use crate::error::{IntoStringResult, ZdbError};
+use crate::mdict_app::{with_read_access, with_write_access};
+use crate::mdx_profile::ProfileId;
+
+/// Collation options for rebuilding index
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CollationOptions {
+ pub language: String,
+ pub collation_type: Option,
+ pub strength: String,
+ pub alternate_handling: String,
+ pub case_level: String,
+ pub case_first: String,
+}
+
+/// Create a dictionary group
+#[command]
+pub async fn library_create_dict_group(group_name: String) -> std::result::Result {
+ with_write_access(|app| {
+ let group = app.library_manager.create_group(group_name);
+ let group_id = group.profile_id;
+ // Save to file
+ app.library_manager.save_library()?;
+ Ok(group_id)
+ }).into_string_result()
+}
+
+/// Delete a dictionary group
+#[command]
+pub async fn library_delete_dict_group(group_id: ProfileId) -> std::result::Result {
+ with_write_access(|app| {
+ if app.library_manager.remove_profile(group_id) {
+ app.library_manager.save_library()?;
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+ }).into_string_result()
+}
+
+/// Rename a dictionary group
+#[command]
+pub async fn library_rename_dict_group(group_id: ProfileId, new_name: String) -> std::result::Result<(), String> {
+ with_write_access(|app| {
+ if let Some(profile) = app.library_manager.get_group_mut(group_id) {
+ profile.title = new_name;
+ // Save to file
+ app.library_manager.save_library()?;
+ Ok(())
+ } else {
+ Err(ZdbError::invalid_parameter("配置文件或组不存在".to_string()))
+ }
+ }).into_string_result()
+}
+
+/// Scan dictionary directory
+#[command]
+pub async fn library_refresh_library() -> std::result::Result<(), String> {
+ with_write_access(|app| {
+ let search_paths = app.get_lib_search_paths()?.to_vec();
+ app.library_manager.refresh_library(&search_paths)?;
+ Ok(())
+ }).into_string_result()
+}
+
+/// Get group for a given group_id
+#[command]
+pub async fn library_get_group(group_id: ProfileId) -> std::result::Result {
+ with_read_access(|app| {
+ if let Some(group) = app.library_manager.get_group(group_id) {
+ let group_value = serde_json::to_value(group)
+ .map_err(|e| ZdbError::invalid_data_format(e.to_string()))?;
+ Ok(group_value)
+ } else {
+ Err(ZdbError::invalid_parameter("词典组不存在".to_string()))
+ }
+ }).into_string_result()
+}
+
+/// Get profile for a given group_id and profile_id
+#[command]
+pub async fn library_get_profile(parent_group_id: ProfileId, profile_id: ProfileId) -> std::result::Result {
+ with_read_access(|app| {
+ if let Some(profile) = app.library_manager.get_profile(parent_group_id, profile_id) {
+ let profile_value = serde_json::to_value(profile)
+ .map_err(|e| ZdbError::invalid_data_format(e.to_string()))?;
+ Ok(profile_value)
+ } else {
+ Err(ZdbError::invalid_parameter("词典不存在".to_string()))
+ }
+ }).into_string_result()
+}
+
+/// List all dictionary groups
+#[command]
+pub async fn library_list_groups() -> std::result::Result {
+ with_read_access(|app| {
+ // Get current main profile ID from main_db
+ let current_main_profile_id = app.get_current_main_profile_id()?;
+
+ let groups = app.library_manager.get_groups();
+ let mut enhanced_groups = Vec::new();
+
+ for group in groups.iter() {
+ let mut group_value = serde_json::to_value(group)
+ .map_err(|e| ZdbError::invalid_data_format(e.to_string()))?;
+
+ // Add is_active flag based on current main profile
+ if let Some(obj) = group_value.as_object_mut() {
+ obj.insert("isActive".to_string(),
+ serde_json::Value::Bool(group.profile_id == current_main_profile_id));
+ }
+ enhanced_groups.push(group_value);
+ }
+
+ Ok(serde_json::Value::Array(enhanced_groups))
+ }).into_string_result()
+}
+
+/// Update profile disabled status
+#[command]
+pub async fn library_update_profile_disabled_status(
+ parent_group_id: ProfileId,
+ profile_id: ProfileId,
+ disabled: bool
+) -> std::result::Result<(), String> {
+ with_write_access(|app| {
+ if let Some(group) = app.library_manager.get_group_mut(parent_group_id) {
+ if let Some(profile) = group.get_profile_mut(profile_id) {
+ profile.disabled = disabled;
+ // Save to file
+ app.library_manager.save_library()?;
+ Ok(())
+ } else {
+ Err(ZdbError::invalid_parameter("词典配置不存在".to_string()))
+ }
+ } else {
+ Err(ZdbError::invalid_parameter("词典组不存在".to_string()))
+ }
+ }).into_string_result()
+}
+
+/// Adjust profile order within a group
+#[command]
+pub async fn library_adjust_profile_order(
+ parent_group_id: ProfileId,
+ profile_id: ProfileId,
+ new_index: usize
+) -> std::result::Result<(), String> {
+ with_write_access(|app| {
+ app.library_manager.adjust_profile_order(parent_group_id, profile_id, new_index);
+ // Save to file
+ app.library_manager.save_library()?;
+ Ok(())
+ }).into_string_result()
+}
+
+/// Adjust group order
+#[command]
+pub async fn library_adjust_group_order(group_id: ProfileId, new_index: usize) -> std::result::Result<(), String> {
+ with_write_access(|app| {
+ app.library_manager.adjust_group_order(group_id, new_index);
+ // Save to file
+ app.library_manager.save_library()?;
+ Ok(())
+ }).into_string_result()
+}
+
+/// Open main database with the given profile
+#[command]
+pub async fn library_open_main_database(profile_id: ProfileId) -> std::result::Result<(), String> {
+ with_write_access(|app| app.open_main_db(profile_id)).into_string_result()
+}
+
+/// Get current main profile ID
+#[command]
+pub async fn library_get_current_main_profile_id() -> std::result::Result {
+ with_read_access(|app| app.get_current_main_profile_id()).into_string_result()
+}
+
+/// Get main database profile (complete object)
+#[command]
+pub async fn library_get_main_db_profile() -> std::result::Result, String> {
+ with_read_access(|app| {
+ match app.get_current_main_profile()? {
+ Some(profile) => {
+ let profile_json = serde_json::to_value(profile)
+ .map_err(|e| ZdbError::invalid_data_format(format!("Failed to serialize profile: {}", e)))?;
+ Ok(Some(profile_json))
+ },
+ None => Ok(None)
+ }
+ }).into_string_result()
+}
+
+/// Rebuild dictionary index with collation options
+#[command]
+pub async fn library_rebuild_index(
+ profile_id: ProfileId,
+ options: CollationOptions
+) -> std::result::Result<(), String> {
+ with_write_access(|_app| {
+ log::info!("Rebuilding index for profile {} with options: {:?}", profile_id, options);
+
+ // Build BCP 47 locale string with collation extensions
+ let mut locale_str = options.language.clone();
+
+ // Add Unicode extension for collation
+ let mut extensions = vec![];
+
+ // Collation type (e.g., pinyin, stroke, traditional)
+ if let Some(ref collation_type) = options.collation_type {
+ if collation_type != "standard" {
+ extensions.push(format!("co-{}", collation_type));
+ }
+ }
+
+ // Strength level (ks = collation strength)
+ let strength = match options.strength.as_str() {
+ "level1" => "level1",
+ "level2" => "level2",
+ "level3" => "level3",
+ "level4" => "level4",
+ _ => "level1",
+ };
+ extensions.push(format!("ks-{}", strength));
+
+ // Alternate handling (ka = alternate handling)
+ if options.alternate_handling == "shifted" {
+ extensions.push("ka-shifted".to_string());
+ }
+
+ // Case level (kc = case level)
+ if options.case_level == "true" {
+ extensions.push("kc-true".to_string());
+ }
+
+ // Case first (kf = case first)
+ if options.case_first != "off" {
+ extensions.push(format!("kf-{}", options.case_first));
+ }
+
+ if !extensions.is_empty() {
+ locale_str.push_str("-u-");
+ locale_str.push_str(&extensions.join("-"));
+ }
+
+ log::info!("Generated BCP 47 locale string: {}", locale_str);
+ Ok(())
+ }).into_string_result()
+}
+
diff --git a/rust/src-tauri/src/library_mgr.rs b/rust/src-tauri/src/library_mgr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6b698734ea252d0e87bac36868604af549ec38cd
--- /dev/null
+++ b/rust/src-tauri/src/library_mgr.rs
@@ -0,0 +1,390 @@
+use std::collections::{LinkedList, HashMap};
+use std::path::{Path, PathBuf};
+use mime_guess::MimeGuess;
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+use mdx::ZdbError;
+use mdx::utils::{scan_dir, get_decoded_path, replace_url_path, with_extension};
+
+use crate::error::Result;
+use crate::mdx_profile::{self, MdxOptions, MdxProfile, ProfileId, DEFAULT_GROUP_ID};
+
+/// MDX库管理器
+/// 基于mdx_manager的简化版本
+#[derive(Deserialize, Serialize)]
+pub struct LibraryManager {
+ mdx_groups: LinkedList,
+ /// 默认MDX选项
+ #[serde(skip)]
+ default_mdx_options: MdxOptions,
+
+ #[serde(skip)]
+ library_file_path: String,
+
+ #[serde(skip)]
+ icon_cache: HashMap, String)>,
+}
+
+impl LibraryManager {
+ pub fn new() -> Self {
+ let mut manager = Self {
+ mdx_groups: LinkedList::new(),
+ default_mdx_options: MdxOptions::default(),
+ library_file_path: String::new(),
+ icon_cache: HashMap::new(),
+ };
+ manager.ensure_default_group();
+ manager
+ }
+
+ pub fn get_next_profile_id(&self) -> ProfileId {
+ let mut ids = Vec::new();
+ for group in &self.mdx_groups {
+ ids.push(group.profile_id);
+ if let Some(profiles) = &group.profiles {
+ for profile in profiles {
+ ids.push(profile.profile_id);
+ }
+ }
+ }
+ let max_id = ids.into_iter().max().unwrap_or(0);
+ max_id + 1
+ }
+
+ /// Ensure the default "All" group exists
+ fn ensure_default_group(&mut self) {
+ // Check if the default group already exists
+ if self.get_group(DEFAULT_GROUP_ID).is_none() {
+ let root_group = MdxProfile::new_group("All databases".to_string(), DEFAULT_GROUP_ID);
+ self.replace_group_profile(&root_group);
+ }
+ }
+
+ /// 通过profile_id查找任意profile（可能是group或individual profile）
+ pub fn find_profile(&self, profile_id: ProfileId) -> Option<&MdxProfile> {
+ // First try to find it in groups
+ if let Some(group) = self.mdx_groups.iter().find(|p| p.profile_id == profile_id) {
+ return Some(group);
+ }
+ //If profile_id can't be found in groups, then only try find it in default group
+ return self.mdx_groups.iter().find(|p| p.profile_id == DEFAULT_GROUP_ID).and_then(|g| g.get_profile(profile_id));
+ }
+
+ pub fn get_groups(&self) -> &LinkedList {
+ &self.mdx_groups
+ }
+
+ /// 获取组（向后兼容）
+ pub fn get_group(&self, group_id: ProfileId) -> Option<&MdxProfile> {
+ self.find_profile(group_id).filter(|p| p.is_group())
+ }
+
+ /// 获取可变组（向后兼容）
+ pub fn get_group_mut(&mut self, group_id: ProfileId) -> Option<&mut MdxProfile> {
+ // 直接在顶级groups中查找，避免调用find_profile_mut造成递归
+ self.mdx_groups.iter_mut().find(|p| p.profile_id == group_id && p.is_group())
+ }
+
+ /// 获取配置文件（在指定group中查找）
+ pub fn get_profile(&self, parent_group_id: ProfileId, profile_id: ProfileId) -> Option<&MdxProfile> {
+ self.get_group(parent_group_id)?.get_profile(profile_id)
+ }
+
+ /// 创建新组
+ pub fn create_group(&mut self, title: String) -> MdxProfile {
+ let mut new_group = MdxProfile::new_group(title, self.get_next_profile_id());
+ new_group.options = self.default_mdx_options.clone();
+ if let Some(default_group) = self.get_group(DEFAULT_GROUP_ID) {
+ if let Some(profiles) = &default_group.profiles {
+ new_group.profiles = Some(profiles.clone());
+ }
+ }
+ self.replace_group_profile(&new_group);
+ new_group
+ }
+
+ /// 移除profile或group
+ pub fn remove_profile(&mut self, profile_id: ProfileId) -> bool {
+ // 尝试从顶级groups中移除
+ let original_len = self.mdx_groups.len();
+ let mut new_groups = LinkedList::new();
+ while let Some(group) = self.mdx_groups.pop_front() {
+ if group.profile_id != profile_id {
+ new_groups.push_back(group);
+ }
+ }
+ self.mdx_groups = new_groups;
+
+ if self.mdx_groups.len() != original_len {
+ return true;
+ }
+
+ // 如果没在顶级找到，在各group的子profiles中查找
+ for group in &mut self.mdx_groups {
+ if let Some(profiles) = &mut group.profiles {
+ let original_len = profiles.len();
+ let mut new_profiles = LinkedList::new();
+ while let Some(profile) = profiles.pop_front() {
+ if profile.profile_id != profile_id {
+ new_profiles.push_back(profile);
+ }
+ }
+ *profiles = new_profiles;
+ if profiles.len() != original_len {
+ return true;
+ }
+ }
+ }
+ false
+ }
+
+ /// 移除组（向后兼容）
+ pub fn remove_group(&mut self, group_id: ProfileId) -> bool {
+ self.remove_profile(group_id)
+ }
+
+ pub fn adjust_profile_order(&mut self, parent_group_id: ProfileId, profile_id: ProfileId, new_index: usize) {
+ if let Some(group) = self.get_group_mut(parent_group_id) {
+ group.adjust_profile_order(profile_id, new_index);
+ }
+ }
+
+ /// 调整组的顺序
+ pub fn adjust_group_order(&mut self, group_id: ProfileId, new_index: usize) {
+ // 找到要移动的组
+ let mut target_group = None;
+ let mut new_groups = LinkedList::new();
+
+ // 先移除目标组
+ while let Some(group) = self.mdx_groups.pop_front() {
+ if group.profile_id == group_id {
+ target_group = Some(group);
+ } else {
+ new_groups.push_back(group);
+ }
+ }
+
+ // 如果找到了目标组，将其插入到新位置
+ if let Some(group) = target_group {
+ let mut final_groups = LinkedList::new();
+ let mut current_index = 0;
+
+ // 先添加新位置之前的组
+ while let Some(g) = new_groups.pop_front() {
+ if current_index == new_index {
+ final_groups.push_back(group.clone());
+ }
+ final_groups.push_back(g);
+ current_index += 1;
+ }
+
+ // 如果新位置在最后，添加目标组
+ if current_index <= new_index {
+ final_groups.push_back(group);
+ }
+
+ self.mdx_groups = final_groups;
+ } else {
+ // 如果没找到目标组，恢复原状态
+ self.mdx_groups = new_groups;
+ }
+ }
+
+ // Replace the existing group profile with the same profile_id, or add a new one if not found.
+ pub fn replace_group_profile(&mut self, group_profile: &MdxProfile) {
+ let profile_id = group_profile.profile_id;
+
+ if let Some(existing_profile) = self.mdx_groups.iter_mut().find(|p| p.profile_id == profile_id) {
+ *existing_profile = group_profile.clone();
+ } else {
+ self.mdx_groups.push_back(group_profile.clone());
+ }
+ }
+
+ // scan the directory url to find all "*.mdx" files recursively
+ // create a new mdx_group with profile_id is DEFAULT_GROUP_ID, and generate every mdx file into a MdxProfile, and add it to this mdx_group object
+ pub fn scan_dir(&self, dir_url: &Url) -> std::result::Result {
+ let mut mdx_group = MdxProfile::new_group("Scanned".to_string(), DEFAULT_GROUP_ID);
+ // Match .mdx files (case-insensitive) that don't start with a dot
+ let pattern = Regex::new(r"(?i)^[^.].*\.mdx$").map_err(|e| ZdbError::invalid_parameter(format!("Regex pattern error: {}", e)))?;
+ let mut files = LinkedList::::new();
+ let target_path = get_decoded_path(dir_url)?;
+ log::info!("scan_dir: {:?}", target_path);
+ scan_dir(&target_path, &pattern, true, &mut files)?;
+
+ let base_url= dir_url.clone();
+ let mut temp_id = 1000; // Use temporary IDs for scanning, will be replaced during merge
+ for file_path in files {
+ let mdx_file_url = replace_url_path(&base_url, &file_path)?;
+ let mut mdx_profile= MdxProfile::new(mdx_file_url.to_string(), mdx_profile::INVALID_PROFILE_ID, false);
+ mdx_profile.options = self.default_mdx_options.clone();
+ mdx_group.replace_profile(&mdx_profile, temp_id);
+ temp_id += 1;
+ }
+ Ok(mdx_group)
+ }
+ /// 扫描词典目录并更新MDX管理器
+ pub fn scan_directories(&self, search_paths: &[String]) -> Result {
+ let mut mdx_group = MdxProfile::new_group("Scanned Directories".to_string(), DEFAULT_GROUP_ID);
+ for search_path in search_paths {
+ let url = Url::from_file_path(search_path)
+ .map_err(|_| ZdbError::invalid_parameter(format!("无效的目录路径: {}", search_path)))?;
+ let new_group = self.scan_dir(&url)?;
+ if let Some(new_profiles) = new_group.profiles {
+ if mdx_group.profiles.is_none() {
+ mdx_group.profiles = Some(LinkedList::new());
+ }
+ mdx_group.profiles.as_mut().unwrap().extend(new_profiles);
+ }
+ }
+ Ok(mdx_group)
+ }
+
+ /// Merge profiles from source_group into target_group by URL
+ /// Keeps profiles that exist in source_group, adds new ones, and removes profiles not in source_group
+ ///
+ /// # Arguments
+ /// * `target_group` - The group to merge into
+ /// * `source_group` - The group to merge from
+ /// * `next_id` - Starting ID for new profiles, will be incremented for each new profile added
+ fn merge_profiles_by_url(&self, target_group: &mut MdxProfile, source_group: &MdxProfile, next_id: &mut ProfileId) {
+ if let Some(source_profiles) = &source_group.profiles {
+ if target_group.profiles.is_none() {
+ target_group.profiles = Some(LinkedList::new());
+ }
+
+ let mut new_merged_profiles = LinkedList::new();
+ let current_profiles = target_group.profiles.as_ref().unwrap();
+
+ // Iterate through source_group's profiles to build the new merged list
+ for source_profile in source_profiles.iter() {
+ // Check if this profile exists in current profiles
+ if let Some(existing_profile) = current_profiles.iter().find(|p| p.url == source_profile.url) {
+ // Keep the existing profile (preserve its profile_id and other settings)
+ new_merged_profiles.push_back(existing_profile.clone());
+ } else {
+ // Add new profile from source_group with a globally unique profile_id
+ let mut new_profile = source_profile.clone();
+ new_profile.profile_id = *next_id;
+ *next_id += 1; // Increment for next new profile
+ new_merged_profiles.push_back(new_profile);
+ }
+ }
+
+ // Replace the current profiles with the merged list
+ target_group.profiles = Some(new_merged_profiles);
+ } else {
+ // If source_group has no profiles, clear all profiles from target_group
+ target_group.profiles = Some(LinkedList::new());
+ }
+ }
+
+ pub fn refresh_library(&mut self, search_paths:&[String])->Result<()> {
+ let new_group = self.scan_directories(search_paths)?;
+
+ // Get the next available ID before we start modifying groups
+ let mut next_id = self.get_next_profile_id();
+
+ // Clone the groups to avoid borrow checker issues
+ let mut updated_groups = LinkedList::new();
+ while let Some(mut group) = self.mdx_groups.pop_front() {
+ log::info!("group id: {}, title: {}", group.profile_id, group.title);
+ self.merge_profiles_by_url(&mut group, &new_group, &mut next_id);
+ updated_groups.push_back(group);
+ }
+ self.mdx_groups = updated_groups;
+
+ for profile in self.mdx_groups.front().unwrap().profiles.as_ref().unwrap().iter() {
+ log::info!("profile id: {}, title: {}", profile.profile_id, profile.title);
+ }
+ Ok(())
+ }
+
+ pub fn from_file>(file_path: P) -> std::result::Result {
+ let mut manager = if file_path.as_ref().exists() {
+ let json = std::fs::read_to_string(&file_path)?;
+ if !json.is_empty() {
+ Self::from_json(&json)?
+ } else {
+ Self::new()
+ }
+ }else{
+ Self::new()
+ };
+
+ // Ensure the default group exists regardless of how the manager was created
+ manager.ensure_default_group();
+ manager.library_file_path = file_path.as_ref().to_string_lossy().to_string();
+ Ok(manager)
+ }
+
+ pub fn save_library(&self) -> Result<()> {
+ self.to_file(&self.library_file_path)?;
+ Ok(())
+ }
+
+ pub fn to_file>(&self, file_path: P) -> std::result::Result<(), ZdbError> {
+ let json = self.to_json()?;
+ std::fs::write(file_path, json)?;
+ Ok(())
+ }
+
+ pub fn from_json(json: &str) -> std::result::Result {
+ let mdx_groups: LinkedList = serde_json::from_str(json)?;
+ let mut manager = Self {
+ mdx_groups,
+ default_mdx_options: MdxOptions::default(),
+ library_file_path: String::new(),
+ icon_cache: HashMap::new(),
+ };
+
+ // Ensure the default "All" group exists
+ manager.ensure_default_group();
+
+ Ok(manager)
+ }
+
+ pub fn to_json(&self) -> std::result::Result {
+ let json = serde_json::to_string(&self.mdx_groups)?;
+ Ok(json)
+ }
+
+ pub fn get_icon_for_profile(&mut self, profile_id: ProfileId) -> Result, String)>> {
+ let profile = self.find_profile(profile_id).ok_or_else(|| ZdbError::invalid_parameter(format!("Profile {} not found", profile_id)))?;
+ let icon_data = self.icon_cache.get(&profile_id);
+ if icon_data.is_none() {
+ let data = load_logo_for_profile(profile)?;
+ if !data.0.is_empty() {
+ self.icon_cache.insert(profile_id, data.clone());
+ }
+ return Ok(Some(data.clone()));
+ }
+ Ok(None)
+ }
+}
+
+impl Default for LibraryManager {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+fn load_logo_for_profile(profile: &MdxProfile) -> Result<(Vec, String)> {
+ const LOGO_EXTENSIONS: &[&str] = &["png", "jpg", "jpeg", "gif", "bmp", "tiff", "ico", "webp"];
+
+ // First try to load logo from the same directory as the MDX file
+ let db_url = Url::parse(&profile.url)?;
+ // Fallback: try to find DictIcon.* in the root
+ for &ext in LOGO_EXTENSIONS {
+ // Build a resource url path like file:///DictIcon.png
+ let logo_url = with_extension(&db_url, ext)?;
+ let logo_path = logo_url.to_file_path().map_err(|_| ZdbError::invalid_parameter(format!("Invalid logo url: {}", &logo_url)))?;
+ if logo_path.is_file() && logo_path.exists() {
+ let logo_bytes=std::fs::read(logo_path)?;
+ return Ok((logo_bytes, MimeGuess::from_ext(ext).first_or_octet_stream().to_string()));
+ }
+ }
+ Ok((Vec::new(), String::new()))
+}
\ No newline at end of file
diff --git a/rust/src-tauri/src/main.rs b/rust/src-tauri/src/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..eaf0db04d21bfb15ca0a0139c81a2c510cc51ce7
--- /dev/null
+++ b/rust/src-tauri/src/main.rs
@@ -0,0 +1,7 @@
+// Prevents additional console window on Windows in release, DO NOT REMOVE!!
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use mdict_app_lib;
+fn main() {
+ mdict_app_lib::run()
+}
diff --git a/rust/src-tauri/src/mdict_app.rs b/rust/src-tauri/src/mdict_app.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f04273f51cf87ee0e09e7b955a31a614d8aad859
--- /dev/null
+++ b/rust/src-tauri/src/mdict_app.rs
@@ -0,0 +1,849 @@
+use std::path::Path;
+use std::sync::{RwLock, Arc, Mutex};
+use std::collections::{HashMap, LinkedList};
+use once_cell::sync::OnceCell;
+use rusqlite::Connection;
+use tauri::{Manager, path::BaseDirectory, Emitter};
+
+use mdx::storage::EntryNo;
+use mdx::utils::fix_windows_path_buf;
+
+use crate::app_config::{AppConfig, ConfigSection, ConfigKey};
+use crate::error::{Result, ZdbError};
+use crate::favorites::FavoritesManager;
+use crate::history::HistoryManager;
+use crate::library_mgr::LibraryManager;
+use crate::mdx_db::{MdxIndex, MdxDb};
+use crate::mdx_db_group::{MdxDbGroup, MdxGroupIndex};
+use crate::mdx_profile::{ProfileId, DEFAULT_GROUP_ID, INVALID_PROFILE_ID, MdxProfile};
+use crate::utils::log_if_err;
+pub enum DbType {
+ MdxDb(MdxDb),
+ MdxDbGroup(MdxDbGroup),
+}
+
+/// MDict应用全局单例结构体
+/// 参考libmdx中的MDictApp实现
+pub struct MdictApp {
+ /// 应用配置
+ pub config: AppConfig,
+ /// 库管理器
+ pub library_manager: LibraryManager,
+ /// 统一数据库连接池 (shared by history and favorites managers)
+ /// Kept for managing database connection lifecycle
+ #[allow(dead_code)]
+ db_connection: Arc>,
+ /// 历史记录管理器
+ pub history_manager: HistoryManager,
+ /// 收藏管理器
+ pub favorites_manager: FavoritesManager,
+ /// 主数据库
+ pub main_db: Option,
+
+ /// Tauri app handle for emitting events
+ app_handle: tauri::AppHandle,
+
+ /// 程序数据根目录
+ data_home_dir: String,
+ /// 文档目录
+ _doc_dir: String,
+ /// 资源目录
+ _res_dir: String,
+ /// 字体目录
+ _font_dir: String,
+ /// 音频库目录
+ _audio_lib_dir: String,
+ /// 临时文件目录
+ tmp_dir: String,
+
+ /// 库搜索路径列表
+ lib_search_paths: Vec,
+
+ /// Cached search results for group mode (normalized_key, display_key, group_indexes)
+ group_search_results: LinkedList<(String, String, LinkedList)>,
+ /// Asset files loaded into memory (filename -> content)
+ assets: HashMap>,
+
+ base_url: String,
+
+}
+
+// SAFETY: MdictApp is protected by RwLock, and we ensure single-threaded access to MDX readers
+unsafe impl Send for MdictApp {}
+unsafe impl Sync for MdictApp {}
+
+impl MdictApp {
+
+ /// 使用主目录初始化应用
+ pub fn init_app_with_home_dir>(
+ data_home_dir: P,
+ extra_search_paths: Vec,
+ app_handle: &tauri::AppHandle
+ ) -> Result {
+
+ let home_dir = fix_windows_path_buf(data_home_dir.as_ref().to_path_buf()).to_string_lossy().into_owned();
+ log::info!("init_app_with_home_dir: {:?}", home_dir);
+ let doc_dir = format!("{}/doc", home_dir);
+ let audio_lib_dir = format!("{}/audiolib", home_dir);
+ let font_dir = format!("{}/fonts", home_dir);
+ let res_dir = format!("{}/res", home_dir);
+ let tmp_dir = format!("{}/tmp", home_dir);
+
+ Self::init_app(home_dir, doc_dir, audio_lib_dir, font_dir, res_dir, tmp_dir, extra_search_paths, app_handle)
+ }
+
+ /// 初始化应用
+ pub fn init_app(
+ data_home_dir: String,
+ doc_dir: String,
+ audio_lib_dir: String,
+ font_dir: String,
+ res_dir: String,
+ tmp_dir: String,
+ extra_search_paths: Vec,
+ app_handle: &tauri::AppHandle,
+ ) -> Result {
+ let data_home_dir = Self::normalize_dir_path(data_home_dir);
+ let doc_dir = Self::normalize_dir_path(doc_dir);
+ let audio_lib_dir = Self::normalize_dir_path(audio_lib_dir);
+ let font_dir = Self::normalize_dir_path(font_dir);
+ let res_dir = Self::normalize_dir_path(res_dir);
+ let tmp_dir = Self::normalize_dir_path(tmp_dir);
+
+ // 默认添加doc目录到搜索路径
+ let mut lib_search_paths = Vec::new();
+ lib_search_paths.push(doc_dir.clone());
+ lib_search_paths.extend(extra_search_paths);
+
+ let dirs = [
+ &doc_dir,
+ &tmp_dir,
+ &audio_lib_dir,
+ &font_dir,
+ ];
+ // 创建必要的目录
+ Self::create_directories(&dirs)?;
+
+ // 清理临时文件
+ Self::cleanup_tmp(&tmp_dir)?;
+
+ let config_file_path = doc_dir.clone() + "/config.json";
+ let config = AppConfig::new(&config_file_path)?;
+
+ // 加载词典列表
+ let extra_library_path = config.get_config_with_default(ConfigSection::Global, ConfigKey::ExtraLibSearchPath, String::new());
+ if !extra_library_path.is_empty() {
+ lib_search_paths.push(extra_library_path);
+ }
+ let library_file_path = doc_dir.clone() + "/library.json";
+ let mut library_manager = LibraryManager::from_file(&library_file_path)?;
+
+ // 自动扫描词典目录变化
+ library_manager.refresh_library(&lib_search_paths)?;
+ library_manager.save_library()?;
+
+ // Initialize unified database connection with mdict.db
+ let mdict_db_path = format!("{}mdict.db", doc_dir);
+ let conn = Connection::open(&mdict_db_path)
+ .map_err(|e| ZdbError::invalid_data_format(format!("Failed to open database: {}", e)))?;
+
+ // Enable WAL mode for better concurrent access (ignore error for compatibility)
+ let _ = conn.query_row("PRAGMA journal_mode=WAL", [], |_| Ok(()));
+
+ // Set busy timeout to handle lock contention
+ let _ = conn.query_row("PRAGMA busy_timeout=5000", [], |_| Ok(()));
+
+ let db_connection = Arc::new(Mutex::new(conn));
+
+ // Initialize history and favorites managers with shared connection
+ let history_manager = HistoryManager::new(db_connection.clone())?;
+ let favorites_manager = FavoritesManager::new(db_connection.clone())?;
+
+ let mut app = Self {
+ config,
+ library_manager,
+ db_connection,
+ history_manager,
+ favorites_manager,
+ data_home_dir,
+ _doc_dir: doc_dir,
+ tmp_dir,
+ _res_dir: res_dir,
+ _font_dir: font_dir,
+ _audio_lib_dir: audio_lib_dir,
+ lib_search_paths,
+ main_db: None,
+ group_search_results: LinkedList::new(),
+ assets: HashMap::new(),
+ app_handle: app_handle.clone(),
+ base_url: "mdx://mdict.cn/service/".to_string(),
+ };
+
+ // Load asset files into memory
+ app.load_assets(app_handle)?;
+
+ // Auto-open last used profile or default group
+ log_if_err(&app.auto_open_startup_profile());
+ Ok(app)
+ }
+
+ /// 规范化目录路径，确保以/结尾
+ fn normalize_dir_path(mut path: String) -> String {
+ if !path.is_empty() && !path.ends_with('/') && !path.ends_with('\\') {
+ path.push('/');
+ }
+ path
+ }
+
+ /// 创建必要的目录
+ fn create_directories(dirs: &[&String]) -> Result<()> {
+ for dir in dirs.iter() {
+ if !dir.is_empty() && !std::path::Path::new(dir).exists() {
+ std::fs::create_dir_all(dir)?;
+ }
+ }
+
+ Ok(())
+ }
+
+ /// 清理临时文件
+ fn cleanup_tmp(tmp_dir: &String) -> Result<()> {
+ if !tmp_dir.is_empty() && std::path::Path::new(&tmp_dir).exists() {
+ if let Ok(entries) = std::fs::read_dir(&tmp_dir) {
+ for entry in entries.flatten() {
+ let _ = std::fs::remove_file(entry.path());
+ }
+ }
+ }
+ Ok(())
+ }
+
+ /// 加载assets目录下的文件到内存
+ fn load_assets(&mut self, app_handle: &tauri::AppHandle) -> Result<()> {
+ // 使用tauri的路径解析来获取assets目录
+ let assets_dir = match app_handle.path().resolve("assets", BaseDirectory::Resource) {
+ Ok(path) => path,
+ Err(_) => {
+ // 如果无法解析resource目录，回退到传统方法
+ let fallback_dir = if let Ok(exe_path) = std::env::current_exe() {
+ if let Some(exe_dir) = exe_path.parent() {
+ exe_dir.join("assets")
+ } else {
+ std::path::PathBuf::from("assets")
+ }
+ } else {
+ std::path::PathBuf::from("assets")
+ };
+
+ // 如果回退目录也不存在，尝试开发环境路径
+ if !fallback_dir.exists() {
+ let dev_assets_dir = std::path::PathBuf::from("src-tauri/assets");
+ if dev_assets_dir.exists() {
+ dev_assets_dir
+ } else {
+ return Err(ZdbError::invalid_parameter(format!("Assets directory not found: {:?}", fallback_dir)));
+ }
+ } else {
+ fallback_dir
+ }
+ }
+ };
+
+ // 确保assets目录存在
+ if assets_dir.exists() {
+ // 递归读取目录下的所有文件
+ self.load_assets_recursive(&assets_dir, &assets_dir)?;
+ log::info!("Loaded {} assets from {:?}", self.assets.len(), assets_dir);
+ }else{
+ log::warn!("Assets directory not found: {:?}", assets_dir);
+ }
+ Ok(())
+ }
+
+ /// 递归加载assets目录下的文件
+ fn load_assets_recursive(&mut self, current_dir: &std::path::Path, assets_root: &std::path::Path) -> Result<()> {
+ let entries = std::fs::read_dir(current_dir)?;
+
+ for entry in entries {
+ let entry = entry?;
+ let file_path = entry.path();
+
+ if file_path.is_file() {
+ // 计算相对于assets根目录的路径
+ let relative_path = file_path.strip_prefix(assets_root)
+ .map_err(|_| ZdbError::invalid_parameter(format!("无法计算相对路径: {:?}", file_path)))?;
+
+ match std::fs::read(&file_path) {
+ Ok(content) => {
+ // 使用包含完整相对路径的key格式，例如"/subdir/file.html"
+ let asset_key = format!("/{}", relative_path.to_string_lossy().replace('\\', "/"));
+ self.assets.insert(asset_key.clone(), content);
+ log::info!("Loaded asset: {} ({} bytes)", asset_key, self.assets.get(&asset_key).unwrap().len());
+ }
+ Err(e) => {
+ log::warn!("Failed to load asset {:?}: {}", relative_path, e);
+ }
+ }
+ } else if file_path.is_dir() {
+ // 递归处理子目录
+ self.load_assets_recursive(&file_path, assets_root)?;
+ }
+ }
+
+ Ok(())
+ }
+
+ pub fn open_main_db(&mut self, profile_id: ProfileId) -> Result<()> {
+ self.main_db = None;
+ // Clear cached search results when switching databases
+ self.group_search_results.clear();
+ if profile_id != INVALID_PROFILE_ID {
+ let profile = self.library_manager.find_profile(profile_id).ok_or_else(|| ZdbError::invalid_parameter(format!("Profile {} not found", profile_id)))?;
+ if profile.is_group() {
+ let db = MdxDbGroup::new(&profile, &self.data_home_dir).map_err(|e| ZdbError::invalid_data_format(format!("Failed to open group database: {}: {}", profile_id, e)))?;
+ self.main_db = Some(DbType::MdxDbGroup(db));
+ } else {
+ let db = MdxDb::new(&profile, &self.data_home_dir).map_err(|e| ZdbError::invalid_data_format(format!("Failed to open database: {}: {}", profile_id, e)))?;
+ self.main_db = Some(DbType::MdxDb(db));
+ }
+ }else{
+ return Err(ZdbError::invalid_parameter(format!("Invalid profile ID: {}", profile_id)));
+ }
+ // Update last_main_profile_id in config
+ self.config.set_config(ConfigSection::Global, ConfigKey::LastMainProfileId, profile_id)?;
+ self.config.save()?;
+
+ Ok(())
+ }
+
+ /// Search for words in group mode and cache results
+ pub fn incremental_search(&mut self, query: &str, max_results_per_lib: usize) -> Result> {
+ // Clear cached grouped results for fresh incremental search
+ self.group_search_results.clear();
+ if let Some(DbType::MdxDb(ref mut db)) = self.main_db {
+ // Find best matching entry
+ if let Some(best_match) = db.find_index(query, true, true, true)? {
+ // Get a list of entries starting from the best match
+ let start_entry = best_match.key_index.entry_no;
+ Ok(Some((start_entry, db.get_entry_count() as usize)))
+ } else {
+ Ok(None)
+ }
+ } else if let Some(DbType::MdxDbGroup(ref mut group_db)) = self.main_db {
+ // Delegate grouped search to MdxDbGroup and cache results
+ let cached_results = group_db.find_best_match_indexes(query, max_results_per_lib)?;
+ self.group_search_results = cached_results;
+ if self.group_search_results.is_empty() {
+ Ok(None)
+ } else {
+ Ok(Some((0, self.group_search_results.len())))
+ }
+ } else {
+ Err(ZdbError::invalid_parameter("No database opened".to_string()))
+ }
+ }
+
+ /// Perform full-text search and cache grouped results
+ /// Returns total result count
+ pub fn fulltext_search(&mut self, query: &str, max_results_per_lib: usize) -> Result {
+ // Reset previous cached results
+ self.group_search_results.clear();
+
+ match &mut self.main_db {
+ Some(DbType::MdxDb(db)) => {
+ let mut group_results : LinkedList<(String, String, LinkedList)> = LinkedList::new();
+ let results = db.fulltext_find(query, max_results_per_lib)?;
+ for (_score, index) in results.into_iter() {
+ let mut group_index=MdxGroupIndex {
+ profile_id: index.profile_id,
+ primary_key: index.key_index.key.clone(),
+ indexes: LinkedList::new(),
+ };
+ group_index.indexes.push_back(index.clone());
+ let mut group_indexes = LinkedList::new();
+ group_indexes.push_back(group_index);
+ group_results.push_back((MdxDb::normalize_keyword(&index.key_index.key), index.key_index.key.clone(), group_indexes));
+ }
+
+ self.group_search_results = group_results;
+ Ok(self.group_search_results.len())
+ }
+ Some(DbType::MdxDbGroup(group_db)) => {
+ // Group dictionary mode: delegate to group's fulltext_find
+ let results = group_db.fulltext_find(query, max_results_per_lib)?;
+ self.group_search_results = results;
+ Ok(self.group_search_results.len())
+ }
+ None => Err(ZdbError::invalid_parameter("No database opened".to_string())),
+ }
+ }
+
+ /// Get HTML content for a single entry
+ pub fn get_entry_html_by_index(&mut self, index:&MdxIndex) -> Result {
+ match &mut self.main_db {
+ Some(DbType::MdxDb(db)) => {
+ let index = db.get_index(index.key_index.entry_no)?;
+ return db.get_html(&index, &self.base_url);
+ }
+ Some(DbType::MdxDbGroup(group_db)) => {
+ if let Some(mdx_db) = group_db.mdx_dbs.get_mut(&index.profile_id) {
+ let index = mdx_db.get_index(index.key_index.entry_no)?;
+ return mdx_db.get_html(&index, &self.base_url);
+ } else {
+ return Err(ZdbError::invalid_parameter(format!("Library with profile_id {} not found in group", index.profile_id)));
+ }
+ }
+ None => return Err(ZdbError::invalid_parameter("No database opened".to_string()))
+ }
+ }
+
+ /// Get binary data from MDD file, returns (data, mime_type)
+ pub fn get_mdd_data(&mut self, profile_id: &ProfileId, file_path: &str) -> Result, String)>> {
+ if file_path=="/$MdxDictIcon" {
+ return self.library_manager.get_icon_for_profile(*profile_id);
+ }
+
+ match &mut self.main_db {
+ Some(DbType::MdxDb(db)) => {
+ if db.profile.profile_id != *profile_id {
+ Err(ZdbError::invalid_parameter(format!("Library id not match {}", profile_id)))
+ } else {
+ db.get_data(file_path)
+ }
+ }
+ Some(DbType::MdxDbGroup(group_db)) => {
+ if let Some(mdx_db) = group_db.mdx_dbs.get_mut(&profile_id) {
+ mdx_db.get_data(file_path)
+ } else {
+ Err(ZdbError::invalid_parameter(format!("Library with profile_id {} not found in group", profile_id)))
+ }
+ }
+ None => Err(ZdbError::invalid_parameter("No database opened".to_string()))
+ }
+ }
+
+ // NOTE: is_single_library_mode and is_group_mode methods have been moved to lib.rs
+ // and are now computed from main_db_profile instead of being implemented here
+
+ /// Auto-open profile on startup based on configuration
+ fn auto_open_startup_profile(&mut self) -> Result<()> {
+ // Get last_main_profile_id from config
+ let mut last_profile_id: ProfileId = self.config.get_config_with_default(
+ ConfigSection::Global,
+ ConfigKey::LastMainProfileId,
+ INVALID_PROFILE_ID
+ );
+
+ if last_profile_id == INVALID_PROFILE_ID {
+ last_profile_id = DEFAULT_GROUP_ID;
+ }
+ let profile= self.library_manager.find_profile(last_profile_id);
+ if profile.is_some() {
+ let profile= profile.unwrap();
+ if profile.is_group() && (profile.get_profiles().is_none() || profile.get_profiles().unwrap().is_empty()) {
+ last_profile_id = INVALID_PROFILE_ID;
+ }
+ }else{
+ last_profile_id = INVALID_PROFILE_ID;
+ }
+
+ if last_profile_id != INVALID_PROFILE_ID {
+ self.open_main_db(last_profile_id)?;
+ }
+ Ok(())
+ }
+
+ /// 结束应用
+ pub fn term_app(&mut self) -> Result<()> {
+ // 保存所有配置
+ self.config.save()?;
+
+ // 保存词典列表
+ let library_path = self.config.get_config_with_default(ConfigSection::Global, ConfigKey::ExtraLibSearchPath, String::new());
+ self.library_manager.to_file(&library_path)?;
+
+ // 清理临时文件
+ Self::cleanup_tmp(&self.tmp_dir)?;
+
+ Ok(())
+ }
+
+ /// 获取base URL
+ pub fn get_base_url(&self) -> &str {
+ &self.base_url
+ }
+
+ /// 设置base URL
+ pub fn set_base_url(&mut self, base_url: String) -> Result<()> {
+ log::info!("Setting base URL: {}", base_url);
+ self.base_url = base_url;
+ Ok(())
+ }
+
+ /// 获取库搜索路径
+ pub fn get_lib_search_paths(&self) -> Result<&[String]> {
+ Ok(&self.lib_search_paths)
+ }
+
+ /// 添加库搜索路径
+ pub fn add_lib_search_path(&mut self, path: String) -> Result<()> {
+ self.lib_search_paths.push(path);
+ Ok(())
+ }
+
+ /// 清空库搜索路径
+ pub fn clear_lib_search_paths(&mut self) -> Result<()> {
+ self.lib_search_paths.clear();
+ Ok(())
+ }
+
+ /// 获取asset文件内容（二进制）
+ pub fn get_asset(&self, filename: &str) -> Result>> {
+ Ok(self.assets.get(filename))
+ }
+
+ /// 获取asset文件内容（文本）
+ pub fn get_asset_text(&self, filename: &str) -> Result> {
+ Ok(self.assets.get(filename).and_then(|bytes| String::from_utf8(bytes.clone()).ok()))
+ }
+
+ /// 获取当前主数据库的profile_id，如果没有则返回INVALID_PROFILE_ID
+ pub fn get_current_main_profile_id(&self) -> Result {
+ Ok(match &self.main_db {
+ Some(DbType::MdxDb(db)) => db.profile.profile_id,
+ Some(DbType::MdxDbGroup(db)) => db.profile.profile_id,
+ None => INVALID_PROFILE_ID,
+ })
+ }
+
+ /// 获取当前主数据库的profile对象
+ pub fn get_current_main_profile(&self) -> Result> {
+ Ok(match &self.main_db {
+ Some(DbType::MdxDb(db)) => Some(db.profile.clone()),
+ Some(DbType::MdxDbGroup(db)) => Some(db.profile.clone()),
+ None => None,
+ })
+ }
+
+ pub fn get_content_url(&self, index_no: usize) -> Result {
+ if let Some(DbType::MdxDb(db)) = &self.main_db {
+ Ok(format!("{}entryx?profile_id={}&entry_no={}", self.base_url, db.profile.profile_id, index_no ))
+ } else if let Some(DbType::MdxDbGroup(_group_db)) = &self.main_db {
+ Ok(format!("{}union?index_no={}", self.base_url, index_no))
+ } else {
+ Err(ZdbError::invalid_parameter("No database opened".to_string()))
+ }
+ }
+
+ /// Get the total entry count for the current database
+ pub fn get_entry_count(&self) -> Result {
+ // Prefer cached grouped results if available (e.g., full-text/group searches)
+ if !self.group_search_results.is_empty() {
+ return Ok(self.group_search_results.len());
+ }
+
+ match &self.main_db {
+ Some(DbType::MdxDb(db)) => {
+ Ok(db.get_entry_count() as usize)
+ }
+ Some(DbType::MdxDbGroup(_group_db)) => {
+ // For group mode, return the count of cached search results
+ Ok(self.group_search_results.len())
+ }
+ None => Err(ZdbError::invalid_parameter("No database opened".to_string()))
+ }
+ }
+
+ /// Find the best matching entry index for a given key
+ /// Returns LinkedList where:
+ /// - Single dictionary mode: returns single MdxGroupIndex with one result
+ /// - Group mode: returns MdxGroupIndex entries grouped by profile_id
+ pub fn find_index(&mut self, key: &str) -> Result> {
+ let mut result = LinkedList::new();
+
+ match &mut self.main_db {
+ Some(DbType::MdxDb(db)) => {
+ // Single dictionary mode: wrap MdxIndex in MdxGroupIndex and put in LinkedList
+ if let Some(mdx_index) = db.find_index(key, false, false, true)? {
+ let mut group_index = MdxGroupIndex::default();
+ group_index.profile_id = db.profile.profile_id;
+ group_index.primary_key = key.to_string();
+ group_index.indexes = LinkedList::new();
+ group_index.indexes.push_back(mdx_index);
+ result.push_back(group_index);
+ }
+ Ok(result)
+ }
+ Some(DbType::MdxDbGroup(group_db)) => {
+ // Group mode: search across all dictionaries and group by profile_id
+ let mut profile_groups = std::collections::HashMap::::new();
+
+ for mdx_db in group_db.mdx_dbs.values_mut() {
+ if let Some(mdx_index) = mdx_db.find_index(key, false, false, true)? {
+ let profile_id = mdx_index.profile_id;
+
+ // Get or create MdxGroupIndex for this profile_id
+ let group_index = profile_groups.entry(profile_id).or_insert_with(|| {
+ MdxGroupIndex {
+ profile_id,
+ primary_key: key.to_string(),
+ indexes: LinkedList::new(),
+ }
+ });
+
+ // Add the found index to this profile's group
+ group_index.indexes.push_back(mdx_index);
+ }
+ }
+
+ // Convert HashMap to LinkedList, sorted by profile order
+ if let Some(profiles) = group_db.profile.get_profiles() {
+ for profile in profiles.iter() {
+ if let Some(group_index) = profile_groups.remove(&profile.profile_id) {
+ result.push_back(group_index);
+ }
+ }
+ }
+
+ Ok(result)
+ }
+ None => Ok(result),
+ }
+ }
+
+
+ /// Get entries starting from a specific index
+ /// Unified method that works for both single dictionary and group modes
+ /// Returns Vec of (keyword, entry_count)
+ pub fn get_result_key_list(&mut self, start_index: i64, max_count: usize) -> Result> {
+ // If we have cached grouped results (e.g., from full-text or grouped search), use them regardless of mode
+ if !self.group_search_results.is_empty() {
+ if start_index >= self.group_search_results.len() as i64 {
+ return Err(ZdbError::invalid_parameter(format!("Start index out of range: {} >= {}", start_index, self.group_search_results.len())));
+ }
+ let mut results = LinkedList::new();
+ for (_, display_key, group_indexes) in self.group_search_results.iter().skip(start_index as usize) {
+ // Entry count equals number of dictionaries (profile groups) contributing to this key
+ let group_count = group_indexes.len();
+ results.push_back((display_key.clone(), group_count));
+ if results.len() >= max_count {
+ break;
+ }
+ }
+ return Ok(results);
+ }
+
+ match &mut self.main_db {
+ Some(DbType::MdxDb(db)) => {
+ // Single dictionary mode: get entries directly from the dictionary
+ let indexes = db.get_indexes(start_index, max_count as u64)?;
+ let mut results = LinkedList::new();
+ for index in indexes {
+ let keyword = index.key_index.key.clone();
+ // For single dictionary mode, group count is always 1
+ results.push_back((keyword, 1));
+ }
+ Ok(results)
+ }
+ Some(DbType::MdxDbGroup(_group_db)) => {
+ // Group mode: get entries from cached search results
+ // If we reached here, it means we have no cached grouped results
+ return Ok(LinkedList::new());
+ }
+ None => Err(ZdbError::invalid_parameter("No database opened".to_string())),
+ }
+ }
+
+ /// Navigate to a URL by emitting an event to the frontend
+ pub fn navigate_to(&self, url: &str) -> Result<()> {
+ log::info!("Navigating to URL: {}", url);
+ self.app_handle.emit("navigate_to", url).map_err(|e| ZdbError::invalid_data_format(format!("Failed to emit navigate_to event: {}", e)))?;
+ Ok(())
+ }
+
+ /// Reload resources (assets and HTML templates)
+ pub fn reload_resources(&mut self) -> Result<()> {
+ log::info!("Reloading resources...");
+
+ // Clear existing assets and templates
+ self.assets.clear();
+
+ // Reload assets
+ self.load_assets(&self.app_handle.clone())?;
+ log::info!("Resources reloaded successfully. {} assets", self.assets.len());
+ Ok(())
+ }
+
+ /// Get indexes for a specific entry position, returning grouped data
+ /// Returns LinkedList
+ pub fn get_group_indexes(&mut self, index_no: usize) -> Result> {
+ // If we have cached grouped results, return from cache regardless of mode
+ if !self.group_search_results.is_empty() {
+ if index_no >= self.group_search_results.len() {
+ return Err(ZdbError::invalid_parameter(format!("Index out of range: {} >= {}", index_no, self.group_search_results.len())));
+ }
+ return Ok(self.group_search_results.iter().nth(index_no).unwrap().2.clone());
+ }
+
+ match &mut self.main_db {
+ Some(DbType::MdxDb(db)) => {
+ // Single dictionary mode: return one MdxGroupIndex with single index
+ if index_no >= db.get_entry_count() as usize {
+ return Err(ZdbError::invalid_parameter(format!("Index out of range: {} >= {}", index_no, db.get_entry_count() as usize)));
+ }
+
+ let mdx_index = db.get_index(index_no as i64)?;
+ let mut indexes = LinkedList::new();
+ indexes.push_back(mdx_index.clone());
+
+ let group_index = MdxGroupIndex {
+ profile_id: db.profile.profile_id,
+ primary_key: mdx_index.key_index.key.clone(),
+ indexes,
+ };
+ let mut result = LinkedList::new();
+ result.push_back(group_index);
+ return Ok(result);
+ }
+ Some(DbType::MdxDbGroup(_group_db)) => {
+ // Group mode without cache
+ return Err(ZdbError::invalid_parameter("No grouped search results available".to_string()));
+ }
+ None => return Err(ZdbError::invalid_parameter("No database opened".to_string()))
+ }
+ }
+}
+
+/// 全局MdictApp实例
+static GLOBAL_MDICT_APP: OnceCell> = OnceCell::new();
+
+/// 初始化全局MdictApp
+pub fn init_mdict_app>(app_home_dir: P, extra_search_paths: Vec, app_handle: &tauri::AppHandle) -> Result<()> {
+ let app = MdictApp::init_app_with_home_dir( app_home_dir, extra_search_paths, app_handle)?;
+ let app_lock = RwLock::new(app);
+
+ GLOBAL_MDICT_APP.set(app_lock)
+ .map_err(|_| ZdbError::invalid_parameter("全局MdictApp已经初始化".to_string()))?;
+
+ Ok(())
+}
+
+/// 获取全局MdictApp
+fn get_mdict_app() -> Result<&'static RwLock> {
+ GLOBAL_MDICT_APP.get()
+ .ok_or_else(|| ZdbError::invalid_parameter("全局MdictApp尚未初始化".to_string()))
+}
+
+fn mdict_app() -> Result<&'static RwLock> {
+ get_mdict_app()
+}
+
+/// 简化的模板方法：统一处理读操作的访问模式
+pub fn with_read_access(operation: F) -> Result
+where
+ F: FnOnce(&MdictApp) -> Result,
+{
+ let app_lock = mdict_app()?;
+ let app = app_lock.read()
+ .map_err(|_| ZdbError::invalid_parameter("无法获取MdictApp读锁".to_string()))?;
+ operation(&app)
+}
+
+/// 简化的模板方法：统一处理写操作的访问模式
+pub fn with_write_access(operation: F) -> Result
+where
+ F: FnOnce(&mut MdictApp) -> Result,
+{
+ let app_lock = mdict_app()?;
+ let mut app = app_lock.write()
+ .map_err(|_| ZdbError::invalid_parameter("无法获取MdictApp写锁".to_string()))?;
+ operation(&mut app)
+}
+
+/// 简化的模板方法：统一处理配置相关的读操作
+pub fn with_config_read(operation: F) -> Result
+where
+ F: FnOnce(&AppConfig) -> Result,
+{
+ let app_lock = mdict_app()?;
+ let app = app_lock.read()
+ .map_err(|_| ZdbError::invalid_parameter("无法获取MdictApp读锁".to_string()))?;
+ operation(&app.config)
+}
+
+/// 简化的模板方法：统一处理配置相关的写操作
+pub fn with_config_write(operation: F) -> Result
+where
+ F: FnOnce(&mut AppConfig) -> Result,
+{
+ let app_lock = mdict_app()?;
+ let mut app = app_lock.write()
+ .map_err(|_| ZdbError::invalid_parameter("无法获取MdictApp写锁".to_string()))?;
+ operation(&mut app.config)
+}
+
+/// 简化的模板方法：统一处理库管理器相关的读操作
+pub fn with_library_read(operation: F) -> Result
+where
+ F: FnOnce(&LibraryManager) -> Result,
+{
+ let app_lock = mdict_app()?;
+ let app = app_lock.read()
+ .map_err(|_| ZdbError::invalid_parameter("无法获取MdictApp读锁".to_string()))?;
+ operation(&app.library_manager)
+}
+
+/// 简化的模板方法：统一处理库管理器相关的写操作
+pub fn with_library_write(operation: F) -> Result
+where
+ F: FnOnce(&mut LibraryManager) -> Result,
+{
+ let app_lock = mdict_app()?;
+ let mut app = app_lock.write()
+ .map_err(|_| ZdbError::invalid_parameter("无法获取MdictApp写锁".to_string()))?;
+ operation(&mut app.library_manager)
+}
+
+/// 简化的模板方法：统一处理历史记录相关的读操作
+pub fn with_history_read(operation: F) -> Result
+where
+ F: FnOnce(&HistoryManager) -> Result,
+{
+ let app_lock = mdict_app()?;
+ let app = app_lock.read()
+ .map_err(|_| ZdbError::invalid_parameter("无法获取MdictApp读锁".to_string()))?;
+ operation(&app.history_manager)
+}
+
+/// 简化的模板方法：统一处理历史记录相关的写操作
+pub fn with_history_write(operation: F) -> Result
+where
+ F: FnOnce(&mut HistoryManager) -> Result,
+{
+ let app_lock = mdict_app()?;
+ let mut app = app_lock.write()
+ .map_err(|_| ZdbError::invalid_parameter("无法获取MdictApp写锁".to_string()))?;
+ operation(&mut app.history_manager)
+}
+
+/// 简化的模板方法：统一处理收藏相关的读操作
+pub fn with_favorites_read(operation: F) -> Result
+where
+ F: FnOnce(&FavoritesManager) -> Result,
+{
+ let app_lock = mdict_app()?;
+ let app = app_lock.read()
+ .map_err(|_| ZdbError::invalid_parameter("无法获取MdictApp读锁".to_string()))?;
+ operation(&app.favorites_manager)
+}
+
+/// 简化的模板方法：统一处理收藏相关的写操作
+pub fn with_favorites_write(operation: F) -> Result
+where
+ F: FnOnce(&mut FavoritesManager) -> Result,
+{
+ let app_lock = mdict_app()?;
+ let mut app = app_lock.write()
+ .map_err(|_| ZdbError::invalid_parameter("无法获取MdictApp写锁".to_string()))?;
+ operation(&mut app.favorites_manager)
+}
diff --git a/rust/src-tauri/src/mdx_db.rs b/rust/src-tauri/src/mdx_db.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ad56bbad443544c75bdeeb375ef08ddd6c7dd9ed
--- /dev/null
+++ b/rust/src-tauri/src/mdx_db.rs
@@ -0,0 +1,143 @@
+use std::collections::LinkedList;
+use serde::{Serialize, Deserialize};
+use url::Url;
+
+use mdx::{Result, MdxReader};
+use mdx::storage::{KeyIndex, EntryNo};
+use mdx::utils::MdxHtmlRewriter;
+
+use crate::mdx_profile::{MdxProfile, ProfileId};
+
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct MdxIndex {
+ pub profile_id: ProfileId,
+ pub key_index: KeyIndex,
+}
+
+pub struct MdxDb {
+ pub profile: MdxProfile,
+ pub mdx_reader: MdxReader,
+
+}
+
+impl MdxDb {
+ pub fn new(profile: &MdxProfile, device_id: &str) -> Result {
+ let mdx_reader = MdxReader::from_url(
+ &Url::parse(&profile.url)?,
+ device_id,
+ )?;
+
+ Ok(Self {
+ profile: profile.clone(),
+ mdx_reader,
+ })
+ }
+
+ pub fn get_title(&self) -> &String{
+ &self.mdx_reader.db_name
+ }
+
+ pub fn get_description(&self) -> String{
+ self.mdx_reader.content_db.meta.db_info.description.clone()
+ }
+
+ pub fn get_entry_count(&self) -> u64 {
+ self.mdx_reader.get_entry_count()
+ }
+
+ pub fn get_index(&mut self, entry_no: EntryNo) -> Result {
+ Ok(MdxIndex {
+ profile_id: self.profile.profile_id,
+ key_index: self.mdx_reader.get_index(entry_no)?.into(),
+ })
+ }
+
+ pub fn get_indexes(&mut self, start_entry_no: EntryNo, max_count: u64) -> Result> {
+ let indexes = self.mdx_reader.get_indexes(start_entry_no, max_count)?;
+ let mut mdx_indexes = LinkedList::new();
+ for index in indexes {
+ mdx_indexes.push_back(MdxIndex {
+ profile_id: self.profile.profile_id,
+ key_index: index.into(),
+ });
+ }
+ Ok(mdx_indexes)
+ }
+
+ pub fn find_index(&mut self, key: &str, prefix_match: bool, partial_match: bool, best_match: bool) -> Result> {
+ let key_index = self.mdx_reader.find_index(key, prefix_match, partial_match, best_match)?;
+ if let Some(key_index) = key_index {
+ Ok(Some(MdxIndex {
+ profile_id: self.profile.profile_id,
+ key_index: key_index.into(),
+ }))
+ } else {
+ Ok(None)
+ }
+ }
+
+ pub fn normalize_keyword(keyword: &str) -> String {
+ keyword.chars()
+ .filter(|c| c.is_alphabetic())
+ .map(|c| c.to_lowercase().collect::())
+ .collect::()
+ }
+
+ pub fn find_similar_index(&mut self, key: &str, prefix_match: bool, partial_match: bool, best_match: bool, max_results: usize) -> Result> {
+ let key_index = self.mdx_reader.find_index(key, prefix_match, partial_match, best_match)?;
+ let mut mdx_indexes = LinkedList::new();
+ if let Some(key_index) = key_index {
+ mdx_indexes.push_back(MdxIndex {
+ profile_id: self.profile.profile_id,
+ key_index: key_index.clone(),
+ });
+ let normalized_key = Self::normalize_keyword(&key_index.key);
+ for i in 1 .. std::cmp::min(max_results as u64, self.get_entry_count() - key_index.entry_no as u64) {
+ let index = self.mdx_reader.get_index(key_index.entry_no + i as EntryNo)?;
+ if normalized_key == Self::normalize_keyword(&index.key) {
+ mdx_indexes.push_back(MdxIndex {
+ profile_id: self.profile.profile_id,
+ key_index: index.into(),
+ });
+ }else {
+ break;
+ }
+ }
+ }
+ Ok(mdx_indexes)
+ }
+
+ //Get the contents of the entry
+ pub fn get_html(&mut self, entry: &MdxIndex, base_url:&str)->Result {
+ let key_index: KeyIndex = entry.key_index.clone().into();
+ MdxHtmlRewriter::rewrite_html_with_base_url(&self.mdx_reader.get_html(&key_index)?, self.profile.profile_id, base_url)
+ }
+
+ pub fn get_data(&mut self, file_path:&str) -> Result, String)>> {
+ self.mdx_reader.get_data(file_path)
+ }
+
+ /// Perform full-text search on the database content
+ /// Returns a vector of MdxIndex results with their search scores
+ pub fn fulltext_find(&mut self, query: &str, max_results: usize) -> Result> {
+ let search_results = self.mdx_reader.fts_search(query, max_results)?;
+ let mut mdx_results = Vec::new();
+
+ for (score, entry_no, _key) in search_results {
+ let key_index = self.mdx_reader.get_index(entry_no)?;
+ let mdx_index = MdxIndex {
+ profile_id: self.profile.profile_id,
+ key_index: key_index.into(),
+ };
+ mdx_results.push((score, mdx_index));
+ }
+
+ Ok(mdx_results)
+ }
+
+ /// Check if full-text search is available for this database
+ pub fn is_fts_available(&self) -> bool {
+ self.mdx_reader.is_fts_available()
+ }
+}
\ No newline at end of file
diff --git a/rust/src-tauri/src/mdx_db_group.rs b/rust/src-tauri/src/mdx_db_group.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a657a07d0e43877e0dba3e688b582206e2a7d284
--- /dev/null
+++ b/rust/src-tauri/src/mdx_db_group.rs
@@ -0,0 +1,188 @@
+use std::collections::{HashMap, LinkedList};
+
+use mdx::{Result, ZdbError};
+
+use crate::mdx_db::{MdxDb, MdxIndex};
+use crate::mdx_profile::{MdxProfile, ProfileId};
+
+#[derive(Default, Debug, Clone, serde::Serialize)]
+pub struct MdxGroupIndex {
+ pub profile_id: ProfileId,
+ pub primary_key: String,
+ pub indexes: LinkedList,
+}
+
+pub struct MdxDbGroup {
+ pub profile: MdxProfile,
+ pub mdx_dbs: HashMap,
+}
+
+impl MdxDbGroup {
+ pub fn new(profile: &MdxProfile, device_id: &str) -> Result {
+ if !profile.as_union || profile.get_profiles().is_none() {
+ return Err(ZdbError::invalid_parameter("Not a union group or no sub profiles"));
+ }
+ let mut mdx_dbs = HashMap::new();
+ for profile in profile.get_profiles().unwrap().iter() {
+ if !profile.disabled {
+ let mdx_db = MdxDb::new(profile, device_id)?;
+ mdx_dbs.insert(profile.profile_id, mdx_db);
+ }
+ }
+ Ok(Self { profile: profile.clone(), mdx_dbs })
+ }
+
+ pub fn find_best_match_indexes(&mut self, query: &str, max_results_per_lib: usize) -> Result)>> {
+ // Map normalized_key -> (display_key, Map>)
+ let mut merged_results = std::collections::BTreeMap::<
+ String,
+ (
+ String,
+ std::collections::BTreeMap>,
+ ),
+ >::new();
+
+ let normalized_query = MdxDb::normalize_keyword(query);
+ // Search in each library within the group
+ for mdx_db in self.mdx_dbs.values_mut() {
+ if let Some(best_match) = mdx_db.find_index(query, true, true, true)? {
+ let start_entry = best_match.key_index.entry_no;
+ if let Ok(indexes) = mdx_db.get_indexes(start_entry, max_results_per_lib as u64) {
+ for index in indexes {
+ // Normalize keyword for merging (ignore case and non-alphabetic characters)
+ let normalized_key = MdxDb::normalize_keyword(&index.key_index.key);
+ let original_key = index.key_index.key.clone();
+
+ if normalized_key max_results_per_lib && &normalized_key>merged_results.last_entry().unwrap().key() {
+ break;
+ }
+ // Ensure entry for normalized key exists with display key
+ let entry = merged_results
+ .entry(normalized_key)
+ .or_insert_with(|| (original_key, std::collections::BTreeMap::new()));
+
+ // Group indexes by profile_id under this key
+ let per_profile_indexes = entry
+ .1
+ .entry(index.profile_id)
+ .or_insert_with(|| LinkedList::new());
+ per_profile_indexes.push_back(index);
+
+ if merged_results.len() > max_results_per_lib{
+ merged_results.pop_last();
+ }
+ }
+ }
+ }
+ }
+
+ // Build results: each key maps to a LinkedList of MdxGroupIndex,
+ // where each MdxGroupIndex contains indexes from a single profile_id
+ // Sort by profile order in the group's profile list
+ let mut results = LinkedList::new();
+ for (normalized_key, (display_key, per_profile_map)) in merged_results {
+ let mut group_index_list = LinkedList::new();
+
+ // Sort profile_ids by their order in the group's profiles list
+ if let Some(profiles) = self.profile.get_profiles() {
+ for profile in profiles.iter() {
+ if let Some(indexes) = per_profile_map.get(&profile.profile_id) {
+ let group_index = MdxGroupIndex {
+ profile_id: profile.profile_id,
+ primary_key: display_key.clone(),
+ indexes: indexes.clone(),
+ };
+ group_index_list.push_back(group_index);
+ }
+ }
+ }
+
+ results.push_back((normalized_key, display_key, group_index_list));
+ }
+
+ Ok(results)
+ }
+
+ /// Perform full-text search across all libraries in the group
+ /// Behavior is similar to `MdxDbGroup::find_index`, but uses `MdxDb::search_fulltext`
+ /// to collect results per library, then merges them by normalized key
+ pub fn fulltext_find(&mut self, query: &str, max_results_per_lib: usize) -> Result)>> {
+ // Map normalized_key -> (display_key, Map>)
+ let mut merged_results = std::collections::BTreeMap::<
+ String,
+ (
+ String,
+ std::collections::BTreeMap>,
+ ),
+ >::new();
+
+ // Search in each library within the group using full-text search when available
+ for mdx_db in self.mdx_dbs.values_mut() {
+ if !mdx_db.is_fts_available() { continue; }
+
+ if let Ok(results) = mdx_db.fulltext_find(query, max_results_per_lib) {
+ for (_score, index) in results {
+ // Normalize keyword for merging (ignore case and non-alphabetic characters)
+ let normalized_key = MdxDb::normalize_keyword(&index.key_index.key);
+ let original_key = index.key_index.key.clone();
+
+ // Ensure entry for normalized key exists with display key
+ let entry = merged_results
+ .entry(normalized_key)
+ .or_insert_with(|| (original_key, std::collections::BTreeMap::new()));
+
+ // Group indexes by profile_id under this key
+ let per_profile_indexes = entry
+ .1
+ .entry(index.profile_id)
+ .or_insert_with(|| LinkedList::new());
+ per_profile_indexes.push_back(index);
+ }
+ }
+ }
+
+ // Build results: each key maps to a LinkedList of MdxGroupIndex,
+ // where each MdxGroupIndex contains indexes from a single profile_id
+ // Sort by profile order in the group's profile list
+ let mut results = LinkedList::new();
+ for (_normalized_key, (display_key, per_profile_map)) in merged_results {
+ let mut group_index_list = LinkedList::new();
+
+ // Sort profile_ids by their order in the group's profiles list
+ if let Some(profiles) = self.profile.get_profiles() {
+ for profile in profiles.iter() {
+ if let Some(indexes) = per_profile_map.get(&profile.profile_id) {
+ let group_index = MdxGroupIndex {
+ profile_id: profile.profile_id,
+ primary_key: display_key.clone(),
+ indexes: indexes.clone(),
+ };
+ group_index_list.push_back(group_index);
+ }
+ }
+ }
+
+ // Use normalized value of display_key as the map key similar to find_index
+ let normalized_key = MdxDb::normalize_keyword(&display_key);
+ results.push_back((normalized_key, display_key, group_index_list));
+ }
+
+ Ok(results)
+ }
+
+ pub fn get_html(&mut self, entry: &MdxIndex, base_url: &str)->Result {
+ let mdx_db = self.mdx_dbs.get_mut(&entry.profile_id).unwrap();
+ mdx_db.get_html(entry, base_url)
+ }
+
+ pub fn is_fts_available(&self) -> bool {
+ for mdx_db in self.mdx_dbs.values() {
+ if mdx_db.is_fts_available() {
+ return true;
+ }
+ }
+ false
+ }
+}
\ No newline at end of file
diff --git a/rust/src-tauri/src/mdx_profile.rs b/rust/src-tauri/src/mdx_profile.rs
new file mode 100644
index 0000000000000000000000000000000000000000..686a3c90f0c52cd7c2734c8cfe9da468b7a1312d
--- /dev/null
+++ b/rust/src-tauri/src/mdx_profile.rs
@@ -0,0 +1,202 @@
+use std::collections::LinkedList;
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+use mdx::utils::{get_decoded_file_stem, with_extension};
+
+
+pub type ProfileId = i32;
+
+pub const DEFAULT_GROUP_ID: ProfileId = 1;
+pub const INVALID_PROFILE_ID: ProfileId = -1;
+
+
+#[derive(Serialize, Deserialize, Default, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct MdxOptions {
+ pub font_file_path: String,
+}
+
+#[derive(Deserialize, Default, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct MdxProfile {
+ pub title: String,
+ pub description: String,
+ pub url: String,
+ pub disabled: bool,
+ pub profile_id: ProfileId,
+ pub options: MdxOptions,
+
+ // Group-related fields (when this profile acts as a group)
+ #[serde(default)]
+ pub profiles: Option>,
+ #[serde(default)]
+ pub as_union: bool,
+}
+
+// Custom Serialize implementation to include computed is_fts_enabled field
+impl Serialize for MdxProfile {
+ fn serialize(&self, serializer: S) -> Result
+ where
+ S: serde::Serializer,
+ {
+ use serde::ser::SerializeStruct;
+
+ let mut state = serializer.serialize_struct("MdxProfile", 9)?;
+ state.serialize_field("title", &self.title)?;
+ state.serialize_field("description", &self.description)?;
+ state.serialize_field("url", &self.url)?;
+ state.serialize_field("disabled", &self.disabled)?;
+ state.serialize_field("profileId", &self.profile_id)?;
+ state.serialize_field("options", &self.options)?;
+ state.serialize_field("profiles", &self.profiles)?;
+ state.serialize_field("asUnion", &self.as_union)?;
+ state.serialize_field("isFtsEnabled", &self.is_fts_enabled())?;
+ state.end()
+ }
+}
+
+impl MdxProfile {
+ /// Check if this profile acts as a group
+ pub fn is_group(&self) -> bool {
+ self.profiles.is_some()
+ }
+
+ pub fn is_fts_enabled(&self) -> bool {
+ if let Some(profiles) = &self.profiles {
+ return profiles.iter().any(|p| p.is_fts_enabled());
+ }else{
+ let idx_url = with_extension(&Url::parse(&self.url).unwrap(), "idx").unwrap();
+ return idx_url.to_file_path().unwrap().exists();
+ }
+ }
+
+ /// Get profiles if this is a group
+ pub fn get_profiles(&self) -> Option<&LinkedList> {
+ self.profiles.as_ref()
+ }
+
+ /// Get mutable profiles if this is a group
+ pub fn get_profiles_mut(&mut self) -> Option<&mut LinkedList> {
+ self.profiles.as_mut()
+ }
+
+
+ /// Get a profile by ID if this is a group
+ pub fn get_profile(&self, profile_id: ProfileId) -> Option<&MdxProfile> {
+ self.profiles.as_ref()?.iter().find(|p| p.profile_id == profile_id)
+ }
+
+ /// Get a mutable profile by ID if this is a group
+ pub fn get_profile_mut(&mut self, profile_id: ProfileId) -> Option<&mut MdxProfile> {
+ self.profiles.as_mut()?.iter_mut().find(|p| p.profile_id == profile_id)
+ }
+
+ /// Replace or add a profile in this group
+ ///
+ /// # Arguments
+ /// * `mdx_profile` - The profile to add or replace
+ /// * `next_id` - The ID to assign if this is a new profile
+ pub fn replace_profile(&mut self, mdx_profile: &MdxProfile, next_id: ProfileId) {
+ if self.profiles.is_none() {
+ self.profiles = Some(LinkedList::new());
+ }
+
+ let profiles = self.profiles.as_mut().unwrap();
+ let profile = profiles.iter_mut().find(|p| p.profile_id == mdx_profile.profile_id);
+ if let Some(profile) = profile {
+ *profile = mdx_profile.clone();
+ } else {
+ let mut new_profile = mdx_profile.clone();
+ new_profile.profile_id = next_id;
+ profiles.push_back(new_profile);
+ }
+ }
+
+
+ /// Adjust profile order within this group
+ pub fn adjust_profile_order(&mut self, profile_id: ProfileId, new_index: usize) {
+ if let Some(profiles) = &mut self.profiles {
+ let mut target_profile: Option = None;
+ let mut new_profiles = LinkedList::new();
+
+ // Collect all profiles except the target
+ for profile in profiles.iter() {
+ if profile.profile_id != profile_id {
+ new_profiles.push_back(profile.clone());
+ } else {
+ target_profile = Some(profile.clone());
+ }
+ }
+
+ // Insert the target profile at the new position
+ if let Some(profile) = target_profile {
+ let mut result_profiles = LinkedList::new();
+ let mut current_index = 0;
+
+ for existing_profile in new_profiles.iter() {
+ if current_index == new_index {
+ result_profiles.push_back(profile.clone());
+ }
+ result_profiles.push_back(existing_profile.clone());
+ current_index += 1;
+ }
+
+ // If new_index is beyond the range, add the profile at the end
+ if new_index >= new_profiles.len() {
+ result_profiles.push_back(profile);
+ }
+
+ *profiles = result_profiles;
+ }
+ }
+ }
+
+ /// Create a new profile (group or individual)
+ ///
+ /// # Arguments
+ /// * `title_or_url` - For groups: the title; For individual profiles: the URL
+ /// * `profile_id` - The unique ID for this profile
+ /// * `is_group` - If true, creates a group profile; if false, creates an individual profile
+ pub fn new(title_or_url: String, profile_id: ProfileId, is_group: bool) -> Self {
+ if is_group {
+ // For groups: title_or_url is the title, url is empty
+ Self {
+ title: title_or_url,
+ description: String::new(),
+ url: String::new(),
+ disabled: false,
+ profile_id,
+ options: MdxOptions::default(),
+ profiles: Some(LinkedList::new()),
+ as_union: true,
+ }
+ } else {
+ // For individual profiles: title_or_url is the URL, title is derived from URL
+ let url = Url::parse(&title_or_url).unwrap_or(Url::parse("file://").unwrap());
+ let title = get_decoded_file_stem(&url).unwrap_or_default();
+ Self {
+ title,
+ description: String::new(),
+ url: title_or_url,
+ disabled: false,
+ profile_id,
+ options: MdxOptions::default(),
+ profiles: None,
+ as_union: false,
+ }
+ }
+ }
+
+ /// Create a new group profile (convenience method)
+ pub fn new_group(title: String, profile_id: ProfileId) -> Self {
+ Self::new(title, profile_id, true)
+ }
+
+ /// Create a new individual profile (convenience method)
+ pub fn new_profile(title: String, url: String, profile_id: ProfileId) -> Self {
+ let mut profile = Self::new(url, profile_id, false);
+ profile.title = title; // Override the auto-derived title with the provided one
+ profile
+ }
+}
\ No newline at end of file
diff --git a/rust/src-tauri/src/mdx_url_parser.rs b/rust/src-tauri/src/mdx_url_parser.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f7d136aff8851f23ba4a528de8f83c2d2e097aa9
--- /dev/null
+++ b/rust/src-tauri/src/mdx_url_parser.rs
@@ -0,0 +1,72 @@
+use crate::error::{Result, ZdbError};
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Default, Hash)]
+#[repr(i32)]
+pub enum MdxAction {
+ #[default]
+ Unknown,
+ Entry,
+ EntryX,
+ HProgEntry,
+ HProgEntryX,
+ ProgEntry,
+ ProgEntryX,
+ IFrame,
+ Mdd,
+ Res,
+ EncryptedRes,
+ File,
+ Sound,
+ Launch,
+ Debug,
+ ViewImage,
+ Info,
+ Notify,
+}
+
+impl MdxAction {
+ pub fn from_str(s: &str) -> MdxAction {
+ match s {
+ "iframe" => MdxAction::IFrame,
+ "res" => MdxAction::Res,
+ "eres" => MdxAction::EncryptedRes,
+ "file" => MdxAction::File,
+ "view_image" => MdxAction::ViewImage,
+ "sound" => MdxAction::Sound,
+ "entry" => MdxAction::Entry,
+ "prog_entry" => MdxAction::ProgEntry,
+ "h_prog_entry" => MdxAction::HProgEntry,
+ "entryx" => MdxAction::EntryX,
+ "prog_entryx" => MdxAction::ProgEntryX,
+ "h_prog_entryx" => MdxAction::HProgEntryX,
+ "mdd" => MdxAction::Mdd,
+ "launch" => MdxAction::Launch,
+ "debug" => MdxAction::Debug,
+ "notify" => MdxAction::Notify,
+ "info" => MdxAction::Info,
+ _ => MdxAction::Unknown,
+ }
+ }
+}
+
+/// Mdx url is like http://mdict.cn/service/action?parameters
+/// 只解析action部分，参数解析留给具体的handler处理
+pub fn parse_mdx_url(url: &str, base_url: &str) -> Result {
+ let base_url = base_url.replace("http.localhost", "localhost");
+ let path_with_action = url.strip_prefix(&base_url).unwrap_or("");
+ // 只获取去掉base_path后的第一层路径
+ let action_str = path_with_action
+ .split('?')
+ .next()
+ .unwrap_or(path_with_action);
+
+ let action = MdxAction::from_str(action_str);
+
+
+ if action != MdxAction::Unknown {
+ // 只返回解析到的action
+ Ok(action)
+ } else {
+ Err(ZdbError::invalid_parameter(format!("Invalid action: {}", action_str)))
+ }
+}
diff --git a/rust/src-tauri/src/request_handler.rs b/rust/src-tauri/src/request_handler.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ec9c30c4e2244037d4dfe87b6df47bf3005ec622
--- /dev/null
+++ b/rust/src-tauri/src/request_handler.rs
@@ -0,0 +1,66 @@
+// 处理webview的URL请求
+use log::debug;
+use tauri::http::{Request, Response, StatusCode};
+use url::Url;
+
+use crate::action_handlers::get_action_handler;
+use crate::error::{Result, ZdbError};
+use crate::error_printer::format_error;
+use crate::mdx_url_parser::parse_mdx_url;
+
+/// 处理MDX URL请求的函数
+fn handle_mdx_url(url: &str, base_url: &str) -> Result>> {
+
+ let action = parse_mdx_url(&url, base_url)?;
+
+ // 使用action handler处理请求
+ let handler = get_action_handler(action)
+ .ok_or_else(|| ZdbError::invalid_parameter(format!("Unsupported action: {:?}", action)))?;
+
+ let response = handler.handle(&Url::parse(url)?, action)?;
+
+ Ok(response)
+}
+
+/// 为响应添加 CORS headers
+fn add_cors_headers(response: &mut Response>) {
+ response.headers_mut().insert("Access-Control-Allow-Origin", "*".parse().unwrap());
+ response.headers_mut().insert("Access-Control-Allow-Methods", "*".parse().unwrap());
+ response.headers_mut().insert("Access-Control-Allow-Headers", "*".parse().unwrap());
+}
+
+pub fn handle_request(request: &Request>, base_url: &str) -> std::result::Result>, Box> {
+ let uri = request.uri().to_string();
+ debug!("Handling request: {}", uri);
+ match handle_mdx_url(&uri, base_url) {
+ Ok(mut response) => {
+ // 统一添加 CORS headers
+ add_cors_headers(&mut response);
+ Ok(response)
+ },
+ Err(error) => {
+ let error_message = format_error(&error);
+
+ // Determine HTTP status code based on error type
+ let status_code = if let ZdbError::KeyNotFound { .. } = &error {
+ log::info!("Key not found: {}", uri);
+ StatusCode::NOT_FOUND
+ } else {
+ log::error!("Error handling MDX URL {}: {}", uri, error_message);
+ StatusCode::INTERNAL_SERVER_ERROR
+ };
+
+ let error_html = format!(
+ "Error
Failed to load content: {}
",
+ error_message
+ );
+ let mut response = Response::new(error_html.into_bytes());
+ *response.status_mut() = status_code;
+ response.headers_mut().insert("Content-Type", "text/html; charset=utf-8".parse().unwrap());
+ // 错误响应也添加 CORS headers
+ add_cors_headers(&mut response);
+ Ok(response)
+ }
+ }
+}
+
diff --git a/rust/src-tauri/src/search_cmd.rs b/rust/src-tauri/src/search_cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..55cb04425963ad456e55f3d5bb71482bbd1f1c0a
--- /dev/null
+++ b/rust/src-tauri/src/search_cmd.rs
@@ -0,0 +1,110 @@
+// Search commands module - Tauri command implementations for search and content retrieval
+use std::collections::LinkedList;
+use tauri::command;
+
+use crate::error::IntoStringResult;
+use crate::mdict_app::{with_read_access, with_write_access};
+
+/// Incremental search (index search)
+#[command]
+pub async fn search_search_incremental(query: String, max_results: Option) -> std::result::Result {
+ let max_results = max_results.unwrap_or(50);
+
+ with_write_access(|app| {
+ match app.incremental_search(&query, max_results)? {
+ Some((start_entry, total_count)) => {
+ Ok(serde_json::json!({
+ "start_entry_no": start_entry,
+ "total_count": total_count
+ }))
+ }
+ None => {
+ // Return {start_entry_no: -1, total_count: 0} to indicate no results found
+ Ok(serde_json::json!({
+ "start_entry_no": -1,
+ "total_count": 0
+ }))
+ }
+ }
+ }).into_string_result()
+}
+
+/// Get content URL for an entry by index number
+#[command]
+pub async fn search_get_content_url(index_no: usize) -> std::result::Result {
+ with_read_access(|app| app.get_content_url(index_no)).into_string_result()
+}
+
+/// Get total entry count
+#[command]
+pub async fn search_get_entry_count() -> std::result::Result {
+ with_read_access(|app| app.get_entry_count()).into_string_result()
+}
+
+/// Find index by keyword
+#[command]
+pub async fn search_find_index(key: String) -> std::result::Result {
+ with_write_access(|app| {
+ let group_indexes = app.find_index(&key)?;
+
+ // Convert LinkedList to JSON array
+ let mut result = Vec::new();
+ for group_index in group_indexes {
+ result.push(serde_json::json!({
+ "profile_id": group_index.profile_id,
+ "primary_key": group_index.primary_key,
+ "indexes": group_index.indexes.iter().map(|idx| serde_json::json!({
+ "profile_id": idx.profile_id,
+ "entry_no": idx.key_index.entry_no,
+ "key": idx.key_index.key
+ })).collect::>()
+ }));
+ }
+
+ Ok(serde_json::Value::Array(result))
+ }).into_string_result()
+}
+
+/// Fulltext search (across single database or dictionary group)
+#[command]
+pub async fn search_fulltext_search(query: String, max_results: Option) -> std::result::Result {
+ let max_results = max_results.unwrap_or(200);
+ with_write_access(|app| {
+ let total = app.fulltext_search(&query, max_results)?;
+ Ok(serde_json::json!({
+ "start_entry_no": 0,
+ "total_count": total
+ }))
+ }).into_string_result()
+}
+
+/// Get result key list (paginated search results)
+#[command]
+pub async fn search_get_result_key_list(start_index_no: i64, max_count: usize) -> std::result::Result, String> {
+ with_write_access(|app| app.get_result_key_list(start_index_no, max_count)).into_string_result()
+}
+
+/// Get group indexes for a given index number
+#[command]
+pub async fn search_get_group_indexes(index_no: usize) -> std::result::Result {
+ with_write_access(|app| {
+ let group_indexes = app.get_group_indexes(index_no)?;
+
+ // Convert LinkedList to JSON array
+ let mut result = Vec::new();
+ for group_index in group_indexes {
+ result.push(serde_json::json!({
+ "profile_id": group_index.profile_id,
+ "primary_key": group_index.primary_key,
+ "indexes": group_index.indexes.iter().map(|idx| serde_json::json!({
+ "profile_id": idx.profile_id,
+ "entry_no": idx.key_index.entry_no,
+ "key": idx.key_index.key
+ })).collect::>()
+ }));
+ }
+
+ Ok(serde_json::Value::Array(result))
+ }).into_string_result()
+}
+
diff --git a/rust/src-tauri/src/system_cmd.rs b/rust/src-tauri/src/system_cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..119a31a57711f4547db0de65ab8a8bc362340a4c
--- /dev/null
+++ b/rust/src-tauri/src/system_cmd.rs
@@ -0,0 +1,11 @@
+// System commands module - Tauri command implementations for system-level operations
+use tauri::command;
+
+use crate::error::IntoStringResult;
+use crate::mdict_app::with_write_access;
+
+/// Set base URL for MDX protocol
+#[command]
+pub async fn system_set_base_url(base_url: String) -> std::result::Result<(), String> {
+ with_write_access(|app| app.set_base_url(base_url)).into_string_result()
+}
diff --git a/rust/src-tauri/src/utils.rs b/rust/src-tauri/src/utils.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c098efb90bbcd5803c97a731c136752b2cd9c0af
--- /dev/null
+++ b/rust/src-tauri/src/utils.rs
@@ -0,0 +1,11 @@
+use log::error;
+
+use mdx::Result;
+
+use crate::error_printer;
+
+pub fn log_if_err(e: &Result<()>) {
+ if let Err(e) = e {
+ error!("{}", error_printer::format_error(&e));
+ }
+}
\ No newline at end of file
diff --git a/rust/src-tauri/tauri.conf.json b/rust/src-tauri/tauri.conf.json
new file mode 100644
index 0000000000000000000000000000000000000000..fa9d1c5fe3a44c15ef3c5bdd835589b49a85fc4d
--- /dev/null
+++ b/rust/src-tauri/tauri.conf.json
@@ -0,0 +1,44 @@
+{
+ "$schema": "https://schema.tauri.app/config/2",
+ "productName": "词典",
+ "version": "0.1.0",
+ "identifier": "cn.mdict.mdict-app",
+ "build": {
+ "beforeDevCommand": "yarn dev",
+ "devUrl": "http://localhost:1420",
+ "beforeBuildCommand": "yarn build",
+ "frontendDist": "../dist"
+ },
+ "app": {
+ "windows": [
+ {
+ "title": "词典",
+ "width": 1200,
+ "height": 800,
+ "minWidth": 800,
+ "minHeight": 600,
+ "resizable": true,
+ "fullscreen": false
+ }
+ ],
+ "security": {
+ "csp": null,
+ "assetProtocol": {
+ "enable": true,
+ "scope": ["**"]
+ }
+ }
+ },
+ "bundle": {
+ "active": true,
+ "targets": "all",
+ "resources": [],
+ "icon": [
+ "icons/32x32.png",
+ "icons/128x128.png",
+ "icons/128x128@2x.png",
+ "icons/icon.icns",
+ "icons/icon.ico"
+ ]
+ }
+}
diff --git a/rust/src/App.tsx b/rust/src/App.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..30ec6354c361d703f67a07720a59dfe3abaf2195
--- /dev/null
+++ b/rust/src/App.tsx
@@ -0,0 +1,339 @@
+import { useState, useEffect, useRef, useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import { MdxGroupIndex } from './types';
+import { useSearchStore, useSettingsStore } from './store';
+import { LibraryView } from './pages/LibraryView';
+import { SearchView, SearchViewRef } from './pages/SearchView';
+import { HistoryView } from './pages/HistoryView';
+import { FavoritesView } from './pages/FavoritesView';
+import { SettingsView } from './pages/SettingsView';
+import {
+ IonApp,
+ IonIcon,
+ IonLabel,
+ IonRouterOutlet,
+ IonTabs,
+ IonTabBar,
+ IonTabButton,
+ IonAlert,
+ setupIonicReact,
+} from '@ionic/react';
+import { IonReactRouter } from '@ionic/react-router';
+import { Redirect, Route } from 'react-router-dom';
+import {
+ searchOutline,
+ libraryOutline,
+ timeOutline,
+ heartOutline,
+ settingsOutline,
+} from 'ionicons/icons';
+import {
+ applyIonicTheme,
+ getEffectiveThemeMode,
+ getEffectiveThemePreset,
+} from './ionicTheme';
+import { listen } from '@tauri-apps/api/event';
+import { readText as tauriReadText } from '@tauri-apps/plugin-clipboard-manager';
+
+// Initialize Ionic - mode will be set dynamically
+// We need to get the initial theme preset from the store before setupIonicReact is called
+const getInitialThemePreset = (): 'ios' | 'md' => {
+ const stored = localStorage.getItem('settings-storage');
+ if (stored) {
+ try {
+ const parsed = JSON.parse(stored);
+ const themePreset = parsed.state?.themePreset || 'auto';
+ return getEffectiveThemePreset(themePreset);
+ } catch (e) {
+ return getEffectiveThemePreset('auto');
+ }
+ }
+ return getEffectiveThemePreset('auto');
+};
+
+setupIonicReact({
+ rippleEffect: true,
+ mode: getInitialThemePreset(),
+});
+/**
+ * Tab item configuration
+ */
+interface TabItem {
+ id: string;
+ titleKey: string;
+ icon: string;
+ path: string;
+}
+
+const tabItems: TabItem[] = [
+ { id: 'search', titleKey: 'Search', icon: searchOutline, path: '/search' },
+ { id: 'library', titleKey: 'Library', icon: libraryOutline, path: '/library' },
+ { id: 'history', titleKey: 'History', icon: timeOutline, path: '/history' },
+ { id: 'favorites', titleKey: 'Favorites', icon: heartOutline, path: '/favorites' },
+ { id: 'settings', titleKey: 'Settings', icon: settingsOutline, path: '/settings' },
+];
+
+/**
+ * App Component
+ *
+ * Main application component with Ionic React navigation and layout.
+ * Uses Zustand stores for state management.
+ *
+ * Architecture:
+ * - Layout: IonTabs with adaptive positioning (side on desktop, bottom on mobile)
+ * - Navigation: React Router with IonReactRouter
+ * - State: Theme preferences, error handling
+ * - Store usage: Direct store imports, no provider needed
+ */
+function App() {
+ const { t } = useTranslation();
+
+ // Use Zustand stores - separate actions from state to reduce re-renders
+ const useProfile = useSearchStore((state) => state.useProfile);
+ const performSearch = useSearchStore ((state) => state.performSearch);
+ const searchTerm = useSearchStore ((state) => state.searchTerm);
+
+ // Subscribe to theme settings from store
+ const themePreset = useSettingsStore((state) => state.themePreset);
+ const themeMode = useSettingsStore((state) => state.themeMode);// const location = useLocation();
+
+ // Get effective theme preset (resolves 'auto' to actual platform)
+ const effectiveThemePreset = getEffectiveThemePreset(themePreset);
+
+ const [errorAlert, setErrorAlert] = useState<{ open: boolean; message: string }>({
+ open: false,
+ message: ''
+ });
+
+ // Effective theme mode (derived from themeMode)
+ const [effectiveThemeMode, setEffectiveThemeMode] = useState<'light' | 'dark'>(() =>
+ getEffectiveThemeMode(themeMode)
+ );
+
+ // Ref for SearchView
+ const searchViewRef = useRef(null);
+
+ const setActiveTab = (tab: string) => {
+ const tabElement = document.querySelector(`[tab="${tab}"]`) as HTMLElement;
+ if (tab) {
+ tabElement.click();
+ }
+ };
+
+ // Handle library selection
+ const handleSelectLibrary = useCallback(async (profileId?: number) => {
+ try {
+ if (profileId) {
+ const lastSearchTerm = searchTerm;
+ await useProfile(profileId);
+ if (lastSearchTerm) {
+ performSearch(lastSearchTerm);
+ }
+ // Trigger search tab click
+ setActiveTab('search');
+ }
+ //TODO: Should recreate useSearchStore here.
+ } catch (error) {
+ console.error('Failed to open library:', error);
+ setErrorAlert({
+ open: true,
+ message: t('Failed to open library. Please check if the dictionary file exists or try again.')
+ });
+ }
+ }, [useProfile, performSearch, searchTerm]);
+
+
+ // Handle entry selection from history/favorites
+ const handleEntrySelect = useCallback((groupIndexes: MdxGroupIndex[], addToHistory: boolean = true) => {
+ if (searchViewRef.current) {
+ searchViewRef.current.displayByEntry(groupIndexes, addToHistory);
+ }
+ setActiveTab('search');
+ }, [searchViewRef]);
+
+
+ const handleCloseErrorAlert = useCallback(() => {
+ setErrorAlert({ open: false, message: '' });
+ }, [setErrorAlert]);
+
+
+ // Update effective theme mode when themeMode changes
+ useEffect(() => {
+ const newEffectiveMode = getEffectiveThemeMode(themeMode);
+ setEffectiveThemeMode(newEffectiveMode);
+ }, [themeMode]);
+
+ // Apply Ionic theme when preset or mode changes
+ useEffect(() => {
+ applyIonicTheme({ preset: effectiveThemePreset, mode: effectiveThemeMode });
+ }, [effectiveThemePreset, effectiveThemeMode]);
+
+ // Listen for system theme changes when in auto mode
+ useEffect(() => {
+ if (themeMode !== 'auto') return;
+
+ const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+ const handleChange = (e: MediaQueryListEvent) => {
+ const newMode = e.matches ? 'dark' : 'light';
+ setEffectiveThemeMode(newMode);
+ };
+
+ // Modern browsers
+ if (mediaQuery.addEventListener) {
+ mediaQuery.addEventListener('change', handleChange);
+ return () => mediaQuery.removeEventListener('change', handleChange);
+ }
+ // Fallback for older browsers
+ else if (mediaQuery.addListener) {
+ mediaQuery.addListener(handleChange);
+ return () => mediaQuery.removeListener(handleChange);
+ }
+ }, [themeMode]);
+
+
+ // Auto lookup clipboard on window focus
+ const autoLookupClipboard = useSettingsStore((state) => state.globalSettings.autoLookupClipboard);
+
+ // Listen for window focus event from backend and check clipboard changes
+ useEffect(() => {
+ let unlisten: (() => void) | undefined;
+ let lastClipboardText: string | null = null;
+
+ const setupWindowFocusListener = async () => {
+ try {
+ // Initialize last clipboard text
+ try {
+ lastClipboardText = await tauriReadText();
+ } catch (error) {
+ console.error('Failed to read initial clipboard:', error);
+ }
+
+ // Listen for window-focus event from backend
+ unlisten = await listen('window-focus', async () => {
+
+ // Only proceed if autoLookupClipboard is enabled
+ if (!autoLookupClipboard) {
+ return;
+ }
+
+ try {
+ // Read current clipboard content
+ const currentClipboardText = await tauriReadText();
+
+ // Check if clipboard content has changed
+ if (currentClipboardText &&
+ currentClipboardText.trim() &&
+ currentClipboardText !== lastClipboardText) {
+
+ // Update last clipboard text
+ lastClipboardText = currentClipboardText;
+
+ // Perform lookup
+ if (searchViewRef.current) {
+ searchViewRef.current.displayByKey(currentClipboardText.trim(), true);
+ }
+ setActiveTab('search');
+ }
+ } catch (error) {
+ console.error('Failed to read clipboard on window focus:', error);
+ }
+ });
+ } catch (error) {
+ console.error('Failed to setup window focus listener:', error);
+ }
+ };
+ setupWindowFocusListener();
+
+ // Cleanup listener on unmount
+ return () => {
+ if (unlisten) {
+ unlisten();
+ }
+ };
+ }, [searchViewRef, autoLookupClipboard]);
+
+ return (
+
+
+
+ {/* Main Content */}
+
+ handleEntrySelect(groupIndexes, false)}
+ />}
+ exact
+ />
+
+ handleEntrySelect(groupIndexes, true)}
+ />}
+ exact
+ />
+
+