列表、滚动与文本

let falloffAnimation1 = CABasicAnimation(
    keyPath: "emitterBehaviors.randomAttractor0.falloff"
)
falloffAnimation1.beginTime = 0.0
falloffAnimation1.fillMode = .both
falloffAnimation1.isRemovedOnCompletion = false
falloffAnimation1.autoreverses = true
falloffAnimation1.repeatCount = .infinity
falloffAnimation1.duration = 2.0
falloffAnimation1.fromValue = -20.0 as NSNumber
falloffAnimation1.toValue = 60.0 as NSNumber
falloffAnimation1.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
self.emitterLayer?.add(
    falloffAnimation1,
    forKey: "emitterBehaviors.randomAttractor0.falloff"
)

let positionAnimation1 = CAKeyframeAnimation(
    keyPath: "emitterBehaviors.randomAttractor0.position"
)
positionAnimation1.beginTime = 0.0
positionAnimation1.fillMode = .both
positionAnimation1.isRemovedOnCompletion = false
positionAnimation1.autoreverses = true
positionAnimation1.repeatCount = .infinity
positionAnimation1.duration = 3.0
positionAnimation1.calculationMode = .discrete

var ascent: CGFloat = 0
var descent: CGFloat = 0
var leading: CGFloat = 0

var width: CGFloat = CGFloat(
    CTLineGetTypographicBounds(line, &ascent, &descent, &leading)
)

let startOffset = CTLineGetOffsetForStringIndex(line, beginLineIndex, nil)
var endOffset = CTLineGetOffsetForStringIndex(line, endLineIndex, nil)

if beginLineIndex < endLineIndex {
    var index = endLineIndex - 1
    while endOffset == 0 && index > 0 {
        endOffset = CTLineGetOffsetForStringIndex(line, index, nil)
        index -= 1
    }
}

width = endOffset - startOffset

let strideTo: StrideTo<Int> = stride(
    from: visibleItems.count - 1,
    to: -1,
    by: -1
)

for i in strideTo {
    let visible = visibleItems[i]
    if let item = self.item(stableId: visible.0.stableId) {
        nrect = rectOf(item: item)

        if let view = viewNecessary(at: i) {
            if view.isInsertionAnimated {
                break
            }
        }

        let y: CGFloat
        if !tableView.isFlipped {
            y = nrect.minY - (frame.height - visible.1) + nrect.height
        } else {
            y = nrect.minY - visible.1
        }

        self.clipView.updateBounds(to: NSMakePoint(0, y))
        break
    }
}

if point == self.destinationOrigin {
    return
}
self.scrollCompletion = completion
self.destinationOrigin = point

if animated {
    self.point = point
    NSAnimationContext.runAnimationGroup({ ctx in
        ctx.duration = 0.35
        let timingFunction = CAMediaTimingFunction(
            controlPoints: 0.5, 1.0 + 0.4 / 3.0, 1.0, 1.0
        )
        ctx.timingFunction = timingFunction
        self.animator().setBoundsOrigin(point)
    }, completionHandler: {
        self.destinationOrigin = nil
        self.point = nil
        self.scrollCompletion?(point == self.bounds.origin)
        self.scrollDidComplete?(point == self.bounds.origin)
    })
} else {
    self.updateBounds(to: point)
    self.point = nil
    self.destinationOrigin = nil
    self.scrollCompletion?(true)
    self.scrollDidComplete?(true)
}

let range = self.tableView.rows(in: NSMakeRect(
    visibleRect.minX,
    visibleRect.minY,
    visibleRect.width,
    visibleRect.height - stickTopInset - secondaryOffset
))

if let stickClass = stickClass, !updating {
    let flipped = tableView.isFlipped
    var index: Int = flipped
        ? range.location
        : range.location + range.length - 1

    let scrollInset = self.documentOffset.y - stickTopInset
        + (flipped ? 0 : frame.height)
    var item: TableRowItem? = optionalItem(at: index)

    if !flipped {
        while let s = item, !s.isKind(of: stickClass) {
            index += 1
            item = self.optionalItem(at: index)
        }
    } else {
        while let s = item, !s.isKind(of: stickClass) {
            index -= 1
            item = self.optionalItem(at: index)
        }
    }
}

let rect: NSRect = self.rectOf(item: item)
let dif: CGFloat
if currentStick != nil {
    dif = min(scrollInset - rect.maxY, item.heightValue)
} else {
    dif = item.heightValue
}
var yTopOffset: CGFloat
if !flipped {
    yTopOffset = min(
        (scrollInset - rect.maxY - secondaryOffset) - rect.height,
        0
    )
} else {
    yTopOffset = min(
        -(rect.height + (scrollInset - rect.minY - secondaryOffset)),
        0
    )
}
if yTopOffset <= -rect.height {
    yTopOffset = 0
}
let updatedPoint = NSMakePoint(
    0,
    yTopOffset + stickTopInset + secondaryOffset
)

if let view = table.viewNecessary(at: idx), let layer = view.layer {
    var inset = (layer.frame.minY - height)
    if let presentLayer = layer.presentation(),
       presentLayer.animation(forKey: "position") != nil {
        inset = presentLayer.position.y
    }

    let from: CGPoint = NSMakePoint(0, inset)
    let to: CGPoint = NSMakePoint(0, layer.position.y)

    layer.animatePosition(
        from: from,
        to: to,
        duration: 0.2,
        timingFunction: .easeOut
    )
    animatedItems.append(
        AnimateItem(index: added[0].index, from: from, to: to)
    )
}

if let left = left, let right = right {
    if left.stableId == right.stableId && (left != right || allUpdated) {
        updatedIndices.append((i, right, previousIndices[left.stableId]!))
        i += 1
        j += 1
    } else {
        if left == right && !allUpdated {
            i += 1
            j += 1
        } else if left > right {
            removeIndices.append(i)
            i += 1
        } else if !(left < right) {
            removeIndices.append(i)
            i += 1
        } else {
            j += 1
        }
    }
} else if let _ = left {
    removeIndices.append(i)
    i += 1
} else if let _ = right {
    j += 1
} else {
    break
}

beginTableUpdates()
for i in range.min ..< range.max {
    let item = self.item(at: i)
    let before = item.heightValue
    let updated = item.makeSize(frame.width, oldWidth: oldWidth)
    let after = item.heightValue
    if (before != after && updated) || item.instantlyResize || inLiveResize {
        reloadData(row: i, animated: false)
        noteHeightOfRow(i, false)
    }
}
endTableUpdates()
if !tableView.inLiveResize && oldWidth != 0 {
    saveScrollState(visibleItems)
}

for listener in scrollListeners {
    listener.handler(self.scrollPosition().current)
}

let existingLayout: TextNodeLayout? = maybeNode?.currentLayout
let layout: TextNodeLayout

if let existingLayout = existingLayout,
   existingLayout.constrainedSize == constrainedSize,
   existingLayout.maximumNumberOfLines == maximumNumberOfLines,
   existingLayout.truncationType == truncationType,
   existingLayout.cutout == cutout,
   existingLayout.selected == selected,
   existingLayout.alignment == alignment {
    let stringMatch: Bool
    if let existingString = existingLayout.attributedString,
       let string = attributedString {
        stringMatch = existingString == string
    } else if existingLayout.attributedString == nil && attributedString == nil {
        stringMatch = true
    } else {
        stringMatch = false
    }

    if stringMatch {
        layout = existingLayout
    } else {
        layout = TextNode.getlayout(attributedString: attributedString, maximumNumberOfLines: maximumNumberOfLines, truncationType: truncationType, backgroundColor: backgroundColor, constrainedSize: constrainedSize, cutout: cutout,selected:selected, alignment: alignment, lineSpacing: lineSpacing)
    }
}

if let layout = self.currentLayout {
    let textMatrix = context.textMatrix
    let textPosition = context.textPosition
    context.textMatrix = CGAffineTransform(scaleX: 1.0, y: -1.0)
    for i in 0 ..< layout.lines.count {
        let line = layout.lines[i]
        var penFlush: CGFloat = 0.0
        if layout.alignment == .center {
            penFlush = 0.5
        }
        let penOffset = CGFloat(
            CTLineGetPenOffsetForFlush(line.line, penFlush, Double(dirtyRect.width))
        )
        context.textPosition = CGPoint(
            x: penOffset + dirtyRect.minX + line.frame.minX,
            y: line.frame.minY + dirtyRect.minY
        )
        let glyphRuns = CTLineGetGlyphRuns(line.line) as NSArray
        for run in glyphRuns {
            let run = run as! CTRun
            CTRunDraw(run, context, CFRangeMake(0, CTRunGetGlyphCount(run)))
        }
    }
    context.textMatrix = textMatrix
    context.textPosition = CGPoint(x: textPosition.x, y: textPosition.y)
}

func addEmbeddedItem(
    item: AnyHashable,
    line: CTLine,
    ascent: CGFloat,
    descent: CGFloat,
    startIndex: Int,
    endIndex: Int,
    rightInset: CGFloat = 0.0
) {
    var secondaryLeftOffset: CGFloat = 0.0
    let rawLeftOffset = CTLineGetOffsetForStringIndex(
        line, startIndex, &secondaryLeftOffset
    )
    var leftOffset = floor(rawLeftOffset)
    if !rawLeftOffset.isEqual(to: secondaryLeftOffset) {
        leftOffset = floor(secondaryLeftOffset)
    }

    var secondaryRightOffset: CGFloat = 0.0
    let rawRightOffset = CTLineGetOffsetForStringIndex(
        line, endIndex, &secondaryRightOffset
    )
    var rightOffset = ceil(rawRightOffset)
    if !rawRightOffset.isEqual(to: secondaryRightOffset) {
        rightOffset = ceil(secondaryRightOffset)
    }

    let lineRange = NSMakeRange(
        CTLineGetStringRange(line).location,
        CTLineGetStringRange(line).length
    )
}

public func checkEmbeddedUnderSpoiler() {
    if let layout = self.textLayout {
        let rects = layout.spoilerRects().map { $0.0 }
        let sublayers = embeddedContainer.sublayers ?? []
        for subview in sublayers {
            var isHidden = false
            loop: for rect in rects {
                if NSIntersectsRect(
                    NSMakeRect(subview.frame.midX, subview.frame.midY, 1, 1),
                    rect
                ) {
                    isHidden = true
                    break loop
                }
            }
            subview.opacity = isHidden ? 0 : 1
        }
    }
}

public func textHeightForWidth(_ width: CGFloat) -> CGFloat {
    let measureSize = CGSize(width: width, height: 1000000.0)

    if self.measurementTextStorage != self.attributedString()
        || self.measurementTextContainer.size != measureSize {
        self.measurementTextStorage.setAttributedString(self.attributedString())
        self.measurementTextContainer.size = measureSize
        self.measurementLayoutManager.invalidateLayout(
            forCharacterRange: NSRange(
                location: 0,
                length: self.measurementTextStorage.length
            ),
            actualCharacterRange: nil
        )
        self.measurementLayoutManager.ensureLayout(
            for: self.measurementTextContainer
        )
    }

    var textSize = self.measurementLayoutManager.usedRect(
        for: self.measurementTextContainer
    ).size
    if string.isEmpty {
        textSize.height += 2
    }
    return textSize.height + insets.top + insets.bottom
        + self.textContainerOrigin.y * 2
}

override func lineFragmentRect(
    forProposedRect proposedRect: CGRect,
    at characterIndex: Int,
    writingDirection baseWritingDirection: NSWritingDirection,
    remaining remainingRect: UnsafeMutablePointer<CGRect>?
) -> CGRect {
    var result = super.lineFragmentRect(
        forProposedRect: proposedRect,
        at: characterIndex,
        writingDirection: baseWritingDirection,
        remaining: remainingRect
    )

    result.origin.x -= 5.0
    result.size.width -= 5.0

    if let textStorage = self.layoutManager?.textStorage {
        let string: NSString = textStorage.string as NSString
        let index = Int(characterIndex)
        if index >= 0 && index < string.length {
            let attributes = textStorage.attributes(at: index, effectiveRange: nil)
            let blockQuote = attributes[TextInputAttributes.quote] as? NSObject
            if let blockQuote = blockQuote {
                result.origin.x += 9.0
                result.size.width -= 9.0
                result.size.width -= 7.0

private func validateEmojies() {
    let textStorage = self.customTextStorage
    var rects: [(CGRect, TextInputTextCustomEmojiAttribute)] = []

    textStorage.enumerateAttributes(
        in: NSMakeRange(0, textStorage.length),
        options: [],
        using: { attributes, range, _ in
            if let value = attributes[TextInputAttributes.customEmoji]
                as? TextInputTextCustomEmojiAttribute {
                if let spoiler = attributes[TextInputAttributes.spoiler] as? NSNumber {
                    if spoiler == 1 {
                        return
                    }
                }
                let glyphRange = self.customLayoutManager.glyphRange(
                    forCharacterRange: range,
                    actualCharacterRange: nil
                )
                if self.customLayoutManager.isValidGlyphIndex(glyphRange.location)
                    && self.customLayoutManager.isValidGlyphIndex(
                        glyphRange.location + glyphRange.length - 1
                    ) {
                } else {
                    return
                }

public override func keyDown(with theEvent: NSEvent) {
    if let delegate = self.customDelegate {
        if delegate.inputViewIsEnabled(theEvent) {
            if isEnterEvent(theEvent) && !self.hasMarkedText() {
                let result = delegate.inputViewProcessEnter(theEvent)

                if (!result && (theEvent.modifierFlags.contains(.command)
                    || theEvent.modifierFlags.contains(.shift))) {
                    super.insertNewline(self)
                    return
                }

                if result {
                    return
                }
            } else if theEvent.keyCode == 53,
                      delegate.inputViewMaybeClosed() {
                return
            }

            if !theEvent.modifierFlags.contains(.command)
                || !isEnterEvent(theEvent) {
                super.keyDown(with: theEvent)
            }
        }
    } else {
        super.keyDown(with: theEvent)
    }
}

public override var isContinuousSpellCheckingEnabled: Bool {
    get {
        return UserDefaults.standard.bool(
            forKey: "ContinuousSpellCheckingEnabled\(settingsKey)"
        )
    }
    set {
        UserDefaults.standard.set(
            newValue,
            forKey: "ContinuousSpellCheckingEnabled\(settingsKey)"
        )
        super.isContinuousSpellCheckingEnabled = newValue
    }
}

public override var isGrammarCheckingEnabled: Bool {
    get {
        return UserDefaults.standard.bool(
            forKey: "GrammarCheckingEnabled\(settingsKey)"
        )
    }
    set {
        UserDefaults.standard.set(
            newValue,
            forKey: "GrammarCheckingEnabled\(settingsKey)"
        )
        super.isGrammarCheckingEnabled = newValue
    }
}

override open func scrollWheel(with event: NSEvent) {
    if let applyExternalScroll = self.applyExternalScroll,
       applyExternalScroll(event) {
        return
    }

    var scrollPoint = contentView.bounds.origin
    let isInverted: Bool = System.isScrollInverted
    if event.scrollingDeltaY != 0 {
        if isInverted {
            scrollPoint.x += -event.scrollingDeltaY
        } else {
            scrollPoint.x -= event.scrollingDeltaY
        }
        scrollPoint.x = min(
            max(0, floorToScreenPixels(backingScaleFactor, scrollPoint.x)),
            documentView!.frame.width - frame.width
        )
        clipView.scroll(to: scrollPoint)
        window?.scrollWheel(with: event)
        return
    }

    if documentView!.frame.width > frame.width {
        if event.scrollingDeltaY != 0 || event.scrollingDeltaX != 0 {
            super.scrollWheel(with: event)
        }
    } else {
        superview?.scrollWheel(with: event)
    }
}

if animated {
    switch updated.animation {
    case .crossFade:
        field.layer?.animateAlpha(
            from: 1,
            to: 0,
            duration: duration - 0.1,
            timingFunction: timingFunction,
            removeOnCompletion: false,
            completion: { [weak field] _ in
                field?.removeFromSuperview()
            }
        )
    case .numeric:
        field.layer?.animateAlpha(
            from: 1,
            to: 0,
            duration: duration - 0.1,
            timingFunction: timingFunction,
            removeOnCompletion: false,
            completion: { [weak field] _ in
                field?.removeFromSuperview()
            }
        )

        let direction = addition[key.hashValue]
        switch direction {
        case .forward?:
            field.layer?.animatePosition(
                from: field.frame.origin,
                to: NSMakePoint(field.frame.minX, field.frame.maxY),
                timingFunction: timingFunction,
                removeOnCompletion: false
            )

override init(frame frameRect: NSRect) {
    super.init(frame: frameRect)
    backgroundColor = .clear
    self.autoresizesSubviews = false
    usesAlternatingRowBackgroundColors = false
    layerContentsRedrawPolicy = .never
    usesAutomaticRowHeights = false
}

override func becomeFirstResponder() -> Bool {
    return false
}

override func rect(ofRow row: Int) -> NSRect {
    return super.rect(ofRow: row)
}
override func row(at point: NSPoint) -> Int {
    return super.row(at: point)
}
override func rows(in rect: NSRect) -> NSRange {
    return super.rows(in: rect)
}

override func isAccessibilityElement() -> Bool {
    return false
}
override func accessibilityParent() -> Any? {
    return nil
}

override public static var isCompatibleWithResponsiveScrolling: Bool {
    return true
}

var range: NSRange = table.visibleRows(height)

let added = added.filter { item in
    if item.index < range.location
        || item.index > range.location + range.length {
        return false
    } else {
        return true
    }
}

let removed = removed.filter { item in
    if item.index < range.location
        || item.index > range.location + range.length {
        return false
    } else {
        return true
    }
}

for item in added {
    height += item.heightValue
}

for item in removed {
    height -= item.heightValue
}

if previousRange.length == 0 {
    return []
}