wip2

osu.Framework/Graphics/Drawable.cs

@@ -1532,11 +1532,7 @@ internal set
 
                 // When this drawable is part of any focus hierarchy (whether it is the first responder or not) unfocus the environment.
                 if (HasFocus)
-                {
-                    // Prevent re-entry.
-                    HasFocus = false;
-                    GetContainingFocusSystem()!.ResignFocus(GetContainingFocusEnvironment()!.CurrentFocus!);
-                }
+                    GetContainingFocusSystem()!.ResignFocusImmediately(this);
 
                 parent = value;
                 Invalidate(InvalidationFromParentSize | Invalidation.Colour | Invalidation.Presence | Invalidation.Parent);
@@ -2416,6 +2412,8 @@ public bool TriggerEvent(UIEvent e)
         /// </summary>
         public virtual bool HandlePositionalInput => RequestsPositionalInput;
 
+        internal bool HadFocus { get; set; }
+
         /// <summary>
         /// Check whether we have active focus.
         /// </summary>

osu.Framework/Input/Focus/IFocusEnvironment.cs

@@ -41,37 +41,5 @@ internal void ChangeFocus(InputState state, Drawable? target)
 
             CurrentFocus = target;
         }
-
-        internal static bool IsDrawableValidForFocus(Drawable drawable)
-        {
-            while (drawable != null)
-            {
-                if (!drawable.IsAlive || !drawable.IsPresent || drawable.Parent == null)
-                    return false;
-
-                if (drawable is IFocusEnvironment)
-                    return true;
-
-                drawable = drawable.Parent;
-            }
-
-            return false;
-        }
-
-        internal static IEnumerable<Drawable> BuildFocusSet(Drawable? target)
-        {
-            Drawable? d = target;
-
-            while (d != null)
-            {
-                if (d is Drawable obj)
-                    yield return obj;
-
-                if (d is IFocusEnvironment)
-                    break;
-
-                d = d.Parent;
-            }
-        }
     }
 }

osu.Framework/Input/Focus/IFocusSystem.cs

@@ -28,5 +28,7 @@ public interface IFocusSystem : IDrawable
         /// </summary>
         /// <param name="target">The drawable.</param>
         void ResignFocus(Drawable target);
+
+        void ResignFocusImmediately(Drawable target);
     }
 }

osu.Framework/Input/InputManager_Focus.cs

@@ -30,9 +30,10 @@ private void updateFocus()
                     Debug.Assert(env.CurrentFocus != null);
 
                     if (!isDrawableValidForFocus(env.CurrentFocus))
-                    {
-                    }
+                        env.ChangeFocus(CurrentState, null);
                 }
+
+                activeEnvironments.Clear();
             }
 
             foreach (IFocusEnvironment env in activeEnvironments)
@@ -50,6 +51,12 @@ public void AcquireFocus(Drawable target)
         public void ResignFocus(Drawable target)
             => enqueueRequest(new FocusRequest(FocusRequestType.Resign, CurrentState, target));
 
+        public void ResignFocusImmediately(Drawable target)
+        {
+            Debug.Assert(target.HasFocus);
+            resign(CurrentState, getEnvironment(target)!.CurrentFocus!);
+        }
+
         internal FocusUpdateBatch BeginFocusUpdateBatch() => new FocusUpdateBatch(this);
 
         internal readonly ref struct FocusUpdateBatch
@@ -132,40 +139,78 @@ void acquire(InputState state, Drawable target)
                 {
                     lastFirstResponder = FirstResponder;
                     nextFirstResponder = target;
+
+                    FirstResponder = target;
                 }
 
-                lastFirstResponder?.TriggerEvent(new ResignFirstResponderEvent(state, nextFirstResponder));
-                environment.ChangeFocus(state, target);
-                nextFirstResponder?.TriggerEvent(new BecomeFirstResponderEvent(state, lastFirstResponder));
+                IEnumerable<Drawable> lastFocusSet = [];
+                IEnumerable<Drawable> nextFocusSet = [];
 
-                if (lastFirstResponder != nextFirstResponder)
-                    FirstResponder = nextFirstResponder;
-            }
+                if (target != environment.CurrentFocus)
+                {
+                    lastFocusSet = enumerateFocusSet(environment.CurrentFocus);
+                    nextFocusSet = enumerateFocusSet(target);
 
-            void resign(InputState state, Drawable target)
-            {
-                if (getEnvironment(target) is not IFocusEnvironment environment)
-                    return;
+                    foreach (var drawable in lastFocusSet)
+                    {
+                        drawable.HadFocus = drawable.HasFocus;
+                        drawable.HasFocus = false;
+                    }
 
-                if (environment.CurrentFocus != target)
-                    return;
+                    foreach (var drawable in nextFocusSet)
+                    {
+                        drawable.HadFocus = drawable.HasFocus;
+                        drawable.HasFocus = true;
+                    }
 
-                Drawable? lastFirstResponder = null;
-                Drawable? nextFirstResponder = null;
+                    environment.CurrentFocus = target;
+                }
 
-                if (FirstResponder == target)
+                // 1. Resign old responder.
+                lastFirstResponder?.TriggerEvent(new ResignFirstResponderEvent(state, nextFirstResponder));
+
+                // 2. Resign focus on old drawables.
+                foreach (var drawable in lastFocusSet)
                 {
-                    lastFirstResponder = FirstResponder;
-                    nextFirstResponder = this.ChildrenOfType<IFocusEnvironment>().Select(e => e.CurrentFocus).FirstOrDefault(d => d != null && d != lastFirstResponder);
+                    if (drawable.HadFocus && !drawable.HasFocus)
+                        drawable.TriggerEvent(new FocusLostEvent(state, target));
                 }
 
-                lastFirstResponder?.TriggerEvent(new ResignFirstResponderEvent(state, nextFirstResponder));
-                environment.ChangeFocus(state, null);
+                // 3. Acquire focus on new drawables.
+                foreach (var drawable in nextFocusSet.Reverse())
+                {
+                    if (!drawable.HadFocus && drawable.HadFocus)
+                        drawable.TriggerEvent(new FocusLostEvent(state, target));
+                }
+
+                // 4. Acquire new responder.
                 nextFirstResponder?.TriggerEvent(new BecomeFirstResponderEvent(state, lastFirstResponder));
+            }
+        }
+
+        private void resign(InputState state, Drawable target)
+        {
+            if (getEnvironment(target) is not IFocusEnvironment environment)
+                return;
+
+            if (environment.CurrentFocus != target)
+                return;
+
+            Drawable? lastFirstResponder = null;
+            Drawable? nextFirstResponder = null;
 
-                if (lastFirstResponder != nextFirstResponder)
-                    FirstResponder = nextFirstResponder;
+            if (FirstResponder == target)
+            {
+                lastFirstResponder = FirstResponder;
+                nextFirstResponder = this.ChildrenOfType<IFocusEnvironment>().Select(e => e.CurrentFocus).FirstOrDefault(d => d != null && d != lastFirstResponder);
             }
+
+            lastFirstResponder?.TriggerEvent(new ResignFirstResponderEvent(state, nextFirstResponder));
+            environment.ChangeFocus(state, null);
+            nextFirstResponder?.TriggerEvent(new BecomeFirstResponderEvent(state, lastFirstResponder));
+
+            if (lastFirstResponder != nextFirstResponder)
+                FirstResponder = nextFirstResponder;
         }
 
         private IFocusEnvironment? getEnvironment(Drawable? drawable)
@@ -187,6 +232,29 @@ private bool isDrawableValidForFocus(Drawable drawable)
             return true;
         }
 
+        /// <summary>
+        /// Enumerates self and all parenting drawables from a target drawable until the first focus environment is found.
+        /// When the target drawable's focus is changed, the returned set contains all targets that must receive focus change events
+        /// in order from target to environment.
+        /// </summary>
+        /// <param name="target">The drawable whose focus state is changed.</param>
+        /// <returns>The set of all drawables that must receive focus change events in order from target to environment.</returns>
+        private static IEnumerable<Drawable> enumerateFocusSet(Drawable? target)
+        {
+            Drawable? d = target;
+
+            while (d != null)
+            {
+                if (d is Drawable obj)
+                    yield return obj;
+
+                if (d is IFocusEnvironment)
+                    break;
+
+                d = d.Parent;
+            }
+        }
+
         void IFocusManager.TriggerFocusContention(Drawable? triggerSource)
         {
         }