Working version

Author: leolost2605

lib/FocusController.vala

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2025 elementary, Inc. (https://elementary.io)
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Authored by: Leonhard Kargl <[email protected]>
+ */
+
+public class Gala.FocusController : Object {
+    public static FocusController get_default (Clutter.Stage stage) {
+        return instance.once (() => new FocusController (stage));
+    }
+
+    public Clutter.Stage stage { get; construct; }
+
+    private bool _focus_visible = false;
+    public bool focus_visible {
+        get { return _focus_visible; }
+        private set {
+            _focus_visible = value;
+            if (stage.get_key_focus () is Focusable) {
+                ((Focusable) stage.get_key_focus ()).notify_visible_focus_changed ();
+            }
+        }
+    }
+
+    private static GLib.Once<FocusController> instance;
+
+    private Gee.List<unowned Focusable> root_focusables;
+
+    private uint timeout_id = 0;
+
+    public FocusController (Clutter.Stage stage) {
+        Object (stage: stage);
+    }
+
+    construct {
+        root_focusables = new Gee.LinkedList<unowned Focusable> ();
+        stage.key_press_event.connect (on_key_press_event);
+    }
+
+    public void register_root (Focusable root) {
+        if (root in root_focusables) {
+            warning ("Trying to register root focusable multiple times.");
+            return;
+        }
+
+        root_focusables.add (root);
+        root.weak_ref ((obj) => root_focusables.remove ((Focusable) obj));
+    }
+
+    private bool on_key_press_event (Clutter.Event event) {
+        if (handle_key_event (event) == Clutter.EVENT_STOP) {
+            show_focus ();
+            return Clutter.EVENT_STOP;
+        }
+
+        return Clutter.EVENT_PROPAGATE;
+    }
+
+    private bool handle_key_event (Clutter.Event event) {
+        Focusable? mapped_root = null;
+        foreach (var root_focusable in root_focusables) {
+            if (root_focusable.mapped) {
+                mapped_root = root_focusable;
+                break;
+            }
+        }
+
+        var direction = Focusable.FocusDirection.get_for_event (event);
+
+        if (mapped_root == null || direction == null) {
+            return Clutter.EVENT_PROPAGATE;
+        }
+
+        if(!mapped_root.focus (direction)) {
+#if HAS_MUTTER47
+            stage.context.get_backend ().get_default_seat ().bell_notify ();
+#else
+            Clutter.get_default_backend ().get_default_seat ().bell_notify ();
+#endif
+        }
+
+        return Clutter.EVENT_STOP;
+    }
+
+    private void show_focus () {
+        if (timeout_id != 0) {
+            Source.remove (timeout_id);
+        } else {
+            focus_visible = true;
+        }
+
+        timeout_id = Timeout.add_seconds (5, () => {
+            focus_visible = false;
+            timeout_id = 0;
+            return Source.REMOVE;
+        });
+    }
+}

lib/Focusable.vala

@@ -5,7 +5,7 @@
  * Authored by: Leonhard Kargl <[email protected]>
  */
 
-public interface Gala.Focusable : Clutter.Actor {
+public interface Gala.Focusable : Clutter.Actor{
     public enum FocusDirection {
         UP,
         DOWN,
@@ -17,6 +17,23 @@ public interface Gala.Focusable : Clutter.Actor {
         public bool is_forward () {
             return this == DOWN || this == RIGHT || this == NEXT;
         }
+
+        public static FocusDirection? get_for_event (Clutter.Event event) {
+            switch (event.get_key_symbol ()) {
+                case Clutter.Key.Up: return UP;
+                case Clutter.Key.Down: return DOWN;
+                case Clutter.Key.Left: return LEFT;
+                case Clutter.Key.Right: return RIGHT;
+                case Clutter.Key.Tab:
+                    if (SHIFT_MASK in event.get_state ()) {
+                        return PREVIOUS;
+                    } else {
+                        return NEXT;
+                    }
+            }
+
+            return null;
+        }
     }
 
     public bool focus (FocusDirection direction) {
@@ -62,6 +79,46 @@ public interface Gala.Focusable : Clutter.Actor {
     }
 
     protected virtual bool move_focus (FocusDirection direction) {
+        var children = get_focusable_children ();
+
+        filter_children_for_direction (children, direction);
+
+        switch (direction) {
+            case NEXT:
+                sort_children_for_direction (children, DOWN);
+                sort_children_for_direction (children, RIGHT);
+                break;
+
+            case PREVIOUS:
+                sort_children_for_direction (children, UP);
+                sort_children_for_direction (children, LEFT);
+                break;
+
+            default:
+                sort_children_for_direction (children, direction);
+                break;
+        }
+
+        foreach (var child in children) {
+            if (child.focus (direction)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private Gee.List<Focusable> get_focusable_children () {
+        var focusable_children = new Gee.ArrayList<Focusable> ();
+        for (var child = get_first_child (); child != null; child = child.get_next_sibling ()) {
+            if (child is Focusable) {
+                focusable_children.add ((Focusable) child);
+            }
+        }
+        return focusable_children;
+    }
+
+    private void filter_children_for_direction (Gee.List<Focusable> children, FocusDirection direction) {
         var focus_actor = get_stage ().get_key_focus ();
 
         Focusable? focus_child = null;
@@ -74,9 +131,9 @@ public interface Gala.Focusable : Clutter.Actor {
             }
         }
 
-        var possible_children = new Gee.ArrayList<Focusable> ();
-        possible_children.add_all_iterator (get_focusable_children ().filter ((c) => {
-            if (focus_child == null || c == focus_child) {
+        var to_retain = new Gee.LinkedList<Focusable> ();
+        to_retain.add_all_iterator (children.filter ((c) => {
+            if (focus_child == null || c == focus_child || direction == NEXT || direction == PREVIOUS) {
                 return true;
             }
 
@@ -97,7 +154,15 @@ public interface Gala.Focusable : Clutter.Actor {
             );
         }));
 
-        possible_children.sort ((a, b) => {
+        children.retain_all (to_retain);
+    }
+
+    private inline Mtk.Rectangle get_allocation_rect (Clutter.Actor actor) {
+        return {(int) actor.x, (int) actor.y, (int) actor.width, (int) actor.height};
+    }
+
+    private void sort_children_for_direction (Gee.List<Focusable> children, FocusDirection direction) {
+        children.sort ((a, b) => {
             if (direction == UP && a.y + a.height > b.y + b.height ||
                 direction == DOWN && a.y < b.y ||
                 direction == LEFT && a.x + a.width > b.x + b.width ||
@@ -108,28 +173,6 @@ public interface Gala.Focusable : Clutter.Actor {
 
             return 1;
         });
-
-        foreach (var child in possible_children) {
-            if (child.focus (direction)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    private Mtk.Rectangle get_allocation_rect (Clutter.Actor actor) {
-        return {(int) actor.x, (int) actor.y, (int) actor.width, (int) actor.height};
-    }
-
-    private Gee.List<Focusable> get_focusable_children () {
-        var focusable_children = new Gee.ArrayList<Focusable> ();
-        for (var child = get_first_child (); child != null; child = child.get_next_sibling ()) {
-            if (child is Focusable) {
-                focusable_children.add ((Focusable) child);
-            }
-        }
-        return focusable_children;
     }
 
     private bool grab_focus () {
@@ -138,6 +181,8 @@ public interface Gala.Focusable : Clutter.Actor {
         }
 
         get_stage ().set_key_focus (this);
+        notify_visible_focus_changed ();
+        key_focus_out.connect (notify_visible_focus_changed);
 
         return true;
     }
@@ -146,37 +191,10 @@ public interface Gala.Focusable : Clutter.Actor {
         return false;
     }
 
-    public void mark_root (Clutter.Stage stage) {
-        stage.key_press_event.connect (on_key_press_event);
+    internal void notify_visible_focus_changed () {
+        var stage = get_stage ();
+        update_focus (stage?.get_key_focus () == this && FocusController.get_default (stage).focus_visible);
     }
 
-    private bool on_key_press_event (Clutter.Event event) {
-        if (!mapped) {
-            return Clutter.EVENT_PROPAGATE;
-        }
-
-        switch (event.get_key_symbol ()) {
-            case Clutter.Key.Tab:
-                if (SHIFT_MASK in event.get_state ()) {
-                    focus (PREVIOUS);
-                } else {
-                    focus (NEXT);
-                }
-                return Clutter.EVENT_STOP;
-            case Clutter.Key.Up:
-                focus (UP);
-                return Clutter.EVENT_STOP;
-            case Clutter.Key.Left:
-                focus (LEFT);
-                return Clutter.EVENT_STOP;
-            case Clutter.Key.Down:
-                focus (DOWN);
-                return Clutter.EVENT_STOP;
-            case Clutter.Key.Right:
-                focus (RIGHT);
-                return Clutter.EVENT_STOP;
-            default:
-                return Clutter.EVENT_PROPAGATE;
-        }
-    }
+    protected virtual void update_focus (bool has_visible_focus) { }
 }

lib/meson.build

@@ -13,6 +13,8 @@ gala_lib_sources = files(
     'Drawing/Color.vala',
     'Drawing/StyleManager.vala',
     'Drawing/Utilities.vala',
+    'Focusable.vala',
+    'FocusController.vala',
     'Image.vala',
     'Plugin.vala',
     'RoundedCornersEffect.vala',

src/Widgets/MultitaskingView/MonitorClone.vala

@@ -11,7 +11,7 @@
  * as the WindowGroup is hidden while the view is active. Only used when
  * workspaces-only-on-primary is set to true.
  */
-public class Gala.MonitorClone : ActorTarget {
+public class Gala.MonitorClone : ActorTarget, Focusable {
     public signal void window_selected (Meta.Window window);
 
     public WindowManager wm { get; construct; }

src/Widgets/MultitaskingView/MultitaskingView.vala

@@ -15,12 +15,14 @@
 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
+public class Gala.PrimaryMonitorContainer : ActorTarget, Focusable { }
+
 /**
  * The central class for the MultitaskingView which takes care of
  * preparing the wm, opening the components and holds containers for
  * the icon groups, the WorkspaceClones and the MonitorClones.
  */
-public class Gala.MultitaskingView : ActorTarget, RootTarget, ActivatableComponent {
+public class Gala.MultitaskingView : ActorTarget, RootTarget, ActivatableComponent, Focusable {
     public const int ANIMATION_DURATION = 250;
 
     private GestureController workspaces_gesture_controller;
@@ -54,6 +56,8 @@ public class Gala.MultitaskingView : ActorTarget, RootTarget, ActivatableCompone
         reactive = true;
         clip_to_allocation = true;
 
+        FocusController.get_default (wm.stage).register_root (this);
+
         opened = false;
         display = wm.get_display ();
 
@@ -78,7 +82,7 @@ public class Gala.MultitaskingView : ActorTarget, RootTarget, ActivatableCompone
         // Create a child container that will be sized to fit the primary monitor, to contain the "main"
         // multitasking view UI. The Clutter.Actor of this class has to be allowed to grow to the size of the
         // stage as it contains MonitorClones for each monitor.
-        primary_monitor_container = new ActorTarget ();
+        primary_monitor_container = new PrimaryMonitorContainer ();
         primary_monitor_container.add_child (workspaces);
         add_child (primary_monitor_container);
 
@@ -107,6 +111,8 @@ public class Gala.MultitaskingView : ActorTarget, RootTarget, ActivatableCompone
         });
 
         style_manager.notify["prefers-color-scheme"].connect (update_brightness_effect);
+
+        wm.stage.key_press_event.connect (on_stage_key_press_event);
     }
 
     /**
@@ -245,7 +251,6 @@ public class Gala.MultitaskingView : ActorTarget, RootTarget, ActivatableCompone
             wm.window_group.hide ();
             wm.top_window_group.hide ();
             show ();
-            grab_key_focus ();
 
             modal_proxy = wm.push_modal (get_stage (), false);
             modal_proxy.set_keybinding_filter (keybinding_filter);
@@ -369,34 +374,12 @@ public class Gala.MultitaskingView : ActorTarget, RootTarget, ActivatableCompone
         }
     }
 
-    /**
-     * Collect key events, mainly for redirecting them to the WindowCloneContainers to
-     * select the active window.
-     */
-    public override bool key_press_event (Clutter.Event event) {
-        if (!opened) {
-            return Clutter.EVENT_PROPAGATE;
-        }
-
-        return get_active_window_clone_container ().key_press_event (event);
-    }
-
-    /**
-     * Finds the active WorkspaceClone
-     *
-     * @return The active WorkspaceClone
-     */
-    private WindowCloneContainer get_active_window_clone_container () {
-        unowned var manager = display.get_workspace_manager ();
-        unowned var active_workspace = manager.get_active_workspace ();
-        foreach (unowned var child in workspaces.get_children ()) {
-            unowned var workspace_clone = (WorkspaceClone) child;
-            if (workspace_clone.workspace == active_workspace) {
-                return workspace_clone.window_container;
-            }
+    private bool on_stage_key_press_event (Clutter.Event event) {
+        if (opened && event.get_key_symbol () == Clutter.Key.Escape) {
+            close ();
+            return Clutter.EVENT_STOP;
         }
-
-        assert_not_reached ();
+        return Clutter.EVENT_PROPAGATE;
     }
 
     private void window_selected (Meta.Window window) {