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

1163 lines
81 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
import AVFoundation
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 singerSongIDs = [Int64:[Int64]]()
@Published var favourites = [Int64:Set<Int64>]()
@Published var musicStores = [MusicStore]()
@Published var readingDurations = false
var newSingerSongs = Set<Int64>()
private var songIndex = [Int64:Song]()
@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")
player = Player(waveformCacheDirectory:root.appendingPathComponent("Waveforms"))
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();songIndex = Dictionary(uniqueKeysWithValues:songs.map { ($0.id,$0) }); singers = try library.entities("singers"); venues = try library.entities("venues")
singerSongIDs = try library.singerSongIDs();favourites = try library.favouriteSongIDs();musicStores = try library.stores()
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 beginSinger(song: Int64? = nil) { newSingerSongs = Set(song.map { [$0] } ?? []); creating = .singer }
func songs(for singer: Int64) -> [Song] {
(singerSongIDs[singer] ?? []).compactMap { songIndex[$0] }
}
func assign(_ song: Int64, to singer: Int64, included: Bool = true) {
perform {
guard let library else { throw LibraryError.message("Library unavailable") }
if included { try library.assignSong(song,singer:singer) } else { try library.removeSingerSong(song,singer:singer) }
try refresh()
}
}
func createSinger(name: String, venue: Int64, songs: Set<Int64>) throws -> Int64 {
guard let library else { throw LibraryError.message("Library unavailable") }
guard venues.contains(where: { $0.id == venue }) else { throw LibraryError.message("Choose a venue first") }
let name = name.trimmingCharacters(in:.whitespacesAndNewlines)
try library.execute("BEGIN IMMEDIATE")
let id: Int64
do {
try library.addEntity("singers",name:name)
guard let singer = try library.entities("singers").first(where: { $0.name == name }) else { throw LibraryError.message("Could not load singer") }
id = singer.id
try library.setMembership(singer:id,venue:venue,included:true)
for song in songs { try library.assignSong(song,singer:id) }
try library.selectVenue(venue);try library.execute("COMMIT")
} catch { try? library.execute("ROLLBACK");throw error }
try refresh();selectedSinger = id;return 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 else { return .init() }
if let selectedSinger { return (try? library.preference(song:song,singer:selectedSinger)) ?? .init() }
return (try? library.defaultPreference(song:song)) ?? .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) } ?? library.defaultPreference(song:song.id)
try player.load(song,preference:preference)
do { try library.updateDuration(song.id,seconds:player.duration);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 setFavourite(_ song: Int64, singer: Int64, included: Bool) { perform { try library?.setFavourite(song:song,singer:singer,included:included);try refresh() } }
func updateTuning(_ song: Int64, pitch: Double? = nil, tempo: Double? = nil) {
perform {
guard let library else { throw LibraryError.message("Library unavailable") }
var value = preference(song)
if let pitch { value.pitch = pitch };if let tempo { value.tempo = tempo }
if let selectedSinger { try library.savePreference(song:song,singer:selectedSinger,value:value) }
else { try library.saveDefaultPreference(song:song,value:value) }
if player.currentSongID == song { if pitch != nil { player.pitch = value.pitch };if tempo != nil { player.tempo = value.tempo } }
try refresh()
}
}
func saveStore(_ store: MusicStore) throws { guard let library else { throw LibraryError.message("Library unavailable") };try library.saveStore(store);try refresh() }
func deleteStore(_ id: Int64) { perform { try library?.deleteStore(id);try refresh() } }
func scanDurations() {
guard !readingDurations else { return };readingDurations = true
let songs = self.songs.filter { $0.duration == 0 }
Task.detached(priority:.utility) { [weak self] in
var durations = [(Int64,Double)]()
for song in songs {
if let file = try? AVAudioFile(forReading:URL(fileURLWithPath:song.audio)) { durations.append((song.id,Double(file.length)/file.processingFormat.sampleRate)) }
}
let completedDurations = durations
await MainActor.run { [weak self] in
guard let self else { return }
self.perform { for (id,value) in completedDurations { try self.library?.updateDuration(id,seconds:value) };try self.refresh() }
self.readingDurations = false
}
}
}
func updateMetadata(_ song: Song,title: String,artist: String,album: String,label: String,rating: Int) throws {
guard let library else { throw LibraryError.message("Library unavailable") }
try library.updateMetadata(song:song.id,title:title,artist:artist,album:album,label:label,rating:rating)
if player.currentSongID == song.id { player.title = title.trimmingCharacters(in:.whitespacesAndNewlines) }
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.beginSinger() }.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"
@State private var singersExpanded = true
@State private var expandedSingers = Set<Int64>()
@State private var expandedSongLists = Set<Int64>()
@State private var songPickerSinger: PersonPlace?
@State private var singerSection = "All Songs"
@State private var storesExpanded = true
@State private var focusedStore: Int64?
@State private var editingSong: Song?
@State private var librarySort = "Song Name"
@State private var sortAscending = true
@Environment(\.openWindow) private var openWindow
private var visibleSongs: [Song] {
let filtered = model.songs.filter { search.isEmpty || ($0.title+" "+$0.artist+" "+$0.album).localizedCaseInsensitiveContains(search) }
return filtered.sorted { a,b in
if a.id == b.id { return false }
if librarySort == "Duration" { return a.duration == b.duration ? a.id < b.id : sortAscending ? a.duration < b.duration : a.duration > b.duration }
if librarySort == "Rating" { return a.rating == b.rating ? a.id < b.id : sortAscending ? a.rating < b.rating : a.rating > b.rating }
let first = librarySort == "Artist" ? a.artist : librarySort == "Album" ? a.album : a.title
let second = librarySort == "Artist" ? b.artist : librarySort == "Album" ? b.album : b.title
let order = first.localizedStandardCompare(second)
return order == .orderedSame ? a.id < b.id : sortAscending ? order == .orderedAscending : order == .orderedDescending
}
}
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 if source == "Singer Songs" { singerSongPane }
else if source == "Music Stores" { MusicStoresPane(model:model,selected:$focusedStore) }
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;expandedSingers.insert(id);expandedSongLists.insert(id);singersExpanded = true;singerSection = "All Songs";source = "Singer Songs" } else { model.chooseVenue(id) }
}
}
.sheet(item:$editingSong) { song in SongMetadataSheet(model:model,song:song) }
.sheet(item:$songPickerSinger) { singer in SingerSongsSheet(model:model,singer:singer) }
.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)
ScrollView {
VStack(spacing:0) {
sourceRow("Library",icon:"music.note.house.fill",color:.yellow)
HStack(spacing:5) {
Button { singersExpanded.toggle() } label: { Image(systemName:singersExpanded ? "chevron.down" : "chevron.right").font(.system(size:10)).frame(width:12) }.buttonStyle(.plain).accessibilityLabel("Expand singers")
Button { source = "Singers" } label: { HStack { Image(systemName:"person.2.fill").foregroundStyle(.green);Text("Singers");Spacer();Text("\(model.venueSingers.count)").font(.caption).foregroundStyle(.secondary) } }.buttonStyle(.plain)
Button { model.beginSinger() } label: { Image(systemName:"plus.circle.fill").foregroundStyle(.green) }.buttonStyle(.plain).help("New singer and songs")
}.padding(.horizontal,10).frame(height:34).background(source == "Singers" ? Color.blue.opacity(0.65) : .clear)
if singersExpanded {
Text(model.currentVenueName).font(.system(size:10)).foregroundStyle(.secondary).lineLimit(1).padding(.leading,30).frame(maxWidth:.infinity,alignment:.leading).padding(.vertical,4)
ForEach(model.venueSingers) { singer in sidebarSinger(singer) }
if model.venueSingers.isEmpty { Text("Add a singer with +").font(.caption).foregroundStyle(.secondary).padding(8) }
}
HStack {
Button { storesExpanded.toggle() } label: { Image(systemName:storesExpanded ? "chevron.down" : "chevron.right").font(.system(size:10)) }.buttonStyle(.plain)
Button { source = "Music Stores" } label: { Label("Music Stores",systemImage:"bag.fill").foregroundStyle(.green);Spacer() }.buttonStyle(.plain)
}.padding(.horizontal,12).frame(height:34)
if storesExpanded {
ForEach(model.musicStores) { store in
Button { focusedStore = store.id;source = "Music Stores" } label: { Label(store.name,systemImage:"globe").font(.system(size:12)).lineLimit(1).padding(.leading,32).frame(maxWidth:.infinity,alignment:.leading).frame(height:26) }.buttonStyle(.plain)
}
Button("Configure Stores…") { source = "Music Stores" }.buttonStyle(.plain).font(.system(size:11)).foregroundStyle(.secondary).padding(.leading,32).frame(maxWidth:.infinity,alignment:.leading).frame(height:25)
}
sourceRow("Venues",icon:"building.2.fill",color:.cyan)
sourceRow("Queue",icon:"list.number",color:.orange)
sourceRow("History",icon:"clock.arrow.circlepath",color:.purple)
sourceRow("Playlists",icon:"music.note.list",color:.mint)
}
}
SidebarVideoMonitor(player:model.player).padding(10)
}.foregroundStyle(.white).background(Classic.navy).overlay(Rectangle().stroke(Classic.line,lineWidth:1))
}
private func sourceRow(_ title: String, icon: String, color: Color) -> some View {
Button { source = title } label: {
HStack(spacing:10) {
Image(systemName:icon).foregroundStyle(color).frame(width:22)
Text(title).font(.system(size:16,weight:.medium));Spacer()
Text("\(sourceCount(title))").font(.system(size:11)).foregroundStyle(.white.opacity(0.6))
}.padding(.horizontal,12).frame(height:34).contentShape(Rectangle())
.background(source == title ? Color(red:0,green:0.36,blue:1) : .clear)
}.buttonStyle(.plain)
}
private func sidebarSinger(_ singer: PersonPlace) -> some View {
VStack(alignment:.leading,spacing:0) {
HStack(spacing:5) {
Button {
if expandedSingers.contains(singer.id) { expandedSingers.remove(singer.id) } else { expandedSingers.insert(singer.id) }
} label: { Image(systemName:expandedSingers.contains(singer.id) ? "chevron.down" : "chevron.right").font(.system(size:9)).frame(width:12) }.buttonStyle(.plain).accessibilityLabel("Expand \(singer.name)’s songs")
Button { model.selectedSinger = singer.id;singerSection = "All Songs";source = "Singer Songs" } label: {
HStack(spacing:5) { Text(singer.name).lineLimit(1);Spacer();Text("\(model.singerSongIDs[singer.id]?.count ?? 0)").font(.system(size:10)).foregroundStyle(.secondary) }
}.buttonStyle(.plain)
Button { model.selectedSinger = singer.id;songPickerSinger = singer;expandedSingers.insert(singer.id) } label: { Image(systemName:"plus").font(.system(size:10,weight:.bold)) }.buttonStyle(.plain).help("Add songs to \(singer.name)")
}.font(.system(size:13,weight:.medium)).padding(.leading,25).padding(.trailing,12).frame(height:29)
.background(model.selectedSinger == singer.id && source == "Singer Songs" ? Color.blue.opacity(0.25) : .clear)
if expandedSingers.contains(singer.id) {
singerFolder("Tonight",icon:"music.note.list",singer:singer)
singerFolder("Favourites",icon:"star.fill",singer:singer)
singerFolder("History",icon:"clock.arrow.circlepath",singer:singer)
HStack(spacing:3) {
Button { if expandedSongLists.contains(singer.id) { expandedSongLists.remove(singer.id) } else { expandedSongLists.insert(singer.id) } } label: { Image(systemName:expandedSongLists.contains(singer.id) ? "chevron.down" : "chevron.right").font(.system(size:9)) }.buttonStyle(.plain)
singerFolder("All Songs",icon:"folder",singer:singer)
}.padding(.leading,28)
if expandedSongLists.contains(singer.id) {
ForEach(model.songs(for:singer.id)) { song in
Button { model.selectedSinger = singer.id;selected = song.id;singerSection = "All Songs";source = "Singer Songs" } label: {
Label(song.title,systemImage:"music.note").font(.system(size:11)).lineLimit(1).frame(maxWidth:.infinity,alignment:.leading).padding(.leading,44).padding(.trailing,8).frame(height:25)
}.buttonStyle(.plain)
.contextMenu {
Button("Play for \(singer.name)") { model.selectedSinger = singer.id;model.perform { try model.play(song,singer:singer.id) } }
Button("Queue for \(singer.name)") { model.selectedSinger = singer.id;model.enqueue(song.id) }.disabled(model.currentVenue == nil)
Button(model.favourites[singer.id]?.contains(song.id) == true ? "Remove Favourite" : "Add to Favourites") { model.setFavourite(song.id,singer:singer.id,included:model.favourites[singer.id]?.contains(song.id) != true) }
Button("Remove from Singer",role:.destructive) { model.assign(song.id,to:singer.id,included:false) }
}
}
if model.songs(for:singer.id).isEmpty { Text("No songs · use +").font(.system(size:10)).foregroundStyle(.secondary).padding(.leading,44).padding(.vertical,5) }
}
}
}
}
private func singerFolder(_ title: String, icon: String, singer: PersonPlace) -> some View {
Button { model.selectedSinger = singer.id;singerSection = title;source = "Singer Songs" } label: {
Label(title,systemImage:icon).font(.system(size:11)).foregroundStyle(title == "Favourites" ? Color(red:1,green:0.75,blue:0.16) : Color.white.opacity(0.75)).padding(.leading,title == "All Songs" ? 0 : 43).frame(maxWidth:.infinity,alignment:.leading).frame(height:25)
}.buttonStyle(.plain)
}
private var singerSongPane: some View {
VStack(alignment:.leading,spacing:12) {
if let singer = model.singers.first(where:{ $0.id == model.selectedSinger }) {
HStack { Text("\(singer.name) · \(singerSection)").font(.headline);Spacer();Button("Add Songs…") { songPickerSinger = singer } }
Text("\(model.currentVenueName) · Singer song lists follow them across venues.").font(.caption).foregroundStyle(.secondary)
if singerSection == "History" {
ScrollView { LazyVStack(alignment:.leading,spacing:12) { ForEach(model.history.filter { $0.singerID == singer.id }) { row in HStack { Text(row.date).font(.caption.monospaced());Text(row.song);Spacer() } } } }
} else if singerSection == "Tonight" {
ScrollView { VStack(spacing:10) { ForEach(model.queue.filter { $0.singerID == singer.id }) { row in HStack { Text(row.title);Spacer();Button("Play") { model.perform { if let song = model.songs.first(where:{ $0.id == row.songID }) { try model.play(song,singer:singer.id);try model.library?.removeQueue(row.id);try model.refresh() } } };Button("Remove") { model.removeQueue(row.id) } } };if model.queue.filter({ $0.singerID == singer.id }).isEmpty { Text("No songs queued for this singer at this venue.").foregroundStyle(.secondary) } } }
} else {
ScrollView {
VStack(spacing:10) {
ForEach(model.songs(for:singer.id).filter { singerSection != "Favourites" || model.favourites[singer.id]?.contains($0.id) == true }) { song in
HStack {
Button { model.setFavourite(song.id,singer:singer.id,included:model.favourites[singer.id]?.contains(song.id) != true) } label: { Image(systemName:model.favourites[singer.id]?.contains(song.id) == true ? "star.fill" : "star").foregroundStyle(Color(red:1,green:0.75,blue:0.16)) }.buttonStyle(.plain).help("Favourite for this singer")
Text(song.title).lineLimit(1);Spacer()
Button("Play") { model.selectedSinger = singer.id;model.perform { try model.play(song,singer:singer.id) } }
Button("Tonight") { model.selectedSinger = singer.id;model.enqueue(song.id) }.disabled(model.currentVenue == nil)
Button("Remove") { model.assign(song.id,to:singer.id,included:false) }
}.padding(8).background(.white.opacity(0.035)).contentShape(Rectangle()).onTapGesture { selected = song.id }
}
if model.songs(for:singer.id).isEmpty { Text("Use Add Songs… or the + beside this singer in the sidebar.").foregroundStyle(.secondary).padding(.top,25) }
}
}
}
} else { Text("Choose a singer from the sidebar.").foregroundStyle(.secondary);Spacer() }
}.padding(14).frame(maxWidth:.infinity,maxHeight:.infinity).background(Classic.navy).overlay(Rectangle().stroke(Classic.line))
}
private var songTable: some View {
GeometryReader { geometry in
ScrollView(.horizontal) {
VStack(spacing: 0) {
tableHeader(width: max(geometry.size.width, 960))
ScrollView(.vertical) {
LazyVStack(spacing: 0) {
ForEach(visibleSongs) { song in songRow(song, width: max(geometry.size.width, 960)) }
}.frame(maxWidth: .infinity, alignment: .topLeading)
}
}.frame(width: max(geometry.size.width, 960), height: geometry.size.height)
}
}.background(Classic.navy).overlay(Rectangle().stroke(Classic.line, lineWidth: 1))
}
private func widths(_ total: CGFloat) -> [CGFloat] { [44,max(220,total-600),110,100,65,82,90,109] }
private func tableHeader(width: CGFloat) -> some View {
let sizes = widths(width)
return HStack(spacing:0) {
ForEach(Array(["ID","Song Name","Artist","Album","Duration","Pitch","Tempo","Rating"].enumerated()),id:\.offset) { index,title in
Button {
guard ["Song Name","Artist","Album","Duration","Rating"].contains(title) else { return }
if librarySort == title { sortAscending.toggle() } else { librarySort = title;sortAscending = true }
} label: { HStack(spacing:3) { Text(title);if librarySort == title { Image(systemName:sortAscending ? "chevron.up" : "chevron.down").font(.system(size:8)) } }.font(.system(size:12,weight:.medium)).lineLimit(1).padding(.leading,7).frame(width:sizes[index],height:30,alignment:.leading) }
.buttonStyle(.plain).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 durationLabel(_ seconds: Double) -> String { seconds > 0 ? String(format:"%d:%02d",Int(seconds)/60,Int(seconds)%60) : "—" }
private func songRow(_ song: Song,width: CGFloat) -> some View {
let sizes = widths(width)
return HStack(spacing:0) {
Text("\(song.id)").foregroundStyle(.secondary).frame(width:sizes[0])
Text(song.title).lineLimit(1).padding(.leading,7).frame(width:sizes[1],alignment:.leading)
Text(song.artist.isEmpty ? "—" : song.artist).foregroundStyle(.secondary).lineLimit(1).padding(.leading,7).frame(width:sizes[2],alignment:.leading)
Text(song.album.isEmpty ? "—" : song.album).foregroundStyle(.secondary).lineLimit(1).padding(.leading,7).frame(width:sizes[3],alignment:.leading)
Text(durationLabel(song.duration)).font(.system(size:11,design:.monospaced)).frame(width:sizes[4])
HStack(spacing:2) {
Text(String(format:"%+.0f",model.preference(song.id).pitch)).font(.system(size:11,design:.monospaced)).frame(width:30)
Stepper("Pitch",value:Binding(get:{ model.preference(song.id).pitch },set:{ model.updateTuning(song.id,pitch:$0) }),in:-12...12,step:1).labelsHidden().controlSize(.mini).fixedSize()
}.frame(width:sizes[5]).help("Saved pitch; applies to the selected singer, or song default")
Picker("Tempo",selection:Binding(get:{ model.preference(song.id).tempo },set:{ model.updateTuning(song.id,tempo:$0) })) {
ForEach(10..<31) { Text("\($0*5)%").tag(Double($0)/20) }
}.labelsHidden().controlSize(.mini).frame(width:sizes[6]-8).padding(.horizontal,4).help("Saved tempo; applies live if this song is playing")
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:12)).foregroundStyle(song.rating == 0 ? Color.gray : Color(red:1,green:0.75,blue:0.16))
}.menuStyle(.borderlessButton).frame(width:sizes[7]-14).padding(.horizontal,7)
}.font(.system(size:12)).foregroundStyle(.white).frame(height:30)
.background(selected == song.id ? Color.blue.opacity(0.5) : song.id % 2 == 0 ? Color.white.opacity(0.025) : .clear)
.contentShape(Rectangle()).onTapGesture(count:2) { selected = song.id;playSelected() }.onTapGesture { selected = song.id }
.contextMenu {
Button("Play") { selected = song.id; playSelected() }
Button("Edit Metadata…") { editingSong = song }
Menu("Add to Singer") {
ForEach(model.venueSingers) { singer in Button(singer.name) { model.assign(song.id,to:singer.id);model.selectedSinger = singer.id;expandedSingers.insert(singer.id) } }
Divider();Button("New Singer + This Song…") { model.beginSinger(song:song.id) }
}
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…") { if source == "Singers" { model.beginSinger() } else { model.creating = .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.beginSinger() } label: { Image(systemName:"plus.circle.fill") }.buttonStyle(.plain).help("Add singer")
Menu("Add to Singer") {
ForEach(model.venueSingers) { singer in Button(singer.name) { if let selected { model.assign(selected,to:singer.id);model.selectedSinger = singer.id;expandedSingers.insert(singer.id) } } }
Divider();Button("New Singer + Song…") { model.beginSinger(song:selected) }
}.disabled(selected == nil)
Button("Queue") { 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)
Button(model.readingDurations ? "Reading…" : "Read Durations") { model.scanDurations() }.controlSize(.small).disabled(model.readingDurations).help("Read durations for songs imported by older versions")
Button("Edit Metadata…") { editingSong = selectedSong }.controlSize(.small).disabled(selectedSong == nil)
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 SongMetadataSheet: View {
@ObservedObject var model: AppModel
let song: Song
@Environment(\.dismiss) private var dismiss
@State private var title = ""
@State private var artist = ""
@State private var album = ""
@State private var label = ""
@State private var rating = 0
@State private var error: String?
var body: some View {
VStack(alignment:.leading,spacing:14) {
Text("Edit Song Metadata").font(.title2.bold())
Grid(alignment:.leading,horizontalSpacing:12,verticalSpacing:10) {
GridRow { Text("Title");TextField("Title",text:$title) }
GridRow { Text("Artist");TextField("Artist",text:$artist) }
GridRow { Text("Album");TextField("Album",text:$album) }
GridRow { Text("Label");TextField("Label / publisher",text:$label) }
GridRow { Text("Rating");Picker("Rating",selection:$rating) { ForEach(0..<6) { Text($0 == 0 ? "Unrated" : String(repeating:"★",count:$0)).tag($0) } }.labelsHidden() }
}.textFieldStyle(.roundedBorder)
Text("Saved to your library. Embedded audio-file tags are not changed, and re-importing will preserve your library edits.").font(.caption).foregroundStyle(.secondary)
Text(URL(fileURLWithPath:song.audio).lastPathComponent).font(.caption.monospaced()).foregroundStyle(.secondary).lineLimit(1).truncationMode(.middle).help(song.audio)
if let error { Text(error).foregroundStyle(.red).font(.callout) }
HStack { Spacer();Button("Cancel") { dismiss() }.keyboardShortcut(.cancelAction);Button("Save") { save() }.keyboardShortcut(.defaultAction).disabled(title.trimmingCharacters(in:.whitespacesAndNewlines).isEmpty) }
}.padding(24).frame(width:500).background(Classic.frame).preferredColorScheme(.dark)
.onAppear { title = song.title;artist = song.artist;album = song.album;label = song.label;rating = song.rating }
}
private func save() { do { try model.updateMetadata(song,title:title,artist:artist,album:album,label:label,rating:rating);dismiss() } catch { self.error = error.localizedDescription } }
}
private struct MusicStoresPane: View {
@ObservedObject var model: AppModel
@Binding var selected: Int64?
@Environment(\.openURL) private var openURL
@State private var editor = false
@State private var editing: MusicStore?
@State private var search = ""
@State private var deleting: Int64?
var body: some View {
VStack(alignment:.leading,spacing:14) {
HStack { Text("Music Stores").font(.headline);Spacer();Button("Add Store…") { editing = nil;editor = true } }
Text("Define websites and optional catalogue-search URLs. Purchases and subscriptions are handled by the store in your browser.").font(.callout).foregroundStyle(.secondary)
HStack { TextField("Search store catalogue",text:$search).textFieldStyle(.roundedBorder);Text("{query} in a store’s search URL is replaced with this text.").font(.caption).foregroundStyle(.secondary) }
ScrollView {
VStack(alignment:.leading,spacing:12) {
ForEach(model.musicStores) { store in
VStack(alignment:.leading,spacing:8) {
HStack { Image(systemName:"bag.fill").foregroundStyle(.green);Text(store.name).font(.headline);Spacer()
Button("Open Store") { open(store,query:"") }
Button("Search") { open(store,query:search) }.disabled(search.isEmpty || store.searchTemplate.isEmpty)
Button("Edit") { editing = store;editor = true }
Button("Delete",role:.destructive) { deleting = store.id }
}
Text(store.url).font(.caption).foregroundStyle(.secondary).textSelection(.enabled)
}.padding(12).background(selected == store.id ? Color.blue.opacity(0.15) : Color.white.opacity(0.035)).contentShape(Rectangle()).onTapGesture { selected = store.id }
}
if model.musicStores.isEmpty { Text("No stores configured. Add a store name and website address to get started.").foregroundStyle(.secondary).padding(.top,20) }
}
}
}.padding(14).frame(maxWidth:.infinity,maxHeight:.infinity).background(Classic.navy).overlay(Rectangle().stroke(Classic.line))
.sheet(isPresented:$editor) { MusicStoreEditor(model:model,store:editing) }
.confirmationDialog("Delete this store definition?",isPresented:Binding(get:{ deleting != nil },set:{ if !$0 { deleting = nil } })) {
Button("Delete",role:.destructive) { if let deleting { model.deleteStore(deleting) };deleting = nil }
}
}
private func open(_ store: MusicStore,query: String) {
do { openURL(try store.destination(query:query)) } catch { model.error = error.localizedDescription }
}
}
private struct MusicStoreEditor: View {
@ObservedObject var model: AppModel
let store: MusicStore?
@Environment(\.dismiss) private var dismiss
@State private var name = ""
@State private var url = ""
@State private var search = ""
@State private var error: String?
var body: some View {
VStack(alignment:.leading,spacing:14) {
Text(store == nil ? "Add Music Store" : "Edit Music Store").font(.title2.bold())
TextField("Store name",text:$name).textFieldStyle(.roundedBorder)
TextField("Website URL — https://example.com",text:$url).textFieldStyle(.roundedBorder)
TextField("Optional search URL — https://example.com/search?q={query}",text:$search).textFieldStyle(.roundedBorder)
Text("Use {query} where the search words belong. Only http:// and https:// websites are accepted.").font(.caption).foregroundStyle(.secondary)
if let error { Text(error).foregroundStyle(.red).font(.callout) }
HStack { Spacer();Button("Cancel") { dismiss() }.keyboardShortcut(.cancelAction);Button("Save") { save() }.keyboardShortcut(.defaultAction).disabled(name.trimmingCharacters(in:.whitespacesAndNewlines).isEmpty || url.isEmpty) }
}.padding(24).frame(width:500).background(Classic.frame).preferredColorScheme(.dark)
.onAppear { name = store?.name ?? "";url = store?.url ?? "";search = store?.searchTemplate ?? "" }
}
private func save() { do { try model.saveStore(.init(id:store?.id ?? 0,name:name,url:url,searchTemplate:search));dismiss() } catch { self.error = error.localizedDescription } }
}
private struct SingerSongsSheet: View {
@ObservedObject var model: AppModel
let singer: PersonPlace
@Environment(\.dismiss) private var dismiss
@State private var search = ""
@State private var importing = false
var body: some View {
VStack(alignment:.leading,spacing:14) {
Text("Songs for \(singer.name)").font(.title2.bold())
Text("Tick songs to add them to this singer. Unticking removes only the assignment.").font(.callout).foregroundStyle(.secondary)
TextField("Search library",text:$search).textFieldStyle(.roundedBorder)
ScrollView {
LazyVStack(alignment:.leading,spacing:12) {
ForEach(model.songs.filter { search.isEmpty || $0.title.localizedCaseInsensitiveContains(search) }) { song in
Toggle(song.title,isOn:Binding(get:{ model.singerSongIDs[singer.id]?.contains(song.id) == true },set:{ model.assign(song.id,to:singer.id,included:$0) })).toggleStyle(.checkbox)
}
if model.songs.isEmpty { Text("Your library is empty. Import audio or MP3+G below.").foregroundStyle(.secondary) }
}.frame(maxWidth:.infinity,alignment:.leading)
}.frame(height:270)
HStack { Button("Import Songs…") { importing = true };Spacer();Button("Done") { dismiss() }.keyboardShortcut(.defaultAction) }
}.padding(24).frame(width:520).background(Classic.frame).preferredColorScheme(.dark)
.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 }
}
}
}
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?
@State private var venue: Int64?
@State private var songs = Set<Int64>()
@State private var search = ""
@FocusState private var focused: Bool
var body: some View {
VStack(alignment:.leading,spacing:16) {
Text(kind == .singer ? "New Singer + Songs" : "New Venue").font(.title2.bold())
TextField("\(kind.title) name",text:$name).textFieldStyle(.roundedBorder).focused($focused).onSubmit(save)
if kind == .singer {
Picker("Venue",selection:$venue) { Text("Choose a venue…").tag(nil as Int64?);ForEach(model.venues) { Text($0.name).tag(Optional($0.id)) } }
Text(venue == nil ? "Create a venue first, then add a singer to it." : "This singer will join the selected venue and become active.").font(.caption).foregroundStyle(.secondary)
Text("Add songs now (optional)").font(.headline)
TextField("Search library",text:$search).textFieldStyle(.roundedBorder)
ScrollView {
LazyVStack(alignment:.leading,spacing:10) {
ForEach(model.songs.filter { search.isEmpty || $0.title.localizedCaseInsensitiveContains(search) }) { song in
Toggle(song.title,isOn:Binding(get:{ songs.contains(song.id) },set:{ if $0 { songs.insert(song.id) } else { songs.remove(song.id) } })).toggleStyle(.checkbox)
}
if model.songs.isEmpty { Text("No library songs yet. You can add songs from the singer’s + button after importing.").font(.callout).foregroundStyle(.secondary) }
}.frame(maxWidth:.infinity,alignment:.leading)
}.frame(height:190)
}
if let error { Text(error).foregroundStyle(.red).font(.callout) }
HStack { Spacer();Button("Cancel") { dismiss() }.keyboardShortcut(.cancelAction)
Button(kind == .singer ? "Add Singer & Songs" : "Add Venue",action:save).keyboardShortcut(.defaultAction)
.disabled(name.trimmingCharacters(in:.whitespacesAndNewlines).isEmpty || (kind == .singer && venue == nil))
}
}.padding(24).frame(width:kind == .singer ? 500 : 360).background(Classic.frame).preferredColorScheme(.dark)
.onAppear { focused = true;venue = model.currentVenue ?? model.venues.first?.id;songs = model.newSingerSongs }
}
private func save() {
do {
let id: Int64
if kind == .singer { guard let venue else { throw LibraryError.message("Choose a venue") };id = try model.createSinger(name:name,venue:venue,songs:songs) }
else { 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)
NowPlayingWaveform(player: player).padding(.top, 4)
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: 130)
}
}
private struct NowPlayingWaveform: View {
@ObservedObject var player: Player
@State private var mixer = false
@State private var zoom: Double = 1
@State private var hoverX: CGFloat?
@State private var scrubStart: Double?
@State private var resumeAfterScrub = false
@State private var scrubSong: Int64?
private var span: Double { max(0.001,player.duration/zoom) }
private var windowStart: Double { scrubStart ?? min(max(0,player.time-span/2),max(0,player.duration-span)) }
private var progress: Double { player.duration > 0 ? min(1,max(0,(player.time-windowStart)/span)) : 0 }
private func clock(_ value: Double) -> String { let n = max(0,Int(value));return String(format:"%d:%02d",n/60,n%60) }
private func preciseClock(_ value: Double) -> String { String(format:"%d:%05.2f",max(0,Int(value))/60,max(0,value).truncatingRemainder(dividingBy:60)) }
private func bandColor(_ index: Int) -> Color {
guard player.waveformBands.indices.contains(index) else { return .cyan }
let band = player.waveformBands[index]
let largest = max(0.000001,max(band.low,max(band.mid,band.high)))
let low = Double(band.low/largest),mid = Double(band.mid/largest),high = Double(band.high/largest)
return Color(red:min(1,pow(low,1.2)+mid*0.12+high*0.6),green:min(1,low*0.08+pow(mid,1.5)*0.97+high*0.1),blue:min(1,low*0.07+mid*0.22+high))
}
var body: some View {
VStack(alignment:.leading,spacing:5) {
Text(player.duration > 0 ? player.title : "Ready to play").font(.system(size:13,weight:.semibold)).foregroundStyle(Color(white:0.94))
.lineLimit(1).truncationMode(.middle).frame(maxWidth:.infinity,alignment:.leading).help(player.title)
GeometryReader { geometry in
Canvas { context,size in
let top: CGFloat = 10,plotHeight = size.height-top,mid = top+plotHeight/2
var centre = Path();centre.move(to:CGPoint(x:0,y:mid));centre.addLine(to:CGPoint(x:size.width,y:mid))
context.stroke(centre,with:.color(.white.opacity(0.13)),lineWidth:0.5)
if player.duration > 0 {
let step = [0.1,0.25,0.5,1.0,2,5,10,15,30,60,120,300,600,1800,3600].first { $0 >= span/5 } ?? 3600
let first = floor(windowStart/(step/4))*(step/4)
for t in stride(from:first,through:min(player.duration,windowStart+span),by:step/4) {
let x = size.width*(t-windowStart)/span
if x < 0 { continue }
let major = abs(t/step-(t/step).rounded()) < 0.001
var tick = Path();tick.move(to:CGPoint(x:x,y:top));tick.addLine(to:CGPoint(x:x,y:size.height))
context.stroke(tick,with:.color(major ? .yellow.opacity(0.65) : .white.opacity(0.16)),lineWidth:major ? 0.8 : 0.5)
if major && x < size.width-25 {
context.draw(Text(span < 10 ? preciseClock(t) : clock(t)).font(.system(size:8,design:.monospaced)).foregroundColor(.gray),at:CGPoint(x:x+3,y:3),anchor:.leading)
}
}
}
if !player.waveform.isEmpty {
let count = max(1,Int(size.width/2)),step = size.width/CGFloat(count)
for bar in 0..<count {
let total = player.waveform.count
let left = windowStart+Double(bar)/Double(count)*span,right = windowStart+Double(bar+1)/Double(count)*span
let start = min(total-1,max(0,Int(left/max(player.duration,0.001)*Double(total))))
let end = min(total,max(start+1,Int(right/max(player.duration,0.001)*Double(total))))
let level = player.waveform[start..<min(end,player.waveform.count)].max() ?? 0
let height = max(0.7,CGFloat(level)*(plotHeight-3)),x = CGFloat(bar)*step
let path = Path(CGRect(x:x,y:mid-height/2,width:max(0.7,step-0.7),height:height))
context.fill(path,with:.color(bandColor(start).opacity(x <= size.width*progress ? 1 : 0.88)))
}
let x = size.width*progress
var head = Path();head.move(to:CGPoint(x:x,y:top));head.addLine(to:CGPoint(x:x,y:size.height))
context.stroke(head,with:.color(.red),lineWidth:1)
if let hoverX {
let hx = min(size.width,max(0,hoverX))
var hover = Path();hover.move(to:CGPoint(x:hx,y:top));hover.addLine(to:CGPoint(x:hx,y:size.height))
context.stroke(hover,with:.color(.white.opacity(0.7)),style:StrokeStyle(lineWidth:1,dash:[2,2]))
let time = windowStart+Double(hx/size.width)*span
context.draw(Text(preciseClock(time)).font(.system(size:9,weight:.bold,design:.monospaced)).foregroundColor(.white),at:CGPoint(x:min(size.width-28,max(28,hx)),y:3))
}
} else if player.waveformLoading {
context.draw(Text("Analysing waveform…").font(.system(size:9)).foregroundColor(.gray),at:CGPoint(x:size.width/2,y:mid))
}
}.contentShape(Rectangle())
.onContinuousHover { phase in switch phase { case .active(let point):hoverX = point.x;case .ended:hoverX = nil } }
.gesture(DragGesture(minimumDistance:0).onChanged { value in
guard player.duration > 0,geometry.size.width > 0 else { return }
if scrubStart == nil {
scrubStart = windowStart;scrubSong = player.currentSongID;resumeAfterScrub = player.playing
if player.playing { player.toggle() }
}
guard scrubSong == player.currentSongID else { return }
hoverX = value.location.x
let target = windowStart+Double(min(1,max(0,value.location.x/geometry.size.width)))*span
if abs(target-player.time) > 0.02 { player.seek(target) }
}.onEnded { value in
if scrubStart == nil {
if player.duration > 0 { player.seek(windowStart+Double(min(1,max(0,value.location.x/max(1,geometry.size.width))))*span) }
return
}
let target = windowStart+Double(min(1,max(0,value.location.x/max(1,geometry.size.width))))*span
if scrubSong == player.currentSongID {
player.seek(target)
if resumeAfterScrub && !player.playing && target < player.duration-0.01 { player.toggle() }
}
scrubStart = nil;resumeAfterScrub = false;scrubSong = nil
}).help("Hover for exact time. Drag to scrub; playback resumes on release. Zoom for fine positioning.")
.accessibilityLabel("Audio waveform").accessibilityValue("\(clock(player.time)) of \(clock(player.duration))")
.accessibilityAdjustableAction { direction in if direction == .increment { player.seek(player.time+5) } else if direction == .decrement { player.seek(player.time-5) } }
}.frame(height:60)
HStack(spacing:5) {
Circle().fill(player.playing ? Color.green : Color.orange).frame(width:4,height:4)
Text(player.duration == 0 ? "NO TRACK LOADED" : player.playing ? "PLAYING" : "PAUSED").tracking(1)
if player.waveformUnavailable { Text("· Waveform unavailable").foregroundStyle(.secondary) }
Spacer(minLength:0)
Button { zoom = max(1,zoom/2) } label: { Image(systemName:"minus.magnifyingglass") }.buttonStyle(.plain).disabled(zoom <= 1).help("Zoom out")
Button { zoom = min(32,zoom*2) } label: { Image(systemName:"plus.magnifyingglass") }.buttonStyle(.plain).disabled(zoom >= 32).help("Zoom in for precise scrubbing")
Menu("\(Int(zoom))×") { ForEach([1.0,2,4,8,16,32],id:\.self) { value in Button("\(Int(value))× zoom") { zoom = value } } }.menuStyle(.borderlessButton).frame(width:34).help("Waveform zoom around the playhead")
Menu { Button("Re-analyse Waveform") { player.reanalyseWaveform() }.disabled(player.duration == 0)
Text(player.waveformLoading ? "Analysing…" : player.waveformFromCache ? "Loaded saved waveform" : player.waveformSaved ? "Analysis saved" : "No saved analysis")
} label: { Image(systemName:"waveform") }.menuStyle(.borderlessButton).frame(width:20).help("Waveform cache and re-analysis")
Button("EQ / TONE") { mixer.toggle() }.buttonStyle(.plain).foregroundStyle(.white.opacity(0.85))
.padding(.horizontal,6).padding(.vertical,2).background(.white.opacity(0.08),in:RoundedRectangle(cornerRadius:3))
.popover(isPresented:$mixer) { ToneMixerView(player:player) }
Text("\(clock(player.time)) / \(clock(player.duration))").monospacedDigit().padding(.leading,5)
}.font(.system(size:9,weight:.medium)).foregroundStyle(Color(white:0.6))
}.padding(.horizontal,12).padding(.vertical,9).frame(maxWidth:.infinity).frame(height:120)
.background(Color(red:0.025,green:0.028,blue:0.035)).overlay(Rectangle().strokeBorder(Color(white:0.24),lineWidth:1))
}
}
private struct ToneKnob: View {
let title: String
@Binding var value: Double
let range: ClosedRange<Double>
var filter = false
@State private var initial: Double?
private var fraction: Double { min(1,max(0,(value-range.lowerBound)/(range.upperBound-range.lowerBound))) }
private var display: String {
if filter { return abs(value) < 0.01 ? "OFF" : value < 0 ? "LOW PASS" : "HIGH PASS" }
return String(format:"%+.1f dB",value)
}
var body: some View {
VStack(spacing:4) {
ZStack {
Circle().trim(from:0,to:0.75).stroke(Color(white:0.21),style:StrokeStyle(lineWidth:4,lineCap:.round)).rotationEffect(.degrees(135))
Circle().trim(from:0,to:0.75*fraction).stroke(Color(white:0.48),style:StrokeStyle(lineWidth:3,lineCap:.round)).rotationEffect(.degrees(135))
Circle().fill(LinearGradient(colors:[Color(white:0.19),Color(white:0.09)],startPoint:.top,endPoint:.bottom)).padding(6).overlay(Circle().stroke(.black.opacity(0.65),lineWidth:1.5).padding(6))
Capsule().fill(.white).frame(width:2,height:12).offset(y:-13).rotationEffect(.degrees(-135+270*fraction))
}.frame(width:50,height:50).contentShape(Circle())
.gesture(DragGesture(minimumDistance:0).onChanged { gesture in
if initial == nil { initial = value }
value = min(range.upperBound,max(range.lowerBound,(initial ?? value)-Double(gesture.translation.height)/130*(range.upperBound-range.lowerBound)))
}.onEnded { _ in initial = nil })
.simultaneousGesture(TapGesture(count:2).onEnded { value = 0 })
.accessibilityElement().accessibilityLabel(title).accessibilityValue(display)
.accessibilityAdjustableAction { direction in
let change = (range.upperBound-range.lowerBound)/24
value = min(range.upperBound,max(range.lowerBound,value+(direction == .increment ? change : -change)))
}.help("Drag up/down to adjust. Double-click to reset.")
Text(title).font(.system(size:10,weight:.bold)).foregroundStyle(Color(white:0.6))
Text(display).font(.system(size:8,design:.monospaced)).foregroundStyle(Color(white:0.45))
}
}
}
private struct StereoMeter: View {
@ObservedObject var player: Player
private func normal(_ level: Float) -> Double { max(0,min(1,(20*log10(Double(max(level,0.000001)))+60)/60)) }
var body: some View {
HStack(spacing:3) {
ForEach(0..<2) { channel in
VStack(spacing:2) {
ForEach((0..<24).reversed(),id:\.self) { segment in
let on = Double(segment)/24 < normal(channel == 0 ? player.leftLevel : player.rightLevel)
Rectangle().fill(on ? (segment > 21 ? Color.red : segment > 17 ? Color.yellow : Color.green) : Color.black.opacity(0.5))
}
}
}
}.frame(width:23,height:125).accessibilityLabel("Stereo output levels")
}
}
private struct MixerFader: View {
@Binding var value: Double
var body: some View {
GeometryReader { geometry in
let travel = geometry.size.height-22
ZStack(alignment:.top) {
VStack { ForEach(0..<7) { _ in Rectangle().fill(.white.opacity(0.09)).frame(height:1);Spacer(minLength:0) } }.padding(.vertical,11)
Capsule().fill(.black.opacity(0.8)).frame(width:5).padding(.vertical,8)
RoundedRectangle(cornerRadius:5).fill(LinearGradient(colors:[Color(white:0.45),Color(white:0.23)],startPoint:.top,endPoint:.bottom))
.frame(width:45,height:20).overlay(Rectangle().fill(.white.opacity(0.15)).frame(width:18,height:1))
.offset(y:(1-value)*travel)
}.frame(maxWidth:.infinity).contentShape(Rectangle())
.gesture(DragGesture(minimumDistance:0).onChanged { value = min(1,max(0,1-Double(($0.location.y-11)/travel))) })
}.frame(width:56,height:135).accessibilityLabel("Master volume").accessibilityValue("\(Int(value*100)) percent")
.accessibilityAdjustableAction { direction in value = min(1,max(0,value+(direction == .increment ? 0.05 : -0.05))) }
}
}
private struct ToneMixerView: View {
@ObservedObject var player: Player
var body: some View {
VStack(spacing:14) {
HStack { Text("TONE / MIXER").font(.system(size:12,weight:.bold));Spacer();Toggle("EQ",isOn:$player.toneEnabled).toggleStyle(.switch).controlSize(.mini) }
HStack(alignment:.top,spacing:28) {
VStack(spacing:8) {
ToneKnob(title:"HIGH",value:$player.highGain,range:-12...12)
ToneKnob(title:"MID",value:$player.midGain,range:-12...12)
ToneKnob(title:"LOW",value:$player.lowGain,range:-12...12)
}
VStack(spacing:15) {
ToneKnob(title:"FILTER",value:$player.filter,range:-1...1,filter:true)
HStack(spacing:20) { StereoMeter(player:player);MixerFader(value:$player.volume) }
Text(player.volume <= 0 ? "−∞ dB" : String(format:"%+.1f dB",20*log10(player.volume))).font(.system(size:10,design:.monospaced)).foregroundStyle(.secondary)
}
}.padding(.horizontal,15)
HStack { Text("Drag knobs · Double-click to reset").font(.system(size:9)).foregroundStyle(.secondary);Spacer();Button("Reset EQ") { player.resetTone() }.controlSize(.small) }
}.padding(18).frame(width:270).background(Color(white:0.105)).preferredColorScheme(.dark)
}
}
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")
}
}