1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-15 15:12:57 +08:00
osu-lazer/osu.Game/Screens/Select/SongSelect.cs

684 lines
25 KiB
C#
Raw Normal View History

// 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.
2018-04-13 17:19:50 +08:00
using osu.Framework.Allocation;
using osu.Framework.Audio;
using osu.Framework.Audio.Sample;
using osu.Framework.Audio.Track;
2019-02-21 18:04:31 +08:00
using osu.Framework.Bindables;
2018-04-13 17:19:50 +08:00
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
2018-10-02 11:02:47 +08:00
using osu.Framework.Input.Events;
2019-01-05 03:13:32 +08:00
using osu.Framework.Logging;
2018-04-13 17:19:50 +08:00
using osu.Framework.Screens;
using osu.Framework.Threading;
using osu.Game.Beatmaps;
using osu.Game.Graphics;
using osu.Game.Graphics.Containers;
using osu.Game.Input.Bindings;
2018-04-13 17:19:50 +08:00
using osu.Game.Overlays;
2018-12-06 18:29:18 +08:00
using osu.Game.Overlays.Mods;
using osu.Game.Rulesets;
using osu.Game.Rulesets.Mods;
2018-04-13 17:19:50 +08:00
using osu.Game.Screens.Backgrounds;
using osu.Game.Screens.Edit;
using osu.Game.Screens.Menu;
using osu.Game.Screens.Play;
2018-04-13 17:19:50 +08:00
using osu.Game.Screens.Select.Options;
using osu.Game.Skinning;
2019-01-05 03:13:32 +08:00
using osuTK;
using osuTK.Graphics;
2019-01-05 03:13:32 +08:00
using osuTK.Input;
using System;
using System.Collections.Generic;
using System.Linq;
2018-04-13 17:19:50 +08:00
namespace osu.Game.Screens.Select
{
public abstract class SongSelect : OsuScreen
{
private static readonly Vector2 wedged_container_size = new Vector2(0.5f, 245);
private static readonly Vector2 background_blur = new Vector2(20);
private const float left_area_padding = 20;
public readonly FilterControl FilterControl;
protected virtual bool ShowFooter => true;
/// <summary>
/// Can be null if <see cref="ShowFooter"/> is false.
/// </summary>
protected readonly BeatmapOptionsOverlay BeatmapOptions;
/// <summary>
/// Can be null if <see cref="ShowFooter"/> is false.
/// </summary>
protected readonly Footer Footer;
/// <summary>
/// Contains any panel which is triggered by a footer button.
/// Helps keep them located beneath the footer itself.
/// </summary>
protected readonly Container FooterPanels;
protected override BackgroundScreen CreateBackground() => new BackgroundScreenBeatmap();
protected readonly BeatmapCarousel Carousel;
private readonly BeatmapInfoWedge beatmapInfoWedge;
private DialogOverlay dialogOverlay;
private BeatmapManager beatmaps;
2018-12-06 18:29:18 +08:00
protected readonly ModSelectOverlay ModSelect;
protected SampleChannel SampleConfirm;
2018-04-13 17:19:50 +08:00
private SampleChannel sampleChangeDifficulty;
private SampleChannel sampleChangeBeatmap;
protected readonly BeatmapDetailArea BeatmapDetails;
2019-02-01 14:42:15 +08:00
private readonly Bindable<RulesetInfo> decoupledRuleset = new Bindable<RulesetInfo>();
[Cached]
[Cached(Type = typeof(IBindable<IEnumerable<Mod>>))]
protected readonly Bindable<IEnumerable<Mod>> SelectedMods = new Bindable<IEnumerable<Mod>>(new Mod[] { });
2018-04-13 17:19:50 +08:00
protected SongSelect()
{
const float carousel_width = 640;
const float filter_height = 100;
2019-01-23 19:52:00 +08:00
AddRangeInternal(new Drawable[]
2018-04-13 17:19:50 +08:00
{
new ParallaxContainer
{
Padding = new MarginPadding { Top = filter_height },
ParallaxAmount = 0.005f,
RelativeSizeAxes = Axes.Both,
Children = new[]
{
new WedgeBackground
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding { Right = carousel_width * 0.76f },
}
}
},
new Container
2018-04-13 17:19:50 +08:00
{
Origin = Anchor.BottomLeft,
Anchor = Anchor.BottomLeft,
RelativeSizeAxes = Axes.Both,
Size = new Vector2(wedged_container_size.X, 1),
Padding = new MarginPadding
{
Bottom = 50,
Top = wedged_container_size.Y + left_area_padding,
Left = left_area_padding,
Right = left_area_padding * 2,
},
Child = BeatmapDetails = new BeatmapDetailArea
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding { Top = 10, Right = 5 },
2018-04-13 17:19:50 +08:00
}
},
new Container
{
RelativeSizeAxes = Axes.Both,
Masking = true,
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Width = 2, //avoid horizontal masking so the panels don't clip when screen stack is pushed.
Child = new Container
{
RelativeSizeAxes = Axes.Both,
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Width = 0.5f,
Children = new Drawable[]
{
Carousel = new BeatmapCarousel
{
Masking = false,
RelativeSizeAxes = Axes.Y,
Size = new Vector2(carousel_width, 1),
Anchor = Anchor.CentreRight,
Origin = Anchor.CentreRight,
SelectionChanged = updateSelectedBeatmap,
2018-04-13 17:19:50 +08:00
BeatmapSetsChanged = carouselBeatmapsLoaded,
},
FilterControl = new FilterControl
{
RelativeSizeAxes = Axes.X,
Height = filter_height,
FilterChanged = c => Carousel.Filter(c),
Background = { Width = 2 },
Exit = () =>
{
2019-01-23 19:52:00 +08:00
if (this.IsCurrentScreen())
this.Exit();
},
2018-04-13 17:19:50 +08:00
},
}
},
},
beatmapInfoWedge = new BeatmapInfoWedge
{
Size = wedged_container_size,
RelativeSizeAxes = Axes.X,
Margin = new MarginPadding
{
Top = left_area_padding,
Right = left_area_padding,
},
},
2018-04-13 17:19:50 +08:00
new ResetScrollContainer(() => Carousel.ScrollToSelected())
{
RelativeSizeAxes = Axes.Y,
Width = 250,
}
});
if (ShowFooter)
{
2019-01-23 19:52:00 +08:00
AddInternal(FooterPanels = new Container
2018-04-13 17:19:50 +08:00
{
Anchor = Anchor.BottomLeft,
Origin = Anchor.BottomLeft,
RelativeSizeAxes = Axes.X,
AutoSizeAxes = Axes.Y,
Margin = new MarginPadding
{
Bottom = Footer.HEIGHT,
},
});
2019-01-23 19:52:00 +08:00
AddInternal(Footer = new Footer
2018-04-13 17:19:50 +08:00
{
OnBack = ExitFromBack,
2018-04-13 17:19:50 +08:00
});
2018-12-06 18:29:18 +08:00
FooterPanels.AddRange(new Drawable[]
{
BeatmapOptions = new BeatmapOptionsOverlay(),
ModSelect = new ModSelectOverlay
{
RelativeSizeAxes = Axes.X,
Origin = Anchor.BottomCentre,
Anchor = Anchor.BottomCentre,
}
});
2018-04-13 17:19:50 +08:00
}
BeatmapDetails.Leaderboard.ScoreSelected += s => this.Push(new SoloResults(s));
}
[BackgroundDependencyLoader(true)]
private void load(BeatmapManager beatmaps, AudioManager audio, DialogOverlay dialog, OsuColour colours, SkinManager skins, Bindable<IEnumerable<Mod>> selectedMods)
2018-04-13 17:19:50 +08:00
{
if (selectedMods != null)
SelectedMods.BindTo(selectedMods);
2018-04-13 17:19:50 +08:00
if (Footer != null)
{
2018-12-06 18:29:18 +08:00
Footer.AddButton(@"mods", colours.Yellow, ModSelect, Key.F1);
2018-04-13 17:19:50 +08:00
Footer.AddButton(@"random", colours.Green, triggerRandom, Key.F2);
Footer.AddButton(@"options", colours.Blue, BeatmapOptions, Key.F3);
2018-10-10 18:26:35 +08:00
BeatmapOptions.AddButton(@"Delete", @"all difficulties", FontAwesome.fa_trash, colours.Pink, () => delete(Beatmap.Value.BeatmapSetInfo), Key.Number4, float.MaxValue);
BeatmapOptions.AddButton(@"Remove", @"from unplayed", FontAwesome.fa_times_circle_o, colours.Purple, null, Key.Number1);
2019-01-09 00:57:03 +08:00
BeatmapOptions.AddButton(@"Clear", @"local scores", FontAwesome.fa_eraser, colours.Purple, () => clearScores(Beatmap.Value.BeatmapInfo), Key.Number2);
2018-04-13 17:19:50 +08:00
}
if (this.beatmaps == null)
this.beatmaps = beatmaps;
this.beatmaps.ItemAdded += onBeatmapSetAdded;
this.beatmaps.ItemRemoved += onBeatmapSetRemoved;
this.beatmaps.BeatmapHidden += onBeatmapHidden;
this.beatmaps.BeatmapRestored += onBeatmapRestored;
dialogOverlay = dialog;
2018-08-31 06:04:40 +08:00
sampleChangeDifficulty = audio.Sample.Get(@"SongSelect/select-difficulty");
sampleChangeBeatmap = audio.Sample.Get(@"SongSelect/select-expand");
SampleConfirm = audio.Sample.Get(@"SongSelect/confirm-selection");
2018-04-13 17:19:50 +08:00
Carousel.LoadBeatmapSetsFromManager(this.beatmaps);
if (dialogOverlay != null)
{
Schedule(() =>
{
// if we have no beatmaps but osu-stable is found, let's prompt the user to import.
if (!beatmaps.GetAllUsableBeatmapSets().Any() && beatmaps.StableInstallationAvailable)
dialogOverlay.Push(new ImportFromStablePopup(() =>
{
beatmaps.ImportFromStableAsync();
skins.ImportFromStableAsync();
}));
});
}
}
private DependencyContainer dependencies;
protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
{
dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
dependencies.CacheAs(this);
2019-02-01 14:42:15 +08:00
dependencies.CacheAs(decoupledRuleset);
dependencies.CacheAs<IBindable<RulesetInfo>>(decoupledRuleset);
return dependencies;
}
protected virtual void ExitFromBack()
{
if (ModSelect.State == Visibility.Visible)
{
ModSelect.Hide();
return;
}
2019-01-23 19:52:00 +08:00
this.Exit();
}
public void Edit(BeatmapInfo beatmap = null)
2018-04-13 17:19:50 +08:00
{
Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap ?? beatmapNoDebounce);
this.Push(new Editor());
2018-04-13 17:19:50 +08:00
}
/// <summary>
/// Call to make a selection and perform the default action for this SongSelect.
/// </summary>
/// <param name="beatmap">An optional beatmap to override the current carousel selection.</param>
/// <param name="performStartAction">Whether to trigger <see cref="OnStart"/>.</param>
public void FinaliseSelection(BeatmapInfo beatmap = null, bool performStartAction = true)
2018-04-13 17:19:50 +08:00
{
// if we have a pending filter operation, we want to run it now.
// it could change selection (ie. if the ruleset has been changed).
Carousel.FlushPendingFilterOperations();
// avoid attempting to continue before a selection has been obtained.
// this could happen via a user interaction while the carousel is still in a loading state.
if (Carousel.SelectedBeatmap == null) return;
2018-04-13 17:19:50 +08:00
if (beatmap != null)
Carousel.SelectBeatmap(beatmap);
if (selectionChangedDebounce?.Completed == false)
{
selectionChangedDebounce.RunTask();
selectionChangedDebounce.Cancel(); // cancel the already scheduled task.
selectionChangedDebounce = null;
}
if (performStartAction)
OnStart();
2018-04-13 17:19:50 +08:00
}
/// <summary>
/// Called when a selection is made.
/// </summary>
/// <returns>If a resultant action occurred that takes the user away from SongSelect.</returns>
protected abstract bool OnStart();
2018-04-13 17:19:50 +08:00
private ScheduledDelegate selectionChangedDebounce;
2019-02-21 17:56:34 +08:00
private void workingBeatmapChanged(ValueChangedEvent<WorkingBeatmap> e)
2018-04-13 17:19:50 +08:00
{
2019-02-21 17:56:34 +08:00
if (e.NewValue is DummyWorkingBeatmap) return;
2018-04-13 17:19:50 +08:00
2019-02-21 17:56:34 +08:00
if (this.IsCurrentScreen() && !Carousel.SelectBeatmap(e.NewValue?.BeatmapInfo, false))
2018-04-13 17:19:50 +08:00
// If selecting new beatmap without bypassing filters failed, there's possibly a ruleset mismatch
2019-02-21 17:56:34 +08:00
if (e.NewValue?.BeatmapInfo?.Ruleset != null && e.NewValue.BeatmapInfo.Ruleset != decoupledRuleset.Value)
2018-04-13 17:19:50 +08:00
{
2019-02-21 17:56:34 +08:00
Ruleset.Value = e.NewValue.BeatmapInfo.Ruleset;
Carousel.SelectBeatmap(e.NewValue.BeatmapInfo);
2018-04-13 17:19:50 +08:00
}
}
// We need to keep track of the last selected beatmap ignoring debounce to play the correct selection sounds.
private BeatmapInfo beatmapNoDebounce;
private RulesetInfo rulesetNoDebounce;
private void updateSelectedBeatmap(BeatmapInfo beatmap)
{
if (beatmap?.Equals(beatmapNoDebounce) == true)
return;
beatmapNoDebounce = beatmap;
performUpdateSelected();
}
private void updateSelectedRuleset(RulesetInfo ruleset)
{
if (ruleset?.Equals(rulesetNoDebounce) == true)
return;
rulesetNoDebounce = ruleset;
performUpdateSelected();
}
2018-04-13 17:19:50 +08:00
/// <summary>
/// selection has been changed as the result of a user interaction.
2018-04-13 17:19:50 +08:00
/// </summary>
private void performUpdateSelected()
2018-04-13 17:19:50 +08:00
{
var beatmap = beatmapNoDebounce;
var ruleset = rulesetNoDebounce;
void run()
2018-04-13 17:19:50 +08:00
{
Logger.Log($"updating selection with beatmap:{beatmap?.ID.ToString() ?? "null"} ruleset:{ruleset?.ID.ToString() ?? "null"}");
2018-07-19 17:51:08 +08:00
bool preview = false;
2019-02-01 14:42:15 +08:00
if (ruleset?.Equals(decoupledRuleset.Value) == false)
{
2019-02-01 14:42:15 +08:00
Logger.Log($"ruleset changed from \"{decoupledRuleset.Value}\" to \"{ruleset}\"");
Beatmap.Value.Mods.Value = Enumerable.Empty<Mod>();
2019-02-01 14:42:15 +08:00
decoupledRuleset.Value = ruleset;
// force a filter before attempting to change the beatmap.
// we may still be in the wrong ruleset as there is a debounce delay on ruleset changes.
Carousel.Filter(null, false);
// Filtering only completes after the carousel runs Update.
// If we also have a pending beatmap change we should delay it one frame.
selectionChangedDebounce = Schedule(run);
return;
}
2018-04-13 17:19:50 +08:00
// We may be arriving here due to another component changing the bindable Beatmap.
// In these cases, the other component has already loaded the beatmap, so we don't need to do so again.
if (!Equals(beatmap, Beatmap.Value.BeatmapInfo))
2018-04-13 17:19:50 +08:00
{
Logger.Log($"beatmap changed from \"{Beatmap.Value.BeatmapInfo}\" to \"{beatmap}\"");
2018-07-19 17:51:08 +08:00
preview = beatmap?.BeatmapSetInfoID != Beatmap.Value?.BeatmapInfo.BeatmapSetInfoID;
Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap, Beatmap.Value);
if (beatmap != null)
{
if (beatmap.BeatmapSetInfoID == beatmapNoDebounce?.BeatmapSetInfoID)
sampleChangeDifficulty.Play();
else
sampleChangeBeatmap.Play();
}
2018-04-13 17:19:50 +08:00
}
2019-01-23 19:52:00 +08:00
if (this.IsCurrentScreen()) ensurePlayingSelected(preview);
2018-04-13 17:19:50 +08:00
UpdateBeatmap(Beatmap.Value);
}
selectionChangedDebounce?.Cancel();
if (beatmap == null)
run();
2018-04-13 17:19:50 +08:00
else
selectionChangedDebounce = Scheduler.AddDelayed(run, 200);
2018-04-13 17:19:50 +08:00
}
private void triggerRandom()
{
if (GetContainingInputManager().CurrentState.Keyboard.ShiftPressed)
Carousel.SelectPreviousRandom();
else
Carousel.SelectNextRandom();
}
2019-01-23 19:52:00 +08:00
public override void OnEntering(IScreen last)
2018-04-13 17:19:50 +08:00
{
base.OnEntering(last);
2019-01-23 19:52:00 +08:00
this.FadeInFromZero(250);
2018-04-13 17:19:50 +08:00
FilterControl.Activate();
}
private const double logo_transition = 250;
protected override void LogoArriving(OsuLogo logo, bool resuming)
{
base.LogoArriving(logo, resuming);
Vector2 position = new Vector2(0.95f, 0.96f);
if (logo.Alpha > 0.8f)
{
logo.MoveTo(position, 500, Easing.OutQuint);
}
else
{
logo.Hide();
logo.ScaleTo(0.2f);
logo.MoveTo(position);
}
logo.FadeIn(logo_transition, Easing.OutQuint);
logo.ScaleTo(0.4f, logo_transition, Easing.OutQuint);
logo.Action = () =>
{
FinaliseSelection();
return false;
};
}
protected override void LogoExiting(OsuLogo logo)
{
base.LogoExiting(logo);
logo.ScaleTo(0.2f, logo_transition / 2, Easing.Out);
logo.FadeOut(logo_transition / 2, Easing.Out);
}
2019-01-23 19:52:00 +08:00
public override void OnResuming(IScreen last)
2018-04-13 17:19:50 +08:00
{
BeatmapDetails.Leaderboard.RefreshScores();
Beatmap.Value.Track.Looping = true;
2018-04-13 17:19:50 +08:00
if (Beatmap != null && !Beatmap.Value.BeatmapSetInfo.DeletePending)
{
UpdateBeatmap(Beatmap.Value);
2018-04-13 17:19:50 +08:00
ensurePlayingSelected();
}
base.OnResuming(last);
2019-01-23 19:52:00 +08:00
this.FadeIn(250);
2018-04-13 17:19:50 +08:00
2019-01-23 19:52:00 +08:00
this.ScaleTo(1, 250, Easing.OutSine);
2018-04-13 17:19:50 +08:00
FilterControl.Activate();
}
2019-01-23 19:52:00 +08:00
public override void OnSuspending(IScreen next)
2018-04-13 17:19:50 +08:00
{
2018-12-06 18:29:18 +08:00
ModSelect.Hide();
2019-01-23 19:52:00 +08:00
this.ScaleTo(1.1f, 250, Easing.InSine);
2018-04-13 17:19:50 +08:00
2019-01-23 19:52:00 +08:00
this.FadeOut(250);
2018-04-13 17:19:50 +08:00
FilterControl.Deactivate();
base.OnSuspending(next);
}
2019-01-23 19:52:00 +08:00
public override bool OnExiting(IScreen next)
2018-04-13 17:19:50 +08:00
{
if (base.OnExiting(next))
return true;
2018-04-13 17:19:50 +08:00
beatmapInfoWedge.State = Visibility.Hidden;
2019-01-23 19:52:00 +08:00
this.FadeOut(100);
2018-04-13 17:19:50 +08:00
FilterControl.Deactivate();
if (Beatmap.Value.Track != null)
Beatmap.Value.Track.Looping = false;
SelectedMods.UnbindAll();
Beatmap.Value.Mods.Value = new Mod[] { };
return false;
2018-04-13 17:19:50 +08:00
}
protected override void Dispose(bool isDisposing)
{
base.Dispose(isDisposing);
2019-02-01 14:42:15 +08:00
decoupledRuleset.UnbindAll();
2018-04-13 17:19:50 +08:00
if (beatmaps != null)
{
beatmaps.ItemAdded -= onBeatmapSetAdded;
beatmaps.ItemRemoved -= onBeatmapSetRemoved;
beatmaps.BeatmapHidden -= onBeatmapHidden;
beatmaps.BeatmapRestored -= onBeatmapRestored;
}
}
/// <summary>
/// Allow components in SongSelect to update their loaded beatmap details.
/// This is a debounced call (unlike directly binding to WorkingBeatmap.ValueChanged).
/// </summary>
/// <param name="beatmap">The working beatmap.</param>
protected virtual void UpdateBeatmap(WorkingBeatmap beatmap)
{
beatmap.Mods.BindTo(SelectedMods);
2018-07-19 17:51:08 +08:00
Logger.Log($"working beatmap updated to {beatmap}");
2018-04-13 17:19:50 +08:00
if (Background is BackgroundScreenBeatmap backgroundModeBeatmap)
{
backgroundModeBeatmap.Beatmap = beatmap;
backgroundModeBeatmap.BlurTo(background_blur, 750, Easing.OutQuint);
backgroundModeBeatmap.FadeColour(Color4.White, 250);
2018-04-13 17:19:50 +08:00
}
beatmapInfoWedge.Beatmap = beatmap;
BeatmapDetails.Beatmap = beatmap;
if (beatmap.Track != null)
beatmap.Track.Looping = true;
2018-04-13 17:19:50 +08:00
}
private void ensurePlayingSelected(bool preview = false)
{
Track track = Beatmap.Value.Track;
if (!track.IsRunning)
{
// Ensure the track is added to the TrackManager, since it is removed after the player finishes the map.
// Using AddItemToList rather than AddItem so that it doesn't attempt to register adjustment dependencies more than once.
Game.Audio.Track.AddItemToList(track);
if (preview) track.Seek(Beatmap.Value.Metadata.PreviewTime);
track.Start();
}
}
private void onBeatmapSetAdded(BeatmapSetInfo s, bool existing) => Carousel.UpdateBeatmapSet(s);
2018-04-13 17:19:50 +08:00
private void onBeatmapSetRemoved(BeatmapSetInfo s) => Carousel.RemoveBeatmapSet(s);
private void onBeatmapRestored(BeatmapInfo b) => Carousel.UpdateBeatmapSet(beatmaps.QueryBeatmapSet(s => s.ID == b.BeatmapSetInfoID));
private void onBeatmapHidden(BeatmapInfo b) => Carousel.UpdateBeatmapSet(beatmaps.QueryBeatmapSet(s => s.ID == b.BeatmapSetInfoID));
private void carouselBeatmapsLoaded()
{
if (rulesetNoDebounce == null)
{
// manual binding to parent ruleset to allow for delayed load in the incoming direction.
2019-02-01 14:42:15 +08:00
rulesetNoDebounce = decoupledRuleset.Value = Ruleset.Value;
Ruleset.ValueChanged += r => updateSelectedRuleset(r.NewValue);
2019-02-01 14:42:15 +08:00
decoupledRuleset.ValueChanged += r => Ruleset.Value = r.NewValue;
2019-02-01 14:42:15 +08:00
decoupledRuleset.DisabledChanged += r => Ruleset.Disabled = r;
Beatmap.BindDisabledChanged(disabled => Carousel.AllowSelection = !disabled, true);
Beatmap.BindValueChanged(workingBeatmapChanged);
}
if (!Beatmap.IsDefault && Beatmap.Value.BeatmapSetInfo?.DeletePending == false && Beatmap.Value.BeatmapSetInfo?.Protected == false
&& Carousel.SelectBeatmap(Beatmap.Value.BeatmapInfo, false))
2018-04-13 17:19:50 +08:00
return;
if (Carousel.SelectedBeatmapSet == null && !Carousel.SelectNextRandom())
{
// in the case random selection failed, we want to trigger selectionChanged
// to show the dummy beatmap (we have nothing else to display).
performUpdateSelected();
2018-04-13 17:19:50 +08:00
}
}
private void delete(BeatmapSetInfo beatmap)
{
2018-09-21 10:29:37 +08:00
if (beatmap == null || beatmap.ID <= 0) return;
2018-04-13 17:19:50 +08:00
dialogOverlay?.Push(new BeatmapDeleteDialog(beatmap));
}
2019-01-09 00:57:03 +08:00
private void clearScores(BeatmapInfo beatmap)
2019-01-05 03:13:32 +08:00
{
if (beatmap == null || beatmap.ID <= 0) return;
dialogOverlay?.Push(new BeatmapClearScoresDialog(beatmap, () =>
// schedule done here rather than inside the dialog as the dialog may fade out and never callback.
Schedule(() => BeatmapDetails.Leaderboard.RefreshScores())));
2019-01-05 03:13:32 +08:00
}
public override bool OnPressed(GlobalAction action)
{
2019-01-23 19:52:00 +08:00
if (!this.IsCurrentScreen()) return false;
switch (action)
{
case GlobalAction.Select:
FinaliseSelection();
return true;
}
return base.OnPressed(action);
}
2018-10-02 11:02:47 +08:00
protected override bool OnKeyDown(KeyDownEvent e)
2018-04-13 17:19:50 +08:00
{
2018-10-02 11:02:47 +08:00
if (e.Repeat) return false;
2018-04-13 17:19:50 +08:00
2018-10-02 11:02:47 +08:00
switch (e.Key)
2018-04-13 17:19:50 +08:00
{
case Key.Delete:
if (e.ShiftPressed)
2018-04-13 17:19:50 +08:00
{
if (!Beatmap.IsDefault)
delete(Beatmap.Value.BeatmapSetInfo);
return true;
}
break;
}
2018-10-02 11:02:47 +08:00
return base.OnKeyDown(e);
2018-04-13 17:19:50 +08:00
}
private class ResetScrollContainer : Container
{
private readonly Action onHoverAction;
public ResetScrollContainer(Action onHoverAction)
{
this.onHoverAction = onHoverAction;
}
2018-10-02 11:02:47 +08:00
protected override bool OnHover(HoverEvent e)
2018-04-13 17:19:50 +08:00
{
onHoverAction?.Invoke();
2018-10-02 11:02:47 +08:00
return base.OnHover(e);
2018-04-13 17:19:50 +08:00
}
}
}
}