Hide focus ring for unfocused layout and under interactive move

niri-visual-tests/src/cases/layout.rs

@@ -262,7 +262,7 @@ impl TestCase for Layout {
         self.layout
             .monitor_for_output(&self.output)
             .unwrap()
-            .render_elements(renderer, RenderTarget::Output)
+            .render_elements(renderer, RenderTarget::Output, true)
             .map(|elem| Box::new(elem) as _)
             .collect()
     }

src/layout/floating.rs

@@ -962,6 +962,7 @@ impl<W: LayoutElement> FloatingSpace<W> {
         view_rect: Rectangle<f64, Logical>,
         scale: Scale<f64>,
         target: RenderTarget,
+        focus_ring: bool,
     ) -> Vec<FloatingSpaceRenderElement<R>> {
         let mut rv = Vec::new();
 
@@ -976,7 +977,7 @@ impl<W: LayoutElement> FloatingSpace<W> {
         let active = self.active_window_id.clone();
         for (tile, tile_pos) in self.tiles_with_render_positions() {
             // For the active tile, draw the focus ring.
-            let focus_ring = Some(tile.window().id()) == active.as_ref();
+            let focus_ring = focus_ring && Some(tile.window().id()) == active.as_ref();
 
             rv.extend(
                 tile.render(renderer, tile_pos, scale, focus_ring, target)

src/layout/mod.rs

@@ -3565,6 +3565,14 @@ impl<W: LayoutElement> Layout<W> {
         }
     }
 
+    pub fn interactive_move_is_moving_above_output(&self, output: &Output) -> bool {
+        let Some(InteractiveMoveState::Moving(move_)) = &self.interactive_move else {
+            return false;
+        };
+
+        move_.output == *output
+    }
+
     pub fn interactive_resize_begin(&mut self, window: W::Id, edges: ResizeEdge) -> bool {
         match &mut self.monitor_set {
             MonitorSet::Normal { monitors, .. } => {

src/layout/monitor.rs

@@ -963,6 +963,7 @@ impl<W: LayoutElement> Monitor<W> {
         &'a self,
         renderer: &'a mut R,
         target: RenderTarget,
+        focus_ring: bool,
     ) -> impl Iterator<Item = MonitorRenderElement<R>> + 'a {
         let _span = tracy_client::span!("Monitor::render_elements");
 
@@ -989,7 +990,7 @@ impl<W: LayoutElement> Monitor<W> {
 
         self.workspaces_with_render_positions()
             .flat_map(move |(ws, offset)| {
-                ws.render_elements(renderer, target)
+                ws.render_elements(renderer, target, focus_ring)
                     .filter_map(move |elem| {
                         CropRenderElement::from_element(elem, scale, crop_bounds)
                     })

src/layout/scrolling.rs

@@ -2180,6 +2180,7 @@ impl<W: LayoutElement> ScrollingSpace<W> {
         renderer: &mut R,
         scale: Scale<f64>,
         target: RenderTarget,
+        focus_ring: bool,
     ) -> Vec<ScrollingSpaceRenderElement<R>> {
         let mut rv = vec![];
 
@@ -2208,7 +2209,7 @@ impl<W: LayoutElement> ScrollingSpace<W> {
         let mut first = true;
         for (tile, tile_pos) in self.tiles_with_render_positions() {
             // For the active tile (which comes first), draw the focus ring.
-            let focus_ring = first;
+            let focus_ring = focus_ring && first;
             first = false;
 
             rv.extend(

src/layout/workspace.rs

@@ -1308,16 +1308,25 @@ impl<W: LayoutElement> Workspace<W> {
         &self,
         renderer: &mut R,
         target: RenderTarget,
+        focus_ring: bool,
     ) -> impl Iterator<Item = WorkspaceRenderElement<R>> {
         let scale = Scale::from(self.scale.fractional_scale());
-        let scrolling = self.scrolling.render_elements(renderer, scale, target);
+        let scrolling_focus_ring = focus_ring && !self.floating_is_active();
+        let scrolling =
+            self.scrolling
+                .render_elements(renderer, scale, target, scrolling_focus_ring);
         let scrolling = scrolling.into_iter().map(WorkspaceRenderElement::from);
 
+        let floating_focus_ring = focus_ring && self.floating_is_active();
         let floating = self.is_floating_visible().then(|| {
             let view_rect = Rectangle::from_loc_and_size((0., 0.), self.view_size);
-            let floating = self
+            let floating = self.floating.render_elements(
-                .floating
+                renderer,
-                .render_elements(renderer, view_rect, scale, target);
+                view_rect,
+                scale,
+                target,
+                floating_focus_ring,
+            );
             floating.into_iter().map(WorkspaceRenderElement::from)
         });
 

src/niri.rs

@@ -3246,9 +3246,13 @@ impl Niri {
             elements.push(element.into());
         }
 
+        // Don't draw the focus ring on the workspaces while interactively moving above those
+        // workspaces, since the interactively-moved window already has a focus ring.
+        let focus_ring = !self.layout.interactive_move_is_moving_above_output(output);
+
         // Get monitor elements.
         let mon = self.layout.monitor_for_output(output).unwrap();
-        let monitor_elements: Vec<_> = mon.render_elements(renderer, target).collect();
+        let monitor_elements: Vec<_> = mon.render_elements(renderer, target, focus_ring).collect();
         let float_elements: Vec<_> = self
             .layout
             .render_floating_for_output(renderer, output, target)