Merge branch 'master' into spun-out

osu.Game.Tests/Visual/UserInterface/TestSceneBeatmapListingSearchSection.cs

@@ -0,0 +1,90 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Overlays;
+using osu.Game.Overlays.BeatmapListing;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneBeatmapListingSearchSection : OsuTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(BeatmapListingSearchSection),
+        };
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
+
+        private readonly BeatmapListingSearchSection section;
+
+        public TestSceneBeatmapListingSearchSection()
+        {
+            OsuSpriteText query;
+            OsuSpriteText ruleset;
+            OsuSpriteText category;
+
+            Add(section = new BeatmapListingSearchSection
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+
+            Add(new FillFlowContainer
+            {
+                AutoSizeAxes = Axes.Both,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0, 5),
+                Children = new Drawable[]
+                {
+                    query = new OsuSpriteText(),
+                    ruleset = new OsuSpriteText(),
+                    category = new OsuSpriteText(),
+                }
+            });
+
+            section.Query.BindValueChanged(q => query.Text = $"Query: {q.NewValue}", true);
+            section.Ruleset.BindValueChanged(r => ruleset.Text = $"Ruleset: {r.NewValue}", true);
+            section.Category.BindValueChanged(c => category.Text = $"Category: {c.NewValue}", true);
+        }
+
+        [Test]
+        public void TestCovers()
+        {
+            AddStep("Set beatmap", () => section.BeatmapSet = beatmap_set);
+            AddStep("Set beatmap (no cover)", () => section.BeatmapSet = no_cover_beatmap_set);
+            AddStep("Set null beatmap", () => section.BeatmapSet = null);
+        }
+
+        private static readonly BeatmapSetInfo beatmap_set = new BeatmapSetInfo
+        {
+            OnlineInfo = new BeatmapSetOnlineInfo
+            {
+                Covers = new BeatmapSetOnlineCovers
+                {
+                    Cover = "https://assets.ppy.sh/beatmaps/1094296/covers/cover@2x.jpg?1581416305"
+                }
+            }
+        };
+
+        private static readonly BeatmapSetInfo no_cover_beatmap_set = new BeatmapSetInfo
+        {
+            OnlineInfo = new BeatmapSetOnlineInfo
+            {
+                Covers = new BeatmapSetOnlineCovers
+                {
+                    Cover = string.Empty
+                }
+            }
+        };
+    }
+}

osu.Game.Tests/Visual/UserInterface/TestSceneBeatmapListingSort.cs

@@ -0,0 +1,55 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Overlays;
+using osu.Game.Overlays.BeatmapListing;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneBeatmapListingSort : OsuTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(BeatmapListingSortTabControl),
+            typeof(OverlaySortTabControl<>),
+        };
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
+
+        public TestSceneBeatmapListingSort()
+        {
+            BeatmapListingSortTabControl control;
+            OsuSpriteText current;
+            OsuSpriteText direction;
+
+            Add(control = new BeatmapListingSortTabControl
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+
+            Add(new FillFlowContainer
+            {
+                AutoSizeAxes = Axes.Both,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0, 5),
+                Children = new Drawable[]
+                {
+                    current = new OsuSpriteText(),
+                    direction = new OsuSpriteText()
+                }
+            });
+
+            control.SortDirection.BindValueChanged(sortDirection => direction.Text = $"Sort direction: {sortDirection.NewValue}", true);
+            control.Current.BindValueChanged(criteria => current.Text = $"Criteria: {criteria.NewValue}", true);
+        }
+    }
+}

osu.Game.Tests/Visual/UserInterface/TestSceneBeatmapSearchFilter.cs

@@ -0,0 +1,58 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics.Containers;
+using osu.Game.Online.API.Requests;
+using osu.Game.Overlays;
+using osu.Game.Overlays.BeatmapListing;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneBeatmapSearchFilter : OsuTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(BeatmapSearchFilterRow<>),
+            typeof(BeatmapSearchRulesetFilterRow),
+            typeof(BeatmapSearchSmallFilterRow<>),
+        };
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
+
+        private readonly ReverseChildIDFillFlowContainer<Drawable> resizableContainer;
+
+        public TestSceneBeatmapSearchFilter()
+        {
+            Add(resizableContainer = new ReverseChildIDFillFlowContainer<Drawable>
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AutoSizeAxes = Axes.Y,
+                RelativeSizeAxes = Axes.X,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0, 10),
+                Children = new Drawable[]
+                {
+                    new BeatmapSearchRulesetFilterRow(),
+                    new BeatmapSearchFilterRow<BeatmapSearchCategory>("Categories"),
+                    new BeatmapSearchSmallFilterRow<BeatmapSearchCategory>("Header Name")
+                }
+            });
+        }
+
+        [Test]
+        public void TestResize()
+        {
+            AddStep("Resize to 0.3", () => resizableContainer.ResizeWidthTo(0.3f, 1000));
+            AddStep("Resize to 1", () => resizableContainer.ResizeWidthTo(1, 1000));
+        }
+    }
+}

osu.Game.Tests/Visual/UserInterface/TestSceneCommentEditor.cs

@@ -0,0 +1,157 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Comments;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneCommentEditor : ManualInputManagerTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(CommentEditor),
+            typeof(CancellableCommentEditor),
+        };
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
+
+        private TestCommentEditor commentEditor;
+        private TestCancellableCommentEditor cancellableCommentEditor;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+            Add(new FillFlowContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AutoSizeAxes = Axes.Y,
+                Width = 800,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0, 20),
+                Children = new Drawable[]
+                {
+                    commentEditor = new TestCommentEditor(),
+                    cancellableCommentEditor = new TestCancellableCommentEditor()
+                }
+            }));
+
+        [Test]
+        public void TestCommitViaKeyboard()
+        {
+            AddStep("click on text box", () =>
+            {
+                InputManager.MoveMouseTo(commentEditor);
+                InputManager.Click(MouseButton.Left);
+            });
+            AddStep("enter text", () => commentEditor.Current.Value = "text");
+
+            AddStep("press Enter", () => press(Key.Enter));
+
+            AddAssert("text committed", () => commentEditor.CommittedText == "text");
+            AddAssert("button is loading", () => commentEditor.IsLoading);
+        }
+
+        [Test]
+        public void TestCommitViaKeyboardWhenEmpty()
+        {
+            AddStep("click on text box", () =>
+            {
+                InputManager.MoveMouseTo(commentEditor);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddStep("press Enter", () => press(Key.Enter));
+
+            AddAssert("no text committed", () => commentEditor.CommittedText == null);
+            AddAssert("button is not loading", () => !commentEditor.IsLoading);
+        }
+
+        [Test]
+        public void TestCommitViaButton()
+        {
+            AddStep("click on text box", () =>
+            {
+                InputManager.MoveMouseTo(commentEditor);
+                InputManager.Click(MouseButton.Left);
+            });
+            AddStep("enter text", () => commentEditor.Current.Value = "some other text");
+
+            AddStep("click submit", () =>
+            {
+                InputManager.MoveMouseTo(commentEditor.ButtonsContainer);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("text committed", () => commentEditor.CommittedText == "some other text");
+            AddAssert("button is loading", () => commentEditor.IsLoading);
+        }
+
+        [Test]
+        public void TestCancelAction()
+        {
+            AddStep("click cancel button", () =>
+            {
+                InputManager.MoveMouseTo(cancellableCommentEditor.ButtonsContainer);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("cancel action fired", () => cancellableCommentEditor.Cancelled);
+        }
+
+        private void press(Key key)
+        {
+            InputManager.PressKey(key);
+            InputManager.ReleaseKey(key);
+        }
+
+        private class TestCommentEditor : CommentEditor
+        {
+            public new Bindable<string> Current => base.Current;
+            public new FillFlowContainer ButtonsContainer => base.ButtonsContainer;
+
+            public string CommittedText { get; private set; }
+
+            public TestCommentEditor()
+            {
+                OnCommit = onCommit;
+            }
+
+            private void onCommit(string value)
+            {
+                CommittedText = value;
+                Scheduler.AddDelayed(() => IsLoading = false, 1000);
+            }
+
+            protected override string FooterText => @"Footer text. And it is pretty long. Cool.";
+            protected override string CommitButtonText => @"Commit";
+            protected override string TextBoxPlaceholder => @"This text box is empty";
+        }
+
+        private class TestCancellableCommentEditor : CancellableCommentEditor
+        {
+            public new FillFlowContainer ButtonsContainer => base.ButtonsContainer;
+            protected override string FooterText => @"Wow, another one. Sicc";
+
+            public bool Cancelled { get; private set; }
+
+            public TestCancellableCommentEditor()
+            {
+                OnCancel = () => Cancelled = true;
+            }
+
+            protected override string CommitButtonText => @"Save";
+            protected override string TextBoxPlaceholder => @"Multiline textboxes soon";
+        }
+    }
+}

osu.Game.Tests/Visual/UserInterface/TestSceneLoadingLayer.cs

@@ -0,0 +1,106 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneLoadingLayer : OsuTestScene
+    {
+        private Drawable dimContent;
+        private LoadingLayer overlay;
+
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(LoadingSpinner) };
+
+        private Container content;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            Children = new[]
+            {
+                content = new Container
+                {
+                    Size = new Vector2(300),
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Children = new[]
+                    {
+                        new Box
+                        {
+                            Colour = Color4.SlateGray,
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        dimContent = new FillFlowContainer
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Direction = FillDirection.Vertical,
+                            Spacing = new Vector2(10),
+                            RelativeSizeAxes = Axes.Both,
+                            Size = new Vector2(0.9f),
+                            Children = new Drawable[]
+                            {
+                                new OsuSpriteText { Text = "Sample content" },
+                                new TriangleButton { Text = "can't puush me", Width = 200, },
+                                new TriangleButton { Text = "puush me", Width = 200, Action = () => { } },
+                            }
+                        },
+                        overlay = new LoadingLayer(dimContent),
+                    }
+                },
+            };
+        });
+
+        [Test]
+        public void TestShowHide()
+        {
+            AddAssert("not visible", () => !overlay.IsPresent);
+
+            AddStep("show", () => overlay.Show());
+
+            AddUntilStep("wait for content dim", () => dimContent.Colour != Color4.White);
+
+            AddStep("hide", () => overlay.Hide());
+
+            AddUntilStep("wait for content restore", () => dimContent.Colour == Color4.White);
+        }
+
+        [Test]
+        public void TestContentRestoreOnDispose()
+        {
+            AddAssert("not visible", () => !overlay.IsPresent);
+
+            AddStep("show", () => overlay.Show());
+
+            AddUntilStep("wait for content dim", () => dimContent.Colour != Color4.White);
+
+            AddStep("expire", () => overlay.Expire());
+
+            AddUntilStep("wait for content restore", () => dimContent.Colour == Color4.White);
+        }
+
+        [Test]
+        public void TestLargeArea()
+        {
+            AddStep("show", () =>
+            {
+                content.RelativeSizeAxes = Axes.Both;
+                content.Size = new Vector2(1);
+
+                overlay.Show();
+            });
+
+            AddStep("hide", () => overlay.Hide());
+        }
+    }
+}

osu.Game.Tests/Visual/UserInterface/TestSceneLoadingSpinner.cs

@@ -8,12 +8,12 @@ using osuTK.Graphics;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
-    public class TestSceneLoadingAnimation : OsuGridTestScene
+    public class TestSceneLoadingSpinner : OsuGridTestScene
     {
-        public TestSceneLoadingAnimation()
+        public TestSceneLoadingSpinner()
             : base(2, 2)
         {
-            LoadingAnimation loading;
+            LoadingSpinner loading;
 
             Cell(0).AddRange(new Drawable[]
             {
@@ -22,7 +22,7 @@ namespace osu.Game.Tests.Visual.UserInterface
                     Colour = Color4.Black,
                     RelativeSizeAxes = Axes.Both
                 },
-                loading = new LoadingAnimation()
+                loading = new LoadingSpinner()
             });
 
             loading.Show();
@@ -34,7 +34,7 @@ namespace osu.Game.Tests.Visual.UserInterface
                     Colour = Color4.White,
                     RelativeSizeAxes = Axes.Both
                 },
-                loading = new LoadingAnimation()
+                loading = new LoadingSpinner(true)
             });
 
             loading.Show();
@@ -46,14 +46,14 @@ namespace osu.Game.Tests.Visual.UserInterface
                     Colour = Color4.Gray,
                     RelativeSizeAxes = Axes.Both
                 },
-                loading = new LoadingAnimation()
+                loading = new LoadingSpinner()
             });
 
             loading.Show();
 
             Cell(3).AddRange(new Drawable[]
             {
-                loading = new LoadingAnimation()
+                loading = new LoadingSpinner()
             });
 
             Scheduler.AddDelayed(() => loading.ToggleVisibility(), 200, true);

osu.Game.Tests/Visual/UserInterface/TestSceneModDisplay.cs

@@ -0,0 +1,40 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Screens.Play.HUD;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneModDisplay : OsuTestScene
+    {
+        [TestCase(ExpansionMode.ExpandOnHover)]
+        [TestCase(ExpansionMode.AlwaysExpanded)]
+        [TestCase(ExpansionMode.AlwaysContracted)]
+        public void TestMode(ExpansionMode mode)
+        {
+            AddStep("create mod display", () =>
+            {
+                Child = new ModDisplay
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    ExpansionMode = mode,
+                    Current =
+                    {
+                        Value = new Mod[]
+                        {
+                            new OsuModHardRock(),
+                            new OsuModDoubleTime(),
+                            new OsuModDifficultyAdjust(),
+                            new OsuModEasy(),
+                        }
+                    }
+                };
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/UserInterface/TestSceneModSettings.cs

@@ -38,8 +38,8 @@ namespace osu.Game.Tests.Visual.UserInterface
         public void TestButtonShowsOnCustomisableMod()
         {
             createModSelect();
+            openModSelect();
 
-            AddStep("open", () => modSelect.Show());
             AddAssert("button disabled", () => !modSelect.CustomiseButton.Enabled.Value);
             AddUntilStep("wait for button load", () => modSelect.ButtonsLoaded);
             AddStep("select mod", () => modSelect.SelectMod(testCustomisableMod));
@@ -58,19 +58,21 @@ namespace osu.Game.Tests.Visual.UserInterface
 
             AddAssert("mods still active", () => SelectedMods.Value.Count == 1);
 
-            AddStep("open", () => modSelect.Show());
+            openModSelect();
             AddAssert("button enabled", () => modSelect.CustomiseButton.Enabled.Value);
         }
 
         [Test]
-        public void TestCustomisationOpensOnModSelect()
+        public void TestCustomisationMenuVisibility()
         {
             createModSelect();
+            openModSelect();
 
-            AddStep("open", () => modSelect.Show());
             AddAssert("Customisation closed", () => modSelect.ModSettingsContainer.Alpha == 0);
             AddStep("select mod", () => modSelect.SelectMod(testCustomisableAutoOpenMod));
             AddAssert("Customisation opened", () => modSelect.ModSettingsContainer.Alpha == 1);
+            AddStep("deselect mod", () => modSelect.SelectMod(testCustomisableAutoOpenMod));
+            AddAssert("Customisation closed", () => modSelect.ModSettingsContainer.Alpha == 0);
         }
 
         private void createModSelect()
@@ -86,6 +88,12 @@ namespace osu.Game.Tests.Visual.UserInterface
             });
         }
 
+        private void openModSelect()
+        {
+            AddStep("open", () => modSelect.Show());
+            AddUntilStep("wait for ready", () => modSelect.State.Value == Visibility.Visible && modSelect.ButtonsLoaded);
+        }
+
         private class TestModSelectOverlay : ModSelectOverlay
         {
             public new Container ModSettingsContainer => base.ModSettingsContainer;

osu.Game.Tests/Visual/UserInterface/TestSceneUserListToolbar.cs

@@ -0,0 +1,57 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Home.Friends;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneUserListToolbar : OsuTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(UserSortTabControl),
+            typeof(OverlaySortTabControl<>),
+            typeof(OverlayPanelDisplayStyleControl),
+            typeof(UserListToolbar),
+        };
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Purple);
+
+        public TestSceneUserListToolbar()
+        {
+            UserListToolbar toolbar;
+            OsuSpriteText sort;
+            OsuSpriteText displayStyle;
+
+            Add(toolbar = new UserListToolbar
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+
+            Add(new FillFlowContainer
+            {
+                AutoSizeAxes = Axes.Both,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0, 5),
+                Children = new Drawable[]
+                {
+                    sort = new OsuSpriteText(),
+                    displayStyle = new OsuSpriteText()
+                }
+            });
+
+            toolbar.SortCriteria.BindValueChanged(criteria => sort.Text = $"Criteria: {criteria.NewValue}", true);
+            toolbar.DisplayStyle.BindValueChanged(style => displayStyle.Text = $"Style: {style.NewValue}", true);
+        }
+    }
+}