Merge pull request #116 from pragmatrix/keyboard-and-hover-rect

pragmatrix · web-flow · commit 45a01f5487d9 · 2026-04-15T09:30:09.000+02:00
Improve the hover rect
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
@@ -38,6 +38,8 @@ Update it whenever you learn something new about the project's patterns, convent
 - When code guarantees an invariant, avoid defensive fallback branches for that path; keep the direct path and fail explicitly if the invariant is violated.
 - For purely defensive invariant checks on hot paths, prefer debug-only assertions to avoid unnecessary release-build work.
 - For platform-specific window commands, detect shortcuts where aggregated input state is available and keep the actual window mutation in the shell/window abstraction.
+- When multiple transient affordances represent the same interaction mode, keep them behind one shared state instead of parallel flags.
+- Cache repeated window state requests at the caller when the underlying platform mutation may hop to the main thread or otherwise be non-trivial.
 - On macOS, prefer native menu selector wiring for commands that users can remap in App Shortcuts, instead of hardcoded key-chord matching.
 
 ## Testing
diff --git a/desktop/src/desktop.rs b/desktop/src/desktop.rs
@@ -28,6 +28,7 @@ pub struct Desktop {
     scene: Scene,
     renderer: AsyncWindowRenderer,
     window: ShellWindow,
+    cursor_visible: bool,
     system: DesktopSystem,
 
     event_manager: EventManager<ViewEvent>,
@@ -132,6 +133,7 @@ impl Desktop {
             scene,
             renderer,
             window,
+            cursor_visible: true,
             system,
             event_manager,
             instance_manager,
@@ -153,13 +155,21 @@ impl Desktop {
                     match event {
                         ShellEvent::WindowEvent(_window_id, window_event) => {
                             if let Some(view_event) = ViewEvent::from_window_event(&window_event)
-                                && let Some(input_event) = self.event_manager.add_event(view_event, Instant::now()) {
-                               let cmd = self.system.process_input_event(
+                                && let Some(input_event) =
+                                    self.event_manager.add_event(view_event, Instant::now())
+                            {
+                                let cmd = self.system.process_input_event(
                                     &input_event,
                                     &self.instance_manager,
                                     self.renderer.geometry(),
                                 )?;
-                                self.system.transact(cmd, &self.scene, &mut self.instance_manager)?;
+                                let cursor_visible = self.system.cursor_visible();
+                                if self.cursor_visible != cursor_visible {
+                                    self.window.set_cursor_visible(cursor_visible);
+                                    self.cursor_visible = cursor_visible;
+                                }
+                                self.system
+                                    .transact(cmd, &self.scene, &mut self.instance_manager)?;
 
                                 let allow_camera_movements = !input_event.any_buttons_pressed();
                                 self.system.update_effects(true, allow_camera_movements)?;
diff --git a/desktop/src/desktop_system.rs b/desktop/src/desktop_system.rs
@@ -8,12 +8,12 @@
 //! The goal here is to remove as much as possible from the specific instances into separate systems
 //! and aggregates that are event driven.
 
-use std::cmp::max;
-use std::collections::HashSet;
-
 use anyhow::{Result, anyhow, bail};
 use derive_more::{Debug, From};
 use log::warn;
+use std::cmp::max;
+use std::collections::HashSet;
+use std::time::Duration;
 use winit::event::ElementState;
 use winit::keyboard::{Key, NamedKey};
 
@@ -49,7 +49,8 @@ use crate::send_transition::{SendTransition, convert_to_send_transitions};
 use crate::{DesktopEnvironment, DirectionBias, EventRouter, Map, OrderedHierarchy, navigation};
 
 const SECTION_SPACING: u32 = 20;
-
+const POINTER_FEEDBACK_REENABLE_MIN_DISTANCE_PX: f64 = 24.0;
+const POINTER_FEEDBACK_REENABLE_MAX_DURATION: Duration = Duration::from_millis(200);
 /// This enum specifies a unique target inside the navigation and layout history.
 #[derive(Debug, Clone, PartialEq, Eq, Hash, From)]
 pub enum DesktopTarget {
@@ -114,6 +115,7 @@ pub struct DesktopSystem {
 
     event_router: EventRouter<DesktopTarget>,
     camera: Animated<PixelCamera>,
+    pointer_feedback_enabled: bool,
 
     #[debug(skip)]
     layouter: IncrementalLayouter<DesktopTarget, 2>,
@@ -178,6 +180,7 @@ impl DesktopSystem {
 
             event_router,
             camera: scene.animated(PixelCamera::default()),
+            pointer_feedback_enabled: true,
             layouter,
 
             aggregates: Aggregates::new(OrderedHierarchy::default(), project_presenter),
@@ -452,41 +455,78 @@ impl DesktopSystem {
         self.camera.value()
     }
 
+    pub fn cursor_visible(&self) -> bool {
+        self.pointer_feedback_enabled
+    }
+
     pub fn process_input_event(
         &mut self,
         event: &Event<ViewEvent>,
         instance_manager: &InstanceManager,
         render_geometry: &RenderGeometry,
     ) -> Result<Cmd> {
         let keyboard_cmd = self.preprocess_keyboard_input(event)?;
-        if !keyboard_cmd.is_none() {
-            return Ok(keyboard_cmd);
-        }
 
-        let hit_tester = AggregateHitTester::new(
-            &self.aggregates.hierarchy,
-            &self.layouter,
-            &self.aggregates.launchers,
-            &self.aggregates.instances,
-            render_geometry,
-        );
+        let cmd = if !keyboard_cmd.is_none() {
+            keyboard_cmd
+        } else {
+            let hit_tester = AggregateHitTester::new(
+                &self.aggregates.hierarchy,
+                &self.layouter,
+                &self.aggregates.launchers,
+                &self.aggregates.instances,
+                render_geometry,
+            );
 
-        // Capture focus before routing the event so we can detect focus transitions afterwards.
-        let focused_before = self.event_router.focused().cloned();
-        let transitions = self.event_router.process(event, &hit_tester)?;
-        // Read focus after routing and immediately recompute launcher layouts when it changed.
-        let focused_after = self.event_router.focused().cloned();
-        self.apply_launcher_layout_for_focus_change(focused_before, focused_after, true);
+            let transitions = self.event_router.process(event, &hit_tester)?;
+            if let Some((from, to)) = transitions.keyboard_focus_change() {
+                self.apply_launcher_layout_for_focus_change(from.cloned(), to.cloned(), true);
+            }
 
-        self.forward_event_transitions(transitions, instance_manager)
+            self.forward_event_transitions(transitions, instance_manager)?
+        };
+
+        self.update_pointer_feedback(event);
+
+        Ok(cmd)
+    }
+
+    fn update_pointer_feedback(&mut self, event: &Event<ViewEvent>) {
+        match (self.pointer_feedback_enabled, event.event()) {
+            (
+                true,
+                ViewEvent::KeyboardInput {
+                    event: key_event, ..
+                },
+            ) if key_event.state == ElementState::Pressed && !key_event.repeat => {
+                self.pointer_feedback_enabled = false;
+                self.aggregates.project_presenter.set_hover_rect(None);
+            }
+            (false, ViewEvent::MouseInput { .. } | ViewEvent::MouseWheel { .. }) => {
+                self.pointer_feedback_enabled = true;
+                let pointer_focus = self.event_router.pointer_focus().cloned();
+                self.sync_hover_rect_to_pointer_path(pointer_focus.as_ref());
+            }
+            (false, ViewEvent::CursorMoved { .. })
+                if event.cursor_has_velocity(
+                    POINTER_FEEDBACK_REENABLE_MIN_DISTANCE_PX,
+                    POINTER_FEEDBACK_REENABLE_MAX_DURATION,
+                ) =>
+            {
+                self.pointer_feedback_enabled = true;
+                let pointer_focus = self.event_router.pointer_focus().cloned();
+                self.sync_hover_rect_to_pointer_path(pointer_focus.as_ref());
+            }
+            _ => {}
+        }
     }
 
     fn focus(&mut self, target: &DesktopTarget, instance_manager: &InstanceManager) -> Result<Cmd> {
         // Focus changes can alter launcher layout targets.
-        let focused_before = self.event_router.focused().cloned();
         let transitions = self.event_router.focus(target);
-        let focused_after = self.event_router.focused().cloned();
-        self.apply_launcher_layout_for_focus_change(focused_before, focused_after, true);
+        if let Some((from, to)) = transitions.keyboard_focus_change() {
+            self.apply_launcher_layout_for_focus_change(from.cloned(), to.cloned(), true);
+        }
         self.forward_event_transitions(transitions, instance_manager)
     }
 
@@ -923,7 +963,9 @@ impl DesktopSystem {
         transitions: EventTransitions<DesktopTarget>,
         instance_manager: &InstanceManager,
     ) -> Result<Cmd> {
-        if let Some(pointer_focus) = transitions.pointer_focus_target() {
+        if self.pointer_feedback_enabled
+            && let Some(pointer_focus) = transitions.pointer_focus_target()
+        {
             self.sync_hover_rect_to_pointer_path(pointer_focus);
         }
 
diff --git a/desktop/src/event_router.rs b/desktop/src/event_router.rs
@@ -370,6 +370,13 @@ impl<T> Default for EventTransitions<T> {
 }
 
 impl<T> EventTransitions<T> {
+    pub fn keyboard_focus_change(&self) -> Option<(Option<&T>, Option<&T>)> {
+        self.0.iter().find_map(|transition| match transition {
+            EventTransition::ChangeKeyboardFocus { from, to } => Some((from.as_ref(), to.as_ref())),
+            _ => None,
+        })
+    }
+
     pub fn pointer_focus_target(&self) -> Option<Option<&T>> {
         self.0.iter().find_map(|transition| match transition {
             EventTransition::ChangePointerFocus { to, .. } => Some(to.as_ref()),
diff --git a/desktop/src/projects/project_presenter.rs b/desktop/src/projects/project_presenter.rs
@@ -21,19 +21,20 @@ pub struct ProjectPresenter {
     // Idea: Use a type that combines Alpha with another Interpolatable type.
     // Robustness: Alpha should be a type.
     hover_alpha: Animated<f32>,
-    hover_rect: Animated<Rect>,
+    hover_rect: Rect,
     // Idea: can't we just animate a visual / Handle<Visual>?
     // Performance: This is a visual that _always_ lives inside the renderer, even though it does not contain a single shape when alpha = 0.0
     hover_visual: Handle<Visual>,
 }
 
 impl ProjectPresenter {
     const HOVER_STROKE: (f64, f64) = (10.0, 10.0);
+
     pub fn new(location: Handle<Location>, scene: &Scene) -> Self {
         Self {
             location: location.clone(),
             hover_alpha: scene.animated(0.0),
-            hover_rect: scene.animated(Rect::ZERO),
+            hover_rect: Rect::ZERO,
             hover_visual: create_hover_shapes(None)
                 .into_visual()
                 .at(location)
@@ -46,23 +47,13 @@ impl ProjectPresenter {
     pub fn set_hover_rect(&mut self, rect: Option<Rect>) {
         match rect {
             Some(rect) => {
-                let was_visible = self.hover_alpha.final_value() == 1.0;
-
                 self.hover_alpha.animate_if_changed(
                     1.0,
                     Self::HOVER_ANIMATION_DURATION,
                     Interpolation::CubicOut,
                 );
 
-                if was_visible {
-                    self.hover_rect.animate_if_changed(
-                        rect,
-                        Self::HOVER_ANIMATION_DURATION,
-                        Interpolation::CubicOut,
-                    );
-                } else {
-                    self.hover_rect.set_immediately(rect);
-                }
+                self.hover_rect = rect;
             }
             None => {
                 self.hover_alpha.animate_if_changed(
@@ -76,7 +67,7 @@ impl ProjectPresenter {
 
     pub fn apply_animations(&mut self) {
         let alpha = self.hover_alpha.value();
-        let rect_alpha = (alpha != 0.0).then(|| (self.hover_rect.value(), alpha));
+        let rect_alpha = (alpha != 0.0).then_some((self.hover_rect, alpha));
 
         // Ergonomics: What something like apply_to_if_changed(&mut self.hover_visual) or so?
         //
diff --git a/input/src/event.rs b/input/src/event.rs
@@ -7,7 +7,7 @@ use massive_geometry::{Point, Vector};
 use winit::keyboard::ModifiersState;
 
 use crate::event_aggregator::DeviceStates;
-use crate::event_history::{EventHistory, EventRecord};
+use crate::event_history::{EventHistory, EventRecord, HistoryIterator};
 use crate::tracker::Movement;
 use crate::{AggregationEvent, ButtonSensor, InputEvent, MouseGesture, PointingDeviceState};
 
@@ -98,6 +98,23 @@ impl<'history, E: InputEvent> Event<'history, E> {
         }
     }
 
+    /// Returns `true` when the current cursor move covers at least `min_distance` within
+    /// `max_duration`.
+    pub fn cursor_has_velocity(&self, min_distance: f64, max_duration: Duration) -> bool {
+        let Some(device) = self.cursor_moved() else {
+            return false;
+        };
+        let Some(pos) = self.device_pos(device) else {
+            return false;
+        };
+
+        self.history
+            .iter()
+            .until(self.time() - max_duration)
+            .max_distance_moved(device, pos)
+            >= min_distance
+    }
+
     pub fn detect_click(&self, mouse_button: MouseButton) -> Option<Point> {
         match self.to_aggregation_event()? {
             AggregationEvent::MouseInput { state, button, .. }
diff --git a/shell/src/shell_window.rs b/shell/src/shell_window.rs
@@ -59,6 +59,11 @@ impl ShellWindow {
         self.shared.window().set_cursor(icon);
     }
 
+    // Note: This may schedule work on the main thread, so callers should avoid redundant updates.
+    pub fn set_cursor_visible(&self, visible: bool) {
+        self.shared.window().set_cursor_visible(visible);
+    }
+
     // DI: Use SizeI to represent initial_size.
     pub fn renderer(&self) -> WindowRendererBuilder {
         WindowRendererBuilder::new(self.shared.clone())
