Add MRU window navigation actions

The MRU actions `focus-window-mru-previous` and `focus-window-mru-next`
are used to navigate windows in most-recently-used or
least-recently-used order.

Whenever a window is focused, it records a timestamp that be used to
sort windows in MRU order. This timestamp is not updated immediately,
but only after a small delay (lock-in period) to ensure that the
focus wasn't transfered to another window in the meantime. This
strategy avoids upsetting the MRU order with focus events generated by
intermediate windows when moving between two non contiguous windows.

The lock-in delay can be configured using the `focus-lockin-ms`
configuration argument.

Calling either of the `focus-window-mru` actions starts an MRU window
traversal sequence if one isn't already in progress. When a sequence is
in progress, focus timestamps are no longer updated.

A traversal sequence ends when:
- either the `Mod` key is released, the focus then stays on the chosen
  window  and its timestamp is immediately refreshed,
- or if the `Escape` key is pressed, the focus returns to the window
  that initially had the focus when the sequence was started.

Rename WindowMRU fields

Improve window close handling during MRU traversal

When the focused window is closed during an MRU traversal, it moves
to the previous window in MRU order instead of the default behavior.

Removed dbg! calls

Merge remote-tracking branch 'upstream/main' into window-mru

Hardcode Alt-Tab/Alt-shift-Tab for MRU window nav

- Add a `PRESET_BINDINGS` containing MRU navigation actions.
  `PRESET_BINDINGS` are overridden by user configuration so these remain
  available if the user needs them for another purpose
- Releasing the `Alt` key ends any in-progress MRU window traversal

Remove `focus-window-mru` actions from config

These actions are configured in presets but no longer available
for the bindings section of the configuration

Cancel MRU traversal with Alt-Esc

Had been forgotten in prior commit and was using `Mod` instead of `Alt`

Rephrase some comments

Fix Alt-Esc not cancelling window-mru

Merge remote-tracking branch 'upstream/main' into window-mru

Lock-in focus immediately on user interaction

As per suggestion by @bbb651, focus is locked-in immediately if a window
is interacted with, ie. receives key events or pointer clicks.

This change is also an opportunity to make the lockin timer less aggresive.

Merge remote-tracking branch 'upstream/main' into window-mru

Simplify WindowMRU::new

Now that there is a more general Niri::lockin_focus method, leverage
it in WindowMRU.

Replace Duration with Instant in WindowMRU timestamp

Merge remote-tracking branch 'upstream/main' into window-mru

Address PR comments - partial

- Swapped meaning of next and previous for MRU traversal
- Fixed comment that still referred to `Mod` as leader key for MRU traversal
  instead of `Alt`
- Fixed doc comments that were missing a period
- Stop using BinaryHeap in `WindowMRU::new()`
- Replaced `WindowMRU::mru_with()` method with a simpler `advance()`
- Simplified `Alt` key release handling code in `State::on_keyboard()`

Simplify early-mru-commit logic

No longer perform the mru-commit/lockin_focus in the next event loop callback.
Instead it is handled directly when it is determined that an event (pointer
or kbd) is forwarded to the active window.

Handle PR comments

- `focus_lockin` variables and configuration item renamed to `mru_commit`.
- added the Esc key to `suppressed_keys` if it was used to cancel an MRU
  traversal.
- removed `WindowMRU::mru_next` and `WindowMRU::mru_previous` methods
  as they didn't really provide more than the generic `WindowMRU::advance`
  method.
- removed obsolete `Niri::event_forwarded_to_focused_client` boolean
- added calls to `mru_commit()` (formerly `focus_lockin`) in:
  - `State::on_pointer_axis()`
  - `State::on_tablet_tool_axis()`
  - `State::on_tablet_tool_tip()`
  - `State::on_tablet_tool_proximity()`
  - `State::on_tablet_tool_button()`
  - `State::on_gesture_swipe_begin()`
  - `State::on_gesture_pinch_begin()`
  - `State::on_gesture_hold_begin()`
  - `State::on_touch_down()`

Merge remote-tracking branch 'upstream/main' into window-mru

Merge remote-tracking branch 'upstream/main' into window-mru

Author: rustn00b

niri-config/src/lib.rs

@@ -25,6 +25,8 @@ use smithay::reexports::input;
 
 pub const DEFAULT_BACKGROUND_COLOR: Color = Color::from_array_unpremul([0.2, 0.2, 0.2, 1.]);
 
+pub const DEFAULT_MRU_COMMIT_MS: u64 = 750;
+
 pub mod layer_rule;
 
 mod utils;
@@ -72,6 +74,8 @@ pub struct Config {
     pub debug: DebugConfig,
     #[knuffel(children(name = "workspace"))]
     pub workspaces: Vec<Workspace>,
+    #[knuffel(child, unwrap(argument), default = DEFAULT_MRU_COMMIT_MS)]
+    pub mru_commit_ms: u64,
 }
 
 #[derive(knuffel::Decode, Debug, Default, PartialEq)]
@@ -1433,6 +1437,10 @@ pub enum Action {
     FocusWindow(u64),
     FocusWindowInColumn(#[knuffel(argument)] u8),
     FocusWindowPrevious,
+    #[knuffel(skip)]
+    FocusWindowMruNext,
+    #[knuffel(skip)]
+    FocusWindowMruPrevious,
     FocusColumnLeft,
     FocusColumnRight,
     FocusColumnFirst,
@@ -1619,6 +1627,8 @@ impl From<niri_ipc::Action> for Action {
             niri_ipc::Action::FocusWindow { id } => Self::FocusWindow(id),
             niri_ipc::Action::FocusWindowInColumn { index } => Self::FocusWindowInColumn(index),
             niri_ipc::Action::FocusWindowPrevious {} => Self::FocusWindowPrevious,
+            niri_ipc::Action::FocusWindowMruNext {} => Self::FocusWindowMruNext,
+            niri_ipc::Action::FocusWindowMruPrevious {} => Self::FocusWindowMruPrevious,
             niri_ipc::Action::FocusColumnLeft {} => Self::FocusColumnLeft,
             niri_ipc::Action::FocusColumnRight {} => Self::FocusColumnRight,
             niri_ipc::Action::FocusColumnFirst {} => Self::FocusColumnFirst,
@@ -3741,6 +3751,8 @@ mod tests {
             }
             workspace "workspace-2"
             workspace "workspace-3"
+
+            mru-commit-ms 123
             "##,
             Config {
                 input: Input {
@@ -4209,6 +4221,7 @@ mod tests {
                     render_drm_device: Some(PathBuf::from("/dev/dri/renderD129")),
                     ..Default::default()
                 },
+                mru_commit_ms: 123u64,
             },
         );
     }

niri-ipc/src/lib.rs

@@ -225,6 +225,10 @@ pub enum Action {
     },
     /// Focus the previously focused window.
     FocusWindowPrevious {},
+    /// Focus the next window in most-recently-used order.
+    FocusWindowMruNext {},
+    /// Focus the previous window in most-recently-used order.
+    FocusWindowMruPrevious {},
     /// Focus the column to the left.
     FocusColumnLeft {},
     /// Focus the column to the right.

src/handlers/compositor.rs

@@ -274,7 +274,11 @@ impl CompositorHandler for State {
                     }
 
                     if was_active {
-                        self.maybe_warp_cursor_to_focus();
+                        if self.niri.window_mru.is_some() {
+                            self.focus_window_mru_next();
+                        } else {
+                            self.maybe_warp_cursor_to_focus();
+                        }
                     }
 
                     // Newly-unmapped toplevels must perform the initial commit-configure sequence

src/handlers/xdg_shell.rs

@@ -676,7 +676,11 @@ impl XdgShellHandler for State {
         }
 
         if was_active {
-            self.maybe_warp_cursor_to_focus();
+            if self.niri.window_mru.is_some() {
+                self.focus_window_mru_next();
+            } else {
+                self.maybe_warp_cursor_to_focus();
+            }
         }
 
         if let Some(output) = output {

src/input/mod.rs

@@ -2,7 +2,7 @@ use std::any::Any;
 use std::cmp::min;
 use std::collections::hash_map::Entry;
 use std::collections::HashSet;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 use calloop::timer::{TimeoutAction, Timer};
 use input::event::gesture::GestureEventCoordinates as _;
@@ -371,7 +371,6 @@ impl State {
             serial,
             time,
             |this, mods, keysym| {
-                let bindings = &this.niri.config.borrow().binds;
                 let key_code = event.key_code();
                 let modified = keysym.modified_sym();
                 let raw = keysym.raw_latin_sym_or_raw_current_sym();
@@ -387,19 +386,64 @@ impl State {
                     }
                 }
 
-                should_intercept_key(
-                    &mut this.niri.suppressed_keys,
-                    bindings,
-                    comp_mod,
-                    key_code,
-                    modified,
-                    raw,
-                    pressed,
-                    *mods,
-                    &this.niri.screenshot_ui,
-                    this.niri.config.borrow().input.disable_power_key_handling,
-                    is_inhibiting_shortcuts,
-                )
+                // check if alt key was released while there was an active
+                // window-mru list. If so,  drop the list and update the current window's timestamp.
+                // window-mru is cancelled *even* when state is locked, however the
+                // focus timestamp on the active window will not be updated
+                if !mods.alt && this.niri.window_mru.take().is_some() && !this.niri.is_locked() {
+                    if let Some(m) = this
+                        .niri
+                        .layout
+                        .active_workspace_mut()
+                        .and_then(|ws| ws.active_window_mut())
+                    {
+                        m.update_focus_timestamp(Instant::now());
+                    }
+                }
+
+                // If the ESC key was pressed with the Alt modifier and
+                // there is an active window-mru, cancel the window-mru and
+                // refocus the initial window (first in the list).
+                if pressed && mods.alt && raw == Some(Keysym::Escape) {
+                    if let Some(id) = this
+                        .niri
+                        .window_mru
+                        .take()
+                        .and_then(|wmru| wmru.ids.into_iter().next())
+                    {
+                        this.niri.suppressed_keys.insert(key_code);
+                        let window = this.niri.layout.windows().find(|(_, m)| m.id() == id);
+                        let window = window.map(|(_, m)| m.window.clone());
+                        if let Some(window) = window {
+                            this.focus_window(&window);
+                            return FilterResult::Intercept(None);
+                        }
+                    }
+                }
+
+                let intercept_result = {
+                    let bindings = &this.niri.config.borrow().binds;
+                    should_intercept_key(
+                        &mut this.niri.suppressed_keys,
+                        bindings,
+                        comp_mod,
+                        key_code,
+                        modified,
+                        raw,
+                        pressed,
+                        *mods,
+                        &this.niri.screenshot_ui,
+                        this.niri.config.borrow().input.disable_power_key_handling,
+                        is_inhibiting_shortcuts,
+                    )
+                };
+                if matches!(intercept_result, FilterResult::Forward) {
+                    // Interaction with the active window, immediately update
+                    // the active window's focus timestamp without waiting for a
+                    // possible pending MRU lock-in delay.
+                    this.niri.mru_commit();
+                }
+                intercept_result
             },
         ) else {
             return;
@@ -697,6 +741,12 @@ impl State {
                     self.focus_window(&window);
                 }
             }
+            Action::FocusWindowMruNext => {
+                self.focus_window_mru_next();
+            }
+            Action::FocusWindowMruPrevious => {
+                self.focus_window_mru_previous();
+            }
             Action::SwitchLayout(action) => {
                 let keyboard = &self.niri.seat.get_keyboard().unwrap();
                 keyboard.with_xkb_state(self, |mut state| match action {
@@ -2175,6 +2225,10 @@ impl State {
             }
         }
 
+        // The event is getting forwarded to a client, consider that the
+        // MRU Window order shoud be committed.
+        self.niri.mru_commit();
+
         pointer.button(
             self,
             &ButtonEvent {
@@ -2392,6 +2446,8 @@ impl State {
 
         pointer.axis(self, frame);
         pointer.frame(self);
+
+        self.niri.mru_commit();
     }
 
     fn on_tablet_tool_axis<I: InputBackend>(&mut self, event: I::TabletToolAxisEvent)
@@ -2437,6 +2493,8 @@ impl State {
 
             self.niri.pointer_hidden = false;
             self.niri.tablet_cursor_location = Some(pos);
+
+            self.niri.mru_commit();
         }
 
         // Redraw to update the cursor position.
@@ -2467,6 +2525,7 @@ impl State {
                             self.niri.queue_redraw_all();
                         }
                         self.niri.focus_layer_surface_if_on_demand(under.layer);
+                        self.niri.mru_commit();
                     }
                 }
                 TabletToolTipState::Up => {
@@ -2501,6 +2560,7 @@ impl State {
                             SERIAL_COUNTER.next_serial(),
                             event.time_msec(),
                         );
+                        self.niri.mru_commit();
                     }
                     self.niri.pointer_hidden = false;
                     self.niri.tablet_cursor_location = Some(pos);
@@ -2536,6 +2596,7 @@ impl State {
                 SERIAL_COUNTER.next_serial(),
                 event.time_msec(),
             );
+            self.niri.mru_commit();
         }
     }
 
@@ -2562,6 +2623,7 @@ impl State {
                 fingers: event.fingers(),
             },
         );
+        self.niri.mru_commit();
     }
 
     fn on_gesture_swipe_update<I: InputBackend + 'static>(
@@ -2714,6 +2776,7 @@ impl State {
                 fingers: event.fingers(),
             },
         );
+        self.niri.mru_commit();
     }
 
     fn on_gesture_pinch_update<I: InputBackend>(&mut self, event: I::GesturePinchUpdateEvent) {
@@ -2768,6 +2831,7 @@ impl State {
                 fingers: event.fingers(),
             },
         );
+        self.niri.mru_commit();
     }
 
     fn on_gesture_hold_end<I: InputBackend>(&mut self, event: I::GestureHoldEndEvent) {
@@ -2880,6 +2944,7 @@ impl State {
 
         // We're using touch, hide the pointer.
         self.niri.pointer_hidden = true;
+        self.niri.mru_commit();
     }
     fn on_touch_up<I: InputBackend>(&mut self, evt: I::TouchUpEvent) {
         let Some(handle) = self.niri.seat.get_touch() else {
@@ -3083,6 +3148,41 @@ fn find_bind(
     find_configured_bind(bindings, comp_mod, trigger, mods)
 }
 
+/// Preset bindings can be overridden in the user configuration.
+/// The reason for treating them differently is that their key + modifier
+/// combination needs to be frozen for some reason.
+const PRESET_BINDINGS: &[Bind] = &[
+    // The following two bindings cover MRU window navigation. They are
+    // preset because the `Alt` key is treated specially in `on_keyboard`.
+    // When it is released the active MRU traversal is considered to have
+    // completed. If the user were allowed to change the MRU bindings
+    // below, the navigation mechanism would no longer work as intended.
+    Bind {
+        key: Key {
+            trigger: Trigger::Keysym(Keysym::Tab),
+            modifiers: Modifiers::ALT,
+        },
+        action: Action::FocusWindowMruNext,
+        repeat: true,
+        cooldown: None,
+        allow_when_locked: false,
+        allow_inhibiting: true,
+        hotkey_overlay_title: None,
+    },
+    Bind {
+        key: Key {
+            trigger: Trigger::Keysym(Keysym::Tab),
+            modifiers: Modifiers::ALT.union(Modifiers::SHIFT),
+        },
+        action: Action::FocusWindowMruPrevious,
+        repeat: true,
+        cooldown: None,
+        allow_when_locked: false,
+        allow_inhibiting: true,
+        hotkey_overlay_title: None,
+    },
+];
+
 fn find_configured_bind(
     bindings: &Binds,
     comp_mod: CompositorMod,
@@ -3100,7 +3200,9 @@ fn find_configured_bind(
         modifiers |= Modifiers::COMPOSITOR;
     }
 
-    for bind in &bindings.0 {
+    // iterate through configured bindings looking for a match, and
+    // then check in  `PRESET_BINDINGS` if none were found
+    for bind in bindings.0.iter().chain(PRESET_BINDINGS.iter()) {
         if bind.key.trigger != trigger {
             continue;
         }