public import Foundation public import ParcelConfig public import ParcelCore public struct LayoutTile: Equatable, Sendable, Identifiable { public let id: UInt64 public let frame: CGRect public let isFocused: Bool public let application: MenuApplicationIdentity? public init(id: UInt64, frame: CGRect, isFocused: Bool = false, application: MenuApplicationIdentity? = nil) { precondition(frame.isFiniteAndPositive) self.id = id self.frame = frame self.isFocused = isFocused self.application = application } } public struct LayoutSnapshot: Equatable, Sendable { public let layout: ConfigLayout public let bounds: CGRect public let capabilityBounds: CGRect public let tiles: [LayoutTile] public let isAutomaticTilingEnabled: Bool public let windowCap: Int? public let ratio: Double public let mainSizeRatio: Double public let isFocused: Bool public let noPeek: Bool public let cleanSpace: Bool public let hoverFocus: Bool? public let arrangementStatus: String? public let isWaitingForSetup: Bool public let hasCustomSizes: Bool public let primaryWindow: UInt64? public let primaryExpandsTile: Bool public init( layout: ConfigLayout, bounds: CGRect, tiles: [LayoutTile], isAutomaticTilingEnabled: Bool = true, windowCap: Int? = nil, ratio: Double = 0.5, capabilityBounds: CGRect? = nil, isFocused: Bool = false, noPeek: Bool = false, cleanSpace: Bool = false, hoverFocus: Bool? = nil, arrangementStatus: String? = nil, isWaitingForSetup: Bool = false, mainSizeRatio: Double? = nil, hasCustomSizes: Bool = false, primaryWindow: UInt64? = nil, primaryExpandsTile: Bool = false ) { precondition(bounds.isFiniteAndPositive) precondition((capabilityBounds ?? bounds).isFiniteAndPositive) precondition(Set(tiles.map(\.id)).count == tiles.count) precondition(windowCap.map { $0 == Int.max || Workspace.windowCapBounds.contains($0) } != false) precondition(MainRatio.bounds.contains(ratio)) precondition((0...1).contains(mainSizeRatio ?? ratio)) self.layout = layout self.bounds = bounds self.capabilityBounds = capabilityBounds ?? bounds self.tiles = tiles self.isAutomaticTilingEnabled = isAutomaticTilingEnabled self.windowCap = windowCap self.ratio = ratio self.mainSizeRatio = mainSizeRatio ?? ratio self.isFocused = isFocused self.noPeek = noPeek self.cleanSpace = cleanSpace self.hoverFocus = hoverFocus self.arrangementStatus = arrangementStatus self.isWaitingForSetup = isWaitingForSetup self.hasCustomSizes = hasCustomSizes self.primaryWindow = primaryWindow self.primaryExpandsTile = primaryExpandsTile } var hasNoWindowLimit: Bool { windowCap == 0 || windowCap == Int.max } var effectiveWindowCap: Int? { guard let windowCap else { return nil } return layout.capabilities(in: capabilityBounds).effectiveWindowCap(for: windowCap) } public var accessibilityDescription: String { if isWaitingForSetup { return MenuText.text("Setup incomplete") } if let arrangementStatus { return arrangementStatus } guard isAutomaticTilingEnabled else { return MenuText.text("Automatic tiling is off") } return String( format: MenuText.text("Tiling %lld windows ยท %@"), locale: .current, Int64(tiles.count), layout.uiTitle) } } @MainActor public protocol LayoutSnapshotProviding: AnyObject { /// Includes the current snapshot, then yields only changes. func snapshots() -> AsyncStream } public enum PermissionStatus: Equatable, Sendable { case checking, missing, granted } @MainActor public protocol PermissionStatusProviding: AnyObject { func permissionUpdates() -> AsyncStream func refreshPermission() async func openAccessibilitySettings() throws } @MainActor public protocol UICommandSink: AnyObject { func send(_ command: ConfigCommand) async throws } @MainActor public protocol UIWorkspaceCommandSink: UICommandSink { func send(_ command: ConfigCommand, in workspace: WorkspaceKey) async throws } @MainActor final class LatestValues { private var value: Value private var continuations: [UUID: AsyncStream.Continuation] = [:] init(_ value: Value) { self.value = value } func stream() -> AsyncStream { let id = UUID() let (stream, continuation) = AsyncStream.makeStream(bufferingPolicy: .bufferingNewest(1)) continuations[id] = continuation continuation.yield(value) continuation.onTermination = { [weak self] _ in Task { @MainActor in self?.continuations.removeValue(forKey: id) } } return stream } func yield(_ value: Value) { self.value = value for continuation in continuations.values { continuation.yield(value) } } deinit { for continuation in continuations.values { continuation.finish() } } } @MainActor public final class PreviewShellServices: LayoutSnapshotProviding, PermissionStatusProviding, UICommandSink { private let layouts: LatestValues private let permissions: LatestValues private var snapshot: LayoutSnapshot public private(set) var commands: [ConfigCommand] = [] public private(set) var settingsOpenCount = 0 public private(set) var refreshCount = 0 public init(snapshot: LayoutSnapshot = .preview, permission: PermissionStatus = .missing) { self.snapshot = snapshot layouts = LatestValues(snapshot) permissions = LatestValues(permission) } public func snapshots() -> AsyncStream { layouts.stream() } public func permissionUpdates() -> AsyncStream { permissions.stream() } public func refreshPermission() async { refreshCount += 1 } public func openAccessibilitySettings() throws { settingsOpenCount += 1 } public func send(_ command: ConfigCommand) async throws { commands.append(command) if command == .toggleAutomaticTiling { publish( LayoutSnapshot( layout: snapshot.layout, bounds: snapshot.bounds, tiles: snapshot.tiles, isAutomaticTilingEnabled: !snapshot.isAutomaticTilingEnabled, windowCap: snapshot.windowCap, ratio: snapshot.ratio, capabilityBounds: snapshot.capabilityBounds, isFocused: snapshot.isFocused, noPeek: snapshot.noPeek, cleanSpace: snapshot.cleanSpace, hoverFocus: snapshot.hoverFocus, arrangementStatus: snapshot.arrangementStatus, isWaitingForSetup: snapshot.isWaitingForSetup, mainSizeRatio: snapshot.mainSizeRatio, hasCustomSizes: snapshot.hasCustomSizes, primaryWindow: snapshot.primaryWindow, primaryExpandsTile: snapshot.primaryExpandsTile)) } else if let layout = ConfigLayout.allCases.first(where: { $0.command == command }) { let count = snapshot.tiles.count let tiles = snapshot.tiles.enumerated().map { index, tile in let width = snapshot.bounds.width let height = snapshot.bounds.height let frame: CGRect switch layout { case .accordion: let focused = snapshot.tiles.firstIndex(where: \.isFocused) ?? 0 let focusedWeight = Double(count) * 4 let total = focusedWeight + Double(count - 1) let weight = index == focused ? focusedWeight : 1 let preceding = Double(index) + (index > focused ? focusedWeight - 1 : 0) frame = CGRect(x: width * preceding / total, y: 0, width: width * weight / total, height: height) case .columns: frame = CGRect( x: Double(index) * width / Double(count), y: 0, width: width / Double(count), height: height) case .rows: frame = CGRect( x: 0, y: Double(index) * height / Double(count), width: width, height: height / Double(count)) case .side: if index == 0 { frame = CGRect(x: 0, y: 0, width: count == 1 ? width : width / 2, height: height) } else { frame = CGRect( x: width / 2, y: Double(index - 1) * height / Double(count - 1), width: width / 2, height: height / Double(count - 1)) } case .grid, .tree, .bsp: let columns = Int(Double(count).squareRoot().rounded(.up)) let rows = (count + columns - 1) / columns frame = CGRect( x: Double(index % columns) * width / Double(columns), y: Double(index / columns) * height / Double(rows), width: width / Double(columns), height: height / Double(rows)) } return LayoutTile( id: tile.id, frame: frame.offsetBy(dx: snapshot.bounds.minX, dy: snapshot.bounds.minY), isFocused: tile.isFocused, application: tile.application ) } publish( LayoutSnapshot( layout: layout, bounds: snapshot.bounds, tiles: tiles, isAutomaticTilingEnabled: snapshot.isAutomaticTilingEnabled, windowCap: snapshot.windowCap, ratio: snapshot.ratio, capabilityBounds: snapshot.capabilityBounds, isFocused: snapshot.isFocused, noPeek: snapshot.noPeek, cleanSpace: snapshot.cleanSpace, hoverFocus: snapshot.hoverFocus, arrangementStatus: snapshot.arrangementStatus, isWaitingForSetup: snapshot.isWaitingForSetup, mainSizeRatio: snapshot.mainSizeRatio, hasCustomSizes: snapshot.hasCustomSizes, primaryWindow: snapshot.primaryWindow, primaryExpandsTile: snapshot.primaryExpandsTile)) } } public func publish(_ snapshot: LayoutSnapshot) { guard self.snapshot != snapshot else { return } self.snapshot = snapshot layouts.yield(snapshot) } public func publish(permission: PermissionStatus) { permissions.yield(permission) } } extension LayoutSnapshot { public static let preview = LayoutSnapshot( layout: .side, bounds: CGRect(x: 0, y: 0, width: 1000, height: 700), tiles: [ LayoutTile(id: 1, frame: CGRect(x: 0, y: 0, width: 550, height: 700), isFocused: true), LayoutTile(id: 2, frame: CGRect(x: 550, y: 0, width: 450, height: 350)), LayoutTile(id: 3, frame: CGRect(x: 550, y: 350, width: 450, height: 350)), ], windowCap: 3 ) } extension CGRect { var isFiniteAndPositive: Bool { origin.x.isFinite && origin.y.isFinite && width.isFinite && height.isFinite && maxX.isFinite && maxY.isFinite && width > 0 && height > 0 } } extension ConfigLayout { func capabilities(in bounds: CGRect) -> LayoutCapabilities { let layout: Layout switch self { case .grid: layout = .grid case .columns: layout = .columns case .rows: layout = .rows case .side: layout = .side case .tree: layout = .tree case .bsp: layout = .bsp case .accordion: layout = .accordion } return layout.capabilities(in: Rect(width: bounds.width, height: bounds.height)) } var uiTitle: String { switch self { case .grid: UIStrings.text("Grid") case .columns: UIStrings.text("Columns") case .rows: UIStrings.text("Rows") case .side: UIStrings.text("Side") case .tree: UIStrings.text("Tree") case .bsp: UIStrings.text("BSP") case .accordion: UIStrings.text("Accordion") } } var command: ConfigCommand { switch self { case .grid: .layoutGrid case .columns: .layoutColumns case .rows: .layoutRows case .side: .layoutSide case .tree: .layoutTree case .bsp: .layoutBSP case .accordion: .layoutAccordion } } } enum UIStrings { static func text(_ key: String) -> String { Bundle.module.localizedString(forKey: key, value: nil, table: "UI") } }