;;; isearch.el --- incremental search minor mode.
-;; Copyright (C) 1992, 93, 94, 95, 96, 97, 1999 Free Software Foundation, Inc.
+;; Copyright (C) 1992, 93, 94, 95, 96, 97, 1999, 2000
+;; Free Software Foundation, Inc.
;; Author: Daniel LaLiberte <liberte@cs.uiuc.edu>
;; Maintainer: FSF
;; 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.
(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)
+ (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)
;; 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
(isearch-dehighlight t)
+ (isearch-lazy-highlight-cleanup)
(let ((found-start (window-start (selected-window)))
(found-point (point)))
(if isearch-window-configuration
(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) (progn (forward-word 1) (point))))))
(defun isearch-yank-line ()
"Pull rest of line from buffer into search string."
(save-excursion
(and (not isearch-forward) isearch-other-end
(goto-char isearch-other-end))
- (buffer-substring (point) (line-end-position)))))
+ (buffer-substring-no-properties (point) (line-end-position)))))
(defun isearch-search-and-update ()
(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.
(if (and enable-multibyte-characters
(>= char ?\200)
(<= char ?\377))
- (isearch-process-search-char (unibyte-char-to-multibyte char))
+ (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)))))
(concat " [" current-input-method-title "]: ")
": ")
)))
- (aset m 0 (upcase (aref m 0)))
- m))
+ (concat (upcase (substring m 0 1)) (substring m 1))))
(defun isearch-message-suffix (&optional c-q-hack ellipsis)
(defvar isearch-overlay nil)
+(defsubst isearch-set-lazy-highlight-faces-at (pos face)
+ "Set the face property of isearch lazy highlight overlays at POS to FACE.
+If POS is nil, nothing is done."
+ (unless (null pos)
+ (dolist (ov (overlays-at pos))
+ (when (and (not (eq ov isearch-overlay))
+ (memq ov isearch-lazy-highlight-overlays)
+ (not (eq (overlay-get ov 'face) face)))
+ (overlay-put ov 'face face)))))
+
(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 (or (null search-highlight) (null (display-color-p)))
+ (cond (isearch-overlay
+ ;; Overlay already exists, just move it.
+
+ ;; Check to see if there are any lazy-isearch overlays at
+ ;; the same position with their face property suppressed
+ ;; (to avoid face clashes), and if so, give them their face
+ ;; back.
+ (isearch-set-lazy-highlight-faces-at (overlay-start isearch-overlay)
+ isearch-lazy-highlight-face)
+
+ (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)))
+
+ ;; Suppress the faces of any lazy-isearch overlays at the new position
+ (isearch-set-lazy-highlight-faces-at beg nil)))
(defun isearch-dehighlight (totally)
- (if isearch-overlay
- (delete-overlay isearch-overlay)))
+ (when isearch-overlay
+ ;; Check to see if there are any lazy-isearch overlays at the same
+ ;; position with their face property suppressed (to avoid face
+ ;; clashes), and if so, give them their face back.
+ (isearch-set-lazy-highlight-faces-at (overlay-start isearch-overlay)
+ isearch-lazy-highlight-face)
+ (delete-overlay isearch-overlay)))
+
;;; General utilities
;; Portability functions to support various Emacs versions.
(defun isearch-text-char-description (c)
- (if (and (integerp c) (or (< c ?\ ) (= c ?\^?)))
- (text-char-description c)
- (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.
(setq unread-command-events
(append char-or-events unread-command-events)))
+\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)
+
+(defgroup isearch-faces nil
+ "Lazy highlighting feature for incremental search."
+ :version "21.1"
+ :group 'isearch)
+
+(defface isearch
+ '((t (:inherit region)))
+ "Face for highlighting matches."
+ :group 'isearch-faces)
+(defvar isearch 'isearch)
+
+(defface isearch-lazy-highlight-face
+ '((t (:inherit secondary-selection)))
+ "Face for lazy highlighting of matches."
+ :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)
+
+(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))))
+ ;; If OV overlaps the current isearch overlay, suppress
+ ;; its face property; otherwise, we sometimes get odd
+ ;; looking face combinations.
+ (unless (memq isearch-overlay
+ (overlays-at (match-beginning 0)))
+ (overlay-put ov 'face isearch-lazy-highlight-face))
+
+ (overlay-put ov 'priority 0)
+
+ (push 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))))))))))
+
+(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))
+
;;; isearch.el ends here
HCoop / bpt / emacs.git / blobdiff