329 lines
12 KiB
C#
329 lines
12 KiB
C#
using System;
|
|
using System.Numerics;
|
|
using AcDream.App.UI.Layout;
|
|
|
|
namespace AcDream.App.UI;
|
|
|
|
/// <summary>
|
|
/// Generic dat-widget button — the production replacement for any dat element of
|
|
/// Type 1 (UIElement_Button, registered via RegisterElementClass(1, UIElement_Button::Create)
|
|
/// @ acclient_2013_pseudo_c.txt:125828).
|
|
///
|
|
/// <para>
|
|
/// Draws per-state sprite media exactly like <see cref="UiDatElement"/> (same
|
|
/// <c>ActiveState</c> defaulting, same <c>ActiveMedia()</c> fallback chain, same tiled
|
|
/// <c>DrawSprite</c> call with UV-repeat so chrome edges tile correctly) plus an
|
|
/// optional centered text label. The click behavior mirrors <see cref="UiDatElement"/>
|
|
/// one-for-one so the chat Send and Max/Min buttons that previously bound through
|
|
/// <c>UiDatElement.OnClick</c> continue to work without behavioral change.
|
|
/// </para>
|
|
///
|
|
/// <para>
|
|
/// State selection: picks <see cref="ElementInfo.DefaultStateName"/> if set, then
|
|
/// "Normal" if the element has a Normal state sprite, then falls back to the unnamed
|
|
/// DirectState ("" key) — identical to <see cref="UiDatElement"/>.
|
|
/// </para>
|
|
///
|
|
/// <para>
|
|
/// Built by <see cref="DatWidgetFactory"/> for Type-1 elements (chat Send 0x10000019,
|
|
/// Max/Min 0x1000046F). NOT the same as <see cref="UiSimpleButton"/>, which is an
|
|
/// earlier dev-scaffold widget with no dat sprites.
|
|
/// </para>
|
|
/// </summary>
|
|
public sealed class UiButton : UiElement, IUiGlobalTimeListener, IUiDatStateful
|
|
{
|
|
private readonly ElementInfo _info;
|
|
private readonly Func<uint, (uint tex, int w, int h)> _resolve;
|
|
private readonly HashSet<uint> _availableStates = new();
|
|
private bool _pressed;
|
|
private bool _pointerOver;
|
|
private bool _selected;
|
|
private bool _hotClicking;
|
|
private bool _suppressNextClick;
|
|
private double _nextHotClickTime = double.NaN;
|
|
|
|
/// <summary>Optional click handler. Wired by the controller (e.g. chat Submit, ToggleMaximize).</summary>
|
|
public Action? OnClick { get; set; }
|
|
|
|
/// <summary>The dat element id from <see cref="ElementInfo.Id"/>.</summary>
|
|
public uint ElementId => _info.Id;
|
|
|
|
/// <summary>Optional centered text label drawn over the sprite (e.g. "Send" on a blank gold frame).</summary>
|
|
public string? Label { get; set; }
|
|
|
|
/// <summary>Dat font for <see cref="Label"/>. Required for the label to draw.</summary>
|
|
public UiDatFont? LabelFont { get; set; }
|
|
|
|
/// <summary>Label color (default white).</summary>
|
|
public Vector4 LabelColor { get; set; } = Vector4.One;
|
|
|
|
/// <summary>Horizontal alignment of <see cref="Label"/>. Center (default) for normal buttons;
|
|
/// Left for the paperdoll "Slots" caption that sits at the left edge, before the slots.</summary>
|
|
public LabelAlignment LabelAlign { get; set; } = LabelAlignment.Center;
|
|
|
|
/// <summary>Label horizontal alignment options.</summary>
|
|
public enum LabelAlignment { Center, Left }
|
|
|
|
public bool ToggleBehavior { get; }
|
|
public bool RolloverEnabled { get; }
|
|
public bool HotClickEnabled { get; }
|
|
public float HotClickInitialDelay { get; }
|
|
public float HotClickRepeatInterval { get; }
|
|
|
|
public bool Selected
|
|
{
|
|
get => _selected;
|
|
set
|
|
{
|
|
if (_selected == value) return;
|
|
_selected = value;
|
|
UpdateVisualState();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Active state name, runtime-settable (e.g. Max/Min toggling Normal ↔ Minimized).
|
|
/// Matches <see cref="UiDatElement.ActiveState"/>.
|
|
/// </summary>
|
|
public string ActiveState { get; set; } = "";
|
|
|
|
public uint ActiveRetailStateId
|
|
{
|
|
get
|
|
{
|
|
if (string.IsNullOrEmpty(ActiveState))
|
|
return UiStateInfo.DirectStateId;
|
|
foreach (var (id, state) in _info.States)
|
|
if (string.Equals(state.Name, ActiveState, StringComparison.Ordinal))
|
|
return id;
|
|
return UiButtonStateMachine.TryStateId(ActiveState, out uint standard)
|
|
? standard
|
|
: RetailUiStateIds.TryStateId(ActiveState, out uint custom) ? custom : 0u;
|
|
}
|
|
}
|
|
|
|
public override string ActiveCursorStateName => ActiveState;
|
|
|
|
public bool TrySetRetailState(uint stateId)
|
|
{
|
|
if (ToggleBehavior && stateId is UiButtonStateMachine.Normal or UiButtonStateMachine.Highlight)
|
|
{
|
|
Selected = stateId == UiButtonStateMachine.Highlight;
|
|
return true;
|
|
}
|
|
if (stateId == UiButtonStateMachine.Ghosted)
|
|
{
|
|
Enabled = false;
|
|
return true;
|
|
}
|
|
if (!Enabled && stateId != UiButtonStateMachine.Ghosted)
|
|
Enabled = true;
|
|
|
|
if (stateId == UiStateInfo.DirectStateId)
|
|
{
|
|
if (!_info.States.ContainsKey(stateId) && !_info.StateMedia.ContainsKey(""))
|
|
return false;
|
|
ActiveState = "";
|
|
return true;
|
|
}
|
|
if (_info.States.TryGetValue(stateId, out var state))
|
|
{
|
|
ActiveState = state.Name;
|
|
return true;
|
|
}
|
|
string stateName = UiButtonStateMachine.StateName(stateId);
|
|
if (string.IsNullOrEmpty(stateName))
|
|
stateName = RetailUiStateIds.StateName(stateId);
|
|
if (!string.IsNullOrEmpty(stateName) && _info.StateMedia.ContainsKey(stateName))
|
|
{
|
|
ActiveState = stateName;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <param name="info">Merged <see cref="ElementInfo"/> for this element.</param>
|
|
/// <param name="resolve">Dat file-id → (GL texture handle, native px width, native px height).
|
|
/// Returns (0,0,0) when the texture is not yet uploaded.</param>
|
|
public UiButton(ElementInfo info, Func<uint, (uint tex, int w, int h)> resolve)
|
|
{
|
|
_info = info;
|
|
_resolve = resolve;
|
|
ClickThrough = false; // buttons are interactive — opt OUT of click-through
|
|
|
|
foreach (uint stateId in info.States.Keys)
|
|
if (stateId != UiStateInfo.DirectStateId)
|
|
_availableStates.Add(stateId);
|
|
foreach (string stateName in info.StateMedia.Keys)
|
|
if (UiButtonStateMachine.TryStateId(stateName, out uint stateId))
|
|
_availableStates.Add(stateId);
|
|
|
|
ToggleBehavior = info.TryGetEffectiveBool(0x0Bu, out bool toggle) && toggle;
|
|
RolloverEnabled = info.TryGetEffectiveBool(0x13u, out bool rollover) && rollover;
|
|
HotClickEnabled = info.TryGetEffectiveBool(0x0Fu, out bool hotClick) && hotClick;
|
|
HotClickInitialDelay = info.TryGetEffectiveFloat(0x10u, out float initialDelay)
|
|
? initialDelay
|
|
: 0f;
|
|
HotClickRepeatInterval = info.TryGetEffectiveFloat(0x11u, out float repeatInterval)
|
|
? repeatInterval
|
|
: 0f;
|
|
_selected = info.TryGetEffectiveBool(0x0Eu, out bool selected) && selected;
|
|
bool disabled = info.TryGetEffectiveBool(0x0Du, out bool ghosted) && ghosted;
|
|
|
|
// State defaulting matches UiDatElement exactly:
|
|
// DefaultStateName wins; else "Normal" if that state has a sprite; else DirectState ("").
|
|
if (!string.IsNullOrEmpty(info.DefaultStateName))
|
|
ActiveState = info.DefaultStateName;
|
|
else if (info.StateMedia.ContainsKey("Normal"))
|
|
ActiveState = "Normal";
|
|
// else ActiveState stays "" (DirectState)
|
|
|
|
Enabled = !disabled;
|
|
UpdateVisualState();
|
|
}
|
|
|
|
/// <summary>The button draws its own face + label; any dat label child is reproduced
|
|
/// procedurally, so the importer must not build the button's children as widgets.</summary>
|
|
public override bool ConsumesDatChildren => true;
|
|
|
|
/// <summary>A button is interactive — it must receive its Click even inside a whole-window-Draggable
|
|
/// frame (e.g. the paperdoll "Slots" toggle in the inventory window), so it opts out of the
|
|
/// IA-12 whole-window-drag that would otherwise swallow the press.</summary>
|
|
public override bool HandlesClick => true;
|
|
|
|
/// <summary>
|
|
/// Returns the File id for the current <see cref="ActiveState"/>, falling back to
|
|
/// the DirectState ("" key) if the named state is absent.
|
|
/// Returns 0 if neither exists.
|
|
/// Mirrors <see cref="UiDatElement.ActiveMedia()"/>.
|
|
/// </summary>
|
|
private uint ActiveFile()
|
|
=> _info.StateMedia.TryGetValue(ActiveState, out var m) ? m.File
|
|
: _info.StateMedia.TryGetValue("", out var d) ? d.File : 0u;
|
|
|
|
protected override void OnDraw(UiRenderContext ctx)
|
|
{
|
|
uint file = ActiveFile();
|
|
if (file != 0)
|
|
{
|
|
var (tex, tw, th) = _resolve(file);
|
|
if (tex != 0 && tw != 0 && th != 0)
|
|
{
|
|
// Tiled draw — same call shape as UiDatElement.OnDraw (UV-repeat; GL_REPEAT-wrapped
|
|
// UI texture). Matches ImgTex::TileCSI; no Stretch mode exists.
|
|
ctx.DrawSprite(tex, 0, 0, Width, Height, 0, 0, Width / tw, Height / th, Vector4.One);
|
|
}
|
|
}
|
|
|
|
if (Label is { Length: > 0 } label && LabelFont is { } lf)
|
|
{
|
|
float tx = LabelAlign == LabelAlignment.Left
|
|
? 3f // small left pad (room for a future checkbox box)
|
|
: (Width - lf.MeasureWidth(label)) * 0.5f; // centered (default)
|
|
float ty = (Height - lf.LineHeight) * 0.5f;
|
|
ctx.DrawStringDat(lf, label, tx, ty, LabelColor);
|
|
}
|
|
}
|
|
|
|
public override bool OnEvent(in UiEvent e)
|
|
{
|
|
switch (e.Type)
|
|
{
|
|
case UiEventType.HoverEnter:
|
|
_pointerOver = true;
|
|
UpdateVisualState();
|
|
return true;
|
|
case UiEventType.HoverLeave:
|
|
_pointerOver = false;
|
|
UpdateVisualState();
|
|
return true;
|
|
case UiEventType.MouseDown:
|
|
_pointerOver = ContainsLocal(e.Data1, e.Data2);
|
|
_pressed = true;
|
|
UpdateVisualState();
|
|
if (HotClickEnabled && Enabled)
|
|
{
|
|
OnClick?.Invoke();
|
|
_hotClicking = true;
|
|
_nextHotClickTime = double.NaN;
|
|
}
|
|
return true;
|
|
case UiEventType.MouseMove:
|
|
if (_pressed)
|
|
{
|
|
_pointerOver = ContainsLocal(e.Data1, e.Data2);
|
|
UpdateVisualState();
|
|
return true;
|
|
}
|
|
return false;
|
|
case UiEventType.MouseUp:
|
|
_pointerOver = ContainsLocal(e.Data1, e.Data2);
|
|
_suppressNextClick = _hotClicking && _pointerOver;
|
|
_hotClicking = false;
|
|
_nextHotClickTime = double.NaN;
|
|
if (_pressed && _pointerOver && Enabled && ToggleBehavior)
|
|
_selected = !_selected;
|
|
_pressed = false;
|
|
UpdateVisualState();
|
|
return true;
|
|
case UiEventType.Click:
|
|
if (!Enabled) return true;
|
|
if (_suppressNextClick)
|
|
{
|
|
_suppressNextClick = false;
|
|
return true;
|
|
}
|
|
OnClick?.Invoke();
|
|
return OnClick is not null;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
protected override void OnEnabledChanged()
|
|
{
|
|
if (!Enabled)
|
|
{
|
|
_pressed = false;
|
|
_hotClicking = false;
|
|
_nextHotClickTime = double.NaN;
|
|
}
|
|
UpdateVisualState();
|
|
}
|
|
|
|
public void OnGlobalUiTime(double nowSeconds)
|
|
{
|
|
if (!_hotClicking || !HotClickEnabled)
|
|
return;
|
|
|
|
if (double.IsNaN(_nextHotClickTime))
|
|
_nextHotClickTime = nowSeconds + HotClickInitialDelay;
|
|
|
|
if (!_pointerOver && nowSeconds >= _nextHotClickTime)
|
|
{
|
|
_nextHotClickTime = nowSeconds;
|
|
return;
|
|
}
|
|
|
|
if (_pointerOver && nowSeconds >= _nextHotClickTime)
|
|
{
|
|
OnClick?.Invoke();
|
|
_nextHotClickTime += HotClickRepeatInterval;
|
|
}
|
|
}
|
|
|
|
private bool ContainsLocal(int x, int y)
|
|
=> x >= 0 && y >= 0 && x < Width && y < Height;
|
|
|
|
private void UpdateVisualState()
|
|
{
|
|
uint requested = UiButtonStateMachine.RequestedState(new UiButtonVisualInput(
|
|
Disabled: !Enabled,
|
|
Selected: _selected,
|
|
RolloverEnabled: RolloverEnabled,
|
|
Pressed: _pressed,
|
|
PointerOver: _pointerOver));
|
|
if (_availableStates.Contains(requested))
|
|
ActiveState = UiButtonStateMachine.StateName(requested);
|
|
}
|
|
}
|