125 lines
6.4 KiB
Swift
125 lines
6.4 KiB
Swift
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
import AppKit
|
|
import SwiftUI
|
|
|
|
// Host window geometry only: never guest memory, transport, or media state.
|
|
@MainActor
|
|
final class WindowPlacements {
|
|
private let defaults: UserDefaults
|
|
init(defaults: UserDefaults) { self.defaults = defaults }
|
|
private func key(_ id: String) -> String { "interface.window.\(id)" }
|
|
func saved(_ id: String) -> CGRect? {
|
|
guard let numbers = defaults.array(forKey: key(id)) as? [Double], numbers.count == 4 else { return nil }
|
|
let rect = CGRect(x: numbers[0], y: numbers[1], width: numbers[2], height: numbers[3])
|
|
return Self.valid(rect) ? rect : nil
|
|
}
|
|
func save(_ frame: CGRect, id: String) {
|
|
guard Self.valid(frame) else { return }
|
|
defaults.set([frame.minX, frame.minY, frame.width, frame.height], forKey: key(id))
|
|
}
|
|
private static func valid(_ r: CGRect) -> Bool {
|
|
[r.origin.x, r.origin.y, r.size.width, r.size.height].allSatisfy { $0.isFinite && abs($0) < 1_000_000 }
|
|
&& r.size.width > 0 && r.size.height > 0
|
|
}
|
|
// Use the screen with the greatest overlap; an unplugged display falls
|
|
// back to the main screen. Keep the title bar reachable even if a native
|
|
// form's minimum size exceeds a small screen's usable area.
|
|
static func reachable(_ frame: CGRect, screens: [CGRect], minimum: CGSize = .zero) -> CGRect {
|
|
guard valid(frame), let fallback = screens.first else { return frame }
|
|
func area(_ r: CGRect) -> CGFloat { r.isNull ? 0 : r.width * r.height }
|
|
let screen = screens.max { area(frame.intersection($0)) < area(frame.intersection($1)) }
|
|
.flatMap { area(frame.intersection($0)) > 0 ? $0 : nil } ?? fallback
|
|
let width = max(minimum.width, min(frame.width, screen.width))
|
|
let height = max(minimum.height, min(frame.height, screen.height))
|
|
return CGRect(x: max(screen.minX, min(frame.minX, screen.maxX - width)),
|
|
y: min(screen.maxY - height, max(frame.minY, screen.minY)),
|
|
width: width, height: height)
|
|
}
|
|
}
|
|
|
|
// SwiftUI owns each window. Observe it rather than replacing its delegate or
|
|
// using global frame-autosave names, which would mix isolated test sessions.
|
|
struct RememberWindowPlacement: NSViewRepresentable {
|
|
let id: String
|
|
let placements: WindowPlacements
|
|
func makeCoordinator() -> Observer { Observer(id: id, placements: placements) }
|
|
func makeNSView(context: Context) -> Anchor {
|
|
let anchor = Anchor()
|
|
anchor.setAccessibilityElement(false)
|
|
anchor.attach = { [weak observer = context.coordinator] window in observer?.attach(window) }
|
|
return anchor
|
|
}
|
|
func updateNSView(_ view: Anchor, context: Context) {}
|
|
static func dismantleNSView(_ view: Anchor, coordinator: Observer) { coordinator.detach() }
|
|
final class Anchor: NSView {
|
|
var attach: ((NSWindow?) -> Void)?
|
|
override func viewDidMoveToWindow() {
|
|
super.viewDidMoveToWindow()
|
|
// Wait for SwiftUI's initial window/default-size layout.
|
|
DispatchQueue.main.async { [weak self] in self?.attach?(self?.window) }
|
|
}
|
|
}
|
|
@MainActor final class Observer {
|
|
let id: String
|
|
let placements: WindowPlacements
|
|
private weak var window: NSWindow?
|
|
private var tokens: [NSObjectProtocol] = []
|
|
private var restoring = false
|
|
private var fullScreenTransition = false
|
|
init(id: String, placements: WindowPlacements) { self.id = id; self.placements = placements }
|
|
deinit { for token in tokens { NotificationCenter.default.removeObserver(token) } }
|
|
private var screens: [CGRect] {
|
|
let ordered = [NSScreen.main].compactMap { $0 } + NSScreen.screens.filter { $0 !== NSScreen.main }
|
|
return ordered.map(\.visibleFrame)
|
|
}
|
|
func attach(_ window: NSWindow?) {
|
|
guard let window, self.window !== window else { return }
|
|
detach(); self.window = window
|
|
if let saved = placements.saved(id) { restore(saved) }
|
|
for name in [NSWindow.didMoveNotification, NSWindow.didResizeNotification,
|
|
NSWindow.didEndLiveResizeNotification, NSWindow.willCloseNotification] {
|
|
observe(name, object: window) { $0.save() }
|
|
}
|
|
observe(NSWindow.willEnterFullScreenNotification, object: window) {
|
|
$0.save(); $0.fullScreenTransition = true
|
|
}
|
|
observe(NSWindow.willExitFullScreenNotification, object: window) { $0.fullScreenTransition = true }
|
|
observe(NSWindow.didExitFullScreenNotification, object: window) {
|
|
$0.fullScreenTransition = false; $0.recoverScreen(); $0.save()
|
|
}
|
|
observe(NSApplication.didChangeScreenParametersNotification, object: nil) { $0.recoverScreen() }
|
|
}
|
|
private func observe(_ name: Notification.Name, object: Any?, action: @escaping (Observer) -> Void) {
|
|
tokens.append(NotificationCenter.default.addObserver(forName: name, object: object, queue: .main) { [weak self] _ in
|
|
guard let self else { return }; action(self)
|
|
})
|
|
}
|
|
func save() {
|
|
guard let window, !restoring, !fullScreenTransition, !window.styleMask.contains(.fullScreen), !window.isMiniaturized else { return }
|
|
placements.save(window.frame, id: id)
|
|
}
|
|
private func restore(_ frame: CGRect) {
|
|
guard let window else { return }
|
|
restoring = true
|
|
let minimum = window.frameRect(forContentRect: CGRect(origin: .zero, size: window.contentMinSize)).size
|
|
window.setFrame(WindowPlacements.reachable(frame, screens: screens, minimum: minimum), display: true)
|
|
restoring = false
|
|
}
|
|
private func recoverScreen() {
|
|
guard let window, window.isVisible, !fullScreenTransition, !window.styleMask.contains(.fullScreen) else { return }
|
|
restore(window.frame); save()
|
|
}
|
|
func detach() {
|
|
save()
|
|
for token in tokens { NotificationCenter.default.removeObserver(token) }
|
|
tokens.removeAll(); window = nil
|
|
}
|
|
}
|
|
}
|
|
|
|
extension View {
|
|
func rememberPlacement(_ id: String, in placements: WindowPlacements) -> some View {
|
|
background(RememberWindowPlacement(id: id, placements: placements).frame(width: 0, height: 0).accessibilityHidden(true))
|
|
}
|
|
}
|