hl-valdemar/terebi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases Wiki Activity

feat: adopt IINA-style playback window

Browse Source
This commit is contained in:
Valdemar Høgsvig Lorenzen
2026-10-10 01:35:49 +02:00
parent df2456f559
commit 462cb52eb2
8 changed files with 654 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Sources/App/PlayerApp.swift
+484 -61
View File
@@ -11,10 +11,21 @@ final class PlayerModel: ObservableObject {
@Published private(set) var pendingRevision: UInt64?
@Published var seekPosition = 0.0
@Published var isSeeking = false
@Published private(set) var volume = 1.0
@Published private(set) var controlsVisible = true
@Published private(set) var isFullScreen = false
@Published private(set) var isOnTop = false
let videoView: NSView?
private var handle: OpaquePointer?
private var timer: Timer?
private weak var window: NSWindow?
private var hideDeadline: ContinuousClock.Instant?
private var controlsHovered = false
private var titleHovered = false
private var controlsDragging = false
private var windowActive = true
private var lastAudibleVolume = 1.0
private init() {
let player = player_create()
@@ -22,14 +33,13 @@ final class PlayerModel: ObservableObject {
if let player, let view = player_macos_make_video_view(player) {
videoView = Unmanaged<NSView>.fromOpaque(view).takeRetainedValue()
state = player_get_state(player)
volume = Double(player_get_volume(player))
} else {
videoView = nil
commandError = "Could not create the media player."
}
timer = Timer.scheduledTimer(withTimeInterval: 0.05, repeats: true) { [weak self] _ in
Task { @MainActor [weak self] in
self?.poll()
}
MainActor.assumeIsolated { self?.poll() }
}
}
@@ -41,19 +51,8 @@ final class PlayerModel: ObservableObject {
var canSeek: Bool { canTogglePlayback && state.duration.isFinite && state.duration > 0 }
var canOpen: Bool { handle != nil && !isBusy }
var canClose: Bool { handle != nil && !isBusy && state.status != PLAYER_EMPTY }
var canSetVolume: Bool { handle != nil && !isBusy && state.has_audio && state.status != PLAYER_ERROR }
var duration: Double { state.duration.isFinite ? max(0, state.duration) : 0 }
var statusText: String {
if isBusy { return "Opening…" }
switch state.status {
case PLAYER_EMPTY: return "Open a local audio or video file to begin."
case PLAYER_OPENING: return "Opening…"
case PLAYER_PAUSED: return "Paused"
case PLAYER_PLAYING: return "Playing"
case PLAYER_ENDED: return "Finished"
case PLAYER_ERROR: return "Unable to play this file"
default: return "Unavailable"
}
}
var errorText: String? {
if let commandError { return commandError }
guard state.status == PLAYER_ERROR else { return nil }
@@ -66,6 +65,7 @@ final class PlayerModel: ObservableObject {
func openPanel() {
guard canOpen else { return }
revealControls()
let panel = NSOpenPanel()
panel.canChooseFiles = true
panel.canChooseDirectories = false
@@ -75,8 +75,13 @@ final class PlayerModel: ObservableObject {
open(url)
}
private func open(_ url: URL) {
guard let handle else { return }
func open(_ url: URL) {
guard canOpen, let handle else { return }
guard url.isFileURL else {
commandError = "Only local media files are supported."
revealControls()
return
}
let revision = player_get_state(handle).revision
let accepted = url.withUnsafeFileSystemRepresentation { path in
guard let path else { return false }
@@ -92,12 +97,16 @@ final class PlayerModel: ObservableObject {
commandError = nil
isSeeking = false
seekPosition = 0
window?.representedURL = url
window?.title = url.lastPathComponent
revealControls()
}
func togglePlayback() {
guard let handle, canTogglePlayback else { return }
let accepted = state.status == PLAYER_PLAYING ? player_pause(handle) : player_play(handle)
commandError = accepted ? nil : "Could not queue playback. Please try again."
revealControls()
}
func finishSeeking() {
@@ -105,6 +114,7 @@ final class PlayerModel: ObservableObject {
guard let handle, canSeek else { return }
let position = min(max(0, seekPosition), duration)
commandError = player_seek(handle, position) ? nil : "Could not queue the seek. Please try again."
revealControls()
}
func closeFile() {
@@ -116,6 +126,108 @@ final class PlayerModel: ObservableObject {
fileName = nil
commandError = nil
isSeeking = false
window?.representedURL = nil
window?.title = "Player"
revealControls()
}
func seekRelative(_ seconds: Double) {
guard canSeek, let handle else { return }
let target = min(max(0, state.position + seconds), duration)
commandError = player_seek(handle, target) ? nil : "Could not queue the seek. Please try again."
seekPosition = target
revealControls()
}
func setVolume(_ value: Double) {
guard let handle else { return }
if player_set_volume(handle, Float(value)) {
volume = Double(player_get_volume(handle))
if volume > 0 { lastAudibleVolume = volume }
}
revealControls()
}
func toggleMute() {
guard canSetVolume else { return }
setVolume(volume == 0 ? lastAudibleVolume : 0)
}
func attachWindow(_ window: NSWindow) {
self.window = window
window.title = fileName ?? "Player"
updateWindowState()
}
func updateWindowState() {
guard let window else { return }
isFullScreen = window.styleMask.contains(.fullScreen)
windowActive = window.isKeyWindow
window.level = isOnTop && !isFullScreen ? .floating : .normal
revealControls()
}
func toggleFullScreen() {
window?.toggleFullScreen(nil)
revealControls()
}
func toggleOnTop() {
guard !isFullScreen else { return }
isOnTop.toggle()
window?.level = isOnTop ? .floating : .normal
revealControls()
}
func setControlsHovered(_ hovered: Bool) {
guard controlsHovered != hovered else { return }
controlsHovered = hovered
revealControls()
}
func setTitleHovered(_ hovered: Bool) {
guard titleHovered != hovered else { return }
titleHovered = hovered
revealControls()
}
func setControlsDragging(_ dragging: Bool) {
guard controlsDragging != dragging else { return }
controlsDragging = dragging
revealControls()
}
func hideControls(hideCursor: Bool = true) {
guard shouldHideControls else { return }
hideDeadline = nil
withAnimation(NSWorkspace.shared.accessibilityDisplayShouldReduceMotion ? nil : .easeIn(duration: 0.25)) {
controlsVisible = false
}
NSCursor.setHiddenUntilMouseMoves(hideCursor)
}
func beginSeeking() {
isSeeking = true
revealControls()
}
func revealControls() {
hideDeadline = nil
NSCursor.setHiddenUntilMouseMoves(false)
if !controlsVisible {
withAnimation(NSWorkspace.shared.accessibilityDisplayShouldReduceMotion ? nil : .easeOut(duration: 0.25)) {
controlsVisible = true
}
}
guard shouldHideControls else { return }
hideDeadline = ContinuousClock.now.advanced(by: .milliseconds(2500))
}
private var shouldHideControls: Bool {
canTogglePlayback && state.has_video && fileName != nil &&
!isSeeking && !controlsHovered && !titleHovered && !controlsDragging &&
windowActive && errorText == nil &&
!NSWorkspace.shared.isVoiceOverEnabled
}
private func poll() {
@@ -125,15 +237,20 @@ final class PlayerModel: ObservableObject {
guard next.revision != revision, next.status != PLAYER_OPENING else { return }
pendingRevision = nil
}
let statusChanged = state.status != next.status
state = next
if !isSeeking {
seekPosition = min(max(0, next.position.isFinite ? next.position : 0), duration)
}
if statusChanged { revealControls() }
if let hideDeadline, ContinuousClock.now >= hideDeadline { hideControls() }
}
func shutdown() {
timer?.invalidate()
timer = nil
hideDeadline = nil
NSCursor.setHiddenUntilMouseMoves(false)
guard let player = handle else { return }
handle = nil
player_destroy(player)
@@ -151,6 +268,12 @@ private struct VideoSurface: NSViewRepresentable {
@MainActor
private struct PlayerContent: View {
@ObservedObject var model: PlayerModel
@State private var showsRemainingTime = false
@State private var dropTargeted = false
@State private var controlSize = CGSize(width: 460, height: 82)
// Relative offsets preserve the dragged position across resize/fullscreen.
@State private var controlOffset = CGSize.zero
@State private var dragOrigin = CGSize.zero
private func time(_ seconds: Double) -> String {
let value = Int(min(max(0, seconds.isFinite ? seconds : 0), Double(Int.max / 2)))
@@ -160,58 +283,332 @@ private struct PlayerContent: View {
: String(format: "%d:%02d", value / 60, value % 60)
}
private func iconButton(_ symbol: String, _ label: String, action: @escaping () -> Void) -> some View {
Button(action: action) {
Image(systemName: symbol).font(.system(size: 17)).frame(width: 24, height: 24)
}
.buttonStyle(.plain)
.help(label)
.accessibilityLabel(label)
}
private var titlebar: some View {
HStack(spacing: 4) {
Image(systemName: model.fileName == nil ? "play.rectangle.fill" : "doc.fill")
.font(.system(size: 14))
.foregroundStyle(.secondary)
Text(model.fileName ?? "Player")
.font(.system(size: 13, weight: .medium))
.lineLimit(1)
.truncationMode(.middle)
.help(model.fileName ?? "Player")
Spacer(minLength: 12)
iconButton(model.isFullScreen ? "arrow.down.right.and.arrow.up.left" : "arrow.up.left.and.arrow.down.right",
model.isFullScreen ? "Exit Full Screen" : "Enter Full Screen", action: model.toggleFullScreen)
iconButton(model.isOnTop ? "pin.fill" : "pin",
model.isOnTop ? "Stop Keeping Window on Top" : "Keep Window on Top", action: model.toggleOnTop)
.foregroundStyle(model.isOnTop ? .white : .secondary)
.disabled(model.isFullScreen)
}
.padding(.leading, model.isFullScreen ? 16 : 86)
.padding(.trailing, 12)
.frame(height: 40)
.background(.ultraThinMaterial)
.overlay(alignment: .bottom) { Rectangle().fill(.white.opacity(0.08)).frame(height: 1) }
.background(WindowChrome(model: model))
.onHover(perform: model.setTitleHovered)
.opacity(model.controlsVisible ? 1 : 0)
.allowsHitTesting(model.controlsVisible)
.accessibilityHidden(!model.controlsVisible)
}
private var playbackControls: some View {
VStack(spacing: 8) {
HStack(spacing: 0) {
HStack(spacing: 4) {
iconButton(model.volume == 0 ? "speaker.slash.fill" : "speaker.wave.2.fill",
model.volume == 0 ? "Unmute" : "Mute", action: model.toggleMute)
Slider(value: Binding(get: { model.volume }, set: model.setVolume), in: 0...1)
.controlSize(.mini)
.frame(width: 70)
.accessibilityLabel("Volume")
.accessibilityValue("\(Int((model.volume * 100).rounded())) percent")
}
.disabled(!model.canSetVolume)
.frame(width: 106, alignment: .leading)
Spacer(minLength: 8)
HStack(spacing: 20) {
iconButton("backward.fill", "Seek Back 5 Seconds") { model.seekRelative(-5) }
.disabled(!model.canSeek)
Button(action: model.togglePlayback) {
Image(systemName: model.state.status == PLAYER_PLAYING ? "pause.fill" : "play.fill")
.font(.system(size: 28))
.frame(width: 32, height: 32)
}
.buttonStyle(.plain)
.accessibilityLabel(model.state.status == PLAYER_PLAYING ? "Pause" : "Play")
.help(model.state.status == PLAYER_PLAYING ? "Pause (Space)" : "Play (Space)")
.disabled(!model.canTogglePlayback)
iconButton("forward.fill", "Seek Forward 5 Seconds") { model.seekRelative(5) }
.disabled(!model.canSeek)
}
Spacer(minLength: 8)
HStack(spacing: 12) {
iconButton(model.isFullScreen ? "arrow.down.right.and.arrow.up.left" : "arrow.up.left.and.arrow.down.right",
model.isFullScreen ? "Exit Full Screen" : "Enter Full Screen", action: model.toggleFullScreen)
Menu {
Button("Open File…", action: model.openPanel).disabled(!model.canOpen)
Button("Close File", action: model.closeFile).disabled(!model.canClose)
Divider()
Button(model.isOnTop ? "Stop Keeping Window on Top" : "Keep Window on Top", action: model.toggleOnTop)
.disabled(model.isFullScreen)
} label: {
Image(systemName: "ellipsis.circle").font(.system(size: 18)).frame(width: 24, height: 24)
}
.menuStyle(.borderlessButton)
.menuIndicator(.hidden)
.fixedSize()
.accessibilityLabel("Playback Actions")
.help("Playback Actions")
}
.frame(width: 106, alignment: .trailing)
}
.padding(.horizontal, 12)
.padding(.top, 14)
HStack(spacing: 8) {
Text(time(model.seekPosition)).frame(width: 46, alignment: .trailing)
Slider(value: $model.seekPosition, in: 0...max(model.duration, 0.001), onEditingChanged: { editing in
if editing { model.beginSeeking() } else { model.finishSeeking() }
})
.controlSize(.mini)
.disabled(!model.canSeek)
.accessibilityLabel("Playback Position")
.accessibilityValue(time(model.seekPosition))
Button {
showsRemainingTime.toggle()
model.revealControls()
} label: {
Text(showsRemainingTime ? "−" + time(model.duration - model.seekPosition) : time(model.duration))
.frame(width: 46, alignment: .leading)
}
.buttonStyle(.plain)
.help(showsRemainingTime ? "Show Duration" : "Show Remaining Time")
.accessibilityLabel(showsRemainingTime ? "Remaining Time" : "Duration")
.accessibilityValue(time(showsRemainingTime ? model.duration - model.seekPosition : model.duration))
}
.font(.system(size: 11).monospacedDigit())
.foregroundStyle(.secondary)
.padding(.horizontal, 8)
.padding(.bottom, 8)
}
.tint(.white)
.onHover(perform: model.setControlsHovered)
}
private func controllerPosition(in size: CGSize) -> CGPoint {
let x = size.width / 2 + controlOffset.width * size.width
let y = size.height * 0.9 - controlSize.height / 2 + controlOffset.height * size.height
return CGPoint(
x: min(max(x, controlSize.width / 2 + 12), size.width - controlSize.width / 2 - 12),
y: min(max(y, 40 + controlSize.height / 2 + 12), size.height - controlSize.height / 2 - 12)
)
}
var body: some View {
VStack(spacing: 0) {
ZStack {
GeometryReader { geometry in
ZStack(alignment: .top) {
Color.black
if let view = model.videoView {
VideoSurface(view: view)
.accessibilityLabel("Video")
.gesture(
TapGesture(count: 2).onEnded { model.toggleFullScreen() }
.exclusively(before: TapGesture().onEnded { model.hideControls() })
)
}
if model.fileName == nil {
VStack(spacing: 12) {
Image(systemName: "play.rectangle").font(.system(size: 48))
Text("Open a local audio or video file")
Button("Open File…", action: model.openPanel)
.disabled(!model.canOpen)
}
.foregroundStyle(.white)
} else if !model.isBusy && !model.state.has_video && model.state.has_audio {
Image(systemName: "waveform").font(.system(size: 64)).foregroundStyle(.white)
}
}
.frame(maxWidth: .infinity, maxHeight: .infinity)
.accessibilityLabel("Video")
VStack(alignment: .leading, spacing: 10) {
HStack {
Button(action: model.togglePlayback) {
Image(systemName: model.state.status == PLAYER_PLAYING ? "pause.fill" : "play.fill")
.frame(width: 22)
}
.keyboardShortcut(.space, modifiers: [])
.accessibilityLabel(model.state.status == PLAYER_PLAYING ? "Pause" : "Play")
.disabled(!model.canTogglePlayback)
Text(time(model.seekPosition)).monospacedDigit().frame(minWidth: 52, alignment: .trailing)
Slider(value: $model.seekPosition, in: 0...max(model.duration, 0.001), onEditingChanged: { editing in
if editing { model.isSeeking = true } else { model.finishSeeking() }
})
.disabled(!model.canSeek)
.accessibilityLabel("Playback position")
Text(time(model.duration)).monospacedDigit().frame(minWidth: 52, alignment: .leading)
Button("Open…", action: model.openPanel)
.accessibilityLabel("Open media file")
.disabled(!model.canOpen)
}
Text(model.fileName ?? "Player").font(.headline).lineLimit(1).help(model.fileName ?? "Player")
Text(model.statusText).font(.caption).foregroundStyle(.secondary)
if let error = model.errorText {
Text(error).font(.callout).foregroundStyle(.red).textSelection(.enabled)
VStack(spacing: 12) {
Image(systemName: "exclamationmark.triangle").font(.system(size: 32)).foregroundStyle(.yellow)
Text("Unable to Play").font(.headline)
Text(error).font(.callout).multilineTextAlignment(.center).textSelection(.enabled)
Button("Open Another File…", action: model.openPanel).disabled(!model.canOpen)
}
.padding(24)
.frame(maxWidth: 420)
.background(.regularMaterial, in: RoundedRectangle(cornerRadius: 12))
.frame(maxWidth: .infinity, maxHeight: .infinity)
} else if model.isBusy {
VStack(spacing: 12) {
ProgressView().controlSize(.large)
Text("Opening…").font(.callout).foregroundStyle(.secondary)
}
.frame(maxWidth: .infinity, maxHeight: .infinity)
} else if model.fileName == nil {
VStack(spacing: 14) {
Image(systemName: "play.rectangle").font(.system(size: 56, weight: .ultraLight))
.foregroundStyle(.white.opacity(0.65))
Text("Player").font(.system(size: 22, weight: .medium))
Text("Drop a media file here").font(.callout).foregroundStyle(.secondary)
Button("Open File…", action: model.openPanel)
.buttonStyle(.bordered).controlSize(.large).disabled(!model.canOpen)
}
.frame(maxWidth: .infinity, maxHeight: .infinity)
} else if !model.state.has_video && model.state.has_audio {
VStack(spacing: 16) {
Image(systemName: "waveform").font(.system(size: 64, weight: .ultraLight))
Text(model.fileName ?? "").font(.headline).lineLimit(1)
}
.foregroundStyle(.secondary)
.padding(40)
.frame(maxWidth: .infinity, maxHeight: .infinity)
}
titlebar
if model.canTogglePlayback {
playbackControls
.frame(width: min(460, geometry.size.width - 32))
.background {
RoundedRectangle(cornerRadius: 12)
.fill(.ultraThinMaterial)
.gesture(DragGesture(minimumDistance: 4).onChanged { value in
model.setControlsDragging(true)
controlOffset = CGSize(width: dragOrigin.width + value.translation.width / geometry.size.width,
height: dragOrigin.height + value.translation.height / geometry.size.height)
}.onEnded { _ in
let position = controllerPosition(in: geometry.size)
controlOffset = CGSize(width: (position.x - geometry.size.width / 2) / geometry.size.width,
height: (position.y - (geometry.size.height * 0.9 - controlSize.height / 2)) / geometry.size.height)
dragOrigin = controlOffset
model.setControlsDragging(false)
})
}
.overlay { RoundedRectangle(cornerRadius: 12).strokeBorder(.white.opacity(0.13), lineWidth: 1).allowsHitTesting(false) }
.shadow(color: .black.opacity(0.3), radius: 16, y: 6)
.onGeometryChange(for: CGSize.self) { $0.size } action: { controlSize = $0 }
.position(controllerPosition(in: geometry.size))
.opacity(model.controlsVisible ? 1 : 0)
.allowsHitTesting(model.controlsVisible)
.accessibilityHidden(!model.controlsVisible)
}
if dropTargeted {
RoundedRectangle(cornerRadius: 10)
.strokeBorder(.white.opacity(0.75), lineWidth: 2)
.padding(8)
.allowsHitTesting(false)
}
}
.dropDestination(for: URL.self) { urls, _ in
guard model.canOpen, let url = urls.first, url.isFileURL else { return false }
model.open(url)
return true
} isTargeted: {
dropTargeted = $0
model.revealControls()
}
.onContinuousHover { phase in
switch phase {
case .active: break
case .ended: model.hideControls(hideCursor: false)
}
}
.padding()
}
.ignoresSafeArea()
.frame(minWidth: 560, minHeight: 360)
.navigationTitle(model.fileName ?? "Player")
.preferredColorScheme(.dark)
}
}
@MainActor
private struct WindowChrome: NSViewRepresentable {
@ObservedObject var model: PlayerModel
func makeNSView(context: Context) -> ChromeView { ChromeView(model: model) }
func updateNSView(_ view: ChromeView, context: Context) { view.updateButtons() }
static func dismantleNSView(_ view: ChromeView, coordinator: ()) { view.detach() }
final class ChromeView: NSView {
private let model: PlayerModel
private weak var configuredWindow: NSWindow?
private var monitor: Any?
private var observers: [NSObjectProtocol] = []
init(model: PlayerModel) {
self.model = model
super.init(frame: .zero)
}
required init?(coder: NSCoder) { nil }
override func viewDidMoveToWindow() {
super.viewDidMoveToWindow()
guard let window else { detach(); return }
guard window !== configuredWindow else { return }
detach()
configuredWindow = window
window.styleMask.insert(.fullSizeContentView)
window.titleVisibility = .hidden
window.titlebarAppearsTransparent = true
window.backgroundColor = .black
window.acceptsMouseMovedEvents = true
window.collectionBehavior.insert(.fullScreenPrimary)
window.appearance = NSAppearance(named: .darkAqua)
for name in [NSWindow.didBecomeKeyNotification, NSWindow.didResignKeyNotification,
NSWindow.didEnterFullScreenNotification, NSWindow.didExitFullScreenNotification] {
observers.append(NotificationCenter.default.addObserver(forName: name, object: window, queue: .main) { [weak self] _ in
MainActor.assumeIsolated {
self?.model.updateWindowState()
self?.updateButtons()
}
})
}
monitor = NSEvent.addLocalMonitorForEvents(matching: [.mouseMoved, .leftMouseDown, .keyDown]) { [weak self] event in
let consumed = MainActor.assumeIsolated {
guard let self, event.window === self.configuredWindow else { return false }
if event.type == .keyDown && event.keyCode == 48 { self.model.revealControls() }
if event.type == .mouseMoved || event.type == .leftMouseDown {
self.model.revealControls()
} else if event.type == .keyDown && !(event.window?.firstResponder is NSSlider) &&
!(event.window?.firstResponder is NSTextView) {
if event.keyCode == 53 && self.model.isFullScreen {
self.model.toggleFullScreen()
return true
}
if event.modifierFlags.intersection([.command, .control, .option]).isEmpty &&
event.charactersIgnoringModifiers?.lowercased() == "f" {
self.model.toggleFullScreen()
return true
}
}
return false
}
return consumed ? nil : event
}
Task { @MainActor [weak self, weak window] in
guard let self, let window else { return }
self.model.attachWindow(window)
self.updateButtons()
}
}
func updateButtons() {
let hidden = !model.controlsVisible || model.isFullScreen
for button in [NSWindow.ButtonType.closeButton, .miniaturizeButton, .zoomButton] {
if let view = configuredWindow?.standardWindowButton(button), view.isHidden != hidden {
view.isHidden = hidden
}
}
}
override func mouseDown(with event: NSEvent) { window?.performDrag(with: event) }
func detach() {
if let monitor { NSEvent.removeMonitor(monitor) }
monitor = nil
observers.forEach(NotificationCenter.default.removeObserver)
observers.removeAll()
configuredWindow = nil
}
}
}
@@ -222,6 +619,10 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
NSApp.activate(ignoringOtherApps: true)
}
func application(_ application: NSApplication, open urls: [URL]) {
if let url = urls.first { PlayerModel.shared.open(url) }
}
func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool { true }
func applicationWillTerminate(_ notification: Notification) {
@@ -236,10 +637,11 @@ struct PlayerApp: App {
@StateObject private var model = PlayerModel.shared
var body: some Scene {
Window("Player", id: "player") {
Window("\(model.fileName ?? "Player")", id: "player") {
PlayerContent(model: model)
}
.defaultSize(width: 900, height: 600)
.defaultSize(width: 900, height: 560)
.windowStyle(.hiddenTitleBar)
.commands {
CommandGroup(replacing: .newItem) {
Button("Open File…", action: model.openPanel).keyboardShortcut("o")
@@ -248,6 +650,27 @@ struct PlayerApp: App {
.keyboardShortcut("w", modifiers: [.command, .shift])
.disabled(!model.canClose)
}
CommandMenu("Playback") {
Button(model.state.status == PLAYER_PLAYING ? "Pause" : "Play", action: model.togglePlayback)
.keyboardShortcut(.space, modifiers: []).disabled(!model.canTogglePlayback)
Button("Seek Back 5 Seconds") { model.seekRelative(-5) }
.keyboardShortcut(.leftArrow, modifiers: []).disabled(!model.canSeek)
Button("Seek Forward 5 Seconds") { model.seekRelative(5) }
.keyboardShortcut(.rightArrow, modifiers: []).disabled(!model.canSeek)
Divider()
Button("Volume Up") { model.setVolume(min(1, model.volume + 0.05)) }
.keyboardShortcut(.upArrow, modifiers: []).disabled(!model.canSetVolume)
Button("Volume Down") { model.setVolume(max(0, model.volume - 0.05)) }
.keyboardShortcut(.downArrow, modifiers: []).disabled(!model.canSetVolume)
Button(model.volume == 0 ? "Unmute" : "Mute", action: model.toggleMute)
.keyboardShortcut("m", modifiers: []).disabled(!model.canSetVolume)
}
CommandGroup(after: .windowArrangement) {
Button(model.isFullScreen ? "Exit Full Screen" : "Enter Full Screen", action: model.toggleFullScreen)
.keyboardShortcut("f", modifiers: [.control, .command])
Button(model.isOnTop ? "Stop Keeping Window on Top" : "Keep Window on Top", action: model.toggleOnTop)
.disabled(model.isFullScreen)
}
}
}
}