feat(macos): UI overhaul -- toolbar, unified log, PM windows, settings window, hotkeys

Mirrors the Windows client's UI overhaul (commit 97fa659 + 540ec13) adapted to
Mac-native conventions. The main window is now just toolbar + channels + users
+ chat; audio device settings moved to a modeless Settings window.

- NSToolbar: Join Voice, Share Screen Audio, Mute, Deafen (SF Symbol toggle
  buttons) + Output Volume slider (NSSlider 0-100, default 80). Voice actions,
  mute/deafen, and output volume moved out of the bottom panel into the toolbar
- Audio device settings (input mode, VAD sensitivity, PTT key, device picker,
  level meter) moved to a new SettingsWindowController -- a modeless window
  opened via the app menu's "Settings..." (Cmd+,) item. Source-of-truth for
  audio state lives in MainWindowController so voice start applies settings even
  before the window has been opened; SettingsWindowController reads from /
  writes back to those properties and applies changes live when voice is active.
  Level meter forwarded from handleLevel -> updateLevel(rms:)
- Unified log: chat NSTextView + activity NSTableView collapsed into a single
  NSTextView -- activity events in secondaryLabelColor (gray), chat in default
- Private messaging: scope dropdown removed; compose always sends to the
  current channel. Each PM conversation opens in its own modeless
  PrivateMessageWindowController. Incoming .textMessage with .private scope
  routed to the right window; outgoing PMs echoed by server arrive through the
  same path. "Send Private Message..." added to user context menu.
- Messages menu: "New Private Message..." (Cmd+Shift+N) opens a UserPickerSheet
  listing all server users so you can PM anyone on the server
- Channel tree now shows live user counts, e.g. "General (3)"; refreshChannelTree
  called on .userJoined/.userLeft (was missing)
- Voice menu: Join Voice (Cmd+Shift+V), Share Screen Audio (Cmd+Shift+S),
  Mute (Cmd+Shift+M), Deafen (Cmd+Shift+D) -- NSMenuItem key equivalents with
  [.command, .shift] mask, dispatched by the responder chain
- setOutputVolume(_:) wrapper added to VoiceCatClient.swift (was missing -- the
  C ABI + C# wrapper shipped in commit 97fa659 but the Swift wrapper was never
  added); wired end-to-end: toolbar slider -> client.setOutputVolume(gain)

Part A -- fixed and verified the previously-uncompiled Swift from the external
PCM feed/tap commit (615d2a8):
- Rebuilt the macOS xcframework slice (regenerated the module map from current
  voicecat.h, exposing vc_pcm_sink_cb / vc_stream_feed_pcm / vc_set_pcm_sink)
- Fixed feedPcm type bug: size_t imports as Int in Swift not UInt; the original
  UInt(samplesPerChannel) was wrong
- Added VoiceCatPcmSinkCallback typealias -- a Swift-idiomatic public alias for
  the C vc_pcm_sink_cb so consumers (tests, the macOS app) can declare a sink
  callback without directly importing the VoiceCatC C module. Mirrors the C#
  VcPcmSinkCallback delegate
- keyCodeName helper deduplicated (was in PttKeyCaptureSheet.swift +
  MainWindowController.swift -- now shared)

Platform-specific adaptations (vs. Windows): NSToolbar instead of ToolStrip;
global menu bar + NSMenuItem key equivalents (Cmd not Ctrl, responder-chain
dispatched, no custom key monitor needed); PM windows as modeless NSWindows;
picker as Mac sheet; gray = secondaryLabelColor; SF Symbols for toolbar icons.

swift test 10/10 (4 ExternalPcmTests + 6 VoiceCatClientSmokeTests against a
live server); xcodebuild Debug + Release BUILD SUCCEEDED with 0 Swift warnings.
This commit is contained in:
2026-06-20 23:30:52 +02:00
parent 615d2a8e5f
commit 6ab78fa792
9 changed files with 1135 additions and 339 deletions

View File

@@ -0,0 +1,165 @@
import AppKit
import VoiceCatCore
// PrivateMessageWindowController a modeless window for a single private message
// conversation, owned and routed-to by MainWindowController. Mirrors the Windows client's
// `PrivateMessageForm` (clients/windows/VoiceCat.App/Forms/PrivateMessageForm.cs): each PM
// conversation opens in its own window instead of sharing the main chat log via a scope
// dropdown. MainWindowController routes incoming `.textMessage` events with `.private` scope
// to the right window; outgoing PMs are echoed back by the server and arrive through the
// same path (no optimistic local echo).
//
// The window is modeless (`NSWindow`) rather than a sheet because the user should be able to
// keep chatting in the main channel while a PM window is open the same Discord/Slack
// pattern the Windows client follows.
final class PrivateMessageWindowController: NSWindowController, NSWindowDelegate, NSTextViewDelegate {
// MARK: - Owned state
private let client: VoiceCatClient
let otherUserId: UInt32
private let selfUserId: UInt32
private let nickname: String
// MARK: - UI
private let historyTextView: NSTextView = {
let tv = NSTextView()
tv.isEditable = false
tv.isSelectable = true
tv.isAutomaticQuoteSubstitutionEnabled = false
tv.textContainerInset = NSSize(width: 4, height: 4)
return tv
}()
private let composeField = NSTextField()
private let sendButton = NSButton()
// MARK: - Init
init(client: VoiceCatClient, otherUserId: UInt32, nickname: String, selfUserId: UInt32) {
self.client = client
self.otherUserId = otherUserId
self.selfUserId = selfUserId
self.nickname = nickname
let window = NSWindow(
contentRect: NSRect(x: 0, y: 0, width: 460, height: 360),
styleMask: [.titled, .closable, .miniaturizable, .resizable],
backing: .buffered,
defer: false
)
window.title = "Private Message — \(nickname)"
window.minSize = NSSize(width: 300, height: 220)
window.center()
super.init(window: window)
window.delegate = self
buildUI()
}
required init?(coder: NSCoder) { fatalError() }
// MARK: - UI construction
private func buildUI() {
guard let contentView = window?.contentView else { return }
historyTextView.setAccessibilityLabel("Private message history with \(nickname)")
let scroll = NSScrollView()
scroll.documentView = historyTextView
scroll.hasVerticalScroller = true
scroll.borderType = .noBorder
scroll.translatesAutoresizingMaskIntoConstraints = false
contentView.addSubview(scroll)
composeField.placeholderString = "Type a private message…"
composeField.setAccessibilityLabel("Private message to \(nickname)")
composeField.target = self
composeField.action = #selector(sendClicked)
sendButton.title = "Send"
sendButton.bezelStyle = .rounded
sendButton.target = self
sendButton.action = #selector(sendClicked)
sendButton.setAccessibilityLabel("Send private message")
sendButton.keyEquivalent = "\r"
let sep = NSBox()
sep.boxType = .separator
sep.translatesAutoresizingMaskIntoConstraints = false
contentView.addSubview(sep)
let composeBar = NSStackView(views: [composeField, sendButton])
composeBar.orientation = .horizontal
composeBar.spacing = 6
composeBar.translatesAutoresizingMaskIntoConstraints = false
contentView.addSubview(composeBar)
NSLayoutConstraint.activate([
scroll.topAnchor.constraint(equalTo: contentView.topAnchor),
scroll.leadingAnchor.constraint(equalTo: contentView.leadingAnchor),
scroll.trailingAnchor.constraint(equalTo: contentView.trailingAnchor),
scroll.bottomAnchor.constraint(equalTo: sep.topAnchor),
sep.leadingAnchor.constraint(equalTo: contentView.leadingAnchor),
sep.trailingAnchor.constraint(equalTo: contentView.trailingAnchor),
sep.heightAnchor.constraint(equalToConstant: 1),
sep.bottomAnchor.constraint(equalTo: composeBar.topAnchor),
composeBar.leadingAnchor.constraint(equalTo: contentView.leadingAnchor, constant: 8),
composeBar.trailingAnchor.constraint(equalTo: contentView.trailingAnchor, constant: -8),
composeBar.bottomAnchor.constraint(equalTo: contentView.bottomAnchor, constant: -8),
composeBar.heightAnchor.constraint(equalToConstant: 28),
sendButton.widthAnchor.constraint(equalToConstant: 70),
])
window?.makeFirstResponder(composeField)
}
// MARK: - Public called by MainWindowController
/// Append a message line. `isSelf=true` renders in gray (our own echoed outgoing message);
/// `false` renders in default color (incoming from the other user). Mirrors the Windows
/// `PrivateMessageForm.AppendMessage`.
func appendMessage(time: String, isSelf: Bool, sender: String, text: String) {
let line = "[\(time)] \(sender): \(text)\n"
let attrs: [NSAttributedString.Key: Any] = isSelf
? [.foregroundColor: NSColor.secondaryLabelColor]
: [:]
let attributed = NSAttributedString(string: line, attributes: attrs)
historyTextView.textStorage?.append(attributed)
historyTextView.scrollToEndOfDocument(nil)
}
/// Append a gray status/activity line (e.g. the other user disconnected). Mirrors the
/// Windows `PrivateMessageForm.AppendActivity`.
func appendActivity(_ text: String) {
let time = DateFormatter.localizedString(from: Date(), dateStyle: .none, timeStyle: .short)
let line = "[\(time)] \(text)\n"
let attributed = NSAttributedString(string: line, attributes: [
.foregroundColor: NSColor.secondaryLabelColor,
])
historyTextView.textStorage?.append(attributed)
historyTextView.scrollToEndOfDocument(nil)
}
// MARK: - Send
@objc private func sendClicked() {
let msg = composeField.stringValue.trimmingCharacters(in: .whitespaces)
guard !msg.isEmpty else { return }
client.sendText(scope: .private, targetId: otherUserId, text: msg)
composeField.stringValue = ""
}
// MARK: - NSWindowDelegate
func windowWillClose(_ notification: Notification) {
// Notify the owner so it can drop this controller from its pmWindows map.
// MainWindowController observes NSWindow.willCloseNotification on this window.
}
}

View File

@@ -0,0 +1,297 @@
import AppKit
import VoiceCatCore
// SettingsWindowController a modeless window containing the audio input settings that used
// to live in the main window's bottom voice panel: input mode (VAD/PTT/Always On), VAD
// sensitivity, PTT key selection, input device picker, and the live microphone level meter.
//
// The main window is now just toolbar + channels + users + chat; audio settings live here
// and are accessed via the app menu's "Settings" item (,). The window is modeless so the
// user can keep it open while interacting with the main window essential for watching the
// level meter while adjusting VAD threshold or testing a device.
//
// Source-of-truth for the current settings lives in MainWindowController (so voice start can
// apply them even before this window has been opened). This window reads from and writes back
// to MainWindowController's stored properties, and applies changes to the client immediately
// when voice is active.
final class SettingsWindowController: NSWindowController, NSWindowDelegate {
// MARK: - References
private let client: VoiceCatClient
weak var mainController: MainWindowController?
// MARK: - UI
private let inputModeControl = NSSegmentedControl(labels: ["VAD", "PTT", "Always On"],
trackingMode: .selectOne,
target: nil, action: nil)
private let vadSlider: NSSlider = {
let s = NSSlider(value: 50, minValue: 1, maxValue: 100, target: nil, action: nil)
s.numberOfTickMarks = 0
return s
}()
private let vadLabel = NSTextField(labelWithString: "Sensitivity:")
private let pttKeyLabel = NSTextField(labelWithString: "(F8)")
private let changePttButton = NSButton()
private let devicePicker = NSPopUpButton()
private let refreshDevicesButton = NSButton()
private let levelMeter: NSProgressIndicator = {
let p = NSProgressIndicator()
p.style = .bar
p.isIndeterminate = false
p.minValue = 0
p.maxValue = 100
p.doubleValue = 0
return p
}()
// Cached VAD slider position so we can restore it when the window reopens.
private var vadSliderValue: Double = 50
// MARK: - Init
init(client: VoiceCatClient, mainController: MainWindowController) {
self.client = client
self.mainController = mainController
let window = NSWindow(
contentRect: NSRect(x: 0, y: 0, width: 380, height: 260),
styleMask: [.titled, .closable, .miniaturizable],
backing: .buffered,
defer: false
)
window.title = "Audio Settings"
window.minSize = NSSize(width: 340, height: 220)
window.center()
super.init(window: window)
window.delegate = self
buildUI()
syncFromMainController()
loadInputDevices()
}
required init?(coder: NSCoder) { fatalError() }
// MARK: - UI construction
private func buildUI() {
guard let contentView = window?.contentView else { return }
let inputModeLabel = NSTextField(labelWithString: "Input mode:")
inputModeLabel.setAccessibilityLabel("Input mode")
inputModeControl.target = self
inputModeControl.action = #selector(inputModeChanged)
inputModeControl.selectedSegment = 0
inputModeControl.setAccessibilityLabel("Input mode: VAD, PTT, or Always On")
vadLabel.setAccessibilityLabel("VAD sensitivity")
vadSlider.target = self
vadSlider.action = #selector(vadSliderChanged)
vadSlider.setAccessibilityLabel("Voice activation sensitivity")
vadSlider.setAccessibilityHelp("Drag right for more sensitive, left for less")
pttKeyLabel.setAccessibilityLabel("Current PTT key")
changePttButton.title = "Change…"
changePttButton.bezelStyle = .rounded
changePttButton.target = self
changePttButton.action = #selector(changePttClicked)
changePttButton.setAccessibilityLabel("Change push-to-talk key")
pttKeyLabel.isHidden = true
changePttButton.isHidden = true
let deviceLabel = NSTextField(labelWithString: "Input device:")
deviceLabel.setAccessibilityLabel("Input device")
devicePicker.setAccessibilityLabel("Input audio device")
devicePicker.target = self
devicePicker.action = #selector(deviceChanged)
refreshDevicesButton.title = ""
refreshDevicesButton.bezelStyle = .rounded
refreshDevicesButton.target = self
refreshDevicesButton.action = #selector(refreshDevicesClicked)
refreshDevicesButton.setAccessibilityLabel("Refresh device list")
refreshDevicesButton.toolTip = "Refresh"
let levelLabel = NSTextField(labelWithString: "Level:")
levelLabel.setAccessibilityLabel("Microphone input level")
levelMeter.setAccessibilityLabel("Microphone input level")
levelMeter.setAccessibilityHelp("Shows current microphone volume level")
let inputModeRow = NSStackView(views: [inputModeLabel, inputModeControl])
inputModeRow.orientation = .horizontal
inputModeRow.spacing = 8
let vadRow = NSStackView(views: [vadLabel, vadSlider])
vadRow.orientation = .horizontal
vadRow.spacing = 8
let pttRow = NSStackView(views: [pttKeyLabel, changePttButton])
pttRow.orientation = .horizontal
pttRow.spacing = 8
let deviceRow = NSStackView(views: [deviceLabel, devicePicker, refreshDevicesButton])
deviceRow.orientation = .horizontal
deviceRow.spacing = 8
let levelRow = NSStackView(views: [levelLabel, levelMeter])
levelRow.orientation = .horizontal
levelRow.spacing = 8
let stack = NSStackView(views: [inputModeRow, vadRow, pttRow, deviceRow, levelRow])
stack.orientation = .vertical
stack.spacing = 12
stack.alignment = .leading
stack.edgeInsets = NSEdgeInsets(top: 20, left: 20, bottom: 20, right: 20)
stack.translatesAutoresizingMaskIntoConstraints = false
contentView.addSubview(stack)
NSLayoutConstraint.activate([
stack.topAnchor.constraint(equalTo: contentView.topAnchor),
stack.leadingAnchor.constraint(equalTo: contentView.leadingAnchor),
stack.trailingAnchor.constraint(equalTo: contentView.trailingAnchor),
stack.bottomAnchor.constraint(equalTo: contentView.bottomAnchor),
vadSlider.widthAnchor.constraint(greaterThanOrEqualToConstant: 200),
levelMeter.widthAnchor.constraint(equalToConstant: 200),
devicePicker.widthAnchor.constraint(greaterThanOrEqualToConstant: 180),
])
}
// MARK: - Sync from MainWindowController
/// Read the current settings from MainWindowController and update our UI to match.
/// Called on init and whenever the window is re-shown.
private func syncFromMainController() {
guard let mc = mainController else { return }
switch mc.selectedInputMode {
case .voiceActivation: inputModeControl.selectedSegment = 0
case .pushToTalk: inputModeControl.selectedSegment = 1
case .alwaysOn: inputModeControl.selectedSegment = 2
}
vadSlider.doubleValue = vadSliderValue
pttKeyLabel.stringValue = "(\(keyCodeName(mc.pttKeyCode)))"
updateConditionalControls()
}
/// Show/hide VAD and PTT controls based on the selected input mode.
private func updateConditionalControls() {
let seg = inputModeControl.selectedSegment
vadLabel.isHidden = seg != 0
vadSlider.isHidden = seg != 0
pttKeyLabel.isHidden = seg != 1
changePttButton.isHidden = seg != 1
}
// MARK: - Actions
@objc private func inputModeChanged() {
updateConditionalControls()
let mode = currentInputMode()
mainController?.selectedInputMode = mode
if let mc = mainController, mc.micStreamId != 0 {
client.setInputMode(mode)
if mode == .voiceActivation {
client.setVadThreshold(vadThresholdFromSlider())
} else if mode == .pushToTalk {
client.setPushToTalk(false)
}
}
}
@objc private func vadSliderChanged() {
vadSliderValue = vadSlider.doubleValue
let threshold = vadThresholdFromSlider()
mainController?.vadThresholdValue = threshold
if let mc = mainController, mc.micStreamId != 0, mc.selectedInputMode == .voiceActivation {
client.setVadThreshold(threshold)
}
}
@objc private func changePttClicked() {
guard let mc = mainController else { return }
let sheet = PttKeyCaptureSheet(currentKeyCode: mc.pttKeyCode)
sheet.onComplete = { [weak self] keyCode in
guard let self, let keyCode else { return }
self.mainController?.pttKeyCode = keyCode
self.pttKeyLabel.stringValue = "(\(keyCodeName(keyCode)))"
}
presentSheet(sheet)
}
@objc private func refreshDevicesClicked() { loadInputDevices() }
@objc private func deviceChanged() {
let devId = devicePicker.selectedItem?.representedObject as? String
mainController?.selectedInputDeviceId = devId
if let mc = mainController, mc.micStreamId != 0, let devId {
client.setInputDevice(streamId: mc.micStreamId, deviceId: devId)
}
}
// MARK: - Level meter (called by MainWindowController)
func updateLevel(rms: Float) {
levelMeter.doubleValue = min(100, Double(rms * 400))
levelMeter.setAccessibilityValue("\(Int(levelMeter.doubleValue)) percent")
}
func resetLevel() {
levelMeter.doubleValue = 0
}
// MARK: - Device enumeration
private func loadInputDevices() {
let devices = client.listDevices(.input)
let prevSelected = devicePicker.selectedItem?.representedObject as? String
devicePicker.removeAllItems()
for d in devices {
let item = NSMenuItem(title: d.name, action: nil, keyEquivalent: "")
item.representedObject = d.id
devicePicker.menu?.addItem(item)
}
// Restore previous selection, or pick default, or first
if let prev = prevSelected,
let item = devicePicker.itemArray.first(where: { ($0.representedObject as? String) == prev }) {
devicePicker.select(item)
} else if let def = devices.first(where: { $0.isDefault }) {
devicePicker.select(devicePicker.item(withTitle: def.name))
} else if devicePicker.numberOfItems > 0 {
devicePicker.selectItem(at: 0)
}
// Sync the selected device back to main controller
let devId = devicePicker.selectedItem?.representedObject as? String
mainController?.selectedInputDeviceId = devId
}
// MARK: - Helpers
private func currentInputMode() -> VoiceCatInputMode {
switch inputModeControl.selectedSegment {
case 1: return .pushToTalk
case 2: return .alwaysOn
default: return .voiceActivation
}
}
private func vadThresholdFromSlider() -> Float {
0.1 * (1.0 - Float(vadSlider.doubleValue - 1.0) / 99.0)
}
private func presentSheet(_ vc: NSViewController) {
if let cvc = window?.contentViewController {
cvc.presentAsSheet(vc)
} else {
let cvc = NSViewController()
cvc.view = window!.contentView!
window?.contentViewController = cvc
cvc.presentAsSheet(vc)
}
}
}