mirror of
https://github.com/space-wizards/RobustToolbox.git
synced 2026-02-15 03:30:53 +01:00
1079 lines
35 KiB
C#
1079 lines
35 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using Robust.Client.Graphics;
|
|
using Robust.Client.Input;
|
|
using Robust.Client.Player;
|
|
using Robust.Client.State;
|
|
using Robust.Client.UserInterface.Controls;
|
|
using Robust.Client.UserInterface.CustomControls;
|
|
using Robust.Shared;
|
|
using Robust.Shared.Configuration;
|
|
using Robust.Shared.Input;
|
|
using Robust.Shared.Input.Binding;
|
|
using Robust.Shared.IoC;
|
|
using Robust.Shared.Map;
|
|
using Robust.Shared.Maths;
|
|
using Robust.Shared.Network;
|
|
using Robust.Shared.Profiling;
|
|
using Robust.Shared.Timing;
|
|
using Robust.Shared.ViewVariables;
|
|
|
|
namespace Robust.Client.UserInterface
|
|
{
|
|
internal sealed class UserInterfaceManager : IUserInterfaceManagerInternal
|
|
{
|
|
[Dependency] private readonly IInputManager _inputManager = default!;
|
|
[Dependency] private readonly IFontManager _fontManager = default!;
|
|
[Dependency] private readonly IClydeInternal _clyde = default!;
|
|
[Dependency] private readonly IGameTiming _gameTiming = default!;
|
|
[Dependency] private readonly IPlayerManager _playerManager = default!;
|
|
[Dependency] private readonly IEyeManager _eyeManager = default!;
|
|
[Dependency] private readonly IStateManager _stateManager = default!;
|
|
[Dependency] private readonly IClientNetManager _netManager = default!;
|
|
[Dependency] private readonly IMapManager _mapManager = default!;
|
|
[Dependency] private readonly IConfigurationManager _configurationManager = default!;
|
|
[Dependency] private readonly ProfManager _prof = default!;
|
|
|
|
[ViewVariables] public UITheme ThemeDefaults { get; private set; } = default!;
|
|
|
|
[ViewVariables]
|
|
public Stylesheet? Stylesheet
|
|
{
|
|
get => _stylesheet;
|
|
set
|
|
{
|
|
_stylesheet = value;
|
|
|
|
foreach (var root in _roots)
|
|
{
|
|
if (root.Stylesheet != null)
|
|
{
|
|
root.StylesheetUpdateRecursive();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[ViewVariables] public Control? KeyboardFocused { get; private set; }
|
|
|
|
private Control? _controlFocused;
|
|
[ViewVariables]
|
|
public Control? ControlFocused
|
|
{
|
|
get => _controlFocused;
|
|
set
|
|
{
|
|
if (_controlFocused == value)
|
|
return;
|
|
_controlFocused?.ControlFocusExited();
|
|
_controlFocused = value;
|
|
}
|
|
}
|
|
|
|
[ViewVariables] public ViewportContainer MainViewport { get; private set; } = default!;
|
|
[ViewVariables] public LayoutContainer StateRoot { get; private set; } = default!;
|
|
[ViewVariables] public PopupContainer ModalRoot { get; private set; } = default!;
|
|
[ViewVariables] public Control? CurrentlyHovered { get; private set; } = default!;
|
|
[ViewVariables] public float DefaultUIScale => _clyde.DefaultWindowScale.X;
|
|
[ViewVariables] public WindowRoot RootControl { get; private set; } = default!;
|
|
[ViewVariables] public LayoutContainer WindowRoot { get; private set; } = default!;
|
|
[ViewVariables] public LayoutContainer PopupRoot { get; private set; } = default!;
|
|
[ViewVariables] public DropDownDebugConsole DebugConsole { get; private set; } = default!;
|
|
[ViewVariables] public IDebugMonitors DebugMonitors => _debugMonitors;
|
|
private DebugMonitors _debugMonitors = default!;
|
|
|
|
private readonly List<Control> _modalStack = new();
|
|
|
|
private bool _rendering = true;
|
|
|
|
private float _tooltipTimer;
|
|
|
|
// set to null when not counting down
|
|
private float? _tooltipDelay;
|
|
private Tooltip _tooltip = default!;
|
|
private bool showingTooltip;
|
|
private Control? _suppliedTooltip;
|
|
private const float TooltipDelay = 1;
|
|
|
|
private readonly Queue<Control> _styleUpdateQueue = new();
|
|
private readonly Queue<Control> _measureUpdateQueue = new();
|
|
private readonly Queue<Control> _arrangeUpdateQueue = new();
|
|
private Stylesheet? _stylesheet;
|
|
private ICursor? _worldCursor;
|
|
private bool _needUpdateActiveCursor;
|
|
|
|
private readonly List<WindowRoot> _roots = new();
|
|
private readonly Dictionary<WindowId, WindowRoot> _windowsToRoot = new();
|
|
|
|
public void Initialize()
|
|
{
|
|
_configurationManager.OnValueChanged(CVars.DisplayUIScale, _uiScaleChanged, true);
|
|
|
|
ThemeDefaults = new UIThemeDummy();
|
|
|
|
_initializeCommon();
|
|
|
|
DebugConsole = new DropDownDebugConsole();
|
|
RootControl.AddChild(DebugConsole);
|
|
|
|
_debugMonitors = new DebugMonitors(_gameTiming, _playerManager, _eyeManager, _inputManager, _stateManager,
|
|
_clyde, _netManager, _mapManager);
|
|
DebugConsole.BelowConsole.AddChild(_debugMonitors);
|
|
|
|
_inputManager.SetInputCommand(EngineKeyFunctions.ShowDebugConsole,
|
|
InputCmdHandler.FromDelegate(session => DebugConsole.Toggle()));
|
|
|
|
_inputManager.SetInputCommand(EngineKeyFunctions.ShowDebugMonitors,
|
|
InputCmdHandler.FromDelegate(enabled: session => { DebugMonitors.Visible = true; },
|
|
disabled: session => { DebugMonitors.Visible = false; }));
|
|
|
|
_inputManager.SetInputCommand(EngineKeyFunctions.HideUI,
|
|
InputCmdHandler.FromDelegate(
|
|
enabled: session => _rendering = false,
|
|
disabled: session => _rendering = true));
|
|
|
|
_inputManager.UIKeyBindStateChanged += OnUIKeyBindStateChanged;
|
|
|
|
_uiScaleChanged(_configurationManager.GetCVar(CVars.DisplayUIScale));
|
|
}
|
|
|
|
private void _initializeCommon()
|
|
{
|
|
RootControl = CreateWindowRoot(_clyde.MainWindow);
|
|
RootControl.Name = "MainWindowRoot";
|
|
|
|
_clyde.OnWindowResized += WindowSizeChanged;
|
|
_clyde.OnWindowScaleChanged += WindowContentScaleChanged;
|
|
_clyde.DestroyWindow += WindowDestroyed;
|
|
|
|
MainViewport = new MainViewportContainer(_eyeManager)
|
|
{
|
|
Name = "MainViewport"
|
|
};
|
|
RootControl.AddChild(MainViewport);
|
|
|
|
StateRoot = new LayoutContainer
|
|
{
|
|
Name = "StateRoot",
|
|
MouseFilter = Control.MouseFilterMode.Ignore
|
|
};
|
|
RootControl.AddChild(StateRoot);
|
|
|
|
WindowRoot = new LayoutContainer
|
|
{
|
|
Name = "WindowRoot",
|
|
MouseFilter = Control.MouseFilterMode.Ignore
|
|
};
|
|
RootControl.AddChild(WindowRoot);
|
|
|
|
ModalRoot = new PopupContainer
|
|
{
|
|
Name = "ModalRoot",
|
|
MouseFilter = Control.MouseFilterMode.Ignore,
|
|
};
|
|
RootControl.AddChild(ModalRoot);
|
|
|
|
PopupRoot = new LayoutContainer
|
|
{
|
|
Name = "PopupRoot",
|
|
MouseFilter = Control.MouseFilterMode.Ignore
|
|
};
|
|
RootControl.AddChild(PopupRoot);
|
|
|
|
_tooltip = new Tooltip();
|
|
PopupRoot.AddChild(_tooltip);
|
|
_tooltip.Visible = false;
|
|
}
|
|
|
|
public void InitializeTesting()
|
|
{
|
|
ThemeDefaults = new UIThemeDummy();
|
|
|
|
_initializeCommon();
|
|
}
|
|
|
|
public WindowRoot CreateWindowRoot(IClydeWindow window)
|
|
{
|
|
if (_windowsToRoot.ContainsKey(window.Id))
|
|
{
|
|
throw new ArgumentException("Window already has a UI root.");
|
|
}
|
|
|
|
var newRoot = new WindowRoot(window)
|
|
{
|
|
MouseFilter = Control.MouseFilterMode.Ignore,
|
|
HorizontalAlignment = Control.HAlignment.Stretch,
|
|
VerticalAlignment = Control.VAlignment.Stretch,
|
|
UIScaleSet = window.ContentScale.X
|
|
};
|
|
|
|
_roots.Add(newRoot);
|
|
_windowsToRoot.Add(window.Id, newRoot);
|
|
|
|
newRoot.StyleSheetUpdate();
|
|
newRoot.InvalidateMeasure();
|
|
QueueMeasureUpdate(newRoot);
|
|
|
|
return newRoot;
|
|
}
|
|
|
|
public void DestroyWindowRoot(IClydeWindow window)
|
|
{
|
|
// Destroy window root if this window had one.
|
|
if (!_windowsToRoot.TryGetValue(window.Id, out var root))
|
|
return;
|
|
|
|
_windowsToRoot.Remove(window.Id);
|
|
_roots.Remove(root);
|
|
|
|
root.RemoveAllChildren();
|
|
}
|
|
|
|
public WindowRoot? GetWindowRoot(IClydeWindow window)
|
|
{
|
|
return !_windowsToRoot.TryGetValue(window.Id, out var root) ? null : root;
|
|
}
|
|
|
|
public IEnumerable<UIRoot> AllRoots => _roots;
|
|
public event Action<PostDrawUIRootEventArgs>? OnPostDrawUIRoot;
|
|
|
|
private void WindowDestroyed(WindowDestroyedEventArgs args)
|
|
{
|
|
DestroyWindowRoot(args.Window);
|
|
}
|
|
|
|
public void FrameUpdate(FrameEventArgs args)
|
|
{
|
|
// Process queued style & layout updates.
|
|
using (_prof.Group("Style"))
|
|
{
|
|
var total = 0;
|
|
while (_styleUpdateQueue.Count != 0)
|
|
{
|
|
var control = _styleUpdateQueue.Dequeue();
|
|
|
|
if (control.Disposed)
|
|
continue;
|
|
|
|
control.DoStyleUpdate();
|
|
total += 1;
|
|
}
|
|
|
|
_prof.WriteValue("Total", ProfData.Int32(total));
|
|
}
|
|
|
|
using (_prof.Group("Measure"))
|
|
{
|
|
var total = 0;
|
|
while (_measureUpdateQueue.Count != 0)
|
|
{
|
|
var control = _measureUpdateQueue.Dequeue();
|
|
|
|
if (control.Disposed)
|
|
continue;
|
|
|
|
RunMeasure(control);
|
|
total += 1;
|
|
}
|
|
|
|
_prof.WriteValue("Total", ProfData.Int32(total));
|
|
}
|
|
|
|
using (_prof.Group("Arrange"))
|
|
{
|
|
var total = 0;
|
|
while (_arrangeUpdateQueue.Count != 0)
|
|
{
|
|
var control = _arrangeUpdateQueue.Dequeue();
|
|
|
|
if (control.Disposed)
|
|
continue;
|
|
|
|
RunArrange(control);
|
|
total += 1;
|
|
}
|
|
|
|
_prof.WriteValue("Total", ProfData.Int32(total));
|
|
}
|
|
|
|
using (_prof.Group("Update"))
|
|
{
|
|
foreach (var root in _roots)
|
|
{
|
|
using (_prof.Group("Root"))
|
|
{
|
|
var totalUpdated = root.DoFrameUpdateRecursive(args);
|
|
|
|
_prof.WriteValue("Total", ProfData.Int32(totalUpdated));
|
|
}
|
|
}
|
|
}
|
|
|
|
// count down tooltip delay if we're not showing one yet and
|
|
// are hovering the mouse over a control without moving it
|
|
if (_tooltipDelay != null && !showingTooltip)
|
|
{
|
|
_tooltipTimer += args.DeltaSeconds;
|
|
if (_tooltipTimer >= _tooltipDelay)
|
|
{
|
|
_showTooltip();
|
|
}
|
|
}
|
|
|
|
if (_needUpdateActiveCursor)
|
|
{
|
|
_needUpdateActiveCursor = false;
|
|
UpdateActiveCursor();
|
|
}
|
|
}
|
|
|
|
private void RunMeasure(Control control)
|
|
{
|
|
if (control.IsMeasureValid || !control.IsInsideTree)
|
|
return;
|
|
|
|
if (control.Parent != null)
|
|
{
|
|
RunMeasure(control.Parent);
|
|
}
|
|
|
|
if (control is WindowRoot root)
|
|
{
|
|
control.Measure(root.Window.RenderTarget.Size / root.UIScale);
|
|
}
|
|
else if (control.PreviousMeasure.HasValue)
|
|
{
|
|
control.Measure(control.PreviousMeasure.Value);
|
|
}
|
|
}
|
|
|
|
private void RunArrange(Control control)
|
|
{
|
|
if (control.IsArrangeValid || !control.IsInsideTree)
|
|
return;
|
|
|
|
if (control.Parent != null)
|
|
{
|
|
RunArrange(control.Parent);
|
|
}
|
|
|
|
if (control is WindowRoot root)
|
|
{
|
|
control.Arrange(UIBox2.FromDimensions(Vector2.Zero, root.Window.RenderTarget.Size / root.UIScale));
|
|
}
|
|
else if (control.PreviousArrange.HasValue)
|
|
{
|
|
control.Arrange(control.PreviousArrange.Value);
|
|
}
|
|
}
|
|
|
|
public bool HandleCanFocusDown(
|
|
ScreenCoordinates pointerPosition,
|
|
[NotNullWhen(true)] out (Control control, Vector2i rel)? hitData)
|
|
{
|
|
var hit = MouseGetControlAndRel(pointerPosition);
|
|
var pos = pointerPosition.Position;
|
|
|
|
// If we have a modal open and the mouse down was outside it, close said modal.
|
|
while (_modalStack.Count != 0)
|
|
{
|
|
var top = _modalStack[^1];
|
|
var offset = pos - top.GlobalPixelPosition;
|
|
if (!top.HasPoint(offset / top.UIScale))
|
|
{
|
|
if (top.MouseFilter != Control.MouseFilterMode.Stop)
|
|
RemoveModal(top);
|
|
else
|
|
{
|
|
ControlFocused = top;
|
|
hitData = null;
|
|
return false; // prevent anything besides the top modal control from receiving input
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
if (hit == null)
|
|
{
|
|
ReleaseKeyboardFocus();
|
|
hitData = null;
|
|
return false;
|
|
}
|
|
|
|
var (control, rel) = hit.Value;
|
|
|
|
if (control != KeyboardFocused)
|
|
{
|
|
ReleaseKeyboardFocus();
|
|
}
|
|
|
|
ControlFocused = control;
|
|
|
|
if (ControlFocused.CanKeyboardFocus && ControlFocused.KeyboardFocusOnClick)
|
|
{
|
|
ControlFocused.GrabKeyboardFocus();
|
|
}
|
|
|
|
hitData = (control, (Vector2i) rel);
|
|
return true;
|
|
}
|
|
|
|
public void HandleCanFocusUp()
|
|
{
|
|
ControlFocused = null;
|
|
}
|
|
|
|
public void KeyBindDown(BoundKeyEventArgs args)
|
|
{
|
|
if (args.Function == EngineKeyFunctions.CloseModals && _modalStack.Count != 0)
|
|
{
|
|
while (_modalStack.Count > 0)
|
|
{
|
|
var top = _modalStack[^1];
|
|
RemoveModal(top);
|
|
}
|
|
|
|
args.Handle();
|
|
return;
|
|
}
|
|
|
|
var control = ControlFocused ?? KeyboardFocused ?? MouseGetControl(args.PointerLocation);
|
|
|
|
if (control == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var guiArgs = new GUIBoundKeyEventArgs(args.Function, args.State, args.PointerLocation, args.CanFocus,
|
|
args.PointerLocation.Position / control.UIScale - control.GlobalPosition,
|
|
args.PointerLocation.Position - control.GlobalPixelPosition);
|
|
|
|
_doGuiInput(control, guiArgs, (c, ev) => c.KeyBindDown(ev));
|
|
|
|
if (guiArgs.Handled)
|
|
{
|
|
args.Handle();
|
|
}
|
|
}
|
|
|
|
public void KeyBindUp(BoundKeyEventArgs args)
|
|
{
|
|
var control = ControlFocused ?? KeyboardFocused ?? MouseGetControl(args.PointerLocation);
|
|
if (control == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var guiArgs = new GUIBoundKeyEventArgs(args.Function, args.State, args.PointerLocation, args.CanFocus,
|
|
args.PointerLocation.Position / control.UIScale - control.GlobalPosition,
|
|
args.PointerLocation.Position - control.GlobalPixelPosition);
|
|
|
|
_doGuiInput(control, guiArgs, (c, ev) => c.KeyBindUp(ev));
|
|
|
|
// Always mark this as handled.
|
|
// The only case it should not be is if we do not have a control to click on,
|
|
// in which case we never reach this.
|
|
args.Handle();
|
|
}
|
|
|
|
public void MouseMove(MouseMoveEventArgs mouseMoveEventArgs)
|
|
{
|
|
_resetTooltipTimer();
|
|
// Update which control is considered hovered.
|
|
var newHovered = MouseGetControl(mouseMoveEventArgs.Position);
|
|
if (newHovered != CurrentlyHovered)
|
|
{
|
|
_clearTooltip();
|
|
CurrentlyHovered?.MouseExited();
|
|
CurrentlyHovered = newHovered;
|
|
CurrentlyHovered?.MouseEntered();
|
|
if (CurrentlyHovered != null)
|
|
{
|
|
_tooltipDelay = CurrentlyHovered.TooltipDelay ?? TooltipDelay;
|
|
}
|
|
else
|
|
{
|
|
_tooltipDelay = null;
|
|
}
|
|
|
|
_needUpdateActiveCursor = true;
|
|
}
|
|
|
|
var target = ControlFocused ?? newHovered;
|
|
if (target != null)
|
|
{
|
|
var pos = mouseMoveEventArgs.Position.Position;
|
|
var guiArgs = new GUIMouseMoveEventArgs(mouseMoveEventArgs.Relative / target.UIScale,
|
|
target,
|
|
pos / target.UIScale, mouseMoveEventArgs.Position,
|
|
pos / target.UIScale - target.GlobalPosition,
|
|
pos - target.GlobalPixelPosition);
|
|
|
|
_doMouseGuiInput(target, guiArgs, (c, ev) => c.MouseMove(ev));
|
|
}
|
|
}
|
|
|
|
private void UpdateActiveCursor()
|
|
{
|
|
// Consider mouse input focus first so that dragging windows don't act up etc.
|
|
var cursorTarget = ControlFocused ?? CurrentlyHovered;
|
|
|
|
if (cursorTarget == null)
|
|
{
|
|
_clyde.SetCursor(_worldCursor);
|
|
return;
|
|
}
|
|
|
|
if (cursorTarget.CustomCursorShape != null)
|
|
{
|
|
_clyde.SetCursor(cursorTarget.CustomCursorShape);
|
|
return;
|
|
}
|
|
|
|
var shape = cursorTarget.DefaultCursorShape switch
|
|
{
|
|
Control.CursorShape.Arrow => StandardCursorShape.Arrow,
|
|
Control.CursorShape.IBeam => StandardCursorShape.IBeam,
|
|
Control.CursorShape.Hand => StandardCursorShape.Hand,
|
|
Control.CursorShape.Crosshair => StandardCursorShape.Crosshair,
|
|
Control.CursorShape.VResize => StandardCursorShape.VResize,
|
|
Control.CursorShape.HResize => StandardCursorShape.HResize,
|
|
_ => StandardCursorShape.Arrow
|
|
};
|
|
|
|
_clyde.SetCursor(_clyde.GetStandardCursor(shape));
|
|
}
|
|
|
|
public void MouseWheel(MouseWheelEventArgs args)
|
|
{
|
|
var control = MouseGetControl(args.Position);
|
|
if (control == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
args.Handle();
|
|
|
|
var pos = args.Position.Position;
|
|
|
|
var guiArgs = new GUIMouseWheelEventArgs(args.Delta, control,
|
|
pos / control.UIScale, args.Position,
|
|
pos / control.UIScale - control.GlobalPosition, pos - control.GlobalPixelPosition);
|
|
|
|
_doMouseGuiInput(control, guiArgs, (c, ev) => c.MouseWheel(ev), true);
|
|
}
|
|
|
|
public void TextEntered(TextEventArgs textEvent)
|
|
{
|
|
if (KeyboardFocused == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var guiArgs = new GUITextEventArgs(KeyboardFocused, textEvent.CodePoint);
|
|
KeyboardFocused.TextEntered(guiArgs);
|
|
}
|
|
|
|
public void Popup(string contents, string title = "Alert!")
|
|
{
|
|
var popup = new DefaultWindow
|
|
{
|
|
Title = title
|
|
};
|
|
|
|
popup.Contents.AddChild(new Label {Text = contents});
|
|
popup.OpenCentered();
|
|
}
|
|
|
|
public Control? MouseGetControl(ScreenCoordinates coordinates)
|
|
{
|
|
return MouseGetControlAndRel(coordinates)?.control;
|
|
}
|
|
|
|
private (Control control, Vector2 rel)? MouseGetControlAndRel(ScreenCoordinates coordinates)
|
|
{
|
|
if (!_windowsToRoot.TryGetValue(coordinates.Window, out var root))
|
|
return null;
|
|
|
|
return MouseFindControlAtPos(root, coordinates.Position);
|
|
}
|
|
|
|
public ScreenCoordinates MousePositionScaled => ScreenToUIPosition(_inputManager.MouseScreenPosition);
|
|
|
|
public ScreenCoordinates ScreenToUIPosition(ScreenCoordinates coordinates)
|
|
{
|
|
if (!_windowsToRoot.TryGetValue(coordinates.Window, out var root))
|
|
return default;
|
|
|
|
return new ScreenCoordinates(coordinates.Position / root.UIScale, coordinates.Window);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void GrabKeyboardFocus(Control control)
|
|
{
|
|
if (control == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(control));
|
|
}
|
|
|
|
if (!control.CanKeyboardFocus)
|
|
{
|
|
throw new ArgumentException("Control cannot get keyboard focus.", nameof(control));
|
|
}
|
|
|
|
if (control == KeyboardFocused)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ReleaseKeyboardFocus();
|
|
|
|
KeyboardFocused = control;
|
|
|
|
KeyboardFocused.KeyboardFocusEntered();
|
|
}
|
|
|
|
public void ReleaseKeyboardFocus()
|
|
{
|
|
var oldFocused = KeyboardFocused;
|
|
oldFocused?.KeyboardFocusExited();
|
|
KeyboardFocused = null;
|
|
}
|
|
|
|
public void ReleaseKeyboardFocus(Control ifControl)
|
|
{
|
|
if (ifControl == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(ifControl));
|
|
}
|
|
|
|
if (ifControl == KeyboardFocused)
|
|
{
|
|
ReleaseKeyboardFocus();
|
|
}
|
|
}
|
|
|
|
public ICursor? WorldCursor
|
|
{
|
|
get => _worldCursor;
|
|
set
|
|
{
|
|
_worldCursor = value;
|
|
_needUpdateActiveCursor = true;
|
|
}
|
|
}
|
|
|
|
public void ControlHidden(Control control)
|
|
{
|
|
// Does the same thing but it could later be changed so..
|
|
ControlRemovedFromTree(control);
|
|
}
|
|
|
|
public void ControlRemovedFromTree(Control control)
|
|
{
|
|
ReleaseKeyboardFocus(control);
|
|
RemoveModal(control);
|
|
if (control == CurrentlyHovered)
|
|
{
|
|
control.MouseExited();
|
|
CurrentlyHovered = null;
|
|
_clearTooltip();
|
|
}
|
|
|
|
if (control != ControlFocused) return;
|
|
ControlFocused = null;
|
|
}
|
|
|
|
public void PushModal(Control modal)
|
|
{
|
|
_modalStack.Add(modal);
|
|
}
|
|
|
|
public void RemoveModal(Control modal)
|
|
{
|
|
if (_modalStack.Remove(modal))
|
|
{
|
|
modal.ModalRemoved();
|
|
}
|
|
}
|
|
|
|
public void Render(IRenderHandle renderHandle)
|
|
{
|
|
// Render secondary windows LAST.
|
|
// This makes it so that (hopefully) the GPU will be done rendering secondary windows
|
|
// by the times we try to blit to them at the end of Clyde's render cycle,
|
|
// So that the GL driver doesn't have to block on glWaitSync.
|
|
|
|
foreach (var root in _roots)
|
|
{
|
|
if (root.Window != _clyde.MainWindow)
|
|
{
|
|
using var _ = _prof.Group("Window");
|
|
_prof.WriteValue("ID", ProfData.Int32((int) root.Window.Id));
|
|
|
|
renderHandle.RenderInRenderTarget(
|
|
root.Window.RenderTarget,
|
|
() => DoRender(root),
|
|
root.ActualBgColor);
|
|
}
|
|
}
|
|
|
|
using (_prof.Group("Main"))
|
|
{
|
|
DoRender(_windowsToRoot[_clyde.MainWindow.Id]);
|
|
}
|
|
|
|
void DoRender(WindowRoot root)
|
|
{
|
|
var total = 0;
|
|
_render(renderHandle, ref total, root, Vector2i.Zero, Color.White, null);
|
|
var drawingHandle = renderHandle.DrawingHandleScreen;
|
|
drawingHandle.SetTransform(Vector2.Zero, Angle.Zero, Vector2.One);
|
|
OnPostDrawUIRoot?.Invoke(new PostDrawUIRootEventArgs(root, drawingHandle));
|
|
|
|
_prof.WriteValue("Controls rendered", ProfData.Int32(total));
|
|
}
|
|
}
|
|
|
|
public void QueueStyleUpdate(Control control)
|
|
{
|
|
_styleUpdateQueue.Enqueue(control);
|
|
}
|
|
|
|
public void QueueMeasureUpdate(Control control)
|
|
{
|
|
_measureUpdateQueue.Enqueue(control);
|
|
_arrangeUpdateQueue.Enqueue(control);
|
|
}
|
|
|
|
public void QueueArrangeUpdate(Control control)
|
|
{
|
|
_arrangeUpdateQueue.Enqueue(control);
|
|
}
|
|
|
|
public void CursorChanged(Control control)
|
|
{
|
|
if (control == ControlFocused || control == CurrentlyHovered)
|
|
{
|
|
_needUpdateActiveCursor = true;
|
|
}
|
|
}
|
|
|
|
private void _render(IRenderHandle renderHandle, ref int total, Control control, Vector2i position, Color modulate,
|
|
UIBox2i? scissorBox)
|
|
{
|
|
if (!control.Visible)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Manual clip test with scissor region as optimization.
|
|
var controlBox = UIBox2i.FromDimensions(position, control.PixelSize);
|
|
|
|
if (scissorBox != null)
|
|
{
|
|
var clipMargin = control.RectDrawClipMargin;
|
|
var clipTestBox = new UIBox2i(controlBox.Left - clipMargin, controlBox.Top - clipMargin,
|
|
controlBox.Right + clipMargin, controlBox.Bottom + clipMargin);
|
|
|
|
if (!scissorBox.Value.Intersects(clipTestBox))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
var clip = control.RectClipContent;
|
|
var scissorRegion = scissorBox;
|
|
if (clip)
|
|
{
|
|
scissorRegion = controlBox;
|
|
if (scissorBox != null)
|
|
{
|
|
// Make the final scissor region a sub region of scissorBox
|
|
var s = scissorBox.Value;
|
|
var result = s.Intersection(scissorRegion.Value);
|
|
if (result == null)
|
|
{
|
|
// Uhm... No intersection so... don't draw anything at all?
|
|
return;
|
|
}
|
|
|
|
scissorRegion = result.Value;
|
|
}
|
|
|
|
renderHandle.SetScissor(scissorRegion);
|
|
}
|
|
|
|
total += 1;
|
|
|
|
var handle = renderHandle.DrawingHandleScreen;
|
|
handle.SetTransform(position, Angle.Zero, Vector2.One);
|
|
modulate *= control.Modulate;
|
|
|
|
if (_rendering || control.AlwaysRender)
|
|
{
|
|
// Handle modulation with care.
|
|
var oldMod = handle.Modulate;
|
|
handle.Modulate = modulate * control.ActualModulateSelf;
|
|
control.DrawInternal(renderHandle);
|
|
handle.Modulate = oldMod;
|
|
handle.UseShader(null);
|
|
}
|
|
|
|
foreach (var child in control.Children)
|
|
{
|
|
_render(renderHandle, ref total, child, position + child.PixelPosition, modulate, scissorRegion);
|
|
}
|
|
|
|
if (clip)
|
|
{
|
|
renderHandle.SetScissor(scissorBox);
|
|
}
|
|
}
|
|
|
|
private static (Control control, Vector2 rel)? MouseFindControlAtPos(Control control, Vector2 position)
|
|
{
|
|
for (var i = control.ChildCount - 1; i >= 0; i--)
|
|
{
|
|
var child = control.GetChild(i);
|
|
if (!child.Visible || child.RectClipContent && !child.PixelRect.Contains((Vector2i) position))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var maybeFoundOnChild = MouseFindControlAtPos(child, position - child.PixelPosition);
|
|
if (maybeFoundOnChild != null)
|
|
{
|
|
return maybeFoundOnChild;
|
|
}
|
|
}
|
|
|
|
if (control.MouseFilter != Control.MouseFilterMode.Ignore && control.HasPoint(position / control.UIScale))
|
|
{
|
|
return (control, position);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static void _doMouseGuiInput<T>(Control? control, T guiEvent, Action<Control, T> action,
|
|
bool ignoreStop = false)
|
|
where T : GUIMouseEventArgs
|
|
{
|
|
while (control != null)
|
|
{
|
|
guiEvent.SourceControl = control;
|
|
if (control.MouseFilter != Control.MouseFilterMode.Ignore)
|
|
{
|
|
action(control, guiEvent);
|
|
|
|
if (guiEvent.Handled || (!ignoreStop && control.MouseFilter == Control.MouseFilterMode.Stop))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
guiEvent.RelativePosition += control.Position;
|
|
guiEvent.RelativePixelPosition += control.PixelPosition;
|
|
control = control.Parent;
|
|
}
|
|
}
|
|
|
|
private static void _doGuiInput(
|
|
Control? control,
|
|
GUIBoundKeyEventArgs guiEvent,
|
|
Action<Control, GUIBoundKeyEventArgs> action,
|
|
bool ignoreStop = false)
|
|
{
|
|
while (control != null)
|
|
{
|
|
if (control.MouseFilter != Control.MouseFilterMode.Ignore)
|
|
{
|
|
action(control, guiEvent);
|
|
|
|
if (guiEvent.Handled || (!ignoreStop && control.MouseFilter == Control.MouseFilterMode.Stop))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
guiEvent.RelativePosition += control.Position;
|
|
guiEvent.RelativePixelPosition += control.PixelPosition;
|
|
control = control.Parent;
|
|
}
|
|
}
|
|
|
|
private void _clearTooltip()
|
|
{
|
|
if (!showingTooltip) return;
|
|
_tooltip.Visible = false;
|
|
if (_suppliedTooltip != null)
|
|
{
|
|
PopupRoot.RemoveChild(_suppliedTooltip);
|
|
_suppliedTooltip = null;
|
|
}
|
|
|
|
CurrentlyHovered?.PerformHideTooltip();
|
|
_resetTooltipTimer();
|
|
showingTooltip = false;
|
|
}
|
|
|
|
|
|
public void HideTooltipFor(Control control)
|
|
{
|
|
if (CurrentlyHovered == control)
|
|
{
|
|
_clearTooltip();
|
|
}
|
|
}
|
|
|
|
public Control? GetSuppliedTooltipFor(Control control)
|
|
{
|
|
return CurrentlyHovered == control ? _suppliedTooltip : null;
|
|
}
|
|
|
|
public Vector2? CalcRelativeMousePositionFor(Control control, ScreenCoordinates mousePosScaled)
|
|
{
|
|
var (pos, window) = mousePosScaled;
|
|
var root = control.Root;
|
|
|
|
if (root?.Window == null || root.Window.Id != window)
|
|
return null;
|
|
|
|
return pos - control.GlobalPosition;
|
|
}
|
|
|
|
public Color GetMainClearColor() => RootControl.ActualBgColor;
|
|
|
|
private void _resetTooltipTimer()
|
|
{
|
|
_tooltipTimer = 0;
|
|
}
|
|
|
|
private void _showTooltip()
|
|
{
|
|
if (showingTooltip) return;
|
|
showingTooltip = true;
|
|
var hovered = CurrentlyHovered;
|
|
if (hovered == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// show supplied tooltip if there is one
|
|
if (hovered.TooltipSupplier != null)
|
|
{
|
|
_suppliedTooltip = hovered.TooltipSupplier.Invoke(hovered);
|
|
if (_suppliedTooltip != null)
|
|
{
|
|
PopupRoot.AddChild(_suppliedTooltip);
|
|
Tooltips.PositionTooltip(_suppliedTooltip);
|
|
}
|
|
}
|
|
else if (!String.IsNullOrWhiteSpace(hovered.ToolTip))
|
|
{
|
|
// show simple tooltip if there is one
|
|
_tooltip.Visible = true;
|
|
_tooltip.Text = hovered.ToolTip;
|
|
Tooltips.PositionTooltip(_tooltip);
|
|
}
|
|
|
|
hovered.PerformShowTooltip();
|
|
}
|
|
|
|
private void _uiScaleChanged(float newValue)
|
|
{
|
|
foreach (var root in _roots)
|
|
{
|
|
UpdateUIScale(root);
|
|
}
|
|
}
|
|
|
|
private void WindowContentScaleChanged(WindowContentScaleEventArgs args)
|
|
{
|
|
if (_windowsToRoot.TryGetValue(args.Window.Id, out var root))
|
|
{
|
|
UpdateUIScale(root);
|
|
_fontManager.ClearFontCache();
|
|
}
|
|
|
|
}
|
|
|
|
private float CalculateAutoScale(WindowRoot root)
|
|
{
|
|
//Grab the OS UIScale or the value set through CVAR debug
|
|
var osScale = _configurationManager.GetCVar(CVars.DisplayUIScale);
|
|
osScale = osScale == 0f ? root.Window.ContentScale.X : osScale;
|
|
var windowSize = root.Window.RenderTarget.Size;
|
|
//Only run autoscale if it is enabled, otherwise default to just use OS UIScale
|
|
if (!root.AutoScale && (windowSize.X <= 0 || windowSize.Y <= 0)) return osScale;
|
|
var maxScaleRes = root.AutoScaleUpperCutoff;
|
|
var minScaleRes = root.AutoScaleLowerCutoff;
|
|
var autoScaleMin = root.AutoScaleMinimum;
|
|
float scaleRatioX;
|
|
float scaleRatioY;
|
|
|
|
//Calculate the scale ratios and clamp it between the maximums and minimums
|
|
scaleRatioX = Math.Clamp(((float) windowSize.X - minScaleRes.X) / (maxScaleRes.X - minScaleRes.X) * osScale, autoScaleMin, osScale);
|
|
scaleRatioY = Math.Clamp(((float) windowSize.Y - minScaleRes.Y) / (maxScaleRes.Y - minScaleRes.Y) * osScale, autoScaleMin, osScale);
|
|
//Take the smallest UIScale value and use it for UI scaling
|
|
return Math.Min(scaleRatioX, scaleRatioY);
|
|
}
|
|
|
|
private void UpdateUIScale(WindowRoot root)
|
|
{
|
|
root.UIScaleSet = CalculateAutoScale(root);
|
|
_propagateUIScaleChanged(root);
|
|
root.InvalidateMeasure();
|
|
}
|
|
|
|
private static void _propagateUIScaleChanged(Control control)
|
|
{
|
|
control.UIScaleChanged();
|
|
|
|
foreach (var child in control.Children)
|
|
{
|
|
_propagateUIScaleChanged(child);
|
|
}
|
|
}
|
|
|
|
private void WindowSizeChanged(WindowResizedEventArgs windowResizedEventArgs)
|
|
{
|
|
if (!_windowsToRoot.TryGetValue(windowResizedEventArgs.Window.Id, out var root))
|
|
return;
|
|
UpdateUIScale(root);
|
|
root.InvalidateMeasure();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converts
|
|
/// </summary>
|
|
/// <param name="args">Event data values for a bound key state change.</param>
|
|
private bool OnUIKeyBindStateChanged(BoundKeyEventArgs args)
|
|
{
|
|
if (args.State == BoundKeyState.Down)
|
|
{
|
|
KeyBindDown(args);
|
|
}
|
|
else
|
|
{
|
|
KeyBindUp(args);
|
|
}
|
|
|
|
// If we are in a focused control or doing a CanFocus, return true
|
|
// So that InputManager doesn't propagate events to simulation.
|
|
if (!args.CanFocus && KeyboardFocused != null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
}
|