import CoreGraphics
|
import Foundation
|
|
public struct QuickSwitchViewModel: Equatable, Sendable {
|
public let displays: [QuickSwitchDisplayViewModel]
|
public let appShelf: [QuickSwitchAppShelfItemViewModel]
|
public let waterfallColumns: [QuickSwitchWaterfallColumnViewModel]
|
public let initialSelection: QuickSwitchSelection?
|
public let lockedSpaceID: UInt64?
|
|
public init(
|
displays: [QuickSwitchDisplayViewModel],
|
appShelf: [QuickSwitchAppShelfItemViewModel],
|
waterfallColumns: [QuickSwitchWaterfallColumnViewModel],
|
initialSelection: QuickSwitchSelection?,
|
lockedSpaceID: UInt64? = nil
|
) {
|
self.displays = displays
|
self.appShelf = appShelf
|
self.waterfallColumns = waterfallColumns
|
self.initialSelection = initialSelection
|
self.lockedSpaceID = lockedSpaceID
|
}
|
|
public var spaceCount: Int {
|
displays.flatMap(\.spaces).count
|
}
|
|
public var windowCount: Int {
|
waterfallColumns.flatMap(\.windows).count
|
}
|
}
|
|
public struct QuickSwitchDisplayViewModel: Equatable, Sendable {
|
public let displayUUID: String
|
public let displayIndex: Int
|
public let displayLabel: String
|
public let physical: Bool
|
public let spaces: [QuickSwitchSpaceViewModel]
|
|
public init(
|
displayUUID: String,
|
displayIndex: Int,
|
displayLabel: String,
|
physical: Bool,
|
spaces: [QuickSwitchSpaceViewModel]
|
) {
|
self.displayUUID = displayUUID
|
self.displayIndex = displayIndex
|
self.displayLabel = displayLabel
|
self.physical = physical
|
self.spaces = spaces
|
}
|
}
|
|
public struct QuickSwitchSpaceViewModel: Equatable, Sendable {
|
public let id: UInt64
|
public let displayUUID: String
|
public let index: Int
|
public let label: String
|
public let type: AlignerSpaceType
|
public let isCurrent: Bool
|
public let windowCount: Int
|
public let appCount: Int
|
public let appNames: [String]
|
public let splitViewAppNames: [String]
|
|
public init(
|
id: UInt64,
|
displayUUID: String,
|
index: Int,
|
label: String,
|
type: AlignerSpaceType,
|
isCurrent: Bool = false,
|
windowCount: Int,
|
appCount: Int,
|
appNames: [String] = [],
|
splitViewAppNames: [String] = []
|
) {
|
self.id = id
|
self.displayUUID = displayUUID
|
self.index = index
|
self.label = label
|
self.type = type
|
self.isCurrent = isCurrent
|
self.windowCount = windowCount
|
self.appCount = appCount
|
self.appNames = appNames
|
self.splitViewAppNames = splitViewAppNames
|
}
|
}
|
|
public struct QuickSwitchAppShelfItemViewModel: Equatable, Sendable {
|
public let appGroupIndex: Int
|
public let app: AlignerApp
|
public let windowCount: Int
|
public let primarySpaceIDs: [UInt64]
|
public let hasMinimizedWindows: Bool
|
public let hasFullscreenWindows: Bool
|
|
public init(
|
appGroupIndex: Int,
|
app: AlignerApp,
|
windowCount: Int,
|
primarySpaceIDs: [UInt64],
|
hasMinimizedWindows: Bool,
|
hasFullscreenWindows: Bool
|
) {
|
self.appGroupIndex = appGroupIndex
|
self.app = app
|
self.windowCount = windowCount
|
self.primarySpaceIDs = primarySpaceIDs
|
self.hasMinimizedWindows = hasMinimizedWindows
|
self.hasFullscreenWindows = hasFullscreenWindows
|
}
|
}
|
|
public struct QuickSwitchWaterfallColumnViewModel: Equatable, Sendable {
|
public let appGroupIndex: Int
|
public let app: AlignerApp
|
public let windows: [QuickSwitchWindowCardViewModel]
|
|
public init(
|
appGroupIndex: Int,
|
app: AlignerApp,
|
windows: [QuickSwitchWindowCardViewModel]
|
) {
|
self.appGroupIndex = appGroupIndex
|
self.app = app
|
self.windows = windows
|
}
|
}
|
|
public struct QuickSwitchWindowCardViewModel: Equatable, Sendable {
|
public let appGroupIndex: Int
|
public let windowIndex: Int
|
public let globalIndex: Int
|
public let window: AlignerWindow
|
public let primarySpaceID: UInt64?
|
public let primarySpaceLabel: String?
|
|
public init(
|
appGroupIndex: Int,
|
windowIndex: Int,
|
globalIndex: Int,
|
window: AlignerWindow,
|
primarySpaceID: UInt64?,
|
primarySpaceLabel: String?
|
) {
|
self.appGroupIndex = appGroupIndex
|
self.windowIndex = windowIndex
|
self.globalIndex = globalIndex
|
self.window = window
|
self.primarySpaceID = primarySpaceID
|
self.primarySpaceLabel = primarySpaceLabel
|
}
|
}
|
|
public enum QuickSwitchViewModelBuilder {
|
public static func viewModel(from snapshot: QuickSwitchSnapshot) -> QuickSwitchViewModel {
|
viewModel(from: snapshot, currentSpaceIDs: [])
|
}
|
|
public static func viewModel(
|
from snapshot: QuickSwitchSnapshot,
|
currentSpaceIDs: Set<UInt64>
|
) -> QuickSwitchViewModel {
|
let spaceLabels = labelsBySpaceID(from: snapshot.displays)
|
let windowItems = snapshot.appGroups.flatMap(\.windows)
|
let windowCountsBySpace = countWindowsBySpace(windowItems)
|
let appCountsBySpace = countAppsBySpace(snapshot.appGroups)
|
let appNamesBySpace = appNamesBySpace(snapshot.appGroups)
|
let splitViewAppNamesBySpace = splitViewAppNamesBySpace(snapshot.appGroups)
|
let displays = displayViewModels(
|
from: snapshot.displays,
|
currentSpaceIDs: currentSpaceIDs,
|
windowCountsBySpace: windowCountsBySpace,
|
appCountsBySpace: appCountsBySpace,
|
appNamesBySpace: appNamesBySpace,
|
splitViewAppNamesBySpace: splitViewAppNamesBySpace
|
)
|
let appShelf = appShelfViewModels(from: snapshot.appGroups)
|
|
var globalIndex = 0
|
let columns = snapshot.appGroups.enumerated().map { appGroupIndex, group in
|
let windows = group.windows.enumerated().map { windowIndex, item in
|
defer { globalIndex += 1 }
|
return QuickSwitchWindowCardViewModel(
|
appGroupIndex: appGroupIndex,
|
windowIndex: windowIndex,
|
globalIndex: globalIndex,
|
window: item.window,
|
primarySpaceID: item.primarySpaceID,
|
primarySpaceLabel: item.primarySpaceID.flatMap { spaceLabels[$0] }
|
)
|
}
|
|
return QuickSwitchWaterfallColumnViewModel(
|
appGroupIndex: appGroupIndex,
|
app: group.app,
|
windows: windows
|
)
|
}
|
|
return QuickSwitchViewModel(
|
displays: displays,
|
appShelf: appShelf,
|
waterfallColumns: columns,
|
initialSelection: QuickSwitchFocusPolicy.initialSelection(in: snapshot),
|
lockedSpaceID: nil
|
)
|
}
|
|
private static func displayViewModels(
|
from displays: [AlignerDisplay],
|
currentSpaceIDs: Set<UInt64>,
|
windowCountsBySpace: [UInt64: Int],
|
appCountsBySpace: [UInt64: Int],
|
appNamesBySpace: [UInt64: [String]],
|
splitViewAppNamesBySpace: [UInt64: [String]]
|
) -> [QuickSwitchDisplayViewModel] {
|
let sortedDisplays = displays
|
.sorted { $0.uuid.localizedStandardCompare($1.uuid) == .orderedAscending }
|
let displayCount = sortedDisplays.count
|
|
return sortedDisplays
|
.enumerated()
|
.map { displayIndex, display in
|
let displayLabel = displayLabel(for: displayIndex)
|
let spaces = display.spaces
|
.sorted { $0.index < $1.index }
|
.map { space in
|
QuickSwitchSpaceViewModel(
|
id: space.id,
|
displayUUID: space.displayUUID,
|
index: space.index,
|
label: spaceLabel(for: space, displayIndex: displayIndex, displayCount: displayCount),
|
type: space.type,
|
isCurrent: currentSpaceIDs.contains(space.id),
|
windowCount: windowCountsBySpace[space.id] ?? 0,
|
appCount: appCountsBySpace[space.id] ?? 0,
|
appNames: appNamesBySpace[space.id] ?? [],
|
splitViewAppNames: splitViewAppNamesBySpace[space.id] ?? []
|
)
|
}
|
|
return QuickSwitchDisplayViewModel(
|
displayUUID: display.uuid,
|
displayIndex: displayIndex,
|
displayLabel: displayLabel,
|
physical: display.physical,
|
spaces: spaces
|
)
|
}
|
}
|
|
private static func appShelfViewModels(
|
from appGroups: [QuickSwitchAppGroup]
|
) -> [QuickSwitchAppShelfItemViewModel] {
|
appGroups.enumerated().map { appGroupIndex, group in
|
QuickSwitchAppShelfItemViewModel(
|
appGroupIndex: appGroupIndex,
|
app: group.app,
|
windowCount: group.windows.count,
|
primarySpaceIDs: orderedUnique(group.windows.compactMap(\.primarySpaceID)),
|
hasMinimizedWindows: group.windows.contains { $0.window.isMinimized },
|
hasFullscreenWindows: group.windows.contains { $0.window.isFullscreen }
|
)
|
}
|
}
|
|
private static func labelsBySpaceID(from displays: [AlignerDisplay]) -> [UInt64: String] {
|
var labels: [UInt64: String] = [:]
|
let sortedDisplays = displays
|
.sorted(by: { $0.uuid.localizedStandardCompare($1.uuid) == .orderedAscending })
|
let displayCount = sortedDisplays.count
|
|
for (displayIndex, display) in sortedDisplays.enumerated() {
|
for space in display.spaces {
|
labels[space.id] = spaceLabel(for: space, displayIndex: displayIndex, displayCount: displayCount)
|
}
|
}
|
|
return labels
|
}
|
|
private static func countWindowsBySpace(_ windowItems: [QuickSwitchWindowItem]) -> [UInt64: Int] {
|
var counts: [UInt64: Int] = [:]
|
for item in windowItems {
|
guard let primarySpaceID = item.primarySpaceID else { continue }
|
counts[primarySpaceID, default: 0] += 1
|
}
|
return counts
|
}
|
|
private static func countAppsBySpace(_ appGroups: [QuickSwitchAppGroup]) -> [UInt64: Int] {
|
var appIdentitiesBySpace: [UInt64: Set<Int>] = [:]
|
|
for (appGroupIndex, group) in appGroups.enumerated() {
|
for spaceID in orderedUnique(group.windows.compactMap(\.primarySpaceID)) {
|
appIdentitiesBySpace[spaceID, default: []].insert(appGroupIndex)
|
}
|
}
|
|
return appIdentitiesBySpace.mapValues(\.count)
|
}
|
|
private static func appNamesBySpace(_ appGroups: [QuickSwitchAppGroup]) -> [UInt64: [String]] {
|
var namesBySpace: [UInt64: [String]] = [:]
|
|
for group in appGroups {
|
for spaceID in orderedUnique(group.windows.compactMap(\.primarySpaceID)) {
|
namesBySpace[spaceID, default: []].append(group.app.name)
|
}
|
}
|
|
return namesBySpace
|
}
|
|
private static func splitViewAppNamesBySpace(_ appGroups: [QuickSwitchAppGroup]) -> [UInt64: [String]] {
|
struct Candidate {
|
let appName: String
|
let windowID: UInt32
|
let frame: CGRect
|
}
|
|
var candidatesBySpace: [UInt64: [Candidate]] = [:]
|
|
for group in appGroups {
|
for item in group.windows {
|
guard item.window.isFullscreen,
|
let primarySpaceID = item.primarySpaceID,
|
let frame = item.window.frame,
|
frame.width > 0,
|
frame.height > 0
|
else {
|
continue
|
}
|
|
candidatesBySpace[primarySpaceID, default: []].append(
|
Candidate(
|
appName: group.app.name,
|
windowID: item.window.id,
|
frame: frame
|
)
|
)
|
}
|
}
|
|
return candidatesBySpace.compactMapValues { candidates in
|
guard candidates.count >= 2 else { return nil }
|
|
return candidates
|
.sorted { lhs, rhs in
|
if lhs.frame.midX != rhs.frame.midX {
|
return lhs.frame.midX < rhs.frame.midX
|
}
|
if lhs.frame.midY != rhs.frame.midY {
|
return lhs.frame.midY < rhs.frame.midY
|
}
|
return lhs.windowID < rhs.windowID
|
}
|
.prefix(2)
|
.map(\.appName)
|
}
|
}
|
|
private static func orderedUnique<T: Hashable>(_ values: [T]) -> [T] {
|
var seen = Set<T>()
|
var result: [T] = []
|
|
for value in values where !seen.contains(value) {
|
seen.insert(value)
|
result.append(value)
|
}
|
|
return result
|
}
|
|
private static func displayLabel(for index: Int) -> String {
|
let scalarA = Int(UnicodeScalar("A").value)
|
var value = index
|
var scalars: [UnicodeScalar] = []
|
|
repeat {
|
let remainder = value % 26
|
scalars.insert(UnicodeScalar(scalarA + remainder)!, at: 0)
|
value = value / 26 - 1
|
} while value >= 0
|
|
return String(String.UnicodeScalarView(scalars))
|
}
|
|
private static func spaceLabel(for space: AlignerSpace, displayIndex: Int, displayCount: Int) -> String {
|
if displayCount <= 1 {
|
return String(format: "%02d", space.index)
|
}
|
|
return "\(displayLabel(for: displayIndex))\(space.index)"
|
}
|
}
|
|
public enum QuickSwitchSpaceFilterPolicy {
|
public static func projectedViewModel(
|
from viewModel: QuickSwitchViewModel,
|
lockedSpaceID: UInt64?,
|
preferredSelection: QuickSwitchSelection? = nil
|
) -> QuickSwitchViewModel {
|
guard let lockedSpaceID else {
|
return replacingInitialSelection(
|
in: viewModel,
|
lockedSpaceID: nil,
|
preferredSelection: preferredSelection
|
)
|
}
|
|
var nextGlobalIndex = 0
|
let columns = viewModel.waterfallColumns.compactMap { column -> QuickSwitchWaterfallColumnViewModel? in
|
let windows = column.windows.filter { $0.primarySpaceID == lockedSpaceID }
|
guard !windows.isEmpty else { return nil }
|
|
let reindexedWindows = windows.enumerated().map { windowIndex, card in
|
defer { nextGlobalIndex += 1 }
|
return QuickSwitchWindowCardViewModel(
|
appGroupIndex: column.appGroupIndex,
|
windowIndex: windowIndex,
|
globalIndex: nextGlobalIndex,
|
window: card.window,
|
primarySpaceID: card.primarySpaceID,
|
primarySpaceLabel: card.primarySpaceLabel
|
)
|
}
|
|
return QuickSwitchWaterfallColumnViewModel(
|
appGroupIndex: column.appGroupIndex,
|
app: column.app,
|
windows: reindexedWindows
|
)
|
}
|
|
let columnsByAppGroupIndex = Dictionary(uniqueKeysWithValues: columns.map { ($0.appGroupIndex, $0) })
|
let appShelf = viewModel.appShelf.compactMap { item -> QuickSwitchAppShelfItemViewModel? in
|
guard let column = columnsByAppGroupIndex[item.appGroupIndex] else { return nil }
|
return QuickSwitchAppShelfItemViewModel(
|
appGroupIndex: item.appGroupIndex,
|
app: item.app,
|
windowCount: column.windows.count,
|
primarySpaceIDs: orderedPrimarySpaceIDs(in: column.windows),
|
hasMinimizedWindows: column.windows.contains { $0.window.isMinimized },
|
hasFullscreenWindows: column.windows.contains { $0.window.isFullscreen }
|
)
|
}
|
|
return QuickSwitchViewModel(
|
displays: viewModel.displays,
|
appShelf: appShelf,
|
waterfallColumns: columns,
|
initialSelection: initialSelection(in: columns, preferredSelection: preferredSelection),
|
lockedSpaceID: lockedSpaceID
|
)
|
}
|
|
public static func singleFullscreenSelection(
|
inSpaceID spaceID: UInt64,
|
viewModel: QuickSwitchViewModel
|
) -> QuickSwitchSelection? {
|
guard viewModel.displays
|
.flatMap(\.spaces)
|
.contains(where: { $0.id == spaceID && $0.type == .fullscreen })
|
else {
|
return nil
|
}
|
|
let cards = viewModel.waterfallColumns
|
.flatMap(\.windows)
|
.filter { $0.primarySpaceID == spaceID }
|
|
guard cards.count == 1,
|
let card = cards.first,
|
card.window.isFullscreen
|
else {
|
return nil
|
}
|
|
return QuickSwitchSelection(
|
appGroupIndex: card.appGroupIndex,
|
windowIndex: card.windowIndex,
|
windowID: card.window.id
|
)
|
}
|
|
private static func replacingInitialSelection(
|
in viewModel: QuickSwitchViewModel,
|
lockedSpaceID: UInt64?,
|
preferredSelection: QuickSwitchSelection?
|
) -> QuickSwitchViewModel {
|
QuickSwitchViewModel(
|
displays: viewModel.displays,
|
appShelf: viewModel.appShelf,
|
waterfallColumns: viewModel.waterfallColumns,
|
initialSelection: initialSelection(in: viewModel.waterfallColumns, preferredSelection: preferredSelection)
|
?? viewModel.initialSelection,
|
lockedSpaceID: lockedSpaceID
|
)
|
}
|
|
private static func initialSelection(
|
in columns: [QuickSwitchWaterfallColumnViewModel],
|
preferredSelection: QuickSwitchSelection?
|
) -> QuickSwitchSelection? {
|
if let preferredSelection,
|
let matchingCard = columns
|
.flatMap(\.windows)
|
.first(where: { $0.window.id == preferredSelection.windowID }) {
|
return QuickSwitchSelection(
|
appGroupIndex: matchingCard.appGroupIndex,
|
windowIndex: matchingCard.windowIndex,
|
windowID: matchingCard.window.id
|
)
|
}
|
|
guard let firstCard = columns.first?.windows.first else { return nil }
|
return QuickSwitchSelection(
|
appGroupIndex: firstCard.appGroupIndex,
|
windowIndex: firstCard.windowIndex,
|
windowID: firstCard.window.id
|
)
|
}
|
|
private static func orderedPrimarySpaceIDs(in cards: [QuickSwitchWindowCardViewModel]) -> [UInt64] {
|
var seen = Set<UInt64>()
|
var result: [UInt64] = []
|
|
for card in cards {
|
guard let spaceID = card.primarySpaceID,
|
!seen.contains(spaceID)
|
else {
|
continue
|
}
|
seen.insert(spaceID)
|
result.append(spaceID)
|
}
|
|
return result
|
}
|
}
|
