Run Windows games on Apple Silicon — free, open source, with an open compatibility database that tells you what actually works.
Swift apple-silicond3dmetaldxmtdxvkfexgame-porting-toolkitgamingmac-gamingmacosmetalmoltenvksteamswiftuivkd3d-protonwhisky-alternativewindows-gameswinewine-wrapper
import SwiftUI
import HighballKit
/// The page a player sees after picking another engine on an environment's page (highball#254,
/// from PR #230 by @matiasmg-ok): what moves, what stays, the steps, and then the steps as they
/// happen. The work itself is the usual move on the activity strip, so closing the page never
/// stops anything (UX plan 0.5: what takes time lives on the strip, never modal).
struct EngineTransitionSheet: View {
@Environment(AppState.self) private var state
@Environment(\.dismiss) private var dismiss
let transition: AppState.EngineTransition
@State private var started = false
/// The steps as they were when Switch was pressed: afterwards the environment is on the new
/// engine and the engine is installed, so a fresh plan would drop the steps that just ran.
@State private var frozen: EngineSwitchPlan?
private var bottle: Bottle? { state.bottles.first { $0.name == transition.bottleName } }
private var target: EngineManifest? {
state.engines.first { $0.id == transition.targetID }?.manifest
?? AppState.knownManifests.first { $0.id == transition.targetID }
}
private var installed: Bool { state.engines.contains { $0.id == transition.targetID } }
private var plan: EngineSwitchPlan { frozen ?? livePlan }
private var livePlan: EngineSwitchPlan {
let current = bottle.flatMap { b in state.engines.first { $0.id == b.settings.engineID }?.manifest }
let refreshes = target.map { EngineManifest.needsPrefixRefresh(from: current, to: $0) } ?? true
return EngineSwitchPlan(engineInstalled: installed, refreshesWindows: refreshes)
}
private var programs: [String] { bottle.map { state.programNames(in: $0) } ?? [] }
var body: some View {
VStack(alignment: .leading, spacing: 16) {
VStack(alignment: .leading, spacing: 4) {
HB.eyebrow(L("Engine"))
Text(String(format: L("Switch '%@' to %@"), transition.bottleName, targetName))
.font(.title2.bold())
Text(verbatim: transition.targetID).font(.caption.monospaced()).foregroundStyle(.tertiary)
}
section(L("What moves"), programs.isEmpty
? L("The environment and everything in it. Programs installed later run on the new engine too.")
: String(format: L("Everything in this environment moves to the new engine, including %@."), programList))
section(L("What stays"), L("Everything installed, your saves and Steam's sign-in. The engine you leave stays installed, so switching back is the same step."))
VStack(alignment: .leading, spacing: 8) {
Text(L("Steps")).font(.callout.weight(.medium))
ForEach(plan.steps, id: \.self) { step in
stepRow(step)
}
}
.padding(12)
.frame(maxWidth: .infinity, alignment: .leading)
.background(RoundedRectangle(cornerRadius: 10).fill(HB.card))
.overlay(RoundedRectangle(cornerRadius: 10).stroke(HB.cardStroke))
if started, state.engineSwitchSucceeded == false {
Text(L("The switch did not finish. The environment keeps the engine it had, and the message at the bottom of the window says why."))
.font(.callout).foregroundStyle(HB.bad).fixedSize(horizontal: false, vertical: true)
} else if !started, state.busy {
Text(L("Something else is running. The switch can start once it finishes."))
.font(.caption).foregroundStyle(.secondary)
}
HStack {
if started && state.engineSwitchSucceeded == nil {
Text(L("You can close this page, the switch carries on at the bottom of the window."))
.font(.caption).foregroundStyle(.secondary)
}
Spacer()
if !started {
Button(L("Cancel")) { dismiss() }.keyboardShortcut(.cancelAction)
Button(L("Switch")) {
frozen = livePlan
started = true
state.startEngineTransition(transition)
}
.keyboardShortcut(.defaultAction)
.buttonStyle(.borderedProminent)
.disabled(state.busy || bottle == nil || target == nil)
} else if state.engineSwitchSucceeded == nil {
Button(L("Hide")) { dismiss() }.keyboardShortcut(.cancelAction)
} else {
Button(L("Done")) { dismiss() }
.keyboardShortcut(.defaultAction)
.buttonStyle(.borderedProminent)
}
}
}
.padding(22)
.frame(width: 520)
.onChange(of: state.debugStartEngineTransition) { _, go in
guard go, !started else { return }
state.debugStartEngineTransition = false
frozen = livePlan
started = true
state.startEngineTransition(transition)
}
}
private var targetName: String { target.map(GamePageCopy.shortEngineName) ?? transition.targetID }
/// Up to four names, then how many more, so a big library does not turn into a wall of text.
private var programList: String {
let shown = programs.prefix(4).joined(separator: ", ")
let rest = programs.count - min(programs.count, 4)
return rest > 0 ? String(format: L("%@ and %d more"), shown, rest) : shown
}
@ViewBuilder private func section(_ title: String, _ body: String) -> some View {
VStack(alignment: .leading, spacing: 3) {
Text(title).font(.callout.weight(.medium))
Text(body).font(.callout).foregroundStyle(.secondary).fixedSize(horizontal: false, vertical: true)
}
}
private func label(_ step: EngineSwitchPlan.Step) -> String {
switch step {
case .download:
let size = target.map(GamePageCopy.downloadSize) ?? ""
return size.isEmpty ? L("Download the engine") : String(format: L("Download the engine, about %@"), size)
case .stopPrograms: return L("Stop what runs in this environment and switch")
case .windowsSetup: return L("Run the Windows setup again, a minute or two")
case .done: return L("Ready to play")
}
}
@ViewBuilder private func stepRow(_ step: EngineSwitchPlan.Step) -> some View {
let steps = plan.steps
let currentIndex = state.engineSwitchStep.flatMap { steps.firstIndex(of: $0) }
let index = steps.firstIndex(of: step) ?? 0
let finished = state.engineSwitchSucceeded == true
let isDone = started && (finished || (currentIndex.map { index < $0 } ?? false))
let isCurrent = started && !finished && currentIndex == index && state.engineSwitchSucceeded == nil
HStack(spacing: 10) {
Group {
if isDone {
Image(systemName: "checkmark.circle.fill").foregroundStyle(HB.good)
} else if isCurrent {
ProgressView().controlSize(.small)
} else {
Image(systemName: "circle").foregroundStyle(.tertiary)
}
}
.frame(width: 18)
Text(label(step))
.font(.callout)
.foregroundStyle(isCurrent ? .primary : (isDone ? .secondary : .secondary))
if isCurrent, step == .download, let p = state.busyProgress, let total = p.total, total > 0 {
Spacer()
Text(verbatim: "\(Int(Double(p.received) / Double(total) * 100)) %")
.font(.caption.monospacedDigit()).foregroundStyle(.secondary)
}
}
}
}