`1136725`

state: inflate gaps by border_width via effective_gaps

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 1 week ago

SHA: 1136725a0e4599b55fe35c9f4c8c69422768ea50
Parents: 2a31cf7
Tree: bb4cbc2

2 changed files

Status	File	+	-
M	`tarmac/src/core/state.rs`	41	5
M	`tarmac/src/main.rs`	1	1

tarmac/src/core/state.rsmodified

+         }
+     }
 -    fn workspace_render_geometries(&self, ws_idx: usize, rect: Rect) -> Vec<(WindowId, Rect)> {
 +    /// Inflate the user-configured gaps by ers's border width so the
 +    /// configured value is the *visible* empty space between tiles, not
 +    /// the gross window-rect-to-window-rect distance. Ers draws border
 +    /// overlays 4px (or whatever `border_width` is) outside each window's
 +    /// frame; with a raw 8px tile gap, two adjacent windows' 4px borders
 +    /// fill the entire gap and visually touch. Adding 2 * border_width
 +    /// to inner gaps and 1 * border_width to outer gaps reserves space
 +    /// for the borders so the configured gap survives as visible empty
 +    /// space.
 +    pub fn effective_gaps(&self, ws_idx: usize) -> (f64, f64) {
          let (gap_inner, gap_outer) = self.workspace_gaps(ws_idx);
 +        let bw = self.borders.border_width.max(0.0);
 +        (gap_inner + 2.0 * bw, gap_outer + bw)
 +    }
++
 +    fn workspace_render_geometries(&self, ws_idx: usize, rect: Rect) -> Vec<(WindowId, Rect)> {
 +        let (gap_inner, gap_outer) = self.effective_gaps(ws_idx);
          self.workspaces
              .get(ws_idx)
              .tree
+     }
      fn workspace_focus_geometries(&self, ws_idx: usize, rect: Rect) -> Vec<(WindowId, Rect)> {
 -        let (gap_inner, gap_outer) = self.workspace_gaps(ws_idx);
 +        let (gap_inner, gap_outer) = self.effective_gaps(ws_idx);
          self.workspaces
              .get(ws_idx)
              .tree
          let _ = crate::platform::skylight::set_window_group_system_alpha(wid, 1.0);
          let _ = crate::platform::skylight::set_window_group_alpha(wid, 1.0);
 +        if let (Ok((ax, ay)), Ok((aw, ah))) = (ax_get_position(ax_ref), ax_get_size(ax_ref)) {
 +            let dx = (ax - rect.x).abs();
 +            let dy = (ay - rect.y).abs();
 +            let dw = (aw - rect.width).abs();
 +            let dh = (ah - rect.height).abs();
 +            if dx > 1.0 || dy > 1.0 || dw > 1.0 || dh > 1.0 {
 +                tracing::debug!(
 +                    wid,
 +                    req_x = rect.x,
 +                    req_y = rect.y,
 +                    req_w = rect.width,
 +                    req_h = rect.height,
 +                    got_x = ax,
 +                    got_y = ay,
 +                    got_w = aw,
 +                    got_h = ah,
 +                    "show_window mismatch"
 +                );
 +            }
 +        }
++
          // Restore AXEnhancedUserInterface
          if was_eui == Some(true)
              && let Some(app) = &app_ref
          let window_under = if let Some(special_idx) = special_ws_idx {
              let sr = self.monitor_rect(mi);
              let ws = self.workspaces.get(special_idx);
 -            let (gap_inner, gap_outer) = self.workspace_gaps(special_idx);
 +            let (gap_inner, gap_outer) = self.effective_gaps(special_idx);
              // Look up config for this special workspace's overlay rect
              let special_name = match &ws.id {
              let overlay_rect = Rect::new(overlay_x, overlay_y, overlay_w, overlay_h);
              // Compute geometries and collect data before calling self methods
 -            let (gap_inner, gap_outer) = self.workspace_gaps(special_idx);
 +            let (gap_inner, gap_outer) = self.effective_gaps(special_idx);
              let geoms =
                  ws.tree
                      .calculate_geometries_with_gaps(overlay_rect, gap_inner, gap_outer, true);
          // Get target monitor's screen rect for layout
          let target_rect = self.monitor_rect(target_mi);
 -        let (target_gap_inner, target_gap_outer) = self.workspace_gaps(target_ws_idx);
 +        let (target_gap_inner, target_gap_outer) = self.effective_gaps(target_ws_idx);
          // Find which workspace the window is actually on
          let current_idx = match self.workspaces.find_window(focused) {

tarmac/src/main.rsmodified

                      .monitor_showing_workspace(ws_idx)
                      .map(|mi| state.monitor_rect(mi))
                      .unwrap_or_else(|| state.focused_rect());
 -                let (gap_inner, gap_outer) = state.workspace_gaps(ws_idx);
 +                let (gap_inner, gap_outer) = state.effective_gaps(ws_idx);
                  let geoms = ws
                      .tree
                      .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);