Add generic DropdownMenuState and RenderDropdownMenu to PixelWidgetBase

New DropdownMenuState with Open/Close/HandleKeyDown, anchor geometry,
OnSelect/OnCustom callbacks, and customizable custom entry label.
RenderDropdownMenu on PixelWidgetBase renders the overlay with full-screen
backdrop dismiss, item highlighting, and keyboard navigation.
Also fix RGBAColor32.Lerp to use Math.Round instead of truncation.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: sebgod

src/DIR.Lib/DIR.Lib.csproj

@@ -8,7 +8,7 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <IsAotCompatible>true</IsAotCompatible>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-    <VersionPrefix>1.3.68</VersionPrefix>
+    <VersionPrefix>1.3.70</VersionPrefix>
     <AssemblyVersion>1.0.0.0</AssemblyVersion>
     <PackageID>DIR.Lib</PackageID>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>

src/DIR.Lib/DropdownMenuState.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+
+namespace DIR.Lib
+{
+    /// <summary>
+    /// State for a generic dropdown menu overlay. Open it with <see cref="Open"/>,
+    /// render with <see cref="PixelWidgetBase{TSurface}.RenderDropdownMenu"/>,
+    /// and handle keyboard with <see cref="HandleKeyDown"/>.
+    /// </summary>
+    public class DropdownMenuState
+    {
+        public bool IsOpen { get; set; }
+        public IReadOnlyList<string> Items { get; set; } = [];
+        public int HighlightIndex { get; set; } = -1;
+
+        // Anchor geometry — set by the trigger during normal layout
+        public float AnchorX { get; set; }
+        public float AnchorY { get; set; }
+        public float AnchorWidth { get; set; }
+
+        /// <summary>Callback when an item is selected (receives index and item text).</summary>
+        public Action<int, string>? OnSelect { get; set; }
+
+        /// <summary>Whether to include a "Custom..." entry at the end of the list.</summary>
+        public bool HasCustomEntry { get; set; }
+
+        /// <summary>Label for the custom entry (defaults to "Custom...").</summary>
+        public string CustomEntryLabel { get; set; } = "Custom...";
+
+        /// <summary>Callback when the custom entry is selected.</summary>
+        public Action? OnCustom { get; set; }
+
+        /// <summary>
+        /// Opens the dropdown anchored below the trigger at the given position.
+        /// </summary>
+        public void Open(float x, float y, float width,
+                         IReadOnlyList<string> items,
+                         Action<int, string> onSelect,
+                         bool hasCustomEntry = false,
+                         Action? onCustom = null,
+                         string? customEntryLabel = null)
+        {
+            IsOpen = true;
+            AnchorX = x;
+            AnchorY = y;
+            AnchorWidth = width;
+            Items = items;
+            OnSelect = onSelect;
+            HasCustomEntry = hasCustomEntry;
+            CustomEntryLabel = customEntryLabel ?? "Custom...";
+            OnCustom = onCustom;
+            HighlightIndex = -1;
+        }
+
+        /// <summary>
+        /// Closes the dropdown.
+        /// </summary>
+        public void Close()
+        {
+            IsOpen = false;
+            HighlightIndex = -1;
+        }
+
+        /// <summary>
+        /// Handles arrow keys, Enter, and Escape. Returns true if consumed.
+        /// </summary>
+        public bool HandleKeyDown(InputKey key)
+        {
+            if (!IsOpen)
+            {
+                return false;
+            }
+
+            var totalItems = Items.Count + (HasCustomEntry ? 1 : 0);
+
+            switch (key)
+            {
+                case InputKey.Down:
+                    HighlightIndex = Math.Min(HighlightIndex + 1, totalItems - 1);
+                    return true;
+
+                case InputKey.Up:
+                    HighlightIndex = Math.Max(HighlightIndex - 1, 0);
+                    return true;
+
+                case InputKey.Enter:
+                    if (HighlightIndex >= 0 && HighlightIndex < Items.Count)
+                    {
+                        OnSelect?.Invoke(HighlightIndex, Items[HighlightIndex]);
+                        Close();
+                    }
+                    else if (HasCustomEntry && HighlightIndex == Items.Count)
+                    {
+                        OnCustom?.Invoke();
+                        Close();
+                    }
+                    return true;
+
+                case InputKey.Escape:
+                    Close();
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+    }
+}

src/DIR.Lib/InputKey.cs

@@ -52,3 +52,30 @@ public enum InputModifier
     Ctrl  = 2,
     Alt   = 4,
 }
+
+/// <summary>
+/// Extension methods for mapping <see cref="InputKey"/> to <see cref="TextInputKey"/>.
+/// </summary>
+public static class InputKeyExtensions
+{
+    extension(InputKey key)
+    {
+        /// <summary>
+        /// Maps an <see cref="InputKey"/> and <see cref="InputModifier"/> to a <see cref="TextInputKey"/>,
+        /// or null if not applicable. Handles Ctrl+A → SelectAll.
+        /// </summary>
+        public TextInputKey? ToTextInputKey(InputModifier modifiers = InputModifier.None) => key switch
+        {
+            InputKey.Backspace => TextInputKey.Backspace,
+            InputKey.Delete => TextInputKey.Delete,
+            InputKey.Left => TextInputKey.Left,
+            InputKey.Right => TextInputKey.Right,
+            InputKey.Home => TextInputKey.Home,
+            InputKey.End => TextInputKey.End,
+            InputKey.Enter => TextInputKey.Enter,
+            InputKey.Escape => TextInputKey.Escape,
+            InputKey.A when (modifiers & InputModifier.Ctrl) != 0 => TextInputKey.SelectAll,
+            _ => null
+        };
+    }
+}

src/DIR.Lib/PixelWidgetBase.cs

@@ -150,6 +150,105 @@ public List<TextInputState> GetRegisteredTextInputs()
         /// </summary>
         public virtual bool HandleMouseWheel(float scrollY, float mouseX, float mouseY) => false;
 
+        // --- Dropdown menu ---
+
+        /// <summary>
+        /// Renders a dropdown menu overlay. <b>Must be called last</b> in the render pass
+        /// so that its clickable regions win hit testing (paint order = z-order).
+        /// Registers a full-screen backdrop that dismisses the dropdown on click-outside.
+        /// </summary>
+        protected void RenderDropdownMenu(
+            DropdownMenuState dropdown,
+            string fontPath,
+            float fontSize,
+            RGBAColor32 bgColor,
+            RGBAColor32 highlightColor,
+            RGBAColor32 textColor,
+            RGBAColor32 borderColor,
+            float viewportWidth,
+            float viewportHeight,
+            float maxHeight = 0f)
+        {
+            if (!dropdown.IsOpen || dropdown.Items.Count == 0)
+            {
+                return;
+            }
+
+            var rowH = fontSize * 1.8f;
+            var padding = fontSize * 0.5f;
+            var totalItems = dropdown.Items.Count + (dropdown.HasCustomEntry ? 1 : 0);
+            var dropdownH = totalItems * rowH;
+            if (maxHeight > 0f && dropdownH > maxHeight)
+            {
+                dropdownH = maxHeight;
+            }
+
+            var x = dropdown.AnchorX;
+            var y = dropdown.AnchorY;
+            var w = dropdown.AnchorWidth;
+
+            // Full-screen backdrop — closes dropdown on click-outside
+            RegisterClickable(0, 0, viewportWidth, viewportHeight, new HitResult.ButtonHit("DropdownBackdrop"),
+                () => dropdown.Close());
+
+            // Border
+            FillRect(x - 1f, y - 1f, w + 2f, dropdownH + 2f, borderColor);
+            // Background
+            FillRect(x, y, w, dropdownH, bgColor);
+
+            // Items
+            var itemY = y;
+            for (var i = 0; i < dropdown.Items.Count && itemY + rowH <= y + dropdownH; i++)
+            {
+                if (i == dropdown.HighlightIndex)
+                {
+                    FillRect(x, itemY, w, rowH, highlightColor);
+                }
+
+                DrawText(dropdown.Items[i].AsSpan(), fontPath,
+                    x + padding, itemY, w - padding * 2f, rowH,
+                    fontSize, textColor, TextAlign.Near, TextAlign.Center);
+
+                var capturedI = i;
+                var capturedItem = dropdown.Items[i];
+                RegisterClickable(x, itemY, w, rowH, new HitResult.ListItemHit("Dropdown", i),
+                    () =>
+                    {
+                        dropdown.OnSelect?.Invoke(capturedI, capturedItem);
+                        dropdown.Close();
+                    });
+
+                itemY += rowH;
+            }
+
+            // "Custom..." entry
+            if (dropdown.HasCustomEntry && itemY + rowH <= y + dropdownH)
+            {
+                var customIdx = dropdown.Items.Count;
+                if (customIdx == dropdown.HighlightIndex)
+                {
+                    FillRect(x, itemY, w, rowH, highlightColor);
+                }
+
+                // Slightly dimmed, blue-shifted text for the "Custom..." entry
+                var customColor = new RGBAColor32(
+                    (byte)((textColor.Red * 3 + 2) / 4),
+                    (byte)((textColor.Green * 3 + 2) / 4),
+                    (byte)Math.Min(255, textColor.Blue + 40),
+                    textColor.Alpha);
+                DrawText(dropdown.CustomEntryLabel.AsSpan(), fontPath,
+                    x + padding, itemY, w - padding * 2f, rowH,
+                    fontSize, customColor, TextAlign.Near, TextAlign.Center);
+
+                RegisterClickable(x, itemY, w, rowH, new HitResult.ListItemHit("Dropdown", customIdx),
+                    () =>
+                    {
+                        dropdown.OnCustom?.Invoke();
+                        dropdown.Close();
+                    });
+            }
+        }
+
         // --- Drawing helpers ---
 
         protected void FillRect(float x, float y, float w, float h, RGBAColor32 color)

src/DIR.Lib/RGBAColor32.cs

@@ -8,10 +8,10 @@ public readonly record struct RGBAColor32(byte Red, byte Green, byte Blue, byte
     /// Linearly interpolates between two colors by factor t (0..1).
     /// </summary>
     public static RGBAColor32 Lerp(RGBAColor32 a, RGBAColor32 b, float t) => new(
-        (byte)(a.Red + (b.Red - a.Red) * t),
-        (byte)(a.Green + (b.Green - a.Green) * t),
-        (byte)(a.Blue + (b.Blue - a.Blue) * t),
-        (byte)(a.Alpha + (b.Alpha - a.Alpha) * t));
+        (byte)Math.Round(a.Red + (b.Red - a.Red) * t),
+        (byte)Math.Round(a.Green + (b.Green - a.Green) * t),
+        (byte)Math.Round(a.Blue + (b.Blue - a.Blue) * t),
+        (byte)Math.Round(a.Alpha + (b.Alpha - a.Alpha) * t));
 
     /// <summary>
     /// Returns this color with alpha premultiplied by the given mask alpha.