Add Straight Line When Adjacent

Author: thecoolwinter

Package.resolved

@@ -0,0 +1,111 @@
+//
+//  NSBezierPath+RoundedCorners.swift
+//  CodeEditSourceEditor
+//
+//  Created by Khan Winter on 6/3/25.
+//
+
+import AppKit
+
+// Wonderful NSBezierPath extension taken with modification from the playground code at:
+// https://github.com/janheiermann/BezierPath-Corners
+
+extension NSBezierPath {
+    struct Corners: OptionSet {
+        public let rawValue: Int
+
+        public init(rawValue: Corners.RawValue) {
+            self.rawValue = rawValue
+        }
+
+        public static let topLeft = Corners(rawValue: 1 << 0)
+        public static let bottomLeft = Corners(rawValue: 1 << 1)
+        public static let topRight = Corners(rawValue: 1 << 2)
+        public static let bottomRight = Corners(rawValue: 1 << 3)
+    }
+
+    convenience init(rect: CGRect, roundedCorners corners: Corners, cornerRadius: CGFloat) {
+        self.init()
+
+        let maxX = rect.maxX
+        let minX = rect.minX
+        let maxY = rect.maxY
+        let minY = rect.minY
+        let radius = min(cornerRadius, min(rect.width, rect.height) / 2)
+
+        // Start at bottom-left corner
+        move(to: CGPoint(x: minX + (corners.contains(.bottomLeft) ? radius : 0), y: minY))
+
+        // Bottom edge
+        if corners.contains(.bottomRight) {
+            line(to: CGPoint(x: maxX - radius, y: minY))
+            appendArc(
+                withCenter: CGPoint(x: maxX - radius, y: minY + radius),
+                radius: radius,
+                startAngle: 270,
+                endAngle: 0,
+                clockwise: false
+            )
+        } else {
+            line(to: CGPoint(x: maxX, y: minY))
+        }
+
+        // Right edge
+        if corners.contains(.topRight) {
+            line(to: CGPoint(x: maxX, y: maxY - radius))
+            appendArc(
+                withCenter: CGPoint(x: maxX - radius, y: maxY - radius),
+                radius: radius,
+                startAngle: 0,
+                endAngle: 90,
+                clockwise: false
+            )
+        } else {
+            line(to: CGPoint(x: maxX, y: maxY))
+        }
+
+        // Top edge
+        if corners.contains(.topLeft) {
+            line(to: CGPoint(x: minX + radius, y: maxY))
+            appendArc(
+                withCenter: CGPoint(x: minX + radius, y: maxY - radius),
+                radius: radius,
+                startAngle: 90,
+                endAngle: 180,
+                clockwise: false
+            )
+        } else {
+            line(to: CGPoint(x: minX, y: maxY))
+        }
+
+        // Left edge
+        if corners.contains(.bottomLeft) {
+            line(to: CGPoint(x: minX, y: minY + radius))
+            appendArc(
+                withCenter: CGPoint(x: minX + radius, y: minY + radius),
+                radius: radius,
+                startAngle: 180,
+                endAngle: 270,
+                clockwise: false
+            )
+        } else {
+            line(to: CGPoint(x: minX, y: minY))
+        }
+
+        close()
+    }
+
+
+    convenience init(roundingRect: CGRect, capTop: Bool, capBottom: Bool, cornerRadius radius: CGFloat) {
+        switch (capTop, capBottom) {
+        case (true, true):
+            self.init(rect: roundingRect)
+        case (false, true):
+            self.init(rect: roundingRect, roundedCorners: [.bottomLeft, .bottomRight], cornerRadius: radius)
+        case (true, false):
+            self.init(rect: roundingRect, roundedCorners: [.topLeft, .topRight], cornerRadius: radius)
+        case (false, false):
+            self.init(roundedRect: roundingRect, xRadius: radius, yRadius: radius)
+        }
+    }
+}

Sources/CodeEditSourceEditor/Extensions/NSBezierPath+RoundedCorners.swift

@@ -15,6 +15,10 @@ struct FoldRange: Sendable, Equatable {
     let depth: Int
     let range: Range<Int>
     var isCollapsed: Bool
+
+    func isHoveringEqual(_ other: FoldRange) -> Bool {
+        depth == other.depth && range.contains(other.range)
+    }
 }
 
 /// Sendable data model for code folding using RangeStore

…/Extensions/NSEdgeInsets+Equatable.swift …SEdgeInsets/NSEdgeInsets+Equatable.swiftSources/CodeEditSourceEditor/Extensions/NSEdgeInsets+Equatable.swift renamed to Sources/CodeEditSourceEditor/Extensions/NSEdgeInsets/NSEdgeInsets+Equatable.swift Sources/CodeEditSourceEditor/Extensions/NSEdgeInsets+Equatable.swift renamed to Sources/CodeEditSourceEditor/Extensions/NSEdgeInsets/NSEdgeInsets+Equatable.swift

@@ -9,20 +9,52 @@ import AppKit
 import CodeEditTextView
 
 extension FoldingRibbonView {
-    /// The context in which the fold is being drawn, including the depth and fold range.
-    struct FoldMarkerDrawingContext {
-        let range: ClosedRange<Int>
-        let depth: UInt
-
-        /// Increment the depth
-        func incrementDepth() -> FoldMarkerDrawingContext {
-            FoldMarkerDrawingContext(
-                range: range,
-                depth: depth + 1
+    struct FoldCapInfo {
+        let startIndices: Set<Int>
+        let endIndices: Set<Int>
+
+        init(_ folds: [DrawingFoldInfo]) {
+            self.startIndices = folds.reduce(into: Set<Int>(), { $0.insert($1.startLine.index) })
+            self.endIndices = folds.reduce(into: Set<Int>(), { $0.insert($1.endLine.index) })
+        }
+
+        func foldNeedsTopCap(_ fold: DrawingFoldInfo) -> Bool {
+            endIndices.contains(fold.startLine.index)
+        }
+
+        func foldNeedsBottomCap(_ fold: DrawingFoldInfo) -> Bool {
+            startIndices.contains(fold.endLine.index)
+        }
+
+        func adjustFoldRect(
+            using fold: DrawingFoldInfo,
+            rect: NSRect
+        ) -> NSRect {
+            let capTop = foldNeedsTopCap(fold)
+            let capBottom = foldNeedsBottomCap(fold)
+            let yDelta = capTop ? fold.startLine.height / 2.0 : 0.0
+            let heightDelta: CGFloat = if capTop && capBottom {
+                -fold.startLine.height
+            } else if capTop || capBottom {
+                -(fold.startLine.height / 2.0)
+            } else {
+                0.0
+            }
+            return NSRect(
+                x: rect.origin.x,
+                y: rect.origin.y + yDelta,
+                width: rect.size.width,
+                height: rect.size.height + heightDelta
             )
         }
     }
 
+    struct DrawingFoldInfo {
+        let fold: FoldRange
+        let startLine: TextLineStorage<TextLine>.TextLinePosition
+        let endLine: TextLineStorage<TextLine>.TextLinePosition
+    }
+
     override func draw(_ dirtyRect: NSRect) {
         guard let context = NSGraphicsContext.current?.cgContext,
               let layoutManager = model?.controller?.textView.layoutManager else {
@@ -38,19 +70,21 @@ extension FoldingRibbonView {
             return
         }
         let textRange = rangeStart.range.location..<rangeEnd.range.upperBound
-
-        let folds = getDrawingFolds(forTextRange: textRange)
-        for fold in folds.filter({ !$0.isCollapsed }) {
+        let folds = getDrawingFolds(forTextRange: textRange, layoutManager: layoutManager)
+        let foldCaps = FoldCapInfo(folds)
+        for fold in folds.filter({ !$0.fold.isCollapsed }) {
             drawFoldMarker(
                 fold,
+                foldCaps: foldCaps,
                 in: context,
                 using: layoutManager
             )
         }
 
-        for fold in folds.filter({ $0.isCollapsed }) {
+        for fold in folds.filter({ $0.fold.isCollapsed }) {
             drawFoldMarker(
                 fold,
+                foldCaps: foldCaps,
                 in: context,
                 using: layoutManager
             )
@@ -59,7 +93,10 @@ extension FoldingRibbonView {
         context.restoreGState()
     }
 
-    private func getDrawingFolds(forTextRange textRange: Range<Int>) -> [FoldRange] {
+    private func getDrawingFolds(
+        forTextRange textRange: Range<Int>,
+        layoutManager: TextLayoutManager
+    ) -> [DrawingFoldInfo] {
         var folds = model?.getFolds(in: textRange) ?? []
 
         // Add in some fake depths, we can draw these underneath the rest of the folds to make it look like it's
@@ -78,44 +115,47 @@ extension FoldingRibbonView {
             }
         }
 
-        return folds
+        return folds.compactMap { fold in
+            guard let startLine = layoutManager.textLineForOffset(fold.range.lowerBound),
+                  let endLine = layoutManager.textLineForOffset(fold.range.upperBound) else {
+                return nil
+            }
+
+            return DrawingFoldInfo(fold: fold, startLine: startLine, endLine: endLine)
+        }
     }
 
     /// Draw a single fold marker for a fold.
     ///
     /// Ensure the correct fill color is set on the drawing context before calling.
     ///
     /// - Parameters:
-    ///   - fold: The fold to draw.
+    ///   - foldInfo: The fold to draw.
     ///   - markerContext: The context in which the fold is being drawn, including the depth and if a line is
     ///                    being hovered.
     ///   - context: The drawing context to use.
     ///   - layoutManager: A layout manager used to retrieve position information for lines.
     private func drawFoldMarker(
-        _ fold: FoldRange,
+        _ foldInfo: DrawingFoldInfo,
+        foldCaps: FoldCapInfo,
         in context: CGContext,
         using layoutManager: TextLayoutManager
     ) {
-        guard let minYPosition = layoutManager.textLineForOffset(fold.range.lowerBound)?.yPos,
-              let maxPosition = layoutManager.textLineForOffset(fold.range.upperBound) else {
-            return
-        }
-
-        let maxYPosition = maxPosition.yPos + maxPosition.height
+        let minYPosition = foldInfo.startLine.yPos
+        let maxYPosition = foldInfo.endLine.yPos + foldInfo.endLine.height
 
-        if fold.isCollapsed {
+        if foldInfo.fold.isCollapsed {
             drawCollapsedFold(minYPosition: minYPosition, maxYPosition: maxYPosition, in: context)
-        } else if let hoveringFold,
-                    hoveringFold.depth == fold.depth,
-                  NSRange(hoveringFold.range).intersection(NSRange(fold.range)) == NSRange(hoveringFold.range) {
+        } else if let hoveringFold, hoveringFold.isHoveringEqual(foldInfo.fold) {
             drawHoveredFold(
                 minYPosition: minYPosition,
                 maxYPosition: maxYPosition,
                 in: context
             )
         } else {
             drawNestedFold(
-                fold: fold,
+                foldInfo: foldInfo,
+                foldCaps: foldCaps,
                 minYPosition: minYPosition,
                 maxYPosition: maxYPosition,
                 in: context
@@ -204,26 +244,37 @@ extension FoldingRibbonView {
     }
 
     private func drawNestedFold(
-        fold: FoldRange,
+        foldInfo: DrawingFoldInfo,
+        foldCaps: FoldCapInfo,
         minYPosition: CGFloat,
         maxYPosition: CGFloat,
         in context: CGContext
     ) {
         context.saveGState()
-        let plainRect = NSRect(x: 0, y: minYPosition + 1, width: 7, height: maxYPosition - minYPosition - 2)
-        // TODO: Draw a single horizontal line when folds are adjacent
-        let roundedRect = NSBezierPath(roundedRect: plainRect, xRadius: 3.5, yRadius: 3.5)
+        let plainRect = foldCaps.adjustFoldRect(
+            using: foldInfo,
+            rect: NSRect(x: 0, y: minYPosition + 1, width: 7, height: maxYPosition - minYPosition - 2)
+        )
+        let radius = plainRect.width / 2.0
+        let roundedRect = NSBezierPath(
+            roundingRect: plainRect,
+            capTop: foldCaps.foldNeedsTopCap(foldInfo),
+            capBottom: foldCaps.foldNeedsBottomCap(foldInfo),
+            cornerRadius: radius
+        )
 
         context.setFillColor(markerColor)
         context.addPath(roundedRect.cgPathFallback)
         context.drawPath(using: .fill)
 
         // Add small white line if we're overlapping with other markers
-        if fold.depth != 0 {
+        if foldInfo.fold.depth != 0 {
             drawOutline(
+                foldInfo: foldInfo,
+                foldCaps: foldCaps,
+                originalPath: roundedRect.cgPathFallback,
                 minYPosition: minYPosition,
                 maxYPosition: maxYPosition,
-                originalPath: roundedRect,
                 in: context
             )
         }
@@ -241,19 +292,31 @@ extension FoldingRibbonView {
     ///   - originalPath: The original bezier path for the rounded rectangle.
     ///   - context: The context to draw in.
     private func drawOutline(
+        foldInfo: DrawingFoldInfo,
+        foldCaps: FoldCapInfo,
+        originalPath: CGPath,
         minYPosition: CGFloat,
         maxYPosition: CGFloat,
-        originalPath: NSBezierPath,
         in context: CGContext
     ) {
         context.saveGState()
 
-        let plainRect = NSRect(x: -0.5, y: minYPosition, width: 8, height: maxYPosition - minYPosition)
-        let roundedRect = NSBezierPath(roundedRect: plainRect, xRadius: 4, yRadius: 4)
+        let plainRect = foldCaps.adjustFoldRect(
+            using: foldInfo,
+            rect: NSRect(x: -0.5, y: minYPosition, width: frame.width + 1.0, height: maxYPosition - minYPosition)
+        )
+        let radius = plainRect.width / 2.0
+        let roundedRect = NSBezierPath(
+            roundingRect: plainRect,
+            capTop: foldCaps.foldNeedsTopCap(foldInfo),
+            capBottom: foldCaps.foldNeedsBottomCap(foldInfo),
+            cornerRadius: radius
+        )
+        roundedRect.transform(using: .init(translationByX: -0.5, byY: 0.0))
 
         let combined = CGMutablePath()
         combined.addPath(roundedRect.cgPathFallback)
-        combined.addPath(originalPath.cgPathFallback)
+        combined.addPath(originalPath)
 
         context.clip(to: CGRect(x: 0, y: minYPosition, width: 7, height: maxYPosition - minYPosition))
         context.addPath(combined)