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.

59.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 Drum Rack body (instrument kind 4), in the 700 × 260 card
// the almanac draws for it. The shared shell draws the header: the kit picker (a factory
// kit replaces the pads), A/B in its context menu, and the pad count.
//
//   Pads 1fr  three views on a tab strip, under a strip with the bank (C1–C4, sixteen
//             notes each), the kit's swing and humanize, and Fold:
//             Pads  — a 4 × 4 grid, pad 1 bottom-left as on hardware. A click plays the
//                     pad and selects it; right-click has rename, choke, chain and remove;
//                     an empty pad offers an instrument; samples dropped on a pad load
//                     there (several fill the pads after it). Fold hides the empty pads.
//             Mixer — the bank's loaded pads as rows: volume, pan, mute · solo · choke.
//             Chain — the selected pad's device chain: its instrument and insert effects.
//             Macro — the kit's eight macros (MacroPanel): a knob each, the name, and where
//                     it goes; a kit loads with its own (KitMacros), mapped onto the pads'
//                     controls and their effects.
//   Pad 186   the selected pad: its one-shot, volume · pan · tune · decay, the choke
//             group, and its instrument's editor. In Macro, the selected macro instead: its
//             receivers with their ranges, and Map · Rename · Clear.
//   Status    the selection and the kit, in words.
//
// A pad's colour is its track-palette slot; accent means selection only, and a pad that is
// sounding lights in its own hue.

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

namespace Nota.App;

internal sealed partial class RackCardView
{
    private static int _drumView;          // 0 Pads, 1 Mixer, 2 Chain, 3 Macro
    private static int _drumMacro;         // Macro: the selected macro, 0..7
    private static int _drumBank;          // 0..3 → C1..C4 (notes 36 + bank × 16)
    private static bool _drumFold;         // Pads: hide the empty pads

    private static readonly string[] DrumViews = { "Pads", "Mixer", "Chain", "Macro" };
    private static readonly string[] BankNames = { "C1", "C2", "C3", "C4" };
    private static readonly string[] ChokeNames = { "Off", "1", "2", "3", "4" };
    private const double DrumPadW = 186, DrumTabH = 20, DrumStripH = 22, DrumStatusH = 18, MixRowH = 13;

    private static int BankBase => 36 + _drumBank * 16;
    private static bool InBank(int note) => note >= BankBase && note < BankBase + 16;

    // ---- entry point --------------------------------------------------------

    /// <summary>The Drum Rack card's body, for the shared shell. <paramref name="padCount"/>
    /// is the number of loaded pads, for the header badge.</summary>
    public Control BuildDrumRackBody(out int padCount)
    {
        var a = new InstrumentRackAccess(E, T);
        _irTick.Clear();
        var pads = LoadedPads(a);
        padCount = pads.Count;
        if (!IsPad(a, Sel)) Sel = FirstPad(a, pads);

        var readout = DrumMono("", TextTertiary, NotaType.Axis);
        readout.Margin = new Thickness(0, 0, 8, 0);
        readout.HorizontalAlignment = HorizontalAlignment.Right;
        var macros = new DrumMacroSurface(this, a);
        Control view = _drumView switch
        {
            1 => DrumMixer(a, readout),
            2 => DrumChain(a),
            3 => MacroPanel.Grid(_ctx, macros, _drumMacro, m => { _drumMacro = m; DeferRebuild(); }, _irTick, stacked: true),
            _ => DrumGrid(a),
        };
        if (_drumView == 3)
            readout.Text = Loc.F("device.rack.drum.slots_assigned", MacroPanel.Count, MacroPanel.Assigned(macros));
        else if (_drumView != 1)
        {
            int inBank = pads.Count(c => InBank(a.ChainTriggerNote(c)));
            readout.Text = Loc.F("device.rack.drum.16_loaded", BankNames[_drumBank], inBank);
        }

        var left = new Grid { RowDefinitions = new RowDefinitions("Auto,Auto,*") };
        left.Children.Add(DrumTabs(readout));
        var strip = DrumStrip(a);
        Grid.SetRow(strip, 1); left.Children.Add(strip);
        Grid.SetRow(view, 2); left.Children.Add(view);

        var panel = DrumBox(_drumView == 3 ? MacroPanel.Detail(_ctx, macros, _drumMacro, _irTick) : DrumPadPanel(a));
        panel.Width = DrumPadW;

        var body = new Grid
        {
            ColumnDefinitions = new ColumnDefinitions("*,Auto"), ColumnSpacing = NotaSpace.DeviceGap,
            Margin = new Thickness(NotaSpace.DeviceGap),
        };
        body.Children.Add(DrumBox(left));
        Grid.SetColumn(panel, 1); body.Children.Add(panel);

        var statusHost = DrumStatus(a, pads, macros);
        DockPanel.SetDock(statusHost, Dock.Bottom);
        var root = new DockPanel { LastChildFill = true, Background = NotaPalette.SurfaceCard, Children = { statusHost, body } };

        if (_irTick.Count > 0) _ctx.AddDeviceRefresher(() => { for (int i = 0; i < _irTick.Count; i++) _irTick[i](); });
        return root;
    }

    // ---- tab strip (20): Pads · Mixer · Chain, and what the view shows ----------------

    private Control DrumTabs(TextBlock readout)
    {
        var row = new StackPanel { Orientation = Orientation.Horizontal };
        for (int i = 0; i < DrumViews.Length; i++)
        {
            int iv = i; bool on = i == _drumView;
            var tb = new TextBlock
            {
                Text = DrumViews[i], FontSize = NotaType.DeviceSection, VerticalAlignment = VerticalAlignment.Center,
                Foreground = on ? TextPrimary : TextTertiary, FontWeight = on ? FontWeight.SemiBold : FontWeight.Normal,
            };
            var cell = new Border
            {
                Padding = new Thickness(8, 0), BorderThickness = new Thickness(0, 0, 0, 2),
                BorderBrush = on ? Brass : Brushes.Transparent, Background = on ? NotaPalette.SurfaceRaised : Brushes.Transparent,
                Cursor = new Cursor(StandardCursorType.Hand), Child = tb,
            };
            cell.PointerPressed += (_, e) =>
            {
                if (!e.GetCurrentPoint(cell).Properties.IsLeftButtonPressed) return;
                e.Handled = true;
                if (_drumView != iv) { _drumView = iv; DeferRebuild(); }
            };
            row.Children.Add(cell);
        }
        var g = new Grid { Height = DrumTabH, ColumnDefinitions = new ColumnDefinitions("Auto,*") };
        g.Children.Add(row);
        Grid.SetColumn(readout, 1); g.Children.Add(readout);
        return new Border { BorderBrush = BorderDef, BorderThickness = new Thickness(0, 0, 0, 1), Child = g };
    }

    // ---- strip (22): bank · swing · humanize · fold ------------------------------------

    private Control DrumStrip(IRackAccess a)
    {
        var bank = Segments(BankNames, () => _drumBank, i =>
        {
            if (i == _drumBank) return;
            _drumBank = i;
            // Follow the bank with the selection, so the pad panel shows a pad you can see.
            int first = FirstPadInBank(a);
            if (first >= 0) Sel = first;
            DeferRebuild();
        }, out _, padX: 5);
        ToolTip.SetTip(bank, Loc.T("device.rack.drum.pad_bank_sixteen_notes_from"));

        var swing = SliderRow("SWING", () => E.RackSwing(T), v => E.RackSetSwing(T, (float)v),
            () => NotaNum.Pct(E.RackSwing(T)), out var swingSync, reset: () => E.RackSetSwing(T, 0f), valueWidth: 28);
        ToolTip.SetTip(swing, Loc.T("device.rack.drum.push_the_off_beat_sixteenths"));
        var humanize = SliderRow("HUMANIZE", () => E.RackHumanize(T), v => E.RackSetHumanize(T, (float)v),
            () => NotaNum.Pct(E.RackHumanize(T)), out var humSync, reset: () => E.RackSetHumanize(T, 0f), valueWidth: 28);
        ToolTip.SetTip(humanize, Loc.T("device.rack.drum.nudge_every_hits_timing_at"));
        _irTick.Add(swingSync); _irTick.Add(humSync);

        var fold = DrumButton("Fold", _drumFold, () => { _drumFold = !_drumFold; DeferRebuild(); });
        ToolTip.SetTip(fold, _drumFold ? Loc.T("device.rack.drum.show_every_pad_of_the") : Loc.T("device.rack.drum.hide_the_empty_pads"));
        if (_drumView != 0) fold.AttachedToVisualTree += (_, _) => Inactive.Set(fold, true);   // Fold is a Pads view setting

        var g = new Grid
        {
            Height = DrumStripH, ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*,*,Auto"), ColumnSpacing = 8,
            Margin = new Thickness(7, 0),
        };
        g.Children.Add(DrumCap("BANK"));
        Grid.SetColumn(bank, 1); g.Children.Add(bank);
        // Kit timing shifts the whole track's notes, so a Drum Rack in a chain has none (specs/041).
        if (!Nested)
        {
            Grid.SetColumn(swing, 2); g.Children.Add(swing);
            Grid.SetColumn(humanize, 3); g.Children.Add(humanize);
        }
        Grid.SetColumn(fold, 4); g.Children.Add(fold);
        return new Border { BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(0, 0, 0, 1), Child = g };
    }

    // ==================== Pads view ====================

    private Control DrumGrid(IRackAccess a)
    {
        // Hardware order: the bank's first note bottom-left, rising left → right, bottom → top.
        // Folded, the loaded pads close up in the same order.
        var notes = new List<int>();
        for (int n = BankBase; n < BankBase + 16; n++)
            if (!_drumFold || ChainForNote(a, n) >= 0) notes.Add(n);

        var grid = new Grid
        {
            RowDefinitions = new RowDefinitions("*,*,*,*"), ColumnDefinitions = new ColumnDefinitions("*,*,*,*"),
            RowSpacing = 4, ColumnSpacing = 4, Margin = new Thickness(5),
        };
        for (int k = 0; k < notes.Count; k++)
        {
            var pad = DrumPad(a, notes[k]);
            Grid.SetRow(pad, 3 - k / 4); Grid.SetColumn(pad, k % 4);
            grid.Children.Add(pad);
        }
        if (notes.Count == 0)
        {
            var empty = DrumHint(Loc.F("device.rack.drum.no_pads_in_bank", BankNames[_drumBank]));
            Grid.SetRowSpan(empty, 4); Grid.SetColumnSpan(empty, 4);
            grid.Children.Add(empty);
        }
        return grid;
    }

    private Control DrumPad(IRackAccess a, int note)
    {
        int chain = ChainForNote(a, note);
        bool filled = chain >= 0, selected = filled && chain == Sel;
        int choke = filled ? E.RackChainChoke(T, chain) : 0;
        string name = filled ? PadName(a, chain) : "";

        var nameTb = new TextBlock
        {
            Text = name, FontSize = 8, FontWeight = FontWeight.SemiBold, VerticalAlignment = VerticalAlignment.Center,
            Foreground = selected ? AccentBright : TextPrimary, TextTrimming = TextTrimming.CharacterEllipsis,
        };
        var top = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*"), ColumnSpacing = 4 };
        if (filled) top.Children.Add(new Border { Width = 3, Height = 9, CornerRadius = NotaRadius.Fine, Background = PadHue(chain), VerticalAlignment = VerticalAlignment.Center });
        Grid.SetColumn(nameTb, 1); top.Children.Add(nameTb);

        var noteTb = DrumMono(NoteName(note), selected ? AccentBright : filled ? TextTertiary : TextDisabled, 7);
        var chokeTb = DrumMono(choke > 0 ? $"Ch {choke}" : "", DeviceCardKit.ModInkBright, 7);
        var bottom = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto"), VerticalAlignment = VerticalAlignment.Bottom };
        bottom.Children.Add(noteTb);
        Grid.SetColumn(chokeTb, 1); bottom.Children.Add(chokeTb);

        var cell = new Grid { RowDefinitions = new RowDefinitions("Auto,*,Auto"), Margin = new Thickness(5, 3) };
        cell.Children.Add(top);
        Grid.SetRow(bottom, 2); cell.Children.Add(bottom);

        IBrush restBg = selected ? NotaPalette.AccentSubtle : filled ? NotaPalette.BgSunken : NotaPalette.SurfaceCard;
        IBrush restBorder = selected ? Brass : NotaPalette.GraphBorder;
        var pad = new Border
        {
            Background = restBg, BorderBrush = restBorder, BorderThickness = new Thickness(1),
            CornerRadius = NotaRadius.Cell, Cursor = new Cursor(StandardCursorType.Hand), ClipToBounds = true, Child = cell,
        };
        ToolTip.SetTip(pad, filled
            ? Loc.F("device.rack.drum.click_to_play_right_click", name, NoteName(note))
            : Loc.F("device.rack.drum.click_to_add_an_instrument", NoteName(note)));

        if (filled)
        {
            // A sounding pad lights in its own hue; accent stays the selection.
            var hot = PadFill(PadHue(chain), 0.22);
            _irTick.Add(() => pad.Background = E.RackChainMeter(T, chain) > 0.02f ? hot : restBg);
            pad.PointerPressed += (_, e) =>
            {
                var pt = e.GetCurrentPoint(pad).Properties;
                if (pt.IsRightButtonPressed) { e.Handled = true; ShowPadMenu(a, pad, chain); return; }
                if (!pt.IsLeftButtonPressed) return;
                e.Handled = true; e.Pointer.Capture(pad); E.TrackNoteOn(T, note, 1.0f);   // this rack only, not the armed tracks (#307)
            };
            pad.PointerReleased += (_, e) =>
            {
                if (e.InitialPressMouseButton != MouseButton.Left) return;
                E.TrackNoteOff(T, note); e.Pointer.Capture(null); SelectPad(chain);
            };
        }
        else
        {
            pad.PointerEntered += (_, _) => pad.BorderBrush = NotaPalette.BorderStrong;
            pad.PointerExited += (_, _) => pad.BorderBrush = restBorder;
            pad.PointerPressed += (_, e) =>
            {
                if (!e.GetCurrentPoint(pad).Properties.IsLeftButtonPressed) return;
                e.Handled = true; ShowAddPadMenu(a, pad, note);
            };
        }

        DragDrop.SetAllowDrop(pad, true);
        DragDrop.AddDragOverHandler(pad, (_, e) =>
        {
            if (!BrowserView.IsAcceptableDrag(e)) { e.DragEffects = DragDropEffects.None; return; }
            e.DragEffects = DragDropEffects.Copy; e.Handled = true; _ctx.HideDropGlow();
            pad.BorderBrush = AccentBright;   // the drop target: colour only, never a thicker edge
        });
        DragDrop.AddDragLeaveHandler(pad, (_, _) => pad.BorderBrush = restBorder);
        DragDrop.AddDropHandler(pad, (_, e) =>
        {
            pad.BorderBrush = restBorder;
            var items = BrowserView.DroppedItems(e);
            if (items.Count == 0) return;
            // Several samples fill this pad and the ones after it, up to the bank's last; the
            // whole drop is one undo step (#236).
            E.BeginUndoGroup();
            try { for (int i = 0; i < items.Count && note + i < BankBase + 16; i++) DropOnPad(a, note + i, items[i]); }
            finally { E.EndUndoGroup(); }
            e.Handled = true;
        });
        return pad;
    }

    // Right-click on a loaded pad: rename, choke group, its chain, remove. The pad is
    // selected too; the card rebuilds once the menu closes.
    private void ShowPadMenu(IRackAccess a, Control anchor, int chain)
    {
        Sel = chain;
        var f = new MenuFlyout();
        f.Items.Add(MenuKit.Header(PadName(a, chain), null, Loc.T("device.rack.drum.pad")));
        f.Items.Add(new Separator());
        var rename = MenuKit.Item(Loc.T("common.rename"), GlyphKind.Edit);
        rename.Click += (_, _) => Avalonia.Threading.Dispatcher.UIThread.Post(() => PromptRenamePad(a, anchor, chain));
        f.Items.Add(rename);

        var chokeMenu = new MenuItem { Header = Loc.T("device.rack.drum.choke_group") };
        int cur = E.RackChainChoke(T, chain);
        for (int g = 0; g < ChokeNames.Length; g++)
        {
            int gv = g;
            var mi = new MenuItem { Header = g == 0 ? Loc.T("device.rack.drum.none_choke_group") : Loc.F("device.rack.drum.group", g), ToggleType = MenuItemToggleType.Radio, IsChecked = g == cur };
            mi.Click += (_, _) => E.RackSetChainChoke(T, chain, gv);
            chokeMenu.Items.Add(mi);
        }
        f.Items.Add(chokeMenu);

        var open = new MenuItem { Header = Loc.T("device.rack.drum.open_chain") };
        open.Click += (_, _) => _drumView = 2;
        f.Items.Add(open);
        f.Items.Add(new Separator());
        f.Items.Add(MenuKit.Danger(Loc.T("device.rack.drum.remove_pad"), GlyphKind.Trash, () => { a.RemoveChain(chain); _ctx.NotifyChanged(); }));

        bool renaming = false;
        rename.Click += (_, _) => renaming = true;
        f.Closed += (_, _) => { if (!renaming) DeferRebuild(); };
        f.ShowAt(anchor, showAtPointer: true);
    }

    private void PromptRenamePad(IRackAccess a, Control anchor, int chain)
    {
        var box = new TextBox { Text = PadName(a, chain), FontSize = 9, Width = 120, Height = 20, Padding = new Thickness(4, 0) };
        var fly = new Flyout { Content = box };
        void Commit()
        {
            string n = (box.Text ?? "").Trim();
            E.RackSetChainName(T, chain, n);   // empty falls back to the instrument's name
            _ctx.NotifyChanged();
        }
        box.KeyDown += (_, e) =>
        {
            if (e.Key == Key.Enter) { Commit(); fly.Hide(); }
            else if (e.Key == Key.Escape) fly.Hide();
        };
        fly.Closed += (_, _) => DeferRebuild();
        fly.ShowAt(anchor);
        box.SelectAll();
        box.Focus();
    }

    // ==================== Mixer view ====================

    private Control DrumMixer(IRackAccess a, TextBlock readout)
    {
        var pads = LoadedPads(a).Where(c => InBank(a.ChainTriggerNote(c))).ToList();
        const string Cols = "86,26,*,26,48";

        var head = new Grid { ColumnDefinitions = new ColumnDefinitions(Cols), ColumnSpacing = 6, Height = MixRowH };
        void H(string t, int col, bool right = false)
        {
            var x = DrumCap(t); if (right) x.HorizontalAlignment = HorizontalAlignment.Right;
            Grid.SetColumn(x, col); head.Children.Add(x);
        }
        H("PAD", 0); H("NOTE", 1); H("VOLUME", 2); H("PAN", 3); H("M S ch", 4, right: true);
        var headBar = new Border { BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(0, 0, 0, 1), Child = head };

        var rows = new StackPanel { Spacing = 1, Margin = new Thickness(0, 2, 0, 0) };
        foreach (int c in pads) rows.Children.Add(DrumMixerRow(a, c, Cols));
        Control list;
        if (pads.Count == 0)
        {
            list = DrumHint(Loc.F("device.rack.drum.no_pads_in_bank_drop", BankNames[_drumBank]));
            readout.Text = Loc.F("device.rack.drum.empty", BankNames[_drumBank]);
        }
        else
        {
            var scroll = new ScrollViewer { Content = rows, VerticalScrollBarVisibility = ScrollBarVisibility.Auto, HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled };
            // The rows in view, e.g. "C1 · 1–12 of 16".
            void Visible()
            {
                double rowH = MixRowH + 1;
                int first = (int)Math.Floor(scroll.Offset.Y / rowH);
                int shown = Math.Max(1, (int)Math.Floor((scroll.Viewport.Height - 2) / rowH));
                int last = Math.Min(pads.Count, first + shown);
                readout.Text = last - first >= pads.Count
                    ? Loc.F("common.pattern_n", BankNames[_drumBank], Loc.Plural("device.rack.drum.pads", pads.Count))
                    : $"{BankNames[_drumBank]} · {first + 1}–{last} of {pads.Count}";
            }
            scroll.ScrollChanged += (_, _) => Visible();
            readout.Text = Loc.F("common.pattern_n", BankNames[_drumBank], Loc.Plural("device.rack.drum.pads", pads.Count));
            list = scroll;
        }
        DockPanel.SetDock(headBar, Dock.Top);
        return new DockPanel { LastChildFill = true, Margin = new Thickness(7, 0, 7, 4), Children = { headBar, list } };
    }

    private Control DrumMixerRow(IRackAccess a, int c, string cols)
    {
        int note = a.ChainTriggerNote(c);
        bool sel = c == Sel;
        var g = new Grid { ColumnDefinitions = new ColumnDefinitions(cols), ColumnSpacing = 6, Height = MixRowH, Background = sel ? NotaPalette.AccentSubtle : Brushes.Transparent };

        var name = new TextBlock
        {
            Text = PadName(a, c), FontSize = 8, FontWeight = sel ? FontWeight.SemiBold : FontWeight.Medium,
            Foreground = sel ? AccentBright : TextPrimary, TextTrimming = TextTrimming.CharacterEllipsis, VerticalAlignment = VerticalAlignment.Center,
        };
        var nameCell = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*"), ColumnSpacing = 4, Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand) };
        nameCell.Children.Add(new Border { Width = 3, Height = 8, CornerRadius = NotaRadius.Fine, Background = PadHue(c), VerticalAlignment = VerticalAlignment.Center });
        Grid.SetColumn(name, 1); nameCell.Children.Add(name);
        nameCell.PointerPressed += (_, e) =>
        {
            if (!e.GetCurrentPoint(nameCell).Properties.IsLeftButtonPressed) return;
            e.Handled = true; SelectPad(c);
        };
        ToolTip.SetTip(nameCell, Loc.T("device.rack.drum.select_the_pad"));
        g.Children.Add(nameCell);

        var noteTb = DrumMono(NoteName(note), sel ? AccentBright : TextTertiary, 7);
        Grid.SetColumn(noteTb, 1); g.Children.Add(noteTb);

        var vol = new SliderTrack { Norm = VolNorm(a.ChainGain(c)), Reset = () => a.SetChainGain(c, 1f) };
        vol.Changed += v => a.SetChainGain(c, NormVol(v));
        _irTick.Add(() => { if (!vol.Dragging) vol.Norm = VolNorm(a.ChainGain(c)); });
        ToolTip.SetTip(vol, Loc.T("device.rack.drum.pad_volume_drag_up_or"));
        ValueEntry.Attach(vol, new ValueField("Pad volume", () => VolNorm(a.ChainGain(c)), n => VolText(NormVol(n)),
            n => { vol.Norm = n; a.SetChainGain(c, NormVol(n)); }, Default: VolNorm(1f)));
        if (!Nested) MidiLearn.Bind(vol, MidiTarget.RackChainGain(T, a.AutomationDeviceIndex, c), "Pad Volume");
        Grid.SetColumn(vol, 2); g.Children.Add(vol);

        var pan = PanDrag(a, c);
        Grid.SetColumn(pan, 3); g.Children.Add(pan);

        int choke = E.RackChainChoke(T, c);
        var mute = MixBtn("M", () => a.ChainMute(c), NotaPalette.Mute, () => a.SetChainMute(c, !a.ChainMute(c)));
        var solo = MixBtn("S", () => a.ChainSolo(c), NotaPalette.Solo, () => a.SetChainSolo(c, !a.ChainSolo(c)));
        var chk = MixBtn(choke > 0 ? choke.ToString() : "·", () => E.RackChainChoke(T, c) > 0, DeviceCardKit.ModInk,
            () => { E.RackSetChainChoke(T, c, (E.RackChainChoke(T, c) + 1) % ChokeNames.Length); DeferRebuild(); }, choke: true);
        ToolTip.SetTip(mute, Loc.T("device.rack.drum.mute_the_pad")); ToolTip.SetTip(solo, Loc.T("device.rack.drum.solo_the_pad")); ToolTip.SetTip(chk, Loc.T("device.rack.drum.choke_group_click_for_the"));
        if (!Nested) MidiLearn.Bind(mute, MidiTarget.RackChainMute(T, a.AutomationDeviceIndex, c), "Pad Mute");
        if (!Nested) MidiLearn.Bind(solo, MidiTarget.RackChainSolo(T, a.AutomationDeviceIndex, c), "Pad Solo");
        var msc = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 2, HorizontalAlignment = HorizontalAlignment.Right, VerticalAlignment = VerticalAlignment.Center, Children = { mute, solo, chk } };
        Grid.SetColumn(msc, 4); g.Children.Add(msc);
        return g;
    }

    // Pan as a mono readout you drag: up is right, as on every value control; double-click centres.
    private Control PanDrag(IRackAccess a, int c)
    {
        var tb = DrumMono(PanText(a.ChainPan(c)), TextSecondary, 7);
        tb.HorizontalAlignment = HorizontalAlignment.Center;
        var host = new Border { Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.SizeNorthSouth), Child = tb };
        ToolTip.SetTip(host, MenuKit.Keys(Loc.T("device.rack.drum.pad_pan_drag_up_or")));
        ValueEntry.Attach(host, new ValueField("Pan", () => (a.ChainPan(c) + 1) / 2, n => PanText((float)(n * 2 - 1)),
            n => a.SetChainPan(c, (float)Math.Clamp(n * 2 - 1, -1, 1)), Default: 0.5) { After = () => tb.Text = PanText(a.ChainPan(c)) }, tb);   // specs/035
        bool drag = false; double lastY = 0;
        host.PointerPressed += (_, e) =>
        {
            if (!e.GetCurrentPoint(host).Properties.IsLeftButtonPressed) return;
            e.Handled = true;
            if ((e.ClickCount == 2 || (e.KeyModifiers & KeyModifiers.Alt) != 0)) { a.SetChainPan(c, 0f); tb.Text = PanText(0f); return; }
            drag = true; lastY = e.GetPosition(host).Y; e.Pointer.Capture(host);
        };
        host.PointerMoved += (_, e) =>
        {
            if (!drag) return;
            double y = e.GetPosition(host).Y, dy = lastY - y; lastY = y;
            bool fine = (e.KeyModifiers & (KeyModifiers.Shift | KeyModifiers.Control | KeyModifiers.Meta)) != 0;
            float v = (float)Math.Clamp(a.ChainPan(c) + dy / (fine ? 700.0 : 70.0), -1, 1);
            a.SetChainPan(c, v); tb.Text = PanText(v);
        };
        host.PointerReleased += (_, e) => { if (drag) { drag = false; e.Pointer.Capture(null); } };
        host.PointerCaptureLost += (_, _) => drag = false;
        _irTick.Add(() => { if (!drag) tb.Text = PanText(a.ChainPan(c)); });
        return host;
    }

    // A mixer switch, 13 × 11: raised when off; when on, filled with its colour (mute, solo)
    // or washed in teal (the choke group, which is a number, not a state).
    private Border MixBtn(string text, Func<bool> on, SolidColorBrush accent, Action toggle, bool choke = false)
    {
        var tb = new TextBlock { Text = text, FontSize = 7, FontWeight = FontWeight.Medium, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center };
        if (choke) tb.FontFamily = NotaFonts.ValuesFamily;
        var b = new Border { Width = 13, Height = 11, CornerRadius = NotaRadius.Field, BorderThickness = new Thickness(1), Cursor = new Cursor(StandardCursorType.Hand), Child = tb };
        void Paint()
        {
            bool v = on();
            if (choke)
            {
                b.Background = v ? NotaPalette.Wash(DeviceCardKit.ModInk, 0x33) : NotaPalette.BgSunken;
                b.BorderBrush = v ? accent : NotaPalette.GraphBorder;
                tb.Foreground = v ? DeviceCardKit.ModInkBright : TextDisabled;
            }
            else
            {
                b.Background = v ? accent : NotaPalette.SurfaceRaised;
                b.BorderBrush = v ? accent : BorderDef;
                tb.Foreground = v ? NotaPalette.InkOn(accent) : TextSecondary;
            }
        }
        b.PointerPressed += (_, e) =>
        {
            if (!e.GetCurrentPoint(b).Properties.IsLeftButtonPressed) return;
            e.Handled = true; toggle(); Paint();
        };
        _irTick.Add(Paint);
        Paint();
        return b;
    }

    // ==================== Chain view ====================

    private Control DrumChain(IRackAccess a)
    {
        if (!IsPad(a, Sel)) return DrumHint(Loc.T("device.rack.drum.select_a_pad_to_see"));
        int sc = Sel, note = a.ChainTriggerNote(sc);
        var head = new StackPanel
        {
            Orientation = Orientation.Horizontal, Spacing = 6, Margin = new Thickness(0, 0, 0, 6),
            Children =
            {
                new Border { Width = 6, Height = 6, CornerRadius = NotaRadius.Field, Background = PadHue(sc), VerticalAlignment = VerticalAlignment.Center },
                new TextBlock { Text = PadName(a, sc), FontSize = 9, FontWeight = FontWeight.SemiBold, Foreground = TextPrimary, VerticalAlignment = VerticalAlignment.Center },
                DrumMono(NoteName(note), TextTertiary, 7),
                new TextBlock { Text = Loc.T("device.rack.drum.instrument_then_its_effects_signal"), FontSize = 8, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center },
            },
        };
        var slots = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 5 };
        slots.Children.Add(IrInstrumentSlot(a, sc));
        for (int d = 0; d < a.ChainDeviceCount(sc); d++) slots.Children.Add(IrDeviceSlot(a, sc, d));
        slots.Children.Add(IrAddDeviceSlot(a, sc));
        var row = new ScrollViewer { Content = slots, HorizontalScrollBarVisibility = ScrollBarVisibility.Auto, VerticalScrollBarVisibility = ScrollBarVisibility.Disabled };
        DockPanel.SetDock(head, Dock.Top);
        return new DockPanel { LastChildFill = true, Margin = new Thickness(8, 6), Children = { head, row } };
    }

    // ==================== the selected pad (186) ====================

    private Control DrumPadPanel(IRackAccess a)
    {
        if (!IsPad(a, Sel))
        {
            var g0 = new Grid { RowDefinitions = new RowDefinitions("Auto,*") };
            g0.Children.Add(new Border
            {
                Height = DrumTabH, BorderBrush = BorderDef, BorderThickness = new Thickness(0, 0, 0, 1), Padding = new Thickness(8, 0),
                Child = new TextBlock { Text = "No pad", FontSize = 9, FontWeight = FontWeight.SemiBold, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center },
            });
            var hint = DrumHint(Loc.T("device.rack.drum.drop_a_sample_on_a"));
            Grid.SetRow(hint, 1); g0.Children.Add(hint);
            return g0;
        }
        int c = Sel, note = a.ChainTriggerNote(c);
        var hue = PadHue(c);

        // header (20): dot · name · note · Open chain
        var link = new TextBlock { Text = _drumView == 2 ? Loc.T("device.rack.drum.back_to_pads") : Loc.T("device.rack.drum.open_chain"), FontSize = 7, Foreground = NotaPalette.TextMuted, VerticalAlignment = VerticalAlignment.Center };
        var linkHost = new Border { Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand), Child = link };
        ToolTip.SetTip(linkHost, _drumView == 2 ? Loc.T("device.rack.drum.show_the_pads") : Loc.T("device.rack.drum.show_the_pads_instrument_and"));
        linkHost.PointerEntered += (_, _) => link.Foreground = TextPrimary;
        linkHost.PointerExited += (_, _) => link.Foreground = NotaPalette.TextMuted;
        linkHost.PointerPressed += (_, e) =>
        {
            if (!e.GetCurrentPoint(linkHost).Properties.IsLeftButtonPressed) return;
            e.Handled = true; _drumView = _drumView == 2 ? 0 : 2; DeferRebuild();
        };
        var head = new Grid { Height = DrumTabH, ColumnDefinitions = new ColumnDefinitions("Auto,Auto,Auto,*"), ColumnSpacing = 5, Margin = new Thickness(8, 0) };
        head.Children.Add(new Border { Width = 6, Height = 6, CornerRadius = NotaRadius.Field, Background = hue, VerticalAlignment = VerticalAlignment.Center });
        var nameTb = new TextBlock { Text = PadName(a, c), FontSize = 9, FontWeight = FontWeight.SemiBold, Foreground = TextPrimary, VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis, MaxWidth = 92 };
        Grid.SetColumn(nameTb, 1); head.Children.Add(nameTb);
        var noteTb = DrumMono(NoteName(note), TextTertiary, 7);
        Grid.SetColumn(noteTb, 2); head.Children.Add(noteTb);
        linkHost.HorizontalAlignment = HorizontalAlignment.Right;
        Grid.SetColumn(linkHost, 3); head.Children.Add(linkHost);
        var headBar = new Border { BorderBrush = BorderDef, BorderThickness = new Thickness(0, 0, 0, 1), Child = head };

        // the one-shot (46)
        var wave = new PadWave { Hue = hue, TopInset = 12 };
        var srcTb = new TextBlock { FontSize = 7, FontWeight = FontWeight.SemiBold, Foreground = TextStrongInk, Margin = new Thickness(6, 3), HorizontalAlignment = HorizontalAlignment.Left, VerticalAlignment = VerticalAlignment.Top };
        var durTb = DrumMono("", TextTertiary, 7);
        durTb.Margin = new Thickness(6, 3); durTb.HorizontalAlignment = HorizontalAlignment.Right; durTb.VerticalAlignment = VerticalAlignment.Top;
        var waveBox = new Panel { Height = 46, Children = { wave, srcTb, durTb } };
        srcTb.Text = a.ChainInstrumentName(c);
        if (E.RackChainSamplerInfo(T, c, out var si) && si.SampleId != 0 && E.TryGetSampleInfo(si.SampleId, out var sinfo))
        {
            wave.Peaks = MiniPeaks(E.ReadSample(si.SampleId), Math.Max(1, sinfo.Channels), sinfo.Frames, 96);
            durTb.Text = sinfo.SampleRate > 0 ? NotaNum.Time(sinfo.Frames / sinfo.SampleRate) : "";
            _irTick.Add(() => { float p = E.RackChainSamplerPlayPosition(T, c); wave.Play = p < 0 ? -1 : p; });
        }
        else
        {
            durTb.Text = a.ChainInstrumentKind(c) == 1 ? "empty" : "synth";
            var none = new TextBlock
            {
                Text = a.ChainInstrumentKind(c) == 1 ? Loc.T("device.rack.drum.no_sample_drop_one_on") : Loc.T("device.rack.drum.a_synth_voice_no_sample"),
                FontSize = 7, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(0, 12, 0, 0),
            };
            waveBox.Children.Add(none);
        }

        // volume · pan · tune · decay
        Grid Row(string label, Func<double> get, Action<double> set, Func<string> text, Action reset, bool bipolar = false)
        {
            var r = SliderRow(label, get, set, text, out var sync, reset: reset, bipolar: bipolar, labelWidth: 40, valueWidth: 38);
            _irTick.Add(sync);
            return r;
        }
        var volRow = Row("VOLUME", () => VolNorm(a.ChainGain(c)), v => a.SetChainGain(c, NormVol(v)), () => VolText(a.ChainGain(c)), () => a.SetChainGain(c, 1f));
        if (!Nested) MidiLearn.Bind(volRow, MidiTarget.RackChainGain(T, a.AutomationDeviceIndex, c), "Pad Volume");
        var panRow = Row("PAN", () => (a.ChainPan(c) + 1) / 2, v => a.SetChainPan(c, (float)(v * 2 - 1)), () => PanText(a.ChainPan(c)), () => a.SetChainPan(c, 0f), bipolar: true);
        var tuneRow = Row("TUNE", () => (E.RackChainTune(T, c) + 48) / 96.0, v => E.RackSetChainTune(T, c, (int)Math.Round(v * 96 - 48)),
            () => NotaNum.Unit(E.RackChainTune(T, c), "+0;−0;0", "st"), () => E.RackSetChainTune(T, c, 0), bipolar: true);
        var decayRow = Row("DECAY", () => E.RackChainDecay(T, c), v => E.RackSetChainDecay(T, c, (float)v), () => DecayText(E.RackChainDecay(T, c)), () => E.RackSetChainDecay(T, c, 1f));
        ToolTip.SetTip(tuneRow, Loc.T("device.rack.drum.transpose_the_note_the_pad"));
        ToolTip.SetTip(decayRow, Loc.T("device.rack.drum.shorten_the_pads_tail_hold"));
        var sliders = new StackPanel { Spacing = 6, Children = { volRow, panRow, tuneRow, decayRow } };

        // choke · instrument
        var chokeSeg = Segments(ChokeNames, () => { int g = E.RackChainChoke(T, c); return g < ChokeNames.Length ? g : -1; },
            i => { E.RackSetChainChoke(T, c, i); DeferRebuild(); }, out var chokeSync, padX: 5);
        _irTick.Add(chokeSync);
        ToolTip.SetTip(chokeSeg, Loc.T("device.rack.drum.pads_in_the_same_group"));
        var chokeRow = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*"), ColumnSpacing = 6 };
        chokeRow.Children.Add(DrumCap("Choke"));
        Grid.SetColumn(chokeSeg, 1); chokeRow.Children.Add(chokeSeg);

        Border inst = null!;
        inst = DrumWideButton(InstrumentWord(a, c), () => OpenChainInstrumentGui(a, c, inst));
        ToolTip.SetTip(inst, Loc.T("device.rack.drum.open_the_pads_instrument"));
        var foot = new StackPanel { Spacing = 5, Children = { chokeRow, inst } };
        var footer = new Border { BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 5, 0, 0), VerticalAlignment = VerticalAlignment.Bottom, Child = foot };

        var col = new Grid { RowDefinitions = new RowDefinitions("Auto,Auto,*"), RowSpacing = 6, Margin = new Thickness(8, 6) };
        col.Children.Add(waveBox);
        Grid.SetRow(sliders, 1); col.Children.Add(sliders);
        Grid.SetRow(footer, 2); col.Children.Add(footer);

        DockPanel.SetDock(headBar, Dock.Top);
        return new DockPanel { LastChildFill = true, Children = { headBar, col } };
    }

    // The instrument button's word: what the pad plays, without the maker's prefix.
    private static string InstrumentWord(IRackAccess a, int c)
    {
        string n = a.ChainInstrumentName(c);
        if (string.IsNullOrEmpty(n)) return "Instrument";
        return n.StartsWith("Nota ", StringComparison.Ordinal) ? n[5..] : n;
    }

    // ---- status strip (18) -----------------------------------------------------------

    private Control DrumStatus(IRackAccess a, List<int> pads, IMacroSurface macros)
    {
        var status = new TextBlock { FontSize = 8, Foreground = TextSecondary, VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis };
        var meta = DrumMono("", TextSecondary, 8);
        int groups = pads.Select(c => E.RackChainChoke(T, c)).Where(g => g > 0).Distinct().Count();
        meta.Text = Loc.F("common.pattern_n", Loc.Plural("device.rack.drum.pads", pads.Count), Loc.Plural("device.rack.drum.choke_groups", groups))
            + (E.SampleRate > 0 ? " · " + NotaNum.Unit(E.SampleRate / 1000.0, "0.#", "kHz") : "");

        // A Drum Rack in a chain has no kit timing (specs/041).
        string Timing() => Nested ? "" : Loc.F("device.rack.drum.swing_humanize", NotaNum.Pct(E.RackSwing(T)), NotaNum.Pct(E.RackHumanize(T)));
        string PadWords(int c)
        {
            string src = E.RackChainSamplerInfo(T, c, out var si) && si.SampleId != 0 && E.TryGetSampleInfo(si.SampleId, out var inf) && inf.SampleRate > 0
                ? Loc.F("device.rack.drum.sampler", NotaNum.Time(inf.Frames / inf.SampleRate))
                : InstrumentWord(a, c).ToLowerInvariant();
            int g = E.RackChainChoke(T, c);
            return Loc.F("device.rack.drum.selected_choke", PadName(a, c), NoteName(a.ChainTriggerNote(c)), src, g > 0 ? g.ToString() : Loc.T("device.rack.drum.off"));
        }
        string Summary()
        {
            string bank = Loc.F("device.rack.drum.bank", BankNames[_drumBank]);
            if (_drumView == 3) return MacroPanel.Status(E, macros, _drumMacro);
            if (_drumView == 1)
            {
                var inBank = pads.Where(c => InBank(a.ChainTriggerNote(c))).ToList();
                var chokes = inBank.GroupBy(c => E.RackChainChoke(T, c)).Where(gr => gr.Key > 0).OrderBy(gr => gr.Key)
                    .Select(gr => Loc.F("device.rack.drum.choke_group_n", gr.Key, string.Join(", ", gr.Select(c => PadName(a, c))))).ToList();
                return Loc.F("common.pattern_n", bank, Loc.Plural("device.rack.drum.pads", inBank.Count)) + (chokes.Count > 0 ? " · " + string.Join(" · ", chokes) : Loc.T("device.rack.drum.no_choke_groups"));
            }
            if (!IsPad(a, Sel)) return Loc.F("device.rack.drum.no_pad_selected", bank, Timing());
            if (_drumView == 2)
            {
                int d = a.ChainDeviceCount(Sel);
                return Loc.F("device.rack.drum.pad_volume_pan", PadName(a, Sel), NoteName(a.ChainTriggerNote(Sel)), a.ChainInstrumentName(Sel), Loc.Plural("device.rack.drum.effects", d));
            }
            return $"{bank} · {PadWords(Sel)}{Timing()}";
        }
        status.Text = Summary();
        _irTick.Add(() => status.Text = Summary());

        var g = new Grid { Height = DrumStatusH, ColumnDefinitions = new ColumnDefinitions("*,Auto"), ColumnSpacing = 10 };
        g.Children.Add(status);
        Grid.SetColumn(meta, 1); g.Children.Add(meta);
        return new Border
        {
            Height = DrumStatusH, BorderBrush = BorderDef, BorderThickness = new Thickness(0, 1, 0, 0),
            Background = NotaPalette.SurfaceAbyss, Padding = new Thickness(8, 0), Child = g,
        };
    }

    // ---- pads: lookup, selection, loading ----------------------------------------------

    private static int ChainForNote(IRackAccess a, int note)
    {
        for (int c = 0; c < a.ChainCount(); c++) if (a.ChainTriggerNote(c) == note) return c;
        return -1;
    }

    private static bool IsPad(IRackAccess a, int c) => c >= 0 && c < a.ChainCount() && a.ChainTriggerNote(c) >= 0;

    // Loaded pads, lowest note first.
    private static List<int> LoadedPads(IRackAccess a)
    {
        var list = new List<int>();
        for (int c = 0; c < a.ChainCount(); c++) if (a.ChainTriggerNote(c) >= 0) list.Add(c);
        list.Sort((x, y) => a.ChainTriggerNote(x).CompareTo(a.ChainTriggerNote(y)));
        return list;
    }

    private static int FirstPadInBank(IRackAccess a)
    {
        foreach (int c in LoadedPads(a)) if (InBank(a.ChainTriggerNote(c))) return c;
        return -1;
    }

    private static int FirstPad(IRackAccess a, List<int> pads)
    {
        int inBank = FirstPadInBank(a);
        return inBank >= 0 ? inBank : pads.Count > 0 ? pads[0] : -1;
    }

    // A pad's display name: the chain name if set, else the chain instrument's.
    private string PadName(IRackAccess a, int chain)
    {
        string n = E.RackChainName(T, chain);
        return n.Length > 0 ? n : a.ChainInstrumentName(chain);
    }

    // Select a pad and show it (rebuilds only when the selection changes).
    private void SelectPad(int chain)
    {
        if (chain < 0 || chain == Sel) return;
        Sel = chain;
        DeferRebuild();
    }

    // A browser item dropped on a specific pad: sample → a Sampler on this note; instrument
    // → that instrument on this note. Either replaces what the pad held.
    private void DropOnPad(IRackAccess a, int note, Nota.Presentation.BrowserItem item)
    {
        // Remove + add + note + name is one gesture: one undo step (#236).
        E.BeginUndoGroup();
        try { DropOnPadSteps(a, note, item); }
        finally { E.EndUndoGroup(); }
    }

    private void DropOnPadSteps(IRackAccess a, int note, Nota.Presentation.BrowserItem item)
    {
        int existing = ChainForNote(a, note);
        int added;
        switch (item.Kind)
        {
            case Nota.Presentation.BrowserItemKind.Sample:
                // An occupied pad keeps its chain (#237): level, pan, mute/solo, sends, choke and
                // effects stay, only the sound changes. A Sampler keeps its tune, envelope and
                // filter; another instrument gives way to a fresh Sampler.
                if (existing >= 0 && E.RackSetChainSamplerSample(T, existing, item.Path, note))
                {
                    added = existing;
                    ResetSampleWindow(existing);
                }
                else
                {
                    if (existing >= 0) a.RemoveChain(existing);
                    added = E.RackAddSamplerChain(T, item.Path, note, false);
                    if (added >= 0) E.RackSetChainTriggerNote(T, added, note);
                }
                // Name the pad after the sample — sixteen pads reading "Nota Sampler" say nothing.
                if (added >= 0) E.RackSetChainName(T, added, System.IO.Path.GetFileNameWithoutExtension(item.Path));
                break;
            case Nota.Presentation.BrowserItemKind.BuiltinInstrument:
                // Racks nest one level, and only in an Instrument Rack chain (specs/041).
                if (item.BuiltinKind is 3 or 4) { _ctx.Status(Loc.T("device.rack.drum.a_rack_cant_go_on")); return; }
                if (existing >= 0) a.RemoveChain(existing);
                added = a.AddChain(item.BuiltinKind);
                if (added >= 0) a.SetChainTriggerNote(added, note);
                break;
            case Nota.Presentation.BrowserItemKind.PluginInstrument:
                if (existing >= 0) a.RemoveChain(existing);
                added = E.RackAddPluginInstrumentChain(T, item.CatalogIndex);
                if (added >= 0) E.RackSetChainTriggerNote(T, added, note);
                break;
            default:
                return;   // effects and presets aren't pad content
        }
        if (added >= 0) Sel = added;
        _ctx.NotifyChanged();
        DeferRebuild();
    }

    // Start / end, reverse and the loop window belong to the sample that was on the pad: a new
    // sample starts from their defaults.
    private static readonly string[] SampleWindowParams = { "start", "end", "reverse", "loopstart", "loopend", "loopxfade" };

    private void ResetSampleWindow(int chain)
    {
        int n = E.RackChainInstrumentParamCount(T, chain);
        for (int p = 0; p < n; p++)
            if (Array.IndexOf(SampleWindowParams, E.RackChainInstrumentParamId(T, chain, p)) >= 0)
                E.RackChainInstrumentParamSet(T, chain, p, E.RackChainInstrumentParamDefault(T, chain, p));
    }

    private void ShowAddPadMenu(IRackAccess a, Control anchor, int note)
    {
        var f = new MenuFlyout();
        void Add(string header, int kind)
        {
            var mi = new MenuItem { Header = header };
            mi.Click += (_, _) =>
            {
                E.BeginUndoGroup();   // the chain and its note: one undo step
                int c = a.AddChain(kind);
                if (c >= 0) { a.SetChainTriggerNote(c, note); Sel = c; }
                E.EndUndoGroup();
                _ctx.NotifyChanged();
                DeferRebuild();
            };
            f.Items.Add(mi);
        }
        Add("Nota Sampler", 1);
        f.Items.Add(new Separator());
        Add("Nota Volt", 6);
        Add("Nota Physical", 2);
        Add("Nota Aurora", 5);
        Add("Nota Pendulum", 8);
        Add("Nota Operator", 9);
        Add("Nota Grain", 10);
        Add("Nota Flux", 11);
        Add("Nota Monolith", 13);
        Add("Nota Pentad", 14);
        Add("Nota Consort", 15);
        Add("Nota Keys", 16);
        Add("Nota Mosaic", 17);
        Add("Nota Twin", 18);
        f.ShowAt(anchor, showAtPointer: true);
    }

    // ---- value mapping ---------------------------------------------------------------

    // Pad hues are the track palette slots themselves, so a pad re-tints with the theme.
    private static SolidColorBrush PadHue(int chain) => NotaPalette.TrackBrushes[((chain % 8) + 8) % 8];
    private static IBrush PadFill(SolidColorBrush c, double alpha) => NotaPalette.Wash(c, (byte)(Math.Clamp(alpha, 0, 1) * 255));
    // Volume: −60 … +6 dB over the slider, silence at the bottom.
    private static double VolNorm(float gain) { double db = gain <= 0.001 ? -60 : 20 * Math.Log10(gain); return Math.Clamp((db + 60) / 66.0, 0, 1); }
    private static float NormVol(double v) { double db = -60 + v * 66; return v <= 0 ? 0f : (float)Math.Pow(10, db / 20); }
    private static string VolText(float gain) => NotaNum.Db(gain <= 0.001 ? double.NegativeInfinity : 20 * Math.Log10(gain), signed: true, floor: -59.5);
    private static string PanText(float pan) { int p = (int)Math.Round(pan * 50); return p == 0 ? "C" : (p < 0 ? $"{-p}L" : $"{p}R"); }
    // The engine's pad decay: 20 ms … 2 s, and "hold" (no shaping) at the top.
    private static string DecayText(float d) => d >= 0.999f ? "hold" : NotaNum.Time(0.02 * Math.Pow(100, d));

    private static float[] MiniPeaks(float[] raw, int ch, long frames, int buckets)
    {
        var o = new float[buckets];
        if (frames <= 0 || raw.Length == 0) return o;
        long per = Math.Max(1, frames / buckets);
        for (int b = 0; b < buckets; b++)
        {
            long s = (long)b * per; float mx = 0;
            for (long i = 0; i < per; i++)
            {
                long f = s + i; if (f >= frames || (f + 1) * ch > raw.Length) break;
                float v = 0; for (int cc = 0; cc < ch; cc++) v += Math.Abs(raw[f * ch + cc]);
                v /= ch; if (v > mx) mx = v;
            }
            o[b] = mx;
        }
        float peak = 0; foreach (float v in o) peak = Math.Max(peak, v);
        if (peak > 0) for (int b = 0; b < buckets; b++) o[b] /= peak;
        return o;
    }

    // ---- small builders --------------------------------------------------------------

    private static readonly IBrush TextStrongInk = NotaPalette.TextStrong;

    // A device section: card ground, hairline, radius 6.
    private static Decorator DrumBox(Control child) => DeviceCardKit.Section(child);

    private static TextBlock DrumCap(string t) => new()
    {
        Text = NotaText.Label(t), FontSize = NotaType.KnobLabel, FontWeight = FontWeight.Medium,
        Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center,
    };

    private static TextBlock DrumMono(string t, IBrush ink, double fs) => new()
    {
        Text = t, FontSize = fs, Foreground = ink, FontFamily = NotaFonts.ValuesFamily, VerticalAlignment = VerticalAlignment.Center,
    };

    // An empty state: one Ink 5 line, centred.
    private static TextBlock DrumHint(string t) => new()
    {
        Text = t, FontSize = 8, Foreground = TextTertiary, TextWrapping = TextWrapping.Wrap, TextAlignment = TextAlignment.Center,
        HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(8, 0),
    };

    // A small raised toggle (Fold): accent edge and bright accent text when on.
    private static Border DrumButton(string text, bool on, Action click)
    {
        var tb = new TextBlock { Text = text, FontSize = 7, FontWeight = FontWeight.SemiBold, Foreground = on ? AccentBright : TextStrongInk, VerticalAlignment = VerticalAlignment.Center };
        var b = new Border
        {
            Height = 14, Padding = new Thickness(6, 0), CornerRadius = NotaRadius.Cell, BorderThickness = new Thickness(1),
            Background = on ? NotaPalette.AccentSubtle : NotaPalette.SurfaceRaised, BorderBrush = on ? Brass : BorderDef,
            Cursor = new Cursor(StandardCursorType.Hand), VerticalAlignment = VerticalAlignment.Center, Child = tb,
        };
        b.PointerPressed += (_, e) =>
        {
            if (!e.GetCurrentPoint(b).Properties.IsLeftButtonPressed) return;
            e.Handled = true; click();
        };
        return b;
    }

    // A full-width raised button (the pad's instrument).
    private static Border DrumWideButton(string text, Action click)
    {
        var tb = new TextBlock { Text = text, FontSize = 7, FontWeight = FontWeight.SemiBold, Foreground = TextStrongInk, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis };
        var b = new Border
        {
            Height = 16, CornerRadius = NotaRadius.Cell, BorderThickness = new Thickness(1),
            Background = NotaPalette.SurfaceRaised, BorderBrush = BorderDef, Cursor = new Cursor(StandardCursorType.Hand), Child = tb,
        };
        b.PointerEntered += (_, _) => b.Background = NotaPalette.SurfaceHover;
        b.PointerExited += (_, _) => b.Background = NotaPalette.SurfaceRaised;
        b.PointerPressed += (_, e) =>
        {
            if (!e.GetCurrentPoint(b).Properties.IsLeftButtonPressed) return;
            e.Handled = true; click();
        };
        return b;
    }

    // ---- the kit macros (MacroPanel), over the rack's macros ------------------------------

    // The rack's eight macros ride its plugin params (index = macro). A pad is a slot; its
    // targets are its own controls (volume · pan · tune · decay), its instrument's params and
    // its effects' params.
    private sealed class DrumMacroSurface(RackCardView v, IRackAccess a) : IMacroSurface
    {
        private IAudioEngine E => v.E;
        public int TrackId => v.T;
        public int AutomationDevice => a.AutomationDeviceIndex;
        public int MacroParamIndex(int m) => m;
        public string MacroName(int m) => a.MacroName(m);
        public void SetMacroName(int m, string n) => a.SetMacroName(m, n);
        public string SlotCount(int n) => Loc.Plural("device.rack.drum.pads", n);
        public IReadOnlyList<int> Slots() => LoadedPads(a);
        public string SlotName(int c) => v.PadName(a, c);
        public IBrush SlotHue(int c) => PadHue(c);
        public int MappingCount() => a.MappingCount();
        public bool TryGetMapping(int i, out RackMacroMapping m) => a.TryGetMapping(i, out m);
        public int AddMapping(int m, int c, int d, int p, float lo, float hi) => a.AddMacroMapping(m, c, d, p, lo, hi);
        public bool RemoveMapping(int i) => a.RemoveMapping(i);
        public bool SetMappingRange(int i, float lo, float hi) => a.SetMappingRange(i, lo, hi);

        public (string Param, string Device) TargetLabel(RackMacroMapping m) => m.DeviceIndex switch
        {
            RackMacroMapping.PadControls => (PadParam(m.ParamIndex), ""),
            < 0 => (a.ChainInstrumentParamName(m.Chain, m.ParamIndex), InstrumentWord(a, m.Chain)),
            _ => (a.ChainDeviceParamName(m.Chain, m.DeviceIndex, m.ParamIndex), a.ChainDeviceName(m.Chain, m.DeviceIndex)),
        };
        public (float Min, float Max) TargetRange(RackMacroMapping m) => m.DeviceIndex switch
        {
            // Tune's ±48 st would squeeze a musical range into a sliver: the bar shows ±24.
            RackMacroMapping.PadControls => m.ParamIndex == RackMacroMapping.PadTune ? (-24f, 24f) : PadRange(m.ParamIndex),
            < 0 => (0f, 1f),
            _ => (a.ChainDeviceParamMin(m.Chain, m.DeviceIndex, m.ParamIndex), a.ChainDeviceParamMax(m.Chain, m.DeviceIndex, m.ParamIndex)),
        };
        public float TargetValue(RackMacroMapping m) => m.DeviceIndex switch
        {
            RackMacroMapping.PadControls => m.ParamIndex switch
            {
                RackMacroMapping.PadVolume => a.ChainGain(m.Chain),
                RackMacroMapping.PadPan => a.ChainPan(m.Chain),
                RackMacroMapping.PadTune => E.RackChainTune(TrackId, m.Chain),
                _ => E.RackChainDecay(TrackId, m.Chain),
            },
            < 0 => a.ChainInstrumentParamGet(m.Chain, m.ParamIndex),
            _ => a.ChainDeviceParamGet(m.Chain, m.DeviceIndex, m.ParamIndex),
        };
        public string FormatTarget(RackMacroMapping m, float x)
        {
            if (m.DeviceIndex >= 0) { var (lo, hi) = TargetRange(m); return MacroPanel.FormatDeviceParam(lo, hi, x); }
            if (m.DeviceIndex != RackMacroMapping.PadControls) return $"{Math.Round(x * 100):0}";
            return m.ParamIndex switch
            {
                RackMacroMapping.PadVolume => x <= 0.001f ? "−∞" : (20 * Math.Log10(x)).ToString("+0;−0;0", NotaNum.Culture),
                RackMacroMapping.PadPan => PanText(x),
                RackMacroMapping.PadTune => Math.Round(x).ToString("+0;−0;0", NotaNum.Culture),
                _ => $"{Math.Round(x * 100):0}",
            };
        }
        public string TargetUnit(RackMacroMapping m)
        {
            if (m.DeviceIndex >= 0) { var (lo, hi) = TargetRange(m); return MacroPanel.DeviceParamUnit(lo, hi); }
            if (m.DeviceIndex != RackMacroMapping.PadControls) return "%";
            return m.ParamIndex switch { RackMacroMapping.PadVolume => "dB", RackMacroMapping.PadPan => "", RackMacroMapping.PadTune => "st", _ => "%" };
        }

        private static string PadParam(int p) => p >= 0 && p < RackMacroMapping.PadParamNames.Length ? RackMacroMapping.PadParamNames[p] : "?";
        private static (float, float) PadRange(int p) => p >= 0 && p < 4 ? (RackMacroMapping.PadParamMin[p], RackMacroMapping.PadParamMax[p]) : (0f, 1f);
        // What a new pad-control mapping sweeps: a musical span rather than the whole control.
        private static (float, float) PadDefault(int p) => p switch
        {
            RackMacroMapping.PadVolume => (0f, 1f),
            RackMacroMapping.PadPan => (-1f, 1f),
            RackMacroMapping.PadTune => (-12f, 12f),
            _ => (0f, 1f),
        };

        public void FillMapMenu(MenuFlyout menu, int macro, Action changed)
        {
            var pads = LoadedPads(a);
            if (pads.Count == 0) { menu.Items.Add(new MenuItem { Header = Loc.T("device.rack.drum.no_pads_to_map"), IsEnabled = false }); return; }

            // Every pad at once: its own controls, or the same effect on each pad that has it.
            var all = new MenuItem { Header = Loc.Plural("device.rack.drum.all_pads", pads.Count) };
            for (int p = 0; p < 4; p++)
            {
                int pp = p;
                var (lo, hi) = PadDefault(p);
                var mi = new MenuItem { Header = PadParam(p) };
                mi.Click += (_, _) => { foreach (int c in pads) MacroPanel.Map(this, macro, c, RackMacroMapping.PadControls, pp, lo, hi); changed(); };
                all.Items.Add(mi);
            }
            var kinds = new List<(int Kind, string Name, int Chain, int Dev)>();
            foreach (int c in pads)
                for (int d = 0; d < a.ChainDeviceCount(c); d++)
                {
                    int k = a.ChainDeviceBuiltinKind(c, d);
                    if (k >= 0 && kinds.All(x => x.Kind != k)) kinds.Add((k, a.ChainDeviceName(c, d), c, d));
                }
            if (kinds.Count > 0) all.Items.Add(new Separator());
            foreach (var (kind, dname, c0, d0) in kinds)
            {
                // The pads holding this effect; each maps its first one.
                var holders = pads.Select(c => (c, d: FirstOfKind(c, kind))).Where(x => x.d >= 0).ToList();
                var fx = new MenuItem { Header = Loc.F("device.rack.drum.every", dname, Loc.Plural("device.rack.drum.pads", holders.Count)) };
                for (int p = 0; p < a.ChainDeviceParamCount(c0, d0); p++)
                {
                    int pp = p;
                    var mi = new MenuItem { Header = a.ChainDeviceParamName(c0, d0, p) };
                    mi.Click += (_, _) =>
                    {
                        foreach (var (c, d) in holders)
                            MacroPanel.Map(this, macro, c, d, pp, a.ChainDeviceParamMin(c, d, pp), a.ChainDeviceParamMax(c, d, pp));
                        changed();
                    };
                    fx.Items.Add(mi);
                }
                all.Items.Add(fx);
            }
            menu.Items.Add(all);
            menu.Items.Add(new Separator());

            // One pad: its controls, its instrument, each of its effects.
            foreach (int c in pads)
            {
                var pad = new MenuItem { Header = $"{v.PadName(a, c)}  ·  {NoteName(a.ChainTriggerNote(c))}" };
                var ctl = new MenuItem { Header = Loc.T("device.rack.drum.pad") };
                for (int p = 0; p < 4; p++)
                {
                    var (lo, hi) = PadDefault(p);
                    ctl.Items.Add(MacroPanel.Target(this, PadParam(p), macro, c, RackMacroMapping.PadControls, p, lo, hi, changed,
                        MacroPanel.IsMapped(this, macro, c, RackMacroMapping.PadControls, p)));
                }
                pad.Items.Add(ctl);
                int ipc = a.ChainInstrumentParamCount(c);
                if (ipc > 0)
                {
                    var inst = new MenuItem { Header = InstrumentWord(a, c) };
                    for (int p = 0; p < ipc; p++)
                        inst.Items.Add(MacroPanel.Target(this, a.ChainInstrumentParamName(c, p), macro, c, -1, p, 0f, 1f, changed,
                            MacroPanel.IsMapped(this, macro, c, -1, p)));
                    pad.Items.Add(inst);
                }
                for (int d = 0; d < a.ChainDeviceCount(c); d++)
                {
                    int dpc = a.ChainDeviceParamCount(c, d);
                    if (dpc <= 0) continue;
                    var dev = new MenuItem { Header = a.ChainDeviceName(c, d) };
                    for (int p = 0; p < dpc; p++)
                        dev.Items.Add(MacroPanel.Target(this, a.ChainDeviceParamName(c, d, p), macro, c, d, p,
                            a.ChainDeviceParamMin(c, d, p), a.ChainDeviceParamMax(c, d, p), changed, MacroPanel.IsMapped(this, macro, c, d, p)));
                    pad.Items.Add(dev);
                }
                menu.Items.Add(pad);
            }
        }

        private int FirstOfKind(int c, int kind)
        {
            for (int d = 0; d < a.ChainDeviceCount(c); d++) if (a.ChainDeviceBuiltinKind(c, d) == kind) return d;
            return -1;
        }
    }
}