Merge branch 'main' into feat/track-drag-outside-view

Author: thecoolwinter

Sources/CodeEditTextView/TextLayoutManager/TextLayoutManager+Public.swift

@@ -75,14 +75,22 @@ extension TextLayoutManager {
               ) else {
             return nil
         }
-        let fragment = fragmentPosition.data
 
+        return textOffsetAtPoint(point, fragmentPosition: fragmentPosition, linePosition: linePosition)
+    }
+
+    func textOffsetAtPoint(
+        _ point: CGPoint,
+        fragmentPosition: TextLineStorage<LineFragment>.TextLinePosition,
+        linePosition: TextLineStorage<TextLine>.TextLinePosition
+    ) -> Int? {
+        let fragment = fragmentPosition.data
         if fragment.width == 0 {
             return linePosition.range.location + fragmentPosition.range.location
         } else if fragment.width <= point.x - edgeInsets.left {
             return findOffsetAfterEndOf(fragmentPosition: fragmentPosition, in: linePosition)
         } else {
-            return findOffsetAtPoint(inFragment: fragment, point: point, inLine: linePosition)
+            return findOffsetAtPoint(inFragment: fragment, xPos: point.x, inLine: linePosition)
         }
     }
 
@@ -125,23 +133,23 @@ extension TextLayoutManager {
     /// Finds a document offset for a point that lies in a line fragment.
     /// - Parameters:
     ///   - fragment: The fragment the point lies in.
-    ///   - point: The point being queried, relative to the text view.
+    ///   - xPos: The point being queried, relative to the text view.
     ///   - linePosition: The position that contains the `fragment`.
     /// - Returns: The offset (relative to the document) that's closest to the given point, or `nil` if it could not be
     ///            found.
-    private func findOffsetAtPoint(
+    func findOffsetAtPoint(
         inFragment fragment: LineFragment,
-        point: CGPoint,
+        xPos: CGFloat,
         inLine linePosition: TextLineStorage<TextLine>.TextLinePosition
     ) -> Int? {
-        guard let (content, contentPosition) = fragment.findContent(atX: point.x - edgeInsets.left) else {
+        guard let (content, contentPosition) = fragment.findContent(atX: xPos - edgeInsets.left) else {
             return nil
         }
         switch content.data {
         case .text(let ctLine):
             let fragmentIndex = CTLineGetStringIndexForPosition(
                 ctLine,
-                CGPoint(x: point.x - edgeInsets.left - contentPosition.xPos, y: fragment.height/2)
+                CGPoint(x: xPos - edgeInsets.left - contentPosition.xPos, y: fragment.height/2)
             )
             return fragmentIndex + contentPosition.offset + linePosition.range.location
         case .attachment:

Sources/CodeEditTextView/TextSelectionManager/TextSelectionManager.swift

@@ -95,6 +95,7 @@ public class TextSelectionManager: NSObject {
                 (0...(textStorage?.length ?? 0)).contains($0.location)
                 && (0...(textStorage?.length ?? 0)).contains($0.max)
             }
+            .sorted(by: { $0.location < $1.location })
             .map {
                 let selection = TextSelection(range: $0)
                 selection.suggestedXPos = layoutManager?.rectForOffset($0.location)?.minX
@@ -127,6 +128,7 @@ public class TextSelectionManager: NSObject {
         }
         if !didHandle {
             textSelections.append(newTextSelection)
+            textSelections.sort(by: { $0.range.location < $1.range.location })
         }
 
         updateSelectionViews()
@@ -136,72 +138,80 @@ public class TextSelectionManager: NSObject {
 
     // MARK: - Selection Views
 
-    /// Update all selection cursors. Placing them in the correct position for each text selection and reseting the
-    /// blink timer.
-    func updateSelectionViews(force: Bool = false) {
+    /// Update all selection cursors. Placing them in the correct position for each text selection and
+    /// optionally reseting the blink timer.
+    func updateSelectionViews(force: Bool = false, skipTimerReset: Bool = false) {
         guard textView?.isFirstResponder ?? false else { return }
         var didUpdate: Bool = false
 
         for textSelection in textSelections {
             if textSelection.range.isEmpty {
-                guard let cursorRect = layoutManager?.rectForOffset(textSelection.range.location) else {
-                    continue
-                }
-
-                var doesViewNeedReposition: Bool
-
-                // If using the system cursor, macOS will change the origin and height by about 0.5, so we do an
-                // approximate equals in that case to avoid extra updates.
-                if useSystemCursor, #available(macOS 14.0, *) {
-                    doesViewNeedReposition = !textSelection.boundingRect.origin.approxEqual(cursorRect.origin)
-                    || !textSelection.boundingRect.height.approxEqual(layoutManager?.estimateLineHeight() ?? 0)
-                } else {
-                    doesViewNeedReposition = textSelection.boundingRect.origin != cursorRect.origin
-                    || textSelection.boundingRect.height != layoutManager?.estimateLineHeight() ?? 0
-                }
-
-                if textSelection.view == nil || doesViewNeedReposition {
-                    let cursorView: NSView
+                didUpdate = didUpdate || repositionCursorSelection(textSelection: textSelection)
+            } else if !textSelection.range.isEmpty && textSelection.view != nil {
+                textSelection.view?.removeFromSuperview()
+                textSelection.view = nil
+                didUpdate = true
+            }
+        }
 
-                    if let existingCursorView = textSelection.view {
-                        cursorView = existingCursorView
-                    } else {
-                        textSelection.view?.removeFromSuperview()
-                        textSelection.view = nil
+        if didUpdate || force {
+            delegate?.setNeedsDisplay()
+            if !skipTimerReset {
+                cursorTimer.resetTimer()
+                resetSystemCursorTimers()
+            }
+        }
+    }
 
-                        if useSystemCursor, #available(macOS 14.0, *) {
-                            let systemCursorView = NSTextInsertionIndicator(frame: .zero)
-                            cursorView = systemCursorView
-                            systemCursorView.displayMode = .automatic
-                        } else {
-                            let internalCursorView = CursorView(color: insertionPointColor)
-                            cursorView = internalCursorView
-                            cursorTimer.register(internalCursorView)
-                        }
+    private func repositionCursorSelection(textSelection: TextSelection) -> Bool {
+        guard let cursorRect = layoutManager?.rectForOffset(textSelection.range.location) else {
+            return false
+        }
 
-                        textView?.addSubview(cursorView, positioned: .above, relativeTo: nil)
-                    }
+        var doesViewNeedReposition: Bool
 
-                    cursorView.frame.origin = cursorRect.origin
-                    cursorView.frame.size.height = cursorRect.height
+        // If using the system cursor, macOS will change the origin and height by about 0.5, so we do an
+        // approximate equals in that case to avoid extra updates.
+        if useSystemCursor, #available(macOS 14.0, *) {
+            doesViewNeedReposition = !textSelection.boundingRect.origin.approxEqual(cursorRect.origin)
+            || !textSelection.boundingRect.height.approxEqual(layoutManager?.estimateLineHeight() ?? 0)
+        } else {
+            doesViewNeedReposition = textSelection.boundingRect.origin != cursorRect.origin
+            || textSelection.boundingRect.height != layoutManager?.estimateLineHeight() ?? 0
+        }
 
-                    textSelection.view = cursorView
-                    textSelection.boundingRect = cursorView.frame
+        if textSelection.view == nil || doesViewNeedReposition {
+            let cursorView: NSView
 
-                    didUpdate = true
-                }
-            } else if !textSelection.range.isEmpty && textSelection.view != nil {
+            if let existingCursorView = textSelection.view {
+                cursorView = existingCursorView
+            } else {
                 textSelection.view?.removeFromSuperview()
                 textSelection.view = nil
-                didUpdate = true
+
+                if useSystemCursor, #available(macOS 14.0, *) {
+                    let systemCursorView = NSTextInsertionIndicator(frame: .zero)
+                    cursorView = systemCursorView
+                    systemCursorView.displayMode = .automatic
+                } else {
+                    let internalCursorView = CursorView(color: insertionPointColor)
+                    cursorView = internalCursorView
+                    cursorTimer.register(internalCursorView)
+                }
+
+                textView?.addSubview(cursorView, positioned: .above, relativeTo: nil)
             }
-        }
 
-        if didUpdate || force {
-            delegate?.setNeedsDisplay()
-            cursorTimer.resetTimer()
-            resetSystemCursorTimers()
+            cursorView.frame.origin = cursorRect.origin
+            cursorView.frame.size.height = cursorRect.height
+
+            textSelection.view = cursorView
+            textSelection.boundingRect = cursorView.frame
+
+            return true
         }
+
+        return false
     }
 
     private func resetSystemCursorTimers() {

Sources/CodeEditTextView/TextView/TextView+ColumnSelection.swift

@@ -0,0 +1,50 @@
+//
+//  TextView+ColumnSelection.swift
+//  CodeEditTextView
+//
+//  Created by Khan Winter on 6/19/25.
+//
+
+import AppKit
+
+extension TextView {
+    /// Set the user's selection to a square region in the editor.
+    ///
+    /// This method will automatically determine a valid region from the provided two points.
+    /// - Parameters:
+    ///   - pointA: The first point.
+    ///   - pointB: The second point.
+    public func selectColumns(betweenPointA pointA: CGPoint, pointB: CGPoint) {
+        let start = CGPoint(x: min(pointA.x, pointB.x), y: min(pointA.y, pointB.y))
+        let end = CGPoint(x: max(pointA.x, pointB.x), y: max(pointA.y, pointB.y))
+
+        // Collect all overlapping text ranges
+        var selectedRanges: [NSRange] = layoutManager.linesStartingAt(start.y, until: end.y).flatMap { textLine in
+            // Collect fragment ranges
+            return textLine.data.lineFragments.compactMap { lineFragment -> NSRange? in
+                let startOffset = self.layoutManager.textOffsetAtPoint(
+                    start,
+                    fragmentPosition: lineFragment,
+                    linePosition: textLine
+                )
+                let endOffset = self.layoutManager.textOffsetAtPoint(
+                    end,
+                    fragmentPosition: lineFragment,
+                    linePosition: textLine
+                )
+                guard let startOffset, let endOffset else { return nil }
+
+                return NSRange(start: startOffset, end: endOffset)
+            }
+        }
+
+        // If we have some non-cursor selections, filter out any cursor selections
+        if selectedRanges.contains(where: { !$0.isEmpty }) {
+            selectedRanges = selectedRanges.filter({
+                !$0.isEmpty || (layoutManager.rectForOffset($0.location)?.origin.x.approxEqual(start.x) ?? false)
+            })
+        }
+
+        selectionManager.setSelectedRanges(selectedRanges)
+    }
+}

Sources/CodeEditTextView/TextView/TextView+FirstResponder.swift

@@ -51,7 +51,10 @@ extension TextView {
     open override func resetCursorRects() {
         super.resetCursorRects()
         if isSelectable {
-            addCursorRect(visibleRect, cursor: .iBeam)
+            addCursorRect(
+                visibleRect,
+                cursor: isOptionPressed ? .crosshair : .iBeam
+            )
         }
     }
 }

Sources/CodeEditTextView/TextView/TextView+KeyDown.swift

@@ -47,4 +47,16 @@ extension TextView {
 
         return false
     }
+
+    override public func flagsChanged(with event: NSEvent) {
+        super.flagsChanged(with: event)
+
+        let modifierFlags = event.modifierFlags.intersection(.deviceIndependentFlagsMask)
+        let modifierFlagsIsOption = modifierFlags == [.option]
+
+        if modifierFlagsIsOption != isOptionPressed {
+            isOptionPressed = modifierFlagsIsOption
+            resetCursorRects()
+        }
+    }
 }

Sources/CodeEditTextView/TextView/TextView+Layout.swift

@@ -11,6 +11,7 @@ extension TextView {
     override public func layout() {
         super.layout()
         layoutManager.layoutLines()
+        selectionManager.updateSelectionViews(skipTimerReset: true)
     }
 
     open override class var isCompatibleWithResponsiveScrolling: Bool {

Sources/CodeEditTextView/TextView/TextView+Mouse.swift

@@ -41,10 +41,11 @@ extension TextView {
             super.mouseDown(with: event)
             return
         }
-        if event.modifierFlags.intersection(.deviceIndependentFlagsMask).isSuperset(of: [.control, .shift]) {
+        let eventFlags = event.modifierFlags.intersection(.deviceIndependentFlagsMask)
+        if eventFlags == [.control, .shift] {
             unmarkText()
             selectionManager.addSelectedRange(NSRange(location: offset, length: 0))
-        } else if event.modifierFlags.intersection(.deviceIndependentFlagsMask).contains(.shift) {
+        } else if eventFlags.contains(.shift) {
             unmarkText()
             shiftClickExtendSelection(to: offset)
         } else {
@@ -143,6 +144,8 @@ extension TextView {
         setNeedsDisplay()
     }
 
+    // MARK: - Mouse Autoscroll
+
     /// Sets up a timer that fires at a predetermined period to autoscroll the text view.
     /// Ensure the timer is disabled using ``disableMouseAutoscrollTimer``.
     func setUpMouseAutoscrollTimer() {
@@ -162,6 +165,8 @@ extension TextView {
         mouseDragTimer = nil
     }
 
+    // MARK: - Drag Selection
+
     private func dragSelection(startPosition: Int, endPosition: Int, mouseDragAnchor: CGPoint) {
         switch cursorSelectionMode {
         case .character:

Sources/CodeEditTextView/TextView/TextView.swift

@@ -269,6 +269,8 @@ public class TextView: NSView, NSTextContent {
     var draggingCursorView: NSView?
     var isDragging: Bool = false
 
+    var isOptionPressed: Bool = false
+
     private var fontCharWidth: CGFloat {
         (" " as NSString).size(withAttributes: [.font: font]).width
     }