mirror of
https://github.com/XcodesOrg/XcodesApp.git
synced 2026-11-16 05:26:49 +01:00
685 lines
30 KiB
Swift
685 lines
30 KiB
Swift
import Path
|
|
import SwiftUI
|
|
import Version
|
|
import XcodesKit
|
|
|
|
struct XcodeListView: View {
|
|
@EnvironmentObject var appState: AppState
|
|
@Binding var selectedXcodeID: Xcode.ID?
|
|
private let searchText: String
|
|
private let category: XcodeListCategory
|
|
private let architecture: XcodeListArchitecture
|
|
private let isInstalledOnly: Bool
|
|
@AppStorage(PreferenceKey.allowedMajorVersions.rawValue) private var allowedMajorVersions = Int.max
|
|
@State private var expansion = XcodeListExpansion()
|
|
@State private var visibleXcodes: [XcodeListEntry] = []
|
|
@State private var groupedSnapshot = XcodeGroupedListSnapshot(xcodes: [], allXcodes: [])
|
|
|
|
init(selectedXcodeID: Binding<Xcode.ID?>, searchText: String, category: XcodeListCategory, isInstalledOnly: Bool, architecture: XcodeListArchitecture) {
|
|
self._selectedXcodeID = selectedXcodeID
|
|
self.searchText = searchText
|
|
self.category = category
|
|
self.isInstalledOnly = isInstalledOnly
|
|
self.architecture = architecture
|
|
}
|
|
|
|
private func updateListSnapshot(xcodes: [Xcode]? = nil) {
|
|
let allXcodes = xcodes ?? appState.allXcodes
|
|
let entries = allXcodes
|
|
.enumerated()
|
|
.map { XcodeListEntry(index: $0.offset, xcode: $0.element) }
|
|
.applying(XcodeListFilters(
|
|
versionFilter: category.versionFilter,
|
|
architectureFilters: architecture.architectureFilters,
|
|
allowedMajorVersions: allowedMajorVersions,
|
|
searchText: searchText,
|
|
installedOnly: isInstalledOnly
|
|
), item: \.listItem)
|
|
let snapshot = XcodeGroupedListSnapshot(xcodes: entries, allXcodes: allXcodes)
|
|
withAnimation(visibleXcodes.isEmpty ? nil : .easeInOut(duration: 0.18)) {
|
|
visibleXcodes = entries
|
|
groupedSnapshot = snapshot
|
|
}
|
|
}
|
|
|
|
private func latestReleaseForSelectedPrerelease(_ xcode: Xcode) -> Xcode? {
|
|
appState.allXcodes.latestReleaseForSelectedPrerelease(xcode)
|
|
}
|
|
|
|
/// Version rows in display order, for moving the selection with the arrow keys
|
|
private var selectableXcodeIDs: [Xcode.ID] {
|
|
guard appState.enableGroupedXcodeList else { return visibleXcodes.map(\.xcode.id) }
|
|
return groupedSnapshot.rows(expansion: expansion).compactMap { row in
|
|
if case let .version(entry, _, _, _) = row { return entry.xcode.id }
|
|
return nil
|
|
}
|
|
}
|
|
|
|
private func moveSelection(by offset: Int) -> KeyPress.Result {
|
|
let ids = selectableXcodeIDs
|
|
guard !ids.isEmpty else { return .ignored }
|
|
guard let current = selectedXcodeID, let index = ids.firstIndex(of: current) else {
|
|
selectedXcodeID = offset > 0 ? ids.first : ids.last
|
|
return .handled
|
|
}
|
|
selectedXcodeID = ids[min(max(index + offset, 0), ids.count - 1)]
|
|
return .handled
|
|
}
|
|
|
|
var body: some View {
|
|
// Selection is drawn by the rows (SelectableRow) rather than List(selection:), because the sidebar's
|
|
// system highlight can't be restyled and left tags and secondary text hard to read.
|
|
List {
|
|
if appState.enableGroupedXcodeList {
|
|
GroupedXcodeListContent(
|
|
snapshot: groupedSnapshot,
|
|
expansion: $expansion,
|
|
selectedXcodeID: $selectedXcodeID,
|
|
appState: appState
|
|
)
|
|
} else {
|
|
ForEach(visibleXcodes) { entry in
|
|
XcodeListViewRow(
|
|
xcode: entry.xcode,
|
|
selected: selectedXcodeID == entry.xcode.id,
|
|
appState: appState,
|
|
latestReleaseForSelectedPrerelease: latestReleaseForSelectedPrerelease(entry.xcode),
|
|
isLatestRelease: entry.xcode.version.isNotPrerelease && groupedSnapshot.latestStableVersion.map { entry.xcode.version.isEquivalent(to: $0) } == true
|
|
)
|
|
.selectableRow(isSelected: selectedXcodeID == entry.xcode.id) { selectedXcodeID = entry.xcode.id }
|
|
}
|
|
}
|
|
}
|
|
.onReceive(appState.$allXcodes) { updateListSnapshot(xcodes: $0) }
|
|
.onChange(of: searchText) { updateListSnapshot() }
|
|
.onChange(of: category) { updateListSnapshot() }
|
|
.onChange(of: architecture) { updateListSnapshot() }
|
|
.onChange(of: isInstalledOnly) { updateListSnapshot() }
|
|
.onChange(of: allowedMajorVersions) { updateListSnapshot() }
|
|
.task(id: expansion) {
|
|
// Persist after the UI has expanded, coalescing rapid clicks.
|
|
do { try await Task.sleep(for: .milliseconds(250)) } catch { return }
|
|
expansion.save()
|
|
}
|
|
.listStyle(.sidebar)
|
|
.focusable()
|
|
.focusEffectDisabled()
|
|
.onKeyPress(.downArrow) { moveSelection(by: 1) }
|
|
.onKeyPress(.upArrow) { moveSelection(by: -1) }
|
|
}
|
|
}
|
|
|
|
struct XcodeListEntry: Identifiable {
|
|
let index: Int
|
|
let xcode: Xcode
|
|
|
|
var id: Int {
|
|
index
|
|
}
|
|
|
|
var listItem: XcodeListItem {
|
|
xcode.listItem
|
|
}
|
|
}
|
|
|
|
/// Expansion is local UI state; saving it never delays a disclosure click.
|
|
struct XcodeListExpansion: Equatable, Hashable {
|
|
var majorVersions: Set<Int>
|
|
var minorVersions: Set<String>
|
|
|
|
init(majorVersions: Set<Int>, minorVersions: Set<String>) {
|
|
self.majorVersions = majorVersions
|
|
self.minorVersions = minorVersions
|
|
}
|
|
|
|
init() {
|
|
let defaults = UserDefaults.standard
|
|
majorVersions = Set((defaults.string(forKey: PreferenceKey.expandedMajorXcodeVersions.rawValue) ?? "").split(separator: ",").compactMap { Int($0) })
|
|
minorVersions = Set((defaults.string(forKey: PreferenceKey.expandedMinorXcodeVersions.rawValue) ?? "").split(separator: ",").map(String.init))
|
|
}
|
|
|
|
mutating func toggleMajor(_ major: Int, minorIDs: [String]) {
|
|
if majorVersions.remove(major) != nil {
|
|
minorVersions.subtract(minorIDs)
|
|
} else {
|
|
majorVersions.insert(major)
|
|
}
|
|
}
|
|
|
|
mutating func toggleMinor(_ id: String) {
|
|
if minorVersions.remove(id) == nil { minorVersions.insert(id) }
|
|
}
|
|
|
|
func save() {
|
|
UserDefaults.standard.set(majorVersions.sorted().map(String.init).joined(separator: ","), forKey: PreferenceKey.expandedMajorXcodeVersions.rawValue)
|
|
UserDefaults.standard.set(minorVersions.sorted().joined(separator: ","), forKey: PreferenceKey.expandedMinorXcodeVersions.rawValue)
|
|
}
|
|
}
|
|
|
|
/// Build summaries only when the dataset or filters change, not when a group opens.
|
|
struct XcodeGroupedListSnapshot {
|
|
struct Summary {
|
|
let displayName: String
|
|
let latestRelease: Xcode?
|
|
let latestSelectableRelease: Xcode?
|
|
let latestSelectionTarget: Xcode?
|
|
let selectedVersion: Xcode?
|
|
let installingVersion: Xcode?
|
|
let versionCount: Int
|
|
let tag: ReleaseTagView?
|
|
|
|
init(versions: [Xcode], displayName: String, latestSelectableRelease: Xcode?, latestStableVersion: Version?, isMajor: Bool) {
|
|
self.displayName = displayName
|
|
latestRelease = versions.latestRelease
|
|
self.latestSelectableRelease = latestSelectableRelease
|
|
latestSelectionTarget = versions.latestInstalledVersion
|
|
selectedVersion = versions.first { $0.selected }
|
|
installingVersion = versions.first { $0.installState.installing }
|
|
versionCount = versions.count
|
|
if let latestStableVersion, versions.contains(where: { $0.version.isNotPrerelease && $0.version.isEquivalent(to: latestStableVersion) }) {
|
|
tag = .latest
|
|
} else if !isMajor, versions.allSatisfy(\.version.isPrerelease), let newest = versions.max(by: { $0.version < $1.version }) {
|
|
tag = ReleaseTagView(prereleaseOf: newest.version)
|
|
} else {
|
|
tag = nil
|
|
}
|
|
}
|
|
}
|
|
|
|
struct Minor {
|
|
let id: String
|
|
let summary: Summary
|
|
let entries: [XcodeListEntry]
|
|
}
|
|
|
|
struct Major {
|
|
let id: Int
|
|
let summary: Summary
|
|
let minors: [Minor]
|
|
}
|
|
|
|
enum Row: Identifiable {
|
|
case major(Major, expanded: Bool)
|
|
case minor(Minor, expanded: Bool, isLast: Bool)
|
|
case version(XcodeListEntry, isLastMinor: Bool, isLastEntry: Bool, latestRelease: Xcode?)
|
|
|
|
var id: String {
|
|
switch self {
|
|
case let .major(group, _): return "major-\(group.id)"
|
|
case let .minor(group, _, _): return "minor-\(group.id)"
|
|
case let .version(entry, _, _, _): return "version-\(entry.xcode.id)"
|
|
}
|
|
}
|
|
}
|
|
|
|
let majors: [Major]
|
|
let latestStableVersion: Version?
|
|
private let replacements: [Xcode.ID: Xcode]
|
|
|
|
init(xcodes: [XcodeListEntry], allXcodes: [Xcode]) {
|
|
let latestStable = allXcodes.latestRelease?.version
|
|
latestStableVersion = latestStable
|
|
replacements = Dictionary(allXcodes.compactMap { xcode in
|
|
allXcodes.latestReleaseForSelectedPrerelease(xcode).map { (xcode.id, $0) }
|
|
}, uniquingKeysWith: { first, _ in first })
|
|
majors = xcodes.groupedByMajorVersion(item: \.listItem).map { major in
|
|
let versions = major.versions.map(\.xcode)
|
|
let latest = versions.latestRelease
|
|
return Major(
|
|
id: major.majorVersion,
|
|
summary: Summary(versions: versions, displayName: "Xcode \(major.displayName)", latestSelectableRelease: latest, latestStableVersion: latestStable, isMajor: true),
|
|
minors: major.minorVersionGroups.map { minor in
|
|
Minor(id: minor.id,
|
|
summary: Summary(versions: minor.versions.map(\.xcode), displayName: minor.displayName, latestSelectableRelease: latest, latestStableVersion: latestStable, isMajor: false),
|
|
entries: minor.versions)
|
|
}
|
|
)
|
|
}
|
|
}
|
|
|
|
func rows(expansion: XcodeListExpansion) -> [Row] {
|
|
var rows: [Row] = []
|
|
for major in majors {
|
|
let expanded = expansion.majorVersions.contains(major.id)
|
|
rows.append(.major(major, expanded: expanded))
|
|
guard expanded else { continue }
|
|
for (minorIndex, minor) in major.minors.enumerated() {
|
|
let minorExpanded = expansion.minorVersions.contains(minor.id)
|
|
let isLastMinor = minorIndex == major.minors.count - 1
|
|
rows.append(.minor(minor, expanded: minorExpanded, isLast: isLastMinor))
|
|
guard minorExpanded else { continue }
|
|
for (entryIndex, entry) in minor.entries.enumerated() {
|
|
rows.append(.version(entry, isLastMinor: isLastMinor, isLastEntry: entryIndex == minor.entries.count - 1, latestRelease: replacements[entry.xcode.id]))
|
|
}
|
|
}
|
|
}
|
|
return rows
|
|
}
|
|
}
|
|
|
|
private struct GroupedXcodeListContent: View {
|
|
let snapshot: XcodeGroupedListSnapshot
|
|
@Binding var expansion: XcodeListExpansion
|
|
@Binding var selectedXcodeID: Xcode.ID?
|
|
let appState: AppState
|
|
|
|
var body: some View {
|
|
// One flat collection lets List identify rows without walking nested, variable-size ForEach views.
|
|
ForEach(snapshot.rows(expansion: expansion)) { row in
|
|
switch row {
|
|
case let .major(group, expanded):
|
|
groupRow(group.summary, expanded: expanded, level: 0) {
|
|
withAnimation(.easeInOut(duration: 0.18)) {
|
|
expansion.toggleMajor(group.id, minorIDs: group.minors.map(\.id))
|
|
}
|
|
}
|
|
case let .minor(group, expanded, isLast):
|
|
groupRow(group.summary, expanded: expanded, level: 1) {
|
|
withAnimation(.easeInOut(duration: 0.18)) { expansion.toggleMinor(group.id) }
|
|
}
|
|
.treeGuides { TreeGuides(guides: [TreeGuide(level: 0, extent: isLast ? .elbow : .tee)]) }
|
|
case let .version(entry, isLastMinor, isLastEntry, latestRelease):
|
|
XcodeListViewRow(
|
|
xcode: entry.xcode,
|
|
selected: selectedXcodeID == entry.xcode.id,
|
|
appState: appState,
|
|
latestReleaseForSelectedPrerelease: latestRelease,
|
|
style: .grouped,
|
|
isLatestRelease: entry.xcode.version.isNotPrerelease && snapshot.latestStableVersion.map { entry.xcode.version.isEquivalent(to: $0) } == true
|
|
)
|
|
.padding(.leading, TreeGuide.contentInset(forLevel: 2))
|
|
.treeGuides {
|
|
TreeGuides(guides: [
|
|
TreeGuide(level: 0, extent: isLastMinor ? .none : .through),
|
|
TreeGuide(level: 1, extent: isLastEntry ? .elbow : .tee, branchesToLeaf: true)
|
|
])
|
|
}
|
|
.selectableRow(isSelected: selectedXcodeID == entry.xcode.id) { selectedXcodeID = entry.xcode.id }
|
|
}
|
|
}
|
|
}
|
|
|
|
private func groupRow(_ summary: XcodeGroupedListSnapshot.Summary, expanded: Bool, level: Int, toggle: @escaping () -> Void) -> some View {
|
|
XcodeVersionGroupRow(
|
|
displayName: summary.displayName,
|
|
latestRelease: summary.latestRelease,
|
|
latestSelectableRelease: summary.latestSelectableRelease,
|
|
latestSelectionTarget: summary.latestSelectionTarget,
|
|
selectedVersion: summary.selectedVersion,
|
|
installingVersion: summary.installingVersion,
|
|
isExpanded: expanded,
|
|
level: level,
|
|
versionCount: summary.versionCount,
|
|
tag: summary.tag,
|
|
showsActiveTag: summary.selectedVersion != nil && !expanded,
|
|
appState: appState,
|
|
onToggleExpanded: toggle
|
|
)
|
|
}
|
|
}
|
|
|
|
/// A vertical guide line connecting a group row to its children, drawn like a file tree (├ └ │).
|
|
private struct TreeGuide: Hashable {
|
|
enum Extent {
|
|
/// No line; the parent's last child has already been drawn.
|
|
case none
|
|
/// A full-height line passing a sibling's descendants.
|
|
case through
|
|
/// A full-height line with a branch to this row (├).
|
|
case tee
|
|
/// A line ending at this row with a branch to it (└).
|
|
case elbow
|
|
}
|
|
|
|
/// Chevron width plus spacing, so each level's content starts one step to the right of its parent's chevron.
|
|
static let levelIndent: CGFloat = 22
|
|
static let chevronWidth: CGFloat = 12
|
|
|
|
let level: Int
|
|
let extent: Extent
|
|
/// Whether this row is a leaf (no chevron), so the branch reaches further to meet its icon.
|
|
var branchesToLeaf = false
|
|
|
|
/// Centered under the parent's chevron.
|
|
var x: CGFloat {
|
|
CGFloat(level) * Self.levelIndent + Self.chevronWidth / 2
|
|
}
|
|
|
|
/// Where the branch drawn for this row stops, just short of the row's chevron or icon.
|
|
var branchEnd: CGFloat {
|
|
let childContentStart = branchesToLeaf ? Self.contentInset(forLevel: level + 1) : CGFloat(level + 1) * Self.levelIndent
|
|
return childContentStart - 4
|
|
}
|
|
|
|
/// Leaf rows have no chevron, so their icon is inset to where a chevron-less row at that level would start.
|
|
static func contentInset(forLevel level: Int) -> CGFloat {
|
|
CGFloat(level) * levelIndent + chevronWidth + 8
|
|
}
|
|
}
|
|
|
|
private struct TreeGuides: View {
|
|
let guides: [TreeGuide]
|
|
/// Where branches meet the row: the middle of its title line. Falls back to the row's middle.
|
|
var branchY: CGFloat? = nil
|
|
|
|
var body: some View {
|
|
Canvas { context, size in
|
|
let lineWidth: CGFloat = 1.5
|
|
// Rows have a little vertical breathing room; extend past it so lines connect between rows.
|
|
let overshoot: CGFloat = 4
|
|
let midY = branchY ?? size.height / 2
|
|
for guide in guides {
|
|
let color = Color.secondary.opacity(0.35)
|
|
var path = Path()
|
|
switch guide.extent {
|
|
case .none:
|
|
continue
|
|
case .through, .tee:
|
|
path.move(to: CGPoint(x: guide.x, y: -overshoot))
|
|
path.addLine(to: CGPoint(x: guide.x, y: size.height + overshoot))
|
|
case .elbow:
|
|
path.move(to: CGPoint(x: guide.x, y: -overshoot))
|
|
path.addLine(to: CGPoint(x: guide.x, y: midY - 5))
|
|
path.addQuadCurve(to: CGPoint(x: guide.x + 5, y: midY), control: CGPoint(x: guide.x, y: midY))
|
|
}
|
|
if guide.extent == .tee || guide.extent == .elbow {
|
|
let branchStart = guide.extent == .tee ? guide.x : guide.x + 5
|
|
path.move(to: CGPoint(x: branchStart, y: midY))
|
|
path.addLine(to: CGPoint(x: guide.branchEnd, y: midY))
|
|
}
|
|
context.stroke(path, with: .color(color), style: StrokeStyle(lineWidth: lineWidth, lineCap: .round))
|
|
}
|
|
}
|
|
.allowsHitTesting(false)
|
|
.accessibilityHidden(true)
|
|
}
|
|
}
|
|
|
|
private struct XcodeVersionGroupRow: View {
|
|
let displayName: String
|
|
let latestRelease: Xcode?
|
|
let latestSelectableRelease: Xcode?
|
|
let latestSelectionTarget: Xcode?
|
|
let selectedVersion: Xcode?
|
|
let installingVersion: Xcode?
|
|
let isExpanded: Bool
|
|
let level: Int
|
|
let versionCount: Int
|
|
let tag: ReleaseTagView?
|
|
let showsActiveTag: Bool
|
|
@ObservedObject var appState: AppState
|
|
let onToggleExpanded: () -> Void
|
|
|
|
var body: some View {
|
|
HStack {
|
|
Button(action: onToggleExpanded) {
|
|
// Nested rows line the chevron up with the title, where the tree guide branch ends;
|
|
// top-level rows center it on the icon.
|
|
HStack(alignment: level == 0 ? .center : .firstTextBaseline, spacing: 8) {
|
|
Image(systemName: isExpanded ? "chevron.down" : "chevron.right")
|
|
.font(.caption.weight(.semibold))
|
|
.foregroundColor(.secondary)
|
|
.frame(width: 12, height: 12)
|
|
|
|
if level == 0 {
|
|
icon
|
|
}
|
|
|
|
VStack(alignment: .leading, spacing: 2) {
|
|
HStack(spacing: 6) {
|
|
Text(verbatim: displayName)
|
|
.font(level == 0 ? .headline : .body.weight(.medium))
|
|
.fixedSize(horizontal: true, vertical: false)
|
|
.treeGuideTitle()
|
|
|
|
if appState.showTags, let tag {
|
|
tag
|
|
}
|
|
|
|
if appState.showTags && showsActiveTag {
|
|
ReleaseTagView.active
|
|
}
|
|
|
|
Text(verbatim: "\(versionCount)")
|
|
.font(.caption2.weight(.semibold).monospacedDigit())
|
|
.foregroundStyle(.secondary)
|
|
.padding(.horizontal, 6)
|
|
.padding(.vertical, 1)
|
|
.background(.quaternary, in: Capsule())
|
|
.accessibilityHidden(true)
|
|
}
|
|
|
|
if let subtitle {
|
|
Text(verbatim: subtitle)
|
|
.font(.caption)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
|
|
Spacer()
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.contentShape(Rectangle())
|
|
}
|
|
.buttonStyle(.plain)
|
|
|
|
// Like the progress ring and Active tag, the checkmark and Open/Install belong to the deepest
|
|
// visible row, so an expanded group leaves them to the rows below it
|
|
if !isExpanded {
|
|
selectControl
|
|
.padding(.trailing, 16)
|
|
installControl
|
|
// Same column width as the Install/Open buttons, so the progress ring lines up with them
|
|
.frame(minWidth: 67)
|
|
}
|
|
}
|
|
.padding(.leading, CGFloat(level) * TreeGuide.levelIndent)
|
|
.padding(.vertical, level == 0 ? 8 : 5)
|
|
.contentShape(Rectangle())
|
|
}
|
|
|
|
/// "Latest: 27.0 · Active: 27.0 Beta 6"
|
|
private var subtitle: String? {
|
|
let parts = [
|
|
latestRelease.map { "Latest: \($0.description)" },
|
|
selectedVersion.map { "Active: \($0.description)" },
|
|
].compactMap { $0 }
|
|
return parts.isEmpty ? nil : parts.joined(separator: " · ")
|
|
}
|
|
|
|
@ViewBuilder
|
|
private var icon: some View {
|
|
if let icon = latestRelease?.icon {
|
|
Image(nsImage: icon)
|
|
.resizable()
|
|
.frame(width: 32, height: 32)
|
|
} else {
|
|
Image(latestRelease?.version.isPrerelease == true ? "xcode-beta" : "xcode")
|
|
.resizable()
|
|
.frame(width: 32, height: 32)
|
|
.opacity(0.5)
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private var selectControl: some View {
|
|
if let selectedVersion, selectedVersion.selected, let latestSelectableRelease, latestSelectableRelease.id != selectedVersion.id {
|
|
switch latestSelectionTarget?.installState {
|
|
case .installed:
|
|
if let latestSelectionTarget, latestSelectionTarget.id != selectedVersion.id {
|
|
Button(action: { appState.select(xcode: latestSelectionTarget) }) {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(.yellow)
|
|
}
|
|
.buttonStyle(PlainButtonStyle())
|
|
.help(staleSelectedHelpText(selectedVersion: selectedVersion, latestRelease: latestSelectableRelease, selectionTarget: latestSelectionTarget))
|
|
} else {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(.yellow)
|
|
.help(staleSelectedHelpText(selectedVersion: selectedVersion, latestRelease: latestSelectableRelease, selectionTarget: latestSelectionTarget))
|
|
}
|
|
case .notInstalled:
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(.yellow)
|
|
.help(staleSelectedHelpText(selectedVersion: selectedVersion, latestRelease: latestSelectableRelease, selectionTarget: latestSelectionTarget))
|
|
case .installing, .uninstalling, .none:
|
|
EmptyView()
|
|
}
|
|
} else if selectedVersion?.selected == true {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundColor(.green)
|
|
.help("ActiveVersionDescription")
|
|
} else if let latestSelectionTarget {
|
|
Button(action: { appState.select(xcode: latestSelectionTarget) }) {
|
|
// Installed but not active: green outline; the active Xcode gets the filled check
|
|
Image(systemName: "checkmark.circle")
|
|
.foregroundColor(.green)
|
|
}
|
|
.buttonStyle(PlainButtonStyle())
|
|
.help("MakeActiveVersionDescription")
|
|
}
|
|
}
|
|
|
|
private func staleSelectedHelpText(selectedVersion: Xcode, latestRelease: Xcode, selectionTarget: Xcode?) -> Text {
|
|
switch selectionTarget?.installState {
|
|
case .installed:
|
|
if let selectionTarget, selectionTarget.id != selectedVersion.id {
|
|
return Text(verbatim: "\(selectedVersion.description) selected, \(latestRelease.description) available. Click to select \(selectionTarget.description).")
|
|
} else {
|
|
return Text(verbatim: "\(selectedVersion.description) selected, \(latestRelease.description) available.")
|
|
}
|
|
case .notInstalled:
|
|
if let selectionTarget {
|
|
return Text(verbatim: "\(selectedVersion.description) selected, \(latestRelease.description) available. Install \(selectionTarget.description) to select it.")
|
|
} else {
|
|
return Text(verbatim: "\(selectedVersion.description) selected, \(latestRelease.description) available.")
|
|
}
|
|
case .installing, .uninstalling, .none:
|
|
return Text(verbatim: "\(selectedVersion.description) selected, \(latestRelease.description) available.")
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private var installControl: some View {
|
|
if let installingVersion,
|
|
case let .installing(installationStep) = installingVersion.installState {
|
|
InstallationStepRowView(
|
|
installationStep: installationStep,
|
|
cancel: { appState.presentedAlert = .cancelInstall(xcode: installingVersion) }
|
|
)
|
|
} else if let latestRelease {
|
|
switch latestRelease.installState {
|
|
case .installed:
|
|
Button("Open") { appState.open(xcode: latestRelease) }
|
|
.textCase(.uppercase)
|
|
.buttonStyle(AppStoreButtonStyle(primary: true, highlighted: false))
|
|
.help("OpenDescription")
|
|
case .notInstalled:
|
|
Button("Install") {
|
|
appState.checkMinVersionAndInstall(id: latestRelease.id)
|
|
}
|
|
.textCase(.uppercase)
|
|
.buttonStyle(AppStoreButtonStyle(primary: false, highlighted: false))
|
|
.help("InstallDescription")
|
|
case .installing, .uninstalling:
|
|
EmptyView()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private extension Array where Element == Xcode {
|
|
var latestRelease: Xcode? {
|
|
filter { $0.version.isNotPrerelease }
|
|
.sorted { $0.version < $1.version }
|
|
.last
|
|
}
|
|
|
|
var latestInstalledVersion: Xcode? {
|
|
filter(\.installState.installed)
|
|
.sorted { $0.version < $1.version }
|
|
.last
|
|
}
|
|
|
|
func latestReleaseForSelectedPrerelease(_ xcode: Xcode) -> Xcode? {
|
|
guard xcode.selected, xcode.version.isPrerelease else { return nil }
|
|
|
|
return first { candidate in
|
|
candidate.id != xcode.id &&
|
|
candidate.architectures == xcode.architectures &&
|
|
candidate.version.major == xcode.version.major &&
|
|
candidate.version.minor == xcode.version.minor &&
|
|
candidate.version.patch == xcode.version.patch &&
|
|
candidate.version.isNotPrerelease &&
|
|
candidate.installState.installing == false
|
|
}
|
|
}
|
|
}
|
|
|
|
struct XcodeListView_Previews: PreviewProvider {
|
|
@MainActor
|
|
static var previews: some View {
|
|
Group {
|
|
XcodeListView(selectedXcodeID: .constant(nil), searchText: "", category: .all, isInstalledOnly: false, architecture: .appleSilicon)
|
|
.environmentObject({ () -> AppState in
|
|
let a = AppState()
|
|
a.allXcodes = [
|
|
Xcode(version: Version("12.0.0+1234A")!, identicalBuilds: [XcodeID(version: Version("12.0.0+1234A")!), XcodeID(version: Version("12.0.0-RC+1234A")!)], installState: .installed(Path("/Applications/Xcode-12.3.0.app")!), selected: false, icon: nil),
|
|
Xcode(version: Version("12.3.0")!, installState: .installed(Path("/Applications/Xcode-12.3.0.app")!), selected: true, icon: nil),
|
|
Xcode(version: Version("12.2.0")!, installState: .notInstalled, selected: false, icon: nil),
|
|
Xcode(version: Version("12.1.0")!, installState: .installing(.downloading(progress: configure(Progress(totalUnitCount: 100)) { $0.completedUnitCount = 40 })), selected: false, icon: nil),
|
|
Xcode(version: Version("12.0.0")!, installState: .installed(Path("/Applications/Xcode-12.3.0.app")!), selected: false, icon: nil),
|
|
Xcode(version: Version("10.1.0")!, installState: .notInstalled, selected: false, icon: nil),
|
|
Xcode(version: Version("10.0.0")!, installState: .installed(Path("/Applications/Xcode-10.0.0.app")!), selected: false, icon: nil),
|
|
Xcode(version: Version("9.0.0")!, installState: .notInstalled, selected: false, icon: nil),
|
|
]
|
|
return a
|
|
}())
|
|
}
|
|
.previewLayout(.sizeThatFits)
|
|
}
|
|
}
|
|
|
|
// MARK: - Tree guide title anchor
|
|
|
|
/// The vertical middle of a row's title, so tree guide branches meet the title rather than the row's middle.
|
|
private struct TreeGuideTitleMidYKey: SwiftUI.PreferenceKey {
|
|
static let defaultValue: CGFloat? = nil
|
|
static func reduce(value: inout CGFloat?, nextValue: () -> CGFloat?) {
|
|
value = value ?? nextValue()
|
|
}
|
|
}
|
|
|
|
private let treeGuideRowSpace = "treeGuideRow"
|
|
|
|
extension View {
|
|
/// Marks the row's title; tree guides drawn with `treeGuides(_:)` branch at its middle.
|
|
func treeGuideTitle() -> some View {
|
|
background {
|
|
GeometryReader { proxy in
|
|
Color.clear.preference(key: TreeGuideTitleMidYKey.self, value: proxy.frame(in: .named(treeGuideRowSpace)).midY)
|
|
}
|
|
}
|
|
}
|
|
|
|
fileprivate func treeGuides(_ guides: @escaping () -> TreeGuides) -> some View {
|
|
coordinateSpace(name: treeGuideRowSpace)
|
|
.backgroundPreferenceValue(TreeGuideTitleMidYKey.self) { titleMidY in
|
|
let base = guides()
|
|
TreeGuides(guides: base.guides, branchY: titleMidY)
|
|
}
|
|
}
|
|
|
|
/// Selects the row on click and draws a soft highlight that keeps text and tags legible.
|
|
func selectableRow(isSelected: Bool, onSelect: @escaping () -> Void) -> some View {
|
|
contentShape(Rectangle())
|
|
.onTapGesture(perform: onSelect)
|
|
.listRowBackground(
|
|
RoundedRectangle(cornerRadius: 6, style: .continuous)
|
|
.fill(isSelected ? Color.accentColor.opacity(0.2) : .clear)
|
|
.padding(.horizontal, 10)
|
|
)
|
|
.accessibilityAddTraits(isSelected ? .isSelected : [])
|
|
}
|
|
}
|