Skip to content

armgit / nota

Public Imported from GitHub
0

Nota — a free DAW for macOS, Windows and Linux. No subscription, no account — just open it and make music.

29.6 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
//
// Detail · Devices — the Nota Arp editor (MIDI effect kind 0), almanac mockups 1a / 1b.
// Two sizes share every value; the S / L toggle in the shell header flips the card (the
// choice is the device's "View" param, so it persists with the project):
//   • L 700 × 260 — ORDER list | Pattern / Groove window over the Free·Sync + division
//     strip | PLAY (Gate · Swing · Vel Amt sliders, Octaves, Retrig, Transpose, Steps,
//     Hold, Restart).
//   • S 260 × 260 — the window with a Pattern / Groove toggle (the lane picked by clicking
//     its name) over four knobs (Rate · Gate · Oct · Swing). The header keeps the full preset
//     picker (same list, same current preset as L); what S can't edit, presets still set.
// The window (ArpGrid) animates from the engine's telemetry: the head band walks the
// steps, played cells dim to a neutral wash and the sounding one turns accent.

using System;
using System.Collections.Generic;
using System.Linq;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Input;
using Avalonia.Layout;
using Avalonia.Media;
using Nota.Application;
using static Nota.App.ArpGrid;
using Nota.Application.Localization;

namespace Nota.App;

internal sealed class ArpMidiBody : IMidiDeviceBody
{
    internal static readonly string[] RateNames = { "1/1", "1/2", "1/4", "1/8", "1/8T", "1/16", "1/16T", "1/32" };
    internal static readonly double[] RateDivisions = { 4.0, 2.0, 1.0, 0.5, 1.0 / 3.0, 0.25, 1.0 / 6.0, 0.125 };
    // The ORDER list, in musical order → the persisted Order value (new orders were appended).
    internal static readonly (string Name, int Value)[] Orders =
    {
        ("Up", ArpPattern.OrdUp), ("Down", ArpPattern.OrdDown), ("Up · Down", ArpPattern.OrdUpDown),
        ("Down · Up", ArpPattern.OrdDownUp), ("Converge", ArpPattern.OrdConverge), ("Diverge", ArpPattern.OrdDiverge),
        ("Random", ArpPattern.OrdRandom), ("Chord", ArpPattern.OrdChord), ("As played", ArpPattern.OrdAsPlayed),
    };
    private static readonly string[] RetrigNames = { "Off", "Note", "Beat" };
    private const double FreeMsMin = 20, FreeMsMax = 1000, LabelW = 50;

    private static readonly IBrush Ground = NotaPalette.SurfaceCard;   // the card surface: sections sit on it, divided by rules (spec 012)
    private static readonly IBrush Bd = NotaPalette.BorderDefault;
    private static readonly IBrush Rule = NotaPalette.GraphBorder;
    private static readonly IBrush Well = NotaPalette.BgSunken;
    private static readonly IBrush Chip = NotaPalette.GridBeat;
    private static readonly IBrush Brass = NotaPalette.Accent;
    private static readonly IBrush Txt = NotaPalette.TextPrimary;
    private static readonly IBrush Sub = NotaPalette.TextSecondary;
    private static readonly IBrush Cap = NotaPalette.TextTertiary;
    private static readonly IBrush Ink = NotaPalette.TextOnAccent;

    // Per-card editor state that survives rebuilds (tab + Groove lane) — UI only, not persisted.
    private sealed class Ui { public bool Groove; public int Lane; }
    private static readonly Dictionary<(int, int), Ui> UiState = new();
    private static Ui UiFor(int track, int mi) { if (!UiState.TryGetValue((track, mi), out var u)) UiState[(track, mi)] = u = new Ui(); return u; }

    public double Width => 700;
    public bool FullBleed => true;

    private static bool IsMini(IAudioEngine e, int track, int mi) => e.MidiEffectParamCount(track, mi) > PView && e.MidiEffectGetParam(track, mi, PView) >= 0.5f;
    public double WidthFor(IAudioEngine engine, int trackId, int index) => IsMini(engine, trackId, index) ? 260 : 700;

    // ---- small builders -------------------------------------------------------------------
    private static TextBlock Caps(string t, IBrush? c = null, double fs = NotaType.KnobLabel) => new()
    { Text = NotaText.Label(t), FontSize = fs, FontWeight = FontWeight.Medium, Foreground = c ?? Cap, VerticalAlignment = VerticalAlignment.Center };
    private static TextBlock Mono(string t, IBrush c, double fs = 8) => new()
    { Text = t, FontSize = fs, FontFamily = NotaFonts.ValuesFamily, Foreground = c, VerticalAlignment = VerticalAlignment.Center };

    private static string RateLabel(IAudioEngine e, int t, int mi)
        => e.MidiEffectGetParam(t, mi, GSync) > 0.5f ? RateNames[Math.Clamp((int)Math.Round(e.MidiEffectGetParam(t, mi, GRate)), 0, 7)]
                                                       : $"{FreeMs(e.MidiEffectGetParam(t, mi, GFreeRate)):0}\u2009ms";
    private static double FreeMs(double hz) => Math.Clamp(1000.0 / Math.Max(0.1, hz), FreeMsMin, FreeMsMax);
    private static string OrderName(int v) => Orders.FirstOrDefault(o => o.Value == v).Name ?? "Up";

    // ---- header accessory: L = MIDI Learn · tempo · S/L; S = S/L only (the shell keeps the same
    //      preset picker in both sizes — presets belong to the device, not to the card size) ----
    public Control? HeaderAccessory(DeviceCardContext ctx, int index)
    {
        var e = ctx.Engine; int t = ctx.TrackId, mi = index;
        if (e.MidiEffectParamCount(t, mi) <= PView) return null;
        bool mini = IsMini(e, t, mi);
        var row = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, VerticalAlignment = VerticalAlignment.Center };

        if (!mini)
        {
            var bpm = Mono("", Cap);
            ctx.AddDeviceRefresher(() => bpm.Text = $"{e.Bpm:0.0} BPM");
            bpm.Text = $"{e.Bpm:0.0} BPM";
            row.Children.Add(MidiCardHeader.LearnButton(ctx)); row.Children.Add(bpm);
        }

        row.Children.Add(MidiCardHeader.SizeToggle(ctx, mi, PView, () => IsMini(e, t, mi)));
        return row;
    }

    private static T WithDock<T>(T c, Dock d) where T : Control { DockPanel.SetDock(c, d); return c; }

    // ---- body -------------------------------------------------------------------------------
    public Control Build(DeviceCardContext ctx, int index)
    {
        var engine = ctx.Engine; int track = ctx.TrackId, mi = index;
        if (engine.MidiEffectParamCount(track, mi) <= PView) return new TextBlock { Text = "Nota Arp", Margin = new Thickness(8) };
        float G(int p) => engine.MidiEffectGetParam(track, mi, p);
        int GI(int p) => (int)Math.Round(G(p));
        void S(int p, double v) => engine.MidiEffectSetParam(track, mi, p, (float)v);
        float Def(int p) => engine.MidiEffectParamDefault(track, mi, p);
        void Begin(int p) => engine.BeginAutomationWrite(track, AutomationTarget.MidiDeviceParam, mi, p, "");
        void End(int p) => engine.EndAutomationWrite(track, AutomationTarget.MidiDeviceParam, mi, p, "");
        void Learn(Control c, int p, string name) => MidiLearn.Bind(c, MidiTarget.MidiDeviceParam(track, mi, p), name);

        var ui = UiFor(track, mi);
        bool mini = IsMini(engine, track, mi);
        var readouts = new List<Action>();
        void Refresh() { foreach (var r in readouts) r(); }

        var grid = new ArpGrid(engine, track, mi) { Mini = mini, Groove = ui.Groove, LaneIndex = ui.Lane };
        grid.Edited += Refresh;

        // Segmented control bound to a param (value = index + off).
        Border Seg(int p, string[] names, int off = 0, bool fill = true, double padX = 6)
        {
            var seg = DeviceCardKit.Segments(names, () => { int c = GI(p) - off; return c >= 0 && c < names.Length ? c : -1; },
                i => { S(p, i + off); Refresh(); }, out var sync, fill: fill, padX: padX, fontSize: 8);
            readouts.Add(sync);
            Learn(seg, p, engine.MidiEffectParamName(track, mi, p));
            return seg;
        }

        // ---- the window's header readout ----
        string InfoText(bool shortForm)
        {
            if (grid.Groove)
            {
                var lane = Lanes[grid.LaneIndex];
                (int s, double v) = grid.LastEdit ?? (Math.Max(0, grid.Position), lane.ToDisp(G(lane.Base + Math.Max(0, grid.Position))));
                v = Math.Clamp(v, lane.Min, lane.Max);
                return shortForm ? $"{s + 1} · {lane.Fmt(v)}" : Loc.F("device.arp.step", s + 1, lane.Fmt(v));
            }
            int len = Math.Max(1, grid.CurrentSequence().Count);
            if (shortForm) return $"{(grid.Position >= 0 ? grid.Position + 1 : 1)}/{grid.StepCount}";
            if (grid.Chord.Count == 0) return Loc.T("device.arp.preview_play_a_chord");
            return Loc.F("device.arp.notes_oct_cycle_steps", grid.Chord.Count, Math.Clamp(GI(GOctaves), 1, 8), len);
        }

        Control root = mini ? BuildMini() : BuildLarge();
        ctx.AddDeviceRefresher(() => { grid.Poll(); Refresh(); });
        Refresh();
        return root;

        // =======================================================================================
        Control BuildLarge()
        {
            // ---- ORDER ----
            var list = new StackPanel { Margin = new Thickness(0, 3) };
            foreach (var (name, value) in Orders)
            {
                int v = value;
                var bar = new Border { Width = 2, Margin = new Thickness(0, 3), HorizontalAlignment = HorizontalAlignment.Left };
                var tb = new TextBlock { Text = name, FontSize = 9, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(8, 0, 0, 0) };
                var rowB = new Border { Height = 18, Cursor = new Cursor(StandardCursorType.Hand), Child = new Panel { Children = { bar, tb } } };
                bool hover = false;
                void Paint()
                {
                    bool on = GI(GOrder) == v;
                    rowB.Background = on ? NotaPalette.AccentSubtle : hover ? NotaPalette.SurfaceRaised : Brushes.Transparent;
                    bar.Background = on ? Brass : Brushes.Transparent;
                    tb.Foreground = on ? Txt : Sub; tb.FontWeight = on ? FontWeight.SemiBold : FontWeight.Normal;
                }
                rowB.PointerEntered += (_, _) => { hover = true; Paint(); };
                rowB.PointerExited += (_, _) => { hover = false; Paint(); };
                rowB.PointerPressed += (_, ev) => { if (!ev.GetCurrentPoint(rowB).Properties.IsLeftButtonPressed) return; S(GOrder, v); Refresh(); ev.Handled = true; };
                Learn(rowB, GOrder, "Order");
                readouts.Add(Paint);
                list.Children.Add(rowB);
            }
            var orderIsland = IslandBox(IslandHead(Caps("ORDER"), null), list, 100);

            // ---- center: tabs + window + rate strip ----
            var info = Mono("", Cap, 7); info.Margin = new Thickness(0, 0, 8, 0);
            var tabRow = new StackPanel { Orientation = Orientation.Horizontal };
            var tabs = new (Border b, TextBlock tb)[2];
            Action layoutFor = () => { };
            string[] tabNames = { "Pattern", "Groove" };
            for (int i = 0; i < 2; i++)
            {
                bool groove = i == 1;
                var tb = new TextBlock { Text = tabNames[i], FontSize = 9, VerticalAlignment = VerticalAlignment.Center };
                var b = new Border { Padding = new Thickness(9, 0), BorderThickness = new Thickness(0, 0, 0, 2), Cursor = new Cursor(StandardCursorType.Hand), Child = tb };
                b.PointerPressed += (_, ev) => { if (!ev.GetCurrentPoint(b).Properties.IsLeftButtonPressed) return; ui.Groove = grid.Groove = groove; layoutFor(); Refresh(); ev.Handled = true; };
                tabs[i] = (b, tb); tabRow.Children.Add(b);
            }
            var tabHead = new Border { Height = 20, BorderBrush = Bd, BorderThickness = new Thickness(0, 0, 0, 1),
                Child = new DockPanel { Children = { WithDock(info, Dock.Right), tabRow } } };

            // Groove lane chips.
            var laneGrid = new Grid { Height = 15, ColumnSpacing = 2, Margin = new Thickness(0, 0, 0, 4) };
            var laneChips = new (Border b, TextBlock tb)[Lanes.Length];
            for (int i = 0; i < Lanes.Length; i++)
            {
                int li = i;
                laneGrid.ColumnDefinitions.Add(new ColumnDefinition(1, GridUnitType.Star));
                var tb = new TextBlock { Text = Lanes[i].Label, FontSize = 8, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center };
                var b = new Border { CornerRadius = NotaRadius.Field, Cursor = new Cursor(StandardCursorType.Hand), Child = tb };
                b.PointerPressed += (_, ev) => { if (!ev.GetCurrentPoint(b).Properties.IsLeftButtonPressed) return; ui.Lane = grid.LaneIndex = li; Refresh(); ev.Handled = true; };
                Grid.SetColumn(b, i); laneGrid.Children.Add(b); laneChips[i] = (b, tb);
            }

            // Rate strip: Free / Sync + divisions, or the free-rate slider.
            var mode = Seg(GSync, new[] { "Free", "Sync" }, fill: false);
            var rateGrid = new Grid { ColumnSpacing = 2, Height = 15, VerticalAlignment = VerticalAlignment.Center };
            var rateChips = new (Border b, TextBlock tb)[RateNames.Length];
            for (int i = 0; i < RateNames.Length; i++)
            {
                int ri = i;
                rateGrid.ColumnDefinitions.Add(new ColumnDefinition(1, GridUnitType.Star));
                var tb = Mono(RateNames[i], Cap); tb.HorizontalAlignment = HorizontalAlignment.Center;
                var b = new Border { CornerRadius = NotaRadius.Field, Cursor = new Cursor(StandardCursorType.Hand), Child = tb };
                b.PointerPressed += (_, ev) => { if (!ev.GetCurrentPoint(b).Properties.IsLeftButtonPressed) return; S(GRate, ri); Refresh(); ev.Handled = true; };
                Learn(b, GRate, "Rate");
                Grid.SetColumn(b, i); rateGrid.Children.Add(b); rateChips[i] = (b, tb);
            }
            var freeTrack = new SliderTrack { Margin = new Thickness(3, 0), Reset = () => { S(GFreeRate, Def(GFreeRate)); Refresh(); } };
            freeTrack.Changed += n => { S(GFreeRate, 1000.0 / (FreeMsMin + n * (FreeMsMax - FreeMsMin))); Refresh(); };
            freeTrack.GestureBegin += () => Begin(GFreeRate); freeTrack.GestureEnd += () => End(GFreeRate);
            Learn(freeTrack, GFreeRate, "Free rate");
            var freeVal = Mono("", Txt); freeVal.Width = 40; freeVal.TextAlignment = TextAlignment.Right;
            ValueEntry.Attach(freeVal, () => (FreeMs(G(GFreeRate)) - FreeMsMin) / (FreeMsMax - FreeMsMin),
                n => S(GFreeRate, 1000.0 / (FreeMsMin + n * (FreeMsMax - FreeMsMin))), () => $"{FreeMs(G(GFreeRate)):0}\u2009ms",
                () => Begin(GFreeRate), () => End(GFreeRate), Refresh, control: freeTrack);
            var freeRow = new DockPanel { Children = { WithDock(freeVal, Dock.Right), freeTrack } };
            var rateHost = new Panel { Margin = new Thickness(4, 0, 0, 0), Children = { rateGrid, freeRow } };
            var rateStrip = new DockPanel { Height = 16, Margin = new Thickness(0, 4, 0, 0), Children = { WithDock(mode, Dock.Left), rateHost } };

            var winRow = new DockPanel { Children = { WithDock(laneGrid, Dock.Top), WithDock(rateStrip, Dock.Bottom), grid } };
            var centerIsland = IslandBox(tabHead, new Border { Padding = new Thickness(8, 5), Child = winRow }, double.NaN);

            void LayoutFor()
            {
                laneGrid.IsVisible = grid.Groove;
                for (int i = 0; i < 2; i++)
                {
                    bool on = (i == 1) == grid.Groove;
                    tabs[i].b.Background = on ? Chip : Brushes.Transparent;
                    tabs[i].b.BorderBrush = on ? Brass : Brushes.Transparent;
                    tabs[i].tb.Foreground = on ? NotaPalette.TextPrimary : Cap;
                    tabs[i].tb.FontWeight = on ? FontWeight.SemiBold : FontWeight.Normal;
                }
            }
            layoutFor = LayoutFor;
            LayoutFor();
            readouts.Add(() =>
            {
                info.Text = InfoText(false);
                info.Foreground = grid.Groove ? Txt : Cap;
                for (int i = 0; i < Lanes.Length; i++)
                {
                    bool on = i == grid.LaneIndex;
                    laneChips[i].b.Background = on ? Brass : Chip;
                    laneChips[i].tb.Foreground = on ? Ink : Sub;
                    laneChips[i].tb.FontWeight = on ? FontWeight.SemiBold : FontWeight.Normal;
                }
                bool sync = G(GSync) > 0.5f;
                rateGrid.IsVisible = sync; freeRow.IsVisible = !sync;
                int rate = GI(GRate);
                for (int i = 0; i < RateNames.Length; i++)
                {
                    bool on = i == rate;
                    rateChips[i].b.Background = on ? Brass : Chip;
                    rateChips[i].tb.Foreground = on ? Ink : Cap;
                }
                double ms = FreeMs(G(GFreeRate));
                if (!freeTrack.Dragging) freeTrack.Norm = (ms - FreeMsMin) / (FreeMsMax - FreeMsMin);
                freeVal.Text = $"{ms:0}\u2009ms";
            });

            // ---- PLAY ----
            var play = new Grid { RowDefinitions = new RowDefinitions("Auto,*,Auto,*,Auto,*,Auto,*,Auto,*,Auto,*,Auto,*,Auto") };
            var playRows = new List<Control>
            {
                SliderLine("GATE", GGate, v => v / 2, n => n * 2, v => $"{v * 100:0}\u2009%"),
                SliderLine("SWING", GSwing, v => v, n => n, v => $"{v * 50:0}\u2009%"),
                SliderLine("VEL AMT", PVelAmt, v => v, n => n, v => $"{v * 100:0}\u2009%"),
                Ruled(Line("OCTAVES", Seg(GOctaves, new[] { "1", "2", "3", "4" }, off: 1))),
                Line("RETRIG", Seg(GRetrig, RetrigNames)),
                Stepper("TRANSPOSE", GTranspose, -24, 24, v => v == 0 ? "0\u2009st" : $"{(v > 0 ? "+" : "−")}{Math.Abs(v)}\u2009st"),
                Stepper("STEPS", GLoop, 1, 16, v => v.ToString()),
                Ruled(ButtonsRow()),
            };
            for (int i = 0; i < playRows.Count; i++) { Grid.SetRow(playRows[i], i * 2); play.Children.Add(playRows[i]); }
            var playHead = IslandHead(Caps("PLAY"), Mono(Loc.T("device.arp.midi_out_ch_1"), Cap, 7));
            var playIsland = IslandBox(playHead, new Border { Padding = new Thickness(8, 5), Child = play }, 176);

            var islands = new DockPanel { Background = Ground, Children = { WithDock(orderIsland, Dock.Left), WithDock(playIsland, Dock.Right), centerIsland } };
            islands.Margin = new Thickness(0);
            orderIsland.Margin = new Thickness(0, 0, 5, 0); playIsland.Margin = new Thickness(5, 0, 0, 0);

            return Framed(islands);
        }

        // =======================================================================================
        Control BuildMini()
        {
            var tabs = DeviceCardKit.Segments(new[] { "Pattern", "Groove" }, () => grid.Groove ? 1 : 0,
                i => { ui.Groove = grid.Groove = i == 1; Refresh(); }, out var tabSync, padX: 6, fontSize: 8);
            readouts.Add(tabSync);
            var laneName = new TextBlock { FontSize = 8, Foreground = Txt, VerticalAlignment = VerticalAlignment.Center };
            var laneBtn = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 4, Cursor = new Cursor(StandardCursorType.Hand), Background = Brushes.Transparent,
                Children = { laneName, new Glyph { Kind = GlyphKind.ChevronDown, Width = 6, Height = 6, Foreground = Cap, VerticalAlignment = VerticalAlignment.Center } } };
            ToolTip.SetTip(laneBtn, Loc.T("device.arp.next_groove_lane"));
            laneBtn.PointerPressed += (_, ev) =>
            {
                if (!ev.GetCurrentPoint(laneBtn).Properties.IsLeftButtonPressed) return;
                ui.Lane = grid.LaneIndex = (grid.LaneIndex + 1) % Lanes.Length; Refresh(); ev.Handled = true;
            };
            var info = Mono("", Cap, 7);
            var head = new DockPanel { Height = 14, Margin = new Thickness(0, 0, 0, 4),
                Children = { WithDock(tabs, Dock.Left), WithDock(info, Dock.Right), laneBtn } };
            laneBtn.Margin = new Thickness(6, 0, 0, 0);

            var knobs = new Grid { Height = 53, ColumnDefinitions = new ColumnDefinitions("*,*,*,*"), Margin = new Thickness(0, 3, 0, 0) };
            var cells = new[]
            {
                KnobCell("RATE", GRate,
                    () => G(GSync) > 0.5f ? GI(GRate) / 7.0 : (FreeMs(G(GFreeRate)) - FreeMsMin) / (FreeMsMax - FreeMsMin),
                    n => { if (G(GSync) > 0.5f) S(GRate, Math.Round(n * 7)); else S(GFreeRate, 1000.0 / (FreeMsMin + n * (FreeMsMax - FreeMsMin))); },
                    () => RateLabel(engine, track, mi), () => G(GSync) > 0.5f ? GRate : GFreeRate),
                KnobCell("GATE", GGate, () => G(GGate) / 2, n => S(GGate, n * 2), () => $"{G(GGate) * 100:0}\u2009%"),
                KnobCell("OCT", GOctaves, () => (Math.Clamp(GI(GOctaves), 1, 4) - 1) / 3.0, n => S(GOctaves, Math.Round(n * 3) + 1), () => $"{GI(GOctaves)}"),
                KnobCell("SWING", GSwing, () => G(GSwing), n => S(GSwing, n), () => $"{G(GSwing) * 50:0}\u2009%"),
            };
            for (int i = 0; i < cells.Length; i++) { Grid.SetColumn(cells[i], i); knobs.Children.Add(cells[i]); }

            var inner = new DockPanel { Children = { WithDock(head, Dock.Top), WithDock(knobs, Dock.Bottom), grid } };
            var island = new RuleSection { Padding = new Thickness(6, 5, 6, 0), Child = inner };

            readouts.Add(() =>
            {
                laneBtn.IsVisible = grid.Groove;
                laneName.Text = Lanes[grid.LaneIndex].Label;
                info.Text = InfoText(true);
                info.Foreground = grid.Groove ? Txt : Cap;
            });

            return Framed(new Border { Background = Ground, Child = island });
        }

        // ---- shared pieces ---------------------------------------------------------------------
        Control Framed(Control main) => new Border { Background = Ground, Padding = new Thickness(5), Child = main };

        Control IslandHead(Control left, Control? right)
        {
            var d = new DockPanel { Margin = new Thickness(8, 0) };
            if (right is not null) d.Children.Add(WithDock(right, Dock.Right));
            d.Children.Add(left);
            return new Border { Height = 20, BorderBrush = Bd, BorderThickness = new Thickness(0, 0, 0, 1), Child = d };
        }

        Decorator IslandBox(Control head, Control content, double width)
        {
            var b = DeviceCardKit.Section(new DockPanel { Children = { WithDock(head, Dock.Top), content } });
            if (!double.IsNaN(width)) b.Width = width;
            return b;
        }

        Control Line(string label, Control c)
        {
            var l = Caps(label); l.Width = LabelW;
            return new DockPanel { Children = { WithDock(l, Dock.Left), c } };
        }
        Control Ruled(Control c) => new Border { BorderBrush = Rule, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 4, 0, 0), Child = c };

        // A PLAY slider: label brightens to primary text once moved off its default.
        Control SliderLine(string label, int p, Func<double, double> toNorm, Func<double, double> fromNorm, Func<double, string> fmt)
        {
            var l = Caps(label); l.Width = LabelW;
            var val = Mono("", Txt); val.Width = 30; val.TextAlignment = TextAlignment.Right;
            var track = new SliderTrack { Height = 11, Reset = () => { S(p, Def(p)); Refresh(); } };
            track.Changed += n => { S(p, fromNorm(n)); Refresh(); };
            track.GestureBegin += () => Begin(p); track.GestureEnd += () => End(p);
            Learn(track, p, label);
            ValueEntry.Attach(val, () => toNorm(G(p)), n => S(p, fromNorm(n)), () => fmt(G(p)), () => Begin(p), () => End(p), Refresh, control: track);
            readouts.Add(() =>
            {
                double v = G(p);
                if (!track.Dragging) track.Norm = toNorm(v);
                bool mod = Math.Abs(v - Def(p)) > 0.005;
                l.Foreground = mod ? Txt : Cap;
                val.Foreground = Txt;
                val.Text = fmt(v);
            });
            track.Margin = new Thickness(0, 0, 4, 0);
            return new DockPanel { Children = { WithDock(l, Dock.Left), WithDock(val, Dock.Right), track } };
        }

        Control Stepper(string label, int p, int min, int max, Func<int, string> fmt)
        {
            var l = Caps(label); l.Width = LabelW;
            var val = Mono("", Txt); val.HorizontalAlignment = HorizontalAlignment.Center;
            Border Btn(string glyph, int d)
            {
                var tb = Mono(glyph, NotaPalette.TextMuted, 9); tb.HorizontalAlignment = HorizontalAlignment.Center;
                var b = new Border { Width = 18, Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand), Child = tb };
                b.PointerEntered += (_, _) => tb.Foreground = Txt; b.PointerExited += (_, _) => tb.Foreground = NotaPalette.TextMuted;
                b.PointerPressed += (_, ev) =>
                {
                    if (!ev.GetCurrentPoint(b).Properties.IsLeftButtonPressed) return;
                    S(p, Math.Clamp(GI(p) + d, min, max)); Refresh(); ev.Handled = true;
                };
                return b;
            }
            var box = new Border { Height = 14, Background = Well, BorderBrush = Bd, BorderThickness = new Thickness(1), CornerRadius = NotaRadius.Cell,
                Child = new DockPanel { Children = { WithDock(Btn("−", -1), Dock.Left), WithDock(Btn("+", +1), Dock.Right), val } } };
            box.PointerPressed += (_, ev) => { if ((ev.ClickCount == 2 || (ev.KeyModifiers & KeyModifiers.Alt) != 0)) { S(p, Def(p)); Refresh(); } };
            Learn(box, p, label);
            // ⌥-click types the value, a double-click resets it (specs/035); the field sees both first.
            double N(int v) => max > min ? (v - min) / (double)(max - min) : 0;
            int V(double n) => (int)Math.Round(min + Math.Clamp(n, 0, 1) * (max - min));
            ValueEntry.Attach(box, new ValueField(NotaText.Label(label), () => N(GI(p)), n => fmt(V(n)), n => S(p, V(n)),
                () => Begin(p), () => End(p), N((int)Math.Round(Def(p)))) { After = Refresh }, val);
            readouts.Add(() =>
            {
                int v = GI(p);
                bool mod = Math.Abs(v - Def(p)) > 0.5;
                l.Foreground = mod ? Txt : Cap;
                val.Foreground = Txt;
                val.Text = fmt(v);
            });
            return new DockPanel { Children = { WithDock(l, Dock.Left), box } };
        }

        Control ButtonsRow()
        {
            Border Btn(string text, Action click, out TextBlock tb)
            {
                var t = new TextBlock { Text = text, FontSize = 8, Foreground = Txt, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center };
                var b = new Border { Height = 16, CornerRadius = NotaRadius.Cell, BorderThickness = new Thickness(1), Background = NotaPalette.TrackOff, BorderBrush = NotaPalette.TrackOff, Cursor = new Cursor(StandardCursorType.Hand), Child = t };
                b.PointerPressed += (_, ev) => { if (!ev.GetCurrentPoint(b).Properties.IsLeftButtonPressed) return; click(); ev.Handled = true; };
                tb = t; return b;
            }
            var hold = Btn("Hold", () => { S(GHold, G(GHold) > 0.5f ? 0 : 1); Refresh(); }, out var holdTb);
            ToolTip.SetTip(hold, Loc.T("device.arp.hold_keep_arpeggiating_after_the"));
            Learn(hold, GHold, "Hold");
            readouts.Add(() =>
            {
                bool on = G(GHold) > 0.5f;
                hold.Background = on ? NotaPalette.AccentSubtle : NotaPalette.TrackOff;
                hold.BorderBrush = on ? NotaPalette.BorderBrass : NotaPalette.TrackOff;
                holdTb.Foreground = on ? NotaPalette.AccentHover : Txt;
                holdTb.FontWeight = on ? FontWeight.SemiBold : FontWeight.Normal;
            });
            var restart = Btn("Restart", () => engine.MidiEffectCommand(track, mi, 1), out var rTb);
            restart.PointerEntered += (_, _) => restart.Background = NotaPalette.SurfaceHover;
            restart.PointerExited += (_, _) => restart.Background = NotaPalette.TrackOff;
            ToolTip.SetTip(restart, Loc.T("device.arp.restart_the_pattern_from_step"));
            var g = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 6 };
            Grid.SetColumn(restart, 1); g.Children.Add(hold); g.Children.Add(restart);
            return g;
        }

        // A mini-view knob: 34px gauge, sentence-case label, mono value. `learnParam` names the param the
        // knob drives right now (Rate is the division when synced, the free rate otherwise).
        Control KnobCell(string label, int p, Func<double> norm, Action<double> set, Func<string> text, Func<int>? learnParam = null)
        {
            var knob = new Knob(norm(), 1.0) { Accent = true, Width = 34, Height = 34, HorizontalAlignment = HorizontalAlignment.Center };
            int LP() => learnParam?.Invoke() ?? p;
            knob.ValueChanged += n => { set(n); Refresh(); };
            knob.GestureBegin += () => Begin(LP()); knob.GestureEnd += () => End(LP());
            Learn(knob, p, label);
            var val = Mono("", Sub, 7); val.HorizontalAlignment = HorizontalAlignment.Center;
            ValueEntry.Attach(knob, label, val, text);
            readouts.Add(() => { double n = norm(); if (!knob.Dragging && Math.Abs(knob.Value - n) > 1e-6) knob.Value = n; val.Text = text(); });
            return new StackPanel { HorizontalAlignment = HorizontalAlignment.Center, Cursor = new Cursor(StandardCursorType.SizeNorthSouth),
                Children = { knob, new TextBlock { Text = NotaText.Label(label), FontSize = NotaType.KnobLabel, FontWeight = FontWeight.Medium, Foreground = Cap, HorizontalAlignment = HorizontalAlignment.Center, LineHeight = 9 }, val } };
        }
    }
}