Files
KMix_Pro/backups/before-waveform-20261103-082733/KJamsClone/KJamsCloneApp.swift
T
2026-11-03 12:53:05 +00:00

637 lines
39 KiB
Swift
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import SwiftUI
import UniformTypeIdentifiers
enum EntityKind: String, Identifiable {
case singer, venue
var id: String { rawValue }
var title: String { self == .singer ? "Singer" : "Venue" }
var table: String { self == .singer ? "singers" : "venues" }
}
@MainActor final class AppModel: ObservableObject {
@Published var songs = [Song]()
@Published var singers = [PersonPlace]()
@Published var venues = [PersonPlace]()
@Published var venueSingers = [PersonPlace]()
@Published var playlists = [PersonPlace]()
@Published var queue = [QueueEntry]()
@Published var history = [Performance]()
@Published private(set) var currentVenue: Int64?
@Published var selectedSinger: Int64?
@Published var autoAdvance = true
@Published var error: String?
@Published var creating: EntityKind?
let player = Player()
private(set) var library: Library?
let root: URL
var currentVenueName: String { venues.first { $0.id == currentVenue }?.name ?? "No venue selected" }
init(storageURL: URL? = nil) {
root = storageURL ?? FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0].appendingPathComponent("KJamsClone")
perform {
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
library = try Library(url:root.appendingPathComponent("Library.sqlite")); try refresh()
}
player.onFinished = { [weak self] in
guard let self, self.autoAdvance, !self.queue.isEmpty else { return }
self.playQueueNext()
}
}
func perform(_ work: () throws -> Void) { do { try work() } catch { self.error = error.localizedDescription } }
func refresh() throws {
guard let library else { throw LibraryError.message("Library unavailable") }
songs = try library.songs(); singers = try library.entities("singers"); venues = try library.entities("venues")
playlists = try library.entities("playlists"); currentVenue = try library.currentVenue()
venueSingers = try currentVenue.map { try library.members(of:$0) } ?? singers
if let selectedSinger, !venueSingers.contains(where: { $0.id == selectedSinger }) { self.selectedSinger = nil }
queue = try library.queue(venue:currentVenue); history = try library.history(venue:currentVenue)
}
func chooseVenue(_ id: Int64?) {
perform {
guard let library else { throw LibraryError.message("Library unavailable") }
try library.selectVenue(id); selectedSinger = nil; try refresh()
}
}
func membership(singer: Int64, included: Bool) {
perform {
guard let library, let currentVenue else { throw LibraryError.message("Select a current venue first") }
try library.setMembership(singer:singer,venue:currentVenue,included:included); try refresh()
}
}
@discardableResult func createEntity(_ kind: EntityKind, name: String) throws -> Int64 {
guard let library else { throw LibraryError.message("Library unavailable") }
let trimmed = name.trimmingCharacters(in:.whitespacesAndNewlines)
try library.addEntity(kind.table,name:trimmed)
guard let entity = try library.entities(kind.table).first(where: { $0.name == trimmed }) else { throw LibraryError.message("Could not load new entry") }
if kind == .singer {
if let currentVenue { try library.setMembership(singer:entity.id,venue:currentVenue,included:true) }
selectedSinger = entity.id
} else { try library.selectVenue(entity.id); selectedSinger = nil }
try refresh(); return entity.id
}
func rename(_ table: String, id: Int64, name: String) { perform { try library?.rename(table,id:id,name:name); try refresh() } }
func delete(_ table: String, id: Int64) { perform { try library?.deleteEntity(table,id:id); try refresh() } }
func preference(_ song: Int64) -> SongPreference {
guard let library, let selectedSinger else { return .init() }
return (try? library.preference(song:song,singer:selectedSinger)) ?? .init()
}
func savePreference(song: Int64, value: SongPreference) {
perform {
guard let library, let selectedSinger else { throw LibraryError.message("Select a singer to save their song preferences") }
try library.savePreference(song:song,singer:selectedSinger,value:value); try refresh()
}
}
func play(_ song: Song, singer: Int64? = nil) throws {
guard let library else { throw LibraryError.message("Library unavailable") }
let singer = singer ?? selectedSinger
if let singer, let currentVenue, try !library.members(of:currentVenue).contains(where: { $0.id == singer }) { throw LibraryError.message("This singer is not in the current venue") }
let preference = try singer.map { try library.preference(song:song.id,singer:$0) } ?? SongPreference()
try player.load(song,preference:preference)
do { try library.record(song.id,singer:singer,venue:currentVenue); selectedSinger = singer; try refresh() }
catch { player.stop(); throw error }
}
func enqueue(_ song: Int64) { perform { try library?.enqueue(song:song,singer:selectedSinger,venue:currentVenue); try refresh() } }
func playQueueNext() {
perform {
guard let row = queue.first, let song = songs.first(where: { $0.id == row.songID }) else { return }
// Explicitly clear selection for unassigned queue entries.
selectedSinger = row.singerID
try play(song,singer:row.singerID); try library?.removeQueue(row.id); try refresh()
}
}
func moveQueue(_ id: Int64, by offset: Int) { perform { if let currentVenue { try library?.moveQueue(id,venue:currentVenue,by:offset); try refresh() } } }
func removeQueue(_ id: Int64) { perform { try library?.removeQueue(id); try refresh() } }
func createPlaylist(_ name: String) { perform { try library?.addEntity("playlists",name:name); try refresh() } }
func addToPlaylist(_ playlist: Int64, song: Int64) { perform { try library?.addToPlaylist(playlist,song:song); try refresh() } }
func importFiles(_ urls: [URL]) { perform { guard let library else { throw LibraryError.message("Library unavailable") }; try Importer(media:root.appendingPathComponent("Media")).run(urls,library:library); try refresh() } }
}
@main struct KJamsCloneApp: App {
@StateObject private var model = AppModel()
var body: some Scene {
Window("KJamsClone", id: "main") {
LibraryView(model: model).frame(minWidth: 1060, minHeight: 680).preferredColorScheme(.dark)
}.defaultSize(width: 1260, height: 840)
.commands {
CommandGroup(replacing: .newItem) {
Button("New Singer…") { model.creating = .singer }.keyboardShortcut("n", modifiers: [.command, .shift])
Button("New Venue…") { model.creating = .venue }.keyboardShortcut("n", modifiers: [.command, .option])
}
}
Window("Video", id: "lyrics") {
LyricsView(player: model.player).frame(minWidth: 480, minHeight: 320).preferredColorScheme(.dark)
}.defaultSize(width: 600, height: 400)
}
}
private enum Classic {
static let frame = Color(red: 0.15, green: 0.15, blue: 0.15)
static let navy = Color(red: 0.008, green: 0.065, blue: 0.16)
static let blue = Color(red: 0.015, green: 0.17, blue: 0.42)
static let header = Color(white: 0.115)
static let line = Color(white: 0.42)
}
struct LyricsView: View {
@ObservedObject var player: Player
var body: some View {
ZStack {
Color.black
if let image = player.image {
Image(decorative: image, scale: 1).interpolation(.none).resizable().aspectRatio(1.5, contentMode: .fit)
}
}
}
}
/// This is another view of the same published CGImage used by the Video window.
/// It owns no decoder, audio player or clock, so seeking/pause/tempo stay identical.
private struct SidebarVideoMonitor: View {
let player: Player
var body: some View {
VStack(alignment: .leading, spacing: 7) {
Label("Video Monitor", systemImage: "tv")
.font(.system(size: 11, weight: .medium)).foregroundStyle(.white.opacity(0.7))
LyricsView(player: player)
.aspectRatio(1.5, contentMode: .fit)
.clipped()
.overlay(Rectangle().strokeBorder(.white.opacity(0.25), lineWidth: 1))
.accessibilityLabel("Video monitor, synchronized with the Video window")
}.frame(maxWidth: .infinity)
}
}
private struct SilverSquareStyle: ButtonStyle {
func makeBody(configuration: Configuration) -> some View {
configuration.label.foregroundStyle(Color(white: 0.25)).padding(.horizontal, 6).padding(.vertical, 3)
.background(LinearGradient(colors: [Color(white: 0.95), Color(white: 0.64)], startPoint: .top, endPoint: .bottom), in: RoundedRectangle(cornerRadius: 4))
.overlay(RoundedRectangle(cornerRadius: 4).strokeBorder(Color(white: 0.45), lineWidth: 1.5))
.overlay(RoundedRectangle(cornerRadius: 3).strokeBorder(.white.opacity(0.7)).padding(3))
.opacity(configuration.isPressed ? 0.7 : 1)
}
}
private struct SilverButton: View {
let symbol: String
let label: String
var size: CGFloat = 40
var active = false
var enabled = true
let action: () -> Void
var body: some View {
Button(action: action) {
Image(systemName: symbol).font(.system(size: size * 0.41, weight: .semibold))
.foregroundStyle(active ? Color.blue : Color(white: 0.24))
.frame(width: size, height: size)
.background(LinearGradient(colors: [.white, Color(white: 0.85), Color(white: 0.63)], startPoint: .top, endPoint: .bottom), in: Circle())
.overlay(Circle().strokeBorder(Color(white: 0.45), lineWidth: 1.5))
.overlay(Circle().strokeBorder(.white.opacity(0.65), lineWidth: 1).padding(3))
.shadow(color: .black.opacity(0.7), radius: 1, y: 1)
}.buttonStyle(.plain).disabled(!enabled).opacity(enabled ? 1 : 0.72)
.help(label).accessibilityLabel(label)
}
}
struct LibraryView: View {
@ObservedObject var model: AppModel
@State private var selected: Int64?
@State private var search = ""
@State private var name = ""
@State private var importing = false
@State private var source = "Library"
@Environment(\.openWindow) private var openWindow
private var visibleSongs: [Song] { model.songs.filter { search.isEmpty || ($0.title+" "+$0.artist+" "+$0.album).localizedCaseInsensitiveContains(search) } }
private var selectedSong: Song? { model.songs.first { $0.id == selected } }
var body: some View {
VStack(spacing: 0) {
TransportView(player: model.player, search: $search, hasSelection: selectedSong != nil,
play: playSelected, next: playNext, display: { openWindow(id: "lyrics") })
.padding(.horizontal, 18).padding(.top, 18).padding(.bottom, 22)
HSplitView {
sidebar.frame(minWidth: 190, idealWidth: 220, maxWidth: 240)
VStack(spacing: 12) {
if source == "Library" { songTable }
else if source == "Queue" { queuePane }
else if source == "History" { historyPane }
else if source == "Playlists" { playlistPane }
else { directory }
detailPanel.frame(height: 135)
}.padding(.leading, 12).frame(minWidth: 780)
}.padding(.horizontal, 18)
footer.padding(.horizontal, 18).padding(.vertical, 12)
}
.background(Classic.frame)
.sheet(item: $model.creating) { kind in
AddEntitySheet(model: model, kind: kind) { id in
if kind == .singer { model.selectedSinger = id } else { model.chooseVenue(id) }
}
}
.fileImporter(isPresented: $importing, allowedContentTypes: [.audio, .zip, UTType(filenameExtension: "cdg") ?? .data], allowsMultipleSelection: true) { result in
switch result {
case .success(let urls): model.importFiles(urls)
case .failure(let error): model.error = error.localizedDescription
}
}
.alert("KJamsClone", isPresented: Binding(get: { model.error != nil }, set: { if !$0 { model.error = nil } })) {
Button("OK") { model.error = nil }
} message: { Text(model.error ?? "") }
}
private func sourceCount(_ source: String) -> Int {
switch source {
case "Library": return model.songs.count
case "Singers": return model.venueSingers.count
case "Venues": return model.venues.count
case "Queue": return model.queue.count
case "History": return model.history.count
default: return model.playlists.count
}
}
private var sidebar: some View {
VStack(alignment: .leading, spacing: 0) {
Text("Source").font(.system(size: 15, weight: .semibold)).padding(.horizontal, 10).frame(height: 31)
.frame(maxWidth: .infinity, alignment: .leading).background(Classic.header)
ForEach([("Library", "music.note.house.fill", Color.yellow), ("Singers", "person.2.fill", Color.green), ("Venues", "building.2.fill", Color.cyan), ("Queue", "list.number", Color.orange), ("History", "clock.arrow.circlepath", Color.purple), ("Playlists", "music.note.list", Color.mint)], id: \.0) { item in
Button { source = item.0 } label: {
HStack(spacing: 10) {
Image(systemName: item.1).foregroundStyle(item.2).frame(width: 22)
Text(item.0).font(.system(size: 16, weight: .medium))
Spacer()
Text("\(sourceCount(item.0))")
.font(.system(size: 11)).foregroundStyle(.white.opacity(0.6))
}.padding(.horizontal, 12).frame(height: 34).contentShape(Rectangle())
.background(source == item.0 ? Color(red: 0, green: 0.36, blue: 1) : .clear)
}.buttonStyle(.plain)
}
Spacer(minLength: 12)
SidebarVideoMonitor(player: model.player).padding(10)
}.foregroundStyle(.white).background(Classic.navy).overlay(Rectangle().stroke(Classic.line, lineWidth: 1))
}
private var songTable: some View {
GeometryReader { geometry in
ScrollView(.horizontal) {
VStack(spacing: 0) {
tableHeader(width: max(geometry.size.width, 790))
ScrollView(.vertical) {
LazyVStack(spacing: 0) {
ForEach(visibleSongs) { song in songRow(song, width: max(geometry.size.width, 790)) }
}.frame(maxWidth: .infinity, alignment: .topLeading)
}
}.frame(width: max(geometry.size.width, 790), height: geometry.size.height)
}
}.background(Classic.navy).overlay(Rectangle().stroke(Classic.line, lineWidth: 1))
}
private func widths(_ total: CGFloat) -> [CGFloat] {
[42, max(200, total - 598), 100, 100, 76, 86, 72, 122]
}
private func tableHeader(width: CGFloat) -> some View {
let sizes = widths(width)
return HStack(spacing: 0) {
ForEach(Array(["PLI", "Song Name", "Artist", "Album", "Label", "Key Adjust", "Tempo", "Rating"].enumerated()), id: \.offset) { index, title in
Text(title).font(.system(size: 13, weight: .medium)).lineLimit(1)
.padding(.leading, 7).frame(width: sizes[index], height: 30, alignment: .leading)
.overlay(alignment: .trailing) { Rectangle().fill(Classic.line).frame(width: 1).padding(.vertical, 4) }
}
}.foregroundStyle(.white).background(Classic.header)
.overlay(alignment: .bottom) { Rectangle().fill(Color(white: 0.65)).frame(height: 1) }
}
private func cellText(_ song: Song, column: Int) -> String {
switch column {
case 2: return song.artist.isEmpty ? "—" : song.artist
case 3: return song.album.isEmpty ? "—" : song.album
case 4: return song.label.isEmpty ? (song.cdg == nil ? "Audio" : URL(fileURLWithPath:song.audio).pathExtension.uppercased()+"+G") : song.label
case 5: return String(format:"%+.0f",model.preference(song.id).pitch)
default: return String(format:"%.0f%%",model.preference(song.id).tempo*100)
}
}
private func songRow(_ song: Song, width: CGFloat) -> some View {
let sizes = widths(width)
return HStack(spacing: 0) {
Image(systemName: song.cdg == nil ? "music.note" : "music.note.tv")
.foregroundStyle(.white.opacity(0.75)).frame(width: sizes[0])
Text(song.title).lineLimit(1).padding(.leading, 7).frame(width: sizes[1], alignment: .leading)
ForEach(2..<7) { index in
Text(cellText(song, column: index))
.foregroundStyle(.white.opacity(0.5)).padding(.leading, 7).frame(width: sizes[index], alignment: .leading)
}
Menu {
ForEach(0..<6) { value in
Button(value == 0 ? "Unrated" : String(repeating: "★", count: value)) {
model.perform { try model.library?.rate(song.id, value); try model.refresh() }
}
}
} label: {
Text(song.rating == 0 ? "☆☆☆☆☆" : String(repeating: "★", count: song.rating) + String(repeating: "☆", count: 5 - song.rating))
.font(.system(size: 13)).foregroundStyle(song.rating == 0 ? Color.gray : Color.yellow)
}.menuStyle(.borderlessButton).frame(width: sizes[7] - 14).padding(.horizontal, 7).help("Set song rating")
}.font(.system(size: 13)).foregroundStyle(.white).frame(height: 30)
.background(selected == song.id ? Color(red: 0, green: 0.28, blue: 0.72) : .clear)
.contentShape(Rectangle()).onTapGesture(count: 2) { selected = song.id; playSelected() }
.onTapGesture { selected = song.id }
.contextMenu {
Button("Play") { selected = song.id; playSelected() }
Button("Add to Current Venue Queue") { model.enqueue(song.id) }.disabled(model.currentVenue == nil)
Menu("Add to Playlist") { ForEach(model.playlists) { playlist in Button(playlist.name) { model.addToPlaylist(playlist.id,song:song.id) } } }
}
}
@State private var managingRoster = false
@State private var rosterNewName = ""
@State private var editingEntity: PersonPlace?
@State private var renameText = ""
@State private var pendingDelete: PersonPlace?
private var directory: some View {
VStack(alignment:.leading,spacing:0) {
HStack {
Text(source == "Singers" ? "Singers · \(model.currentVenueName)" : "Venues").font(.headline)
Spacer()
if source == "Singers" { Button("Manage Venue Singers…") { managingRoster = true }.disabled(model.currentVenue == nil) }
Button(source == "Singers" ? "New Singer…" : "New Venue…") { model.creating = source == "Singers" ? .singer : .venue }
}.padding(12).background(Classic.header)
ScrollView {
VStack(alignment:.leading,spacing:0) {
if source == "Singers" && model.venueSingers.isEmpty {
Text("No singers at this venue. Add a singer or use Manage Venue Singers to include existing singers.").foregroundStyle(.secondary).padding()
}
ForEach(source == "Singers" ? model.venueSingers : model.venues) { entity in
HStack {
Button {
if source == "Singers" { model.selectedSinger = entity.id } else { model.chooseVenue(entity.id) }
} label: {
HStack {
Image(systemName:source == "Singers" ? "person.fill" : "building.2.fill")
Text(entity.name); Spacer()
if entity.id == (source == "Singers" ? model.selectedSinger : model.currentVenue) {
Text(source == "Singers" ? "Selected" : "Current venue").font(.caption).foregroundStyle(.cyan)
Image(systemName:"checkmark.circle.fill").foregroundStyle(.cyan)
}
}.contentShape(Rectangle())
}.buttonStyle(.plain)
Button("Rename") { renameText = entity.name; editingEntity = entity }
Button("Delete",role:.destructive) { pendingDelete = entity }
}.padding(12)
}
}
}
HStack {
TextField(source == "Singers" ? "Singer name" : "Venue name",text:$name).textFieldStyle(.roundedBorder).onSubmit(addEntity)
Button(source == "Singers" ? "Add Singer" : "Add Venue",action:addEntity).disabled(name.trimmingCharacters(in:.whitespacesAndNewlines).isEmpty)
}.padding(12)
}.foregroundStyle(.white).background(Classic.navy).overlay(Rectangle().stroke(Classic.line))
.sheet(isPresented:$managingRoster) { rosterSheet }
.sheet(item:$editingEntity) { entity in
VStack(alignment:.leading,spacing:16) {
Text("Rename \(source == "Singers" ? "Singer" : "Venue")").font(.headline)
TextField("Name",text:$renameText).textFieldStyle(.roundedBorder)
HStack { Button("Cancel") { editingEntity = nil }; Spacer(); Button("Save") { model.rename(source == "Singers" ? "singers" : "venues",id:entity.id,name:renameText); editingEntity = nil }.disabled(renameText.trimmingCharacters(in:.whitespacesAndNewlines).isEmpty) }
}.padding(24).frame(width:360)
}
.confirmationDialog("Delete \(pendingDelete?.name ?? "entry")? Historical plays are kept. Venue memberships and queued entries for it will be removed.",isPresented:Binding(get:{ pendingDelete != nil },set:{ if !$0 { pendingDelete = nil } })) {
Button("Delete",role:.destructive) { if let entity = pendingDelete { model.delete(source == "Singers" ? "singers" : "venues",id:entity.id) }; pendingDelete = nil }
}
}
private var rosterSheet: some View {
VStack(alignment:.leading,spacing:16) {
Text("Singers at \(model.currentVenueName)").font(.title2.bold())
Text("A singer can belong to any number of venues. Unchecking removes them from this venue only.").foregroundStyle(.secondary)
ScrollView {
VStack(alignment:.leading,spacing:12) {
ForEach(model.singers) { singer in
Toggle(singer.name,isOn:Binding(get:{ model.venueSingers.contains { $0.id == singer.id } },set:{ model.membership(singer:singer.id,included:$0) }))
}
}.frame(maxWidth:.infinity,alignment:.leading)
}.frame(minHeight:120,maxHeight:280)
HStack {
TextField("New singer name",text:$rosterNewName).textFieldStyle(.roundedBorder)
Button("Add") { model.perform { _ = try model.createEntity(.singer,name:rosterNewName); rosterNewName = "" } }.disabled(rosterNewName.trimmingCharacters(in:.whitespacesAndNewlines).isEmpty)
Spacer(); Button("Done") { managingRoster = false }.keyboardShortcut(.defaultAction)
}
}.padding(24).frame(width:460)
}
private var detailPanel: some View {
VStack(alignment:.leading,spacing:9) {
HStack(spacing:10) {
Picker("Current venue",selection:Binding(get:{ model.currentVenue },set:{ model.chooseVenue($0) })) {
Text("Select venue…").tag(nil as Int64?)
ForEach(model.venues) { Text($0.name).tag(Optional($0.id)) }
}
Button { model.creating = .venue } label: { Image(systemName:"plus.circle.fill") }.buttonStyle(.plain).help("Add venue")
Picker("Singer",selection:$model.selectedSinger) {
Text("None").tag(nil as Int64?)
ForEach(model.venueSingers) { Text($0.name).tag(Optional($0.id)) }
}
Button { model.creating = .singer } label: { Image(systemName:"plus.circle.fill") }.buttonStyle(.plain).help("Add singer")
Button("Queue Song") { if let selected { model.enqueue(selected) } }.disabled(selected == nil || model.currentVenue == nil)
}
PlaybackSettings(player:model.player,model:model,selectedSong:selected)
SeekBar(player:model.player)
}.padding(12).frame(maxWidth:.infinity,maxHeight:.infinity)
.background(Classic.navy).overlay(Rectangle().stroke(Classic.line))
}
@State private var playlistName = ""
@State private var selectedPlaylist: Int64?
private var queuePane: some View {
VStack(alignment:.leading,spacing:12) {
HStack { Text("Queue · \(model.currentVenueName)").font(.headline); Spacer(); Toggle("Auto play next",isOn:$model.autoAdvance).toggleStyle(.checkbox); Button("Play Next") { model.playQueueNext() }.disabled(model.queue.isEmpty) }
ScrollView {
VStack(spacing:0) {
ForEach(Array(model.queue.enumerated()),id:\.element.id) { index,row in
HStack {
Text("\(index+1)").foregroundStyle(.secondary).frame(width:24)
Text(row.singer).frame(width:140,alignment:.leading)
Text(row.title).lineLimit(1); Spacer()
Button { model.moveQueue(row.id,by:-1) } label: { Image(systemName:"arrow.up") }.disabled(index == 0)
Button { model.moveQueue(row.id,by:1) } label: { Image(systemName:"arrow.down") }.disabled(index == model.queue.count-1)
Button("Remove") { model.removeQueue(row.id) }
}.padding(.vertical,8)
}
if model.queue.isEmpty { Text("Choose a venue and singer, select a library song, then click Queue Song.").foregroundStyle(.secondary).padding(.top,30) }
}
}
}.padding(14).frame(maxWidth:.infinity,maxHeight:.infinity).background(Classic.navy).overlay(Rectangle().stroke(Classic.line))
}
@State private var historyAllVenues = false
private var displayedHistory: [Performance] {
if historyAllVenues { return (try? model.library?.history(venue:nil,singer:model.selectedSinger)) ?? [] }
return model.history.filter { model.selectedSinger == nil || $0.singer == model.singers.first(where: { $0.id == model.selectedSinger })?.name }
}
private var historyPane: some View {
VStack(alignment:.leading,spacing:12) {
HStack { Text("History · \(historyAllVenues || model.currentVenue == nil ? "All venues" : model.currentVenueName)").font(.headline); Spacer(); Toggle("All venues",isOn:$historyAllVenues).toggleStyle(.checkbox) }
ScrollView {
LazyVStack(alignment:.leading,spacing:12) {
ForEach(displayedHistory) { row in
HStack { Text(row.date).font(.system(.caption,design:.monospaced)); Text(row.singer).frame(width:130,alignment:.leading); Text(row.song); Spacer(); Text(row.venue).foregroundStyle(.secondary) }
}
}
}
}.padding(14).frame(maxWidth:.infinity,maxHeight:.infinity).background(Classic.navy).overlay(Rectangle().stroke(Classic.line))
}
private var playlistPane: some View {
VStack(alignment:.leading,spacing:12) {
HStack {
Picker("Playlist",selection:$selectedPlaylist) { Text("Choose…").tag(nil as Int64?); ForEach(model.playlists) { Text($0.name).tag(Optional($0.id)) } }
TextField("New playlist name",text:$playlistName).textFieldStyle(.roundedBorder)
Button("Create") { model.createPlaylist(playlistName); selectedPlaylist = model.playlists.first { $0.name == playlistName.trimmingCharacters(in:.whitespacesAndNewlines) }?.id; playlistName = "" }.disabled(playlistName.trimmingCharacters(in:.whitespacesAndNewlines).isEmpty)
if let selectedPlaylist {
Button("Rename") { model.rename("playlists",id:selectedPlaylist,name:playlistName); playlistName = "" }.disabled(playlistName.trimmingCharacters(in:.whitespacesAndNewlines).isEmpty)
Button("Delete",role:.destructive) { model.delete("playlists",id:selectedPlaylist); self.selectedPlaylist = nil } }
}
ScrollView {
if let selectedPlaylist {
let ids = (try? model.library?.playlistSongIDs(selectedPlaylist)) ?? []
VStack(alignment:.leading,spacing:10) {
ForEach(ids,id:\.self) { id in
if let song = model.songs.first(where: { $0.id == id }) {
HStack {
Text(song.title); Spacer()
Button("Play") { model.perform { try model.play(song) } }
Button("Queue") { model.enqueue(song.id) }.disabled(model.currentVenue == nil)
Button("Remove") { model.perform { try model.library?.removeFromPlaylist(selectedPlaylist,song:id); try model.refresh() } }
}
}
}
}
}
Text("Add songs using the library row’s context menu.").foregroundStyle(.secondary).padding(.top,20)
}
}.padding(14).frame(maxWidth:.infinity,maxHeight:.infinity).background(Classic.navy).overlay(Rectangle().stroke(Classic.line))
}
private var footer: some View {
HStack {
Button { importing = true } label: { Image(systemName: "plus").font(.system(size: 20, weight: .bold)).frame(width: 32, height: 24) }
.help("Import audio, MP3+G or ZIP").accessibilityLabel("Import songs")
RepeatButton(player: model.player).padding(.leading, 12)
Spacer()
Text("\(visibleSongs.count) \(visibleSongs.count == 1 ? "Song" : "Songs")").font(.system(size: 14, weight: .medium))
Spacer()
Button { openWindow(id: "lyrics") } label: { Image(systemName: "rectangle.on.rectangle").frame(width: 32, height: 24) }
.help("Open video window").accessibilityLabel("Open video window")
}.buttonStyle(SilverSquareStyle())
}
private func playSelected() {
guard let song = selectedSong else { return }
model.perform { try model.play(song) }
}
private func playNext() {
guard !visibleSongs.isEmpty else { return }
let index = visibleSongs.firstIndex { $0.id == selected } ?? -1
selected = visibleSongs[(index + 1) % visibleSongs.count].id; playSelected()
}
private func addEntity() {
model.perform {
let kind: EntityKind = source == "Singers" ? .singer : .venue
let id = try model.createEntity(kind, name: name)
if kind == .singer { model.selectedSinger = id } else { model.chooseVenue(id) }
name = ""
}
}
}
private struct AddEntitySheet: View {
@ObservedObject var model: AppModel
let kind: EntityKind
let saved: (Int64) -> Void
@Environment(\.dismiss) private var dismiss
@State private var name = ""
@State private var error: String?
@FocusState private var focused: Bool
var body: some View {
VStack(alignment: .leading, spacing: 16) {
Text("New \(kind.title)").font(.title2.bold())
TextField("\(kind.title) name", text: $name).textFieldStyle(.roundedBorder)
.focused($focused).onSubmit(save)
if let error { Text(error).foregroundStyle(.red).font(.callout) }
HStack {
Spacer()
Button("Cancel") { dismiss() }.keyboardShortcut(.cancelAction)
Button("Add \(kind.title)", action: save).keyboardShortcut(.defaultAction)
.disabled(name.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
}
}.padding(24).frame(width: 360).onAppear { focused = true }
}
private func save() {
do { let id = try model.createEntity(kind, name: name); saved(id); dismiss() }
catch { self.error = error.localizedDescription }
}
}
private struct TransportView: View {
@ObservedObject var player: Player
@Binding var search: String
let hasSelection: Bool
let play: () -> Void
let next: () -> Void
let display: () -> Void
var body: some View {
HStack(alignment: .top, spacing: 28) {
VStack(spacing: 15) {
HStack(spacing: 7) {
SilverButton(symbol: "backward.fill", label: "Back 10 seconds", size: 35, enabled: player.duration > 0) { player.seek(player.time - 10) }
SilverButton(symbol: player.playing ? "pause.fill" : "play.fill", label: player.playing ? "Pause" : "Play", size: 49, enabled: hasSelection || player.duration > 0) {
if player.duration > 0 { player.toggle() } else { play() }
}
SilverButton(symbol: "stop", label: "Stop", size: 46, enabled: player.duration > 0) { player.stop() }
SilverButton(symbol: "forward.fill", label: "Forward 10 seconds", size: 35, enabled: player.duration > 0) { player.seek(player.time + 10) }
SilverButton(symbol: "forward.end.fill", label: "Play next song", size: 26, enabled: hasSelection, action: next)
}
HStack(spacing: 9) {
Image(systemName: "speaker.fill").font(.system(size: 11))
Slider(value: $player.volume, in: 0...1).controlSize(.small).tint(.gray).accessibilityLabel("Volume")
Image(systemName: "speaker.wave.3.fill").font(.system(size: 12))
}.frame(width: 180)
}.frame(width: 220)
VStack(spacing: 0) {
Text(player.duration == 0 ? "Ready!" : player.title).font(.system(size: 15, weight: .medium)).lineLimit(1).padding(.horizontal, 20)
if player.duration > 0 { Text(player.playing ? "Playing" : "Paused").font(.system(size: 10)).foregroundStyle(.white.opacity(0.65)).padding(.top, 4) }
}.frame(maxWidth: .infinity).frame(height: 64)
.background(LinearGradient(colors: [Color(red: 0, green: 0.10, blue: 0.30), Classic.blue], startPoint: .top, endPoint: .bottom), in: Capsule())
.overlay(Capsule().strokeBorder(LinearGradient(colors: [.black, .white], startPoint: .top, endPoint: .bottom), lineWidth: 1.5))
.padding(.top, 14)
HStack(spacing: 12) {
TextField("Search", text: $search).textFieldStyle(.plain).font(.system(size: 16))
.padding(.horizontal, 8).frame(width: 145, height: 28).background(Color(white: 0.07), in: RoundedRectangle(cornerRadius: 5))
.overlay(RoundedRectangle(cornerRadius: 5).stroke(.white.opacity(0.1)))
SilverButton(symbol: "eye", label: "Open video window", size: 48, action: display)
}.padding(.top, 15)
}.foregroundStyle(.white).frame(height: 96)
}
}
private struct PlaybackSettings: View {
@ObservedObject var player: Player
@ObservedObject var model: AppModel
let selectedSong: Int64?
@State private var personalRating = 0
var body: some View {
HStack(spacing:10) {
Text("Key")
Picker("Key",selection:$player.pitch) { ForEach(-12..<13) { Text(String(format:"%+d",$0)).tag(Double($0)) } }.labelsHidden().frame(width:70)
Text("Tempo")
Slider(value:$player.tempo,in:0.5...1.5,step:0.05).frame(width:85)
Text(String(format:"%.0f%%",player.tempo*100)).monospacedDigit().frame(width:40)
Text("Rating")
Picker("Singer rating",selection:$personalRating) { ForEach(0..<6) { Text($0 == 0 ? "Unrated" : String(repeating:"★",count:$0)).tag($0) } }.labelsHidden().frame(width:88).help("Singer-specific song rating")
Button("Save for Singer") {
if let song = player.currentSongID ?? selectedSong { model.savePreference(song:song,value:.init(pitch:player.pitch,tempo:player.tempo,rating:personalRating)) }
}.disabled(model.selectedSinger == nil || (player.currentSongID == nil && selectedSong == nil))
Menu {
Button("Reset key / tempo") { player.pitch = 0; player.tempo = 1 }
ForEach([-1.0,-0.5,0,0.5,1.0],id:\.self) { offset in Button(String(format:"Graphics offset %+.1fs",offset)) { player.graphicsOffset = offset } }
} label: { Image(systemName:"slider.horizontal.3") }.menuStyle(.borderlessButton).frame(width:22).help("Playback settings")
}.font(.system(size:11))
.onChange(of:model.selectedSinger) { _ in loadRating() }
.onChange(of:player.currentSongID) { _ in loadRating() }
.onChange(of:selectedSong) { _ in loadRating() }
}
private func loadRating() { if let song = player.currentSongID ?? selectedSong { personalRating = model.preference(song).rating } else { personalRating = 0 } }
}
private struct SeekBar: View {
@ObservedObject var player: Player
private func clock(_ seconds: Double) -> String { let n = Int(seconds); return String(format: "%d:%02d", n / 60, n % 60) }
var body: some View {
HStack(spacing: 10) {
Text(clock(player.time))
Slider(value: Binding(get: { player.time }, set: { player.seek($0) }), in: 0...max(1, player.duration))
.controlSize(.mini).tint(.gray).disabled(player.duration == 0).accessibilityLabel("Playback position")
Text(clock(player.duration))
}.font(.system(size: 10, design: .monospaced)).foregroundStyle(.white.opacity(0.65))
}
}
private struct RepeatButton: View {
@ObservedObject var player: Player
var body: some View {
Button { player.repeating.toggle() } label: {
Image(systemName: "repeat").font(.system(size: 18, weight: .semibold))
.foregroundStyle(player.repeating ? Color.blue : Color(white: 0.25)).frame(width: 32, height: 24)
}.help(player.repeating ? "Repeat song: on" : "Repeat song: off").accessibilityLabel("Repeat song").accessibilityValue(player.repeating ? "On" : "Off")
}
}