oxwm

const std = @import("std");

const mem = std.mem;

const display_mod = @import("x11/display.zig");

const xlib = @import("x11/xlib.zig");

const events = @import("x11/events.zig");

const atoms_mod = @import("x11/atoms.zig");

const chord_mod = @import("keyboard/chord.zig");

const client_mod = @import("client.zig");

const monitor_mod = @import("monitor.zig");

const bar_mod = @import("bar/bar.zig");

const blocks_mod = @import("bar/blocks/blocks.zig");

const config_mod = @import("config/config.zig");

const overlay_mod = @import("overlay.zig");

const animations = @import("animations.zig");

const tiling = @import("layouts/tiling.zig");

const monocle = @import("layouts/monocle.zig");

const floating = @import("layouts/floating.zig");

const scrolling = @import("layouts/scrolling.zig");

const grid = @import("layouts/grid.zig");

const Display = display_mod.Display;

const Atoms = atoms_mod.Atoms;

const ChordState = chord_mod.ChordState;

const Client = client_mod.Client;

const Monitor = monitor_mod.Monitor;

const Bar = bar_mod.Bar;

const Config = config_mod.Config;

pub const Cursors = struct {

    normal: xlib.Cursor,

    resize: xlib.Cursor,

    move: xlib.Cursor,

    pub fn init(display: *Display) Cursors {

        return .{

            .normal = xlib.XCreateFontCursor(display.handle, xlib.XC_left_ptr),

            .resize = xlib.XCreateFontCursor(display.handle, xlib.XC_sizing),

            .move = xlib.XCreateFontCursor(display.handle, xlib.XC_fleur),

        };

    }

};

pub const WindowManager = struct {

    allocator: mem.Allocator,

    /// The connection to the X server.

    display: Display,

    x11_fd: c_int,

    /// Invisible 1×1 window used to satisfy the _NET_SUPPORTING_WM_CHECK

    /// EWMH convention.

    wm_check_window: xlib.Window,

    atoms: Atoms,

    cursors: Cursors,

    numlock_mask: c_uint,

    config: Config,

    /// Path to the config file that was loaded.

    /// Null if using default config.

    config_path: ?[]const u8,

    /// Head of the linked list of all managed monitors.

    monitors: ?*Monitor,

    /// The monitor that currently has input focus.

    selected_monitor: ?*Monitor,

    /// Head of the linked list of status bars (one per monitor).

    bars: ?*Bar,

    chord: ChordState,

    overlay: ?*overlay_mod.Keybind_Overlay,

    scroll_animation: animations.Scroll_Animation,

    animation_config: animations.Animation_Config,

    running: bool,

    last_motion_monitor: ?*Monitor,

    /// Initialises the window manager

    ///

    /// Returns an error if the display cannot be opened or another WM is

    /// already running.

    pub fn init(allocator: mem.Allocator, config: Config, config_path: ?[]const u8) !WindowManager {

        var display = try Display.open();

        errdefer display.close();

        try display.become_window_manager();

        const x11_fd = xlib.XConnectionNumber(display.handle);

        const atoms_result = Atoms.init(display.handle, display.root);

        const cursors = Cursors.init(&display);

        _ = xlib.XDefineCursor(display.handle, display.root, cursors.normal);

        tiling.set_display(display.handle);

        tiling.set_screen_size(display.screen_width(), display.screen_height());

        monitor_mod.init(allocator);

        // client_mod.init(allocator);

        var wm = WindowManager{

            .allocator = allocator,

            .display = display,

            .x11_fd = x11_fd,

            .wm_check_window = atoms_result.check_window,

            .atoms = atoms_result.atoms,

            .cursors = cursors,

            .numlock_mask = 0,

            .config = config,

            .config_path = config_path,

            .monitors = null,

            .selected_monitor = null,

            .bars = null,

            .chord = .{},

            .overlay = null,

            .scroll_animation = .{},

            .animation_config = .{ .duration_ms = 150, .easing = .ease_out },

            .running = true,

            .last_motion_monitor = null,

        };

        wm.setup_monitors();

        wm.setup_bars();

        wm.setup_overlay();

        return wm;

    }

    /// Release all allocated memory owned by the WM.

    pub fn deinit(self: *WindowManager) void {

        bar_mod.destroy_bars(self.bars, self.allocator, self.display.handle);

        self.bars = null;

        if (self.overlay) |o| {

            o.deinit(self.allocator);

            self.overlay = null;

        }

        var mon = self.monitors;

        while (mon) |m| {

            const next = m.next;

            monitor_mod.destroy(m);

            mon = next;

        }

        self.monitors = null;

        self.selected_monitor = null;

        _ = xlib.XDestroyWindow(self.display.handle, self.wm_check_window);

        self.display.close();

        self.config.deinit();

    }

    fn setup_monitors(self: *WindowManager) void {

        if (xlib.XineramaIsActive(self.display.handle) != 0) {

            var screen_count: c_int = 0;

            const screens = xlib.XineramaQueryScreens(self.display.handle, &screen_count);

            if (screen_count > 0 and screens != null) {

                var prev_monitor: ?*Monitor = null;

                var index: usize = 0;

                while (index < @as(usize, @intCast(screen_count))) : (index += 1) {

                    const screen = screens[index];

                    const mon = monitor_mod.create() orelse continue;

                    mon.num = @intCast(index);

                    mon.mon_x = screen.x_org;

                    mon.mon_y = screen.y_org;

                    mon.mon_w = screen.width;

                    mon.mon_h = screen.height;

                    mon.win_x = screen.x_org;

                    mon.win_y = screen.y_org;

                    mon.win_w = screen.width;

                    mon.win_h = screen.height;

                    mon.lt[0] = &tiling.layout;

                    mon.lt[1] = &monocle.layout;

                    mon.lt[2] = &floating.layout;

                    mon.lt[3] = &scrolling.layout;

                    mon.lt[4] = &grid.layout;

                    for (0..10) |i| {

                        mon.pertag.ltidxs[i][0] = mon.lt[0];

                        mon.pertag.ltidxs[i][1] = mon.lt[1];

                        mon.pertag.ltidxs[i][2] = mon.lt[2];

                        mon.pertag.ltidxs[i][3] = mon.lt[3];

                        mon.pertag.ltidxs[i][4] = mon.lt[4];

                    }

                    self.init_monitor_gaps(mon);

                    if (prev_monitor) |prev| {

                        prev.next = mon;

                    } else {

                        self.monitors = mon;

                        self.selected_monitor = mon;

                    }

                    prev_monitor = mon;

                }

                _ = xlib.XFree(@ptrCast(screens));

            }

        }

        // Fallback: single monitor covering the full screen.

        if (self.monitors == null) {

            const mon = monitor_mod.create() orelse return;

            mon.num = 0;

            mon.mon_x = 0;

            mon.mon_y = 0;

            mon.mon_w = self.display.screen_width();

            mon.mon_h = self.display.screen_height();

            mon.win_x = 0;

            mon.win_y = 0;

            mon.win_w = mon.mon_w;

            mon.win_h = mon.mon_h;

            mon.lt[0] = &tiling.layout;

            mon.lt[1] = &monocle.layout;

            mon.lt[2] = &floating.layout;

            mon.lt[3] = &scrolling.layout;

            mon.lt[4] = &grid.layout;

            for (0..10) |i| {

                mon.pertag.ltidxs[i][0] = mon.lt[0];

                mon.pertag.ltidxs[i][1] = mon.lt[1];

                mon.pertag.ltidxs[i][2] = mon.lt[2];

                mon.pertag.ltidxs[i][3] = mon.lt[3];

                mon.pertag.ltidxs[i][4] = mon.lt[4];

            }

            self.init_monitor_gaps(mon);

            self.monitors = mon;

            self.selected_monitor = mon;

        }

        // Mirror into monitor_mod so legacy code that still reads the

        // module-level vars continues to work during the transition.

        // TODO(wm-refactor): remove once all callers use self.monitors.

        monitor_mod.monitors = self.monitors;

        monitor_mod.selected_monitor = self.selected_monitor;

    }

    fn init_monitor_gaps(self: *WindowManager, mon: *Monitor) void {

        const cfg = &self.config;

        const any_gap_nonzero = cfg.gap_inner_h != 0 or cfg.gap_inner_v != 0 or

            cfg.gap_outer_h != 0 or cfg.gap_outer_v != 0;

        if (cfg.gaps_enabled and any_gap_nonzero) {

            mon.gap_inner_h = cfg.gap_inner_h;

            mon.gap_inner_v = cfg.gap_inner_v;

            mon.gap_outer_h = cfg.gap_outer_h;

            mon.gap_outer_v = cfg.gap_outer_v;

        } else {

            mon.gap_inner_h = 0;

            mon.gap_inner_v = 0;

            mon.gap_outer_h = 0;

            mon.gap_outer_v = 0;

        }

    }

    pub fn setup_bars(self: *WindowManager) void {

        var current_monitor = self.monitors;

        var last_bar: ?*Bar = null;

        while (current_monitor) |monitor| {

            const bar = Bar.create(

                self.allocator,

                self.display.handle,

                self.display.screen,

                monitor,

                self.config,

            ) orelse {

                current_monitor = monitor.next;

                continue;

            };

            if (tiling.bar_height == 0) {

                tiling.set_bar_height(bar.height);

            }

            self.populate_bar_blocks(bar);

            if (last_bar) |prev| {

                prev.next = bar;

            } else {

                self.bars = bar;

            }

            last_bar = bar;

            std.debug.print("bar created for monitor {d}\n", .{monitor.num});

            current_monitor = monitor.next;

        }

    }

    pub fn populate_bar_blocks(self: *WindowManager, bar: *Bar) void {

        if (self.config.blocks.items.len > 0) {

            for (self.config.blocks.items) |cfg_block| {

                bar.add_block(config_block_to_bar_block(cfg_block));

            }

        } else {

            bar.add_block(blocks_mod.Block.init_ram("", 5, 0x7aa2f7, true));

            bar.add_block(blocks_mod.Block.init_static(" | ", 0x666666, false));

            bar.add_block(blocks_mod.Block.init_datetime("", "%H:%M", 1, 0x0db9d7, true));

        }

    }

    fn setup_overlay(self: *WindowManager) void {

        self.overlay = overlay_mod.Keybind_Overlay.init(

            self.display.handle,

            self.display.screen,

            self.display.root,

            self.config.font,

            self.allocator,

        );

    }

    // Wrap free functions in `bar_mod` with `self.bars` passed in.

    pub fn invalidate_bars(self: *WindowManager) void {

        bar_mod.invalidate_bars(self.bars);

    }

    pub fn window_to_bar(self: *WindowManager, win: xlib.Window) ?*Bar {

        return bar_mod.window_to_bar(self.bars, win);

    }

};

/// Converts a config block description into a live status bar block.

pub fn config_block_to_bar_block(cfg: config_mod.Block) blocks_mod.Block {

    return switch (cfg.block_type) {

        .static => blocks_mod.Block.init_static(cfg.format, cfg.color, cfg.underline),

        .datetime => blocks_mod.Block.init_datetime(

            cfg.format,

            cfg.datetime_format orelse "%H:%M",

            cfg.interval,

            cfg.color,

            cfg.underline,

        ),

        .ram => blocks_mod.Block.init_ram(cfg.format, cfg.interval, cfg.color, cfg.underline),

        .shell => blocks_mod.Block.init_shell(

            cfg.format,

            cfg.command orelse "",

            cfg.interval,

            cfg.color,

            cfg.underline,

        ),

        .battery => blocks_mod.Block.init_battery(

            cfg.format_charging orelse "",

            cfg.format_discharging orelse "",

            cfg.format_full orelse "",

            cfg.battery_name orelse "BAT0",

            cfg.interval,

            cfg.color,

            cfg.underline,

        ),

        .cpu_temp => blocks_mod.Block.init_cpu_temp(

            cfg.format,

            cfg.thermal_zone orelse "thermal_zone0",

            cfg.interval,

            cfg.color,

            cfg.underline,

        ),

    };

}