osu/osu.Game.Tests/Visual/UserInterface/TestSceneOverlayContainer.cs at e1bdfdd99c558a8ab13129ab2e7be603b08d65e8 · ppy/osu · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
// 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.Allocation;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Colour;
using osu.Framework.Graphics.Containers;
using osu.Framework.Input.Events;
using osu.Game.Graphics.Containers;
using osu.Game.Graphics.Sprites;
using osu.Game.Overlays.Volume;
using osuTK;
using osuTK.Graphics;
using osuTK.Input;
using Box = osu.Framework.Graphics.Shapes.Box;

namespace osu.Game.Tests.Visual.UserInterface
{
    public partial class TestSceneOverlayContainer : OsuManualInputManagerTestScene
    {
        private TestOverlay createOverlay() => new TestOverlay
        {
            Anchor = Anchor.Centre,
            Origin = Anchor.Centre,
            RelativeSizeAxes = Axes.Both,
            Size = new Vector2(0.5f)
        };

        private void loadOverlay() => Schedule(() => Child = createOverlay());
        private void loadBlockingOverlay() => Schedule(() => Child = createOverlay().With(d =>
        {
            d.Child = new BlockingContainer
            {
                RelativeSizeAxes = Axes.Both,
            };
        }));

        [Test]
        public void TestScrollBlocked()
        {
            OsuScrollContainer scroll = null!;

            AddStep("load overlay", () => loadOverlay());
            AddStep("add scroll container", () =>
            {
                Add(scroll = new OsuScrollContainer
                {
                    RelativeSizeAxes = Axes.Both,
                    Depth = float.MaxValue,
                    Child = new Box
                    {
                        RelativeSizeAxes = Axes.X,
                        Height = DrawHeight * 10,
                        Colour = ColourInfo.GradientVertical(Colour4.Black, Colour4.White),
                    }
                });
            });

            AddStep("perform scroll", () =>
            {
                InputManager.MoveMouseTo(Content);
                InputManager.ScrollVerticalBy(-10);
            });

            AddAssert("scroll didn't receive input", () => scroll.Current == 0);
        }

        [Test]
        public void TestAltScrollNotBlocked()
        {
            TestGlobalAltScrollAdjustsVolume volumeAdjust = null!;

            AddStep("load overlay", () => loadOverlay());
            AddStep("add volume control receptor", () => Add(volumeAdjust = new TestGlobalAltScrollAdjustsVolume
            {
                RelativeSizeAxes = Axes.Both,
                Depth = float.MaxValue,
            }));

            AddStep("hold alt", () => InputManager.PressKey(Key.AltLeft));
            AddStep("perform scroll", () =>
            {
                InputManager.MoveMouseTo(Content);
                InputManager.ScrollVerticalBy(10);
            });

            AddAssert("receptor received scroll input", () => volumeAdjust.ScrollReceived);
            AddStep("release alt", () => InputManager.ReleaseKey(Key.AltLeft));
        }

        [Test]
        public void TestAltScrollBlockedByOptOut()
        {
            TestGlobalAltScrollAdjustsVolume volumeAdjust = null!;

            AddStep("add blocker and receptor", () =>
            {
                Add(volumeAdjust = new TestGlobalAltScrollAdjustsVolume
                {
                    RelativeSizeAxes = Axes.Both,
                    Depth = float.MaxValue,
                });
            });
            AddStep("load blocking overlay", () => loadBlockingOverlay());

            AddStep("hold alt", () => InputManager.PressKey(Key.AltLeft));
            AddStep("perform scroll", () =>
            {
                InputManager.MoveMouseTo(Content);
                InputManager.ScrollVerticalBy(10);
            });

            AddAssert("receptor did not receive scroll input", () => !volumeAdjust.ScrollReceived);
            AddStep("release alt", () => InputManager.ReleaseKey(Key.AltLeft));
        }

        public partial class TestGlobalAltScrollAdjustsVolume : GlobalAltScrollAdjustsVolume
        {
            public bool ScrollReceived { get; private set; }

            protected override bool OnScroll(ScrollEvent e)
            {
                ScrollReceived = true;
                return base.OnScroll(e);
            }
        }

        private partial class BlockingContainer : Container, IBlockGlobalAltScrollVolume
        {
            public BlockingContainer()
            {
            }
        }

        private partial class TestOverlay : OsuFocusedOverlayContainer
        {
            [BackgroundDependencyLoader]
            private void load()
            {
                State.Value = Visibility.Visible;

                Children = new Drawable[]
                {
                    new Box
                    {
                        RelativeSizeAxes = Axes.Both
                    },
                    new OsuSpriteText
                    {
                        Anchor = Anchor.Centre,
                        Origin = Anchor.Centre,
                        Text = "Overlay content",
                        Colour = Color4.Black,
                    },
                };
            }

            protected override void PopIn()
            {
            }
        }
    }
}