Monorepo for Aesthetic.Computer
aesthetic.computer
Unify palette controllers and refine floating palette
- consolidate waveform and floating palette behavior into the unified palette flow
- refine floating palette presentation, interaction, and stable expanded sizing
- carry forward main-branch localization and keymap resource updates needed by the new palette path
- remove legacy menubar strip and piano palette controllers
authored by
Esteban Uribe
and committed by
prompt.ac/@jeffrey
b213c125
bbc5b0c6
+1335
-2428
8 changed files
+7
-4
slab/menuband/Sources/MenuBand/AppDelegate.swift
+7
-4
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 pianoWaveformPalette = PianoWaveformPalette(menuBand: menuBand)
17
17
-
private var floatingPlayPalette: PianoWaveformPalette { pianoWaveformPalette }
18
18
-
private var waveformStrip: PianoWaveformPalette { pianoWaveformPalette }
16
16
+
private lazy var pianoWaveformPalette = UnifiedPianoWaveformPalette(menuBand: menuBand)
17
17
+
private var floatingPlayPalette: UnifiedPianoWaveformPalette { pianoWaveformPalette }
18
18
+
private var waveformStrip: UnifiedPianoWaveformPalette { pianoWaveformPalette }
19
19
private var appBeforePopover: NSRunningApplication?
20
20
private var appBeforeFocusCapture: NSRunningApplication?
21
21
private var focusCaptureArmedByShortcut = false
···
172
172
self.updateIcon()
173
173
self.popoverVC?.refreshHeldNotes()
174
174
self.floatingPlayPalette.refresh()
175
175
-
self.waveformStrip.refreshAppearance()
175
175
+
self.waveformStrip.refresh()
176
176
self.updateWaveformStrip()
177
177
}
178
178
menuBand.onInstrumentVisualChange = { [weak self] in
···
314
314
keyCode: keyCode, isDown: isDown, isRepeat: isRepeat, flags: flags
315
315
)
316
316
if consumed && isDown {
317
317
+
if !self.menuBand.litNotes.isEmpty {
318
318
+
self.waveformStrip.showIfNeeded()
319
319
+
}
317
320
// Use the most-recent lit display note as the wave pivot
318
321
// so the ripple emanates from whichever key the user just
319
322
// played. `litNotes` is updated synchronously on this
+31
-11
slab/menuband/Sources/MenuBand/ArrowKeysIndicator.swift
+31
-11
slab/menuband/Sources/MenuBand/ArrowKeysIndicator.swift
···
14
14
case horizontalPair
15
15
}
16
16
17
17
+
enum Style {
18
18
+
case standard
19
19
+
case prominent
20
20
+
}
21
21
+
17
22
private var pressed: Set<Int> = []
18
23
private var hovered: Int?
19
24
private var trackingArea: NSTrackingArea?
···
24
29
/// keyboard arrows drive (preview note while held, commit on
25
30
/// release).
26
31
var onClick: ((Int, Bool) -> Void)?
32
32
+
var accentColor: NSColor = .controlAccentColor { didSet { needsDisplay = true } }
33
33
+
var style: Style = .standard { didSet { needsDisplay = true } }
34
34
+
var isDarkAppearance: Bool = false { didSet { needsDisplay = true } }
27
35
28
36
var displayMode: DisplayMode = .cluster {
29
37
didSet {
···
68
76
needsDisplay = true
69
77
}
70
78
79
79
+
override var mouseDownCanMoveWindow: Bool { false }
80
80
+
override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
71
81
override var isFlipped: Bool { false }
82
82
+
72
83
73
84
// MARK: - Geometry
74
85
···
150
161
let isHover = (!lit && hovered == idx)
151
162
let path = NSBezierPath(roundedRect: kr, xRadius: radius, yRadius: radius)
152
163
if lit {
153
153
-
NSColor.controlAccentColor.withAlphaComponent(0.85).setFill()
164
164
+
accentColor.withAlphaComponent(0.9).setFill()
154
165
path.fill()
155
166
} else if isHover {
156
156
-
// Rollover wash — soft accent tint behind the glyph,
157
157
-
// no fill on the rest of the cap so it reads as a
158
158
-
// "ready to click" state, not "selected".
159
159
-
NSColor.controlAccentColor.withAlphaComponent(0.18).setFill()
167
167
+
accentColor.withAlphaComponent(style == .prominent ? 0.24 : 0.18).setFill()
168
168
+
path.fill()
169
169
+
} else if style == .prominent {
170
170
+
let idleFill = isDarkAppearance
171
171
+
? NSColor.white.withAlphaComponent(0.08)
172
172
+
: NSColor.black.withAlphaComponent(0.06)
173
173
+
idleFill.setFill()
160
174
path.fill()
161
175
}
162
176
let stroke: NSColor = lit
163
163
-
? NSColor.controlAccentColor
177
177
+
? accentColor
164
178
: isHover
165
165
-
? NSColor.controlAccentColor.withAlphaComponent(0.75)
166
166
-
: NSColor.labelColor.withAlphaComponent(0.55)
179
179
+
? accentColor.withAlphaComponent(style == .prominent ? 0.9 : 0.75)
180
180
+
: style == .prominent
181
181
+
? accentColor.withAlphaComponent(0.58)
182
182
+
: NSColor.labelColor.withAlphaComponent(0.55)
167
183
stroke.setStroke()
168
168
-
path.lineWidth = 0.8
184
184
+
path.lineWidth = style == .prominent ? 1.0 : 0.8
169
185
path.stroke()
170
186
let glyphColor: NSColor = lit
171
187
? .black
172
172
-
: (isHover ? .controlAccentColor : NSColor.labelColor)
188
188
+
: isHover
189
189
+
? accentColor
190
190
+
: style == .prominent
191
191
+
? (isDarkAppearance ? NSColor.white.withAlphaComponent(0.96) : NSColor.black.withAlphaComponent(0.9))
192
192
+
: NSColor.labelColor
173
193
let attrs: [NSAttributedString.Key: Any] = [
174
174
-
.font: NSFont.systemFont(ofSize: 10, weight: .heavy),
194
194
+
.font: NSFont.systemFont(ofSize: style == .prominent ? 10.5 : 10, weight: .heavy),
175
195
.foregroundColor: glyphColor,
176
196
]
177
197
let s = NSAttributedString(string: glyphs[idx], attributes: attrs)
+292
-421
slab/menuband/Sources/MenuBand/FloatingPlayPalette.swift
+292
-421
slab/menuband/Sources/MenuBand/FloatingPlayPalette.swift
···
22
22
override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
23
23
}
24
24
25
25
-
final class FloatingPlayPaletteController: NSObject, NSWindowDelegate {
26
26
-
enum DismissReason {
27
27
-
case closeButton
28
28
-
case shortcut
29
29
-
case programmatic
30
30
-
31
31
-
var shouldRestoreFocus: Bool {
32
32
-
switch self {
33
33
-
case .closeButton, .shortcut:
34
34
-
return true
35
35
-
case .programmatic:
36
36
-
return false
37
37
-
}
38
38
-
}
25
25
+
final class FloatingPlayPaletteViewController: NSViewController {
26
26
+
enum DisplayMode {
27
27
+
case expanded
28
28
+
case collapsed
39
29
}
40
30
41
41
-
private let menuBand: MenuBandController
42
42
-
private let viewController: FloatingPlayPaletteViewController
43
43
-
private var panel: FloatingPlayPalettePanel?
44
44
-
private var keyMonitor: Any?
45
45
-
private var appBeforeOpen: NSRunningApplication?
46
46
-
private var isDismissing = false
47
47
-
private var savedOrigin: NSPoint?
31
31
+
private static let panelCornerRadius: CGFloat = 18
48
32
49
49
-
private static let customOriginXKey = "notepat.floatingPlayPalette.customOriginX"
50
50
-
private static let customOriginYKey = "notepat.floatingPlayPalette.customOriginY"
33
33
+
private let containerView = NSView()
34
34
+
private let paletteView: FloatingPlayPaletteView
35
35
+
private let stripView: UnifiedWaveformStripView
36
36
+
private let closeButton = NSButton()
37
37
+
private let dockButton = NSButton()
38
38
+
private let expandCollapseButton = NSButton()
39
39
+
private var displayedView: NSView?
40
40
+
private var displayMode: DisplayMode = .expanded
41
41
+
private var isPresented = false
42
42
+
private var trackingArea: NSTrackingArea?
43
43
+
private var isMouseInsideView = false
44
44
+
private weak var closeButtonGlassView: NSView?
45
45
+
private weak var dockButtonGlassView: NSView?
46
46
+
private weak var expandCollapseButtonGlassView: NSView?
47
47
+
private let closeButtonSize: CGFloat = 30
48
48
+
private let closeButtonCornerInset: CGFloat = 3
49
49
+
private let gap: CGFloat = 8
51
50
52
52
-
var onDismiss: (() -> Void)?
53
53
-
var onFocusRelease: (() -> Void)?
54
54
-
var onToggleKeymap: (() -> Void)?
55
55
-
var onExpandCollapseToggle: (() -> Void)? {
56
56
-
get { viewController.onExpandCollapseToggle }
57
57
-
set { viewController.onExpandCollapseToggle = newValue }
51
51
+
var onCloseRequested: (() -> Void)?
52
52
+
53
53
+
var onDockRequested: (() -> Void)?
54
54
+
55
55
+
var onTogglePresentationMode: (() -> Void)?
56
56
+
57
57
+
var onStepBackward: (() -> Void)? {
58
58
+
get { stripView.onStepBackward }
59
59
+
set { stripView.onStepBackward = newValue }
58
60
}
59
59
-
var isPianoFocusActive: (() -> Bool)? {
60
60
-
get { viewController.isPianoFocusActive }
61
61
-
set { viewController.isPianoFocusActive = newValue }
61
61
+
62
62
+
var onStepForward: (() -> Void)? {
63
63
+
get { stripView.onStepForward }
64
64
+
set { stripView.onStepForward = newValue }
62
65
}
63
66
64
64
-
var isShown: Bool {
65
65
-
panel?.isVisible == true
67
67
+
var onStepUp: (() -> Void)? {
68
68
+
get { stripView.onStepUp }
69
69
+
set { stripView.onStepUp = newValue }
66
70
}
67
71
68
68
-
init(menuBand: MenuBandController) {
69
69
-
self.menuBand = menuBand
70
70
-
self.viewController = FloatingPlayPaletteViewController(menuBand: menuBand)
71
71
-
self.savedOrigin = Self.loadSavedOrigin()
72
72
-
super.init()
73
73
-
self.viewController.onClose = { [weak self] in
74
74
-
self?.dismiss(reason: .closeButton)
75
75
-
}
72
72
+
var onStepDown: (() -> Void)? {
73
73
+
get { stripView.onStepDown }
74
74
+
set { stripView.onStepDown = newValue }
76
75
}
77
76
78
78
-
func toggleFromShortcut() {
79
79
-
if isShown {
80
80
-
dismiss(reason: .shortcut)
81
81
-
} else {
82
82
-
show()
83
83
-
}
77
77
+
var isPianoFocusActive: (() -> Bool)? {
78
78
+
get { paletteView.isPianoFocusActive }
79
79
+
set { paletteView.isPianoFocusActive = newValue }
84
80
}
85
81
86
86
-
func showFromCommand(restoringTo previousApp: NSRunningApplication? = nil) {
87
87
-
show(restoringTo: previousApp)
82
82
+
init(menuBand: MenuBandController) {
83
83
+
self.paletteView = FloatingPlayPaletteView(menuBand: menuBand)
84
84
+
self.stripView = UnifiedWaveformStripView(menuBand: menuBand)
85
85
+
super.init(nibName: nil, bundle: nil)
86
86
+
preferredContentSize = preferredSize(for: displayMode)
88
87
}
89
88
90
90
-
func show(restoringTo previousApp: NSRunningApplication? = nil) {
91
91
-
if panel == nil { buildPanel() }
92
92
-
guard let panel = panel else { return }
89
89
+
@available(*, unavailable)
90
90
+
required init?(coder: NSCoder) {
91
91
+
nil
92
92
+
}
93
93
94
94
-
if panel.isVisible {
95
95
-
panel.makeKeyAndOrderFront(nil)
96
96
-
return
97
97
-
}
94
94
+
override func loadView() {
95
95
+
view = containerView
96
96
+
containerView.wantsLayer = true
97
97
+
configureOverlayButton(
98
98
+
closeButton,
99
99
+
symbolName: "xmark",
100
100
+
toolTip: "Close",
101
101
+
action: #selector(closeClicked(_:))
102
102
+
)
103
103
+
configureOverlayButton(
104
104
+
dockButton,
105
105
+
symbolName: "menubar.dock.rectangle",
106
106
+
toolTip: "Dock Below Menubar Piano",
107
107
+
action: #selector(dockClicked(_:))
108
108
+
)
109
109
+
configureOverlayButton(
110
110
+
expandCollapseButton,
111
111
+
symbolName: "square.resize.down",
112
112
+
toolTip: "Collapse",
113
113
+
action: #selector(expandCollapseClicked(_:))
114
114
+
)
115
115
+
containerView.addSubview(closeButton)
116
116
+
containerView.addSubview(dockButton)
117
117
+
containerView.addSubview(expandCollapseButton)
118
118
+
installOverlayGlassBackgrounds()
119
119
+
NSLayoutConstraint.activate([
120
120
+
closeButton.topAnchor.constraint(
121
121
+
equalTo: containerView.topAnchor,
122
122
+
constant: Self.panelCornerRadius - closeButtonSize / 2 + closeButtonCornerInset
123
123
+
),
124
124
+
closeButton.leadingAnchor.constraint(
125
125
+
equalTo: containerView.leadingAnchor,
126
126
+
constant: Self.panelCornerRadius - closeButtonSize / 2 + closeButtonCornerInset
127
127
+
),
128
128
+
closeButton.widthAnchor.constraint(equalToConstant: closeButtonSize),
129
129
+
closeButton.heightAnchor.constraint(equalToConstant: closeButtonSize),
98
130
99
99
-
appBeforeOpen = previousApp ?? currentFrontmostOtherApp()
100
100
-
viewController.refresh()
101
101
-
panel.setFrame(restoredFrame(size: viewController.preferredContentSize), display: false)
131
131
+
expandCollapseButton.topAnchor.constraint(equalTo: closeButton.topAnchor),
132
132
+
expandCollapseButton.trailingAnchor.constraint(
133
133
+
equalTo: containerView.trailingAnchor,
134
134
+
constant: -(Self.panelCornerRadius - closeButtonSize / 2 + closeButtonCornerInset)
135
135
+
),
136
136
+
expandCollapseButton.widthAnchor.constraint(equalToConstant: closeButtonSize),
137
137
+
expandCollapseButton.heightAnchor.constraint(equalToConstant: closeButtonSize),
102
138
103
103
-
NSApp.activate(ignoringOtherApps: true)
104
104
-
panel.makeKeyAndOrderFront(nil)
105
105
-
viewController.setPresented(true)
106
106
-
installMonitors()
107
107
-
}
108
108
-
109
109
-
func dismiss(reason: DismissReason = .programmatic) {
110
110
-
guard !isDismissing else { return }
111
111
-
guard isShown || keyMonitor != nil else { return }
112
112
-
113
113
-
isDismissing = true
114
114
-
removeMonitors()
115
115
-
viewController.setPresented(false)
116
116
-
viewController.clearInteraction()
117
117
-
menuBand.releaseAllHeldNotes()
118
118
-
panel?.orderOut(nil)
119
119
-
onDismiss?()
120
120
-
if reason.shouldRestoreFocus {
121
121
-
restorePreviousAppFocus()
122
122
-
}
123
123
-
appBeforeOpen = nil
124
124
-
isDismissing = false
139
139
+
dockButton.topAnchor.constraint(equalTo: closeButton.topAnchor),
140
140
+
dockButton.trailingAnchor.constraint(equalTo: expandCollapseButton.leadingAnchor, constant: -gap),
141
141
+
dockButton.widthAnchor.constraint(equalToConstant: closeButtonSize),
142
142
+
dockButton.heightAnchor.constraint(equalToConstant: closeButtonSize),
143
143
+
])
144
144
+
installTrackingArea()
145
145
+
installDisplayedView()
146
146
+
isMouseInsideView = isMouseInsideContainer()
147
147
+
setOverlayControlsVisible(isMouseInsideView, animated: false)
125
148
}
126
149
127
150
func refresh() {
128
128
-
guard isShown else { return }
129
129
-
viewController.refresh()
130
130
-
resizePanelToCurrentContent()
151
151
+
paletteView.refresh()
152
152
+
stripView.refresh()
153
153
+
preferredContentSize = preferredSize(for: displayMode)
131
154
}
132
155
133
156
func clearInteraction() {
134
134
-
viewController.clearInteraction()
157
157
+
paletteView.clearInteraction()
135
158
}
136
159
137
137
-
var isKeyboardFocused: Bool {
138
138
-
panel?.isKeyWindow == true
160
160
+
func setPresented(_ isPresented: Bool) {
161
161
+
self.isPresented = isPresented
162
162
+
updatePresentationState()
139
163
}
140
164
141
141
-
func releaseKeyboardFocus() {
142
142
-
guard isShown else { return }
143
143
-
restorePreviousAppFocus()
144
144
-
}
145
145
-
146
146
-
private func buildPanel() {
147
147
-
let p = FloatingPlayPalettePanel(
148
148
-
contentRect: NSRect(origin: .zero, size: viewController.preferredContentSize),
149
149
-
styleMask: [.titled, .closable, .fullSizeContentView],
150
150
-
backing: .buffered,
151
151
-
defer: false
152
152
-
)
153
153
-
p.contentViewController = viewController
154
154
-
p.delegate = self
155
155
-
p.isOpaque = false
156
156
-
p.backgroundColor = .clear
157
157
-
p.hasShadow = true
158
158
-
p.level = .floating
159
159
-
p.animationBehavior = .none
160
160
-
p.collectionBehavior = [.transient]
161
161
-
p.hidesOnDeactivate = false
162
162
-
p.canHide = false
163
163
-
p.isMovableByWindowBackground = true
164
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
165
165
+
func setDisplayMode(_ displayMode: DisplayMode) {
166
166
+
guard self.displayMode != displayMode else {
167
167
+
preferredContentSize = preferredSize(for: displayMode)
168
168
+
updatePresentationState()
169
169
+
return
170
170
}
171
171
-
if let mini = p.standardWindowButton(.miniaturizeButton) {
172
172
-
mini.isHidden = true
171
171
+
self.displayMode = displayMode
172
172
+
if isViewLoaded {
173
173
+
installDisplayedView()
173
174
}
174
174
-
if let zoom = p.standardWindowButton(.zoomButton) {
175
175
-
zoom.isHidden = true
176
176
-
}
177
177
-
panel = p
175
175
+
preferredContentSize = preferredSize(for: displayMode)
176
176
+
updatePresentationState()
178
177
}
179
178
180
180
-
private func installMonitors() {
181
181
-
if keyMonitor == nil {
182
182
-
keyMonitor = NSEvent.addLocalMonitorForEvents(matching: [.keyDown, .keyUp]) { [weak self] event in
183
183
-
guard let self = self, self.panel?.isKeyWindow == true else { return event }
184
184
-
let isDown = event.type == .keyDown
185
185
-
if isDown && event.keyCode == 53 /* kVK_Escape */ {
186
186
-
self.onFocusRelease?()
187
187
-
return nil
188
188
-
}
189
189
-
if isDown && MenuBandShortcutPreferences.focusShortcut.matches(event: event) {
190
190
-
self.onFocusRelease?()
191
191
-
return nil
192
192
-
}
193
193
-
if isDown && MenuBandShortcut.layoutToggle.matches(event: event) {
194
194
-
self.onToggleKeymap?()
195
195
-
return nil
196
196
-
}
197
197
-
let consumed = self.menuBand.handleLocalKey(
198
198
-
keyCode: event.keyCode,
199
199
-
isDown: isDown,
200
200
-
isRepeat: event.isARepeat,
201
201
-
flags: event.modifierFlags
202
202
-
)
203
203
-
if consumed {
204
204
-
self.refresh()
205
205
-
return nil
206
206
-
}
207
207
-
return event
208
208
-
}
179
179
+
private func installDisplayedView() {
180
180
+
let nextView: NSView
181
181
+
switch displayMode {
182
182
+
case .expanded:
183
183
+
nextView = paletteView
184
184
+
case .collapsed:
185
185
+
nextView = stripView
209
186
}
187
187
+
188
188
+
guard displayedView !== nextView else { return }
189
189
+
displayedView?.removeFromSuperview()
190
190
+
nextView.translatesAutoresizingMaskIntoConstraints = false
191
191
+
containerView.addSubview(nextView, positioned: .below, relativeTo: nil)
192
192
+
NSLayoutConstraint.activate([
193
193
+
nextView.leadingAnchor.constraint(equalTo: containerView.leadingAnchor),
194
194
+
nextView.trailingAnchor.constraint(equalTo: containerView.trailingAnchor),
195
195
+
nextView.topAnchor.constraint(equalTo: containerView.topAnchor),
196
196
+
nextView.bottomAnchor.constraint(equalTo: containerView.bottomAnchor),
197
197
+
])
198
198
+
displayedView = nextView
210
199
}
211
200
212
212
-
private func removeMonitors() {
213
213
-
if let m = keyMonitor {
214
214
-
NSEvent.removeMonitor(m)
215
215
-
keyMonitor = nil
201
201
+
private func preferredSize(for displayMode: DisplayMode) -> NSSize {
202
202
+
switch displayMode {
203
203
+
case .expanded:
204
204
+
return paletteView.fittingSize
205
205
+
case .collapsed:
206
206
+
return stripView.fittingSize
216
207
}
217
208
}
218
209
219
219
-
private func resizePanelToCurrentContent() {
220
220
-
guard let panel = panel, panel.isVisible else { return }
221
221
-
let size = viewController.preferredContentSize
222
222
-
let old = panel.frame
223
223
-
guard abs(old.width - size.width) > 0.5 || abs(old.height - size.height) > 0.5 else { return }
224
224
-
var frame = NSRect(
225
225
-
x: old.origin.x,
226
226
-
y: old.origin.y,
227
227
-
width: size.width,
228
228
-
height: size.height
229
229
-
)
230
230
-
let visible = (panel.screen ?? NSScreen.main)?.visibleFrame
231
231
-
?? NSRect(x: 0, y: 0, width: 1024, height: 768)
232
232
-
frame = clamped(frame, to: visible)
233
233
-
panel.setFrame(frame, display: true)
234
234
-
persistPanelOrigin()
210
210
+
private func updatePresentationState() {
211
211
+
paletteView.setPresented(isPresented && displayMode == .expanded)
212
212
+
stripView.setLive(isPresented && displayMode == .collapsed)
213
213
+
let controlsHidden = false
214
214
+
[closeButton, dockButton, expandCollapseButton, closeButtonGlassView, dockButtonGlassView, expandCollapseButtonGlassView]
215
215
+
.compactMap { $0 }
216
216
+
.forEach { $0.isHidden = controlsHidden }
217
217
+
updateExpandCollapseButtonAppearance()
218
218
+
isMouseInsideView = isMouseInsideContainer()
219
219
+
setOverlayControlsVisible(isMouseInsideView, animated: false)
220
220
+
applyOverlayButtonAppearance()
235
221
}
236
222
237
237
-
private func frameForCurrentMouseScreen(size: NSSize) -> NSRect {
238
238
-
let mouse = NSEvent.mouseLocation
239
239
-
let screen = NSScreen.screens.first { NSMouseInRect(mouse, $0.frame, false) }
240
240
-
?? NSScreen.main
241
241
-
?? NSScreen.screens.first
242
242
-
let visible = screen?.visibleFrame ?? NSRect(x: 0, y: 0, width: 1024, height: 768)
243
243
-
let margin: CGFloat = 16
244
244
-
let preferred = NSPoint(
245
245
-
x: visible.midX - size.width / 2,
246
246
-
y: visible.midY + visible.height * 0.12 - size.height / 2
247
247
-
)
248
248
-
let x = min(max(preferred.x, visible.minX + margin), visible.maxX - size.width - margin)
249
249
-
let y = min(max(preferred.y, visible.minY + margin), visible.maxY - size.height - margin)
250
250
-
return NSRect(origin: NSPoint(x: x, y: y), size: size)
251
251
-
}
252
252
-
253
253
-
private func restoredFrame(size: NSSize) -> NSRect {
254
254
-
guard let savedOrigin else {
255
255
-
return frameForCurrentMouseScreen(size: size)
223
223
+
private func configureOverlayButton(
224
224
+
_ button: NSButton,
225
225
+
symbolName: String,
226
226
+
toolTip: String,
227
227
+
action: Selector
228
228
+
) {
229
229
+
let config = NSImage.SymbolConfiguration(pointSize: 12, weight: .semibold)
230
230
+
button.translatesAutoresizingMaskIntoConstraints = false
231
231
+
button.image = NSImage(systemSymbolName: symbolName, accessibilityDescription: toolTip)?
232
232
+
.withSymbolConfiguration(config)
233
233
+
button.isBordered = false
234
234
+
button.imagePosition = .imageOnly
235
235
+
button.contentTintColor = .white.withAlphaComponent(0.92)
236
236
+
button.toolTip = toolTip
237
237
+
button.target = self
238
238
+
button.action = action
239
239
+
button.alphaValue = 0
240
240
+
button.wantsLayer = true
241
241
+
button.layer?.cornerRadius = closeButtonSize / 2
242
242
+
button.layer?.borderWidth = 1
243
243
+
if #available(macOS 10.15, *) {
244
244
+
button.layer?.cornerCurve = .continuous
256
245
}
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
246
}
263
247
264
264
-
private func clamped(_ frame: NSRect, to visible: NSRect) -> NSRect {
265
265
-
let margin: CGFloat = 16
266
266
-
let x = min(max(frame.origin.x, visible.minX + margin), visible.maxX - frame.width - margin)
267
267
-
let y = min(max(frame.origin.y, visible.minY + margin), visible.maxY - frame.height - margin)
268
268
-
return NSRect(origin: NSPoint(x: x, y: y), size: frame.size)
248
248
+
private func installOverlayGlassBackgrounds() {
249
249
+
guard FloatingPlayPaletteView.shouldUseLiquidGlass, #available(macOS 26.0, *) else { return }
250
250
+
self.closeButtonGlassView = installGlassBackground(for: closeButton)
251
251
+
self.dockButtonGlassView = installGlassBackground(for: dockButton)
252
252
+
self.expandCollapseButtonGlassView = installGlassBackground(for: expandCollapseButton)
269
253
}
270
254
271
271
-
private func currentFrontmostOtherApp() -> NSRunningApplication? {
272
272
-
let frontmost = NSWorkspace.shared.frontmostApplication
273
273
-
guard frontmost?.bundleIdentifier != Bundle.main.bundleIdentifier else { return nil }
274
274
-
return frontmost
255
255
+
@available(macOS 26.0, *)
256
256
+
private func installGlassBackground(for target: NSView) -> NSView {
257
257
+
let glassView = FloatingPaletteGlassEffectView()
258
258
+
glassView.translatesAutoresizingMaskIntoConstraints = false
259
259
+
glassView.cornerRadius = closeButtonSize / 2
260
260
+
containerView.addSubview(glassView, positioned: .below, relativeTo: target)
261
261
+
NSLayoutConstraint.activate([
262
262
+
glassView.leadingAnchor.constraint(equalTo: target.leadingAnchor),
263
263
+
glassView.trailingAnchor.constraint(equalTo: target.trailingAnchor),
264
264
+
glassView.topAnchor.constraint(equalTo: target.topAnchor),
265
265
+
glassView.bottomAnchor.constraint(equalTo: target.bottomAnchor),
266
266
+
])
267
267
+
return glassView
275
268
}
276
269
277
277
-
private func restorePreviousAppFocus() {
278
278
-
guard let app = appBeforeOpen,
279
279
-
!app.isTerminated,
280
280
-
app.bundleIdentifier != Bundle.main.bundleIdentifier else { return }
281
281
-
app.activate(options: [.activateIgnoringOtherApps])
282
282
-
}
283
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)
270
270
+
private func setOverlayControlsVisible(_ isVisible: Bool, animated: Bool = true) {
271
271
+
let alpha: CGFloat = isVisible ? 1.0 : 0.0
272
272
+
let views = [closeButton, dockButton, expandCollapseButton, closeButtonGlassView, dockButtonGlassView, expandCollapseButtonGlassView]
273
273
+
.compactMap { $0 }
274
274
+
if animated {
275
275
+
NSAnimationContext.runAnimationGroup { context in
276
276
+
context.duration = 0.12
277
277
+
closeButton.animator().alphaValue = alpha
278
278
+
dockButton.animator().alphaValue = alpha
279
279
+
expandCollapseButton.animator().alphaValue = alpha
280
280
+
closeButtonGlassView?.animator().alphaValue = alpha
281
281
+
dockButtonGlassView?.animator().alphaValue = alpha
282
282
+
expandCollapseButtonGlassView?.animator().alphaValue = alpha
283
283
+
}
284
284
+
} else {
285
285
+
views.forEach { $0.alphaValue = alpha }
286
286
+
}
294
287
}
295
288
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)
289
289
+
private func installTrackingArea() {
290
290
+
if let trackingArea {
291
291
+
containerView.removeTrackingArea(trackingArea)
292
292
+
}
293
293
+
let trackingArea = NSTrackingArea(
294
294
+
rect: .zero,
295
295
+
options: [.mouseEnteredAndExited, .activeAlways, .inVisibleRect],
296
296
+
owner: self,
297
297
+
userInfo: nil
303
298
)
299
299
+
containerView.addTrackingArea(trackingArea)
300
300
+
self.trackingArea = trackingArea
304
301
}
305
302
306
306
-
deinit {
307
307
-
dismiss(reason: .programmatic)
303
303
+
override func mouseEntered(with event: NSEvent) {
304
304
+
isMouseInsideView = true
305
305
+
setOverlayControlsVisible(true)
308
306
}
309
309
-
}
310
307
311
311
-
private final class FloatingPlayPaletteViewController: NSViewController {
312
312
-
private let paletteView: FloatingPlayPaletteView
313
313
-
var onClose: (() -> Void)? {
314
314
-
get { paletteView.onClose }
315
315
-
set { paletteView.onClose = newValue }
316
316
-
}
317
317
-
var onExpandCollapseToggle: (() -> Void)? {
318
318
-
get { paletteView.onExpandCollapseToggle }
319
319
-
set { paletteView.onExpandCollapseToggle = newValue }
320
320
-
}
321
321
-
var isPianoFocusActive: (() -> Bool)? {
322
322
-
get { paletteView.isPianoFocusActive }
323
323
-
set { paletteView.isPianoFocusActive = newValue }
324
324
-
}
325
325
-
var onHoverChanged: ((Bool) -> Void)? {
326
326
-
get { paletteView.onHoverChanged }
327
327
-
set { paletteView.onHoverChanged = newValue }
308
308
+
override func mouseExited(with event: NSEvent) {
309
309
+
isMouseInsideView = false
310
310
+
setOverlayControlsVisible(false)
328
311
}
329
312
330
330
-
init(menuBand: MenuBandController) {
331
331
-
self.paletteView = FloatingPlayPaletteView(menuBand: menuBand)
332
332
-
super.init(nibName: nil, bundle: nil)
333
333
-
preferredContentSize = paletteView.fittingSize
313
313
+
private func isMouseInsideContainer() -> Bool {
314
314
+
guard let window = containerView.window else { return false }
315
315
+
let location = containerView.convert(window.mouseLocationOutsideOfEventStream, from: nil)
316
316
+
return containerView.bounds.contains(location)
334
317
}
335
318
336
336
-
@available(*, unavailable)
337
337
-
required init?(coder: NSCoder) {
338
338
-
nil
319
319
+
private func applyOverlayButtonAppearance() {
320
320
+
let effectiveView: NSView
321
321
+
switch displayMode {
322
322
+
case .expanded:
323
323
+
effectiveView = paletteView
324
324
+
case .collapsed:
325
325
+
effectiveView = stripView
326
326
+
}
327
327
+
let isDark = effectiveView.effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua
328
328
+
let tintColor = paletteView.paletteTintColor
329
329
+
if FloatingPlayPaletteView.shouldUseLiquidGlass, #available(macOS 26.0, *) {
330
330
+
for view in [closeButtonGlassView, dockButtonGlassView, expandCollapseButtonGlassView] {
331
331
+
(view as? NSGlassEffectView)?.style = .clear
332
332
+
(view as? NSGlassEffectView)?.tintColor = tintColor.withAlphaComponent(0.34)
333
333
+
}
334
334
+
for button in [closeButton, dockButton, expandCollapseButton] {
335
335
+
button.layer?.backgroundColor = NSColor.clear.cgColor
336
336
+
button.layer?.borderColor = NSColor.clear.cgColor
337
337
+
}
338
338
+
} else {
339
339
+
let border = NSColor.white.withAlphaComponent(0.28).cgColor
340
340
+
let background = NSColor.windowBackgroundColor.withAlphaComponent(isDark ? 0.18 : 0.22).cgColor
341
341
+
for button in [closeButton, dockButton, expandCollapseButton] {
342
342
+
button.layer?.backgroundColor = background
343
343
+
button.layer?.borderColor = border
344
344
+
}
345
345
+
}
339
346
}
340
347
341
341
-
override func loadView() {
342
342
-
view = paletteView
348
348
+
private func updateExpandCollapseButtonAppearance() {
349
349
+
let symbolName = displayMode == .expanded ? "square.resize.down" : "square.resize.up"
350
350
+
let toolTip = displayMode == .expanded ? "Collapse" : "Expand floating piano"
351
351
+
let config = NSImage.SymbolConfiguration(pointSize: 12, weight: .semibold)
352
352
+
expandCollapseButton.image = NSImage(systemSymbolName: symbolName, accessibilityDescription: toolTip)?
353
353
+
.withSymbolConfiguration(config)
354
354
+
expandCollapseButton.toolTip = toolTip
343
355
}
344
356
345
345
-
func refresh() {
346
346
-
paletteView.refresh()
347
347
-
preferredContentSize = paletteView.fittingSize
357
357
+
@objc private func closeClicked(_ sender: NSButton) {
358
358
+
onCloseRequested?()
348
359
}
349
360
350
350
-
func clearInteraction() {
351
351
-
paletteView.clearInteraction()
361
361
+
@objc private func dockClicked(_ sender: NSButton) {
362
362
+
onDockRequested?()
352
363
}
353
364
354
354
-
func setPresented(_ isPresented: Bool) {
355
355
-
paletteView.setPresented(isPresented)
365
365
+
@objc private func expandCollapseClicked(_ sender: NSButton) {
366
366
+
onTogglePresentationMode?()
356
367
}
357
368
}
358
369
···
371
382
return FloatingPaletteVisualStyleOverride(rawValue: defaultsValue)
372
383
}
373
384
374
374
-
private static var shouldUseLiquidGlass: Bool {
385
385
+
static var shouldUseLiquidGlass: Bool {
375
386
switch visualStyleOverride {
376
387
case .liquid:
377
388
if #available(macOS 26.0, *) { return true }
···
398
409
private let instrumentReadout = NSTextField(labelWithString: "")
399
410
private let instrumentTitleRow: NSStackView
400
411
private let pianoView: FloatingPianoView
401
401
-
private let closeButton = NSButton()
402
402
-
private let dockButton = NSButton()
403
403
-
private let expandCollapseButton = NSButton()
404
412
private let shortcutHintRow = NSStackView()
405
413
private let focusHintLabel = NSTextField(labelWithString: "")
406
414
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
415
private weak var paletteGlassView: NSView?
411
416
private weak var waveformGlassView: NSView?
412
417
private weak var waveformSectionGlassView: NSView?
···
418
423
/// at 2× scale so it's legible at the floating palette's size.
419
424
private let qwertyView = QwertyLayoutView()
420
425
421
421
-
var onClose: (() -> Void)?
422
422
-
var onExpandCollapseToggle: (() -> Void)?
423
426
var isPianoFocusActive: (() -> Bool)?
424
427
var onHoverChanged: ((Bool) -> Void)?
425
428
426
429
private let pianoScale: CGFloat = 1.6
427
430
private let inset: CGFloat = 14
428
431
private let gap: CGFloat = 8
429
429
-
private let closeButtonSize: CGFloat = 30
430
430
-
private let closeButtonCornerInset: CGFloat = 3
431
432
private let hintHeight: CGFloat = 20
432
433
private let heldNotesRowHeight: CGFloat = 26
433
434
private let chordCandidatesRowHeight: CGFloat = 30
434
435
private var waveformHeightConstraint: NSLayoutConstraint?
435
436
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
440
440
+
private static let expandedPanelWidth: CGFloat = 440
440
441
441
442
init(menuBand: MenuBandController) {
442
443
self.menuBand = menuBand
···
500
501
instrumentTitleRow.spacing = 0
501
502
instrumentTitleRow.translatesAutoresizingMaskIntoConstraints = false
502
503
pianoView.translatesAutoresizingMaskIntoConstraints = false
503
503
-
closeButton.translatesAutoresizingMaskIntoConstraints = false
504
504
-
dockButton.translatesAutoresizingMaskIntoConstraints = false
505
505
-
expandCollapseButton.translatesAutoresizingMaskIntoConstraints = false
506
504
shortcutHintRow.orientation = .horizontal
507
505
shortcutHintRow.alignment = .centerY
508
506
shortcutHintRow.distribution = .fill
···
555
553
layoutHintLabel.alignment = .left
556
554
focusHintLabel.alignment = .right
557
555
updateShortcutHint()
558
558
-
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()
578
578
-
addSubview(closeButton)
579
579
-
addSubview(dockButton)
580
580
-
addSubview(expandCollapseButton)
581
556
installLiquidGlassBackgrounds()
582
557
583
558
let keyboardSize = self.keyboardSize()
···
589
564
let titleSpacers = instrumentTitleRow.arrangedSubviews
590
565
591
566
NSLayoutConstraint.activate([
592
592
-
widthAnchor.constraint(equalToConstant: keyboardSize.width + inset * 2),
567
567
+
widthAnchor.constraint(
568
568
+
equalToConstant: max(keyboardSize.width + inset * 2, Self.expandedPanelWidth)
569
569
+
),
593
570
594
571
contentStack.topAnchor.constraint(equalTo: topAnchor, constant: inset),
595
572
contentStack.leadingAnchor.constraint(equalTo: leadingAnchor, constant: inset),
···
599
576
waveformSection.leadingAnchor.constraint(equalTo: contentStack.leadingAnchor),
600
577
waveformSection.trailingAnchor.constraint(equalTo: contentStack.trailingAnchor),
601
578
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),
612
612
-
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),
625
625
-
626
579
heldNotesStack.centerXAnchor.constraint(equalTo: heldNotesRow.centerXAnchor),
627
580
heldNotesStack.centerYAnchor.constraint(equalTo: heldNotesRow.centerYAnchor),
628
581
heldNotesStack.leadingAnchor.constraint(greaterThanOrEqualTo: heldNotesRow.leadingAnchor, constant: 6),
···
660
613
instrumentTitleRow.leadingAnchor.constraint(equalTo: waveformSection.leadingAnchor, constant: 6),
661
614
instrumentTitleRow.trailingAnchor.constraint(equalTo: waveformSection.trailingAnchor, constant: -6),
662
615
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),
666
616
667
617
shortcutHintRow.leadingAnchor.constraint(equalTo: contentStack.leadingAnchor),
668
618
shortcutHintRow.trailingAnchor.constraint(equalTo: contentStack.trailingAnchor),
···
706
656
below: waveformSection,
707
657
cornerRadius: Self.sectionCornerRadius
708
658
)
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
659
self.pianoGlassView = installGlassBackground(
725
660
matchedTo: pianoView,
726
661
below: pianoView,
···
774
709
775
710
override func mouseEntered(with event: NSEvent) {
776
711
super.mouseEntered(with: event)
777
777
-
setCloseControlVisible(true)
778
712
onHoverChanged?(true)
779
713
}
780
714
781
715
override func mouseExited(with event: NSEvent) {
782
716
super.mouseExited(with: event)
783
783
-
setCloseControlVisible(false)
784
717
onHoverChanged?(false)
785
718
}
786
719
···
840
773
waveformView.alphaValue = (menuBand?.midiMode ?? false) ? 0.35 : 1.0
841
774
}
842
775
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
-
856
776
private func applyAppearanceToVisualizer() {
857
777
let isDark = effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua
858
778
waveformView.setLightMode(!isDark)
···
867
787
868
788
private func applyWaveformTint() {
869
789
guard let menuBand else { return }
870
870
-
let paletteTint: NSColor
871
790
if menuBand.midiMode {
872
791
waveformView.setDotMatrix(MenuBandPopoverViewController.midiDotPattern)
873
792
waveformView.setBaseColor(.controlAccentColor)
874
793
waveformSection.layer?.borderColor = NSColor.controlAccentColor
875
794
.withAlphaComponent(0.24).cgColor
876
876
-
paletteTint = NSColor.controlAccentColor.withAlphaComponent(0.20)
877
795
} else {
878
796
waveformView.setDotMatrix(nil)
879
797
let safe = max(0, min(127, Int(menuBand.effectiveMelodicProgram)))
···
881
799
waveformView.setBaseColor(familyColor)
882
800
waveformSection.layer?.borderColor = familyColor
883
801
.withAlphaComponent(0.22).cgColor
884
884
-
paletteTint = familyColor.withAlphaComponent(0.16)
885
802
}
886
803
if #available(macOS 26.0, *) {
804
804
+
let paletteTint = paletteTintColor
887
805
for view in [paletteGlassView, waveformSectionGlassView, pianoGlassView, keymapGlassView, hintGlassView] {
888
806
(view as? NSGlassEffectView)?.tintColor = paletteTint
889
807
}
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
-
}
905
808
}
906
809
}
907
810
811
811
+
var paletteTintColor: NSColor {
812
812
+
guard let menuBand else { return NSColor.controlAccentColor.withAlphaComponent(0.20) }
813
813
+
if menuBand.midiMode {
814
814
+
return NSColor.controlAccentColor.withAlphaComponent(0.20)
815
815
+
}
816
816
+
let safe = max(0, min(127, Int(menuBand.effectiveMelodicProgram)))
817
817
+
return InstrumentListView.colorForProgram(safe).withAlphaComponent(0.16)
818
818
+
}
819
819
+
908
820
private func keyboardSize() -> NSSize {
909
821
withFloatingPaletteKeyboard(menuBand: menuBand) {
910
822
let piano = KeyboardIconRenderer.pianoImageSize(layout: .tightActiveRange)
···
1045
957
: "Focus Piano: \(focusShortcut)"
1046
958
}
1047
959
1048
1048
-
@objc private func closeClicked(_ sender: NSButton) {
1049
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
1089
1089
-
}
1090
960
}
1091
961
1092
962
private final class FloatingPianoView: NSView {
···
1119
989
}
1120
990
1121
991
override var acceptsFirstResponder: Bool { true }
992
992
+
override var mouseDownCanMoveWindow: Bool { false }
1122
993
1123
994
func refreshLayout() {
1124
995
let preferredSize = preferredSize()
-1812
slab/menuband/Sources/MenuBand/MenuBarWaveformStrip.swift
-1812
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
-
938
938
-
/// Thin floating waveform strip that slides down from beneath the menubar
939
939
-
/// piano when notes are played, and slides back up after a configurable
940
940
-
/// idle delay. Hidden whenever the settings popover or floating piano
941
941
-
/// palette is visible to avoid visual clutter.
942
942
-
///
943
943
-
/// The panel sits one level below `NSWindow.Level.mainMenu` so the menubar
944
944
-
/// itself occludes it. The slide animation moves the panel from behind the
945
945
-
/// menubar downward into view, and reverses to hide.
946
946
-
private final class LiquidMenuBarWaveformStrip: NSObject, MenuBarWaveformStripImplementation {
947
947
-
private let menuBand: MenuBandController
948
948
-
private let waveformView = WaveformView()
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()
954
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()
959
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?
965
965
-
private var panel: NSPanel?
966
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)?
972
972
-
973
973
-
/// How long to keep the strip visible after the last note ends.
974
974
-
private let hideDelay: TimeInterval = 2.0
975
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?
979
979
-
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"
996
996
-
997
997
-
/// Animation duration in seconds.
998
998
-
private static let fadeInDuration: TimeInterval = 0.18
999
999
-
private static let fadeOutDuration: TimeInterval = 0.18
1000
1000
-
1001
1001
-
/// Window level just below the menubar so the menubar occludes the
1002
1002
-
/// strip while it's tucked behind.
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
-
}
1031
1031
-
1032
1032
-
/// CVDisplayLink-driven slide animation. NSAnimationContext + animator()
1033
1033
-
/// proxy doesn't reliably move borderless non-activating panels, so we
1034
1034
-
/// drive the frame ourselves at display refresh rate.
1035
1035
-
private var slideLink: CVDisplayLink?
1036
1036
-
private var slideStartTime: CFTimeInterval = 0
1037
1037
-
private var slideFromY: CGFloat = 0
1038
1038
-
private var slideToY: CGFloat = 0
1039
1039
-
private var slideCompletion: (() -> Void)?
1040
1040
-
private var isSliding = false
1041
1041
-
private var isPointerInsideStrip = false
1042
1042
-
private var isDraggingStrip = false
1043
1043
-
1044
1044
-
/// True while the strip panel is on screen (visible or animating in).
1045
1045
-
var isShown: Bool { panel?.isVisible == true }
1046
1046
-
var isDocked: Bool { customOrigin == nil }
1047
1047
-
1048
1048
-
/// External suppression — callers set this when the popover or floating
1049
1049
-
/// palette opens. While suppressed, `showIfNeeded` is a no-op and any
1050
1050
-
/// visible strip is immediately hidden.
1051
1051
-
var suppressed: Bool = false {
1052
1052
-
didSet {
1053
1053
-
guard suppressed != oldValue else { return }
1054
1054
-
if suppressed { hide(animated: false) }
1055
1055
-
}
1056
1056
-
}
1057
1057
-
1058
1058
-
init(menuBand: MenuBandController) {
1059
1059
-
self.menuBand = menuBand
1060
1060
-
super.init()
1061
1061
-
customOrigin = loadCustomOrigin()
1062
1062
-
waveformView.menuBand = menuBand
1063
1063
-
waveformView.setSurfaceStyle(.glassEmbedded)
1064
1064
-
waveformBezel.wantsLayer = true
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
-
}
1076
1076
-
heldNotesStack.orientation = .horizontal
1077
1077
-
heldNotesStack.alignment = .centerY
1078
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()
1157
1157
-
}
1158
1158
-
1159
1159
-
/// Pre-build the panel so the first note doesn't pay construction cost.
1160
1160
-
func warmUp() {
1161
1161
-
if panel == nil { buildPanel() }
1162
1162
-
}
1163
1163
-
1164
1164
-
deinit {
1165
1165
-
stopSlide()
1166
1166
-
}
1167
1167
-
1168
1168
-
// MARK: - Show / hide
1169
1169
-
1170
1170
-
/// Call whenever `litNotes` becomes non-empty (a note starts).
1171
1171
-
func showIfNeeded() {
1172
1172
-
guard !suppressed else { return }
1173
1173
-
cancelPendingHide()
1174
1174
-
if !isShown && !isSliding { show() }
1175
1175
-
}
1176
1176
-
1177
1177
-
/// Call whenever `litNotes` becomes empty (all notes released).
1178
1178
-
func scheduleHide() {
1179
1179
-
guard !isPointerInsideStrip, !isDraggingStrip else {
1180
1180
-
cancelPendingHide()
1181
1181
-
return
1182
1182
-
}
1183
1183
-
cancelPendingHide()
1184
1184
-
let work = DispatchWorkItem { [weak self] in
1185
1185
-
self?.hide(animated: true)
1186
1186
-
}
1187
1187
-
hideWorkItem = work
1188
1188
-
DispatchQueue.main.asyncAfter(deadline: .now() + hideDelay, execute: work)
1189
1189
-
}
1190
1190
-
1191
1191
-
/// Immediately tear down (app termination, etc.).
1192
1192
-
func dismiss() {
1193
1193
-
cancelPendingHide()
1194
1194
-
stopSlide()
1195
1195
-
isPointerInsideStrip = false
1196
1196
-
setControlsVisible(false, animated: false)
1197
1197
-
waveformView.isLive = false
1198
1198
-
panel?.orderOut(nil)
1199
1199
-
}
1200
1200
-
1201
1201
-
/// Store the button reference so positioning works from inside show().
1202
1202
-
func reposition(statusItemButton: NSStatusBarButton?) {
1203
1203
-
statusButton = statusItemButton
1204
1204
-
guard let panel = panel, panel.isVisible, !isSliding else { return }
1205
1205
-
guard isDocked else { return }
1206
1206
-
positionPanel(panel)
1207
1207
-
}
1208
1208
-
1209
1209
-
func refreshAppearance() {
1210
1210
-
applyAppearanceToVisualizer()
1211
1211
-
applyWaveformTint()
1212
1212
-
refreshReadout()
1213
1213
-
}
1214
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
-
1224
1224
-
// MARK: - Geometry
1225
1225
-
1226
1226
-
/// Compute the target frame for the strip: directly below the menubar,
1227
1227
-
/// aligned to the piano key region of the status item.
1228
1228
-
private func targetFrame() -> NSRect? {
1229
1229
-
guard let button = statusButton,
1230
1230
-
let buttonWindow = button.window else { return nil }
1231
1231
-
1232
1232
-
let imgSize = KeyboardIconRenderer.imageSize
1233
1233
-
let bb = button.bounds
1234
1234
-
let xOff = (bb.width - imgSize.width) / 2.0
1235
1235
-
1236
1236
-
let pianoOriginX = xOff + KeyboardIconRenderer.pad
1237
1237
-
let pianoWidth = imgSize.width - KeyboardIconRenderer.settingsW
1238
1238
-
- KeyboardIconRenderer.settingsGap - KeyboardIconRenderer.pad * 2
1239
1239
-
1240
1240
-
let localRect = NSRect(x: pianoOriginX, y: 0, width: pianoWidth, height: bb.height)
1241
1241
-
let windowRect = button.convert(localRect, to: nil)
1242
1242
-
let screenRect = buttonWindow.convertToScreen(windowRect)
1243
1243
-
1244
1244
-
let stripHeight = currentStripHeight(for: screenRect.width)
1245
1245
-
let anchoredFrame = NSRect(
1246
1246
-
x: screenRect.origin.x,
1247
1247
-
y: screenRect.origin.y - stripHeight,
1248
1248
-
width: screenRect.width,
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
1256
1256
-
)
1257
1257
-
}
1258
1258
-
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
1318
1318
-
1319
1319
-
private func show() {
1320
1320
-
if panel == nil { buildPanel() }
1321
1321
-
guard let panel = panel, let target = targetFrame() else { return }
1322
1322
-
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
1330
1330
-
applyAppearanceToVisualizer()
1331
1331
-
applyWaveformTint()
1332
1332
-
refreshReadout()
1333
1333
-
waveformView.isLive = true
1334
1334
-
panel.orderFrontRegardless()
1335
1335
-
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
1344
1344
-
}
1345
1345
-
}
1346
1346
-
1347
1347
-
private func hide(animated: Bool) {
1348
1348
-
cancelPendingHide()
1349
1349
-
stopSlide()
1350
1350
-
guard !isPointerInsideStrip, !isDraggingStrip else { return }
1351
1351
-
guard let panel = panel, panel.isVisible else {
1352
1352
-
waveformView.isLive = false
1353
1353
-
return
1354
1354
-
}
1355
1355
-
if !animated {
1356
1356
-
panel.animator().alphaValue = 1.0
1357
1357
-
waveformView.isLive = false
1358
1358
-
panel.orderOut(nil)
1359
1359
-
return
1360
1360
-
}
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
1368
1368
-
panel.orderOut(nil)
1369
1369
-
panel.alphaValue = 1.0
1370
1370
-
self.isSliding = false
1371
1371
-
}
1372
1372
-
}
1373
1373
-
1374
1374
-
private func startSlide(fromY: CGFloat, toY: CGFloat, completion: @escaping () -> Void) {
1375
1375
-
stopSlide()
1376
1376
-
isSliding = true
1377
1377
-
slideFromY = fromY
1378
1378
-
slideToY = toY
1379
1379
-
slideStartTime = CACurrentMediaTime()
1380
1380
-
slideCompletion = completion
1381
1381
-
1382
1382
-
var link: CVDisplayLink?
1383
1383
-
CVDisplayLinkCreateWithActiveCGDisplays(&link)
1384
1384
-
guard let link = link else {
1385
1385
-
// Fallback: jump immediately if CVDisplayLink fails.
1386
1386
-
panel?.setFrameOrigin(NSPoint(x: panel?.frame.origin.x ?? 0, y: toY))
1387
1387
-
completion()
1388
1388
-
return
1389
1389
-
}
1390
1390
-
let opaque = Unmanaged.passUnretained(self).toOpaque()
1391
1391
-
CVDisplayLinkSetOutputCallback(link, { _, _, _, _, _, ctx -> CVReturn in
1392
1392
-
guard let ctx = ctx else { return kCVReturnSuccess }
1393
1393
-
let strip = Unmanaged<LiquidMenuBarWaveformStrip>.fromOpaque(ctx).takeUnretainedValue()
1394
1394
-
DispatchQueue.main.async { strip.tickSlide() }
1395
1395
-
return kCVReturnSuccess
1396
1396
-
}, opaque)
1397
1397
-
CVDisplayLinkStart(link)
1398
1398
-
slideLink = link
1399
1399
-
}
1400
1400
-
1401
1401
-
private func tickSlide() {
1402
1402
-
guard isSliding, let panel = panel else {
1403
1403
-
stopSlide()
1404
1404
-
return
1405
1405
-
}
1406
1406
-
let elapsed = CACurrentMediaTime() - slideStartTime
1407
1407
-
let t = min(1.0, elapsed / Self.fadeInDuration)
1408
1408
-
// Ease-out cubic for show, ease-in cubic for hide.
1409
1409
-
let eased: CGFloat
1410
1410
-
if slideToY < slideFromY {
1411
1411
-
// Sliding down (show): ease-out
1412
1412
-
let f = 1.0 - t
1413
1413
-
eased = CGFloat(1.0 - f * f * f)
1414
1414
-
} else {
1415
1415
-
// Sliding up (hide): ease-in
1416
1416
-
eased = CGFloat(t * t * t)
1417
1417
-
}
1418
1418
-
let currentY = slideFromY + (slideToY - slideFromY) * eased
1419
1419
-
panel.setFrameOrigin(NSPoint(x: panel.frame.origin.x, y: currentY))
1420
1420
-
1421
1421
-
if t >= 1.0 {
1422
1422
-
let completion = slideCompletion
1423
1423
-
stopSlide()
1424
1424
-
completion?()
1425
1425
-
}
1426
1426
-
}
1427
1427
-
1428
1428
-
private func stopSlide() {
1429
1429
-
if let link = slideLink {
1430
1430
-
CVDisplayLinkStop(link)
1431
1431
-
slideLink = nil
1432
1432
-
}
1433
1433
-
slideCompletion = nil
1434
1434
-
}
1435
1435
-
1436
1436
-
private func cancelPendingHide() {
1437
1437
-
hideWorkItem?.cancel()
1438
1438
-
hideWorkItem = nil
1439
1439
-
}
1440
1440
-
1441
1441
-
// MARK: - Panel construction
1442
1442
-
1443
1443
-
private func buildPanel() {
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],
1451
1451
-
backing: .buffered,
1452
1452
-
defer: false
1453
1453
-
)
1454
1454
-
p.isOpaque = false
1455
1455
-
p.backgroundColor = .clear
1456
1456
-
p.hasShadow = true
1457
1457
-
p.level = Self.stripLevel
1458
1458
-
p.collectionBehavior = [.transient, .ignoresCycle]
1459
1459
-
p.hidesOnDeactivate = false
1460
1460
-
p.canHide = false
1461
1461
-
p.isMovable = true
1462
1462
-
p.isMovableByWindowBackground = false
1463
1463
-
p.animationBehavior = .none
1464
1464
-
p.acceptsMouseMovedEvents = false
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]
1471
1471
-
waveformView.translatesAutoresizingMaskIntoConstraints = false
1472
1472
-
waveformBezel.translatesAutoresizingMaskIntoConstraints = false
1473
1473
-
waveformClipView.translatesAutoresizingMaskIntoConstraints = false
1474
1474
-
instrumentArrows.translatesAutoresizingMaskIntoConstraints = false
1475
1475
-
instrumentRowContainer.translatesAutoresizingMaskIntoConstraints = false
1476
1476
-
instrumentLabel.translatesAutoresizingMaskIntoConstraints = false
1477
1477
-
closeButton.translatesAutoresizingMaskIntoConstraints = false
1478
1478
-
dockButton.translatesAutoresizingMaskIntoConstraints = false
1479
1479
-
expandButton.translatesAutoresizingMaskIntoConstraints = false
1480
1480
-
heldNotesContainer.translatesAutoresizingMaskIntoConstraints = false
1481
1481
-
heldNotesStack.translatesAutoresizingMaskIntoConstraints = false
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
1583
1583
-
NSLayoutConstraint.activate([
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),
1613
1613
-
])
1614
1614
-
applyAppearanceToVisualizer()
1615
1615
-
applyWaveformTint()
1616
1616
-
refreshReadout()
1617
1617
-
setControlsVisible(false, animated: false)
1618
1618
-
1619
1619
-
panel = p
1620
1620
-
}
1621
1621
-
1622
1622
-
private func positionPanel(_ panel: NSPanel) {
1623
1623
-
guard let target = targetFrame() else { return }
1624
1624
-
waveformBezelHeightConstraint?.constant = currentWaveformBezelHeight(for: target.width)
1625
1625
-
panel.setFrame(target, display: true)
1626
1626
-
}
1627
1627
-
1628
1628
-
private func applyAppearanceToVisualizer() {
1629
1629
-
let isDark = NSApp.effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua
1630
1630
-
waveformView.setLightMode(!isDark)
1631
1631
-
if isDark {
1632
1632
-
waveformBezel.layer?.backgroundColor = NSColor.white.withAlphaComponent(0.04).cgColor
1633
1633
-
instrumentLabel.textColor = .labelColor
1634
1634
-
} else {
1635
1635
-
waveformBezel.layer?.backgroundColor = NSColor.white.withAlphaComponent(0.18).cgColor
1636
1636
-
instrumentLabel.textColor = .labelColor
1637
1637
-
}
1638
1638
-
}
1639
1639
-
1640
1640
-
private func applyWaveformTint() {
1641
1641
-
let stripTint: NSColor
1642
1642
-
if menuBand.midiMode {
1643
1643
-
waveformView.setDotMatrix(MenuBandPopoverViewController.midiDotPattern)
1644
1644
-
waveformView.setBaseColor(.controlAccentColor)
1645
1645
-
waveformBezel.layer?.borderColor = NSColor.controlAccentColor
1646
1646
-
.withAlphaComponent(0.24).cgColor
1647
1647
-
stripTint = NSColor.controlAccentColor.withAlphaComponent(0.20)
1648
1648
-
} else {
1649
1649
-
waveformView.setDotMatrix(nil)
1650
1650
-
let safe = max(0, min(127, Int(menuBand.effectiveMelodicProgram)))
1651
1651
-
let familyColor = InstrumentListView.colorForProgram(safe)
1652
1652
-
waveformView.setBaseColor(familyColor)
1653
1653
-
waveformBezel.layer?.borderColor = familyColor
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
-
}
1679
1679
-
}
1680
1680
-
}
1681
1681
-
1682
1682
-
private func refreshReadout() {
1683
1683
-
let safe = max(0, min(127, Int(menuBand.effectiveMelodicProgram)))
1684
1684
-
let familyColor = menuBand.midiMode
1685
1685
-
? NSColor.controlAccentColor
1686
1686
-
: InstrumentListView.colorForProgram(safe)
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
-
)
1709
1709
-
for view in heldNotesStack.arrangedSubviews {
1710
1710
-
heldNotesStack.removeArrangedSubview(view)
1711
1711
-
view.removeFromSuperview()
1712
1712
-
}
1713
1713
-
for name in menuBand.heldNoteNames() {
1714
1714
-
heldNotesStack.addArrangedSubview(makeHeldNoteBox(name: name, color: familyColor))
1715
1715
-
}
1716
1716
-
}
1717
1717
-
1718
1718
-
private func makeHeldNoteBox(name: String, color: NSColor) -> NSView {
1719
1719
-
let box = NSView()
1720
1720
-
box.wantsLayer = true
1721
1721
-
box.layer?.cornerRadius = 4
1722
1722
-
box.layer?.backgroundColor = color.withAlphaComponent(0.85).cgColor
1723
1723
-
box.translatesAutoresizingMaskIntoConstraints = false
1724
1724
-
let label = NSTextField(labelWithString: name)
1725
1725
-
label.font = NSFont.monospacedSystemFont(ofSize: 9, weight: .heavy)
1726
1726
-
label.textColor = .black
1727
1727
-
label.drawsBackground = false
1728
1728
-
label.translatesAutoresizingMaskIntoConstraints = false
1729
1729
-
box.addSubview(label)
1730
1730
-
NSLayoutConstraint.activate([
1731
1731
-
label.leadingAnchor.constraint(equalTo: box.leadingAnchor, constant: 5),
1732
1732
-
label.trailingAnchor.constraint(equalTo: box.trailingAnchor, constant: -5),
1733
1733
-
label.topAnchor.constraint(equalTo: box.topAnchor, constant: 1),
1734
1734
-
label.bottomAnchor.constraint(equalTo: box.bottomAnchor, constant: -1),
1735
1735
-
])
1736
1736
-
return box
1737
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
-
1812
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
-
}
+1
slab/menuband/Sources/MenuBand/QwertyLayoutView.swift
+1
slab/menuband/Sources/MenuBand/QwertyLayoutView.swift
···
63
63
required init?(coder: NSCoder) { fatalError() }
64
64
65
65
override var isFlipped: Bool { false }
66
66
+
override var mouseDownCanMoveWindow: Bool { false }
66
67
67
68
/// Three-row macOS QWERTY layout — keys identified by `kVK_*`
68
69
/// codes, mirroring `MenuBandLayout.panByKeyCode` so the visual
+977
slab/menuband/Sources/MenuBand/UnifiedPianoWaveformPalette.swift
+977
slab/menuband/Sources/MenuBand/UnifiedPianoWaveformPalette.swift
···
1
1
+
import AppKit
2
2
+
3
3
+
final class UnifiedPianoWaveformPalette: NSObject, NSWindowDelegate {
4
4
+
enum State {
5
5
+
case collapsed
6
6
+
case expanded
7
7
+
}
8
8
+
9
9
+
enum DismissReason {
10
10
+
case closeButton
11
11
+
case shortcut
12
12
+
case programmatic
13
13
+
14
14
+
var shouldRestoreFocus: Bool {
15
15
+
switch self {
16
16
+
case .closeButton, .shortcut:
17
17
+
return true
18
18
+
case .programmatic:
19
19
+
return false
20
20
+
}
21
21
+
}
22
22
+
}
23
23
+
24
24
+
private let menuBand: MenuBandController
25
25
+
private let paletteController: FloatingPlayPaletteViewController
26
26
+
private var panel: UnifiedPianoWaveformPalettePanel?
27
27
+
private weak var statusItemButton: NSStatusBarButton?
28
28
+
private var state: State = .collapsed
29
29
+
private var preferredState: State
30
30
+
private var keyMonitor: Any?
31
31
+
private var appBeforeOpen: NSRunningApplication?
32
32
+
private var dismissHandler: (() -> Void)?
33
33
+
private var isDismissing = false
34
34
+
private var isPositioningPanel = false
35
35
+
private var savedExpandedOrigin: NSPoint?
36
36
+
private var collapsedCustomOrigin: NSPoint?
37
37
+
private var hideWorkItem: DispatchWorkItem?
38
38
+
private var isEnabled: Bool
39
39
+
40
40
+
private static let expandedOriginXKey = "notepat.unifiedPalette.expandedOriginX"
41
41
+
private static let expandedOriginYKey = "notepat.unifiedPalette.expandedOriginY"
42
42
+
private static let collapsedOriginXKey = "notepat.unifiedPalette.collapsedOriginX"
43
43
+
private static let collapsedOriginYKey = "notepat.unifiedPalette.collapsedOriginY"
44
44
+
private static let enabledKey = "notepat.unifiedPalette.enabled"
45
45
+
private static let preferredStateKey = "notepat.unifiedPalette.preferredState"
46
46
+
private static let collapsedHideDelay: TimeInterval = 2.0
47
47
+
48
48
+
var onDismiss: (() -> Void)? {
49
49
+
get { dismissHandler }
50
50
+
set { dismissHandler = newValue }
51
51
+
}
52
52
+
53
53
+
var onFocusRelease: (() -> Void)?
54
54
+
55
55
+
var onToggleKeymap: (() -> Void)?
56
56
+
57
57
+
var isPianoFocusActive: (() -> Bool)? {
58
58
+
get { paletteController.isPianoFocusActive }
59
59
+
set { paletteController.isPianoFocusActive = newValue }
60
60
+
}
61
61
+
62
62
+
var isShown: Bool {
63
63
+
state == .expanded && panel?.isVisible == true
64
64
+
}
65
65
+
66
66
+
var isKeyboardFocused: Bool {
67
67
+
state == .expanded && panel?.isKeyWindow == true
68
68
+
}
69
69
+
70
70
+
var isCollapsedState: Bool { state == .collapsed }
71
71
+
72
72
+
var isFeatureEnabled: Bool { isEnabled }
73
73
+
74
74
+
var onStepBackward: (() -> Void)? {
75
75
+
get { paletteController.onStepBackward }
76
76
+
set { paletteController.onStepBackward = newValue }
77
77
+
}
78
78
+
79
79
+
var onStepForward: (() -> Void)? {
80
80
+
get { paletteController.onStepForward }
81
81
+
set { paletteController.onStepForward = newValue }
82
82
+
}
83
83
+
84
84
+
var onStepUp: (() -> Void)? {
85
85
+
get { paletteController.onStepUp }
86
86
+
set { paletteController.onStepUp = newValue }
87
87
+
}
88
88
+
89
89
+
var onStepDown: (() -> Void)? {
90
90
+
get { paletteController.onStepDown }
91
91
+
set { paletteController.onStepDown = newValue }
92
92
+
}
93
93
+
94
94
+
var suppressed: Bool = false {
95
95
+
didSet {
96
96
+
guard suppressed != oldValue else { return }
97
97
+
if suppressed && state == .collapsed {
98
98
+
dismissCollapsedPanel()
99
99
+
}
100
100
+
}
101
101
+
}
102
102
+
103
103
+
var isDocked: Bool { collapsedCustomOrigin == nil }
104
104
+
105
105
+
init(menuBand: MenuBandController) {
106
106
+
self.menuBand = menuBand
107
107
+
self.paletteController = FloatingPlayPaletteViewController(menuBand: menuBand)
108
108
+
self.preferredState = Self.loadPreferredState()
109
109
+
self.isEnabled = Self.loadEnabledState()
110
110
+
self.savedExpandedOrigin = Self.loadOrigin(
111
111
+
xKey: Self.expandedOriginXKey,
112
112
+
yKey: Self.expandedOriginYKey
113
113
+
)
114
114
+
self.collapsedCustomOrigin = Self.loadOrigin(
115
115
+
xKey: Self.collapsedOriginXKey,
116
116
+
yKey: Self.collapsedOriginYKey
117
117
+
)
118
118
+
super.init()
119
119
+
120
120
+
paletteController.onCloseRequested = { [weak self] in
121
121
+
self?.disable(reason: .closeButton)
122
122
+
}
123
123
+
paletteController.onDockRequested = { [weak self] in
124
124
+
self?.dockOnMenu()
125
125
+
}
126
126
+
paletteController.onTogglePresentationMode = { [weak self] in
127
127
+
self?.togglePresentationMode()
128
128
+
}
129
129
+
}
130
130
+
131
131
+
func toggleFromShortcut() {
132
132
+
if isEnabled {
133
133
+
disable(reason: .shortcut)
134
134
+
return
135
135
+
}
136
136
+
enableAndShowPreferred(restoringTo: nil)
137
137
+
}
138
138
+
139
139
+
func showFromCommand(restoringTo previousApp: NSRunningApplication? = nil) {
140
140
+
setEnabled(true)
141
141
+
preferredState = .expanded
142
142
+
persistPreferredState()
143
143
+
transitionToExpanded()
144
144
+
showExpanded(restoringTo: previousApp)
145
145
+
}
146
146
+
147
147
+
func show(restoringTo previousApp: NSRunningApplication? = nil) {
148
148
+
setEnabled(true)
149
149
+
preferredState = .expanded
150
150
+
persistPreferredState()
151
151
+
transitionToExpanded()
152
152
+
showExpanded(restoringTo: previousApp)
153
153
+
}
154
154
+
155
155
+
func dismiss(reason: DismissReason = .programmatic) {
156
156
+
guard state == .expanded else { return }
157
157
+
dismissExpanded(reason: reason)
158
158
+
}
159
159
+
160
160
+
func refresh() {
161
161
+
switch state {
162
162
+
case .expanded:
163
163
+
paletteController.setDisplayMode(.expanded)
164
164
+
paletteController.refresh()
165
165
+
if let panel, panel.isVisible {
166
166
+
setPanelFrame(expandedFrame(
167
167
+
size: paletteController.preferredContentSize,
168
168
+
fallbackOrigin: panel.frame.origin
169
169
+
))
170
170
+
}
171
171
+
case .collapsed:
172
172
+
paletteController.setDisplayMode(.collapsed)
173
173
+
paletteController.refresh()
174
174
+
if let panel, panel.isVisible {
175
175
+
setPanelFrame(collapsedFrame(size: paletteController.preferredContentSize))
176
176
+
}
177
177
+
}
178
178
+
}
179
179
+
180
180
+
func clearInteraction() {
181
181
+
paletteController.clearInteraction()
182
182
+
}
183
183
+
184
184
+
func releaseKeyboardFocus() {
185
185
+
guard state == .expanded else { return }
186
186
+
restorePreviousAppFocus()
187
187
+
}
188
188
+
189
189
+
func warmUp() {
190
190
+
if panel == nil {
191
191
+
buildPanel()
192
192
+
}
193
193
+
paletteController.setDisplayMode(.collapsed)
194
194
+
paletteController.refresh()
195
195
+
}
196
196
+
197
197
+
func showIfNeeded() {
198
198
+
guard state == .collapsed, !suppressed, isEnabled, preferredState == .collapsed else { return }
199
199
+
cancelPendingHide()
200
200
+
if panel == nil {
201
201
+
buildPanel()
202
202
+
}
203
203
+
paletteController.setDisplayMode(.collapsed)
204
204
+
paletteController.refresh()
205
205
+
showCollapsedIfNeeded()
206
206
+
if !menuBand.litNotes.isEmpty {
207
207
+
focusCollapsedPaletteIfNeeded()
208
208
+
}
209
209
+
}
210
210
+
211
211
+
func scheduleHide() {
212
212
+
guard state == .collapsed else { return }
213
213
+
cancelPendingHide()
214
214
+
let work = DispatchWorkItem { [weak self] in
215
215
+
self?.dismissCollapsedPanel()
216
216
+
}
217
217
+
hideWorkItem = work
218
218
+
DispatchQueue.main.asyncAfter(deadline: .now() + Self.collapsedHideDelay, execute: work)
219
219
+
}
220
220
+
221
221
+
func reposition(statusItemButton: NSStatusBarButton?) {
222
222
+
self.statusItemButton = statusItemButton
223
223
+
guard state == .collapsed, let panel, panel.isVisible else { return }
224
224
+
setPanelFrame(collapsedFrame(size: paletteController.preferredContentSize))
225
225
+
}
226
226
+
227
227
+
func refreshAppearance() {
228
228
+
guard state == .collapsed else { return }
229
229
+
paletteController.setDisplayMode(.collapsed)
230
230
+
paletteController.refresh()
231
231
+
if let panel, panel.isVisible {
232
232
+
setPanelFrame(collapsedFrame(size: paletteController.preferredContentSize))
233
233
+
}
234
234
+
}
235
235
+
236
236
+
func registerArrowInput() {
237
237
+
guard state == .collapsed, !suppressed, isEnabled else { return }
238
238
+
showIfNeeded()
239
239
+
paletteController.refresh()
240
240
+
focusCollapsedPaletteIfNeeded()
241
241
+
if menuBand.litNotes.isEmpty {
242
242
+
scheduleHide()
243
243
+
}
244
244
+
}
245
245
+
246
246
+
func windowDidMove(_ notification: Notification) {
247
247
+
guard let panel, !isPositioningPanel else { return }
248
248
+
switch state {
249
249
+
case .expanded:
250
250
+
savedExpandedOrigin = panel.frame.origin
251
251
+
persistOrigin(savedExpandedOrigin, xKey: Self.expandedOriginXKey, yKey: Self.expandedOriginYKey)
252
252
+
case .collapsed:
253
253
+
collapsedCustomOrigin = panel.frame.origin
254
254
+
persistOrigin(collapsedCustomOrigin, xKey: Self.collapsedOriginXKey, yKey: Self.collapsedOriginYKey)
255
255
+
}
256
256
+
}
257
257
+
258
258
+
private func buildPanel() {
259
259
+
let panel = UnifiedPianoWaveformPalettePanel(
260
260
+
contentRect: NSRect(origin: .zero, size: paletteController.preferredContentSize),
261
261
+
styleMask: [.titled, .closable, .fullSizeContentView],
262
262
+
backing: .buffered,
263
263
+
defer: false
264
264
+
)
265
265
+
panel.delegate = self
266
266
+
panel.isOpaque = false
267
267
+
panel.backgroundColor = .clear
268
268
+
panel.hasShadow = true
269
269
+
panel.level = .floating
270
270
+
panel.animationBehavior = .none
271
271
+
panel.collectionBehavior = [.transient]
272
272
+
panel.hidesOnDeactivate = false
273
273
+
panel.canHide = false
274
274
+
panel.isMovableByWindowBackground = true
275
275
+
panel.acceptsMouseMovedEvents = true
276
276
+
panel.titleVisibility = .hidden
277
277
+
panel.titlebarAppearsTransparent = true
278
278
+
panel.isReleasedWhenClosed = false
279
279
+
panel.contentViewController = paletteController
280
280
+
if let button = panel.standardWindowButton(.closeButton) {
281
281
+
button.isHidden = true
282
282
+
}
283
283
+
if let mini = panel.standardWindowButton(.miniaturizeButton) {
284
284
+
mini.isHidden = true
285
285
+
}
286
286
+
if let zoom = panel.standardWindowButton(.zoomButton) {
287
287
+
zoom.isHidden = true
288
288
+
}
289
289
+
self.panel = panel
290
290
+
}
291
291
+
292
292
+
private func showExpanded(restoringTo previousApp: NSRunningApplication?) {
293
293
+
if panel == nil {
294
294
+
buildPanel()
295
295
+
}
296
296
+
guard let panel else { return }
297
297
+
cancelPendingHide()
298
298
+
setEnabled(true)
299
299
+
appBeforeOpen = previousApp ?? currentFrontmostOtherApp()
300
300
+
paletteController.setDisplayMode(.expanded)
301
301
+
paletteController.refresh()
302
302
+
panel.ignoresMouseEvents = false
303
303
+
setPanelFrame(expandedFrame(
304
304
+
size: paletteController.preferredContentSize,
305
305
+
fallbackOrigin: panel.frame.origin
306
306
+
))
307
307
+
NSApp.activate(ignoringOtherApps: true)
308
308
+
panel.makeKeyAndOrderFront(nil)
309
309
+
paletteController.setPresented(true)
310
310
+
installMonitors()
311
311
+
}
312
312
+
313
313
+
private func showCollapsedIfNeeded() {
314
314
+
guard let panel else { return }
315
315
+
paletteController.setDisplayMode(.collapsed)
316
316
+
panel.ignoresMouseEvents = false
317
317
+
setPanelFrame(collapsedFrame(size: paletteController.preferredContentSize))
318
318
+
if !panel.isVisible {
319
319
+
panel.orderFrontRegardless()
320
320
+
}
321
321
+
paletteController.setPresented(true)
322
322
+
}
323
323
+
324
324
+
private func focusCollapsedPaletteIfNeeded() {
325
325
+
guard state == .collapsed, let panel else { return }
326
326
+
NSApp.activate(ignoringOtherApps: true)
327
327
+
panel.makeKeyAndOrderFront(nil)
328
328
+
paletteController.setPresented(true)
329
329
+
}
330
330
+
331
331
+
private func dismissExpanded(reason: DismissReason) {
332
332
+
guard !isDismissing else { return }
333
333
+
guard panel?.isVisible == true || keyMonitor != nil else { return }
334
334
+
isDismissing = true
335
335
+
removeMonitors()
336
336
+
paletteController.setPresented(false)
337
337
+
paletteController.clearInteraction()
338
338
+
menuBand.releaseAllHeldNotes()
339
339
+
panel?.ignoresMouseEvents = false
340
340
+
panel?.orderOut(nil)
341
341
+
state = .collapsed
342
342
+
dismissHandler?()
343
343
+
if reason.shouldRestoreFocus {
344
344
+
restorePreviousAppFocus()
345
345
+
}
346
346
+
appBeforeOpen = nil
347
347
+
isDismissing = false
348
348
+
}
349
349
+
350
350
+
private func dismissCollapsedPanel() {
351
351
+
cancelPendingHide()
352
352
+
paletteController.setPresented(false)
353
353
+
panel?.ignoresMouseEvents = false
354
354
+
panel?.orderOut(nil)
355
355
+
}
356
356
+
357
357
+
private func togglePresentationMode() {
358
358
+
switch state {
359
359
+
case .collapsed:
360
360
+
expandFromStrip()
361
361
+
case .expanded:
362
362
+
collapseToStrip()
363
363
+
}
364
364
+
}
365
365
+
366
366
+
private func dockOnMenu() {
367
367
+
collapsedCustomOrigin = nil
368
368
+
persistOrigin(nil, xKey: Self.collapsedOriginXKey, yKey: Self.collapsedOriginYKey)
369
369
+
collapseToStrip()
370
370
+
if let panel, panel.isVisible {
371
371
+
setPanelFrame(collapsedFrame(size: paletteController.preferredContentSize))
372
372
+
}
373
373
+
}
374
374
+
375
375
+
private func transitionToExpanded() {
376
376
+
if panel == nil {
377
377
+
buildPanel()
378
378
+
}
379
379
+
state = .expanded
380
380
+
preferredState = .expanded
381
381
+
persistPreferredState()
382
382
+
panel?.ignoresMouseEvents = false
383
383
+
paletteController.setDisplayMode(.expanded)
384
384
+
}
385
385
+
386
386
+
private func collapseToStrip() {
387
387
+
guard state != .collapsed else {
388
388
+
preferredState = .collapsed
389
389
+
persistPreferredState()
390
390
+
paletteController.setDisplayMode(.collapsed)
391
391
+
paletteController.refresh()
392
392
+
showIfNeeded()
393
393
+
if menuBand.litNotes.isEmpty {
394
394
+
scheduleHide()
395
395
+
}
396
396
+
return
397
397
+
}
398
398
+
removeMonitors()
399
399
+
paletteController.setPresented(false)
400
400
+
paletteController.clearInteraction()
401
401
+
state = .collapsed
402
402
+
preferredState = .collapsed
403
403
+
persistPreferredState()
404
404
+
paletteController.setDisplayMode(.collapsed)
405
405
+
paletteController.refresh()
406
406
+
showCollapsedIfNeeded()
407
407
+
if menuBand.litNotes.isEmpty {
408
408
+
scheduleHide()
409
409
+
}
410
410
+
}
411
411
+
412
412
+
private func expandFromStrip() {
413
413
+
transitionToExpanded()
414
414
+
showExpanded(restoringTo: nil)
415
415
+
}
416
416
+
417
417
+
private func installMonitors() {
418
418
+
if keyMonitor == nil {
419
419
+
keyMonitor = NSEvent.addLocalMonitorForEvents(matching: [.keyDown, .keyUp]) { [weak self] event in
420
420
+
guard let self, self.state == .expanded, self.panel?.isKeyWindow == true else { return event }
421
421
+
let isDown = event.type == .keyDown
422
422
+
if isDown && event.keyCode == 53 {
423
423
+
self.onFocusRelease?()
424
424
+
return nil
425
425
+
}
426
426
+
if isDown && MenuBandShortcutPreferences.focusShortcut.matches(event: event) {
427
427
+
self.onFocusRelease?()
428
428
+
return nil
429
429
+
}
430
430
+
if isDown && MenuBandShortcut.layoutToggle.matches(event: event) {
431
431
+
self.onToggleKeymap?()
432
432
+
return nil
433
433
+
}
434
434
+
let consumed = self.menuBand.handleLocalKey(
435
435
+
keyCode: event.keyCode,
436
436
+
isDown: isDown,
437
437
+
isRepeat: event.isARepeat,
438
438
+
flags: event.modifierFlags
439
439
+
)
440
440
+
if consumed {
441
441
+
self.refresh()
442
442
+
return nil
443
443
+
}
444
444
+
return event
445
445
+
}
446
446
+
}
447
447
+
}
448
448
+
449
449
+
private func removeMonitors() {
450
450
+
if let keyMonitor {
451
451
+
NSEvent.removeMonitor(keyMonitor)
452
452
+
self.keyMonitor = nil
453
453
+
}
454
454
+
}
455
455
+
456
456
+
private func expandedFrame(size: NSSize, fallbackOrigin: NSPoint?) -> NSRect {
457
457
+
let origin = fallbackOrigin ?? savedExpandedOrigin
458
458
+
return clampedFrame(
459
459
+
origin: origin ?? centeredOrigin(for: size),
460
460
+
size: size,
461
461
+
preferredScreen: panel?.screen ?? NSScreen.main
462
462
+
)
463
463
+
}
464
464
+
465
465
+
private func collapsedFrame(size: NSSize) -> NSRect {
466
466
+
guard let anchoredFrame = anchoredCollapsedFrame(size: size) else {
467
467
+
return clampedFrame(
468
468
+
origin: collapsedCustomOrigin ?? centeredOrigin(for: size),
469
469
+
size: size,
470
470
+
preferredScreen: panel?.screen ?? NSScreen.main
471
471
+
)
472
472
+
}
473
473
+
guard let collapsedCustomOrigin else { return anchoredFrame }
474
474
+
return clampedFrame(
475
475
+
origin: collapsedCustomOrigin,
476
476
+
size: anchoredFrame.size,
477
477
+
preferredScreen: panel?.screen ?? statusItemButton?.window?.screen
478
478
+
)
479
479
+
}
480
480
+
481
481
+
private func anchoredCollapsedFrame(size: NSSize) -> NSRect? {
482
482
+
guard let button = statusItemButton,
483
483
+
let buttonWindow = button.window else { return nil }
484
484
+
485
485
+
let imgSize = KeyboardIconRenderer.imageSize
486
486
+
let buttonBounds = button.bounds
487
487
+
let xOffset = (buttonBounds.width - imgSize.width) / 2.0
488
488
+
let pianoOriginX = xOffset + KeyboardIconRenderer.pad
489
489
+
let pianoWidth = imgSize.width - KeyboardIconRenderer.settingsW
490
490
+
- KeyboardIconRenderer.settingsGap - KeyboardIconRenderer.pad * 2
491
491
+
492
492
+
let localRect = NSRect(x: pianoOriginX, y: 0, width: pianoWidth, height: buttonBounds.height)
493
493
+
let windowRect = button.convert(localRect, to: nil)
494
494
+
let screenRect = buttonWindow.convertToScreen(windowRect)
495
495
+
return NSRect(
496
496
+
x: screenRect.origin.x,
497
497
+
y: screenRect.origin.y - size.height,
498
498
+
width: screenRect.width,
499
499
+
height: size.height
500
500
+
)
501
501
+
}
502
502
+
503
503
+
private func centeredOrigin(for size: NSSize) -> NSPoint {
504
504
+
let mouse = NSEvent.mouseLocation
505
505
+
let screen = NSScreen.screens.first { NSMouseInRect(mouse, $0.frame, false) }
506
506
+
?? NSScreen.main
507
507
+
?? NSScreen.screens.first
508
508
+
let visible = screen?.visibleFrame ?? NSRect(x: 0, y: 0, width: 1024, height: 768)
509
509
+
return NSPoint(
510
510
+
x: visible.midX - size.width / 2,
511
511
+
y: visible.midY - size.height / 2
512
512
+
)
513
513
+
}
514
514
+
515
515
+
private func clampedFrame(origin: NSPoint, size: NSSize, preferredScreen: NSScreen?) -> NSRect {
516
516
+
let visible = visibleFrame(for: origin, preferredScreen: preferredScreen)
517
517
+
let margin: CGFloat = 16
518
518
+
let x = min(max(origin.x, visible.minX + margin), visible.maxX - size.width - margin)
519
519
+
let y = min(max(origin.y, visible.minY + margin), visible.maxY - size.height - margin)
520
520
+
return NSRect(origin: NSPoint(x: x, y: y), size: size)
521
521
+
}
522
522
+
523
523
+
private func visibleFrame(for origin: NSPoint, preferredScreen: NSScreen?) -> NSRect {
524
524
+
if let screen = NSScreen.screens.first(where: { $0.visibleFrame.contains(origin) }) {
525
525
+
return screen.visibleFrame
526
526
+
}
527
527
+
if let preferredScreen {
528
528
+
return preferredScreen.visibleFrame
529
529
+
}
530
530
+
return NSScreen.main?.visibleFrame ?? NSRect(x: 0, y: 0, width: 1440, height: 900)
531
531
+
}
532
532
+
533
533
+
private func setPanelFrame(_ frame: NSRect) {
534
534
+
guard let panel else { return }
535
535
+
isPositioningPanel = true
536
536
+
panel.setFrame(frame, display: true)
537
537
+
isPositioningPanel = false
538
538
+
}
539
539
+
540
540
+
private func cancelPendingHide() {
541
541
+
hideWorkItem?.cancel()
542
542
+
hideWorkItem = nil
543
543
+
}
544
544
+
545
545
+
private func enableAndShowPreferred(restoringTo previousApp: NSRunningApplication?) {
546
546
+
setEnabled(true)
547
547
+
switch preferredState {
548
548
+
case .expanded:
549
549
+
transitionToExpanded()
550
550
+
showExpanded(restoringTo: previousApp)
551
551
+
case .collapsed:
552
552
+
state = .collapsed
553
553
+
showIfNeeded()
554
554
+
focusCollapsedPaletteIfNeeded()
555
555
+
}
556
556
+
}
557
557
+
558
558
+
private func disable(reason: DismissReason) {
559
559
+
setEnabled(false)
560
560
+
switch state {
561
561
+
case .expanded:
562
562
+
dismissExpanded(reason: reason)
563
563
+
case .collapsed:
564
564
+
dismissCollapsedPanel()
565
565
+
}
566
566
+
}
567
567
+
568
568
+
private func setEnabled(_ isEnabled: Bool) {
569
569
+
guard self.isEnabled != isEnabled else { return }
570
570
+
self.isEnabled = isEnabled
571
571
+
UserDefaults.standard.set(isEnabled, forKey: Self.enabledKey)
572
572
+
}
573
573
+
574
574
+
private func persistPreferredState() {
575
575
+
let value = preferredState == .expanded ? "expanded" : "collapsed"
576
576
+
UserDefaults.standard.set(value, forKey: Self.preferredStateKey)
577
577
+
}
578
578
+
579
579
+
private func currentFrontmostOtherApp() -> NSRunningApplication? {
580
580
+
let frontmost = NSWorkspace.shared.frontmostApplication
581
581
+
guard frontmost?.bundleIdentifier != Bundle.main.bundleIdentifier else { return nil }
582
582
+
return frontmost
583
583
+
}
584
584
+
585
585
+
private func restorePreviousAppFocus() {
586
586
+
guard let app = appBeforeOpen,
587
587
+
!app.isTerminated,
588
588
+
app.bundleIdentifier != Bundle.main.bundleIdentifier else { return }
589
589
+
app.activate(options: [.activateIgnoringOtherApps])
590
590
+
}
591
591
+
592
592
+
private func persistOrigin(_ origin: NSPoint?, xKey: String, yKey: String) {
593
593
+
let defaults = UserDefaults.standard
594
594
+
guard let origin else {
595
595
+
defaults.removeObject(forKey: xKey)
596
596
+
defaults.removeObject(forKey: yKey)
597
597
+
return
598
598
+
}
599
599
+
defaults.set(origin.x, forKey: xKey)
600
600
+
defaults.set(origin.y, forKey: yKey)
601
601
+
}
602
602
+
603
603
+
private static func loadOrigin(xKey: String, yKey: String) -> NSPoint? {
604
604
+
let defaults = UserDefaults.standard
605
605
+
guard defaults.object(forKey: xKey) != nil,
606
606
+
defaults.object(forKey: yKey) != nil else { return nil }
607
607
+
return NSPoint(
608
608
+
x: defaults.double(forKey: xKey),
609
609
+
y: defaults.double(forKey: yKey)
610
610
+
)
611
611
+
}
612
612
+
613
613
+
private static func loadEnabledState() -> Bool {
614
614
+
UserDefaults.standard.bool(forKey: enabledKey)
615
615
+
}
616
616
+
617
617
+
private static func loadPreferredState() -> State {
618
618
+
UserDefaults.standard.string(forKey: preferredStateKey) == "expanded"
619
619
+
? .expanded
620
620
+
: .collapsed
621
621
+
}
622
622
+
}
623
623
+
624
624
+
private final class UnifiedPianoWaveformPalettePanel: NSPanel {
625
625
+
override var canBecomeKey: Bool { true }
626
626
+
override var canBecomeMain: Bool { false }
627
627
+
}
628
628
+
629
629
+
@available(macOS 26.0, *)
630
630
+
private final class UnifiedWaveformStripGlassEffectView: NSGlassEffectView {
631
631
+
override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
632
632
+
}
633
633
+
634
634
+
final class UnifiedWaveformStripView: NSView {
635
635
+
private static var shouldUseLiquidGlass: Bool {
636
636
+
if #available(macOS 26.0, *) { return true }
637
637
+
return false
638
638
+
}
639
639
+
640
640
+
private weak var menuBand: MenuBandController?
641
641
+
private let contentContainer = NSView()
642
642
+
private let waveformContainer = NSView()
643
643
+
private let waveformClipView = NSView()
644
644
+
private let waveformView = WaveformView()
645
645
+
private let heldNotesContainer = NSView()
646
646
+
private let heldNotesStack = NSStackView()
647
647
+
private let instrumentRow = NSView()
648
648
+
private let instrumentArrows = ArrowKeysIndicator()
649
649
+
private let instrumentLabel = NSTextField(labelWithString: "")
650
650
+
private var trackingArea: NSTrackingArea?
651
651
+
private weak var paletteGlassView: NSView?
652
652
+
private weak var waveformGlassView: NSView?
653
653
+
private weak var instrumentRowGlassView: NSView?
654
654
+
655
655
+
var onHoverChanged: ((Bool) -> Void)?
656
656
+
var onStepBackward: (() -> Void)?
657
657
+
var onStepForward: (() -> Void)?
658
658
+
var onStepUp: (() -> Void)?
659
659
+
var onStepDown: (() -> Void)?
660
660
+
661
661
+
private static let waveformHeight: CGFloat = 64
662
662
+
private static let heldNotesRowHeight: CGFloat = 16
663
663
+
private static let instrumentRowHeight: CGFloat = 22
664
664
+
665
665
+
init(menuBand: MenuBandController) {
666
666
+
self.menuBand = menuBand
667
667
+
super.init(frame: .zero)
668
668
+
wantsLayer = true
669
669
+
layer?.cornerRadius = 10
670
670
+
layer?.masksToBounds = true
671
671
+
672
672
+
contentContainer.translatesAutoresizingMaskIntoConstraints = false
673
673
+
waveformView.menuBand = menuBand
674
674
+
waveformView.translatesAutoresizingMaskIntoConstraints = false
675
675
+
waveformView.setSurfaceStyle(.standard)
676
676
+
677
677
+
waveformContainer.wantsLayer = true
678
678
+
waveformContainer.translatesAutoresizingMaskIntoConstraints = false
679
679
+
waveformContainer.layer?.cornerRadius = 8
680
680
+
waveformContainer.layer?.masksToBounds = false
681
681
+
682
682
+
waveformClipView.wantsLayer = true
683
683
+
waveformClipView.translatesAutoresizingMaskIntoConstraints = false
684
684
+
waveformClipView.layer?.cornerRadius = 8
685
685
+
waveformClipView.layer?.masksToBounds = true
686
686
+
687
687
+
heldNotesContainer.translatesAutoresizingMaskIntoConstraints = false
688
688
+
heldNotesStack.orientation = .horizontal
689
689
+
heldNotesStack.alignment = .centerY
690
690
+
heldNotesStack.spacing = 4
691
691
+
heldNotesStack.translatesAutoresizingMaskIntoConstraints = false
692
692
+
693
693
+
instrumentRow.translatesAutoresizingMaskIntoConstraints = false
694
694
+
instrumentRow.wantsLayer = true
695
695
+
instrumentRow.layer?.cornerRadius = 7
696
696
+
if #available(macOS 10.15, *) {
697
697
+
instrumentRow.layer?.cornerCurve = .continuous
698
698
+
}
699
699
+
instrumentArrows.translatesAutoresizingMaskIntoConstraints = false
700
700
+
instrumentArrows.setContentHuggingPriority(.required, for: .horizontal)
701
701
+
instrumentArrows.setContentCompressionResistancePriority(.required, for: .horizontal)
702
702
+
instrumentArrows.displayMode = .horizontalPair
703
703
+
instrumentArrows.style = .prominent
704
704
+
instrumentArrows.toolTip = "Change instrument"
705
705
+
instrumentArrows.onClick = { [weak self] direction, isDown in
706
706
+
guard let self, isDown else { return }
707
707
+
switch direction {
708
708
+
case 0:
709
709
+
self.onStepBackward?()
710
710
+
case 1:
711
711
+
self.onStepForward?()
712
712
+
case 2:
713
713
+
self.onStepDown?()
714
714
+
case 3:
715
715
+
self.onStepUp?()
716
716
+
default:
717
717
+
break
718
718
+
}
719
719
+
}
720
720
+
721
721
+
instrumentLabel.translatesAutoresizingMaskIntoConstraints = false
722
722
+
instrumentLabel.lineBreakMode = .byTruncatingTail
723
723
+
instrumentLabel.drawsBackground = false
724
724
+
instrumentLabel.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
725
725
+
726
726
+
addSubview(contentContainer)
727
727
+
contentContainer.addSubview(waveformContainer)
728
728
+
contentContainer.addSubview(heldNotesContainer)
729
729
+
contentContainer.addSubview(instrumentRow)
730
730
+
waveformContainer.addSubview(waveformClipView)
731
731
+
waveformClipView.addSubview(waveformView)
732
732
+
heldNotesContainer.addSubview(heldNotesStack)
733
733
+
instrumentRow.addSubview(instrumentArrows)
734
734
+
instrumentRow.addSubview(instrumentLabel)
735
735
+
installLiquidGlassBackgrounds()
736
736
+
737
737
+
NSLayoutConstraint.activate([
738
738
+
widthAnchor.constraint(equalToConstant: KeyboardIconRenderer.imageSize.width),
739
739
+
contentContainer.leadingAnchor.constraint(equalTo: leadingAnchor),
740
740
+
contentContainer.trailingAnchor.constraint(equalTo: trailingAnchor),
741
741
+
contentContainer.topAnchor.constraint(equalTo: topAnchor),
742
742
+
contentContainer.bottomAnchor.constraint(equalTo: bottomAnchor),
743
743
+
744
744
+
waveformContainer.leadingAnchor.constraint(equalTo: contentContainer.leadingAnchor),
745
745
+
waveformContainer.trailingAnchor.constraint(equalTo: contentContainer.trailingAnchor),
746
746
+
waveformContainer.topAnchor.constraint(equalTo: contentContainer.topAnchor),
747
747
+
waveformContainer.heightAnchor.constraint(equalToConstant: Self.waveformHeight),
748
748
+
749
749
+
waveformClipView.leadingAnchor.constraint(equalTo: waveformContainer.leadingAnchor, constant: 5),
750
750
+
waveformClipView.trailingAnchor.constraint(equalTo: waveformContainer.trailingAnchor, constant: -5),
751
751
+
waveformClipView.topAnchor.constraint(equalTo: waveformContainer.topAnchor, constant: 5),
752
752
+
waveformClipView.bottomAnchor.constraint(equalTo: waveformContainer.bottomAnchor, constant: -5),
753
753
+
754
754
+
waveformView.leadingAnchor.constraint(equalTo: waveformClipView.leadingAnchor),
755
755
+
waveformView.trailingAnchor.constraint(equalTo: waveformClipView.trailingAnchor),
756
756
+
waveformView.topAnchor.constraint(equalTo: waveformClipView.topAnchor),
757
757
+
waveformView.bottomAnchor.constraint(equalTo: waveformClipView.bottomAnchor),
758
758
+
759
759
+
heldNotesContainer.leadingAnchor.constraint(equalTo: contentContainer.leadingAnchor),
760
760
+
heldNotesContainer.trailingAnchor.constraint(equalTo: contentContainer.trailingAnchor),
761
761
+
heldNotesContainer.topAnchor.constraint(equalTo: waveformContainer.bottomAnchor, constant: 2),
762
762
+
heldNotesContainer.heightAnchor.constraint(equalToConstant: Self.heldNotesRowHeight),
763
763
+
764
764
+
heldNotesStack.centerXAnchor.constraint(equalTo: heldNotesContainer.centerXAnchor),
765
765
+
heldNotesStack.centerYAnchor.constraint(equalTo: heldNotesContainer.centerYAnchor),
766
766
+
767
767
+
instrumentRow.leadingAnchor.constraint(equalTo: contentContainer.leadingAnchor),
768
768
+
instrumentRow.trailingAnchor.constraint(equalTo: contentContainer.trailingAnchor),
769
769
+
instrumentRow.topAnchor.constraint(equalTo: heldNotesContainer.bottomAnchor, constant: 2),
770
770
+
instrumentRow.heightAnchor.constraint(equalToConstant: Self.instrumentRowHeight),
771
771
+
instrumentRow.bottomAnchor.constraint(equalTo: contentContainer.bottomAnchor, constant: -2),
772
772
+
773
773
+
instrumentArrows.leadingAnchor.constraint(equalTo: instrumentRow.leadingAnchor, constant: 6),
774
774
+
instrumentArrows.centerYAnchor.constraint(equalTo: instrumentRow.centerYAnchor),
775
775
+
776
776
+
instrumentLabel.leadingAnchor.constraint(equalTo: instrumentArrows.trailingAnchor, constant: 6),
777
777
+
instrumentLabel.centerYAnchor.constraint(equalTo: instrumentRow.centerYAnchor),
778
778
+
instrumentLabel.trailingAnchor.constraint(equalTo: instrumentRow.trailingAnchor, constant: -8),
779
779
+
])
780
780
+
781
781
+
refresh()
782
782
+
}
783
783
+
784
784
+
@available(*, unavailable)
785
785
+
required init?(coder: NSCoder) {
786
786
+
nil
787
787
+
}
788
788
+
789
789
+
override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
790
790
+
791
791
+
override func updateTrackingAreas() {
792
792
+
super.updateTrackingAreas()
793
793
+
if let trackingArea {
794
794
+
removeTrackingArea(trackingArea)
795
795
+
}
796
796
+
let trackingArea = NSTrackingArea(
797
797
+
rect: bounds,
798
798
+
options: [.activeAlways, .inVisibleRect, .mouseEnteredAndExited],
799
799
+
owner: self,
800
800
+
userInfo: nil
801
801
+
)
802
802
+
addTrackingArea(trackingArea)
803
803
+
self.trackingArea = trackingArea
804
804
+
}
805
805
+
806
806
+
override func mouseEntered(with event: NSEvent) {
807
807
+
onHoverChanged?(true)
808
808
+
super.mouseEntered(with: event)
809
809
+
}
810
810
+
811
811
+
override func mouseExited(with event: NSEvent) {
812
812
+
onHoverChanged?(false)
813
813
+
super.mouseExited(with: event)
814
814
+
}
815
815
+
816
816
+
func refresh() {
817
817
+
guard let menuBand else { return }
818
818
+
let isDark = effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua
819
819
+
waveformView.setLightMode(!isDark)
820
820
+
821
821
+
let safe = max(0, min(127, Int(menuBand.effectiveMelodicProgram)))
822
822
+
let familyColor = menuBand.midiMode
823
823
+
? NSColor.controlAccentColor
824
824
+
: InstrumentListView.colorForProgram(safe)
825
825
+
826
826
+
let waveformBackground = isDark
827
827
+
? NSColor(white: 0.06, alpha: 1.0)
828
828
+
: NSColor(white: 0.82, alpha: 1.0)
829
829
+
let glassWaveformBackground = isDark
830
830
+
? NSColor.white.withAlphaComponent(0.04)
831
831
+
: NSColor.white.withAlphaComponent(0.18)
832
832
+
let instrumentRowBackground = isDark
833
833
+
? NSColor.white.withAlphaComponent(0.08)
834
834
+
: NSColor.white.withAlphaComponent(0.3)
835
835
+
waveformContainer.layer?.backgroundColor = NSColor.clear.cgColor
836
836
+
waveformClipView.layer?.backgroundColor = Self.shouldUseLiquidGlass
837
837
+
? glassWaveformBackground.cgColor
838
838
+
: waveformBackground.cgColor
839
839
+
waveformContainer.layer?.borderWidth = 1
840
840
+
waveformContainer.layer?.borderColor = familyColor.withAlphaComponent(
841
841
+
Self.shouldUseLiquidGlass ? 0.22 : 0.55
842
842
+
).cgColor
843
843
+
instrumentRow.layer?.backgroundColor = Self.shouldUseLiquidGlass
844
844
+
? NSColor.clear.cgColor
845
845
+
: instrumentRowBackground.cgColor
846
846
+
instrumentRow.layer?.borderWidth = 1
847
847
+
instrumentRow.layer?.borderColor = familyColor.withAlphaComponent(
848
848
+
Self.shouldUseLiquidGlass ? 0.22 : 0.35
849
849
+
).cgColor
850
850
+
instrumentLabel.textColor = isDark ? .white : .black
851
851
+
instrumentArrows.accentColor = familyColor
852
852
+
instrumentArrows.isDarkAppearance = isDark
853
853
+
854
854
+
if menuBand.midiMode {
855
855
+
waveformView.setDotMatrix(MenuBandPopoverViewController.midiDotPattern)
856
856
+
waveformView.setBaseColor(.controlAccentColor)
857
857
+
} else {
858
858
+
waveformView.setDotMatrix(nil)
859
859
+
waveformView.setBaseColor(familyColor)
860
860
+
}
861
861
+
862
862
+
let shadow = NSShadow()
863
863
+
shadow.shadowColor = familyColor.withAlphaComponent(isDark ? 0.9 : 0.55)
864
864
+
shadow.shadowOffset = NSSize(width: 0, height: -1)
865
865
+
shadow.shadowBlurRadius = 3
866
866
+
let titleFont: NSFont = {
867
867
+
if let descriptor = AppDelegate.ywftBoldDescriptor,
868
868
+
let font = NSFont(descriptor: descriptor, size: 14),
869
869
+
font.familyName == "YWFT Processing" {
870
870
+
return font
871
871
+
}
872
872
+
return NSFont.systemFont(ofSize: 14, weight: .black)
873
873
+
}()
874
874
+
instrumentLabel.attributedStringValue = NSAttributedString(
875
875
+
string: GeneralMIDI.programNames[safe],
876
876
+
attributes: [
877
877
+
.font: titleFont,
878
878
+
.foregroundColor: isDark ? NSColor.white : NSColor.black,
879
879
+
.shadow: shadow,
880
880
+
]
881
881
+
)
882
882
+
883
883
+
for view in heldNotesStack.arrangedSubviews {
884
884
+
heldNotesStack.removeArrangedSubview(view)
885
885
+
view.removeFromSuperview()
886
886
+
}
887
887
+
for name in menuBand.heldNoteNames() {
888
888
+
heldNotesStack.addArrangedSubview(makeHeldNoteBox(name: name, color: familyColor))
889
889
+
}
890
890
+
891
891
+
if Self.shouldUseLiquidGlass, #available(macOS 26.0, *) {
892
892
+
let paletteTint = familyColor.withAlphaComponent(menuBand.midiMode ? 0.20 : 0.16)
893
893
+
(paletteGlassView as? NSGlassEffectView)?.style = .clear
894
894
+
(paletteGlassView as? NSGlassEffectView)?.tintColor = paletteTint
895
895
+
(waveformGlassView as? NSGlassEffectView)?.style = .clear
896
896
+
(waveformGlassView as? NSGlassEffectView)?.tintColor = paletteTint.withAlphaComponent(0.55)
897
897
+
(instrumentRowGlassView as? NSGlassEffectView)?.style = .clear
898
898
+
(instrumentRowGlassView as? NSGlassEffectView)?.tintColor = paletteTint.withAlphaComponent(0.42)
899
899
+
layer?.backgroundColor = NSColor.clear.cgColor
900
900
+
} else {
901
901
+
layer?.backgroundColor = (isDark
902
902
+
? NSColor(white: 0.06, alpha: 0.96)
903
903
+
: NSColor(white: 0.88, alpha: 0.96)).cgColor
904
904
+
}
905
905
+
}
906
906
+
907
907
+
func setLive(_ isLive: Bool) {
908
908
+
waveformView.isLive = isLive
909
909
+
}
910
910
+
911
911
+
private func makeHeldNoteBox(name: String, color: NSColor) -> NSView {
912
912
+
let box = NSView()
913
913
+
box.translatesAutoresizingMaskIntoConstraints = false
914
914
+
box.wantsLayer = true
915
915
+
box.layer?.cornerRadius = 4
916
916
+
box.layer?.backgroundColor = color.withAlphaComponent(0.85).cgColor
917
917
+
918
918
+
let label = NSTextField(labelWithString: name)
919
919
+
label.translatesAutoresizingMaskIntoConstraints = false
920
920
+
label.font = NSFont.monospacedSystemFont(ofSize: 9, weight: .heavy)
921
921
+
label.textColor = .black
922
922
+
box.addSubview(label)
923
923
+
924
924
+
NSLayoutConstraint.activate([
925
925
+
label.leadingAnchor.constraint(equalTo: box.leadingAnchor, constant: 5),
926
926
+
label.trailingAnchor.constraint(equalTo: box.trailingAnchor, constant: -5),
927
927
+
label.topAnchor.constraint(equalTo: box.topAnchor, constant: 1),
928
928
+
label.bottomAnchor.constraint(equalTo: box.bottomAnchor, constant: -1),
929
929
+
])
930
930
+
return box
931
931
+
}
932
932
+
933
933
+
private func installLiquidGlassBackgrounds() {
934
934
+
guard Self.shouldUseLiquidGlass, #available(macOS 26.0, *) else { return }
935
935
+
936
936
+
let paletteGlassView = UnifiedWaveformStripGlassEffectView()
937
937
+
paletteGlassView.translatesAutoresizingMaskIntoConstraints = false
938
938
+
paletteGlassView.cornerRadius = 10
939
939
+
addSubview(paletteGlassView, positioned: .below, relativeTo: contentContainer)
940
940
+
NSLayoutConstraint.activate([
941
941
+
paletteGlassView.leadingAnchor.constraint(equalTo: leadingAnchor),
942
942
+
paletteGlassView.trailingAnchor.constraint(equalTo: trailingAnchor),
943
943
+
paletteGlassView.topAnchor.constraint(equalTo: topAnchor),
944
944
+
paletteGlassView.bottomAnchor.constraint(equalTo: bottomAnchor),
945
945
+
])
946
946
+
self.paletteGlassView = paletteGlassView
947
947
+
948
948
+
self.waveformGlassView = installGlassBackground(
949
949
+
matchedTo: waveformContainer,
950
950
+
below: waveformContainer,
951
951
+
cornerRadius: 8
952
952
+
)
953
953
+
self.instrumentRowGlassView = installGlassBackground(
954
954
+
matchedTo: instrumentRow,
955
955
+
below: instrumentRow,
956
956
+
cornerRadius: 7
957
957
+
)
958
958
+
}
959
959
+
960
960
+
@available(macOS 26.0, *)
961
961
+
private func installGlassBackground(matchedTo target: NSView,
962
962
+
below anchor: NSView,
963
963
+
cornerRadius: CGFloat) -> NSView {
964
964
+
let glassView = UnifiedWaveformStripGlassEffectView()
965
965
+
glassView.translatesAutoresizingMaskIntoConstraints = false
966
966
+
glassView.cornerRadius = cornerRadius
967
967
+
addSubview(glassView, positioned: .below, relativeTo: anchor)
968
968
+
NSLayoutConstraint.activate([
969
969
+
glassView.leadingAnchor.constraint(equalTo: target.leadingAnchor),
970
970
+
glassView.trailingAnchor.constraint(equalTo: target.trailingAnchor),
971
971
+
glassView.topAnchor.constraint(equalTo: target.topAnchor),
972
972
+
glassView.bottomAnchor.constraint(equalTo: target.bottomAnchor),
973
973
+
])
974
974
+
return glassView
975
975
+
}
976
976
+
977
977
+
}
+27
-5
slab/menuband/Sources/MenuBand/WaveformView.swift
+27
-5
slab/menuband/Sources/MenuBand/WaveformView.swift
···
61
61
stopLink()
62
62
for i in 0..<levels.count { levels[i] = 0 }
63
63
for i in 0..<displayLevels.count { displayLevels[i] = 0 }
64
64
-
display() // one final paint to clear bars
64
64
+
requestDisplay() // one final paint to clear bars
65
65
}
66
66
}
67
67
}
···
88
88
dotMatrixActive = true
89
89
// Static frame — nudge a single redraw so the pattern
90
90
// appears even when the live link is off.
91
91
-
display()
91
91
+
requestDisplay()
92
92
} else {
93
93
stopDotMatrix()
94
94
}
···
99
99
for i in 0..<dotMasks.count { dotMasks[i] = 0 }
100
100
uniforms.dotMatrix = 0
101
101
dotMatrixActive = false
102
102
-
display()
102
102
+
requestDisplay()
103
103
}
104
104
}
105
105
···
119
119
// slow frame can build a backlog of stale draw requests.
120
120
guard view.markDisplayPending() else { return kCVReturnSuccess }
121
121
DispatchQueue.main.async {
122
122
-
view.display()
122
122
+
view.requestDisplay()
123
123
view.clearDisplayPending()
124
124
}
125
125
return kCVReturnSuccess
···
157
157
pendingDisplayLock.unlock()
158
158
}
159
159
160
160
+
private var canDrawSurface: Bool {
161
161
+
guard window?.isVisible == true,
162
162
+
!isHiddenOrHasHiddenAncestor,
163
163
+
bounds.width > 0,
164
164
+
bounds.height > 0 else {
165
165
+
return false
166
166
+
}
167
167
+
return true
168
168
+
}
169
169
+
170
170
+
private func requestDisplay() {
171
171
+
guard Thread.isMainThread else {
172
172
+
DispatchQueue.main.async { [weak self] in
173
173
+
self?.requestDisplay()
174
174
+
}
175
175
+
return
176
176
+
}
177
177
+
guard canDrawSurface else { return }
178
178
+
display()
179
179
+
}
180
180
+
160
181
deinit { stopLink() }
161
182
162
183
override func viewDidMoveToWindow() {
···
318
339
clearColor = MTLClearColor(red: 0.06, green: 0.08, blue: 0.10, alpha: 1.0)
319
340
uniforms.isLight = 0
320
341
}
321
321
-
display()
342
342
+
requestDisplay()
322
343
}
323
344
324
345
func setSurfaceStyle(_ style: SurfaceStyle) {
···
407
428
func mtkView(_ view: MTKView, drawableSizeWillChange size: CGSize) {}
408
429
409
430
func draw(in view: MTKView) {
431
431
+
guard canDrawSurface else { return }
410
432
updateLevels()
411
433
412
434
let drawableSize = view.drawableSize