230 lines
8.0 KiB
C#
230 lines
8.0 KiB
C#
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Windows.Data;
|
|
using CommunityToolkit.Mvvm.ComponentModel;
|
|
using CursorLang.Core.Models;
|
|
using CursorLang.Core.Services;
|
|
|
|
namespace CursorLang.Settings.ViewModels;
|
|
|
|
/// <summary>
|
|
/// An option in a list. The caption changes together with the language, while the
|
|
/// object itself lives for as long as the window does: recreating the list items
|
|
/// makes the ComboBox drop the selected value.
|
|
/// </summary>
|
|
public sealed class EnumOption<T> : ObservableObject where T : struct, Enum
|
|
{
|
|
private string _display;
|
|
|
|
public EnumOption(T value, string display)
|
|
{
|
|
Value = value;
|
|
_display = display;
|
|
}
|
|
|
|
public T Value { get; }
|
|
|
|
public string Display
|
|
{
|
|
get => _display;
|
|
set => SetProperty(ref _display, value);
|
|
}
|
|
|
|
// Accessibility tools take the name of the list item from here
|
|
public override string ToString() => Display;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The settings window. The values are edited right in <see cref="AppSettings"/>,
|
|
/// so the popup picks them up at once, without an "Apply" button.
|
|
/// </summary>
|
|
public sealed partial class SettingsViewModel : ObservableObject, IDisposable
|
|
{
|
|
private static readonly Color[] Palette =
|
|
[
|
|
Color.FromArgb(0x20, 0x20, 0x20),
|
|
Color.FromArgb(0x00, 0x00, 0x00),
|
|
Color.FromArgb(0x1E, 0x3A, 0x8A),
|
|
Color.FromArgb(0x0F, 0x76, 0x6E),
|
|
Color.FromArgb(0x7C, 0x2D, 0x12),
|
|
Color.FromArgb(0x86, 0x19, 0x8F),
|
|
Color.FromArgb(0xB9, 0x1C, 0x1C),
|
|
Color.FromArgb(0xF5, 0xF5, 0xF5),
|
|
];
|
|
|
|
private static readonly Color[] ForegroundPalette =
|
|
[
|
|
Color.FromArgb(0xFF, 0xFF, 0xFF),
|
|
Color.FromArgb(0xD4, 0xD4, 0xD4),
|
|
Color.FromArgb(0x00, 0x00, 0x00),
|
|
Color.FromArgb(0xFA, 0xCC, 0x15),
|
|
Color.FromArgb(0x4A, 0xDE, 0x80),
|
|
Color.FromArgb(0x60, 0xA5, 0xFA),
|
|
Color.FromArgb(0xF9, 0x73, 0x16),
|
|
Color.FromArgb(0xF8, 0x71, 0x71),
|
|
];
|
|
|
|
private readonly IStartupService _startup;
|
|
private readonly Version _version;
|
|
|
|
private StartupState _startupState = StartupState.Unavailable;
|
|
|
|
public SettingsViewModel(
|
|
AppSettings settings,
|
|
ILocalizationService localization,
|
|
IStartupService startup,
|
|
Version version)
|
|
{
|
|
Settings = settings;
|
|
Localization = localization;
|
|
_startup = startup;
|
|
_version = version;
|
|
|
|
// The interface language is a setting like any other and is stored in the same place
|
|
Localization.CurrentLanguage = settings.Language;
|
|
Settings.PropertyChanged += OnSettingsChanged;
|
|
Localization.PropertyChanged += OnLocalizationChanged;
|
|
|
|
Themes = CreateOptions<AppTheme>();
|
|
PlacementModes = CreateOptions<PopupPlacementMode>();
|
|
AnchorSides = CreateOptions<AnchorSide>();
|
|
CaretSides = CreateOptions<CaretSide>();
|
|
ScreenPositions = CreateOptions<ScreenPosition>();
|
|
}
|
|
|
|
public AppSettings Settings { get; }
|
|
|
|
public ILocalizationService Localization { get; }
|
|
|
|
/// <summary>
|
|
/// The title of the window, with the version in it.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The version is nowhere else in the interface: a package installed from the
|
|
/// Store is updated by the Store, so the window has nothing to say about
|
|
/// updates — but which version is running is still worth knowing, if only to
|
|
/// name it in a bug report.
|
|
///
|
|
/// Three numbers, not four: the fourth one is the revision the Store keeps
|
|
/// for itself, and it is a zero in every package we build. The numbers are
|
|
/// put together by hand rather than by <c>ToString(3)</c>, which throws on a
|
|
/// version that has fewer of them than asked for.
|
|
/// </remarks>
|
|
public string Title => string.Format(
|
|
Localization["SettingsTitle"],
|
|
$"{_version.Major}.{_version.Minor}.{Math.Max(_version.Build, 0)}");
|
|
|
|
public IReadOnlyList<Color> BackgroundPalette { get; } = Palette;
|
|
|
|
public IReadOnlyList<Color> TextPalette { get; } = ForegroundPalette;
|
|
|
|
public IReadOnlyList<EnumOption<AppTheme>> Themes { get; }
|
|
|
|
public IReadOnlyList<EnumOption<PopupPlacementMode>> PlacementModes { get; }
|
|
|
|
public IReadOnlyList<EnumOption<AnchorSide>> AnchorSides { get; }
|
|
|
|
/// <summary>The sides on offer next to the caret: there the popup only goes beside it.</summary>
|
|
public IReadOnlyList<EnumOption<CaretSide>> CaretSides { get; }
|
|
|
|
public IReadOnlyList<EnumOption<ScreenPosition>> ScreenPositions { get; }
|
|
|
|
/// <summary>Whether to show the startup setting.</summary>
|
|
public bool IsStartupAvailable => _startupState != StartupState.Unavailable;
|
|
|
|
/// <summary>Startup is up to the application rather than to Windows.</summary>
|
|
public bool CanChangeStartup => _startupState is StartupState.Enabled or StartupState.Disabled;
|
|
|
|
/// <summary>It has to be explained why the setting does not give in.</summary>
|
|
public bool IsStartupLocked => IsStartupAvailable && !CanChangeStartup;
|
|
|
|
/// <summary>
|
|
/// Start the application together with Windows.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The value is not stored in the application settings: Windows knows it, and it
|
|
/// may be changed behind our back — in the "Startup apps" section. So the property
|
|
/// answers from the last known state of the task every time.
|
|
/// </remarks>
|
|
public bool RunAtStartup
|
|
{
|
|
get => _startupState is StartupState.Enabled or StartupState.EnabledByPolicy;
|
|
set
|
|
{
|
|
if (value == RunAtStartup)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_ = ApplyStartupAsync(value);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Asks Windows about the state of startup. Called after the window is shown: the
|
|
/// answer has to be waited for, while the settings must open right away.
|
|
/// </summary>
|
|
public async Task InitializeAsync() => UpdateStartupState(await _startup.GetStateAsync());
|
|
|
|
public void Dispose()
|
|
{
|
|
Settings.PropertyChanged -= OnSettingsChanged;
|
|
Localization.PropertyChanged -= OnLocalizationChanged;
|
|
}
|
|
|
|
private async Task ApplyStartupAsync(bool enabled) =>
|
|
UpdateStartupState(await _startup.SetEnabledAsync(enabled));
|
|
|
|
private void UpdateStartupState(StartupState state)
|
|
{
|
|
_startupState = state;
|
|
|
|
// The change is reported even when the state is the same: the checkbox has
|
|
// already been toggled, and only a re-read value can put it back
|
|
OnPropertyChanged(nameof(RunAtStartup));
|
|
OnPropertyChanged(nameof(IsStartupAvailable));
|
|
OnPropertyChanged(nameof(CanChangeStartup));
|
|
OnPropertyChanged(nameof(IsStartupLocked));
|
|
}
|
|
|
|
private void OnSettingsChanged(object? sender, PropertyChangedEventArgs e)
|
|
{
|
|
if (e.PropertyName == nameof(AppSettings.Language))
|
|
{
|
|
Localization.CurrentLanguage = Settings.Language;
|
|
}
|
|
}
|
|
|
|
// The option captions come from the resources, so on a language change we update
|
|
// only the text — the list items themselves stay the same
|
|
private void OnLocalizationChanged(object? sender, PropertyChangedEventArgs e)
|
|
{
|
|
if (e.PropertyName != Binding.IndexerName)
|
|
{
|
|
return;
|
|
}
|
|
|
|
OnPropertyChanged(nameof(Title));
|
|
Translate(Themes);
|
|
Translate(PlacementModes);
|
|
Translate(AnchorSides);
|
|
Translate(CaretSides);
|
|
Translate(ScreenPositions);
|
|
}
|
|
|
|
private EnumOption<T>[] CreateOptions<T>() where T : struct, Enum =>
|
|
[.. Enum.GetValues<T>().Select(value => new EnumOption<T>(value, GetDisplayName(value)))];
|
|
|
|
private void Translate<T>(IReadOnlyList<EnumOption<T>> options) where T : struct, Enum
|
|
{
|
|
foreach (EnumOption<T> option in options)
|
|
{
|
|
option.Display = GetDisplayName(option.Value);
|
|
}
|
|
}
|
|
|
|
// The resource key is built from the type name and the value: PopupPlacementMode_AtCursor
|
|
private string GetDisplayName<T>(T value) where T : struct, Enum =>
|
|
Localization[$"{typeof(T).Name}_{value}"];
|
|
}
|