@bghitcode/bghitapp 1.0.0

package/src-tauri/src/app/config.rs

@@ -0,0 +1,100 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct WindowConfig {
+    pub url: String,
+    pub hide_title_bar: bool,
+    pub fullscreen: bool,
+    pub maximize: bool,
+    pub width: f64,
+    pub height: f64,
+    pub resizable: bool,
+    pub url_type: String,
+    pub always_on_top: bool,
+    pub dark_mode: bool,
+    pub disabled_web_shortcuts: bool,
+    pub activation_shortcut: String,
+    pub hide_on_close: bool,
+    pub incognito: bool,
+    pub title: Option<String>,
+    pub enable_wasm: bool,
+    pub enable_drag_drop: bool,
+    #[serde(default)]
+    pub new_window: bool,
+    pub start_to_tray: bool,
+    #[serde(default)]
+    pub force_internal_navigation: bool,
+    #[serde(default)]
+    pub internal_url_regex: String,
+    #[serde(default)]
+    pub enable_find: bool,
+    #[serde(default = "default_zoom")]
+    pub zoom: u32,
+    #[serde(default)]
+    pub min_width: f64,
+    #[serde(default)]
+    pub min_height: f64,
+    #[serde(default)]
+    pub ignore_certificate_errors: bool,
+    #[serde(default)]
+    pub splash: String,
+    #[serde(default)]
+    pub auto_splash: bool,
+    #[serde(default)]
+    pub offline: bool,
+}
+
+fn default_zoom() -> u32 {
+    100
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct PlatformSpecific<T> {
+    pub macos: T,
+    pub linux: T,
+    pub windows: T,
+}
+
+impl<T> PlatformSpecific<T> {
+    pub const fn get(&self) -> &T {
+        #[cfg(target_os = "macos")]
+        let platform = &self.macos;
+        #[cfg(target_os = "linux")]
+        let platform = &self.linux;
+        #[cfg(target_os = "windows")]
+        let platform = &self.windows;
+
+        platform
+    }
+}
+
+impl<T> PlatformSpecific<T>
+where
+    T: Copy,
+{
+    pub const fn copied(&self) -> T {
+        *self.get()
+    }
+}
+
+pub type UserAgent = PlatformSpecific<String>;
+pub type FunctionON = PlatformSpecific<bool>;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct BghitappConfig {
+    pub windows: Vec<WindowConfig>,
+    pub user_agent: UserAgent,
+    pub system_tray: FunctionON,
+    pub system_tray_path: String,
+    pub proxy_url: String,
+    #[serde(default)]
+    pub multi_instance: bool,
+    #[serde(default)]
+    pub multi_window: bool,
+}
+
+impl BghitappConfig {
+    pub fn show_system_tray(&self) -> bool {
+        self.system_tray.copied()
+    }
+}

package/src-tauri/src/app/invoke.rs

@@ -0,0 +1,242 @@
+use crate::util::{check_file_or_append, get_download_message_with_lang, show_toast, MessageType};
+use std::fs::File;
+use std::io::Write;
+use std::str::FromStr;
+use std::sync::atomic::{AtomicI64, Ordering};
+use tauri::http::Method;
+use tauri::{command, AppHandle, Manager, Url, WebviewWindow};
+use tauri_plugin_http::reqwest::{ClientBuilder, Request};
+
+#[cfg(target_os = "macos")]
+use tauri::Theme;
+
+static BADGE_COUNT: AtomicI64 = AtomicI64::new(0);
+const MAX_BADGE_COUNT: i64 = 99_999;
+const MAX_BADGE_LABEL_CHARS: usize = 16;
+
+fn normalize_badge_count(count: Option<i64>) -> Option<i64> {
+    count.filter(|n| (1..=MAX_BADGE_COUNT).contains(n))
+}
+
+fn normalize_badge_label(label: Option<&str>) -> Result<Option<String>, String> {
+    let Some(label) = label.map(str::trim).filter(|label| !label.is_empty()) else {
+        return Ok(None);
+    };
+
+    if label.chars().count() > MAX_BADGE_LABEL_CHARS {
+        return Err(format!(
+            "Badge label must be {MAX_BADGE_LABEL_CHARS} characters or fewer"
+        ));
+    }
+
+    Ok(Some(label.to_string()))
+}
+
+fn apply_badge(app: &AppHandle, count: Option<i64>) -> Result<(), String> {
+    let label = normalize_badge_count(count).map(|n| n.to_string());
+    apply_badge_label(app, label.as_deref())
+}
+
+#[cfg(target_os = "macos")]
+fn apply_badge_label(app: &AppHandle, label: Option<&str>) -> Result<(), String> {
+    use objc2::MainThreadMarker;
+    use objc2_app_kit::NSApplication;
+    use objc2_foundation::NSString;
+
+    let label = label.map(str::to_owned);
+    app.run_on_main_thread(move || {
+        let Some(mtm) = MainThreadMarker::new() else {
+            return;
+        };
+        let dock_tile = NSApplication::sharedApplication(mtm).dockTile();
+        let ns_label = label.as_deref().map(NSString::from_str);
+        dock_tile.setBadgeLabel(ns_label.as_deref());
+    })
+    .map_err(|e| format!("Failed to dispatch dock badge update: {e}"))
+}
+
+#[cfg(not(target_os = "macos"))]
+fn apply_badge_label(app: &AppHandle, label: Option<&str>) -> Result<(), String> {
+    let window = app
+        .get_webview_window("bghitapp")
+        .ok_or("Main window not found")?;
+    let count = label.and_then(|s| s.parse::<i64>().ok());
+    window
+        .set_badge_count(count)
+        .map_err(|e| format!("Failed to set badge count: {e}"))
+}
+
+#[derive(serde::Deserialize)]
+pub struct DownloadFileParams {
+    url: String,
+    filename: String,
+    language: Option<String>,
+}
+
+#[derive(serde::Deserialize)]
+pub struct NotificationParams {
+    title: String,
+    body: String,
+    icon: String,
+}
+
+#[command]
+pub async fn download_file(app: AppHandle, params: DownloadFileParams) -> Result<(), String> {
+    let window: WebviewWindow = app.get_webview_window("bghitapp").ok_or("Window not found")?;
+
+    show_toast(
+        &window,
+        &get_download_message_with_lang(MessageType::Start, params.language.clone()),
+    );
+
+    let download_dir = app
+        .path()
+        .download_dir()
+        .map_err(|e| format!("Failed to get download dir: {}", e))?;
+
+    let output_path = download_dir.join(&params.filename);
+
+    let path_str = output_path.to_str().ok_or("Invalid output path")?;
+
+    let file_path = check_file_or_append(path_str);
+
+    let client = ClientBuilder::new()
+        .build()
+        .map_err(|e| format!("Failed to build client: {}", e))?;
+
+    let url = Url::from_str(&params.url).map_err(|e| format!("Invalid URL: {}", e))?;
+
+    let request = Request::new(Method::GET, url);
+
+    let response = client.execute(request).await;
+
+    match response {
+        Ok(mut res) => {
+            let mut file =
+                File::create(file_path).map_err(|e| format!("Failed to create file: {}", e))?;
+
+            while let Some(chunk) = res
+                .chunk()
+                .await
+                .map_err(|e| format!("Failed to get chunk: {}", e))?
+            {
+                file.write_all(&chunk)
+                    .map_err(|e| format!("Failed to write chunk: {}", e))?;
+            }
+
+            show_toast(
+                &window,
+                &get_download_message_with_lang(MessageType::Success, params.language.clone()),
+            );
+            Ok(())
+        }
+        Err(e) => {
+            show_toast(
+                &window,
+                &get_download_message_with_lang(MessageType::Failure, params.language),
+            );
+            Err(e.to_string())
+        }
+    }
+}
+
+#[command]
+pub fn send_notification(app: AppHandle, params: NotificationParams) -> Result<(), String> {
+    use tauri_plugin_notification::NotificationExt;
+    app.notification()
+        .builder()
+        .title(&params.title)
+        .body(&params.body)
+        .icon(&params.icon)
+        .show()
+        .map_err(|e| format!("Failed to show notification: {}", e))?;
+    Ok(())
+}
+
+#[command]
+pub fn set_dock_badge(app: AppHandle, count: Option<i64>) -> Result<(), String> {
+    let normalized = normalize_badge_count(count);
+    BADGE_COUNT.store(normalized.unwrap_or(0), Ordering::SeqCst);
+    apply_badge(&app, normalized)
+}
+
+#[command]
+pub fn increment_dock_badge(app: AppHandle) -> Result<(), String> {
+    let current = BADGE_COUNT.load(Ordering::SeqCst);
+    let next = current.saturating_add(1).clamp(1, MAX_BADGE_COUNT);
+    BADGE_COUNT.store(next, Ordering::SeqCst);
+    apply_badge(&app, Some(next))
+}
+
+#[command]
+pub fn clear_dock_badge(app: AppHandle) -> Result<(), String> {
+    BADGE_COUNT.store(0, Ordering::SeqCst);
+    apply_badge(&app, None)
+}
+
+#[command]
+pub fn set_dock_badge_label(app: AppHandle, label: Option<String>) -> Result<(), String> {
+    BADGE_COUNT.store(0, Ordering::SeqCst);
+    let label = normalize_badge_label(label.as_deref())?;
+    apply_badge_label(&app, label.as_deref())
+}
+
+#[command]
+pub async fn update_theme_mode(app: AppHandle, mode: String) {
+    #[cfg(target_os = "macos")]
+    {
+        if let Some(window) = app.get_webview_window("bghitapp") {
+            let theme = if mode == "dark" {
+                Theme::Dark
+            } else {
+                Theme::Light
+            };
+            let _ = window.set_theme(Some(theme));
+        }
+    }
+    #[cfg(not(target_os = "macos"))]
+    {
+        let _ = app;
+        let _ = mode;
+    }
+}
+
+#[command]
+#[allow(unreachable_code)]
+pub fn clear_cache_and_restart(app: AppHandle) -> Result<(), String> {
+    if let Some(window) = app.get_webview_window("bghitapp") {
+        match window.clear_all_browsing_data() {
+            Ok(_) => {
+                // Clear all browsing data successfully
+                app.restart();
+                Ok(())
+            }
+            Err(e) => {
+                eprintln!("Failed to clear browsing data: {}", e);
+                Err(format!("Failed to clear browsing data: {}", e))
+            }
+        }
+    } else {
+        Err("Main window not found".to_string())
+    }
+}
+
+#[command]
+pub async fn close_splashscreen(app: AppHandle) -> Result<(), String> {
+    if let Some(splash) = app.get_webview_window("splash") {
+        let _ = splash.eval("document.body.classList.add('fade-out')");
+        tokio::time::sleep(tokio::time::Duration::from_millis(300)).await;
+        if let Err(e) = splash.destroy() {
+            eprintln!("[BghitApp] Failed to destroy splash window: {}", e);
+        }
+    }
+    if let Some(main) = app.get_webview_window("bghitapp") {
+        if let Err(e) = main.show() {
+            eprintln!("[BghitApp] Failed to show main window: {}", e);
+        }
+        if let Err(e) = main.set_focus() {
+            eprintln!("[BghitApp] Failed to focus main window: {}", e);
+        }
+    }
+    Ok(())
+}

package/src-tauri/src/app/menu.rs

@@ -0,0 +1,324 @@
+// Menu functionality is only used on macOS
+#![cfg(target_os = "macos")]
+
+use crate::app::window::open_additional_window_safe;
+use tauri::menu::{AboutMetadata, Menu, MenuItem, PredefinedMenuItem, Submenu};
+use tauri::{AppHandle, Manager, Wry};
+use tauri_plugin_opener::OpenerExt;
+
+pub fn set_app_menu(
+    app: &AppHandle<Wry>,
+    allow_multi_window: bool,
+    enable_find: bool,
+) -> tauri::Result<()> {
+    let bghitapp_version = env!("CARGO_PKG_VERSION");
+    let bghitapp_menu_item_title = format!("Built with BghitApp V{}", bghitapp_version);
+
+    let window_submenu = window_menu(app)?;
+
+    let menu = Menu::with_items(
+        app,
+        &[
+            &app_menu(app)?,
+            &file_menu(app, allow_multi_window)?,
+            &edit_menu(app, enable_find)?,
+            &view_menu(app)?,
+            &navigation_menu(app)?,
+            &window_submenu,
+            &help_menu(app, &bghitapp_menu_item_title)?,
+        ],
+    )?;
+
+    app.set_menu(menu)?;
+
+    // AppKit injects Move & Resize, Fill, Center, Full Screen Tile, and
+    // window-cycling once the submenu is registered as the windows menu.
+    window_submenu.set_as_windows_menu_for_nsapp()?;
+
+    Ok(())
+}
+
+fn app_menu(app: &AppHandle<Wry>) -> tauri::Result<Submenu<Wry>> {
+    let app_menu = Submenu::new(app, "BghitApp", true)?;
+    let about_metadata = AboutMetadata::default();
+    app_menu.append(&PredefinedMenuItem::about(
+        app,
+        Some("BghitApp"),
+        Some(about_metadata),
+    )?)?;
+    app_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    app_menu.append(&PredefinedMenuItem::services(app, None)?)?;
+    app_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    app_menu.append(&PredefinedMenuItem::hide(app, None)?)?;
+    app_menu.append(&PredefinedMenuItem::hide_others(app, None)?)?;
+    app_menu.append(&PredefinedMenuItem::show_all(app, None)?)?;
+    app_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    app_menu.append(&PredefinedMenuItem::quit(app, None)?)?;
+    Ok(app_menu)
+}
+
+fn file_menu(app: &AppHandle<Wry>, allow_multi_window: bool) -> tauri::Result<Submenu<Wry>> {
+    let file_menu = Submenu::new(app, "File", true)?;
+    if allow_multi_window {
+        file_menu.append(&MenuItem::with_id(
+            app,
+            "new_window",
+            "New Window",
+            true,
+            Some("CmdOrCtrl+N"),
+        )?)?;
+        file_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    }
+    file_menu.append(&PredefinedMenuItem::close_window(app, None)?)?;
+    file_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    file_menu.append(&MenuItem::with_id(
+        app,
+        "clear_cache_restart",
+        "Clear Cache & Restart",
+        true,
+        Some("CmdOrCtrl+Shift+Backspace"),
+    )?)?;
+    Ok(file_menu)
+}
+
+fn edit_menu(app: &AppHandle<Wry>, enable_find: bool) -> tauri::Result<Submenu<Wry>> {
+    let edit_menu = Submenu::new(app, "Edit", true)?;
+    edit_menu.append(&PredefinedMenuItem::undo(app, None)?)?;
+    edit_menu.append(&PredefinedMenuItem::redo(app, None)?)?;
+    edit_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    edit_menu.append(&PredefinedMenuItem::cut(app, None)?)?;
+    edit_menu.append(&PredefinedMenuItem::copy(app, None)?)?;
+    edit_menu.append(&PredefinedMenuItem::paste(app, None)?)?;
+    edit_menu.append(&MenuItem::with_id(
+        app,
+        "paste_and_match_style",
+        "Paste and Match Style",
+        true,
+        Some("CmdOrCtrl+Shift+Option+V"),
+    )?)?;
+    edit_menu.append(&PredefinedMenuItem::select_all(app, None)?)?;
+    edit_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    if enable_find {
+        edit_menu.append(&MenuItem::with_id(
+            app,
+            "find",
+            "Find",
+            true,
+            Some("CmdOrCtrl+F"),
+        )?)?;
+        edit_menu.append(&MenuItem::with_id(
+            app,
+            "find_next",
+            "Find Next",
+            true,
+            Some("CmdOrCtrl+G"),
+        )?)?;
+        edit_menu.append(&MenuItem::with_id(
+            app,
+            "find_previous",
+            "Find Previous",
+            true,
+            Some("CmdOrCtrl+Shift+G"),
+        )?)?;
+        edit_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    }
+    edit_menu.append(&MenuItem::with_id(
+        app,
+        "copy_url",
+        "Copy URL",
+        true,
+        Some("CmdOrCtrl+L"),
+    )?)?;
+    Ok(edit_menu)
+}
+
+fn view_menu(app: &AppHandle<Wry>) -> tauri::Result<Submenu<Wry>> {
+    let view_menu = Submenu::new(app, "View", true)?;
+    view_menu.append(&MenuItem::with_id(
+        app,
+        "reload",
+        "Reload",
+        true,
+        Some("CmdOrCtrl+R"),
+    )?)?;
+    view_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    view_menu.append(&MenuItem::with_id(
+        app,
+        "zoom_in",
+        "Zoom In",
+        true,
+        Some("CmdOrCtrl+="),
+    )?)?;
+    view_menu.append(&MenuItem::with_id(
+        app,
+        "zoom_out",
+        "Zoom Out",
+        true,
+        Some("CmdOrCtrl+-"),
+    )?)?;
+    view_menu.append(&MenuItem::with_id(
+        app,
+        "zoom_reset",
+        "Actual Size",
+        true,
+        Some("CmdOrCtrl+0"),
+    )?)?;
+    view_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    view_menu.append(&PredefinedMenuItem::fullscreen(app, None)?)?;
+    view_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    view_menu.append(&MenuItem::with_id(
+        app,
+        "toggle_devtools",
+        "Toggle Developer Tools",
+        cfg!(debug_assertions),
+        Some("CmdOrCtrl+Option+I"),
+    )?)?;
+    Ok(view_menu)
+}
+
+fn navigation_menu(app: &AppHandle<Wry>) -> tauri::Result<Submenu<Wry>> {
+    let navigation_menu = Submenu::new(app, "Navigation", true)?;
+    navigation_menu.append(&MenuItem::with_id(
+        app,
+        "go_back",
+        "Back",
+        true,
+        Some("CmdOrCtrl+["),
+    )?)?;
+    navigation_menu.append(&MenuItem::with_id(
+        app,
+        "go_forward",
+        "Forward",
+        true,
+        Some("CmdOrCtrl+]"),
+    )?)?;
+    navigation_menu.append(&MenuItem::with_id(
+        app,
+        "go_home",
+        "Go Home",
+        true,
+        Some("CmdOrCtrl+Shift+H"),
+    )?)?;
+    Ok(navigation_menu)
+}
+
+fn window_menu(app: &AppHandle<Wry>) -> tauri::Result<Submenu<Wry>> {
+    let window_menu = Submenu::new(app, "Window", true)?;
+    window_menu.append(&PredefinedMenuItem::minimize(app, None)?)?;
+    window_menu.append(&PredefinedMenuItem::maximize(app, None)?)?;
+    window_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    window_menu.append(&MenuItem::with_id(
+        app,
+        "always_on_top",
+        "Toggle Always on Top",
+        true,
+        None::<&str>,
+    )?)?;
+    window_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    window_menu.append(&PredefinedMenuItem::close_window(app, None)?)?;
+    Ok(window_menu)
+}
+
+fn help_menu(app: &AppHandle<Wry>, title: &str) -> tauri::Result<Submenu<Wry>> {
+    let help_menu = Submenu::new(app, "Help", true)?;
+    let github_item = MenuItem::with_id(app, "bghitapp_github_link", title, true, None::<&str>)?;
+    help_menu.append(&github_item)?;
+    Ok(help_menu)
+}
+
+pub fn handle_menu_click(app_handle: &AppHandle, id: &str) {
+    match id {
+        "new_window" => {
+            open_additional_window_safe(app_handle);
+        }
+        "bghitapp_github_link" => {
+            let _ = app_handle
+                .opener()
+                .open_url("https://github.com/BghitCode/bghitapp", None::<&str>);
+        }
+        "reload" => {
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                let _ = window.eval("window.location.reload()");
+            }
+        }
+        "toggle_devtools" => {
+            #[cfg(debug_assertions)] // Only allow in debug builds
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                if window.is_devtools_open() {
+                    window.close_devtools();
+                } else {
+                    window.open_devtools();
+                }
+            }
+        }
+        "zoom_in" => {
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                let _ = window.eval("zoomIn()");
+            }
+        }
+        "zoom_out" => {
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                let _ = window.eval("zoomOut()");
+            }
+        }
+        "zoom_reset" => {
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                let _ = window.eval("setZoom('100%')");
+            }
+        }
+        "go_back" => {
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                let _ = window.eval("window.history.back()");
+            }
+        }
+        "go_forward" => {
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                let _ = window.eval("window.history.forward()");
+            }
+        }
+        "go_home" => {
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                let _ = window.eval("window.location.href = window.bghitappConfig.url");
+            }
+        }
+        "copy_url" => {
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                let _ = window.eval("navigator.clipboard.writeText(window.location.href)");
+            }
+        }
+        "paste_and_match_style" => {
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                let _ = window.eval("triggerPasteAsPlainText()");
+            }
+        }
+        "find" => {
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                let _ = window.eval("window.bghitappFind?.open()");
+            }
+        }
+        "find_next" => {
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                let _ = window.eval("window.bghitappFind?.next()");
+            }
+        }
+        "find_previous" => {
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                let _ = window.eval("window.bghitappFind?.previous()");
+            }
+        }
+        "clear_cache_restart" => {
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                if let Ok(_) = window.clear_all_browsing_data() {
+                    app_handle.restart();
+                }
+            }
+        }
+        "always_on_top" => {
+            if let Some(window) = app_handle.get_webview_window("bghitapp") {
+                let is_on_top = window.is_always_on_top().unwrap_or(false);
+                let _ = window.set_always_on_top(!is_on_top);
+            }
+        }
+        _ => {}
+    }
+}

package/src-tauri/src/app/mod.rs

@@ -0,0 +1,6 @@
+pub mod config;
+pub mod invoke;
+#[cfg(target_os = "macos")]
+pub mod menu;
+pub mod setup;
+pub mod window;