greetd-moongreet/src/main.rs

// ABOUTME: Entry point for Moongreet — greetd greeter for Wayland.
// ABOUTME: Sets up GTK Application, Layer Shell, CSS, and multi-monitor windows.

mod config;
mod fingerprint;
mod greeter;
mod i18n;
mod ipc;
mod power;
mod sessions;
mod users;

use gdk4 as gdk;
use gtk4::prelude::*;
use gtk4::{self as gtk, gio};
use gtk4_layer_shell::LayerShell;
fn load_css(display: &gdk::Display) {
    let css_provider = gtk::CssProvider::new();
    css_provider.load_from_resource("/dev/moonarch/moongreet/style.css");
    gtk::style_context_add_provider_for_display(
        display,
        &css_provider,
        gtk::STYLE_PROVIDER_PRIORITY_USER,
    );
}

fn setup_layer_shell(window: &gtk::ApplicationWindow, keyboard: bool, layer: gtk4_layer_shell::Layer) {
    window.init_layer_shell();
    window.set_layer(layer);
    window.set_exclusive_zone(-1);
    if keyboard {
        window.set_keyboard_mode(gtk4_layer_shell::KeyboardMode::Exclusive);
    }
    // Anchor to all edges for fullscreen
    window.set_anchor(gtk4_layer_shell::Edge::Top, true);
    window.set_anchor(gtk4_layer_shell::Edge::Bottom, true);
    window.set_anchor(gtk4_layer_shell::Edge::Left, true);
    window.set_anchor(gtk4_layer_shell::Edge::Right, true);
}

fn activate(app: &gtk::Application) {
    let display = match gdk::Display::default() {
        Some(d) => d,
        None => {
            log::error!("No display available — cannot start greeter UI");
            return;
        }
    };

    log::debug!("Display: {:?}", display);
    load_css(&display);

    // Load config and resolve wallpaper
    let config = config::load_config(None);
    let bg_texture = config::resolve_background_path(&config)
        .and_then(|path| {
            log::debug!("Background path: {}", path.display());
            greeter::load_background_texture(&path)
        });

    let blur_cache = std::rc::Rc::new(std::cell::RefCell::new(None));

    let use_layer_shell = std::env::var("MOONGREET_NO_LAYER_SHELL").is_err();
    log::debug!("Layer shell: {use_layer_shell}");

    // Main greeter window (login UI) — compositor picks focused monitor
    let greeter_window = greeter::create_greeter_window(bg_texture.as_ref(), &config, &blur_cache, app);
    if use_layer_shell {
        setup_layer_shell(&greeter_window, true, gtk4_layer_shell::Layer::Top);
    }
    greeter_window.present();

    // Wallpaper-only windows on all monitors (only with layer shell)
    if use_layer_shell
        && let Some(ref texture) = bg_texture
    {
        let monitors = display.monitors();
        log::debug!("Monitor count: {}", monitors.n_items());
        for i in 0..monitors.n_items() {
            if let Some(monitor) = monitors
                .item(i)
                .and_then(|obj| obj.downcast::<gdk::Monitor>().ok())
            {
                let wallpaper = greeter::create_wallpaper_window(texture, config.background_blur, &blur_cache, app);
                setup_layer_shell(&wallpaper, false, gtk4_layer_shell::Layer::Bottom);
                wallpaper.set_monitor(Some(&monitor));
                wallpaper.present();
            }
        }
    }
}

fn setup_logging() {
    match systemd_journal_logger::JournalLog::new() {
        Ok(logger) => {
            if let Err(e) = logger.install() {
                eprintln!("Failed to install journal logger: {e}");
            }
        }
        Err(e) => {
            eprintln!("Failed to create journal logger: {e}");
        }
    }
    let level = if std::env::var("MOONGREET_DEBUG").is_ok() {
        log::LevelFilter::Debug
    } else {
        log::LevelFilter::Info
    };
    log::set_max_level(level);
}

fn main() {
    setup_logging();
    log::info!("Moongreet starting");

    // Register compiled GResources
    gio::resources_register_include!("moongreet.gresource").expect("Failed to register resources");

    let app = gtk::Application::builder()
        .application_id("dev.moonarch.moongreet")
        .build();

    app.connect_activate(activate);
    app.run();
}