Function: logview--fontify-region
logview--fontify-region is a natively compiled function defined in
logview.el.
Signature
(logview--fontify-region REGION-START REGION-END LOUDLY)
Source Code
;; Defined in /nix/store/3zkn9hgpv447zb8nrg55d9x2ynmmrk40-emacs-packages-deps/share/emacs/site-lisp/elpa/logview-20260218.2013/logview.el
(defun logview--fontify-region (region-start region-end loudly)
(when (logview-initialized-p)
;; We are basically managing narrowing indirectly, by not fontifying further than
;; `region-end' (possibly expanded). Not using `std' here to prevent
;; `logview--iterate-entries-forward' from stopping early because of outer narrowing.
(logview--temporarily-widening
;; We are very fast. Don't fontify too little to avoid overhead.
;; FIXME: See `font-lock-extend-region-functions'. Might want to reuse that instead.
(when (and (< region-end (point-max)) (not (get-text-property (1+ region-end) 'fontified)))
(let ((expanded-region-end (min (point-max) (+ region-start logview--lazy-region-size))))
(when (< region-end expanded-region-end)
(setq region-end (or (next-single-property-change (1+ region-end) 'fontified nil expanded-region-end) expanded-region-end)))))
(when (and (> region-start (point-min)) (not (get-text-property (1- region-start) 'fontified)))
(let ((expanded-region-start (max (point-min) (- region-end logview--lazy-region-size))))
(when (> region-start expanded-region-start)
(setq region-start (or (previous-single-property-change (1- region-start) 'fontified nil expanded-region-start) expanded-region-start)))))
;; Largely for derived modes. Logview itself simply replaces all relevant
;; properties (e.g. faces) everywhere in the fontified region and that's normally
;; enough.
(font-lock-unfontify-region region-start region-end)
(logview--std-altering
(if logview--postpone-fontification
(progn (add-face-text-property region-start region-end 'logview-unprocessed)
(unless logview--pending-refontifications
(run-with-idle-timer 0 nil #'logview--schedule-pending-refontification))
(push (list (current-buffer) region-start region-end) logview--pending-refontifications))
(save-match-data
(let ((region-start (cdr (logview--do-locate-current-entry region-start))))
(when region-start
(let* ((have-timestamp (memq 'timestamp logview--submode-features))
(have-level (memq 'level logview--submode-features))
(have-name (memq 'name logview--submode-features))
(have-thread (memq 'thread logview--submode-features))
(validator (cdr logview--effective-filter))
(difference-to-section-headers logview--timestamp-difference-to-section-headers)
(sections-thread-bound (when difference-to-section-headers (logview-sections-thread-bound-p)))
(common-difference-base (or logview--timestamp-difference-base
(when (and difference-to-section-headers (not sections-thread-bound)) :unknown)))
(difference-bases-per-thread (or logview--timestamp-difference-per-thread-bases
(when (and difference-to-section-headers sections-thread-bound) (make-hash-table :test #'equal))))
(displaying-differences (or common-difference-base difference-bases-per-thread))
(difference-format-string logview--timestamp-difference-format-string)
(header-filter (cdr logview--section-header-filter))
(show-only-headers (and header-filter logview--narrow-to-section-headers))
(highlighter (cdr logview--highlighted-filter))
(highlighted-part logview-highlighted-entry-part)
(dim-unsearchable (and logview-search-only-in-messages isearch-mode)))
(logview--iterate-entries-forward
region-start
(lambda (entry start)
(let ((end (logview--entry-end entry start))
filtered)
(if (or (null validator) (funcall validator entry start))
(let ((header-entry (and header-filter (funcall header-filter entry start))))
(if (and show-only-headers (not header-entry))
(setf filtered t)
(when have-level
(let ((entry-faces (aref logview--submode-level-faces (logview--entry-level entry))))
(put-text-property start end 'face (car entry-faces))
(add-face-text-property (logview--entry-group-start entry start logview--level-group)
(logview--entry-group-end entry start logview--level-group)
(cdr entry-faces))))
(when have-timestamp
(let ((from (logview--entry-group-start entry start logview--timestamp-group))
(to (logview--entry-group-end entry start logview--timestamp-group))
(thread (when difference-bases-per-thread (logview--entry-group entry start logview--thread-group)))
timestamp-replaced)
(add-face-text-property from to 'logview-timestamp)
(when displaying-differences
(when (and header-entry difference-to-section-headers)
(let ((base `(,entry . ,start)))
(if difference-bases-per-thread
(puthash thread base difference-bases-per-thread)
(setf common-difference-base base))))
(let ((difference-base (or (when difference-bases-per-thread
(gethash thread difference-bases-per-thread (when difference-bases-per-thread :unknown)))
common-difference-base)))
;; This is possible only when displaying differences to section header.
;; Means that we don't yet know where the header is.
(when (eq difference-base :unknown)
;; FIXME: Might need to improve performance here, e.g. using cache.
(save-excursion
(goto-char start)
(logview--forward-section 0)
(logview--locate-current-entry entry start
(setf difference-base (when (funcall header-filter entry start) `(,entry . ,start)))
(if difference-bases-per-thread
(puthash thread difference-base difference-bases-per-thread)
(setf common-difference-base difference-base)))))
;; Hide timestamp with time difference if there is a difference
;; base entry and we are not positioned over it right now.
(when (and difference-base (not (and (= (cdr difference-base) start)
(progn (logview--entry-timestamp entry start) ; Make sure that it is parsed.
(equal (car difference-base) entry)))))
;; FIXME: It is possible that fractionals are not the last
;; thing in the timestamp, in which case it would be
;; nicer to add some spaces on the right. However,
;; it's not easy to do and is also quite unlikely,
;; so ignoring that for now.
(let* ((difference (- (logview--entry-timestamp entry start)
(logview--entry-timestamp (car difference-base) (cdr difference-base))))
(difference-string (format difference-format-string difference))
(length-delta (- to from (length difference-string))))
(when (> length-delta 0)
(setq difference-string (concat (make-string length-delta ? ) difference-string)))
(put-text-property from to 'display difference-string)
(setq timestamp-replaced t)))))
(unless timestamp-replaced
(remove-list-of-text-properties from to '(display)))))
(when have-name
(add-face-text-property (logview--entry-group-start entry start logview--name-group)
(logview--entry-group-end entry start logview--name-group)
'logview-name))
(when have-thread
(add-face-text-property (logview--entry-group-start entry start logview--thread-group)
(logview--entry-group-end entry start logview--thread-group)
'logview-thread))
(when header-entry
(add-face-text-property start end 'logview-section))
(when dim-unsearchable
(add-face-text-property start (logview--entry-message-start entry start) 'logview-unsearchable))
(when (and highlighter (funcall highlighter entry start))
(add-face-text-property (if (eq highlighted-part 'message) (logview--entry-message-start entry start) start)
(if (eq highlighted-part 'header) (logview--space-back (logview--entry-message-start entry start)) end)
'logview-highlight))))
(setq filtered t))
(logview--update-entry-invisibility start (logview--entry-details-start entry start) end filtered 'propagate 'propagate)
;; There appears to be a bug in displaying code for the case that
;; fontifying function hides all the text in the region it has been
;; called for: Emacs still displays an empty line or at least the
;; ellipses to denote hidden text (i.e. not merged with the
;; previous ellipses). Previously, we'd work around this by
;; continuing past the region. However, now we stop anyway because
;; of responsiveness improvements: that is more important than
;; minor displaying glitches.
(< end region-end)))))))
(setf logview--num-fontified-in-row (1+ (or logview--num-fontified-in-row 0)))
(when (or (input-pending-p) (>= logview--num-fontified-in-row logview--max-fontified-in-row))
(setf logview--postpone-fontification t))
;; `font-lock-default-fontify-region' includes some other calls that we simply
;; drop for now. It is unlikely that e.g. a syntax table would be useful here.
(unless (equal font-lock-keywords '(t nil))
;; This is largely for derived modes. Logview itself doesn't define any keywords.
(font-lock-fontify-keywords-region region-start region-end loudly)))))))
`(jit-lock-bounds ,region-start . ,region-end))