导航、手势与上下文菜单

UIView<UIKitPortalViewProtocol> * _Nullable makePortalView(bool matchPosition) {
    static Class portalViewClass = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        portalViewClass = NSClassFromString([@[@"_", @"UI", @"Portal", @"View"] componentsJoinedByString:@""]);
    });
    if (!portalViewClass) {
        return nil;
    }
    UIView<UIKitPortalViewProtocol> *view = [[portalViewClass alloc] init];
    if (@available(iOS 14.0, *)) {
        view.forwardsClientHitTestingToSourceView = false;
    }
    view.matchesPosition = matchPosition;
    view.matchesTransform = matchPosition;
    view.matchesAlpha = false;
    if (@available(iOS 14.0, *)) {
        view.allowsHitTesting = false;
    }
    return view;
}

let wrapperFrameInWindow = CGRect(origin: wrapperOriginInWindow, size: containingItem.view.bounds.size)
wrapper.frame = surface.convert(wrapperFrameInWindow, from: nil)
surface.addSubview(wrapper)

switch containingItem {
case let .node(containingNode):
    wrapper.addSubview(containingNode.contentNode.view)
case let .view(containingView):
    wrapper.addSubview(containingView.contentView)
}

wrapper.addPortal(view: clone)
overlayHost.addSubview(clone.view)

self.surface = surface
self.wrapper = wrapper
self.clone = clone
self.containingItem = containingItem

return wrapper.layer

// This is what catches a tap outside the menu contents, which is what dismisses the menu.
// A layer that renders nothing at all does not receive those taps.
// The filter is not in `-hitTest:`.
// It is in touch delivery, against what the layer actually renders.
// Giving the layer fully transparent contents is enough to make it participate.
// It does not depend on an undocumented opacity threshold.
// Invisible, and harmless for the dim/blur cases.
self.backgroundNode.layer.contents = transparentHitTestImage.cgImage

for i in 0 ..< configuration.sources.count {
    let source = configuration.sources[i]
    let mappedSource = Source(
        controller: controller,
        id: source.id,
        title: source.title,
        footer: source.footer,

let contentNodeValue = ItemContentNode(containingItem: takeInfo.containingItem)
contentNodeValue.animateClippingFromContentAreaInScreenSpace = takeInfo.contentAreaInScreenSpace
contentNodeValue.sourceTransitionSurface = takeInfo.sourceTransitionSurface

let sourceView = takeInfo.containingItem.view
let modeledWidth = sourceView.bounds.width
if modeledWidth > 0.001 {
    let visualWidth = sourceView.convert(sourceView.bounds, to: nil).width
    let detectedScale = visualWidth / modeledWidth
    if abs(detectedScale - 1.0) > 0.001 {
        contentNodeValue.presentationScale = detectedScale
        contentNodeValue.offsetContainerNode.layer.transform = CATransform3DMakeScale(
            detectedScale, detectedScale, 1.0
        )
    }
}

self.scrollNode.insertSubnode(contentNodeValue, aboveSubnode: self.actionsContainerNode)
self.itemContentNode = contentNodeValue

let displacement = residual + modelDelta / compensationScale

var durationFactor = UIView.animationDurationFactor()
if durationFactor.isZero {
    durationFactor = 1.0
}
let elapsed = (CACurrentMediaTime() - animatingOutState.startTimestamp) / durationFactor
let remainingDuration = max(0.0, animatingOutState.duration - elapsed)

let key = "animateOutRetarget"
if abs(displacement) < CGFloat.ulpOfOne || remainingDuration < Double.ulpOfOne {
    animateLayer.removeAnimation(forKey: key)
} else {
    animateLayer.animate(
        from: displacement as NSNumber,
        to: 0.0 as NSNumber,
        keyPath: "bounds.origin.y",
        timingFunction: animatingOutState.timingFunction,
        duration: remainingDuration,
        delay: 0.0,
        additive: true,
        key: key
    )
}

if let target = self.view?.hitTest(self.firstLocation, with: event) {
    let horizontalGestures = hasHorizontalGestures(
        target, point: self.view?.convert(self.firstLocation, to: target)
    )
    switch horizontalGestures {
    case .some, .strict:
        if allowedDirections.contains(.down) {
        } else if case .strict = horizontalGestures {
            allowedDirections = []
        } else if allowedDirections.contains(.leftEdge) || allowedDirections.contains(.rightEdge) {
            allowedDirections.remove(.leftCenter)
            allowedDirections.remove(.rightCenter)
        }
    case .none:
        break
    }
}
if allowedDirections.isEmpty {
    self.state = .failed
} else {
    self.currentAllowedDirections = allowedDirections
}

let navigationTransitionCoordinator = NavigationTransitionCoordinator(transition: .Pop, isInteractive: true, isFlat: self.isFlat, container: self, topNode: topNode, topNavigationBar: topController.transitionNavigationBar, bottomNode: bottomNode, bottomNavigationBar: bottomController.transitionNavigationBar, screenCornerRadius: screenCornerRadius, didUpdateProgress: { [weak self, weak bottomController] progress, transition, topFrame, bottomFrame in
    if let strongSelf = self {
        if let top = strongSelf.state.top {
            strongSelf.syncKeyboard(leftEdge: top.value.displayNode.frame.minX, transition: transition)
            
            var updatedStatusBarStyle = strongSelf.statusBarStyle
            if let bottomController = bottomController, progress >= 0.3 {
                updatedStatusBarStyle = bottomController.statusBar.statusBarStyle
            } else {
                updatedStatusBarStyle = top.value.statusBar.statusBarStyle
            }
            if strongSelf.statusBarStyle != updatedStatusBarStyle {
                strongSelf.statusBarStyle = updatedStatusBarStyle
                strongSelf.statusBarStyleUpdated?(.animated(duration: 0.3, curve: .easeInOut))
            }
        }
    }
})
bottomController.displayNode.recursivelyEnsureDisplaySynchronously(true)

let containerSize = self.container.bounds.size
let topFrame = CGRect(
    origin: CGPoint(x: floorToScreenPixels(position * containerSize.width), y: 0.0),
    size: containerSize
)
let bottomFrame = CGRect(
    origin: CGPoint(
        x: self.isFlat ? -floorToScreenPixels((1.0 - position) * containerSize.width)
                       : ((position - 1.0) * containerSize.width * 0.3),
        y: 0.0
    ),
    size: containerSize
)
transition.updateFrame(node: self.topNode, frame: topFrame, completion: { _ in
    if canInvokeCompletion { completion() } else { hadEarlyCompletion = true }
})
transition.updateFrame(node: self.dimNode, frame: CGRect(
    origin: CGPoint(x: 0.0, y: dimInset),
    size: CGSize(width: max(0.0, topFrame.minX + self.container.overflowInset + 62.0), height: self.container.bounds.size.height - dimInset)
))
transition.updateAlpha(node: self.dimNode, alpha: (1.0 - position) * 0.15)
transition.updateFrame(node: self.bottomNode, frame: bottomFrame)

self.topNavigationBar = topNavigationBar
self.topNavigationBarSupernode = topNavigationBar.supernode
self.bottomNavigationBar = bottomNavigationBar
self.bottomNavigationBarSupernode = bottomNavigationBar.supernode

self.topClippingNode = ASDisplayNode()
self.topClippingNode.clipsToBounds = true
self.bottomClippingNode = ASDisplayNode()
self.bottomClippingNode.clipsToBounds = true

self.topClippingNode.addSubnode(self.topNavigationBar)
self.bottomClippingNode.addSubnode(self.bottomNavigationBar)
self.addSubnode(self.bottomClippingNode)
self.addSubnode(self.topClippingNode)

func complete() {
    self.topNavigationBarSupernode?.addSubnode(self.topNavigationBar)
    self.bottomNavigationBarSupernode?.addSubnode(self.bottomNavigationBar)
}

let windowLocation = touch.location(in: nil)
if windowLocation.x < 8.0 {
    self.state = .failed
    return
}

let delayTimer = Timer(timeInterval: self.beginDelay, target: TimerTargetWrapper { [weak self] in
    guard let strongSelf = self, let _ = strongSelf.delayTimer else {
        return
    }
    strongSelf.isValidated = true
    if strongSelf.animator == nil {
        strongSelf.animator = DisplayLinkAnimator(duration: 0.2, from: 0.0, to: 1.0, update: { value in
            guard let strongSelf = self else {
                return
            }
            if strongSelf.isValidated {
                strongSelf.currentProgress = value
                strongSelf.activationProgress?(value, .update)
            }
        }, completion: {
            guard let strongSelf = self else {
                return
            }
            switch strongSelf.state {
            case .possible:
                strongSelf.delayTimer?.invalidate()
                strongSelf.animator?.invalidate()
                strongSelf.activated?(strongSelf, location)
                strongSelf.wasActivated = true
                // ... 取消同窗口和父链手势。
                strongSelf.state = .began
            default:
                break
            }
        })
    }
}, selector: #selector(TimerTargetWrapper.timerEvent), userInfo: nil, repeats: false)

if #available(iOS 13.4, *) {
    isSecondary = event.buttonMask == .secondary
} else {
    isSecondary = false
}

if let hitResult = self.view?.hitTest(touch.location(in: self.view), with: event),
   let _ = hitResult as? UIButton {
    self.state = .failed
    return
}

self.tapCount += 1
if self.tapCount == 2 && self.touchCount == 1 {
    self.timer?.invalidate()
    self.timer = nil
    self.lastRecognizedGestureAndLocation = (.doubleTap, self.location(in: self.view))
    self.state = .ended
} else {
    let touchLocationAndTimestamp = (touch.location(in: self.view), CACurrentMediaTime())
    self.touchLocationAndTimestamp = touchLocationAndTimestamp
    var tapAction: TapLongTapOrDoubleTapGestureRecognizerAction = .waitForDoubleTap
    if let tapActionAtPoint = self.tapActionAtPoint {
        tapAction = tapActionAtPoint(touchLocationAndTimestamp.0)
    }

func animateIn(from rect: CGRect) {
    self.dimNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.3)
    self.blurView.layer.animateAlpha(from: 0.0, to: self.blurView.alpha, duration: 0.3)

    let offset = CGPoint(
        x: rect.midX - self.containerNode.position.x,
        y: rect.midY - self.containerNode.position.y
    )
    self.containerNode.layer.animateSpring(
        from: NSValue(cgPoint: offset), to: NSValue(cgPoint: CGPoint()),
        keyPath: "position", duration: 0.4, initialVelocity: 0.0,
        damping: 110.0, additive: true
    )

    if let appeared = self.controller?.appeared {
        appeared()
        let scale = rect.width / self.contentNode.frame.width
        self.containerNode.layer.animateSpring(
            from: scale as NSNumber, to: 1.0 as NSNumber,
            keyPath: "transform.scale", duration: 0.4, initialVelocity: 0.0, damping: 110.0
        )
    }
}

var found = false
let point = touch.location(in: self.view)
if let scrollView = traceScrollView(view: view, point: point) {
    let contentOffset = scrollView.contentOffset
    let contentInset = scrollView.contentInset
    if contentOffset.y.isLessThanOrEqualTo(contentInset.top) {
        found = true
    }
}
if found {
    self.beginPosition = point
} else {
    self.state = .failed
}

let translation = CGPoint(x: point.x - self.beginPosition.x, y: point.y - self.beginPosition.y)
if self.state == .possible {
    if abs(translation.x) > 5.0 {
        self.state = .failed
        return
    }
    if lockDown && translation.y > 2.0 {
        self.state = .began
    }
}

self.addSubnode(self.containerNode)
self.controllerView = self.item.controller.displayNode.view
self.containerNode.view.addSubview(self.item.controller.displayNode.view)

Queue.mainQueue().after(0.45) {
    self.isReady = true
    if !self.isDismissed, let snapshotView = self.item.controller.makeContentSnapshotView() {
        self.containerNode.view.addSubview(self.snapshotContainerView)
        self.snapshotView = snapshotView
        self.controllerView?.removeFromSuperview()
        self.controllerView = nil
        self.snapshotContainerView.addSubview(snapshotView)
        self.requestLayout(transition: .immediate)
    }
}

self.addSubnode(self.headerNode)
self.addSubnode(self.dimCoverNode)

if requiresBlur {
    let blurredSnapshotView: UIView?
    if let current = self.blurredSnapshotView {
        blurredSnapshotView = current
    } else {
        blurredSnapshotView = snapshotView.snapshotView(afterScreenUpdates: false)
        if let blurredSnapshotView {
            if let blurFilter = makeBlurFilter() {
                blurFilter.setValue(20.0 as NSNumber, forKey: "inputRadius")
                blurFilter.setValue(true as NSNumber, forKey: "inputNormalizeEdges")
                blurredSnapshotView.layer.filters = [blurFilter]
            }
            self.snapshotContainerView.insertSubview(blurredSnapshotView, at: 0)
            self.blurredSnapshotView = blurredSnapshotView
        }
    }
    blurredSnapshotView?.frame = blurFrame
} else if let blurredSnapshotView = self.blurredSnapshotView {
    self.blurredSnapshotView = nil
    blurredSnapshotView.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2,
        removeOnCompletion: false, completion: { _ in blurredSnapshotView.removeFromSuperview() })
}

if self.isExpanded {
    let currentItemFrame = frameForIndex(
        index: index, size: layout.size, insets: itemInsets,
        itemCount: self.items.count, boundingSize: layout.size
    )
    let currentItemTransform = final3dTransform(
        for: currentItemFrame.minY, size: currentItemFrame.size,
        contentHeight: contentHeight, itemCount: self.items.count,
        additionalAngle: self.highlightedItemId == item.id ? 0.04 : nil,
        scrollBounds: effectiveScrollBounds, insets: itemInsets
    )
    var effectiveItemFrame = currentItemFrame
    let effectiveItemTransform = currentItemTransform
    if let dismissingItemId = self.dismissingItemId,
       let deletingIndex = self.items.firstIndex(where: { $0.id == dismissingItemId }),
       let offset = self.dismissingItemOffset, deletingIndex == index {
        effectiveItemFrame = effectiveItemFrame.offsetBy(dx: offset, dy: 0.0)
    }
    itemFrame = effectiveItemFrame
    itemTransform = effectiveItemTransform
    itemNode.isCovered = false
}

let masterWidth: CGFloat = min(max(320.0, floor(layout.size.width / 3.0)), floor(layout.size.width / 2.0))
let detailWidth = layout.size.width - masterWidth
let scrollToTopHeight = max(layout.statusBarHeight ?? layout.safeInsets.top, 1.0)
return (
    master: CGRect(origin: CGPoint(), size: CGSize(width: masterWidth, height: scrollToTopHeight)),
    detail: CGRect(origin: CGPoint(x: masterWidth, y: 0.0), size: CGSize(width: detailWidth, height: scrollToTopHeight))
)

var masterSafeInsets = layout.safeInsets
masterSafeInsets.right = 0.0
var detailSafeInsets = layout.safeInsets
detailSafeInsets.left = 0.0

self.masterContainer.update(
    layout: ContainerViewLayout(size: CGSize(width: masterWidth, height: layout.size.height),
        metrics: layout.metrics, deviceMetrics: layout.deviceMetrics,
        intrinsicInsets: layout.intrinsicInsets, safeInsets: masterSafeInsets,
        additionalInsets: UIEdgeInsets(), statusBarHeight: layout.statusBarHeight,

func prepareTap() {
    if let selectionGenerator = self.selectionGenerator {
        selectionGenerator.prepare()
    }
}

func tap() {
    if let selectionGenerator = self.selectionGenerator {
        selectionGenerator.selectionChanged()
    }
}

private func impactGenerator(for style: ImpactHapticFeedbackStyle) -> UIImpactFeedbackGenerator {
    if let impactGenerator = self.impactGenerators[style] {
        return impactGenerator
    }
    let impactGenerator: UIImpactFeedbackGenerator
    switch style {
    case .light: impactGenerator = UIImpactFeedbackGenerator(style: .light)
    case .medium: impactGenerator = UIImpactFeedbackGenerator(style: .medium)
    case .heavy: impactGenerator = UIImpactFeedbackGenerator(style: .heavy)
    case .soft: impactGenerator = UIImpactFeedbackGenerator(style: .soft)
    case .rigid: impactGenerator = UIImpactFeedbackGenerator(style: .rigid)
    case .veryLight, .click05, .click06: impactGenerator = UIImpactFeedbackGenerator()
    }
    self.impactGenerators[style] = impactGenerator
    return impactGenerator
}

self.view.insertSubview(copyView, belowSubview: self.containerNode.view)
copyView.frame = transformedSelfFrame

let intermediateCompletion = { [weak copyView] in
    if positionCompleted && boundsCompleted && copyCompleted {
        copyView?.removeFromSuperview()
        completion()
    }
}

copyView.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.1, removeOnCompletion: false)
copyView.layer.animatePosition(
    from: CGPoint(x: transformedCopyViewInitialFrame.midX, y: transformedCopyViewInitialFrame.midY),
    to: CGPoint(x: transformedSelfFrame.midX, y: transformedSelfFrame.midY),
    duration: 0.25, timingFunction: kCAMediaTimingFunctionSpring, removeOnCompletion: false
)
let scale = CGSize(
    width: transformedCopyViewInitialFrame.size.width / transformedSelfFrame.size.width,
    height: transformedCopyViewInitialFrame.size.height / transformedSelfFrame.size.height
)
copyView.layer.animate(
    from: NSValue(caTransform3D: CATransform3DMakeScale(scale.width, scale.height, 1.0)),
    to: NSValue(caTransform3D: CATransform3DIdentity), keyPath: "transform",
    timingFunction: kCAMediaTimingFunctionSpring, duration: 0.25, removeOnCompletion: false,
    completion: { _ in copyCompleted = true; intermediateCompletion() }
)

case .topOnly:
    if scrollView.contentSize.height <= scrollView.bounds.height {
        if adjustedBounds.origin.y > 0.0 {
            adjustedBounds.origin.y = 0.0
        } else {
            adjustedBounds.origin.y = floorToScreenPixels(adjustedBounds.origin.y * 0.35)
            topOverscroll = -adjustedBounds.origin.y
        }
    } else {
        if adjustedBounds.origin.y < 0.0 {
            adjustedBounds.origin.y = floorToScreenPixels(adjustedBounds.origin.y * 0.35)
            topOverscroll = -adjustedBounds.origin.y
        } else if adjustedBounds.origin.y + adjustedBounds.height > scrollView.contentSize.height {
            adjustedBounds.origin.y = scrollView.contentSize.height - adjustedBounds.height
        }
    }
self.scrollNode.bounds = adjustedBounds

if let reactionContextNode = self.reactionContextNode {
    if !reactionContextNode.isExpanded && reactionContextNode.canBeExpanded {
        if topOverscroll > 30.0 && self.scroller.isTracking {
            self.scroller.panGestureRecognizer.state = .cancelled
            reactionContextNode.expand()
        } else {
            reactionContextNode.updateExtension(distance: topOverscroll)
        }
    }
}