`6ca3c46`

Add deferred features: gaps, rules, EWMH, startup adoption

- Gaps: gap_inner between windows, gap_outer around screen edges
- Window rules: gar.rule() for class/instance/title matching
- gar.exec_once() for autostart commands
- EWMH workspace hints for status bar integration
- Adopt existing windows on WM startup
- Cycle floating windows with mod+Tab
- Auto-create user config on first run

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

SHA: 6ca3c46cf3a7d2bb323f5a74faaf349f926a5bf0
Parents: 1572972
Tree: d3c6b83

9 changed files

Status	File	+	-
M	`gar/config/default.lua`	6	3
M	`gar/src/config/lua.rs`	126	18
M	`gar/src/config/mod.rs`	1	1
M	`gar/src/core/mod.rs`	234	20
M	`gar/src/core/window.rs`	3	2
M	`gar/src/core/workspace.rs`	28	3
M	`gar/src/main.rs`	8	3
M	`gar/src/x11/connection.rs`	355	2
M	`gar/src/x11/events.rs`	284	79

gar/config/default.luamodified

  gar.set("border_width", 2)
  gar.set("border_color_focused", "#5294e2")
  gar.set("border_color_unfocused", "#2d2d2d")
 -gar.set("gap_inner", 0)
 -gar.set("gap_outer", 0)
 +gar.set("gap_inner", 8)
 +gar.set("gap_outer", 8)
  -- Mod key: "mod" = Super/Win, "alt" = Alt
  -- Using alt for testing in nested X (i3 grabs super)
  gar.bind(mod .. "+e", gar.equalize)
  -- Toggle floating
 -gar.bind(mod .. "+shift+space", gar.toggle_floating)
 +gar.bind(mod .. "+f", gar.toggle_floating)
++
 +-- Cycle through floating windows
 +gar.bind(mod .. "+Tab", gar.cycle_floating)
  -- Workspaces
  for i = 1, 9 do

gar/src/config/lua.rsmodified

 +use std::collections::HashSet;
  use std::path::PathBuf;
  use std::sync::{Arc, Mutex};
      Reload,
      Exit,
      ToggleFloating,
 +    CycleFloating,
      LuaCallback(usize), // Index into callback registry
+ }
      pub action: Action,
+ }
 +/// Window rule matching criteria
 +#[derive(Debug, Clone, Default)]
 +pub struct WindowMatch {
 +    pub class: Option<String>,
 +    pub instance: Option<String>,
 +    pub title: Option<String>,
 +}
++
 +/// Actions to apply when a rule matches
 +#[derive(Debug, Clone, Default)]
 +pub struct RuleActions {
 +    pub floating: Option<bool>,
 +    pub workspace: Option<usize>,
 +}
++
 +/// A window rule: if match criteria are met, apply actions
 +#[derive(Debug, Clone)]
 +pub struct WindowRule {
 +    pub match_criteria: WindowMatch,
 +    pub actions: RuleActions,
 +}
++
  /// Shared state between Lua and Rust
  pub struct LuaState {
      pub config: Config,
      pub keybinds: Vec<Keybind>,
      pub callbacks: Vec<mlua::RegistryKey>,
 +    pub rules: Vec<WindowRule>,
 +    pub exec_once_cmds: HashSet<String>,
+ }
  impl Default for LuaState {
              config: Config::default(),
              keybinds: Vec::new(),
              callbacks: Vec::new(),
 +            rules: Vec::new(),
 +            exec_once_cmds: HashSet::new(),
+         }
+     }
+ }
          // Set up the gar global table with all APIs
          self.setup_api()?;
 -        // Find config file
 -        let config_path = Self::find_config();
 +        // Find or create config file
 +        let config_path = Self::find_or_create_config()?;
 -        let source = match config_path {
 -            Some(path) => {
 -                tracing::info!("Loading config from {:?}", path);
 -                std::fs::read_to_string(&path).map_err(|e| mlua::Error::external(e))?
 -            }
 -            None => {
 -                tracing::info!("Using default config");
 -                include_str!("../../config/default.lua").to_string()
 -            }
 -        };
 +        tracing::info!("Loading config from {:?}", config_path);
 +        let source = std::fs::read_to_string(&config_path)
 +            .map_err(|e| mlua::Error::external(e))?;
          self.lua.load(&source).exec()?;
          Ok(())
+     }
 -    /// Reload configuration (clears existing keybinds)
 +    /// Reload configuration (clears existing keybinds and rules)
      pub fn reload(&self) -> LuaResult<()> {
+         {
              let mut state = self.state.lock().unwrap();
              state.keybinds.clear();
              state.callbacks.clear();
 +            state.rules.clear();
              state.config = Config::default();
+         }
          self.load()
          Ok(())
+     }
 -    fn find_config() -> Option<PathBuf> {
 -        dirs::config_dir()
 -            .map(|p| p.join("gar/init.lua"))
 -            .filter(|p| p.exists())
 +    /// Find user config or create it from defaults if it doesn't exist.
 +    fn find_or_create_config() -> LuaResult<PathBuf> {
 +        let config_dir = dirs::config_dir()
 +            .ok_or_else(|| mlua::Error::external("Could not determine config directory"))?
 +            .join("gar");
 +        let config_path = config_dir.join("init.lua");
++
 +        if config_path.exists() {
 +            return Ok(config_path);
 +        }
++
 +        // Create config directory if needed
 +        if !config_dir.exists() {
 +            std::fs::create_dir_all(&config_dir)
 +                .map_err(|e| mlua::Error::external(format!("Failed to create config dir: {}", e)))?;
 +            tracing::info!("Created config directory: {:?}", config_dir);
 +        }
++
 +        // Write default config
 +        let default_config = include_str!("../../config/default.lua");
 +        std::fs::write(&config_path, default_config)
 +            .map_err(|e| mlua::Error::external(format!("Failed to write default config: {}", e)))?;
 +        tracing::info!("Created default config at {:?}", config_path);
++
 +        Ok(config_path)
+     }
      fn setup_api(&self) -> LuaResult<()> {
          // gar.exec(cmd)
          self.register_exec(&gar)?;
 +        // gar.rule(match, actions)
 +        self.register_rule(&gar)?;
++
          // Built-in action functions
          self.register_actions(&gar)?;
                              "exit" => Action::Exit,
                              "equalize" => Action::Equalize,
                              "toggle_floating" => Action::ToggleFloating,
 +                            "cycle_floating" => Action::CycleFloating,
                              "focus" => {
                                  let dir: String = t.get("direction").unwrap_or_default();
                                  Action::Focus(dir)
                  .ok();
              Ok(())
          })?;
 -        gar.set("exec", exec_fn)
 +        gar.set("exec", exec_fn)?;
++
 +        // gar.exec_once(cmd) - only run if not already run this session
 +        let state = Arc::clone(&self.state);
 +        let exec_once_fn = self.lua.create_function(move |_, cmd: String| {
 +            let mut state = state.lock().unwrap();
 +            if state.exec_once_cmds.contains(&cmd) {
 +                tracing::debug!("exec_once: skipping already-run command: {}", cmd);
 +                return Ok(());
 +            }
 +            tracing::info!("exec_once: {}", cmd);
 +            state.exec_once_cmds.insert(cmd.clone());
 +            drop(state); // Release lock before spawning
 +            std::process::Command::new("sh")
 +                .arg("-c")
 +                .arg(&cmd)
 +                .spawn()
 +                .ok();
 +            Ok(())
 +        })?;
 +        gar.set("exec_once", exec_once_fn)
 +    }
++
 +    fn register_rule(&self, gar: &Table) -> LuaResult<()> {
 +        let state = Arc::clone(&self.state);
 +        // gar.rule({ class = "Firefox" }, { floating = true, workspace = 2 })
 +        let rule_fn = self.lua.create_function(move |_, (match_table, actions_table): (Table, Table)| {
 +            let mut match_criteria = WindowMatch::default();
 +            let mut actions = RuleActions::default();
++
 +            // Parse match criteria
 +            if let Ok(class) = match_table.get::<String>("class") {
 +                match_criteria.class = Some(class);
 +            }
 +            if let Ok(instance) = match_table.get::<String>("instance") {
 +                match_criteria.instance = Some(instance);
 +            }
 +            if let Ok(title) = match_table.get::<String>("title") {
 +                match_criteria.title = Some(title);
 +            }
++
 +            // Parse actions
 +            if let Ok(floating) = actions_table.get::<bool>("floating") {
 +                actions.floating = Some(floating);
 +            }
 +            if let Ok(workspace) = actions_table.get::<usize>("workspace") {
 +                actions.workspace = Some(workspace);
 +            }
++
 +            let rule = WindowRule { match_criteria, actions };
 +            tracing::debug!("Registered rule: {:?}", rule);
++
 +            let mut state = state.lock().unwrap();
 +            state.rules.push(rule);
 +            Ok(())
 +        })?;
 +        gar.set("rule", rule_fn)
+     }
      fn register_actions(&self, gar: &Table) -> LuaResult<()> {
          toggle_floating.set("action", "toggle_floating")?;
          gar.set("toggle_floating", toggle_floating)?;
 +        // gar.cycle_floating
 +        let cycle_floating = self.lua.create_table()?;
 +        cycle_floating.set("action", "cycle_floating")?;
 +        gar.set("cycle_floating", cycle_floating)?;
++
          // gar.focus(direction) - creates action
          let focus_fn = self.lua.create_function(|lua, direction: String| {
              let t = lua.create_table()?;

gar/src/config/mod.rsmodified

  mod lua;
 -pub use lua::{Action, Keybind, LuaConfig, LuaState};
 +pub use lua::{Action, Keybind, LuaConfig, LuaState, RuleActions, WindowMatch, WindowRule};
  #[derive(Debug, Clone)]
  pub struct Config {

gar/src/core/mod.rsmodified

  use std::sync::{Arc, Mutex};
  use x11rb::protocol::xproto::Window as XWindow;
 -use crate::config::{Config, LuaConfig, LuaState};
 +use crate::config::{Config, LuaConfig, LuaState, RuleActions, WindowMatch};
  use crate::x11::Connection;
  use crate::x11::events::DragState;
  use crate::Result;
              return;
+         }
 -        tracing::info!("Managing window {}", window);
 +        tracing::info!("Managing window {} (tiled)", window);
          // Track the window with current workspace
          let win = Window::new(window, self.focused_workspace);
          self.windows.insert(window, win);
 +        // Set EWMH _NET_WM_DESKTOP
 +        let _ = self.conn.set_window_desktop(window, self.focused_workspace as u32);
++
          // Insert into current workspace's tree with smart splitting
          let focused = self.current_workspace().focused;
          let screen = self.screen_rect();
          self.focused_window = Some(window);
+     }
 +    /// Add a window to management on a specific workspace.
 +    pub fn manage_window_on_workspace(&mut self, window: XWindow, workspace_idx: usize) {
 +        if !self.should_manage(window) {
 +            return;
 +        }
++
 +        tracing::info!("Managing window {} on workspace {} (tiled)", window, workspace_idx + 1);
++
 +        // Track the window
 +        let win = Window::new(window, workspace_idx);
 +        self.windows.insert(window, win);
++
 +        // Set EWMH _NET_WM_DESKTOP
 +        let _ = self.conn.set_window_desktop(window, workspace_idx as u32);
++
 +        // Insert into target workspace's BSP tree
 +        let focused = self.workspaces[workspace_idx].focused;
 +        let screen = self.screen_rect();
 +        self.workspaces[workspace_idx].tree.insert_with_rect(window, focused, screen);
 +    }
++
 +    /// Add a window to management as a floating window on a specific workspace.
 +    pub fn manage_window_floating_on_workspace(&mut self, window: XWindow, workspace_idx: usize) {
 +        if !self.should_manage(window) {
 +            return;
 +        }
++
 +        tracing::info!("Managing window {} on workspace {} (floating)", window, workspace_idx + 1);
++
 +        // Calculate floating geometry
 +        let screen = self.screen_rect();
 +        let float_width = (screen.width * 4 / 5).max(400);
 +        let float_height = (screen.height * 4 / 5).max(300);
 +        let float_x = screen.x + (screen.width as i16 - float_width as i16) / 2;
 +        let float_y = screen.y + (screen.height as i16 - float_height as i16) / 2;
++
 +        // Track the window with floating state
 +        let mut win = Window::new(window, workspace_idx);
 +        win.floating = true;
 +        win.floating_geometry = Rect::new(float_x, float_y, float_width, float_height);
 +        self.windows.insert(window, win);
++
 +        // Set EWMH _NET_WM_DESKTOP
 +        let _ = self.conn.set_window_desktop(window, workspace_idx as u32);
++
 +        // Add to target workspace's floating list
 +        self.workspaces[workspace_idx].add_floating(window);
 +    }
++
 +    /// Add a window to management as a floating window.
 +    pub fn manage_window_floating(&mut self, window: XWindow) {
 +        if !self.should_manage(window) {
 +            return;
 +        }
++
 +        tracing::info!("Managing window {} (floating)", window);
++
 +        // Calculate centered floating geometry
 +        let screen = self.screen_rect();
 +        let float_width = 640.min(screen.width.saturating_sub(40));
 +        let float_height = 480.min(screen.height.saturating_sub(40));
 +        let float_x = screen.x + (screen.width as i16 - float_width as i16) / 2;
 +        let float_y = screen.y + (screen.height as i16 - float_height as i16) / 2;
++
 +        // Track the window with floating state
 +        let mut win = Window::new(window, self.focused_workspace);
 +        win.floating = true;
 +        win.floating_geometry = Rect::new(float_x, float_y, float_width, float_height);
 +        self.windows.insert(window, win);
++
 +        // Set EWMH _NET_WM_DESKTOP
 +        let _ = self.conn.set_window_desktop(window, self.focused_workspace as u32);
++
 +        // Add to floating list (on top)
 +        self.current_workspace_mut().add_floating(window);
 +        self.current_workspace_mut().focused = Some(window);
 +        self.focused_window = Some(window);
 +    }
++
      /// Remove a window from management.
      pub fn unmanage_window(&mut self, window: XWindow) {
 -        if self.windows.remove(&window).is_some() {
 +        if let Some(win) = self.windows.remove(&window) {
              tracing::info!("Unmanaging window {}", window);
 -            // Remove from workspace tree
 -            self.current_workspace_mut().tree.remove(window);
 +            if win.floating {
 +                // Remove from floating list
 +                self.current_workspace_mut().remove_floating(window);
 +            } else {
 +                // Remove from BSP tree
 +                self.current_workspace_mut().tree.remove(window);
 +            }
              // Update focus if this was the focused window
              if self.focused_window == Some(window) {
 -                self.focused_window = self.current_workspace().tree.first_window();
 +                // Try to focus another window (prefer tiled, then floating)
 +                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;
+             }
+         }
+     }
 +    /// Check window rules and return actions to apply.
 +    pub fn check_rules(&self, window: XWindow) -> RuleActions {
 +        let state = self.lua_state.lock().unwrap();
++
 +        // Get window properties
 +        let (instance, class) = self.conn.get_wm_class(window).unwrap_or_default();
 +        let title = self.conn.get_window_title(window).unwrap_or_default();
++
 +        tracing::debug!("Checking rules for window {}: class={}, instance={}, title={}",
 +            window, class, instance, title);
++
 +        let mut result = RuleActions::default();
++
 +        for rule in &state.rules {
 +            let matches = rule_matches(&rule.match_criteria, &class, &instance, &title);
 +            if matches {
 +                tracing::info!("Rule matched for window {}: {:?}", window, rule.actions);
 +                // Merge actions (later rules override earlier ones)
 +                if rule.actions.floating.is_some() {
 +                    result.floating = rule.actions.floating;
 +                }
 +                if rule.actions.workspace.is_some() {
 +                    result.workspace = rule.actions.workspace;
 +                }
 +            }
 +        }
++
 +        result
 +    }
++
      /// Set focus to a window.
      pub fn set_focus(&mut self, window: XWindow) -> Result<()> {
          self.focused_window = Some(window);
          self.current_workspace_mut().focused = Some(window);
          self.conn.set_focus(window)?;
 +        self.conn.set_active_window(Some(window))?;
          self.update_borders()?;
          Ok(())
+     }
          let unfocused_color = self.config.border_color_unfocused;
          let border_width = self.config.border_width;
 -        for &window in self.current_workspace().tree.windows().iter() {
 +        // Update borders for all windows (tiled + floating)
 +        for window in self.current_workspace().all_windows() {
              let color = if Some(window) == focused {
                  focused_color
              } else {
+     }
      /// Apply the current layout to all windows.
 +    /// Stacking order: tiled windows at bottom, floating windows on top (in list order).
      pub fn apply_layout(&mut self) -> Result<()> {
 +        use x11rb::protocol::xproto::{ConfigureWindowAux, ConnectionExt, StackMode};
++
          let border_width = self.config.border_width;
 +        let gap_outer = self.config.gap_outer as i16;
 +        let gap_inner = self.config.gap_inner as i16;
 +        let half_gap = gap_inner / 2;
 -        // Calculate usable area (screen minus borders)
 +        // Apply outer gap to screen rect
          let screen = self.screen_rect();
 +        let work_area = Rect::new(
 +            screen.x + gap_outer,
 +            screen.y + gap_outer,
 +            screen.width.saturating_sub(2 * gap_outer as u16),
 +            screen.height.saturating_sub(2 * gap_outer as u16),
 +        );
++
 +        tracing::debug!(
 +            "apply_layout: screen={:?}, work_area={:?}, tiled_count={}, floating_count={}",
 +            screen,
 +            work_area,
 +            self.current_workspace().tree.window_count(),
 +            self.current_workspace().floating.len()
 +        );
 -        // Get geometries from the tree
 -        let geometries = self.current_workspace().tree.calculate_geometries(screen);
 +        // 1. Configure tiled windows from the BSP tree
 +        let geometries = self.current_workspace().tree.calculate_geometries(work_area);
 +        for (window, rect) in &geometries {
 +            // Apply inner gap: shrink each window by half_gap on each side
 +            let gapped_x = rect.x + half_gap;
 +            let gapped_y = rect.y + half_gap;
 +            let gapped_width = rect.width.saturating_sub(gap_inner as u16);
 +            let gapped_height = rect.height.saturating_sub(gap_inner as u16);
 -        // Apply geometries to windows
 -        for (window, rect) in geometries {
 -            // Account for border width in geometry
 -            let adjusted_width = rect.width.saturating_sub(2 * border_width as u16);
 -            let adjusted_height = rect.height.saturating_sub(2 * border_width as u16);
 +            // Account for border width
 +            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)
 +            );
              self.conn.configure_window(
 -                window,
 -                rect.x,
 -                rect.y,
 -                adjusted_width.max(1),
 -                adjusted_height.max(1),
 +                *window,
 +                gapped_x,
 +                gapped_y,
 +                final_width.max(1),
 +                final_height.max(1),
                  border_width,
              )?;
+         }
 +        // 2. Configure floating windows and stack them above tiled
 +        // Get floating window IDs (in stacking order: first = bottom, last = top)
 +        let floating_ids: Vec<XWindow> = self.current_workspace().floating.clone();
++
 +        for window_id in floating_ids {
 +            // Get the window's floating geometry from our state
 +            if let Some(win) = self.windows.get(&window_id) {
 +                let geom = win.floating_geometry;
 +                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)?;
 +            } else {
 +                tracing::warn!("apply_layout: floating window {} not in windows map!", window_id);
 +            }
 +        }
++
          self.update_borders()?;
          self.conn.flush()?;
          Ok(())
+     }
+ }
++
 +/// Check if window properties match rule criteria (case-insensitive substring match).
 +fn rule_matches(criteria: &WindowMatch, class: &str, instance: &str, title: &str) -> bool {
 +    let class_lower = class.to_lowercase();
 +    let instance_lower = instance.to_lowercase();
 +    let title_lower = title.to_lowercase();
++
 +    // All specified criteria must match
 +    if let Some(ref c) = criteria.class {
 +        let c_lower: String = c.to_lowercase();
 +        if !class_lower.contains(&c_lower) {
 +            return false;
 +        }
 +    }
 +    if let Some(ref i) = criteria.instance {
 +        let i_lower: String = i.to_lowercase();
 +        if !instance_lower.contains(&i_lower) {
 +            return false;
 +        }
 +    }
 +    if let Some(ref t) = criteria.title {
 +        let t_lower: String = t.to_lowercase();
 +        if !title_lower.contains(&t_lower) {
 +            return false;
 +        }
 +    }
++
 +    // At least one criterion must be specified
 +    criteria.class.is_some() || criteria.instance.is_some() || criteria.title.is_some()
 +}

gar/src/core/window.rsmodified

  #[derive(Debug, Clone)]
  pub struct Window {
      pub id: XWindow,
 -    pub geometry: Rect,
 +    /// Geometry for floating mode (position and size when floating)
 +    pub floating_geometry: Rect,
      pub mapped: bool,
      pub focused: bool,
      pub floating: bool,
      pub fn new(id: XWindow, workspace: usize) -> Self {
          Self {
              id,
 -            geometry: Rect::new(0, 0, 1, 1),
 +            floating_geometry: Rect::new(0, 0, 640, 480),
              mapped: false,
              focused: false,
              floating: false,

gar/src/core/workspace.rsmodified

  use x11rb::protocol::xproto::Window as XWindow;
  use super::tree::Node;
 -use super::Window;
  #[derive(Debug)]
  pub struct Workspace {
      pub id: usize,
      pub name: String,
      pub tree: Node,
 -    pub floating: Vec<Window>,
 +    /// Floating window IDs in stacking order (first = bottom, last = top)
 +    pub floating: Vec<XWindow>,
      pub focused: Option<XWindow>,
      pub visible: bool,
+ }
      pub fn all_windows(&self) -> Vec<XWindow> {
          let mut windows = self.tree.windows();
 -        windows.extend(self.floating.iter().map(|w| w.id));
 +        windows.extend(self.floating.iter().copied());
          windows
+     }
      pub fn is_empty(&self) -> bool {
          self.tree.is_empty() && self.floating.is_empty()
+     }
++
 +    /// Add a window to the floating list (on top)
 +    pub fn add_floating(&mut self, window: XWindow) {
 +        if !self.floating.contains(&window) {
 +            self.floating.push(window);
 +        }
 +    }
++
 +    /// Remove a window from the floating list
 +    pub fn remove_floating(&mut self, window: XWindow) {
 +        self.floating.retain(|&w| w != window);
 +    }
++
 +    /// Raise a floating window to the top of the stacking order
 +    pub fn raise_floating(&mut self, window: XWindow) {
 +        if let Some(pos) = self.floating.iter().position(|&w| w == window) {
 +            self.floating.remove(pos);
 +            self.floating.push(window);
 +        }
 +    }
++
 +    /// Check if a window is in the floating list
 +    pub fn is_floating(&self, window: XWindow) -> bool {
 +        self.floating.contains(&window)
 +    }
+ }

gar/src/main.rsmodified

 +use std::fs::File;
  use tracing_subscriber::{fmt, prelude::*, EnvFilter};
  use gar::x11::Connection;
  use gar::WindowManager;
  fn main() {
 -    // Set up logging
 -    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
 +    // Set up logging to both stdout and file
 +    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("debug"));
++
 +    let log_file = File::create("/tmp/gar.log").expect("Failed to create log file");
      tracing_subscriber::registry()
 -        .with(fmt::layer())
 +        .with(fmt::layer().with_writer(std::io::stdout))
 +        .with(fmt::layer().with_writer(log_file).with_ansi(false))
          .with(filter)
          .init();
      tracing::info!("gar {} starting", env!("CARGO_PKG_VERSION"));
 +    tracing::info!("Logging to /tmp/gar.log");
      if let Err(e) = run() {
          tracing::error!("Fatal error: {}", e);

gar/src/x11/connection.rsmodified

  use x11rb::connection::Connection as X11Connection;
  use x11rb::protocol::xproto::{
 -    ButtonIndex, ChangeWindowAttributesAux, ConfigureWindowAux, ConnectionExt, EventMask,
 -    GrabMode, InputFocus, ModMask, Screen, Window,
 +    Atom, AtomEnum, ButtonIndex, ChangeWindowAttributesAux, ClientMessageData,
 +    ClientMessageEvent, ConfigureWindowAux, ConnectionExt, EventMask, GrabMode, InputFocus,
 +    ModMask, Screen, Window,
  };
  use x11rb::rust_connection::RustConnection;
  use x11rb::wrapper::ConnectionExt as WrapperConnectionExt;
      pub root: Window,
      pub screen_width: u16,
      pub screen_height: u16,
 +    // ICCCM atoms
 +    pub wm_protocols: Atom,
 +    pub wm_delete_window: Atom,
 +    pub wm_transient_for: Atom,
 +    // EWMH atoms for window types
 +    pub net_wm_window_type: Atom,
 +    pub net_wm_window_type_dialog: Atom,
 +    pub net_wm_window_type_utility: Atom,
 +    pub net_wm_window_type_toolbar: Atom,
 +    pub net_wm_window_type_splash: Atom,
 +    pub net_wm_window_type_notification: Atom,
 +    // EWMH atoms for window state
 +    pub net_wm_state: Atom,
 +    pub net_wm_state_modal: Atom,
 +    // EWMH atoms for workspaces
 +    pub net_supported: 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,
+ }
  impl Connection {
          let screen_width = screen.width_in_pixels;
          let screen_height = screen.height_in_pixels;
 +        // Intern ICCCM atoms
 +        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;
++
 +        // Intern EWMH atoms for window types
 +        let net_wm_window_type = conn.intern_atom(false, b"_NET_WM_WINDOW_TYPE")?.reply()?.atom;
 +        let net_wm_window_type_dialog = conn.intern_atom(false, b"_NET_WM_WINDOW_TYPE_DIALOG")?.reply()?.atom;
 +        let net_wm_window_type_utility = conn.intern_atom(false, b"_NET_WM_WINDOW_TYPE_UTILITY")?.reply()?.atom;
 +        let net_wm_window_type_toolbar = conn.intern_atom(false, b"_NET_WM_WINDOW_TYPE_TOOLBAR")?.reply()?.atom;
 +        let net_wm_window_type_splash = conn.intern_atom(false, b"_NET_WM_WINDOW_TYPE_SPLASH")?.reply()?.atom;
 +        let net_wm_window_type_notification = conn.intern_atom(false, b"_NET_WM_WINDOW_TYPE_NOTIFICATION")?.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;
++
 +        // Intern EWMH atoms for workspaces
 +        let net_supported = conn.intern_atom(false, b"_NET_SUPPORTED")?.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_wm_desktop = conn.intern_atom(false, b"_NET_WM_DESKTOP")?.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;
++
          tracing::info!(
              "Connected to X server, screen {}x{}",
              screen_width,
              root,
              screen_width,
              screen_height,
 +            wm_protocols,
 +            wm_delete_window,
 +            wm_transient_for,
 +            net_wm_window_type,
 +            net_wm_window_type_dialog,
 +            net_wm_window_type_utility,
 +            net_wm_window_type_toolbar,
 +            net_wm_window_type_splash,
 +            net_wm_window_type_notification,
 +            net_wm_state,
 +            net_wm_state_modal,
 +            net_supported,
 +            net_number_of_desktops,
 +            net_current_desktop,
 +            net_desktop_names,
 +            net_wm_desktop,
 +            net_active_window,
 +            utf8_string,
          })
+     }
          Ok(())
+     }
 +    /// Grab Alt+Button1 and Alt+Button3 on root for floating window move/resize.
 +    pub fn grab_mod_buttons(&self) -> Result<(), Error> {
 +        let numlock = ModMask::M2;
 +        let capslock = ModMask::LOCK;
++
 +        // Grab Alt+Button1 (move) and Alt+Button3 (resize) with NumLock/CapsLock variants
 +        for button in [ButtonIndex::M1, ButtonIndex::M3] {
 +            for mods in [
 +                ModMask::M1,
 +                ModMask::M1 | numlock,
 +                ModMask::M1 | capslock,
 +                ModMask::M1 | numlock | capslock,
 +            ] {
 +                self.conn.grab_button(
 +                    false,
 +                    self.root,
 +                    EventMask::BUTTON_PRESS | EventMask::BUTTON_RELEASE | EventMask::BUTTON_MOTION,
 +                    GrabMode::ASYNC,
 +                    GrabMode::ASYNC,
 +                    x11rb::NONE,
 +                    x11rb::NONE,
 +                    button,
 +                    mods,
 +                )?;
 +            }
 +        }
 +        tracing::debug!("Grabbed Alt+Button1/Button3 on root for floating move/resize");
 +        Ok(())
 +    }
++
      /// Set input focus to a window.
      pub fn set_focus(&self, window: Window) -> Result<(), Error> {
          self.conn
          self.conn.sync()?;
          Ok(())
+     }
++
 +    /// Check if a window supports the WM_DELETE_WINDOW protocol.
 +    pub fn supports_delete_window(&self, window: Window) -> bool {
 +        match self.conn.get_property(
 +            false,
 +            window,
 +            self.wm_protocols,
 +            AtomEnum::ATOM,
 +            0,
 +            1024,
 +        ) {
 +            Ok(cookie) => {
 +                if let Ok(reply) = cookie.reply() {
 +                    if reply.type_ == u32::from(AtomEnum::ATOM) && reply.format == 32 {
 +                        // Parse atoms from the value (32-bit little-endian values)
 +                        for chunk in reply.value.chunks_exact(4) {
 +                            let atom = u32::from_ne_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
 +                            if atom == self.wm_delete_window {
 +                                return true;
 +                            }
 +                        }
 +                    }
 +                }
 +                false
 +            }
 +            Err(_) => false,
 +        }
 +    }
++
 +    /// Send WM_DELETE_WINDOW client message to gracefully close a window.
 +    pub fn send_delete_window(&self, window: Window) -> Result<(), Error> {
 +        let data = ClientMessageData::from([
 +            self.wm_delete_window,
 +            CURRENT_TIME,
 +            0,
 +            0,
 +            0,
 +        ]);
++
 +        let event = ClientMessageEvent::new(32, window, self.wm_protocols, data);
++
 +        self.conn.send_event(false, window, EventMask::NO_EVENT, event)?;
 +        Ok(())
 +    }
++
 +    /// Check if a window should automatically float based on ICCCM/EWMH hints.
 +    /// Returns true for dialogs, transients, utilities, toolbars, splashes, etc.
 +    pub fn should_float(&self, window: Window) -> bool {
 +        // 1. Check WM_TRANSIENT_FOR (ICCCM) - dialogs and popups
 +        if let Ok(cookie) = self.conn.get_property(
 +            false,
 +            window,
 +            self.wm_transient_for,
 +            AtomEnum::WINDOW,
 +            0,
 +            1,
 +        ) {
 +            if let Ok(reply) = cookie.reply() {
 +                if reply.type_ == u32::from(AtomEnum::WINDOW) && !reply.value.is_empty() {
 +                    tracing::debug!("Window {} has WM_TRANSIENT_FOR, should float", window);
 +                    return true;
 +                }
 +            }
 +        }
++
 +        // 2. Check _NET_WM_WINDOW_TYPE (EWMH)
 +        if let Ok(cookie) = self.conn.get_property(
 +            false,
 +            window,
 +            self.net_wm_window_type,
 +            AtomEnum::ATOM,
 +            0,
 +            32,
 +        ) {
 +            if let Ok(reply) = cookie.reply() {
 +                if reply.type_ == u32::from(AtomEnum::ATOM) && reply.format == 32 {
 +                    let float_types = [
 +                        self.net_wm_window_type_dialog,
 +                        self.net_wm_window_type_utility,
 +                        self.net_wm_window_type_toolbar,
 +                        self.net_wm_window_type_splash,
 +                        self.net_wm_window_type_notification,
 +                    ];
++
 +                    for chunk in reply.value.chunks_exact(4) {
 +                        let atom = u32::from_ne_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
 +                        if float_types.contains(&atom) {
 +                            tracing::debug!("Window {} has floating window type, should float", window);
 +                            return true;
 +                        }
 +                    }
 +                }
 +            }
 +        }
++
 +        // 3. Check _NET_WM_STATE for modal windows
 +        if let Ok(cookie) = self.conn.get_property(
 +            false,
 +            window,
 +            self.net_wm_state,
 +            AtomEnum::ATOM,
 +            0,
 +            32,
 +        ) {
 +            if let Ok(reply) = cookie.reply() {
 +                if reply.type_ == u32::from(AtomEnum::ATOM) && reply.format == 32 {
 +                    for chunk in reply.value.chunks_exact(4) {
 +                        let atom = u32::from_ne_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
 +                        if atom == self.net_wm_state_modal {
 +                            tracing::debug!("Window {} is modal, should float", window);
 +                            return true;
 +                        }
 +                    }
 +                }
 +            }
 +        }
++
 +        false
 +    }
++
 +    /// Get WM_CLASS property (instance, class) for a window.
 +    pub fn get_wm_class(&self, window: Window) -> Option<(String, String)> {
 +        let wm_class_atom = self.conn.intern_atom(false, b"WM_CLASS").ok()?.reply().ok()?.atom;
 +        let string_atom = self.conn.intern_atom(false, b"STRING").ok()?.reply().ok()?.atom;
++
 +        let cookie = self.conn.get_property(false, window, wm_class_atom, string_atom, 0, 1024).ok()?;
 +        let reply = cookie.reply().ok()?;
++
 +        if reply.format != 8 {
 +            return None;
 +        }
++
 +        // WM_CLASS is two null-terminated strings: instance\0class\0
 +        let value = reply.value;
 +        let mut parts = value.split(|&b| b == 0).filter(|s| !s.is_empty());
++
 +        let instance = parts.next().and_then(|s| String::from_utf8(s.to_vec()).ok())?;
 +        let class = parts.next().and_then(|s| String::from_utf8(s.to_vec()).ok())?;
++
 +        Some((instance, class))
 +    }
++
 +    /// Get _NET_WM_NAME or WM_NAME for a window.
 +    pub fn get_window_title(&self, window: Window) -> Option<String> {
 +        // Try _NET_WM_NAME first (UTF-8)
 +        let net_wm_name = self.conn.intern_atom(false, b"_NET_WM_NAME").ok()?.reply().ok()?.atom;
 +        let utf8_string = self.conn.intern_atom(false, b"UTF8_STRING").ok()?.reply().ok()?.atom;
++
 +        if let Ok(cookie) = self.conn.get_property(false, window, net_wm_name, utf8_string, 0, 1024) {
 +            if let Ok(reply) = cookie.reply() {
 +                if reply.format == 8 && !reply.value.is_empty() {
 +                    return String::from_utf8(reply.value).ok();
 +                }
 +            }
 +        }
++
 +        // Fall back to WM_NAME
 +        let wm_name = self.conn.intern_atom(false, b"WM_NAME").ok()?.reply().ok()?.atom;
 +        let string_atom = self.conn.intern_atom(false, b"STRING").ok()?.reply().ok()?.atom;
++
 +        let cookie = self.conn.get_property(false, window, wm_name, string_atom, 0, 1024).ok()?;
 +        let reply = cookie.reply().ok()?;
++
 +        if reply.format == 8 {
 +            return String::from_utf8(reply.value).ok();
 +        }
++
 +        None
 +    }
++
 +    /// 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_number_of_desktops,
 +            self.net_current_desktop,
 +            self.net_desktop_names,
 +            self.net_wm_desktop,
 +            self.net_active_window,
 +        ];
 +        self.conn.change_property32(
 +            x11rb::protocol::xproto::PropMode::REPLACE,
 +            self.root,
 +            self.net_supported,
 +            AtomEnum::ATOM,
 +            &supported,
 +        )?;
 +        Ok(())
 +    }
++
 +    /// Set _NET_NUMBER_OF_DESKTOPS on root window.
 +    pub fn set_number_of_desktops(&self, count: u32) -> Result<(), Error> {
 +        self.conn.change_property32(
 +            x11rb::protocol::xproto::PropMode::REPLACE,
 +            self.root,
 +            self.net_number_of_desktops,
 +            AtomEnum::CARDINAL,
 +            &[count],
 +        )?;
 +        Ok(())
 +    }
++
 +    /// Set _NET_CURRENT_DESKTOP on root window.
 +    pub fn set_current_desktop(&self, index: u32) -> Result<(), Error> {
 +        self.conn.change_property32(
 +            x11rb::protocol::xproto::PropMode::REPLACE,
 +            self.root,
 +            self.net_current_desktop,
 +            AtomEnum::CARDINAL,
 +            &[index],
 +        )?;
 +        Ok(())
 +    }
++
 +    /// Set _NET_DESKTOP_NAMES on root window.
 +    pub fn set_desktop_names(&self, names: &[String]) -> Result<(), Error> {
 +        // Names are null-terminated UTF8 strings concatenated together
 +        let mut data: Vec<u8> = Vec::new();
 +        for name in names {
 +            data.extend_from_slice(name.as_bytes());
 +            data.push(0);
 +        }
 +        self.conn.change_property8(
 +            x11rb::protocol::xproto::PropMode::REPLACE,
 +            self.root,
 +            self.net_desktop_names,
 +            self.utf8_string,
 +            &data,
 +        )?;
 +        Ok(())
 +    }
++
 +    /// Set _NET_ACTIVE_WINDOW on root window.
 +    pub fn set_active_window(&self, window: Option<Window>) -> Result<(), Error> {
 +        let win = window.unwrap_or(0);
 +        self.conn.change_property32(
 +            x11rb::protocol::xproto::PropMode::REPLACE,
 +            self.root,
 +            self.net_active_window,
 +            AtomEnum::WINDOW,
 +            &[win],
 +        )?;
 +        Ok(())
 +    }
++
 +    /// Set _NET_WM_DESKTOP on a window.
 +    pub fn set_window_desktop(&self, window: Window, desktop: u32) -> Result<(), Error> {
 +        self.conn.change_property32(
 +            x11rb::protocol::xproto::PropMode::REPLACE,
 +            window,
 +            self.net_wm_desktop,
 +            AtomEnum::CARDINAL,
 +            &[desktop],
 +        )?;
 +        Ok(())
 +    }
+ }
  impl std::ops::Deref for Connection {

gar/src/x11/events.rsmodified

+             }
+         }
 +        // Grab Alt+Button1/Button3 on root for floating window move/resize
 +        self.conn.grab_mod_buttons()?;
++
          self.conn.flush()?;
          tracing::info!("{} keybinds registered", state.keybinds.len());
          Ok(())
+     }
 +    /// Set up EWMH workspace hints for status bar integration.
 +    pub fn setup_ewmh_hints(&self) -> Result<()> {
 +        // Advertise supported EWMH atoms
 +        self.conn.set_ewmh_supported()?;
++
 +        // Set number of desktops
 +        let num_desktops = self.workspaces.len() as u32;
 +        self.conn.set_number_of_desktops(num_desktops)?;
++
 +        // Set desktop names
 +        let names: Vec<String> = self.workspaces.iter().map(|ws| ws.name.clone()).collect();
 +        self.conn.set_desktop_names(&names)?;
++
 +        // Set current desktop
 +        self.conn.set_current_desktop(self.focused_workspace as u32)?;
++
 +        // Set active window (none at startup)
 +        self.conn.set_active_window(None)?;
++
 +        self.conn.flush()?;
 +        tracing::info!("EWMH workspace hints initialized: {} desktops", num_desktops);
 +        Ok(())
 +    }
++
 +    /// Adopt any existing windows that were already mapped before we started.
 +    pub fn adopt_existing_windows(&mut self) -> Result<()> {
 +        use x11rb::protocol::xproto::MapState;
++
 +        // Query children of root window
 +        let reply = self.conn.conn.query_tree(self.conn.root)?.reply()?;
 +        let mut adopted = 0;
++
 +        for &window in &reply.children {
 +            // Get window attributes to check if it's mapped and not override-redirect
 +            let attrs = match self.conn.conn.get_window_attributes(window)?.reply() {
 +                Ok(a) => a,
 +                Err(_) => continue, // Window may have been destroyed
 +            };
++
 +            // Skip override-redirect windows (menus, tooltips, etc.)
 +            if attrs.override_redirect {
 +                continue;
 +            }
++
 +            // Only adopt currently mapped windows
 +            if attrs.map_state != MapState::VIEWABLE {
 +                continue;
 +            }
++
 +            // Skip if we already manage this window
 +            if self.windows.contains_key(&window) {
 +                continue;
 +            }
++
 +            // Subscribe to events on the window
 +            self.conn.select_input(
 +                window,
 +                EventMask::ENTER_WINDOW
 +                    | EventMask::FOCUS_CHANGE
 +                    | EventMask::PROPERTY_CHANGE
 +                    | EventMask::STRUCTURE_NOTIFY,
 +            )?;
++
 +            // Grab button for click-to-focus
 +            self.conn.grab_button(window)?;
++
 +            // Check window rules and EWMH hints
 +            let rule_actions = self.check_rules(window);
 +            let should_float = rule_actions.floating.unwrap_or_else(|| self.conn.should_float(window));
++
 +            // Manage the window
 +            if should_float {
 +                self.manage_window_floating(window);
 +            } else {
 +                self.manage_window(window);
 +            }
 +            adopted += 1;
 +        }
++
 +        if adopted > 0 {
 +            self.apply_layout()?;
 +            // Focus the first window
 +            if let Some(window) = self.focused_window {
 +                self.set_focus(window)?;
 +                self.conn.ungrab_button(window)?;
 +            }
 +            tracing::info!("Adopted {} existing windows", adopted);
 +        }
++
 +        Ok(())
 +    }
++
      pub fn handle_event(&mut self, event: Event) -> Result<()> {
          match event {
              Event::MapRequest(e) => self.handle_map_request(e)?,
          // Grab button for click-to-focus
          self.conn.grab_button(window)?;
 -        // Manage the window
 -        self.manage_window(window);
 +        // Check window rules first
 +        let rule_actions = self.check_rules(window);
++
 +        // Determine target workspace (rule or current)
 +        let target_workspace = rule_actions.workspace.unwrap_or(self.focused_workspace + 1);
 +        let target_idx = target_workspace.saturating_sub(1).min(self.workspaces.len() - 1);
 -        // Map the window
 -        self.conn.map_window(window)?;
 +        // Determine if window should float (rule > ICCCM/EWMH hints)
 +        let should_float = rule_actions.floating.unwrap_or_else(|| self.conn.should_float(window));
++
 +        // Manage window on target workspace
 +        if target_idx != self.focused_workspace {
 +            // Window goes to a different workspace
 +            if should_float {
 +                self.manage_window_floating_on_workspace(window, target_idx);
 +            } else {
 +                self.manage_window_on_workspace(window, target_idx);
 +            }
 +            // Don't map - it's on another workspace
 +        } else {
 +            // Window goes to current workspace
 +            if should_float {
 +                self.manage_window_floating(window);
 +            } else {
 +                self.manage_window(window);
 +            }
 +            // Map the window
 +            self.conn.map_window(window)?;
 +        }
          // Apply layout to all windows
          self.apply_layout()?;
 -        // Focus the new window
 -        self.set_focus(window)?;
 +        // Focus the new window (only if on current workspace)
 +        if target_idx == self.focused_workspace {
 +            self.set_focus(window)?;
 +        }
          Ok(())
+     }
      fn handle_button_press(&mut self, event: ButtonPressEvent) -> Result<()> {
          let window = event.event;
 -        tracing::debug!("ButtonPress on window {}, button {}", window, event.detail);
 +        let child = event.child;
 +        tracing::debug!("ButtonPress on window {}, child {}, button {}", window, child, event.detail);
          // Check for mod+click on floating windows (move/resize)
          let has_mod = event.state.contains(x11rb::protocol::xproto::KeyButMask::MOD1);
 -        if has_mod && self.is_floating(window) {
 -            let geometry = self.get_floating_geometry(window);
 +        // For Alt+click from root grab, use child window (the window under cursor)
 +        let target = if window == self.conn.root && child != 0 {
 +            child
 +        } else {
 +            window
 +        };
++
 +        if has_mod && self.is_floating(target) {
 +            let geometry = self.get_floating_geometry(target);
              if event.detail == 1 {
                  // Mod+Button1 = Move
 -                tracing::debug!("Starting move for floating window {}", window);
 +                tracing::debug!("Starting move for floating window {}", target);
                  self.drag_state = Some(DragState::Move {
 -                    window,
 +                    window: target,
                      start_x: event.root_x,
                      start_y: event.root_y,
                      start_geometry: geometry,
                  });
                  // Grab pointer for motion events
 -                self.conn.grab_pointer(window)?;
 +                self.conn.grab_pointer(target)?;
                  return Ok(());
              } else if event.detail == 3 {
                  // Mod+Button3 = Resize
                  let edge = determine_resize_edge(&geometry, event.root_x, event.root_y);
 -                tracing::debug!("Starting resize for floating window {}, edge {:?}", window, edge);
 +                tracing::debug!("Starting resize for floating window {}, edge {:?}", target, edge);
                  self.drag_state = Some(DragState::Resize {
 -                    window,
 +                    window: target,
                      start_x: event.root_x,
                      start_y: event.root_y,
                      start_geometry: geometry,
                      edge,
                  });
 -                self.conn.grab_pointer(window)?;
 +                self.conn.grab_pointer(target)?;
                  return Ok(());
+             }
+         }
                      self.toggle_floating(window)?;
+                 }
+             }
 +            Action::CycleFloating => {
 +                self.cycle_floating()?;
 +            }
              Action::LuaCallback(index) => {
                  if let Err(e) = self.lua_config.execute_callback(index) {
                      tracing::error!("Lua callback error: {}", e);
      fn close_window(&mut self, window: u32) -> Result<()> {
          tracing::info!("Closing window {}", window);
 -        // TODO: Send WM_DELETE_WINDOW if supported (ICCCM)
 -        // For now, just kill the client
 -        self.conn.conn.kill_client(window)?;
 -        self.conn.sync()?;
 +        // Try graceful ICCCM close first
 +        if self.conn.supports_delete_window(window) {
 +            tracing::debug!("Window {} supports WM_DELETE_WINDOW, sending graceful close", window);
 +            self.conn.send_delete_window(window)?;
 +        } else {
 +            tracing::debug!("Window {} doesn't support WM_DELETE_WINDOW, using kill_client", window);
 +            self.conn.conn.kill_client(window)?;
 +        }
 +        self.conn.flush()?;
          Ok(())
+     }
          tracing::info!("Switching to workspace {}", idx + 1);
 -        // Hide windows on current workspace
 -        for window in self.current_workspace().tree.windows() {
 +        // Hide all windows on current workspace (tiled + floating)
 +        for window in self.current_workspace().all_windows() {
              self.conn.unmap_window(window)?;
+         }
          // Switch workspace
          self.focused_workspace = idx;
 -        // Show windows on new workspace
 -        for window in self.current_workspace().tree.windows() {
 +        // Update EWMH _NET_CURRENT_DESKTOP
 +        self.conn.set_current_desktop(idx as u32)?;
++
 +        // Show all windows on new workspace (tiled + floating)
 +        for window in self.current_workspace().all_windows() {
              self.conn.map_window(window)?;
+         }
          // Apply layout and update focus
          self.apply_layout()?;
 -        // Focus the workspace's focused window or first window
 +        // Focus the workspace's focused window, preferring floating on top
          if let Some(window) = self
              .current_workspace()
              .focused
 +            .or_else(|| self.current_workspace().floating.last().copied())
              .or_else(|| self.current_workspace().tree.first_window())
+         {
              self.set_focus(window)?;
              return Ok(());
          };
 -        tracing::info!("Moving window {} to workspace {}", window, idx + 1);
 +        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);
 -        // Remove from current workspace tree
 -        self.current_workspace_mut().tree.remove(window);
 +        // Remove from current workspace (tree or floating list)
 +        if is_floating {
 +            self.current_workspace_mut().remove_floating(window);
 +        } else {
 +            self.current_workspace_mut().tree.remove(window);
 +        }
          // Update focus on current workspace
 -        self.focused_window = self.current_workspace().tree.first_window();
 +        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;
          // Update window's workspace tracking
              win.workspace = idx;
+         }
 +        // 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)?;
          // Insert into target workspace
 -        let target_focused = self.workspaces[idx].focused;
 -        let screen = self.screen_rect();
 -        self.workspaces[idx]
 -            .tree
 -            .insert_with_rect(window, target_focused, screen);
 +        if is_floating {
 +            self.workspaces[idx].add_floating(window);
 +        } else {
 +            let target_focused = self.workspaces[idx].focused;
 +            let screen = self.screen_rect();
 +            self.workspaces[idx]
 +                .tree
 +                .insert_with_rect(window, target_focused, screen);
 +        }
          // Re-apply layout on current workspace
          self.apply_layout()?;
          // Set up keybinds
          self.setup_grabs()?;
 +        // Set up EWMH workspace hints
 +        self.setup_ewmh_hints()?;
++
 +        // Adopt any existing windows
 +        self.adopt_existing_windows()?;
++
          while self.running {
              let event = self.conn.conn.wait_for_event()?;
              self.handle_event(event)?;
      fn get_floating_geometry(&self, window: u32) -> Rect {
          self.windows
              .get(&window)
 -            .map(|w| w.geometry)
 +            .map(|w| w.floating_geometry)
              .unwrap_or_default()
+     }
      fn set_floating_position(&mut self, window: u32, x: i16, y: i16) -> Result<()> {
          if let Some(win) = self.windows.get_mut(&window) {
 -            win.geometry.x = x;
 -            win.geometry.y = y;
 +            win.floating_geometry.x = x;
 +            win.floating_geometry.y = y;
              self.conn.configure_window(
                  window,
                  x,
                  y,
 -                win.geometry.width,
 -                win.geometry.height,
 +                win.floating_geometry.width,
 +                win.floating_geometry.height,
                  self.config.border_width,
              )?;
              self.conn.flush()?;
      fn set_floating_geometry(&mut self, window: u32, x: i16, y: i16, w: u16, h: u16) -> Result<()> {
          if let Some(win) = self.windows.get_mut(&window) {
 -            win.geometry = Rect::new(x, y, w, h);
 +            win.floating_geometry = Rect::new(x, y, w, h);
              self.conn.configure_window(
                  window,
                  x,
+     }
      fn raise_window(&mut self, window: u32) -> Result<()> {
 +        // Update stacking order in workspace's floating list
 +        self.current_workspace_mut().raise_floating(window);
++
 +        // Raise in X11
          let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
          self.conn.conn.configure_window(window, &aux)?;
          self.conn.flush()?;
          Ok(())
+     }
 +    /// Cycle through floating windows on the current workspace.
 +    fn cycle_floating(&mut self) -> Result<()> {
 +        let floating = &self.current_workspace().floating;
 +        if floating.is_empty() {
 +            tracing::debug!("No floating windows to cycle");
 +            return Ok(());
 +        }
++
 +        // Find current position in floating list
 +        let current_idx = self.focused_window
 +            .and_then(|w| floating.iter().position(|&fw| fw == w));
++
 +        // Get next floating window (wrap around)
 +        let next_idx = match current_idx {
 +            Some(idx) => (idx + 1) % floating.len(),
 +            None => 0, // Not focused on a floating window, focus the first one
 +        };
++
 +        let next_window = floating[next_idx];
++
 +        // Regrab button on old focused window
 +        if let Some(old) = self.focused_window {
 +            self.conn.grab_button(old)?;
 +        }
++
 +        // Focus and raise the next floating window
 +        self.set_focus(next_window)?;
 +        self.conn.ungrab_button(next_window)?;
 +        self.raise_window(next_window)?;
++
 +        tracing::debug!("Cycled to floating window {} (idx {})", next_window, next_idx);
 +        Ok(())
 +    }
++
      fn toggle_floating(&mut self, window: u32) -> Result<()> {
 -        let Some(win) = self.windows.get_mut(&window) else {
 +        // Check if window is managed
 +        let Some(win_state) = self.windows.get(&window) else {
 +            tracing::warn!("toggle_floating: window {} not managed", window);
              return Ok(());
          };
 +        let is_floating = win_state.floating;
 -        if win.floating {
 +        tracing::debug!(
 +            "toggle_floating: window={}, is_floating={}, in_tree={}, in_floating_list={}",
 +            window,
 +            is_floating,
 +            self.current_workspace().tree.contains(window),
 +            self.current_workspace().floating.contains(&window)
 +        );
++
 +        if is_floating {
              // Return to tiled
              tracing::info!("Returning window {} to tiled", window);
 -            win.floating = false;
++
 +            // Update window state
 +            if let Some(win) = self.windows.get_mut(&window) {
 +                win.floating = false;
 +            }
              // Remove from floating list
 -            self.current_workspace_mut()
 -                .floating
 -                .retain(|w| w.id != window);
 +            self.current_workspace_mut().remove_floating(window);
 -            // Insert back into BSP tree
 -            let focused = self.current_workspace().focused;
 +            // Find a target window to insert next to (not ourselves)
 +            let target = self.current_workspace().tree.first_window();
              let screen = self.screen_rect();
              self.current_workspace_mut()
                  .tree
 -                .insert_with_rect(window, focused, screen);
 +                .insert_with_rect(window, target, screen);
              // Re-apply layout
              self.apply_layout()?;
              // Make floating
              tracing::info!("Floating window {}", window);
 -            // Get current geometry before removing from tree
 +            // Check if window is actually in the tree
 +            if !self.current_workspace().tree.contains(window) {
 +                tracing::warn!("toggle_floating: window {} not in tree, cannot float", window);
 +                return Ok(());
 +            }
++
 +            // Use a centered floating geometry (80% of screen size, centered)
              let screen = self.screen_rect();
 -            let geometries = self.current_workspace().tree.calculate_geometries(screen);
 -            let geometry = geometries
 -                .iter()
 -                .find(|(w, _)| *w == window)
 -                .map(|(_, r)| *r)
 -                .unwrap_or_else(|| Rect::new(100, 100, 640, 480));
 +            let float_w = (screen.width * 4 / 5).max(400);
 +            let float_h = (screen.height * 4 / 5).max(300);
 +            let float_x = screen.x + (screen.width as i16 - float_w as i16) / 2;
 +            let float_y = screen.y + (screen.height as i16 - float_h as i16) / 2;
 +            let geometry = Rect::new(float_x, float_y, float_w, float_h);
++
 +            tracing::debug!("Floating geometry: {:?}", geometry);
              // Remove from BSP tree
 -            self.current_workspace_mut().tree.remove(window);
 +            let removed = self.current_workspace_mut().tree.remove(window);
 +            tracing::debug!("Removed from tree: {}", removed);
 -            // Mark as floating and store geometry
 -            let win = self.windows.get_mut(&window).unwrap();
 -            win.floating = true;
 -            win.geometry = geometry;
 +            // Update window state with floating geometry
 +            if let Some(win) = self.windows.get_mut(&window) {
 +                win.floating = true;
 +                win.floating_geometry = geometry;
 +            }
 -            // Add to floating list
 -            let workspace_idx = self.focused_workspace;
 -            self.current_workspace_mut()
 -                .floating
 -                .push(crate::core::Window::new(window, workspace_idx));
 +            // Add to floating list (on top)
 +            self.current_workspace_mut().add_floating(window);
 -            // Re-apply layout for tiled windows
 +            // Re-apply layout (this will configure the floating window and stack it)
              self.apply_layout()?;
+-
 -            // Configure floating window to its geometry
 -            self.conn.configure_window(
 -                window,
 -                geometry.x,
 -                geometry.y,
 -                geometry.width,
 -                geometry.height,
 -                self.config.border_width,
 -            )?;
+-
 -            // Raise floating window above tiled
 -            self.raise_window(window)?;
+         }
          Ok(())