Merge branch 'master' into fix-proxydrawable-lifetime

osu.Framework.Tests/Visual/UserInterface/TestSceneFocusedOverlayContainer.cs

···
 using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
+using osuTK.Input;
 
 namespace osu.Framework.Tests.Visual.UserInterface
 {
     public class TestSceneFocusedOverlayContainer : ManualInputManagerTestScene
     {
-        private TestFocusedOverlayContainer testContainer;
+        private TestFocusedOverlayContainer overlayContainer;
+
+        private ParentContainer parentContainer;
+
+        [Test]
+        public void TestClickDismiss()
+        {
+            AddStep("create container", () => { Child = overlayContainer = new TestFocusedOverlayContainer(); });
+
+            AddStep("show", () => overlayContainer.Show());
+            AddAssert("has focus", () => overlayContainer.HasFocus);
+
+            AddStep("click inside", () =>
+            {
+                InputManager.MoveMouseTo(overlayContainer.ScreenSpaceDrawQuad.Centre);
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("still has focus", () => overlayContainer.HasFocus);
+
+            AddStep("click outside", () =>
+            {
+                InputManager.MoveMouseTo(overlayContainer.ScreenSpaceDrawQuad.TopLeft - new Vector2(20));
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("lost focus", () => !overlayContainer.HasFocus);
+            AddAssert("not visible", () => overlayContainer.State.Value == Visibility.Hidden);
+        }
 
         [Test]
-        public void TestInputBlocking()
+        public void TestScrollBlocking()
         {
-            AddStep("create container", () => Child = testContainer = new TestFocusedOverlayContainer());
+            AddStep("create container", () =>
+            {
+                Child = parentContainer = new ParentContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        overlayContainer = new TestFocusedOverlayContainer()
+                    }
+                };
+            });
+
+            AddStep("show", () => overlayContainer.Show());
+
+            AddAssert("has focus", () => overlayContainer.HasFocus);
+
+            int initialScrollCount = 0;
+
+            AddStep("scroll inside", () =>
+            {
+                initialScrollCount = parentContainer.ScrollReceived;
+                InputManager.MoveMouseTo(overlayContainer.ScreenSpaceDrawQuad.Centre);
+                InputManager.ScrollVerticalBy(1);
+            });
 
-            AddStep("show", () => testContainer.Show());
+            AddAssert("scroll not received by parent", () => parentContainer.ScrollReceived == initialScrollCount);
 
-            AddAssert("has focus", () => testContainer.HasFocus);
+            AddStep("scroll outside", () =>
+            {
+                InputManager.MoveMouseTo(overlayContainer.ScreenSpaceDrawQuad.TopLeft - new Vector2(20));
+                InputManager.ScrollVerticalBy(1);
+            });
+
+            AddAssert("scroll received by parent", () => parentContainer.ScrollReceived == ++initialScrollCount);
         }
 
         private class TestFocusedOverlayContainer : FocusedOverlayContainer
···
 
                 base.PopOut();
             }
+        }
+    }
+
+    public class ParentContainer : Container
+    {
+        public int ScrollReceived;
+
+        protected override bool OnScroll(ScrollEvent e)
+        {
+            ScrollReceived++;
+            return base.OnScroll(e);
         }
     }
 }

osu.Framework/Game.cs

···
 
 namespace osu.Framework
 {
-    public abstract class Game : Container, IKeyBindingHandler<FrameworkAction>, IHandleGlobalInput
+    public abstract class Game : Container, IKeyBindingHandler<FrameworkAction>, IHandleGlobalKeyboardInput
     {
         public IWindow Window => Host?.Window;
 

osu.Framework/Graphics/Containers/OverlayContainer.cs

···
 
 using System.Collections.Generic;
 using osu.Framework.Input;
-using osuTK;
+using osu.Framework.Input.Events;
 
 namespace osu.Framework.Graphics.Containers
 {
···
             {
                 // when blocking non-positional input behind us, we still want to make sure the global handlers receive events
                 // but we don't want other drawables behind us handling them.
-                queue.RemoveAll(d => !(d is IHandleGlobalInput));
+                queue.RemoveAll(d => !(d is IHandleGlobalKeyboardInput));
             }
 
             return base.BuildNonPositionalInputQueue(queue, allowBlocking);
         }
 
-        internal override bool BuildPositionalInputQueue(Vector2 screenSpacePos, List<Drawable> queue)
+        protected override bool Handle(UIEvent e)
         {
-            if (PropagatePositionalInputSubTree && HandlePositionalInput && BlockPositionalInput && ReceivePositionalInputAt(screenSpacePos))
+            switch (e)
             {
-                // when blocking positional input behind us, we still want to make sure the global handlers receive events
-                // but we don't want other drawables behind us handling them.
-                queue.RemoveAll(d => !(d is IHandleGlobalInput));
+                case ScrollEvent _:
+                    if (BlockPositionalInput && base.ReceivePositionalInputAt(e.ScreenSpaceMousePosition))
+                        return true;
+
+                    break;
+
+                case MouseEvent _:
+                    if (BlockPositionalInput)
+                        return true;
+
+                    break;
             }
 
-            return base.BuildPositionalInputQueue(screenSpacePos, queue);
+            return base.Handle(e);
         }
     }
 }

osu.Framework/Graphics/Cursor/TooltipContainer.cs

···
     /// <summary>
     /// Displays Tooltips for all its children that inherit from the <see cref="IHasTooltip"/> or <see cref="IHasCustomTooltip"/> interfaces. Keep in mind that only children with <see cref="Drawable.HandlePositionalInput"/> set to true will be checked for their tooltips.
     /// </summary>
-    public class TooltipContainer : CursorEffectContainer<TooltipContainer, ITooltipContentProvider>, IHandleGlobalInput
+    public class TooltipContainer : CursorEffectContainer<TooltipContainer, ITooltipContentProvider>
     {
         private readonly CursorContainer cursorContainer;
         private readonly ITooltip defaultTooltip;

osu.Framework/Graphics/UserInterface/TabControl.cs

···
     /// support for pinning items, causing them to be displayed before all other items at the
     /// start of the list.
     /// </summary>
+    /// <remarks>
+    /// If a multi-line (or vertical) tab control is required, <see cref="TabFillFlowContainer.AllowMultiline"/> must be set to true.
+    /// Without this, <see cref="TabControl{T}"/> will automatically hide extra items.
+    /// </remarks>
     /// <typeparam name="T">The type of item to be represented by tabs.</typeparam>
     public abstract class TabControl<T> : CompositeDrawable, IHasCurrentValue<T>, IKeyBindingHandler<PlatformAction>
     {
···
         {
             private bool allowMultiline;
 
+            /// <summary>
+            /// Whether tabs should be allowed to flow beyond a single line. If set to false, overflowing tabs will be automatically hidden.
+            /// </summary>
             public bool AllowMultiline
             {
                 get => allowMultiline;

osu.Framework/Graphics/Visualisation/DrawVisualiser.cs

···
 namespace osu.Framework.Graphics.Visualisation
 {
     [Cached]
-    internal class DrawVisualiser : OverlayContainer, IContainVisualisedDrawables
+    // Implementing IRequireHighFrequencyMousePosition is necessary to gain the ability to block high frequency mouse position updates.
+    internal class DrawVisualiser : OverlayContainer, IContainVisualisedDrawables, IRequireHighFrequencyMousePosition
     {
         public Vector2 ToolPosition
         {
···
             inputManager = GetContainingInputManager();
         }
 
-        protected override bool BlockPositionalInput => Searching;
+        protected override bool Handle(UIEvent e) => Searching;
 
         protected override void PopIn()
         {

osu.Framework/Input/IHandleGlobalInput.cs osu.Framework/Input/IHandleGlobalKeyboardInput.cs

···
 namespace osu.Framework.Input
 {
     /// <summary>
-    /// Denotes that this class handles input globally.
+    /// Denotes that this class handles keyboard input globally.
     /// </summary>
-    public interface IHandleGlobalInput
+    public interface IHandleGlobalKeyboardInput
     {
     }
 }

osu.Framework/Input/PlatformActionContainer.cs

···
     /// can be created to handle events that should trigger specifically on a focused drawable.
     /// Will send repeat events by default.
     /// </summary>
-    public class PlatformActionContainer : KeyBindingContainer<PlatformAction>, IHandleGlobalInput
+    public class PlatformActionContainer : KeyBindingContainer<PlatformAction>, IHandleGlobalKeyboardInput
     {
         [Resolved]
         private GameHost host { get; set; }

osu.Framework/Testing/TestBrowser.cs

···
 namespace osu.Framework.Testing
 {
     [Cached]
-    public class TestBrowser : KeyBindingContainer<TestBrowserAction>, IKeyBindingHandler<TestBrowserAction>, IHandleGlobalInput
+    public class TestBrowser : KeyBindingContainer<TestBrowserAction>, IKeyBindingHandler<TestBrowserAction>, IHandleGlobalKeyboardInput
     {
         public TestScene CurrentTest { get; private set; }