`0e5c598`

Add multi-monitor support and panic mode

Multi-monitor via RandR:
- Detect monitors, distribute workspaces across them
- mod+comma/period to focus prev/next monitor
- mod+shift+comma/period to move window to monitor
- Per-monitor workspace switching, hotplug support
- garctl: focus-monitor, move-to-monitor, get-monitors

Panic mode:
- mod+shift+Escape exits gar immediately
- start-gar.sh script for real X11 testing
- Default config now uses Super key

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 4 months ago

SHA: 0e5c59844f386dfef35f0c4c7e705b860890c13e
Parents: a392445
Tree: 916a212

8 changed files

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)
 -local mod = "alt"
 +-- Use "mod" for real X session, "alt" for nested testing (Xephyr)
 +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)