Merge branch 'master' of github.com:ppy/osu into better-song-select

osu-framework

@@ -1 +1 @@
-Subproject commit f839a542eed0508c2e7eeb9ba86b5c7ba0620652
+Subproject commit 1d43e1ed56421fbbefdf6c23dab8deeeaa0f592a

osu.Game.Tests/Beatmaps/IO/ImportBeatmapTest.cs

@@ -35,19 +35,20 @@ namespace osu.Game.Tests.Beatmaps.IO
         public void TestImportWhenClosed()
         {
             //unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            HeadlessGameHost host = new HeadlessGameHost();
+            using (HeadlessGameHost host = new HeadlessGameHost())
-
+            {
                 var osu = loadOsu(host);
                 osu.Dependencies.Get<BeatmapDatabase>().Import(osz_path);
                 ensureLoaded(osu);
             }
+        }
 
         [Test]
         public void TestImportOverIPC()
         {
-            HeadlessGameHost host = new HeadlessGameHost("host", true);
+            using (HeadlessGameHost host = new HeadlessGameHost("host", true))
-            HeadlessGameHost client = new HeadlessGameHost("client", true);
+            using (HeadlessGameHost client = new HeadlessGameHost("client", true))
-
+            {
                 Assert.IsTrue(host.IsPrimaryInstance);
                 Assert.IsTrue(!client.IsPrimaryInstance);
 
@@ -59,6 +60,7 @@ namespace osu.Game.Tests.Beatmaps.IO
 
                 ensureLoaded(osu, 10000);
             }
+        }
 
         private OsuGameBase loadOsu(BasicGameHost host)
         {

osu.Game/Beatmaps/Drawable/BeatmapGroup.cs

@@ -26,12 +26,12 @@ namespace osu.Game.Beatmaps.Drawable
         /// </summary>
         public Action<BeatmapGroup, BeatmapInfo> SelectionChanged;
 
-        private BeatmapSetInfo beatmapSet;
         public BeatmapSetHeader Header;
 
         private BeatmapGroupState state;
 
         public List<BeatmapPanel> BeatmapPanels;
+        private WorkingBeatmap beatmap;
 
         public BeatmapGroupState State
         {
@@ -65,11 +65,11 @@ namespace osu.Game.Beatmaps.Drawable
             }
         }
 
-        public BeatmapGroup(BeatmapSetInfo beatmapSet, WorkingBeatmap working)
+        public BeatmapGroup(WorkingBeatmap beatmap)
         {
-            this.beatmapSet = beatmapSet;
+            this.beatmap = beatmap;
 
-            Header = new BeatmapSetHeader(beatmapSet, working)
+            Header = new BeatmapSetHeader(beatmap)
             {
                 GainedSelection = headerGainedSelection,
                 RelativeSizeAxes = Axes.X,
@@ -77,7 +77,7 @@ namespace osu.Game.Beatmaps.Drawable
                 Origin = Anchor.TopRight,
             };
 
-            BeatmapPanels = beatmapSet.Beatmaps.Select(b => new BeatmapPanel(b)
+            BeatmapPanels = beatmap.BeatmapSetInfo.Beatmaps.Select(b => new BeatmapPanel(b)
             {
                 GainedSelection = panelGainedSelection,
                 Anchor = Anchor.TopRight,

osu.Game/Beatmaps/Drawable/BeatmapSetHeader.cs

@@ -14,29 +14,71 @@ using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Game.Configuration;
 using osu.Framework.Graphics.Colour;
+using osu.Framework;
 
 namespace osu.Game.Beatmaps.Drawable
 {
     class BeatmapSetHeader : Panel
     {
         public Action<BeatmapSetHeader> GainedSelection;
-        private BeatmapSetInfo beatmapSet;
         private SpriteText title, artist;
         private OsuConfigManager config;
         private Bindable<bool> preferUnicode;
+        private WorkingBeatmap beatmap;
+
+        public BeatmapSetHeader(WorkingBeatmap beatmap)
+        {
+            this.beatmap = beatmap;
+
+            Children = new Framework.Graphics.Drawable[]
+            {
+                new PanelBackground(beatmap)
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new FlowContainer
+                {
+                    Direction = FlowDirection.VerticalOnly,
+                    Padding = new MarginPadding { Top = 5, Left = 18, Right = 10, Bottom = 10 },
+                    AutoSizeAxes = Axes.Both,
+                    Children = new[]
+                    {
+                        title = new SpriteText
+                        {
+                            Font = @"Exo2.0-BoldItalic",
+                            Text = beatmap.BeatmapSetInfo.Metadata.Title,
+                            TextSize = 22,
+                            Shadow = true,
+                        },
+                        artist = new SpriteText
+                        {
+                            Margin = new MarginPadding { Top = -1 },
+                            Font = @"Exo2.0-SemiBoldItalic",
+                            Text = beatmap.BeatmapSetInfo.Metadata.Artist,
+                            TextSize = 17,
+                            Shadow = true,
+                        },
+                        new FlowContainer
+                        {
+                            Margin = new MarginPadding { Top = 5 },
+                            AutoSizeAxes = Axes.Both,
+                            Children = new[]
+                            {
+                                new DifficultyIcon(FontAwesome.fa_dot_circle_o, new Color4(159, 198, 0, 255)),
+                                new DifficultyIcon(FontAwesome.fa_dot_circle_o, new Color4(246, 101, 166, 255)),
+                            }
+                        }
+                    }
+                }
+            };
+        }
 
         protected override void Selected()
         {
             base.Selected();
-            
             GainedSelection?.Invoke(this);
         }
 
-        protected override void Deselected()
-        {
-            base.Deselected();
-        }
-
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config)
         {
@@ -48,8 +90,8 @@ namespace osu.Game.Beatmaps.Drawable
         }
 
        private void preferUnicode_changed(object sender, EventArgs e)
         {
-            title.Text = config.GetUnicodeString(beatmapSet.Metadata.Title, beatmapSet.Metadata.TitleUnicode);
+            title.Text = config.GetUnicodeString(beatmap.BeatmapSetInfo.Metadata.Title, beatmap.BeatmapSetInfo.Metadata.TitleUnicode);
-            artist.Text = config.GetUnicodeString(beatmapSet.Metadata.Artist, beatmapSet.Metadata.ArtistUnicode);
+            artist.Text = config.GetUnicodeString(beatmap.BeatmapSetInfo.Metadata.Artist, beatmap.BeatmapSetInfo.Metadata.ArtistUnicode);
         }
 
         protected override void Dispose(bool isDisposing)
@@ -59,26 +101,21 @@ namespace osu.Game.Beatmaps.Drawable
             base.Dispose(isDisposing);
         }
 
-        public BeatmapSetHeader(BeatmapSetInfo beatmapSet, WorkingBeatmap working)
+        class PanelBackground : BufferedContainer
         {
-            this.beatmapSet = beatmapSet;
+            private readonly WorkingBeatmap working;
-            Children = new Framework.Graphics.Drawable[]
+
+            public PanelBackground(WorkingBeatmap working)
             {
-                new BufferedContainer
+                this.working = working;
+
+                CacheDrawnFrameBuffer = true;
+
+                Children = new[]
                 {
-                    CacheDrawnFrameBuffer = true,
-                    RelativeSizeAxes = Axes.Both,
-                    Children = new Framework.Graphics.Drawable[]
-                    {
-                        working.Background == null ? new Box{ RelativeSizeAxes = Axes.Both, Colour = new Color4(200, 200, 200, 255) } : new Sprite
-                        {
-                            Texture = working.Background,
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
-                            Scale = new Vector2(1366 / working.Background.Width * 0.6f),
-                        },
                     new FlowContainer
                     {
+                        Depth = 1,
                         Direction = FlowDirection.HorizontalOnly,
                         RelativeSizeAxes = Axes.Both,
                         // This makes the gradient not be perfectly horizontal, but diagonal at a ~40° angle
@@ -114,43 +151,45 @@ namespace osu.Game.Beatmaps.Drawable
                             },
                         }
                     },
-                    }
-                },
-                new FlowContainer
-                {
-                    Direction = FlowDirection.VerticalOnly,
-                    Padding = new MarginPadding { Top = 5, Left = 18, Right = 10, Bottom = 10 },
-                    AutoSizeAxes = Axes.Both,
-                    Children = new[]
-                    {
-                        title = new SpriteText
-                        {
-                            Font = @"Exo2.0-BoldItalic",
-                            Text = beatmapSet.Metadata.Title,
-                            TextSize = 22,
-                            Shadow = true,
-                        },
-                        artist = new SpriteText
-                        {
-                            Margin = new MarginPadding { Top = -1 },
-                            Font = @"Exo2.0-SemiBoldItalic",
-                            Text = beatmapSet.Metadata.Artist,
-                            TextSize = 17,
-                            Shadow = true,
-                        },
-                        new FlowContainer
-                        {
-                            Margin = new MarginPadding { Top = 5 },
-                            AutoSizeAxes = Axes.Both,
-                            Children = new[]
-                            {
-                                new DifficultyIcon(FontAwesome.fa_dot_circle_o, new Color4(159, 198, 0, 255)),
-                                new DifficultyIcon(FontAwesome.fa_dot_circle_o, new Color4(246, 101, 166, 255)),
-                            }
-                        }
-                    }
-                }
                 };
             }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuGameBase game)
+            {
+                //todo: masking check
+                new BeatmapBackground(working)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                }.Preload(game, (bg) =>
+                {
+                    Add(bg);
+                    ForceRedraw();
+                });
+            }
+
+            class BeatmapBackground : Sprite
+            {
+                private readonly WorkingBeatmap working;
+
+                public BeatmapBackground(WorkingBeatmap working)
+                {
+                    this.working = working;
+                }
+
+                [BackgroundDependencyLoader]
+                private void load(OsuGameBase game)
+                {
+                    Texture = working.Background;
+                }
+
+                protected override void LoadComplete()
+                {
+                    base.LoadComplete();
+                    Scale = new Vector2(1366 / (Texture?.Width ?? 1) * 0.6f);
+                }
+            }
+        }
     }
 }

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -18,7 +18,7 @@ namespace osu.Game.Beatmaps
         public readonly BeatmapSetInfo BeatmapSetInfo;
         private readonly BeatmapDatabase database;
 
-        private ArchiveReader reader => database?.GetReader(BeatmapSetInfo);
+        private ArchiveReader GetReader() => database?.GetReader(BeatmapSetInfo);
 
         private Texture background;
         private object backgroundLock = new object();
@@ -32,7 +32,8 @@ namespace osu.Game.Beatmaps
 
                     try
                     {
-                        background = new TextureStore(new RawTextureLoaderStore(reader)).Get(BeatmapInfo.Metadata.BackgroundFile);
+                        using (var reader = GetReader())
+                            background = new TextureStore(new RawTextureLoaderStore(reader), false).Get(BeatmapInfo.Metadata.BackgroundFile);
                     }
                     catch { }
 
@@ -54,6 +55,7 @@ namespace osu.Game.Beatmaps
 
                     try
                     {
+                        using (var reader = GetReader())
                         using (var stream = new StreamReader(reader.GetStream(BeatmapInfo.Path)))
                             beatmap = BeatmapDecoder.GetDecoder(stream)?.Decode(stream);
                     }
@@ -76,11 +78,14 @@ namespace osu.Game.Beatmaps
                     if (track != null) return track;
 
                     try
+                    {
+                        using (var reader = GetReader())
                         {
                             var trackData = reader?.GetStream(BeatmapInfo.Metadata.AudioFile);
                             if (trackData != null)
                                 track = new AudioTrackBass(trackData);
                         }
+                    }
                     catch { }
 
                     return track;
@@ -89,6 +94,8 @@ namespace osu.Game.Beatmaps
             set { lock (trackLock) track = value; }
         }
 
+        public bool TrackLoaded => track != null;
+
         public WorkingBeatmap(Beatmap beatmap)
         {
             this.beatmap = beatmap;
@@ -108,7 +115,7 @@ namespace osu.Game.Beatmaps
             if (!isDisposed)
             {
                 track?.Dispose();
-                reader?.Dispose();
+                background?.Dispose();
                 isDisposed = true;
             }
         }
@@ -116,6 +123,7 @@ namespace osu.Game.Beatmaps
         public void Dispose()
         {
             Dispose(true);
+            GC.SuppressFinalize(this);
         }
 
         public void TransferTo(WorkingBeatmap working)

osu.Game/Database/BeatmapDatabase.cs

@@ -136,7 +136,7 @@ namespace osu.Game.Database
 
         public BeatmapSetInfo GetBeatmapSet(int id)
         {
-            return Query<BeatmapSetInfo>().Where(s => s.BeatmapSetID == id).FirstOrDefault();
+            return Query<BeatmapSetInfo>().FirstOrDefault(s => s.BeatmapSetID == id);
         }
 
         public WorkingBeatmap GetWorkingBeatmap(BeatmapInfo beatmapInfo, WorkingBeatmap previous = null)
@@ -144,7 +144,7 @@ namespace osu.Game.Database
             var beatmapSetInfo = Query<BeatmapSetInfo>().FirstOrDefault(s => s.BeatmapSetID == beatmapInfo.BeatmapSetID);
 
             //we need metadata
-            GetChildren(beatmapSetInfo);
+            GetChildren(beatmapSetInfo, false);
 
             if (beatmapSetInfo == null)
                 throw new InvalidOperationException($@"Beatmap set {beatmapInfo.BeatmapSetID} is not in the local database.");
@@ -175,10 +175,10 @@ namespace osu.Game.Database
             return connection.GetWithChildren<T>(id);
         }
 
-        public List<T> GetAllWithChildren<T>(Expression<Func<T, bool>> filter = null,
+        public List<T> GetAllWithChildren<T>(Expression<Func<T, bool>> filter = null, bool recursive = true)
-            bool recursive = true) where T : class
+            where T : class
         {
-            return connection.GetAllWithChildren<T>(filter, recursive);
+            return connection.GetAllWithChildren(filter, recursive);
         }
 
         public T GetChildren<T>(T item, bool recursive = true)
@@ -199,7 +199,7 @@ namespace osu.Game.Database
 
         public void Update<T>(T record, bool cascade = true) where T : class
         {
-            if (!validTypes.Any(t => t == typeof(T)))
+            if (validTypes.All(t => t != typeof(T)))
                 throw new ArgumentException(nameof(T), "Must be a type managed by BeatmapDatabase");
             if (cascade)
                 connection.UpdateWithChildren(record);

osu.Game/Graphics/UserInterface/Volume/VolumeMeter.cs

@@ -75,7 +75,7 @@ namespace osu.Game.Graphics.UserInterface.Volume
 
         protected override bool OnWheel(InputState state)
         {
-            Volume += 0.05f * state.Mouse.WheelDiff;
+            Volume += 0.05f * state.Mouse.WheelDelta;
             return true;
         }
 

osu.Game/Overlays/MusicController.cs

@@ -34,7 +34,6 @@ namespace osu.Game.Overlays
         private DragBar progress;
         private TextAwesome playButton, listButton;
         private SpriteText title, artist;
-        private Texture fallbackTexture;
 
         private List<BeatmapSetInfo> playList;
         private List<BeatmapInfo> playHistory = new List<BeatmapInfo>();
@@ -47,6 +46,7 @@ namespace osu.Game.Overlays
         private OsuConfigManager config;
         private WorkingBeatmap current;
         private BeatmapDatabase beatmaps;
+        private BaseGame game;
 
         public MusicController()
         {
@@ -208,7 +208,7 @@ namespace osu.Game.Overlays
             beatmapSource = osuGame.Beatmap ?? new Bindable<WorkingBeatmap>();
             playList = beatmaps.GetAllWithChildren<BeatmapSetInfo>();
 
-            backgroundSprite = new MusicControllerBackground(fallbackTexture = textures.Get(@"Backgrounds/bg4"));
+            backgroundSprite = new MusicControllerBackground();
             AddInternal(backgroundSprite);
         }
 
@@ -222,13 +222,16 @@ namespace osu.Game.Overlays
         protected override void Update()
         {
             base.Update();
-            if (current?.Track == null) return;
+
+            if (current?.TrackLoaded ?? false)
+            {
 
                 progress.UpdatePosition((float)(current.Track.CurrentTime / current.Track.Length));
                 playButton.Icon = current.Track.IsRunning ? FontAwesome.fa_pause_circle_o : FontAwesome.fa_play_circle_o;
 
                 if (current.Track.HasCompleted && !current.Track.Looping) next();
             }
+        }
 
         void preferUnicode_changed(object sender, EventArgs e)
         {
@@ -304,7 +307,15 @@ namespace osu.Game.Overlays
             updateDisplay(current, isNext ? TransformDirection.Next : TransformDirection.Prev);
         }
 
+        protected override void PerformLoad(BaseGame game)
+        {
+            this.game = game;
+            base.PerformLoad(game);
+        }
+
         private void updateDisplay(WorkingBeatmap beatmap, TransformDirection direction)
+        {
+            Task.Run(() =>
             {
                 if (beatmap.Beatmap == null)
                     //todo: we may need to display some default text here (currently in the constructor).
@@ -313,8 +324,12 @@ namespace osu.Game.Overlays
                 BeatmapMetadata metadata = beatmap.Beatmap.BeatmapInfo.Metadata;
                 title.Text = config.GetUnicodeString(metadata.Title, metadata.TitleUnicode);
                 artist.Text = config.GetUnicodeString(metadata.Artist, metadata.ArtistUnicode);
+            });
 
-            MusicControllerBackground newBackground = new MusicControllerBackground(beatmap.Background ?? fallbackTexture);
+            MusicControllerBackground newBackground;
+
+            (newBackground = new MusicControllerBackground(beatmap)).Preload(game, delegate
+            {
 
                 Add(newBackground);
 
@@ -334,6 +349,7 @@ namespace osu.Game.Overlays
 
                 backgroundSprite.Expire();
                 backgroundSprite = newBackground;
+            });
         }
 
         private void seek(float position)
@@ -363,9 +379,11 @@ namespace osu.Game.Overlays
         private class MusicControllerBackground : BufferedContainer
         {
             private Sprite sprite;
+            private WorkingBeatmap beatmap;
 
-            public MusicControllerBackground(Texture backgroundTexture)
+            public MusicControllerBackground(WorkingBeatmap beatmap = null)
             {
+                this.beatmap = beatmap;
                 CacheDrawnFrameBuffer = true;
                 RelativeSizeAxes = Axes.Both;
                 Depth = float.MinValue;
@@ -374,7 +392,6 @@ namespace osu.Game.Overlays
                 {
                     sprite = new Sprite
                     {
-                        Texture = backgroundTexture,
                         Colour = new Color4(150, 150, 150, 255)
                     },
                     new Box
@@ -388,6 +405,12 @@ namespace osu.Game.Overlays
                 };
             }
 
+            [BackgroundDependencyLoader]
+            private void load(TextureStore textures)
+            {
+                sprite.Texture = beatmap?.Background ?? textures.Get(@"Backgrounds/bg4");
+            }
+
             protected override void LoadComplete()
             {
                 base.LoadComplete();

osu.Game/Screens/Backgrounds/BackgroundModeBeatmap.cs

@@ -1,9 +1,8 @@
 //Copyright (c) 2007-2016 ppy Pty Ltd <contact@ppy.sh>.
 //Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Allocation;
 using OpenTK;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Transformations;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.Background;
@@ -15,6 +14,7 @@ namespace osu.Game.Screens.Backgrounds
         private Background background;
 
         private WorkingBeatmap beatmap;
+        private Vector2 blurTarget;
 
         public WorkingBeatmap Beatmap
         {
@@ -30,10 +30,16 @@ namespace osu.Game.Screens.Backgrounds
 
                 beatmap = value;
 
+                Schedule(() =>
+                {
+                    Background newBackground = new BeatmapBackground(beatmap);
+
+                    newBackground.Preload(Game, delegate
+                    {
                         Background oldBackground = background;
 
-                addBackground(background = new Background());
+                        Add(background = newBackground);
-                background.Sprite.Texture = beatmap.Background;
+                        background.BlurSigma = blurTarget;
 
                         if (oldBackground != null)
                         {
@@ -41,9 +47,9 @@ namespace osu.Game.Screens.Backgrounds
                             oldBackground.Flush();
                             oldBackground.FadeOut(250);
                             oldBackground.Expire();
-
-                    background.BlurSigma = oldBackground.BlurSigma;
                         }
+                    });
+                });
             }
         }
 
@@ -52,20 +58,33 @@ namespace osu.Game.Screens.Backgrounds
             Beatmap = beatmap;
         }
 
-        private void addBackground(Background background)
-        {
-            background.CacheDrawnFrameBuffer = true;
-            Add(background);
-        }
-
         public void BlurTo(Vector2 sigma, double duration)
         {
             background?.BlurTo(sigma, duration, EasingTypes.OutExpo);
+            blurTarget = sigma;
         }
 
         public override bool Equals(BackgroundMode other)
         {
             return base.Equals(other) && beatmap == ((BackgroundModeBeatmap)other).Beatmap;
         }
+
+        class BeatmapBackground : Background
+        {
+            private WorkingBeatmap beatmap;
+
+            public BeatmapBackground(WorkingBeatmap beatmap)
+            {
+                this.beatmap = beatmap;
+                CacheDrawnFrameBuffer = true;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Sprite.Texture = beatmap.Background;
+            }
+
+        }
     }
 }

osu.Game/Screens/Play/Player.cs

@@ -125,9 +125,9 @@ namespace osu.Game.Screens.Play
             {
             }
 
-            protected override void UpdateMouseState(InputState state)
+            protected override void TransformState(InputState state)
             {
-                base.UpdateMouseState(state);
+                base.TransformState(state);
 
                 MouseState mouse = (MouseState)state.Mouse;
 

osu.Game/Screens/Select/PlaySongSelect.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
@@ -44,6 +45,7 @@ namespace osu.Game.Screens.Select
         private Container wedgedBeatmapInfo;
 
         private static readonly Vector2 BACKGROUND_BLUR = new Vector2(20);
+        private CancellationTokenSource initialAddSetsTask;
 
         /// <param name="database">Optionally provide a database to use instead of the OsuGame one.</param>
         public PlaySongSelect(BeatmapDatabase database = null)
@@ -153,11 +155,18 @@ namespace osu.Game.Screens.Select
             if (database == null)
                 database = beatmaps;
 
-            database.BeatmapSetAdded += s => Schedule(() => addBeatmapSet(s, game));
+            database.BeatmapSetAdded += onDatabaseOnBeatmapSetAdded;
 
             trackManager = audio.Track;
 
-            Task.Factory.StartNew(() => addBeatmapSets(game));
+            initialAddSetsTask = new CancellationTokenSource();
+
+            Task.Factory.StartNew(() => addBeatmapSets(game, initialAddSetsTask.Token), initialAddSetsTask.Token);
+        }
+
+        private void onDatabaseOnBeatmapSetAdded(BeatmapSetInfo s)
+        {
+            Schedule(() => addBeatmapSet(s, Game));
         }
 
         protected override void OnEntering(GameMode last)
@@ -196,6 +205,10 @@ namespace osu.Game.Screens.Select
             base.Dispose(isDisposing);
             if (playMode != null)
                 playMode.ValueChanged -= playMode_ValueChanged;
+
+            database.BeatmapSetAdded -= onDatabaseOnBeatmapSetAdded;
+
+            initialAddSetsTask.Cancel();
         }
 
         private void playMode_ValueChanged(object sender, EventArgs e)
@@ -215,6 +228,7 @@ namespace osu.Game.Screens.Select
                 (Background as BackgroundModeBeatmap)?.BlurTo(BACKGROUND_BLUR, 1000);
             }
 
+            //todo: move to own class and fix async logic (move every call on WorkingBeatmap.* to load() and use Preload to create it.
             refreshWedgedBeatmapInfo(beatmap);
         }
 
@@ -329,6 +343,7 @@ namespace osu.Game.Screens.Select
         {
             base.OnBeatmapChanged(beatmap);
 
+            //todo: change background in selectionChanged instead; support per-difficulty backgrounds.
             changeBackground(beatmap);
 
             selectBeatmap(beatmap.BeatmapInfo);
@@ -372,9 +387,9 @@ namespace osu.Game.Screens.Select
             beatmapSet.Beatmaps.ForEach(b => database.GetChildren(b));
             beatmapSet.Beatmaps = beatmapSet.Beatmaps.OrderBy(b => b.BaseDifficulty.OverallDifficulty).ToList();
 
-            var working = database.GetWorkingBeatmap(beatmapSet.Beatmaps.FirstOrDefault());
+            var beatmap = database.GetWorkingBeatmap(beatmapSet.Beatmaps.FirstOrDefault());
 
-            var group = new BeatmapGroup(beatmapSet, working) { SelectionChanged = selectionChanged };
+            var group = new BeatmapGroup(beatmap) { SelectionChanged = selectionChanged };
 
             //for the time being, let's completely load the difficulty panels in the background.
             //this likely won't scale so well, but allows us to completely async the loading flow.
@@ -393,10 +408,13 @@ namespace osu.Game.Screens.Select
             }));
         }
 
-        private void addBeatmapSets(BaseGame game)
+        private void addBeatmapSets(BaseGame game, CancellationToken token)
         {
             foreach (var beatmapSet in database.Query<BeatmapSetInfo>())
+            {
+                if (token.IsCancellationRequested) return;
                 addBeatmapSet(beatmapSet, game);
             }
         }
     }
+}