`79cf08a`

Sprint 8: EWMH/ICCCM, fullscreen, urgency, titlebars, i3-style workspaces

- EWMH: _NET_SUPPORTING_WM_CHECK, _NET_CLIENT_LIST, ClientMessage handler
- ICCCM: WM_HINTS and WM_NORMAL_HINTS parsing
- Fullscreen: toggle support, Mod+Shift+f keybind
- Urgency: PropertyNotify handler, border_color_urgent, clear on focus
- Title bars: frame.rs reparenting framework, config options
- i3-style: dynamic workspace/monitor assignment, follow_window_on_move

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

SHA: 79cf08a65627854e3d4de428f099d40df95adc77
Parents: 0c71d2c
Tree: 368e870

8 changed files

Status	File	+	-
M	`gar/src/config/lua.rs`	58	0
M	`gar/src/config/mod.rs`	18	0
M	`gar/src/core/mod.rs`	316	58
M	`gar/src/core/window.rs`	19	0
M	`gar/src/x11/connection.rs`	272	1
M	`gar/src/x11/events.rs`	332	54
A	`gar/src/x11/frame.rs`	290	0
M	`gar/src/x11/mod.rs`	2	0

gar/src/config/lua.rsmodified

      Reload,
      Exit,
      ToggleFloating,
 +    ToggleFullscreen,
      CycleFloating,
      FocusMonitor(String),     // "next", "prev", or monitor name
      MoveToMonitor(String),    // "next", "prev", or monitor name
+                         }
+                     }
+                 }
 +                "border_color_urgent" => {
 +                    if let Value::String(s) = value {
 +                        if let Ok(str_val) = s.to_str() {
 +                            if let Some(color) = parse_color(&str_val) {
 +                                state.config.border_color_urgent = color;
 +                            }
 +                        }
 +                    }
 +                }
                  "gap_inner" => {
                      if let Value::Integer(v) = value {
                          state.config.gap_inner = v as u32;
                          state.config.gap_outer = v as u32;
+                     }
+                 }
 +                "titlebar_enabled" => {
 +                    if let Value::Boolean(v) = value {
 +                        state.config.titlebar_enabled = v;
 +                    }
 +                }
 +                "titlebar_height" => {
 +                    if let Value::Integer(v) = value {
 +                        state.config.titlebar_height = v as u32;
 +                    }
 +                }
 +                "titlebar_color_focused" => {
 +                    if let Value::String(s) = value {
 +                        if let Ok(str_val) = s.to_str() {
 +                            if let Some(color) = parse_color(&str_val) {
 +                                state.config.titlebar_color_focused = color;
 +                            }
 +                        }
 +                    }
 +                }
 +                "titlebar_color_unfocused" => {
 +                    if let Value::String(s) = value {
 +                        if let Ok(str_val) = s.to_str() {
 +                            if let Some(color) = parse_color(&str_val) {
 +                                state.config.titlebar_color_unfocused = color;
 +                            }
 +                        }
 +                    }
 +                }
 +                "titlebar_text_color" => {
 +                    if let Value::String(s) = value {
 +                        if let Ok(str_val) = s.to_str() {
 +                            if let Some(color) = parse_color(&str_val) {
 +                                state.config.titlebar_text_color = color;
 +                            }
 +                        }
 +                    }
 +                }
 +                "follow_window_on_move" => {
 +                    if let Value::Boolean(v) = value {
 +                        state.config.follow_window_on_move = v;
 +                    }
 +                }
                  _ => {
                      tracing::warn!("Unknown config key: {}", key);
+                 }
                              "exit" => Action::Exit,
                              "equalize" => Action::Equalize,
                              "toggle_floating" => Action::ToggleFloating,
 +                            "toggle_fullscreen" => Action::ToggleFullscreen,
                              "cycle_floating" => Action::CycleFloating,
                              "focus" => {
                                  let dir: String = t.get("direction").unwrap_or_default();
          toggle_floating.set("action", "toggle_floating")?;
          gar.set("toggle_floating", toggle_floating)?;
 +        // gar.toggle_fullscreen
 +        let toggle_fullscreen = self.lua.create_table()?;
 +        toggle_fullscreen.set("action", "toggle_fullscreen")?;
 +        gar.set("toggle_fullscreen", toggle_fullscreen)?;
++
          // gar.cycle_floating
          let cycle_floating = self.lua.create_table()?;
          cycle_floating.set("action", "cycle_floating")?;

gar/src/config/mod.rsmodified

      pub border_width: u32,
      pub border_color_focused: u32,
      pub border_color_unfocused: u32,
 +    pub border_color_urgent: u32,
      pub gap_inner: u32,
      pub gap_outer: u32,
 +    // Title bar settings
 +    pub titlebar_enabled: bool,
 +    pub titlebar_height: u32,
 +    pub titlebar_color_focused: u32,
 +    pub titlebar_color_unfocused: u32,
 +    pub titlebar_text_color: u32,
 +    // Behavior settings
 +    pub follow_window_on_move: bool,
+ }
  impl Default for Config {
              border_width: 2,
              border_color_focused: 0x5294e2,
              border_color_unfocused: 0x2d2d2d,
 +            border_color_urgent: 0xff5555, // Red for urgent windows
              gap_inner: 0,
              gap_outer: 0,
 +            // Title bars disabled by default
 +            titlebar_enabled: false,
 +            titlebar_height: 20,
 +            titlebar_color_focused: 0x3d3d3d,
 +            titlebar_color_unfocused: 0x2d2d2d,
 +            titlebar_text_color: 0xffffff,
 +            // Behavior: follow window when moving to another workspace
 +            follow_window_on_move: false,
+         }
+     }
+ }

gar/src/core/mod.rsmodified

  use crate::ipc::IpcServer;
  use crate::x11::Connection;
  use crate::x11::events::DragState;
 +use crate::x11::FrameManager;
  use crate::Result;
  pub struct WindowManager {
      pub ipc_server: Option<IpcServer>,
      /// Timestamp of last pointer warp - used to suppress EnterNotify feedback loop
      pub last_warp: std::time::Instant,
 +    /// Frame manager for title bars
 +    pub frames: FrameManager,
+ }
  impl WindowManager {
              ));
+         }
 -        // Assign workspaces to monitors
 -        let ws_count = workspaces.len();
 -        let mon_count = monitors.len();
 +        // i3-style: each monitor starts with one workspace (1, 2, 3...)
 +        // Any workspace can be moved to any monitor dynamically
          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);
 +            monitor.workspaces = vec![i]; // Just track initial workspace
 +            monitor.active_workspace = i; // Monitor 0 shows ws 0, monitor 1 shows ws 1, etc.
 +            tracing::debug!("Monitor '{}' starts with workspace {}", monitor.name, i + 1);
+         }
          Ok(Self {
              drag_state: None,
              ipc_server,
              last_warp: std::time::Instant::now(),
 +            frames: FrameManager::new(),
          })
+     }
              .unwrap_or_else(|| Rect::new(0, 0, self.conn.screen_width, self.conn.screen_height))
+     }
 -    /// Find which monitor a workspace belongs to.
 +    /// Find which monitor is currently displaying a workspace (i3-style).
      pub fn monitor_for_workspace(&self, workspace_idx: usize) -> Option<&Monitor> {
 -        self.monitors.iter().find(|m| m.workspaces.contains(&workspace_idx))
 +        self.monitors.iter().find(|m| m.active_workspace == workspace_idx)
+     }
 -    /// Find the monitor index for a workspace.
 +    /// Find the monitor index currently displaying a workspace (i3-style).
      pub fn monitor_idx_for_workspace(&self, workspace_idx: usize) -> Option<usize> {
 -        self.monitors.iter().position(|m| m.workspaces.contains(&workspace_idx))
 +        self.monitors.iter().position(|m| m.active_workspace == workspace_idx)
+     }
      /// Refresh monitors (called on RandR screen change).
              ));
+         }
 -        // Reassign workspaces to monitors
 -        let ws_count = self.workspaces.len();
 -        let mon_count = new_monitors.len();
 +        // Try to preserve workspace assignments from old monitors
 +        // If we have more monitors now, new ones get next available workspaces
 +        let old_mon_count = self.monitors.len();
 +        let mut used_workspaces: std::collections::HashSet<usize> = std::collections::HashSet::new();
++
          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);
 +            if i < old_mon_count {
 +                // Preserve old monitor's workspace
 +                monitor.active_workspace = self.monitors[i].active_workspace;
 +                monitor.workspaces = vec![monitor.active_workspace];
 +                used_workspaces.insert(monitor.active_workspace);
 +            } else {
 +                // New monitor - assign first unused workspace
 +                let first_free = (0..self.workspaces.len())
 +                    .find(|ws| !used_workspaces.contains(ws))
 +                    .unwrap_or(0);
 +                monitor.active_workspace = first_free;
 +                monitor.workspaces = vec![first_free];
 +                used_workspaces.insert(first_free);
 +            }
 +            tracing::info!("Monitor '{}' showing workspace {}", monitor.name, monitor.active_workspace + 1);
+         }
          self.monitors = new_monitors;
              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;
 -        }
 +        // Update focused_workspace to match the focused monitor
 +        self.focused_workspace = self.monitors[self.focused_monitor].active_workspace;
          // Re-apply layout for visible workspaces
          self.apply_layout()?;
              .insert_with_rect(window, focused, screen);
          self.current_workspace_mut().focused = Some(window);
          self.focused_window = Some(window);
++
 +        // Update EWMH client lists
 +        self.update_client_lists();
+     }
      /// Add a window to management on a specific workspace.
          let focused = self.workspaces[workspace_idx].focused;
          let screen = self.screen_rect();
          self.workspaces[workspace_idx].tree.insert_with_rect(window, focused, screen);
++
 +        // Update EWMH client lists
 +        self.update_client_lists();
+     }
      /// Add a window to management as a floating window on a specific workspace.
          // Add to target workspace's floating list
          self.workspaces[workspace_idx].add_floating(window);
++
 +        // Update EWMH client lists
 +        self.update_client_lists();
+     }
      /// Add a window to management as a floating window.
          self.current_workspace_mut().add_floating(window);
          self.current_workspace_mut().focused = Some(window);
          self.focused_window = Some(window);
++
 +        // Update EWMH client lists
 +        self.update_client_lists();
 +    }
++
 +    /// Create a frame for a window if title bars are enabled.
 +    /// Returns the frame window ID if created.
 +    pub fn create_frame_for_window(&mut self, window: XWindow) -> Option<XWindow> {
 +        if !self.config.titlebar_enabled {
 +            return None;
 +        }
++
 +        // Get window title for display
 +        let title = self.conn.get_window_title(window).unwrap_or_default();
++
 +        // Create frame with initial geometry (will be updated by apply_layout)
 +        let screen = self.screen_rect();
 +        let frame = match self.frames.create_frame(
 +            &self.conn.conn,
 +            self.conn.root,
 +            window,
 +            screen.x,
 +            screen.y,
 +            400, // Initial width, will be adjusted
 +            300, // Initial height, will be adjusted
 +            self.config.titlebar_height as u16,
 +            self.config.border_width as u16,
 +            self.config.border_color_unfocused,
 +            self.config.titlebar_color_unfocused,
 +        ) {
 +            Ok(f) => f,
 +            Err(e) => {
 +                tracing::error!("Failed to create frame for window {}: {}", window, e);
 +                return None;
 +            }
 +        };
++
 +        // Update window state with frame and title
 +        if let Some(win) = self.windows.get_mut(&window) {
 +            win.frame = Some(frame);
 +            win.title = title;
 +        }
++
 +        Some(frame)
+     }
      /// Remove a window from management.
              let ws_idx = win.workspace;
              tracing::info!("Unmanaging window {} from workspace {}", window, ws_idx + 1);
 +            // Destroy frame if it exists
 +            if win.frame.is_some() {
 +                if let Err(e) = self.frames.destroy_frame(&self.conn.conn, self.conn.root, window) {
 +                    tracing::warn!("Failed to destroy frame for window {}: {}", window, e);
 +                }
 +            }
++
              // Remove from the window's actual workspace (not current_workspace!)
              if win.floating {
                  self.workspaces[ws_idx].remove_floating(window);
                      .or_else(|| self.workspaces[ws_idx].floating.last().copied());
                  self.workspaces[ws_idx].focused = self.focused_window;
+             }
++
 +            // Update EWMH client lists
 +            self.update_client_lists();
 +        }
 +    }
++
 +    /// Update _NET_CLIENT_LIST and _NET_CLIENT_LIST_STACKING on root window.
 +    pub fn update_client_lists(&self) {
 +        let windows: Vec<u32> = self.windows.keys().copied().collect();
 +        if let Err(e) = self.conn.update_client_list(&windows) {
 +            tracing::warn!("Failed to update client list: {}", e);
 +        }
 +        // For stacking order, we use the same list for now (tiling WM doesn't have true stacking)
 +        // A more sophisticated implementation would order by focus history
 +        if let Err(e) = self.conn.update_client_list_stacking(&windows) {
 +            tracing::warn!("Failed to update client list stacking: {}", e);
+         }
+     }
      pub fn set_focus(&mut self, window: XWindow) -> Result<()> {
          self.focused_window = Some(window);
          self.current_workspace_mut().focused = Some(window);
++
 +        // Clear urgency when window receives focus
 +        if let Some(win) = self.windows.get_mut(&window) {
 +            if win.urgent {
 +                tracing::debug!("Clearing urgency for window {} on focus", window);
 +                win.urgent = false;
 +            }
 +        }
++
          self.conn.set_focus(window)?;
          self.conn.set_active_window(Some(window))?;
          self.update_borders()?;
          Ok(())
+     }
 +    /// Toggle fullscreen state for a window.
 +    pub fn toggle_fullscreen(&mut self, window: XWindow) -> Result<()> {
 +        let win = match self.windows.get_mut(&window) {
 +            Some(w) => w,
 +            None => return Ok(()),
 +        };
++
 +        let ws_idx = win.workspace;
++
 +        if win.fullscreen {
 +            // Exit fullscreen - restore previous state
 +            tracing::info!("Window {} exiting fullscreen", window);
++
 +            win.fullscreen = false;
++
 +            // Restore previous floating state
 +            let was_floating = win.pre_fullscreen_floating;
 +            if was_floating != win.floating {
 +                if was_floating {
 +                    // Was floating before - remove from tree, add to floating
 +                    self.workspaces[ws_idx].tree.remove(window);
 +                    self.workspaces[ws_idx].add_floating(window);
 +                } else {
 +                    // Was tiled before - remove from floating, add to tree
 +                    self.workspaces[ws_idx].remove_floating(window);
 +                    let focused = self.workspaces[ws_idx].focused;
 +                    let screen = self.screen_rect();
 +                    self.workspaces[ws_idx].tree.insert_with_rect(window, focused, screen);
 +                }
 +                if let Some(w) = self.windows.get_mut(&window) {
 +                    w.floating = was_floating;
 +                }
 +            }
++
 +            // Clear EWMH fullscreen state
 +            let _ = self.conn.set_window_state(window, &[]);
 +        } else {
 +            // Enter fullscreen
 +            tracing::info!("Window {} entering fullscreen", window);
++
 +            // Save current state
 +            win.pre_fullscreen_floating = win.floating;
 +            win.fullscreen = true;
++
 +            // Set EWMH fullscreen state
 +            let _ = self.conn.set_window_state(window, &[self.conn.net_wm_state_fullscreen]);
 +        }
++
 +        // Re-apply layout (fullscreen windows get special treatment in apply_layout)
 +        self.apply_layout()?;
 +        self.conn.flush()?;
 +        Ok(())
 +    }
++
 +    /// Set fullscreen state for a window explicitly (for EWMH client messages).
 +    pub fn set_fullscreen(&mut self, window: XWindow, fullscreen: bool) -> Result<()> {
 +        let is_fullscreen = self.windows.get(&window).map(|w| w.fullscreen).unwrap_or(false);
 +        if is_fullscreen != fullscreen {
 +            self.toggle_fullscreen(window)?;
 +        }
 +        Ok(())
 +    }
++
      /// Warp pointer to center of a monitor (for focus without windows)
      pub fn warp_to_monitor(&mut self, monitor_idx: usize) -> Result<()> {
          let geom = self.monitors[monitor_idx].geometry;
          Ok(())
+     }
 -    /// Update border colors for all visible windows based on focus state.
 +    /// Update border colors for all visible windows based on focus and urgency state.
      pub fn update_borders(&mut self) -> Result<()> {
          let focused = self.focused_window;
          let focused_color = self.config.border_color_focused;
          let unfocused_color = self.config.border_color_unfocused;
 +        let urgent_color = self.config.border_color_urgent;
          let border_width = self.config.border_width;
          // Get all visible workspace indices
          // Update borders for all windows on visible workspaces
          for ws_idx in visible_ws {
              for window in self.workspaces[ws_idx].all_windows() {
 -                let color = if Some(window) == focused {
 +                // Check if window is urgent (and not focused - focused clears urgency)
 +                let is_urgent = self.windows.get(&window)
 +                    .map(|w| w.urgent && Some(window) != focused)
 +                    .unwrap_or(false);
++
 +                let color = if is_urgent {
 +                    urgent_color
 +                } else if Some(window) == focused {
                      focused_color
                  } else {
                      unfocused_color
                  };
 -                self.conn.set_border(window, border_width, color)?;
++
 +                // If window has a frame, set border on the frame instead
 +                if self.windows.get(&window).and_then(|w| w.frame).is_some() {
 +                    self.frames.set_frame_border(&self.conn.conn, window, color)?;
 +                } else {
 +                    self.conn.set_border(window, border_width, color)?;
 +                }
+             }
+         }
          Ok(())
          // Layout each monitor's active workspace
          for (ws_idx, screen) in &visible_workspaces {
 +            // Check for fullscreen windows on this workspace
 +            let fullscreen_windows: Vec<XWindow> = self.windows.iter()
 +                .filter(|(_, w)| w.workspace == *ws_idx && w.fullscreen)
 +                .map(|(id, _)| *id)
 +                .collect();
++
 +            // If there's a fullscreen window, it takes the whole monitor
 +            if let Some(&fs_window) = fullscreen_windows.first() {
 +                tracing::debug!(
 +                    "apply_layout: FULLSCREEN window={} on monitor {:?}",
 +                    fs_window, screen
 +                );
++
 +                // Configure fullscreen window to cover entire monitor (no gaps, no borders)
 +                self.conn.configure_window(
 +                    fs_window,
 +                    screen.x,
 +                    screen.y,
 +                    screen.width,
 +                    screen.height,
 +                    0, // No border for fullscreen
 +                )?;
++
 +                // Raise fullscreen window above everything
 +                let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
 +                self.conn.conn.configure_window(fs_window, &aux)?;
++
 +                // Skip normal layout for this workspace - fullscreen window covers everything
 +                continue;
 +            }
++
              let work_area = Rect::new(
                  screen.x + gap_outer,
                  screen.y + gap_outer,
                  ws.tree.window_count(), ws.floating.len()
              );
 +            // Get titlebar settings
 +            let titlebar_enabled = self.config.titlebar_enabled;
 +            let titlebar_height = self.config.titlebar_height as u16;
++
              // 1. Configure tiled windows from the BSP tree
              let geometries = ws.tree.calculate_geometries(work_area);
              for (window, rect) in &geometries {
                  let final_width = gapped_width.saturating_sub(2 * border_width as u16);
                  let final_height = gapped_height.saturating_sub(2 * border_width as u16);
 -                tracing::debug!(
 -                    "apply_layout: TILED window={} at ({}, {}) size {}x{}",
 -                    window, gapped_x, gapped_y, final_width.max(1), final_height.max(1)
 -                );
 +                // Check if window has a frame
 +                let has_frame = self.windows.get(window).and_then(|w| w.frame).is_some();
++
 +                if has_frame && titlebar_enabled {
 +                    // Configure frame (includes titlebar height)
 +                    let client_height = final_height.saturating_sub(titlebar_height);
 +                    self.frames.configure_frame(
 +                        &self.conn.conn,
 +                        *window,
 +                        gapped_x,
 +                        gapped_y,
 +                        final_width.max(1),
 +                        client_height.max(1),
 +                        titlebar_height,
 +                        border_width as u16,
 +                    )?;
 -                self.conn.configure_window(
 -                    *window,
 -                    gapped_x,
 -                    gapped_y,
 -                    final_width.max(1),
 -                    final_height.max(1),
 -                    border_width,
 -                )?;
 +                    tracing::debug!(
 +                        "apply_layout: TILED+FRAME window={} at ({}, {}) size {}x{} (titlebar: {})",
 +                        window, gapped_x, gapped_y, final_width.max(1), final_height.max(1), titlebar_height
 +                    );
 +                } else {
 +                    tracing::debug!(
 +                        "apply_layout: TILED window={} at ({}, {}) size {}x{}",
 +                        window, gapped_x, gapped_y, final_width.max(1), final_height.max(1)
 +                    );
++
 +                    self.conn.configure_window(
 +                        *window,
 +                        gapped_x,
 +                        gapped_y,
 +                        final_width.max(1),
 +                        final_height.max(1),
 +                        border_width,
 +                    )?;
 +                }
+             }
              // 2. Configure floating windows and stack them above tiled
                      let adjusted_width = geom.width.saturating_sub(2 * border_width as u16);
                      let adjusted_height = geom.height.saturating_sub(2 * border_width as u16);
 -                    tracing::debug!(
 -                        "apply_layout: FLOATING window={} at ({}, {}) size {}x{} (raising)",
 -                        window_id, geom.x, geom.y, adjusted_width.max(1), adjusted_height.max(1)
 -                    );
+-
 -                    // Configure geometry
 -                    self.conn.configure_window(
 -                        window_id,
 -                        geom.x,
 -                        geom.y,
 -                        adjusted_width.max(1),
 -                        adjusted_height.max(1),
 -                        border_width,
 -                    )?;
+-
 -                    // Raise to top of stack (each subsequent window goes above the previous)
 -                    let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
 -                    self.conn.conn.configure_window(window_id, &aux)?;
 +                    let has_frame = win.frame.is_some();
++
 +                    if has_frame && titlebar_enabled {
 +                        // Configure frame for floating window
 +                        let client_height = adjusted_height.saturating_sub(titlebar_height);
 +                        self.frames.configure_frame(
 +                            &self.conn.conn,
 +                            window_id,
 +                            geom.x,
 +                            geom.y,
 +                            adjusted_width.max(1),
 +                            client_height.max(1),
 +                            titlebar_height,
 +                            border_width as u16,
 +                        )?;
++
 +                        // Raise frame to top of stack
 +                        if let Some(frame) = self.frames.frame_for_client(window_id) {
 +                            let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
 +                            self.conn.conn.configure_window(frame, &aux)?;
 +                        }
++
 +                        tracing::debug!(
 +                            "apply_layout: FLOATING+FRAME window={} at ({}, {}) size {}x{} (raising)",
 +                            window_id, geom.x, geom.y, adjusted_width.max(1), adjusted_height.max(1)
 +                        );
 +                    } else {
 +                        tracing::debug!(
 +                            "apply_layout: FLOATING window={} at ({}, {}) size {}x{} (raising)",
 +                            window_id, geom.x, geom.y, adjusted_width.max(1), adjusted_height.max(1)
 +                        );
++
 +                        // Configure geometry
 +                        self.conn.configure_window(
 +                            window_id,
 +                            geom.x,
 +                            geom.y,
 +                            adjusted_width.max(1),
 +                            adjusted_height.max(1),
 +                            border_width,
 +                        )?;
++
 +                        // Raise to top of stack (each subsequent window goes above the previous)
 +                        let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
 +                        self.conn.conn.configure_window(window_id, &aux)?;
 +                    }
                  } else {
                      tracing::warn!("apply_layout: floating window {} not in windows map!", window_id);
+                 }

gar/src/core/window.rsmodified

      pub mapped: bool,
      pub focused: bool,
      pub floating: bool,
 +    pub fullscreen: bool,
 +    /// Saved geometry before entering fullscreen (for restore)
 +    pub pre_fullscreen_geometry: Option<Rect>,
 +    /// Was the window floating before entering fullscreen?
 +    pub pre_fullscreen_floating: bool,
      pub urgent: bool,
      pub workspace: usize,
 +    /// Frame window ID (if title bars are enabled, client is reparented into this)
 +    pub frame: Option<XWindow>,
 +    /// Window title (cached from _NET_WM_NAME or WM_NAME)
 +    pub title: String,
+ }
  impl Window {
              mapped: false,
              focused: false,
              floating: false,
 +            fullscreen: false,
 +            pre_fullscreen_geometry: None,
 +            pre_fullscreen_floating: false,
              urgent: false,
              workspace,
 +            frame: None,
 +            title: String::new(),
+         }
+     }
++
 +    /// Get the window to configure (frame if present, otherwise client).
 +    pub fn outer_window(&self) -> XWindow {
 +        self.frame.unwrap_or(self.id)
 +    }
+ }

gar/src/x11/connection.rsmodified

  use super::Error;
 +/// Parsed WM_HINTS structure (ICCCM).
 +#[derive(Debug, Clone, Default)]
 +pub struct WmHints {
 +    pub input: bool,
 +    pub initial_state: Option<u32>,
 +    pub urgent: bool,
 +}
++
 +/// Parsed WM_NORMAL_HINTS (size hints) structure (ICCCM).
 +#[derive(Debug, Clone, Default)]
 +pub struct SizeHints {
 +    pub min_width: Option<u32>,
 +    pub min_height: Option<u32>,
 +    pub max_width: Option<u32>,
 +    pub max_height: Option<u32>,
 +    pub base_width: Option<u32>,
 +    pub base_height: Option<u32>,
 +    pub width_inc: Option<u32>,
 +    pub height_inc: Option<u32>,
 +}
++
  pub struct Connection {
      pub conn: RustConnection,
      pub screen_num: usize,
      pub wm_protocols: Atom,
      pub wm_delete_window: Atom,
      pub wm_transient_for: Atom,
 +    pub wm_hints: Atom,
 +    pub wm_normal_hints: Atom,
      // EWMH atoms for window types
      pub net_wm_window_type: Atom,
      pub net_wm_window_type_dialog: Atom,
      // EWMH atoms for window state
      pub net_wm_state: Atom,
      pub net_wm_state_modal: Atom,
 +    pub net_wm_state_fullscreen: Atom,
      // EWMH atoms for workspaces
      pub net_supported: Atom,
 +    pub net_supporting_wm_check: Atom,
 +    pub net_client_list: Atom,
 +    pub net_client_list_stacking: Atom,
 +    pub net_close_window: Atom,
 +    pub net_wm_name: Atom,
      pub net_number_of_desktops: Atom,
      pub net_current_desktop: Atom,
      pub net_desktop_names: Atom,
      pub net_wm_desktop: Atom,
      pub net_active_window: Atom,
      pub utf8_string: Atom,
 +    // Compositor integration
 +    pub net_wm_bypass_compositor: Atom,
+ }
  impl Connection {
          let wm_protocols = conn.intern_atom(false, b"WM_PROTOCOLS")?.reply()?.atom;
          let wm_delete_window = conn.intern_atom(false, b"WM_DELETE_WINDOW")?.reply()?.atom;
          let wm_transient_for = conn.intern_atom(false, b"WM_TRANSIENT_FOR")?.reply()?.atom;
 +        let wm_hints = conn.intern_atom(false, b"WM_HINTS")?.reply()?.atom;
 +        let wm_normal_hints = conn.intern_atom(false, b"WM_NORMAL_HINTS")?.reply()?.atom;
          // Intern EWMH atoms for window types
          let net_wm_window_type = conn.intern_atom(false, b"_NET_WM_WINDOW_TYPE")?.reply()?.atom;
          // Intern EWMH atoms for window state
          let net_wm_state = conn.intern_atom(false, b"_NET_WM_STATE")?.reply()?.atom;
          let net_wm_state_modal = conn.intern_atom(false, b"_NET_WM_STATE_MODAL")?.reply()?.atom;
 +        let net_wm_state_fullscreen = conn.intern_atom(false, b"_NET_WM_STATE_FULLSCREEN")?.reply()?.atom;
 -        // Intern EWMH atoms for workspaces
 +        // Intern EWMH atoms for workspaces and WM identification
          let net_supported = conn.intern_atom(false, b"_NET_SUPPORTED")?.reply()?.atom;
 +        let net_supporting_wm_check = conn.intern_atom(false, b"_NET_SUPPORTING_WM_CHECK")?.reply()?.atom;
 +        let net_client_list = conn.intern_atom(false, b"_NET_CLIENT_LIST")?.reply()?.atom;
 +        let net_client_list_stacking = conn.intern_atom(false, b"_NET_CLIENT_LIST_STACKING")?.reply()?.atom;
 +        let net_close_window = conn.intern_atom(false, b"_NET_CLOSE_WINDOW")?.reply()?.atom;
 +        let net_wm_name = conn.intern_atom(false, b"_NET_WM_NAME")?.reply()?.atom;
          let net_number_of_desktops = conn.intern_atom(false, b"_NET_NUMBER_OF_DESKTOPS")?.reply()?.atom;
          let net_current_desktop = conn.intern_atom(false, b"_NET_CURRENT_DESKTOP")?.reply()?.atom;
          let net_desktop_names = conn.intern_atom(false, b"_NET_DESKTOP_NAMES")?.reply()?.atom;
          let net_active_window = conn.intern_atom(false, b"_NET_ACTIVE_WINDOW")?.reply()?.atom;
          let utf8_string = conn.intern_atom(false, b"UTF8_STRING")?.reply()?.atom;
 +        // Compositor integration atom - apps can set this to request un-redirection for fullscreen
 +        let net_wm_bypass_compositor = conn.intern_atom(false, b"_NET_WM_BYPASS_COMPOSITOR")?.reply()?.atom;
++
          tracing::info!(
              "Connected to X server, screen {}x{}",
              screen_width,
              wm_protocols,
              wm_delete_window,
              wm_transient_for,
 +            wm_hints,
 +            wm_normal_hints,
              net_wm_window_type,
              net_wm_window_type_dialog,
              net_wm_window_type_utility,
              net_wm_window_type_notification,
              net_wm_state,
              net_wm_state_modal,
 +            net_wm_state_fullscreen,
              net_supported,
 +            net_supporting_wm_check,
 +            net_client_list,
 +            net_client_list_stacking,
 +            net_close_window,
 +            net_wm_name,
              net_number_of_desktops,
              net_current_desktop,
              net_desktop_names,
              net_wm_desktop,
              net_active_window,
              utf8_string,
 +            net_wm_bypass_compositor,
          })
+     }
          Ok(())
+     }
 +    /// Warp the mouse pointer to absolute screen coordinates.
 +    pub fn warp_pointer(&self, x: i16, y: i16) -> Result<(), Error> {
 +        self.conn.warp_pointer(
 +            x11rb::NONE,  // src_window
 +            self.root,    // dst_window (root for absolute coords)
 +            0, 0,         // src_x, src_y
 +            0, 0,         // src_width, src_height
 +            x,            // dst_x
 +            y,            // dst_y
 +        )?;
 +        Ok(())
 +    }
++
      /// Set window border width and color.
      pub fn set_border(&self, window: Window, width: u32, color: u32) -> Result<(), Error> {
          let aux = ChangeWindowAttributesAux::new().border_pixel(color);
          None
+     }
 +    /// Get WM_HINTS for a window (ICCCM).
 +    /// Returns urgency flag and other hints.
 +    pub fn get_wm_hints(&self, window: Window) -> Option<WmHints> {
 +        let reply = self.conn.get_property(
 +            false,
 +            window,
 +            self.wm_hints,
 +            AtomEnum::ANY,
 +            0,
 +            9, // WM_HINTS has 9 32-bit values
 +        ).ok()?.reply().ok()?;
++
 +        if reply.format != 32 || reply.value.len() < 4 {
 +            return None;
 +        }
++
 +        // Parse the 32-bit values
 +        let values: Vec<u32> = reply.value
 +            .chunks_exact(4)
 +            .map(|chunk| u32::from_ne_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]))
 +            .collect();
++
 +        if values.is_empty() {
 +            return None;
 +        }
++
 +        let flags = values[0];
++
 +        // Flag bits from ICCCM
 +        const INPUT_HINT: u32 = 1 << 0;
 +        const STATE_HINT: u32 = 1 << 1;
 +        const URGENCY_HINT: u32 = 1 << 8; // XUrgencyHint
++
 +        let mut hints = WmHints::default();
++
 +        // Input hint (does window want keyboard focus?)
 +        if flags & INPUT_HINT != 0 && values.len() > 1 {
 +            hints.input = values[1] != 0;
 +        } else {
 +            hints.input = true; // Default to accepting input
 +        }
++
 +        // Initial state hint
 +        if flags & STATE_HINT != 0 && values.len() > 2 {
 +            hints.initial_state = Some(values[2]);
 +        }
++
 +        // Urgency hint
 +        hints.urgent = flags & URGENCY_HINT != 0;
++
 +        Some(hints)
 +    }
++
 +    /// Get WM_NORMAL_HINTS (size hints) for a window (ICCCM).
 +    pub fn get_size_hints(&self, window: Window) -> Option<SizeHints> {
 +        let reply = self.conn.get_property(
 +            false,
 +            window,
 +            self.wm_normal_hints,
 +            AtomEnum::ANY,
 +            0,
 +            18, // WM_SIZE_HINTS has up to 18 32-bit values
 +        ).ok()?.reply().ok()?;
++
 +        if reply.format != 32 || reply.value.len() < 4 {
 +            return None;
 +        }
++
 +        // Parse the 32-bit values
 +        let values: Vec<u32> = reply.value
 +            .chunks_exact(4)
 +            .map(|chunk| u32::from_ne_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]))
 +            .collect();
++
 +        if values.is_empty() {
 +            return None;
 +        }
++
 +        let flags = values[0];
++
 +        // Flag bits from ICCCM (indices into the values array)
 +        const P_MIN_SIZE: u32 = 1 << 4;    // min_width, min_height at [5], [6]
 +        const P_MAX_SIZE: u32 = 1 << 5;    // max_width, max_height at [7], [8]
 +        const P_RESIZE_INC: u32 = 1 << 6;  // width_inc, height_inc at [9], [10]
 +        const P_BASE_SIZE: u32 = 1 << 8;   // base_width, base_height at [15], [16]
++
 +        let mut hints = SizeHints::default();
++
 +        // Min size (indices 5, 6)
 +        if flags & P_MIN_SIZE != 0 && values.len() > 6 {
 +            hints.min_width = Some(values[5]);
 +            hints.min_height = Some(values[6]);
 +        }
++
 +        // Max size (indices 7, 8)
 +        if flags & P_MAX_SIZE != 0 && values.len() > 8 {
 +            hints.max_width = Some(values[7]);
 +            hints.max_height = Some(values[8]);
 +        }
++
 +        // Resize increment (indices 9, 10)
 +        if flags & P_RESIZE_INC != 0 && values.len() > 10 {
 +            hints.width_inc = Some(values[9]);
 +            hints.height_inc = Some(values[10]);
 +        }
++
 +        // Base size (indices 15, 16)
 +        if flags & P_BASE_SIZE != 0 && values.len() > 16 {
 +            hints.base_width = Some(values[15]);
 +            hints.base_height = Some(values[16]);
 +        }
++
 +        Some(hints)
 +    }
++
      /// Set _NET_SUPPORTED on root window to advertise supported EWMH atoms.
      pub fn set_ewmh_supported(&self) -> Result<(), Error> {
          let supported = [
              self.net_supported,
 +            self.net_supporting_wm_check,
 +            self.net_client_list,
 +            self.net_client_list_stacking,
              self.net_number_of_desktops,
              self.net_current_desktop,
              self.net_desktop_names,
              self.net_wm_desktop,
              self.net_active_window,
 +            self.net_close_window,
 +            self.net_wm_state,
 +            self.net_wm_state_fullscreen,
 +            self.net_wm_name,
          ];
          self.conn.change_property32(
              x11rb::protocol::xproto::PropMode::REPLACE,
          Ok(())
+     }
 +    /// Setup _NET_SUPPORTING_WM_CHECK window and set _NET_WM_NAME.
 +    /// Returns the check window ID for cleanup.
 +    pub fn setup_wm_check(&self) -> Result<Window, Error> {
 +        use x11rb::protocol::xproto::{CreateWindowAux, WindowClass, PropMode};
++
 +        // Create a small off-screen window for WM identification
 +        let check_window = self.conn.generate_id()?;
 +        self.conn.create_window(
 +            0, // depth: copy from parent
 +            check_window,
 +            self.root,
 +            -1, -1, 1, 1, // x, y, width, height (off-screen)
 +            0, // border_width
 +            WindowClass::INPUT_OUTPUT,
 +            0, // visual: copy from parent
 +            &CreateWindowAux::new(),
 +        )?;
++
 +        // Set _NET_SUPPORTING_WM_CHECK on root window pointing to check window
 +        self.conn.change_property32(
 +            PropMode::REPLACE,
 +            self.root,
 +            self.net_supporting_wm_check,
 +            AtomEnum::WINDOW,
 +            &[check_window],
 +        )?;
++
 +        // Set _NET_SUPPORTING_WM_CHECK on check window pointing to itself
 +        self.conn.change_property32(
 +            PropMode::REPLACE,
 +            check_window,
 +            self.net_supporting_wm_check,
 +            AtomEnum::WINDOW,
 +            &[check_window],
 +        )?;
++
 +        // Set _NET_WM_NAME on check window to "gar"
 +        self.conn.change_property8(
 +            PropMode::REPLACE,
 +            check_window,
 +            self.net_wm_name,
 +            self.utf8_string,
 +            b"gar",
 +        )?;
++
 +        tracing::info!("Created WM check window {}", check_window);
 +        Ok(check_window)
 +    }
++
 +    /// Update _NET_CLIENT_LIST on root window with all managed windows.
 +    pub fn update_client_list(&self, windows: &[Window]) -> Result<(), Error> {
 +        self.conn.change_property32(
 +            x11rb::protocol::xproto::PropMode::REPLACE,
 +            self.root,
 +            self.net_client_list,
 +            AtomEnum::WINDOW,
 +            windows,
 +        )?;
 +        Ok(())
 +    }
++
 +    /// Update _NET_CLIENT_LIST_STACKING on root window with windows in stacking order.
 +    pub fn update_client_list_stacking(&self, windows: &[Window]) -> Result<(), Error> {
 +        self.conn.change_property32(
 +            x11rb::protocol::xproto::PropMode::REPLACE,
 +            self.root,
 +            self.net_client_list_stacking,
 +            AtomEnum::WINDOW,
 +            windows,
 +        )?;
 +        Ok(())
 +    }
++
      /// Set _NET_NUMBER_OF_DESKTOPS on root window.
      pub fn set_number_of_desktops(&self, count: u32) -> Result<(), Error> {
          self.conn.change_property32(
          Ok(())
+     }
 +    /// Set _NET_WM_STATE on a window with the specified state atoms.
 +    pub fn set_window_state(&self, window: Window, states: &[Atom]) -> Result<(), Error> {
 +        self.conn.change_property32(
 +            x11rb::protocol::xproto::PropMode::REPLACE,
 +            window,
 +            self.net_wm_state,
 +            AtomEnum::ATOM,
 +            states,
 +        )?;
 +        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};

gar/src/x11/events.rsmodified

  use x11rb::connection::Connection as X11Connection;
  use x11rb::protocol::xproto::{
 -    ButtonPressEvent, ButtonReleaseEvent, ConfigureRequestEvent, ConfigureWindowAux, ConnectionExt,
 -    DestroyNotifyEvent, EnterNotifyEvent, EventMask, KeyPressEvent, MapRequestEvent, ModMask,
 -    MotionNotifyEvent, NotifyMode, StackMode, UnmapNotifyEvent,
 +    ButtonPressEvent, ButtonReleaseEvent, ClientMessageEvent, ConfigureRequestEvent,
 +    ConfigureWindowAux, ConnectionExt, DestroyNotifyEvent, EnterNotifyEvent, EventMask,
 +    ExposeEvent, KeyPressEvent, MapRequestEvent, ModMask, MotionNotifyEvent, NotifyMode,
 +    PropertyNotifyEvent, StackMode, UnmapNotifyEvent,
  };
  use x11rb::protocol::Event;
          // Advertise supported EWMH atoms
          self.conn.set_ewmh_supported()?;
 +        // Create WM check window for EWMH identification
 +        self.conn.setup_wm_check()?;
++
 +        // Initialize empty client lists
 +        self.conn.update_client_list(&[])?;
 +        self.conn.update_client_list_stacking(&[])?;
++
          // Set number of desktops
          let num_desktops = self.workspaces.len() as u32;
          self.conn.set_number_of_desktops(num_desktops)?;
                  tracing::info!("RandR notify event, refreshing monitors");
                  self.refresh_monitors()?;
+             }
 +            Event::ClientMessage(e) => {
 +                self.handle_client_message(e)?;
 +            }
 +            Event::PropertyNotify(e) => {
 +                self.handle_property_notify(e)?;
 +            }
 +            Event::Expose(e) => {
 +                self.handle_expose(e)?;
 +            }
              _ => {
                  tracing::trace!("Unhandled event: {:?}", event);
+             }
              } else {
                  self.manage_window_on_workspace(window, target_idx);
+             }
 +            // Create frame if title bars enabled
 +            self.create_frame_for_window(window);
              // Don't map - it's on another workspace
          } else {
              // Window goes to current workspace
              } else {
                  self.manage_window(window);
+             }
 -            // Map the window
 +            // Create frame if title bars enabled
 +            let frame = self.create_frame_for_window(window);
++
 +            // Map the window (and frame if present)
 +            if frame.is_some() {
 +                self.frames.map_frame(&self.conn.conn, window)?;
 +            }
              self.conn.map_window(window)?;
+         }
          Ok(())
+     }
 +    /// Handle EWMH client message requests (focus, workspace switch, close, state changes).
 +    fn handle_client_message(&mut self, event: ClientMessageEvent) -> Result<()> {
 +        let msg_type = event.type_;
 +        let window = event.window;
++
 +        if msg_type == self.conn.net_active_window {
 +            // Application requesting focus
 +            tracing::debug!("ClientMessage: _NET_ACTIVE_WINDOW for window {}", window);
++
 +            if self.windows.contains_key(&window) {
 +                // Get the window's workspace and switch to it if needed
 +                if let Some(win) = self.windows.get(&window) {
 +                    let ws_idx = win.workspace;
 +                    if ws_idx != self.focused_workspace {
 +                        self.switch_workspace(ws_idx)?;
 +                    }
 +                }
 +                // Focus the window
 +                if let Some(old) = self.focused_window {
 +                    self.conn.grab_button(old)?;
 +                }
 +                self.set_focus(window)?;
 +                self.conn.ungrab_button(window)?;
 +                if self.is_floating(window) {
 +                    self.raise_window(window)?;
 +                }
 +            }
 +        } else if msg_type == self.conn.net_current_desktop {
 +            // Workspace switch request (from pagers, etc.)
 +            let desktop = event.data.as_data32()[0] as usize;
 +            tracing::debug!("ClientMessage: _NET_CURRENT_DESKTOP to {}", desktop);
++
 +            if desktop < self.workspaces.len() {
 +                self.switch_workspace(desktop)?;
 +            }
 +        } else if msg_type == self.conn.net_close_window {
 +            // Close window request
 +            tracing::debug!("ClientMessage: _NET_CLOSE_WINDOW for window {}", window);
++
 +            if self.windows.contains_key(&window) {
 +                self.close_window(window)?;
 +            }
 +        } else if msg_type == self.conn.net_wm_state {
 +            // Window state change request (fullscreen, etc.)
 +            let action = event.data.as_data32()[0];
 +            let property = event.data.as_data32()[1];
 +            tracing::debug!(
 +                "ClientMessage: _NET_WM_STATE action={} property={} for window {}",
 +                action, property, window
 +            );
++
 +            // Handle fullscreen state changes
 +            if property == self.conn.net_wm_state_fullscreen {
 +                // action: 0 = remove, 1 = add, 2 = toggle
 +                match action {
 +                    0 => {
 +                        // Remove fullscreen
 +                        self.set_fullscreen(window, false)?;
 +                    }
 +                    1 => {
 +                        // Add fullscreen
 +                        self.set_fullscreen(window, true)?;
 +                    }
 +                    2 => {
 +                        // Toggle fullscreen
 +                        self.toggle_fullscreen(window)?;
 +                    }
 +                    _ => {}
 +                }
 +            }
 +        } else {
 +            tracing::trace!("Unhandled ClientMessage type: {}", msg_type);
 +        }
++
 +        self.conn.flush()?;
 +        Ok(())
 +    }
++
 +    /// Handle PropertyNotify events (urgency hints, etc.).
 +    fn handle_property_notify(&mut self, event: PropertyNotifyEvent) -> Result<()> {
 +        let window = event.window;
 +        let atom = event.atom;
++
 +        // Check if WM_HINTS changed (urgency flag may have changed)
 +        if atom == self.conn.wm_hints {
 +            // Only handle for managed windows
 +            if !self.windows.contains_key(&window) {
 +                return Ok(());
 +            }
++
 +            tracing::debug!("WM_HINTS changed for window {}", window);
++
 +            // Get the current WM_HINTS
 +            if let Some(hints) = self.conn.get_wm_hints(window) {
 +                let old_urgent = self.windows.get(&window).map(|w| w.urgent).unwrap_or(false);
 +                let new_urgent = hints.urgent;
++
 +                if old_urgent != new_urgent {
 +                    tracing::info!(
 +                        "Window {} urgency changed: {} -> {}",
 +                        window, old_urgent, new_urgent
 +                    );
++
 +                    // Update window state
 +                    if let Some(win) = self.windows.get_mut(&window) {
 +                        win.urgent = new_urgent;
 +                    }
++
 +                    // Update border colors
 +                    self.update_borders()?;
 +                    self.conn.flush()?;
 +                }
 +            }
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Handle Expose events to redraw title bars.
 +    fn handle_expose(&mut self, event: ExposeEvent) -> Result<()> {
 +        let window = event.window;
++
 +        // Only process when count is 0 (last expose in batch)
 +        if event.count != 0 {
 +            return Ok(());
 +        }
++
 +        // Check if this is a frame window
 +        if let Some(client) = self.frames.client_for_frame(window) {
 +            // Redraw the title bar
 +            if self.config.titlebar_enabled {
 +                let win_state = self.windows.get(&client);
 +                let title = win_state.map(|w| w.title.as_str()).unwrap_or("");
 +                let focused = self.focused_window == Some(client);
++
 +                let bg_color = if focused {
 +                    self.config.titlebar_color_focused
 +                } else {
 +                    self.config.titlebar_color_unfocused
 +                };
++
 +                // Get frame width from expose event
 +                let width = event.width;
 +                let titlebar_height = self.config.titlebar_height as u16;
++
 +                self.frames.draw_titlebar(
 +                    &self.conn.conn,
 +                    client,
 +                    title,
 +                    width,
 +                    titlebar_height,
 +                    bg_color,
 +                    self.config.titlebar_text_color,
 +                    focused,
 +                )?;
++
 +                self.conn.flush()?;
 +            }
 +        }
++
 +        Ok(())
 +    }
++
      fn handle_key_press(&mut self, event: KeyPressEvent) -> Result<()> {
          let keycode = event.detail;
          let state = event.state;
                      self.toggle_floating(window)?;
+                 }
+             }
 +            Action::ToggleFullscreen => {
 +                if let Some(window) = self.focused_window {
 +                    self.toggle_fullscreen(window)?;
 +                }
 +            }
              Action::CycleFloating => {
                  self.cycle_floating()?;
+             }
          Ok(())
+     }
 +    /// Switch to workspace using i3-style behavior:
 +    /// - If workspace is visible on another monitor, focus moves to that monitor
 +    /// - If workspace is not visible, it appears on the current monitor
      fn switch_workspace(&mut self, idx: usize) -> Result<()> {
          if idx >= self.workspaces.len() {
              return Ok(());
+         }
 -        // Find which monitor owns this workspace
 -        let target_monitor_idx = self.monitor_idx_for_workspace(idx).unwrap_or(0);
 -        let old_ws_on_target = self.monitors[target_monitor_idx].active_workspace;
 +        // Check if workspace is already visible on some monitor
 +        let visible_on_monitor = self.monitors.iter().position(|m| m.active_workspace == idx);
 -        // Already on this workspace?
 -        if idx == old_ws_on_target && target_monitor_idx == self.focused_monitor {
 -            return Ok(());
 -        }
 +        if let Some(monitor_idx) = visible_on_monitor {
 +            // Workspace is already visible - just focus that monitor (i3 behavior)
 +            if monitor_idx == self.focused_monitor {
 +                // Already on this workspace on this monitor
 +                return Ok(());
 +            }
 -        tracing::info!(
 -            "Switching to workspace {} on monitor {} (was ws {})",
 -            idx + 1, target_monitor_idx, old_ws_on_target + 1
 -        );
 +            tracing::info!(
 +                "Workspace {} already visible on monitor {}, focusing it",
 +                idx + 1, monitor_idx
 +            );
++
 +            // Focus the monitor that has this workspace
 +            self.focused_monitor = monitor_idx;
 +            self.focused_workspace = idx;
++
 +            // Update EWMH
 +            self.conn.set_current_desktop(idx as u32)?;
++
 +            // Warp pointer to that monitor
 +            let monitor_geom = self.monitors[monitor_idx].geometry;
 +            let center_x = monitor_geom.x + (monitor_geom.width as i16 / 2);
 +            let center_y = monitor_geom.y + (monitor_geom.height as i16 / 2);
 +            self.conn.warp_pointer(center_x, center_y)?;
 +            self.last_warp = std::time::Instant::now();
++
 +            // Focus a window on that workspace
 +            if let Some(window) = self.workspaces[idx].focused
 +                .or_else(|| self.workspaces[idx].floating.last().copied())
 +                .or_else(|| self.workspaces[idx].tree.first_window())
 +            {
 +                self.set_focus(window)?;
 +            } else {
 +                self.focused_window = None;
 +                self.conn.set_active_window(None)?;
 +            }
 +        } else {
 +            // Workspace not visible - show it on current monitor (i3 behavior)
 +            let current_monitor = self.focused_monitor;
 +            let old_ws = self.monitors[current_monitor].active_workspace;
++
 +            tracing::info!(
 +                "Switching monitor {} from workspace {} to {}",
 +                current_monitor, old_ws + 1, idx + 1
 +            );
 -        // If switching to a different workspace on the target monitor, hide old/show new
 -        if idx != old_ws_on_target {
              // Hide windows on old workspace
 -            for window in self.workspaces[old_ws_on_target].all_windows() {
 +            for window in self.workspaces[old_ws].all_windows() {
                  self.conn.unmap_window(window)?;
 +                // Also unmap frames if present
 +                if let Some(frame) = self.frames.frame_for_client(window) {
 +                    self.conn.unmap_window(frame)?;
 +                }
+             }
              // Update monitor's active workspace
 -            self.monitors[target_monitor_idx].active_workspace = idx;
 +            self.monitors[current_monitor].active_workspace = idx;
 +            self.focused_workspace = idx;
++
 +            // Update EWMH
 +            self.conn.set_current_desktop(idx as u32)?;
              // Show windows on new workspace
              for window in self.workspaces[idx].all_windows() {
 +                if let Some(frame) = self.frames.frame_for_client(window) {
 +                    self.conn.map_window(frame)?;
 +                }
                  self.conn.map_window(window)?;
+             }
 -        }
 -        // Update focused state
 -        self.focused_monitor = target_monitor_idx;
 -        self.focused_workspace = idx;
+-
 -        // Update EWMH _NET_CURRENT_DESKTOP
 -        self.conn.set_current_desktop(idx as u32)?;
+-
 -        // Apply layout
 -        self.apply_layout()?;
 +            // Apply layout
 +            self.apply_layout()?;
 -        // Focus a window on the target workspace
 -        if let Some(window) = self.workspaces[idx].focused
 -            .or_else(|| self.workspaces[idx].floating.last().copied())
 -            .or_else(|| self.workspaces[idx].tree.first_window())
 -        {
 -            self.set_focus(window)?;
 -            self.conn.ungrab_button(window)?;
 -        } else {
 -            self.focused_window = None;
 +            // Focus a window on the new workspace
 +            if let Some(window) = self.workspaces[idx].focused
 +                .or_else(|| self.workspaces[idx].floating.last().copied())
 +                .or_else(|| self.workspaces[idx].tree.first_window())
 +            {
 +                self.set_focus(window)?;
 +            } else {
 +                // No windows - warp to center of monitor
 +                self.focused_window = None;
 +                self.conn.set_active_window(None)?;
 +                let monitor_geom = self.monitors[current_monitor].geometry;
 +                let center_x = monitor_geom.x + (monitor_geom.width as i16 / 2);
 +                let center_y = monitor_geom.y + (monitor_geom.height as i16 / 2);
 +                self.conn.warp_pointer(center_x, center_y)?;
 +                self.last_warp = std::time::Instant::now();
 +            }
+         }
          self.conn.flush()?;
+     }
      fn move_to_workspace(&mut self, idx: usize) -> Result<()> {
 -        if idx >= self.workspaces.len() || idx == self.focused_workspace {
 +        if idx >= self.workspaces.len() {
              return Ok(());
+         }
              return Ok(());
          };
 +        // Get current workspace for this window
 +        let current_ws = self.windows.get(&window).map(|w| w.workspace).unwrap_or(self.focused_workspace);
++
 +        // Don't move if already on target workspace
 +        if idx == current_ws {
 +            return Ok(());
 +        }
++
          let is_floating = self.windows.get(&window).map(|w| w.floating).unwrap_or(false);
 -        tracing::info!("Moving window {} to workspace {} (floating: {})", window, idx + 1, is_floating);
 +        tracing::info!("Moving window {} from workspace {} to {} (floating: {})",
 +            window, current_ws + 1, idx + 1, is_floating);
          // Remove from current workspace (tree or floating list)
          if is_floating {
 -            self.current_workspace_mut().remove_floating(window);
 +            self.workspaces[current_ws].remove_floating(window);
          } else {
 -            self.current_workspace_mut().tree.remove(window);
 +            self.workspaces[current_ws].tree.remove(window);
+         }
          // Update focus on current workspace
 -        self.focused_window = self.current_workspace().tree.first_window()
 -            .or_else(|| self.current_workspace().floating.last().copied());
 -        self.current_workspace_mut().focused = self.focused_window;
 +        let new_focus_on_current = self.workspaces[current_ws].tree.first_window()
 +            .or_else(|| self.workspaces[current_ws].floating.last().copied());
 +        self.workspaces[current_ws].focused = new_focus_on_current;
          // Update window's workspace tracking
          if let Some(win) = self.windows.get_mut(&window) {
          // Update EWMH _NET_WM_DESKTOP
          self.conn.set_window_desktop(window, idx as u32)?;
 -        // Hide the window (it's moving to another workspace)
 -        self.conn.unmap_window(window)?;
 +        // Check if target workspace is visible on any monitor
 +        let target_visible_on = self.monitors.iter().position(|m| m.active_workspace == idx);
 -        // Insert into target workspace (use target monitor's geometry)
 +        // Insert into target workspace
          if is_floating {
              self.workspaces[idx].add_floating(window);
          } else {
              let target_focused = self.workspaces[idx].focused;
 -            let screen = self.workspace_rect(idx);
 +            // Use target monitor's geometry if visible, otherwise use current monitor's
 +            let screen = if let Some(mon_idx) = target_visible_on {
 +                self.monitors[mon_idx].geometry
 +            } else {
 +                self.monitors[self.focused_monitor].geometry
 +            };
              self.workspaces[idx]
                  .tree
                  .insert_with_rect(window, target_focused, screen);
+         }
 -        // Re-apply layout on current workspace
 +        // If target workspace is visible, map the window; otherwise hide it
 +        if target_visible_on.is_some() {
 +            // Target is visible - map the window
 +            if let Some(frame) = self.frames.frame_for_client(window) {
 +                self.conn.map_window(frame)?;
 +            }
 +            self.conn.map_window(window)?;
 +        } else {
 +            // Target is not visible - hide the window
 +            self.conn.unmap_window(window)?;
 +            if let Some(frame) = self.frames.frame_for_client(window) {
 +                self.conn.unmap_window(frame)?;
 +            }
 +        }
++
 +        // Re-apply layout
          self.apply_layout()?;
 -        // Update focus
 -        if let Some(new_focus) = self.focused_window {
 -            self.set_focus(new_focus)?;
 -            self.conn.ungrab_button(new_focus)?;
 +        // Check if we should follow the window to the target workspace
 +        if self.config.follow_window_on_move {
 +            // Switch to target workspace (this will focus the moved window)
 +            self.switch_workspace(idx)?;
 +        } else {
 +            // Stay on current workspace, update focus to next window
 +            if current_ws == self.focused_workspace {
 +                self.focused_window = new_focus_on_current;
 +                if let Some(new_focus) = self.focused_window {
 +                    self.set_focus(new_focus)?;
 +                } else {
 +                    self.conn.set_active_window(None)?;
 +                }
 +            }
+         }
          self.conn.flush()?;

gar/src/x11/frame.rsadded

 +//! Frame window management for title bars.
 +//!
 +//! When title bars are enabled, client windows are reparented into frame windows.
 +//! The frame handles the title bar drawing and the client sits below it.
++
 +use std::collections::HashMap;
++
 +use x11rb::connection::Connection as X11Connection;
 +use x11rb::protocol::xproto::{
 +    ChangeWindowAttributesAux, ConfigureWindowAux, ConnectionExt, CreateGCAux, CreateWindowAux,
 +    EventMask, Gcontext, Rectangle, Window, WindowClass,
 +};
 +use x11rb::COPY_DEPTH_FROM_PARENT;
++
 +use super::Error;
++
 +/// Manages frame windows for title bars.
 +pub struct FrameManager {
 +    /// Map from client window to frame window
 +    client_to_frame: HashMap<Window, Window>,
 +    /// Map from frame window to client window
 +    frame_to_client: HashMap<Window, Window>,
 +    /// Graphics context for drawing (reused)
 +    gc: Option<Gcontext>,
 +}
++
 +impl FrameManager {
 +    pub fn new() -> Self {
 +        Self {
 +            client_to_frame: HashMap::new(),
 +            frame_to_client: HashMap::new(),
 +            gc: None,
 +        }
 +    }
++
 +    /// Check if a window is a frame we created.
 +    pub fn is_frame(&self, window: Window) -> bool {
 +        self.frame_to_client.contains_key(&window)
 +    }
++
 +    /// Get the client window for a frame.
 +    pub fn client_for_frame(&self, frame: Window) -> Option<Window> {
 +        self.frame_to_client.get(&frame).copied()
 +    }
++
 +    /// Get the frame window for a client.
 +    pub fn frame_for_client(&self, client: Window) -> Option<Window> {
 +        self.client_to_frame.get(&client).copied()
 +    }
++
 +    /// Create a frame window for a client and reparent the client into it.
 +    pub fn create_frame<C: X11Connection>(
 +        &mut self,
 +        conn: &C,
 +        root: Window,
 +        client: Window,
 +        x: i16,
 +        y: i16,
 +        width: u16,
 +        height: u16,
 +        titlebar_height: u16,
 +        border_width: u16,
 +        border_color: u32,
 +        bg_color: u32,
 +    ) -> Result<Window, Error> {
 +        // Total frame height includes title bar + client area
 +        let frame_height = height + titlebar_height;
++
 +        // Generate a new window ID for the frame
 +        let frame = conn.generate_id()?;
++
 +        // Create the frame window
 +        let aux = CreateWindowAux::new()
 +            .event_mask(
 +                EventMask::SUBSTRUCTURE_REDIRECT
 +                    | EventMask::SUBSTRUCTURE_NOTIFY
 +                    | EventMask::BUTTON_PRESS
 +                    | EventMask::BUTTON_RELEASE
 +                    | EventMask::ENTER_WINDOW
 +                    | EventMask::EXPOSURE,
 +            )
 +            .background_pixel(bg_color)
 +            .border_pixel(border_color);
++
 +        conn.create_window(
 +            COPY_DEPTH_FROM_PARENT,
 +            frame,
 +            root,
 +            x,
 +            y,
 +            width,
 +            frame_height,
 +            border_width,
 +            WindowClass::INPUT_OUTPUT,
 +            0, // CopyFromParent visual
 +            &aux,
 +        )?;
++
 +        // Reparent the client window into the frame, below the title bar
 +        conn.reparent_window(client, frame, 0, titlebar_height as i16)?;
++
 +        // Configure the client to fill the frame width
 +        let client_aux = ConfigureWindowAux::new()
 +            .x(0)
 +            .y(titlebar_height as i32)
 +            .width(width as u32)
 +            .height(height as u32)
 +            .border_width(0); // No border on client inside frame
 +        conn.configure_window(client, &client_aux)?;
++
 +        // Track the mapping
 +        self.client_to_frame.insert(client, frame);
 +        self.frame_to_client.insert(frame, client);
++
 +        tracing::debug!(
 +            "Created frame {} for client {} at ({}, {}) size {}x{} (titlebar: {})",
 +            frame, client, x, y, width, frame_height, titlebar_height
 +        );
++
 +        Ok(frame)
 +    }
++
 +    /// Destroy a frame and reparent the client back to root.
 +    pub fn destroy_frame<C: X11Connection>(
 +        &mut self,
 +        conn: &C,
 +        root: Window,
 +        client: Window,
 +    ) -> Result<(), Error> {
 +        if let Some(frame) = self.client_to_frame.remove(&client) {
 +            self.frame_to_client.remove(&frame);
++
 +            // Reparent client back to root
 +            conn.reparent_window(client, root, 0, 0)?;
++
 +            // Destroy the frame window
 +            conn.destroy_window(frame)?;
++
 +            tracing::debug!("Destroyed frame {} for client {}", frame, client);
 +        }
 +        Ok(())
 +    }
++
 +    /// Configure a frame's geometry.
 +    pub fn configure_frame<C: X11Connection>(
 +        &self,
 +        conn: &C,
 +        client: Window,
 +        x: i16,
 +        y: i16,
 +        width: u16,
 +        height: u16,
 +        titlebar_height: u16,
 +        border_width: u16,
 +    ) -> Result<(), Error> {
 +        if let Some(&frame) = self.client_to_frame.get(&client) {
 +            let frame_height = height + titlebar_height;
++
 +            // Configure frame position and size
 +            let frame_aux = ConfigureWindowAux::new()
 +                .x(x as i32)
 +                .y(y as i32)
 +                .width(width as u32)
 +                .height(frame_height as u32)
 +                .border_width(border_width as u32);
 +            conn.configure_window(frame, &frame_aux)?;
++
 +            // Configure client within frame
 +            let client_aux = ConfigureWindowAux::new()
 +                .x(0)
 +                .y(titlebar_height as i32)
 +                .width(width as u32)
 +                .height(height as u32);
 +            conn.configure_window(client, &client_aux)?;
 +        }
 +        Ok(())
 +    }
++
 +    /// Draw a title bar on the frame.
 +    pub fn draw_titlebar<C: X11Connection>(
 +        &mut self,
 +        conn: &C,
 +        client: Window,
 +        title: &str,
 +        width: u16,
 +        titlebar_height: u16,
 +        bg_color: u32,
 +        text_color: u32,
 +        focused: bool,
 +    ) -> Result<(), Error> {
 +        let Some(&frame) = self.client_to_frame.get(&client) else {
 +            return Ok(());
 +        };
++
 +        // Ensure we have a GC
 +        let gc = match self.gc {
 +            Some(gc) => gc,
 +            None => {
 +                let gc = conn.generate_id()?;
 +                let aux = CreateGCAux::new()
 +                    .foreground(text_color)
 +                    .background(bg_color);
 +                conn.create_gc(gc, frame, &aux)?;
 +                self.gc = Some(gc);
 +                gc
 +            }
 +        };
++
 +        // Update GC colors
 +        let gc_aux = ChangeWindowAttributesAux::new();
 +        let _ = gc_aux; // We'll use ChangeGC instead
++
 +        // Clear the title bar area with background color
 +        let rect = Rectangle {
 +            x: 0,
 +            y: 0,
 +            width,
 +            height: titlebar_height,
 +        };
++
 +        // Set fill color and fill rectangle
 +        conn.change_gc(gc, &x11rb::protocol::xproto::ChangeGCAux::new().foreground(bg_color))?;
 +        conn.poly_fill_rectangle(frame, gc, &[rect])?;
++
 +        // Draw the title text (simple, centered vertically)
 +        if !title.is_empty() {
 +            conn.change_gc(gc, &x11rb::protocol::xproto::ChangeGCAux::new().foreground(text_color))?;
++
 +            // Draw text at (8, titlebar_height - 4) - simple positioning
 +            // X11 core fonts are limited, but this gives basic text rendering
 +            let text_y = titlebar_height.saturating_sub(4) as i16;
 +            conn.image_text8(frame, gc, 8, text_y, title.as_bytes())?;
 +        }
++
 +        // Add a focus indicator - subtle line at bottom
 +        if focused {
 +            let indicator_rect = Rectangle {
 +                x: 0,
 +                y: (titlebar_height - 2) as i16,
 +                width,
 +                height: 2,
 +            };
 +            conn.change_gc(gc, &x11rb::protocol::xproto::ChangeGCAux::new().foreground(0x5294e2))?; // Blue accent
 +            conn.poly_fill_rectangle(frame, gc, &[indicator_rect])?;
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Update frame border color.
 +    pub fn set_frame_border<C: X11Connection>(
 +        &self,
 +        conn: &C,
 +        client: Window,
 +        border_color: u32,
 +    ) -> Result<(), Error> {
 +        if let Some(&frame) = self.client_to_frame.get(&client) {
 +            let aux = ChangeWindowAttributesAux::new().border_pixel(border_color);
 +            conn.change_window_attributes(frame, &aux)?;
 +        }
 +        Ok(())
 +    }
++
 +    /// Map the frame window.
 +    pub fn map_frame<C: X11Connection>(&self, conn: &C, client: Window) -> Result<(), Error> {
 +        if let Some(&frame) = self.client_to_frame.get(&client) {
 +            conn.map_window(frame)?;
 +        }
 +        Ok(())
 +    }
++
 +    /// Unmap the frame window.
 +    pub fn unmap_frame<C: X11Connection>(&self, conn: &C, client: Window) -> Result<(), Error> {
 +        if let Some(&frame) = self.client_to_frame.get(&client) {
 +            conn.unmap_window(frame)?;
 +        }
 +        Ok(())
 +    }
++
 +    /// Get all frame windows.
 +    pub fn all_frames(&self) -> impl Iterator<Item = Window> + '_ {
 +        self.frame_to_client.keys().copied()
 +    }
 +}
++
 +impl Default for FrameManager {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}

gar/src/x11/mod.rsmodified

  pub mod connection;
  pub mod error;
  pub mod events;
 +pub mod frame;
  pub use connection::Connection;
  pub use error::Error;
 +pub use frame::FrameManager;