import ParcelCore struct AppTabViewMinimized: Sendable { let window: ManagedWindow let frame: Rect let lastKnownWorkspace: WorkspaceKey? } struct AppTabViewLayout: Sendable { struct Card: Sendable { let window: ManagedWindow let frame: Rect let position: Int let total: Int let isMinimized: Bool } struct Display: Sendable { let id: DisplayID let frame: Rect let cards: [Card] } enum Failure: Error { case missingWindow(WindowID) case missingFrame(WindowID) case invalidFrame(WindowID) case duplicateWindow(WindowID) } private struct Group { let windows: [ManagedWindow] let frame: Rect } static func make( state: State, minimized: [AppTabViewMinimized], classifier: WindowClassifier = WindowClassifier() ) throws -> [Display] { var seen: Set = [] var result: [Display] = [] for display in state.displays.values.sorted(by: { $0.id < $1.id }) where display.hasUsableGeometry { let frame = display.fullFrame let workspace = state.activeSpaces[display.id].flatMap { state.workspaces[WorkspaceKey(display: display.id, space: $0)] } var groups: [Group] = [] for stack in workspace?.tree?.stacks ?? [] { let windows = try stack.windows.map { id in guard let window = state.windows[id] else { throw Failure.missingWindow(id) } guard seen.insert(id).inserted else { throw Failure.duplicateWindow(id) } return window } guard let tile = state.frames[stack.visible] ?? state.observedFrames[stack.visible] else { throw Failure.missingFrame(stack.visible) } groups.append(Group(windows: windows, frame: tile)) } var floating: [(window: ManagedWindow, frame: Rect)] = [] for id in workspace?.order ?? [] where state.windows[id]?.isFloating == true { guard let window = state.windows[id] else { throw Failure.missingWindow(id) } guard seen.insert(id).inserted else { throw Failure.duplicateWindow(id) } guard let tile = state.observedFrames[id] ?? state.frames[id] else { throw Failure.missingFrame(id) } guard valid(tile) else { throw Failure.invalidFrame(id) } floating.append((window, tile)) } floating.sort { let left = $0.frame.center let right = $1.frame.center if left.xCoordinate != right.xCoordinate { return left.xCoordinate < right.xCoordinate } if left.yCoordinate != right.yCoordinate { return left.yCoordinate < right.yCoordinate } return $0.window.id < $1.window.id } let fallbackDisplay = state.activeDisplay.flatMap { state.displays[$0]?.hasUsableGeometry == true ? $0 : nil } ?? state.displays.values.filter(\.hasUsableGeometry).map(\.id).sorted().first let minimizedHere = minimized.filter { item in let window = item.window var facts = window.facts ?? WindowFacts( bundleID: window.app.bundleID, role: window.role, subrole: window.subrole, title: window.title) facts.isMinimized = false guard classifier.classify(facts).disposition != .ignore else { return false } if let workspace = item.lastKnownWorkspace, state.displays[workspace.display] != nil { return workspace.display == display.id && state.isActive(workspace) } let nearest = nearestDisplay(to: item.frame, displays: state.displays.values.map { $0 }) return (nearest ?? fallbackDisplay) == display.id }.sorted { $0.window.id < $1.window.id } let margin = min(frame.size.width, frame.size.height) * 0.08 let floatingHeight = floating.isEmpty ? 0 : min(88, frame.size.height * 0.12) let rowHeight = minimizedHere.isEmpty ? 0 : min(100, frame.size.height * 0.14) let usable = Rect( x: frame.minX + margin, y: frame.minY + margin, width: frame.size.width - margin * 2, height: frame.size.height - margin * 2 - floatingHeight - rowHeight) let scale = min(usable.size.width / frame.size.width, usable.size.height / frame.size.height) let originX = usable.minX + (usable.size.width - frame.size.width * scale) / 2 let originY = usable.minY + (usable.size.height - frame.size.height * scale) / 2 var cards: [Card] = [] for (index, group) in groups.enumerated() { guard valid(group.frame) else { throw Failure.invalidFrame(group.windows[0].id) } let mapped = Rect( x: originX + (group.frame.minX - frame.minX) * scale, y: originY + (group.frame.minY - frame.minY) * scale, width: group.frame.size.width * scale, height: group.frame.size.height * scale) let cardHeight = mapped.size.height / Double(group.windows.count) for (offset, window) in group.windows.enumerated() { let padding = min(4, mapped.size.width / 4, cardHeight / 4) cards.append( Card( window: window, frame: Rect( x: mapped.minX + padding, y: mapped.minY + Double(offset) * cardHeight + padding, width: mapped.size.width - padding * 2, height: cardHeight - padding * 2), position: index + 1, total: groups.count, isMinimized: false)) } } if !floating.isEmpty { let width = usable.size.width / Double(floating.count) for (index, item) in floating.enumerated() { let padding = min(4, width / 4, floatingHeight / 4) cards.append( Card( window: item.window, frame: Rect( x: usable.minX + Double(index) * width + padding, y: usable.maxY + padding, width: width - padding * 2, height: floatingHeight - padding * 2), position: index + 1, total: floating.count, isMinimized: false)) } } if !minimizedHere.isEmpty { let width = usable.size.width / Double(minimizedHere.count) for (index, item) in minimizedHere.enumerated() { guard seen.insert(item.window.id).inserted else { throw Failure.duplicateWindow(item.window.id) } let padding = min(4, width / 4, rowHeight / 4) cards.append( Card( window: item.window, frame: Rect( x: usable.minX + Double(index) * width + padding, y: usable.maxY + floatingHeight + padding, width: width - padding * 2, height: rowHeight - padding * 2), position: index + 1, total: minimizedHere.count, isMinimized: true)) } } let geometry = try TabViewCardGeometry(frames: cards.map(\.frame), viewport: frame) let arranged = zip(cards, geometry.frames).map { card, frame in Card( window: card.window, frame: frame, position: card.position, total: card.total, isMinimized: card.isMinimized) } result.append(Display(id: display.id, frame: frame, cards: arranged)) } return result } private static func valid(_ frame: Rect) -> Bool { frame.isValid && frame.size.width > 0 && frame.size.height > 0 && frame.maxX.isFinite && frame.maxY.isFinite } private static func nearestDisplay(to frame: Rect, displays: [ParcelCore.Display]) -> DisplayID? { guard valid(frame) else { return nil } return displays.filter(\.hasUsableGeometry).sorted { $0.id < $1.id }.max { lhs, rhs in intersection(frame, lhs.fullFrame) < intersection(frame, rhs.fullFrame) }.flatMap { intersection(frame, $0.fullFrame) > 0 ? $0.id : nil } } private static func intersection(_ lhs: Rect, _ rhs: Rect) -> Double { max(0, min(lhs.maxX, rhs.maxX) - max(lhs.minX, rhs.minX)) * max(0, min(lhs.maxY, rhs.maxY) - max(lhs.minY, rhs.minY)) } }