Fixes a major performance regression from the introduction of Kitty image

support.

The scroll() method was computing very expensive operations on each line
scrolled, now instead, we keep track of which lines have images, and
only trigger the expensive call if we have to.

So the manual poking to attach images needs to be gated so that we can
keep our accounting correct.

Author: migueldeicaza

Sources/SwiftTerm/Apple/AppleTerminalView.swift

@@ -1693,7 +1693,7 @@ extension TerminalView {
                 attachedImage.kittyPixelOffsetY = context.pixelOffsetY
             }
 
-            buffer.lines [buffer.y+buffer.yBase].attach(image: attachedImage)
+            buffer.attachImage(attachedImage, toLineAt: buffer.y+buffer.yBase)
 
             terminal.updateRange (buffer.y)
 

Sources/SwiftTerm/Buffer.swift

@@ -20,6 +20,7 @@ public final class Buffer {
     private var _lines: CircularBufferLineList
     var xDisp, _yDisp, xBase: Int
     private var _x, _y, _yBase: Int
+    private var _linesWithImagesCount: Int = 0
 
     // this keeps incrementing even as we run out of space in _lines and trim out
     // old lines.
@@ -200,6 +201,54 @@ public final class Buffer {
     var lines : CircularBufferLineList {
         get { return _lines }
     }
+
+    /// Returns true if any lines in this buffer have images attached
+    public var hasAnyImages: Bool {
+        return _linesWithImagesCount > 0
+    }
+
+    /// Attaches an image to the line at the given index, tracking the count of lines with images
+    func attachImage(_ image: TerminalImage, toLineAt index: Int) {
+        let line = lines[index]
+        let hadImages = line.images != nil
+        line.attach(image: image)
+        if !hadImages {
+            _linesWithImagesCount += 1
+        }
+    }
+
+    /// Clears images from the line at the given index, tracking the count of lines with images
+    func clearImagesFromLine(at index: Int) {
+        let line = lines[index]
+        if line.images != nil {
+            _linesWithImagesCount -= 1
+            line.images = nil
+        }
+    }
+
+    /// Recalculates the count of lines with images (used after reflow operations)
+    func recalculateLinesWithImagesCount() {
+        var count = 0
+        for i in 0..<lines.count {
+            if lines[i].images != nil {
+                count += 1
+            }
+        }
+        _linesWithImagesCount = count
+    }
+
+    private func setupLinesCallbacks() {
+        _lines.onLineRecycled = { [weak self] hadImages in
+            if hadImages {
+                self?._linesWithImagesCount -= 1
+            }
+        }
+        _lines.onLinePushed = { [weak self] hasImages in
+            if hasImages {
+                self?._linesWithImagesCount += 1
+            }
+        }
+    }
 
     private var curAttr: Attribute = Attribute.empty
     private var insertMode: Bool = false
@@ -242,6 +291,7 @@ public final class Buffer {
         let len = hasScrollback ? (scrollback ?? 0) + rows : rows
         _lines = CircularBufferLineList (maxLength: len)
         _lines.makeEmpty = { [unowned self] line in getBlankLine(attribute: CharData.defaultAttr, isWrapped: false) }
+        setupLinesCallbacks()
         setupTabStops (tabStopWidth: tabStopWidth)
     }
 
@@ -308,6 +358,8 @@ public final class Buffer {
 
         _lines = CircularBufferLineList (maxLength: getCorrectBufferLength(rows))
         _lines.makeEmpty = { [unowned self] line in getBlankLine(attribute: CharData.defaultAttr, isWrapped: false) }
+        setupLinesCallbacks()
+        _linesWithImagesCount = 0
         scrollTop = 0
         scrollBottom = rows - 1
 
@@ -1036,6 +1088,7 @@ public final class Buffer {
         } else {
             reflowNarrower (cols, rows, newCols, newRows)
         }
+        recalculateLinesWithImagesCount()
     }
 
     static var n = 0

Sources/SwiftTerm/BufferLine.swift

@@ -287,8 +287,9 @@ public final class BufferLine: CustomDebugStringConvertible {
         return result
     }
 
-    /// Attaches the specified terminal image to this buffer line
-    public func attach (image: TerminalImage) {
+    /// Attaches the specified terminal image to this buffer line.
+    /// This method is internal - use Buffer.attachImage() to attach images with proper tracking.
+    func attach (image: TerminalImage) {
         if var imageArray = self.images {
             imageArray.append (image)
             images = imageArray

Sources/SwiftTerm/CircularList.swift

@@ -266,6 +266,12 @@ internal class CircularBufferLineList {
     /// does not exist, or the index requested otherwise
     //
     var makeEmpty: ((_ idx: Int) -> BufferLine)? = nil
+
+    /// Called when a line is about to be recycled, with true if the line had images
+    var onLineRecycled: ((_ hadImages: Bool) -> Void)? = nil
+
+    /// Called when a line is pushed, with true if the line has images
+    var onLinePushed: ((_ hasImages: Bool) -> Void)? = nil
 
     public init (maxLength: Int)
     {
@@ -314,6 +320,7 @@ internal class CircularBufferLineList {
         } else {
             count = count + 1
         }
+        onLinePushed?(value.images != nil)
     }
 
     func recycle ()
@@ -325,7 +332,9 @@ internal class CircularBufferLineList {
         let index = getCyclicIndex(count)
         startIndex += 1
         startIndex = startIndex % maxLength
+        let hadImages = array[index]?.images != nil
         array[index]?.clear(with: CharData.defaultAttr)
+        onLineRecycled?(hadImages)
         //array [index] = makeEmpty! (-1)
     }
 

Sources/SwiftTerm/KittyGraphics.swift

@@ -1322,7 +1322,7 @@ extension Terminal {
             image.col = newLeftCol
             image.kittyCol = newLeftCol
             image.kittyRow = newTopRow
-            buffer.lines[move.targetRow].attach(image: image)
+            buffer.attachImage(image, toLineAt: move.targetRow)
         }
     }
 
@@ -1462,10 +1462,10 @@ extension Terminal {
 
     func clearAllKittyImages() {
         for idx in 0..<buffer.lines.count {
-            buffer.lines[idx].images = nil
+            buffer.clearImagesFromLine(at: idx)
         }
         for idx in 0..<altBuffer.lines.count {
-            altBuffer.lines[idx].images = nil
+            altBuffer.clearImagesFromLine(at: idx)
         }
         kittyGraphicsState.imagesById.removeAll()
         kittyGraphicsState.imageNumbers.removeAll()