Monorepo for Aesthetic.Computer
aesthetic.computer
Refine waveform strip and floating palette
- expand menubar waveform strip controls, interactions, and behavior
- split liquid and legacy strip presentation while restoring strip updates
- polish floating palette glass layout and unify collapse behavior with strip controls
- add palette implementation notes for follow-up work
authored by
Esteban Uribe
and committed by
prompt.ac/@jeffrey
bbc5b0c6
ad1dddaa
+2376
-173
8 changed files
+108
slab/menuband/PALETTE_LEARNINGS.md
+108
slab/menuband/PALETTE_LEARNINGS.md
···
1
1
+
## Piano / Waveform Palette Learnings
2
2
+
3
3
+
This file captures the current behavior and implementation constraints for the unified floating/collapsed palette work.
4
4
+
5
5
+
### Current architecture
6
6
+
7
7
+
- `PianoWaveformPalette` is the facade for the two UI states.
8
8
+
- Expanded state is `FloatingPlayPaletteController`.
9
9
+
- Collapsed state is `MenuBarWaveformStrip`.
10
10
+
- `AppDelegate` now treats both as one conceptual element through `pianoWaveformPalette`.
11
11
+
12
12
+
### Current state model
13
13
+
14
14
+
- `PianoWaveformPalette.State.expanded` means the floating palette is the active representation.
15
15
+
- `PianoWaveformPalette.State.collapsed` means the strip is the active representation, even if the strip is currently hidden.
16
16
+
- Hidden collapsed strip is intentional state, not a reset back to expanded.
17
17
+
- In collapsed state, key presses and menubar piano mouse-drag can revive the strip.
18
18
+
- In expanded state, note activity must not auto-show the strip.
19
19
+
20
20
+
### Position persistence
21
21
+
22
22
+
- Expanded palette position is persisted in `FloatingPlayPaletteController` via `UserDefaults`.
23
23
+
- Collapsed strip position is persisted separately in `MenuBarWaveformStrip`.
24
24
+
- Collapsed `Dock` resets the strip back under the menubar piano by clearing the custom origin.
25
25
+
26
26
+
### API learnings
27
27
+
28
28
+
- `NSGlassEffectView` is the primary AppKit Liquid Glass surface for this work.
29
29
+
- `NSGlassEffectView.contentView` is the supported place to embed real content.
30
30
+
- `NSGlassEffectView.cornerRadius` is the direct way to shape the glass surface.
31
31
+
- `NSGlassEffectView.style` can be set to `.clear` for button-like glass chrome.
32
32
+
- `NSGlassEffectView.tintColor` is the supported API for pushing the glass toward the current instrument/accent color.
33
33
+
- `NSGlassEffectContainerView` is useful when several nearby glass views should merge efficiently.
34
34
+
- `NSGlassEffectContainerView.contentView` is the descendant subtree the container manages and merges.
35
35
+
- Apple’s AppKit docs explicitly note that `NSGlassEffectContainerView` can improve performance by batching nearby similar glass views.
36
36
+
- `NSGlassEffectView` only guarantees correct glass behavior for its `contentView`; arbitrary subviews are not guaranteed to behave correctly relative to the glass surface or z-order.
37
37
+
- For fallback styling on older macOS versions, plain layer-backed `NSButton` plus translucent background/border is a practical substitute.
38
38
+
39
39
+
### Liquid Glass implementation rules
40
40
+
41
41
+
- Prefer one larger glass container plus a few intentional child glass surfaces instead of many unrelated decorative glass views.
42
42
+
- Use clear-style glass only for chrome-like controls; use the main strip/palette glass views for the actual body surfaces.
43
43
+
- Keep the overlay buttons and their glass backplates as siblings in the same ancestor view hierarchy.
44
44
+
- Add the interactive button to the hierarchy first, then add and constrain the glass backplate to it.
45
45
+
- If hover-only controls are used, initialize both the button and its glass background to hidden.
46
46
+
- Reapply tinting when the instrument family or MIDI visual mode changes.
47
47
+
48
48
+
### Expanded palette controls
49
49
+
50
50
+
- `FloatingPlayPalette` has hover-only corner controls.
51
51
+
- Left: close.
52
52
+
- Right: dock, expand/collapse.
53
53
+
- On macOS 26+, these use `NSGlassEffectView` with clear-style glass backplates.
54
54
+
- Older macOS versions use a translucent layer-backed fallback.
55
55
+
56
56
+
### Collapsed strip controls
57
57
+
58
58
+
- The strip no longer uses the footer-row controls for close/dock/expand.
59
59
+
- Those controls are now top overlay controls.
60
60
+
- Left: close.
61
61
+
- Right: dock, expand.
62
62
+
- They are intended to be visible only while the pointer is inside the strip.
63
63
+
- Legacy implementation uses layer-backed circular buttons.
64
64
+
- Liquid implementation uses clear `NSGlassEffectView` backplates plus overlay buttons.
65
65
+
66
66
+
### Important crash gotcha
67
67
+
68
68
+
- Do not create glass backplates for buttons before the buttons are attached to the same ancestor view hierarchy.
69
69
+
- We hit an `NSGenericException` from constraints between `StripMovableGlassEffectView` and `NSButton` with no common ancestor.
70
70
+
- Correct order:
71
71
+
1. add the buttons to `rootView`
72
72
+
2. then create/install glass backplates constrained to those buttons
73
73
+
74
74
+
### Important hover/visibility gotcha
75
75
+
76
76
+
- Overlay controls must be explicitly reset hidden on strip `show()` and `dismiss()`.
77
77
+
- Relying only on `button.alphaValue = 0` during setup is not enough once the strip has already been shown and hovered before.
78
78
+
- For the liquid strip, glass backplates also need `alphaValue = 0` at creation time.
79
79
+
- Hover state should be treated as transient UI state, not inferred from visibility state.
80
80
+
81
81
+
### Symbol visibility gotcha
82
82
+
83
83
+
- The collapsed strip overlay buttons were effectively invisible when using the weaker default tint assumptions.
84
84
+
- Explicit symbol tinting is safer here.
85
85
+
- Current working tint is `NSColor.white.withAlphaComponent(0.92)`.
86
86
+
87
87
+
### Best practices found so far
88
88
+
89
89
+
- Keep `PianoWaveformPalette` as the only place that understands expanded vs collapsed state transitions.
90
90
+
- Let `AppDelegate` talk to the facade instead of branching on raw strip/palette types.
91
91
+
- Treat “collapsed but hidden” as a real persisted state rather than as a reset.
92
92
+
- Keep note-driven revival behavior gated by palette state, not by global strip availability.
93
93
+
- Preserve origin when resizing floating panels; avoid recentering after every content-size change.
94
94
+
- When moving controls from inline layout to overlay layout, remove their old constraints completely instead of trying to reuse them.
95
95
+
- For hover-only corner controls, separate layout concerns from visibility concerns.
96
96
+
- After crashes involving view hierarchy or constraints, assume later UI errors may be follow-on failures until the first exception is fixed.
97
97
+
98
98
+
### Behavior intentionally disabled
99
99
+
100
100
+
- The old independent menubar waveform-strip behavior is no longer the primary model.
101
101
+
- The strip still exists, but it should behave as the collapsed state of `PianoWaveformPalette`.
102
102
+
- Do not reintroduce unconditional note-driven strip showing unless that behavior is explicitly wanted again.
103
103
+
104
104
+
### Future work areas
105
105
+
106
106
+
- Wire the collapsed `Dock` button to any broader palette-level docking semantics if the expanded state should also understand docking.
107
107
+
- Consider whether collapsed-state `Close` should remain hidden-state collapsed, or switch the conceptual state elsewhere.
108
108
+
- If hover-only controls still appear immediately on show, investigate initial tracking-area / pointer-enter timing rather than button styling.
+61
-14
slab/menuband/Sources/MenuBand/AppDelegate.swift
+61
-14
slab/menuband/Sources/MenuBand/AppDelegate.swift
···
13
13
private var layoutToggleHotkey: GlobalHotkey?
14
14
private let popover = NSPopover()
15
15
private var popoverVC: MenuBandPopoverViewController?
16
16
-
private lazy var floatingPlayPalette = FloatingPlayPaletteController(menuBand: menuBand)
17
17
-
private lazy var waveformStrip = MenuBarWaveformStrip(menuBand: menuBand)
16
16
+
private lazy var pianoWaveformPalette = PianoWaveformPalette(menuBand: menuBand)
17
17
+
private var floatingPlayPalette: PianoWaveformPalette { pianoWaveformPalette }
18
18
+
private var waveformStrip: PianoWaveformPalette { pianoWaveformPalette }
18
19
private var appBeforePopover: NSRunningApplication?
19
20
private var appBeforeFocusCapture: NSRunningApplication?
20
21
private var focusCaptureArmedByShortcut = false
···
171
172
self.updateIcon()
172
173
self.popoverVC?.refreshHeldNotes()
173
174
self.floatingPlayPalette.refresh()
174
174
-
// strip retired — no-op
175
175
+
self.waveformStrip.refreshAppearance()
175
176
self.updateWaveformStrip()
176
177
}
177
178
menuBand.onInstrumentVisualChange = { [weak self] in
···
179
180
guard let self = self else { return }
180
181
self.updateIcon()
181
182
self.floatingPlayPalette.refresh()
182
182
-
// strip retired — no-op
183
183
+
self.waveformStrip.refreshAppearance()
183
184
}
184
185
}
185
186
menuBand.bootstrap()
187
187
+
lastKnownOctaveShift = menuBand.octaveShift
186
188
floatingPlayPalette.onDismiss = { [weak self] in
187
189
self?.updateIcon()
188
190
self?.popoverVC?.syncFromController()
···
225
227
}
226
228
updateIcon()
227
229
228
228
-
// Strip retired — no warmup needed.
230
230
+
// Pre-build the waveform strip panel so the first note press
231
231
+
// doesn't stall on panel + Metal pipeline construction.
232
232
+
waveformStrip.reposition(statusItemButton: statusItem.button)
233
233
+
waveformStrip.onStepBackward = { [weak self] in
234
234
+
self?.menuBand.stepMelodicProgram(delta: -1)
235
235
+
}
236
236
+
waveformStrip.onStepForward = { [weak self] in
237
237
+
self?.menuBand.stepMelodicProgram(delta: +1)
238
238
+
}
239
239
+
waveformStrip.onStepUp = { [weak self] in
240
240
+
self?.menuBand.stepMelodicProgram(delta: -InstrumentListView.cols)
241
241
+
}
242
242
+
waveformStrip.onStepDown = { [weak self] in
243
243
+
self?.menuBand.stepMelodicProgram(delta: +InstrumentListView.cols)
244
244
+
}
245
245
+
waveformStrip.warmUp()
229
246
230
247
registerTypeModeHotkey()
231
248
_ = registerFocusCaptureHotkey(MenuBandShortcutPreferences.focusShortcut)
···
262
279
) {
263
280
self.toggleKeyboardLayoutShortcut()
264
281
return true
282
282
+
}
283
283
+
if self.popover.isShown == false && self.floatingPlayPalette.isShown == false {
284
284
+
switch keyCode {
285
285
+
case 123: // kVK_LeftArrow
286
286
+
if isDown {
287
287
+
self.waveformStrip.registerArrowInput()
288
288
+
if !isRepeat { self.menuBand.stepMelodicProgram(delta: -1) }
289
289
+
}
290
290
+
return true
291
291
+
case 124: // kVK_RightArrow
292
292
+
if isDown {
293
293
+
self.waveformStrip.registerArrowInput()
294
294
+
if !isRepeat { self.menuBand.stepMelodicProgram(delta: +1) }
295
295
+
}
296
296
+
return true
297
297
+
case 125: // kVK_DownArrow
298
298
+
if isDown {
299
299
+
self.waveformStrip.registerArrowInput()
300
300
+
if !isRepeat { self.menuBand.stepMelodicProgram(delta: +InstrumentListView.cols) }
301
301
+
}
302
302
+
return true
303
303
+
case 126: // kVK_UpArrow
304
304
+
if isDown {
305
305
+
self.waveformStrip.registerArrowInput()
306
306
+
if !isRepeat { self.menuBand.stepMelodicProgram(delta: -InstrumentListView.cols) }
307
307
+
}
308
308
+
return true
309
309
+
default:
310
310
+
break
311
311
+
}
265
312
}
266
313
let consumed = self.menuBand.handleLocalKey(
267
314
keyCode: keyCode, isDown: isDown, isRepeat: isRepeat, flags: flags
···
1162
1209
let initialShift = downEvent.modifierFlags.contains(.shift)
1163
1210
|| downEvent.modifierFlags.contains(.capsLock)
1164
1211
menuBand.startTapNote(startNote, velocity: vel0, pan: pan0, linger: initialShift)
1212
1212
+
waveformStrip.showIfNeeded()
1165
1213
// Arm sandbox-friendly local capture on a real piano click. We
1166
1214
// skip arming when global TYPE mode is already on — the global
1167
1215
// tap is already handling keys, doubling up would re-trigger
···
1195
1243
let shiftNow = next.modifierFlags.contains(.shift)
1196
1244
|| next.modifierFlags.contains(.capsLock)
1197
1245
menuBand.startTapNote(nxt, velocity: v, pan: p, linger: shiftNow)
1246
1246
+
waveformStrip.showIfNeeded()
1198
1247
}
1199
1248
current = hovered
1200
1249
} else if let c = current {
···
1295
1344
// MARK: - Menubar waveform strip
1296
1345
1297
1346
private func updateWaveformStrip() {
1298
1298
-
// Strip retired — the menubar mini meter replaces it. We keep
1299
1299
-
// this method as a no-op so the call sites elsewhere stay
1300
1300
-
// wired without each one having to know about the retirement.
1347
1347
+
guard waveformStrip.isCollapsedState else { return }
1348
1348
+
if !menuBand.litNotes.isEmpty {
1349
1349
+
waveformStrip.showIfNeeded()
1350
1350
+
} else {
1351
1351
+
waveformStrip.scheduleHide()
1352
1352
+
}
1301
1353
}
1302
1354
1303
1355
private func updateWaveformStripSuppression() {
1304
1304
-
// Strip retired. The mini meter now stays animating at all
1305
1305
-
// times (including when the popover or palette is open) so
1306
1306
-
// the menubar icon always feels "live." When silent, the
1307
1307
-
// bars fall to a short floor instead of disappearing — see
1308
1308
-
// KeyboardIconRenderer.drawChipVisualizer for the silent-
1309
1309
-
// floor handling. This method is intentionally a no-op now.
1356
1356
+
waveformStrip.suppressed = waveformStrip.isDocked && (popover.isShown || floatingPlayPalette.isShown)
1310
1357
}
1311
1358
}
+45
-14
slab/menuband/Sources/MenuBand/ArrowKeysIndicator.swift
+45
-14
slab/menuband/Sources/MenuBand/ArrowKeysIndicator.swift
···
9
9
/// Direction indices match `InstrumentMapView.onArrowKey`:
10
10
/// 0 = ← 1 = → 2 = ↓ 3 = ↑
11
11
final class ArrowKeysIndicator: NSView {
12
12
+
enum DisplayMode {
13
13
+
case cluster
14
14
+
case horizontalPair
15
15
+
}
16
16
+
12
17
private var pressed: Set<Int> = []
13
18
private var hovered: Int?
14
19
private var trackingArea: NSTrackingArea?
···
20
25
/// release).
21
26
var onClick: ((Int, Bool) -> Void)?
22
27
23
23
-
static let intrinsicSize = NSSize(width: 46, height: 30)
24
24
-
override var intrinsicContentSize: NSSize { Self.intrinsicSize }
28
28
+
var displayMode: DisplayMode = .cluster {
29
29
+
didSet {
30
30
+
invalidateIntrinsicContentSize()
31
31
+
needsDisplay = true
32
32
+
}
33
33
+
}
34
34
+
35
35
+
private static let clusterIntrinsicSize = NSSize(width: 46, height: 30)
36
36
+
private static let horizontalPairIntrinsicSize = NSSize(width: 29, height: 15)
37
37
+
override var intrinsicContentSize: NSSize {
38
38
+
switch displayMode {
39
39
+
case .cluster:
40
40
+
return Self.clusterIntrinsicSize
41
41
+
case .horizontalPair:
42
42
+
return Self.horizontalPairIntrinsicSize
43
43
+
}
44
44
+
}
25
45
26
46
override init(frame frameRect: NSRect) {
27
47
super.init(frame: frameRect)
28
28
-
setFrameSize(Self.intrinsicSize)
48
48
+
setFrameSize(Self.clusterIntrinsicSize)
29
49
}
30
50
required init?(coder: NSCoder) { fatalError() }
31
51
···
54
74
55
75
/// Compute the four keycap rects in the same layout as `draw`.
56
76
/// Returned in direction index order: 0=←, 1=→, 2=↓, 3=↑.
57
57
-
private func keyRects() -> [NSRect] {
77
77
+
private func keyRects() -> [(direction: Int, rect: NSRect)] {
58
78
let r = bounds
59
79
let key: CGFloat = 13
60
80
let gap: CGFloat = 1
61
61
-
let centerX = r.midX
62
81
let bottomY = r.minY + 1
63
63
-
let topY = bottomY + key + gap
64
64
-
let downRect = NSRect(x: centerX - key / 2, y: bottomY, width: key, height: key)
65
65
-
let leftRect = NSRect(x: downRect.minX - key - gap, y: bottomY, width: key, height: key)
66
66
-
let rightRect = NSRect(x: downRect.maxX + gap, y: bottomY, width: key, height: key)
67
67
-
let upRect = NSRect(x: downRect.minX, y: topY, width: key, height: key)
68
68
-
return [leftRect, rightRect, downRect, upRect]
82
82
+
switch displayMode {
83
83
+
case .cluster:
84
84
+
let centerX = r.midX
85
85
+
let topY = bottomY + key + gap
86
86
+
let downRect = NSRect(x: centerX - key / 2, y: bottomY, width: key, height: key)
87
87
+
let leftRect = NSRect(x: downRect.minX - key - gap, y: bottomY, width: key, height: key)
88
88
+
let rightRect = NSRect(x: downRect.maxX + gap, y: bottomY, width: key, height: key)
89
89
+
let upRect = NSRect(x: downRect.minX, y: topY, width: key, height: key)
90
90
+
return [(0, leftRect), (1, rightRect), (2, downRect), (3, upRect)]
91
91
+
case .horizontalPair:
92
92
+
let pairWidth = key * 2 + gap
93
93
+
let startX = r.midX - pairWidth / 2
94
94
+
let leftRect = NSRect(x: startX, y: bottomY, width: key, height: key)
95
95
+
let rightRect = NSRect(x: leftRect.maxX + gap, y: bottomY, width: key, height: key)
96
96
+
return [(0, leftRect), (1, rightRect)]
97
97
+
}
69
98
}
70
99
71
100
private func direction(at point: NSPoint) -> Int? {
72
72
-
for (idx, kr) in keyRects().enumerated() where kr.contains(point) {
73
73
-
return idx
101
101
+
for item in keyRects() where item.rect.contains(point) {
102
102
+
return item.direction
74
103
}
75
104
return nil
76
105
}
···
114
143
super.draw(dirtyRect)
115
144
let radius: CGFloat = 2.5
116
145
let glyphs = ["←", "→", "↓", "↑"]
117
117
-
for (idx, kr) in keyRects().enumerated() {
146
146
+
for item in keyRects() {
147
147
+
let idx = item.direction
148
148
+
let kr = item.rect
118
149
let lit = pressed.contains(idx)
119
150
let isHover = (!lit && hovered == idx)
120
151
let path = NSBezierPath(roundedRect: kr, xRadius: radius, yRadius: radius)
+457
-76
slab/menuband/Sources/MenuBand/FloatingPlayPalette.swift
+457
-76
slab/menuband/Sources/MenuBand/FloatingPlayPalette.swift
···
1
1
import AppKit
2
2
3
3
+
private enum FloatingPaletteVisualStyleOverride: String {
4
4
+
case automatic
5
5
+
case liquid
6
6
+
case legacy
7
7
+
8
8
+
init(rawValue: String?) {
9
9
+
switch rawValue?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() {
10
10
+
case Self.liquid.rawValue:
11
11
+
self = .liquid
12
12
+
case Self.legacy.rawValue:
13
13
+
self = .legacy
14
14
+
default:
15
15
+
self = .automatic
16
16
+
}
17
17
+
}
18
18
+
}
19
19
+
20
20
+
@available(macOS 26.0, *)
21
21
+
private final class FloatingPaletteGlassEffectView: NSGlassEffectView {
22
22
+
override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
23
23
+
}
24
24
+
3
25
final class FloatingPlayPaletteController: NSObject, NSWindowDelegate {
4
26
enum DismissReason {
5
27
case closeButton
···
22
44
private var keyMonitor: Any?
23
45
private var appBeforeOpen: NSRunningApplication?
24
46
private var isDismissing = false
47
47
+
private var savedOrigin: NSPoint?
48
48
+
49
49
+
private static let customOriginXKey = "notepat.floatingPlayPalette.customOriginX"
50
50
+
private static let customOriginYKey = "notepat.floatingPlayPalette.customOriginY"
25
51
26
52
var onDismiss: (() -> Void)?
27
53
var onFocusRelease: (() -> Void)?
28
54
var onToggleKeymap: (() -> Void)?
55
55
+
var onExpandCollapseToggle: (() -> Void)? {
56
56
+
get { viewController.onExpandCollapseToggle }
57
57
+
set { viewController.onExpandCollapseToggle = newValue }
58
58
+
}
29
59
var isPianoFocusActive: (() -> Bool)? {
30
60
get { viewController.isPianoFocusActive }
31
61
set { viewController.isPianoFocusActive = newValue }
···
38
68
init(menuBand: MenuBandController) {
39
69
self.menuBand = menuBand
40
70
self.viewController = FloatingPlayPaletteViewController(menuBand: menuBand)
71
71
+
self.savedOrigin = Self.loadSavedOrigin()
41
72
super.init()
42
73
self.viewController.onClose = { [weak self] in
43
74
self?.dismiss(reason: .closeButton)
···
67
98
68
99
appBeforeOpen = previousApp ?? currentFrontmostOtherApp()
69
100
viewController.refresh()
70
70
-
panel.setFrame(frameForCurrentMouseScreen(size: viewController.preferredContentSize), display: false)
101
101
+
panel.setFrame(restoredFrame(size: viewController.preferredContentSize), display: false)
71
102
72
103
NSApp.activate(ignoringOtherApps: true)
73
104
panel.makeKeyAndOrderFront(nil)
···
115
146
private func buildPanel() {
116
147
let p = FloatingPlayPalettePanel(
117
148
contentRect: NSRect(origin: .zero, size: viewController.preferredContentSize),
118
118
-
styleMask: [.borderless],
149
149
+
styleMask: [.titled, .closable, .fullSizeContentView],
119
150
backing: .buffered,
120
151
defer: false
121
152
)
···
129
160
p.collectionBehavior = [.transient]
130
161
p.hidesOnDeactivate = false
131
162
p.canHide = false
132
132
-
p.isMovableByWindowBackground = false
163
163
+
p.isMovableByWindowBackground = true
133
164
p.acceptsMouseMovedEvents = true
165
165
+
p.titleVisibility = .hidden
166
166
+
p.titlebarAppearsTransparent = true
167
167
+
p.isReleasedWhenClosed = false
168
168
+
if let button = p.standardWindowButton(.closeButton) {
169
169
+
button.isHidden = true
170
170
+
}
171
171
+
if let mini = p.standardWindowButton(.miniaturizeButton) {
172
172
+
mini.isHidden = true
173
173
+
}
174
174
+
if let zoom = p.standardWindowButton(.zoomButton) {
175
175
+
zoom.isHidden = true
176
176
+
}
134
177
panel = p
135
178
}
136
179
···
178
221
let size = viewController.preferredContentSize
179
222
let old = panel.frame
180
223
guard abs(old.width - size.width) > 0.5 || abs(old.height - size.height) > 0.5 else { return }
181
181
-
let center = NSPoint(x: old.midX, y: old.midY)
182
224
var frame = NSRect(
183
183
-
x: center.x - size.width / 2,
184
184
-
y: center.y - size.height / 2,
225
225
+
x: old.origin.x,
226
226
+
y: old.origin.y,
185
227
width: size.width,
186
228
height: size.height
187
229
)
···
189
231
?? NSRect(x: 0, y: 0, width: 1024, height: 768)
190
232
frame = clamped(frame, to: visible)
191
233
panel.setFrame(frame, display: true)
234
234
+
persistPanelOrigin()
192
235
}
193
236
194
237
private func frameForCurrentMouseScreen(size: NSSize) -> NSRect {
···
207
250
return NSRect(origin: NSPoint(x: x, y: y), size: size)
208
251
}
209
252
253
253
+
private func restoredFrame(size: NSSize) -> NSRect {
254
254
+
guard let savedOrigin else {
255
255
+
return frameForCurrentMouseScreen(size: size)
256
256
+
}
257
257
+
let preferredScreen = NSScreen.screens.first(where: { $0.visibleFrame.contains(savedOrigin) })
258
258
+
?? NSScreen.main
259
259
+
?? NSScreen.screens.first
260
260
+
let visible = preferredScreen?.visibleFrame ?? NSRect(x: 0, y: 0, width: 1024, height: 768)
261
261
+
return clamped(NSRect(origin: savedOrigin, size: size), to: visible)
262
262
+
}
263
263
+
210
264
private func clamped(_ frame: NSRect, to visible: NSRect) -> NSRect {
211
265
let margin: CGFloat = 16
212
266
let x = min(max(frame.origin.x, visible.minX + margin), visible.maxX - frame.width - margin)
···
227
281
app.activate(options: [.activateIgnoringOtherApps])
228
282
}
229
283
284
284
+
func windowDidMove(_ notification: Notification) {
285
285
+
persistPanelOrigin()
286
286
+
}
287
287
+
288
288
+
private func persistPanelOrigin() {
289
289
+
guard let panel else { return }
290
290
+
savedOrigin = panel.frame.origin
291
291
+
let defaults = UserDefaults.standard
292
292
+
defaults.set(panel.frame.origin.x, forKey: Self.customOriginXKey)
293
293
+
defaults.set(panel.frame.origin.y, forKey: Self.customOriginYKey)
294
294
+
}
295
295
+
296
296
+
private static func loadSavedOrigin() -> NSPoint? {
297
297
+
let defaults = UserDefaults.standard
298
298
+
guard defaults.object(forKey: customOriginXKey) != nil,
299
299
+
defaults.object(forKey: customOriginYKey) != nil else { return nil }
300
300
+
return NSPoint(
301
301
+
x: defaults.double(forKey: customOriginXKey),
302
302
+
y: defaults.double(forKey: customOriginYKey)
303
303
+
)
304
304
+
}
305
305
+
230
306
deinit {
231
307
dismiss(reason: .programmatic)
232
308
}
···
238
314
get { paletteView.onClose }
239
315
set { paletteView.onClose = newValue }
240
316
}
317
317
+
var onExpandCollapseToggle: (() -> Void)? {
318
318
+
get { paletteView.onExpandCollapseToggle }
319
319
+
set { paletteView.onExpandCollapseToggle = newValue }
320
320
+
}
241
321
var isPianoFocusActive: (() -> Bool)? {
242
322
get { paletteView.isPianoFocusActive }
243
323
set { paletteView.isPianoFocusActive = newValue }
324
324
+
}
325
325
+
var onHoverChanged: ((Bool) -> Void)? {
326
326
+
get { paletteView.onHoverChanged }
327
327
+
set { paletteView.onHoverChanged = newValue }
244
328
}
245
329
246
330
init(menuBand: MenuBandController) {
···
273
357
}
274
358
275
359
private final class FloatingPlayPaletteView: NSView {
360
360
+
private static let defaultsDomain = "computer.aestheticcomputer.menuband"
361
361
+
private static let styleOverrideDefaultsKey = "MenuBandFloatingPlayPaletteStyle"
362
362
+
private static let styleOverrideEnvironmentKey = "MENUBAND_FLOATING_PLAY_PALETTE_STYLE"
363
363
+
364
364
+
private static var visualStyleOverride: FloatingPaletteVisualStyleOverride {
365
365
+
let environmentValue = ProcessInfo.processInfo.environment[styleOverrideEnvironmentKey]
366
366
+
if environmentValue != nil {
367
367
+
return FloatingPaletteVisualStyleOverride(rawValue: environmentValue)
368
368
+
}
369
369
+
let defaultsValue = UserDefaults(suiteName: defaultsDomain)?.string(forKey: styleOverrideDefaultsKey)
370
370
+
?? UserDefaults.standard.string(forKey: styleOverrideDefaultsKey)
371
371
+
return FloatingPaletteVisualStyleOverride(rawValue: defaultsValue)
372
372
+
}
373
373
+
374
374
+
private static var shouldUseLiquidGlass: Bool {
375
375
+
switch visualStyleOverride {
376
376
+
case .liquid:
377
377
+
if #available(macOS 26.0, *) { return true }
378
378
+
return false
379
379
+
case .legacy:
380
380
+
return false
381
381
+
case .automatic:
382
382
+
if #available(macOS 26.0, *) { return true }
383
383
+
return false
384
384
+
}
385
385
+
}
386
386
+
276
387
private weak var menuBand: MenuBandController?
388
388
+
private let contentStack = NSStackView()
389
389
+
private let waveformSection = NSView()
277
390
private let waveformView = WaveformView()
278
391
private let waveformBezel = NSView()
392
392
+
private let waveformClipView = NSView()
279
393
private let heldNotesStack = NSStackView()
280
394
private let heldNotesRow = NSView()
281
395
private let chordCandidatesStack = NSStackView()
···
284
398
private let instrumentReadout = NSTextField(labelWithString: "")
285
399
private let instrumentTitleRow: NSStackView
286
400
private let pianoView: FloatingPianoView
287
287
-
private let dragHandle = FloatingPaletteDragHandleView()
288
401
private let closeButton = NSButton()
289
289
-
private let shortcutHintLabel = NSTextField(labelWithString: "")
402
402
+
private let dockButton = NSButton()
403
403
+
private let expandCollapseButton = NSButton()
404
404
+
private let shortcutHintRow = NSStackView()
405
405
+
private let focusHintLabel = NSTextField(labelWithString: "")
406
406
+
private let layoutHintLabel = NSTextField(labelWithString: "")
407
407
+
private weak var closeButtonGlassView: NSView?
408
408
+
private weak var dockButtonGlassView: NSView?
409
409
+
private weak var expandCollapseButtonGlassView: NSView?
410
410
+
private weak var paletteGlassView: NSView?
411
411
+
private weak var waveformGlassView: NSView?
412
412
+
private weak var waveformSectionGlassView: NSView?
413
413
+
private weak var pianoGlassView: NSView?
414
414
+
private weak var keymapGlassView: NSView?
415
415
+
private weak var hintGlassView: NSView?
290
416
/// Large QWERTY keymap shown beneath the piano so the user can
291
417
/// see at a glance which physical keys play which notes. Driven
292
418
/// at 2× scale so it's legible at the floating palette's size.
293
419
private let qwertyView = QwertyLayoutView()
294
420
295
421
var onClose: (() -> Void)?
422
422
+
var onExpandCollapseToggle: (() -> Void)?
296
423
var isPianoFocusActive: (() -> Bool)?
424
424
+
var onHoverChanged: ((Bool) -> Void)?
297
425
298
426
private let pianoScale: CGFloat = 1.6
299
427
private let inset: CGFloat = 14
300
428
private let gap: CGFloat = 8
301
301
-
private let closeSize: CGFloat = 18
302
302
-
private let hintHeight: CGFloat = 42
429
429
+
private let closeButtonSize: CGFloat = 30
430
430
+
private let closeButtonCornerInset: CGFloat = 3
431
431
+
private let hintHeight: CGFloat = 20
303
432
private let heldNotesRowHeight: CGFloat = 26
304
433
private let chordCandidatesRowHeight: CGFloat = 30
305
434
private var waveformHeightConstraint: NSLayoutConstraint?
435
435
+
private var trackingArea: NSTrackingArea?
436
436
+
private var isExpanded = true
437
437
+
private static let panelCornerRadius: CGFloat = 18
438
438
+
private static let sectionCornerRadius: CGFloat = 14
439
439
+
private static let waveformClipCornerRadius: CGFloat = 12
306
440
307
441
init(menuBand: MenuBandController) {
308
442
self.menuBand = menuBand
···
317
451
318
452
waveformView.menuBand = menuBand
319
453
waveformView.translatesAutoresizingMaskIntoConstraints = false
454
454
+
waveformView.setSurfaceStyle(.glassEmbedded)
455
455
+
contentStack.orientation = .vertical
456
456
+
contentStack.alignment = .centerX
457
457
+
contentStack.distribution = .fill
458
458
+
contentStack.spacing = gap
459
459
+
contentStack.translatesAutoresizingMaskIntoConstraints = false
460
460
+
waveformSection.wantsLayer = true
461
461
+
waveformSection.layer?.cornerRadius = Self.sectionCornerRadius
462
462
+
waveformSection.layer?.borderWidth = 0.8
463
463
+
if #available(macOS 10.15, *) {
464
464
+
waveformSection.layer?.cornerCurve = .continuous
465
465
+
}
466
466
+
waveformSection.translatesAutoresizingMaskIntoConstraints = false
320
467
waveformBezel.wantsLayer = true
321
321
-
waveformBezel.layer?.cornerRadius = 6
322
322
-
waveformBezel.layer?.backgroundColor = NSColor(white: 0.06, alpha: 1.0).cgColor
323
323
-
waveformBezel.layer?.borderWidth = 1
468
468
+
waveformBezel.layer?.cornerRadius = Self.waveformClipCornerRadius + 2
469
469
+
waveformBezel.layer?.borderWidth = 0
470
470
+
if #available(macOS 10.15, *) {
471
471
+
waveformBezel.layer?.cornerCurve = .continuous
472
472
+
}
324
473
waveformBezel.translatesAutoresizingMaskIntoConstraints = false
474
474
+
waveformClipView.wantsLayer = true
475
475
+
waveformClipView.translatesAutoresizingMaskIntoConstraints = false
476
476
+
waveformClipView.layer?.cornerRadius = Self.waveformClipCornerRadius
477
477
+
waveformClipView.layer?.masksToBounds = true
478
478
+
if #available(macOS 10.15, *) {
479
479
+
waveformClipView.layer?.cornerCurve = .continuous
480
480
+
}
325
481
heldNotesStack.orientation = .horizontal
326
482
heldNotesStack.alignment = .centerY
327
483
heldNotesStack.spacing = 6
···
344
500
instrumentTitleRow.spacing = 0
345
501
instrumentTitleRow.translatesAutoresizingMaskIntoConstraints = false
346
502
pianoView.translatesAutoresizingMaskIntoConstraints = false
347
347
-
dragHandle.translatesAutoresizingMaskIntoConstraints = false
348
503
closeButton.translatesAutoresizingMaskIntoConstraints = false
349
349
-
shortcutHintLabel.translatesAutoresizingMaskIntoConstraints = false
504
504
+
dockButton.translatesAutoresizingMaskIntoConstraints = false
505
505
+
expandCollapseButton.translatesAutoresizingMaskIntoConstraints = false
506
506
+
shortcutHintRow.orientation = .horizontal
507
507
+
shortcutHintRow.alignment = .centerY
508
508
+
shortcutHintRow.distribution = .fill
509
509
+
shortcutHintRow.spacing = gap
510
510
+
shortcutHintRow.translatesAutoresizingMaskIntoConstraints = false
511
511
+
focusHintLabel.translatesAutoresizingMaskIntoConstraints = false
512
512
+
layoutHintLabel.translatesAutoresizingMaskIntoConstraints = false
350
513
qwertyView.scale = 1.4
351
514
qwertyView.keymap = menuBand.keymap
352
515
qwertyView.translatesAutoresizingMaskIntoConstraints = false
···
364
527
// for the chord readout. Stack vertically: pills on top, cards
365
528
// beneath, both centered. Waveform draws underneath, peeking
366
529
// through the translucent card backgrounds.
367
367
-
waveformBezel.addSubview(waveformView)
530
530
+
waveformBezel.addSubview(waveformClipView)
531
531
+
waveformClipView.addSubview(waveformView)
368
532
waveformBezel.layer?.masksToBounds = false
369
533
heldNotesRow.wantsLayer = true
370
534
heldNotesRow.layer?.masksToBounds = false
···
372
536
chordCandidatesRow.layer?.masksToBounds = false
373
537
waveformBezel.addSubview(heldNotesRow)
374
538
waveformBezel.addSubview(chordCandidatesRow)
375
375
-
addSubview(waveformBezel)
376
376
-
addSubview(instrumentTitleRow)
377
377
-
addSubview(pianoView)
378
378
-
addSubview(qwertyView)
379
379
-
shortcutHintLabel.font = NSFont.systemFont(ofSize: 10)
380
380
-
shortcutHintLabel.textColor = .secondaryLabelColor
381
381
-
shortcutHintLabel.alignment = .center
382
382
-
shortcutHintLabel.maximumNumberOfLines = 2
383
383
-
shortcutHintLabel.lineBreakMode = .byWordWrapping
384
384
-
addSubview(shortcutHintLabel)
385
385
-
addSubview(dragHandle)
539
539
+
waveformSection.addSubview(waveformBezel)
540
540
+
waveformSection.addSubview(instrumentTitleRow)
541
541
+
addSubview(contentStack)
542
542
+
contentStack.addArrangedSubview(waveformSection)
543
543
+
contentStack.addArrangedSubview(pianoView)
544
544
+
shortcutHintRow.addArrangedSubview(layoutHintLabel)
545
545
+
shortcutHintRow.addArrangedSubview(NSView())
546
546
+
shortcutHintRow.addArrangedSubview(focusHintLabel)
547
547
+
contentStack.addArrangedSubview(shortcutHintRow)
548
548
+
contentStack.addArrangedSubview(qwertyView)
549
549
+
for label in [focusHintLabel, layoutHintLabel] {
550
550
+
label.font = NSFont.systemFont(ofSize: 10, weight: .bold)
551
551
+
label.textColor = .secondaryLabelColor
552
552
+
label.maximumNumberOfLines = 1
553
553
+
label.lineBreakMode = .byTruncatingTail
554
554
+
}
555
555
+
layoutHintLabel.alignment = .left
556
556
+
focusHintLabel.alignment = .right
386
557
updateShortcutHint()
387
558
388
388
-
let closeConfig = NSImage.SymbolConfiguration(pointSize: 12, weight: .semibold)
389
389
-
closeButton.image = NSImage(systemSymbolName: "xmark", accessibilityDescription: "Close")?
390
390
-
.withSymbolConfiguration(closeConfig)
391
391
-
closeButton.isBordered = false
392
392
-
closeButton.imagePosition = .imageOnly
393
393
-
closeButton.contentTintColor = .secondaryLabelColor
394
394
-
closeButton.toolTip = "Close"
395
395
-
closeButton.target = self
396
396
-
closeButton.action = #selector(closeClicked(_:))
559
559
+
configureCornerButton(
560
560
+
closeButton,
561
561
+
symbolName: "xmark",
562
562
+
toolTip: "Close",
563
563
+
action: #selector(closeClicked(_:))
564
564
+
)
565
565
+
configureCornerButton(
566
566
+
dockButton,
567
567
+
symbolName: "menubar.dock.rectangle",
568
568
+
toolTip: "Dock Below Menubar Piano",
569
569
+
action: #selector(dockClicked(_:))
570
570
+
)
571
571
+
configureCornerButton(
572
572
+
expandCollapseButton,
573
573
+
symbolName: "square.resize.down",
574
574
+
toolTip: "Collapse",
575
575
+
action: #selector(expandCollapseClicked(_:))
576
576
+
)
577
577
+
updateExpandCollapseButton()
397
578
addSubview(closeButton)
579
579
+
addSubview(dockButton)
580
580
+
addSubview(expandCollapseButton)
581
581
+
installLiquidGlassBackgrounds()
398
582
399
583
let keyboardSize = self.keyboardSize()
400
584
let waveformHeightConstraint = waveformView.heightAnchor.constraint(
···
407
591
NSLayoutConstraint.activate([
408
592
widthAnchor.constraint(equalToConstant: keyboardSize.width + inset * 2),
409
593
410
410
-
closeButton.topAnchor.constraint(equalTo: topAnchor, constant: inset),
411
411
-
closeButton.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -inset),
412
412
-
closeButton.widthAnchor.constraint(equalToConstant: closeSize),
413
413
-
closeButton.heightAnchor.constraint(equalToConstant: closeSize),
594
594
+
contentStack.topAnchor.constraint(equalTo: topAnchor, constant: inset),
595
595
+
contentStack.leadingAnchor.constraint(equalTo: leadingAnchor, constant: inset),
596
596
+
contentStack.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -inset),
597
597
+
contentStack.bottomAnchor.constraint(equalTo: bottomAnchor, constant: -inset),
598
598
+
599
599
+
waveformSection.leadingAnchor.constraint(equalTo: contentStack.leadingAnchor),
600
600
+
waveformSection.trailingAnchor.constraint(equalTo: contentStack.trailingAnchor),
601
601
+
602
602
+
closeButton.topAnchor.constraint(
603
603
+
equalTo: topAnchor,
604
604
+
constant: Self.panelCornerRadius - closeButtonSize / 2 + closeButtonCornerInset
605
605
+
),
606
606
+
closeButton.leadingAnchor.constraint(
607
607
+
equalTo: leadingAnchor,
608
608
+
constant: Self.panelCornerRadius - closeButtonSize / 2 + closeButtonCornerInset
609
609
+
),
610
610
+
closeButton.widthAnchor.constraint(equalToConstant: closeButtonSize),
611
611
+
closeButton.heightAnchor.constraint(equalToConstant: closeButtonSize),
414
612
415
415
-
dragHandle.leadingAnchor.constraint(equalTo: leadingAnchor, constant: inset),
416
416
-
dragHandle.trailingAnchor.constraint(equalTo: closeButton.leadingAnchor, constant: -gap),
417
417
-
dragHandle.centerYAnchor.constraint(equalTo: closeButton.centerYAnchor),
418
418
-
dragHandle.heightAnchor.constraint(equalToConstant: closeSize),
613
613
+
expandCollapseButton.topAnchor.constraint(equalTo: closeButton.topAnchor),
614
614
+
expandCollapseButton.trailingAnchor.constraint(
615
615
+
equalTo: trailingAnchor,
616
616
+
constant: -(Self.panelCornerRadius - closeButtonSize / 2 + closeButtonCornerInset)
617
617
+
),
618
618
+
expandCollapseButton.widthAnchor.constraint(equalToConstant: closeButtonSize),
619
619
+
expandCollapseButton.heightAnchor.constraint(equalToConstant: closeButtonSize),
620
620
+
621
621
+
dockButton.topAnchor.constraint(equalTo: closeButton.topAnchor),
622
622
+
dockButton.trailingAnchor.constraint(equalTo: expandCollapseButton.leadingAnchor, constant: -gap),
623
623
+
dockButton.widthAnchor.constraint(equalToConstant: closeButtonSize),
624
624
+
dockButton.heightAnchor.constraint(equalToConstant: closeButtonSize),
419
625
420
626
heldNotesStack.centerXAnchor.constraint(equalTo: heldNotesRow.centerXAnchor),
421
627
heldNotesStack.centerYAnchor.constraint(equalTo: heldNotesRow.centerYAnchor),
···
429
635
chordCandidatesStack.trailingAnchor.constraint(lessThanOrEqualTo: chordCandidatesRow.trailingAnchor, constant: -6),
430
636
chordCandidatesRow.heightAnchor.constraint(equalToConstant: chordCandidatesRowHeight),
431
637
432
432
-
waveformBezel.topAnchor.constraint(equalTo: closeButton.bottomAnchor, constant: gap),
433
433
-
waveformBezel.leadingAnchor.constraint(equalTo: leadingAnchor, constant: inset),
434
434
-
waveformBezel.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -inset),
435
435
-
waveformView.leadingAnchor.constraint(equalTo: waveformBezel.leadingAnchor, constant: bezelInset),
436
436
-
waveformView.trailingAnchor.constraint(equalTo: waveformBezel.trailingAnchor, constant: -bezelInset),
437
437
-
waveformView.topAnchor.constraint(equalTo: waveformBezel.topAnchor, constant: bezelInset),
438
438
-
waveformView.bottomAnchor.constraint(equalTo: waveformBezel.bottomAnchor, constant: -bezelInset),
638
638
+
waveformBezel.topAnchor.constraint(equalTo: waveformSection.topAnchor, constant: bezelInset),
639
639
+
waveformBezel.leadingAnchor.constraint(equalTo: waveformSection.leadingAnchor, constant: bezelInset),
640
640
+
waveformBezel.trailingAnchor.constraint(equalTo: waveformSection.trailingAnchor, constant: -bezelInset),
641
641
+
waveformClipView.leadingAnchor.constraint(equalTo: waveformBezel.leadingAnchor, constant: bezelInset),
642
642
+
waveformClipView.trailingAnchor.constraint(equalTo: waveformBezel.trailingAnchor, constant: -bezelInset),
643
643
+
waveformClipView.topAnchor.constraint(equalTo: waveformBezel.topAnchor, constant: bezelInset),
644
644
+
waveformClipView.bottomAnchor.constraint(equalTo: waveformBezel.bottomAnchor, constant: -bezelInset),
645
645
+
waveformView.leadingAnchor.constraint(equalTo: waveformClipView.leadingAnchor),
646
646
+
waveformView.trailingAnchor.constraint(equalTo: waveformClipView.trailingAnchor),
647
647
+
waveformView.topAnchor.constraint(equalTo: waveformClipView.topAnchor),
648
648
+
waveformView.bottomAnchor.constraint(equalTo: waveformClipView.bottomAnchor),
439
649
waveformHeightConstraint,
440
650
441
651
heldNotesRow.leadingAnchor.constraint(equalTo: waveformBezel.leadingAnchor),
···
446
656
chordCandidatesRow.trailingAnchor.constraint(equalTo: waveformBezel.trailingAnchor),
447
657
chordCandidatesRow.bottomAnchor.constraint(equalTo: waveformBezel.bottomAnchor, constant: -8),
448
658
449
449
-
instrumentTitleRow.topAnchor.constraint(equalTo: waveformBezel.bottomAnchor, constant: gap),
450
450
-
instrumentTitleRow.leadingAnchor.constraint(equalTo: leadingAnchor, constant: inset),
451
451
-
instrumentTitleRow.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -inset),
659
659
+
instrumentTitleRow.topAnchor.constraint(equalTo: waveformBezel.bottomAnchor, constant: 6),
660
660
+
instrumentTitleRow.leadingAnchor.constraint(equalTo: waveformSection.leadingAnchor, constant: 6),
661
661
+
instrumentTitleRow.trailingAnchor.constraint(equalTo: waveformSection.trailingAnchor, constant: -6),
662
662
+
instrumentTitleRow.bottomAnchor.constraint(equalTo: waveformSection.bottomAnchor, constant: -6),
663
663
+
664
664
+
pianoView.leadingAnchor.constraint(equalTo: contentStack.leadingAnchor),
665
665
+
pianoView.trailingAnchor.constraint(equalTo: contentStack.trailingAnchor),
452
666
453
453
-
pianoView.topAnchor.constraint(equalTo: instrumentTitleRow.bottomAnchor, constant: gap),
454
454
-
pianoView.leadingAnchor.constraint(equalTo: leadingAnchor, constant: inset),
455
455
-
pianoView.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -inset),
667
667
+
shortcutHintRow.leadingAnchor.constraint(equalTo: contentStack.leadingAnchor),
668
668
+
shortcutHintRow.trailingAnchor.constraint(equalTo: contentStack.trailingAnchor),
669
669
+
shortcutHintRow.heightAnchor.constraint(equalToConstant: hintHeight),
456
670
457
457
-
qwertyView.topAnchor.constraint(equalTo: pianoView.bottomAnchor, constant: gap),
458
671
qwertyView.centerXAnchor.constraint(equalTo: centerXAnchor),
459
672
qwertyView.widthAnchor.constraint(
460
673
equalToConstant: QwertyLayoutView.intrinsicSize.width * 1.4
···
462
675
qwertyView.heightAnchor.constraint(
463
676
equalToConstant: QwertyLayoutView.intrinsicSize.height * 1.4
464
677
),
465
465
-
466
466
-
shortcutHintLabel.topAnchor.constraint(equalTo: qwertyView.bottomAnchor, constant: gap),
467
467
-
shortcutHintLabel.leadingAnchor.constraint(equalTo: leadingAnchor, constant: inset),
468
468
-
shortcutHintLabel.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -inset),
469
469
-
shortcutHintLabel.heightAnchor.constraint(equalToConstant: hintHeight),
470
470
-
shortcutHintLabel.bottomAnchor.constraint(equalTo: bottomAnchor, constant: -inset)
471
678
])
472
679
if titleSpacers.count == 3 {
473
680
titleSpacers[0].widthAnchor.constraint(equalTo: titleSpacers[2].widthAnchor).isActive = true
···
479
686
nil
480
687
}
481
688
689
689
+
private func installLiquidGlassBackgrounds() {
690
690
+
guard Self.shouldUseLiquidGlass, #available(macOS 26.0, *) else { return }
691
691
+
692
692
+
let paletteGlassView = FloatingPaletteGlassEffectView()
693
693
+
paletteGlassView.translatesAutoresizingMaskIntoConstraints = false
694
694
+
paletteGlassView.cornerRadius = Self.panelCornerRadius
695
695
+
addSubview(paletteGlassView, positioned: .below, relativeTo: waveformSection)
696
696
+
NSLayoutConstraint.activate([
697
697
+
paletteGlassView.leadingAnchor.constraint(equalTo: leadingAnchor),
698
698
+
paletteGlassView.trailingAnchor.constraint(equalTo: trailingAnchor),
699
699
+
paletteGlassView.topAnchor.constraint(equalTo: topAnchor),
700
700
+
paletteGlassView.bottomAnchor.constraint(equalTo: bottomAnchor),
701
701
+
])
702
702
+
self.paletteGlassView = paletteGlassView
703
703
+
704
704
+
self.waveformSectionGlassView = installGlassBackground(
705
705
+
matchedTo: waveformSection,
706
706
+
below: waveformSection,
707
707
+
cornerRadius: Self.sectionCornerRadius
708
708
+
)
709
709
+
self.closeButtonGlassView = installGlassBackground(
710
710
+
matchedTo: closeButton,
711
711
+
below: closeButton,
712
712
+
cornerRadius: closeButtonSize / 2
713
713
+
)
714
714
+
self.dockButtonGlassView = installGlassBackground(
715
715
+
matchedTo: dockButton,
716
716
+
below: dockButton,
717
717
+
cornerRadius: closeButtonSize / 2
718
718
+
)
719
719
+
self.expandCollapseButtonGlassView = installGlassBackground(
720
720
+
matchedTo: expandCollapseButton,
721
721
+
below: expandCollapseButton,
722
722
+
cornerRadius: closeButtonSize / 2
723
723
+
)
724
724
+
self.pianoGlassView = installGlassBackground(
725
725
+
matchedTo: pianoView,
726
726
+
below: pianoView,
727
727
+
cornerRadius: Self.sectionCornerRadius
728
728
+
)
729
729
+
self.keymapGlassView = installGlassBackground(
730
730
+
matchedTo: qwertyView,
731
731
+
below: qwertyView,
732
732
+
cornerRadius: Self.sectionCornerRadius
733
733
+
)
734
734
+
self.hintGlassView = installGlassBackground(
735
735
+
matchedTo: shortcutHintRow,
736
736
+
below: shortcutHintRow,
737
737
+
cornerRadius: Self.sectionCornerRadius
738
738
+
)
739
739
+
}
740
740
+
741
741
+
@available(macOS 26.0, *)
742
742
+
private func installGlassBackground(matchedTo target: NSView,
743
743
+
below anchor: NSView,
744
744
+
cornerRadius: CGFloat) -> NSView {
745
745
+
let glassView = FloatingPaletteGlassEffectView()
746
746
+
glassView.translatesAutoresizingMaskIntoConstraints = false
747
747
+
glassView.cornerRadius = cornerRadius
748
748
+
addSubview(glassView, positioned: .below, relativeTo: anchor)
749
749
+
NSLayoutConstraint.activate([
750
750
+
glassView.leadingAnchor.constraint(equalTo: target.leadingAnchor),
751
751
+
glassView.trailingAnchor.constraint(equalTo: target.trailingAnchor),
752
752
+
glassView.topAnchor.constraint(equalTo: target.topAnchor),
753
753
+
glassView.bottomAnchor.constraint(equalTo: target.bottomAnchor),
754
754
+
])
755
755
+
return glassView
756
756
+
}
757
757
+
482
758
override var acceptsFirstResponder: Bool { true }
483
759
760
760
+
override func updateTrackingAreas() {
761
761
+
super.updateTrackingAreas()
762
762
+
if let trackingArea {
763
763
+
removeTrackingArea(trackingArea)
764
764
+
}
765
765
+
let trackingArea = NSTrackingArea(
766
766
+
rect: bounds,
767
767
+
options: [.mouseEnteredAndExited, .activeAlways, .inVisibleRect],
768
768
+
owner: self,
769
769
+
userInfo: nil
770
770
+
)
771
771
+
addTrackingArea(trackingArea)
772
772
+
self.trackingArea = trackingArea
773
773
+
}
774
774
+
775
775
+
override func mouseEntered(with event: NSEvent) {
776
776
+
super.mouseEntered(with: event)
777
777
+
setCloseControlVisible(true)
778
778
+
onHoverChanged?(true)
779
779
+
}
780
780
+
781
781
+
override func mouseExited(with event: NSEvent) {
782
782
+
super.mouseExited(with: event)
783
783
+
setCloseControlVisible(false)
784
784
+
onHoverChanged?(false)
785
785
+
}
786
786
+
484
787
override func viewDidChangeEffectiveAppearance() {
485
788
super.viewDidChangeEffectiveAppearance()
486
789
applyAppearanceToVisualizer()
···
494
797
495
798
override func draw(_ dirtyRect: NSRect) {
496
799
super.draw(dirtyRect)
800
800
+
if Self.shouldUseLiquidGlass, #available(macOS 26.0, *) {
801
801
+
return
802
802
+
}
497
803
let background = bounds.insetBy(dx: 0.5, dy: 0.5)
498
804
let path = NSBezierPath(roundedRect: background, xRadius: 13, yRadius: 13)
499
805
NSColor.windowBackgroundColor.withAlphaComponent(0.96).setFill()
···
534
840
waveformView.alphaValue = (menuBand?.midiMode ?? false) ? 0.35 : 1.0
535
841
}
536
842
843
843
+
private func setCloseControlVisible(_ isVisible: Bool) {
844
844
+
let alpha: CGFloat = isVisible ? 1.0 : 0.0
845
845
+
NSAnimationContext.runAnimationGroup { context in
846
846
+
context.duration = 0.12
847
847
+
closeButton.animator().alphaValue = alpha
848
848
+
closeButtonGlassView?.animator().alphaValue = alpha
849
849
+
dockButton.animator().alphaValue = alpha
850
850
+
dockButtonGlassView?.animator().alphaValue = alpha
851
851
+
expandCollapseButton.animator().alphaValue = alpha
852
852
+
expandCollapseButtonGlassView?.animator().alphaValue = alpha
853
853
+
}
854
854
+
}
855
855
+
537
856
private func applyAppearanceToVisualizer() {
538
857
let isDark = effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua
539
858
waveformView.setLightMode(!isDark)
540
859
if isDark {
541
541
-
waveformBezel.layer?.backgroundColor = NSColor(white: 0.06, alpha: 1.0).cgColor
860
860
+
waveformSection.layer?.backgroundColor = NSColor.white.withAlphaComponent(0.06).cgColor
861
861
+
waveformBezel.layer?.backgroundColor = NSColor.white.withAlphaComponent(0.04).cgColor
542
862
} else {
543
543
-
waveformBezel.layer?.backgroundColor = NSColor(white: 0.82, alpha: 1.0).cgColor
863
863
+
waveformSection.layer?.backgroundColor = NSColor.white.withAlphaComponent(0.22).cgColor
864
864
+
waveformBezel.layer?.backgroundColor = NSColor.white.withAlphaComponent(0.18).cgColor
544
865
}
545
866
}
546
867
547
868
private func applyWaveformTint() {
548
869
guard let menuBand else { return }
870
870
+
let paletteTint: NSColor
549
871
if menuBand.midiMode {
550
872
waveformView.setDotMatrix(MenuBandPopoverViewController.midiDotPattern)
551
873
waveformView.setBaseColor(.controlAccentColor)
552
552
-
waveformBezel.layer?.borderColor = NSColor.controlAccentColor
553
553
-
.withAlphaComponent(0.55).cgColor
874
874
+
waveformSection.layer?.borderColor = NSColor.controlAccentColor
875
875
+
.withAlphaComponent(0.24).cgColor
876
876
+
paletteTint = NSColor.controlAccentColor.withAlphaComponent(0.20)
554
877
} else {
555
878
waveformView.setDotMatrix(nil)
556
879
let safe = max(0, min(127, Int(menuBand.effectiveMelodicProgram)))
557
880
let familyColor = InstrumentListView.colorForProgram(safe)
558
881
waveformView.setBaseColor(familyColor)
559
559
-
waveformBezel.layer?.borderColor = familyColor
560
560
-
.withAlphaComponent(0.55).cgColor
882
882
+
waveformSection.layer?.borderColor = familyColor
883
883
+
.withAlphaComponent(0.22).cgColor
884
884
+
paletteTint = familyColor.withAlphaComponent(0.16)
885
885
+
}
886
886
+
if #available(macOS 26.0, *) {
887
887
+
for view in [paletteGlassView, waveformSectionGlassView, pianoGlassView, keymapGlassView, hintGlassView] {
888
888
+
(view as? NSGlassEffectView)?.tintColor = paletteTint
889
889
+
}
890
890
+
for view in [closeButtonGlassView, dockButtonGlassView, expandCollapseButtonGlassView] {
891
891
+
(view as? NSGlassEffectView)?.style = .clear
892
892
+
(view as? NSGlassEffectView)?.tintColor = paletteTint.withAlphaComponent(0.34)
893
893
+
}
894
894
+
for button in [closeButton, dockButton, expandCollapseButton] {
895
895
+
button.layer?.backgroundColor = NSColor.clear.cgColor
896
896
+
button.layer?.borderColor = NSColor.clear.cgColor
897
897
+
}
898
898
+
} else {
899
899
+
for button in [closeButton, dockButton, expandCollapseButton] {
900
900
+
button.layer?.backgroundColor = NSColor.windowBackgroundColor
901
901
+
.withAlphaComponent(0.22)
902
902
+
.cgColor
903
903
+
button.layer?.borderColor = NSColor.white.withAlphaComponent(0.28).cgColor
904
904
+
}
561
905
}
562
906
}
563
907
···
693
1037
}
694
1038
695
1039
private func updateShortcutHint() {
696
696
-
let floatingShortcut = MenuBandShortcutPreferences.playPaletteShortcut.displayString
697
1040
let focusShortcut = MenuBandShortcutPreferences.focusShortcut.displayString
698
1041
let layoutShortcut = MenuBandShortcut.layoutToggle.displayString
699
699
-
let focusText = (isPianoFocusActive?() ?? false)
700
700
-
? "Exit focus: \(focusShortcut)"
701
701
-
: "Focus piano: \(focusShortcut)"
702
702
-
shortcutHintLabel.stringValue =
703
703
-
"Show/hide floating piano: \(floatingShortcut)\n\(focusText) Toggle layout: \(layoutShortcut)"
1042
1042
+
layoutHintLabel.stringValue = "Toggle Layout: \(layoutShortcut)"
1043
1043
+
focusHintLabel.stringValue = (isPianoFocusActive?() ?? false)
1044
1044
+
? "Exit Focus: \(focusShortcut)"
1045
1045
+
: "Focus Piano: \(focusShortcut)"
704
1046
}
705
1047
706
1048
@objc private func closeClicked(_ sender: NSButton) {
707
1049
onClose?()
1050
1050
+
}
1051
1051
+
1052
1052
+
@objc private func dockClicked(_ sender: NSButton) {
1053
1053
+
NSSound.beep()
1054
1054
+
}
1055
1055
+
1056
1056
+
@objc private func expandCollapseClicked(_ sender: NSButton) {
1057
1057
+
onExpandCollapseToggle?()
1058
1058
+
}
1059
1059
+
1060
1060
+
private func configureCornerButton(_ button: NSButton,
1061
1061
+
symbolName: String,
1062
1062
+
toolTip: String,
1063
1063
+
action: Selector) {
1064
1064
+
let config = NSImage.SymbolConfiguration(pointSize: 12, weight: .semibold)
1065
1065
+
button.image = NSImage(systemSymbolName: symbolName, accessibilityDescription: toolTip)?
1066
1066
+
.withSymbolConfiguration(config)
1067
1067
+
button.isBordered = false
1068
1068
+
button.imagePosition = .imageOnly
1069
1069
+
button.contentTintColor = .white.withAlphaComponent(0.92)
1070
1070
+
button.toolTip = toolTip
1071
1071
+
button.target = self
1072
1072
+
button.action = action
1073
1073
+
button.alphaValue = 0
1074
1074
+
button.wantsLayer = true
1075
1075
+
button.layer?.cornerRadius = closeButtonSize / 2
1076
1076
+
button.layer?.borderWidth = 1
1077
1077
+
if #available(macOS 10.15, *) {
1078
1078
+
button.layer?.cornerCurve = .continuous
1079
1079
+
}
1080
1080
+
}
1081
1081
+
1082
1082
+
private func updateExpandCollapseButton() {
1083
1083
+
let symbolName = isExpanded ? "square.resize.down" : "square.resize.up"
1084
1084
+
let toolTip = isExpanded ? "Collapse" : "Expand"
1085
1085
+
let config = NSImage.SymbolConfiguration(pointSize: 12, weight: .semibold)
1086
1086
+
expandCollapseButton.image = NSImage(systemSymbolName: symbolName, accessibilityDescription: toolTip)?
1087
1087
+
.withSymbolConfiguration(config)
1088
1088
+
expandCollapseButton.toolTip = toolTip
708
1089
}
709
1090
}
710
1091
+10
slab/menuband/Sources/MenuBand/MenuBandController.swift
+10
slab/menuband/Sources/MenuBand/MenuBandController.swift
···
404
404
onInstrumentVisualChange?()
405
405
}
406
406
407
407
+
func stepMelodicProgram(delta: Int) {
408
408
+
let next = max(0, min(127, Int(melodicProgram) + delta))
409
409
+
guard next != Int(melodicProgram) else { return }
410
410
+
setMelodicProgram(UInt8(next))
411
411
+
}
412
412
+
413
413
+
func stepOctave(delta: Int) {
414
414
+
octaveStepOnce(delta: delta)
415
415
+
}
416
416
+
407
417
// MARK: - Instrument backend (GM vs GarageBand)
408
418
409
419
enum InstrumentBackend: String { case gm, garageBand = "gb" }
+1496
-67
slab/menuband/Sources/MenuBand/MenuBarWaveformStrip.swift
+1496
-67
slab/menuband/Sources/MenuBand/MenuBarWaveformStrip.swift
···
1
1
import AppKit
2
2
3
3
+
private enum StripVisualStyleOverride: String {
4
4
+
case automatic
5
5
+
case liquid
6
6
+
case legacy
7
7
+
8
8
+
init(rawValue: String?) {
9
9
+
switch rawValue?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() {
10
10
+
case Self.liquid.rawValue:
11
11
+
self = .liquid
12
12
+
case Self.legacy.rawValue:
13
13
+
self = .legacy
14
14
+
default:
15
15
+
self = .automatic
16
16
+
}
17
17
+
}
18
18
+
}
19
19
+
20
20
+
private final class LegacyMenuBarWaveformStripPanel: NSPanel {
21
21
+
var onDragBegan: (() -> Void)?
22
22
+
var onDragMoved: ((NSPoint) -> Void)?
23
23
+
var onDragEnded: (() -> Void)?
24
24
+
25
25
+
private var dragStartMouseLocation: NSPoint?
26
26
+
private var dragStartOrigin: NSPoint = .zero
27
27
+
private var isDraggingStrip = false
28
28
+
29
29
+
override func sendEvent(_ event: NSEvent) {
30
30
+
switch event.type {
31
31
+
case .leftMouseDown:
32
32
+
if event.clickCount == 1 {
33
33
+
dragStartMouseLocation = convertToScreen(
34
34
+
NSRect(origin: event.locationInWindow, size: .zero)
35
35
+
).origin
36
36
+
dragStartOrigin = frame.origin
37
37
+
isDraggingStrip = false
38
38
+
}
39
39
+
case .leftMouseDragged:
40
40
+
guard let startMouseLocation = dragStartMouseLocation else { break }
41
41
+
let current = convertToScreen(
42
42
+
NSRect(origin: event.locationInWindow, size: .zero)
43
43
+
).origin
44
44
+
let deltaX = current.x - startMouseLocation.x
45
45
+
let deltaY = current.y - startMouseLocation.y
46
46
+
if !isDraggingStrip {
47
47
+
isDraggingStrip = true
48
48
+
onDragBegan?()
49
49
+
}
50
50
+
onDragMoved?(NSPoint(x: dragStartOrigin.x + deltaX, y: dragStartOrigin.y + deltaY))
51
51
+
case .leftMouseUp:
52
52
+
dragStartMouseLocation = nil
53
53
+
if isDraggingStrip {
54
54
+
isDraggingStrip = false
55
55
+
onDragEnded?()
56
56
+
}
57
57
+
default:
58
58
+
break
59
59
+
}
60
60
+
super.sendEvent(event)
61
61
+
}
62
62
+
}
63
63
+
64
64
+
private final class LegacyMenuBarWaveformStrip: NSObject, MenuBarWaveformStripImplementation {
65
65
+
private let menuBand: MenuBandController
66
66
+
private let waveformView = WaveformView()
67
67
+
private let waveformBezel = NSView()
68
68
+
private var waveformBezelHeightConstraint: NSLayoutConstraint?
69
69
+
private let instrumentArrows = ArrowKeysIndicator()
70
70
+
private let instrumentRowContainer = NSView()
71
71
+
private let instrumentLabel = NSTextField(labelWithString: "")
72
72
+
private let closeButton = NSButton()
73
73
+
private let dockButton = NSButton()
74
74
+
private let expandButton = NSButton()
75
75
+
private let heldNotesContainer = NSView()
76
76
+
private let heldNotesStack = NSStackView()
77
77
+
private var panel: NSPanel?
78
78
+
private weak var statusButton: NSStatusBarButton?
79
79
+
private var isPointerInsideStrip = false
80
80
+
var onStepBackward: (() -> Void)?
81
81
+
var onStepForward: (() -> Void)?
82
82
+
var onStepUp: (() -> Void)?
83
83
+
var onStepDown: (() -> Void)?
84
84
+
var onExpandRequested: (() -> Void)?
85
85
+
86
86
+
private let hideDelay: TimeInterval = 2.0
87
87
+
private var hideWorkItem: DispatchWorkItem?
88
88
+
private let customOriginXKey = "notepat.waveformStrip.customOriginX"
89
89
+
private let customOriginYKey = "notepat.waveformStrip.customOriginY"
90
90
+
private var customOrigin: NSPoint?
91
91
+
92
92
+
private static let waveformAspectRatio: CGFloat = InstrumentListView.preferredWidth / 64
93
93
+
private static let controlButtonSize: CGFloat = 20
94
94
+
private static let footerHeight: CGFloat = 46
95
95
+
private static let heldNotesRowHeight: CGFloat = 14
96
96
+
private static let instrumentRowHeight: CGFloat = 22
97
97
+
private static let fadeInDuration: TimeInterval = 0.18
98
98
+
private static let fadeOutDuration: TimeInterval = 0.18
99
99
+
private static let stripLevel = NSWindow.Level(rawValue: NSWindow.Level.mainMenu.rawValue - 1)
100
100
+
101
101
+
private var slideLink: CVDisplayLink?
102
102
+
private var slideStartTime: CFTimeInterval = 0
103
103
+
private var slideFromY: CGFloat = 0
104
104
+
private var slideToY: CGFloat = 0
105
105
+
private var slideCompletion: (() -> Void)?
106
106
+
private var isSliding = false
107
107
+
108
108
+
var isShown: Bool { panel?.isVisible == true }
109
109
+
var isDocked: Bool { customOrigin == nil }
110
110
+
111
111
+
var suppressed: Bool = false {
112
112
+
didSet {
113
113
+
guard suppressed != oldValue else { return }
114
114
+
if suppressed { hide(animated: false) }
115
115
+
}
116
116
+
}
117
117
+
118
118
+
init(menuBand: MenuBandController) {
119
119
+
self.menuBand = menuBand
120
120
+
super.init()
121
121
+
customOrigin = loadCustomOrigin()
122
122
+
waveformView.menuBand = menuBand
123
123
+
waveformView.setSurfaceStyle(.standard)
124
124
+
waveformBezel.wantsLayer = true
125
125
+
waveformBezel.layer?.cornerRadius = 6
126
126
+
waveformBezel.layer?.backgroundColor = NSColor(white: 0.06, alpha: 1.0).cgColor
127
127
+
waveformBezel.layer?.borderWidth = 1
128
128
+
heldNotesStack.orientation = .horizontal
129
129
+
heldNotesStack.alignment = .centerY
130
130
+
heldNotesStack.spacing = 4
131
131
+
instrumentLabel.drawsBackground = false
132
132
+
instrumentLabel.lineBreakMode = .byTruncatingTail
133
133
+
instrumentArrows.displayMode = .horizontalPair
134
134
+
instrumentArrows.toolTip = "Change instrument"
135
135
+
instrumentArrows.onClick = { [weak self] dir, isDown in
136
136
+
guard isDown else { return }
137
137
+
self?.registerArrowInput()
138
138
+
switch dir {
139
139
+
case 0: self?.onStepBackward?()
140
140
+
case 1: self?.onStepForward?()
141
141
+
default: break
142
142
+
}
143
143
+
}
144
144
+
configureControlButton(
145
145
+
closeButton,
146
146
+
symbolName: "xmark",
147
147
+
toolTip: "Close",
148
148
+
action: #selector(closeButtonClicked(_:))
149
149
+
)
150
150
+
configureControlButton(
151
151
+
dockButton,
152
152
+
symbolName: "menubar.dock.rectangle",
153
153
+
toolTip: "Dock Below Menubar Piano",
154
154
+
action: #selector(dockButtonClicked(_:))
155
155
+
)
156
156
+
configureControlButton(
157
157
+
expandButton,
158
158
+
symbolName: "square.resize.up",
159
159
+
toolTip: "Expand floating piano",
160
160
+
action: #selector(expandButtonClicked(_:))
161
161
+
)
162
162
+
}
163
163
+
164
164
+
deinit {
165
165
+
stopSlide()
166
166
+
}
167
167
+
168
168
+
private func handleStripDragBegan() {
169
169
+
cancelPendingHide()
170
170
+
stopSlide()
171
171
+
isSliding = false
172
172
+
}
173
173
+
174
174
+
private func handleStripDragEnded() {
175
175
+
if menuBand.litNotes.isEmpty {
176
176
+
scheduleHide()
177
177
+
}
178
178
+
}
179
179
+
180
180
+
private func handleStripMouseEntered() {
181
181
+
guard !isPointerInsideStrip else { return }
182
182
+
isPointerInsideStrip = true
183
183
+
setControlsVisible(true)
184
184
+
cancelPendingHide()
185
185
+
}
186
186
+
187
187
+
private func handleStripMouseExited() {
188
188
+
guard isPointerInsideStrip else { return }
189
189
+
isPointerInsideStrip = false
190
190
+
setControlsVisible(false)
191
191
+
if menuBand.litNotes.isEmpty {
192
192
+
scheduleHide()
193
193
+
}
194
194
+
}
195
195
+
196
196
+
func warmUp() {
197
197
+
if panel == nil { buildPanel() }
198
198
+
}
199
199
+
200
200
+
func showIfNeeded() {
201
201
+
guard !suppressed else { return }
202
202
+
cancelPendingHide()
203
203
+
if !isShown && !isSliding { show() }
204
204
+
}
205
205
+
206
206
+
func scheduleHide() {
207
207
+
guard !isPointerInsideStrip else { return }
208
208
+
cancelPendingHide()
209
209
+
let work = DispatchWorkItem { [weak self] in
210
210
+
self?.hide(animated: true)
211
211
+
}
212
212
+
hideWorkItem = work
213
213
+
DispatchQueue.main.asyncAfter(deadline: .now() + hideDelay, execute: work)
214
214
+
}
215
215
+
216
216
+
func dismiss() {
217
217
+
cancelPendingHide()
218
218
+
stopSlide()
219
219
+
isPointerInsideStrip = false
220
220
+
setControlsVisible(false, animated: false)
221
221
+
waveformView.isLive = false
222
222
+
panel?.orderOut(nil)
223
223
+
}
224
224
+
225
225
+
func reposition(statusItemButton: NSStatusBarButton?) {
226
226
+
statusButton = statusItemButton
227
227
+
guard let panel = panel, panel.isVisible, !isSliding else { return }
228
228
+
positionPanel(panel)
229
229
+
}
230
230
+
231
231
+
func refreshAppearance() {
232
232
+
applyAppearanceToVisualizer()
233
233
+
applyWaveformTint()
234
234
+
refreshReadout()
235
235
+
}
236
236
+
237
237
+
func registerArrowInput() {
238
238
+
guard !suppressed else { return }
239
239
+
showIfNeeded()
240
240
+
refreshReadout()
241
241
+
if menuBand.litNotes.isEmpty {
242
242
+
scheduleHide()
243
243
+
}
244
244
+
}
245
245
+
246
246
+
private func targetFrame() -> NSRect? {
247
247
+
guard let button = statusButton,
248
248
+
let buttonWindow = button.window else { return nil }
249
249
+
250
250
+
let imgSize = KeyboardIconRenderer.imageSize
251
251
+
let bb = button.bounds
252
252
+
let xOff = (bb.width - imgSize.width) / 2.0
253
253
+
254
254
+
let pianoOriginX = xOff + KeyboardIconRenderer.pad
255
255
+
let pianoWidth = imgSize.width - KeyboardIconRenderer.settingsW
256
256
+
- KeyboardIconRenderer.settingsGap - KeyboardIconRenderer.pad * 2
257
257
+
258
258
+
let localRect = NSRect(x: pianoOriginX, y: 0, width: pianoWidth, height: bb.height)
259
259
+
let windowRect = button.convert(localRect, to: nil)
260
260
+
let screenRect = buttonWindow.convertToScreen(windowRect)
261
261
+
262
262
+
let stripHeight = currentStripHeight(for: screenRect.width)
263
263
+
let anchoredFrame = NSRect(
264
264
+
x: screenRect.origin.x,
265
265
+
y: screenRect.origin.y - stripHeight,
266
266
+
width: screenRect.width,
267
267
+
height: stripHeight
268
268
+
)
269
269
+
guard let customOrigin else { return anchoredFrame }
270
270
+
return clampedFrame(
271
271
+
origin: customOrigin,
272
272
+
size: anchoredFrame.size,
273
273
+
preferredScreen: panel?.screen ?? buttonWindow.screen
274
274
+
)
275
275
+
}
276
276
+
277
277
+
private func currentWaveformBezelHeight(for width: CGFloat) -> CGFloat {
278
278
+
round(width / Self.waveformAspectRatio)
279
279
+
}
280
280
+
281
281
+
private func currentStripHeight(for width: CGFloat) -> CGFloat {
282
282
+
currentWaveformBezelHeight(for: width) + Self.footerHeight
283
283
+
}
284
284
+
285
285
+
private func loadCustomOrigin() -> NSPoint? {
286
286
+
let defaults = UserDefaults.standard
287
287
+
guard defaults.object(forKey: customOriginXKey) != nil,
288
288
+
defaults.object(forKey: customOriginYKey) != nil else { return nil }
289
289
+
return NSPoint(
290
290
+
x: defaults.double(forKey: customOriginXKey),
291
291
+
y: defaults.double(forKey: customOriginYKey)
292
292
+
)
293
293
+
}
294
294
+
295
295
+
private func saveCustomOrigin(_ origin: NSPoint) {
296
296
+
let defaults = UserDefaults.standard
297
297
+
defaults.set(origin.x, forKey: customOriginXKey)
298
298
+
defaults.set(origin.y, forKey: customOriginYKey)
299
299
+
}
300
300
+
301
301
+
private func clampedFrame(origin: NSPoint, size: NSSize, preferredScreen: NSScreen?) -> NSRect {
302
302
+
let visible = visibleFrame(for: origin, preferredScreen: preferredScreen)
303
303
+
let x = min(max(origin.x, visible.minX), visible.maxX - size.width)
304
304
+
let y = min(max(origin.y, visible.minY), visible.maxY - size.height)
305
305
+
return NSRect(origin: NSPoint(x: x, y: y), size: size)
306
306
+
}
307
307
+
308
308
+
private func visibleFrame(for origin: NSPoint, preferredScreen: NSScreen?) -> NSRect {
309
309
+
if let screen = NSScreen.screens.first(where: { $0.visibleFrame.contains(origin) }) {
310
310
+
return screen.visibleFrame
311
311
+
}
312
312
+
if let preferredScreen {
313
313
+
return preferredScreen.visibleFrame
314
314
+
}
315
315
+
return NSScreen.main?.visibleFrame ?? NSRect(x: 0, y: 0, width: 1440, height: 900)
316
316
+
}
317
317
+
318
318
+
private func moveStrip(to origin: NSPoint) {
319
319
+
guard let panel = panel else { return }
320
320
+
let frame = clampedFrame(origin: origin, size: panel.frame.size, preferredScreen: panel.screen)
321
321
+
customOrigin = frame.origin
322
322
+
saveCustomOrigin(frame.origin)
323
323
+
panel.setFrameOrigin(frame.origin)
324
324
+
}
325
325
+
326
326
+
private func resetCustomPosition() {
327
327
+
customOrigin = nil
328
328
+
let defaults = UserDefaults.standard
329
329
+
defaults.removeObject(forKey: customOriginXKey)
330
330
+
defaults.removeObject(forKey: customOriginYKey)
331
331
+
guard let panel = panel else { return }
332
332
+
positionPanel(panel)
333
333
+
}
334
334
+
335
335
+
private func show() {
336
336
+
if panel == nil { buildPanel() }
337
337
+
guard let panel = panel, let target = targetFrame() else { return }
338
338
+
339
339
+
isPointerInsideStrip = false
340
340
+
setControlsVisible(false, animated: false)
341
341
+
waveformBezelHeightConstraint?.constant = currentWaveformBezelHeight(for: target.width)
342
342
+
panel.setFrame(target, display: true)
343
343
+
isSliding = true
344
344
+
panel.alphaValue = 1.0
345
345
+
panel.alphaValue = 0.0
346
346
+
applyAppearanceToVisualizer()
347
347
+
applyWaveformTint()
348
348
+
refreshReadout()
349
349
+
waveformView.isLive = true
350
350
+
panel.orderFrontRegardless()
351
351
+
352
352
+
NSAnimationContext.runAnimationGroup { context in
353
353
+
context.duration = Self.fadeInDuration
354
354
+
context.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
355
355
+
panel.animator().alphaValue = 1.0
356
356
+
} completionHandler: { [weak self, weak panel] in
357
357
+
guard let self, let panel else { return }
358
358
+
panel.alphaValue = 1.0
359
359
+
self.isSliding = false
360
360
+
}
361
361
+
}
362
362
+
363
363
+
private func hide(animated: Bool) {
364
364
+
cancelPendingHide()
365
365
+
stopSlide()
366
366
+
guard let panel = panel, panel.isVisible else {
367
367
+
waveformView.isLive = false
368
368
+
return
369
369
+
}
370
370
+
if !animated {
371
371
+
panel.animator().alphaValue = 1.0
372
372
+
waveformView.isLive = false
373
373
+
panel.orderOut(nil)
374
374
+
return
375
375
+
}
376
376
+
NSAnimationContext.runAnimationGroup { context in
377
377
+
context.duration = Self.fadeOutDuration
378
378
+
context.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
379
379
+
panel.animator().alphaValue = 0.0
380
380
+
} completionHandler: { [weak self, weak panel] in
381
381
+
guard let self, let panel else { return }
382
382
+
self.waveformView.isLive = false
383
383
+
panel.orderOut(nil)
384
384
+
panel.alphaValue = 1.0
385
385
+
self.isSliding = false
386
386
+
}
387
387
+
}
388
388
+
389
389
+
private func startSlide(fromY: CGFloat, toY: CGFloat, completion: @escaping () -> Void) {
390
390
+
stopSlide()
391
391
+
isSliding = true
392
392
+
slideFromY = fromY
393
393
+
slideToY = toY
394
394
+
slideStartTime = CACurrentMediaTime()
395
395
+
slideCompletion = completion
396
396
+
397
397
+
var link: CVDisplayLink?
398
398
+
CVDisplayLinkCreateWithActiveCGDisplays(&link)
399
399
+
guard let link = link else {
400
400
+
panel?.setFrameOrigin(NSPoint(x: panel?.frame.origin.x ?? 0, y: toY))
401
401
+
completion()
402
402
+
return
403
403
+
}
404
404
+
let opaque = Unmanaged.passUnretained(self).toOpaque()
405
405
+
CVDisplayLinkSetOutputCallback(link, { _, _, _, _, _, ctx -> CVReturn in
406
406
+
guard let ctx = ctx else { return kCVReturnSuccess }
407
407
+
let strip = Unmanaged<LegacyMenuBarWaveformStrip>.fromOpaque(ctx).takeUnretainedValue()
408
408
+
DispatchQueue.main.async { strip.tickSlide() }
409
409
+
return kCVReturnSuccess
410
410
+
}, opaque)
411
411
+
CVDisplayLinkStart(link)
412
412
+
slideLink = link
413
413
+
}
414
414
+
415
415
+
private func tickSlide() {
416
416
+
guard isSliding, let panel = panel else {
417
417
+
stopSlide()
418
418
+
return
419
419
+
}
420
420
+
let elapsed = CACurrentMediaTime() - slideStartTime
421
421
+
let t = min(1.0, elapsed / Self.fadeInDuration)
422
422
+
let eased: CGFloat
423
423
+
if slideToY < slideFromY {
424
424
+
let f = 1.0 - t
425
425
+
eased = CGFloat(1.0 - f * f * f)
426
426
+
} else {
427
427
+
eased = CGFloat(t * t * t)
428
428
+
}
429
429
+
let currentY = slideFromY + (slideToY - slideFromY) * eased
430
430
+
panel.setFrameOrigin(NSPoint(x: panel.frame.origin.x, y: currentY))
431
431
+
432
432
+
if t >= 1.0 {
433
433
+
let completion = slideCompletion
434
434
+
stopSlide()
435
435
+
completion?()
436
436
+
}
437
437
+
}
438
438
+
439
439
+
private func stopSlide() {
440
440
+
if let link = slideLink {
441
441
+
CVDisplayLinkStop(link)
442
442
+
slideLink = nil
443
443
+
}
444
444
+
slideCompletion = nil
445
445
+
}
446
446
+
447
447
+
private func cancelPendingHide() {
448
448
+
hideWorkItem?.cancel()
449
449
+
hideWorkItem = nil
450
450
+
}
451
451
+
452
452
+
private func buildPanel() {
453
453
+
let initialWidth: CGFloat = 200
454
454
+
let p = LegacyMenuBarWaveformStripPanel(
455
455
+
contentRect: NSRect(
456
456
+
origin: .zero,
457
457
+
size: NSSize(width: initialWidth, height: currentStripHeight(for: initialWidth))
458
458
+
),
459
459
+
styleMask: [.borderless, .nonactivatingPanel],
460
460
+
backing: .buffered,
461
461
+
defer: false
462
462
+
)
463
463
+
p.isOpaque = true
464
464
+
p.backgroundColor = .black
465
465
+
p.hasShadow = true
466
466
+
p.level = Self.stripLevel
467
467
+
p.collectionBehavior = [.transient, .ignoresCycle]
468
468
+
p.hidesOnDeactivate = false
469
469
+
p.canHide = false
470
470
+
p.isMovable = false
471
471
+
p.animationBehavior = .none
472
472
+
p.acceptsMouseMovedEvents = false
473
473
+
p.onDragBegan = { [weak self] in
474
474
+
self?.handleStripDragBegan()
475
475
+
}
476
476
+
p.onDragMoved = { [weak self] origin in
477
477
+
self?.moveStrip(to: origin)
478
478
+
}
479
479
+
p.onDragEnded = { [weak self] in
480
480
+
self?.handleStripDragEnded()
481
481
+
}
482
482
+
483
483
+
waveformView.translatesAutoresizingMaskIntoConstraints = false
484
484
+
waveformBezel.translatesAutoresizingMaskIntoConstraints = false
485
485
+
instrumentArrows.translatesAutoresizingMaskIntoConstraints = false
486
486
+
instrumentRowContainer.translatesAutoresizingMaskIntoConstraints = false
487
487
+
instrumentLabel.translatesAutoresizingMaskIntoConstraints = false
488
488
+
closeButton.translatesAutoresizingMaskIntoConstraints = false
489
489
+
dockButton.translatesAutoresizingMaskIntoConstraints = false
490
490
+
expandButton.translatesAutoresizingMaskIntoConstraints = false
491
491
+
heldNotesContainer.translatesAutoresizingMaskIntoConstraints = false
492
492
+
heldNotesStack.translatesAutoresizingMaskIntoConstraints = false
493
493
+
let content = StripInteractiveSurfaceView()
494
494
+
content.onMouseEntered = { [weak self] in self?.handleStripMouseEntered() }
495
495
+
content.onMouseExited = { [weak self] in self?.handleStripMouseExited() }
496
496
+
content.wantsLayer = true
497
497
+
content.layer?.backgroundColor = NSColor.clear.cgColor
498
498
+
p.contentView = content
499
499
+
p.contentView?.addSubview(waveformBezel)
500
500
+
p.contentView?.addSubview(heldNotesContainer)
501
501
+
p.contentView?.addSubview(instrumentRowContainer)
502
502
+
p.contentView?.addSubview(closeButton)
503
503
+
p.contentView?.addSubview(dockButton)
504
504
+
p.contentView?.addSubview(expandButton)
505
505
+
instrumentRowContainer.addSubview(instrumentArrows)
506
506
+
instrumentRowContainer.addSubview(instrumentLabel)
507
507
+
heldNotesContainer.addSubview(heldNotesStack)
508
508
+
waveformBezel.addSubview(waveformView)
509
509
+
let bezelInset: CGFloat = 5
510
510
+
let waveformBezelHeightConstraint = waveformBezel.heightAnchor.constraint(
511
511
+
equalToConstant: currentWaveformBezelHeight(for: initialWidth)
512
512
+
)
513
513
+
self.waveformBezelHeightConstraint = waveformBezelHeightConstraint
514
514
+
NSLayoutConstraint.activate([
515
515
+
waveformBezel.leadingAnchor.constraint(equalTo: content.leadingAnchor),
516
516
+
waveformBezel.trailingAnchor.constraint(equalTo: content.trailingAnchor),
517
517
+
waveformBezel.topAnchor.constraint(equalTo: content.topAnchor),
518
518
+
waveformBezelHeightConstraint,
519
519
+
waveformView.leadingAnchor.constraint(equalTo: waveformBezel.leadingAnchor, constant: bezelInset),
520
520
+
waveformView.trailingAnchor.constraint(equalTo: waveformBezel.trailingAnchor, constant: -bezelInset),
521
521
+
waveformView.topAnchor.constraint(equalTo: waveformBezel.topAnchor, constant: bezelInset),
522
522
+
waveformView.bottomAnchor.constraint(equalTo: waveformBezel.bottomAnchor, constant: -bezelInset),
523
523
+
heldNotesContainer.leadingAnchor.constraint(equalTo: content.leadingAnchor),
524
524
+
heldNotesContainer.trailingAnchor.constraint(equalTo: content.trailingAnchor),
525
525
+
heldNotesContainer.topAnchor.constraint(equalTo: waveformBezel.bottomAnchor, constant: 2),
526
526
+
heldNotesContainer.heightAnchor.constraint(equalToConstant: Self.heldNotesRowHeight),
527
527
+
heldNotesStack.centerXAnchor.constraint(equalTo: heldNotesContainer.centerXAnchor),
528
528
+
heldNotesStack.centerYAnchor.constraint(equalTo: heldNotesContainer.centerYAnchor),
529
529
+
closeButton.topAnchor.constraint(equalTo: content.topAnchor, constant: 6),
530
530
+
closeButton.leadingAnchor.constraint(equalTo: content.leadingAnchor, constant: 6),
531
531
+
closeButton.widthAnchor.constraint(equalToConstant: Self.controlButtonSize),
532
532
+
closeButton.heightAnchor.constraint(equalToConstant: Self.controlButtonSize),
533
533
+
expandButton.topAnchor.constraint(equalTo: content.topAnchor, constant: 6),
534
534
+
expandButton.trailingAnchor.constraint(equalTo: content.trailingAnchor, constant: -6),
535
535
+
expandButton.widthAnchor.constraint(equalToConstant: Self.controlButtonSize),
536
536
+
expandButton.heightAnchor.constraint(equalToConstant: Self.controlButtonSize),
537
537
+
dockButton.topAnchor.constraint(equalTo: content.topAnchor, constant: 6),
538
538
+
dockButton.trailingAnchor.constraint(equalTo: expandButton.leadingAnchor, constant: -4),
539
539
+
dockButton.widthAnchor.constraint(equalToConstant: Self.controlButtonSize),
540
540
+
dockButton.heightAnchor.constraint(equalToConstant: Self.controlButtonSize),
541
541
+
instrumentRowContainer.leadingAnchor.constraint(equalTo: content.leadingAnchor),
542
542
+
instrumentRowContainer.trailingAnchor.constraint(equalTo: content.trailingAnchor),
543
543
+
instrumentRowContainer.topAnchor.constraint(equalTo: heldNotesContainer.bottomAnchor, constant: 2),
544
544
+
instrumentRowContainer.heightAnchor.constraint(equalToConstant: Self.instrumentRowHeight),
545
545
+
instrumentRowContainer.bottomAnchor.constraint(equalTo: content.bottomAnchor, constant: -2),
546
546
+
instrumentArrows.leadingAnchor.constraint(equalTo: instrumentRowContainer.leadingAnchor, constant: 4),
547
547
+
instrumentArrows.centerYAnchor.constraint(equalTo: instrumentRowContainer.centerYAnchor),
548
548
+
instrumentLabel.leadingAnchor.constraint(equalTo: instrumentArrows.trailingAnchor, constant: 4),
549
549
+
instrumentLabel.centerYAnchor.constraint(equalTo: instrumentRowContainer.centerYAnchor),
550
550
+
instrumentLabel.trailingAnchor.constraint(equalTo: instrumentRowContainer.trailingAnchor, constant: -6),
551
551
+
])
552
552
+
applyAppearanceToVisualizer()
553
553
+
applyWaveformTint()
554
554
+
refreshReadout()
555
555
+
setControlsVisible(false, animated: false)
556
556
+
557
557
+
panel = p
558
558
+
}
559
559
+
560
560
+
private func positionPanel(_ panel: NSPanel) {
561
561
+
guard let target = targetFrame() else { return }
562
562
+
waveformBezelHeightConstraint?.constant = currentWaveformBezelHeight(for: target.width)
563
563
+
panel.setFrame(target, display: true)
564
564
+
}
565
565
+
566
566
+
private func applyAppearanceToVisualizer() {
567
567
+
let isDark = NSApp.effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua
568
568
+
waveformView.setLightMode(!isDark)
569
569
+
if isDark {
570
570
+
waveformBezel.layer?.backgroundColor = NSColor(white: 0.06, alpha: 1.0).cgColor
571
571
+
instrumentLabel.textColor = .white
572
572
+
} else {
573
573
+
waveformBezel.layer?.backgroundColor = NSColor(white: 0.82, alpha: 1.0).cgColor
574
574
+
instrumentLabel.textColor = .black
575
575
+
}
576
576
+
}
577
577
+
578
578
+
private func applyWaveformTint() {
579
579
+
if menuBand.midiMode {
580
580
+
waveformView.setDotMatrix(MenuBandPopoverViewController.midiDotPattern)
581
581
+
waveformView.setBaseColor(.controlAccentColor)
582
582
+
waveformBezel.layer?.borderColor = NSColor.controlAccentColor.withAlphaComponent(0.55).cgColor
583
583
+
} else {
584
584
+
waveformView.setDotMatrix(nil)
585
585
+
let safe = max(0, min(127, Int(menuBand.effectiveMelodicProgram)))
586
586
+
let familyColor = InstrumentListView.colorForProgram(safe)
587
587
+
waveformView.setBaseColor(familyColor)
588
588
+
waveformBezel.layer?.borderColor = familyColor.withAlphaComponent(0.55).cgColor
589
589
+
}
590
590
+
for button in [closeButton, dockButton, expandButton] {
591
591
+
button.layer?.backgroundColor = NSColor.windowBackgroundColor.withAlphaComponent(0.22).cgColor
592
592
+
button.layer?.borderColor = NSColor.white.withAlphaComponent(0.28).cgColor
593
593
+
}
594
594
+
}
595
595
+
596
596
+
private func refreshReadout() {
597
597
+
let safe = max(0, min(127, Int(menuBand.effectiveMelodicProgram)))
598
598
+
let familyColor = menuBand.midiMode
599
599
+
? NSColor.controlAccentColor
600
600
+
: InstrumentListView.colorForProgram(safe)
601
601
+
let isDark = NSApp.effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua
602
602
+
let textColor: NSColor = isDark ? .white : .black
603
603
+
let shadow = NSShadow()
604
604
+
shadow.shadowColor = (familyColor.highlight(withLevel: isDark ? 0.3 : 0.7) ?? familyColor)
605
605
+
shadow.shadowOffset = NSSize(width: 1, height: -1)
606
606
+
shadow.shadowBlurRadius = 0
607
607
+
let titleFont: NSFont = {
608
608
+
if let desc = AppDelegate.ywftBoldDescriptor,
609
609
+
let f = NSFont(descriptor: desc, size: 14),
610
610
+
f.familyName == "YWFT Processing" {
611
611
+
return f
612
612
+
}
613
613
+
return NSFont.systemFont(ofSize: 14, weight: .black)
614
614
+
}()
615
615
+
instrumentLabel.attributedStringValue = NSAttributedString(
616
616
+
string: GeneralMIDI.programNames[safe],
617
617
+
attributes: [
618
618
+
.font: titleFont,
619
619
+
.foregroundColor: textColor,
620
620
+
.shadow: shadow,
621
621
+
]
622
622
+
)
623
623
+
for view in heldNotesStack.arrangedSubviews {
624
624
+
heldNotesStack.removeArrangedSubview(view)
625
625
+
view.removeFromSuperview()
626
626
+
}
627
627
+
for name in menuBand.heldNoteNames() {
628
628
+
heldNotesStack.addArrangedSubview(makeHeldNoteBox(name: name, color: familyColor))
629
629
+
}
630
630
+
}
631
631
+
632
632
+
private func makeHeldNoteBox(name: String, color: NSColor) -> NSView {
633
633
+
let box = NSView()
634
634
+
box.wantsLayer = true
635
635
+
box.layer?.cornerRadius = 4
636
636
+
box.layer?.backgroundColor = color.withAlphaComponent(0.85).cgColor
637
637
+
box.translatesAutoresizingMaskIntoConstraints = false
638
638
+
let label = NSTextField(labelWithString: name)
639
639
+
label.font = NSFont.monospacedSystemFont(ofSize: 9, weight: .heavy)
640
640
+
label.textColor = .black
641
641
+
label.drawsBackground = false
642
642
+
label.translatesAutoresizingMaskIntoConstraints = false
643
643
+
box.addSubview(label)
644
644
+
NSLayoutConstraint.activate([
645
645
+
label.leadingAnchor.constraint(equalTo: box.leadingAnchor, constant: 5),
646
646
+
label.trailingAnchor.constraint(equalTo: box.trailingAnchor, constant: -5),
647
647
+
label.topAnchor.constraint(equalTo: box.topAnchor, constant: 1),
648
648
+
label.bottomAnchor.constraint(equalTo: box.bottomAnchor, constant: -1),
649
649
+
])
650
650
+
return box
651
651
+
}
652
652
+
653
653
+
private func configureControlButton(_ button: NSButton,
654
654
+
symbolName: String,
655
655
+
toolTip: String,
656
656
+
action: Selector) {
657
657
+
let config = NSImage.SymbolConfiguration(pointSize: 10, weight: .semibold)
658
658
+
button.image = NSImage(
659
659
+
systemSymbolName: symbolName,
660
660
+
accessibilityDescription: toolTip
661
661
+
)?.withSymbolConfiguration(config)
662
662
+
button.isBordered = false
663
663
+
button.setButtonType(.momentaryChange)
664
664
+
button.imagePosition = .imageOnly
665
665
+
button.contentTintColor = .white.withAlphaComponent(0.92)
666
666
+
button.toolTip = toolTip
667
667
+
button.target = self
668
668
+
button.action = action
669
669
+
button.alphaValue = 0
670
670
+
button.wantsLayer = true
671
671
+
button.layer?.cornerRadius = CGFloat(Self.controlButtonSize) / 2
672
672
+
button.layer?.borderWidth = 1
673
673
+
}
674
674
+
675
675
+
@objc private func closeButtonClicked(_ sender: NSButton) {
676
676
+
dismiss()
677
677
+
}
678
678
+
679
679
+
@objc private func dockButtonClicked(_ sender: NSButton) {
680
680
+
resetCustomPosition()
681
681
+
}
682
682
+
683
683
+
@objc private func expandButtonClicked(_ sender: NSButton) {
684
684
+
onExpandRequested?()
685
685
+
}
686
686
+
687
687
+
private func setControlsVisible(_ isVisible: Bool, animated: Bool = true) {
688
688
+
let alpha: CGFloat = isVisible ? 1.0 : 0.0
689
689
+
if animated {
690
690
+
NSAnimationContext.runAnimationGroup { context in
691
691
+
context.duration = 0.12
692
692
+
closeButton.animator().alphaValue = alpha
693
693
+
dockButton.animator().alphaValue = alpha
694
694
+
expandButton.animator().alphaValue = alpha
695
695
+
}
696
696
+
} else {
697
697
+
closeButton.alphaValue = alpha
698
698
+
dockButton.alphaValue = alpha
699
699
+
expandButton.alphaValue = alpha
700
700
+
}
701
701
+
}
702
702
+
}
703
703
+
704
704
+
final class MenuBarWaveformStrip {
705
705
+
private let implementation: any MenuBarWaveformStripImplementation
706
706
+
707
707
+
var onStepBackward: (() -> Void)? {
708
708
+
get { implementation.onStepBackward }
709
709
+
set { implementation.onStepBackward = newValue }
710
710
+
}
711
711
+
712
712
+
var onStepForward: (() -> Void)? {
713
713
+
get { implementation.onStepForward }
714
714
+
set { implementation.onStepForward = newValue }
715
715
+
}
716
716
+
717
717
+
var onStepUp: (() -> Void)? {
718
718
+
get { implementation.onStepUp }
719
719
+
set { implementation.onStepUp = newValue }
720
720
+
}
721
721
+
722
722
+
var onStepDown: (() -> Void)? {
723
723
+
get { implementation.onStepDown }
724
724
+
set { implementation.onStepDown = newValue }
725
725
+
}
726
726
+
727
727
+
var onExpandRequested: (() -> Void)? {
728
728
+
get { implementation.onExpandRequested }
729
729
+
set { implementation.onExpandRequested = newValue }
730
730
+
}
731
731
+
732
732
+
var isDocked: Bool { implementation.isDocked }
733
733
+
734
734
+
var suppressed: Bool {
735
735
+
get { implementation.suppressed }
736
736
+
set { implementation.suppressed = newValue }
737
737
+
}
738
738
+
739
739
+
init(menuBand: MenuBandController) {
740
740
+
switch resolvedStripVisualStyle() {
741
741
+
case .liquid:
742
742
+
implementation = LiquidMenuBarWaveformStrip(menuBand: menuBand)
743
743
+
case .legacy:
744
744
+
implementation = LegacyMenuBarWaveformStrip(menuBand: menuBand)
745
745
+
}
746
746
+
}
747
747
+
748
748
+
func warmUp() {
749
749
+
implementation.warmUp()
750
750
+
}
751
751
+
752
752
+
func showIfNeeded() {
753
753
+
implementation.showIfNeeded()
754
754
+
}
755
755
+
756
756
+
func scheduleHide() {
757
757
+
implementation.scheduleHide()
758
758
+
}
759
759
+
760
760
+
func dismiss() {
761
761
+
implementation.dismiss()
762
762
+
}
763
763
+
764
764
+
func reposition(statusItemButton: NSStatusBarButton?) {
765
765
+
implementation.reposition(statusItemButton: statusItemButton)
766
766
+
}
767
767
+
768
768
+
func refreshAppearance() {
769
769
+
implementation.refreshAppearance()
770
770
+
}
771
771
+
772
772
+
func registerArrowInput() {
773
773
+
implementation.registerArrowInput()
774
774
+
}
775
775
+
}
776
776
+
777
777
+
private enum ResolvedStripVisualStyle {
778
778
+
case liquid
779
779
+
case legacy
780
780
+
}
781
781
+
782
782
+
private let stripStyleDefaultsDomain = "computer.aestheticcomputer.menuband"
783
783
+
private let stripStyleDefaultsKey = "MenuBandWaveformStripStyle"
784
784
+
private let stripStyleEnvironmentKey = "MENUBAND_WAVEFORM_STRIP_STYLE"
785
785
+
786
786
+
private func resolvedStripVisualStyle() -> ResolvedStripVisualStyle {
787
787
+
let environmentValue = ProcessInfo.processInfo.environment[stripStyleEnvironmentKey]
788
788
+
let defaultsValue = UserDefaults(suiteName: stripStyleDefaultsDomain)?.string(forKey: stripStyleDefaultsKey)
789
789
+
?? UserDefaults.standard.string(forKey: stripStyleDefaultsKey)
790
790
+
let override = StripVisualStyleOverride(rawValue: environmentValue ?? defaultsValue)
791
791
+
switch override {
792
792
+
case .liquid:
793
793
+
if #available(macOS 26.0, *) {
794
794
+
return .liquid
795
795
+
}
796
796
+
return .legacy
797
797
+
case .legacy:
798
798
+
return .legacy
799
799
+
case .automatic:
800
800
+
if #available(macOS 26.0, *) {
801
801
+
return .liquid
802
802
+
}
803
803
+
return .legacy
804
804
+
}
805
805
+
}
806
806
+
807
807
+
private protocol MenuBarWaveformStripImplementation: AnyObject {
808
808
+
var onStepBackward: (() -> Void)? { get set }
809
809
+
var onStepForward: (() -> Void)? { get set }
810
810
+
var onStepUp: (() -> Void)? { get set }
811
811
+
var onStepDown: (() -> Void)? { get set }
812
812
+
var onExpandRequested: (() -> Void)? { get set }
813
813
+
var isDocked: Bool { get }
814
814
+
var suppressed: Bool { get set }
815
815
+
func warmUp()
816
816
+
func showIfNeeded()
817
817
+
func scheduleHide()
818
818
+
func dismiss()
819
819
+
func reposition(statusItemButton: NSStatusBarButton?)
820
820
+
func refreshAppearance()
821
821
+
func registerArrowInput()
822
822
+
}
823
823
+
824
824
+
private final class StripDragHandleView: NSView {
825
825
+
var onResetRequested: (() -> Void)?
826
826
+
827
827
+
private let imageView = NSImageView()
828
828
+
override init(frame frameRect: NSRect) {
829
829
+
super.init(frame: frameRect)
830
830
+
translatesAutoresizingMaskIntoConstraints = false
831
831
+
toolTip = "Double-click to re-dock."
832
832
+
imageView.translatesAutoresizingMaskIntoConstraints = false
833
833
+
imageView.imageScaling = .scaleProportionallyUpOrDown
834
834
+
imageView.image = NSImage(
835
835
+
systemSymbolName: "move.3d",
836
836
+
accessibilityDescription: "Drag strip"
837
837
+
)?.withSymbolConfiguration(.init(pointSize: 10, weight: .semibold))
838
838
+
addSubview(imageView)
839
839
+
NSLayoutConstraint.activate([
840
840
+
widthAnchor.constraint(equalToConstant: 14),
841
841
+
heightAnchor.constraint(equalToConstant: 14),
842
842
+
imageView.centerXAnchor.constraint(equalTo: centerXAnchor),
843
843
+
imageView.centerYAnchor.constraint(equalTo: centerYAnchor),
844
844
+
])
845
845
+
}
846
846
+
847
847
+
required init?(coder: NSCoder) { fatalError() }
848
848
+
849
849
+
override func viewDidChangeEffectiveAppearance() {
850
850
+
super.viewDidChangeEffectiveAppearance()
851
851
+
imageView.contentTintColor = .secondaryLabelColor
852
852
+
}
853
853
+
854
854
+
override func mouseDown(with event: NSEvent) {
855
855
+
if event.clickCount == 2 {
856
856
+
onResetRequested?()
857
857
+
}
858
858
+
}
859
859
+
}
860
860
+
861
861
+
private class StripInteractiveSurfaceView: NSView {
862
862
+
var onMouseEntered: (() -> Void)?
863
863
+
var onMouseExited: (() -> Void)?
864
864
+
private var trackingArea: NSTrackingArea?
865
865
+
866
866
+
override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
867
867
+
868
868
+
override func updateTrackingAreas() {
869
869
+
if let trackingArea {
870
870
+
removeTrackingArea(trackingArea)
871
871
+
}
872
872
+
let trackingArea = NSTrackingArea(
873
873
+
rect: bounds,
874
874
+
options: [.activeAlways, .inVisibleRect, .mouseEnteredAndExited],
875
875
+
owner: self,
876
876
+
userInfo: nil
877
877
+
)
878
878
+
addTrackingArea(trackingArea)
879
879
+
self.trackingArea = trackingArea
880
880
+
super.updateTrackingAreas()
881
881
+
}
882
882
+
883
883
+
override func mouseEntered(with event: NSEvent) {
884
884
+
onMouseEntered?()
885
885
+
super.mouseEntered(with: event)
886
886
+
}
887
887
+
888
888
+
override func mouseExited(with event: NSEvent) {
889
889
+
onMouseExited?()
890
890
+
super.mouseExited(with: event)
891
891
+
}
892
892
+
}
893
893
+
894
894
+
private final class MenuBarWaveformStripPanel: NSPanel {
895
895
+
var onDragBegan: (() -> Void)?
896
896
+
var onDragEnded: (() -> Void)?
897
897
+
var onFrameChanged: ((NSRect) -> Void)?
898
898
+
var passthroughViews: [NSView] = []
899
899
+
900
900
+
override var canBecomeKey: Bool { true }
901
901
+
override var canBecomeMain: Bool { false }
902
902
+
903
903
+
override func setFrame(_ frameRect: NSRect, display flag: Bool) {
904
904
+
super.setFrame(frameRect, display: flag)
905
905
+
onFrameChanged?(frame)
906
906
+
}
907
907
+
908
908
+
override func setFrameOrigin(_ point: NSPoint) {
909
909
+
super.setFrameOrigin(point)
910
910
+
onFrameChanged?(frame)
911
911
+
}
912
912
+
913
913
+
override func sendEvent(_ event: NSEvent) {
914
914
+
if event.type == .leftMouseDown,
915
915
+
event.clickCount == 1,
916
916
+
shouldBeginDrag(for: event) {
917
917
+
onDragBegan?()
918
918
+
performDrag(with: event)
919
919
+
onDragEnded?()
920
920
+
return
921
921
+
}
922
922
+
super.sendEvent(event)
923
923
+
}
924
924
+
925
925
+
private func shouldBeginDrag(for event: NSEvent) -> Bool {
926
926
+
guard let contentView else { return true }
927
927
+
let point = contentView.convert(event.locationInWindow, from: nil)
928
928
+
guard let hitView = contentView.hitTest(point) else { return true }
929
929
+
return !passthroughViews.contains(where: { hitView === $0 || hitView.isDescendant(of: $0) })
930
930
+
}
931
931
+
}
932
932
+
933
933
+
@available(macOS 26.0, *)
934
934
+
private final class StripMovableGlassEffectView: NSGlassEffectView {
935
935
+
override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
936
936
+
}
937
937
+
3
938
/// Thin floating waveform strip that slides down from beneath the menubar
4
939
/// piano when notes are played, and slides back up after a configurable
5
940
/// idle delay. Hidden whenever the settings popover or floating piano
···
8
943
/// The panel sits one level below `NSWindow.Level.mainMenu` so the menubar
9
944
/// itself occludes it. The slide animation moves the panel from behind the
10
945
/// menubar downward into view, and reverses to hide.
11
11
-
final class MenuBarWaveformStrip {
946
946
+
private final class LiquidMenuBarWaveformStrip: NSObject, MenuBarWaveformStripImplementation {
12
947
private let menuBand: MenuBandController
13
948
private let waveformView = WaveformView()
14
14
-
private let waveformBezel = NSView()
949
949
+
private let waveformBezel = StripInteractiveSurfaceView()
950
950
+
private let waveformClipView = StripInteractiveSurfaceView()
951
951
+
private var waveformBezelHeightConstraint: NSLayoutConstraint?
952
952
+
private let instrumentArrows = ArrowKeysIndicator()
953
953
+
private let instrumentRowContainer = StripInteractiveSurfaceView()
15
954
private let instrumentLabel = NSTextField(labelWithString: "")
955
955
+
private let closeButton = NSButton()
956
956
+
private let dockButton = NSButton()
957
957
+
private let expandButton = NSButton()
958
958
+
private let heldNotesContainer = StripInteractiveSurfaceView()
16
959
private let heldNotesStack = NSStackView()
960
960
+
private weak var closeButtonGlassView: NSView?
961
961
+
private weak var dockButtonGlassView: NSView?
962
962
+
private weak var expandButtonGlassView: NSView?
963
963
+
private weak var waveformGlassView: NSView?
964
964
+
private weak var stripBackgroundView: NSView?
17
965
private var panel: NSPanel?
18
966
private weak var statusButton: NSStatusBarButton?
967
967
+
var onStepBackward: (() -> Void)?
968
968
+
var onStepForward: (() -> Void)?
969
969
+
var onStepUp: (() -> Void)?
970
970
+
var onStepDown: (() -> Void)?
971
971
+
var onExpandRequested: (() -> Void)?
19
972
20
973
/// How long to keep the strip visible after the last note ends.
21
974
private let hideDelay: TimeInterval = 2.0
22
975
private var hideWorkItem: DispatchWorkItem?
976
976
+
private let customOriginXKey = "notepat.waveformStrip.customOriginX"
977
977
+
private let customOriginYKey = "notepat.waveformStrip.customOriginY"
978
978
+
private var customOrigin: NSPoint?
23
979
24
24
-
/// Strip height in points.
25
25
-
private static let stripHeight: CGFloat = 56
980
980
+
/// Match the popover waveform bezel's width:height ratio (224:64) so the
981
981
+
/// meter reads consistently in both places.
982
982
+
private static let waveformAspectRatio: CGFloat = InstrumentListView.preferredWidth / 64
983
983
+
private static let waveformGlassCornerRadius: CGFloat = 14
984
984
+
private static let waveformClipCornerRadius: CGFloat = 12
985
985
+
private static let controlButtonSize: CGFloat = 24
986
986
+
private static let controlInset: CGFloat = 8
987
987
+
private static let waveformOuterInset: CGFloat = 4
988
988
+
private static let waveformInnerInset: CGFloat = 2
989
989
+
private static let footerHeight: CGFloat = 54
990
990
+
private static let heldNotesRowHeight: CGFloat = 14
991
991
+
private static let instrumentRowHeight: CGFloat = 30
992
992
+
private static let hitTestBackdropAlpha: CGFloat = 0.001
993
993
+
private static let defaultsDomain = "computer.aestheticcomputer.menuband"
994
994
+
private static let styleOverrideDefaultsKey = "MenuBandWaveformStripStyle"
995
995
+
private static let styleOverrideEnvironmentKey = "MENUBAND_WAVEFORM_STRIP_STYLE"
26
996
27
997
/// Animation duration in seconds.
28
28
-
private static let slideDuration: TimeInterval = 0.22
998
998
+
private static let fadeInDuration: TimeInterval = 0.18
999
999
+
private static let fadeOutDuration: TimeInterval = 0.18
29
1000
30
1001
/// Window level just below the menubar so the menubar occludes the
31
1002
/// strip while it's tucked behind.
32
32
-
private static let stripLevel = NSWindow.Level(rawValue: NSWindow.Level.mainMenu.rawValue - 1)
1003
1003
+
private static let stripLevel = NSWindow.Level.floating
1004
1004
+
1005
1005
+
private static var visualStyleOverride: StripVisualStyleOverride {
1006
1006
+
let environmentValue = ProcessInfo.processInfo.environment[styleOverrideEnvironmentKey]
1007
1007
+
if environmentValue != nil {
1008
1008
+
return StripVisualStyleOverride(rawValue: environmentValue)
1009
1009
+
}
1010
1010
+
let defaultsValue = UserDefaults(suiteName: defaultsDomain)?.string(forKey: styleOverrideDefaultsKey)
1011
1011
+
?? UserDefaults.standard.string(forKey: styleOverrideDefaultsKey)
1012
1012
+
return StripVisualStyleOverride(rawValue: defaultsValue)
1013
1013
+
}
1014
1014
+
1015
1015
+
private static var shouldUseLiquidGlass: Bool {
1016
1016
+
switch visualStyleOverride {
1017
1017
+
case .liquid:
1018
1018
+
if #available(macOS 26.0, *) {
1019
1019
+
return true
1020
1020
+
}
1021
1021
+
return false
1022
1022
+
case .legacy:
1023
1023
+
return false
1024
1024
+
case .automatic:
1025
1025
+
if #available(macOS 26.0, *) {
1026
1026
+
return true
1027
1027
+
}
1028
1028
+
return false
1029
1029
+
}
1030
1030
+
}
33
1031
34
1032
/// CVDisplayLink-driven slide animation. NSAnimationContext + animator()
35
1033
/// proxy doesn't reliably move borderless non-activating panels, so we
···
40
1038
private var slideToY: CGFloat = 0
41
1039
private var slideCompletion: (() -> Void)?
42
1040
private var isSliding = false
1041
1041
+
private var isPointerInsideStrip = false
1042
1042
+
private var isDraggingStrip = false
43
1043
44
1044
/// True while the strip panel is on screen (visible or animating in).
45
1045
var isShown: Bool { panel?.isVisible == true }
1046
1046
+
var isDocked: Bool { customOrigin == nil }
46
1047
47
1048
/// External suppression — callers set this when the popover or floating
48
1049
/// palette opens. While suppressed, `showIfNeeded` is a no-op and any
···
56
1057
57
1058
init(menuBand: MenuBandController) {
58
1059
self.menuBand = menuBand
1060
1060
+
super.init()
1061
1061
+
customOrigin = loadCustomOrigin()
59
1062
waveformView.menuBand = menuBand
1063
1063
+
waveformView.setSurfaceStyle(.glassEmbedded)
60
1064
waveformBezel.wantsLayer = true
61
61
-
waveformBezel.layer?.cornerRadius = 6
62
62
-
waveformBezel.layer?.backgroundColor = NSColor(white: 0.06, alpha: 1.0).cgColor
63
63
-
waveformBezel.layer?.borderWidth = 1
1065
1065
+
waveformBezel.layer?.cornerRadius = Self.waveformGlassCornerRadius
1066
1066
+
waveformBezel.layer?.borderWidth = 0.8
1067
1067
+
if #available(macOS 10.15, *) {
1068
1068
+
waveformBezel.layer?.cornerCurve = .continuous
1069
1069
+
}
1070
1070
+
waveformClipView.wantsLayer = true
1071
1071
+
waveformClipView.layer?.cornerRadius = Self.waveformClipCornerRadius
1072
1072
+
waveformClipView.layer?.masksToBounds = true
1073
1073
+
if #available(macOS 10.15, *) {
1074
1074
+
waveformClipView.layer?.cornerCurve = .continuous
1075
1075
+
}
64
1076
heldNotesStack.orientation = .horizontal
65
1077
heldNotesStack.alignment = .centerY
66
1078
heldNotesStack.spacing = 4
1079
1079
+
instrumentLabel.drawsBackground = false
1080
1080
+
instrumentLabel.lineBreakMode = .byTruncatingTail
1081
1081
+
instrumentArrows.displayMode = .cluster
1082
1082
+
instrumentArrows.toolTip = "Change instrument or octave"
1083
1083
+
instrumentArrows.onClick = { [weak self] dir, isDown in
1084
1084
+
guard isDown else { return }
1085
1085
+
self?.registerArrowInput()
1086
1086
+
switch dir {
1087
1087
+
case 0: self?.onStepBackward?()
1088
1088
+
case 1: self?.onStepForward?()
1089
1089
+
case 2: self?.onStepDown?()
1090
1090
+
case 3: self?.onStepUp?()
1091
1091
+
default: break
1092
1092
+
}
1093
1093
+
}
1094
1094
+
configureControlButton(
1095
1095
+
closeButton,
1096
1096
+
symbolName: "xmark",
1097
1097
+
toolTip: "Close",
1098
1098
+
action: #selector(closeButtonClicked(_:))
1099
1099
+
)
1100
1100
+
configureControlButton(
1101
1101
+
dockButton,
1102
1102
+
symbolName: "menubar.dock.rectangle",
1103
1103
+
toolTip: "Dock Below Menubar Piano",
1104
1104
+
action: #selector(dockButtonClicked(_:))
1105
1105
+
)
1106
1106
+
configureControlButton(
1107
1107
+
expandButton,
1108
1108
+
symbolName: "square.resize.up",
1109
1109
+
toolTip: "Expand floating piano",
1110
1110
+
action: #selector(expandButtonClicked(_:))
1111
1111
+
)
1112
1112
+
}
1113
1113
+
1114
1114
+
private func handleStripDragBegan() {
1115
1115
+
isDraggingStrip = true
1116
1116
+
cancelPendingHide()
1117
1117
+
stopSlide()
1118
1118
+
isSliding = false
1119
1119
+
}
1120
1120
+
1121
1121
+
private func handleStripDragEnded() {
1122
1122
+
isDraggingStrip = false
1123
1123
+
persistPanelOriginIfNeeded(force: true)
1124
1124
+
refreshAutoHideState()
1125
1125
+
}
1126
1126
+
1127
1127
+
private func persistPanelOriginIfNeeded(force: Bool = false) {
1128
1128
+
guard let panel, force || isDraggingStrip else { return }
1129
1129
+
let frame = clampedFrame(origin: panel.frame.origin, size: panel.frame.size, preferredScreen: panel.screen)
1130
1130
+
customOrigin = frame.origin
1131
1131
+
saveCustomOrigin(frame.origin)
1132
1132
+
if panel.frame.origin != frame.origin {
1133
1133
+
panel.setFrameOrigin(frame.origin)
1134
1134
+
}
1135
1135
+
}
1136
1136
+
1137
1137
+
private func handleStripMouseEntered() {
1138
1138
+
guard !isPointerInsideStrip else { return }
1139
1139
+
isPointerInsideStrip = true
1140
1140
+
setControlsVisible(true)
1141
1141
+
cancelPendingHide()
1142
1142
+
}
1143
1143
+
1144
1144
+
private func handleStripMouseExited() {
1145
1145
+
guard isPointerInsideStrip else { return }
1146
1146
+
isPointerInsideStrip = false
1147
1147
+
setControlsVisible(false)
1148
1148
+
refreshAutoHideState()
1149
1149
+
}
1150
1150
+
1151
1151
+
private func refreshAutoHideState() {
1152
1152
+
guard menuBand.litNotes.isEmpty else {
1153
1153
+
cancelPendingHide()
1154
1154
+
return
1155
1155
+
}
1156
1156
+
scheduleHide()
67
1157
}
68
1158
69
1159
/// Pre-build the panel so the first note doesn't pay construction cost.
···
86
1176
87
1177
/// Call whenever `litNotes` becomes empty (all notes released).
88
1178
func scheduleHide() {
1179
1179
+
guard !isPointerInsideStrip, !isDraggingStrip else {
1180
1180
+
cancelPendingHide()
1181
1181
+
return
1182
1182
+
}
89
1183
cancelPendingHide()
90
1184
let work = DispatchWorkItem { [weak self] in
91
1185
self?.hide(animated: true)
···
98
1192
func dismiss() {
99
1193
cancelPendingHide()
100
1194
stopSlide()
1195
1195
+
isPointerInsideStrip = false
1196
1196
+
setControlsVisible(false, animated: false)
101
1197
waveformView.isLive = false
102
1198
panel?.orderOut(nil)
103
1199
}
···
106
1202
func reposition(statusItemButton: NSStatusBarButton?) {
107
1203
statusButton = statusItemButton
108
1204
guard let panel = panel, panel.isVisible, !isSliding else { return }
1205
1205
+
guard isDocked else { return }
109
1206
positionPanel(panel)
110
1207
}
111
1208
···
115
1212
refreshReadout()
116
1213
}
117
1214
1215
1215
+
func registerArrowInput() {
1216
1216
+
guard !suppressed else { return }
1217
1217
+
showIfNeeded()
1218
1218
+
refreshReadout()
1219
1219
+
if menuBand.litNotes.isEmpty {
1220
1220
+
scheduleHide()
1221
1221
+
}
1222
1222
+
}
1223
1223
+
118
1224
// MARK: - Geometry
119
1225
120
1226
/// Compute the target frame for the strip: directly below the menubar,
···
135
1241
let windowRect = button.convert(localRect, to: nil)
136
1242
let screenRect = buttonWindow.convertToScreen(windowRect)
137
1243
138
138
-
return NSRect(
1244
1244
+
let stripHeight = currentStripHeight(for: screenRect.width)
1245
1245
+
let anchoredFrame = NSRect(
139
1246
x: screenRect.origin.x,
140
140
-
y: screenRect.origin.y - Self.stripHeight,
1247
1247
+
y: screenRect.origin.y - stripHeight,
141
1248
width: screenRect.width,
142
142
-
height: Self.stripHeight
1249
1249
+
height: stripHeight
1250
1250
+
)
1251
1251
+
guard let customOrigin else { return anchoredFrame }
1252
1252
+
return clampedFrame(
1253
1253
+
origin: customOrigin,
1254
1254
+
size: anchoredFrame.size,
1255
1255
+
preferredScreen: panel?.screen ?? buttonWindow.screen
143
1256
)
144
1257
}
145
1258
146
146
-
// MARK: - Slide animation
1259
1259
+
private func currentWaveformBezelHeight(for width: CGFloat) -> CGFloat {
1260
1260
+
round(width / Self.waveformAspectRatio)
1261
1261
+
}
1262
1262
+
1263
1263
+
private func currentStripHeight(for width: CGFloat) -> CGFloat {
1264
1264
+
currentWaveformBezelHeight(for: width) + Self.footerHeight
1265
1265
+
}
1266
1266
+
1267
1267
+
private func loadCustomOrigin() -> NSPoint? {
1268
1268
+
let defaults = UserDefaults.standard
1269
1269
+
guard defaults.object(forKey: customOriginXKey) != nil,
1270
1270
+
defaults.object(forKey: customOriginYKey) != nil else { return nil }
1271
1271
+
return NSPoint(
1272
1272
+
x: defaults.double(forKey: customOriginXKey),
1273
1273
+
y: defaults.double(forKey: customOriginYKey)
1274
1274
+
)
1275
1275
+
}
1276
1276
+
1277
1277
+
private func saveCustomOrigin(_ origin: NSPoint) {
1278
1278
+
let defaults = UserDefaults.standard
1279
1279
+
defaults.set(origin.x, forKey: customOriginXKey)
1280
1280
+
defaults.set(origin.y, forKey: customOriginYKey)
1281
1281
+
}
1282
1282
+
1283
1283
+
private func clampedFrame(origin: NSPoint, size: NSSize, preferredScreen: NSScreen?) -> NSRect {
1284
1284
+
let visible = visibleFrame(for: origin, preferredScreen: preferredScreen)
1285
1285
+
let x = min(max(origin.x, visible.minX), visible.maxX - size.width)
1286
1286
+
let y = min(max(origin.y, visible.minY), visible.maxY - size.height)
1287
1287
+
return NSRect(origin: NSPoint(x: x, y: y), size: size)
1288
1288
+
}
1289
1289
+
1290
1290
+
private func visibleFrame(for origin: NSPoint, preferredScreen: NSScreen?) -> NSRect {
1291
1291
+
if let screen = NSScreen.screens.first(where: { $0.visibleFrame.contains(origin) }) {
1292
1292
+
return screen.visibleFrame
1293
1293
+
}
1294
1294
+
if let preferredScreen {
1295
1295
+
return preferredScreen.visibleFrame
1296
1296
+
}
1297
1297
+
return NSScreen.main?.visibleFrame ?? NSRect(x: 0, y: 0, width: 1440, height: 900)
1298
1298
+
}
1299
1299
+
1300
1300
+
private func moveStrip(to origin: NSPoint) {
1301
1301
+
guard let panel = panel else { return }
1302
1302
+
let frame = clampedFrame(origin: origin, size: panel.frame.size, preferredScreen: panel.screen)
1303
1303
+
customOrigin = frame.origin
1304
1304
+
saveCustomOrigin(frame.origin)
1305
1305
+
panel.setFrameOrigin(frame.origin)
1306
1306
+
}
1307
1307
+
1308
1308
+
private func resetCustomPosition() {
1309
1309
+
customOrigin = nil
1310
1310
+
let defaults = UserDefaults.standard
1311
1311
+
defaults.removeObject(forKey: customOriginXKey)
1312
1312
+
defaults.removeObject(forKey: customOriginYKey)
1313
1313
+
guard let panel = panel else { return }
1314
1314
+
positionPanel(panel)
1315
1315
+
}
1316
1316
+
1317
1317
+
// MARK: - Visibility animation
147
1318
148
1319
private func show() {
149
1320
if panel == nil { buildPanel() }
150
1321
guard let panel = panel, let target = targetFrame() else { return }
151
1322
152
152
-
// Start tucked behind the menubar (origin shifted up by strip height).
153
153
-
let hiddenY = target.origin.y + target.height
154
154
-
panel.setFrame(NSRect(x: target.origin.x, y: hiddenY,
155
155
-
width: target.width, height: target.height),
156
156
-
display: true)
1323
1323
+
isPointerInsideStrip = false
1324
1324
+
setControlsVisible(false, animated: false)
1325
1325
+
waveformBezelHeightConstraint?.constant = currentWaveformBezelHeight(for: target.width)
1326
1326
+
panel.setFrame(target, display: true)
1327
1327
+
isSliding = true
1328
1328
+
panel.alphaValue = 1.0
1329
1329
+
panel.alphaValue = 0.0
157
1330
applyAppearanceToVisualizer()
158
1331
applyWaveformTint()
159
1332
refreshReadout()
160
1333
waveformView.isLive = true
161
1334
panel.orderFrontRegardless()
162
1335
163
163
-
// Slide down to the target position.
164
164
-
startSlide(fromY: hiddenY, toY: target.origin.y) { [weak self] in
165
165
-
// Ensure we land exactly at the target.
166
166
-
panel.setFrameOrigin(target.origin)
167
167
-
self?.isSliding = false
1336
1336
+
NSAnimationContext.runAnimationGroup { context in
1337
1337
+
context.duration = Self.fadeInDuration
1338
1338
+
context.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
1339
1339
+
panel.animator().alphaValue = 1.0
1340
1340
+
} completionHandler: { [weak self, weak panel] in
1341
1341
+
guard let self, let panel else { return }
1342
1342
+
panel.alphaValue = 1.0
1343
1343
+
self.isSliding = false
168
1344
}
169
1345
}
170
1346
171
1347
private func hide(animated: Bool) {
172
1348
cancelPendingHide()
173
1349
stopSlide()
1350
1350
+
guard !isPointerInsideStrip, !isDraggingStrip else { return }
174
1351
guard let panel = panel, panel.isVisible else {
175
1352
waveformView.isLive = false
176
1353
return
177
1354
}
178
1355
if !animated {
1356
1356
+
panel.animator().alphaValue = 1.0
179
1357
waveformView.isLive = false
180
1358
panel.orderOut(nil)
181
1359
return
182
1360
}
183
183
-
// Slide back up behind the menubar.
184
184
-
let currentY = panel.frame.origin.y
185
185
-
let hiddenY = currentY + panel.frame.height
186
186
-
startSlide(fromY: currentY, toY: hiddenY) { [weak self] in
187
187
-
self?.waveformView.isLive = false
1361
1361
+
NSAnimationContext.runAnimationGroup { context in
1362
1362
+
context.duration = Self.fadeOutDuration
1363
1363
+
context.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
1364
1364
+
panel.animator().alphaValue = 0.0
1365
1365
+
} completionHandler: { [weak self, weak panel] in
1366
1366
+
guard let self, let panel else { return }
1367
1367
+
self.waveformView.isLive = false
188
1368
panel.orderOut(nil)
189
189
-
self?.isSliding = false
1369
1369
+
panel.alphaValue = 1.0
1370
1370
+
self.isSliding = false
190
1371
}
191
1372
}
192
1373
···
209
1390
let opaque = Unmanaged.passUnretained(self).toOpaque()
210
1391
CVDisplayLinkSetOutputCallback(link, { _, _, _, _, _, ctx -> CVReturn in
211
1392
guard let ctx = ctx else { return kCVReturnSuccess }
212
212
-
let strip = Unmanaged<MenuBarWaveformStrip>.fromOpaque(ctx).takeUnretainedValue()
1393
1393
+
let strip = Unmanaged<LiquidMenuBarWaveformStrip>.fromOpaque(ctx).takeUnretainedValue()
213
1394
DispatchQueue.main.async { strip.tickSlide() }
214
1395
return kCVReturnSuccess
215
1396
}, opaque)
···
223
1404
return
224
1405
}
225
1406
let elapsed = CACurrentMediaTime() - slideStartTime
226
226
-
let t = min(1.0, elapsed / Self.slideDuration)
1407
1407
+
let t = min(1.0, elapsed / Self.fadeInDuration)
227
1408
// Ease-out cubic for show, ease-in cubic for hide.
228
1409
let eased: CGFloat
229
1410
if slideToY < slideFromY {
···
260
1441
// MARK: - Panel construction
261
1442
262
1443
private func buildPanel() {
263
263
-
let p = NSPanel(
264
264
-
contentRect: NSRect(origin: .zero, size: NSSize(width: 200, height: Self.stripHeight)),
265
265
-
styleMask: [.borderless, .nonactivatingPanel],
1444
1444
+
let initialWidth: CGFloat = 200
1445
1445
+
let p = MenuBarWaveformStripPanel(
1446
1446
+
contentRect: NSRect(
1447
1447
+
origin: .zero,
1448
1448
+
size: NSSize(width: initialWidth, height: currentStripHeight(for: initialWidth))
1449
1449
+
),
1450
1450
+
styleMask: [.borderless],
266
1451
backing: .buffered,
267
1452
defer: false
268
1453
)
269
269
-
p.isOpaque = true
270
270
-
p.backgroundColor = .black
1454
1454
+
p.isOpaque = false
1455
1455
+
p.backgroundColor = .clear
271
1456
p.hasShadow = true
272
1457
p.level = Self.stripLevel
273
1458
p.collectionBehavior = [.transient, .ignoresCycle]
274
1459
p.hidesOnDeactivate = false
275
1460
p.canHide = false
276
276
-
p.isMovable = false
1461
1461
+
p.isMovable = true
1462
1462
+
p.isMovableByWindowBackground = false
277
1463
p.animationBehavior = .none
278
1464
p.acceptsMouseMovedEvents = false
279
279
-
1465
1465
+
p.onDragBegan = { [weak self] in self?.handleStripDragBegan() }
1466
1466
+
p.onDragEnded = { [weak self] in self?.handleStripDragEnded() }
1467
1467
+
p.onFrameChanged = { [weak self] _ in
1468
1468
+
self?.persistPanelOriginIfNeeded()
1469
1469
+
}
1470
1470
+
p.passthroughViews = [instrumentArrows, closeButton, dockButton, expandButton]
280
1471
waveformView.translatesAutoresizingMaskIntoConstraints = false
281
1472
waveformBezel.translatesAutoresizingMaskIntoConstraints = false
1473
1473
+
waveformClipView.translatesAutoresizingMaskIntoConstraints = false
1474
1474
+
instrumentArrows.translatesAutoresizingMaskIntoConstraints = false
1475
1475
+
instrumentRowContainer.translatesAutoresizingMaskIntoConstraints = false
282
1476
instrumentLabel.translatesAutoresizingMaskIntoConstraints = false
1477
1477
+
closeButton.translatesAutoresizingMaskIntoConstraints = false
1478
1478
+
dockButton.translatesAutoresizingMaskIntoConstraints = false
1479
1479
+
expandButton.translatesAutoresizingMaskIntoConstraints = false
1480
1480
+
heldNotesContainer.translatesAutoresizingMaskIntoConstraints = false
283
1481
heldNotesStack.translatesAutoresizingMaskIntoConstraints = false
284
284
-
let content = NSView()
285
285
-
content.wantsLayer = true
286
286
-
content.layer?.backgroundColor = NSColor.clear.cgColor
287
287
-
p.contentView = content
288
288
-
p.contentView!.addSubview(waveformBezel)
289
289
-
p.contentView!.addSubview(instrumentLabel)
290
290
-
p.contentView!.addSubview(heldNotesStack)
291
291
-
waveformBezel.addSubview(waveformView)
292
292
-
let bezelInset: CGFloat = 5
1482
1482
+
let rootView = StripInteractiveSurfaceView()
1483
1483
+
rootView.translatesAutoresizingMaskIntoConstraints = false
1484
1484
+
rootView.onMouseEntered = { [weak self] in self?.handleStripMouseEntered() }
1485
1485
+
rootView.onMouseExited = { [weak self] in self?.handleStripMouseExited() }
1486
1486
+
rootView.wantsLayer = true
1487
1487
+
// Keep the panel visually transparent while ensuring WindowServer
1488
1488
+
// still treats it as a hittable surface instead of passing clicks
1489
1489
+
// through to the app underneath.
1490
1490
+
rootView.layer?.backgroundColor = NSColor.black.withAlphaComponent(Self.hitTestBackdropAlpha).cgColor
1491
1491
+
let layoutRoot: NSView
1492
1492
+
if #available(macOS 26.0, *) {
1493
1493
+
let glassContainer = NSGlassEffectContainerView()
1494
1494
+
glassContainer.translatesAutoresizingMaskIntoConstraints = false
1495
1495
+
glassContainer.spacing = 18
1496
1496
+
glassContainer.contentView = rootView
1497
1497
+
p.contentView = glassContainer
1498
1498
+
1499
1499
+
let stripGlassView = StripMovableGlassEffectView()
1500
1500
+
stripGlassView.translatesAutoresizingMaskIntoConstraints = false
1501
1501
+
stripGlassView.cornerRadius = 14
1502
1502
+
let stripContentView = StripInteractiveSurfaceView()
1503
1503
+
stripContentView.translatesAutoresizingMaskIntoConstraints = false
1504
1504
+
stripGlassView.contentView = stripContentView
1505
1505
+
rootView.addSubview(stripGlassView)
1506
1506
+
NSLayoutConstraint.activate([
1507
1507
+
stripGlassView.leadingAnchor.constraint(equalTo: rootView.leadingAnchor),
1508
1508
+
stripGlassView.trailingAnchor.constraint(equalTo: rootView.trailingAnchor),
1509
1509
+
stripGlassView.topAnchor.constraint(equalTo: rootView.topAnchor),
1510
1510
+
stripGlassView.bottomAnchor.constraint(equalTo: rootView.bottomAnchor),
1511
1511
+
])
1512
1512
+
1513
1513
+
stripBackgroundView = stripGlassView
1514
1514
+
layoutRoot = stripContentView
1515
1515
+
1516
1516
+
let waveformGlassView = StripMovableGlassEffectView()
1517
1517
+
waveformGlassView.translatesAutoresizingMaskIntoConstraints = false
1518
1518
+
waveformGlassView.cornerRadius = Self.waveformGlassCornerRadius
1519
1519
+
let waveformContentView = StripInteractiveSurfaceView()
1520
1520
+
waveformContentView.translatesAutoresizingMaskIntoConstraints = false
1521
1521
+
waveformGlassView.contentView = waveformContentView
1522
1522
+
layoutRoot.addSubview(waveformBezel)
1523
1523
+
waveformBezel.addSubview(waveformGlassView)
1524
1524
+
self.waveformGlassView = waveformGlassView
1525
1525
+
waveformContentView.addSubview(waveformClipView)
1526
1526
+
waveformClipView.addSubview(waveformView)
1527
1527
+
NSLayoutConstraint.activate([
1528
1528
+
waveformBezel.leadingAnchor.constraint(equalTo: layoutRoot.leadingAnchor, constant: Self.waveformOuterInset),
1529
1529
+
waveformBezel.trailingAnchor.constraint(equalTo: layoutRoot.trailingAnchor, constant: -Self.waveformOuterInset),
1530
1530
+
waveformBezel.topAnchor.constraint(equalTo: layoutRoot.topAnchor, constant: Self.waveformOuterInset),
1531
1531
+
waveformGlassView.leadingAnchor.constraint(equalTo: waveformBezel.leadingAnchor),
1532
1532
+
waveformGlassView.trailingAnchor.constraint(equalTo: waveformBezel.trailingAnchor),
1533
1533
+
waveformGlassView.topAnchor.constraint(equalTo: waveformBezel.topAnchor),
1534
1534
+
waveformGlassView.bottomAnchor.constraint(equalTo: waveformBezel.bottomAnchor),
1535
1535
+
waveformClipView.leadingAnchor.constraint(equalTo: waveformContentView.leadingAnchor, constant: Self.waveformInnerInset),
1536
1536
+
waveformClipView.trailingAnchor.constraint(equalTo: waveformContentView.trailingAnchor, constant: -Self.waveformInnerInset),
1537
1537
+
waveformClipView.topAnchor.constraint(equalTo: waveformContentView.topAnchor, constant: Self.waveformInnerInset),
1538
1538
+
waveformClipView.bottomAnchor.constraint(equalTo: waveformContentView.bottomAnchor, constant: -Self.waveformInnerInset),
1539
1539
+
waveformView.leadingAnchor.constraint(equalTo: waveformClipView.leadingAnchor),
1540
1540
+
waveformView.trailingAnchor.constraint(equalTo: waveformClipView.trailingAnchor),
1541
1541
+
waveformView.topAnchor.constraint(equalTo: waveformClipView.topAnchor),
1542
1542
+
waveformView.bottomAnchor.constraint(equalTo: waveformClipView.bottomAnchor),
1543
1543
+
])
1544
1544
+
} else {
1545
1545
+
p.contentView = rootView
1546
1546
+
stripBackgroundView = rootView
1547
1547
+
rootView.addSubview(waveformBezel)
1548
1548
+
waveformBezel.addSubview(waveformClipView)
1549
1549
+
waveformClipView.addSubview(waveformView)
1550
1550
+
NSLayoutConstraint.activate([
1551
1551
+
waveformBezel.leadingAnchor.constraint(equalTo: rootView.leadingAnchor, constant: Self.waveformOuterInset),
1552
1552
+
waveformBezel.trailingAnchor.constraint(equalTo: rootView.trailingAnchor, constant: -Self.waveformOuterInset),
1553
1553
+
waveformBezel.topAnchor.constraint(equalTo: rootView.topAnchor, constant: Self.waveformOuterInset),
1554
1554
+
waveformClipView.leadingAnchor.constraint(equalTo: waveformBezel.leadingAnchor, constant: Self.waveformInnerInset),
1555
1555
+
waveformClipView.trailingAnchor.constraint(equalTo: waveformBezel.trailingAnchor, constant: -Self.waveformInnerInset),
1556
1556
+
waveformClipView.topAnchor.constraint(equalTo: waveformBezel.topAnchor, constant: Self.waveformInnerInset),
1557
1557
+
waveformClipView.bottomAnchor.constraint(equalTo: waveformBezel.bottomAnchor, constant: -Self.waveformInnerInset),
1558
1558
+
waveformView.leadingAnchor.constraint(equalTo: waveformClipView.leadingAnchor),
1559
1559
+
waveformView.trailingAnchor.constraint(equalTo: waveformClipView.trailingAnchor),
1560
1560
+
waveformView.topAnchor.constraint(equalTo: waveformClipView.topAnchor),
1561
1561
+
waveformView.bottomAnchor.constraint(equalTo: waveformClipView.bottomAnchor),
1562
1562
+
])
1563
1563
+
layoutRoot = rootView
1564
1564
+
waveformGlassView = waveformBezel
1565
1565
+
}
1566
1566
+
layoutRoot.addSubview(heldNotesContainer)
1567
1567
+
layoutRoot.addSubview(instrumentRowContainer)
1568
1568
+
rootView.addSubview(closeButton)
1569
1569
+
rootView.addSubview(dockButton)
1570
1570
+
rootView.addSubview(expandButton)
1571
1571
+
if #available(macOS 26.0, *) {
1572
1572
+
closeButtonGlassView = installControlGlassBackground(for: closeButton, in: rootView)
1573
1573
+
dockButtonGlassView = installControlGlassBackground(for: dockButton, in: rootView)
1574
1574
+
expandButtonGlassView = installControlGlassBackground(for: expandButton, in: rootView)
1575
1575
+
}
1576
1576
+
instrumentRowContainer.addSubview(instrumentArrows)
1577
1577
+
instrumentRowContainer.addSubview(instrumentLabel)
1578
1578
+
heldNotesContainer.addSubview(heldNotesStack)
1579
1579
+
let waveformBezelHeightConstraint = waveformBezel.heightAnchor.constraint(
1580
1580
+
equalToConstant: currentWaveformBezelHeight(for: initialWidth)
1581
1581
+
)
1582
1582
+
self.waveformBezelHeightConstraint = waveformBezelHeightConstraint
293
1583
NSLayoutConstraint.activate([
294
294
-
waveformBezel.leadingAnchor.constraint(equalTo: p.contentView!.leadingAnchor),
295
295
-
waveformBezel.trailingAnchor.constraint(equalTo: p.contentView!.trailingAnchor),
296
296
-
waveformBezel.topAnchor.constraint(equalTo: p.contentView!.topAnchor),
297
297
-
waveformBezel.heightAnchor.constraint(equalToConstant: 36),
298
298
-
waveformView.leadingAnchor.constraint(equalTo: waveformBezel.leadingAnchor, constant: bezelInset),
299
299
-
waveformView.trailingAnchor.constraint(equalTo: waveformBezel.trailingAnchor, constant: -bezelInset),
300
300
-
waveformView.topAnchor.constraint(equalTo: waveformBezel.topAnchor, constant: bezelInset),
301
301
-
waveformView.bottomAnchor.constraint(equalTo: waveformBezel.bottomAnchor, constant: -bezelInset),
302
302
-
instrumentLabel.leadingAnchor.constraint(equalTo: p.contentView!.leadingAnchor, constant: 6),
303
303
-
instrumentLabel.bottomAnchor.constraint(equalTo: p.contentView!.bottomAnchor, constant: -4),
304
304
-
heldNotesStack.centerXAnchor.constraint(equalTo: p.contentView!.centerXAnchor),
305
305
-
heldNotesStack.centerYAnchor.constraint(equalTo: instrumentLabel.centerYAnchor),
1584
1584
+
waveformBezelHeightConstraint,
1585
1585
+
heldNotesContainer.leadingAnchor.constraint(equalTo: layoutRoot.leadingAnchor, constant: 4),
1586
1586
+
heldNotesContainer.trailingAnchor.constraint(equalTo: layoutRoot.trailingAnchor, constant: -4),
1587
1587
+
heldNotesContainer.topAnchor.constraint(equalTo: waveformBezel.bottomAnchor, constant: 3),
1588
1588
+
heldNotesContainer.heightAnchor.constraint(equalToConstant: Self.heldNotesRowHeight),
1589
1589
+
heldNotesStack.centerXAnchor.constraint(equalTo: heldNotesContainer.centerXAnchor),
1590
1590
+
heldNotesStack.centerYAnchor.constraint(equalTo: heldNotesContainer.centerYAnchor),
1591
1591
+
closeButton.topAnchor.constraint(equalTo: rootView.topAnchor, constant: Self.controlInset),
1592
1592
+
closeButton.leadingAnchor.constraint(equalTo: rootView.leadingAnchor, constant: Self.controlInset),
1593
1593
+
closeButton.widthAnchor.constraint(equalToConstant: Self.controlButtonSize),
1594
1594
+
closeButton.heightAnchor.constraint(equalToConstant: Self.controlButtonSize),
1595
1595
+
expandButton.topAnchor.constraint(equalTo: rootView.topAnchor, constant: Self.controlInset),
1596
1596
+
expandButton.trailingAnchor.constraint(equalTo: rootView.trailingAnchor, constant: -Self.controlInset),
1597
1597
+
expandButton.widthAnchor.constraint(equalToConstant: Self.controlButtonSize),
1598
1598
+
expandButton.heightAnchor.constraint(equalToConstant: Self.controlButtonSize),
1599
1599
+
dockButton.topAnchor.constraint(equalTo: rootView.topAnchor, constant: Self.controlInset),
1600
1600
+
dockButton.trailingAnchor.constraint(equalTo: expandButton.leadingAnchor, constant: -6),
1601
1601
+
dockButton.widthAnchor.constraint(equalToConstant: Self.controlButtonSize),
1602
1602
+
dockButton.heightAnchor.constraint(equalToConstant: Self.controlButtonSize),
1603
1603
+
instrumentRowContainer.leadingAnchor.constraint(equalTo: layoutRoot.leadingAnchor, constant: 4),
1604
1604
+
instrumentRowContainer.trailingAnchor.constraint(equalTo: layoutRoot.trailingAnchor, constant: -4),
1605
1605
+
instrumentRowContainer.topAnchor.constraint(equalTo: heldNotesContainer.bottomAnchor, constant: 3),
1606
1606
+
instrumentRowContainer.heightAnchor.constraint(equalToConstant: Self.instrumentRowHeight),
1607
1607
+
instrumentRowContainer.bottomAnchor.constraint(equalTo: layoutRoot.bottomAnchor, constant: -4),
1608
1608
+
instrumentArrows.leadingAnchor.constraint(equalTo: instrumentRowContainer.leadingAnchor, constant: 6),
1609
1609
+
instrumentArrows.centerYAnchor.constraint(equalTo: instrumentRowContainer.centerYAnchor),
1610
1610
+
instrumentLabel.leadingAnchor.constraint(equalTo: instrumentArrows.trailingAnchor, constant: 4),
1611
1611
+
instrumentLabel.centerYAnchor.constraint(equalTo: instrumentRowContainer.centerYAnchor),
1612
1612
+
instrumentLabel.trailingAnchor.constraint(equalTo: instrumentRowContainer.trailingAnchor, constant: -6),
306
1613
])
307
1614
applyAppearanceToVisualizer()
308
1615
applyWaveformTint()
309
1616
refreshReadout()
1617
1617
+
setControlsVisible(false, animated: false)
310
1618
311
1619
panel = p
312
1620
}
313
1621
314
1622
private func positionPanel(_ panel: NSPanel) {
315
1623
guard let target = targetFrame() else { return }
1624
1624
+
waveformBezelHeightConstraint?.constant = currentWaveformBezelHeight(for: target.width)
316
1625
panel.setFrame(target, display: true)
317
1626
}
318
1627
···
320
1629
let isDark = NSApp.effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua
321
1630
waveformView.setLightMode(!isDark)
322
1631
if isDark {
323
323
-
waveformBezel.layer?.backgroundColor = NSColor(white: 0.06, alpha: 1.0).cgColor
324
324
-
instrumentLabel.textColor = .white
1632
1632
+
waveformBezel.layer?.backgroundColor = NSColor.white.withAlphaComponent(0.04).cgColor
1633
1633
+
instrumentLabel.textColor = .labelColor
325
1634
} else {
326
326
-
waveformBezel.layer?.backgroundColor = NSColor(white: 0.82, alpha: 1.0).cgColor
327
327
-
instrumentLabel.textColor = .black
1635
1635
+
waveformBezel.layer?.backgroundColor = NSColor.white.withAlphaComponent(0.18).cgColor
1636
1636
+
instrumentLabel.textColor = .labelColor
328
1637
}
329
1638
}
330
1639
331
1640
private func applyWaveformTint() {
1641
1641
+
let stripTint: NSColor
332
1642
if menuBand.midiMode {
333
1643
waveformView.setDotMatrix(MenuBandPopoverViewController.midiDotPattern)
334
1644
waveformView.setBaseColor(.controlAccentColor)
335
1645
waveformBezel.layer?.borderColor = NSColor.controlAccentColor
336
336
-
.withAlphaComponent(0.55).cgColor
1646
1646
+
.withAlphaComponent(0.24).cgColor
1647
1647
+
stripTint = NSColor.controlAccentColor.withAlphaComponent(0.20)
337
1648
} else {
338
1649
waveformView.setDotMatrix(nil)
339
1650
let safe = max(0, min(127, Int(menuBand.effectiveMelodicProgram)))
340
1651
let familyColor = InstrumentListView.colorForProgram(safe)
341
1652
waveformView.setBaseColor(familyColor)
342
1653
waveformBezel.layer?.borderColor = familyColor
343
343
-
.withAlphaComponent(0.55).cgColor
1654
1654
+
.withAlphaComponent(0.22).cgColor
1655
1655
+
stripTint = familyColor.withAlphaComponent(0.16)
1656
1656
+
}
1657
1657
+
if #available(macOS 26.0, *),
1658
1658
+
let glassView = stripBackgroundView as? NSGlassEffectView {
1659
1659
+
glassView.tintColor = stripTint
1660
1660
+
}
1661
1661
+
if #available(macOS 26.0, *),
1662
1662
+
let glassView = waveformGlassView as? NSGlassEffectView {
1663
1663
+
glassView.tintColor = stripTint.withAlphaComponent(0.55)
1664
1664
+
}
1665
1665
+
if #available(macOS 26.0, *) {
1666
1666
+
for view in [closeButtonGlassView, dockButtonGlassView, expandButtonGlassView] {
1667
1667
+
(view as? NSGlassEffectView)?.style = .clear
1668
1668
+
(view as? NSGlassEffectView)?.tintColor = stripTint.withAlphaComponent(0.34)
1669
1669
+
}
1670
1670
+
for button in [closeButton, dockButton, expandButton] {
1671
1671
+
button.layer?.backgroundColor = NSColor.clear.cgColor
1672
1672
+
button.layer?.borderColor = NSColor.clear.cgColor
1673
1673
+
}
1674
1674
+
} else {
1675
1675
+
for button in [closeButton, dockButton, expandButton] {
1676
1676
+
button.layer?.backgroundColor = NSColor.windowBackgroundColor.withAlphaComponent(0.22).cgColor
1677
1677
+
button.layer?.borderColor = NSColor.white.withAlphaComponent(0.28).cgColor
1678
1678
+
}
344
1679
}
345
1680
}
346
1681
···
349
1684
let familyColor = menuBand.midiMode
350
1685
? NSColor.controlAccentColor
351
1686
: InstrumentListView.colorForProgram(safe)
352
352
-
instrumentLabel.stringValue = GeneralMIDI.programNames[safe]
353
353
-
instrumentLabel.font = NSFont.systemFont(ofSize: 10, weight: .black)
1687
1687
+
let isDark = NSApp.effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua
1688
1688
+
let textColor: NSColor = isDark ? .white : .black
1689
1689
+
let shadow = NSShadow()
1690
1690
+
shadow.shadowColor = (familyColor.highlight(withLevel: isDark ? 0.3 : 0.7) ?? familyColor)
1691
1691
+
shadow.shadowOffset = NSSize(width: 1, height: -1)
1692
1692
+
shadow.shadowBlurRadius = 0
1693
1693
+
let titleFont: NSFont = {
1694
1694
+
if let desc = AppDelegate.ywftBoldDescriptor,
1695
1695
+
let f = NSFont(descriptor: desc, size: 14),
1696
1696
+
f.familyName == "YWFT Processing" {
1697
1697
+
return f
1698
1698
+
}
1699
1699
+
return NSFont.systemFont(ofSize: 14, weight: .black)
1700
1700
+
}()
1701
1701
+
instrumentLabel.attributedStringValue = NSAttributedString(
1702
1702
+
string: GeneralMIDI.programNames[safe],
1703
1703
+
attributes: [
1704
1704
+
.font: titleFont,
1705
1705
+
.foregroundColor: textColor,
1706
1706
+
.shadow: shadow,
1707
1707
+
]
1708
1708
+
)
354
1709
for view in heldNotesStack.arrangedSubviews {
355
1710
heldNotesStack.removeArrangedSubview(view)
356
1711
view.removeFromSuperview()
···
380
1735
])
381
1736
return box
382
1737
}
1738
1738
+
1739
1739
+
private func configureControlButton(_ button: NSButton,
1740
1740
+
symbolName: String,
1741
1741
+
toolTip: String,
1742
1742
+
action: Selector) {
1743
1743
+
let config = NSImage.SymbolConfiguration(pointSize: 11, weight: .semibold)
1744
1744
+
button.image = NSImage(
1745
1745
+
systemSymbolName: symbolName,
1746
1746
+
accessibilityDescription: toolTip
1747
1747
+
)?.withSymbolConfiguration(config)
1748
1748
+
button.isBordered = false
1749
1749
+
button.setButtonType(.momentaryChange)
1750
1750
+
button.imagePosition = .imageOnly
1751
1751
+
button.contentTintColor = .white.withAlphaComponent(0.92)
1752
1752
+
button.toolTip = toolTip
1753
1753
+
button.target = self
1754
1754
+
button.action = action
1755
1755
+
button.alphaValue = 0
1756
1756
+
button.wantsLayer = true
1757
1757
+
button.layer?.cornerRadius = Self.controlButtonSize / 2
1758
1758
+
button.layer?.borderWidth = 1
1759
1759
+
}
1760
1760
+
1761
1761
+
@objc private func closeButtonClicked(_ sender: NSButton) {
1762
1762
+
dismiss()
1763
1763
+
}
1764
1764
+
1765
1765
+
@objc private func dockButtonClicked(_ sender: NSButton) {
1766
1766
+
resetCustomPosition()
1767
1767
+
}
1768
1768
+
1769
1769
+
@objc private func expandButtonClicked(_ sender: NSButton) {
1770
1770
+
onExpandRequested?()
1771
1771
+
}
1772
1772
+
1773
1773
+
@available(macOS 26.0, *)
1774
1774
+
private func installControlGlassBackground(for button: NSButton, in container: NSView) -> NSView {
1775
1775
+
let glassView = StripMovableGlassEffectView()
1776
1776
+
glassView.translatesAutoresizingMaskIntoConstraints = false
1777
1777
+
glassView.cornerRadius = Self.controlButtonSize / 2
1778
1778
+
glassView.style = .clear
1779
1779
+
glassView.alphaValue = 0
1780
1780
+
container.addSubview(glassView, positioned: .below, relativeTo: button)
1781
1781
+
NSLayoutConstraint.activate([
1782
1782
+
glassView.leadingAnchor.constraint(equalTo: button.leadingAnchor),
1783
1783
+
glassView.trailingAnchor.constraint(equalTo: button.trailingAnchor),
1784
1784
+
glassView.topAnchor.constraint(equalTo: button.topAnchor),
1785
1785
+
glassView.bottomAnchor.constraint(equalTo: button.bottomAnchor),
1786
1786
+
])
1787
1787
+
return glassView
1788
1788
+
}
1789
1789
+
1790
1790
+
private func setControlsVisible(_ isVisible: Bool, animated: Bool = true) {
1791
1791
+
let alpha: CGFloat = isVisible ? 1.0 : 0.0
1792
1792
+
if animated {
1793
1793
+
NSAnimationContext.runAnimationGroup { context in
1794
1794
+
context.duration = 0.12
1795
1795
+
closeButton.animator().alphaValue = alpha
1796
1796
+
dockButton.animator().alphaValue = alpha
1797
1797
+
expandButton.animator().alphaValue = alpha
1798
1798
+
closeButtonGlassView?.animator().alphaValue = alpha
1799
1799
+
dockButtonGlassView?.animator().alphaValue = alpha
1800
1800
+
expandButtonGlassView?.animator().alphaValue = alpha
1801
1801
+
}
1802
1802
+
} else {
1803
1803
+
closeButton.alphaValue = alpha
1804
1804
+
dockButton.alphaValue = alpha
1805
1805
+
expandButton.alphaValue = alpha
1806
1806
+
closeButtonGlassView?.alphaValue = alpha
1807
1807
+
dockButtonGlassView?.alphaValue = alpha
1808
1808
+
expandButtonGlassView?.alphaValue = alpha
1809
1809
+
}
1810
1810
+
}
1811
1811
+
383
1812
}
+175
slab/menuband/Sources/MenuBand/PianoWaveformPalette.swift
+175
slab/menuband/Sources/MenuBand/PianoWaveformPalette.swift
···
1
1
+
import AppKit
2
2
+
3
3
+
final class PianoWaveformPalette {
4
4
+
enum State {
5
5
+
case collapsed
6
6
+
case expanded
7
7
+
}
8
8
+
9
9
+
private let menuBand: MenuBandController
10
10
+
private let expandedPalette: FloatingPlayPaletteController
11
11
+
private let collapsedPalette: MenuBarWaveformStrip
12
12
+
private weak var statusItemButton: NSStatusBarButton?
13
13
+
private var state: State = .collapsed
14
14
+
private var dismissHandler: (() -> Void)?
15
15
+
16
16
+
init(menuBand: MenuBandController) {
17
17
+
self.menuBand = menuBand
18
18
+
expandedPalette = FloatingPlayPaletteController(menuBand: menuBand)
19
19
+
collapsedPalette = MenuBarWaveformStrip(menuBand: menuBand)
20
20
+
expandedPalette.onDismiss = { [weak self] in
21
21
+
self?.state = .collapsed
22
22
+
self?.dismissHandler?()
23
23
+
}
24
24
+
expandedPalette.onExpandCollapseToggle = { [weak self] in
25
25
+
self?.collapse()
26
26
+
}
27
27
+
collapsedPalette.onExpandRequested = { [weak self] in
28
28
+
self?.expandFromCollapsed()
29
29
+
}
30
30
+
}
31
31
+
32
32
+
var expandedState: State { .expanded }
33
33
+
var collapsedState: State { .collapsed }
34
34
+
35
35
+
var onDismiss: (() -> Void)? {
36
36
+
get { dismissHandler }
37
37
+
set { dismissHandler = newValue }
38
38
+
}
39
39
+
40
40
+
var onFocusRelease: (() -> Void)? {
41
41
+
get { expandedPalette.onFocusRelease }
42
42
+
set { expandedPalette.onFocusRelease = newValue }
43
43
+
}
44
44
+
45
45
+
var onToggleKeymap: (() -> Void)? {
46
46
+
get { expandedPalette.onToggleKeymap }
47
47
+
set { expandedPalette.onToggleKeymap = newValue }
48
48
+
}
49
49
+
50
50
+
var isPianoFocusActive: (() -> Bool)? {
51
51
+
get { expandedPalette.isPianoFocusActive }
52
52
+
set { expandedPalette.isPianoFocusActive = newValue }
53
53
+
}
54
54
+
55
55
+
var isShown: Bool { expandedPalette.isShown }
56
56
+
var isKeyboardFocused: Bool { expandedPalette.isKeyboardFocused }
57
57
+
var isCollapsedState: Bool { state == .collapsed }
58
58
+
59
59
+
var onStepBackward: (() -> Void)? {
60
60
+
get { collapsedPalette.onStepBackward }
61
61
+
set { collapsedPalette.onStepBackward = newValue }
62
62
+
}
63
63
+
64
64
+
var onStepForward: (() -> Void)? {
65
65
+
get { collapsedPalette.onStepForward }
66
66
+
set { collapsedPalette.onStepForward = newValue }
67
67
+
}
68
68
+
69
69
+
var onStepUp: (() -> Void)? {
70
70
+
get { collapsedPalette.onStepUp }
71
71
+
set { collapsedPalette.onStepUp = newValue }
72
72
+
}
73
73
+
74
74
+
var onStepDown: (() -> Void)? {
75
75
+
get { collapsedPalette.onStepDown }
76
76
+
set { collapsedPalette.onStepDown = newValue }
77
77
+
}
78
78
+
79
79
+
var suppressed: Bool {
80
80
+
get { collapsedPalette.suppressed }
81
81
+
set { collapsedPalette.suppressed = newValue }
82
82
+
}
83
83
+
84
84
+
var isDocked: Bool { collapsedPalette.isDocked }
85
85
+
86
86
+
func toggleFromShortcut() {
87
87
+
if expandedPalette.isShown {
88
88
+
state = .collapsed
89
89
+
expandedPalette.toggleFromShortcut()
90
90
+
return
91
91
+
}
92
92
+
collapsedPalette.dismiss()
93
93
+
state = .expanded
94
94
+
expandedPalette.toggleFromShortcut()
95
95
+
}
96
96
+
97
97
+
func showFromCommand(restoringTo previousApp: NSRunningApplication? = nil) {
98
98
+
collapsedPalette.dismiss()
99
99
+
state = .expanded
100
100
+
expandedPalette.showFromCommand(restoringTo: previousApp)
101
101
+
}
102
102
+
103
103
+
func show(restoringTo previousApp: NSRunningApplication? = nil) {
104
104
+
collapsedPalette.dismiss()
105
105
+
state = .expanded
106
106
+
expandedPalette.show(restoringTo: previousApp)
107
107
+
}
108
108
+
109
109
+
func dismiss(reason: FloatingPlayPaletteController.DismissReason = .programmatic) {
110
110
+
state = .collapsed
111
111
+
expandedPalette.dismiss(reason: reason)
112
112
+
}
113
113
+
114
114
+
func refresh() {
115
115
+
expandedPalette.refresh()
116
116
+
}
117
117
+
118
118
+
func clearInteraction() {
119
119
+
expandedPalette.clearInteraction()
120
120
+
}
121
121
+
122
122
+
func releaseKeyboardFocus() {
123
123
+
expandedPalette.releaseKeyboardFocus()
124
124
+
}
125
125
+
126
126
+
func warmUp() {
127
127
+
collapsedPalette.warmUp()
128
128
+
}
129
129
+
130
130
+
func showIfNeeded() {
131
131
+
guard state == .collapsed else { return }
132
132
+
collapsedPalette.reposition(statusItemButton: statusItemButton)
133
133
+
collapsedPalette.refreshAppearance()
134
134
+
collapsedPalette.showIfNeeded()
135
135
+
}
136
136
+
137
137
+
func scheduleHide() {
138
138
+
guard state == .collapsed else { return }
139
139
+
collapsedPalette.scheduleHide()
140
140
+
}
141
141
+
142
142
+
func reposition(statusItemButton: NSStatusBarButton?) {
143
143
+
self.statusItemButton = statusItemButton
144
144
+
collapsedPalette.reposition(statusItemButton: statusItemButton)
145
145
+
}
146
146
+
147
147
+
func refreshAppearance() {
148
148
+
guard state == .collapsed else { return }
149
149
+
collapsedPalette.refreshAppearance()
150
150
+
}
151
151
+
152
152
+
func registerArrowInput() {
153
153
+
guard state == .collapsed else { return }
154
154
+
collapsedPalette.registerArrowInput()
155
155
+
}
156
156
+
157
157
+
private func collapse() {
158
158
+
guard state != .collapsed else { return }
159
159
+
state = .collapsed
160
160
+
expandedPalette.dismiss(reason: .closeButton)
161
161
+
collapsedPalette.reposition(statusItemButton: statusItemButton)
162
162
+
collapsedPalette.refreshAppearance()
163
163
+
collapsedPalette.showIfNeeded()
164
164
+
if menuBand.litNotes.isEmpty {
165
165
+
collapsedPalette.scheduleHide()
166
166
+
}
167
167
+
}
168
168
+
169
169
+
private func expandFromCollapsed() {
170
170
+
guard state != .expanded else { return }
171
171
+
state = .expanded
172
172
+
collapsedPalette.dismiss()
173
173
+
expandedPalette.show()
174
174
+
}
175
175
+
}
+24
-2
slab/menuband/Sources/MenuBand/WaveformView.swift
+24
-2
slab/menuband/Sources/MenuBand/WaveformView.swift
···
13
13
/// driven by MTKView's internal CVDisplayLink at the screen's native
14
14
/// refresh. Hidden when MIDI mode is on.
15
15
final class WaveformView: MTKView {
16
16
+
enum SurfaceStyle {
17
17
+
case standard
18
18
+
case glassEmbedded
19
19
+
}
20
20
+
16
21
weak var menuBand: MenuBandController?
17
22
18
23
private static let barCount = 16
···
44
49
/// we need a per-view lease bit to avoid over-releasing the controller's
45
50
/// shared capture refcount.
46
51
private var hasCaptureLease = false
52
52
+
private var surfaceStyle: SurfaceStyle = .standard
47
53
48
54
var isLive: Bool = false {
49
55
didSet {
···
212
218
}
213
219
214
220
override var isOpaque: Bool { true }
221
221
+
override var mouseDownCanMoveWindow: Bool { true }
222
222
+
override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
215
223
216
224
private func buildPipeline(device: MTLDevice) {
217
225
do {
···
294
302
/// instead of brightening to white, so peak still reads as
295
303
/// "hotter" without washing out against the light substrate.
296
304
func setLightMode(_ isLight: Bool) {
297
297
-
if isLight {
305
305
+
switch (surfaceStyle, isLight) {
306
306
+
case (.standard, true):
298
307
// Warm off-white — closer to a printed page than pure
299
308
// white, so the colored bars don't vibrate against it.
300
309
clearColor = MTLClearColor(red: 0.93, green: 0.92, blue: 0.90, alpha: 1.0)
301
310
uniforms.isLight = 1
302
302
-
} else {
311
311
+
case (.standard, false):
303
312
clearColor = MTLClearColor(red: 0, green: 0, blue: 0, alpha: 1.0)
304
313
uniforms.isLight = 0
314
314
+
case (.glassEmbedded, true):
315
315
+
clearColor = MTLClearColor(red: 0.86, green: 0.88, blue: 0.90, alpha: 1.0)
316
316
+
uniforms.isLight = 1
317
317
+
case (.glassEmbedded, false):
318
318
+
clearColor = MTLClearColor(red: 0.06, green: 0.08, blue: 0.10, alpha: 1.0)
319
319
+
uniforms.isLight = 0
305
320
}
306
321
display()
322
322
+
}
323
323
+
324
324
+
func setSurfaceStyle(_ style: SurfaceStyle) {
325
325
+
guard surfaceStyle != style else { return }
326
326
+
surfaceStyle = style
327
327
+
let isDark = effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua
328
328
+
setLightMode(!isDark)
307
329
}
308
330
309
331
// MARK: - Per-frame audio analysis