Add back missing right controls in options

Author: valkyrienyanko

Template.OptionsGen/OptionsGen/OptionsGen.csproj

@@ -12,7 +12,7 @@
         <NoWarn>NU5128</NoWarn>
 
         <!-- Package Settings -->
-        <Version>1.0.4</Version>
+        <Version>1.0.5</Version>
         <PackageId>Template.OptionsGen</PackageId>
         <AssemblyName>Template.OptionsGen</AssemblyName>
         <Description>Strongly typed options settings source generator for CSharpGodotTools/Template</Description>

Template/Framework/Libraries/Template.OptionsGen.1.0.4.nupkg

@@ -2,6 +2,7 @@
 using GodotUtils;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using VSyncMode = Godot.DisplayServer.VSyncMode;
 
@@ -27,16 +28,20 @@ public partial class OptionsManager : IDisposable, IOptionsService
     internal event Action<RegisteredDropdownOption> DropdownOptionRegistered = null!;
     internal event Action<RegisteredLineEditOption> LineEditOptionRegistered = null!;
     internal event Action<RegisteredToggleOption> ToggleOptionRegistered = null!;
+    internal event Action<RegisteredRightControl> RightControlRegistered = null!;
 
     // Fields
     private readonly OptionsSettingsStore _settingsStore = new();
     private readonly OptionsHotkeysService _hotkeysService = new();
     private readonly OptionsCustomRegistry _customRegistry;
     private readonly OptionsSettings _settings;
+    private readonly Dictionary<string, int> _rightControlIds = new(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<int, RegisteredRightControl> _rightControls = [];
 
     private ResourceOptions _options;
     private string _currentOptionsTab = OptionsTabs.General;
     private AutoloadsFramework _autoloads = null!;
+    private int _nextRightControlId;
 
     public OptionsManager(AutoloadsFramework autoloads)
     {
@@ -184,9 +189,6 @@ private void SetFloatSetting(string key, float value)
             case OptionsSaveKeys.SfxVolume:
                 SetSFXVolume(value);
                 return;
-            case OptionsSaveKeys.Resolution:
-                SetResolution((int)value);
-                return;
             case OptionsSaveKeys.MaxFps:
                 SetMaxFPS((int)value);
                 return;
@@ -264,11 +266,6 @@ private void SetWindowSize(int width, int height)
             ApplyWindowSize();
     }
 
-    private void SetResolution(int resolution)
-    {
-        WriteOptionInt(OptionsSaveKeys.Resolution, Math.Clamp(resolution, 1, 36));
-    }
-
     private void SetVSyncMode(VSyncMode vsyncMode)
     {
         VSyncMode clamped = CoerceVSyncMode((int)vsyncMode);
@@ -303,6 +300,11 @@ internal IEnumerable<RegisteredToggleOption> GetToggleOptions()
         return _customRegistry.GetToggleOptions();
     }
 
+    internal IEnumerable<RegisteredRightControl> GetRightControls()
+    {
+        return _rightControls.Values.OrderBy(control => control.Id);
+    }
+
     /// <summary>
     /// Registers a custom option class.
     /// </summary>
@@ -333,6 +335,31 @@ public void AddOption(OptionDefinition option)
         }
     }
 
+    public void AddRightControl(OptionRightControlDefinition definition)
+    {
+        ArgumentNullException.ThrowIfNull(definition);
+
+        OptionValidator.ValidateTab(definition.Tab);
+        OptionValidator.ValidateLabel(definition.TargetLabel, "RightControl target");
+        OptionValidator.ValidateLabel(definition.Name, "RightControl name");
+
+        string key = CreateRightControlKey(definition.Tab, definition.TargetLabel, definition.Name);
+        if (!_rightControlIds.TryGetValue(key, out int id))
+        {
+            id = ++_nextRightControlId;
+            _rightControlIds[key] = id;
+        }
+
+        RegisteredRightControl registered = new(id, definition);
+        _rightControls[id] = registered;
+        RightControlRegistered?.Invoke(registered);
+    }
+
+    private static string CreateRightControlKey(string tab, string targetLabel, string name)
+    {
+        return $"{tab.Trim()}::{targetLabel.Trim()}::{name.Trim()}";
+    }
+
     private void ToggleFullscreen()
     {
         if (DisplayServer.WindowGetMode() == DisplayServer.WindowMode.Windowed)

Template/Framework/Libraries/Template.OptionsGen.1.0.5.nupkg

@@ -0,0 +1,51 @@
+using Godot;
+using System;
+
+namespace __TEMPLATE__.Ui;
+
+/// <summary>
+/// Disposable helper that owns a right-side control attached to an existing option row.
+/// </summary>
+internal sealed class RightControlBinding : IDisposable
+{
+    private readonly Control _control;
+    private readonly Control _anchorControl;
+    private readonly Action<Control, Control>? _onDetaching;
+
+    private RightControlBinding(
+        Control control,
+        Control anchorControl,
+        Action<Control, Control>? onDetaching)
+    {
+        _control = control;
+        _anchorControl = anchorControl;
+        _onDetaching = onDetaching;
+    }
+
+    internal static RightControlBinding Create(
+        HBoxContainer controlsContainer,
+        Control anchorControl,
+        RegisteredRightControl rightControl)
+    {
+        OptionRightControlDefinition definition = rightControl.Definition;
+
+        Control control = definition.CreateControl(anchorControl)
+            ?? throw new InvalidOperationException($"Right control '{definition.Name}' returned null.");
+
+        if (!string.IsNullOrWhiteSpace(definition.Name))
+            control.Name = definition.Name;
+
+        controlsContainer.AddChild(control);
+        definition.OnAttached?.Invoke(control, anchorControl);
+
+        return new RightControlBinding(control, anchorControl, definition.OnDetaching);
+    }
+
+    public void Dispose()
+    {
+        _onDetaching?.Invoke(_control, _anchorControl);
+
+        if (GodotObject.IsInstanceValid(_control))
+            _control.QueueFree();
+    }
+}

Template/Framework/Scenes/Options/Core/OptionsManager.cs

@@ -0,0 +1 @@
+uid://c5datfuovvtvp

Template/Framework/Scenes/Options/Custom/Bindings/RightControlBinding.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Godot;
 
 namespace __TEMPLATE__.Ui;
 
@@ -8,6 +9,18 @@ namespace __TEMPLATE__.Ui;
 /// </summary>
 public static class OptionDefinitions
 {
+    public static OptionRightControlDefinition RightControl(
+        string tab,
+        string targetLabel,
+        string name,
+        Func<Control, Control> createControl,
+        Action<Control, Control>? onAttached = null,
+        Action<Control, Control>? onDetaching = null)
+    {
+        ArgumentNullException.ThrowIfNull(createControl);
+        return new OptionRightControlDefinition(tab, targetLabel, name, createControl, onAttached, onDetaching);
+    }
+
     public static SliderOptionDefinition Slider(
         string tab,
         string label,

Template/Framework/Scenes/Options/Custom/Bindings/RightControlBinding.cs.uid

@@ -0,0 +1,40 @@
+using Godot;
+using System;
+
+namespace __TEMPLATE__.Ui;
+
+/// <summary>
+/// Describes a UI control that should be attached to the right side of another option row.
+/// </summary>
+public sealed class OptionRightControlDefinition
+{
+    private readonly string _tab;
+    private readonly string _targetLabel;
+    private readonly string _name;
+    private readonly Func<Control, Control> _createControl;
+    private readonly Action<Control, Control>? _onAttached;
+    private readonly Action<Control, Control>? _onDetaching;
+
+    public OptionRightControlDefinition(
+        string tab,
+        string targetLabel,
+        string name,
+        Func<Control, Control> createControl,
+        Action<Control, Control>? onAttached = null,
+        Action<Control, Control>? onDetaching = null)
+    {
+        _tab = tab;
+        _targetLabel = targetLabel;
+        _name = name;
+        _createControl = createControl;
+        _onAttached = onAttached;
+        _onDetaching = onDetaching;
+    }
+
+    public string Tab => _tab;
+    public string TargetLabel => _targetLabel;
+    public string Name => _name;
+    public Func<Control, Control> CreateControl => _createControl;
+    public Action<Control, Control>? OnAttached => _onAttached;
+    public Action<Control, Control>? OnDetaching => _onDetaching;
+}

Template/Framework/Scenes/Options/Custom/Definitions/OptionDefinitions.cs

@@ -0,0 +1 @@
+uid://bo8t7a03v20p5

Template/Framework/Scenes/Options/Custom/Definitions/OptionRightControlDefinition.cs

@@ -13,11 +13,13 @@ public sealed class OptionsCustom : IDisposable
     private readonly Action<RegisteredDropdownOption> _dropdownHandler;
     private readonly Action<RegisteredLineEditOption> _lineEditHandler;
     private readonly Action<RegisteredToggleOption> _toggleHandler;
+    private readonly Action<RegisteredRightControl> _rightControlHandler;
 
     // Properties
     internal OptionsNav Nav { get; }
     internal OptionsManager OptionsManager { get; }
     internal Dictionary<int, IDisposable> Bindings { get; } = [];
+    internal Dictionary<int, IDisposable> RightControlBindings { get; } = [];
 
     /// <summary>
     /// Constructs the custom options UI manager and subscribes to option registration events.
@@ -32,6 +34,7 @@ public OptionsCustom(OptionsNav nav, OptionsManager optionsManager)
         _dropdownHandler = d => CustomOptionSetup.OnDropdownRegistered(this, d);
         _lineEditHandler = l => CustomOptionSetup.OnLineEditRegistered(this, l);
         _toggleHandler = t => CustomOptionSetup.OnToggleRegistered(this, t);
+        _rightControlHandler = r => CustomOptionSetup.OnRightControlRegistered(this, r);
 
         // Build UI for options that were registered before this screen opened
         CustomOptionSetup.Setup(this);
@@ -41,6 +44,7 @@ public OptionsCustom(OptionsNav nav, OptionsManager optionsManager)
         OptionsManager.DropdownOptionRegistered += _dropdownHandler;
         OptionsManager.LineEditOptionRegistered += _lineEditHandler;
         OptionsManager.ToggleOptionRegistered += _toggleHandler;
+        OptionsManager.RightControlRegistered += _rightControlHandler;
     }
 
     /// <summary>
@@ -52,10 +56,15 @@ public void Dispose()
         OptionsManager.DropdownOptionRegistered -= _dropdownHandler;
         OptionsManager.LineEditOptionRegistered -= _lineEditHandler;
         OptionsManager.ToggleOptionRegistered -= _toggleHandler;
+        OptionsManager.RightControlRegistered -= _rightControlHandler;
 
         foreach (IDisposable binding in Bindings.Values)
             binding.Dispose();
 
+        foreach (IDisposable binding in RightControlBindings.Values)
+            binding.Dispose();
+
         Bindings.Clear();
+        RightControlBindings.Clear();
     }
 }