TGUIKit 核心

private func getView(for menu: ContextMenu, screen: NSScreen,
                     parentView: Window?, submenuId: Int64?) -> Window {
    let panel = Window(contentRect: .zero,
                       styleMask: [.fullSizeContentView],
                       backing: .buffered, defer: false)
    panel._canBecomeMain = false
    panel._canBecomeKey = false
    panel.level = .screenSaver
    panel.backgroundColor = .clear
    panel.isOpaque = false
    panel.hasShadow = false

    let contentView = View()
    panel.contentView = contentView
    contentView.backgroundColor = .clear
    contentView.flip = false
    contentView.layer?.isOpaque = false

    let view = MenuView(frame: .zero)
    view.submenuId = submenuId
    view.parentView = parentView
    // ...
    panel.setFrame(view.frame.insetBy(dx: -20, dy: -20), display: false)
    panel.contentView?.addSubview(view)
}

open override func updateLayer() {
    super.updateLayer()
    if #available(macOS 10.13, *) {
        guard let backdrop = self.layer?.sublayers?.first else {
            return
        }
        let sublayers = backdrop.sublayers ?? []
        for layer in sublayers {
            if layer.name != "backdrop" && layer.name != "Backdrop" {
                layer.removeFromSuperlayer()
            }
        }
        let allowedKeys: [String] = [
            "colorSaturate",
            "gaussianBlur"
        ]
        sublayers.first?.filters = sublayers.first?.filters?.filter { filter in
            guard let filter = filter as? NSObject else { return true }
            let filterName = String(describing: filter)
            return allowedKeys.contains(filterName)
        }
        // ...

let eventType = event.type
if sheets.isEmpty {
    if eventType == .keyDown {
        applyResponderIfNeeded(event)
        cleanUndefinedHandlers()
        if let globalHandlers = keyHandlers[.All]?.sorted(by: >),
           let keyCode = KeyboardKey(rawValue:event.keyCode) {
            for globalHandler in globalHandlers {
                let handle = keyHandlers[keyCode]?.sorted(by: >).first
                if handle == nil || globalHandler.priority > handle!.priority {
                    if (handle?.modifierFlags == nil ||
                        !event.modifierFlags.contains(handle!.modifierFlags!)) ||
                        globalHandler.priority == .supreme {
                        switch globalHandler.handler(event) {
                        case .invoked: return
                        case .rejected: break
                        case .invokeNext:
                            super.sendEvent(event)
                            return
                        }
                    }
                }
            }
        }
        // ...

public var _transformation: CATransform3D? = nil {
    didSet { self.updateLayer() }
}
public var _anchorPoint: NSPoint? = nil {
    didSet { self.updateLayer() }
}
public var _sublayerTransform: CATransform3D? = nil {
    didSet { self.updateLayer() }
}
open override var wantsUpdateLayer: Bool {
    return self._anchorPoint != nil || self._transformation != nil ||
        self._sublayerTransform != nil
}
open override func updateLayer() {
    super.updateLayer()
    if let _anchorPoint = _anchorPoint {
        self.setAnchorPoint(anchorPoint: _anchorPoint)
    }
    if let _transformation = _transformation {
        self.layer?.transform = _transformation
    }
    if let _sublayerTransform = _sublayerTransform {
        self.layer?.sublayerTransform = _sublayerTransform
    }
}

open override var isFlipped: Bool {
    return flip
}
private func initialize() {
    acceptsTouchEvents = true
    self.wantsLayer = true
    self.layer?.masksToBounds = true
    self.autoresizesSubviews = false
    self.layer?.disableActions()

    self.layer?.backgroundColor = backgroundColor.cgColor
    self.layer?.isOpaque = true
    self.layerContentsRedrawPolicy = .onSetNeedsDisplay
    if #available(macOS 10.15, *) {
        self.layer?.cornerCurve = .continuous
    }
}

open class SimpleShapeLayer : CAShapeLayer {
    public var didEnterHierarchy: (() -> Void)?
    public var didExitHierarchy: (() -> Void)?
    public private(set) var isInHierarchy: Bool = false

    override open func action(forKey event: String) -> CAAction? {
        if event == kCAOnOrderIn {
            self.isInHierarchy = true
            self.didEnterHierarchy?()
        } else if event == kCAOnOrderOut {
            self.isInHierarchy = false
            self.didExitHierarchy?()
        }
        return nullAction
    }

    override public init() {
        super.init()
        contentsScale = System.backingScale
    }
}

public extension CALayer {
    var layerTintColor: CGColor? {
        get {
            if let value = self.value(forKey: "contentsMultiplyColor"),
               CFGetTypeID(value as CFTypeRef) == CGColor.typeID {
                let result = value as! CGColor
                return result
            } else {
                return nil
            }
        }
        set(value) {
            self.setValue(value, forKey: "contentsMultiplyColor")
        }
    }

    func disableActions() -> Void {
        self.actions = ["onOrderIn":NSNull(), "sublayers":NSNull(),
                        "bounds":NSNull(), "frame":NSNull(),
                        "background":NSNull(), "position":NSNull(),
                        "contents":NSNull(), "backgroundColor":NSNull()]
        removeAllAnimations()
    }
}

open override func hitTest(_ point: NSPoint) -> NSView? {
    if isEventLess {
        let view = super.hitTest(point)
        if let view = view as? View {
            if view.isEventLess || view === self {
                return nil
            }
        }
        if let view = view as? ImageView {
            if view.isEventLess || view === self {
                return nil
            }
        }
        if let view = view as? LayerBackedView {
            if view.isEventLess || view === self {
                return nil
            }
        }
        return view
    } else {
        return super.hitTest(point)
    }
}

func _mouseInside() -> Bool {
    if let window = self.window {
        var location:NSPoint = window.mouseLocationOutsideOfEventStream
        location = self.convert(location, from: nil)
        if let view = window.contentView!.hitTest(
            window.mouseLocationOutsideOfEventStream) {
            if let view = view as? View {
                if view.isEventLess {
                    return NSPointInRect(location, self.bounds)
                }
            } else if let view = view as? ImageView, view.isEventLess {
                return NSPointInRect(location, self.bounds)
            } else if let view = view as? LayerBackedView, view.isEventLess {
                return NSPointInRect(location, self.bounds)
            } else if let view = view as? EventLessView, view.isEventLess {
                return NSPointInRect(location, self.bounds)
            } else if let _ = view as? VisualEffect {
                return NSPointInRect(location, self.bounds)
            }
            if view == self {
                return NSPointInRect(location, self.bounds)
            }

open override func updateTrackingAreas() {
    super.updateTrackingAreas();
    if let trackingArea = trackingArea {
        self.removeTrackingArea(trackingArea)
    }
    trackingArea = nil
    if let _ = window, visibleRect != .zero {
        let options:NSTrackingArea.Options = [
            .cursorUpdate, .mouseEnteredAndExited, .mouseMoved,
            .activeInActiveApp, .assumeInside, .inVisibleRect
        ]
        self.trackingArea = NSTrackingArea(rect: self.bounds,
            options: options, owner: self, userInfo: nil)
        self.addTrackingArea(self.trackingArea!)
    }
}
open override func viewDidMoveToSuperview() {
    super.viewDidMoveToSuperview()
    updateTrackingAreas()
}

init?(onQueue queue: DispatchQueue = DispatchQueue.main) {
    source = DispatchSource.makeUserDataAddSource(queue: queue)
    var timerRef : CVDisplayLink? = nil
    var successLink = CVDisplayLinkCreateWithCGDisplay(
        CGMainDisplayID(), &timerRef)
    if let timer = timerRef {
        successLink = CVDisplayLinkSetOutputCallback(timer, {
            (timer, currentTime, outputTime, _, _, sourceUnsafeRaw) -> CVReturn in
            if let sourceUnsafeRaw = sourceUnsafeRaw {
                let sourceUnmanaged = Unmanaged<DispatchSourceUserDataAdd>
                    .fromOpaque(sourceUnsafeRaw)
                sourceUnmanaged.takeUnretainedValue().add(data: 1)
            }
            return kCVReturnSuccess
        }, Unmanaged.passUnretained(source).toOpaque())
        guard successLink == kCVReturnSuccess else {
            NSLog("Failed to create timer with active display")
            return nil
        }
        self.timer = timer
    } else {
        return nil
    }
    source.setEventHandler(handler: { [weak self] in self?.callback?() })
}

private func displayLinkEvent(duration: TimeInterval) {
    self.isProcessingEvent = true
    var removeIndices: [Int]?
    loop: for i in 0 ..< self.requests.count {
        let request = self.requests[i]
        if let link = request.link, link.isValid {
            if !link.isPaused {
                var itemDuration = duration
                switch request.framesPerSecond {
                case let .fps(value):
                    let secondsPerFrame = 1.0 / CGFloat(value)
                    itemDuration = secondsPerFrame
                    request.lastDuration += duration
                    if request.lastDuration >= secondsPerFrame * 0.95 {
                    } else {
                        continue loop
                    }
                case .max:
                    break
                }
                request.lastDuration = 0.0
                link.update(itemDuration)
            }
        }
    // ...

@objc private func tick(_ isFirst: Bool) {
    if self.completed { return }
    let timestamp = CACurrentMediaTime()
    var t = min(timestamp - self.startTime, self.duration) / self.duration
    t = max(0.0, t)
    t = min(1.0, t)
    let solved: Float
    if isFirst {
        solved = 0
    } else {
        solved = TimingFunctionSolve(timingControlPoints, Float(t),
                                     solveEps(Float(duration)))
    }
    self.update(self.fromValue * CGFloat(1 - solved) +
                self.toValue * CGFloat(solved))
    if abs(t - 1.0) < Double.ulpOfOne {
        self.completed = true
        self.displayLink?.invalidate()
        self.completion()
    }
}

case .push:
    controller.view.disableHierarchyDynamicContent()
    previous.viewWillDisappear(true);
    controller.viewWillAppear(true);

    nfrom = popInteractiveInset != nil ? popInteractiveInset! : frame.width
    nto = keepLeft
    pfrom = previous.view.frame.minX
    if previous.stake.keepLeft > 0 && previous.stake.keepLeft != frame.width {
        pto = frame.maxX
    } else if keepLeft > 0 {
        pto = 0
    } else {
        pto = -round(NSWidth(self.frame)/3.0)
    }
    previous.view.setFrameOrigin(NSMakePoint(pfrom, previous.frame.minY))
    controller.view.setFrameOrigin(NSMakePoint(nfrom, controller.frame.minY))
    containerView.addSubview(controller.view, positioned: .above,
                             relativeTo: previous.view)
    sto = -shadowView.frame.width + keepLeft
    if controller.isOpaque {
        addShadowView(.right, controller: controller,
                      updateOrigin: shadowView.superview == nil)
    }

case let .swiping(delta, previous):
    let settings = self.controller.stake
    let keepLeft: CGFloat = self.frame.width == settings.keepLeft
        ? 0 : settings.keepLeft
    let nPosition = min(max(keepLeft, delta + keepLeft),
                        self.containerView.frame.width)
    self.controller.view._change(pos: NSMakePoint(
        nPosition, self.controller.view.frame.minY), animated: false)
    let previousStart = keepLeft > 0 ? 0
        : -round(NSWidth(self.containerView.frame)/3.0)
    previous.view._change(pos: NSMakePoint(
        min(previousStart + max(delta, 0) / 3.0, 0),
        previous.view.frame.minY), animated: false)
    self.shadowView.setFrameOrigin(nPosition - self.shadowView.frame.width,
                                   self.shadowView.frame.minY)
    self.navigationLeftBorder.setFrameOrigin(
        nPosition - self.navigationLeftBorder.frame.width,
        self.navigationLeftBorder.frame.minY)
    self.shadowView.layer?.opacity = min(1.0 - Float(
        nPosition / self.containerView.frame.width) + 0.2, 1.0)
    // ...

background.addSubview(container)
background.userInteractionEnabled = controller.handleEvents
if controller.handleEvents {
    window.set(responder: { [weak controller] () -> NSResponder? in
        return controller?.firstResponder()
    }, with: self, priority: controller.responderPriority)
    if controller.handleAllEvents {
        window.set(handler: { [weak controller] _ -> KeyHandlerResult in
            if let controller = controller, controller.redirectMouseAfterClosing {
                controller.close()
                return .rejected
            }
            return .invokeNext
        }, with: self, for: .All, priority: controller.responderPriority)
    }
    window.set(escape: { [weak self] _ -> KeyHandlerResult in
        if self?.controller?.escapeKeyAction() == .rejected {
            if self?.controller?.closable == true {
                self?.controller?.close()
            }
        }
        return .invoked
    }, with: self, priority: controller.responderPriority)
    // ...

let noBorder = controller.contentBelowBackground ||
    controller.containerBackground == .clear || controller.isFullScreen ||
    !controller.hasBorder
container = ModalContainerView(frame: noBorder ? containerRect :
    containerRect.insetBy(dx: -1, dy: -1))
container.layer?.cornerRadius = controller.cornerRadius
container.background = controller.containerBackground

self.container.layer?.shouldRasterize = true
self.container.layer?.rasterizationScale = CGFloat(System.backingScale)
self.container.layer?.isOpaque = false

let shadow = NSShadow()
shadow.shadowBlurRadius = 20
shadow.shadowColor = NSColor.black.withAlphaComponent(0.3)
shadow.shadowOffset = NSMakeSize(0, 0)
self.container.shadow = shadow

container.layer?.masksToBounds = false
container.container.layer?.masksToBounds = true
container.container.layer?.cornerRadius = controller.cornerRadius
container.borderView.layer?.borderColor =
    controller.modalTheme.grayText.withAlphaComponent(0.1).cgColor
container.borderView.layer?.cornerRadius = controller.cornerRadius

let point = control.convert(NSMakePoint(control.frame.width / 2,
                                        control.frame.height / 2), to: nil)
var anchor = strongSelf.background.convert(point, from: nil)
if strongSelf.background.flip {
    anchor.y += strongSelf.background.frame.height
}
let completion:(Bool)->Void = { [weak controller] _ in
    if let strongSelf = self, !once {
        once = true
        controller?.viewDidAppear(strongSelf.animates)
        if result == true {
            _ = strongSelf.window?.makeFirstResponder(
                controller?.firstResponder())
        } else if result == false {
            _ = strongSelf.window?.makeFirstResponder(nil)
        }
    }
}
switch strongSelf.animationMode {
case .classic:
    strongSelf.background.layer?.animateScaleSpringFrom(
        anchor: anchor, from: 0.1, to: 1.0, duration: 0.4, bounce: false)
    strongSelf.background.layer?.animateAlpha(from: 0, to: 1,
                                               duration: 0.2, completion: completion)
// ...

let updatePosition:(Bool)->Void = { [weak tooltip, weak view, weak window] animated in
    if let tooltip = tooltip, let view = view, let window = window {
        var point = view.convert(NSZeroPoint, to: nil)
        if window.contentView!.isFlipped {
            point.y = window.contentView!.frame.height - point.y -
                view.frame.height / 2 - 10
        }
        point.y += offset.y
        let pos = NSMakePoint(min(max(floorToScreenPixels(
            System.backingScale, point.x -
            (tooltip.frame.width - view.frame.width) / 2), 10),
            window.frame.width - tooltip.frame.width - 10), point.y)
        tooltip.change(pos: pos, animated: isExists || animated)
    }
}
updatePosition(isExists)
if autoCorner {
    let point = tooltip.convert(NSMakePoint(floorToScreenPixels(
        System.backingScale, view.frame.width / 2), 0), from: view)
    tooltip.move(corner: point.x, animated: isExists)
} else {
    let mousePoint = tooltip.convert(location, from: nil)
    tooltip.move(corner: mousePoint.x, animated: isExists)
}

if let superlayer = superlayer {
    if let tile = tile {
        let size = tile.size
        let tileSize = size.aspectFitted(frame.size)
        if shouldTile {
            if tileSize.width < frame.width {
                while rects.reduce(CGFloat(0), { $0 + $1.width }) < frame.width {
                    let width = rects.reduce(CGFloat(0), { $0 + $1.width })
                    rects.append(CGRect(origin: .init(x: width,
                        y: (frame.height - tileSize.height) / 2), size: tileSize))
                }
            } else {
                rects.append(frame.focus(size.aspectFilled(frame.size)))
            }
        } else {
            rects.append(frame.focus(size.aspectFilled(frame.size)))
        }
        while self.tileLayers.count > rects.count {
            self.tileLayers.removeLast().removeFromSuperlayer()
        }
        while self.tileLayers.count < rects.count {
            let layer = SimpleLayer()
            self.tileLayers.append(layer)
        }
        // ...

let nHandler:(Control) -> Void = { [weak strongSelf] control in
    if let strongSelf = strongSelf {
        let s = Signal<Void,NoError>.single(Void()) |> delay(0.2,
            queue: Queue.mainQueue()) |> then(Signal<Void,NoError>.single(Void())
            |> delay(0.2, queue: Queue.mainQueue()) |> restart)
        strongSelf.disposable.set(s.start(next: { [weak strongSelf] () in
            if let strongSelf = strongSelf {
                if !strongSelf.inside() && !control.mouseInside() {
                    if (NSEvent.pressedMouseButtons & (1 << 0)) == 0 {
                        if !contextMenuOnScreen() {
                            strongSelf.hide()
                        }
                    }
                }
            }
        }))
    }
}
var first: Bool = true
// ...