margin/src-tauri/src/lib.rs

mod epub;
mod fonts;
mod gdrive;
mod library;
#[cfg(target_os = "macos")]
mod macspell;
mod pdf;
mod project;
mod proofing;

#[cfg(desktop)]
use tauri::menu::{Menu, MenuItemBuilder, MenuItemKind, PredefinedMenuItem, SubmenuBuilder};
#[cfg(desktop)]
use tauri::{Emitter, Runtime};

#[cfg(desktop)]
fn build_menu<R: Runtime>(handle: &tauri::AppHandle<R>) -> tauri::Result<Menu<R>> {
    let menu = Menu::default(handle)?;

    let new_book = MenuItemBuilder::with_id("new-book", "New Book")
        .accelerator("CmdOrCtrl+N")
        .build(handle)?;
    let save = MenuItemBuilder::with_id("save", "Save")
        .accelerator("CmdOrCtrl+S")
        .build(handle)?;
    let export_pdf = MenuItemBuilder::with_id("export-pdf", "Export as PDF…")
        .accelerator("CmdOrCtrl+Shift+P")
        .build(handle)?;
    let export_epub = MenuItemBuilder::with_id("export-epub", "Export as EPUB…")
        .accelerator("CmdOrCtrl+Shift+E")
        .build(handle)?;
    let check_updates =
        MenuItemBuilder::with_id("check-updates", "Check for Updates…").build(handle)?;
    let settings = MenuItemBuilder::with_id("settings", "Settings…")
        .accelerator("CmdOrCtrl+,")
        .build(handle)?;
    let find = MenuItemBuilder::with_id("find", "Find…")
        .accelerator("CmdOrCtrl+F")
        .build(handle)?;
    let report_issue =
        MenuItemBuilder::with_id("report-issue", "Report an Issue…").build(handle)?;

    let submenus: Vec<_> = menu
        .items()?
        .into_iter()
        .filter_map(|item| match item {
            MenuItemKind::Submenu(submenu) => Some(submenu),
            _ => None,
        })
        .collect();

    let find_submenu = |name: &str| {
        submenus
            .iter()
            .find(|submenu| submenu.text().map(|t| t == name).unwrap_or(false))
            .cloned()
    };

    match find_submenu("File") {
        Some(submenu) => {
            submenu.prepend_items(&[
                &new_book,
                &PredefinedMenuItem::separator(handle)?,
                &save,
                &PredefinedMenuItem::separator(handle)?,
                &export_pdf,
                &export_epub,
                &PredefinedMenuItem::separator(handle)?,
            ])?;
        }
        None => {
            let submenu = SubmenuBuilder::new(handle, "File")
                .item(&new_book)
                .item(&PredefinedMenuItem::separator(handle)?)
                .item(&save)
                .item(&PredefinedMenuItem::separator(handle)?)
                .item(&export_pdf)
                .item(&export_epub)
                .build()?;
            menu.insert(&submenu, 1)?;
        }
    }

    if let Some(edit) = find_submenu("Edit") {
        edit.append_items(&[&PredefinedMenuItem::separator(handle)?, &find])?;
    }

    if let Some(help) = find_submenu("Help") {
        help.append_items(&[&report_issue])?;
    }

    #[cfg(target_os = "macos")]
    {
        if let Some(app_submenu) = submenus.first() {
            app_submenu.insert(&check_updates, 1)?;
            app_submenu.insert(&settings, 3)?;
            app_submenu.insert(&PredefinedMenuItem::separator(handle)?, 4)?;
        }
        if let Some(view) = find_submenu("View") {
            let toggle_chapters = MenuItemBuilder::with_id("toggle-chapters", "Toggle Chapters")
                .accelerator("CmdOrCtrl+\\")
                .build(handle)?;
            let next_chapter = MenuItemBuilder::with_id("next-chapter", "Next Chapter")
                .accelerator("CmdOrCtrl+Alt+Down")
                .build(handle)?;
            let prev_chapter = MenuItemBuilder::with_id("prev-chapter", "Previous Chapter")
                .accelerator("CmdOrCtrl+Alt+Up")
                .build(handle)?;
            view.prepend_items(&[
                &toggle_chapters,
                &PredefinedMenuItem::separator(handle)?,
                &next_chapter,
                &prev_chapter,
                &PredefinedMenuItem::separator(handle)?,
            ])?;
        }
    }

    #[cfg(not(target_os = "macos"))]
    {
        if let Some(file) = find_submenu("File") {
            file.append_items(&[&PredefinedMenuItem::separator(handle)?, &check_updates])?;
        }
        if let Some(edit) = find_submenu("Edit") {
            edit.append_items(&[&settings])?;
        }
    }

    Ok(menu)
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    let context = tauri::generate_context!();

    #[cfg_attr(mobile, allow(unused_mut))]
    let mut builder = tauri::Builder::default()
        .plugin(tauri_plugin_opener::init())
        .plugin(tauri_plugin_dialog::init());

    #[cfg(desktop)]
    {
        builder = builder.plugin(tauri_plugin_process::init());
        if context.config().plugins.0.contains_key("updater") {
            builder = builder.plugin(tauri_plugin_updater::Builder::new().build());
        }
    }

    builder = builder
        .manage(proofing::new_state())
        .manage(gdrive::GDriveState::default())
        .setup(|app| {
            gdrive::init_session(app.handle());
            Ok(())
        });

    #[cfg(desktop)]
    {
        builder = builder
            .menu(|handle| build_menu(handle))
            .on_menu_event(|app, event| {
                if matches!(
                    event.id().0.as_str(),
                    "new-book"
                        | "save"
                        | "export-pdf"
                        | "export-epub"
                        | "check-updates"
                        | "settings"
                        | "find"
                        | "toggle-chapters"
                        | "next-chapter"
                        | "prev-chapter"
                        | "report-issue"
                ) {
                    app.emit("menu-action", event.id().0.as_str()).ok();
                }
            });
    }

    builder
        .invoke_handler(tauri::generate_handler![
            epub::package_epub,
            epub::unzip_epub,
            fonts::list_system_fonts,
            pdf::compile_pdf,
            project::read_file,
            project::write_file,
            project::write_bytes,
            library::list_books,
            library::load_book,
            library::save_book,
            library::delete_book,
            proofing::proof_text,
            proofing::remember_word,
            gdrive::gdrive_connect,
            gdrive::gdrive_disconnect,
            gdrive::gdrive_status,
            gdrive::gdrive_backup,
            gdrive::gdrive_restore,
            gdrive::gdrive_list_backups
        ])
        .run(context)
        .expect("error while running margin");
}