fix floating window stacking and add _NET_WM_STATE_ABOVE support

Status	File	+	-
M	`gar/src/core/mod.rs`	24	10
M	`gar/src/x11/connection.rs`	10	1
M	`gar/src/x11/events.rs`	19	1

gar/src/core/mod.rsmodified

                          border_width as u16,
                      )?;
++                    // Ensure tiled frame is below floating windows by stacking at bottom
++                    if let Some(frame) = self.frames.frame_for_client(*window) {
++                        let aux = ConfigureWindowAux::new().stack_mode(StackMode::BELOW);
++                        self.conn.conn.configure_window(frame, &aux)?;
++                    }
++
                      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
                          final_height.max(1),
                          border_width,
                      )?;
++
++                    // Ensure tiled window is below floating windows
++                    let aux = ConfigureWindowAux::new().stack_mode(StackMode::BELOW);
++                    self.conn.conn.configure_window(*window, &aux)?;
+                 }
                  // Store the actual geometry for pointer warping
                      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::info!(
++                            "apply_layout: FLOATING+FRAME window={} frame={} raised ABOVE (at ({}, {}) size {}x{})",
++                            window_id, frame, geom.x, geom.y, adjusted_width.max(1), adjusted_height.max(1)
++                        );
++                    } else {
++                        tracing::warn!(
++                            "apply_layout: FLOATING window={} has_frame=true but no frame found!",
++                            window_id
++                        );
+                     }
--
--                    tracing::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,
                      // 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)?;
++
++                    tracing::info!(
++                        "apply_layout: FLOATING window={} raised ABOVE (at ({}, {}) size {}x{})",
++                        window_id, geom.x, geom.y, adjusted_width.max(1), adjusted_height.max(1)
++                    );
+                 }
                  // Store the actual geometry for pointer warping

gar/src/x11/connection.rsmodified

      pub net_wm_state: Atom,
      pub net_wm_state_modal: Atom,
      pub net_wm_state_fullscreen: Atom,
++    pub net_wm_state_above: Atom,
      // EWMH atoms for workspaces
      pub net_supported: Atom,
      pub net_supporting_wm_check: Atom,
          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;
++        let net_wm_state_above = conn.intern_atom(false, b"_NET_WM_STATE_ABOVE")?.reply()?.atom;
          // Intern EWMH atoms for workspaces and WM identification
          let net_supported = conn.intern_atom(false, b"_NET_SUPPORTED")?.reply()?.atom;
              net_wm_state,
              net_wm_state_modal,
              net_wm_state_fullscreen,
++            net_wm_state_above,
              net_supported,
              net_supporting_wm_check,
              net_client_list,
              }
          }
--        // 3. Check _NET_WM_STATE for modal windows
++        // 3. Check _NET_WM_STATE for modal or above windows
          if let Ok(cookie) = self.conn.get_property(
              false,
              window,
                              tracing::debug!("Window {} is modal, should float", window);
                              return true;
                          }
++                        if atom == self.net_wm_state_above {
++                            tracing::debug!("Window {} has ABOVE state, should float", window);
++                            return true;
++                        }
                      }
                  }
              }
              self.net_close_window,
              self.net_wm_state,
              self.net_wm_state_fullscreen,
++            self.net_wm_state_modal,
++            self.net_wm_state_above,
              self.net_wm_name,
          ];
          self.conn.change_property32(

gar/src/x11/events.rsmodified

                  self.conn.flush()?;
                  return Ok(());
+             }
--            // Not on edge - if this is a focused floating window, replay the click
++            // Not on edge - if this is a focused floating window, raise it and replay the click
++            // This ensures clicking on a floating window that somehow ended up behind
++            // other windows will bring it to the front
              if self.focused_window == Some(window) {
++                self.raise_window(window)?;
                  self.conn.conn.allow_events(
                      x11rb::protocol::xproto::Allow::REPLAY_POINTER,
                      x11rb::CURRENT_TIME,
                      _ => {}
+                 }
+             }
++            // Handle ABOVE state changes - raise window when requested
++            else if property == self.conn.net_wm_state_above {
++                match action {
++                    1 | 2 => {
++                        // Add or toggle ABOVE - raise the window
++                        tracing::info!("Window {} requesting ABOVE state, raising", window);
++                        if self.windows.contains_key(&window) {
++                            self.raise_window(window)?;
++                        }
++                    }
++                    _ => {}
++                }
++            }
          } else {
              tracing::trace!("Unhandled ClientMessage type: {}", msg_type);
+         }
          // Raise in X11 - if window has a frame, raise the frame instead
          let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
          if let Some(frame) = self.frames.frame_for_client(window) {
++            tracing::info!("raise_window: window={} -> raising frame={}", window, frame);
              self.conn.conn.configure_window(frame, &aux)?;
          } else {
++            tracing::info!("raise_window: window={} (no frame)", window);
              self.conn.conn.configure_window(window, &aux)?;
+         }
          self.conn.flush()?;

gardesk/gar / `6c9c79b`

3 changed files