node_gui/

ui.rs

// #t(file: rust_hardcoded_url) user-facing product URLs opened in browser

//! Slint window construction, callback wiring, and event-loop polling.

use std::{cell::RefCell, rc::Rc, time::Duration};

use copypasta::{ClipboardContext, ClipboardProvider};
use slint::ComponentHandle;
use wowlab_node::{init_ui_logging, log_dir};

use crate::{
    AppWindow,
    app::{App, AppInitError},
    tray, update,
};

const POLL_INTERVAL: Duration = Duration::from_millis(100);
const CLIPBOARD_FEEDBACK_DURATION: Duration = Duration::from_secs(2);

#[derive(Debug, thiserror::Error)]
pub(crate) enum UiError {
    #[error(transparent)]
    Application(#[from] AppInitError),
    #[error("application window failed: {0}")]
    Window(#[from] slint::PlatformError),
}

pub(crate) fn run(no_update: bool) -> Result<(), UiError> {
    let (_logging_guard, log_rx) = init_ui_logging();

    let window = AppWindow::new()?;
    let app = Rc::new(RefCell::new(App::new(log_rx)?));

    initialize_window(&window, &app.borrow());
    wire_node_callbacks(&window, &app);
    wire_utility_callbacks(&window, &app);
    wire_settings_callbacks(&window, &app);

    if update::should_check_on_startup(no_update) {
        update::check_in_background(&window.as_weak());
    }

    let tray_state = tray::create_tray();
    let timer = start_poll_timer(&window, &app, tray_state);

    window.run()?;
    drop(timer);

    Ok(())
}

fn initialize_window(window: &AppWindow, app: &App) {
    window.set_version_text(format!("Version {}", crate::VERSION).into());
    window.set_cpu_cores(app.cpu_cores().to_string().into());
    window.set_node_name(app.node_name().into());
    window.set_public_key(app.public_key().into());
    window.set_app_state(app.state_name().into());
    window.set_connection_status(app.connection_status_name().into());
}

fn wire_node_callbacks(window: &AppWindow, app: &Rc<RefCell<App>>) {
    let window_weak = window.as_weak();

    window.on_token_changed(move |text| {
        let (error, valid) = crate::app::validate_token(&text);

        if let Some(window) = window_weak.upgrade() {
            window.set_token_error(error.into());
            window.set_token_valid(valid);
        }
    });

    let app_ref = Rc::clone(app);

    window.on_register(move |token| {
        app_ref.borrow_mut().register(token.to_string());
    });

    let app_ref = Rc::clone(app);
    let window_weak = window.as_weak();

    window.on_unlink(move || {
        if let Some(window) = window_weak.upgrade() {
            window.set_unlink_busy(true);
            window.set_unlink_error("".into());
        }

        app_ref.borrow_mut().request_unlink();
    });

    let app_ref = Rc::clone(app);
    let window_weak = window.as_weak();

    window.on_toggle_node(move || {
        if let Some(window) = window_weak.upgrade() {
            let enabled = window.get_node_enabled();

            if enabled {
                app_ref.borrow_mut().disconnect();
                window.set_node_enabled(false);
            } else {
                app_ref.borrow_mut().reconnect();
                window.set_node_enabled(true);
            }
        }
    });
}

fn wire_utility_callbacks(window: &AppWindow, app: &Rc<RefCell<App>>) {
    window.on_open_portal(|| {
        let _ = open::that("https://wowlab.gg/account/nodes?showToken");
    });

    window.on_open_logs(|| {
        if let Some(directory) = log_dir() {
            let _ = open::that(directory);
        }
    });

    let app_ref = Rc::clone(app);
    let window_weak = window.as_weak();

    window.on_copy_public_key(move || {
        let public_key = app_ref.borrow().public_key().to_string();

        copy_to_clipboard_with_feedback(&public_key, &window_weak);
    });

    let window_weak = window.as_weak();

    window.on_copy_log_entry(move |message| {
        copy_to_clipboard_with_feedback(&message, &window_weak);
    });

    let app_ref = Rc::clone(app);
    let window_weak = window.as_weak();

    window.on_set_filter(move |filter| {
        app_ref.borrow_mut().set_filter(filter);

        if let Some(window) = window_weak.upgrade() {
            app_ref.borrow().update_logs(&window);
        }
    });

    let app_ref = Rc::clone(app);
    let window_weak = window.as_weak();

    window.on_search_changed(move |text| {
        app_ref.borrow_mut().set_search_text(text.to_string());

        if let Some(window) = window_weak.upgrade() {
            app_ref.borrow().update_logs(&window);
        }
    });
}

fn wire_settings_callbacks(window: &AppWindow, app: &Rc<RefCell<App>>) {
    let window_weak = window.as_weak();

    window.on_check_for_updates(move || {
        update::check_in_background(&window_weak);
    });

    let window_weak = window.as_weak();

    window.on_toggle_minimize_to_tray(move || {
        if let Some(window) = window_weak.upgrade() {
            window.set_minimize_to_tray(!window.get_minimize_to_tray());
        }
    });

    let window_weak = window.as_weak();
    let app_ref = Rc::clone(app);

    window.window().on_close_requested(move || {
        if let Some(window) = window_weak.upgrade() {
            if app_ref.borrow().unlink_in_progress() {
                return slint::CloseRequestResponse::KeepWindowShown;
            }

            if window.get_minimize_to_tray() {
                let _ = window.hide();

                return slint::CloseRequestResponse::KeepWindowShown;
            }
        }

        slint::CloseRequestResponse::HideWindow
    });
}

fn start_poll_timer(
    window: &AppWindow,
    app: &Rc<RefCell<App>>,
    tray_state: Option<tray::TrayState>,
) -> slint::Timer {
    let timer = slint::Timer::default();
    let app_ref = Rc::clone(app);
    let window_weak = window.as_weak();

    timer.start(slint::TimerMode::Repeated, POLL_INTERVAL, move || {
        if let Some(window) = window_weak.upgrade() {
            let close_after_unlink = app_ref.borrow_mut().poll(&window);

            if close_after_unlink {
                let _ = slint::quit_event_loop();

                return;
            }
        }

        if let Some(ref tray) = tray_state {
            match tray::poll_tray_events(tray) {
                tray::TrayAction::Show => {
                    if let Some(window) = window_weak.upgrade() {
                        let _ = window.show();
                    }
                }
                tray::TrayAction::Quit => {
                    if !app_ref.borrow().unlink_in_progress() {
                        let _ = slint::quit_event_loop();
                    }
                }
                tray::TrayAction::None => {}
            }
        }
    });

    timer
}

fn copy_to_clipboard_with_feedback(text: &str, window: &slint::Weak<AppWindow>) {
    if let Ok(mut clipboard) = ClipboardContext::new() {
        if clipboard.set_contents(text.to_string()).is_ok() {
            if let Some(window) = window.upgrade() {
                window.set_show_copied_feedback(true);
                let feedback_window = window.as_weak();

                slint::Timer::single_shot(CLIPBOARD_FEEDBACK_DURATION, move || {
                    if let Some(window) = feedback_window.upgrade() {
                        window.set_show_copied_feedback(false);
                    }
                });
            }
        }
    }
}