import CoreGraphics
|
import Foundation
|
|
public enum FinderTabSpaceAttributionPolicy {
|
private static let finderBundleIdentifier = "com.apple.finder"
|
private static let minimumOverlapRatio: CGFloat = 0.85
|
private static let minimumBestScoreGap: CGFloat = 0.05
|
|
public static func attributedRecords(_ records: [WindowEnumerationRecord]) -> [WindowEnumerationRecord] {
|
let hosts = records.filter(isFinderFullscreenHost)
|
guard !hosts.isEmpty else { return records }
|
|
return records.map { record in
|
guard isFinderTabCandidate(record),
|
let host = bestHost(for: record, in: hosts)
|
else {
|
return record
|
}
|
|
return copy(
|
record,
|
isFullscreen: true,
|
spaceIDs: host.spaceIDs
|
)
|
}
|
}
|
|
private static func isFinderTabCandidate(_ record: WindowEnumerationRecord) -> Bool {
|
WindowEnumerationPolicy.shouldInclude(record)
|
&& record.identifierSource == .cgWindow
|
&& record.app.bundleIdentifier == finderBundleIdentifier
|
&& record.spaceIDs.isEmpty
|
&& !record.isMinimized
|
&& !record.title.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
|
&& record.frame?.isEmpty == false
|
}
|
|
private static func isFinderFullscreenHost(_ record: WindowEnumerationRecord) -> Bool {
|
WindowEnumerationPolicy.shouldInclude(record)
|
&& record.app.bundleIdentifier == finderBundleIdentifier
|
&& record.isFullscreen
|
&& !record.spaceIDs.isEmpty
|
&& record.subrole == .standard
|
&& record.frame?.isEmpty == false
|
}
|
|
private static func bestHost(
|
for candidate: WindowEnumerationRecord,
|
in hosts: [WindowEnumerationRecord]
|
) -> WindowEnumerationRecord? {
|
let compatibleHosts = hosts.filter { host in
|
sameProcess(candidate, host)
|
}
|
let scoredHosts = compatibleHosts.compactMap { host -> (record: WindowEnumerationRecord, score: CGFloat)? in
|
guard let score = overlapScore(candidate.frame, host.frame),
|
score >= minimumOverlapRatio
|
else {
|
return nil
|
}
|
|
return (host, score)
|
}
|
.sorted { lhs, rhs in
|
if lhs.score != rhs.score {
|
return lhs.score > rhs.score
|
}
|
return lhs.record.id < rhs.record.id
|
}
|
|
guard let best = scoredHosts.first else { return nil }
|
if scoredHosts.count == 1 {
|
return best.record
|
}
|
|
let sameSpaceCompetitors = scoredHosts.filter { $0.record.spaceIDs == best.record.spaceIDs }
|
if sameSpaceCompetitors.count == scoredHosts.count {
|
return best.record
|
}
|
|
let secondBest = scoredHosts[1]
|
return best.score - secondBest.score >= minimumBestScoreGap ? best.record : nil
|
}
|
|
private static func sameProcess(
|
_ lhs: WindowEnumerationRecord,
|
_ rhs: WindowEnumerationRecord
|
) -> Bool {
|
guard let lhsPID = lhs.app.processIdentifier,
|
let rhsPID = rhs.app.processIdentifier
|
else {
|
return false
|
}
|
|
return lhsPID == rhsPID
|
}
|
|
private static func overlapScore(_ lhs: CGRect?, _ rhs: CGRect?) -> CGFloat? {
|
guard let lhs,
|
let rhs,
|
!lhs.isEmpty,
|
!rhs.isEmpty
|
else {
|
return nil
|
}
|
|
let intersection = lhs.intersection(rhs)
|
guard !intersection.isNull,
|
!intersection.isEmpty
|
else {
|
return nil
|
}
|
|
let denominator = min(lhs.width * lhs.height, rhs.width * rhs.height)
|
guard denominator > 0 else { return nil }
|
return (intersection.width * intersection.height) / denominator
|
}
|
|
private static func copy(
|
_ record: WindowEnumerationRecord,
|
isFullscreen: Bool,
|
spaceIDs: [UInt64]
|
) -> WindowEnumerationRecord {
|
WindowEnumerationRecord(
|
id: record.id,
|
app: record.app,
|
activationPolicy: record.activationPolicy,
|
title: record.title,
|
identifierSource: record.identifierSource,
|
size: record.size,
|
frame: record.frame,
|
subrole: record.subrole,
|
isMinimized: record.isMinimized,
|
isFullscreen: isFullscreen,
|
isGhost: record.isGhost,
|
isDesktopElement: record.isDesktopElement,
|
isSystemCritical: record.isSystemCritical,
|
isInteractable: record.isInteractable,
|
hasAXBacking: record.hasAXBacking,
|
isOnscreen: record.isOnscreen,
|
spaceIDs: spaceIDs
|
)
|
}
|
}
|
