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.

(feat) Hear notes in the piano roll and play its keys (#181)

Chris Laupama2bec9c9d30f5
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e952963b..5dfd50d1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,6 +23,14 @@ Entry categories: `Added`, `Changed`, `Fixed`, `Removed`.
## [Unreleased]
### Added
+- **Hear notes while you edit them in the piano roll** (nota-daw/nota#46): with the new
+ speaker switch in the clip editor's header on (it is by default), a note sounds on the
+ track's instrument while you place it, click it or drag it, and re-sounds at each new pitch
+ as you drag. The switch is remembered. Nothing is auditioned while a take is recording.
+- **Play the piano roll's keys** (nota-daw/nota#47): click a key on the left of the piano roll
+ to play it on the track's instrument, ⇧-drag down the keys to glide through them, and
+ ⌘-click (Ctrl-click) a key to select every note of that pitch (⇧ adds to the selection).
+ Dragging up or down on the keys still zooms the rows.
- **The sustain pedal on every built-in instrument** (nota-daw/nota#99): with the pedal down,
released keys keep sounding on Synth, Sampler, Volt, Bass, Flux, Grain, Operator,
Wavetable, Physical, Pentad, Consort, Monolith and Pendulum (and on an Instrument Rack's
diff --git a/FEATURES.md b/FEATURES.md
index e57aa835..a57f7be0 100644
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -221,6 +221,10 @@ track count and closes with Escape.
- **Piano Roll**: draw, move, stretch and delete notes on the snap grid; **QUANTIZE** with
its own step (1/32 … 1/2, triplets; independent of the zoom) and strength; a velocity
editor; transposing the selection.
+ - **Note audition** (the speaker switch in the header, on by default): a note sounds while
+ it is placed, clicked or dragged, re-sounding at each new pitch.
+ - **Playable keys**: click a key to hear it, ⇧-drag to glide, ⌘-click to select every note
+ of that pitch; a vertical drag on the keys zooms the rows.
- Drag a note's left edge to move its start (the end stays put); stacked notes keep
separate velocity stems (grab a stem by its cap, ⇧-click to add it to the selection).
- Notes replace the same-pitch notes they land on instead of stacking: moved, stretched,
diff --git a/specs/024-piano-roll-audition/spec.md b/specs/024-piano-roll-audition/spec.md
new file mode 100644
index 00000000..3c74394e
--- /dev/null
+++ b/specs/024-piano-roll-audition/spec.md
@@ -0,0 +1,55 @@
+# Feature Specification: Hear notes in the piano roll
+
+**Feature Branch**: `024-piano-roll-audition`
+
+**Created**: 2026-10-18
+
+**Status**: Implemented
+
+**Input**: User description: "Piano roll: note audition toggle — play notes when placing, selecting, dragging (nota-daw/nota#46) — and make the keys column playable: click a key to hear it, drag across keys for a glissando, modifier-click selects all notes of that pitch (nota-daw/nota#47)."
+
+## Nota Context
+
+**Feature area**: UI (Avalonia) — `PianoRollView`, `ClipEditorView`, `MainWindow.Detail`.
+No engine change: audition goes through the existing `TrackNoteOn` / `TrackNoteOff` ABI (a
+live note addressed to one track, armed or not).
+
+## Clarifications
+
+### Session 2026-10-18
+
+Defaults chosen for the open points:
+
+- Q: Where is the switch, and is it per clip? → A: A speaker chip in the clip editor's header, first in the right-hand group. One app-wide setting (`Settings.PianoRollAudition`), on by default (FL Studio's default); every open editor's chip follows it.
+- Q: How long does an auditioned note sound? → A: While the mouse button is down. A drag to another pitch ends the old note and starts the new one.
+- Q: Which note sounds when a group is dragged? → A: The note under the pointer (the grabbed one), at its own velocity.
+- Q: What about recording? → A: No audition while the engine records: a track's live notes are recorded into its take.
+- Q: The keys column already zooms on a vertical drag (specs/019 FR-004, which said a key drag must not audition). How do both live there? → A: A press plays the key; moving more than 4 px vertically turns the press into the zoom and lets the note go. ⇧ held at the press glides through the keys instead of zooming. This amends 019 FR-004: the press sounds the key until the drag starts.
+- Q: Does the audition switch silence the keys? → A: No. The keys are an instrument; the switch is about notes being edited.
+- Q: Which modifier selects a pitch? → A: ⌘-click (Ctrl-click on Windows / Linux), ⇧ added keeps the existing selection. It plays nothing.
+
+## User Scenarios & Testing
+
+### User Story 1 - Hear notes while editing (P1)
+
+**Acceptance Scenarios**:
+
+1. **Given** audition on, **When** the user double-clicks empty grid, **Then** the new note sounds until the button comes up.
+2. **Given** audition on, **When** the user presses a note and drags it up, **Then** it sounds at its pitch, then at each new pitch, and stops on release.
+3. **Given** audition off, **When** the user presses or drags a note, **Then** nothing sounds.
+4. **Given** the switch was turned off, **When** Nota restarts, **Then** it is still off.
+
+### User Story 2 - Play the keys (P2)
+
+1. **Given** any clip open, **When** the user presses a key, **Then** that pitch sounds on the track's instrument and the key lights until release.
+2. **Given** a press on a key, **When** the user drags vertically, **Then** the rows zoom as before and the note stops.
+3. **Given** ⇧ held, **When** the user drags across keys, **Then** each key sounds in turn.
+4. **Given** notes of C4 in the clip, **When** the user ⌘-clicks the C4 key, **Then** exactly those notes are selected.
+
+## Requirements
+
+- **FR-001**: The roll MUST play at most one audition note at a time and MUST end it on release, capture loss or when the editor is closed.
+- **FR-002**: Audition MUST go to the clip's own track (arrangement clip or Session slot), armed or not.
+- **FR-003**: Audition MUST NOT play while the engine is recording.
+- **FR-004**: The switch MUST persist in Settings and stay in step across open editors.
+- **FR-005**: Settings → Shortcuts MUST list the keys-column gestures.
diff --git a/specs/024-piano-roll-audition/tasks.md b/specs/024-piano-roll-audition/tasks.md
new file mode 100644
index 00000000..aca64d1a
--- /dev/null
+++ b/specs/024-piano-roll-audition/tasks.md
@@ -0,0 +1,10 @@
+# Tasks: Hear notes in the piano roll
+
+**Input**: [spec.md](spec.md)
+
+- [x] T001 `PianoRollView`: `AuditionOn/Off` host hooks, app-wide `AuditionEnabled` + `AuditionToggled`, one-note `Audition/StopAudition`, `SelectPitch`
+- [x] T002 Note grid: audition on double-click placement, note press and pitch change while dragging; stop on release / capture loss / detach
+- [x] T003 Keys column: press plays (forced), >4 px vertical drag becomes the 019 zoom, ⇧-drag glides, ⌘-click selects the pitch; the sounding key lights
+- [x] T004 `ClipEditorView`: speaker chip; `MainWindow`: wire both roll builders to `TrackNoteOn/Off` (skipped while recording), seed + save `Settings.PianoRollAudition`
+- [x] T005 Settings → Shortcuts row, CHANGELOG, FEATURES.md, nota-docs piano-roll page EN + RU
+- [x] T006 Verified in the headless app against the real engine (track meter reads the auditioned note), `scripts/build-linux.sh` green; macOS check on the Mac
diff --git a/src/managed/Nota.App/ClipEditorView.cs b/src/managed/Nota.App/ClipEditorView.cs
index a3db78ae..853073e3 100644
--- a/src/managed/Nota.App/ClipEditorView.cs
+++ b/src/managed/Nota.App/ClipEditorView.cs
@@ -61,13 +61,30 @@ public sealed class ClipEditorView : UserControl
var right = new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 12,
- Children = { FitControl(roll), SnapControl(roll), HeaderDivider(), ScaleControls(), HeaderDivider(), _toolsToggle },
+ Children = { AuditionControl(), FitControl(roll), SnapControl(roll), HeaderDivider(), ScaleControls(), HeaderDivider(), _toolsToggle },
};
var header = Header(roll.TrackBrush, clipName, "MIDI", tabs, null, right);
DockPanel.SetDock(header, Dock.Top);
Content = new DockPanel { Background = NotaPalette.Gutter, Children = { header, grid } };
}
+ // Note audition (#46): the speaker chip. One app-wide setting, so every open editor's
+ // chip follows a flip made in another.
+ private static Control AuditionControl()
+ {
+ var b = new ToggleButton
+ {
+ Content = new Glyph(GlyphKind.Speaker, 14), Padding = new Thickness(8, 0), Classes = { "chip" },
+ IsChecked = PianoRollView.AuditionEnabled,
+ };
+ ToolTip.SetTip(b, "Hear notes as you place, click or drag them");
+ b.Click += (_, _) => PianoRollView.SetAuditionEnabled(b.IsChecked == true);
+ void Sync() => b.IsChecked = PianoRollView.AuditionEnabled;
+ b.AttachedToVisualTree += (_, _) => { Sync(); PianoRollView.AuditionToggled += Sync; };
+ b.DetachedFromVisualTree += (_, _) => PianoRollView.AuditionToggled -= Sync;
+ return b;
+ }
+
// Fit to notes (⇧F): rows zoom so every note of the clip is in view.
private static Control FitControl(PianoRollView roll)
{
diff --git a/src/managed/Nota.App/MainWindow.Detail.cs b/src/managed/Nota.App/MainWindow.Detail.cs
index 2df2f8e3..0eeb09a4 100644
--- a/src/managed/Nota.App/MainWindow.Detail.cs
+++ b/src/managed/Nota.App/MainWindow.Detail.cs
@@ -393,6 +393,15 @@ public partial class MainWindow
ShowDetail(250, honorPersist: true);
}
+ // Piano-roll audition (#46/#47) plays into the clip's own track, armed or not. Not while
+ // a take is recording: a track's live notes are recorded, and a tap on a key mid-take
+ // must not land in the clip.
+ private void AuditionNoteOn(int trackId, int pitch, float velocity)
+ {
+ if (Engine.IsRecording) return;
+ Engine.TrackNoteOn(trackId, pitch, velocity);
+ }
+
// Build the piano-roll editor for a specific arrangement clip (no panel switch).
private void BuildClipEditor(int trackId, int clipIndex)
{
@@ -434,6 +443,8 @@ public partial class MainWindow
PollHeldNotes = buf => Engine.LiveHeldNotes(buf),
ExpressionOf = id => Engine.GetNoteExpression(id),
CreateExpression = pts => Engine.CreateNoteExpression(pts),
+ AuditionOn = (pitch, vel) => AuditionNoteOn(trackId, pitch, vel),
+ AuditionOff = pitch => Engine.TrackNoteOff(trackId, pitch),
// The ruler moves the transport (#50): clip-local beat → arrangement beat.
Seek = local =>
{
@@ -641,6 +652,8 @@ public partial class MainWindow
PollHeldNotes = buf => Engine.LiveHeldNotes(buf),
ExpressionOf = id => Engine.GetNoteExpression(id),
CreateExpression = pts => Engine.CreateNoteExpression(pts),
+ AuditionOn = (pitch, vel) => AuditionNoteOn(trackId, pitch, vel),
+ AuditionOff = pitch => Engine.TrackNoteOff(trackId, pitch),
};
double slotLen = Engine.SessionSlotLength(trackId, scene);
roll.SetTrackColor(TrackBrush(trackId));
diff --git a/src/managed/Nota.App/MainWindow.axaml.cs b/src/managed/Nota.App/MainWindow.axaml.cs
index d2925753..f7f456bf 100644
--- a/src/managed/Nota.App/MainWindow.axaml.cs
+++ b/src/managed/Nota.App/MainWindow.axaml.cs
@@ -360,6 +360,10 @@ public partial class MainWindow : Window
// Arrangement view options (View menu) persist the same way.
Timeline.ClipLabels = (ClipLabelMode)Math.Clamp(vm.Settings.Current.ArrangementClipLabels, 0, 2);
Timeline.ShowSections = vm.Settings.Current.ArrangementShowSections;
+ // The piano roll's note audition (speaker chip) persists too.
+ PianoRollView.AuditionEnabled = vm.Settings.Current.PianoRollAudition;
+ PianoRollView.AuditionToggled -= OnAuditionToggled;
+ PianoRollView.AuditionToggled += OnAuditionToggled;
vm.Transport.CountInBars = Math.Clamp(vm.Settings.Current.CountInBars, 0, 4);
vm.Transport.LoopRecordReplace = vm.Settings.Current.LoopRecordReplace;
vm.Transport.PropertyChanged += (_, e) =>
@@ -811,6 +815,14 @@ public partial class MainWindow : Window
private NativeMenuItem? _followMenuItem;
+ private void OnAuditionToggled()
+ {
+ if (_vm is null) return;
+ _vm.Settings.Current.PianoRollAudition = PianoRollView.AuditionEnabled;
+ _vm.Settings.Save();
+ _vm.StatusText = PianoRollView.AuditionEnabled ? "Note audition on" : "Note audition off";
+ }
+
private static NativeMenuItem? FindMenuItem(NativeMenu? menu, string header)
{
if (menu is null) return null;
diff --git a/src/managed/Nota.App/PianoRollView.cs b/src/managed/Nota.App/PianoRollView.cs
index 6324d109..4cfb12f4 100644
--- a/src/managed/Nota.App/PianoRollView.cs
+++ b/src/managed/Nota.App/PianoRollView.cs
@@ -10,6 +10,8 @@
// list; every edit invokes Commit so the window pushes the set to the engine.
// Rows zoom vertically (⌘⌥+wheel, drag on the keys, ⌥+pinch, ⇧F = Fit to notes);
// the row height is per-clip view state like the horizontal zoom.
+// With note audition on (the clip editor's speaker chip, #46) a note sounds on the track's
+// instrument while it is placed, pressed or dragged; the keys column plays its keys (#47).
using System;
using System.Collections.Generic;
@@ -40,6 +42,58 @@ public sealed partial class PianoRollView : UserControl
/// <summary>Moves the transport to a clip-local beat (#50): a click or drag on the ruler.
/// Null (a session slot, which runs its own clock) leaves the ruler inert.</summary>
public Action<double>? Seek { get; set; }
+ /// <summary>Starts / ends a note on the clip's own track (note audition, #46; the playable
+ /// keys, #47): pitch and velocity 0..1. Null leaves the roll silent. Set by the host.</summary>
+ public Action<int, float>? AuditionOn { get; set; }
+ public Action<int>? AuditionOff { get; set; }
+
+ /// <summary>Note audition (#46): placing, clicking or dragging a note plays it on the
+ /// track's instrument. App-wide like FL Studio's speaker toggle; on by default, seeded
+ /// from and saved to Settings by the host. The keys column plays whatever this says.</summary>
+ public static bool AuditionEnabled { get; set; } = true;
+ /// <summary>Fired when a clip editor's speaker chip flips <see cref="AuditionEnabled"/>.</summary>
+ public static event Action? AuditionToggled;
+ public static void SetAuditionEnabled(bool on)
+ {
+ if (AuditionEnabled == on) return;
+ AuditionEnabled = on;
+ AuditionToggled?.Invoke();
+ }
+
+ // The one pitch sounding from the roll (−1 = none): a new audition ends the previous one,
+ // so a drag across pitches re-triggers instead of stacking notes.
+ private int _auditionPitch = -1;
+ /// <summary>Sound <paramref name="pitch"/> until <see cref="StopAudition"/>. The note grid
+ /// asks only while audition is on; the keys column always plays (force).</summary>
+ internal void Audition(int pitch, float velocity, bool force = false)
+ {
+ if (AuditionOn is null || (!force && !AuditionEnabled) || pitch == _auditionPitch) return;
+ StopAudition();
+ if (pitch < MinPitch || pitch > MaxPitch) return;
+ _auditionPitch = pitch;
+ AuditionOn(pitch, Math.Clamp(velocity, 0.05f, 1f));
+ _keys.InvalidateVisual();
+ }
+ internal void StopAudition()
+ {
+ if (_auditionPitch < 0) return;
+ int p = _auditionPitch;
+ _auditionPitch = -1;
+ AuditionOff?.Invoke(p);
+ _keys.InvalidateVisual();
+ }
+
+ /// <summary>Selects every note of <paramref name="pitch"/> (⌘/Ctrl-click on a key, #47);
+ /// <paramref name="add"/> keeps the current selection.</summary>
+ internal void SelectPitch(int pitch, bool add)
+ {
+ SettlePlacement(); // a pending placement lands first: it can cut or remove notes
+ if (!add) _selection.Clear();
+ for (int i = 0; i < _notes.Count; i++)
+ if (_notes[i].Pitch == pitch) _selection.Add(i);
+ Invalidate();
+ Changed?.Invoke();
+ }
// The recording take shown in this roll (#56): its held notes grow on the grid and new
// notes settle in. Null when the roll shows any other clip.
@@ -360,7 +414,7 @@ public sealed partial class PianoRollView : UserControl
}
_heldTimer.Start();
};
- DetachedFromVisualTree += (_, _) => { _heldTimer?.Stop(); if (_held.Count > 0) { _held.Clear(); _keys.InvalidateVisual(); _gridControl.InvalidateVisual(); } };
+ DetachedFromVisualTree += (_, _) => { StopAudition(); _heldTimer?.Stop(); if (_held.Count > 0) { _held.Clear(); _keys.InvalidateVisual(); _gridControl.InvalidateVisual(); } };
// The grid setting (and Quantize step) is app-wide: follow it while on screen only —
// a roll is rebuilt for every clip, so a lasting subscription would leak.
@@ -1128,37 +1182,52 @@ public sealed partial class PianoRollView : UserControl
public KeysColumn(PianoRollView o) { _o = o; }
private double RowH => _o.RowH;
- // Drag zoom: press a key and drag vertically — down taller, up shorter — with the
- // pressed key held at the press height. Nothing is played or created.
+ // A press plays the key on the track's instrument (#47) until release. Dragging
+ // vertically past a few pixels turns the press into the row zoom of specs/019 — down
+ // taller, up shorter, the pressed key held at the press height — and lets the note
+ // go; with Shift held the drag glides through the keys instead. ⌘/Ctrl-click
+ // selects every note of that pitch (⇧ adds to the selection) and plays nothing.
private static readonly Cursor ZoomCursor = new(StandardCursorType.SizeNorthSouth);
- private bool _zooming;
+ private const double ZoomSlop = 4;
+ private enum Press { None, Key, Glide, Zoom }
+ private Press _press;
private double _pressY, _pressRowH;
+ private int PitchAt(double y) => (int)Math.Clamp(MaxPitch - Math.Floor(y / RowH), MinPitch, MaxPitch);
+ private const float KeyVelocity = 0.8f;
+
protected override void OnPointerPressed(PointerPressedEventArgs e)
{
if (!e.GetCurrentPoint(this).Properties.IsLeftButtonPressed || _o._gridControl.Dragging) return;
- _zooming = true;
+ int pitch = PitchAt(e.GetPosition(this).Y);
+ e.Handled = true;
+ if (ArrangementView.IsPrimaryDown(e.KeyModifiers))
+ {
+ _o.SelectPitch(pitch, (e.KeyModifiers & KeyModifiers.Shift) != 0);
+ return;
+ }
+ _press = (e.KeyModifiers & KeyModifiers.Shift) != 0 ? Press.Glide : Press.Key;
_pressY = e.GetPosition(_o._bodyScroll).Y;
_pressRowH = RowH;
- Cursor = ZoomCursor;
+ _o.Audition(pitch, KeyVelocity, force: true);
e.Pointer.Capture(this);
- e.Handled = true;
}
protected override void OnPointerReleased(PointerReleasedEventArgs e)
{
- if (!_zooming) return;
+ if (_press == Press.None) return;
e.Pointer.Capture(null);
- EndZoom();
+ EndPress();
e.Handled = true;
}
- protected override void OnPointerCaptureLost(PointerCaptureLostEventArgs e) => EndZoom();
+ protected override void OnPointerCaptureLost(PointerCaptureLostEventArgs e) => EndPress();
- private void EndZoom()
+ private void EndPress()
{
- if (!_zooming) return;
- _zooming = false;
+ if (_press == Press.None) return;
+ _press = Press.None;
+ _o.StopAudition();
Cursor = null;
}
@@ -1174,13 +1243,20 @@ public sealed partial class PianoRollView : UserControl
protected override void OnPointerMoved(PointerEventArgs e)
{
- if (_zooming)
+ if (_press == Press.Key && Math.Abs(e.GetPosition(_o._bodyScroll).Y - _pressY) > ZoomSlop)
+ {
+ _press = Press.Zoom; // a drag, not a key press: zoom, and let the note go
+ _o.StopAudition();
+ Cursor = ZoomCursor;
+ }
+ if (_press == Press.Zoom)
{
double dy = e.GetPosition(_o._bodyScroll).Y - _pressY;
_o.SetRowHeightAt(_pressRowH * Math.Exp(dy * 0.01), _pressY);
return;
}
- int p = (int)Math.Clamp(MaxPitch - Math.Floor(e.GetPosition(this).Y / RowH), MinPitch, MaxPitch);
+ int p = PitchAt(e.GetPosition(this).Y);
+ if (_press == Press.Glide) _o.Audition(p, KeyVelocity, force: true);
if (p != _hover) { _hover = p; InvalidateVisual(); }
}
protected override void OnPointerExited(PointerEventArgs e)
@@ -1213,9 +1289,16 @@ public sealed partial class PianoRollView : UserControl
ctx.FillRectangle(HeldKeyFill, new Rect(0, y, w, RowH - 1));
DrawKeyLabel(ctx, hp, y, w, KeyLabelOnAccent);
}
+ // The key the roll itself is sounding (a pressed key, an auditioned note).
+ if (_o._auditionPitch >= MinPitch && !_o._held.Contains(_o._auditionPitch))
+ {
+ double y = (MaxPitch - _o._auditionPitch) * RowH;
+ ctx.FillRectangle(HeldKeyFill, new Rect(0, y, w, RowH - 1));
+ DrawKeyLabel(ctx, _o._auditionPitch, y, w, KeyLabelOnAccent);
+ }
// Hovered key: highlight it and label its note name (works for black keys too,
// where the octave-C label wouldn't otherwise show).
- if (_hover >= MinPitch)
+ if (_hover >= MinPitch && _hover != _o._auditionPitch)
{
double hy = (MaxPitch - _hover) * RowH;
ctx.FillRectangle(KeyHover, new Rect(0, hy, w, RowH - 1));
@@ -1507,6 +1590,8 @@ public sealed partial class PianoRollView : UserControl
_o._notes.Add(nt);
_o._selection.Clear(); _o._selection.Add(_o._notes.Count - 1);
_o._placementPending = true; // a drawn note overwrites what it lands on
+ _o.Audition(nt.Pitch, nt.Velocity); // heard until the button comes up
+ e.Pointer.Capture(this);
}
_o.Invalidate(); _o.CommitNotes(); _o.Changed?.Invoke();
e.Handled = true;
@@ -1524,6 +1609,7 @@ public sealed partial class PianoRollView : UserControl
}
if (!_o._selection.Contains(hit)) { _o._selection.Clear(); _o._selection.Add(hit); }
e.Pointer.Capture(this);
+ _o.Audition(_o._notes[hit].Pitch, _o._notes[hit].Velocity);
_primary = hit;
_o.Remember(hit);
_dragMoved = false;
@@ -1588,6 +1674,8 @@ public sealed partial class PianoRollView : UserControl
}
_dragMoved = true;
PushLive();
+ // A drag to a new pitch re-triggers the grabbed note there (#46).
+ _o.Audition(_o._notes[_primary].Pitch, _o._notes[_primary].Velocity);
}
else if (_drag == Mode.Resize)
{
@@ -1666,6 +1754,13 @@ public sealed partial class PianoRollView : UserControl
if (hn != _hoverNote || left != _hoverLeft) { _hoverNote = hn; _hoverLeft = left; _o.Invalidate(); }
}
+ // Whatever ends the press (release, a window losing the pointer) ends its note.
+ protected override void OnPointerCaptureLost(PointerCaptureLostEventArgs e)
+ {
+ _o.StopAudition();
+ base.OnPointerCaptureLost(e);
+ }
+
protected override void OnPointerExited(PointerEventArgs e)
{
if (_cursorKind != 0) { _cursorKind = 0; Cursor = ArrowCursor; }
@@ -1676,7 +1771,8 @@ public sealed partial class PianoRollView : UserControl
protected override void OnPointerReleased(PointerReleasedEventArgs e)
{
StopAutoScroll();
- if (_drag == Mode.None) return;
+ _o.StopAudition();
+ if (_drag == Mode.None) { e.Pointer.Capture(null); return; }
var was = _drag;
_drag = Mode.None;
e.Pointer.Capture(null);
diff --git a/src/managed/Nota.App/PreferencesWindow.cs b/src/managed/Nota.App/PreferencesWindow.cs
index b01fe089..f32003a6 100644
--- a/src/managed/Nota.App/PreferencesWindow.cs
+++ b/src/managed/Nota.App/PreferencesWindow.cs
@@ -1173,6 +1173,7 @@ public sealed partial class PreferencesWindow : NotaWindow
("Drag in the Bend / Pres / Slide lane", "Draw the selected note's MPE curve · ⌥ draws a straight line · drag a point to move it"),
("Double-click in an MPE lane", "Add a point · on a point, delete it · right-click to clear the curve"),
("⌘⌥ + wheel", "Zoom rows (vertical zoom)"),
+ ("Click a key", "Play it on the track's instrument · ⇧-drag glides through the keys · ⌘-click selects every note of that pitch"),
("Drag on the keys", "Zoom rows · down taller, up shorter"),
("⌥ + pinch", "Zoom rows (trackpad)"),
("⇧F", "Fit to notes"),
diff --git a/src/managed/Nota.Application/Settings.cs b/src/managed/Nota.Application/Settings.cs
index 49478f65..3323599e 100644
--- a/src/managed/Nota.Application/Settings.cs
+++ b/src/managed/Nota.Application/Settings.cs
@@ -143,6 +143,9 @@ public sealed class Settings
/// <summary>How audio clips draw their waveform on the lanes (Settings → Appearance):
/// 0 bars — spaced peak strokes (default), 1 solid — one column per pixel.</summary>
public int ArrangementWaveform { get; set; }
+ /// <summary>Piano-roll note audition (#46): notes sound while they are placed, clicked or
+ /// dragged. The speaker chip in the clip editor's header; on by default.</summary>
+ public bool PianoRollAudition { get; set; } = true;
}
public interface ISettingsService