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 glib::clone;
use gtk4::prelude::*;
use gtk4::{self as gtk, gio};
use gtk4_layer_shell::LayerShell;
use std::rc::Rc;
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}");

    if use_layer_shell {
        // One greeter window per monitor — only the first gets keyboard input
        let monitors = display.monitors();
        log::debug!("Monitor count: {}", monitors.n_items());
        let mut first = true;
        for i in 0..monitors.n_items() {
            if let Some(monitor) = monitors
                .item(i)
                .and_then(|obj| obj.downcast::<gdk::Monitor>().ok())
            {
                let window = greeter::create_greeter_window(bg_texture.as_ref(), &config, &blur_cache, app);
                setup_layer_shell(&window, first, gtk4_layer_shell::Layer::Top);
                window.set_monitor(Some(&monitor));
                window.present();
                first = false;
            }
        }

        // Handle monitor hotplug — create greeter windows for newly added monitors
        // (without keyboard, since the primary monitor already has it)
        let bg_texture = Rc::new(bg_texture);
        let config = Rc::new(config);
        monitors.connect_items_changed(clone!(
            #[weak]
            app,
            #[strong]
            blur_cache,
            move |list, position, _removed, added| {
                for i in position..position + added {
                    if let Some(monitor) = list
                        .item(i)
                        .and_then(|obj| obj.downcast::<gdk::Monitor>().ok())
                    {
                        log::debug!("Monitor hotplug: creating greeter window");
                        let window = greeter::create_greeter_window(
                            bg_texture.as_ref().as_ref(), &config, &blur_cache, &app,
                        );
                        setup_layer_shell(&window, false, gtk4_layer_shell::Layer::Top);
                        window.set_monitor(Some(&monitor));
                        window.present();
                    }
                }
            }
        ));
    } else {
        // No layer shell — single window for development
        let greeter_window = greeter::create_greeter_window(bg_texture.as_ref(), &config, &blur_cache, app);
        greeter_window.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();
}