wehub-resource-sync
686 lines
26 KiB
Swift
686 lines
26 KiB
Swift
import AppKit
|
|
import CodexBarCore
|
|
import Observation
|
|
import SwiftUI
|
|
|
|
extension StatusItemController {
|
|
func switcherWeeklyRemaining(for provider: UsageProvider) -> Double? {
|
|
let snapshot = self.store.snapshot(for: provider)
|
|
return Self.switcherWeeklyMetricPercent(
|
|
for: provider,
|
|
snapshot: snapshot,
|
|
showUsed: self.settings.usageBarsShowUsed,
|
|
preference: self.settings.menuBarMetricPreference(for: provider, snapshot: snapshot))
|
|
}
|
|
|
|
func applySubtitle(_ subtitle: String, to item: NSMenuItem, title: String) {
|
|
if #available(macOS 14.4, *) {
|
|
// NSMenuItem.subtitle is only available on macOS 14.4+.
|
|
item.subtitle = subtitle
|
|
} else {
|
|
item.view = self.makeMenuSubtitleView(title: title, subtitle: subtitle, isEnabled: item.isEnabled)
|
|
item.toolTip = "\(title) — \(subtitle)"
|
|
}
|
|
}
|
|
|
|
func makeMenuSubtitleView(title: String, subtitle: String, isEnabled: Bool) -> NSView {
|
|
let container = NSView()
|
|
container.translatesAutoresizingMaskIntoConstraints = false
|
|
container.alphaValue = isEnabled ? 1.0 : 0.7
|
|
|
|
let titleField = NSTextField(labelWithString: title)
|
|
titleField.font = NSFont.menuFont(ofSize: NSFont.systemFontSize)
|
|
titleField.textColor = NSColor.labelColor
|
|
titleField.lineBreakMode = .byTruncatingTail
|
|
titleField.maximumNumberOfLines = 1
|
|
titleField.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
|
|
|
|
let subtitleField = NSTextField(labelWithString: subtitle)
|
|
subtitleField.font = NSFont.menuFont(ofSize: NSFont.smallSystemFontSize)
|
|
subtitleField.textColor = NSColor.secondaryLabelColor
|
|
subtitleField.lineBreakMode = .byTruncatingTail
|
|
subtitleField.maximumNumberOfLines = 1
|
|
subtitleField.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
|
|
|
|
let stack = NSStackView(views: [titleField, subtitleField])
|
|
stack.orientation = .vertical
|
|
stack.alignment = .leading
|
|
stack.spacing = 1
|
|
stack.translatesAutoresizingMaskIntoConstraints = false
|
|
container.addSubview(stack)
|
|
|
|
NSLayoutConstraint.activate([
|
|
stack.leadingAnchor.constraint(equalTo: container.leadingAnchor, constant: 18),
|
|
stack.trailingAnchor.constraint(equalTo: container.trailingAnchor, constant: -10),
|
|
stack.topAnchor.constraint(equalTo: container.topAnchor, constant: 2),
|
|
stack.bottomAnchor.constraint(equalTo: container.bottomAnchor, constant: -2),
|
|
])
|
|
|
|
return container
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
protocol MenuCardHighlighting: AnyObject {
|
|
var allowsMenuHighlight: Bool { get }
|
|
func setHighlighted(_ highlighted: Bool)
|
|
}
|
|
|
|
extension MenuCardHighlighting {
|
|
var allowsMenuHighlight: Bool {
|
|
true
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
protocol MenuCardMeasuring: AnyObject {
|
|
func measuredHeight(width: CGFloat) -> CGFloat
|
|
}
|
|
|
|
@MainActor
|
|
@Observable
|
|
final class MenuCardHighlightState {
|
|
var isHighlighted = false
|
|
}
|
|
|
|
final class MenuHostingView<Content: View>: NSHostingView<Content> {
|
|
/// The height AppKit should give this item's menu row. NSMenu reads `intrinsicContentSize`
|
|
/// (not the explicit `frame`) when it lays out custom-view rows, so a measured height that
|
|
/// only lives in `frame` is silently reverted to the open-time row height — leaving the
|
|
/// SwiftUI content centered in a stale, oversized row. Routing the height through the
|
|
/// intrinsic size is the channel the menu actually honors.
|
|
private var measuredHeight: CGFloat?
|
|
|
|
override var allowsVibrancy: Bool {
|
|
true
|
|
}
|
|
|
|
override var intrinsicContentSize: NSSize {
|
|
guard let measuredHeight else { return super.intrinsicContentSize }
|
|
return NSSize(width: NSView.noIntrinsicMetric, height: measuredHeight)
|
|
}
|
|
|
|
func applyMeasuredHeight(width: CGFloat, height: CGFloat) {
|
|
let resolvedHeight = max(1, ceil(height))
|
|
guard self.measuredHeight != resolvedHeight || self.frame.height != resolvedHeight else { return }
|
|
|
|
self.measuredHeight = resolvedHeight
|
|
self.frame = NSRect(
|
|
origin: self.frame.origin,
|
|
size: NSSize(width: width, height: resolvedHeight))
|
|
self.invalidateIntrinsicContentSize()
|
|
self.layoutSubtreeIfNeeded()
|
|
self.superview?.layoutSubtreeIfNeeded()
|
|
}
|
|
|
|
/// Measures the true SwiftUI content height at `width`. The cached `measuredHeight` is routed
|
|
/// through `intrinsicContentSize`, so `fittingSize` would otherwise echo the stale cached value;
|
|
/// clearing it for the measurement lets the live content size drive the result. Used to resize
|
|
/// the row exactly when expandable content (e.g. status groups) toggles.
|
|
func measuredFittingHeight(width: CGFloat) -> CGFloat {
|
|
let saved = self.measuredHeight
|
|
self.measuredHeight = nil
|
|
self.frame = NSRect(origin: self.frame.origin, size: NSSize(width: width, height: 1))
|
|
self.invalidateIntrinsicContentSize()
|
|
self.layoutSubtreeIfNeeded()
|
|
let height = self.fittingSize.height
|
|
self.measuredHeight = saved
|
|
return height
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
final class MenuCardItemHostingView<Content: View>: NSHostingView<Content>, MenuCardHighlighting, MenuCardMeasuring {
|
|
let highlightState: MenuCardHighlightState
|
|
private(set) var allowsMenuHighlight: Bool
|
|
private var onClick: (() -> Void)?
|
|
private var containsInteractiveControls: Bool
|
|
let interactiveRegionStore: MenuCardInteractiveRegionStore?
|
|
private var isPressed = false
|
|
private var isForwardingHostedControlPress = false
|
|
#if DEBUG
|
|
private var testForwardedHostedControlMouseDown = false
|
|
private var testForwardedHostedControlMouseUp = false
|
|
#endif
|
|
|
|
override var allowsVibrancy: Bool {
|
|
true
|
|
}
|
|
|
|
override var intrinsicContentSize: NSSize {
|
|
let size = super.intrinsicContentSize
|
|
guard self.frame.width > 0 else { return size }
|
|
return NSSize(width: self.frame.width, height: size.height)
|
|
}
|
|
|
|
init(
|
|
rootView: Content,
|
|
highlightState: MenuCardHighlightState,
|
|
allowsMenuHighlight: Bool,
|
|
containsInteractiveControls: Bool = false,
|
|
interactiveRegionStore: MenuCardInteractiveRegionStore? = nil,
|
|
onClick: (() -> Void)? = nil)
|
|
{
|
|
self.highlightState = highlightState
|
|
self.allowsMenuHighlight = allowsMenuHighlight
|
|
self.containsInteractiveControls = containsInteractiveControls
|
|
self.interactiveRegionStore = interactiveRegionStore
|
|
self.onClick = onClick
|
|
super.init(rootView: rootView)
|
|
}
|
|
|
|
/// Reuses this hosting view for a rebuilt card with the same identity: the replaced
|
|
/// `rootView` is diffed in place by SwiftUI instead of tearing down and recreating the
|
|
/// hosting view and its graph. Callers must construct `rootView` around this view's own
|
|
/// `highlightState` so menu hover highlighting keeps driving the rendered content.
|
|
func prepareForReuse(
|
|
rootView: Content,
|
|
allowsMenuHighlight: Bool,
|
|
containsInteractiveControls: Bool = false,
|
|
onClick: (() -> Void)?)
|
|
{
|
|
self.rootView = rootView
|
|
self.allowsMenuHighlight = allowsMenuHighlight
|
|
self.containsInteractiveControls = containsInteractiveControls
|
|
self.onClick = onClick
|
|
self.isPressed = false
|
|
self.isForwardingHostedControlPress = false
|
|
}
|
|
|
|
/// `NSMenu` tracking consumes keyboard events before they reach a menu item's custom view, so
|
|
/// the pointer `onClick` path has no native counterpart for assistive tech. Expose the row as an
|
|
/// accessibility button whose press mirrors a click, giving VoiceOver an activation path that runs
|
|
/// `onClick` (and therefore keeps the menu open) instead of regressing to mouse-only.
|
|
override func accessibilityRole() -> NSAccessibility.Role? {
|
|
self.onClick == nil ? super.accessibilityRole() : .button
|
|
}
|
|
|
|
override func accessibilityPerformPress() -> Bool {
|
|
guard let onClick = self.onClick else {
|
|
return super.accessibilityPerformPress()
|
|
}
|
|
onClick()
|
|
return true
|
|
}
|
|
|
|
required init(rootView: Content) {
|
|
self.highlightState = MenuCardHighlightState()
|
|
self.allowsMenuHighlight = false
|
|
self.containsInteractiveControls = false
|
|
self.interactiveRegionStore = nil
|
|
self.onClick = nil
|
|
super.init(rootView: rootView)
|
|
}
|
|
|
|
@available(*, unavailable)
|
|
required init?(coder: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
|
|
override func acceptsFirstMouse(for event: NSEvent?) -> Bool {
|
|
true
|
|
}
|
|
|
|
override func hitTest(_ point: NSPoint) -> NSView? {
|
|
let descendant = super.hitTest(point)
|
|
if let descendant {
|
|
var current: NSView? = descendant
|
|
while let view = current, view !== self {
|
|
if view is NSButton || view is NSControl {
|
|
return descendant
|
|
}
|
|
current = view.superview
|
|
}
|
|
if self.hitsHostedInteractiveControl(at: point) {
|
|
return descendant
|
|
}
|
|
if descendant !== self, self.onClick != nil {
|
|
return self
|
|
}
|
|
}
|
|
return descendant
|
|
}
|
|
|
|
private func locationInView(for event: NSEvent) -> NSPoint {
|
|
guard self.window != nil else {
|
|
return event.locationInWindow
|
|
}
|
|
return self.convert(event.locationInWindow, from: nil)
|
|
}
|
|
|
|
override func mouseDown(with event: NSEvent) {
|
|
guard event.type == .leftMouseDown, self.onClick != nil else {
|
|
super.mouseDown(with: event)
|
|
return
|
|
}
|
|
let localPoint = self.locationInView(for: event)
|
|
if self.beginPrimaryPress(at: localPoint) {
|
|
#if DEBUG
|
|
self.testForwardedHostedControlMouseDown = true
|
|
#endif
|
|
super.mouseDown(with: event)
|
|
}
|
|
}
|
|
|
|
override func mouseUp(with event: NSEvent) {
|
|
guard event.type == .leftMouseUp, self.onClick != nil else {
|
|
super.mouseUp(with: event)
|
|
return
|
|
}
|
|
let result = self.endPrimaryPress(at: self.locationInView(for: event))
|
|
if result.forwardToHostedControl {
|
|
#if DEBUG
|
|
self.testForwardedHostedControlMouseUp = true
|
|
#endif
|
|
super.mouseUp(with: event)
|
|
return
|
|
}
|
|
if result.invokeRowAction {
|
|
self.onClick?()
|
|
}
|
|
}
|
|
|
|
/// Returns whether AppKit should forward the press into a nested SwiftUI control.
|
|
private func beginPrimaryPress(at point: NSPoint) -> Bool {
|
|
if self.hitsHostedInteractiveControl(at: point) {
|
|
self.isForwardingHostedControlPress = true
|
|
return true
|
|
}
|
|
self.isPressed = self.bounds.contains(point)
|
|
return false
|
|
}
|
|
|
|
private func endPrimaryPress(at point: NSPoint) -> (forwardToHostedControl: Bool, invokeRowAction: Bool) {
|
|
if self.isForwardingHostedControlPress {
|
|
self.isForwardingHostedControlPress = false
|
|
return (true, false)
|
|
}
|
|
defer { self.isPressed = false }
|
|
return (false, self.isPressed && self.bounds.contains(point))
|
|
}
|
|
|
|
private func hitsHostedInteractiveControl(at point: NSPoint) -> Bool {
|
|
self.containsInteractiveControls &&
|
|
(self.interactiveRegionStore?.contains(
|
|
point,
|
|
hostingBounds: self.bounds,
|
|
fittedSize: self.fittingSize) == true)
|
|
}
|
|
|
|
func measuredHeight(width: CGFloat) -> CGFloat {
|
|
self.frame = NSRect(origin: self.frame.origin, size: NSSize(width: width, height: 1))
|
|
self.layoutSubtreeIfNeeded()
|
|
return self.fittingSize.height
|
|
}
|
|
|
|
func setHighlighted(_ highlighted: Bool) {
|
|
guard self.highlightState.isHighlighted != highlighted else { return }
|
|
self.highlightState.isHighlighted = highlighted
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
final class PersistentRefreshMenuView: NSView, MenuCardHighlighting {
|
|
private static let minimumShortcutColumnWidth: CGFloat = 44
|
|
private static let titleShortcutGap: CGFloat = 8
|
|
private static let shortcutReferenceText = "⌘ R"
|
|
|
|
private let selectionView = NSVisualEffectView()
|
|
private let iconView = NSImageView()
|
|
private let titleField: NSTextField
|
|
private let shortcutField: NSTextField?
|
|
private var isRowHighlighted = false
|
|
private var isRowEnabled = true
|
|
private var rowHeight = PersistentRefreshRowMetrics.defaults.rowHeight
|
|
private var onClick: (() -> Void)?
|
|
|
|
override var allowsVibrancy: Bool {
|
|
true
|
|
}
|
|
|
|
override var intrinsicContentSize: NSSize {
|
|
NSSize(width: self.frame.width, height: self.rowHeight)
|
|
}
|
|
|
|
init(
|
|
title: String,
|
|
systemImageName: String?,
|
|
shortcutText: String?,
|
|
onClick: (() -> Void)? = nil)
|
|
{
|
|
self.titleField = NSTextField(labelWithString: title)
|
|
self.shortcutField = shortcutText.map(NSTextField.init(labelWithString:))
|
|
self.onClick = onClick
|
|
super.init(frame: .zero)
|
|
self.setupSelectionView()
|
|
self.setupIconView(systemImageName: systemImageName)
|
|
self.setupTextFields()
|
|
if onClick != nil {
|
|
self.installClickRecognizer()
|
|
}
|
|
self.updateColors()
|
|
}
|
|
|
|
@available(*, unavailable)
|
|
required init?(coder _: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
|
|
override func acceptsFirstMouse(for event: NSEvent?) -> Bool {
|
|
true
|
|
}
|
|
|
|
override func accessibilityRole() -> NSAccessibility.Role? {
|
|
self.onClick == nil ? super.accessibilityRole() : .button
|
|
}
|
|
|
|
override func accessibilityLabel() -> String? {
|
|
self.titleField.stringValue
|
|
}
|
|
|
|
override func isAccessibilityEnabled() -> Bool {
|
|
self.isRowEnabled
|
|
}
|
|
|
|
override func accessibilityPerformPress() -> Bool {
|
|
guard self.isRowEnabled else { return false }
|
|
guard let onClick = self.onClick else {
|
|
return super.accessibilityPerformPress()
|
|
}
|
|
onClick()
|
|
return true
|
|
}
|
|
|
|
func applySize(width: CGFloat, height: CGFloat) {
|
|
self.rowHeight = max(1, ceil(height))
|
|
self.frame = NSRect(origin: .zero, size: NSSize(width: width, height: self.rowHeight))
|
|
self.invalidateIntrinsicContentSize()
|
|
self.needsLayout = true
|
|
}
|
|
|
|
func setHighlighted(_ highlighted: Bool) {
|
|
guard self.isRowHighlighted != highlighted else { return }
|
|
self.isRowHighlighted = highlighted
|
|
self.selectionView.isHidden = !highlighted
|
|
self.updateColors()
|
|
}
|
|
|
|
func setEnabled(_ enabled: Bool) {
|
|
guard self.isRowEnabled != enabled else { return }
|
|
self.isRowEnabled = enabled
|
|
if !enabled {
|
|
self.isRowHighlighted = false
|
|
self.selectionView.isHidden = true
|
|
}
|
|
self.updateColors()
|
|
}
|
|
|
|
override func layout() {
|
|
super.layout()
|
|
|
|
let metrics = PersistentRefreshRowMetrics.defaults
|
|
self.selectionView.frame = self.bounds.insetBy(
|
|
dx: metrics.selectionHorizontalInset,
|
|
dy: metrics.selectionVerticalInset)
|
|
self.selectionView.layer?.cornerRadius = metrics.selectionCornerRadius
|
|
|
|
var leadingX = metrics.leadingPadding
|
|
if self.iconView.image != nil {
|
|
let iconSide = metrics.iconWidth
|
|
self.iconView.symbolConfiguration = Self.iconConfiguration(for: metrics)
|
|
self.iconView.frame = NSRect(
|
|
x: leadingX,
|
|
y: floor((self.bounds.height - iconSide) / 2),
|
|
width: iconSide,
|
|
height: iconSide)
|
|
leadingX += metrics.iconWidth + metrics.iconTitleSpacing
|
|
}
|
|
|
|
var titleMaxX = self.bounds.maxX - metrics.trailingPadding
|
|
if let shortcutField {
|
|
shortcutField.font = Self.shortcutFont(for: metrics)
|
|
let shortcutSize = shortcutField.intrinsicContentSize
|
|
let referenceWidth = Self.shortcutReferenceWidth(for: metrics)
|
|
let shortcutColumnWidth = max(Self.minimumShortcutColumnWidth, referenceWidth, shortcutSize.width)
|
|
let shortcutX = self.bounds.maxX
|
|
- metrics.trailingPadding
|
|
+ metrics.shortcutXOffset
|
|
- referenceWidth
|
|
shortcutField.frame = NSRect(
|
|
x: shortcutX,
|
|
y: floor((self.bounds.height - shortcutSize.height) / 2) + metrics.shortcutYOffset,
|
|
width: shortcutColumnWidth,
|
|
height: shortcutSize.height)
|
|
titleMaxX = shortcutX - Self.titleShortcutGap
|
|
}
|
|
|
|
let titleSize = self.titleField.intrinsicContentSize
|
|
self.titleField.frame = NSRect(
|
|
x: leadingX,
|
|
y: floor((self.bounds.height - titleSize.height) / 2),
|
|
width: max(0, titleMaxX - leadingX),
|
|
height: titleSize.height)
|
|
}
|
|
|
|
private func setupSelectionView() {
|
|
self.selectionView.material = .selection
|
|
self.selectionView.blendingMode = .withinWindow
|
|
self.selectionView.state = .active
|
|
self.selectionView.isEmphasized = true
|
|
self.selectionView.isHidden = true
|
|
self.selectionView.wantsLayer = true
|
|
self.selectionView.layer?.masksToBounds = true
|
|
self.addSubview(self.selectionView)
|
|
}
|
|
|
|
private func setupIconView(systemImageName: String?) {
|
|
guard let systemImageName,
|
|
let baseImage = NSImage(systemSymbolName: systemImageName, accessibilityDescription: nil)
|
|
else {
|
|
self.iconView.isHidden = true
|
|
return
|
|
}
|
|
|
|
baseImage.isTemplate = true
|
|
self.iconView.image = baseImage
|
|
self.iconView.symbolConfiguration = Self.iconConfiguration(for: PersistentRefreshRowMetrics.defaults)
|
|
self.iconView.imageScaling = .scaleProportionallyDown
|
|
self.iconView.contentTintColor = .labelColor
|
|
self.addSubview(self.iconView)
|
|
}
|
|
|
|
private func setupTextFields() {
|
|
// Title truncates, shortcut clips; configuring them separately keeps the shortcut column stable.
|
|
self.titleField.font = NSFont.menuFont(ofSize: 0)
|
|
self.configureTitleField(self.titleField)
|
|
|
|
if let shortcutField {
|
|
shortcutField.font = Self.shortcutFont(for: PersistentRefreshRowMetrics.defaults)
|
|
self.configureShortcutField(shortcutField)
|
|
}
|
|
}
|
|
|
|
private func configureTitleField(_ field: NSTextField) {
|
|
field.lineBreakMode = .byTruncatingTail
|
|
field.maximumNumberOfLines = 1
|
|
field.allowsDefaultTighteningForTruncation = true
|
|
field.backgroundColor = .clear
|
|
self.addSubview(field)
|
|
}
|
|
|
|
private func configureShortcutField(_ field: NSTextField) {
|
|
field.alignment = .left
|
|
field.lineBreakMode = .byClipping
|
|
field.maximumNumberOfLines = 1
|
|
field.allowsDefaultTighteningForTruncation = false
|
|
field.backgroundColor = .clear
|
|
self.addSubview(field)
|
|
}
|
|
|
|
private func installClickRecognizer() {
|
|
let recognizer = NSClickGestureRecognizer(target: self, action: #selector(self.handlePrimaryClick(_:)))
|
|
recognizer.buttonMask = 0x1
|
|
self.addGestureRecognizer(recognizer)
|
|
}
|
|
|
|
private func updateColors() {
|
|
guard self.isRowEnabled else {
|
|
self.titleField.textColor = .disabledControlTextColor
|
|
self.shortcutField?.textColor = .disabledControlTextColor
|
|
self.iconView.contentTintColor = .disabledControlTextColor
|
|
return
|
|
}
|
|
|
|
if self.isRowHighlighted {
|
|
self.titleField.textColor = .selectedMenuItemTextColor
|
|
self.shortcutField?.textColor = .selectedMenuItemTextColor
|
|
self.iconView.contentTintColor = .selectedMenuItemTextColor
|
|
return
|
|
}
|
|
|
|
self.titleField.textColor = .labelColor
|
|
self.shortcutField?.textColor = .tertiaryLabelColor
|
|
self.iconView.contentTintColor = .labelColor
|
|
}
|
|
|
|
private static func iconConfiguration(for metrics: PersistentRefreshRowMetrics) -> NSImage.SymbolConfiguration {
|
|
NSImage.SymbolConfiguration(pointSize: metrics.iconSymbolPointSize, weight: metrics.iconSymbolWeight)
|
|
}
|
|
|
|
private static func shortcutFont(for metrics: PersistentRefreshRowMetrics) -> NSFont {
|
|
NSFont.menuFont(ofSize: metrics.shortcutFontSize)
|
|
}
|
|
|
|
private static func shortcutReferenceWidth(for metrics: PersistentRefreshRowMetrics) -> CGFloat {
|
|
(self.shortcutReferenceText as NSString).size(withAttributes: [
|
|
.font: self.shortcutFont(for: metrics),
|
|
]).width
|
|
}
|
|
|
|
@objc private func handlePrimaryClick(_ recognizer: NSClickGestureRecognizer) {
|
|
guard recognizer.state == .ended else { return }
|
|
guard self.isRowEnabled else { return }
|
|
self.onClick?()
|
|
}
|
|
}
|
|
|
|
#if DEBUG
|
|
extension MenuCardItemHostingView {
|
|
var _test_forwardedHostedControlEvents: (mouseDown: Bool, mouseUp: Bool) {
|
|
(self.testForwardedHostedControlMouseDown, self.testForwardedHostedControlMouseUp)
|
|
}
|
|
|
|
func _test_hitsHostedInteractiveControl(at point: NSPoint) -> Bool {
|
|
self.hitsHostedInteractiveControl(at: point)
|
|
}
|
|
|
|
func _test_simulateRuntimeClick(at point: NSPoint? = nil) -> Bool {
|
|
let clickPoint = point ?? NSPoint(x: self.bounds.midX, y: self.bounds.midY)
|
|
guard let onClick = self.onClick else { return false }
|
|
guard !self.beginPrimaryPress(at: clickPoint) else {
|
|
_ = self.endPrimaryPress(at: clickPoint)
|
|
return false
|
|
}
|
|
let result = self.endPrimaryPress(at: clickPoint)
|
|
guard result.invokeRowAction else { return false }
|
|
onClick()
|
|
return true
|
|
}
|
|
}
|
|
#endif
|
|
|
|
struct MenuCardSectionContainerView<Content: View>: View {
|
|
@Bindable var highlightState: MenuCardHighlightState
|
|
let showsSubmenuIndicator: Bool
|
|
let submenuIndicatorAlignment: Alignment
|
|
let submenuIndicatorTopPadding: CGFloat
|
|
var refreshMonitor: MenuCardRefreshMonitor?
|
|
var interactiveRegionStore: MenuCardInteractiveRegionStore?
|
|
@ViewBuilder let content: () -> Content
|
|
|
|
init(
|
|
highlightState: MenuCardHighlightState,
|
|
showsSubmenuIndicator: Bool,
|
|
submenuIndicatorAlignment: Alignment,
|
|
submenuIndicatorTopPadding: CGFloat,
|
|
refreshMonitor: MenuCardRefreshMonitor?,
|
|
interactiveRegionStore: MenuCardInteractiveRegionStore? = nil,
|
|
@ViewBuilder content: @escaping () -> Content)
|
|
{
|
|
self.highlightState = highlightState
|
|
self.showsSubmenuIndicator = showsSubmenuIndicator
|
|
self.submenuIndicatorAlignment = submenuIndicatorAlignment
|
|
self.submenuIndicatorTopPadding = submenuIndicatorTopPadding
|
|
self.refreshMonitor = refreshMonitor
|
|
self.interactiveRegionStore = interactiveRegionStore
|
|
self.content = content
|
|
}
|
|
|
|
var body: some View {
|
|
self.content()
|
|
.environment(\.menuItemHighlighted, self.highlightState.isHighlighted)
|
|
.environment(\.menuCardRefreshMonitor, self.refreshMonitor)
|
|
.coordinateSpace(name: MenuCardInteractiveRegionPreferenceKey.coordinateSpaceName)
|
|
.onPreferenceChange(MenuCardInteractiveRegionPreferenceKey.self) { regions in
|
|
self.interactiveRegionStore?.regions = regions
|
|
}
|
|
.foregroundStyle(MenuHighlightStyle.primary(self.highlightState.isHighlighted))
|
|
.background(alignment: .topLeading) {
|
|
if self.highlightState.isHighlighted {
|
|
RoundedRectangle(cornerRadius: 6, style: .continuous)
|
|
.fill(MenuHighlightStyle.selectionBackground(true))
|
|
.padding(.horizontal, 6)
|
|
.padding(.vertical, 2)
|
|
}
|
|
}
|
|
.overlay(alignment: self.submenuIndicatorAlignment) {
|
|
if self.showsSubmenuIndicator {
|
|
Image(systemName: "chevron.right")
|
|
.font(.caption2.weight(.semibold))
|
|
.foregroundStyle(MenuHighlightStyle.secondary(self.highlightState.isHighlighted))
|
|
.padding(.top, self.submenuIndicatorTopPadding)
|
|
.padding(.trailing, 10)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
@Observable
|
|
final class MenuCardInteractiveRegionStore {
|
|
var regions: [CGRect] = []
|
|
|
|
func contains(_ point: CGPoint, hostingBounds: CGRect, fittedSize: CGSize) -> Bool {
|
|
// NSHostingView centers intrinsic-height SwiftUI content in the menu item's padded frame.
|
|
// Preference rectangles use the SwiftUI root's coordinates, so remove that AppKit offset.
|
|
let contentOrigin = CGPoint(
|
|
x: max(0, (hostingBounds.width - fittedSize.width) / 2),
|
|
y: max(0, (hostingBounds.height - fittedSize.height) / 2))
|
|
let contentPoint = CGPoint(x: point.x - contentOrigin.x, y: point.y - contentOrigin.y)
|
|
return self.regions.contains { $0.contains(contentPoint) }
|
|
}
|
|
}
|
|
|
|
struct MenuCardInteractiveRegionPreferenceKey: PreferenceKey {
|
|
static let coordinateSpaceName = "MenuCardInteractiveRegion"
|
|
static let defaultValue: [CGRect] = []
|
|
|
|
static func reduce(value: inout [CGRect], nextValue: () -> [CGRect]) {
|
|
value.append(contentsOf: nextValue())
|
|
}
|
|
}
|
|
|
|
extension View {
|
|
func menuCardInteractiveControl(isEnabled: Bool = true) -> some View {
|
|
self.background {
|
|
GeometryReader { proxy in
|
|
Color.clear.preference(
|
|
key: MenuCardInteractiveRegionPreferenceKey.self,
|
|
value: isEnabled
|
|
? [proxy.frame(in: .named(MenuCardInteractiveRegionPreferenceKey.coordinateSpaceName))]
|
|
: [])
|
|
}
|
|
}
|
|
}
|
|
}
|