diff --git a/StarterNG/Controls/KeySlot.cs b/StarterNG/Controls/KeySlot.cs
new file mode 100644
index 0000000..c274075
--- /dev/null
+++ b/StarterNG/Controls/KeySlot.cs
@@ -0,0 +1,21 @@
+using Avalonia;
+using Avalonia.Controls;
+
+namespace StarterNG.Controls;
+
+///
+/// Where the settings layout wants the row of one of the SimulatorKeys, so it
+/// sits among the rows it belongs with; the row is put in when the page is built.
+///
+public sealed class KeySlot : Decorator
+{
+ public static readonly StyledProperty KeyProperty =
+ AvaloniaProperty.Register(nameof(Key));
+
+ /// The eu07.ini key whose row goes here.
+ public string? Key
+ {
+ get => GetValue(KeyProperty);
+ set => SetValue(KeyProperty, value);
+ }
+}
diff --git a/StarterNG/Controls/SettingRow.cs b/StarterNG/Controls/SettingRow.cs
index bee10d4..42a993b 100644
--- a/StarterNG/Controls/SettingRow.cs
+++ b/StarterNG/Controls/SettingRow.cs
@@ -17,6 +17,13 @@ public class SettingRow : ContentControl
public static readonly StyledProperty ValueTextProperty =
AvaloniaProperty.Register(nameof(ValueText));
+ ///
+ /// Why the simulator to be started would pass this setting over; the row dims
+ /// and says so. The input stays usable - the file may serve another build.
+ ///
+ public static readonly StyledProperty IdleNoteProperty =
+ AvaloniaProperty.Register(nameof(IdleNote));
+
public string? Label
{
get => GetValue(LabelProperty);
@@ -41,6 +48,12 @@ public class SettingRow : ContentControl
set => SetValue(ValueTextProperty, value);
}
+ public string? IdleNote
+ {
+ get => GetValue(IdleNoteProperty);
+ set => SetValue(IdleNoteProperty, value);
+ }
+
public SettingRow()
{
UpdatePseudoClasses();
@@ -54,8 +67,12 @@ public class SettingRow : ContentControl
change.Property == DescriptionProperty ||
change.Property == ConfigKeyProperty ||
change.Property == ValueTextProperty ||
+ change.Property == IdleNoteProperty ||
change.Property == ContentProperty)
UpdatePseudoClasses();
+
+ if (change.Property == IdleNoteProperty)
+ ToolTip.SetTip(this, string.IsNullOrEmpty(IdleNote) ? null : IdleNote);
}
private void UpdatePseudoClasses()
@@ -65,5 +82,6 @@ public class SettingRow : ContentControl
PseudoClasses.Set(":no-key", string.IsNullOrEmpty(ConfigKey));
PseudoClasses.Set(":no-value", string.IsNullOrEmpty(ValueText));
PseudoClasses.Set(":no-content", Content is null);
+ PseudoClasses.Set(":idle", !string.IsNullOrEmpty(IdleNote));
}
}
diff --git a/StarterNG/Controls/SettingsSection.cs b/StarterNG/Controls/SettingsSection.cs
index 7cb092d..02fd743 100644
--- a/StarterNG/Controls/SettingsSection.cs
+++ b/StarterNG/Controls/SettingsSection.cs
@@ -1,4 +1,6 @@
+using System;
using Avalonia;
+using Avalonia.Controls;
using Avalonia.Controls.Primitives;
namespace StarterNG.Controls;
@@ -8,9 +10,56 @@ public class SettingsSection : HeaderedContentControl
public static readonly StyledProperty ToggleProperty =
AvaloniaProperty.Register(nameof(Toggle));
+ public static readonly StyledProperty ToggleKeyProperty =
+ AvaloniaProperty.Register(nameof(ToggleKey));
+
+ public static readonly StyledProperty ResetLabelProperty =
+ AvaloniaProperty.Register(nameof(ResetLabel));
+
+ public static readonly StyledProperty LevelProperty =
+ AvaloniaProperty.Register(nameof(Level));
+
+ private Button? _reset;
+
+ /// The header's choice of a level of detail for this section alone; none where it has no such thing.
+ public object? Level
+ {
+ get => GetValue(LevelProperty);
+ set => SetValue(LevelProperty, value);
+ }
+
public object? Toggle
{
get => GetValue(ToggleProperty);
set => SetValue(ToggleProperty, value);
}
+
+ /// The eu07.ini key the header's switch sets.
+ public string? ToggleKey
+ {
+ get => GetValue(ToggleKeyProperty);
+ set => SetValue(ToggleKeyProperty, value);
+ }
+
+ /// The words on the header's button that puts the section back as the simulator has it; none, no button.
+ public string? ResetLabel
+ {
+ get => GetValue(ResetLabelProperty);
+ set => SetValue(ResetLabelProperty, value);
+ }
+
+ /// Raised when the header's reset button is pressed.
+ public event Action? ResetRequested;
+
+ protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
+ {
+ base.OnApplyTemplate(e);
+ if (_reset is not null)
+ _reset.Click -= OnResetClick;
+ _reset = e.NameScope.Find("PART_Reset");
+ if (_reset is not null)
+ _reset.Click += OnResetClick;
+ }
+
+ private void OnResetClick(object? sender, Avalonia.Interactivity.RoutedEventArgs e) => ResetRequested?.Invoke(this);
}
diff --git a/StarterNG/Styles/Carbon.axaml b/StarterNG/Styles/Carbon.axaml
index e58c9a5..736d216 100644
--- a/StarterNG/Styles/Carbon.axaml
+++ b/StarterNG/Styles/Carbon.axaml
@@ -20,6 +20,12 @@
-
+
+
@@ -99,6 +111,24 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/StarterNG/Views/AdvancedSettingsWindow.cs b/StarterNG/Views/AdvancedSettingsWindow.cs
deleted file mode 100644
index f54d609..0000000
--- a/StarterNG/Views/AdvancedSettingsWindow.cs
+++ /dev/null
@@ -1,187 +0,0 @@
-using System;
-using Avalonia.Controls;
-using Avalonia.Controls.Primitives;
-using Avalonia.Layout;
-using Avalonia.Media;
-using StarterNG.Infrastructure;
-using StarterNG.Application;
-
-namespace StarterNG.Views;
-
-public sealed class AdvancedSettingsWindow : Window
-{
- private readonly TextBox _log = new()
- {
- IsReadOnly = true,
- AcceptsReturn = true,
- TextWrapping = TextWrapping.NoWrap,
- FontFamily = MonoFont.Family,
- FontSize = 12
- };
-
- private readonly CheckBox _compressTex = new();
- private readonly CheckBox _mipmaps = new();
- private readonly CheckBox _scaleSpeculars = new();
- private readonly CheckBox _shaderGamma = new();
- private readonly CheckBox _useGles = new();
- private readonly CheckBox _convertModels = new();
- private readonly CheckBox _resourceMove = new();
- private readonly CheckBox _resourceSweep = new();
- private readonly CheckBox _ignoreIrrelevant = new();
- private readonly Slider _threads = new() { Minimum = 0, Maximum = 16, TickFrequency = 1, IsSnapToTickEnabled = true };
- private readonly TextBlock _threadsValue = new() { VerticalAlignment = VerticalAlignment.Center, MinWidth = 24 };
-
- public event Action? ToolRequested;
-
- public AdvancedSettingsWindow()
- {
- Title = App.Loc["AdvancedSettings"];
- Width = 620;
- Height = 470;
- MinWidth = 480;
- MinHeight = 360;
- WindowStartupLocation = WindowStartupLocation.CenterOwner;
-
- _compressTex.Content = App.Loc["CompressTextures"];
- _mipmaps.Content = App.Loc["ScreenMipmaps"];
- _scaleSpeculars.Content = App.Loc["ScaleSpeculars"];
- _shaderGamma.Content = App.Loc["ShaderGamma"];
- _useGles.Content = App.Loc["UseGLES"];
- _convertModels.Content = App.Loc["ExtendedModelConversion"];
- _resourceMove.Content = App.Loc["GfxResourceMove"];
- _resourceSweep.Content = App.Loc["GfxResourceSweep"];
- _ignoreIrrelevant.Content = App.Loc["IgnoreIrrelevantTrains"];
- _threads.PropertyChanged += (_, e) =>
- {
- if (e.Property == RangeBase.ValueProperty)
- _threadsValue.Text = ((int)_threads.Value).ToString();
- };
-
- Load();
-
- var tabs = new TabControl();
- tabs.Items.Add(new TabItem { Header = App.Loc["AdvLogPage"], Content = BuildLogPage() });
- tabs.Items.Add(new TabItem { Header = App.Loc["Advanced"], Content = BuildOptionsPage() });
- tabs.Items.Add(new TabItem { Header = App.Loc["Tools"], Content = BuildToolsPage() });
-
- var close = new Button
- {
- Content = App.Loc["Close"],
- MinWidth = 100,
- HorizontalAlignment = HorizontalAlignment.Right,
- Margin = new Avalonia.Thickness(0, 8, 0, 0),
- Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand)
- };
- close.Classes.Add("Accent");
- close.Click += (_, _) => { Store(); Close(); };
-
- var root = new DockPanel { Margin = new Avalonia.Thickness(10) };
- DockPanel.SetDock(close, Dock.Bottom);
- root.Children.Add(close);
- root.Children.Add(tabs);
- Content = root;
- }
-
- private Control BuildLogPage()
- {
- _log.Text = Diagnostics.Text;
-
- var clear = new Button
- {
- Content = App.Loc["AdvClearLog"],
- Margin = new Avalonia.Thickness(0, 8, 0, 0),
- HorizontalAlignment = HorizontalAlignment.Left,
- Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand)
- };
- clear.Classes.Add("Flat");
- clear.Click += (_, _) => { Diagnostics.Clear(); _log.Text = ""; };
-
- ScrollViewer.SetHorizontalScrollBarVisibility(_log, ScrollBarVisibility.Auto);
- ScrollViewer.SetVerticalScrollBarVisibility(_log, ScrollBarVisibility.Auto);
-
- var panel = new DockPanel { Margin = new Avalonia.Thickness(8) };
- DockPanel.SetDock(clear, Dock.Bottom);
- panel.Children.Add(clear);
- panel.Children.Add(_log);
- return panel;
- }
-
- private Control BuildOptionsPage()
- {
- var sp = new StackPanel { Margin = new Avalonia.Thickness(10), Spacing = 8 };
- foreach (var c in new Control[]
- {
- _compressTex, _scaleSpeculars, _useGles, _shaderGamma, _mipmaps,
- _convertModels, _resourceMove, _resourceSweep, _ignoreIrrelevant
- })
- sp.Children.Add(c);
-
- var row = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Margin = new Avalonia.Thickness(0, 6, 0, 0) };
- row.Children.Add(new TextBlock
- {
- Text = App.Loc["TrainPhysicsThreads"],
- VerticalAlignment = VerticalAlignment.Center
- });
- _threads.Width = 220;
- row.Children.Add(_threads);
- row.Children.Add(_threadsValue);
- sp.Children.Add(row);
-
- return new ScrollViewer { Content = sp, VerticalScrollBarVisibility = ScrollBarVisibility.Auto };
- }
-
- private Control BuildToolsPage()
- {
- var sp = new StackPanel { Margin = new Avalonia.Thickness(10), Spacing = 8 };
-
- Button Tool(string key, string tag)
- {
- var b = new Button
- {
- Content = App.Loc[key],
- HorizontalAlignment = HorizontalAlignment.Stretch,
- HorizontalContentAlignment = HorizontalAlignment.Center,
- Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand)
- };
- b.Classes.Add("Flat");
- b.Click += (_, _) => ToolRequested?.Invoke(tag);
- return b;
- }
-
- sp.Children.Add(Tool("AddAllCategory", "category"));
- sp.Children.Add(Tool("AddUniqueMmd", "mmd"));
- sp.Children.Add(Tool("RemoveAllTrains", "removeall"));
- return sp;
- }
-
- private void Load()
- {
- var s = AppServices.Current.Settings;
- _compressTex.IsChecked = s.CompressTextures;
- _mipmaps.IsChecked = s.ScreenMipmaps;
- _scaleSpeculars.IsChecked = s.ScaleSpeculars;
- _shaderGamma.IsChecked = s.ShaderGamma;
- _useGles.IsChecked = s.UseGLES;
- _convertModels.IsChecked = s.ExtendedModelConversion;
- _resourceMove.IsChecked = s.GfxResourceMove;
- _resourceSweep.IsChecked = s.GfxResourceSweep;
- _ignoreIrrelevant.IsChecked = s.IgnoreIrrelevantTrains;
- _threads.Value = s.TrainPhysicsThreads;
- _threadsValue.Text = s.TrainPhysicsThreads.ToString();
- }
-
- private void Store()
- {
- var s = AppServices.Current.Settings;
- s.CompressTextures = _compressTex.IsChecked == true;
- s.ScreenMipmaps = _mipmaps.IsChecked == true;
- s.ScaleSpeculars = _scaleSpeculars.IsChecked == true;
- s.ShaderGamma = _shaderGamma.IsChecked == true;
- s.UseGLES = _useGles.IsChecked == true;
- s.ExtendedModelConversion = _convertModels.IsChecked == true;
- s.GfxResourceMove = _resourceMove.IsChecked == true;
- s.GfxResourceSweep = _resourceSweep.IsChecked == true;
- s.IgnoreIrrelevantTrains = _ignoreIrrelevant.IsChecked == true;
- s.TrainPhysicsThreads = (int)_threads.Value;
- }
-}
diff --git a/StarterNG/Views/Developer.axaml b/StarterNG/Views/Developer.axaml
deleted file mode 100644
index 3dc1bc7..0000000
--- a/StarterNG/Views/Developer.axaml
+++ /dev/null
@@ -1,65 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/StarterNG/Views/Developer.axaml.cs b/StarterNG/Views/Developer.axaml.cs
deleted file mode 100644
index cac678d..0000000
--- a/StarterNG/Views/Developer.axaml.cs
+++ /dev/null
@@ -1,78 +0,0 @@
-using System;
-using System.Globalization;
-using System.Linq;
-using Avalonia.Controls;
-using Avalonia.Interactivity;
-using Avalonia.Markup.Xaml;
-using StarterNG.Application;
-using StarterNG.Domain.Vehicles;
-
-namespace StarterNG.Views;
-
-///
-/// The developer tab: what the starter read out of the installation, and the state
-/// of the JSON copy it keeps of it. Read-only apart from rebuilding that copy.
-///
-public partial class Developer : UserControl
-{
- public Developer()
- {
- InitializeComponent();
- }
-
- private void InitializeComponent() => AvaloniaXamlLoader.Load(this);
-
- /// Fills the panel from the catalogue as it stands right now.
- public void Refresh()
- {
- var catalog = AppServices.Current.Library.Vehicles;
- var status = AppServices.Current.VehicleCache.Status;
-
- VehiclesValue.Text = Count(catalog.TextureByUuid.Values
- .Select(texture => texture.Directory)
- .Distinct(StringComparer.OrdinalIgnoreCase)
- .Count());
- LiveriesValue.Text = Wrecks(catalog);
- GroupsValue.Text = Count(catalog.GroupsById.Count);
- SetsValue.Text = Count(catalog.Sets.Count);
- FilesValue.Text = Count(status.Sources);
- SourceValue.Text = App.Loc[status.ServedFromCopy ? "DevSourceCopy" : "DevSourceTextures"];
- WrittenValue.Text = status.Written is { } written
- ? written.ToLocalTime().ToString("yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture)
- : "-";
- LocationValue.Text = status.Directory;
- RebuildStatus.Text = "";
- }
-
- ///
- /// Rebuilds the copy on disk without disturbing the catalogue the other tabs
- /// are already drawn from - the vehicles on screen keep pointing at the entries
- /// they were built with.
- ///
- private void RebuildButton_OnClick(object? sender, RoutedEventArgs e)
- {
- RebuildButton.IsEnabled = false;
- try
- {
- int liveries = AppServices.Current.VehicleCache
- .Rebuild(new VehicleCatalog(AppServices.Current.MiniTextures));
- Refresh();
- RebuildStatus.Text = $"{App.Loc["DevRebuilt"]} ({liveries})";
- }
- finally
- {
- RebuildButton.IsEnabled = true;
- }
- }
-
- /// Liveries offered, saying so when wrecks are being held back.
- private static string Wrecks(VehicleCatalog catalog)
- {
- int wrecks = catalog.TextureByUuid.Count - catalog.Textures.Count;
- return wrecks > 0
- ? $"{Count(catalog.Textures.Count)} (+{Count(wrecks)} {App.Loc["DevWrecks"]})"
- : Count(catalog.Textures.Count);
- }
-
- private static string Count(int value) => value.ToString(CultureInfo.InvariantCulture);
-}
diff --git a/StarterNG/Views/ExeProblemText.cs b/StarterNG/Views/ExeProblemText.cs
index 58161a1..b3a3dde 100644
--- a/StarterNG/Views/ExeProblemText.cs
+++ b/StarterNG/Views/ExeProblemText.cs
@@ -8,6 +8,7 @@ public static class ExeProblemText
public static string Key(ExeProblem problem) => problem switch
{
ExeProblem.NotExecutable => "ExeNotExecutable",
+ ExeProblem.NotAProgram => "ExeNotAProgram",
ExeProblem.WrongPlatform => "ExeWrongPlatform",
_ => "ExeNotFound"
};
diff --git a/StarterNG/Views/IniChangesWindow.cs b/StarterNG/Views/IniChangesWindow.cs
new file mode 100644
index 0000000..0af2bfe
--- /dev/null
+++ b/StarterNG/Views/IniChangesWindow.cs
@@ -0,0 +1,93 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Documents;
+using Avalonia.Media;
+using StarterNG.Application;
+using StarterNG.Infrastructure;
+
+namespace StarterNG.Views;
+
+/// What a save would change in eu07.ini, key by key, before it is made.
+internal static class IniChangesWindow
+{
+ private static readonly IBrush Dim = new SolidColorBrush(Color.Parse("#9098A0"));
+ private static readonly IBrush New = new SolidColorBrush(Color.Parse("#41C400"));
+
+ /// Whether the save was asked for.
+ public static async Task Show(Window owner, string path, IReadOnlyList changes,
+ bool keyboardChanged)
+ {
+ var win = MessageBox.FixedDialog(App.Loc["IniChangesTitle"], 680);
+
+ var list = new StackPanel { Spacing = 2 };
+ AddGroup(list, App.Loc["IniChangesChanged"], changes.Where(c => c.Before is not null && c.After is not null));
+ AddGroup(list, App.Loc["IniChangesAdded"], changes.Where(c => c.Before is null));
+ AddGroup(list, App.Loc["IniChangesRemoved"], changes.Where(c => c.After is null));
+
+ var body = new StackPanel { Margin = new Thickness(16), Spacing = 12 };
+ body.Children.Add(new TextBlock
+ {
+ Text = path, Foreground = Dim, FontSize = 12, TextTrimming = TextTrimming.CharacterEllipsis
+ });
+ body.Children.Add(changes.Count == 0
+ ? new TextBlock { Text = App.Loc["IniChangesNone"], TextWrapping = TextWrapping.Wrap }
+ : new ScrollViewer { MaxHeight = 440, Content = list });
+ if (keyboardChanged)
+ body.Children.Add(new TextBlock { Text = App.Loc["IniChangesKeyboard"], TextWrapping = TextWrapping.Wrap });
+
+ bool save = false;
+ var saveBtn = new Button { Content = App.Loc["Save"], MinWidth = 80 };
+ saveBtn.Classes.Add("Accent");
+ saveBtn.IsEnabled = changes.Count > 0 || keyboardChanged;
+ saveBtn.Click += (_, _) => { save = true; win.Close(); };
+ var closeBtn = new Button { Content = App.Loc["Close"], MinWidth = 80 };
+ closeBtn.Classes.Add("Flat");
+ closeBtn.Click += (_, _) => win.Close();
+ body.Children.Add(MessageBox.ButtonRow(saveBtn, closeBtn));
+
+ win.Content = body;
+ await win.ShowDialog(owner);
+ return save;
+ }
+
+ private static void AddGroup(Panel list, string title, IEnumerable group)
+ {
+ var changes = group.ToList();
+ if (changes.Count == 0)
+ return;
+
+ list.Children.Add(new TextBlock
+ {
+ Text = $"{title} ({changes.Count})",
+ FontWeight = FontWeight.SemiBold,
+ Margin = new Thickness(0, list.Children.Count == 0 ? 0 : 12, 0, 4)
+ });
+ foreach (var change in changes)
+ {
+ var row = new Grid { ColumnDefinitions = new ColumnDefinitions("240,*") };
+ row.Children.Add(new TextBlock
+ {
+ Text = change.Key, FontFamily = MonoFont.Family, FontSize = 12,
+ TextTrimming = TextTrimming.CharacterEllipsis
+ });
+
+ var value = new TextBlock { FontFamily = MonoFont.Family, FontSize = 12, TextWrapping = TextWrapping.Wrap };
+ if (change.Before is not null)
+ value.Inlines!.Add(new Run(change.Before)
+ {
+ Foreground = Dim,
+ TextDecorations = change.After is null ? TextDecorations.Strikethrough : null
+ });
+ if (change.Before is not null && change.After is not null)
+ value.Inlines!.Add(new Run(" → ") { Foreground = Dim });
+ if (change.After is not null)
+ value.Inlines!.Add(new Run(change.After) { Foreground = New });
+ Grid.SetColumn(value, 1);
+ row.Children.Add(value);
+ list.Children.Add(row);
+ }
+ }
+}
diff --git a/StarterNG/Views/KeyBindingsTab.cs b/StarterNG/Views/KeyBindingsTab.cs
new file mode 100644
index 0000000..0670b56
--- /dev/null
+++ b/StarterNG/Views/KeyBindingsTab.cs
@@ -0,0 +1,688 @@
+using System;
+using System.Collections.Generic;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Input;
+using Avalonia.Layout;
+using Avalonia.Media;
+using StarterNG.Classes;
+using StarterNG.Infrastructure;
+
+using KeyBinding = StarterNG.Classes.KeyBinding;
+
+namespace StarterNG.Views;
+
+///
+/// The key bindings of the settings screen: the list of commands, the keyboard they
+/// sit on, and the wait for a keypress.
+///
+internal sealed class KeyBindingsTab(Grid host, TextBox search)
+{
+ /// Raised on an edit by hand.
+ public event Action? Changed;
+
+ private StackPanel? _bindingListPanel;
+ private StackPanel? _keyboardPanel;
+
+ ///
+ /// True while a cab-control binding is waiting for a keypress. The window's own
+ /// shortcuts stand down for the duration, otherwise Ctrl+N would never reach here.
+ ///
+ public bool IsCapturing => _capturing is not null;
+
+ private KeyBinding? _capturing;
+ private Button? _capturingButton;
+
+ private readonly Dictionary _keyCells = new(StringComparer.OrdinalIgnoreCase);
+
+ private bool _flyoutLoading;
+
+ private static readonly IBrush KeyUnassignedBrush = new SolidColorBrush(Color.Parse("#2A3036"));
+ private static readonly IBrush KeyFillerBrush = new SolidColorBrush(Color.Parse("#21262B"));
+ private static readonly IBrush KeyPlainBrush = new SolidColorBrush(Color.Parse("#2E9E1F"));
+ private static readonly IBrush KeyShiftBrush = new SolidColorBrush(Color.Parse("#C9A227"));
+ private static readonly IBrush KeyCtrlBrush = new SolidColorBrush(Color.Parse("#2D7FD3"));
+ private static readonly IBrush KeyShiftCtrlBrush = new SolidColorBrush(Color.Parse("#C8372D"));
+ private static readonly IBrush KeyBorderBrush = new SolidColorBrush(Color.Parse("#3A424A"));
+ private static readonly IBrush FgBrush = new SolidColorBrush(Color.Parse("#E6E8EA"));
+ private static readonly IBrush FgDimBrush = new SolidColorBrush(Color.Parse("#9098A0"));
+ private static readonly IBrush ConflictBrush = new SolidColorBrush(Color.Parse("#E06C5A"));
+
+ // The four combinations a key can be on. After the brushes: static fields start in text order.
+ private static readonly (bool Shift, bool Ctrl, string SlotTextKey, IBrush Colour)[] ModifierSlots =
+ {
+ (false, false, "BindNoMod", KeyPlainBrush),
+ (true, false, "BindShift", KeyShiftBrush),
+ (false, true, "BindCtrl", KeyCtrlBrush),
+ (true, true, "BindShiftCtrl", KeyShiftCtrlBrush),
+ };
+
+ private const double KeyUnit = 30;
+ private const double KeyHeight = 34;
+ private const double KeyGap = 4;
+
+ public void Build()
+ {
+ CancelCapture();
+ host.Children.Clear();
+
+ var head = new StackPanel { Spacing = 6, Margin = new Thickness(0, 0, 0, 8) };
+ var topBar = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8 };
+ topBar.Children.Add(new TextBlock
+ {
+ Text = App.Loc["BindingsHint"],
+ VerticalAlignment = VerticalAlignment.Center,
+ Foreground = FgDimBrush
+ });
+ var restoreBtn = new Button { Content = App.Loc["RestoreDefaults"] };
+ restoreBtn.Classes.Add("Flat");
+ restoreBtn.Click += (_, _) =>
+ {
+ CancelCapture();
+ KeyboardConfig.Instance.LoadDefaults();
+ BindingsEdited();
+ };
+ topBar.Children.Add(restoreBtn);
+ head.Children.Add(topBar);
+
+ _numpadText = new TextBlock
+ {
+ Foreground = FgBrush,
+ FontSize = 12,
+ TextWrapping = TextWrapping.Wrap,
+ VerticalAlignment = VerticalAlignment.Center
+ };
+ var numpadShow = new Button
+ {
+ Content = App.Loc["BindingsNumpadShow"],
+ VerticalAlignment = VerticalAlignment.Center,
+ HorizontalContentAlignment = HorizontalAlignment.Center
+ };
+ numpadShow.Classes.Add("Flat");
+ numpadShow.Click += (_, _) => search.Text = KeyMap.NumpadPrefix;
+ Grid.SetColumn(numpadShow, 1);
+ _numpadNote = new Border
+ {
+ BorderBrush = ConflictBrush,
+ BorderThickness = new Thickness(1),
+ CornerRadius = new CornerRadius(2),
+ Padding = new Thickness(8, 4),
+ Child = new Grid
+ {
+ ColumnDefinitions = new ColumnDefinitions("*,Auto"),
+ ColumnSpacing = 8,
+ Children = { _numpadText, numpadShow }
+ }
+ };
+ head.Children.Add(_numpadNote);
+ Grid.SetRow(head, 0);
+ host.Children.Add(head);
+
+ _bindingListPanel = new StackPanel { Spacing = 3 };
+ var listScroll = new ScrollViewer
+ {
+ Content = _bindingListPanel,
+ VerticalScrollBarVisibility = ScrollBarVisibility.Auto
+ };
+ Grid.SetRow(listScroll, 1);
+ host.Children.Add(listScroll);
+
+ var bottom = new StackPanel { Spacing = 8, Margin = new Thickness(0, 10, 0, 0) };
+ bottom.Children.Add(BuildLegend());
+ _keyboardPanel = new StackPanel();
+ bottom.Children.Add(new ScrollViewer
+ {
+ Content = _keyboardPanel,
+ HorizontalScrollBarVisibility = ScrollBarVisibility.Auto,
+ VerticalScrollBarVisibility = ScrollBarVisibility.Disabled
+ });
+ Grid.SetRow(bottom, 2);
+ host.Children.Add(bottom);
+
+ RedrawBindings();
+ }
+
+ /// The bindings as the file has them, and no key waited for.
+ public void Reload()
+ {
+ CancelCapture();
+ KeyboardConfig.Instance.Load();
+ RedrawBindings();
+ }
+
+ private void BindingsEdited()
+ {
+ KeyboardConfig.Instance.Dirty = true;
+ Changed?.Invoke();
+ RedrawBindings();
+ }
+
+ private void RedrawBindings()
+ {
+ RebuildList();
+ RebuildKeyboard();
+ }
+
+ public void RebuildList()
+ {
+ if (_bindingListPanel is null)
+ return;
+
+ _bindingListPanel.Children.Clear();
+ // The sidebar search box serves this list too - see Settings.ApplyFilter.
+ string filter = search.Text?.Trim() ?? string.Empty;
+ var conflicts = KeyboardConfig.Instance.ConflictingCombos();
+
+ foreach (var b in KeyboardConfig.Instance.Bindings)
+ {
+ if (filter.Length > 0 && !MatchesFilter(b, filter))
+ continue;
+ _bindingListPanel.Children.Add(BuildBindingRow(b, conflicts));
+ }
+
+ UpdateNumpadNote();
+ }
+
+ private Border? _numpadNote;
+ private TextBlock? _numpadText;
+
+ ///
+ /// Said whenever a binding uses the numpad: neither Windows nor Linux tells whether a
+ /// keyboard has one, a keyboard without it reports the same as any other.
+ ///
+ private void UpdateNumpadNote()
+ {
+ if (_numpadNote is null || _numpadText is null)
+ return;
+
+ int onNumpad = KeyboardConfig.Instance.BindingsOnNumpad();
+ _numpadNote.IsVisible = onNumpad > 0;
+ _numpadText.Text = string.Format(App.Loc["BindingsNumpadNote"], onNumpad);
+ }
+
+ private static bool MatchesFilter(KeyBinding b, string filter) =>
+ TextMatch.Contains(b.Command, filter) ||
+ TextMatch.Contains(b.Key, filter) ||
+ TextMatch.Contains(KeyboardConfig.Instance.DescriptionOf(b, TranslatedCommand), filter);
+
+ // Polish reads the bundled key file, which has the descriptions with Polish letters.
+ private static string TranslatedCommand(string command) =>
+ string.Equals(App.Loc.CurrentLangCode, "pl", StringComparison.OrdinalIgnoreCase)
+ ? string.Empty
+ : App.Loc.OptOrEnglish("Cmd." + command);
+
+ private Control BuildBindingRow(KeyBinding b, HashSet conflicts)
+ {
+ var grid = new Grid
+ {
+ ColumnDefinitions = new ColumnDefinitions("*,Auto,Auto"),
+ VerticalAlignment = VerticalAlignment.Center
+ };
+
+ var label = new StackPanel { VerticalAlignment = VerticalAlignment.Center };
+ label.Children.Add(new TextBlock
+ {
+ Text = CommandLabel(b),
+ Foreground = FgBrush,
+ FontSize = 12,
+ TextTrimming = TextTrimming.CharacterEllipsis
+ });
+ label.Children.Add(new TextBlock
+ {
+ Text = b.Command,
+ Foreground = FgDimBrush,
+ FontSize = 12,
+ TextTrimming = TextTrimming.CharacterEllipsis
+ });
+ Grid.SetColumn(label, 0);
+ grid.Children.Add(label);
+
+ var simulatorUse = b.IsAssigned ? KeyMap.SimulatorUse(b.Key, b.Shift, b.Ctrl) : null;
+ bool conflict = (b.IsAssigned && conflicts.Contains(b.ComboKey)) || simulatorUse is not null;
+ var comboButton = new Button
+ {
+ Content = _capturing == b ? App.Loc["PressKey"] : ComboText(b),
+ MinWidth = 140,
+ HorizontalContentAlignment = HorizontalAlignment.Center,
+ VerticalAlignment = VerticalAlignment.Center,
+ Foreground = conflict ? ConflictBrush : FgBrush
+ };
+ comboButton.Classes.Add("Flat");
+ if (simulatorUse is { } use)
+ ToolTip.SetTip(comboButton, SimulatorUseText(b.Key, b.Shift, b.Ctrl, use));
+ else if (conflict)
+ ToolTip.SetTip(comboButton, App.Loc["ConflictTooltip"]);
+ comboButton.Click += (_, _) => StartCapture(b, comboButton);
+ Grid.SetColumn(comboButton, 1);
+ grid.Children.Add(comboButton);
+
+ var clearButton = new Button
+ {
+ Content = "✕",
+ Margin = new Thickness(6, 0, 0, 0),
+ VerticalAlignment = VerticalAlignment.Center
+ };
+ clearButton.Classes.Add("Basic");
+ ToolTip.SetTip(clearButton, App.Loc["ClearBinding"]);
+ clearButton.Click += (_, _) =>
+ {
+ CancelCapture();
+ b.Clear();
+ BindingsEdited();
+ };
+ Grid.SetColumn(clearButton, 2);
+ grid.Children.Add(clearButton);
+
+ return new Border
+ {
+ Background = KeyUnassignedBrush,
+ BorderBrush = KeyBorderBrush,
+ BorderThickness = new Thickness(1),
+ CornerRadius = new CornerRadius(2),
+ Padding = new Thickness(8, 4),
+ Child = grid
+ };
+ }
+
+ private void StartCapture(KeyBinding b, Button button)
+ {
+
+ if (_capturing is not null && _capturingButton is not null)
+ _capturingButton.Content = ComboText(_capturing);
+
+ _capturing = b;
+ _capturingButton = button;
+ button.Content = App.Loc["PressKey"];
+ button.Focus();
+ }
+
+ private void CancelCapture()
+ {
+ if (_capturing is not null && _capturingButton is not null)
+ _capturingButton.Content = ComboText(_capturing);
+ _capturing = null;
+ _capturingButton = null;
+ }
+
+ public void OnKeyDown(object? sender, KeyEventArgs e)
+ {
+ if (_capturing is null)
+ return;
+
+ if (e.Key == Key.Escape)
+ {
+ CancelCapture();
+ e.Handled = true;
+ return;
+ }
+
+ if (KeyMap.IsModifierKey(e.Key))
+ return;
+
+ string? token = KeyMap.FromInput(e.Key, e.PhysicalKey);
+ if (token is null)
+ {
+ e.Handled = true;
+ return;
+ }
+
+ bool shift = e.KeyModifiers.HasFlag(KeyModifiers.Shift);
+ bool ctrl = e.KeyModifiers.HasFlag(KeyModifiers.Control);
+ if (KeyMap.SimulatorUse(token, shift, ctrl) is { Blocks: true } taken)
+ {
+ // Bound here it would never fire: the wait for a key goes on.
+ if (_capturingButton is not null)
+ _capturingButton.Content = string.Format(App.Loc["KbTaken"], App.Loc[taken.TextKey]);
+ e.Handled = true;
+ return;
+ }
+
+ // As the key flyout does: the combination moves here, not doubled up.
+ KeyboardConfig.Instance.Put(_capturing, token, shift, ctrl);
+ e.Handled = true;
+
+ _capturing = null;
+ _capturingButton = null;
+ BindingsEdited();
+ }
+
+ private void RebuildKeyboard()
+ {
+ if (_keyboardPanel is null)
+ return;
+
+ _keyCells.Clear();
+ _keyboardPanel.Children.Clear();
+ var states = ComputeKeyStates();
+
+ var row = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 14 };
+ row.Children.Add(BuildKeyBlock(KeyMap.MainBlock, states));
+ row.Children.Add(BuildKeyBlock(KeyMap.NavBlock, states));
+ row.Children.Add(BuildKeyBlock(KeyMap.NumpadBlock, states));
+ _keyboardPanel.Children.Add(row);
+ }
+
+ private void UpdateKeyboardColors()
+ {
+ var states = ComputeKeyStates();
+ foreach (var (token, content) in _keyCells)
+ {
+ if (content.Children.Count > 0)
+ content.Children.RemoveAt(0);
+ content.Children.Insert(0, BuildKeyBackground(token, states));
+ states.TryGetValue(token, out var state);
+ ToolTip.SetTip(content, BuildKeyTooltip(token, state));
+ }
+ }
+
+ private Control BuildKeyBlock(KeyCap[][] rows, Dictionary states)
+ {
+ var block = new StackPanel { Spacing = KeyGap, VerticalAlignment = VerticalAlignment.Top };
+ foreach (var rowCaps in rows)
+ {
+ var rowPanel = new StackPanel { Orientation = Orientation.Horizontal, Spacing = KeyGap };
+ foreach (var cap in rowCaps)
+ rowPanel.Children.Add(BuildKeyCap(cap, states));
+ block.Children.Add(rowPanel);
+ }
+ return block;
+ }
+
+ private Control BuildKeyCap(KeyCap cap, Dictionary states)
+ {
+ double width = cap.Width * KeyUnit + (cap.Width - 1) * KeyGap;
+ var content = new Grid { Width = width, Height = KeyHeight };
+
+ var keyBorder = new Border
+ {
+ BorderBrush = KeyBorderBrush,
+ BorderThickness = new Thickness(1),
+ CornerRadius = new CornerRadius(3),
+ ClipToBounds = true,
+ Child = content
+ };
+
+ if (cap.Token is null)
+ {
+
+ content.Children.Add(new Border { Background = KeyFillerBrush });
+ content.Children.Add(new TextBlock
+ {
+ Text = cap.Label,
+ Foreground = FgDimBrush,
+ FontSize = 9,
+ HorizontalAlignment = HorizontalAlignment.Center,
+ VerticalAlignment = VerticalAlignment.Center
+ });
+ keyBorder.Opacity = 0.55;
+ if (!string.IsNullOrEmpty(cap.Label))
+ ToolTip.SetTip(keyBorder, App.Loc[cap.Label switch
+ {
+ "Shift" or "Ctrl" => "KbModifier",
+ "Alt" => "KbAlt",
+ _ => "KbNotInSimulator"
+ }]);
+ return keyBorder;
+ }
+
+ string token = cap.Token;
+ states.TryGetValue(token.ToLowerInvariant(), out var st);
+ content.Children.Add(BuildKeyBackground(token, states));
+ content.Children.Add(new TextBlock
+ {
+ Text = cap.Label,
+ Foreground = FgBrush,
+ FontSize = 10,
+ FontWeight = FontWeight.SemiBold,
+ HorizontalAlignment = HorizontalAlignment.Center,
+ VerticalAlignment = VerticalAlignment.Center
+ });
+ ToolTip.SetTip(content, BuildKeyTooltip(token, st));
+
+ keyBorder.Cursor = new Cursor(StandardCursorType.Hand);
+ keyBorder.PointerPressed += (_, _) => ShowKeyFlyout(token, keyBorder);
+ _keyCells[token] = content;
+ return keyBorder;
+ }
+
+ private Control BuildKeyBackground(string token, Dictionary states)
+ {
+ states.TryGetValue(token.ToLowerInvariant(), out var state);
+ var colours = new List();
+ for (int i = 0; i < ModifierSlots.Length; i++)
+ if (state is not null && state.SlotOn[i])
+ colours.Add(ModifierSlots[i].Colour);
+
+ if (colours.Count == 0)
+ return new Border { Background = KeyUnassignedBrush };
+
+ var stripes = new UniformGrid { Rows = 1, Columns = colours.Count };
+ foreach (var c in colours)
+ stripes.Children.Add(new Border { Background = c });
+ return stripes;
+ }
+
+ private string BuildKeyTooltip(string token, KeyState? state)
+ {
+ string head = KeyMap.DisplayName(token);
+ var lines = new List();
+ if (state is null || state.Tips.Count == 0)
+ {
+ lines.Add($"{head}: {App.Loc["KbUnassigned"]}");
+ }
+ else
+ {
+ lines.Add(head);
+ lines.AddRange(state.Tips);
+ }
+ lines.AddRange(SimulatorNotes(token));
+ return string.Join("\n", lines);
+ }
+
+ private static string SimulatorUseText(string token, bool shift, bool ctrl, SimulatorKeyUse use) =>
+ string.Format(App.Loc[use.Blocks ? "KbSimBlocks" : "KbSimReplaces"],
+ KeyMap.ComboText(token, shift, ctrl),
+ App.Loc[use.TextKey]);
+
+ /// What the simulator does with this key by itself, once per thing it does.
+ private static List SimulatorNotes(string token)
+ {
+ var notes = new List();
+ var seen = new HashSet();
+ foreach (var (shift, ctrl, _, _) in ModifierSlots)
+ if (KeyMap.SimulatorUse(token, shift, ctrl) is { } use && seen.Add(use))
+ notes.Add(SimulatorUseText(token, shift, ctrl, use));
+ return notes;
+ }
+
+ private void ShowKeyFlyout(string token, Control anchor)
+ {
+ CancelCapture();
+ var commands = KeyboardConfig.Instance.Bindings;
+
+ var items = new List { App.Loc["BindNone"] };
+ foreach (var c in commands)
+ items.Add(CommandLabel(c));
+
+ var combos = new ComboBox[ModifierSlots.Length];
+ var grid = new Grid
+ {
+ ColumnDefinitions = new ColumnDefinitions("Auto,*"),
+ RowDefinitions = new RowDefinitions("Auto,Auto,Auto,Auto")
+ };
+
+ for (int i = 0; i < ModifierSlots.Length; i++)
+ {
+ var (shift, ctrl, labelKey, colour) = ModifierSlots[i];
+
+ // The swatch ties the row to the key colours on the keyboard above.
+ var lbl = new StackPanel
+ {
+ Orientation = Orientation.Horizontal,
+ Spacing = 6,
+ VerticalAlignment = VerticalAlignment.Center,
+ Margin = new Thickness(0, 4, 12, 4),
+ Children =
+ {
+ new Border
+ {
+ Width = 10, Height = 10, CornerRadius = new CornerRadius(2),
+ Background = colour, VerticalAlignment = VerticalAlignment.Center
+ },
+ new TextBlock { Text = App.Loc[labelKey], Foreground = FgBrush, VerticalAlignment = VerticalAlignment.Center }
+ }
+ };
+ Grid.SetRow(lbl, i);
+ Grid.SetColumn(lbl, 0);
+ grid.Children.Add(lbl);
+
+ var cb = new ComboBox
+ {
+ ItemsSource = items,
+ MinWidth = 280,
+ MaxDropDownHeight = 320,
+ Margin = new Thickness(0, 4),
+ HorizontalAlignment = HorizontalAlignment.Stretch
+ };
+ if (KeyMap.SimulatorUse(token, shift, ctrl) is { } use)
+ {
+ ToolTip.SetTip(cb, SimulatorUseText(token, shift, ctrl, use));
+ // What a hand-edited file put there can still be taken off.
+ cb.IsEnabled = !use.Blocks || KeyboardConfig.Instance.BindingAt(token, shift, ctrl) is not null;
+ }
+ cb.SelectionChanged += (_, _) =>
+ {
+ if (_flyoutLoading)
+ return;
+ AssignSlot(token, shift, ctrl, cb.SelectedIndex, commands);
+ SyncFlyoutCombos(token, combos);
+ UpdateKeyboardColors();
+ RebuildList();
+ };
+ Grid.SetRow(cb, i);
+ Grid.SetColumn(cb, 1);
+ grid.Children.Add(cb);
+ combos[i] = cb;
+ }
+
+ SyncFlyoutCombos(token, combos);
+
+ var panel = new StackPanel { Spacing = 8, Margin = new Thickness(12), MinWidth = 360 };
+ panel.Children.Add(new TextBlock
+ {
+ Text = $"{App.Loc["BindKeyTitle"]} {KeyMap.DisplayName(token)}",
+ FontWeight = FontWeight.SemiBold,
+ Foreground = FgBrush
+ });
+ panel.Children.Add(new TextBlock
+ {
+ Text = App.Loc["BindKeyHint"],
+ Foreground = FgDimBrush,
+ FontSize = 12,
+ TextWrapping = TextWrapping.Wrap
+ });
+ panel.Children.Add(grid);
+ foreach (string note in SimulatorNotes(token))
+ panel.Children.Add(new TextBlock
+ {
+ Text = note,
+ Foreground = ConflictBrush,
+ FontSize = 12,
+ TextWrapping = TextWrapping.Wrap,
+ MaxWidth = 460
+ });
+
+ var flyout = new Flyout { Content = panel };
+ flyout.ShowAt(anchor);
+ }
+
+ private void SyncFlyoutCombos(string token, ComboBox[] combos)
+ {
+ var commands = KeyboardConfig.Instance.Bindings;
+ _flyoutLoading = true;
+ for (int i = 0; i < combos.Length; i++)
+ {
+ var cmd = KeyboardConfig.Instance.BindingAt(token, ModifierSlots[i].Shift, ModifierSlots[i].Ctrl);
+ combos[i].SelectedIndex = cmd is null ? 0 : commands.IndexOf(cmd) + 1;
+ }
+ _flyoutLoading = false;
+ }
+
+ private void AssignSlot(string token, bool shift, bool ctrl, int selectedIndex, List commands)
+ {
+ KeyBinding? chosen = selectedIndex <= 0 ? null : commands[selectedIndex - 1];
+ KeyboardConfig.Instance.Put(chosen, token, shift, ctrl);
+ KeyboardConfig.Instance.Dirty = true;
+ Changed?.Invoke();
+ }
+
+ private Control BuildLegend()
+ {
+ var legend = new WrapPanel { Orientation = Orientation.Horizontal };
+ legend.Children.Add(LegendItem(KeyUnassignedBrush, App.Loc["KbUnassigned"]));
+ legend.Children.Add(LegendItem(KeyPlainBrush, App.Loc["KbAssigned"]));
+ legend.Children.Add(LegendItem(KeyShiftBrush, App.Loc["KbShift"]));
+ legend.Children.Add(LegendItem(KeyCtrlBrush, App.Loc["KbCtrl"]));
+ legend.Children.Add(LegendItem(KeyShiftCtrlBrush, App.Loc["KbShiftCtrl"]));
+ return legend;
+ }
+
+ private Control LegendItem(IBrush brush, string text)
+ {
+ var sp = new StackPanel
+ {
+ Orientation = Orientation.Horizontal,
+ Spacing = 6,
+ Margin = new Thickness(0, 0, 16, 0),
+ VerticalAlignment = VerticalAlignment.Center
+ };
+ sp.Children.Add(new Border
+ {
+ Width = 16,
+ Height = 16,
+ Background = brush,
+ BorderBrush = KeyBorderBrush,
+ BorderThickness = new Thickness(1),
+ CornerRadius = new CornerRadius(2),
+ VerticalAlignment = VerticalAlignment.Center
+ });
+ sp.Children.Add(new TextBlock { Text = text, Foreground = FgDimBrush, VerticalAlignment = VerticalAlignment.Center });
+ return sp;
+ }
+
+ private sealed class KeyState
+ {
+ /// Which of the
+ public readonly bool[] SlotOn = new bool[ModifierSlots.Length];
+ public readonly List Tips = new();
+ }
+
+ private static Dictionary ComputeKeyStates()
+ {
+ var map = new Dictionary(StringComparer.OrdinalIgnoreCase);
+ foreach (var b in KeyboardConfig.Instance.Bindings)
+ {
+ if (!b.IsAssigned)
+ continue;
+ string key = b.Key.ToLowerInvariant();
+ if (!map.TryGetValue(key, out var state))
+ map[key] = state = new KeyState();
+
+ state.SlotOn[Array.FindIndex(ModifierSlots, slot => slot.Shift == b.Shift && slot.Ctrl == b.Ctrl)] = true;
+
+ state.Tips.Add($"{ComboText(b)} — {CommandLabel(b)}");
+ }
+ return map;
+ }
+
+ private static string ComboText(KeyBinding b) => KeyMap.ComboText(b.Key, b.Shift, b.Ctrl);
+
+ private static string CommandLabel(KeyBinding b) =>
+ KeyboardConfig.Instance.DescriptionOf(b, TranslatedCommand) is { Length: > 0 } description
+ ? Capitalize(description)
+ : b.Command;
+
+ private static string Capitalize(string s) =>
+ string.IsNullOrEmpty(s) ? s : char.ToUpperInvariant(s[0]) + s.Substring(1);
+}
diff --git a/StarterNG/Views/LogAndToolsWindow.cs b/StarterNG/Views/LogAndToolsWindow.cs
new file mode 100644
index 0000000..0c0793d
--- /dev/null
+++ b/StarterNG/Views/LogAndToolsWindow.cs
@@ -0,0 +1,105 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Layout;
+using Avalonia.Media;
+using StarterNG.Infrastructure;
+
+namespace StarterNG.Views;
+
+///
+/// The starter's event log and the bulk depot tools. The options it used to carry
+/// live in the Advanced category of the settings now, where they are found.
+///
+public sealed class LogAndToolsWindow : Window
+{
+ private readonly TextBox _log = new()
+ {
+ IsReadOnly = true,
+ AcceptsReturn = true,
+ TextWrapping = TextWrapping.NoWrap,
+ FontFamily = MonoFont.Family,
+ FontSize = 12
+ };
+
+ public event Action? ToolRequested;
+
+ public LogAndToolsWindow()
+ {
+ Title = App.Loc["LogAndTools"];
+ Width = 620;
+ Height = 470;
+ MinWidth = 480;
+ MinHeight = 360;
+ WindowStartupLocation = WindowStartupLocation.CenterOwner;
+
+ var tabs = new TabControl();
+ tabs.Items.Add(new TabItem { Header = App.Loc["AdvLogPage"], Content = BuildLogPage() });
+ tabs.Items.Add(new TabItem { Header = App.Loc["Tools"], Content = BuildToolsPage() });
+
+ var close = new Button
+ {
+ Content = App.Loc["Close"],
+ MinWidth = 100,
+ HorizontalAlignment = HorizontalAlignment.Right,
+ Margin = new Avalonia.Thickness(0, 8, 0, 0),
+ Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand)
+ };
+ close.Classes.Add("Accent");
+ close.Click += (_, _) => Close();
+
+ var root = new DockPanel { Margin = new Avalonia.Thickness(10) };
+ DockPanel.SetDock(close, Dock.Bottom);
+ root.Children.Add(close);
+ root.Children.Add(tabs);
+ Content = root;
+ }
+
+ private Control BuildLogPage()
+ {
+ _log.Text = Diagnostics.Text;
+
+ var clear = new Button
+ {
+ Content = App.Loc["AdvClearLog"],
+ Margin = new Avalonia.Thickness(0, 8, 0, 0),
+ HorizontalAlignment = HorizontalAlignment.Left,
+ Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand)
+ };
+ clear.Classes.Add("Flat");
+ clear.Click += (_, _) => { Diagnostics.Clear(); _log.Text = ""; };
+
+ ScrollViewer.SetHorizontalScrollBarVisibility(_log, ScrollBarVisibility.Auto);
+ ScrollViewer.SetVerticalScrollBarVisibility(_log, ScrollBarVisibility.Auto);
+
+ var panel = new DockPanel { Margin = new Avalonia.Thickness(8) };
+ DockPanel.SetDock(clear, Dock.Bottom);
+ panel.Children.Add(clear);
+ panel.Children.Add(_log);
+ return panel;
+ }
+
+ private Control BuildToolsPage()
+ {
+ var sp = new StackPanel { Margin = new Avalonia.Thickness(10), Spacing = 8 };
+
+ Button Tool(string key, string tag)
+ {
+ var b = new Button
+ {
+ Content = App.Loc[key],
+ HorizontalAlignment = HorizontalAlignment.Stretch,
+ HorizontalContentAlignment = HorizontalAlignment.Center,
+ Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand)
+ };
+ b.Classes.Add("Flat");
+ b.Click += (_, _) => ToolRequested?.Invoke(tag);
+ return b;
+ }
+
+ sp.Children.Add(Tool("AddAllCategory", "category"));
+ sp.Children.Add(Tool("AddUniqueMmd", "mmd"));
+ sp.Children.Add(Tool("RemoveAllTrains", "removeall"));
+ return sp;
+ }
+}
diff --git a/StarterNG/Views/MessageBox.cs b/StarterNG/Views/MessageBox.cs
index 40a80f8..30818b4 100644
--- a/StarterNG/Views/MessageBox.cs
+++ b/StarterNG/Views/MessageBox.cs
@@ -1,3 +1,4 @@
+using System;
using System.Threading.Tasks;
using Avalonia.Controls;
using Avalonia.Layout;
@@ -18,34 +19,13 @@ public static class MessageBox
public static async Task Show(Window owner, string message, string title, MessageBoxButtons buttons,
string? yesText = null, string? noText = null)
{
- var win = new Window
- {
- Title = title,
- Width = 420,
- SizeToContent = SizeToContent.Height,
- WindowStartupLocation = WindowStartupLocation.CenterOwner,
- CanResize = false
- };
+ var win = FixedDialog(title, 420);
bool yes = false;
- var yesBtn = new Button { Content = App.Loc["Yes"], MinWidth = 80, Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand) };
- yesBtn.Classes.Add("Accent");
- yesBtn.Click += (_, _) => { yes = true; win.Close(); };
-
- var noBtn = new Button { Content = App.Loc["No"], MinWidth = 80, Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand) };
- noBtn.Classes.Add("Flat");
- noBtn.Click += (_, _) => win.Close();
-
- if (yesText is not null)
- yesBtn.Content = yesText;
- if (noText is not null)
- noBtn.Content = noText;
-
- if (buttons == MessageBoxButtons.Ok)
- {
- yesBtn.Content = App.Loc["Ok"];
- noBtn.IsVisible = false;
- }
+ var yesBtn = DialogButton(buttons == MessageBoxButtons.Ok ? App.Loc["Ok"] : yesText ?? App.Loc["Yes"],
+ "Accent", 80, () => { yes = true; win.Close(); });
+ var noBtn = DialogButton(noText ?? App.Loc["No"], "Flat", 80, () => win.Close());
+ noBtn.IsVisible = buttons != MessageBoxButtons.Ok;
win.Content = new StackPanel
{
@@ -54,17 +34,81 @@ public static class MessageBox
Children =
{
new TextBlock { Text = message, TextWrapping = TextWrapping.Wrap },
- new StackPanel
- {
- Orientation = Orientation.Horizontal,
- HorizontalAlignment = HorizontalAlignment.Right,
- Spacing = 8,
- Children = { yesBtn, noBtn }
- }
+ ButtonRow(yesBtn, noBtn)
}
};
await win.ShowDialog(owner);
return yes;
}
+
+ ///
+ /// A notice with one action besides closing it, and a box to stop it coming
+ /// back, which counts however the window is closed.
+ ///
+ public static async Task<(bool Act, bool Silence)> ShowNotice(Window owner, string message, string title,
+ string actionText, string silenceText)
+ {
+ var win = FixedDialog(title, 460);
+
+ bool act = false;
+ var actBtn = DialogButton(actionText, "Accent", null, () => { act = true; win.Close(); });
+ var okBtn = DialogButton(App.Loc["Ok"], "Flat", 80, () => win.Close());
+
+ var silence = new CheckBox { Content = silenceText, VerticalAlignment = VerticalAlignment.Center };
+
+ win.Content = new StackPanel
+ {
+ Margin = new Avalonia.Thickness(16),
+ Spacing = 16,
+ Children =
+ {
+ new SelectableTextBlock { Text = message, TextWrapping = TextWrapping.Wrap },
+ new DockPanel
+ {
+ Children =
+ {
+ silence,
+ ButtonRow(actBtn, okBtn)
+ }
+ }
+ }
+ };
+
+ await win.ShowDialog(owner);
+ return (act, silence.IsChecked == true);
+ }
+
+ /// A dialog over its owner, as tall as what it holds, not to be resized.
+ internal static Window FixedDialog(string title, double width) => new()
+ {
+ Title = title,
+ Width = width,
+ SizeToContent = SizeToContent.Height,
+ WindowStartupLocation = WindowStartupLocation.CenterOwner,
+ CanResize = false
+ };
+
+ /// A dialog's buttons, at its right edge.
+ internal static StackPanel ButtonRow(params Button[] buttons)
+ {
+ var row = new StackPanel
+ {
+ Orientation = Orientation.Horizontal,
+ HorizontalAlignment = HorizontalAlignment.Right,
+ Spacing = 8
+ };
+ row.Children.AddRange(buttons);
+ return row;
+ }
+
+ private static Button DialogButton(string content, string cssClass, double? minWidth, Action onClick)
+ {
+ var button = new Button { Content = content, Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand) };
+ if (minWidth is { } width)
+ button.MinWidth = width;
+ button.Classes.Add(cssClass);
+ button.Click += (_, _) => onClick();
+ return button;
+ }
}
diff --git a/StarterNG/Views/SettingTexts.cs b/StarterNG/Views/SettingTexts.cs
new file mode 100644
index 0000000..63edfc4
--- /dev/null
+++ b/StarterNG/Views/SettingTexts.cs
@@ -0,0 +1,124 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using StarterNG.Domain.Settings;
+
+namespace StarterNG.Views;
+
+/// The captions of the settings' rows and the words for their values.
+internal static class SettingTexts
+{
+ public static string[] QualityWords => new[]
+ {
+ App.Loc["QualityVeryLow"], App.Loc["QualityLow"], App.Loc["QualityNormal"],
+ App.Loc["QualityHigh"], App.Loc["QualityVeryHigh"]
+ };
+
+ /// The words of a slider that goes from 1 to 4, which has no middle.
+ public static string Fidelity(int level)
+ {
+ var q = QualityWords;
+ string[] four = { q[0], q[1], q[3], q[4] };
+ return four[Math.Clamp(level, 1, 4) - 1];
+ }
+
+ public static string Anisotropy(double value) => "x" + value.ToString("0.#", CultureInfo.CurrentCulture);
+
+ public static string Multisampling(int level) => level <= 0 ? App.Loc["MsaaNone"] : "x" + (1 << level);
+
+ public static string TwoDecimals(double value) => value.ToString("0.00", CultureInfo.CurrentCulture);
+
+ public static string ShadowMapWord(int pixels) => pixels switch
+ {
+ <= 512 => App.Loc["QualityVeryLow"],
+ <= 1024 => App.Loc["QualityLow"],
+ <= 2048 => App.Loc["QualityModerate"],
+ <= 4096 => App.Loc["QualityHigh"],
+ _ => App.Loc["QualityVeryHigh"]
+ };
+
+ public static string ShadowRangeWord(int metres) => metres switch
+ {
+ <= 100 => App.Loc["RangeLow"],
+ <= 150 => App.Loc["RangeModerate"],
+ <= 250 => App.Loc["RangeHigh"],
+ _ => App.Loc["RangeVeryHigh"]
+ };
+
+ public static string CabShadowRangeWord(int metres) => metres switch
+ {
+ <= 10 => App.Loc["RangeVeryLow"],
+ <= 20 => App.Loc["RangeLow"],
+ <= 30 => App.Loc["RangeStandard"],
+ <= 50 => App.Loc["RangeHigh"],
+ _ => App.Loc["RangeVeryHigh"]
+ };
+
+ /// A rate below one a second reads better as the time between updates.
+ public static string ReflectionsInterval(double perSecond)
+ {
+ if (perSecond >= 1)
+ return string.Format(App.Loc["TimesPerSecond"], perSecond.ToString("0.##", CultureInfo.CurrentCulture));
+ double seconds = 1 / perSecond;
+ return seconds >= 60
+ ? string.Format(App.Loc["EveryMinutes"], (seconds / 60).ToString("0.#", CultureInfo.CurrentCulture))
+ : string.Format(App.Loc["EverySeconds"], seconds.ToString("0.#", CultureInfo.CurrentCulture));
+ }
+
+ /// What a level sets, in the words and the units of the rows it sets.
+ public static string PresetSummary(GraphicsPreset p)
+ {
+ var lines = new List();
+ void Add(string label, string value) => lines.Add(App.Loc[label] + ": " + value);
+ string YesNo(bool on) => App.Loc[on ? "Yes" : "No"];
+ string Whole(double value) => value.ToString("0.#", CultureInfo.CurrentCulture);
+
+ Add("MaxTexResolution", p.TextureSize + " px");
+ Add("MaxTexCabResolution", p.CabTextureSize + " px");
+ Add("TexFilteringQuality", Anisotropy(p.Anisotropy));
+ Add("Multisampling", Multisampling(p.Multisampling));
+ Add("DynamicLights", p.DynamicLights.ToString(CultureInfo.CurrentCulture));
+ Add("SmokeParticlesMultiplier", Fidelity(p.SmokeFidelity));
+ Add("RenderShadows", YesNo(p.Shadows));
+ if (p.Shadows)
+ {
+ Add("ShadowsResolution", p.ShadowMap + " px");
+ Add("ShaderRange", SimulatorSettings.ShadowReach(p.ShadowRange, p.ShadowMap, legacyRenderer: false) + " m");
+ Add("ShadowDisplay", App.Loc[p.ShadowRank switch { 1 => "CSROnlyImportant", 2 => "CSRLimited", _ => "CSRAll" }]);
+ }
+ Add("ReflectionsCubeMap", YesNo(p.EnvMap));
+ if (p.EnvMap)
+ {
+ Add("ReflectionsDetails", App.Loc[p.ReflectionsFidelity switch { 0 => "RDTerrain", 1 => "RDTerrainModels", _ => "RDTerrainModelsVehicles" }]);
+ Add("ReflectionsFramerate", ReflectionsInterval(p.ReflectionsRate));
+ }
+ Add("AdditionalShadersEffects", YesNo(p.ExtraEffects));
+ Add("TrackCurvesQuality", Fidelity(p.SplineFidelity));
+ Add("Ini.basedrawrange", Whole(p.DrawRange) + " m");
+ Add("Ini.heightbase", "×" + p.DistanceFactor.ToString("0.##", CultureInfo.CurrentCulture));
+ Add("BufforResolution", p.BufferScale + "%");
+ Add("Ini." + GraphicsPreset.SleeperKey, Whole(p.SleeperDistance) + " m");
+ Add("RenderRange", "×" + Whole(p.DrawRangeFactor));
+ Add("Ini." + GraphicsPreset.ReflectedInstancesKey, Whole(p.ReflectedInstances) + " m");
+ Add("Ini." + GraphicsPreset.ReflectedVehiclesKey, Whole(p.ReflectedVehicles) + " m");
+ Add("CabShadowsRange", p.CabShadowsRange + " m");
+
+ if (p.Extras is { } extras)
+ {
+ Add("MotionBlur", YesNo(extras.MotionBlur));
+ Add("ChromaticAberration", YesNo(extras.ChromaticAberration));
+ Add("SmokeDisplay", YesNo(extras.Smoke));
+ Add("PyScreenPriority", App.Loc[extras.PythonUpdateMs <= 200 ? "PyPriorityNormal" : "PyPriorityLowest"]);
+ }
+ if (p.Top is { } top)
+ {
+ lines.Insert(0, App.Loc["PresetUltraNote"]);
+ Add("ShadowAngleLimit", TwoDecimals(top.ShadowAngleLimit));
+ Add("Ini." + GraphicsTop.TargetFpsKey, YesNo(top.TargetFps > 0));
+ Add("Ini." + GraphicsTop.TextureReleaseKey, YesNo(top.TextureRelease > 0));
+ Add("CompressTextures", YesNo(top.CompressTextures));
+ Add("IgnoreIrrelevantTrains", YesNo(top.SkipDecor));
+ }
+ return string.Join("\n", lines);
+ }
+}
diff --git a/StarterNG/Views/Settings.axaml b/StarterNG/Views/Settings.axaml
index 95873eb..025bdc6 100644
--- a/StarterNG/Views/Settings.axaml
+++ b/StarterNG/Views/Settings.axaml
@@ -14,14 +14,17 @@
-
-
+
+
+ TextTrimming="LeadingCharacterEllipsis" />
+
-
+
+
+
+
+
+
+
+
+
+
@@ -79,7 +101,15 @@
Text="{Binding [General], Source={x:Static starterNg:App.Loc}}" />
-
+
+
+
+
+
@@ -121,7 +151,7 @@
-
+
-
-
-
-
@@ -149,9 +171,6 @@
-
-
@@ -160,17 +179,48 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
- 3840x2160
- 2560x1440
- 1920x1080
- 1600x900
- 1366x768
- 1280x720
-
+
-
-
+
-
-
+
+
+
+
+
+
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -214,38 +277,44 @@
IsSnapToTickEnabled="True" Value="4"
ValueChanged="QualitySlider_OnValueChanged" />
-
-
-
+
-
-
-
-
-
+
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
@@ -255,26 +324,7 @@
-
-
-
-
-
-
-
-
-
-
-
-
+
@@ -285,29 +335,26 @@
IsSnapToTickEnabled="True" Value="2"
ValueChanged="QualitySlider_OnValueChanged" />
-
-
-
+
-
+
-
+
-
-
+
+
@@ -332,12 +381,13 @@
IsSnapToTickEnabled="True" Value="30"
ValueChanged="QualitySlider_OnValueChanged" />
-
+
-
+
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
@@ -376,18 +431,23 @@
-
-
-
-
-
-
+
+
+
+
+
+
+
+
@@ -396,7 +456,7 @@
+
-
-
-
-
-
@@ -465,20 +525,20 @@
-
+
-
-
+
-
-
+
@@ -495,7 +555,7 @@
-
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -526,7 +679,8 @@
+
+
diff --git a/StarterNG/Views/Settings.axaml.cs b/StarterNG/Views/Settings.axaml.cs
index 8d77728..2523910 100644
--- a/StarterNG/Views/Settings.axaml.cs
+++ b/StarterNG/Views/Settings.axaml.cs
@@ -12,15 +12,13 @@ using Avalonia.Input;
using Avalonia.Interactivity;
using Avalonia.Layout;
using Avalonia.LogicalTree;
-using Avalonia.Markup.Xaml.Styling;
using Avalonia.Media;
using Avalonia.Platform.Storage;
+using Avalonia.Threading;
using StarterNG.Classes;
using StarterNG.Controls;
using StarterNG.Infrastructure;
-using StarterNG.Services;
-using KeyBinding = StarterNG.Classes.KeyBinding;
using StarterNG.Domain.Settings;
using StarterNG.Application;
@@ -30,34 +28,57 @@ public partial class Settings : UserControl, ISettingsCapture
{
private bool _loading;
+ private readonly SimulatorKeyRows _keyRows = new();
+
+ private readonly KeyBindingsTab _keyBindings;
+
+ private readonly SliderSteps _fpsLimit;
+
+ private readonly SliderSteps _reflections;
+
+ private readonly SliderSteps _anisotropy;
+
+ private readonly SliderSteps _multisampling;
+
+ private readonly SliderSteps _drawRangeFactor;
+
+ // False while the layout loads: the handlers it names fire as it sets their controls'
+ // values, before the fields of the controls are there, and do nothing until this is set.
+ private bool _built;
+
///
/// Raised once a saved (or applied) setting changes something the other tabs
/// have already drawn, so they can redraw instead of waiting for a restart.
///
public event Action? ThumbnailSizeChanged;
- /// Raised when the developer tab is switched on or off, so the top bar can follow.
- public event Action? DeveloperToolsChanged;
-
/// Thumbnail size the other tabs were last drawn at.
private bool _drawnThumbs = AppServices.Current.Settings.LargeThumbnails;
- /// Whether the top bar was last drawn with the developer tab on it.
- private bool _shownDeveloperTools = AppServices.Current.Settings.DeveloperTools;
-
public Settings()
{
InitializeComponent();
+ _fpsLimit = new SliderSteps(FpsLimitSlider, Steps.FrameRateLimits);
+ _reflections = new SliderSteps(reflectionsFramerate, Steps.ReflectionUpdates);
+ _anisotropy = new SliderSteps(TexFilteringSlider, Steps.Anisotropy);
+ _multisampling = new SliderSteps(MultisamplingSlider, Steps.MultisamplingLevels);
+ _drawRangeFactor = new SliderSteps(RenderRangeSlider, Steps.DrawRangeFactors);
+ _built = true;
+
SettingsPathText.Text = AppServices.Current.SettingsStore.LoadedFrom;
ToolTip.SetTip(SettingsPathText, AppServices.Current.SettingsStore.LoadedFrom);
this.AttachedToVisualTree += (_, _) =>
{
- TextureResolutionSlider_OnValueChanged(null, null);
- CabTextureResolutionSlider_OnValueChanged(null, null);
- shaderResolutionSlider_OnValueChanged(null, null);
+ ShowPixels(TexResolutionRow, textureResolutionSlider);
+ ShowPixels(CabTexResolutionRow, cabTextureResolutionSlider);
+ UpdateShadowResolution();
UpdateQualityCaptions();
+ // Only now is it known which window, and so which monitors, this is on.
+ RefreshResolutions();
+ if (TopLevel.GetTopLevel(this)?.Screens is { } screens)
+ screens.Changed += (_, _) => RefreshResolutions();
};
FillLanguageCombo();
@@ -65,21 +86,52 @@ public partial class Settings : UserControl, ISettingsCapture
App.Loc.LanguageChanged += SelectActiveLanguage;
App.Loc.LanguageChanged += UpdateQualityCaptions;
App.Loc.LanguageChanged += UpdateSaveState;
- App.Loc.LanguageChanged += () => shaderResolutionSlider_OnValueChanged(null, null);
+ App.Loc.LanguageChanged += UpdateShadowResolution;
+ App.Loc.LanguageChanged += RefreshResolutions;
+ App.Loc.LanguageChanged += () =>
+ {
+ if (SelectExeCb.Items.Count > 0 && SelectExeCb.Items[0] is ComboBoxItem auto)
+ auto.Content = App.Loc["SelectEXEAuto"];
+ };
+ _keyBindings = new KeyBindingsTab(ControlsHost, SettingsSearch);
+ _keyBindings.Changed += MarkDirty;
+ App.Loc.LanguageChanged += _keyBindings.Build;
+
+ _keyRows.Build(SettingsStack);
+ _keyRows.Changed += MarkDirty;
+ _keyRows.Changed += QueuePresetMarks;
+ BuildPresetButtons();
+ BuildMonitorRates();
+ App.Loc.LanguageChanged += _keyRows.UpdateTexts;
FeedbackCb.SelectionChanged += FeedbackCb_OnSelectionChanged;
- FpsLimitEnableCb.IsCheckedChanged += (_, _) => FpsLimitSlider.IsEnabled = IsChecked(FpsLimitEnableCb);
+ SelectExeCb.SelectionChanged += (_, _) => UpdateIdleNotes();
+ FullscreenWindowedCb.IsCheckedChanged += (_, _) => UpdateIdleNotes();
+ App.Loc.LanguageChanged += UpdateIdleNotes;
+ App.Loc.LanguageChanged += UpdateGpuNote;
+ // targetfps decides whether the draw range factor does anything.
+ _keyRows.Moved += key =>
+ {
+ if (string.Equals(key.Key, "targetfps", StringComparison.OrdinalIgnoreCase))
+ UpdateIdleNotes();
+ };
+ MotionBlurCb.IsCheckedChanged += (_, _) => UpdateDependentRows();
+ ReflectionsCubeMapCb.IsCheckedChanged += (_, _) => UpdateDependentRows();
AppServices.Current.SettingsStore.RegisterCapture(this);
- PopulateProfileCombo();
+ HookUart();
+ ProfileCb.SelectionChanged += (_, _) => UpdateProfileState();
+ App.Loc.LanguageChanged += UpdateProfileState;
+
ApplyToUi();
KeyboardConfig.Instance.Load();
- BuildControlsTab();
- AddHandler(KeyDownEvent, OnControlsKeyDown, RoutingStrategies.Tunnel);
+ _keyBindings.Build();
+ AddHandler(KeyDownEvent, _keyBindings.OnKeyDown, RoutingStrategies.Tunnel);
HookDirtyTracking();
+ HookSectionResets();
ApplyFilter();
UpdateSaveState();
}
@@ -113,38 +165,61 @@ public partial class Settings : UserControl, ISettingsCapture
int idx = FindComboIndexByContent(ProfileCb, current);
if (idx >= 0) ProfileCb.SelectedIndex = idx;
}
+ UpdateProfileState();
}
+ /// Nothing to apply says so, rather than a button that does nothing.
+ private void UpdateProfileState()
+ {
+ ProfileCb.PlaceholderText = App.Loc[ProfileCb.ItemCount == 0 ? "ProfileNone" : "ProfilePick"];
+ ProfileApplyBtn.IsEnabled = ProfileCb.SelectedItem is not null;
+ }
+
+ /// Applied means in eu07.ini, the file the simulator goes by, and on this screen.
private void ProfileApplyButton_OnClick(object? sender, RoutedEventArgs e)
{
if (ProfileCb.SelectedItem is not ComboBoxItem { Content: string name } || string.IsNullOrWhiteSpace(name))
return;
+
string path = SettingsProfileStore.PathFor(name);
- if (!File.Exists(path)) return;
- AppServices.Current.SettingsStore.LoadFrom(path);
+ var store = AppServices.Current.SettingsStore;
+ bool loaded = store.TryLoadProfile(path);
ApplyToUi();
- RedrawThumbnailsIfNeeded();
+ if (!loaded)
+ {
+ SaveStatus.Text = string.Format(App.Loc["ProfileNotApplied"], name);
+ return;
+ }
+
+ Save();
+ if (!store.LastSaveFailed)
+ SaveStatus.Text = string.Format(App.Loc["ProfileApplied"], name);
}
private void ProfileSaveAsButton_OnClick(object? sender, RoutedEventArgs e)
{
var nameBox = new TextBox { PlaceholderText = App.Loc["ProfileNamePrompt"], MinWidth = 220 };
- var ok = new Button { Content = App.Loc["ProfileSaveAs"] };
+ var ok = new Button
+ {
+ Content = App.Loc["Save"],
+ HorizontalAlignment = HorizontalAlignment.Right,
+ HorizontalContentAlignment = HorizontalAlignment.Center,
+ MinWidth = 90
+ };
+ ok.Classes.Add("Flat");
+ ok.Classes.Add("Accent");
var panel = new StackPanel { Spacing = 6, Margin = new Thickness(8), MinWidth = 240 };
panel.Children.Add(new TextBlock { Text = App.Loc["ProfileNamePrompt"], FontWeight = FontWeight.Bold, FontSize = 12 });
panel.Children.Add(nameBox);
panel.Children.Add(ok);
var flyout = new Flyout { Content = panel };
- void Commit()
+ async void Commit()
{
- if (string.IsNullOrWhiteSpace(nameBox.Text)) return;
- CaptureInto(AppServices.Current.Settings);
- AppServices.Current.SettingsStore.SaveTo(SettingsProfileStore.PathFor(nameBox.Text));
- PopulateProfileCombo();
- int idx = FindComboIndexByContent(ProfileCb, nameBox.Text.Trim());
- if (idx >= 0) ProfileCb.SelectedIndex = idx;
+ string name = nameBox.Text?.Trim() ?? string.Empty;
+ if (name.Length == 0) return;
flyout.Hide();
+ await SaveProfileAsync(name);
}
ok.Click += (_, _) => Commit();
nameBox.KeyDown += (_, ev) => { if (ev.Key == Key.Enter) { ev.Handled = true; Commit(); } };
@@ -152,6 +227,23 @@ public partial class Settings : UserControl, ISettingsCapture
nameBox.Focus(); nameBox.SelectAll();
}
+ private async Task SaveProfileAsync(string name)
+ {
+ string path = SettingsProfileStore.PathFor(name);
+ if (File.Exists(path) && TopLevel.GetTopLevel(this) is Window window &&
+ !await MessageBox.Show(window, string.Format(App.Loc["ProfileOverwrite"], name),
+ App.Loc["ProfileSaveAs"], MessageBoxButtons.YesNo))
+ return;
+
+ var store = AppServices.Current.SettingsStore;
+ CaptureInto(AppServices.Current.Settings);
+ store.SaveTo(path);
+ PopulateProfileCombo();
+ int idx = FindComboIndexByContent(ProfileCb, Path.GetFileNameWithoutExtension(path));
+ if (idx >= 0) ProfileCb.SelectedIndex = idx;
+ SaveStatus.Text = string.Format(App.Loc[store.LastSaveFailed ? "ProfileNotSaved" : "ProfileSaved"], name);
+ }
+
private void PopulateExeCombo()
{
string? current = (SelectExeCb.SelectedItem as ComboBoxItem)?.Content?.ToString();
@@ -208,6 +300,13 @@ public partial class Settings : UserControl, ISettingsCapture
? Path.GetFileName(path)
: path;
+ SelectExeEntry(entry);
+ return true;
+ }
+
+ /// Selects the simulator of that name, joining the list if the list lacks it.
+ private void SelectExeEntry(string entry)
+ {
int index = FindComboIndexByContent(SelectExeCb, entry);
if (index < 0)
{
@@ -215,11 +314,39 @@ public partial class Settings : UserControl, ISettingsCapture
index = SelectExeCb.Items.Count - 1;
}
SelectExeCb.SelectedIndex = index;
- return true;
}
public void ReloadFromSettings() => ApplyToUi();
+ ///
+ /// True while a cab-control binding is waiting for a keypress. The window's own
+ /// shortcuts stand down for the duration, otherwise Ctrl+N would never reach here.
+ ///
+ public bool IsCapturingKey => _keyBindings.IsCapturing;
+
+ /// Switched on from the tapes' window: the boxes follow, as no edit of their own.
+ public void SyncLogs() =>
+ WhileLoading(() =>
+ {
+ SpeedometerTapesCb.IsChecked = AppServices.Current.Settings.PhysicsLog;
+ SimLogsCb.IsChecked = AppServices.Current.Settings.DebugLog;
+ });
+
+ /// Runs
+ private void WhileLoading(Action change)
+ {
+ bool loading = _loading;
+ _loading = true;
+ try
+ {
+ change();
+ }
+ finally
+ {
+ _loading = loading;
+ }
+ }
+
private void ApplyToUi()
{
var s = AppServices.Current.Settings;
@@ -230,112 +357,431 @@ public partial class Settings : UserControl, ISettingsCapture
PopulateExeCombo();
SelectActiveLanguage();
- FullscreenCb.IsChecked = s.Fullscreen;
- PauseInactiveCb.IsChecked = s.PauseWhenInactive;
- PauseStartCb.IsChecked = s.PauseOnStart;
- CursorSensitivitySlider.Value = s.CursorSensitivity;
- MouseHorInvertCb.IsChecked = s.InvertMouseHorizontal;
- MouseVertInvertCb.IsChecked = s.InvertMouseVertical;
-
- GamepadIgnoreCb.IsChecked = s.IgnoreGamepad;
- FeedbackCb.SelectedIndex = s.FeedbackMode;
- FeedbackPortNud.Value = (decimal)s.FeedbackPort;
- UpdateFeedbackDetailVisibility();
-
- if (s.SelectExeAutomatically)
- {
- SelectExeCb.SelectedIndex = 0;
- }
- else
- {
- int exeIdx = FindComboIndexByContent(SelectExeCb, s.ExecutablePath);
- if (exeIdx < 0)
- {
- SelectExeCb.Items.Add(new ComboBoxItem { Content = s.ExecutablePath });
- exeIdx = SelectExeCb.Items.Count - 1;
- }
- SelectExeCb.SelectedIndex = exeIdx;
- }
- DebugModeCb.IsChecked = s.DebugMode;
- VirtualShuntingCb.IsChecked = s.VirtualShunting;
- LogMissingVehicleFilesCb.IsChecked = s.LogMissingVehicleFiles;
- DeveloperToolsCb.IsChecked = s.DeveloperTools;
-
- RenderEngineCb.SelectedIndex = s.RenderEngine;
- SelectResolution(s.Width, s.Height);
- bufferScale.Value = s.BufferScalePercent;
- textureResolutionSlider.Value = Log2(s.MaxTextureSize, 12);
- cabTextureResolutionSlider.Value = Log2(s.MaxCabTextureSize, 12);
- TexFilteringSlider.Value = AnisotropyToSlider(s.TextureFiltering);
- MultisamplingSlider.Value = s.Multisampling + 1;
- DynamicLightsSlider.Value = s.DynamicLights;
- RenderRangeSlider.Value = (int)Math.Round(s.DrawRangeFactor);
- VSyncCb.IsChecked = s.VSync;
- SmokeDisplayCb.IsChecked = s.Smoke;
- SmokeParticlesSlider.Value = s.SmokeFidelity;
- ChromaticAberrationCb.IsChecked = s.ChromaticAberration;
- MotionBlurCb.IsChecked = s.MotionBlur;
- AdditionalShadersCb.IsChecked = s.ExtraEffects;
- ReflectionsCubeMapCb.IsChecked = s.EnvMap;
- RenderVBOCb.IsChecked = s.UseVbo;
- RenderShadowsCb.IsChecked = s.RenderShadows;
- reflectionsFramerate.Value = s.ReflectionsFramerate;
- shaderResolutionSlider.Value = Log2(s.ShadowMapResolution, 12);
- shaderRange.Value = s.ShadowProjectionRange;
- cabShaderSourceRange.Value = s.CabShadowsRange;
- ShadowDisplayCb.SelectedIndex = Clamp(s.ShadowRankCutoff - 1, 0, 2);
- ReflectionsDetailsCb.SelectedIndex = s.ReflectionsFidelity;
- fovSlider.Value = s.FieldOfView;
- RenderScreensCb.IsChecked = s.PythonScreens;
- RenderScreensThreadCb.IsChecked = s.PythonThreadedUpload;
- FpsLimitEnableCb.IsChecked = s.FpsLimitEnabled;
- FpsLimitSlider.Value = s.FpsLimit;
- FpsLimitSlider.IsEnabled = s.FpsLimitEnabled;
- ShadowAngleLimitSlider.Value = s.ShadowAngleLimit;
- FullscreenWindowedCb.IsChecked = s.FullscreenWindowed;
- RenderAngleVulkanCb.IsChecked = s.RenderAngleVulkan;
-
- TrackCurvesSlider.Value = s.SplineFidelity;
- PhysicsAccuracyCb.IsChecked = s.FullPhysics;
- PantographBreakCb.IsChecked = s.EnableTraction;
- OverheadOnlyCb.IsChecked = s.LiveTraction;
- SpeedometerTapesCb.IsChecked = s.PhysicsLog;
- SimLogsCb.IsChecked = s.DebugLog;
- KeepLogsCb.IsChecked = s.MultipleLogs;
- DisplaySimulationCb.IsChecked = s.DisplaySimulation;
- CrashDamageCb.IsChecked = s.CrashDamage;
- FrictionSlider.Value = s.Friction;
- BrakeStepSlider.Value = s.BrakeStep;
- BrakeSpeedSlider.Value = s.BrakeSpeed;
-
- EnableSoundsCb.IsChecked = s.SoundEnabled;
- VolumeSlider.Value = s.Volume;
- RadioVolumeSlider.Value = s.RadioVolume;
- VehiclesVolumeSlider.Value = s.VehiclesVolume;
- PositionalVolumeSlider.Value = s.PositionalVolume;
- AmbientVolumeSlider.Value = s.AmbientVolume;
- SkipPipelineCb.IsChecked = s.SkipPipeline;
- DebugLogVisibleCb.IsChecked = s.DebugLogVisible;
- PyScreenPriorityCb.SelectedIndex = Math.Max(0, IndexOfTag(PyScreenPriorityCb, s.PythonScreenUpdateRate.ToString(CultureInfo.InvariantCulture)));
-
- AutoCloseStarterCb.IsChecked = s.AutoCloseStarter;
- LargeThumbnailsCb.IsChecked = s.LargeThumbnails;
- AutoExpandTreeCb.IsChecked = s.AutoExpandSceneryTree;
- ReadyOverrideCb.SelectedIndex = (int)s.ReadyOverride;
+ ShowValues(s);
+ _keyRows.Apply(s);
}
finally
{
_loading = false;
}
- UpdateQualityCaptions();
+ // A reloaded file may name another simulator, or start a server.
+ RefreshDerivedRows();
+ UpdateGpuNote();
+ NoteShownValues();
+ UpdatePresetMarks();
}
+ ///
+ /// Puts
+ private void ShowValues(SimulatorSettings s)
+ {
+ FullscreenCb.IsChecked = s.Fullscreen;
+ PauseInactiveCb.IsChecked = s.PauseWhenInactive;
+ PauseStartCb.IsChecked = s.PauseOnStart;
+ CursorSensitivitySlider.Value = s.CursorSensitivity;
+ MouseHorInvertCb.IsChecked = s.InvertMouseHorizontal;
+ MouseVertInvertCb.IsChecked = s.InvertMouseVertical;
+
+ GamepadIgnoreCb.IsChecked = s.IgnoreGamepad;
+ FeedbackCb.SelectedIndex = s.FeedbackMode;
+ FeedbackPortNud.Value = (decimal)s.FeedbackPort;
+ ShowUart(s);
+ UpdateFeedbackDetailVisibility();
+
+ if (s.SelectExeAutomatically)
+ {
+ SelectExeCb.SelectedIndex = 0;
+ }
+ else
+ {
+ SelectExeEntry(s.ExecutablePath);
+ }
+ DebugModeCb.IsChecked = s.DebugMode;
+ VirtualShuntingCb.IsChecked = s.VirtualShunting;
+ LogMissingVehicleFilesCb.IsChecked = s.LogMissingVehicleFiles;
+
+ RenderEngineCb.SelectedIndex = s.RenderEngine;
+ GpuCb.SelectedIndex = s.Gpu == GpuPreference.System ? 1 : 0;
+ SelectResolution(s.Width, s.Height);
+ bufferScale.Value = s.BufferScalePercent;
+ textureResolutionSlider.Value = Log2(s.MaxTextureSize, 12);
+ cabTextureResolutionSlider.Value = Log2(s.MaxCabTextureSize, 12);
+ _anisotropy.Value = s.TextureFiltering;
+ _multisampling.Value = s.Multisampling;
+ DynamicLightsSlider.Value = s.DynamicLights;
+ _drawRangeFactor.Value = s.DrawRangeFactor;
+ VSyncCb.IsChecked = s.VSync;
+ SmokeDisplayCb.IsChecked = s.Smoke;
+ SmokeParticlesSlider.Value = s.SmokeFidelity;
+ ChromaticAberrationCb.IsChecked = s.ChromaticAberration;
+ MotionBlurCb.IsChecked = s.MotionBlur;
+ AdditionalShadersCb.IsChecked = s.ExtraEffects;
+ ReflectionsCubeMapCb.IsChecked = s.EnvMap;
+ RenderVBOCb.IsChecked = s.UseVbo;
+ RenderShadowsCb.IsChecked = s.RenderShadows;
+ _reflections.Value = s.ReflectionsFramerate;
+ shaderResolutionSlider.Value = Log2(s.ShadowMapResolution, 12);
+ shaderRange.Value = s.ShadowProjectionRange;
+ cabShaderSourceRange.Value = s.CabShadowsRange;
+ ShadowDisplayCb.SelectedIndex = Math.Clamp(s.ShadowRankCutoff - 1, 0, 2);
+ ReflectionsDetailsCb.SelectedIndex = s.ReflectionsFidelity;
+ fovSlider.Value = s.FieldOfView;
+ RenderScreensCb.IsChecked = s.PythonScreens;
+ RenderScreensThreadCb.IsChecked = s.PythonThreadedUpload;
+ _fpsLimit.Value = s.FpsLimitEnabled ? s.FpsLimit : 0;
+ ShadowAngleLimitSlider.Value = s.ShadowAngleLimit;
+ FullscreenWindowedCb.IsChecked = s.FullscreenWindowed;
+ RenderAngleVulkanCb.IsChecked = s.RenderAngleVulkan;
+
+ TrackCurvesSlider.Value = s.SplineFidelity;
+ PhysicsAccuracyCb.IsChecked = s.FullPhysics;
+ PantographBreakCb.IsChecked = s.EnableTraction;
+ OverheadOnlyCb.IsChecked = s.LiveTraction;
+ SpeedometerTapesCb.IsChecked = s.PhysicsLog;
+ SimLogsCb.IsChecked = s.DebugLog;
+ KeepLogsCb.IsChecked = s.MultipleLogs;
+ DisplaySimulationCb.IsChecked = s.DisplaySimulation;
+ CrashDamageCb.IsChecked = s.CrashDamage;
+ FrictionSlider.Value = s.Friction;
+ BrakeStepSlider.Value = s.BrakeStep;
+ BrakeSpeedSlider.Value = s.BrakeSpeed;
+
+ EnableSoundsCb.IsChecked = s.SoundEnabled;
+ VolumeSlider.Value = s.Volume;
+ RadioVolumeSlider.Value = s.RadioVolume;
+ VehiclesVolumeSlider.Value = s.VehiclesVolume;
+ PositionalVolumeSlider.Value = s.PositionalVolume;
+ AmbientVolumeSlider.Value = s.AmbientVolume;
+ SkipPipelineCb.IsChecked = s.SkipPipeline;
+ DebugLogVisibleCb.IsChecked = s.DebugLogVisible;
+ PyScreenPriorityCb.SelectedIndex = Math.Max(0, IndexOfTag(PyScreenPriorityCb, s.PythonScreenUpdateRate.ToString(CultureInfo.InvariantCulture)));
+
+ AutoCloseStarterCb.IsChecked = s.AutoCloseStarter;
+ LargeThumbnailsCb.IsChecked = s.LargeThumbnails;
+ AutoExpandTreeCb.IsChecked = s.AutoExpandSceneryTree;
+ ReadyOverrideCb.SelectedIndex = (int)s.ReadyOverride;
+
+ CompressTexCb.IsChecked = s.CompressTextures;
+ ScaleSpecularsCb.IsChecked = s.ScaleSpeculars;
+ UseGlesCb.IsChecked = s.UseGLES;
+ ShaderGammaCb.IsChecked = s.ShaderGamma;
+ ScreenMipmapsCb.IsChecked = s.ScreenMipmaps;
+ ConvertModelsCb.IsChecked = s.ExtendedModelConversion;
+ ResourceMoveCb.IsChecked = s.GfxResourceMove;
+ ResourceSweepCb.IsChecked = s.GfxResourceSweep;
+ TrainThreadsSlider.Maximum = Math.Max(1, Environment.ProcessorCount);
+ TrainThreadsSlider.Value = s.TrainPhysicsThreads;
+ IgnoreIrrelevantCb.IsChecked = s.IgnoreIrrelevantTrains;
+ }
+
+ ///
+ /// Puts
+ private void ShowAsEdits(SimulatorSettings s)
+ {
+ ShowValues(s);
+ RefreshDerivedRows();
+ }
+
+ /// What on the screen follows the values shown, and is not one of them.
+ private void RefreshDerivedRows()
+ {
+ UpdateQualityCaptions();
+ UpdateIdleNotes();
+ UpdateDependentRows();
+ }
+
+ // ── Levels of detail ─────────────────────────────────────────────────────
+
+ private readonly List<(GraphicsPreset Preset, Button Button)> _presetButtons = new();
+
+ private bool _presetMarksQueued;
+
+ private void BuildPresetButtons()
+ {
+ foreach (var preset in GraphicsPreset.All)
+ {
+ var button = new Button { Cursor = new Cursor(StandardCursorType.Hand) };
+ button.Classes.Add("Flat");
+ button.Click += (_, _) => ApplyPreset(preset);
+ PresetButtons.Children.Add(button);
+ _presetButtons.Add((preset, button));
+ }
+
+ foreach (var (section, group) in new[]
+ {
+ (DrawRangeSection, GraphicsGroup.DrawRange), (TexturesSection, GraphicsGroup.Textures),
+ (EffectsSection, GraphicsGroup.Effects), (ShadowsSection, GraphicsGroup.Shadows),
+ (ReflectionsSection, GraphicsGroup.Reflections)
+ })
+ {
+ var levels = new ComboBox();
+ levels.Classes.Add("SectionLevel");
+ levels.SelectionChanged += (_, _) =>
+ {
+ if (!_markingLevels && levels.SelectedItem is ComboBoxItem { Tag: GraphicsPreset level })
+ ApplyGroupLevel(group, level);
+ };
+ section.Level = levels;
+ _groupLevels.Add((group, levels));
+ }
+
+ UpdatePresetTexts();
+ App.Loc.LanguageChanged += UpdatePresetTexts;
+ }
+
+ private void UpdatePresetTexts()
+ {
+ foreach (var (preset, button) in _presetButtons)
+ {
+ button.Content = App.Loc[preset.NameKey];
+ ToolTip.SetTip(button, SettingTexts.PresetSummary(preset));
+ }
+
+ _markingLevels = true;
+ foreach (var (group, levels) in _groupLevels)
+ {
+ levels.Items.Clear();
+ foreach (var level in GraphicsPreset.All)
+ levels.Items.Add(new ComboBoxItem { Content = App.Loc[level.NameKey], Tag = level });
+ levels.PlaceholderText = App.Loc["PresetCustom"];
+ ToolTip.SetTip(levels, App.Loc["GfxGroupLevelTip"]);
+ }
+ _markingLevels = false;
+
+ UpdatePresetMarks();
+ }
+
+ private readonly GraphicsPresetMemory _presetMemory = new();
+
+ private readonly List<(GraphicsGroup Group, ComboBox Levels)> _groupLevels = new();
+
+ private GraphicsGroupLevels? _groups;
+
+ private GraphicsGroupLevels Groups => _groups ??= new GraphicsGroupLevels(AppServices.Current.SettingsStore);
+
+ // The screen following the values, not the player choosing.
+ private bool _markingLevels;
+
+ /// Puts a level of detail on the screen, as edits waiting for Save.
+ private void ApplyPreset(GraphicsPreset preset)
+ {
+ var trial = Trial();
+ var applied = _presetMemory.Apply(preset, trial);
+ ShowAsEdits(trial);
+ foreach (string key in applied.RowKeys)
+ _keyRows.Show(key, trial.Extra[key]);
+
+ // Chosen as a whole, its values are choices, not ones the screen could not show.
+ ForgetShown(applied.ChosenKeys);
+ UpdatePresetMarks();
+ }
+
+ /// Puts one part at a level, as edits waiting for Save.
+ private void ApplyGroupLevel(GraphicsGroup group, GraphicsPreset level)
+ {
+ var trial = Groups.Apply(group, level, Trial());
+ ShowAsEdits(trial);
+ foreach (string key in group.Keys.Where(key => SimulatorKeys.All.Any(known => known.Key == key)))
+ _keyRows.Show(key, SimulatorKeys.Named(key).RawIn(trial));
+
+ ForgetShown(group.Keys);
+ UpdatePresetMarks();
+ }
+
+ /// Marks the level the screen is at, once the controls moving now settle.
+ private void QueuePresetMarks()
+ {
+ if (_presetMarksQueued)
+ return;
+ _presetMarksQueued = true;
+ Dispatcher.UIThread.Post(() =>
+ {
+ _presetMarksQueued = false;
+ UpdatePresetMarks();
+ }, DispatcherPriority.Background);
+ }
+
+ private void UpdatePresetMarks()
+ {
+ var trial = Trial();
+ var matching = GraphicsPreset.Matching(trial);
+ foreach (var (preset, button) in _presetButtons)
+ {
+ button.Classes.Set("Accent", preset == matching);
+ button.Classes.Set("Flat", preset != matching);
+ }
+ PresetStateText.Text = matching is null ? App.Loc["PresetCustom"] : string.Empty;
+
+ var groupLevels = Groups.LevelsOf(trial);
+ _markingLevels = true;
+ foreach (var (group, levels) in _groupLevels)
+ levels.SelectedItem = levels.Items.OfType()
+ .FirstOrDefault(item => ReferenceEquals(item.Tag, groupLevels[group]));
+ _markingLevels = false;
+ }
+
+ // ── The screens' refresh rates, for the frame rate limit ─────────────────
+
+ private static readonly IBrush FgDimBrush = new SolidColorBrush(Color.Parse("#9098A0"));
+
+ private void BuildMonitorRates()
+ {
+ var displays = AppServices.Current.Displays.List();
+ if (displays.Count == 0)
+ return;
+
+ MonitorRates.IsVisible = true;
+ UpdateMonitorRates(displays);
+ App.Loc.LanguageChanged += () => UpdateMonitorRates(displays);
+ }
+
+ private void UpdateMonitorRates(IReadOnlyList displays)
+ {
+ MonitorRates.Children.Clear();
+ foreach (var display in displays)
+ {
+ string screen = string.IsNullOrEmpty(display.Name)
+ ? string.Format(App.Loc["MonitorRate"], display.RefreshRate)
+ : string.Format(App.Loc["MonitorRateNamed"], display.Name, display.RefreshRate);
+ MonitorRates.Children.Add(new TextBlock
+ {
+ Text = screen, FontSize = 11, Foreground = FgDimBrush, VerticalAlignment = VerticalAlignment.Center
+ });
+ var match = new Button
+ {
+ Content = string.Format(App.Loc["MonitorRateUse"], display.RefreshRate),
+ Margin = new Thickness(4, 0, 14, 0)
+ };
+ match.Classes.Add("Outline");
+ match.Classes.Add("SectionReset");
+ int rate = display.RefreshRate;
+ match.Click += (_, _) => _fpsLimit.Value = rate;
+ MonitorRates.Children.Add(match);
+ }
+ }
+
+ // ── Sections back to the simulator's own values ──────────────────────────
+
+ // The language and the simulator are choices, not settings with a default;
+ // the uart key holds the port and the speed of a board that is plugged in.
+ private static readonly HashSet KeptOnReset = new(StringComparer.OrdinalIgnoreCase)
+ {
+ "lang", "starter.exe.path", "uart"
+ };
+
+ private readonly List _resettable = new();
+
+ private void HookSectionResets()
+ {
+ foreach (var section in SettingsStack.GetLogicalDescendants().OfType())
+ {
+ if (ResettableKeys(section).Count == 0)
+ continue;
+ section.ResetRequested += ResetSection;
+ _resettable.Add(section);
+ }
+
+ UpdateResetLabels();
+ App.Loc.LanguageChanged += UpdateResetLabels;
+ }
+
+ private void UpdateResetLabels()
+ {
+ foreach (var section in _resettable)
+ section.ResetLabel = App.Loc["SectionDefaults"];
+ }
+
+ /// The keys of the section's rows and switch that it can put back.
+ private static HashSet ResettableKeys(SettingsSection section)
+ {
+ var keys = new HashSet(StringComparer.OrdinalIgnoreCase);
+ if (!string.IsNullOrEmpty(section.ToggleKey))
+ keys.Add(section.ToggleKey);
+ foreach (var row in section.GetLogicalDescendants().OfType())
+ foreach (string key in (row.ConfigKey ?? string.Empty)
+ .Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+ keys.Add(key);
+ keys.ExceptWith(KeptOnReset);
+ return keys;
+ }
+
+ /// Puts the section's rows at the simulator's own values, as edits waiting for Save.
+ private void ResetSection(SettingsSection section)
+ {
+ var keys = ResettableKeys(section);
+ ShowAsEdits(AppServices.Current.SettingsStore.WithDefaults(Trial(), keys));
+ foreach (string key in keys)
+ _keyRows.ShowDefault(key);
+
+ // Put back by hand, a value is a choice like any other.
+ ForgetShown(keys);
+ }
+
+ // ── Values the screen shows otherwise than the file has them ─────────────
+
+ private IReadOnlyDictionary _shownUnlikeSettings = new Dictionary();
+
+ /// ShownUnlikeSettings => _shownUnlikeSettings;
+
+ ///
+ /// Notes the keys a control shows otherwise than the settings hold them - a
+ /// value past the end of its slider, one its list lacks - so a save leaves
+ /// them as the file has them until the control is moved.
+ ///
+ private void NoteShownValues() =>
+ _shownUnlikeSettings = AppServices.Current.SettingsStore.ShownUnlike(Trial());
+
+ private void ForgetShown(IEnumerable keys)
+ {
+ var forgotten = new HashSet(keys, StringComparer.OrdinalIgnoreCase);
+ _shownUnlikeSettings = _shownUnlikeSettings
+ .Where(pair => !forgotten.Contains(pair.Key))
+ .ToDictionary(pair => pair.Key, pair => pair.Value, StringComparer.OrdinalIgnoreCase);
+ }
+
+ /// The settings with this screen's edits in, apart from the ones a save writes.
+ private SimulatorSettings Trial()
+ {
+ var trial = AppServices.Current.Settings.Copy();
+ CaptureControls(trial, remember: false);
+ return trial;
+ }
+
+ ///
+ /// Rows that only matter while another is on: the shutter with motion blur,
+ /// and the reflections with their cube map - which only the full renderer can
+ /// switch off; the others draw reflections regardless.
+ ///
+ private void UpdateDependentRows()
+ {
+ if (_keyRows.RowOf("gfx.postfx.motionblur.shutter") is { } shutter)
+ shutter.IsEnabled = IsChecked(MotionBlurCb);
+ ReflectionRows.IsEnabled = IsChecked(ReflectionsCubeMapCb) ||
+ SelectedRendererKind() != RendererKind.Modern;
+ }
+
+ private string SelectedRenderer() =>
+ SimulatorSettings.RenderEngines.ElementAtOrDefault(RenderEngineCb.SelectedIndex) ?? "full";
+
+ private RendererKind SelectedRendererKind() => SettingReach.KindOf(SelectedRenderer());
+
///
/// Writes the pending edits on this screen into the settings, so a save from
/// anywhere in the application picks them up.
///
- public void CaptureInto(SimulatorSettings s)
+ public void CaptureInto(SimulatorSettings s) => CaptureControls(s, remember: true);
+
+ /// (Uart.BaudRates);
+ // One the simulator's list lacks still works; keep it rather than lose it.
+ if (!rates.Contains(s.UartBaud))
+ rates.Add(s.UartBaud);
+ rates.Sort();
+ UartBaudCb.ItemsSource = rates.Select(r => r.ToString(CultureInfo.InvariantCulture)).ToList();
+ UartBaudCb.SelectedIndex = rates.IndexOf(s.UartBaud);
+
+ _uartEveryShown = Uart.ShownUpdateTime(s.UartUpdateTime);
+ UartEveryNud.Maximum = (decimal)Uart.MaxShownUpdateTime;
+ UartEveryNud.Value = _uartEveryShown;
+ UartTuneBox.Text = s.UartTune;
+ UartDebugCb.IsChecked = s.UartDebug;
+ UartMainCb.IsChecked = s.UartMain;
+ UartScndCb.IsChecked = s.UartScnd;
+ UartTrainCb.IsChecked = s.UartTrain;
+ UartLocalCb.IsChecked = s.UartLocal;
+ UartRadioVolumeCb.IsChecked = s.UartRadioVolume;
+ UartRadioChannelCb.IsChecked = s.UartRadioChannel;
+ ValidateUart();
+ }
+
+ private void CaptureUart(SimulatorSettings s)
+ {
+ s.UartEnabled = IsChecked(UartEnabledCb);
+ s.UartPort = (UartPortCb.Text ?? string.Empty).Trim();
+ if (int.TryParse(UartBaudCb.SelectedItem as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out int baud))
+ s.UartBaud = baud;
+ if (UartEveryNud.Value is { } every && every != _uartEveryShown)
+ s.UartUpdateTime = (double)every;
+ s.UartTune = UartTuneBox.Text ?? string.Empty;
+ s.UartDebug = IsChecked(UartDebugCb);
+ s.UartMain = IsChecked(UartMainCb);
+ s.UartScnd = IsChecked(UartScndCb);
+ s.UartTrain = IsChecked(UartTrainCb);
+ s.UartLocal = IsChecked(UartLocalCb);
+ s.UartRadioVolume = IsChecked(UartRadioVolumeCb);
+ s.UartRadioChannel = IsChecked(UartRadioChannelCb);
+ }
+
+ private void OpenLogToolsButton_OnClick(object? sender, RoutedEventArgs e) =>
+ (TopLevel.GetTopLevel(this) as MainWindow)?.OpenLogAndTools();
+
private void SaveButton_OnClick(object? sender, RoutedEventArgs e) => Save();
+ /// Shows what a save would change in eu07.ini, and saves if asked to.
+ private async void ChangesButton_OnClick(object? sender, RoutedEventArgs e)
+ {
+ if (TopLevel.GetTopLevel(this) is not Window owner)
+ return;
+
+ var store = AppServices.Current.SettingsStore;
+ var changes = store.Changes(Trial());
+ if (await IniChangesWindow.Show(owner, store.SavePath, changes, KeyboardConfig.Instance.Dirty))
+ Save();
+ }
+
public void Save()
{
CaptureInto(AppServices.Current.Settings);
- AppServices.Current.SettingsStore.Save();
+ var store = AppServices.Current.SettingsStore;
+ store.Save();
KeyboardConfig.Instance.Save();
RedrawThumbnailsIfNeeded();
- RedrawNavIfNeeded();
- _dirty = false;
+ // Not saved, it is still there to be saved.
+ _dirty = store.LastSaveFailed;
UpdateSaveState();
- if (SaveStatus is not null)
- SaveStatus.Text = App.Loc["SettingsSaved"];
+ SaveStatus.Text = App.Loc[store.LastSaveFailed ? "SettingsNotSaved" : "SettingsSaved"];
}
private void RenderEngineCb_OnSelectionChanged(object? sender, SelectionChangedEventArgs e)
{
- if (RenderEngineWarning is not null)
- RenderEngineWarning.IsVisible =
- SimulatorSettings.RenderEngines.ElementAtOrDefault(RenderEngineCb.SelectedIndex) == "experimental";
- }
-
- private void RedrawNavIfNeeded()
- {
- bool developer = AppServices.Current.Settings.DeveloperTools;
- if (developer == _shownDeveloperTools)
+ if (!_built)
return;
- _shownDeveloperTools = developer;
- DeveloperToolsChanged?.Invoke();
+ RefreshDerivedRows();
}
+ // ── The graphics card of a native Linux simulator ────────────────────────
+
+ private IReadOnlyList? _gpus;
+
+ private void GpuCb_OnSelectionChanged(object? sender, SelectionChangedEventArgs e)
+ {
+ if (!_built)
+ return;
+
+ UpdateGpuNote();
+ }
+
+ /// Names the cards found and says which one the simulator would get with the choice made here.
+ private void UpdateGpuNote()
+ {
+ if (!AppServices.Current.Environment.IsLinux)
+ return;
+
+ _gpus ??= AppServices.Current.Gpus.List();
+ var environment = AppServices.Current.Environment;
+ var preference = SelectedGpu();
+ string cards = string.Join(", ", _gpus);
+
+ GpuRow.Description = GpuOffload.NoteFor(_gpus, preference, environment.GetVariable) switch
+ {
+ GpuNote.Unread => App.Loc["GpuNoteUnread"],
+ GpuNote.OneCard => string.Format(App.Loc["GpuNoteOne"], cards),
+ GpuNote.LeftToSystem => string.Format(App.Loc["GpuNoteSystem"], cards),
+ GpuNote.PlayerChose => string.Format(App.Loc["GpuNotePlayer"], cards,
+ string.Join(", ", GpuOffload.PlayerChoices(environment.GetVariable))),
+ GpuNote.Moved => string.Format(App.Loc["GpuNoteTarget"], cards,
+ GpuOffload.Target(_gpus, preference, environment.GetVariable)),
+ _ => string.Format(App.Loc["GpuNoteNone"], cards)
+ };
+ }
+
+ private GpuPreference SelectedGpu() => GpuCb.SelectedIndex == 1 ? GpuPreference.System : GpuPreference.Discrete;
+
+ // ── Settings the chosen simulator would pass over ────────────────────────
+
+ /// The simulator the start button would run with the pick on this screen.
+ private string TargetExecutable()
+ {
+ var exes = AppServices.Current.Executables;
+ var pick = new SimulatorSettings
+ {
+ SelectExeAutomatically = SelectExeCb.SelectedIndex <= 0,
+ ExecutablePath = (SelectExeCb.SelectedItem as ComboBoxItem)?.Content?.ToString() ?? string.Empty
+ };
+ return exes.FullPath(exes.Resolve(pick, out _));
+ }
+
+ ///
+ /// Dims the rows the simulator to be started would ignore and says why. Follows
+ /// the simulator and renderer picked here, before they are saved.
+ ///
+ private void UpdateIdleNotes()
+ {
+ string exe = TargetExecutable();
+ var settings = AppServices.Current.Settings;
+ var target = new SimulatorTarget(
+ AppServices.Current.Executables.IsWindowsBuild(exe),
+ SelectedRenderer(),
+ settings.NetworkServer,
+ _keyRows.NumberIfSet("targetfps", settings),
+ settings.FpsAverage,
+ IsChecked(FullscreenWindowedCb));
+
+ foreach (var row in SettingsStack.GetLogicalDescendants().OfType())
+ row.IdleNote = string.IsNullOrEmpty(row.ConfigKey)
+ ? null
+ : IdleText(SettingReach.Why(row.ConfigKey, target));
+
+ RenderEngineWarning.IsVisible = SelectedRendererKind() == RendererKind.Experimental;
+ }
+
+ private static string? IdleText(IdleReason reason) => reason switch
+ {
+ IdleReason.WindowsBuildOnly => App.Loc["IdleWindowsBuildOnly"],
+ IdleReason.LegacyRendererOnly => App.Loc["IdleLegacyRendererOnly"],
+ IdleReason.ModernRendererOnly => App.Loc["IdleModernRendererOnly"],
+ IdleReason.OpenGlRenderersOnly => App.Loc["IdleOpenGlRenderersOnly"],
+ IdleReason.NeedsNetworkServer => App.Loc["IdleNeedsNetworkServer"],
+ IdleReason.NeedsFrameRateTarget => App.Loc["IdleNeedsFrameRateTarget"],
+ IdleReason.MonitorModeInstead => App.Loc["IdleMonitorMode"],
+ _ => null
+ };
+
private void RedrawThumbnailsIfNeeded()
{
bool large = AppServices.Current.Settings.LargeThumbnails;
@@ -476,77 +1116,108 @@ public partial class Settings : UserControl, ISettingsCapture
AppServices.Current.SettingsStore.Load();
ApplyToUi();
RedrawThumbnailsIfNeeded();
- CancelCapture();
- KeyboardConfig.Instance.Load();
- RebuildBindingList();
- RebuildKeyboard();
+ _keyBindings.Reload();
_dirty = false;
UpdateSaveState();
}
+ /// The list as
private void SelectResolution(int width, int height)
{
- string target = $"{width}x{height}";
- foreach (var obj in ResolutionCb.Items)
- {
- if (obj is ComboBoxItem item && item.Content?.ToString() == target)
- {
- ResolutionCb.SelectedItem = item;
- return;
- }
- }
+ var wanted = new ScreenSize(width, height);
+ var shown = ShownResolution();
+ var monitors = TopLevel.GetTopLevel(this)?.Screens is { } screens
+ ? screens.All.OrderByDescending(m => m.IsPrimary)
+ .Select(m => new ScreenSize(m.Bounds.Width, m.Bounds.Height)).ToList()
+ : new List();
- var added = new ComboBoxItem { Content = target };
- ResolutionCb.Items.Add(added);
- ResolutionCb.SelectedItem = added;
+ // Filling the list is not an edit; a size other than the one shown is.
+ WhileLoading(() =>
+ {
+ ResolutionCb.Items.Clear();
+ foreach (var choice in ResolutionChoices.For(monitors, wanted))
+ {
+ var item = new ComboBoxItem
+ {
+ Tag = choice.Size,
+ Content = choice.IsMonitor
+ ? string.Format(App.Loc["ResolutionOnMonitor"], choice.Size)
+ : choice.Size.ToString()
+ };
+ ResolutionCb.Items.Add(item);
+ if (choice.Size == wanted)
+ ResolutionCb.SelectedItem = item;
+ }
+ });
+
+ if (shown != wanted)
+ MarkDirty();
+ }
+
+ private ScreenSize? ShownResolution() => (ResolutionCb.SelectedItem as ComboBoxItem)?.Tag as ScreenSize?;
+
+ /// A monitor came or went, or the language changed: the same size, on a list made afresh.
+ private void RefreshResolutions()
+ {
+ if (ShownResolution() is { } shown)
+ SelectResolution(shown.Width, shown.Height);
}
private void ReadResolution(SimulatorSettings s)
{
- var text = (ResolutionCb.SelectedItem as ComboBoxItem)?.Content?.ToString();
- if (string.IsNullOrEmpty(text))
- return;
- var parts = text.Split('x');
- if (parts.Length == 2 &&
- int.TryParse(parts[0], out int w) && int.TryParse(parts[1], out int h))
+ if (ShownResolution() is { } size)
{
- s.Width = w;
- s.Height = h;
+ s.Width = size.Width;
+ s.Height = size.Height;
}
}
private void TextureResolutionSlider_OnValueChanged(object? sender, RangeBaseValueChangedEventArgs e)
{
- if (TexResolutionRow is null || textureResolutionSlider is null)
+ if (!_built)
return;
- int resolution = 1 << (int)textureResolutionSlider.Value;
- TexResolutionRow.ValueText = $"{resolution} px";
+ ShowPixels(TexResolutionRow, textureResolutionSlider);
}
private void CabTextureResolutionSlider_OnValueChanged(object? sender, RangeBaseValueChangedEventArgs e)
{
- if (CabTexResolutionRow is null || cabTextureResolutionSlider is null)
+ if (!_built)
return;
- int resolution = 1 << (int)cabTextureResolutionSlider.Value;
- CabTexResolutionRow.ValueText = $"{resolution} px";
+ ShowPixels(CabTexResolutionRow, cabTextureResolutionSlider);
}
private void shaderResolutionSlider_OnValueChanged(object? sender, RangeBaseValueChangedEventArgs e)
{
- if (ShadowResolutionRow is null || shaderResolutionSlider is null)
+ if (!_built)
return;
- int resolution = 1 << (int)shaderResolutionSlider.Value;
- ShadowResolutionRow.ValueText = $"{resolution} px";
- ToolTip.SetTip(shaderResolutionSlider, ShadowMapWord(resolution));
+ UpdateShadowResolution();
+ }
+
+ /// A power of two as the row of its slider says it; the size itself for what else follows it.
+ private static int ShowPixels(SettingRow row, Slider slider)
+ {
+ int resolution = 1 << (int)slider.Value;
+ row.ValueText = $"{resolution} px";
+ return resolution;
+ }
+
+ private void UpdateShadowResolution()
+ {
+ int resolution = ShowPixels(ShadowResolutionRow, shaderResolutionSlider);
+ ToolTip.SetTip(shaderResolutionSlider, SettingTexts.ShadowMapWord(resolution));
+
+ // Below this the simulator would raise the range anyway.
+ shaderRange.Minimum = SimulatorSettings.ShadowRangeFloor(resolution);
+ UpdateQualityCaptions();
}
private void FillLanguageCombo()
{
ChangeLanguageCb.Items.Clear();
- foreach (var lang in LocalizationService.AvailableLanguages())
+ foreach (var lang in App.Loc.Languages())
ChangeLanguageCb.Items.Add(new ComboBoxItem { Content = lang.Name, Tag = lang.Code });
if (ChangeLanguageCb.ItemCount == 0)
ChangeLanguageCb.Items.Add(new ComboBoxItem { Content = "English", Tag = "en" });
@@ -562,16 +1233,23 @@ public partial class Settings : UserControl, ISettingsCapture
if (item != null && !ReferenceEquals(ChangeLanguageCb.SelectedItem, item))
ChangeLanguageCb.SelectedItem = item;
+
+ LanguageRow.Description = !App.Loc.HasOwnTexts
+ ? App.Loc["LanguageStarterMissing"]
+ : SimulatorSpeaks(App.Loc.CurrentLangCode)
+ ? App.Loc.Opt("LanguageDesc")
+ : App.Loc["LanguageSimMissing"];
}
+ /// The simulator reads lang/<code>.po and is in English without one.
+ private static bool SimulatorSpeaks(string code) =>
+ string.Equals(code, "en", StringComparison.OrdinalIgnoreCase) ||
+ AppServices.Current.Files.FileExists(AppServices.Current.Paths.FromRoot("lang", code + ".po"));
+
private void LanguageComboBox_OnSelectionChanged(object? sender, SelectionChangedEventArgs e)
{
- if ((ChangeLanguageCb.SelectedItem as ComboBoxItem)?.Tag is not string code)
- return;
- if (string.Equals(code, App.Loc.CurrentLangCode, StringComparison.OrdinalIgnoreCase))
- return;
-
- App.ApplyLanguage(code);
+ if ((ChangeLanguageCb.SelectedItem as ComboBoxItem)?.Tag is string code)
+ App.ChangeLanguage(code);
}
private void FeedbackCb_OnSelectionChanged(object? sender, SelectionChangedEventArgs e) =>
@@ -586,9 +1264,11 @@ public partial class Settings : UserControl, ISettingsCapture
private bool ConditionAllows(SettingRow row)
{
+ if (ReferenceEquals(row, GpuRow))
+ return AppServices.Current.Environment.IsLinux;
if (ReferenceEquals(row, FeedbackPortRow))
return FeedbackCb.SelectedIndex == 3;
- if (ReferenceEquals(row, ComButtonRow))
+ if (ReferenceEquals(row.FindLogicalAncestorOfType(), UartSettings))
return FeedbackCb.SelectedIndex == 5;
return true;
}
@@ -599,6 +1279,9 @@ public partial class Settings : UserControl, ISettingsCapture
private void CategoryList_OnSelectionChanged(object? sender, SelectionChangedEventArgs e)
{
+ if (!_built)
+ return;
+
// Picking a category is how you leave a search, so the query goes with it.
if (SettingsSearch is { Text.Length: > 0 })
SettingsSearch.Text = string.Empty; // raises TextChanged -> ApplyFilter
@@ -606,7 +1289,13 @@ public partial class Settings : UserControl, ISettingsCapture
ApplyFilter();
}
- private void SettingsSearch_OnTextChanged(object? sender, TextChangedEventArgs e) => ApplyFilter();
+ private void SettingsSearch_OnTextChanged(object? sender, TextChangedEventArgs e)
+ {
+ if (!_built)
+ return;
+
+ ApplyFilter();
+ }
///
/// Single owner of what is on screen. With an empty query it shows the selected
@@ -615,10 +1304,7 @@ public partial class Settings : UserControl, ISettingsCapture
///
private void ApplyFilter()
{
- if (SettingsStack is null || CategoryList is null || ControlsHost is null)
- return;
-
- string query = SettingsSearch?.Text?.Trim() ?? string.Empty;
+ string query = SettingsSearch.Text?.Trim() ?? string.Empty;
bool searching = query.Length > 0;
string category = (CategoryList.SelectedItem as ListBoxItem)?.Tag as string ?? string.Empty;
@@ -628,10 +1314,11 @@ public partial class Settings : UserControl, ISettingsCapture
bool bindings = category == "controls";
ControlsHost.IsVisible = bindings;
SettingsScroll.IsVisible = !bindings;
+ PresetBar.IsVisible = category == "graphics" && !searching;
if (bindings)
{
- RebuildBindingList();
+ _keyBindings.RebuildList();
foreach (var entry in CategoryList.Items.OfType())
entry.Classes.Set("NoHits", false);
return;
@@ -714,27 +1401,38 @@ public partial class Settings : UserControl, ISettingsCapture
{
switch (control)
{
- // Choosing a profile changes nothing until Apply is pressed.
- case ComboBox combo when ReferenceEquals(combo, ProfileCb):
+ // Choosing a profile changes nothing until Apply is pressed, and a
+ // language is saved the moment it is picked.
+ case ComboBox combo when ReferenceEquals(combo, ProfileCb) ||
+ ReferenceEquals(combo, ChangeLanguageCb):
+ break;
+ // The rows of SimulatorKeyRows report their own changes.
+ case { Tag: SimulatorKey }:
break;
case CheckBox cb:
- cb.IsCheckedChanged += (_, _) => MarkDirty();
+ cb.IsCheckedChanged += (_, _) => OnControlChanged();
break;
case Slider slider:
- slider.ValueChanged += (_, _) => MarkDirty();
+ slider.ValueChanged += (_, _) => OnControlChanged();
break;
case ComboBox combo:
- combo.SelectionChanged += (_, _) => MarkDirty();
+ combo.SelectionChanged += (_, _) => OnControlChanged();
break;
case NumericUpDown nud:
- nud.ValueChanged += (_, _) => MarkDirty();
+ nud.ValueChanged += (_, _) => OnControlChanged();
break;
}
}
foreach (var section in this.GetLogicalDescendants().OfType())
if (section.Toggle is CheckBox toggle)
- toggle.IsCheckedChanged += (_, _) => MarkDirty();
+ toggle.IsCheckedChanged += (_, _) => OnControlChanged();
+ }
+
+ private void OnControlChanged()
+ {
+ MarkDirty();
+ QueuePresetMarks();
}
private void MarkDirty()
@@ -748,9 +1446,6 @@ public partial class Settings : UserControl, ISettingsCapture
private void UpdateSaveState()
{
- if (SaveButton is null || SaveStatus is null)
- return;
-
bool dirty = _dirty || KeyboardConfig.Instance.Dirty;
SaveButton.Classes.Set("Accent", dirty);
SaveStatus.Text = dirty ? App.Loc["UnsavedChanges"] : string.Empty;
@@ -758,8 +1453,6 @@ public partial class Settings : UserControl, ISettingsCapture
private static bool IsChecked(CheckBox cb) => cb.IsChecked == true;
- private static int Clamp(int v, int lo, int hi) => v < lo ? lo : (v > hi ? hi : v);
-
private static int ParsePriorityTag(object? tag)
{
if (tag is int i) return i;
@@ -774,717 +1467,58 @@ public partial class Settings : UserControl, ISettingsCapture
return log;
}
- private static int AnisotropyToSlider(int anisotropy)
- {
- var steps = SimulatorSettings.AnisotropySteps;
- for (int i = 0; i < steps.Length; i++)
- if (steps[i] == anisotropy)
- return i + 1;
- return 4;
- }
-
- private StackPanel? _bindingListPanel;
- private StackPanel? _keyboardPanel;
-
- ///
- /// True while a cab-control binding is waiting for a keypress. The window's own
- /// shortcuts stand down for the duration, otherwise Ctrl+N would never reach here.
- ///
- public bool IsCapturingKey => _capturing is not null;
-
- private KeyBinding? _capturing;
- private Button? _capturingButton;
-
- private readonly Dictionary _keyCells = new(StringComparer.OrdinalIgnoreCase);
-
- private bool _flyoutLoading;
-
- private static readonly IBrush KeyUnassignedBrush = new SolidColorBrush(Color.Parse("#2A3036"));
- private static readonly IBrush KeyFillerBrush = new SolidColorBrush(Color.Parse("#21262B"));
- private static readonly IBrush KeyPlainBrush = new SolidColorBrush(Color.Parse("#2E9E1F"));
- private static readonly IBrush KeyShiftBrush = new SolidColorBrush(Color.Parse("#C9A227"));
- private static readonly IBrush KeyCtrlBrush = new SolidColorBrush(Color.Parse("#2D7FD3"));
- private static readonly IBrush KeyShiftCtrlBrush = new SolidColorBrush(Color.Parse("#C8372D"));
- private static readonly IBrush KeyBorderBrush = new SolidColorBrush(Color.Parse("#3A424A"));
- private static readonly IBrush FgBrush = new SolidColorBrush(Color.Parse("#E6E8EA"));
- private static readonly IBrush FgDimBrush = new SolidColorBrush(Color.Parse("#9098A0"));
- private static readonly IBrush ConflictBrush = new SolidColorBrush(Color.Parse("#E06C5A"));
-
- private const double KeyUnit = 30;
- private const double KeyHeight = 34;
- private const double KeyGap = 4;
-
- private void BuildControlsTab()
- {
- if (ControlsHost is null)
- return;
-
- var topBar = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Margin = new Thickness(0, 0, 0, 8) };
- topBar.Children.Add(new TextBlock
- {
- Text = App.Loc["BindingsHint"],
- VerticalAlignment = VerticalAlignment.Center,
- Foreground = FgDimBrush
- });
- var restoreBtn = new Button { Content = App.Loc["RestoreDefaults"] };
- restoreBtn.Classes.Add("Flat");
- restoreBtn.Click += (_, _) =>
- {
- CancelCapture();
- KeyboardConfig.Instance.LoadDefaults();
- KeyboardConfig.Instance.Dirty = true;
- MarkDirty();
- RebuildBindingList();
- RebuildKeyboard();
- };
- topBar.Children.Add(restoreBtn);
- Grid.SetRow(topBar, 0);
- ControlsHost.Children.Add(topBar);
-
- _bindingListPanel = new StackPanel { Spacing = 3 };
- var listScroll = new ScrollViewer
- {
- Content = _bindingListPanel,
- VerticalScrollBarVisibility = ScrollBarVisibility.Auto
- };
- Grid.SetRow(listScroll, 1);
- ControlsHost.Children.Add(listScroll);
-
- var bottom = new StackPanel { Spacing = 8, Margin = new Thickness(0, 10, 0, 0) };
- bottom.Children.Add(BuildLegend());
- _keyboardPanel = new StackPanel();
- bottom.Children.Add(new ScrollViewer
- {
- Content = _keyboardPanel,
- HorizontalScrollBarVisibility = ScrollBarVisibility.Auto,
- VerticalScrollBarVisibility = ScrollBarVisibility.Disabled
- });
- Grid.SetRow(bottom, 2);
- ControlsHost.Children.Add(bottom);
-
- RebuildBindingList();
- RebuildKeyboard();
- }
-
- private void RebuildBindingList()
- {
- if (_bindingListPanel is null)
- return;
-
- _bindingListPanel.Children.Clear();
- // The sidebar search box serves this list too - see ApplyFilter.
- string filter = SettingsSearch?.Text?.Trim() ?? string.Empty;
- var conflicts = ComputeConflicts();
-
- foreach (var b in KeyboardConfig.Instance.Bindings)
- {
- if (filter.Length > 0 && !MatchesFilter(b, filter))
- continue;
- _bindingListPanel.Children.Add(BuildBindingRow(b, conflicts));
- }
- }
-
- private static bool MatchesFilter(KeyBinding b, string filter) =>
- TextMatch.Contains(b.Command, filter) ||
- TextMatch.Contains(KeyboardConfig.Instance.DescriptionOf(b), filter);
-
- private Control BuildBindingRow(KeyBinding b, HashSet conflicts)
- {
- var grid = new Grid
- {
- ColumnDefinitions = new ColumnDefinitions("*,Auto,Auto"),
- VerticalAlignment = VerticalAlignment.Center
- };
-
- var label = new StackPanel { VerticalAlignment = VerticalAlignment.Center };
- label.Children.Add(new TextBlock
- {
- Text = CommandLabel(b),
- Foreground = FgBrush,
- FontSize = 12,
- TextTrimming = TextTrimming.CharacterEllipsis
- });
- label.Children.Add(new TextBlock
- {
- Text = b.Command,
- Foreground = FgDimBrush,
- FontSize = 12,
- TextTrimming = TextTrimming.CharacterEllipsis
- });
- Grid.SetColumn(label, 0);
- grid.Children.Add(label);
-
- bool conflict = b.IsAssigned && conflicts.Contains(ComboKey(b));
- var comboButton = new Button
- {
- Content = _capturing == b ? App.Loc["PressKey"] : ComboText(b),
- MinWidth = 140,
- HorizontalContentAlignment = HorizontalAlignment.Center,
- VerticalAlignment = VerticalAlignment.Center,
- Foreground = conflict ? ConflictBrush : FgBrush
- };
- comboButton.Classes.Add("Flat");
- if (conflict)
- ToolTip.SetTip(comboButton, App.Loc["ConflictTooltip"]);
- comboButton.Click += (_, _) => StartCapture(b, comboButton);
- Grid.SetColumn(comboButton, 1);
- grid.Children.Add(comboButton);
-
- var clearButton = new Button
- {
- Content = "✕",
- Margin = new Thickness(6, 0, 0, 0),
- VerticalAlignment = VerticalAlignment.Center
- };
- clearButton.Classes.Add("Basic");
- ToolTip.SetTip(clearButton, App.Loc["ClearBinding"]);
- clearButton.Click += (_, _) =>
- {
- CancelCapture();
- b.Shift = b.Ctrl = false;
- b.Key = "none";
- KeyboardConfig.Instance.Dirty = true;
- MarkDirty();
- RebuildBindingList();
- RebuildKeyboard();
- };
- Grid.SetColumn(clearButton, 2);
- grid.Children.Add(clearButton);
-
- return new Border
- {
- Background = KeyUnassignedBrush,
- BorderBrush = KeyBorderBrush,
- BorderThickness = new Thickness(1),
- CornerRadius = new CornerRadius(2),
- Padding = new Thickness(8, 4),
- Child = grid
- };
- }
-
- private void StartCapture(KeyBinding b, Button button)
- {
-
- if (_capturing is not null && _capturingButton is not null)
- _capturingButton.Content = ComboText(_capturing);
-
- _capturing = b;
- _capturingButton = button;
- button.Content = App.Loc["PressKey"];
- button.Focus();
- }
-
- private void CancelCapture()
- {
- if (_capturing is not null && _capturingButton is not null)
- _capturingButton.Content = ComboText(_capturing);
- _capturing = null;
- _capturingButton = null;
- }
-
- private void OnControlsKeyDown(object? sender, KeyEventArgs e)
- {
- if (_capturing is null)
- return;
-
- if (e.Key == Key.Escape)
- {
- CancelCapture();
- e.Handled = true;
- return;
- }
-
- if (KeyMap.IsModifierKey(e.Key))
- return;
-
- string? token = KeyMap.FromInput(e.Key, e.PhysicalKey);
- if (token is null)
- {
- e.Handled = true;
- return;
- }
-
- _capturing.Shift = e.KeyModifiers.HasFlag(KeyModifiers.Shift);
- _capturing.Ctrl = e.KeyModifiers.HasFlag(KeyModifiers.Control);
- _capturing.Key = token;
- // As the key flyout does: the combination moves here, not doubled up.
- ReleaseCombo(token, _capturing.Shift, _capturing.Ctrl, _capturing);
- KeyboardConfig.Instance.Dirty = true;
- MarkDirty();
- e.Handled = true;
-
- _capturing = null;
- _capturingButton = null;
- RebuildBindingList();
- RebuildKeyboard();
- }
-
- private void RebuildKeyboard()
- {
- if (_keyboardPanel is null)
- return;
-
- _keyCells.Clear();
- _keyboardPanel.Children.Clear();
- var states = ComputeKeyStates();
-
- var row = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 16 };
- row.Children.Add(BuildKeyBlock(KeyMap.MainBlock, states));
- row.Children.Add(BuildKeyBlock(KeyMap.NavBlock, states));
- row.Children.Add(BuildKeyBlock(KeyMap.NumpadBlock, states));
- _keyboardPanel.Children.Add(row);
- }
-
- private void UpdateKeyboardColors()
- {
- var states = ComputeKeyStates();
- foreach (var (token, content) in _keyCells)
- {
- if (content.Children.Count > 0)
- content.Children.RemoveAt(0);
- content.Children.Insert(0, BuildKeyBackground(token, states));
- states.TryGetValue(token, out var state);
- ToolTip.SetTip(content, BuildKeyTooltip(token, state));
- }
- }
-
- private Control BuildKeyBlock(KeyCap[][] rows, Dictionary states)
- {
- var block = new StackPanel { Spacing = KeyGap, VerticalAlignment = VerticalAlignment.Top };
- foreach (var rowCaps in rows)
- {
- var rowPanel = new StackPanel { Orientation = Orientation.Horizontal, Spacing = KeyGap };
- foreach (var cap in rowCaps)
- rowPanel.Children.Add(BuildKeyCap(cap, states));
- block.Children.Add(rowPanel);
- }
- return block;
- }
-
- private Control BuildKeyCap(KeyCap cap, Dictionary states)
- {
- double width = cap.Width * KeyUnit + (cap.Width - 1) * KeyGap;
- var content = new Grid { Width = width, Height = KeyHeight };
-
- var keyBorder = new Border
- {
- BorderBrush = KeyBorderBrush,
- BorderThickness = new Thickness(1),
- CornerRadius = new CornerRadius(3),
- ClipToBounds = true,
- Child = content
- };
-
- if (cap.Token is null)
- {
-
- content.Children.Add(new Border { Background = KeyFillerBrush });
- content.Children.Add(new TextBlock
- {
- Text = cap.Label,
- Foreground = FgDimBrush,
- FontSize = 9,
- HorizontalAlignment = HorizontalAlignment.Center,
- VerticalAlignment = VerticalAlignment.Center
- });
- keyBorder.Opacity = 0.55;
- if (!string.IsNullOrEmpty(cap.Label))
- ToolTip.SetTip(keyBorder, App.Loc["KbReserved"]);
- return keyBorder;
- }
-
- string token = cap.Token;
- states.TryGetValue(token.ToLowerInvariant(), out var st);
- content.Children.Add(BuildKeyBackground(token, states));
- content.Children.Add(new TextBlock
- {
- Text = cap.Label,
- Foreground = FgBrush,
- FontSize = 10,
- FontWeight = FontWeight.SemiBold,
- HorizontalAlignment = HorizontalAlignment.Center,
- VerticalAlignment = VerticalAlignment.Center
- });
- ToolTip.SetTip(content, BuildKeyTooltip(token, st));
-
- keyBorder.Cursor = new Cursor(StandardCursorType.Hand);
- keyBorder.PointerPressed += (_, _) => ShowKeyFlyout(token, keyBorder);
- _keyCells[token] = content;
- return keyBorder;
- }
-
- private Control BuildKeyBackground(string token, Dictionary states)
- {
- states.TryGetValue(token.ToLowerInvariant(), out var state);
- var colours = new List();
- if (state is { Plain: true }) colours.Add(KeyPlainBrush);
- if (state is { Shift: true }) colours.Add(KeyShiftBrush);
- if (state is { Ctrl: true }) colours.Add(KeyCtrlBrush);
- if (state is { ShiftCtrl: true }) colours.Add(KeyShiftCtrlBrush);
-
- if (colours.Count == 0)
- return new Border { Background = KeyUnassignedBrush };
-
- var stripes = new UniformGrid { Rows = 1, Columns = colours.Count };
- foreach (var c in colours)
- stripes.Children.Add(new Border { Background = c });
- return stripes;
- }
-
- private string BuildKeyTooltip(string token, KeyState? state)
- {
- string head = KeyMap.DisplayName(token);
- if (state is null || state.Tips.Count == 0)
- return $"{head}: {App.Loc["KbUnassigned"]}";
- return head + "\n" + string.Join("\n", state.Tips);
- }
-
- private void ShowKeyFlyout(string token, Control anchor)
- {
- CancelCapture();
- var commands = KeyboardConfig.Instance.Bindings;
-
- var items = new List { App.Loc["BindNone"] };
- foreach (var c in commands)
- items.Add(CommandLabel(c));
-
- var slots = new (bool shift, bool ctrl, string labelKey, IBrush colour)[]
- {
- (false, false, "BindNoMod", KeyPlainBrush),
- (true, false, "BindShift", KeyShiftBrush),
- (false, true, "BindCtrl", KeyCtrlBrush),
- (true, true, "BindShiftCtrl", KeyShiftCtrlBrush),
- };
-
- var combos = new ComboBox[slots.Length];
- var grid = new Grid
- {
- ColumnDefinitions = new ColumnDefinitions("Auto,*"),
- RowDefinitions = new RowDefinitions("Auto,Auto,Auto,Auto")
- };
-
- for (int i = 0; i < slots.Length; i++)
- {
- var (shift, ctrl, labelKey, colour) = slots[i];
-
- // The swatch ties the row to the key colours on the keyboard above.
- var lbl = new StackPanel
- {
- Orientation = Orientation.Horizontal,
- Spacing = 6,
- VerticalAlignment = VerticalAlignment.Center,
- Margin = new Thickness(0, 4, 12, 4),
- Children =
- {
- new Border
- {
- Width = 10, Height = 10, CornerRadius = new CornerRadius(2),
- Background = colour, VerticalAlignment = VerticalAlignment.Center
- },
- new TextBlock { Text = App.Loc[labelKey], Foreground = FgBrush, VerticalAlignment = VerticalAlignment.Center }
- }
- };
- Grid.SetRow(lbl, i);
- Grid.SetColumn(lbl, 0);
- grid.Children.Add(lbl);
-
- var cb = new ComboBox
- {
- ItemsSource = items,
- MinWidth = 280,
- MaxDropDownHeight = 320,
- Margin = new Thickness(0, 4),
- HorizontalAlignment = HorizontalAlignment.Stretch
- };
- cb.SelectionChanged += (_, _) =>
- {
- if (_flyoutLoading)
- return;
- AssignSlot(token, shift, ctrl, cb.SelectedIndex, commands);
- SyncFlyoutCombos(token, combos);
- UpdateKeyboardColors();
- RebuildBindingList();
- };
- Grid.SetRow(cb, i);
- Grid.SetColumn(cb, 1);
- grid.Children.Add(cb);
- combos[i] = cb;
- }
-
- SyncFlyoutCombos(token, combos);
-
- var panel = new StackPanel { Spacing = 8, Margin = new Thickness(12), MinWidth = 360 };
- panel.Children.Add(new TextBlock
- {
- Text = $"{App.Loc["BindKeyTitle"]} {KeyMap.DisplayName(token)}",
- FontWeight = FontWeight.SemiBold,
- Foreground = FgBrush
- });
- panel.Children.Add(new TextBlock
- {
- Text = App.Loc["BindKeyHint"],
- Foreground = FgDimBrush,
- FontSize = 12,
- TextWrapping = TextWrapping.Wrap
- });
- panel.Children.Add(grid);
-
- var flyout = new Flyout { Content = panel };
- flyout.ShowAt(anchor);
- }
-
- private void SyncFlyoutCombos(string token, ComboBox[] combos)
- {
- var commands = KeyboardConfig.Instance.Bindings;
- var slots = new (bool shift, bool ctrl)[] { (false, false), (true, false), (false, true), (true, true) };
- _flyoutLoading = true;
- for (int i = 0; i < combos.Length; i++)
- {
- var cmd = CommandInSlot(token, slots[i].shift, slots[i].ctrl);
- combos[i].SelectedIndex = cmd is null ? 0 : commands.IndexOf(cmd) + 1;
- }
- _flyoutLoading = false;
- }
-
- private void AssignSlot(string token, bool shift, bool ctrl, int selectedIndex, List commands)
- {
- KeyBinding? chosen = selectedIndex <= 0 ? null : commands[selectedIndex - 1];
- ReleaseCombo(token, shift, ctrl, chosen);
-
- if (chosen is not null)
- {
- chosen.Key = token;
- chosen.Shift = shift;
- chosen.Ctrl = ctrl;
- }
-
- KeyboardConfig.Instance.Dirty = true;
- MarkDirty();
- }
-
- ///
- /// Frees a key combination for
- private static void ReleaseCombo(string token, bool shift, bool ctrl, KeyBinding? keeper)
- {
- foreach (var b in KeyboardConfig.Instance.Bindings)
- {
- if (!ReferenceEquals(b, keeper) && b.IsAssigned &&
- string.Equals(b.Key, token, StringComparison.OrdinalIgnoreCase) &&
- b.Shift == shift && b.Ctrl == ctrl)
- {
- b.Shift = b.Ctrl = false;
- b.Key = "none";
- }
- }
- }
-
- private static KeyBinding? CommandInSlot(string token, bool shift, bool ctrl) =>
- KeyboardConfig.Instance.Bindings.FirstOrDefault(b =>
- b.IsAssigned &&
- string.Equals(b.Key, token, StringComparison.OrdinalIgnoreCase) &&
- b.Shift == shift && b.Ctrl == ctrl);
-
- private Control BuildLegend()
- {
- var legend = new WrapPanel { Orientation = Orientation.Horizontal };
- legend.Children.Add(LegendItem(KeyUnassignedBrush, App.Loc["KbUnassigned"]));
- legend.Children.Add(LegendItem(KeyPlainBrush, App.Loc["KbAssigned"]));
- legend.Children.Add(LegendItem(KeyShiftBrush, App.Loc["KbShift"]));
- legend.Children.Add(LegendItem(KeyCtrlBrush, App.Loc["KbCtrl"]));
- legend.Children.Add(LegendItem(KeyShiftCtrlBrush, App.Loc["KbShiftCtrl"]));
- return legend;
- }
-
- private Control LegendItem(IBrush brush, string text)
- {
- var sp = new StackPanel
- {
- Orientation = Orientation.Horizontal,
- Spacing = 6,
- Margin = new Thickness(0, 0, 16, 0),
- VerticalAlignment = VerticalAlignment.Center
- };
- sp.Children.Add(new Border
- {
- Width = 16,
- Height = 16,
- Background = brush,
- BorderBrush = KeyBorderBrush,
- BorderThickness = new Thickness(1),
- CornerRadius = new CornerRadius(2),
- VerticalAlignment = VerticalAlignment.Center
- });
- sp.Children.Add(new TextBlock { Text = text, Foreground = FgDimBrush, VerticalAlignment = VerticalAlignment.Center });
- return sp;
- }
-
- private sealed class KeyState
- {
- public bool Plain;
- public bool Shift;
- public bool Ctrl;
- public bool ShiftCtrl;
- public readonly List Tips = new();
- }
-
- private static Dictionary ComputeKeyStates()
- {
- var map = new Dictionary(StringComparer.OrdinalIgnoreCase);
- foreach (var b in KeyboardConfig.Instance.Bindings)
- {
- if (!b.IsAssigned)
- continue;
- string key = b.Key.ToLowerInvariant();
- if (!map.TryGetValue(key, out var state))
- map[key] = state = new KeyState();
-
- switch (b.Shift, b.Ctrl)
- {
- case (false, false): state.Plain = true; break;
- case (true, false): state.Shift = true; break;
- case (false, true): state.Ctrl = true; break;
- default: state.ShiftCtrl = true; break;
- }
-
- state.Tips.Add($"{ComboText(b)} — {CommandLabel(b)}");
- }
- return map;
- }
-
- private static HashSet ComputeConflicts()
- {
- var seen = new HashSet(StringComparer.OrdinalIgnoreCase);
- var dup = new HashSet(StringComparer.OrdinalIgnoreCase);
- foreach (var b in KeyboardConfig.Instance.Bindings)
- {
- if (!b.IsAssigned)
- continue;
- string k = ComboKey(b);
- if (!seen.Add(k))
- dup.Add(k);
- }
- return dup;
- }
-
- private static string ComboKey(KeyBinding b) =>
- $"{(b.Ctrl ? 1 : 0)}|{(b.Shift ? 1 : 0)}|{b.Key.ToLowerInvariant()}";
-
- private static string ComboText(KeyBinding b)
- {
- if (!b.IsAssigned)
- return "—";
- var parts = new List();
- if (b.Ctrl) parts.Add("Ctrl");
- if (b.Shift) parts.Add("Shift");
- parts.Add(KeyMap.DisplayName(b.Key));
- return string.Join(" + ", parts);
- }
-
- private static string CommandLabel(KeyBinding b) =>
- KeyboardConfig.Instance.DescriptionOf(b) is { Length: > 0 } description ? Capitalize(description) : b.Command;
-
- private static string Capitalize(string s) =>
- string.IsNullOrEmpty(s) ? s : char.ToUpperInvariant(s[0]) + s.Substring(1);
-
- private static string[] QualityWords => new[]
- {
- App.Loc["QualityVeryLow"], App.Loc["QualityLow"], App.Loc["QualityNormal"],
- App.Loc["QualityHigh"], App.Loc["QualityVeryHigh"]
- };
-
private void QualitySlider_OnValueChanged(object? sender, RangeBaseValueChangedEventArgs e)
- => UpdateQualityCaptions();
+ {
+ if (!_built)
+ return;
+
+ UpdateQualityCaptions();
+ }
private void UpdateQualityCaptions()
{
- var q = QualityWords;
+ var q = SettingTexts.QualityWords;
- if (TexFilteringRow != null)
- TexFilteringRow.ValueText = q[Clamp((int)TexFilteringSlider.Value, 1, 5) - 1];
+ TexFilteringRow.ValueText = SettingTexts.Anisotropy(_anisotropy.Value);
- string[] four = { q[0], q[1], q[3], q[4] };
- if (TrackCurvesRow != null)
- TrackCurvesRow.ValueText = four[Clamp((int)TrackCurvesSlider.Value, 1, 4) - 1];
- if (SmokeParticlesRow != null)
- SmokeParticlesRow.ValueText = four[Clamp((int)SmokeParticlesSlider.Value, 1, 4) - 1];
+ TrackCurvesRow.ValueText = SettingTexts.Fidelity((int)TrackCurvesSlider.Value);
+ SmokeParticlesRow.ValueText = SettingTexts.Fidelity((int)SmokeParticlesSlider.Value);
- string[] msaa = { App.Loc["MsaaNone"], "x2", "x4", "x8" };
- if (MultisamplingRow != null)
- MultisamplingRow.ValueText = msaa[Clamp((int)MultisamplingSlider.Value, 1, 4) - 1];
+ MultisamplingRow.ValueText = SettingTexts.Multisampling((int)_multisampling.Value);
- string[] range = { App.Loc["RangeNormal"], App.Loc["RangeHigh"], App.Loc["RangeVeryHigh"] };
- if (RenderRangeRow != null)
- RenderRangeRow.ValueText = range[Clamp((int)RenderRangeSlider.Value, 1, 3) - 1];
+ RenderRangeRow.ValueText = "×" + _drawRangeFactor.Value.ToString("0.0", CultureInfo.CurrentCulture);
- if (CursorSensitivityRow != null)
- CursorSensitivityRow.ValueText = (int)CursorSensitivitySlider.Value switch
- {
- <= 1 => q[1],
- 2 => App.Loc["QualityStandard"],
- 3 => q[3],
- _ => q[4]
- };
-
- if (ShadowRangeRow != null)
+ CursorSensitivityRow.ValueText = (int)CursorSensitivitySlider.Value switch
{
- int metres = (int)shaderRange.Value;
- ShadowRangeRow.ValueText = $"{metres} m";
- ToolTip.SetTip(shaderRange, ShadowRangeWord(metres));
- }
+ <= 1 => q[1],
+ 2 => App.Loc["QualityStandard"],
+ 3 => q[3],
+ _ => q[4]
+ };
- if (CabShadowRangeRow != null)
- {
- int metres = (int)cabShaderSourceRange.Value;
- CabShadowRangeRow.ValueText = metres <= 0 ? App.Loc["RangeDisabled"] : $"{metres} m";
- ToolTip.SetTip(cabShaderSourceRange, CabShadowRangeWord(metres));
- }
+ int metres = (int)shaderRange.Value;
+ // Only the full renderer's cascades are known to stretch.
+ int reach = SimulatorSettings.ShadowReach(metres, 1 << (int)shaderResolutionSlider.Value,
+ SelectedRendererKind() != RendererKind.Modern);
+ ShadowRangeRow.ValueText = reach == metres ? $"{metres} m" : $"{metres} m → {reach} m";
+ ToolTip.SetTip(shaderRange, SettingTexts.ShadowRangeWord(reach));
- if (ReflectionsFramerateRow != null)
- {
- int fps = (int)reflectionsFramerate.Value;
- string word = ReflectionsRefreshWord(fps);
- ReflectionsFramerateRow.ValueText = $"{fps} FPS";
- ToolTip.SetTip(reflectionsFramerate, word.Length == 0 ? null : word);
- }
+ int cabMetres = (int)cabShaderSourceRange.Value;
+ CabShadowRangeRow.ValueText = cabMetres <= 0 ? App.Loc["RangeDisabled"] : $"{cabMetres} m";
+ ToolTip.SetTip(cabShaderSourceRange, SettingTexts.CabShadowRangeWord(cabMetres));
+
+ ReflectionsFramerateRow.ValueText = SettingTexts.ReflectionsInterval(_reflections.Value);
+
+ FpsLimitRow.ValueText = _fpsLimit.Value <= 0
+ ? App.Loc["FpsLimitOff"]
+ : _fpsLimit.Value.ToString("0.##", CultureInfo.CurrentCulture) + " FPS";
+
+ // Set here rather than bound with a StringFormat, which would keep the old
+ // language's decimal separator until the slider moved.
+ ShadowAngleLimitRow.ValueText = SettingTexts.TwoDecimals(ShadowAngleLimitSlider.Value);
+ FrictionRow.ValueText = SettingTexts.TwoDecimals(FrictionSlider.Value);
+ BrakeStepRow.ValueText = SettingTexts.TwoDecimals(BrakeStepSlider.Value);
+ BrakeSpeedRow.ValueText = SettingTexts.TwoDecimals(BrakeSpeedSlider.Value);
+ TrainThreadsRow.ValueText = ((int)TrainThreadsSlider.Value).ToString(CultureInfo.CurrentCulture);
}
-
- private static string ShadowMapWord(int pixels) => pixels switch
- {
- <= 512 => App.Loc["QualityVeryLow"],
- <= 1024 => App.Loc["QualityLow"],
- <= 2048 => App.Loc["QualityModerate"],
- <= 4096 => App.Loc["QualityHigh"],
- _ => App.Loc["QualityVeryHigh"]
- };
-
- private static string ShadowRangeWord(int metres) => metres switch
- {
- <= 25 => App.Loc["RangeVeryLow"],
- <= 50 => App.Loc["RangeLow"],
- <= 150 => App.Loc["RangeModerate"],
- <= 250 => App.Loc["RangeHigh"],
- _ => App.Loc["RangeVeryHigh"]
- };
-
- private static string CabShadowRangeWord(int metres) => metres switch
- {
- <= 10 => App.Loc["RangeVeryLow"],
- <= 20 => App.Loc["RangeLow"],
- <= 30 => App.Loc["RangeStandard"],
- <= 50 => App.Loc["RangeHigh"],
- _ => App.Loc["RangeVeryHigh"]
- };
-
- private static string ReflectionsRefreshWord(int fps) => fps switch
- {
- <= 5 => App.Loc["QualityVeryLow"],
- <= 10 => App.Loc["QualityLow"],
- <= 25 => App.Loc["QualityHigh"],
- <= 60 => App.Loc["QualityVeryHigh"],
- _ => string.Empty
- };
-
}
diff --git a/StarterNG/Views/SimulatorKeyRows.cs b/StarterNG/Views/SimulatorKeyRows.cs
new file mode 100644
index 0000000..a59fea5
--- /dev/null
+++ b/StarterNG/Views/SimulatorKeyRows.cs
@@ -0,0 +1,251 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.LogicalTree;
+using StarterNG.Controls;
+using StarterNG.Domain.Settings;
+
+namespace StarterNG.Views;
+
+///
+/// The rows of the
+internal sealed class SimulatorKeyRows
+{
+ private sealed record Row(SimulatorKey Key, SettingRow Setting, Control Input)
+ {
+ public string Shown = string.Empty;
+ }
+
+ private readonly List _rows = new();
+
+ private readonly List<(SettingsSection Section, string HeaderKey)> _sections = new();
+
+ public event Action? Changed;
+
+ /// Raised on every move of a row, the starter's own setting of it included.
+ public event Action? Moved;
+
+ ///
+ /// Puts each row where the layout has a
+ public void Build(Panel categories)
+ {
+ var slots = categories.GetLogicalDescendants().OfType()
+ .Where(slot => slot.Key is not null)
+ .ToDictionary(slot => slot.Key!, StringComparer.OrdinalIgnoreCase);
+
+ foreach (var key in SimulatorKeys.All)
+ if (slots.TryGetValue(key.Key, out var slot))
+ slot.Child = BuildRow(key);
+
+ foreach (var group in SimulatorKeys.All.Where(k => !slots.ContainsKey(k.Key))
+ .GroupBy(k => (k.Category, k.Section)))
+ {
+ var category = categories.Children.OfType()
+ .FirstOrDefault(p => string.Equals(p.Tag as string, group.Key.Category, StringComparison.Ordinal));
+ if (category is null)
+ continue;
+
+ var rows = new StackPanel();
+ foreach (var key in group)
+ rows.Children.Add(BuildRow(key));
+
+ var section = new SettingsSection { Content = rows };
+ _sections.Add((section, group.Key.Section));
+ category.Children.Add(section);
+ }
+
+ UpdateTexts();
+ }
+
+ private SettingRow BuildRow(SimulatorKey key)
+ {
+ Control input = key.Kind switch
+ {
+ SimulatorKeyKind.Toggle => new CheckBox(),
+ SimulatorKeyKind.Number => new Slider
+ {
+ Minimum = key.Minimum,
+ Maximum = key.Maximum,
+ TickFrequency = key.Step,
+ IsSnapToTickEnabled = true
+ },
+ _ => new TextBox { MinWidth = 200 }
+ };
+
+ // Marks the input as one of these rows, which tell about their own changes.
+ input.Tag = key;
+
+ var setting = new SettingRow { ConfigKey = key.Key, Content = input };
+ var row = new Row(key, setting, input);
+ _rows.Add(row);
+
+ switch (input)
+ {
+ case CheckBox box:
+ box.IsCheckedChanged += (_, _) => OnEdited(row);
+ break;
+ case Slider slider:
+ slider.ValueChanged += (_, _) =>
+ {
+ UpdateValueText(row);
+ OnEdited(row);
+ };
+ break;
+ case TextBox text:
+ text.TextChanged += (_, _) => OnEdited(row);
+ break;
+ }
+
+ return setting;
+ }
+
+ ///
+ /// Only a value other than the one shown counts: a text box reports the text it
+ /// was given after the fact, and a slider reports its own clamping.
+ ///
+ private void OnEdited(Row row)
+ {
+ Moved?.Invoke(row.Key);
+ if (Current(row) != row.Shown)
+ Changed?.Invoke();
+ }
+
+ /// The row of
+ public SettingRow? RowOf(string key) => Find(key)?.Setting;
+
+ private Row? Find(string key) =>
+ _rows.FirstOrDefault(row => string.Equals(row.Key.Key, key, StringComparison.OrdinalIgnoreCase));
+
+ ///
+ /// The number a row holds once it says something: moved by the user, or read
+ /// from a file that has the key. Null while it only shows the default, which
+ /// the simulator may not share.
+ ///
+ public double? NumberIfSet(string key, SimulatorSettings settings)
+ {
+ var row = Find(key);
+ if (row is null || row.Input is not Slider slider)
+ return null;
+ if (Current(row) == row.Shown && !settings.Extra.ContainsKey(row.Key.Key))
+ return null;
+ return slider.Value;
+ }
+
+ /// Labels in the current language; called again when it changes.
+ public void UpdateTexts()
+ {
+ foreach (var (section, headerKey) in _sections)
+ section.Header = App.Loc[headerKey];
+
+ foreach (var row in _rows)
+ {
+ string label = App.Loc[row.Key.LabelKey];
+ row.Setting.Description = App.Loc[row.Key.DescriptionKey];
+
+ switch (row.Input)
+ {
+ case CheckBox box:
+ box.Content = label;
+ break;
+ case TextBox text:
+ row.Setting.Label = label;
+ text.PlaceholderText = App.Loc["IniDefault"];
+ break;
+ default:
+ row.Setting.Label = label;
+ UpdateValueText(row);
+ break;
+ }
+ }
+ }
+
+ public void Apply(SimulatorSettings settings)
+ {
+ foreach (var row in _rows)
+ {
+ Put(row, row.Key.RawIn(settings));
+ row.Shown = Current(row);
+ }
+ }
+
+ ///
+ /// Puts
+ public void Show(string key, string raw)
+ {
+ if (Find(key) is { } row)
+ Put(row, raw);
+ }
+
+ /// Puts the simulator's own value in the row of
+ public void ShowDefault(string key)
+ {
+ if (Find(key) is { } row)
+ Put(row, row.Key.Default);
+ }
+
+ private static void Put(Row row, string raw)
+ {
+ switch (row.Input)
+ {
+ case CheckBox box:
+ box.IsChecked = SimulatorKey.ParseToggle(raw);
+ break;
+ case Slider slider:
+ slider.Value = Math.Clamp(row.Key.ParseNumber(raw), row.Key.Minimum, row.Key.Maximum);
+ break;
+ case TextBox text:
+ text.Text = raw.Trim();
+ break;
+ }
+ }
+
+ private static string Current(Row row) => row.Input switch
+ {
+ CheckBox box => SimulatorKey.FormatToggle(box.IsChecked == true),
+ Slider slider => row.Key.FormatNumber(slider.Value),
+ TextBox text => (text.Text ?? string.Empty).Trim(),
+ _ => string.Empty
+ };
+
+ private static void UpdateValueText(Row row)
+ {
+ if (row.Input is not Slider slider)
+ return;
+
+ double value = slider.Value;
+ row.Setting.ValueText = value == 0 && row.Key.ZeroIsOff
+ ? App.Loc["RangeDisabled"]
+ : value.ToString(NumberFormat(row.Key.Step), CultureInfo.CurrentCulture) + row.Key.Unit;
+ }
+
+ private static string NumberFormat(double step) =>
+ step >= 1 ? "0" : step >= 0.1 ? "0.0" : step >= 0.01 ? "0.00" : "0.000";
+}
diff --git a/StarterNG/Views/SliderSteps.cs b/StarterNG/Views/SliderSteps.cs
new file mode 100644
index 0000000..2ba90f5
--- /dev/null
+++ b/StarterNG/Views/SliderSteps.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Controls;
+using StarterNG.Domain.Settings;
+
+namespace StarterNG.Views;
+
+///
+/// A slider that moves through a list of values rather than along a range: its
+/// position is an index, so the values sit evenly on the track however far apart
+/// they are - 30 and 144 frames alike. A value the list lacks joins it while
+/// shown, so opening and saving the settings never moves it.
+///
+internal sealed class SliderSteps
+{
+ private readonly Slider _slider;
+ private readonly IReadOnlyList _steps;
+ private IReadOnlyList _shown;
+
+ public SliderSteps(Slider slider, IReadOnlyList steps)
+ {
+ _slider = slider;
+ _steps = steps;
+ _shown = steps;
+ slider.Minimum = 0;
+ slider.TickFrequency = 1;
+ slider.IsSnapToTickEnabled = true;
+ slider.Maximum = steps.Count - 1;
+ }
+
+ public double Value
+ {
+ get => _shown[Math.Clamp((int)Math.Round(_slider.Value), 0, _shown.Count - 1)];
+ set
+ {
+ _shown = Steps.With(_steps, value);
+ _slider.Maximum = _shown.Count - 1;
+ int at = Steps.IndexOf(_shown, value);
+ _slider.Value = at;
+ }
+ }
+}
diff --git a/StarterNG/Views/UartWindow.cs b/StarterNG/Views/UartWindow.cs
deleted file mode 100644
index 69d1904..0000000
--- a/StarterNG/Views/UartWindow.cs
+++ /dev/null
@@ -1,129 +0,0 @@
-using Avalonia.Controls;
-using Avalonia.Controls.Primitives;
-using Avalonia.Layout;
-using Avalonia.Media;
-using StarterNG.Application;
-
-namespace StarterNG.Views;
-
-public sealed class UartWindow : Window
-{
- private readonly CheckBox _enabled = new();
- private readonly TextBox _port = new() { PlaceholderText = "COM3", MinWidth = 170 };
- private readonly TextBox _tune = new() { MinWidth = 170 };
- private readonly CheckBox _debug = new();
- private readonly CheckBox _main = new();
- private readonly CheckBox _scnd = new();
- private readonly CheckBox _train = new();
- private readonly CheckBox _local = new();
- private readonly CheckBox _radioVolume = new();
- private readonly CheckBox _radioChannel = new();
-
- public UartWindow()
- {
- Title = App.Loc["UartSection"];
- Width = 430;
- SizeToContent = SizeToContent.Height;
- CanResize = false;
- WindowStartupLocation = WindowStartupLocation.CenterOwner;
-
- _enabled.Content = App.Loc["UartEnable"];
- _debug.Content = App.Loc["UartDebug"];
- _main.Content = App.Loc["UartMain"];
- _scnd.Content = App.Loc["UartScnd"];
- _train.Content = App.Loc["UartTrain"];
- _local.Content = App.Loc["UartLocal"];
- _radioVolume.Content = App.Loc["UartRadioVolume"];
- _radioChannel.Content = App.Loc["UartRadioChannel"];
-
- Load();
-
- var root = new StackPanel { Margin = new Avalonia.Thickness(16), Spacing = 8 };
- root.Children.Add(_enabled);
- root.Children.Add(Row(App.Loc["UartPort"], _port));
- root.Children.Add(Row(App.Loc["UartTune"], _tune));
- root.Children.Add(new TextBlock
- {
- Text = App.Loc["UartHint"],
- FontSize = 12,
- Opacity = 0.65,
- TextWrapping = TextWrapping.Wrap
- });
- root.Children.Add(_debug);
-
- root.Children.Add(new TextBlock
- {
- Text = App.Loc["UartFeature"],
- FontWeight = FontWeight.Bold,
- Margin = new Avalonia.Thickness(0, 6, 0, 0)
- });
- var top = new UniformGrid { Columns = 2, Margin = new Avalonia.Thickness(0, 0, 0, 2) };
- top.Children.Add(_main);
- top.Children.Add(_scnd);
- top.Children.Add(_train);
- top.Children.Add(_local);
- root.Children.Add(top);
-
- var mid = new UniformGrid { Columns = 2 };
- mid.Children.Add(_radioVolume);
- mid.Children.Add(_radioChannel);
- root.Children.Add(mid);
-
- var save = new Button
- {
- Content = App.Loc["UartSaveClose"],
- MinWidth = 140,
- Margin = new Avalonia.Thickness(0, 10, 0, 0),
- HorizontalAlignment = HorizontalAlignment.Right,
- Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Hand)
- };
- save.Classes.Add("Accent");
- save.Click += (_, _) => { Store(); Close(); };
- root.Children.Add(save);
-
- Content = root;
- }
-
- private static Control Row(string label, Control input)
- {
- var sp = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8 };
- sp.Children.Add(new TextBlock
- {
- Text = label,
- VerticalAlignment = VerticalAlignment.Center,
- MinWidth = 110
- });
- sp.Children.Add(input);
- return sp;
- }
-
- private void Load()
- {
- var s = AppServices.Current.Settings;
- _enabled.IsChecked = s.UartEnabled;
- _port.Text = s.UartPort;
- _tune.Text = s.UartTune;
- _debug.IsChecked = s.UartDebug;
- _main.IsChecked = s.UartMain;
- _scnd.IsChecked = s.UartScnd;
- _train.IsChecked = s.UartTrain;
- _local.IsChecked = s.UartLocal;
- _radioVolume.IsChecked = s.UartRadioVolume;
- _radioChannel.IsChecked = s.UartRadioChannel;
- }
-
- private void Store()
- {
- var s = AppServices.Current.Settings;
- s.UartEnabled = _enabled.IsChecked == true;
- s.UartPort = _port.Text ?? "";
- s.UartTune = _tune.Text ?? "";
- s.UartDebug = _debug.IsChecked == true;
- s.UartMain = _main.IsChecked == true;
- s.UartScnd = _scnd.IsChecked == true;
- s.UartTrain = _train.IsChecked == true;
- s.UartLocal = _local.IsChecked == true;
- s.UartRadioVolume = _radioVolume.IsChecked == true;
- s.UartRadioChannel = _radioChannel.IsChecked == true;
- }
-}