;;; isearch.el --- incremental search minor mode.
-;; Copyright (C) 1992, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
+;; Copyright (C) 1992, 93, 94, 95, 96, 97, 1999 Free Software Foundation, Inc.
;; Author: Daniel LaLiberte <liberte@cs.uiuc.edu>
;; Maintainer: FSF
+;; Keywords: matching
;; This file is part of GNU Emacs.
;; For programmed use of isearch-mode, e.g. calling (isearch-forward),
;; isearch-mode behaves modally and does not return until the search
-;; is completed. It uses a recursive-edit to behave this way. Note:
-;; gnus does it wrong: (call-interactively 'isearch-forward).
+;; is completed. It uses a recursive-edit to behave this way.
;; The key bindings active within isearch-mode are defined below in
;; `isearch-mode-map' which is given bindings close to the default
;; be longer than two chars. Also see minibuffer-local-isearch-map
;; for bindings active during `isearch-edit-string'.
-;; Note to emacs version 19 users: isearch-mode should work even if
-;; you switch windows with the mouse, in which case isearch-mode is
-;; terminated automatically before the switch. This is true of lemacs
-;; too, with a few more cleanups I've neglected in this release.
-;; No one has supplied patches for epoch yet.
+;; isearch-mode should work even if you switch windows with the mouse,
+;; in which case isearch-mode is terminated automatically before the
+;; switch.
;; The search ring and completion commands automatically put you in
;; the minibuffer to edit the string. This gives you a chance to
(defgroup isearch nil
"Incremental search minor mode."
+ :link '(emacs-commentary-link "isearch")
+ :link '(custom-manual "(emacs)Incremental Search")
:prefix "isearch-"
:prefix "search-"
:group 'matching)
If this value is `not-yanks', yanked text is always downcased."
:type '(choice (const :tag "off" nil)
(const not-yanks)
- (sexp :tag "on" :format "%t\n" t))
+ (other :tag "on" t))
:group 'isearch)
(defcustom search-nonincremental-instead t
(defcustom search-whitespace-regexp "\\s-+"
"*If non-nil, regular expression to match a sequence of whitespace chars.
-You might want to use something like \"[ \\t\\r\\n]+\" instead."
+This applies to regular expression incremental search.
+You might want to use something like \"[ \\t\\r\\n]+\" instead.
+In the Customization buffer, that is `[' followed by a space,
+a tab, a carriage return (control-M), a newline, and `]+'."
:type 'regexp
:group 'isearch)
(or (vectorp (nth 1 map))
(char-table-p (nth 1 map))
(error "The initialization of isearch-mode-map must be updated"))
- ;; Make Latin-1, Latin-2, Latin-3 and Latin-4 characters
- ;; search for themselves.
- (aset (nth 1 map) (make-char 'latin-iso8859-1) 'isearch-printing-char)
- (aset (nth 1 map) (make-char 'latin-iso8859-2) 'isearch-printing-char)
- (aset (nth 1 map) (make-char 'latin-iso8859-3) 'isearch-printing-char)
- (aset (nth 1 map) (make-char 'latin-iso8859-4) 'isearch-printing-char)
- (aset (nth 1 map) (make-char 'latin-iso8859-9) 'isearch-printing-char)
+ ;; Make all multibyte characters search for themselves.
+ (let ((l (generic-character-list))
+ (table (nth 1 map)))
+ (while l
+ (set-char-table-default table (car l) 'isearch-printing-char)
+ (setq l (cdr l))))
;; Make function keys, etc, exit the search.
(define-key map [t] 'isearch-other-control-char)
;; Control chars, by default, end isearch mode transparently.
(define-key map (make-string 1 i) 'isearch-other-control-char)
(setq i (1+ i)))
- ;; Printing chars extend the search string by default.
+ ;; Single-byte printing chars extend the search string by default.
(setq i ?\ )
- (while (< i (length (nth 1 map)))
+ (while (< i 256)
(define-key map (vector i) 'isearch-printing-char)
(setq i (1+ i)))
(define-key map "\C-j" 'isearch-printing-char)
(define-key map "\t" 'isearch-printing-char)
(define-key map " " 'isearch-whitespace-chars)
+ (define-key map [?\S-\ ] 'isearch-whitespace-chars)
(define-key map "\C-w" 'isearch-yank-word)
(define-key map "\C-y" 'isearch-yank-line)
(define-key map "\C-\\" 'isearch-toggle-input-method)
(define-key map "\C-^" 'isearch-toggle-specified-input-method)
+ ;; People expect to be able to paste with the mouse.
+ (define-key map [mouse-2] #'isearch-mouse-yank)
+ (define-key map [down-mouse-2] nil)
+
(setq isearch-mode-map map)
))
;; Accumulate here the overlays opened during searching.
(defvar isearch-opened-overlays nil)
+;; The value of input-method-function when isearch is invoked.
+(defvar isearch-input-method-function nil)
+
+;; A flag to tell if input-method-function is locally bound when
+;; isearch is invoked.
+(defvar isearch-input-method-local-p nil)
+
;; Minor-mode-alist changes - kind of redundant with the
;; echo area, but if isearching in multiple windows, it can be useful.
(define-key esc-map "\C-r" 'isearch-backward-regexp)
;;; Entry points to isearch-mode.
-;;; These four functions should replace those in loaddefs.el
-;;; An alternative is to defalias isearch-forward etc to isearch-mode,
-;;; and look at this-command to set the options accordingly.
(defun isearch-forward (&optional regexp-p no-recursive-edit)
"\
string and search for it.
Type \\[isearch-yank-line] to yank rest of line onto end of search string\
and search for it.
-Type \\[isearch-yank-kill] to yank the last string of killed text.
+Type \\[isearch-yank-kill] to yank last killed text onto end of search string\
+ and search for it.
Type \\[isearch-quote-char] to quote control character to search for it.
\\[isearch-abort] while searching or when search has failed cancels input\
back to what has
isearch-opoint (point)
search-ring-yank-pointer nil
isearch-opened-overlays nil
+ isearch-input-method-function input-method-function
+ isearch-input-method-local-p (local-variable-p 'input-method-function)
regexp-search-ring-yank-pointer nil)
+
+ ;; We must bypass input method while reading key. When a user type
+ ;; printable character, appropriate input method is turned on in
+ ;; minibuffer to read multibyte charactes.
+ (or isearch-input-method-local-p
+ (make-local-variable 'input-method-function))
+ (setq input-method-function nil)
+
(looking-at "")
(setq isearch-window-configuration
(if isearch-slow-terminal-mode (current-window-configuration) nil))
(setq ;; quit-flag nil not for isearch-mode
isearch-adjusted nil
isearch-yank-flag nil)
- )
+ (isearch-lazy-highlight-new-loop))
(defun isearch-done (&optional nopush edit)
(remove-hook 'mouse-leave-buffer-hook 'isearch-done)
(setq overriding-terminal-local-map nil)
;; (setq pre-command-hook isearch-old-pre-command-hook) ; for lemacs
(isearch-dehighlight t)
+ (isearch-lazy-highlight-cleanup)
(let ((found-start (window-start (selected-window)))
(found-point (point)))
(if isearch-window-configuration
(message "Mark saved where search started"))))))
(setq isearch-mode nil)
+ (if isearch-input-method-local-p
+ (setq input-method-function isearch-input-method-function)
+ (kill-local-variable 'input-method-function))
+
(force-mode-line-update)
+ ;; If we ended in the middle of some intangible text,
+ ;; move to the further end of that intangible text.
+ (let ((after (if (eobp) nil
+ (get-text-property (point) 'intangible)))
+ (before (if (bobp) nil
+ (get-text-property (1- (point)) 'intangible))))
+ (when (and before after (eq before after))
+ (if isearch-forward
+ (goto-char (next-single-property-change (point) 'intangible))
+ (goto-char (previous-single-property-change (point) 'intangible)))))
+
(if (and (> (length isearch-string) 0) (not nopush))
;; Update the ring data.
(isearch-update-ring isearch-string isearch-regexp))
(setcdr (nthcdr (1- search-ring-max) search-ring) nil))))))
;;; Switching buffers should first terminate isearch-mode.
-;;; This is done quite differently for each variant of emacs.
-;;; For lemacs, see Exiting in lemacs below
-
-;; For Emacs 19, the frame switch event is handled.
-(defun isearch-switch-frame-handler ()
- (interactive) ;; Is this necessary?
- ;; First terminate isearch-mode.
- (isearch-done)
- (isearch-clean-overlays)
- (handle-switch-frame (car (cdr (isearch-last-command-char)))))
+;;; ;; For Emacs 19, the frame switch event is handled.
+;;; (defun isearch-switch-frame-handler ()
+;;; (interactive) ;; Is this necessary?
+;;; ;; First terminate isearch-mode.
+;;; (isearch-done)
+;;; (isearch-clean-overlays)
+;;; (handle-switch-frame (car (cdr last-command-char))))
\f
;; Commands active while inside of the isearch minor mode.
(isearch-update))
-(defun isearch-yank (chunk)
- ;; Helper for isearch-yank-word and isearch-yank-line
- ;; CHUNK should be word, line, kill, or x-sel.
- (let ((string (cond
- ((eq chunk 'kill)
- (current-kill 0))
- ((eq chunk 'x-sel)
- (x-get-selection))
- (t
- (save-excursion
- (and (not isearch-forward) isearch-other-end
- (goto-char isearch-other-end))
- (buffer-substring
- (point)
- (save-excursion
- (cond
- ((eq chunk 'word)
- (forward-word 1))
- ((eq chunk 'line)
- (end-of-line)))
- (point))))))))
- ;; Downcase the string if not supposed to case-fold yanked strings.
- (if (and isearch-case-fold-search
- (eq 'not-yanks search-upper-case))
- (setq string (downcase string)))
- (if isearch-regexp (setq string (regexp-quote string)))
- (setq isearch-string (concat isearch-string string)
- isearch-message
- (concat isearch-message
- (mapconcat 'isearch-text-char-description
- string ""))
- ;; Don't move cursor in reverse search.
- isearch-yank-flag t))
+(defun isearch-yank-string (string)
+ "Pull STRING into search string."
+ ;; Downcase the string if not supposed to case-fold yanked strings.
+ (if (and isearch-case-fold-search
+ (eq 'not-yanks search-upper-case))
+ (setq string (downcase string)))
+ (if isearch-regexp (setq string (regexp-quote string)))
+ (setq isearch-string (concat isearch-string string)
+ isearch-message
+ (concat isearch-message
+ (mapconcat 'isearch-text-char-description
+ string ""))
+ ;; Don't move cursor in reverse search.
+ isearch-yank-flag t)
(isearch-search-and-update))
(defun isearch-yank-kill ()
"Pull string from kill ring into search string."
(interactive)
- (isearch-yank 'kill))
+ (isearch-yank-string (current-kill 0)))
+
+(defun isearch-yank-x-selection ()
+ "Pull current X selection into search string."
+ (interactive)
+ (isearch-yank-string (x-get-selection)))
+
+(defun isearch-mouse-yank (click arg)
+ "Yank with the mouse in Isearch mode.
+For a click in the echo area, invoke `isearch-yank-x-selection'.
+Otherwise invoke `mouse-yank-at-click'."
+ (interactive "e\nP")
+ (let ((w (posn-window (event-start click))))
+ (if (and (window-minibuffer-p w)
+ (not (minibuffer-window-active-p w))) ; in echo area
+ (isearch-yank-x-selection)
+ (mouse-yank-at-click click arg))))
(defun isearch-yank-word ()
"Pull next word from buffer into search string."
(interactive)
- (isearch-yank 'word))
+ (isearch-yank-string
+ (save-excursion
+ (and (not isearch-forward) isearch-other-end
+ (goto-char isearch-other-end))
+ (buffer-substring (point) (progn (forward-word 1) (point))))))
(defun isearch-yank-line ()
"Pull rest of line from buffer into search string."
(interactive)
- (isearch-yank 'line))
+ (isearch-yank-string
+ (save-excursion
+ (and (not isearch-forward) isearch-other-end
+ (goto-char isearch-other-end))
+ (buffer-substring (point) (line-end-position)))))
(defun isearch-search-and-update ()
(if (and (not isearch-forward) (not isearch-adjusted)
(condition-case ()
(let ((case-fold-search isearch-case-fold-search))
+ (if (and (eq case-fold-search t) search-upper-case)
+ (setq case-fold-search
+ (isearch-no-upper-case-p isearch-string isearch-regexp)))
(looking-at (if isearch-regexp isearch-string
(regexp-quote isearch-string))))
(error nil))
- (or isearch-yank-flag
- (<= (match-end 0)
- (min isearch-opoint isearch-barrier))))
+ (or isearch-yank-flag
+ (<= (match-end 0)
+ (min isearch-opoint isearch-barrier))))
(progn
(setq isearch-success t
isearch-invalid-regexp nil
"Handle * and ? specially in regexps."
(interactive)
(if isearch-regexp
-
- (progn
- (setq isearch-adjusted t)
- ;; Get the isearch-other-end from before the last search.
- ;; We want to start from there,
- ;; so that we don't retreat farther than that.
- ;; (car isearch-cmds) is after last search;
- ;; (car (cdr isearch-cmds)) is from before it.
- (let ((cs (nth 5 (car (cdr isearch-cmds)))))
- (setq cs (or cs isearch-barrier))
- (goto-char
- (if isearch-forward
- (max cs isearch-barrier)
- (min cs isearch-barrier))))))
- (isearch-process-search-char (isearch-last-command-char)))
+ (let ((idx (length isearch-string)))
+ (while (and (> idx 0)
+ (eq (aref isearch-string (1- idx)) ?\\))
+ (setq idx (1- idx)))
+ (when (= (mod (- (length isearch-string) idx) 2) 0)
+ (setq isearch-adjusted t)
+ ;; Get the isearch-other-end from before the last search.
+ ;; We want to start from there,
+ ;; so that we don't retreat farther than that.
+ ;; (car isearch-cmds) is after last search;
+ ;; (car (cdr isearch-cmds)) is from before it.
+ (let ((cs (nth 5 (car (cdr isearch-cmds)))))
+ (setq cs (or cs isearch-barrier))
+ (goto-char
+ (if isearch-forward
+ (max cs isearch-barrier)
+ (min cs isearch-barrier)))))))
+ (isearch-process-search-char last-command-char))
(defun isearch-|-char ()
(progn
(setq isearch-adjusted t)
(goto-char isearch-barrier)))
- (isearch-process-search-char (isearch-last-command-char)))
+ (isearch-process-search-char last-command-char))
(defalias 'isearch-other-control-char 'isearch-other-meta-char)
"Quote special characters for incremental search."
(interactive)
(let ((char (read-quoted-char (isearch-message t))))
- ;; Assume character codes 0200 - 0377 stand for
- ;; European characters in Latin-1, and convert them
- ;; to Emacs characters.
+ ;; Assume character codes 0200 - 0377 stand for characters in some
+ ;; single-byte character set, and convert them to Emacs
+ ;; characters.
(and enable-multibyte-characters
(>= char ?\200)
(<= char ?\377)
- (setq char (+ char nonascii-insert-offset)))
+ (setq char (unibyte-char-to-multibyte char)))
(isearch-process-search-char char)))
(defun isearch-return-char ()
(defun isearch-printing-char ()
"Add this ordinary printing character to the search string and search."
(interactive)
- (if current-input-method
- (isearch-process-search-multibyte-characters (isearch-last-command-char))
- (isearch-process-search-char (isearch-last-command-char))))
+ (let ((char last-command-char))
+ (if (= char ?\S-\ )
+ (setq char ?\ ))
+ (if (and enable-multibyte-characters
+ (>= char ?\200)
+ (<= char ?\377))
+ (isearch-process-search-char (unibyte-char-to-multibyte char))
+ (if current-input-method
+ (isearch-process-search-multibyte-characters char)
+ (isearch-process-search-char char)))))
(defun isearch-whitespace-chars ()
"Match all whitespace chars, if in regexp mode.
-If you want to search for just a space, type C-q SPC."
+If you want to search for just a space, type \\[quoted-insert] SPC."
(interactive)
(if isearch-regexp
(if (and search-whitespace-regexp (not isearch-within-brackets)
(defun isearch-process-search-char (char)
;; Append the char to the search string, update the message and re-search.
(isearch-process-search-string
- (isearch-char-to-string char)
- (if (>= char 0200)
+ (char-to-string char)
+ (if (>= char ?\200)
(char-to-string char)
(isearch-text-char-description char))))
(isearch-ring-adjust nil))
(defun isearch-ring-advance-edit (n)
- "Insert the next element of the search history into the minibuffer."
+ "Insert the next element of the search history into the minibuffer.
+With prefix arg N, insert the Nth element."
(interactive "p")
(let* ((yank-pointer-name (if isearch-regexp
'regexp-search-ring-yank-pointer
(mod (- (or yank-pointer 0) n)
length)))
- (erase-buffer)
+ (delete-field)
(insert (nth yank-pointer ring))
(goto-char (point-max)))))
(defun isearch-ring-retreat-edit (n)
- "Inserts the previous element of the search history into the minibuffer."
+ "Insert the previous element of the search history into the minibuffer.
+With prefix arg N, insert the Nth element."
(interactive "p")
(isearch-ring-advance-edit (- n)))
(setq isearch-string (buffer-string))
(if (isearch-complete1)
(progn
- (erase-buffer)
+ (delete-field)
(insert isearch-string))))
\f
(overlay-put ov 'intangible nil)))
-;;; This is called at the end of isearch. I will open the overlays
-;;; that contain the latest match. Obviously in case of a C-g the
+;;; This is called at the end of isearch. It will open the overlays
+;;; that contain the latest match. Obviously in case of a C-g the
;;; point returns to the original location which surely is not contain
;;; in any of these overlays, se we are safe in this case too.
(defun isearch-open-necessary-overlays (ov)
;; Check that invisibility runs up to END.
(save-excursion
(goto-char beg)
- (let
- ;; can-be-opened keeps track if we can open some overlays.
- ((can-be-opened (eq search-invisible 'open))
- ;; the list of overlays that could be opened
- (crt-overlays nil))
+ (let (
+ ;; can-be-opened keeps track if we can open some overlays.
+ (can-be-opened (eq search-invisible 'open))
+ ;; the list of overlays that could be opened
+ (crt-overlays nil))
(when (and can-be-opened isearch-hide-immediately)
- (isearch-close-unecessary-overlays beg end))
+ (isearch-close-unecessary-overlays beg end))
;; If the following character is currently invisible,
;; skip all characters with that same `invisible' property value.
;; Do that over and over.
(while overlays
(setq o (car overlays)
invis-prop (overlay-get o 'invisible))
- (if (or (memq invis-prop buffer-invisibility-spec)
- (assq invis-prop buffer-invisibility-spec))
+ (if (if (eq buffer-invisibility-spec t)
+ invis-prop
+ (or (memq invis-prop buffer-invisibility-spec)
+ (assq invis-prop buffer-invisibility-spec)))
(if (overlay-get o 'isearch-open-invisible)
(setq ov-list (cons o ov-list))
;; We found one overlay that cannot be
;; It makes sense to append to the open
;; overlays list only if we know that this is
;; t.
- (setq crt-overlays (append ov-list crt-overlays))))
- (goto-char (next-overlay-change (point))))))
+ (setq crt-overlays (append ov-list crt-overlays)))))
+ (goto-char (next-overlay-change (point)))))
;; See if invisibility reaches up thru END.
(if (>= (point) end)
(if (and (not (null can-be-opened)) (consp crt-overlays))
;; Portability functions to support various Emacs versions.
-(defun isearch-char-to-string (c)
- (char-to-string c))
-
(defun isearch-text-char-description (c)
(if (and (integerp c) (or (< c ?\ ) (= c ?\^?)))
(text-char-description c)
- (isearch-char-to-string c)))
+ (char-to-string c)))
;; General function to unread characters or events.
;; Also insert them in a keyboard macro being defined.
(setq unread-command-events
(append char-or-events unread-command-events)))
-(defun isearch-last-command-char ()
- ;; General function to return the last command character.
- last-command-char)
+\f
+;;; isearch-lazy-highlight feature
+;;; by Bob Glickstein <http://www.zanshin.com/~bobg/>
+
+;;; When active, *every* match for the current search string is
+;;; highlighted: the current one using the normal isearch match color
+;;; and all the others using the unobtrusive `secondary-selection'
+;;; color. The extra highlighting makes it easier to anticipate where
+;;; the cursor will land each time you press C-s or C-r to repeat a
+;;; pending search. Highlighting of these additional matches happens
+;;; in a deferred fashion using "idle timers," so the cycles needed do
+;;; not rob isearch of its usual snappy response.
+
+;;; IMPLEMENTATION NOTE: This depends on some isearch internals.
+;;; Specifically:
+;;; - `isearch-update' is expected to be called (at least) every time
+;;; the search string changes;
+;;; - `isearch-string' is expected to contain the current search
+;;; string as entered by the user;
+;;; - `isearch-overlay' is expected to contain the overlay used for
+;;; primary isearch match-highlighting;
+;;; - `isearch-opoint' is expected to contain the location where the
+;;; current search began;
+;;; - the type of the current search is expected to be given by
+;;; `isearch-word' and `isearch-regexp';
+;;; - the direction of the current search is expected to be given by
+;;; `isearch-forward';
+;;; - the variable `isearch-invalid-regexp' is expected to be true
+;;; iff `isearch-string' is an invalid regexp.
+
+(require 'timer)
+
+(defgroup isearch-lazy-highlight nil
+ "Lazy highlighting feature for incremental search."
+ :prefix "isearch-lazy-highlight-"
+ :group 'isearch)
+
+(defcustom isearch-lazy-highlight t
+ "*Controls the lazy-highlighting during incremental searches.
+When non-nil, all text in the buffer matching the current search
+string is highlighted lazily (see `isearch-lazy-highlight-initial-delay'
+and `isearch-lazy-highlight-interval')."
+ :type 'boolean
+ :group 'isearch-lazy-highlight)
+
+(defcustom isearch-lazy-highlight-cleanup t
+ "*Controls whether to remove extra highlighting after a search.
+If this is nil, extra highlighting can be \"manually\" removed with
+\\[isearch-lazy-highlight-cleanup]."
+ :type 'boolean
+ :group 'isearch-lazy-highlight)
+
+(defcustom isearch-lazy-highlight-initial-delay 0.25
+ "*Seconds to wait before beginning to lazily highlight all matches."
+ :type 'number
+ :group 'isearch-lazy-highlight)
+
+(defcustom isearch-lazy-highlight-interval 0.0625
+ "*Seconds between lazily highlighting successive matches."
+ :type 'number
+ :group 'isearch-lazy-highlight)
+
+(defcustom isearch-lazy-highlight-face 'secondary-selection
+ "*Face to use for lazily highlighting all matches."
+ :type 'face
+ :group 'isearch-lazy-highlight)
+
+(defvar isearch-lazy-highlight-overlays nil)
+(defvar isearch-lazy-highlight-wrapped nil)
+(defvar isearch-lazy-highlight-start nil)
+(defvar isearch-lazy-highlight-end nil)
+(defvar isearch-lazy-highlight-timer nil)
+(defvar isearch-lazy-highlight-last-string nil)
+
+(defun isearch-lazy-highlight-cleanup (&optional force)
+ "Stop lazy highlighting and remove extra highlighting from current buffer.
+FORCE non-nil means do it whether or not `isearch-lazy-highlight-cleanup'
+is nil. This function is called when exiting an incremental search if
+`isearch-lazy-highlight-cleanup' is non-nil."
+ (interactive '(t))
+ (if (or force isearch-lazy-highlight-cleanup)
+ (isearch-lazy-highlight-remove-overlays))
+ (if isearch-lazy-highlight-timer
+ (progn
+ (cancel-timer isearch-lazy-highlight-timer)
+ (setq isearch-lazy-highlight-timer nil))))
+
+(defun isearch-lazy-highlight-remove-overlays ()
+ "Remove lazy highlight overlays from the current buffer."
+ (while isearch-lazy-highlight-overlays
+ (delete-overlay (car isearch-lazy-highlight-overlays))
+ (setq isearch-lazy-highlight-overlays
+ (cdr isearch-lazy-highlight-overlays))))
+
+(defun isearch-lazy-highlight-new-loop ()
+ "Cleanup any previous isearch-lazy-highlight loop and begin a new one.
+This happens when `isearch-update' is invoked (which can cause the
+search string to change)."
+ (if (and isearch-lazy-highlight
+ (not (equal isearch-string isearch-lazy-highlight-last-string)))
+ ;; the search string did indeed change
+ (progn
+ (isearch-lazy-highlight-cleanup t) ;kill old loop & remove overlays
+ (if (and isearch-overlay
+ (not (overlay-get isearch-overlay 'priority)))
+ ;; make sure the isearch-overlay takes priority
+ (overlay-put isearch-overlay 'priority 1))
+ (setq isearch-lazy-highlight-start isearch-opoint
+ isearch-lazy-highlight-end isearch-opoint
+ isearch-lazy-highlight-last-string isearch-string
+ isearch-lazy-highlight-wrapped nil)
+ (setq isearch-lazy-highlight-timer
+ (run-with-idle-timer isearch-lazy-highlight-initial-delay nil
+ 'isearch-lazy-highlight-update)))))
+
+(defun isearch-lazy-highlight-search ()
+ "Search ahead for the next or previous match, for lazy highlighting.
+Attempt to do the search exactly the way the pending isearch would."
+ (let ((case-fold-search isearch-case-fold-search))
+ (funcall (cond (isearch-word (if isearch-forward
+ 'word-search-forward
+ 'word-search-backward))
+ (isearch-regexp (if isearch-forward
+ 're-search-forward
+ 're-search-backward))
+ (t (if isearch-forward
+ 'search-forward
+ 'search-backward)))
+ isearch-string
+ (if isearch-forward
+ (if isearch-lazy-highlight-wrapped
+ isearch-lazy-highlight-start
+ nil)
+ (if isearch-lazy-highlight-wrapped
+ isearch-lazy-highlight-end
+ nil))
+ t)))
+
+(defun isearch-lazy-highlight-update ()
+ "Find and highlight the next match in the lazy highlighting loop."
+ (when (not isearch-invalid-regexp)
+ (save-excursion
+ (save-match-data
+ (goto-char (if isearch-forward
+ isearch-lazy-highlight-end
+ isearch-lazy-highlight-start))
+ (let ((found (isearch-lazy-highlight-search))) ;do search
+ (if found
+ ;; found the next match
+ (let ((ov (make-overlay (match-beginning 0)
+ (match-end 0))))
+ (overlay-put ov 'face isearch-lazy-highlight-face)
+ (overlay-put ov 'priority 0)
+ (setq isearch-lazy-highlight-overlays
+ (cons ov isearch-lazy-highlight-overlays))
+ (setq isearch-lazy-highlight-timer
+ (run-at-time isearch-lazy-highlight-interval nil
+ 'isearch-lazy-highlight-update))
+ (if isearch-forward
+ (setq isearch-lazy-highlight-end (point))
+ (setq isearch-lazy-highlight-start (point))))
+ ;; found no next match
+ (when (not isearch-lazy-highlight-wrapped)
+ ;; let's try wrapping around the end of the buffer
+ (setq isearch-lazy-highlight-wrapped t)
+ (setq isearch-lazy-highlight-timer
+ (run-at-time isearch-lazy-highlight-interval nil
+ 'isearch-lazy-highlight-update))
+ (if isearch-forward
+ (setq isearch-lazy-highlight-end (point-min))
+ (setq isearch-lazy-highlight-start (point-max))))))))))
;;; isearch.el ends here