Add multi-monitor support and panic mode

Status	File	+	-
M	`gar/config/default.lua`	11	2
M	`gar/src/config/lua.rs`	28	0
M	`gar/src/core/mod.rs`	109	4
M	`gar/src/core/monitor.rs`	7	1
M	`gar/src/x11/connection.rs`	68	0
M	`gar/src/x11/events.rs`	223	4
M	`garctl/src/main.rs`	21	0
A	`start-gar.sh`	65	0

gar/config/default.luamodified

  gar.set("gap_outer", 8)
  -- Mod key: "mod" = Super/Win, "alt" = Alt
---- Using alt for testing in nested X (i3 grabs super)
++-- Use "mod" for real X session, "alt" for nested testing (Xephyr)
--local mod = "alt"
++local mod = "mod"
  -- Terminal
  gar.bind(mod .. "+Return", function()
  -- Reload config
  gar.bind(mod .. "+shift+r", gar.reload)
++-- PANIC: Exit gar immediately (mod+shift+Escape)
++gar.bind(mod .. "+shift+Escape", gar.exit)
++
  -- Focus navigation (arrow keys)
  gar.bind(mod .. "+Left", gar.focus("left"))
  gar.bind(mod .. "+Right", gar.focus("right"))
  end
  gar.bind(mod .. "+0", gar.workspace(10))
  gar.bind(mod .. "+shift+0", gar.move_to_workspace(10))
++
++-- Multi-monitor (comma/period = prev/next)
++gar.bind(mod .. "+comma", gar.focus_monitor("prev"))
++gar.bind(mod .. "+period", gar.focus_monitor("next"))
++gar.bind(mod .. "+shift+comma", gar.move_to_monitor("prev"))
++gar.bind(mod .. "+shift+period", gar.move_to_monitor("next"))

gar/src/config/lua.rsmodified

      Exit,
      ToggleFloating,
      CycleFloating,
++    FocusMonitor(String),     // "next", "prev", or monitor name
++    MoveToMonitor(String),    // "next", "prev", or monitor name
      LuaCallback(usize), // Index into callback registry
+ }
                                  let n: usize = t.get("workspace").unwrap_or(1);
                                  Action::MoveToWorkspace(n)
+                             }
++                            "focus_monitor" => {
++                                let target: String = t.get("target").unwrap_or_default();
++                                Action::FocusMonitor(target)
++                            }
++                            "move_to_monitor" => {
++                                let target: String = t.get("target").unwrap_or_default();
++                                Action::MoveToMonitor(target)
++                            }
                              _ => {
                                  tracing::warn!("Unknown action type: {}", action_type);
                                  return Ok(());
          })?;
          gar.set("move_to_workspace", move_fn)?;
++        // gar.focus_monitor(target) - "next", "prev", or monitor name
++        let focus_monitor_fn = self.lua.create_function(|lua, target: String| {
++            let t = lua.create_table()?;
++            t.set("action", "focus_monitor")?;
++            t.set("target", target)?;
++            Ok(t)
++        })?;
++        gar.set("focus_monitor", focus_monitor_fn)?;
++
++        // gar.move_to_monitor(target) - "next", "prev", or monitor name
++        let move_to_monitor_fn = self.lua.create_function(|lua, target: String| {
++            let t = lua.create_table()?;
++            t.set("action", "move_to_monitor")?;
++            t.set("target", target)?;
++            Ok(t)
++        })?;
++        gar.set("move_to_monitor", move_to_monitor_fn)?;
++
          Ok(())
+     }
+ }

gar/src/core/mod.rsmodified

      pub windows: HashMap<XWindow, Window>,
      pub focused_workspace: usize,
      pub focused_window: Option<XWindow>,
++    pub focused_monitor: usize,
      pub running: bool,
      pub drag_state: Option<DragState>,
      pub ipc_server: Option<IpcServer>,
  impl WindowManager {
      pub fn new(conn: Connection) -> Result<Self> {
--        let workspaces = (1..=10)
++        let workspaces: Vec<Workspace> = (1..=10)
              .map(|i| Workspace::new(i, i.to_string()))
              .collect();
+             }
          };
++        // Subscribe to RandR events for hotplug
++        if let Err(e) = conn.subscribe_randr_events() {
++            tracing::warn!("Failed to subscribe to RandR events: {}", e);
++        }
++
++        // Detect monitors
++        let mut monitors = conn.detect_monitors().unwrap_or_else(|e| {
++            tracing::warn!("Failed to detect monitors: {}, using single screen", e);
++            vec![Monitor::new(
++                "default".to_string(),
++                0,
++                Rect::new(0, 0, conn.screen_width, conn.screen_height),
++            )]
++        });
++
++        // Ensure at least one monitor
++        if monitors.is_empty() {
++            monitors.push(Monitor::new(
++                "default".to_string(),
++                0,
++                Rect::new(0, 0, conn.screen_width, conn.screen_height),
++            ));
++        }
++
++        // Assign workspaces to monitors
++        let ws_count = workspaces.len();
++        let mon_count = monitors.len();
++        for (i, monitor) in monitors.iter_mut().enumerate() {
++            // Distribute workspaces: first monitor gets ws 1-N/M, etc.
++            let start = i * ws_count / mon_count;
++            let end = (i + 1) * ws_count / mon_count;
++            monitor.workspaces = (start..end).collect();
++            monitor.active_workspace = start;
++            tracing::debug!("Monitor '{}' assigned workspaces {:?}", monitor.name, monitor.workspaces);
++        }
++
          Ok(Self {
              conn,
              config,
              lua_config,
              lua_state,
              workspaces,
--            monitors: Vec::new(),
++            monitors,
              windows: HashMap::new(),
              focused_workspace: 0,
              focused_window: None,
++            focused_monitor: 0,
              running: true,
              drag_state: None,
              ipc_server,
          &mut self.workspaces[self.focused_workspace]
+     }
--    /// Get the screen rectangle (full usable area).
++    pub fn current_monitor(&self) -> &Monitor {
++        &self.monitors[self.focused_monitor]
++    }
++
++    /// Get the rectangle for the focused monitor.
      pub fn screen_rect(&self) -> Rect {
--        Rect::new(0, 0, self.conn.screen_width, self.conn.screen_height)
++        self.monitors[self.focused_monitor].geometry
++    }
++
++    /// Get the rectangle for a specific workspace's monitor.
++    pub fn workspace_rect(&self, workspace_idx: usize) -> Rect {
++        self.monitor_for_workspace(workspace_idx)
++            .map(|m| m.geometry)
++            .unwrap_or_else(|| Rect::new(0, 0, self.conn.screen_width, self.conn.screen_height))
++    }
++
++    /// Find which monitor a workspace belongs to.
++    pub fn monitor_for_workspace(&self, workspace_idx: usize) -> Option<&Monitor> {
++        self.monitors.iter().find(|m| m.workspaces.contains(&workspace_idx))
++    }
++
++    /// Find the monitor index for a workspace.
++    pub fn monitor_idx_for_workspace(&self, workspace_idx: usize) -> Option<usize> {
++        self.monitors.iter().position(|m| m.workspaces.contains(&workspace_idx))
++    }
++
++    /// Refresh monitors (called on RandR screen change).
++    pub fn refresh_monitors(&mut self) -> Result<()> {
++        tracing::info!("Refreshing monitor configuration");
++
++        let mut new_monitors = self.conn.detect_monitors().unwrap_or_else(|e| {
++            tracing::warn!("Failed to detect monitors: {}, keeping current", e);
++            return self.monitors.clone();
++        });
++
++        if new_monitors.is_empty() {
++            new_monitors.push(Monitor::new(
++                "default".to_string(),
++                0,
++                Rect::new(0, 0, self.conn.screen_width, self.conn.screen_height),
++            ));
++        }
++
++        // Reassign workspaces to monitors
++        let ws_count = self.workspaces.len();
++        let mon_count = new_monitors.len();
++        for (i, monitor) in new_monitors.iter_mut().enumerate() {
++            let start = i * ws_count / mon_count;
++            let end = (i + 1) * ws_count / mon_count;
++            monitor.workspaces = (start..end).collect();
++            monitor.active_workspace = start;
++            tracing::info!("Monitor '{}' assigned workspaces {:?}", monitor.name, monitor.workspaces);
++        }
++
++        self.monitors = new_monitors;
++
++        // Ensure focused_monitor is valid
++        if self.focused_monitor >= self.monitors.len() {
++            self.focused_monitor = 0;
++        }
++
++        // Ensure focused_workspace is on the focused monitor
++        if !self.monitors[self.focused_monitor].workspaces.contains(&self.focused_workspace) {
++            self.focused_workspace = self.monitors[self.focused_monitor].active_workspace;
++        }
++
++        // Re-apply layout for visible workspaces
++        self.apply_layout()?;
++
++        Ok(())
+     }
      /// Check if a window should be managed (not override-redirect, etc.)

gar/src/core/monitor.rsmodified

++use x11rb::protocol::randr::Output;
++
  use super::tree::Rect;
  #[derive(Debug, Clone)]
  pub struct Monitor {
      pub name: String,
++    pub output: Output,
      pub geometry: Rect,
      pub primary: bool,
++    /// Workspace indices assigned to this monitor
      pub workspaces: Vec<usize>,
++    /// Currently active workspace index on this monitor
      pub active_workspace: usize,
  }
  impl Monitor {
--    pub fn new(name: String, geometry: Rect) -> Self {
++    pub fn new(name: String, output: Output, geometry: Rect) -> Self {
          Self {
              name,
++            output,
              geometry,
              primary: false,
              workspaces: Vec::new(),

gar/src/x11/connection.rsmodified

          )?;
          Ok(())
+     }
++
++    /// Detect connected monitors via RandR.
++    pub fn detect_monitors(&self) -> Result<Vec<crate::core::Monitor>, Error> {
++        use x11rb::protocol::randr::{self, ConnectionExt as RandrExt};
++        use crate::core::{Monitor, Rect};
++
++        let resources = self.conn.randr_get_screen_resources(self.root)?.reply()?;
++        let primary = self.conn.randr_get_output_primary(self.root)?.reply()?.output;
++
++        let mut monitors = Vec::new();
++
++        for &output in &resources.outputs {
++            let info = match self.conn.randr_get_output_info(output, 0)?.reply() {
++                Ok(info) => info,
++                Err(_) => continue,
++            };
++
++            // Skip disconnected outputs
++            if info.connection != randr::Connection::CONNECTED {
++                continue;
++            }
++
++            // Skip outputs without a CRTC (not active)
++            let crtc = match info.crtc {
++                0 => continue,
++                c => c,
++            };
++
++            let crtc_info = match self.conn.randr_get_crtc_info(crtc, 0)?.reply() {
++                Ok(info) => info,
++                Err(_) => continue,
++            };
++
++            let name = String::from_utf8_lossy(&info.name).to_string();
++            let geometry = Rect::new(
++                crtc_info.x,
++                crtc_info.y,
++                crtc_info.width,
++                crtc_info.height,
++            );
++
++            let mut monitor = Monitor::new(name, output, geometry);
++            monitor.primary = output == primary;
++
++            monitors.push(monitor);
++        }
++
++        // Sort monitors by X position (left to right)
++        monitors.sort_by_key(|m| m.geometry.x);
++
++        tracing::info!("Detected {} monitors: {:?}",
++            monitors.len(),
++            monitors.iter().map(|m| &m.name).collect::<Vec<_>>()
++        );
++
++        Ok(monitors)
++    }
++
++    /// Subscribe to RandR screen change events.
++    pub fn subscribe_randr_events(&self) -> Result<(), Error> {
++        use x11rb::protocol::randr::{self, ConnectionExt as RandrExt};
++
++        self.conn.randr_select_input(
++            self.root,
++            randr::NotifyMask::SCREEN_CHANGE | randr::NotifyMask::OUTPUT_CHANGE,
++        )?;
++        Ok(())
++    }
+ }
  impl std::ops::Deref for Connection {

gar/src/x11/events.rsmodified

              Event::EnterNotify(e) => {
                  tracing::trace!("EnterNotify for window {}", e.event);
+             }
++            Event::RandrScreenChangeNotify(_) => {
++                tracing::info!("RandR screen change detected, refreshing monitors");
++                self.refresh_monitors()?;
++            }
++            Event::RandrNotify(_) => {
++                tracing::info!("RandR notify event, refreshing monitors");
++                self.refresh_monitors()?;
++            }
              _ => {
                  tracing::trace!("Unhandled event: {:?}", event);
+             }
              Action::CycleFloating => {
                  self.cycle_floating()?;
+             }
++            Action::FocusMonitor(target) => {
++                self.focus_monitor(&target)?;
++            }
++            Action::MoveToMonitor(target) => {
++                self.move_to_monitor(&target)?;
++            }
              Action::LuaCallback(index) => {
                  if let Err(e) = self.lua_config.execute_callback(index) {
                      tracing::error!("Lua callback error: {}", e);
+     }
      fn switch_workspace(&mut self, idx: usize) -> Result<()> {
--        if idx >= self.workspaces.len() || idx == self.focused_workspace {
++        if idx >= self.workspaces.len() {
++            return Ok(());
++        }
++
++        // Find which monitor owns this workspace
++        let target_monitor = self.monitor_idx_for_workspace(idx);
++
++        // If the workspace is on a different monitor, just focus that monitor
++        if let Some(mon_idx) = target_monitor {
++            if mon_idx != self.focused_monitor {
++                tracing::info!("Workspace {} is on monitor {}, switching focus", idx + 1, mon_idx);
++                self.focused_monitor = mon_idx;
++                self.focused_workspace = idx;
++                self.monitors[mon_idx].active_workspace = idx;
++                self.conn.set_current_desktop(idx as u32)?;
++
++                // Focus a window on the target workspace
++                let ws = &self.workspaces[idx];
++                if let Some(window) = ws.focused
++                    .or_else(|| ws.floating.last().copied())
++                    .or_else(|| ws.tree.first_window())
++                {
++                    self.set_focus(window)?;
++                } else {
++                    self.focused_window = None;
++                }
++                self.conn.flush()?;
++                return Ok(());
++            }
++        }
++
++        // Same monitor - switch its active workspace
++        if idx == self.focused_workspace {
              return Ok(());
+         }
              self.conn.unmap_window(window)?;
+         }
--        // Switch workspace
++        // Update monitor's active workspace
++        let old_ws = self.focused_workspace;
          self.focused_workspace = idx;
++        self.monitors[self.focused_monitor].active_workspace = idx;
          // Update EWMH _NET_CURRENT_DESKTOP
          self.conn.set_current_desktop(idx as u32)?;
              self.focused_window = None;
+         }
++        tracing::debug!("Switched from workspace {} to {}", old_ws + 1, idx + 1);
          self.conn.flush()?;
          Ok(())
+     }
          // Hide the window (it's moving to another workspace)
          self.conn.unmap_window(window)?;
--        // Insert into target workspace
++        // Insert into target workspace (use target monitor's geometry)
          if is_floating {
              self.workspaces[idx].add_floating(window);
          } else {
              let target_focused = self.workspaces[idx].focused;
--            let screen = self.screen_rect();
++            let screen = self.workspace_rect(idx);
              self.workspaces[idx]
                  .tree
                  .insert_with_rect(window, target_focused, screen);
                  // Handle subscription in handle_ipc directly
                  Response::success(None)
+             }
++            "focus_monitor" => {
++                let target = args.get("target").and_then(|v| v.as_str()).unwrap_or("next");
++                match self.focus_monitor(target) {
++                    Ok(_) => Response::success(None),
++                    Err(e) => Response::error(e.to_string()),
++                }
++            }
++            "move_to_monitor" => {
++                let target = args.get("target").and_then(|v| v.as_str()).unwrap_or("next");
++                match self.move_to_monitor(target) {
++                    Ok(_) => Response::success(None),
++                    Err(e) => Response::error(e.to_string()),
++                }
++            }
++            "get_monitors" => {
++                Response::success(Some(self.get_monitors_json()))
++            }
              _ => Response::error(format!("Unknown command: {}", command)),
+         }
+     }
          })
+     }
++    /// Get monitor info as JSON
++    fn get_monitors_json(&self) -> serde_json::Value {
++        serde_json::json!(self.monitors.iter().enumerate().map(|(i, mon)| {
++            serde_json::json!({
++                "name": mon.name,
++                "focused": i == self.focused_monitor,
++                "primary": mon.primary,
++                "geometry": {
++                    "x": mon.geometry.x,
++                    "y": mon.geometry.y,
++                    "width": mon.geometry.width,
++                    "height": mon.geometry.height,
++                },
++                "workspaces": mon.workspaces.iter().map(|ws| ws + 1).collect::<Vec<_>>(),
++                "active_workspace": mon.active_workspace + 1,
++            })
++        }).collect::<Vec<_>>())
++    }
++
      // Floating window helpers
      fn is_floating(&self, window: u32) -> bool {
          Ok(())
+     }
++    /// Focus a different monitor.
++    /// Target can be "next", "prev", "left", "right", or a monitor name.
++    fn focus_monitor(&mut self, target: &str) -> Result<()> {
++        if self.monitors.len() <= 1 {
++            return Ok(());
++        }
++
++        let target_idx = match target.to_lowercase().as_str() {
++            "next" | "right" => (self.focused_monitor + 1) % self.monitors.len(),
++            "prev" | "left" => {
++                if self.focused_monitor == 0 {
++                    self.monitors.len() - 1
++                } else {
++                    self.focused_monitor - 1
++                }
++            }
++            name => {
++                // Find monitor by name
++                match self.monitors.iter().position(|m| m.name.eq_ignore_ascii_case(name)) {
++                    Some(idx) => idx,
++                    None => {
++                        tracing::warn!("Monitor '{}' not found", name);
++                        return Ok(());
++                    }
++                }
++            }
++        };
++
++        if target_idx == self.focused_monitor {
++            return Ok(());
++        }
++
++        tracing::info!("Focusing monitor {}: '{}'", target_idx, self.monitors[target_idx].name);
++        self.focused_monitor = target_idx;
++
++        // Focus the active workspace on that monitor
++        let workspace_idx = self.monitors[target_idx].active_workspace;
++        self.focused_workspace = workspace_idx;
++
++        // Focus a window on that workspace if any
++        if let Some(window) = self.workspaces[workspace_idx].focused
++            .or_else(|| self.workspaces[workspace_idx].floating.last().copied())
++            .or_else(|| self.workspaces[workspace_idx].tree.first_window())
++        {
++            if let Some(old) = self.focused_window {
++                self.conn.grab_button(old)?;
++            }
++            self.set_focus(window)?;
++            self.conn.ungrab_button(window)?;
++        } else {
++            self.focused_window = None;
++        }
++
++        self.conn.flush()?;
++        Ok(())
++    }
++
++    /// Move focused window to another monitor.
++    /// Target can be "next", "prev", "left", "right", or a monitor name.
++    fn move_to_monitor(&mut self, target: &str) -> Result<()> {
++        if self.monitors.len() <= 1 {
++            return Ok(());
++        }
++
++        let Some(window) = self.focused_window else {
++            return Ok(());
++        };
++
++        let target_idx = match target.to_lowercase().as_str() {
++            "next" | "right" => (self.focused_monitor + 1) % self.monitors.len(),
++            "prev" | "left" => {
++                if self.focused_monitor == 0 {
++                    self.monitors.len() - 1
++                } else {
++                    self.focused_monitor - 1
++                }
++            }
++            name => {
++                match self.monitors.iter().position(|m| m.name.eq_ignore_ascii_case(name)) {
++                    Some(idx) => idx,
++                    None => {
++                        tracing::warn!("Monitor '{}' not found", name);
++                        return Ok(());
++                    }
++                }
++            }
++        };
++
++        if target_idx == self.focused_monitor {
++            return Ok(());
++        }
++
++        let is_floating = self.windows.get(&window).map(|w| w.floating).unwrap_or(false);
++        let target_workspace = self.monitors[target_idx].active_workspace;
++
++        tracing::info!("Moving window {} to monitor {}: '{}' (workspace {})",
++            window, target_idx, self.monitors[target_idx].name, target_workspace + 1);
++
++        // Remove from current workspace
++        if is_floating {
++            self.current_workspace_mut().remove_floating(window);
++        } else {
++            self.current_workspace_mut().tree.remove(window);
++        }
++
++        // Update window's workspace
++        if let Some(win) = self.windows.get_mut(&window) {
++            win.workspace = target_workspace;
++        }
++
++        // Add to target workspace
++        if is_floating {
++            self.workspaces[target_workspace].add_floating(window);
++        } else {
++            let target_focused = self.workspaces[target_workspace].focused;
++            let target_rect = self.monitors[target_idx].geometry;
++            self.workspaces[target_workspace].tree.insert_with_rect(window, target_focused, target_rect);
++        }
++
++        // Update EWMH
++        self.conn.set_window_desktop(window, target_workspace as u32)?;
++
++        // Focus follows window to new monitor
++        self.focused_monitor = target_idx;
++        self.focused_workspace = target_workspace;
++        self.workspaces[target_workspace].focused = Some(window);
++
++        // Apply layouts on both monitors
++        self.apply_layout()?;
++
++        self.conn.flush()?;
++        Ok(())
++    }
++
      /// Cycle through floating windows on the current workspace.
      fn cycle_floating(&mut self) -> Result<()> {
          let floating = &self.current_workspace().floating;

garctl/src/main.rsmodified

      GetFocused,
      /// Get window tree
      GetTree,
++    /// Focus monitor (next, prev, or name)
++    FocusMonitor {
++        /// Target: next, prev, left, right, or monitor name
++        target: String,
++    },
++    /// Move focused window to monitor
++    MoveToMonitor {
++        /// Target: next, prev, left, right, or monitor name
++        target: String,
++    },
++    /// Get monitor information
++    GetMonitors,
+ }
  fn get_socket_path() -> PathBuf {
          Command::GetTree => {
              json!({ "command": "get_tree", "args": {} })
+         }
++        Command::FocusMonitor { target } => {
++            json!({ "command": "focus_monitor", "args": { "target": target } })
++        }
++        Command::MoveToMonitor { target } => {
++            json!({ "command": "move_to_monitor", "args": { "target": target } })
++        }
++        Command::GetMonitors => {
++            json!({ "command": "get_monitors", "args": {} })
++        }
      };
      match send_command(request) {

start-gar.shadded

++#!/usr/bin/env bash
++# Start gar window manager on a real X session
++#
++# PANIC MODE: Alt+Shift+Escape to exit gar immediately
++# BACKUP: Ctrl+Alt+F2 to switch to TTY2 if gar freezes
++#
++# Usage:
++#   ./start-gar.sh        # Start on next available display
++#   ./start-gar.sh :2     # Start on specific display
++#
++# To return to Hyprland after exiting:
++#   Just log out and log back in, or run: Hyprland
++
++set -e
++
++GAR_DIR="$(cd "$(dirname "$0")" && pwd)"
++GAR_BIN="$GAR_DIR/target/release/gar"
++
++# Check if gar is built
++if [[ ! -x "$GAR_BIN" ]]; then
++    echo "Error: gar not found at $GAR_BIN"
++    echo "Run: nix-shell --run 'cargo build --release'"
++    exit 1
++fi
++
++# Find display
++DISPLAY_NUM="${1:-:1}"
++
++echo "========================================"
++echo "  Starting gar window manager"
++echo "========================================"
++echo ""
++echo "  PANIC MODE: Alt+Shift+Escape"
++echo "  TTY ESCAPE: Ctrl+Alt+F2"
++echo ""
++echo "  Display: $DISPLAY_NUM"
++echo "========================================"
++echo ""
++
++# Create xinitrc for gar
++XINITRC=$(mktemp)
++cat > "$XINITRC" << EOF
++#!/bin/sh
++# Set up environment
++export GAR_LOG=info
++
++# Start gar
++exec $GAR_BIN
++EOF
++chmod +x "$XINITRC"
++
++# Trap to clean up
++cleanup() {
++    rm -f "$XINITRC"
++    echo ""
++    echo "gar exited. You can now return to your normal session."
++}
++trap cleanup EXIT
++
++# Start X with gar
++echo "Starting X server with gar..."
++echo "Press Ctrl+C here or Alt+Shift+Escape in gar to exit"
++echo ""
++
++startx "$XINITRC" -- "$DISPLAY_NUM" vt$(tty | grep -o '[0-9]*' || echo 7)

gardesk/gar / `0e5c598`

8 changed files