1163 lines
81 KiB
Swift
1163 lines
81 KiB
Swift
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")
|
||
}
|
||
}
|