Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174extension State { func nativeTabPeer(for window: ManagedWindow, workspace key: WorkspaceKey, frame: Rect) -> WindowID? { guard !window.isFloating, window.facts?.hasNativeTabs == true, let workspace = workspaces[key], let tree = workspace.tree else { return nil } return tree.windows.first { id in guard id != window.id, let peer = windows[id], !peer.isFloating, peer.app == window.app else { return false } return window.sharesNativeTabGroup(with: peer, frame: frame, peerFrame: observedFrames[id]) || window.sharesNativeTabGroup(with: peer, frame: frame, peerFrame: frames[id]) } }
func nativeTabDetached( _ window: ManagedWindow, previous: ManagedWindow?, workspace: Workspace, closingWindows: Set<WindowID> = [] ) -> Bool { let changedMembers: Bool if let group = window.facts?.nativeTabGroup, let earlierGroup = previous?.facts?.nativeTabGroup, case .windowIDs(let members) = group, case .windowIDs(let earlier) = earlierGroup { changedMembers = Set(members).subtracting(closingWindows) != Set(earlier).subtracting(closingWindows) } else { changedMembers = false } guard let previous, previous.facts?.hasNativeTabs == true, window.facts?.hasNativeTabs == false || changedMembers, let stack = workspace.tree?.stacks.first(where: { $0.windows.contains(window.id) }) else { return false } return stack.windows.contains { id in guard id != window.id, !closingWindows.contains(id), let peer = windows[id] else { return false } return previous.sharesNativeTabGroup(with: peer, frame: frames[window.id], peerFrame: frames[id]) && !(window.sharesNativeTabGroup( with: peer, frame: observedFrames[window.id], peerFrame: observedFrames[id]) || window.sharesNativeTabGroup( with: peer, frame: observedFrames[window.id], peerFrame: frames[id])) } }
func nativeTabSurvivor(closing window: WindowID) -> WindowID? { guard let closing = windows[window], let key = workspace(containing: window), let stack = workspaces[key]?.tree?.stacks.first(where: { $0.windows.contains(window) }) else { return nil } return stack.windows.first { id in guard id != window, let peer = windows[id], !peer.isFloating else { return false } return closing.sharesNativeTabGroup( with: peer, frame: frames[window], peerFrame: frames[id], closingWindow: window) } }
func nativeTabEventOrder(_ events: [Event]) -> [Int] { var order = Array(events.indices) var refreshed = self for event in events { if case .windowAppeared(let window, _, let frame) = event, windows[window.id] != nil, window.facts?.hasNativeTabs == true { refreshed.windows[window.id] = window refreshed.observedFrames[window.id] = frame } } for (index, event) in events.enumerated() { guard case .windowAppeared(let window, let key, let frame) = event, let peer = refreshed.nativeTabPeer(for: window, workspace: key, frame: frame) else { continue } let membership = workspaces[key]?.tree?.windows ?? [] let windowPosition = membership.firstIndex(of: window.id) ?? membership.count let peerPosition = membership.firstIndex(of: peer) ?? membership.count if peerPosition < windowPosition, let update = order.firstIndex(where: { if case .windowAppeared(let candidate, _, _) = events[$0] { candidate.id == peer } else { false } }), let appeared = order.firstIndex(of: index), update > appeared, order[appeared...update].allSatisfy({ events[$0].isWindowLifecycleObservation }) { let refresh = order.remove(at: update) order.insert(refresh, at: appeared) } if let removed = order.firstIndex(where: { events[$0] == .windowDisappeared(peer) }), let appeared = order.firstIndex(of: index), removed < appeared, order[removed..<appeared].allSatisfy({ events[$0].isWindowLifecycleObservation }) { // Selected native tabs can disappear before their replacement appears in the same AX scan. order.remove(at: appeared) order.insert(index, at: removed) } } for (index, event) in events.enumerated() { guard case .windowAppeared(let window, let key, _) = event, window.facts?.hasNativeTabs == false, windows[window.id]?.facts?.hasNativeTabs == true, let stack = workspaces[key]?.tree?.stacks.first(where: { $0.windows.contains(window.id) }) else { continue } for peer in stack.windows where peer != window.id { guard let previous = windows[window.id], let closingWindow = windows[peer], previous.sharesNativeTabGroup( with: closingWindow, frame: frames[window.id], peerFrame: frames[peer]), let removed = order.firstIndex(where: { events[$0] == .windowDisappeared(peer) }), let appeared = order.firstIndex(of: index), appeared < removed, order[appeared...removed].allSatisfy({ events[$0].isWindowLifecycleObservation }) else { continue } // A final tab losing its tab bar is not a detach; close its sibling before refreshing it. let closing = order.remove(at: removed) order.insert(closing, at: appeared) } } return order }}
extension ManagedWindow { package func sharesNativeTabGroup( with peer: ManagedWindow, frame: Rect?, peerFrame: Rect?, closingWindow: WindowID? = nil ) -> Bool { guard app == peer.app, facts?.hasNativeTabs == true, peer.facts?.hasNativeTabs == true, let group = facts?.nativeTabGroup, let other = peer.facts?.nativeTabGroup else { return false } switch (group, other) { case (.windowIDs(let ids), .windowIDs(let peers)): let members = Set(ids) let otherMembers = Set(peers) let sameMembers = closingWindow.map { members.subtracting([$0]) == otherMembers.subtracting([$0]) } ?? (members == otherMembers) return members.count > 1 && sameMembers && members.contains(id) && members.contains(peer.id) case (.titles(let titles), .titles(let peers)): let members = Set(titles) guard members.count > 1, members.count == titles.count, !members.contains(""), members == Set(peers), peers.count == titles.count, let frame, let peerFrame, frame.isValid, peerFrame.isValid, frame.size.width > 0, frame.size.height > 0 else { return false } return abs(frame.minX - peerFrame.minX) <= 2 && abs(frame.minY - peerFrame.minY) <= 2 && abs(frame.size.width - peerFrame.size.width) <= 2 && abs(frame.size.height - peerFrame.size.height) <= 2 default: return false } }}
extension Event { fileprivate var isWindowLifecycleObservation: Bool { switch self { case .windowAppeared, .windowDisappeared: true default: false } }}
extension Workspace { mutating func insertNativeTab(_ window: WindowID, alongside peer: WindowID) -> Bool { guard let tree, tree.windows.contains(peer), let index = order.firstIndex(of: peer) else { return false } if tree.stacks.contains(where: { $0.windows.contains(peer) && $0.windows.contains(window) }) { return true } if !order.contains(window) { order.insert(window, at: index + 1) if let opened = openingOrder.firstIndex(of: peer) { openingOrder.insert(window, at: opened + 1) } else { openingOrder.append(window) } } guard let remaining = tree.removing(window) else { return false } self.tree = remaining.mappingStacks { stack in guard stack.windows.contains(peer) else { return stack } var updated = stack updated.append(window) updated.isUserMade = true updated.select(window) return updated } return true }}