Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666import CryptoKitpublic import Foundation
public enum WorkspaceMemoryError: Error, Sendable, Equatable { case duplicateWorkspace(WorkspaceKey) case duplicateWindowToken(WindowID) case invalidWorkspace(WorkspaceKey) case invalidWindow(WindowID) case invalidTitleSalt case invalidTimestamp case invalidPruningPolicy case windowTokensExhausted}
public struct WorkspaceMemory: Sendable, Equatable, Codable { public struct SavedWindow: Sendable, Equatable, Codable { public let token: WindowID public let bundleID: String public let titleDigest: String? public let role: String public let subrole: String? public let display: DisplayID public let isFloating: Bool public let normalizedFloatingFrame: Rect?
public init( token: WindowID, bundleID: String, titleDigest: String?, role: String = "AXWindow", subrole: String? = nil, display: DisplayID, isFloating: Bool = false, normalizedFloatingFrame: Rect? = nil ) { self.token = token self.bundleID = bundleID self.titleDigest = titleDigest self.role = role self.subrole = subrole self.display = display self.isFloating = isFloating self.normalizedFloatingFrame = normalizedFloatingFrame }
fileprivate func retokened(_ token: WindowID) -> SavedWindow { SavedWindow( token: token, bundleID: bundleID, titleDigest: titleDigest, role: role, subrole: subrole, display: display, isFloating: isFloating, normalizedFloatingFrame: normalizedFloatingFrame) } }
public struct Record: Sendable, Equatable, Codable { public let workspace: Workspace public let windows: [SavedWindow] public let lastSeen: TimeInterval
public init(workspace: Workspace, windows: [SavedWindow] = [], lastSeen: TimeInterval = 0) { self.workspace = workspace self.windows = windows self.lastSeen = lastSeen }
public func retainingApplications(_ bundleIDs: Set<String>) -> Record { let retained = windows.filter { bundleIDs.contains($0.bundleID) } var mapping: [WindowID: WindowID] = [:] for window in retained { mapping[window.token] = window.token } return Record(workspace: workspace.memoryRemapping(mapping), windows: retained, lastSeen: lastSeen) }
private enum CodingKeys: String, CodingKey { case workspace, windows, lastSeen } private struct RatioCheck: Decodable { let key: WorkspaceKey let ratio: Double let configuredRatio: Double? }
public init(from decoder: any Decoder) throws { let container = try decoder.container(keyedBy: CodingKeys.self) let check = try container.decode(RatioCheck.self, forKey: .workspace) guard check.ratio.isFinite, MainRatio.bounds.contains(check.ratio), check.configuredRatio.map({ $0.isFinite && MainRatio.bounds.contains($0) }) != false else { throw WorkspaceMemoryError.invalidWorkspace(check.key) } var workspace = try container.decode(Workspace.self, forKey: .workspace) workspace.restoreAutomaticTiles() self.workspace = workspace windows = try container.decode([SavedWindow].self, forKey: .windows) lastSeen = try container.decode(TimeInterval.self, forKey: .lastSeen) }
public func mergingMissingWindows( from previous: Record, tokens: Set<WindowID>, maximumCount: Int = 128 ) throws -> Record { guard maximumCount >= 0 else { throw WorkspaceMemoryError.invalidPruningPolicy } guard workspace.key == previous.workspace.key else { throw WorkspaceMemoryError.invalidWorkspace(previous.workspace.key) } let members = Set(workspace.order) let missing = previous.windows.filter { tokens.contains($0.token) && !members.contains($0.token) } guard missing.count <= maximumCount else { throw WorkspaceMemoryError.invalidWorkspace(workspace.key) } guard !missing.isEmpty else { return self } guard Set(missing.map(\.token)).count == missing.count else { throw WorkspaceMemoryError.invalidWorkspace(previous.workspace.key) } let focus = workspace.focus let savedByToken = Dictionary(uniqueKeysWithValues: missing.map { ($0.token, $0) }) func merging(into source: Workspace, from savedTree: TileTree?) -> Workspace { var merged = source for token in previous.workspace.order { guard let window = savedByToken[token] else { continue } let next = previous.workspace.order.drop { $0 != token }.dropFirst().first { merged.order.contains($0) } let position = next.flatMap { merged.order.firstIndex(of: $0) } let savedStack = savedTree?.stacks.first { $0.windows.contains(token) } let anchor = savedStack?.windows.first { merged.tree?.windows.contains($0) == true } if !window.isFloating, let anchor, let tree = merged.tree { merged.insert(token, floating: true, in: nil, windows: [:], position: position) merged.tree = tree.mappingStacks { stack in guard stack.windows.contains(anchor) else { return stack } var updated = stack updated.append(token) return updated } } else { merged.insert(token, floating: window.isFloating, in: nil, windows: [:], position: position) } if savedStack?.isUserMade == true { merged.tree = merged.tree?.mappingStacks { stack in guard stack.windows.contains(token) else { return stack } var marked = stack marked.isUserMade = true return marked } } } if let focus { merged.select(focus) } else { merged.focus = nil } return merged } var expanded = workspace expanded.restoreAdaptiveTiles() expanded.displaySize = nil expanded.capabilitySize = nil expanded.setWindowCap(Int.max) expanded = merging( into: expanded, from: previous.workspace.adaptiveTileMemory?.original ?? previous.workspace.tree) var merged = workspace merged.adaptiveTileMemory = nil merged = merging(into: merged, from: previous.workspace.tree) // Projection stacks must not erase a missing window's separate expandable slot. if let original = expanded.tree, let projection = merged.tree, original.tileCount > projection.tileCount { merged.adaptiveTileMemory = AdaptiveTileMemory(original: original, projection: projection) } merged.pendingSplitAxis = workspace.pendingSplitAxis return Record(workspace: merged, windows: windows + missing, lastSeen: lastSeen) } }
public let records: [Record] public let titleSalt: Data
public init(titleSalt: Data = Data()) { records = [] self.titleSalt = titleSalt }
public init(records: [Record], titleSalt: Data) throws { self.records = records.sorted { $0.workspace.key < $1.workspace.key } self.titleSalt = titleSalt try validate() }
private enum CodingKeys: String, CodingKey { case records, titleSalt }
public init(from decoder: any Decoder) throws { let container = try decoder.container(keyedBy: CodingKeys.self) try self.init( records: container.decode([Record].self, forKey: .records), titleSalt: container.decode(Data.self, forKey: .titleSalt)) }
public func titleDigest(for title: String) throws -> String? { guard titleSalt.count == 32 else { throw WorkspaceMemoryError.invalidTitleSalt } return Self.digest(title, salt: titleSalt) }
public func pruned( asOf now: TimeInterval, maximumAge: TimeInterval = 30 * 24 * 60 * 60, maximumCount: Int = 128 ) throws -> WorkspaceMemory { guard now.isFinite, now >= 0 else { throw WorkspaceMemoryError.invalidTimestamp } guard maximumAge.isFinite, maximumAge >= 0, maximumCount >= 0 else { throw WorkspaceMemoryError.invalidPruningPolicy } let retained = records.filter { now - $0.lastSeen <= maximumAge }.sorted { if $0.lastSeen != $1.lastSeen { return $0.lastSeen > $1.lastSeen } return $0.workspace.key < $1.workspace.key } return try WorkspaceMemory(records: Array(retained.prefix(maximumCount)), titleSalt: titleSalt) }
public func validate() throws { guard titleSalt.count == 32 || (titleSalt.isEmpty && records.allSatisfy({ $0.windows.isEmpty })) else { throw WorkspaceMemoryError.invalidTitleSalt } var keys: Set<WorkspaceKey> = [] var tokens: Set<WindowID> = [] for record in records { guard record.lastSeen.isFinite, record.lastSeen >= 0 else { throw WorkspaceMemoryError.invalidTimestamp } let workspace = record.workspace let key = workspace.key guard keys.insert(key).inserted else { throw WorkspaceMemoryError.duplicateWorkspace(key) } let members = Set(workspace.order) guard !key.display.rawValue.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty, key.space.rawValue > 0, workspace.windowCap > 0, workspace.ratio.value.isFinite, MainRatio.bounds.contains(workspace.ratio.value), Self.validLength(workspace.gaps.inner), Self.validInsets(workspace.gaps.outer), Self.validInsets(workspace.reservedEdges), members.count == workspace.order.count, Set(workspace.openingOrder) == members, workspace.openingOrder.count == members.count, workspace.focus.map(members.contains) != false, workspace.displaySize.map(Self.validSize) != false, workspace.capabilitySize.map(Self.validSize) != false, (workspace.capabilitySize ?? workspace.displaySize).map({ workspace.layout.capabilities(in: Rect(origin: Point(), size: $0)).variant == workspace.layoutVariant }) != false, Self.validTree(workspace.tree, members: members, cap: workspace.effectiveWindowCap), Self.validTree(workspace.alternateSideTree, members: members, cap: Int.max), workspace.adaptiveTileMemory.map({ memory in Self.validTree(memory.original, members: members, cap: Int.max) && Self.validTree(memory.projection, members: members, cap: workspace.effectiveWindowCap) && Set(memory.original.windows) == Set(workspace.tree?.windows ?? []) && Set(memory.projection.windows) == Set(workspace.tree?.windows ?? []) }) != false, record.windows.count == members.count, Set(record.windows.map(\.token)) == members else { throw WorkspaceMemoryError.invalidWorkspace(key) } var tiled: Set<WindowID> = [] for window in record.windows { guard tokens.insert(window.token).inserted else { throw WorkspaceMemoryError.duplicateWindowToken(window.token) } guard window.token.rawValue > 0, window.display == key.display, !window.bundleID.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty, window.titleDigest.map(Self.validTitleDigest) != false, !window.role.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty, window.subrole.map({ !$0.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }) != false, window.normalizedFloatingFrame.map(Self.validNormalizedFrame) != false, window.isFloating || window.normalizedFloatingFrame == nil else { throw WorkspaceMemoryError.invalidWindow(window.token) } if !window.isFloating { tiled.insert(window.token) } } guard Set(workspace.tree?.windows ?? []) == tiled else { throw WorkspaceMemoryError.invalidWorkspace(key) } } }
/// Refreshes observed workspaces; absent records survive only within the age and count limits. public static func capture( _ state: State, preserving existing: WorkspaceMemory = WorkspaceMemory(), now: TimeInterval = 0, titleSalt: Data? = nil, pinned: [WindowID: WindowID] = [:], candidates: Set<WindowID>? = nil, preservingMissing: Set<WindowID> = [], maximumCount: Int = 128 ) throws -> WorkspaceMemory { try existing.validate() guard now.isFinite, now >= 0 else { throw WorkspaceMemoryError.invalidTimestamp } let salt = titleSalt ?? existing.titleSalt guard existing.records.allSatisfy({ $0.windows.isEmpty }) || salt == existing.titleSalt else { throw WorkspaceMemoryError.invalidTitleSalt } let digester = WorkspaceMemory(titleSalt: salt) try digester.validate() var records = Dictionary(uniqueKeysWithValues: existing.records.map { ($0.workspace.key, $0) }) let previousMapping = existing.windowMapping(in: state, pinned: pinned, candidates: candidates) var previousTokens: [WindowID: WindowID] = [:] for (token, id) in previousMapping { guard previousTokens.updateValue(token, forKey: id) == nil else { throw WorkspaceMemoryError.invalidWindow(id) } } var used = Set(existing.records.flatMap { $0.windows.map(\.token) }) var nextToken: UInt32 = 1 var capturedLive: Set<WindowID> = [] for key in state.workspaces.keys.sorted() where state.displays[key.display] != nil { guard let workspace = state.workspaces[key], let screen = state.displays[key.display]?.frame else { continue } if !state.isActive(key), workspace.order.isEmpty, records[key] != nil { continue } guard workspace.key == key else { throw WorkspaceMemoryError.invalidWorkspace(key) } var mapping: [WindowID: WindowID] = [:] var liveWindows: [SavedWindow] = [] var savedWindows: [SavedWindow] = [] for id in workspace.order { guard let window = state.windows[id], window.id == id, capturedLive.insert(id).inserted else { throw WorkspaceMemoryError.invalidWindow(id) } let token: WindowID if let previous = previousTokens[id] { token = previous } else { while used.contains(WindowID(rawValue: nextToken)) { guard nextToken < UInt32.max else { throw WorkspaceMemoryError.windowTokensExhausted } nextToken += 1 } token = WindowID(rawValue: nextToken) used.insert(token) } mapping[id] = token let frame = window.isFloating ? (state.frames[id] ?? state.observedFrames[id]) : nil if let frame, !frame.isValid { throw WorkspaceMemoryError.invalidWindow(id) } let digest = try digester.titleDigest(for: window.title) let liveWindow = SavedWindow( token: id, bundleID: window.app.bundleID, titleDigest: digest, role: window.role, subrole: window.subrole, display: key.display, isFloating: window.isFloating, normalizedFloatingFrame: frame.flatMap { Self.normalize($0, in: screen) }) liveWindows.append(liveWindow) savedWindows.append(liveWindow.retokened(token)) } _ = try WorkspaceMemory( records: [Record(workspace: workspace, windows: liveWindows, lastSeen: now)], titleSalt: salt) var record = Record( workspace: workspace.memoryRemapping(mapping), windows: savedWindows, lastSeen: now) if let previous = records[key] { record = try record.mergingMissingWindows(from: previous, tokens: preservingMissing) } records[key] = record } return try WorkspaceMemory(records: Array(records.values), titleSalt: salt) .pruned(asOf: now, maximumCount: maximumCount) }
/// Tokens are not live IDs. Only active cross-display matching may span displays' distinct active Spaces. public func windowMapping( in state: State, pinned: [WindowID: WindowID] = [:], candidates: Set<WindowID>? = nil, acrossDisplays: Bool = false, activeOnly: Bool = false ) -> [WindowID: WindowID] { var savedGroups: [Identity: [SavedWindow]] = [:] var liveGroups: [Identity: [ManagedWindow]] = [:] var result: [WindowID: WindowID] = [:] var assigned: Set<WindowID> = [] var eligibleTokens: Set<WindowID> = [] let reserved = Set(pinned.values) for record in records { let key = record.workspace.key let eligible = state.displays[key.display] != nil && (!activeOnly || (state.isActive(key) && state.displays[key.display]?.hasUsableGeometry == true)) guard eligible || acrossDisplays else { continue } for window in record.windows { if eligible { eligibleTokens.insert(window.token) } let identity = Identity(window, key: key, acrossDisplays: acrossDisplays, activeOnly: activeOnly) if let id = pinned[window.token] { if eligible, let live = state.windows[id], let source = state.workspace(containing: id), (!activeOnly || (state.isActive(source) && state.displays[source.display]?.hasUsableGeometry == true)), Identity(live, key: source, acrossDisplays: acrossDisplays, activeOnly: activeOnly) == identity, assigned.insert(id).inserted { result[window.token] = id } continue } savedGroups[identity, default: []].append(window) } } for key in state.workspaces.keys.sorted() where state.displays[key.display] != nil { guard !activeOnly || (state.isActive(key) && state.displays[key.display]?.hasUsableGeometry == true) else { continue } for id in state.workspaces[key]?.order ?? [] where !reserved.contains(id) { guard let window = state.windows[id] else { continue } liveGroups[ Identity(window, key: key, acrossDisplays: acrossDisplays, activeOnly: activeOnly), default: [] ].append(window) } } for (identity, saved) in savedGroups { let live = liveGroups[identity] ?? [] let savedTitles = Dictionary(grouping: saved, by: \.titleDigest) let liveTitles = Dictionary(grouping: live, by: { Self.digest($0.title, salt: titleSalt) }) for (title, windows) in savedTitles where title != nil && windows.count == 1 { guard eligibleTokens.contains(windows[0].token), let matches = liveTitles[title], matches.count == 1, candidates?.contains(matches[0].id) != false else { continue } result[windows[0].token] = matches[0].id } // Candidate filtering must not make an ambiguous identity appear one-to-one. if saved.count == 1, live.count == 1, eligibleTokens.contains(saved[0].token), saved[0].titleDigest != nil, Self.digest(live[0].title, salt: titleSalt) != nil, candidates?.contains(live[0].id) != false { result[saved[0].token] = live[0].id } } return result }
/// The caller owns restoration lifetime; pinned tokens cannot be reassigned as titles change. public func restoring( _ state: State, restoreWindows: Bool = true, pinned: [WindowID: WindowID] = [:], candidates: Set<WindowID>? = nil, mapping supplied: [WindowID: WindowID]? = nil, restoringTiling: Bool = false, activeOnly: Bool = false ) -> State { var result = state let mapping = restoreWindows ? (supplied ?? windowMapping(in: state, pinned: pinned, candidates: candidates, activeOnly: activeOnly)) : [:] if supplied != nil { var verified: Set<WindowID> = [] var knownTokens: Set<WindowID> = [] for record in records { let key = record.workspace.key for saved in record.windows { knownTokens.insert(saved.token) guard let id = mapping[saved.token] else { continue } let live = state.windows[id] let source = state.workspace(containing: id) let permittedSource = source.map { source in state.displays[source.display] != nil && (!activeOnly || (state.isActive(source) && state.isActive(key) && state.displays[source.display]?.hasUsableGeometry == true && state.displays[key.display]?.hasUsableGeometry == true)) && (source.space == key.space || (restoringTiling && activeOnly)) } == true precondition( verified.insert(id).inserted && state.displays[key.display] != nil && permittedSource && live?.app.bundleID == saved.bundleID && live?.role == saved.role && live?.subrole == saved.subrole && (restoringTiling || source == key), "Supplied memory matches require unique identities on recorded or active display Spaces") } } precondition( Set(mapping.keys).isSubset(of: knownTokens), "Supplied memory tokens must belong to the snapshot") } if restoringTiling { for record in records { let destination = record.workspace.key guard state.displays[destination.display] != nil, !activeOnly || state.isActive(destination) else { continue } for saved in record.windows { guard let id = mapping[saved.token], let live = state.windows[id], let source = state.workspace(containing: id), source.space == destination.space || (activeOnly && state.isActive(source) && state.isActive(destination)), live.app.bundleID == saved.bundleID, live.role == saved.role, live.subrole == saved.subrole else { continue } if source != destination { result.workspaces[source]?.remove(id) } result.windows[id]?.isFloating = saved.isFloating } } } for record in records where state.displays[record.workspace.key.display] != nil { let saved = record.workspace let key = saved.key guard let display = state.displays[key.display], !activeOnly || (state.isActive(key) && display.hasUsableGeometry) else { continue } let screen = display.frame let current = result.workspaces[key] ?? Workspace(key: key) var workspace = current.applyingMemorySettings(saved, display: display) guard restoreWindows else { if let focused = state.focusedWindow { workspace.select(focused) } result.workspaces[key] = workspace continue } for window in record.windows { guard let id = mapping[window.token], window.isFloating else { continue } result.windows[id]?.isFloating = true if let normalized = window.normalizedFloatingFrame { result.frames[id] = Self.clamped(Self.denormalize(normalized, in: screen), in: screen) } } let matched = saved.memoryRemapping(mapping) let matchedMembers = Set(matched.order) if !matchedMembers.isEmpty { let tiledMapping = mapping.filter { result.windows[$0.value]?.isFloating == false } workspace = saved.memoryRemapping(tiledMapping) workspace.order = matched.order workspace.openingOrder = matched.openingOrder workspace.focus = matched.focus ?? current.focus.flatMap { matchedMembers.contains($0) ? $0 : nil } workspace.adapt(to: screen, fullFrame: display.fullFrame) workspace.restoreAutomaticTiles() var insertionEffects: [Effect] = [] for id in current.order where !matchedMembers.contains(id) { guard let window = result.windows[id] else { continue } result.insertWindow( id, into: &workspace, floating: window.isFloating, frame: result.frames[id] ?? result.observedFrames[id] ?? screen, effects: &insertionEffects) } } if let focused = state.focusedWindow { workspace.select(focused) } result.workspaces[key] = workspace } return result }
func identityCandidates(for saved: SavedWindow, workspace key: WorkspaceKey, in state: State) -> [WindowID] { let identity = Identity(saved, key: key, acrossDisplays: true, activeOnly: true) return state.workspaces.keys.sorted().filter { state.isActive($0) && state.displays[$0.display]?.hasUsableGeometry == true }.flatMap { source in (state.workspaces[source]?.order ?? []).filter { id in state.windows[id].map { Identity($0, key: source, acrossDisplays: true, activeOnly: true) == identity } == true } } }
private struct Identity: Hashable { let bundleID: String let role: String let subrole: String? let display: DisplayID? let space: SpaceID?
init(_ window: SavedWindow, key: WorkspaceKey, acrossDisplays: Bool = false, activeOnly: Bool = false) { bundleID = window.bundleID role = window.role subrole = window.subrole display = acrossDisplays ? nil : key.display space = acrossDisplays && activeOnly ? nil : key.space }
init(_ window: ManagedWindow, key: WorkspaceKey, acrossDisplays: Bool = false, activeOnly: Bool = false) { bundleID = window.app.bundleID role = window.role subrole = window.subrole display = acrossDisplays ? nil : key.display space = acrossDisplays && activeOnly ? nil : key.space } }
private static func digest(_ title: String, salt: Data) -> String? { let normalized = normalizedTitle(title) guard !normalized.isEmpty else { return nil } let digest = HMAC<SHA256>.authenticationCode( for: Data(normalized.utf8), using: SymmetricKey(data: salt)) return digest.map { String(format: "%02x", $0) }.joined() }
private static func validTitleDigest(_ digest: String) -> Bool { digest.utf8.count == 64 && digest.utf8.allSatisfy { (48...57).contains($0) || (97...102).contains($0) } }
private static func clamped(_ frame: Rect, in screen: Rect) -> Rect { let width = min(frame.size.width, screen.size.width) let height = min(frame.size.height, screen.size.height) return Rect( x: min(screen.maxX - width, max(screen.minX, frame.minX)), y: min(screen.maxY - height, max(screen.minY, frame.minY)), width: width, height: height) }
private static func normalizedTitle(_ title: String) -> String { title.precomposedStringWithCanonicalMapping .folding(options: [.caseInsensitive], locale: Locale(identifier: "en_US_POSIX")) .split(whereSeparator: \.isWhitespace).joined(separator: " ") }
private static func validLength(_ value: Double) -> Bool { value.isFinite && (0...1_000_000).contains(value) }
private static func validSize(_ size: Size) -> Bool { validLength(size.width) && validLength(size.height) }
private static func validInsets(_ insets: Insets) -> Bool { [insets.top, insets.left, insets.bottom, insets.right].allSatisfy(validLength) }
private static func validNormalizedFrame(_ frame: Rect) -> Bool { frame.isValid && abs(frame.minX) <= 1_000_000 && abs(frame.minY) <= 1_000_000 && frame.size.width > 0 && frame.size.height > 0 && frame.size.width <= 1_000_000 && frame.size.height <= 1_000_000 }
private static func validTree(_ tree: TileTree?, members: Set<WindowID>, cap: Int) -> Bool { guard let tree else { return true } return tree.isValid && tree.tileCount <= cap && Set(tree.windows).isSubset(of: members) }
private static func normalize(_ frame: Rect, in screen: Rect) -> Rect? { guard screen.size.width > 0, screen.size.height > 0 else { return nil } return Rect( x: (frame.minX - screen.minX) / screen.size.width, y: (frame.minY - screen.minY) / screen.size.height, width: frame.size.width / screen.size.width, height: frame.size.height / screen.size.height) }
private static func denormalize(_ frame: Rect, in screen: Rect) -> Rect { Rect( x: screen.minX + frame.minX * screen.size.width, y: screen.minY + frame.minY * screen.size.height, width: frame.size.width * screen.size.width, height: frame.size.height * screen.size.height) }}
extension TileTree { func memoryRemapping(_ mapping: [WindowID: WindowID]) -> TileTree? { switch self { case .tile(let stack): return stack.memoryRemapping(mapping).map(TileTree.tile) case .split(let axis, let fraction, let first, let second): let left = first.memoryRemapping(mapping) let right = second.memoryRemapping(mapping) if let left, let right { return .split(axis: axis, fraction: fraction, first: left, second: right) } return left ?? right case .partition(let axis, let fraction, let first, let second): let left = first.memoryRemapping(mapping) let right = second.memoryRemapping(mapping) if let left, let right { return .partition(axis: axis, fraction: fraction, first: left, second: right) } return left ?? right } }}
extension Workspace { func memoryRemapping(_ mapping: [WindowID: WindowID]) -> Workspace { var result = self result.order = order.compactMap { mapping[$0] } result.openingOrder = openingOrder.compactMap { mapping[$0] } result.focus = focus.flatMap { mapping[$0] } result.tree = tree?.memoryRemapping(mapping) result.alternateSideTree = alternateSideTree?.memoryRemapping(mapping) if let memory = adaptiveTileMemory, let original = memory.original.memoryRemapping(mapping), let projection = memory.projection.memoryRemapping(mapping) { result.adaptiveTileMemory = AdaptiveTileMemory(original: original, projection: projection) } else { result.adaptiveTileMemory = nil } if layout == .side, let primaryWindow, let primary = tree?.stack(containing: primaryWindow), primary.windows.allSatisfy({ mapping[$0] == nil }) { // A surviving sidebar is the new main area, not a full-display sidebar subtree. result.rebuild(stacks: result.tree?.stacks ?? []) } return result }
fileprivate func applyingMemorySettings(_ saved: Workspace, display: Display) -> Workspace { var result = self if result.layout != saved.layout { result.changeLayout(saved.layout) } result.layoutDefaults = saved.layoutDefaults if result.ratio != saved.ratio { if result.layout == .side { result.changeRatio(saved.ratio) } else { result.ratio = saved.ratio } } result.configuredRatio = saved.configuredRatio result.gaps = saved.gaps result.reservedEdges = saved.reservedEdges result.whenFull = saved.whenFull result.pendingSplitAxis = saved.pendingSplitAxis result.setWindowCap(saved.windowCap) result.adapt(to: display.frame, fullFrame: display.fullFrame) return result }}