import Foundation import ParcelCore import ParcelPlatform import Synchronization final class NativeNewWindowTargets: Sendable { private struct Slots { var frames: [WorkspaceKey: Rect] = [:] var displays: [DisplayID: Rect] = [:] var spaces: [DisplayID: SpaceID] = [:] var classifier: WindowClassifier? var placement: State? var consumed: [WorkspaceKey: WindowID] = [:] } private let slots = Mutex(Slots()) func clear() { slots.withLock { slots in let consumed = slots.consumed slots = Slots() slots.consumed = consumed } } func reset() { slots.withLock { $0 = Slots() } } func forget(_ window: WindowID) { slots.withLock { $0.consumed = $0.consumed.filter { $0.value != window } $0.placement = nil } } func update(_ state: State, classifier: WindowClassifier?, enabled: Bool) { guard enabled, let classifier else { clear(); return } let unchanged = slots.withLock { slots in slots.classifier = classifier slots.consumed = slots.consumed.filter { state.windows[$0.value] == nil } guard let previous = slots.placement else { return false } return previous.windows == state.windows && previous.workspaces == state.workspaces && previous.displays == state.displays && previous.activeSpaces == state.activeSpaces && previous.focusModes == state.focusModes && previous.layoutDefaults == state.layoutDefaults && previous.displayLayoutDefaults == state.displayLayoutDefaults } guard !unchanged else { return } let placeholder = WindowID(rawValue: UInt32.max) guard state.windows[placeholder] == nil else { clear(); return } let window = ManagedWindow(id: placeholder, app: AppID(pid: 0, bundleID: "")) var frames: [WorkspaceKey: Rect] = [:] for (display, space) in state.activeSpaces { let key = WorkspaceKey(display: display, space: space) guard let screen = state.displays[display] else { continue } let (next, _) = reduce(state, .windowAppeared(window, workspace: key, frame: screen.frame)) if next.visibleWindows.contains(placeholder), let target = next.frames[placeholder] { frames[key] = target } } slots.withLock { slots in slots.frames = frames.filter { slots.consumed[$0.key] == nil } slots.displays = state.displays.mapValues(\.frame) slots.spaces = state.activeSpaces slots.classifier = classifier slots.placement = state } } func take(_ created: AppThreadCreatedWindow) -> CGRect? { slots.withLock { slots in guard created.isOnScreen, let classifier = slots.classifier, created.facts.role == "AXWindow", created.facts.isResizable == true, created.facts.hasNativeTabs != true, created.facts.nativeTabGroup == nil, created.frame.width > 100, created.frame.height > 100 else { return nil } let classification = classifier.classify(created.facts) guard classification.disposition == .tile, classification.display == nil, classification.position == nil, classification.layout == nil, classification.space == nil, let display = slots.displays.keys.sorted().max(by: { Self.intersection(slots.displays[$0], created.frame) < Self.intersection(slots.displays[$1], created.frame) }), Self.intersection(slots.displays[display], created.frame) > 0, let space = slots.spaces[display] else { return nil } let key = WorkspaceKey(display: display, space: space) guard let target = slots.frames[key] else { return nil } if let minimum = created.facts.minimumSize, minimum.width > target.size.width || minimum.height > target.size.height { return nil } slots.frames[key] = nil slots.consumed[key] = WindowID(rawValue: created.windowID) return target.cgRect } } private static func intersection(_ screen: Rect?, _ frame: CGRect) -> Double { guard let screen else { return 0 } return max(0, min(screen.maxX, frame.maxX) - max(screen.minX, frame.minX)) * max(0, min(screen.maxY, frame.maxY) - max(screen.minY, frame.minY)) } }