1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-16 01:55:37 +08:00
osu-lazer/osu.Game/Screens/Edit/Editor.cs

294 lines
10 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 System;
2018-11-20 15:51:59 +08:00
using osuTK.Graphics;
2018-04-13 17:19:50 +08:00
using osu.Framework.Screens;
using osu.Game.Screens.Backgrounds;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Shapes;
using osu.Game.Graphics;
using osu.Game.Screens.Edit.Components.Timelines.Summary;
using osu.Framework.Allocation;
2019-02-21 18:04:31 +08:00
using osu.Framework.Bindables;
2018-04-13 17:19:50 +08:00
using osu.Framework.Graphics.UserInterface;
2018-10-02 11:02:47 +08:00
using osu.Framework.Input.Events;
2018-06-19 19:19:52 +08:00
using osu.Framework.Platform;
2018-04-13 17:19:50 +08:00
using osu.Framework.Timing;
using osu.Game.Graphics.UserInterface;
using osu.Game.Screens.Edit.Components;
2018-11-06 17:28:22 +08:00
using osu.Game.Screens.Edit.Components.Menus;
2018-11-07 12:04:17 +08:00
using osu.Game.Screens.Edit.Design;
using osuTK.Input;
using System.Collections.Generic;
using osu.Framework;
2019-06-30 18:31:31 +08:00
using osu.Framework.Input.Bindings;
using osu.Game.Input.Bindings;
2019-10-09 15:04:58 +08:00
using osu.Game.Screens.Edit.Compose;
using osu.Game.Screens.Edit.Setup;
using osu.Game.Screens.Edit.Timing;
using osu.Game.Users;
2018-04-13 17:19:50 +08:00
namespace osu.Game.Screens.Edit
{
2019-06-30 18:31:31 +08:00
public class Editor : OsuScreen, IKeyBindingHandler<GlobalAction>
2018-04-13 17:19:50 +08:00
{
protected override BackgroundScreen CreateBackground() => new BackgroundScreenCustom(@"Backgrounds/bg4");
2019-06-25 15:55:49 +08:00
public override bool AllowBackButton => false;
public override bool HideOverlaysOnEnter => true;
2019-02-01 14:42:15 +08:00
public override bool DisallowExternalBeatmapRulesetChanges => true;
2018-04-13 17:19:50 +08:00
private Box bottomBackground;
private Container screenContainer;
private EditorScreen currentScreen;
private readonly BindableBeatDivisor beatDivisor = new BindableBeatDivisor();
private EditorClock clock;
private DependencyContainer dependencies;
2018-06-19 19:19:52 +08:00
private GameHost host;
2018-04-13 17:19:50 +08:00
protected override UserActivity InitialActivity => new UserActivity.Editing(Beatmap.Value.BeatmapInfo);
2018-07-11 16:07:14 +08:00
protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
=> dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
2018-04-13 17:19:50 +08:00
[BackgroundDependencyLoader]
2018-06-19 19:19:52 +08:00
private void load(OsuColour colours, GameHost host)
2018-04-13 17:19:50 +08:00
{
2018-06-19 19:19:52 +08:00
this.host = host;
// TODO: should probably be done at a DrawableRuleset level to share logic with Player.
2018-04-13 17:19:50 +08:00
var sourceClock = (IAdjustableClock)Beatmap.Value.Track ?? new StopwatchClock();
clock = new EditorClock(Beatmap.Value, beatDivisor) { IsCoupled = false };
2018-04-13 17:19:50 +08:00
clock.ChangeSource(sourceClock);
dependencies.CacheAs<IFrameBasedClock>(clock);
dependencies.CacheAs<IAdjustableClock>(clock);
dependencies.Cache(beatDivisor);
EditorMenuBar menuBar;
var fileMenuItems = new List<MenuItem>();
2019-04-01 11:16:05 +08:00
if (RuntimeInfo.IsDesktop)
{
fileMenuItems.Add(new EditorMenuItem("Export", MenuItemType.Standard, exportBeatmap));
fileMenuItems.Add(new EditorMenuItemSpacer());
}
2019-02-28 17:58:52 +08:00
fileMenuItems.Add(new EditorMenuItem("Exit", MenuItemType.Standard, this.Exit));
2019-01-23 19:52:00 +08:00
InternalChildren = new[]
2018-04-13 17:19:50 +08:00
{
new Container
{
Name = "Screen container",
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding { Top = 40, Bottom = 60 },
Child = screenContainer = new Container
{
RelativeSizeAxes = Axes.Both,
Masking = true
}
},
new Container
{
Name = "Top bar",
RelativeSizeAxes = Axes.X,
Height = 40,
Child = menuBar = new EditorMenuBar
{
Anchor = Anchor.CentreLeft,
Origin = Anchor.CentreLeft,
RelativeSizeAxes = Axes.Both,
Items = new[]
{
new MenuItem("File")
{
Items = fileMenuItems
2018-04-13 17:19:50 +08:00
}
}
}
},
new Container
{
Name = "Bottom bar",
Anchor = Anchor.BottomLeft,
Origin = Anchor.BottomLeft,
RelativeSizeAxes = Axes.X,
Height = 60,
Children = new Drawable[]
{
bottomBackground = new Box { RelativeSizeAxes = Axes.Both },
new Container
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding { Vertical = 5, Horizontal = 10 },
Child = new GridContainer
{
RelativeSizeAxes = Axes.Both,
ColumnDimensions = new[]
{
new Dimension(GridSizeMode.Absolute, 220),
new Dimension(),
new Dimension(GridSizeMode.Absolute, 220)
},
Content = new[]
{
new Drawable[]
{
new Container
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding { Right = 10 },
Child = new TimeInfoContainer { RelativeSizeAxes = Axes.Both },
2018-04-13 17:19:50 +08:00
},
new SummaryTimeline
2018-04-13 17:19:50 +08:00
{
RelativeSizeAxes = Axes.Both,
},
new Container
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding { Left = 10 },
Child = new PlaybackControl { RelativeSizeAxes = Axes.Both },
2018-04-13 17:19:50 +08:00
}
},
}
},
}
}
},
};
menuBar.Mode.ValueChanged += onModeChanged;
bottomBackground.Colour = colours.Gray2;
}
protected override bool OnKeyDown(KeyDownEvent e)
2018-04-13 17:19:50 +08:00
{
switch (e.Key)
2018-04-13 17:19:50 +08:00
{
case Key.Left:
seek(e, -1);
return true;
2019-04-01 11:16:05 +08:00
case Key.Right:
seek(e, 1);
return true;
2018-04-13 17:19:50 +08:00
}
return base.OnKeyDown(e);
2018-04-13 17:19:50 +08:00
}
private double scrollAccumulation;
2018-10-02 11:02:47 +08:00
protected override bool OnScroll(ScrollEvent e)
2018-04-13 17:19:50 +08:00
{
scrollAccumulation += (e.ScrollDelta.X + e.ScrollDelta.Y) * (e.IsPrecise ? 0.1 : 1);
const int precision = 1;
while (Math.Abs(scrollAccumulation) > precision)
{
if (scrollAccumulation > 0)
seek(e, -1);
else
seek(e, 1);
scrollAccumulation = scrollAccumulation < 0 ? Math.Min(0, scrollAccumulation + precision) : Math.Max(0, scrollAccumulation - precision);
}
2018-04-13 17:19:50 +08:00
return true;
}
2019-06-30 18:31:31 +08:00
public bool OnPressed(GlobalAction action)
{
if (action == GlobalAction.Back)
{
// as we don't want to display the back button, manual handling of exit action is required.
2019-06-30 18:31:31 +08:00
this.Exit();
return true;
}
return false;
}
public bool OnReleased(GlobalAction action) => action == GlobalAction.Back;
2019-01-23 19:52:00 +08:00
public override void OnResuming(IScreen last)
2018-04-13 17:19:50 +08:00
{
base.OnResuming(last);
2019-07-10 23:22:40 +08:00
Beatmap.Value.Track?.Stop();
2018-04-13 17:19:50 +08:00
}
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-07-10 23:22:40 +08:00
2018-04-13 17:19:50 +08:00
Background.FadeColour(Color4.DarkGray, 500);
2019-07-10 23:22:40 +08:00
resetTrack();
2018-04-13 17:19:50 +08:00
}
2019-01-23 19:52:00 +08:00
public override bool OnExiting(IScreen next)
2018-04-13 17:19:50 +08:00
{
Background.FadeColour(Color4.White, 500);
2019-07-10 23:22:40 +08:00
resetTrack();
2019-07-10 16:43:02 +08:00
2018-04-13 17:19:50 +08:00
return base.OnExiting(next);
}
2019-07-10 23:22:40 +08:00
private void resetTrack()
{
Beatmap.Value.Track?.ResetSpeedAdjustments();
Beatmap.Value.Track?.Stop();
}
private void exportBeatmap() => host.OpenFileExternally(Beatmap.Value.Save());
2019-02-21 17:56:34 +08:00
private void onModeChanged(ValueChangedEvent<EditorScreenMode> e)
{
currentScreen?.Exit();
2019-02-21 17:56:34 +08:00
switch (e.NewValue)
{
case EditorScreenMode.SongSetup:
currentScreen = new SetupScreen();
break;
case EditorScreenMode.Compose:
currentScreen = new ComposeScreen();
break;
2019-04-01 11:16:05 +08:00
case EditorScreenMode.Design:
currentScreen = new DesignScreen();
break;
2019-04-01 11:16:05 +08:00
case EditorScreenMode.Timing:
currentScreen = new TimingScreen();
break;
}
LoadComponentAsync(currentScreen, screenContainer.Add);
}
private void seek(UIEvent e, int direction)
{
double amount = e.ShiftPressed ? 2 : 1;
if (direction < 1)
clock.SeekBackward(!clock.IsRunning, amount);
else
clock.SeekForward(!clock.IsRunning, amount);
}
2018-04-13 17:19:50 +08:00
}
}