+flake.lock

+gar.exec_once("garcard daemon")

+

+-- External fallback authentication agents (optional):

+-- gar.exec_once("/usr/libexec/kf6/polkit-kde-authentication-agent-1")

+-- gar.exec_once("/usr/lib/polkit-gnome/polkit-gnome-authentication-agent-1")

+# Compositor is now managed by gar itself via start_compositor()

+# based on the "compositor" setting in init.lua ("picom", "garchomp", or "none")

+# Do NOT start picom here - it causes dual-compositor conflicts when garchomp is selected

+                "focus_follows_mouse" => {

+                    if let Value::Boolean(v) = value {

+                        state.config.focus_follows_mouse = v;

+                    }

+                }

+                // Compositor selection: "picom", "garchomp", or "none"

+                "compositor" => {

+                    if let Value::String(s) = value {

+                        if let Ok(str_val) = s.to_str() {

+                            let comp = str_val.to_lowercase();

+                            if comp == "picom" || comp == "garchomp" || comp == "none" {

+                                state.config.compositor = comp;

+                            } else {

+                                tracing::warn!("Unknown compositor '{}', using 'picom'", str_val);

+                            }

+                        }

+                    }

+                }

+                // Picom backend: "glx" or "xrender"

+                "compositor_backend" | "picom_backend" => {

+                    if let Value::String(s) = value {

+                        if let Ok(str_val) = s.to_str() {

+                            let backend = str_val.to_lowercase();

+                            if backend == "glx" || backend == "xrender" {

+                                state.config.picom_backend = backend;

+                            } else {

+                                tracing::warn!("Unknown compositor backend '{}', using 'glx'", str_val);

+                            }

+                        }

+                    }

+                }

+            // Optional: shadow (use Option<bool> so nil doesn't become false)

+            if let Ok(Some(shadow)) = table.get::<Option<bool>>("shadow") {

+            // Optional: blur_background (use Option<bool> so nil doesn't become false)

+            if let Ok(Some(blur)) = table.get::<Option<bool>>("blur_background") {

+    pub focus_follows_mouse: bool,

+    // Compositor selection: "picom" (default), "garchomp", or "none"

+    pub compositor: String,

+    // Picom backend: "glx" (GPU) or "xrender" (CPU, safer on NVIDIA)

+    pub picom_backend: String,

+            // dual_kawase requires GLX backend; fall back to kernel blur on xrender

+            let (blur_method, blur_strength) = if self.picom_backend == "xrender"

+                && self.blur_method == "dual_kawase"

+            {

+                tracing::info!(

+                    "Switching blur from dual_kawase to kernel (xrender backend doesn't support dual_kawase)"

+                );

+                ("kernel".to_string(), self.blur_strength)

+            } else {

+                (self.blur_method.clone(), self.blur_strength)

+            };

+

+blur-kern = "3x3box";"#,

+                blur_method, blur_strength

+shadow-offset-y = {};"#,

+no-fading-destroyed-argb = true;"#,

+        // Unified rules section (picom v13 format)

+        // Replaces deprecated: shadow-exclude, fade-exclude, blur-background-exclude,

+        // rounded-corners-exclude, and wintypes blocks

+        let mut rules = String::from("# Rules (picom v13 format)\nrules = (\n");

+

+        // Built-in window type rules

+        rules.push_str(r#"    {

+        match = "window_type = 'dock'";

+        shadow = false;

+        corner-radius = 0;

+        blur-background = false;

+        clip-shadow-above = true;

+    },

+    {

+        match = "window_type = 'desktop'";

+        shadow = false;

+        corner-radius = 0;

+        blur-background = false;

+    },

+    {

+        match = "window_type = 'tooltip'";

+        shadow = false;

+        corner-radius = 0;

+        blur-background = false;

+        fade = true;

+        opacity = 0.95;

+        focus = true;

+    },

+    {

+        match = "window_type = 'menu'";

+        shadow = false;

+        corner-radius = 0;

+        blur-background = false;

+        fade = false;

+    },

+    {

+        match = "window_type = 'dropdown_menu'";

+        shadow = false;

+        corner-radius = 0;

+        blur-background = false;

+        fade = false;

+        opacity = 0.95;

+    },

+    {

+        match = "window_type = 'popup_menu'";

+        shadow = false;

+        corner-radius = 0;

+        blur-background = false;

+        fade = false;

+        opacity = 0.95;

+    },

+    {

+        match = "window_type = 'dnd'";

+        shadow = false;

+    },

+    {

+        match = "_NET_WM_STATE *= '_NET_WM_STATE_FULLSCREEN'";

+        corner-radius = 0;

+        shadow = false;

+    },

+    {

+        match = "_NET_WM_BYPASS_COMPOSITOR = 1";

+        shadow = false;

+        blur-background = false;

+    },

+"#);

+

+        // User custom picom rules

+        for rule in &self.picom_rules {

+            rules.push_str(&format!("    {{\n        match = \"{}\";\n", rule.match_expr));

+            if let Some(cr) = rule.corner_radius {

+                rules.push_str(&format!("        corner-radius = {};\n", cr));

+            }

+            if let Some(opacity) = rule.opacity {

+                rules.push_str(&format!("        opacity = {:.2};\n", opacity));

+            }

+            if let Some(shadow) = rule.shadow {

+                rules.push_str(&format!("        shadow = {};\n", shadow));

+            }

+            if let Some(blur) = rule.blur_background {

+                rules.push_str(&format!("        blur-background = {};\n", blur));

+            }

+            if let Some(ref shader) = rule.shader {

+                let expanded = if shader.starts_with("~/") {

+                    if let Some(home) = dirs::home_dir() {

+                        home.join(&shader[2..]).to_string_lossy().to_string()

+                    }

+                } else {

+                    shader.clone()

+                };

+                rules.push_str(&format!("        shader = \"{}\";\n", expanded));

+            rules.push_str("    },\n");

+        }

+

+        rules.push_str(");");

+        let rules_section = rules;

+backend = "{}";

+            self.picom_backend,

+    /// Write picom config to ~/.config/gar/picom.conf and optionally restart picom.

+    /// Only writes/restarts if compositor is set to "picom".

+        // Only generate picom config if using picom

+        if self.compositor != "picom" {

+            tracing::debug!("Skipping picom config (compositor={})", self.compositor);

+            return Ok(());

+        }

+

+    /// Start the configured compositor.

+    /// Called on gar startup to launch the appropriate compositor.

+    pub fn start_compositor(&self) {

+        match self.compositor.as_str() {

+            "picom" => {

+                // Generate picom config first

+                if let Err(e) = self.write_picom_config() {

+                    tracing::warn!("Failed to write picom config: {}", e);

+                }

+                // picom will be started by write_picom_config -> reload_picom

+            }

+            "garchomp" => {

+                // Kill any existing compositor first (use -f for NixOS wrappers)

+                let _ = Command::new("pkill").args(["-f", "picom"]).status();

+                let _ = Command::new("pkill").args(["-f", "garchomp"]).status();

+

+                std::thread::sleep(std::time::Duration::from_millis(100));

+

+                // Start garchomp

+                match Command::new("garchomp").spawn() {

+                    Ok(_) => {

+                        tracing::info!("Started garchomp compositor");

+                    }

+                    Err(e) => {

+                        tracing::error!("Failed to start garchomp: {}", e);

+                        // Fall back to picom

+                        tracing::info!("Falling back to picom");

+                        Self::reload_picom();

+                    }

+                }

+            }

+            "none" => {

+                tracing::info!("Compositor disabled (compositor=none)");

+                // Kill any running compositor (use -f for NixOS wrappers)

+                let _ = Command::new("pkill").args(["-f", "picom"]).status();

+                let _ = Command::new("pkill").args(["-f", "garchomp"]).status();

+            }

+            _ => {

+                tracing::warn!("Unknown compositor '{}', defaulting to picom", self.compositor);

+                if let Err(e) = self.write_picom_config() {

+                    tracing::warn!("Failed to write picom config: {}", e);

+        }

+    }

+

+    /// Stop any running compositor.

+    pub fn stop_compositor() {

+        use std::process::Command;

+        // Use -f to match full command line (needed for NixOS wrappers)

+        let _ = Command::new("pkill").args(["-f", "picom"]).status();

+        let _ = Command::new("pkill").args(["-f", "garchomp"]).status();

+    }

+

+    /// Apply screen timeout settings using xset.

+    ///

+    /// Always disables hardware DPMS (causes Xid 79 GPU crashes on NVIDIA with

+    /// multi-monitor HDMI setups). Uses the X11 screen saver extension for software

+    /// blanking instead, which draws black without hardware power state changes.

+    pub fn apply_screen_timeout(&self) {

+        use std::process::Command;

+

+        // Always disable hardware DPMS - it sends power state changes to monitors

+        // via the NVIDIA driver, which can crash the GPU (Xid 79) when HDMI displays

+        // have unreliable EDID links

+        match Command::new("xset").args(["dpms", "0", "0", "0"]).status() {

+            Ok(status) if status.success() => {

+                tracing::debug!("Disabled hardware DPMS timeouts");

+            }

+            Ok(_) => tracing::warn!("xset dpms 0 command failed"),

+            Err(e) => tracing::warn!("Failed to run xset: {}", e),

+        }

+        match Command::new("xset").args(["-dpms"]).status() {

+            Ok(_) => {}

+            Err(e) => tracing::warn!("Failed to disable DPMS: {}", e),

+        }

+        if self.screen_timeout_enabled {

+            // Use X11 screen saver for software blanking (safe, no hardware power changes)

+            let timeout = self.screen_timeout_seconds.to_string();

+                    tracing::info!(

+                        "Screen blanking enabled via X11 screen saver ({} seconds)",

+                        self.screen_timeout_seconds

+                    );

+            // Disable screen saver blanking too

+                    tracing::info!("Screen blanking disabled");

+            // Behavior: focus window when mouse enters it

+            focus_follows_mouse: true,

+            // Screen timeout: disabled by default - X11 screen saver blanking triggers

+            // Xid 79 GPU crashes on NVIDIA with multi-monitor HDMI setups

+            screen_timeout_enabled: false,

+            // Compositor selection: "picom" (default), "garchomp", or "none"

+            compositor: "picom".to_string(),

+            // Picom backend: "glx" (GPU) or "xrender" (CPU, safer on NVIDIA)

+            picom_backend: "glx".to_string(),

+        let mut workspaces: Vec<Workspace> = (1..=10)

+        // Start the configured compositor (picom, garchomp, or none)

+        config.start_compositor();

+            if i < workspaces.len() {

+                workspaces[i].last_monitor = Some(i);

+            }

+        // Update cached screen dimensions (may have changed due to rotation)

+        self.conn.update_screen_size();

+

+            if monitor.active_workspace < self.workspaces.len() {

+                self.workspaces[monitor.active_workspace].last_monitor = Some(i);

+            }

+                // Fullscreen windows have no borders

+                if self.windows.get(&window).map(|w| w.fullscreen).unwrap_or(false) {

+                    continue;

+                }

+

+                if let Some(frame) = self.frames.frame_for_client(fs_window) {

+                    // Window has a frame — position frame at monitor origin with no border,

+                    // and configure client to fill the entire frame.

+                    let frame_aux = ConfigureWindowAux::new()

+                        .x(screen.x as i32)

+                        .y(screen.y as i32)

+                        .width(screen.width as u32)

+                        .height(screen.height as u32)

+                        .border_width(0);

+                    self.conn.conn.configure_window(frame, &frame_aux)?;

+

+                    let client_aux = ConfigureWindowAux::new()

+                        .x(0)

+                        .y(0)

+                        .width(screen.width as u32)

+                        .height(screen.height as u32)

+                        .border_width(0);

+                    self.conn.conn.configure_window(fs_window, &client_aux)?;

+

+                    // Raise frame above everything

+                    let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);

+                    self.conn.conn.configure_window(frame, &aux)?;

+                } else {

+                    // No frame — configure client directly

+                    self.conn.configure_window(

+                        fs_window,

+                        screen.x,

+                        screen.y,

+                        screen.width,

+                        screen.height,

+                        0,

+                    )?;

+                    let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);

+                    self.conn.conn.configure_window(fs_window, &aux)?;

+                }

+                    // Ensure tiled frame is below floating windows by stacking at bottom

+                    if let Some(frame) = self.frames.frame_for_client(*window) {

+                        let aux = ConfigureWindowAux::new().stack_mode(StackMode::BELOW);

+                        self.conn.conn.configure_window(frame, &aux)?;

+                    }

+

+

+                    // Ensure tiled window is below floating windows

+                    let aux = ConfigureWindowAux::new().stack_mode(StackMode::BELOW);

+                    self.conn.conn.configure_window(*window, &aux)?;

+                        tracing::info!(

+                            "apply_layout: FLOATING+FRAME window={} frame={} raised ABOVE (at ({}, {}) size {}x{})",

+                            window_id, frame, geom.x, geom.y, adjusted_width.max(1), adjusted_height.max(1)

+                        );

+                    } else {

+                        tracing::warn!(

+                            "apply_layout: FLOATING window={} has_frame=true but no frame found!",

+                            window_id

+                        );

+

+                    tracing::info!(

+                        "apply_layout: FLOATING window={} raised ABOVE (at ({}, {}) size {}x{})",

+                        window_id, geom.x, geom.y, adjusted_width.max(1), adjusted_height.max(1)

+                    );

+    /// Last monitor this workspace was displayed on (for focus-back behavior)

+    pub last_monitor: Option<usize>,

+            last_monitor: None,

+    pub net_wm_state_above: Atom,

+        let net_wm_state_above = conn.intern_atom(false, b"_NET_WM_STATE_ABOVE")?.reply()?.atom;

+            net_wm_state_above,

+                    | EventMask::PROPERTY_CHANGE

+                    | EventMask::ENTER_WINDOW

+                    | EventMask::POINTER_MOTION,

+        // 3. Check _NET_WM_STATE for modal or above windows

+                        if atom == self.net_wm_state_above {

+                            tracing::debug!("Window {} has ABOVE state, should float", window);

+                            return true;

+                        }

+            self.net_wm_state_modal,

+            self.net_wm_state_above,

+

+    /// Update cached screen dimensions using RandR query.

+    /// Called after RandR events when we don't have the new size from the event.

+    pub fn update_screen_size(&mut self) {

+        use x11rb::protocol::randr::ConnectionExt as RandrExt;

+

+        // Query current screen size from RandR

+        if let Ok(reply) = self.conn.randr_get_screen_info(self.root) {

+            if let Ok(info) = reply.reply() {

+                // Get the size from the current rotation/size index

+                if let Some(size) = info.sizes.get(info.size_id as usize) {

+                    let (new_w, new_h) = if info.rotation.contains(x11rb::protocol::randr::Rotation::ROTATE90)

+                        || info.rotation.contains(x11rb::protocol::randr::Rotation::ROTATE270)

+                    {

+                        // Rotated 90 or 270 - swap dimensions

+                        (size.height, size.width)

+                    } else {

+                        (size.width, size.height)

+                    };

+

+                    if new_w != self.screen_width || new_h != self.screen_height {

+                        tracing::info!(

+                            "Screen size updated: {}x{} -> {}x{}",

+                            self.screen_width, self.screen_height, new_w, new_h

+                        );

+                        self.screen_width = new_w;

+                        self.screen_height = new_h;

+                    }

+                }

+            }

+        }

+    }

+            Event::RandrScreenChangeNotify(e) => {

+                tracing::info!(

+                    "RandR screen change: {}x{} -> {}x{}",

+                    self.conn.screen_width, self.conn.screen_height,

+                    e.width, e.height

+                );

+                // Update cached screen dimensions from the event

+                self.conn.screen_width = e.width;

+                self.conn.screen_height = e.height;

+        // Focus and raise the new window if on a visible workspace

+            self.raise_window(window)?;

+            // Not on edge - if this is a focused floating window, raise it and replay the click

+            // This ensures clicking on a floating window that somehow ended up behind

+            // other windows will bring it to the front

+                self.raise_window(window)?;

+            } else {

+                if self.tiled_edge_cursor.is_some() {

+                    // Moving to unmanaged window or root - clear tiled edge cursor

+                    let (old_w1, old_w2, _) = self.tiled_edge_cursor.unwrap();

+                    self.conn.clear_window_cursor(old_w1)?;

+                    self.conn.clear_window_cursor(old_w2)?;

+                    self.conn.flush()?;

+                    self.tiled_edge_cursor = None;

+                }

+                // Pointer is on root/empty desktop — check for cross-monitor movement

+                let monitor_idx = self.monitor_idx_at_point(event.root_x, event.root_y);

+                if monitor_idx != self.focused_monitor {

+                    let old_workspace_idx = self.focused_workspace;

+                    self.focused_monitor = monitor_idx;

+                    let workspace_idx = self.monitors[monitor_idx].active_workspace;

+                    self.focused_workspace = workspace_idx;

+                    self.focused_window = None;

+                    self.conn.set_active_window(None)?;

+                    self.conn.set_current_desktop(workspace_idx as u32)?;

+                    if workspace_idx != old_workspace_idx {

+                        self.broadcast_i3_workspace_event("focus", workspace_idx, Some(old_workspace_idx));

+                    }

+                    self.conn.flush()?;

+                }

+        // For unmanaged windows (root window / empty desktop areas),

+        // check if the pointer crossed to a different monitor and update

+        // focused workspace accordingly so garbar underline tracks correctly.

+            let monitor_idx = self.monitor_idx_at_point(event.root_x, event.root_y);

+            if monitor_idx != self.focused_monitor {

+                let old_workspace_idx = self.focused_workspace;

+                self.focused_monitor = monitor_idx;

+                let workspace_idx = self.monitors[monitor_idx].active_workspace;

+                self.focused_workspace = workspace_idx;

+                self.focused_window = None;

+                self.conn.set_active_window(None)?;

+                self.conn.set_current_desktop(workspace_idx as u32)?;

+                if workspace_idx != old_workspace_idx {

+                    self.broadcast_i3_workspace_event("focus", workspace_idx, Some(old_workspace_idx));

+                }

+                self.conn.flush()?;

+            }

+        let old_workspace_idx = self.focused_workspace;

+

+        // If workspace changed (cross-monitor mouse move), update EWMH and notify garbar

+        if self.focused_workspace != old_workspace_idx {

+            self.conn.set_current_desktop(self.focused_workspace as u32)?;

+            self.broadcast_i3_workspace_event("focus", self.focused_workspace, Some(old_workspace_idx));

+        }

+

+            // Handle ABOVE state changes - raise window when requested

+            else if property == self.conn.net_wm_state_above {

+                match action {

+                    1 | 2 => {

+                        // Add or toggle ABOVE - raise the window

+                        tracing::info!("Window {} requesting ABOVE state, raising", window);

+                        if self.windows.contains_key(&window) {

+                            self.raise_window(window)?;

+                        }

+                    }

+                    _ => {}

+                }

+            }

+        let old_workspace_idx = self.focused_workspace;

+        // Update EWMH

+        self.conn.set_current_desktop(workspace_idx as u32)?;

+

+            self.conn.set_active_window(None)?;

+        // Broadcast i3 workspace event so garbar updates

+        if workspace_idx != old_workspace_idx {

+            self.broadcast_i3_workspace_event("focus", workspace_idx, Some(old_workspace_idx));

+        }

+

+    /// Force refresh layout - just re-apply layout.

+    /// Note: GTK apps may not fully re-render at new scale without restart.

+    fn force_refresh_layout(&mut self) -> Result<()> {

+        self.apply_layout()?;

+        tracing::info!("Layout refreshed");

+        Ok(())

+    }

+

+            self.workspaces[idx].last_monitor = Some(monitor_idx);

+            // Workspace not visible — show it on the monitor it was last on,

+            // falling back to the current monitor if it was never shown.

+            let target_monitor = self.workspaces[idx].last_monitor

+                .filter(|&m| m < self.monitors.len())

+                .unwrap_or(self.focused_monitor);

+            let old_ws = self.monitors[target_monitor].active_workspace;

+                target_monitor, old_ws + 1, idx + 1

+            self.monitors[target_monitor].active_workspace = idx;

+            self.workspaces[idx].last_monitor = Some(target_monitor);

+            self.focused_monitor = target_monitor;

+                    let monitor_geom = self.monitors[target_monitor].geometry;

+        // Kill compositor to prevent overlay from bleeding into the greeter

+        tracing::info!("Killing compositor...");

+        // Use -f to match against full command line (needed for NixOS wrappers)

+        let _ = std::process::Command::new("pkill")

+            .args(["-f", "garchomp"])

+            .status();

+            .args(["-f", "picom"])

+            "refresh_layout" => {

+                // Re-apply layout to all windows without changing ratios.

+                // Useful after display scaling changes when GTK apps resize internally.

+                // Two-step approach: first shrink windows, then expand - forces GTK to re-layout.

+                match self.force_refresh_layout() {

+                    Ok(_) => {

+                        tracing::info!("Layout force-refreshed");

+                        Response::success(None)

+                    }

+                    Err(e) => Response::error(e.to_string()),

+                }

+            }

+        // Raise in X11 - if window has a frame, raise the frame instead

+        if let Some(frame) = self.frames.frame_for_client(window) {

+            tracing::info!("raise_window: window={} -> raising frame={}", window, frame);

+            self.conn.conn.configure_window(frame, &aux)?;

+        } else {

+            tracing::info!("raise_window: window={} (no frame)", window);

+            self.conn.conn.configure_window(window, &aux)?;

+        }

+        let old_workspace_idx = self.focused_workspace;

+        // Update EWMH

+        self.conn.set_current_desktop(workspace_idx as u32)?;

+

+            // No windows - clear EWMH active window and warp to monitor center

+            self.conn.set_active_window(None)?;

+        // Broadcast i3 workspace event so garbar updates

+        if workspace_idx != old_workspace_idx {

+            self.broadcast_i3_workspace_event("focus", workspace_idx, Some(old_workspace_idx));

+        }

+

+        let source_ws = self.focused_workspace;

+        // Update focus on source workspace so it doesn't point to the moved window

+        let new_focus_on_source = self.workspaces[source_ws].tree.first_window()

+            .or_else(|| self.workspaces[source_ws].floating.last().copied());

+        self.workspaces[source_ws].focused = new_focus_on_source;

+

+        let old_workspace_idx = self.focused_workspace;

+        // Update EWMH

+        self.conn.set_current_desktop(target_workspace as u32)?;

+

+        // Broadcast i3 workspace event so garbar updates

+        if target_workspace != old_workspace_idx {

+            self.broadcast_i3_workspace_event("focus", target_workspace, Some(old_workspace_idx));

+        }

+

+    /// Refresh window layout (re-apply without changing ratios)

+    RefreshLayout,

+        Command::RefreshLayout => {

+            json!({ "command": "refresh_layout", "args": {} })

+        }