spotlit 0.1.4

A cross-platform desktop wallpaper companion for Windows Spotlight and Bing wallpapers.
Documentation
use std::cell::RefCell;

use anyhow::Context;
use slint::{CloseRequestResponse, ComponentHandle};

use crate::{MainWindow, app_state::AppState, diagnostics, ui_events::UiSink, window_presenter};

thread_local! {
    static WINDOW_MANAGER: RefCell<Option<WindowManager>> = const { RefCell::new(None) };
}

pub(crate) fn install(app_state: AppState, ui_sink: UiSink) {
    WINDOW_MANAGER.with(|manager| {
        *manager.borrow_mut() = Some(WindowManager::new(app_state, ui_sink));
    });
    tracing::info!("window manager installed");
}

pub(crate) fn set_tray_available(available: bool) {
    WINDOW_MANAGER.with(|manager| {
        let mut manager = manager.borrow_mut();
        let Some(manager) = manager.as_mut() else {
            tracing::warn!("window manager was not installed");
            return;
        };

        manager.set_tray_available(available);
    });
}

pub(crate) fn present_window() {
    WINDOW_MANAGER.with(|manager| {
        let mut manager = manager.borrow_mut();
        let Some(manager) = manager.as_mut() else {
            tracing::warn!("window manager was not installed");
            return;
        };

        if let Err(error) = manager.present() {
            tracing::warn!(%error, "failed to present main window");
        }
    });
}

fn close_current_window(window_id: u64) -> CloseRequestResponse {
    WINDOW_MANAGER.with(|manager| {
        let mut manager = manager.borrow_mut();
        let Some(manager) = manager.as_mut() else {
            return CloseRequestResponse::HideWindow;
        };

        manager.close_window(window_id)
    })
}

struct WindowManager {
    app_state: AppState,
    ui_sink: UiSink,
    app: Option<MainWindow>,
    current_window_id: u64,
    next_window_id: u64,
    startup_marked: bool,
    tray_available: bool,
}

impl WindowManager {
    fn new(app_state: AppState, ui_sink: UiSink) -> Self {
        Self {
            app_state,
            ui_sink,
            app: None,
            current_window_id: 0,
            next_window_id: 1,
            startup_marked: false,
            tray_available: false,
        }
    }

    fn set_tray_available(&mut self, available: bool) {
        self.tray_available = available;
        tracing::info!(available, "tray availability updated");
    }

    fn present(&mut self) -> anyhow::Result<()> {
        tracing::info!(
            has_window = self.app.is_some(),
            window_id = self.current_window_id,
            "present window requested"
        );

        if self.app.is_none() {
            self.create_window()
                .context("failed to create main window")?;
        }

        let Some(app) = self.app.as_ref() else {
            return Ok(());
        };

        self.ui_sink.set_current(app);
        window_presenter::present(app);
        self.app_state
            .apply_cached_snapshot_after_present(app.as_weak());

        if !self.startup_marked {
            diagnostics::mark_since_start(diagnostics::Metric::Startup);
            self.startup_marked = true;
        }
        diagnostics::apply_to_ui(app);
        self.app_state.refresh_after_present(app.as_weak());
        Ok(())
    }

    fn create_window(&mut self) -> anyhow::Result<()> {
        let app = MainWindow::new().context("failed to create main window")?;
        let window_id = self.next_window_id;
        self.next_window_id = self.next_window_id.saturating_add(1);
        self.current_window_id = window_id;

        self.app_state.install(&app);
        self.install_close_handler(&app, window_id);
        self.ui_sink.set_current(&app);
        self.app = Some(app);
        tracing::info!(window_id, "main window created");
        Ok(())
    }

    fn install_close_handler(&self, app: &MainWindow, window_id: u64) {
        app.window().on_close_requested(move || {
            tracing::info!(window_id, "main window close requested");
            close_current_window(window_id)
        });
    }

    fn close_window(&mut self, window_id: u64) -> CloseRequestResponse {
        if self.current_window_id != window_id || self.app.is_none() {
            return CloseRequestResponse::HideWindow;
        }

        let keep_running_in_background = self
            .app_state
            .keep_running_in_background()
            .unwrap_or_else(|| {
                self.app
                    .as_ref()
                    .is_some_and(MainWindow::get_keep_running_in_background_enabled)
            });
        if should_hide_to_tray(self.tray_available, keep_running_in_background) {
            self.hide_window_to_tray(window_id);
        } else {
            self.quit_after_close(window_id);
        }

        CloseRequestResponse::HideWindow
    }

    fn hide_window_to_tray(&mut self, window_id: u64) {
        if let Some(app) = self.app.as_ref() {
            self.ui_sink.clear_current();
            self.app_state.cancel_window_work();
            window_presenter::cancel_pending_window_work();
            app.window().set_minimized(false);
            tracing::info!(window_id, "main window hidden to tray");
        }
    }

    fn quit_after_close(&mut self, window_id: u64) {
        if let Some(app) = self.app.as_ref() {
            self.ui_sink.clear_current();
            self.app_state.cancel_window_work();
            window_presenter::cancel_pending_window_work();
            crate::bridge::release_window_images(app);
            tracing::info!(window_id, "main window closed without tray");
        }

        if let Err(error) = slint::quit_event_loop() {
            tracing::warn!(%error, "failed to quit event loop after closing main window");
        }
    }
}

fn should_hide_to_tray(tray_available: bool, keep_running_in_background: bool) -> bool {
    tray_available && keep_running_in_background
}

#[cfg(test)]
mod tests {
    use super::should_hide_to_tray;

    #[test]
    fn close_hides_only_when_tray_and_background_mode_are_available() {
        assert!(should_hide_to_tray(true, true));
        assert!(!should_hide_to_tray(true, false));
        assert!(!should_hide_to_tray(false, true));
    }
}