Move Text Layout, Selection Edits to Storage Delegates

Author: thecoolwinter

Sources/CodeEditTextView/TextLayoutManager/TextLayoutManager+Edits.swift

@@ -10,17 +10,50 @@ import AppKit
 // MARK: - Edits
 
 extension TextLayoutManager: NSTextStorageDelegate {
-    /// Notifies the layout manager of an edit.
+    /// Receives edit notifications from the text storage and updates internal data structures to stay in sync with
+    /// text content.
     ///
-    /// Used by the `TextView` to tell the layout manager about any edits that will happen.
-    /// Use this to keep the layout manager's line storage in sync with the text storage.
+    /// If the changes are only attribute changes, this method invalidates layout for the edited range and returns.
     ///
-    /// - Parameters:
-    ///   - range: The range of the edit.
-    ///   - string: The string to replace in the given range.
-    public func willReplaceCharactersInRange(range: NSRange, with string: String) {
+    /// Otherwise, any lines that were removed or replaced by the edit are first removed from the text line layout
+    /// storage. Then, any new lines are inserted into the same storage.
+    ///
+    /// For instance, if inserting a newline this method will:
+    /// - Remove no lines (none were replaced)
+    /// - Update the current line's range to contain the newline character.
+    /// - Insert a new line after the current line.
+    ///
+    /// If a selection containing a newline is deleted and replaced with two more newlines this method will:
+    /// - Delete the original line.
+    /// - Insert two lines.
+    ///
+    /// - Note: This method *does not* cause a layout calculation. If a method is finding `NaN` values for line
+    ///         fragments, ensure `layout` or `ensureLayoutUntil` are called on the subject ranges.
+    public func textStorage(
+        _ textStorage: NSTextStorage,
+        didProcessEditing editedMask: NSTextStorageEditActions,
+        range editedRange: NSRange,
+        changeInLength delta: Int
+    ) {
+        guard editedMask.contains(.editedCharacters) else {
+            if editedMask.contains(.editedAttributes) && delta == 0 {
+                invalidateLayoutForRange(editedRange)
+            }
+            return
+        }
+
+        let insertedStringRange = NSRange(location: editedRange.location, length: editedRange.length - delta)
+        removeLayoutLinesIn(range: insertedStringRange)
+        insertNewLines(for: editedRange)
+        invalidateLayoutForRange(editedRange)
+    }
+
+    /// Removes all lines in the range, as if they were deleted. This is a setup for inserting the lines back in on an
+    /// edit.
+    /// - Parameter range: The range that was deleted.
+    private func removeLayoutLinesIn(range: NSRange) {
         // Loop through each line being replaced in reverse, updating and removing where necessary.
-         for linePosition in lineStorage.linesInRange(range).reversed() {
+        for linePosition in lineStorage.linesInRange(range).reversed() {
             // Two cases: Updated line, deleted line entirely
             guard let intersection = linePosition.range.intersection(range), !intersection.isEmpty else { continue }
             if intersection == linePosition.range && linePosition.range.max != lineStorage.length {
@@ -38,25 +71,24 @@ extension TextLayoutManager: NSTextStorageDelegate {
                 lineStorage.update(atIndex: linePosition.range.location, delta: -intersection.length, deltaHeight: 0)
             }
         }
-
+    }
+    
+    /// Inserts any newly inserted lines into the line layout storage. Exits early if the range is empty.
+    /// - Parameter range: The range of the string that was inserted into the text storage.
+    private func insertNewLines(for range: NSRange) {
+        guard !range.isEmpty, let string = textStorage?.substring(from: range) as? NSString else { return }
         // Loop through each line being inserted, inserting & splitting where necessary
-        if !string.isEmpty {
-            var index = 0
-            while let nextLine = (string as NSString).getNextLine(startingAt: index) {
-                let lineRange = NSRange(start: index, end: nextLine.max)
-                applyLineInsert((string as NSString).substring(with: lineRange) as NSString, at: range.location + index)
-                index = nextLine.max
-            }
+        var index = 0
+        while let nextLine = string.getNextLine(startingAt: index) {
+            let lineRange = NSRange(start: index, end: nextLine.max)
+            applyLineInsert(string.substring(with: lineRange) as NSString, at: range.location + index)
+            index = nextLine.max
+        }
 
-            if index < (string as NSString).length {
-                // Get the last line.
-                applyLineInsert(
-                    (string as NSString).substring(from: index) as NSString,
-                    at: range.location + index
-                )
-            }
+        if index < string.length {
+            // Get the last line.
+            applyLineInsert(string.substring(from: index) as NSString, at: range.location + index)
         }
-        setNeedsLayout()
     }
 
     /// Applies a line insert to the internal line storage tree.
@@ -96,18 +128,4 @@ extension TextLayoutManager: NSTextStorageDelegate {
             lineStorage.update(atIndex: location, delta: insertedString.length, deltaHeight: 0.0)
         }
     }
-
-    /// This method is to simplify keeping the layout manager in sync with attribute changes in the storage object.
-    /// This does not handle cases where characters have been inserted or removed from the storage.
-    /// For that, see the `willPerformEdit` method.
-    public func textStorage(
-        _ textStorage: NSTextStorage,
-        didProcessEditing editedMask: NSTextStorageEditActions,
-        range editedRange: NSRange,
-        changeInLength delta: Int
-    ) {
-        if editedMask.contains(.editedAttributes) && delta == 0 {
-            invalidateLayoutForRange(editedRange)
-        }
-    }
 }

Sources/CodeEditTextView/TextLayoutManager/TextLayoutManager+Public.swift

@@ -121,7 +121,7 @@ extension TextLayoutManager {
             return nil
         }
         if linePosition.data.lineFragments.isEmpty {
-            let newHeight = ensureLayoutFor(position: linePosition)
+            let newHeight = preparePositionForDisplay(linePosition)
             if linePosition.height != newHeight {
                 delegate?.layoutManagerHeightDidUpdate(newHeight: lineStorage.height)
             }
@@ -165,7 +165,8 @@ extension TextLayoutManager {
     ///   - line: The line to calculate rects for.
     /// - Returns: Multiple bounding rects. Will return one rect for each line fragment that overlaps the given range.
     public func rectsFor(range: NSRange) -> [CGRect] {
-        lineStorage.linesInRange(range).flatMap { self.rectsFor(range: range, in: $0) }
+        ensureLayoutUntil(range.max)
+        return lineStorage.linesInRange(range).flatMap { self.rectsFor(range: range, in: $0) }
     }
 
     /// Calculates all text bounding rects that intersect with a given range, with a given line position.
@@ -176,6 +177,8 @@ extension TextLayoutManager {
     private func rectsFor(range: NSRange, in line: borrowing TextLineStorage<TextLine>.TextLinePosition) -> [CGRect] {
         guard let textStorage = (textStorage?.string as? NSString) else { return [] }
 
+        _ = preparePositionForDisplay(line)
+
         // Don't make rects in between characters
         let realRangeStart = textStorage.rangeOfComposedCharacterSequence(at: range.lowerBound)
         let realRangeEnd = textStorage.rangeOfComposedCharacterSequence(at: range.upperBound - 1)
@@ -239,6 +242,8 @@ extension TextLayoutManager {
         // Combine the points in clockwise order
         let points = leftSidePoints + rightSidePoints
 
+        guard points.allSatisfy({ $0.x.isFinite && $0.y.isFinite }) else { return nil }
+
         // Close the path
         if let firstPoint = points.first {
             return NSBezierPath.smoothPath(points + [firstPoint], radius: cornerRadius)
@@ -286,7 +291,7 @@ extension TextLayoutManager {
         for linePosition in lineStorage.linesInRange(
             NSRange(start: startingLinePosition.range.location, end: linePosition.range.max)
         ) {
-            let height = ensureLayoutFor(position: linePosition)
+            let height = preparePositionForDisplay(linePosition)
             if height != linePosition.height {
                 lineStorage.update(
                     atIndex: linePosition.range.location,

Sources/CodeEditTextView/TextLayoutManager/TextLayoutManager+Transaction.swift

@@ -8,9 +8,10 @@
 import Foundation
 
 extension TextLayoutManager {
-    /// Forces layout calculation for all lines up to and including the given offset.
-    /// - Parameter offset: The offset to ensure layout until.
-    package func ensureLayoutFor(position: TextLineStorage<TextLine>.TextLinePosition) -> CGFloat {
+    /// Invalidates and prepares a line position for display.
+    /// - Parameter position: The line position to prepare.
+    /// - Returns: The height of the newly laid out line and all it's fragments.
+    package func preparePositionForDisplay(_ position: TextLineStorage<TextLine>.TextLinePosition) -> CGFloat {
         guard let textStorage else { return 0 }
         let displayData = TextLine.DisplayData(
             maxWidth: maxLineLayoutWidth,

Sources/CodeEditTextView/TextLayoutManager/TextLayoutManager+ensureLayout.swift

@@ -211,15 +211,15 @@ public class TextLayoutManager: NSObject {
 
     /// Lays out all visible lines
     func layoutLines(in rect: NSRect? = nil) { // swiftlint:disable:this function_body_length
-        assertNotInLayout()
+//        assertNotInLayout()
         guard let visibleRect = rect ?? delegate?.visibleRect,
               !isInTransaction,
               let textStorage else {
             return
         }
-        #if DEBUG
-        isInLayout = true
-        #endif
+//        #if DEBUG
+//        isInLayout = true
+//        #endif
         let minY = max(visibleRect.minY - verticalLayoutPadding, 0)
         let maxY = max(visibleRect.maxY + verticalLayoutPadding, 0)
         let originalHeight = lineStorage.height
@@ -271,9 +271,9 @@ public class TextLayoutManager: NSObject {
         // Update the visible lines with the new set.
         visibleLineIds = newVisibleLines
 
-        #if DEBUG
-        isInLayout = false
-        #endif
+//        #if DEBUG
+//        isInLayout = false
+//        #endif
 
         // These are fine to update outside of `isInLayout` as our internal data structures are finalized at this point
         // so laying out again won't break our line storage or visible line.

Sources/CodeEditTextView/TextLayoutManager/TextLayoutManager.swift

@@ -6,22 +6,24 @@
 //
 
 import Foundation
+import AppKit
+
+extension TextSelectionManager: NSTextStorageDelegate {
+    public func textStorage(
+        _ textStorage: NSTextStorage,
+        didProcessEditing editedMask: NSTextStorageEditActions,
+        range editedRange: NSRange,
+        changeInLength delta: Int
+    ) {
+        guard editedMask.contains(.editedCharacters) else { return }
 
-extension TextSelectionManager {
-    public func didReplaceCharacters(in range: NSRange, replacementLength: Int) {
-        let delta = replacementLength == 0 ? -range.length : replacementLength
         for textSelection in self.textSelections {
-            if textSelection.range.location > range.max {
-                textSelection.range.location = max(0, textSelection.range.location + delta)
+            // If the text selection is ahead of the edited range, move it back by the range's length
+            if textSelection.range.location > editedRange.max {
+                textSelection.range.location += delta
                 textSelection.range.length = 0
-            } else if textSelection.range.intersection(range) != nil
-                        || textSelection.range == range
-                        || (textSelection.range.isEmpty && textSelection.range.location == range.max) {
-                if replacementLength > 0 {
-                    textSelection.range.location = range.location + replacementLength
-                } else {
-                    textSelection.range.location = range.location
-                }
+            } else if textSelection.range.intersection(editedRange) != nil {
+                textSelection.range.location = editedRange.max
                 textSelection.range.length = 0
             } else {
                 textSelection.range.length = 0
@@ -37,6 +39,8 @@ extension TextSelectionManager {
                 allRanges.insert(selection.range)
             }
         }
+
+        notifyAfterEdit()
     }
 
     func notifyAfterEdit() {

Sources/CodeEditTextView/TextSelectionManager/TextSelectionManager+Update.swift

@@ -16,7 +16,6 @@ extension TextView {
     public func replaceCharacters(in ranges: [NSRange], with string: String) {
         guard isEditable else { return }
         NotificationCenter.default.post(name: Self.textWillChangeNotification, object: self)
-        layoutManager.beginTransaction()
         textStorage.beginEditing()
 
         // Can't insert an empty string into an empty range. One must be not empty
@@ -25,21 +24,18 @@ extension TextView {
         (delegate?.textView(self, shouldReplaceContentsIn: range, with: string) ?? true) {
             delegate?.textView(self, willReplaceContentsIn: range, with: string)
 
-            layoutManager.willReplaceCharactersInRange(range: range, with: string)
             _undoManager?.registerMutation(
                 TextMutation(string: string as String, range: range, limit: textStorage.length)
             )
             textStorage.replaceCharacters(
                 in: range,
                 with: NSAttributedString(string: string, attributes: typingAttributes)
             )
-            selectionManager.didReplaceCharacters(in: range, replacementLength: (string as NSString).length)
 
             delegate?.textView(self, didReplaceContentsIn: range, with: string)
         }
 
         textStorage.endEditing()
-        layoutManager.endTransaction()
         selectionManager.notifyAfterEdit()
         NotificationCenter.default.post(name: Self.textDidChangeNotification, object: self)
 

Sources/CodeEditTextView/TextView/TextView+ReplaceCharacters.swift

@@ -58,7 +58,6 @@ public class TextView: NSView, NSTextContent {
             textStorage.string
         }
         set {
-            layoutManager.willReplaceCharactersInRange(range: documentRange, with: newValue)
             textStorage.setAttributedString(NSAttributedString(string: newValue, attributes: typingAttributes))
         }
     }
@@ -339,8 +338,10 @@ public class TextView: NSView, NSTextContent {
 
         layoutManager = setUpLayoutManager(lineHeightMultiplier: lineHeightMultiplier, wrapLines: wrapLines)
         storageDelegate.addDelegate(layoutManager)
+
         selectionManager = setUpSelectionManager()
         selectionManager.useSystemCursor = useSystemCursor
+        storageDelegate.addDelegate(selectionManager)
 
         _undoManager = CEUndoManager(textView: self)
 

Sources/CodeEditTextView/TextView/TextView.swift

@@ -173,19 +173,13 @@ public class CEUndoManager {
 
     /// Groups all incoming mutations.
     public func beginUndoGrouping() {
-        guard !isGrouping else {
-            assertionFailure("UndoManager already in a group. Call `beginUndoGrouping` before this can be called.")
-            return
-        }
+        guard !isGrouping else { return }
         isGrouping = true
     }
 
     /// Stops grouping all incoming mutations.
     public func endUndoGrouping() {
-        guard isGrouping else {
-            assertionFailure("UndoManager not in a group. Call `endUndoGrouping` before this can be called.")
-            return
-        }
+        guard isGrouping else { return }
         isGrouping = false
     }