- rewrote function's name.

window.

modules/rewrite-message-urls.lisp

@@ -56,7 +56,7 @@ So the whole list is like: '((\"foo\" \"bar\") (\"old\" \"new\") ...)")
                               text
                               (cdr mapping)))
 
-(defun skipped-row-p (row)
+(defun rewriting-link-skipped-row-p (row)
   (let* ((original-type     (message-window:row-get-original-object row))
          (skipped-row-types (list 'gemini-parser:pre-line
                                   'gemini-parser:pre-start
@@ -65,25 +65,30 @@ So the whole list is like: '((\"foo\" \"bar\") (\"old\" \"new\") ...)")
     (or (message-window:row-invisible-p row)
         (find-if (lambda (a) (typep original-type a)) skipped-row-types))))
 
-(defun %rewriting-link-rewrite-row (links-mapping)
-  (lambda (row)
-    (let* ((original-string (line-oriented-window:normal-text row)))
-      (if (skipped-row-p row)
-          row
+(defun rewriting-link-rewrite-row (window index links-mapping)
+  (with-accessors ((rows line-oriented-window:rows)) window
+    (when rows
+      (let* ((row             (elt rows index))
+             (original-string (line-oriented-window:normal-text row)))
+        (when (not (rewriting-link-skipped-row-p row))
           (let* ((simple-string   (tui:tui-string->chars-string original-string))
                  (replaced-string simple-string))
             (loop for mapping in links-mapping do
               (setf replaced-string
                     (rewriting-link-replace-mapping mapping replaced-string)))
-            replaced-string)))))
+            (setf (line-oriented-window:normal-text row)
+                  (message-window::colorize-lines replaced-string))
+            (setf (elt rows index)
+                  (message-window:text->rendered-lines-rows window row))))))))
 
 (defun rewriting-link-message-hook-fn (message-window)
-  (let* ((map-fn        (%rewriting-link-rewrite-row *rewriting-link-rules*))
-         (replaced-rows (line-oriented-window:rows-map-raw message-window
-                                                           map-fn))
-         (new-rows      (message-window:text->rendered-lines-rows message-window
-                                                                  replaced-rows)))
-    (line-oriented-window:update-all-rows message-window new-rows)))
+  (multiple-value-bind (x start-visible-index end-visible-index)
+      (message-window:visible-rows message-window)
+    (declare (ignore x))
+    (loop for i from start-visible-index below end-visible-index do
+      (rewriting-link-rewrite-row message-window i *rewriting-link-rules*))
+    message-window))
+
 
 (defun rewriting-link-links-window-hook-fn (all-links)
   (let ((links-mapping  (rewriting-link-messages-links-rules all-links))

src/message-window.lisp

@@ -100,13 +100,25 @@
 (defmethod calculate ((object message-window) dt)
   (declare (ignore object dt)))
 
+(defun visible-rows (window)
+  (with-accessors ((row-selected-index row-selected-index)) window
+    (let* ((start  row-selected-index)
+           (end    (+ start
+                      (win-height-no-border window)))
+           (rows   (rows-safe-subseq window
+                                     row-selected-index
+                                     :end end)))
+      (values rows
+              start
+              (length rows)))))
+
 (defun draw-text (window)
   (when hooks:*before-rendering-message-text*
     (hooks:run-hook 'hooks:*before-rendering-message-text* window))
   (with-accessors ((row-selected-index row-selected-index)) window
-    (let ((actual-rows (line-oriented-window:rows-safe-subseq window row-selected-index)))
-      (loop for line in actual-rows
-            for y from  1 below (win-height-no-border window)
+    (let ((visible-rows (visible-rows window)))
+      (loop for line in visible-rows
+            for y from  1
             do
                (cond
                  ;; testing invisibility should  never returns true as
@@ -294,21 +306,21 @@
 (defmethod text->rendered-lines-rows (window (text complex-string))
   text)
 
-(defgeneric collect-lines-from-ir (object))
+(defgeneric collect-lines-from-ir (object window))
 
-(defmethod collect-lines-from-ir ((object gemini-parser:with-lines))
-  (let ((colorized-lines (colorize-lines (gemini-parser:lines object))))
+(defmethod collect-lines-from-ir ((object gemini-parser:with-lines) (window message-window))
+  (let ((colorized-lines (colorize-lines (%fit-lines window (gemini-parser:lines object)))))
     (loop for i in colorized-lines
           collect
           (make-instance 'line
                          :normal-text i))))
 
 (defmethod text->rendered-lines-rows (window (text gemini-parser:quoted-lines))
-  (collect-lines-from-ir text))
+  (collect-lines-from-ir text window))
 
 (defmethod text->rendered-lines-rows (window (text gemini-parser:header-line))
   (let* ((group-id (gemini-parser:group-id text))
-         (lines    (collect-lines-from-ir text))
+         (lines    (collect-lines-from-ir text window))
          (res      (mapcar (lambda (a)
                              (let ((line (row-add-original-object a text)))
                                (row-add-group-id line group-id)))
@@ -316,15 +328,18 @@
     res))
 
 (defmethod text->rendered-lines-rows (window (text gemini-parser:unordered-list-line))
-  (collect-lines-from-ir text))
+  (collect-lines-from-ir text window))
 
 (defmethod text->rendered-lines-rows (window (text gemini-parser:link-line))
-  (let ((res (collect-lines-from-ir text)))
+  (let ((res (collect-lines-from-ir text window)))
     (row-add-original-object res text)
     res)) ; even if row-add-original-object returns the modified line explicit returns for clarity
 
-(defmethod text->rendered-lines-rows (window (text string))
-  (labels ((fit-lines (lines)
+(defun %fit-text (window text)
+  (let ((lines (split-lines text)))
+    (%fit-lines window lines)))
+
+(defun %fit-lines (window lines)
   (let ((res   ()))
     (loop for line in lines do
       (cond
@@ -337,16 +352,17 @@
                                           (win-width-no-border window))
                do
                   (push fitted-line res)))))
-               (reverse res))))
-    (let* ((lines        (split-lines text))
-           (fitted-lines (fit-lines lines))
+    (reverse res)))
+
+(defmethod text->rendered-lines-rows (window (text string))
+  (let* ((fitted-lines (%fit-text window text))
          (new-rows     (colorize-lines fitted-lines)))
     (mapcar (lambda (text-line)
               (if (typep text-line 'line)
                   text-line
                   (make-instance 'line
                                  :normal-text text-line)))
-              new-rows))))
+            new-rows)))
 
 (defun remove-invisible-rows (rows)
   (remove-if #'row-invisible-p rows))

src/package.lisp

@@ -1941,6 +1941,7 @@
    :display-chat-p
    :row-get-original-object
    :viewport-width
+   :visible-rows
    :row-vertical-space-p
    :row-preformatted-p
    :row-invisible-p