-;;; isearch.el --- incremental search minor mode.
+;;; 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, 2000, 01, 2003, 2004
+;; 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
;; Added word search option to isearch-edit-string.
;; Renamed isearch-quit to isearch-abort.
;; Numerous changes to comments and doc strings.
-;;
+;;
;; Revision 1.3 92/06/29 13:10:08 liberte
;; Moved modal isearch-mode handling into isearch-mode.
;; Got rid of buffer-local isearch variables.
;;; Code:
\f
-;;; Some additional options and constants.
+;; Some additional options and constants.
(defgroup isearch nil
"Incremental search minor mode."
+ :link '(emacs-commentary-link "isearch")
+ :link '(custom-manual "(emacs)Incremental Search")
:prefix "isearch-"
:prefix "search-"
:group 'matching)
:type 'boolean
:group 'isearch)
-(defcustom search-whitespace-regexp "\\s-+"
+(defcustom search-whitespace-regexp "\\(?:\\s-+\\)"
"*If non-nil, regular expression to match a sequence of whitespace chars.
This applies to regular expression incremental search.
-You might want to use something like \"[ \\t\\r\\n]+\" instead."
+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)
If the value is `open', if the text matched is made invisible by
an overlay having an `invisible' property and that overlay has a property
`isearch-open-invisible', then incremental search will show the contents.
-\(This applies when using `outline.el' and `hideshow.el'.)"
+\(This applies when using `outline.el' and `hideshow.el'.)
+See also `reveal-mode' if you want overlays to automatically be opened
+whenever point is in one of them."
:type '(choice (const :tag "Match hidden text" t)
(const :tag "Open overlays" open)
(const :tag "Don't match hidden text" nil))
This variable makes a difference when `search-invisible' is set to `open'.
It means that after search makes some invisible text visible
to show the match, it makes the text invisible again when the match moves.
-Ordinarily the text becomes invisible again at the end of the search."
- :type 'boolean
+Ordinarily the text becomes invisible again at the end of the search."
+ :type 'boolean
+ :group 'isearch)
+
+(defcustom isearch-resume-enabled t
+ "*If non-nil, `isearch-resume' commands are added to the command history."
+ :type 'boolean
:group 'isearch)
(defvar isearch-mode-hook nil
(defvar isearch-mode-end-hook nil
"Function(s) to call after terminating an incremental search.")
-;;; Search ring.
+;; Search ring.
(defvar search-ring nil
"List of search string sequences.")
:type 'boolean
:group 'isearch)
-;;; Define isearch-mode keymap.
-
-(defvar isearch-mode-map nil
- "Keymap for isearch-mode.")
-
-(or isearch-mode-map
- (let* ((i 0)
- (map (make-keymap)))
- (or (vectorp (nth 1 map))
- (char-table-p (nth 1 map))
- (error "The initialization of isearch-mode-map must be updated"))
- ;; 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.
- ;; We need these explicit definitions because, in a dense keymap,
- ;; the binding for t does not affect characters.
- ;; We use a dense keymap to save space.
- (while (< i ?\ )
- (define-key map (make-string 1 i) 'isearch-other-control-char)
- (setq i (1+ i)))
-
- ;; Single-byte printing chars extend the search string by default.
- (setq i ?\ )
- (while (< i 256)
- (define-key map (vector i) 'isearch-printing-char)
- (setq i (1+ i)))
-
- ;; To handle local bindings with meta char prefix keys, define
- ;; another full keymap. This must be done for any other prefix
- ;; keys as well, one full keymap per char of the prefix key. It
- ;; would be simpler to disable the global keymap, and/or have a
- ;; default local key binding for any key not otherwise bound.
- (let ((meta-map (make-sparse-keymap)))
- (define-key map (char-to-string meta-prefix-char) meta-map)
- (define-key map [escape] meta-map))
- (define-key map (vector meta-prefix-char t) 'isearch-other-meta-char)
-
- ;; Several non-printing chars change the searching behavior.
- (define-key map "\C-s" 'isearch-repeat-forward)
- (define-key map "\C-r" 'isearch-repeat-backward)
- (define-key map "\177" 'isearch-delete-char)
- (define-key map "\C-g" 'isearch-abort)
- ;; This assumes \e is the meta-prefix-char.
- (or (= ?\e meta-prefix-char)
- (error "Inconsistency in isearch.el"))
- (define-key map "\e\e\e" 'isearch-cancel)
- (define-key map [escape escape escape] 'isearch-cancel)
-
- (define-key map "\C-q" 'isearch-quote-char)
-
- (define-key map "\r" 'isearch-exit)
- (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 keys for regexp chars * ? |.
- ;; Nothing special for + because it matches at least once.
- (define-key map "*" 'isearch-*-char)
- (define-key map "?" 'isearch-*-char)
- (define-key map "|" 'isearch-|-char)
-
-;;; Turned off because I find I expect to get the global definition--rms.
-;;; ;; Instead bind C-h to special help command for isearch-mode.
-;;; (define-key map "\C-h" 'isearch-mode-help)
-
- (define-key map "\M-n" 'isearch-ring-advance)
- (define-key map "\M-p" 'isearch-ring-retreat)
- (define-key map "\M-y" 'isearch-yank-kill)
-
- (define-key map "\M-\t" 'isearch-complete)
-
- ;; Pass frame events transparently so they won't exit the search.
- ;; In particular, if we have more than one display open, then a
- ;; switch-frame might be generated by someone typing at another keyboard.
- (define-key map [switch-frame] nil)
- (define-key map [delete-frame] nil)
- (define-key map [iconify-frame] nil)
- (define-key map [make-frame-visible] nil)
- ;; For searching multilingual text.
- (define-key map "\C-\\" 'isearch-toggle-input-method)
- (define-key map "\C-^" 'isearch-toggle-specified-input-method)
-
- (setq isearch-mode-map map)
- ))
-
-;; Some bindings you may want to put in your isearch-mode-hook.
-;; Suggest some alternates...
-;; (define-key isearch-mode-map "\C-t" 'isearch-toggle-case-fold)
-;; (define-key isearch-mode-map "\C-t" 'isearch-toggle-regexp)
-;; (define-key isearch-mode-map "\C-^" 'isearch-edit-string)
+;; Define isearch-mode keymap.
+
+(defvar isearch-mode-map
+ (let* ((i 0)
+ (map (make-keymap)))
+ (or (char-table-p (nth 1 map))
+ (error "The initialization of isearch-mode-map must be updated"))
+ ;; Make all multibyte characters search for themselves.
+ (set-char-table-range (nth 1 map) (cons #x100 (max-char))
+ 'isearch-printing-char)
+ ;; Make function keys, etc, which aren't bound to a scrolling-function
+ ;; exit the search.
+ (define-key map [t] 'isearch-other-control-char)
+ ;; Control chars, by default, end isearch mode transparently.
+ ;; We need these explicit definitions because, in a dense keymap,
+ ;; the binding for t does not affect characters.
+ ;; We use a dense keymap to save space.
+ (while (< i ?\ )
+ (define-key map (make-string 1 i) 'isearch-other-control-char)
+ (setq i (1+ i)))
+ ;; Single-byte printing chars extend the search string by default.
+ (setq i ?\ )
+ (while (< i 256)
+ (define-key map (vector i) 'isearch-printing-char)
+ (setq i (1+ i)))
-(defvar minibuffer-local-isearch-map nil
+ ;; To handle local bindings with meta char prefix keys, define
+ ;; another full keymap. This must be done for any other prefix
+ ;; keys as well, one full keymap per char of the prefix key. It
+ ;; would be simpler to disable the global keymap, and/or have a
+ ;; default local key binding for any key not otherwise bound.
+ (let ((meta-map (make-sparse-keymap)))
+ (define-key map (char-to-string meta-prefix-char) meta-map)
+ (define-key map [escape] meta-map))
+ (define-key map (vector meta-prefix-char t) 'isearch-other-meta-char)
+
+ ;; Several non-printing chars change the searching behavior.
+ (define-key map "\C-s" 'isearch-repeat-forward)
+ (define-key map "\C-r" 'isearch-repeat-backward)
+ ;; Define M-C-s and M-C-r like C-s and C-r so that the same key
+ ;; combinations can be used to repeat regexp isearches that can
+ ;; be used to start these searches.
+ (define-key map "\M-\C-s" 'isearch-repeat-forward)
+ (define-key map "\M-\C-r" 'isearch-repeat-backward)
+ (define-key map "\177" 'isearch-delete-char)
+ (define-key map "\C-g" 'isearch-abort)
+
+ ;; This assumes \e is the meta-prefix-char.
+ (or (= ?\e meta-prefix-char)
+ (error "Inconsistency in isearch.el"))
+ (define-key map "\e\e\e" 'isearch-cancel)
+ (define-key map [escape escape escape] 'isearch-cancel)
+
+ (define-key map "\C-q" 'isearch-quote-char)
+
+ (define-key map "\r" 'isearch-exit)
+ (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-or-char)
+ (define-key map "\C-y" 'isearch-yank-line)
+
+ ;; Define keys for regexp chars * ? |.
+ ;; Nothing special for + because it matches at least once.
+ (define-key map "*" 'isearch-*-char)
+ (define-key map "?" 'isearch-*-char)
+ (define-key map "{" 'isearch-{-char)
+ (define-key map "|" 'isearch-|-char)
+
+ ;; Turned off because I find I expect to get the global definition--rms.
+ ;; ;; Instead bind C-h to special help command for isearch-mode.
+ ;; (define-key map "\C-h" 'isearch-mode-help)
+
+ (define-key map "\M-n" 'isearch-ring-advance)
+ (define-key map "\M-p" 'isearch-ring-retreat)
+ (define-key map "\M-y" 'isearch-yank-kill)
+
+ (define-key map "\M-\t" 'isearch-complete)
+
+ ;; Pass frame events transparently so they won't exit the search.
+ ;; In particular, if we have more than one display open, then a
+ ;; switch-frame might be generated by someone typing at another keyboard.
+ (define-key map [switch-frame] nil)
+ (define-key map [delete-frame] nil)
+ (define-key map [iconify-frame] nil)
+ (define-key map [make-frame-visible] nil)
+ (define-key map [mouse-movement] nil)
+ ;; For searching multilingual text.
+ (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-2)
+ (define-key map [down-mouse-2] nil)
+
+ ;; Some bindings you may want to put in your isearch-mode-hook.
+ ;; Suggest some alternates...
+ (define-key map "\M-c" 'isearch-toggle-case-fold)
+ (define-key map "\M-r" 'isearch-toggle-regexp)
+ (define-key map "\M-e" 'isearch-edit-string)
+
+ map)
+ "Keymap for `isearch-mode'.")
+
+(defvar minibuffer-local-isearch-map
+ (let ((map (make-sparse-keymap)))
+ (set-keymap-parent map minibuffer-local-map)
+ (define-key map "\r" 'isearch-nonincremental-exit-minibuffer)
+ (define-key map "\M-n" 'isearch-ring-advance-edit)
+ (define-key map "\M-p" 'isearch-ring-retreat-edit)
+ (define-key map "\M-\t" 'isearch-complete-edit)
+ (define-key map "\C-s" 'isearch-forward-exit-minibuffer)
+ (define-key map "\C-r" 'isearch-reverse-exit-minibuffer)
+ map)
"Keymap for editing isearch strings in the minibuffer.")
-(or minibuffer-local-isearch-map
- (let ((map (copy-keymap minibuffer-local-map)))
- (define-key map "\r" 'isearch-nonincremental-exit-minibuffer)
- (define-key map "\M-n" 'isearch-ring-advance-edit)
- (define-key map "\M-p" 'isearch-ring-retreat-edit)
- (define-key map "\M-\t" 'isearch-complete-edit)
- (define-key map "\C-s" 'isearch-forward-exit-minibuffer)
- (define-key map "\C-r" 'isearch-reverse-exit-minibuffer)
- (setq minibuffer-local-isearch-map map)
- ))
-
;; Internal variables declared globally for byte-compiler.
;; These are all set with setq while isearching
;; and bound locally while editing the search string.
(defvar isearch-forward nil) ; Searching in the forward direction.
(defvar isearch-regexp nil) ; Searching for a regexp.
(defvar isearch-word nil) ; Searching for words.
+(defvar isearch-hidden nil) ; Non-nil if the string exists but is invisible.
+
+(defvar isearch-cmds nil
+ "Stack of search status sets.
+Each set is a list of the form:
+ (STRING MESSAGE POINT SUCCESS FORWARD OTHER-END WORD
+ INVALID-REGEXP WRAPPED BARRIER WITHIN-BRACKETS CASE-FOLD-SEARCH)")
-(defvar isearch-cmds nil) ; Stack of search status sets.
(defvar isearch-string "") ; The current search string.
(defvar isearch-message "") ; text-char-description version of isearch-string
(defvar isearch-wrapped nil) ; Searching restarted from the top (bottom).
(defvar isearch-barrier 0)
(defvar isearch-just-started nil)
+(defvar isearch-start-hscroll 0) ; hscroll when starting the search.
; case-fold-search while searching.
; either nil, t, or 'yes. 'yes means the same as t except that mixed
; case in the search string is ignored.
(defvar isearch-case-fold-search nil)
+(defvar isearch-last-case-fold-search nil)
+
+;; Used to save default value while isearch is active
+(defvar isearch-original-minibuffer-message-timeout nil)
+
(defvar isearch-adjusted nil)
(defvar isearch-slow-terminal-mode nil)
-;;; If t, using a small window.
+;; If t, using a small window.
(defvar isearch-small-window nil)
(defvar isearch-opoint 0)
-;;; The window configuration active at the beginning of the search.
+;; The window configuration active at the beginning of the search.
(defvar isearch-window-configuration nil)
;; Flag to indicate a yank occurred, so don't move the cursor.
(defvar isearch-yank-flag nil)
-;;; A function to be called after each input character is processed.
-;;; (It is not called after characters that exit the search.)
-;;; It is only set from an optional argument to `isearch-mode'.
+;; A function to be called after each input character is processed.
+;; (It is not called after characters that exit the search.)
+;; It is only set from an optional argument to `isearch-mode'.
(defvar isearch-op-fun nil)
-;;; Is isearch-mode in a recursive edit for modal searching.
+;; Is isearch-mode in a recursive edit for modal searching.
(defvar isearch-recursive-edit nil)
-;;; Should isearch be terminated after doing one search?
+;; Should isearch be terminated after doing one search?
(defvar isearch-nonincremental nil)
;; New value of isearch-forward after isearch-edit-string.
;; 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 global-map "\C-r" 'isearch-backward)
(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.
+;; Entry points to isearch-mode.
(defun isearch-forward (&optional regexp-p no-recursive-edit)
"\
With a prefix argument, do an incremental regular expression search instead.
\\<isearch-mode-map>
As you type characters, they add to the search string and are found.
-The following non-printing keys are bound in `isearch-mode-map'.
+The following non-printing keys are bound in `isearch-mode-map'.
-Type \\[isearch-delete-char] to cancel characters from end of search string.
+Type \\[isearch-delete-char] to cancel last input item from end of search string.
+Type \\[isearch-del-char] to cancel last character from end of search string.
Type \\[isearch-exit] to exit, leaving point at location found.
Type LFD (C-j) to match end of line.
Type \\[isearch-repeat-forward] to search again forward,\
\\[isearch-repeat-backward] to search again backward.
+Type \\[isearch-yank-char] to yank character from buffer onto end of search\
+ string and search for it.
Type \\[isearch-yank-word] to yank word from buffer onto end of search\
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-abort] when search is successful aborts and moves point to\
starting point.
+Type \\[isearch-toggle-case-fold] to toggle search case-sensitivity.
+Type \\[isearch-toggle-regexp] to toggle regular-expression mode.
+Type \\[isearch-edit-string] to edit the search string in the minibuffer.
+
Also supported is a search ring of the previous 16 search strings.
Type \\[isearch-ring-advance] to search for the next item in the search ring.
Type \\[isearch-ring-retreat] to search for the previous item in the search\
ring.
Type \\[isearch-complete] to complete the search string using the search ring.
-The above keys, bound in `isearch-mode-map', are often controlled by
- options; do M-x apropos on search-.* to find them.
+If an input method is turned on in the current buffer, that input
+method is also active while you are typing characters to search. To
+toggle the input method, type \\[isearch-toggle-input-method]. It
+also toggles the input method in the current buffer.
+
+To use a different input method for searching, type
+\\[isearch-toggle-specified-input-method], and specify an input method
+you want to use.
+
+The above keys, bound in `isearch-mode-map', are often controlled by
+ options; do \\[apropos] on search-.* to find them.
Other control and meta characters terminate the search
and are then executed normally (depending on `search-exit-option').
Likewise for function keys and mouse button events.
;;(defvar isearch-commands '(isearch-forward isearch-backward
;; isearch-forward-regexp isearch-backward-regexp)
;; "List of commands for which isearch-mode does not recursive-edit.")
-
+
(defun isearch-mode (forward &optional regexp op-fun recursive-edit word-p)
"Start isearch minor mode. Called by `isearch-forward', etc.
isearch-regexp regexp
isearch-word word-p
isearch-op-fun op-fun
+ isearch-last-case-fold-search isearch-case-fold-search
isearch-case-fold-search case-fold-search
isearch-string ""
isearch-message ""
isearch-within-brackets nil
isearch-slow-terminal-mode (and (<= baud-rate search-slow-speed)
(> (window-height)
- (* 4 search-slow-window-lines)))
+ (* 4
+ (abs search-slow-window-lines))))
isearch-other-end nil
isearch-small-window nil
isearch-just-started t
+ isearch-start-hscroll (window-hscroll)
isearch-opoint (point)
search-ring-yank-pointer nil
isearch-opened-overlays nil
- regexp-search-ring-yank-pointer 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
+
+ ;; Save the original value of `minibuffer-message-timeout', and
+ ;; set it to nil so that isearch's messages don't get timed out.
+ isearch-original-minibuffer-message-timeout minibuffer-message-timeout
+ minibuffer-message-timeout 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 characters.
+ (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))
;; Maybe make minibuffer frame visible and/or raise it.
(let ((frame (window-frame (minibuffer-window))))
- (if (not (memq (frame-live-p frame) '(nil t)))
- (progn
- (make-frame-visible frame)
- (if minibuffer-auto-raise
- (raise-frame frame)))))
+ (unless (memq (frame-live-p frame) '(nil t))
+ (unless (frame-visible-p frame)
+ (make-frame-visible frame))
+ (if minibuffer-auto-raise
+ (raise-frame frame))))
(setq isearch-mode " Isearch") ;; forward? regexp?
(force-mode-line-update)
(run-hooks 'isearch-mode-hook)
(add-hook 'mouse-leave-buffer-hook 'isearch-done)
+ (add-hook 'kbd-macro-termination-hook 'isearch-done)
- ;; isearch-mode can be made modal (in the sense of not returning to
- ;; the calling function until searching is completed) by entering
+ ;; isearch-mode can be made modal (in the sense of not returning to
+ ;; the calling function until searching is completed) by entering
;; a recursive-edit and exiting it when done isearching.
(if recursive-edit
(let ((isearch-recursive-edit t))
;; Some high level utilities. Others below.
(defun isearch-update ()
- ;; Called after each command to update the display.
- (if (null unread-command-events)
+ ;; Called after each command to update the display.
+ (if (and (null unread-command-events)
+ (null executing-kbd-macro))
(progn
- (if (not (input-pending-p))
- (isearch-message))
- (if (and isearch-slow-terminal-mode
- (not (or isearch-small-window
- (pos-visible-in-window-p))))
- (let ((found-point (point)))
- (setq isearch-small-window t)
- (move-to-window-line 0)
- (let ((window-min-height 1))
- (split-window nil (if (< search-slow-window-lines 0)
- (1+ (- search-slow-window-lines))
- (- (window-height)
- (1+ search-slow-window-lines)))))
- (if (< search-slow-window-lines 0)
- (progn (vertical-motion (- 1 search-slow-window-lines))
- (set-window-start (next-window) (point))
- (set-window-hscroll (next-window)
- (window-hscroll))
- (set-window-hscroll (selected-window) 0))
- (other-window 1))
- (goto-char found-point)))
+ (if (not (input-pending-p))
+ (isearch-message))
+ (if (and isearch-slow-terminal-mode
+ (not (or isearch-small-window
+ (pos-visible-in-window-p))))
+ (let ((found-point (point)))
+ (setq isearch-small-window t)
+ (move-to-window-line 0)
+ (let ((window-min-height 1))
+ (split-window nil (if (< search-slow-window-lines 0)
+ (1+ (- search-slow-window-lines))
+ (- (window-height)
+ (1+ search-slow-window-lines)))))
+ (if (< search-slow-window-lines 0)
+ (progn (vertical-motion (- 1 search-slow-window-lines))
+ (set-window-start (next-window) (point))
+ (set-window-hscroll (next-window)
+ (window-hscroll))
+ (set-window-hscroll (selected-window) 0))
+ (other-window 1))
+ (goto-char found-point))
+ ;; Keep same hscrolling as at the start of the search when possible
+ (let ((current-scroll (window-hscroll)))
+ (set-window-hscroll (selected-window) isearch-start-hscroll)
+ (unless (pos-visible-in-window-p)
+ (set-window-hscroll (selected-window) current-scroll))))
(if isearch-other-end
- (if (< isearch-other-end (point)) ; isearch-forward?
- (isearch-highlight isearch-other-end (point))
- (isearch-highlight (point) isearch-other-end))
- (isearch-dehighlight nil))
- ))
+ (if (< isearch-other-end (point)) ; isearch-forward?
+ (isearch-highlight isearch-other-end (point))
+ (isearch-highlight (point) isearch-other-end))
+ (isearch-dehighlight nil))
+ ))
(setq ;; quit-flag nil not for isearch-mode
isearch-adjusted nil
isearch-yank-flag nil)
- )
+ (isearch-lazy-highlight-new-loop)
+ ;; We must prevent the point moving to the end of composition when a
+ ;; part of the composition has just been searched.
+ (setq disable-point-adjustment t))
(defun isearch-done (&optional nopush edit)
+ (if isearch-resume-enabled
+ (let ((command `(isearch-resume ,isearch-string ,isearch-regexp
+ ,isearch-word ,isearch-forward
+ ,isearch-message
+ ',isearch-case-fold-search)))
+ (unless (equal (car command-history) command)
+ (setq command-history (cons command command-history)))))
+
(remove-hook 'mouse-leave-buffer-hook 'isearch-done)
+ (remove-hook 'kbd-macro-termination-hook 'isearch-done)
+ (setq isearch-lazy-highlight-start nil)
+
;; Called by all commands that terminate isearch-mode.
;; If NOPUSH is non-nil, we don't push the string on the search ring.
(setq overriding-terminal-local-map nil)
;; (setq pre-command-hook isearch-old-pre-command-hook) ; for lemacs
+ (setq minibuffer-message-timeout isearch-original-minibuffer-message-timeout)
(isearch-dehighlight t)
+ (isearch-lazy-highlight-cleanup 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))
(defun isearch-update-ring (string &optional regexp)
"Add STRING to the beginning of the search ring.
REGEXP says which ring to use."
- (if regexp
+ (if regexp
(if (or (null regexp-search-ring)
(not (string= string (car regexp-search-ring))))
(progn
- (setq regexp-search-ring
- (cons string regexp-search-ring))
+ (push string regexp-search-ring)
(if (> (length regexp-search-ring) regexp-search-ring-max)
(setcdr (nthcdr (1- search-ring-max) regexp-search-ring)
nil))))
(if (or (null search-ring)
(not (string= string (car search-ring))))
(progn
- (setq search-ring (cons string search-ring))
+ (push string search-ring)
(if (> (length search-ring) search-ring-max)
(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)))))
+;; Switching buffers should first terminate isearch-mode.
+;; ;; 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.
search and `search-nonincremental-instead' is non-nil, do a
nonincremental search instead via `isearch-edit-string'."
(interactive)
- (if (and search-nonincremental-instead
+ (if (and search-nonincremental-instead
(= 0 (length isearch-string)))
(let ((isearch-nonincremental t))
(isearch-edit-string)))
(isearch-recursive-edit isearch-recursive-edit)
;; Save current configuration so we can restore it here.
(isearch-window-configuration (current-window-configuration))
+
+ ;; Temporarily restore `minibuffer-message-timeout'.
+ (minibuffer-message-timeout
+ isearch-original-minibuffer-message-timeout)
+ (isearch-original-minibuffer-message-timeout
+ isearch-original-minibuffer-message-timeout)
)
;; Actually terminate isearching until editing is done.
- ;; This is so that the user can do anything without failure,
+ ;; This is so that the user can do anything without failure,
;; like switch buffers and start another isearch, and return.
(condition-case err
(isearch-done t t)
(isearch-message) ;; for read-char
(unwind-protect
- (let* (;; Why does following read-char echo?
+ (let* (;; Why does following read-char echo?
;;(echo-keystrokes 0) ;; not needed with above message
(e (let ((cursor-in-echo-area t))
(read-event)))
;; Word search does not apply (yet) to regexp searches,
;; no check is made here.
(message (isearch-message-prefix nil nil t))
- (if (eq 'isearch-yank-word
- (lookup-key isearch-mode-map (vector e)))
+ (if (memq (lookup-key isearch-mode-map (vector e))
+ '(isearch-yank-word
+ isearch-yank-word-or-char))
(setq isearch-word t;; so message-prefix is right
isearch-new-word t)
(cancel-kbd-macro-events)
(mapconcat 'isearch-text-char-description
isearch-new-string "")))
;; Always resume isearching by restarting it.
- (isearch-mode isearch-forward
- isearch-regexp
- isearch-op-fun
+ (isearch-mode isearch-forward
+ isearch-regexp
+ isearch-op-fun
nil
isearch-word)
(setq isearch-string (or (car (if isearch-regexp
regexp-search-ring
search-ring))
- ""))
+ "")
+
+ isearch-message
+ (mapconcat 'isearch-text-char-description
+ isearch-string ""))
;; This used to set the last search string,
;; but I think it is not right to do that here.
;; Only the string actually used should be saved.
;; Reinvoke the pending search.
(isearch-search)
(isearch-update)
- (if isearch-nonincremental
+ (if isearch-nonincremental
(progn
;; (sit-for 1) ;; needed if isearch-done does: (message "")
(isearch-done))))
(or (if isearch-regexp
(car regexp-search-ring)
(car search-ring))
- "")
+ (error "No previous search string"))
isearch-message
(mapconcat 'isearch-text-char-description
- isearch-string ""))
+ isearch-string "")
+ isearch-case-fold-search isearch-last-case-fold-search)
;; If already have what to search for, repeat it.
(or isearch-success
- (progn
+ (progn
(goto-char (if isearch-forward (point-min) (point-max)))
(setq isearch-wrapped t))))
;; C-s in reverse or C-r in forward, change direction.
(if (equal isearch-string "")
(setq isearch-success t)
- (if (and isearch-success (equal (match-end 0) (match-beginning 0))
+ (if (and isearch-success
+ (equal (point) isearch-other-end)
(not isearch-just-started))
;; If repeating a search that found
;; an empty string, ensure we advance.
(isearch-update))
(defun isearch-delete-char ()
- "Discard last input item and move point back.
+ "Discard last input item and move point back.
If no previous match was done, just beep."
(interactive)
(if (null (cdr isearch-cmds))
(isearch-pop-state))
(isearch-update))
+(defun isearch-del-char ()
+ "Discard last character and move point back.
+If there is no previous character, just beep."
+ (interactive)
+ (if (equal isearch-string "")
+ (ding)
+ (setq isearch-string (substring isearch-string 0 -1)
+ isearch-message (mapconcat 'isearch-text-char-description
+ isearch-string "")))
+ (isearch-search-and-update))
(defun isearch-yank-string (string)
"Pull STRING into search string."
(isearch-yank-string (current-kill 0)))
(defun isearch-yank-x-selection ()
- "Pull current X selection into search string.
-Some users like to put this command on Mouse-2.
-To do that, evaluate these expressions:
- (define-key isearch-mode-map [down-mouse-2] nil)
- (define-key isearch-mode-map [mouse-2] 'isearch-yank-x-selection)"
+ "Pull current X selection into search string."
(interactive)
(isearch-yank-string (x-get-selection)))
-(defun isearch-yank-word ()
- "Pull next word from buffer into search string."
- (interactive)
+
+(defun isearch-mouse-2 (click)
+ "Handle mouse-2 in Isearch mode.
+For a click in the echo area, invoke `isearch-yank-x-selection'.
+Otherwise invoke whatever mouse-2 is bound to outside of Isearch."
+ (interactive "e")
+ (let* ((w (posn-window (event-start click)))
+ (overriding-terminal-local-map nil)
+ (key (vector (event-basic-type click)))
+ ;; FIXME: `key-binding' should accept an event as argument
+ ;; and do all the overlay/text-properties lookup etc...
+ (binding (with-current-buffer
+ (if (window-live-p w) (window-buffer w) (current-buffer))
+ (key-binding key))))
+ (if (and (window-minibuffer-p w)
+ (not (minibuffer-window-active-p w))) ; in echo area
+ (isearch-yank-x-selection)
+ (when (functionp binding)
+ (call-interactively binding)))))
+
+
+(defun isearch-yank-internal (jumpform)
+ "Pull the text from point to the point reached by JUMPFORM.
+JUMPFORM is a lambda expression that takes no arguments and returns a
+buffer position, possibly having moved point to that position. For
+example, it might move point forward by a word and return point, or it
+might return the position of the end of the line."
(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))))))
+ (buffer-substring-no-properties (point) (funcall jumpform)))))
+
+(defun isearch-yank-char ()
+ "Pull next character from buffer into search string."
+ (interactive)
+ (isearch-yank-internal (lambda () (forward-char 1) (point))))
+
+(defun isearch-yank-word-or-char ()
+ "Pull next character or word from buffer into search string."
+ (interactive)
+ (isearch-yank-internal
+ (lambda ()
+ (if (or (= (char-syntax (or (char-after) 0)) ?w)
+ (= (char-syntax (or (char-after (1+ (point))) 0)) ?w))
+ (forward-word 1)
+ (forward-char 1)) (point))))
+
+(defun isearch-yank-word ()
+ "Pull next word from buffer into search string."
+ (interactive)
+ (isearch-yank-internal (lambda () (forward-word 1) (point))))
(defun isearch-yank-line ()
"Pull rest of line from buffer into search string."
(interactive)
- (isearch-yank-string
- (save-excursion
- (and (not isearch-forward) isearch-other-end
- (goto-char isearch-other-end))
- (buffer-substring (point) (line-end-position)))))
+ (isearch-yank-internal 'line-end-position))
(defun isearch-search-and-update ()
;; Do the search and update the display.
- (if (and (not isearch-success)
- ;; unsuccessful regexp search may become
- ;; successful by addition of characters which
- ;; make isearch-string valid
- (not isearch-regexp))
- nil
+ (when (or isearch-success
+ ;; Unsuccessful regexp search may become successful by
+ ;; addition of characters which make isearch-string valid
+ isearch-regexp
+ ;; If the string was found but was completely invisible,
+ ;; it might now be partly visible, so try again.
+ (prog1 isearch-hidden (setq isearch-hidden nil)))
;; In reverse search, adding stuff at
;; the end may cause zero or many more chars to be
;; matched, in the string following point.
(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)
+ (<= (match-end 0)
(min isearch-opoint isearch-barrier))))
(progn
- (setq isearch-success t
+ (setq isearch-success t
isearch-invalid-regexp nil
isearch-within-brackets nil
isearch-other-end (match-end 0))
;; Not regexp, not reverse, or no match at point.
(if (and isearch-other-end (not isearch-adjusted))
(goto-char (if isearch-forward isearch-other-end
- (min isearch-opoint
- isearch-barrier
+ (min isearch-opoint
+ isearch-barrier
(1+ isearch-other-end)))))
(isearch-search)
))
(isearch-update))
+(defun isearch-{-char ()
+ "Handle \{ specially in regexps."
+ (interactive)
+ (isearch-*-char t))
+
;; *, ?, and | chars can make a regexp more liberal.
;; They can make a regexp match sooner or make it succeed instead of failing.
;; So go back to place last successful search started
;; or to the last ^S/^R (barrier), whichever is nearer.
;; + needs no special handling because the string must match at least once.
-(defun isearch-*-char ()
- "Handle * and ? specially in regexps."
+(defun isearch-*-char (&optional want-backslash)
+ "Handle * and ? specially in regexps.
+When WANT-BACKSLASH is non-nil, do special handling for \{."
(interactive)
- (if isearch-regexp
+ (if isearch-regexp
(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)
+ ;; * and ? are special when not preceded by \.
+ ;; { is special when it is preceded by \.
+ (when (= (mod (- (length isearch-string) idx) 2)
+ (if want-backslash 1 0))
(setq isearch-adjusted t)
;; Get the isearch-other-end from before the last search.
;; We want to start from there,
(if isearch-forward
(max cs isearch-barrier)
(min cs isearch-barrier)))))))
- (isearch-process-search-char (isearch-last-command-char)))
-
+ (isearch-process-search-char last-command-char))
+
(defun isearch-|-char ()
"If in regexp search, jump to the barrier."
(progn
(setq isearch-adjusted t)
(goto-char isearch-barrier)))
- (isearch-process-search-char (isearch-last-command-char)))
+ (isearch-process-search-char last-command-char))
+
+(defun isearch-unread-key-sequence (keylist)
+ "Unread the given key-sequence KEYLIST.
+Scroll-bar or mode-line events are processed appropriately."
+ (cancel-kbd-macro-events)
+ (apply 'isearch-unread keylist)
+ ;; If the event was a scroll-bar or mode-line click, the event will have
+ ;; been prefixed by a symbol such as vertical-scroll-bar. We must remove
+ ;; it here, because this symbol will be attached to the event again next
+ ;; time it gets read by read-key-sequence.
+ ;;
+ ;; (Old comment from isearch-other-meta-char: "Note that we don't have to
+ ;; modify the event anymore in 21 because read_key_sequence no longer
+ ;; modifies events to produce fake prefix keys.")
+ (if (and (> (length keylist) 1)
+ (symbolp (car keylist))
+ (listp (cadr keylist))
+ (not (numberp (posn-point
+ (event-start (cadr keylist) )))))
+ (pop unread-command-events)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; scrolling within Isearch mode. Alan Mackenzie (acm@muc.de), 2003/2/24
+;;
+;; The idea here is that certain vertical scrolling commands (like C-l
+;; `recenter') should be usable WITHIN Isearch mode. For a command to be
+;; suitable, it must NOT alter the buffer, swap to another buffer or frame,
+;; tamper with isearch's state, or move point. It is unacceptable for the
+;; search string to be scrolled out of the current window. If a command
+;; attempts this, we scroll the text back again.
+;;
+;; We implement this feature with a property called `isearch-scroll'.
+;; If a command's symbol has the value t for this property it is a
+;; scrolling command. The feature needs to be enabled by setting the
+;; customizable variable `isearch-allow-scroll' to a non-nil value.
+;;
+;; The universal argument commands (e.g. C-u) in simple.el are marked
+;; as scrolling commands, and isearch.el has been amended to allow
+;; prefix arguments to be passed through to scrolling commands. Thus
+;; M-0 C-l will scroll point to the top of the window.
+;;
+;; Horizontal scrolling commands are currently not catered for.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Set the isearch-scroll property on some standard functions:
+;; Scroll-bar functions:
+(if (fboundp 'scroll-bar-toolkit-scroll)
+ (put 'scroll-bar-toolkit-scroll 'isearch-scroll t))
+(if (fboundp 'mac-handle-scroll-bar-event)
+ (put 'mac-handle-scroll-bar-event 'isearch-scroll t))
+(if (fboundp 'w32-handle-scroll-bar-event)
+ (put 'w32-handle-scroll-bar-event 'isearch-scroll t))
+
+;; Commands which scroll the window:
+(put 'recenter 'isearch-scroll t)
+(put 'reposition-window 'isearch-scroll t)
+(put 'scroll-up 'isearch-scroll t)
+(put 'scroll-down 'isearch-scroll t)
+
+;; Commands which act on the other window
+(put 'list-buffers 'isearch-scroll t)
+(put 'scroll-other-window 'isearch-scroll t)
+(put 'scroll-other-window-down 'isearch-scroll t)
+(put 'beginning-of-buffer-other-window 'isearch-scroll t)
+(put 'end-of-buffer-other-window 'isearch-scroll t)
+
+;; Commands which change the window layout
+(put 'delete-other-windows 'isearch-scroll t)
+(put 'balance-windows 'isearch-scroll t)
+(put 'split-window-vertically 'isearch-scroll t)
+(put 'enlarge-window 'isearch-scroll t)
+
+;; Universal argument commands
+(put 'universal-argument 'isearch-scroll t)
+(put 'negative-argument 'isearch-scroll t)
+(put 'digit-argument 'isearch-scroll t)
+
+(defcustom isearch-allow-scroll nil
+ "If non-nil, scrolling commands are allowed during incremental search."
+ :type 'boolean
+ :group 'isearch)
+(defun isearch-string-out-of-window (isearch-point)
+ "Test whether the search string is currently outside of the window.
+Return nil if it's completely visible, or if point is visible,
+together with as much of the search string as will fit; the symbol
+`above' if we need to scroll the text downwards; the symbol `below',
+if upwards."
+ (let ((w-start (window-start))
+ (w-end (window-end nil t))
+ (w-L1 (save-excursion (move-to-window-line 1) (point)))
+ (w-L-1 (save-excursion (move-to-window-line -1) (point)))
+ start end) ; start and end of search string in buffer
+ (if isearch-forward
+ (setq end isearch-point start (or isearch-other-end isearch-point))
+ (setq start isearch-point end (or isearch-other-end isearch-point)))
+ (cond ((or (and (>= start w-start) (<= end w-end))
+ (if isearch-forward
+ (and (>= isearch-point w-L-1) (< isearch-point w-end)) ; point on Line -1
+ (and (>= isearch-point w-start) (< isearch-point w-L1)))) ; point on Line 0
+ nil)
+ ((and (< start w-start)
+ (< isearch-point w-L-1))
+ 'above)
+ (t 'below))))
+
+(defun isearch-back-into-window (above isearch-point)
+ "Scroll the window to bring the search string back into view.
+Restore point to ISEARCH-POINT in the process. ABOVE is t when the
+search string is above the top of the window, nil when it is beneath
+the bottom."
+ (let (start end)
+ (if isearch-forward
+ (setq end isearch-point start (or isearch-other-end isearch-point))
+ (setq start isearch-point end (or isearch-other-end isearch-point)))
+ (if above
+ (progn
+ (goto-char start)
+ (recenter 0)
+ (when (>= isearch-point (window-end nil t))
+ (goto-char isearch-point)
+ (recenter -1)))
+ (goto-char end)
+ (recenter -1)
+ (when (< isearch-point (window-start))
+ (goto-char isearch-point)
+ (recenter 0))))
+ (goto-char isearch-point))
+
+(defun isearch-reread-key-sequence-naturally (keylist)
+ "Reread key sequence KEYLIST with Isearch mode's keymap deactivated.
+Return the key sequence as a string/vector."
+ (isearch-unread-key-sequence keylist)
+ (let (overriding-terminal-local-map)
+ (read-key-sequence nil))) ; This will go through function-key-map, if nec.
+
+(defun isearch-lookup-scroll-key (key-seq)
+ "If KEY-SEQ is bound to a scrolling command, return it as a symbol.
+Otherwise return nil."
+ (let* ((overriding-terminal-local-map nil)
+ (binding (key-binding key-seq)))
+ (and binding (symbolp binding) (commandp binding)
+ (eq (get binding 'isearch-scroll) t)
+ binding)))
(defalias 'isearch-other-control-char 'isearch-other-meta-char)
-(defun isearch-other-meta-char ()
- "Exit the search normally and reread this key sequence.
-But only if `search-exit-option' is non-nil, the default.
-If it is the symbol `edit', the search string is edited in the minibuffer
-and the meta character is unread so that it applies to editing the string."
- (interactive)
- (let* ((key (this-command-keys))
+(defun isearch-other-meta-char (&optional arg)
+ "Process a miscellaneous key sequence in Isearch mode.
+
+Try to convert the current key-sequence to something usable in Isearch
+mode, either by converting it with `function-key-map', downcasing a
+key with C-<upper case>, or finding a \"scrolling command\" bound to
+it. \(In the last case, we may have to read more events.) If so,
+either unread the converted sequence or execute the command.
+
+Otherwise, if `search-exit-option' is non-nil (the default) unread the
+key-sequence and exit the search normally. If it is the symbol
+`edit', the search string is edited in the minibuffer and the meta
+character is unread so that it applies to editing the string.
+
+ARG is the prefix argument. It will be transmitted through to the
+scrolling command or to the command whose key-sequence exits
+Isearch mode."
+ (interactive "P")
+ (let* ((key (if current-prefix-arg ; not nec the same as ARG
+ (substring (this-command-keys) universal-argument-num-events)
+ (this-command-keys)))
(main-event (aref key 0))
- (keylist (listify-key-sequence key)))
+ (keylist (listify-key-sequence key))
+ scroll-command isearch-point)
(cond ((and (= (length key) 1)
(let ((lookup (lookup-key function-key-map key)))
(not (or (null lookup) (integerp lookup)
;; so that the translated key takes effect within isearch.
(cancel-kbd-macro-events)
(if (lookup-key global-map key)
- (progn
+ (progn
(isearch-done)
(apply 'isearch-unread keylist))
- (apply 'isearch-unread
- (listify-key-sequence (lookup-key function-key-map key)))))
+ (setq keylist
+ (listify-key-sequence (lookup-key function-key-map key)))
+ (while keylist
+ (setq key (car keylist))
+ ;; If KEY is a printing char, we handle it here
+ ;; directly to avoid the input method and keyboard
+ ;; coding system translating it.
+ (if (and (integerp key)
+ (>= key ?\ ) (/= key 127) (< key 256))
+ (progn
+ (isearch-process-search-char key)
+ (setq keylist (cdr keylist)))
+ ;; As the remaining keys in KEYLIST can't be handled
+ ;; here, we must reread them.
+ (apply 'isearch-unread keylist)
+ (setq keylist nil)))))
(
;; Handle an undefined shifted control character
;; by downshifting it if that makes it defined.
((eq search-exit-option 'edit)
(apply 'isearch-unread keylist)
(isearch-edit-string))
+ ;; Handle a scrolling function.
+ ((and isearch-allow-scroll
+ (progn (setq key (isearch-reread-key-sequence-naturally keylist))
+ (setq keylist (listify-key-sequence key))
+ (setq main-event (aref key 0))
+ (setq scroll-command (isearch-lookup-scroll-key key))))
+ ;; From this point onwards, KEY, KEYLIST and MAIN-EVENT hold a
+ ;; complete key sequence, possibly as modified by function-key-map,
+ ;; not merely the one or two event fragment which invoked
+ ;; isearch-other-meta-char in the first place.
+ (setq isearch-point (point))
+ (setq prefix-arg arg)
+ (command-execute scroll-command)
+ (let ((ab-bel (isearch-string-out-of-window isearch-point)))
+ (if ab-bel
+ (isearch-back-into-window (eq ab-bel 'above) isearch-point)
+ (or (eq (point) isearch-point)
+ (goto-char isearch-point))))
+ (isearch-update))
(search-exit-option
(let (window)
- (cancel-kbd-macro-events)
- (apply 'isearch-unread keylist)
- ;; Properly handle scroll-bar and mode-line clicks
- ;; for which a dummy prefix event was generated as (aref key 0).
- (and (> (length key) 1)
- (symbolp (aref key 0))
- (listp (aref key 1))
- (not (numberp (posn-point (event-start (aref key 1)))))
- ;; Convert the event back into its raw form,
- ;; with the dummy prefix implicit in the mouse event,
- ;; so it will get split up once again.
- (progn (setq unread-command-events
- (cdr unread-command-events))
- (setq main-event (car unread-command-events))
- (setcar (cdr (event-start main-event))
- (car (nth 1 (event-start main-event))))))
- ;; If we got a mouse click, maybe it was read with the buffer
+ (isearch-unread-key-sequence keylist)
+ (setq main-event (car unread-command-events))
+
+ ;; If we got a mouse click event, that event contains the
+ ;; window clicked on. maybe it was read with the buffer
;; it was clicked on. If so, that buffer, not the current one,
;; is in isearch mode. So end the search in that buffer.
- (if (and (listp main-event)
+
+ ;; ??? I have no idea what this if checks for, but it's
+ ;; obviously wrong for the case that a down-mouse event
+ ;; on another window invokes this function. The event
+ ;; will contain the window clicked on and that window's
+ ;; buffer is certainly not always in Isearch mode.
+ ;;
+ ;; Leave the code in, but check for current buffer not
+ ;; being in Isearch mode for now, until someone tells
+ ;; what it's really supposed to do.
+ ;;
+ ;; --gerd 2001-08-10.
+
+ (if (and (not isearch-mode)
+ (listp main-event)
(setq window (posn-window (event-start main-event)))
(windowp window)
(or (> (minibuffer-depth) 0)
(isearch-done)
(isearch-clean-overlays))
(isearch-done)
- (isearch-clean-overlays))))
- (t;; otherwise nil
+ (isearch-clean-overlays)
+ (setq prefix-arg arg))))
+ (t;; otherwise nil
(isearch-process-search-string key key)))))
(defun isearch-quote-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)
- (let ((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 (+ char nonascii-insert-offset))
+ (if (keyboard-coding-system)
+ (isearch-process-search-multibyte-characters char)
+ (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 \\<isearch-mode-map>\\[isearch-quote-char] SPC."
(interactive)
- (if isearch-regexp
+ (if isearch-regexp
(if (and search-whitespace-regexp (not isearch-within-brackets)
(not isearch-invalid-regexp))
(isearch-process-search-string search-whitespace-regexp " ")
(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)
+ (isearch-process-search-string
+ (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)))
;; Helper for isearch-complete and isearch-complete-edit
;; Return t if completion OK, nil if no completion exists.
(let* ((ring (if isearch-regexp regexp-search-ring search-ring))
- (alist (mapcar (function (lambda (string) (list string))) ring))
(completion-ignore-case case-fold-search)
- (completion (try-completion isearch-string alist)))
+ (completion (try-completion isearch-string ring)))
(cond
((eq completion t)
;; isearch-string stays the same
(progn
(if completion-auto-help
(with-output-to-temp-buffer "*Isearch completions*"
- (display-completion-list
- (all-completions isearch-string alist))))
+ (display-completion-list
+ (all-completions isearch-string ring))))
t)
(and completion
(setq isearch-string completion))))
If there is no completion possible, say so and continue searching."
(interactive)
(if (isearch-complete1)
- (isearch-edit-string)
+ (progn (setq isearch-message
+ (mapconcat 'isearch-text-char-description
+ isearch-string ""))
+ (isearch-edit-string))
;; else
(sit-for 1)
(isearch-update)))
(defun isearch-complete-edit ()
"Same as `isearch-complete' except in the minibuffer."
(interactive)
- (setq isearch-string (buffer-string))
+ (setq isearch-string (field-string))
(if (isearch-complete1)
(progn
- (erase-buffer)
+ (delete-field)
(insert isearch-string))))
\f
(defun isearch-pop-state ()
(setq isearch-cmds (cdr isearch-cmds))
- (isearch-top-state)
- )
+ (isearch-top-state))
(defun isearch-push-state ()
- (setq isearch-cmds
+ (setq isearch-cmds
(cons (list isearch-string isearch-message (point)
- isearch-success isearch-forward isearch-other-end
+ isearch-success isearch-forward isearch-other-end
isearch-word
isearch-invalid-regexp isearch-wrapped isearch-barrier
isearch-within-brackets isearch-case-fold-search)
(let ((cursor-in-echo-area ellipsis)
(m (concat
(isearch-message-prefix c-q-hack ellipsis isearch-nonincremental)
- isearch-message
+ (if (and (not isearch-success)
+ (string-match " +$" isearch-message))
+ (concat
+ (substring isearch-message 0 (match-beginning 0))
+ (propertize (substring isearch-message (match-beginning 0))
+ 'face 'trailing-whitespace))
+ isearch-message)
(isearch-message-suffix c-q-hack ellipsis)
)))
(if c-q-hack
(concat " [" current-input-method-title "]: ")
": ")
)))
- (aset m 0 (upcase (aref m 0)))
- m))
-
+ (propertize (concat (upcase (substring m 0 1)) (substring m 1))
+ 'face 'minibuffer-prompt)))
(defun isearch-message-suffix (&optional c-q-hack ellipsis)
(concat (if c-q-hack "^Q" "")
"")))
\f
-;;; Searching
+;; Searching
+
+(defvar isearch-search-fun-function nil
+ "Override `isearch-search-fun'.
+This function should return the search function for isearch to use.
+It will call this function with three arguments
+as if it were `search-forward'.")
+
+(defun isearch-search-fun ()
+ "Return the function to use for the search.
+Can be changed via `isearch-search-fun-function' for special needs."
+ (if isearch-search-fun-function
+ (funcall isearch-search-fun-function)
+ (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)))))
(defun isearch-search ()
;; Do the search with the current search string.
(while retry
(setq isearch-success
(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-search-fun)
isearch-string nil t))
;; Clear RETRY unless we matched some invisible text
;; and we aren't supposed to do that.
(quit (isearch-unread ?\C-g)
(setq isearch-success nil))
- (invalid-regexp
+ (invalid-regexp
(setq isearch-invalid-regexp (car (cdr lossage)))
(setq isearch-within-brackets (string-match "\\`Unmatched \\["
isearch-invalid-regexp))
(setq isearch-invalid-regexp "incomplete input")))
(error
;; stack overflow in regexp search.
- (setq isearch-invalid-regexp (car (cdr lossage)))))
+ (setq isearch-invalid-regexp (format "%s" lossage))))
(if isearch-success
nil
(goto-char (nth 2 (car isearch-cmds)))))
-;;; Called when opening an overlay, and we are still in isearch.
+;; Called when opening an overlay, and we are still in isearch.
(defun isearch-open-overlay-temporary (ov)
- (if (not (null (overlay-get ov 'isearch-open-invisible-temporary)))
+ (if (not (null (overlay-get ov 'isearch-open-invisible-temporary)))
;; Some modes would want to open the overlays temporary during
;; isearch in their own way, they should set the
;; `isearch-open-invisible-temporary' to a function doing this.
;; properties, and then set them to nil. This way the text hidden
;; by this overlay becomes visible.
- ;; Do we realy need to set the `intangible' property to t? Can we
+ ;; Do we really need to set the `intangible' property to t? Can we
;; have the point inside an overlay with an `intangible' property?
;; In 19.34 this does not exist so I cannot test it.
(overlay-put ov 'isearch-invisible (overlay-get ov 'invisible))
(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
-;;; point returns to the original location which surely is not contain
-;;; in any of these overlays, se we are safe in this case too.
+;; 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)
- (let ((inside-overlay (and (> (point) (overlay-start ov))
+ (let ((inside-overlay (and (> (point) (overlay-start ov))
(< (point) (overlay-end ov))))
;; If this exists it means that the overlay was opened using
;; this function, not by us tweaking the overlay properties.
(if fct-temp
(funcall fct-temp ov t)))))
-;;; This is called when exiting isearch. It closes the temporary
-;;; opened overlays, except the ones that contain the latest match.
+;; This is called when exiting isearch. It closes the temporary
+;; opened overlays, except the ones that contain the latest match.
(defun isearch-clean-overlays ()
(when isearch-opened-overlays
- ;; Use a cycle instead of a mapcar here?
- (mapcar
- (function isearch-open-necessary-overlays) isearch-opened-overlays)
+ (mapc 'isearch-open-necessary-overlays isearch-opened-overlays)
(setq isearch-opened-overlays nil)))
-;;; Verify if the current match is outside of each element of
-;;; `isearch-opened-overlays', if so close that overlay.
-(defun isearch-close-unecessary-overlays (begin end)
- (let ((ov-list isearch-opened-overlays)
- ov
- inside-overlay
- fct-temp)
+
+(defun isearch-intersects-p (start0 end0 start1 end1)
+ "Return t if regions START0..END0 and START1..END1 intersect."
+ (or (and (>= start0 start1) (< start0 end1))
+ (and (> end0 start1) (<= end0 end1))
+ (and (>= start1 start0) (< start1 end0))
+ (and (> end1 start0) (<= end1 end0))))
+
+
+;; Verify if the current match is outside of each element of
+;; `isearch-opened-overlays', if so close that overlay.
+
+(defun isearch-close-unnecessary-overlays (begin end)
+ (let ((overlays isearch-opened-overlays))
(setq isearch-opened-overlays nil)
- (while ov-list
- (setq ov (car ov-list))
- (setq ov-list (cdr ov-list))
- (setq inside-overlay (or (and (> begin (overlay-start ov))
- (< begin (overlay-end ov)))
- (and (> end (overlay-start ov))
- (< end (overlay-end ov)))))
- ;; If this exists it means that the overlay was opened using
- ;; this function, not by us tweaking the overlay properties.
- (setq fct-temp (overlay-get ov 'isearch-open-invisible-temporary))
- (if inside-overlay
- (setq isearch-opened-overlays (cons ov isearch-opened-overlays))
- (if fct-temp
- (funcall fct-temp ov t)
- (overlay-put ov 'invisible (overlay-get ov 'isearch-invisible))
- (overlay-put ov 'intangible (overlay-get ov 'isearch-intangible))
- (overlay-put ov 'isearch-invisible nil)
- (overlay-put ov 'isearch-intangible nil))))))
+ (dolist (ov overlays)
+ (if (isearch-intersects-p begin end (overlay-start ov) (overlay-end ov))
+ (push ov isearch-opened-overlays)
+ (let ((fct-temp (overlay-get ov 'isearch-open-invisible-temporary)))
+ (if fct-temp
+ ;; If this exists it means that the overlay was opened
+ ;; using this function, not by us tweaking the overlay
+ ;; properties.
+ (funcall fct-temp ov t)
+ (overlay-put ov 'invisible (overlay-get ov 'isearch-invisible))
+ (overlay-put ov 'intangible (overlay-get ov 'isearch-intangible))
+ (overlay-put ov 'isearch-invisible nil)
+ (overlay-put ov 'isearch-intangible nil)))))))
+
(defun isearch-range-invisible (beg end)
"Return t if all the text from BEG to END is invisible."
- (and (/= beg end)
- ;; 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))
- (when (and can-be-opened isearch-hide-immediately)
- (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 (and (< (point) end)
- (let ((prop
- (get-char-property (point) 'invisible)))
- (if (eq buffer-invisibility-spec t)
- prop
- (or (memq prop buffer-invisibility-spec)
- (assq prop buffer-invisibility-spec)))))
- (if (get-text-property (point) 'invisible)
- (progn
- (goto-char (next-single-property-change (point) 'invisible
- nil end))
- ;; if text is hidden by an `invisible' text property
- ;; we cannot open it at all.
- (setq can-be-opened nil))
- (unless (null can-be-opened)
- (let ((overlays (overlays-at (point)))
- ov-list
- o
- invis-prop)
- (while overlays
- (setq o (car overlays)
- invis-prop (overlay-get o 'invisible))
- (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
- ;; opened, that means the whole chunk
- ;; cannot be opened.
- (setq can-be-opened nil)))
- (setq overlays (cdr overlays)))
- (if can-be-opened
- ;; 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)))))
- ;; See if invisibility reaches up thru END.
- (if (>= (point) end)
- (if (and (not (null can-be-opened)) (consp crt-overlays))
- (progn
- (setq isearch-opened-overlays
- (append isearch-opened-overlays crt-overlays))
- ;; maybe use a cycle instead of mapcar?
- (mapcar (function isearch-open-overlay-temporary)
- crt-overlays)
- nil)
- t))))))
+ (when (/= beg end)
+ ;; 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))
+ (when (and can-be-opened isearch-hide-immediately)
+ (isearch-close-unnecessary-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 (and (< (point) end)
+ (let ((prop
+ (get-char-property (point) 'invisible)))
+ (if (eq buffer-invisibility-spec t)
+ prop
+ (or (memq prop buffer-invisibility-spec)
+ (assq prop buffer-invisibility-spec)))))
+ (if (get-text-property (point) 'invisible)
+ (progn
+ (goto-char (next-single-property-change (point) 'invisible
+ nil end))
+ ;; if text is hidden by an `invisible' text property
+ ;; we cannot open it at all.
+ (setq can-be-opened nil))
+ (when can-be-opened
+ (let ((overlays (overlays-at (point)))
+ ov-list
+ o
+ invis-prop)
+ (while overlays
+ (setq o (car overlays)
+ invis-prop (overlay-get o 'invisible))
+ (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
+ ;; opened, that means the whole chunk
+ ;; cannot be opened.
+ (setq can-be-opened nil)))
+ (setq overlays (cdr overlays)))
+ (if can-be-opened
+ ;; 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)))))
+ ;; See if invisibility reaches up thru END.
+ (if (>= (point) end)
+ (if (and can-be-opened (consp crt-overlays))
+ (progn
+ (setq isearch-opened-overlays
+ (append isearch-opened-overlays crt-overlays))
+ (mapc 'isearch-open-overlay-temporary crt-overlays)
+ nil)
+ (setq isearch-hidden t)))))))
\f
-;;; Highlighting
+;; Highlighting
(defvar isearch-overlay nil)
(defun isearch-highlight (beg end)
- (if (or (null search-highlight) (null window-system))
- nil
- (or isearch-overlay (setq isearch-overlay (make-overlay beg end)))
- (move-overlay isearch-overlay beg end (current-buffer))
- (overlay-put isearch-overlay 'face
- (if (internal-find-face 'isearch nil)
- 'isearch 'region))))
+ (unless (null search-highlight)
+ (cond (isearch-overlay
+ ;; Overlay already exists, just move it.
+ (move-overlay isearch-overlay beg end (current-buffer)))
+
+ (t
+ ;; Overlay doesn't exist, create it.
+ (setq isearch-overlay (make-overlay beg end))
+ (overlay-put isearch-overlay 'face isearch)
+ (overlay-put isearch-overlay 'priority 1) ;higher than lazy overlays
+ ))))
(defun isearch-dehighlight (totally)
- (if isearch-overlay
- (delete-overlay isearch-overlay)))
+ (when isearch-overlay
+ (delete-overlay isearch-overlay)))
+
-;;; General utilities
+;; General utilities
(defun isearch-no-upper-case-p (string regexp-flag)
"Return t if there are no upper case chars in STRING.
If REGEXP-FLAG is non-nil, disregard letters preceded by `\\' (but not `\\\\')
since they have special meaning in a regexp."
- (let (quote-flag (i 0) (len (length string)) found)
+ (let (quote-flag (i 0) (len (length string)) found)
(while (and (not found) (< i len))
(let ((char (aref string i)))
(if (and regexp-flag (eq char ?\\))
(setq quote-flag (not quote-flag))
(if (and (not quote-flag) (not (eq char (downcase char))))
- (setq found t))))
+ (setq found t))
+ (setq quote-flag nil)))
(setq i (1+ i)))
(not found)))
;; 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)))
+ (cond
+ ((< c ?\ ) (format "^%c" (+ c 64)))
+ ((= c ?\^?) "^?")
+ (t (char-to-string c))))
;; General function to unread characters or events.
;; Also insert them in a keyboard macro being defined.
(defun isearch-unread (&rest char-or-events)
- (mapcar 'store-kbd-macro-event char-or-events)
+ (mapc 'store-kbd-macro-event char-or-events)
(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 `isearch-lazy-highlight-face'. 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 or window-start changes;
+;; - `isearch-string' is expected to contain the current search
+;; string as entered by the user;
+;; - 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.
+
+(defgroup isearch-lazy-highlight nil
+ "Lazy highlighting feature for incremental search."
+ :prefix "isearch-lazy-highlight-"
+ :version "21.1"
+ :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 ; 0.0625
+ "*Seconds between lazily highlighting successive matches."
+ :type 'number
+ :group 'isearch-lazy-highlight)
+
+(defcustom isearch-lazy-highlight-max-at-a-time 20
+ "*Maximum matches to highlight at a time (for `isearch-lazy-highlight').
+Larger values may reduce isearch's responsiveness to user input;
+smaller values make matches highlight slowly.
+A value of nil means highlight all matches."
+ :type '(choice (const :tag "All" nil)
+ (integer :tag "Some"))
+ :group 'isearch-lazy-highlight)
+
+(defgroup isearch-faces nil
+ "Lazy highlighting feature for incremental search."
+ :version "21.1"
+ :group 'isearch)
+(defface isearch
+ '((((class color) (min-colors 88) (background light))
+ ;; The background must not be too dark, for that means
+ ;; the character is hard to see when the cursor is there.
+ (:background "magenta2" :foreground "lightskyblue1"))
+ (((class color) (min-colors 88) (background dark))
+ (:background "palevioletred2" :foreground "brown4"))
+ (((class color) (min-colors 16))
+ (:background "magenta4" :foreground "cyan1"))
+ (((class color) (min-colors 8))
+ (:background "magenta4" :foreground "cyan1"))
+ (t (:inverse-video t)))
+ "Face for highlighting Isearch matches."
+ :group 'isearch-faces)
+(defvar isearch 'isearch)
+
+(defface isearch-lazy-highlight-face
+ '((((class color) (min-colors 88) (background light))
+ (:background "paleturquoise"))
+ (((class color) (min-colors 88) (background dark))
+ (:background "paleturquoise4"))
+ (((class color) (min-colors 16))
+ (:background "turquoise3"))
+ (((class color) (min-colors 8))
+ (:background "turquoise3"))
+ (t (:underline t)))
+ "Face for lazy highlighting of Isearch matches other than the current one."
+ :group 'isearch-faces)
+(defvar isearch-lazy-highlight-face 'isearch-lazy-highlight-face)
+
+(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)
+(defvar isearch-lazy-highlight-window nil)
+(defvar isearch-lazy-highlight-window-start nil)
+(defvar isearch-lazy-highlight-window-end nil)
+(defvar isearch-lazy-highlight-case-fold-search nil)
+(defvar isearch-lazy-highlight-regexp 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)
+ (while isearch-lazy-highlight-overlays
+ (delete-overlay (car isearch-lazy-highlight-overlays))
+ (setq isearch-lazy-highlight-overlays
+ (cdr isearch-lazy-highlight-overlays))))
+ (when isearch-lazy-highlight-timer
+ (cancel-timer isearch-lazy-highlight-timer)
+ (setq isearch-lazy-highlight-timer nil)))
+
+(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 or the window to scroll)."
+ (when (and isearch-lazy-highlight
+ (null executing-kbd-macro)
+ (sit-for 0) ;make sure (window-start) is credible
+ (or (not (equal isearch-string
+ isearch-lazy-highlight-last-string))
+ (not (eq (selected-window)
+ isearch-lazy-highlight-window))
+ (not (eq isearch-lazy-highlight-case-fold-search
+ isearch-case-fold-search))
+ (not (eq isearch-lazy-highlight-regexp
+ isearch-regexp))
+ (not (= (window-start)
+ isearch-lazy-highlight-window-start))
+ (not (= (window-end) ; Window may have been split/joined.
+ isearch-lazy-highlight-window-end))))
+ ;; something important did indeed change
+ (isearch-lazy-highlight-cleanup t) ;kill old loop & remove overlays
+ (when (not isearch-invalid-regexp)
+ (setq isearch-lazy-highlight-window (selected-window)
+ isearch-lazy-highlight-window-start (window-start)
+ isearch-lazy-highlight-window-end (window-end)
+ isearch-lazy-highlight-start (point)
+ isearch-lazy-highlight-end (point)
+ isearch-lazy-highlight-last-string isearch-string
+ isearch-lazy-highlight-case-fold-search isearch-case-fold-search
+ isearch-lazy-highlight-regexp isearch-regexp
+ 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 (isearch-search-fun)
+ isearch-string
+ (if isearch-forward
+ (if isearch-lazy-highlight-wrapped
+ isearch-lazy-highlight-start
+ (window-end))
+ (if isearch-lazy-highlight-wrapped
+ isearch-lazy-highlight-end
+ (window-start)))
+ t)))
+
+(defun isearch-lazy-highlight-update ()
+ "Update highlighting of other matches for current search."
+ (let ((max isearch-lazy-highlight-max-at-a-time)
+ (looping t)
+ nomore)
+ (save-excursion
+ (save-match-data
+ (goto-char (if isearch-forward
+ isearch-lazy-highlight-end
+ isearch-lazy-highlight-start))
+ (while looping
+ (let ((found (isearch-lazy-highlight-search)))
+ (when max
+ (setq max (1- max))
+ (if (<= max 0)
+ (setq looping nil)))
+ (if found
+ (let ((mb (match-beginning 0))
+ (me (match-end 0)))
+ (if (= mb me) ;zero-length match
+ (forward-char 1)
+
+ ;; non-zero-length match
+ (let ((ov (make-overlay mb me)))
+ (overlay-put ov 'face isearch-lazy-highlight-face)
+ (overlay-put ov 'priority 0) ;lower than main overlay
+ (overlay-put ov 'window (selected-window))
+ (push ov isearch-lazy-highlight-overlays)))
+ (if isearch-forward
+ (setq isearch-lazy-highlight-end (point))
+ (setq isearch-lazy-highlight-start (point))))
+
+ ;; not found
+ (if isearch-lazy-highlight-wrapped
+ (setq looping nil
+ nomore t)
+ (setq isearch-lazy-highlight-wrapped t)
+ (if isearch-forward
+ (progn
+ (setq isearch-lazy-highlight-end (window-start))
+ (goto-char (window-start)))
+ (setq isearch-lazy-highlight-start (window-end))
+ (goto-char (window-end)))))))
+ (unless nomore
+ (setq isearch-lazy-highlight-timer
+ (run-at-time isearch-lazy-highlight-interval nil
+ 'isearch-lazy-highlight-update)))))))
+
+(defun isearch-resume (search regexp word forward message case-fold)
+ "Resume an incremental search.
+SEARCH is the string or regexp searched for.
+REGEXP non-nil means the resumed search was a regexp search.
+WORD non-nil means resume a word search.
+FORWARD non-nil means resume a forward search.
+MESSAGE is the echo-area message recorded for the search resumed.
+CASE-FOLD non-nil means the search was case-insensitive."
+ (isearch-mode forward regexp nil nil word)
+ (setq isearch-string search
+ isearch-message message
+ isearch-case-fold-search case-fold)
+ (isearch-search))
+
+;;; arch-tag: 74850515-f7d8-43a6-8a2c-ca90a4c1e675
;;; isearch.el ends here
HCoop / bpt / emacs.git / blobdiff