wehub-resource-sync
222 lines
9.7 KiB
Swift
222 lines
9.7 KiB
Swift
import AppKit
|
|
|
|
/// Pre-harvest snapshot of one live content row, captured before card views are detached
|
|
/// into the recycle pool so reconciliation can still compare row shapes afterwards.
|
|
struct MenuRowShape {
|
|
let isSeparator: Bool
|
|
let requiresNativeImageReplacement: Bool
|
|
let id: String?
|
|
let viewClassName: String?
|
|
}
|
|
|
|
extension StatusItemController {
|
|
func menuContentShapes(in menu: NSMenu, fromIndex: Int) -> [MenuRowShape] {
|
|
guard fromIndex >= 0, fromIndex <= menu.items.count else { return [] }
|
|
return menu.items[fromIndex...].map { item in
|
|
MenuRowShape(
|
|
isSeparator: item.isSeparatorItem,
|
|
requiresNativeImageReplacement: self.shouldReplaceNativeImageItemDuringReconcile(item),
|
|
id: item.representedObject as? String,
|
|
viewClassName: item.view.map { String(describing: type(of: $0)) })
|
|
}
|
|
}
|
|
|
|
/// Identifies leaf AppKit image items that should be replaced instead of updated in place.
|
|
///
|
|
/// AppKit can retain stale layout state for standard image-backed menu items after repeated
|
|
/// in-place updates, which makes rows such as "Status Page" drift horizontally. Submenu rows
|
|
/// stay on the normal reconciliation path because replacing their parent item can disturb an
|
|
/// active submenu.
|
|
private func shouldReplaceNativeImageItemDuringReconcile(_ item: NSMenuItem) -> Bool {
|
|
!item.isSeparatorItem && item.view == nil && item.image != nil && item.submenu == nil
|
|
}
|
|
|
|
/// Position-wise in-place reconciliation: live rows whose shape matches the freshly
|
|
/// built content (separator placement, card identifier, view class) are updated in
|
|
/// place — views transplanted, plain rows recopied — and only the mismatched middle
|
|
/// span is removed and reinserted. Matching runs from both ends, so the expensive card
|
|
/// rows at the top and the shared action rows at the bottom survive even a provider
|
|
/// switch whose middle sections differ; AppKit then relayouts the open tracked menu for
|
|
/// the few changed rows instead of once per row.
|
|
func reconcileMenuContent(
|
|
_ menu: NSMenu,
|
|
fromIndex: Int,
|
|
shapes: [MenuRowShape],
|
|
with scratch: NSMenu)
|
|
{
|
|
defer { self.finishReconciledHighlightTracking(in: menu) }
|
|
let newItems = scratch.items
|
|
scratch.removeAllItems()
|
|
guard menu.items.count - fromIndex == shapes.count else {
|
|
// The live region changed underneath the snapshot; replace it wholesale.
|
|
self.replaceMenuContent(menu, fromIndex: fromIndex, with: newItems)
|
|
return
|
|
}
|
|
|
|
func updatable(_ shape: MenuRowShape, _ newItem: NSMenuItem) -> Bool {
|
|
guard shape.isSeparator == newItem.isSeparatorItem else { return false }
|
|
if shape.isSeparator { return true }
|
|
guard !shape.requiresNativeImageReplacement,
|
|
!self.shouldReplaceNativeImageItemDuringReconcile(newItem)
|
|
else { return false }
|
|
guard shape.id == newItem.representedObject as? String else { return false }
|
|
return shape.viewClassName == newItem.view.map { String(describing: type(of: $0)) }
|
|
}
|
|
|
|
var prefix = 0
|
|
while prefix < min(shapes.count, newItems.count), updatable(shapes[prefix], newItems[prefix]) {
|
|
prefix += 1
|
|
}
|
|
var suffix = 0
|
|
while suffix < min(shapes.count, newItems.count) - prefix,
|
|
updatable(shapes[shapes.count - 1 - suffix], newItems[newItems.count - 1 - suffix])
|
|
{
|
|
suffix += 1
|
|
}
|
|
|
|
for offset in 0..<prefix {
|
|
self.updateMenuItemInPlace(menu.items[fromIndex + offset], from: newItems[offset])
|
|
}
|
|
for offset in 0..<suffix {
|
|
self.updateMenuItemInPlace(
|
|
menu.items[menu.items.count - 1 - offset],
|
|
from: newItems[newItems.count - 1 - offset])
|
|
}
|
|
|
|
let liveMiddleCount = shapes.count - prefix - suffix
|
|
let insertionIndex = fromIndex + prefix
|
|
for _ in 0..<liveMiddleCount {
|
|
menu.removeItem(at: insertionIndex)
|
|
}
|
|
let newMiddle = newItems[prefix..<(newItems.count - suffix)]
|
|
for (offset, item) in newMiddle.enumerated() {
|
|
menu.insertItem(item, at: insertionIndex + offset)
|
|
}
|
|
}
|
|
|
|
/// Replaces cached content without first emptying the tracked menu. Compatible item shells
|
|
/// stay attached while their payloads swap; only separator or row-count differences cause
|
|
/// structural mutations.
|
|
func replaceMenuContentKeepingRowsVisible(
|
|
_ menu: NSMenu,
|
|
fromIndex: Int,
|
|
with newItems: [NSMenuItem])
|
|
-> [NSMenuItem]
|
|
{
|
|
guard fromIndex >= 0, fromIndex <= menu.items.count else { return [] }
|
|
defer { self.finishReconciledHighlightTracking(in: menu) }
|
|
|
|
let liveItems = Array(menu.items[fromIndex...])
|
|
let liveCount = liveItems.count
|
|
let sharedCount = min(liveCount, newItems.count)
|
|
var displacedItems: [NSMenuItem] = []
|
|
displacedItems.reserveCapacity(liveCount)
|
|
for offset in 0..<sharedCount {
|
|
let index = fromIndex + offset
|
|
let liveItem = liveItems[offset]
|
|
let newItem = newItems[offset]
|
|
let requiresNativeImageReplacement =
|
|
self.shouldReplaceNativeImageItemDuringReconcile(liveItem) ||
|
|
self.shouldReplaceNativeImageItemDuringReconcile(newItem)
|
|
if liveItem.isSeparatorItem == newItem.isSeparatorItem, !requiresNativeImageReplacement {
|
|
if !liveItem.isSeparatorItem {
|
|
self.swapMenuItemContents(liveItem, newItem)
|
|
}
|
|
displacedItems.append(newItem)
|
|
} else {
|
|
menu.insertItem(newItem, at: index)
|
|
menu.removeItem(liveItem)
|
|
displacedItems.append(liveItem)
|
|
}
|
|
}
|
|
if newItems.count > liveCount {
|
|
for offset in liveCount..<newItems.count {
|
|
menu.insertItem(newItems[offset], at: fromIndex + offset)
|
|
}
|
|
} else if liveCount > newItems.count {
|
|
for offset in newItems.count..<liveCount {
|
|
menu.removeItem(liveItems[offset])
|
|
displacedItems.append(liveItems[offset])
|
|
}
|
|
}
|
|
return displacedItems
|
|
}
|
|
|
|
private func finishReconciledHighlightTracking(in menu: NSMenu) {
|
|
let menuKey = ObjectIdentifier(menu)
|
|
guard let highlightedItem = self.highlightedMenuItems[menuKey] else { return }
|
|
guard highlightedItem.menu === menu else {
|
|
self.highlightedMenuItems.removeValue(forKey: menuKey)
|
|
(highlightedItem.view as? MenuCardHighlighting)?.setHighlighted(false)
|
|
return
|
|
}
|
|
guard highlightedItem.isEnabled,
|
|
(highlightedItem.view as? MenuCardHighlighting)?.allowsMenuHighlight != false
|
|
else {
|
|
self.highlightedMenuItems.removeValue(forKey: menuKey)
|
|
(highlightedItem.view as? MenuCardHighlighting)?.setHighlighted(false)
|
|
return
|
|
}
|
|
(highlightedItem.view as? MenuCardHighlighting)?.setHighlighted(true)
|
|
}
|
|
|
|
private func replaceMenuContent(_ menu: NSMenu, fromIndex: Int, with newItems: [NSMenuItem]) {
|
|
while menu.items.count > fromIndex {
|
|
menu.removeItem(at: fromIndex)
|
|
}
|
|
for item in newItems {
|
|
menu.addItem(item)
|
|
}
|
|
}
|
|
|
|
private func updateMenuItemInPlace(_ liveItem: NSMenuItem, from newItem: NSMenuItem) {
|
|
if liveItem.isSeparatorItem { return }
|
|
let remainsHighlighted = liveItem.menu.map {
|
|
self.highlightedMenuItems[ObjectIdentifier($0)] === liveItem
|
|
} ?? false
|
|
// Detach from the scratch item first so a view or submenu is never referenced by
|
|
// two menu items at once.
|
|
let view = newItem.view
|
|
newItem.view = nil
|
|
let submenu = newItem.submenu
|
|
newItem.submenu = nil
|
|
liveItem.view = view
|
|
liveItem.submenu = submenu
|
|
liveItem.title = newItem.title
|
|
liveItem.attributedTitle = newItem.attributedTitle
|
|
liveItem.action = newItem.action
|
|
liveItem.target = newItem.target
|
|
liveItem.representedObject = newItem.representedObject
|
|
liveItem.state = newItem.state
|
|
liveItem.isEnabled = newItem.isEnabled
|
|
let allowsHighlight = (view as? MenuCardHighlighting)?.allowsMenuHighlight != false
|
|
(view as? MenuCardHighlighting)?.setHighlighted(newItem.isEnabled && allowsHighlight && remainsHighlighted)
|
|
liveItem.image = newItem.image
|
|
liveItem.toolTip = newItem.toolTip
|
|
liveItem.keyEquivalent = newItem.keyEquivalent
|
|
liveItem.keyEquivalentModifierMask = newItem.keyEquivalentModifierMask
|
|
liveItem.indentationLevel = newItem.indentationLevel
|
|
liveItem.tag = newItem.tag
|
|
liveItem.identifier = newItem.identifier
|
|
liveItem.isHidden = newItem.isHidden
|
|
liveItem.isAlternate = newItem.isAlternate
|
|
liveItem.allowsKeyEquivalentWhenHidden = newItem.allowsKeyEquivalentWhenHidden
|
|
liveItem.onStateImage = newItem.onStateImage
|
|
liveItem.offStateImage = newItem.offStateImage
|
|
liveItem.mixedStateImage = newItem.mixedStateImage
|
|
if #available(macOS 14.4, *) {
|
|
liveItem.subtitle = newItem.subtitle
|
|
}
|
|
if self.isPersistentRefreshItem(liveItem) {
|
|
self.persistentRefreshItems.add(liveItem)
|
|
}
|
|
}
|
|
|
|
private func swapMenuItemContents(_ liveItem: NSMenuItem, _ cachedItem: NSMenuItem) {
|
|
let holder = NSMenuItem()
|
|
self.updateMenuItemInPlace(holder, from: liveItem)
|
|
self.updateMenuItemInPlace(liveItem, from: cachedItem)
|
|
self.updateMenuItemInPlace(cachedItem, from: holder)
|
|
}
|
|
}
|