Files

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))
}
}