import Foundation
|
|
public struct QuickSwitchViewModel: Equatable, Sendable {
|
public let displays: [QuickSwitchDisplayViewModel]
|
public let appShelf: [QuickSwitchAppShelfItemViewModel]
|
public let waterfallColumns: [QuickSwitchWaterfallColumnViewModel]
|
public let initialSelection: QuickSwitchSelection?
|
|
public init(
|
displays: [QuickSwitchDisplayViewModel],
|
appShelf: [QuickSwitchAppShelfItemViewModel],
|
waterfallColumns: [QuickSwitchWaterfallColumnViewModel],
|
initialSelection: QuickSwitchSelection?
|
) {
|
self.displays = displays
|
self.appShelf = appShelf
|
self.waterfallColumns = waterfallColumns
|
self.initialSelection = initialSelection
|
}
|
|
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 init(
|
id: UInt64,
|
displayUUID: String,
|
index: Int,
|
label: String,
|
type: AlignerSpaceType,
|
isCurrent: Bool = false,
|
windowCount: Int,
|
appCount: Int,
|
appNames: [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
|
}
|
}
|
|
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 displays = displayViewModels(
|
from: snapshot.displays,
|
currentSpaceIDs: currentSpaceIDs,
|
windowCountsBySpace: windowCountsBySpace,
|
appCountsBySpace: appCountsBySpace,
|
appNamesBySpace: appNamesBySpace
|
)
|
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)
|
)
|
}
|
|
private static func displayViewModels(
|
from displays: [AlignerDisplay],
|
currentSpaceIDs: Set<UInt64>,
|
windowCountsBySpace: [UInt64: Int],
|
appCountsBySpace: [UInt64: Int],
|
appNamesBySpace: [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] ?? []
|
)
|
}
|
|
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 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)"
|
}
|
}
|
