greetd-moongreet/src/main.rs

// ABOUTME: Entry point for Moongreet — greetd greeter for Wayland.
// ABOUTME: Sets up GTK Application, Layer Shell, CSS, and a single greeter window.

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, layer: gtk4_layer_shell::Layer) {
    window.init_layer_shell();
    window.set_layer(layer);
    window.set_exclusive_zone(-1);
    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 {
        // Single greeter window. No set_monitor — the compositor places it on the
        // focused output (same as moonset). Exclusive keyboard binds input to this
        // surface regardless of pointer position; the mouse may wander to other
        // outputs but typing always reaches the greeter. The previous per-monitor
        // approach gave keyboard only to the first monitor's window, so a user on
        // any other output could not type the password.
        let window = greeter::create_greeter_window(bg_texture.as_ref(), &config, &blur_cache, app);
        setup_layer_shell(&window, gtk4_layer_shell::Layer::Top);
        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}");
        }
    }
    // Require MOONGREET_DEBUG=1 to raise verbosity. Mere presence (e.g. an
    // empty value in a session-setup script) must not escalate the journal
    // to Debug, which leaks socket paths, usernames, and auth round counts.
    let level = match std::env::var("MOONGREET_DEBUG").ok().as_deref() {
        Some("1") => log::LevelFilter::Debug,
        _ => 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();
}