mirror of
https://github.com/MaSzyna-EU07/StarterNG.git
synced 2026-11-16 21:14:10 +01:00
A review against WCAG 2.2 AA left places a screen reader user could not work: - Key bindings: a key's button says the command and the key, the clear button which command it clears; a new key is said aloud and focus comes back to its row. The on-screen keyboard is reached with Tab and walked with the arrows. - Number fields read their label; the spin buttons are named and left out of Tab. - Dialogs: Enter presses the main button, Esc closes, focus starts on the first button and the message is read with it. - Consist: every change is said - added, removed, turned, moved, replaced, undone - and the strip is a named list; a turned card says so. - Searches say how many entries are left once typing pauses. - Hasler tapes, the black box timeline, timetable and cab panel take focus, work from the keyboard, read their value as it changes and draw a focus frame. - Section reset and level controls, the crew button and the tabs carry names; English names from Avalonia's templates are read in the starter's language; sort and crew menus are radio items. - Input borders reach 3:1 against the panels; Tab starts at the top bar; the splash screen has a title and its progress reads the loading step.
354 lines
14 KiB
C#
354 lines
14 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Globalization;
|
||
using System.Linq;
|
||
using Avalonia;
|
||
using Avalonia.Automation.Peers;
|
||
using Avalonia.Controls;
|
||
using Avalonia.Input;
|
||
using Avalonia.Media;
|
||
|
||
namespace Eu07.BlackBox.Views;
|
||
|
||
/// <summary>
|
||
/// The timetable of the user's train, a row a station: what the timetable said and what
|
||
/// happened, by the end of the recording read so far. A stop shows the time of arrival and
|
||
/// of departure with the delay, how well the train was stopped against the stop point and
|
||
/// whether it stood along the platform; a station passed through the time of passing. The
|
||
/// station of the moment played is marked; a click goes to the moment the train was there.
|
||
/// </summary>
|
||
public sealed class TimetablePanel : Control
|
||
{
|
||
private const double Pad = 12;
|
||
private const double HeaderHeight = 50;
|
||
private const double RowHeight = 54;
|
||
|
||
private Recording? _recording;
|
||
private double _time;
|
||
private int _builtRevision = -1;
|
||
private IReadOnlyList<StationProgress> _rows = Array.Empty<StationProgress>();
|
||
private Timetable? _timetable;
|
||
private int _hover = -1;
|
||
|
||
public event Action<double>? Seek;
|
||
|
||
public IBlackBoxStrings Strings { get; set; } = new DefaultBlackBoxStrings();
|
||
|
||
public TimetablePanel()
|
||
{
|
||
ClipToBounds = true;
|
||
Cursor = new Cursor(StandardCursorType.Hand);
|
||
// The stations walked from the keyboard as well: the arrows go up and down the rows,
|
||
// Enter goes to the moment as a click does.
|
||
Focusable = true;
|
||
}
|
||
|
||
// The row the keyboard stands at; -1 until it is moved, when the station played is meant.
|
||
private int _keyRow = -1;
|
||
private string? _spoken;
|
||
|
||
protected override AutomationPeer OnCreateAutomationPeer() =>
|
||
new SpokenPeer(this, AutomationControlType.List, () => _spoken ?? RowText(KeyRow), () => Strings["TimetableHelp"]);
|
||
|
||
private int KeyRow => _keyRow >= 0 && _keyRow < _rows.Count ? _keyRow : Current();
|
||
|
||
/// <summary>A row as it is read: the station, the times of the timetable, the kilometre and what happened there.</summary>
|
||
private string? RowText(int i)
|
||
{
|
||
if (_timetable is null)
|
||
return Strings["TimetableNone"];
|
||
if (i < 0 || i >= _rows.Count)
|
||
return null;
|
||
var row = _rows[i];
|
||
var culture = CultureInfo.CurrentCulture;
|
||
string planned = row.Row.IsStop
|
||
? $"{Minutes(row.Row.Arrival)} – {Minutes(row.Row.Departure)}"
|
||
: Minutes(row.Row.Departure);
|
||
var parts = new List<string> { StationNames.Display(row.Row.Station), planned };
|
||
if (row.Row.Km > 0 || i > 0)
|
||
parts.Add($"km {row.Row.Km.ToString("0.0", culture)}");
|
||
parts.AddRange(Chips(row, culture).Select(c => c.Text));
|
||
return $"{i + 1}/{_rows.Count}. {string.Join(", ", parts)}";
|
||
}
|
||
|
||
protected override void OnKeyDown(KeyEventArgs e)
|
||
{
|
||
base.OnKeyDown(e);
|
||
if (_rows.Count == 0)
|
||
return;
|
||
|
||
int at = KeyRow;
|
||
int? to = e.Key switch
|
||
{
|
||
Key.Up => at - 1,
|
||
Key.Down => at + 1,
|
||
Key.Home => 0,
|
||
Key.End => _rows.Count - 1,
|
||
_ => null
|
||
};
|
||
if (e.Key == Key.Enter && at >= 0 && (_rows[at].ArrivedAt ?? _rows[at].DepartedAt) is { } t)
|
||
{
|
||
Seek?.Invoke(Math.Max(0, t - 5));
|
||
e.Handled = true;
|
||
return;
|
||
}
|
||
if (to is not { } row)
|
||
return;
|
||
|
||
_keyRow = Math.Clamp(row, 0, _rows.Count - 1);
|
||
string? before = _spoken;
|
||
_spoken = RowText(_keyRow);
|
||
(ControlAutomationPeer.FromElement(this) as SpokenPeer)?.Told(before, _spoken);
|
||
this.BringIntoView(new Rect(0, HeaderHeight + _keyRow * RowHeight, Bounds.Width, RowHeight));
|
||
InvalidateVisual();
|
||
e.Handled = true;
|
||
}
|
||
|
||
protected override void OnGotFocus(FocusChangedEventArgs e)
|
||
{
|
||
base.OnGotFocus(e);
|
||
_spoken = null;
|
||
InvalidateVisual();
|
||
}
|
||
|
||
protected override void OnLostFocus(FocusChangedEventArgs e)
|
||
{
|
||
base.OnLostFocus(e);
|
||
_keyRow = -1;
|
||
InvalidateVisual();
|
||
}
|
||
|
||
public Recording? Recording
|
||
{
|
||
get => _recording;
|
||
set
|
||
{
|
||
_recording = value;
|
||
_builtRevision = -1;
|
||
Rebuild();
|
||
}
|
||
}
|
||
|
||
public double Time
|
||
{
|
||
get => _time;
|
||
set
|
||
{
|
||
_time = value;
|
||
Rebuild();
|
||
InvalidateVisual();
|
||
}
|
||
}
|
||
|
||
private void Rebuild()
|
||
{
|
||
if (_recording is not { } recording)
|
||
{
|
||
_rows = Array.Empty<StationProgress>();
|
||
_timetable = null;
|
||
InvalidateMeasure();
|
||
return;
|
||
}
|
||
var timetable = recording.TimetableAt(_time);
|
||
if (recording.Revision == _builtRevision && ReferenceEquals(timetable, _timetable))
|
||
return;
|
||
_builtRevision = recording.Revision;
|
||
_timetable = timetable;
|
||
_rows = StationProgress.Of(recording, _time);
|
||
InvalidateMeasure();
|
||
InvalidateVisual();
|
||
}
|
||
|
||
protected override Size MeasureOverride(Size availableSize) =>
|
||
new(0, _timetable is null ? 80 : HeaderHeight + _rows.Count * RowHeight + Pad);
|
||
|
||
/// <summary>The row of the station the train was at, or made for, at the moment played.</summary>
|
||
private int Current()
|
||
{
|
||
int current = -1;
|
||
for (int i = 0; i < _rows.Count; i++)
|
||
{
|
||
var row = _rows[i];
|
||
double? at = row.ArrivedAt ?? row.DepartedAt;
|
||
if (at is { } t && t <= _time + 0.05)
|
||
current = i;
|
||
}
|
||
// Still standing there, or on the way to the next one.
|
||
if (current >= 0 && _rows[current].DepartedAt is { } left && left <= _time && current + 1 < _rows.Count)
|
||
return current + 1;
|
||
return current < 0 ? (_rows.Count > 0 ? 0 : -1) : current;
|
||
}
|
||
|
||
public override void Render(DrawingContext context)
|
||
{
|
||
var size = Bounds.Size;
|
||
var culture = CultureInfo.CurrentCulture;
|
||
if (IsFocused)
|
||
context.DrawRectangle(null, Palette.FocusPen, new Rect(size).Deflate(1));
|
||
if (_timetable is not { } timetable)
|
||
{
|
||
context.DrawText(MapView.Text(Strings["TimetableNone"], Palette.DimText, 12), new Point(Pad, Pad));
|
||
return;
|
||
}
|
||
|
||
// The train: its number and category, from where to where.
|
||
var train = MapView.Text($"{timetable.Category} {timetable.Train}".Trim(), Palette.Text, 15, FontWeight.SemiBold);
|
||
context.DrawText(train, new Point(Pad, 6));
|
||
string relation = string.Format(culture, Strings["Relation"], timetable.From, timetable.To);
|
||
if (timetable.Vmax > 0)
|
||
relation += $" · {timetable.Vmax:0} km/h";
|
||
context.DrawText(MapView.Text(relation, Palette.DimText, 11), new Point(Pad, 6 + train.Height + 1));
|
||
|
||
int current = Current();
|
||
double rail = Pad + 6;
|
||
for (int i = 0; i < _rows.Count; i++)
|
||
{
|
||
double top = HeaderHeight + i * RowHeight;
|
||
var row = _rows[i];
|
||
if (i == current)
|
||
{
|
||
context.DrawRectangle(Palette.CardHover, null, new Rect(0, top, size.Width, RowHeight - 1));
|
||
context.DrawRectangle(Palette.Accent, null, new Rect(0, top, 2, RowHeight - 1));
|
||
}
|
||
else if (i == _hover)
|
||
context.DrawRectangle(Palette.Faded(Palette.CardHover, 0.6), null, new Rect(0, top, size.Width, RowHeight - 1));
|
||
if (IsFocused && i == KeyRow)
|
||
context.DrawRectangle(null, Palette.FocusPen, new Rect(1, top + 1, size.Width - 2, RowHeight - 3));
|
||
|
||
// The line of the route through the stations, a dot each: hollow ahead, filled when done.
|
||
var outcome = row.Outcome;
|
||
var colour = outcome switch
|
||
{
|
||
StationOutcome.Missed => Palette.Bad,
|
||
StationOutcome.Ahead => Palette.FaintText,
|
||
_ => DelayBrush(row.ArrivalDelay ?? row.DepartureDelay)
|
||
};
|
||
double dotY = top + 15;
|
||
if (i + 1 < _rows.Count)
|
||
context.DrawLine(new Pen(Palette.Grid, 2), new Point(rail, dotY), new Point(rail, dotY + RowHeight));
|
||
bool stop = row.Row.IsStop;
|
||
double radius = stop ? 5.5 : 3.5;
|
||
context.DrawEllipse(outcome == StationOutcome.Ahead ? Palette.Card : colour, new Pen(colour, 2), new Point(rail, dotY), radius, radius);
|
||
|
||
// The station and what the timetable said.
|
||
double x = rail + 16;
|
||
var name = MapView.Text(StationNames.Display(row.Row.Station), outcome == StationOutcome.Ahead ? Palette.DimText : Palette.Text, 13,
|
||
stop ? FontWeight.SemiBold : FontWeight.Normal);
|
||
context.DrawText(name, new Point(x, dotY - name.Height / 2));
|
||
string planned = stop
|
||
? $"{Minutes(row.Row.Arrival)} → {Minutes(row.Row.Departure)}"
|
||
: Minutes(row.Row.Departure);
|
||
var plan = MapView.Text(planned, Palette.DimText, 12);
|
||
context.DrawText(plan, new Point(size.Width - Pad - plan.Width, dotY - plan.Height / 2));
|
||
if (row.Row.Km > 0 || i > 0)
|
||
{
|
||
var km = MapView.Text($"km {row.Row.Km:0.0}", Palette.FaintText, 10);
|
||
double kmX = size.Width - Pad - plan.Width - 12 - km.Width;
|
||
if (kmX > x + name.Width + 8)
|
||
context.DrawText(km, new Point(kmX, dotY - km.Height / 2));
|
||
}
|
||
|
||
// What happened there, under it: each part in its colour, on to a second line when long.
|
||
double partX = x, partY = top + 25;
|
||
bool first = true;
|
||
foreach (var (text, brush) in Chips(row, culture))
|
||
{
|
||
var part = MapView.Text(first ? text : "· " + text, brush, 11);
|
||
if (!first && partX + part.Width > size.Width - Pad)
|
||
{
|
||
partX = x;
|
||
partY += 14;
|
||
part = MapView.Text(text, brush, 11);
|
||
}
|
||
context.DrawText(part, new Point(partX, partY));
|
||
partX += part.Width + 6;
|
||
first = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>What happened at a station, each part with its colour.</summary>
|
||
private IEnumerable<(string Text, IBrush Brush)> Chips(StationProgress row, CultureInfo culture)
|
||
{
|
||
switch (row.Outcome)
|
||
{
|
||
case StationOutcome.Ahead:
|
||
if (row.Row.Maintenance)
|
||
yield return (Strings["TtTechnical"], Palette.FaintText);
|
||
yield break;
|
||
case StationOutcome.Passed:
|
||
yield return (string.Format(culture, Strings["TtPassed"], Clock(row.DepartureClock)), Palette.DimText);
|
||
if (row.DepartureDelay is { } passDelay)
|
||
yield return (string.Format(culture, Strings["Minutes"], passDelay), DelayBrush(passDelay));
|
||
yield break;
|
||
}
|
||
if (row.ArrivedAt is null)
|
||
{
|
||
yield return (Strings["TtMissed"], Palette.Bad);
|
||
yield break;
|
||
}
|
||
yield return (string.Format(culture, Strings["TtArrived"], Clock(row.ArrivalClock)), Palette.DimText);
|
||
if (row.ArrivalDelay is { } arrival)
|
||
yield return (string.Format(culture, Strings["Minutes"], arrival), DelayBrush(arrival));
|
||
if (row.Outcome == StationOutcome.Missed)
|
||
yield return (Strings["TtLeftEarly"], Palette.Bad);
|
||
else if (row.DepartedAt is not null)
|
||
{
|
||
yield return (string.Format(culture, Strings["TtDeparted"], Clock(row.DepartureClock)), Palette.DimText);
|
||
if (row.DepartureDelay is { } departure)
|
||
yield return (string.Format(culture, Strings["Minutes"], departure), DelayBrush(departure));
|
||
}
|
||
else
|
||
yield return (Strings["TtStanding"], Palette.Station);
|
||
if (row.StopError is { } error)
|
||
yield return Math.Abs(error) < 1
|
||
? (Strings["TtStopExact"], Palette.Good)
|
||
: (string.Format(culture, Strings[error > 0 ? "TtStopShort" : "TtStopPast"], Math.Abs(error)),
|
||
Math.Abs(error) <= 5 ? Palette.Good : Math.Abs(error) <= 15 ? Palette.Warn : Palette.Bad);
|
||
if (row.OnPlatform is { } along)
|
||
yield return along
|
||
? (Strings["TtOnPlatform"], Palette.Good)
|
||
: (string.Format(culture, Strings["TtOffPlatform"], row.OffPlatform ?? 0), Palette.Bad);
|
||
}
|
||
|
||
private static IBrush DelayBrush(double? minutes) => Palette.Delay(minutes);
|
||
|
||
private static string Minutes(float minutes) =>
|
||
minutes < 0 ? "–" : TimeSpan.FromMinutes(minutes).ToString(@"hh\:mm", CultureInfo.InvariantCulture);
|
||
|
||
private static string Clock(double? minutes) =>
|
||
minutes is { } m ? TimeSpan.FromMinutes(m % 1440).ToString(@"hh\:mm\:ss", CultureInfo.InvariantCulture) : "–";
|
||
|
||
private int RowAt(Point p)
|
||
{
|
||
int i = (int)Math.Floor((p.Y - HeaderHeight) / RowHeight);
|
||
return p.Y >= HeaderHeight && i >= 0 && i < _rows.Count ? i : -1;
|
||
}
|
||
|
||
protected override void OnPointerMoved(PointerEventArgs e)
|
||
{
|
||
base.OnPointerMoved(e);
|
||
int hover = RowAt(e.GetPosition(this));
|
||
if (hover != _hover)
|
||
{
|
||
_hover = hover;
|
||
InvalidateVisual();
|
||
}
|
||
}
|
||
|
||
protected override void OnPointerExited(PointerEventArgs e)
|
||
{
|
||
base.OnPointerExited(e);
|
||
_hover = -1;
|
||
InvalidateVisual();
|
||
}
|
||
|
||
protected override void OnPointerPressed(PointerPressedEventArgs e)
|
||
{
|
||
base.OnPointerPressed(e);
|
||
int i = RowAt(e.GetPosition(this));
|
||
if (i >= 0 && (_rows[i].ArrivedAt ?? _rows[i].DepartedAt) is { } t)
|
||
Seek?.Invoke(Math.Max(0, t - 5));
|
||
}
|
||
}
|