;;; iswitchb.el --- switch between buffers using substrings
-;; Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+;; Copyright (C) 1996, 1997, 2000, 2001, 2003 Free Software Foundation, Inc.
-;; Author: Stephen Eglen <stephen@cns.ed.ac.uk>
-;; Maintainer: Stephen Eglen <stephen@cns.ed.ac.uk>
-;; Keywords: extensions
+;; Author: Stephen Eglen <stephen@gnu.org>
+;; Maintainer: Stephen Eglen <stephen@gnu.org>
+;; Keywords: completion convenience
+;; location: http://www.anc.ed.ac.uk/~stephen/emacs/
;; This file is part of GNU Emacs.
;;; Commentary:
;; Installation:
-;; To get the functions in this package bound to keys, do
-;; (iswitchb-default-keybindings)
+;; To get the functions in this package bound to keys, use
+;; M-x iswitchb-mode or customize the option `iswitchb-mode'.
+;; Alternatively, add the following line to your .emacs:
+;; (iswitchb-mode 1)
;; As you type in a substring, the list of buffers currently matching
-;; the substring are displayed as you type. The list is ordered so
+;; the substring is displayed as you type. The list is ordered so
;; that the most recent buffers visited come at the start of the list.
;; The buffer at the start of the list will be the one visited when
;; you press return. By typing more of the substring, the list is
;; narrowed down so that gradually the buffer you want will be at the
-;; top of the list. Alternatively, you can use C-s an C-r to rotate
+;; top of the list. Alternatively, you can use C-s and C-r to rotate
;; buffer names in the list until the one you want is at the top of
;; the list. Completion is also available so that you can see what is
;; common to all of the matching buffers as you type.
;; This code is similar to a couple of other packages. Michael R Cook
-;; <mcook@cognex.com> wrote a similar buffer switching package, but
+;; <cook@sightpath.com> wrote a similar buffer switching package, but
;; does exact matching rather than substring matching on buffer names.
;; I also modified a couple of functions from icomplete.el to provide
;; the completion feedback in the minibuffer.
-;;; Example
+;;; Example
-;;If I have two buffers called "123456" and "123", with "123456" the
-;;most recent, when I use iswitchb, I first of all get presented with
-;;the list of all the buffers
+;; If I have two buffers called "123456" and "123", with "123456" the
+;; most recent, when I use iswitchb, I first of all get presented with
+;; the list of all the buffers
;;
-;; iswitch {123456,123}
+;; iswitch {123456,123}
;;
;; If I then press 2:
;; iswitch 2[3]{123456,123}
;; The list in {} are the matching buffers, most recent first (buffers
;; visible in the current frame are put at the end of the list by
;; default). At any time I can select the item at the head of the
-;; list by pressing RET. I can also bring the put the first element
-;; at the end of the list by pressing C-s, or put the last element at
-;; the head of the list by pressing C-r. The item in [] indicates
-;; what can be added to my input by pressing TAB. In this case, I
-;; will get "3" added to my input. So, press TAB:
+;; list by pressing RET. I can also put the first element at the end
+;; of the list by pressing C-s, or put the last element at the head of
+;; the list by pressing C-r. The item in [] indicates what can be
+;; added to my input by pressing TAB. In this case, I will get "3"
+;; added to my input. So, press TAB:
;; iswitch 23{123456,123}
;;
;; At this point, I still have two matching buffers.
;; wanted the second in the list, I could press C-s to move it to the
;; top of the list and then RET to select it.
;;
-;;However, If I type 4, I only have one match left:
+;; However, if I type 4, I only have one match left:
;; iswitch 234[123456] [Matched]
;;
-;;Since there is only one matching buffer left, it is given in [] and we
-;;see the text [Matched] afterwards. I can now press TAB or RET to go
-;;to that buffer.
+;; Since there is only one matching buffer left, it is given in [] and we
+;; see the text [Matched] afterwards. I can now press TAB or RET to go
+;; to that buffer.
;;
;; If however, I now type "a":
;; iswitch 234a [No match]
;; If you find that the file you are after is not in a buffer, you can
;; press C-x C-f to immediately drop into find-file.
+;; See the doc string of iswitchb for full keybindings and features.
+;; (describe-function 'iswitchb)
+
+;; Case matching: The case of strings when matching can be ignored or
+;; used depending on the value of iswitchb-case (default is the same
+;; as case-fold-search, normally t). Imagine you have the following
+;; buffers:
+;;
+;; INBOX *info* *scratch*
+;;
+;; Then these will be the matching buffers, depending on how you type
+;; the two letters `in' and the value of iswitchb-case:
;;
-;; See the doc string of iswitchb for full keybindings and features.
-;; (describe-function 'iswitchb)
+;; iswitchb-case user input | matching buffers
+;; ----------------------------------------------
+;; nil in | *info*
+;; t in | INBOX, *info*
+;; t IN | INBOX
+;; t In | [No match]
;;; Customisation
;; See the User Variables section below for easy ways to change the
;; functionality of the program. These are accessible using the
;; custom package.
-;; To modify the keybindings, use the hook provided. For example:
-;;(add-hook 'iswitchb-define-mode-map-hook
-;; 'iswitchb-my-keys)
+;; To modify the keybindings, use something like:
;;
+;;(add-hook 'iswitchb-mode-hook 'iswitchb-my-keys)
;;(defun iswitchb-my-keys ()
;; "Add my keybindings for iswitchb."
-;; (define-key iswitchb-mode-map " " 'iswitchb-next-match)
-;; )
+;; (define-key iswitchb-mode-map " " 'iswitchb-next-match))
;;
;; Seeing all the matching buffers
;;
;; If you have many matching buffers, they may not all fit onto one
-;; line of the minibuffer. In this case, you should use rsz-mini
-;; (resize-minibuffer-mode). You can also limit iswitchb so that it
+;; line of the minibuffer. In Emacs 21, the variable
+;; `resize-mini-windows' controls how many lines of the minibuffer can
+;; be seen. For older versions of emacs, you can use
+;; `resize-minibuffer-mode'. You can also limit iswitchb so that it
;; only shows a certain number of lines -- see the documentation for
;; `iswitchb-minibuffer-setup-hook'.
-
;; Changing the list of buffers
;; By default, the list of current buffers is most recent first,
;; then all buffers matching "Summary" are moved to the end of the
;; list. (I find this handy for keeping the INBOX Summary and so on
;; out of the way.) It also moves buffers matching "output\*$" to the
-;; end of the list (these are created by AUC TeX when compiling.)
+;; end of the list (these are created by AUCTeX when compiling.)
;; Other functions could be made available which alter the list of
;; matching buffers (either deleting or rearranging elements.)
;; this is too harsh, let me know. Colouring of the matching buffer
;; name was suggested by Carsten Dominik (dominik@strw.leidenuniv.nl)
-
;; Replacement for read-buffer
;; iswitchb-read-buffer has been written to be a drop in replacement
;; for the normal buffer selection routine `read-buffer'. To use
;; iswitch for all buffer selections in Emacs, add:
;; (setq read-buffer-function 'iswitchb-read-buffer)
-;; (This variable should be present in Emacs 20.3+)
+;; (This variable was introduced in Emacs 20.3.)
;; XEmacs users can get the same behaviour by doing:
-;; (defalias 'read-buffer 'iswitchb-read-buffer)
+;; (defalias 'read-buffer 'iswitchb-read-buffer)
;; since `read-buffer' is defined in lisp.
+;; Using iswitchb for other completion tasks.
+
+;; Kin Cho (kin@neoscale.com) sent the following suggestion to use
+;; iswitchb for other completion tasks.
+;;
+;; (defun my-icompleting-read (prompt choices)
+;; "Use iswitch as a completing-read replacement to choose from
+;; choices. PROMPT is a string to prompt with. CHOICES is a list of
+;; strings to choose from."
+;; (let ((iswitchb-make-buflist-hook
+;; (lambda ()
+;; (setq iswitchb-temp-buflist choices))))
+;; (iswitchb-read-buffer prompt)))
+;;
+;; example:
+;; (my-icompleting-read "Which fruit? " '
+;; ("apple" "pineapple" "pear" "bananas" "oranges") )
+
+;; Kin Cho also suggested the following defun. Once you have a subset of
+;; matching buffers matching your current prompt, you can then press
+;; e.g. C-o to restrict matching to those buffers and clearing the prompt:
+;; (defun iswitchb-exclude-nonmatching()
+;; "Make iswitchb work on only the currently matching names."
+;; (interactive)
+;; (setq iswitchb-buflist iswitchb-matches)
+;; (setq iswitchb-rescan t)
+;; (delete-minibuffer-contents))
+;;
+;; (add-hook 'iswitchb-define-mode-map-hook
+;; '(lambda () (define-key
+;; iswitchb-mode-map "\C-o"
+;; 'iswitchb-exclude-nonmatching)))
+
+;; Other lisp packages extend iswitchb behaviour to other tasks. See
+;; ido.el (by Kim Storm) and mcomplete.el (Yuji Minejima).
+
+;; Window managers: Switching frames/focus follows mouse; Sawfish.
+
+;; If you switch to a buffer that is visible in another frame,
+;; iswitchb can switch focus to that frame. If your window manager
+;; uses "click to focus" policy for window selection, you should also
+;; set focus-follows-mouse to nil.
+
+;; iswitch functionality has also been implemented for switching
+;; between windows in the Sawfish window manager.
+
;; Regexp matching
;; There is limited provision for regexp matching within iswitchb,
;;; Code:
-
;; CL needed for cadr and last
-(require 'cl)
+(if (not (and (fboundp 'cadr)
+ (fboundp 'last)))
+ (require 'cl))
;; Set up the custom library.
;; taken from http://www.dina.kvl.dk/~abraham/custom/
;; We have the old custom-library, hack around it!
(defmacro defgroup (&rest args)
nil)
- (defmacro defcustom (var value doc &rest args)
- (` (defvar (, var) (, value) (, doc))))))
+ (defmacro defcustom (var value doc &rest args)
+ `(defvar ,var ,value ,doc))))
;;; User Variables
;;
(defgroup iswitchb nil
"Switch between buffers using substrings."
- :group 'extensions
- ;; These links are to be added in later versions of custom and
- ;; so are currently commented out.
+ :group 'convenience
+ :group 'completion
:link '(emacs-commentary-link :tag "Commentary" "iswitchb.el")
- :link '(emacs-library-link :tag "Lisp File" "iswitchb.el")
-)
-
+ :link '(url-link "http://www.anc.ed.ac.uk/~stephen/emacs/")
+ :link '(emacs-library-link :tag "Lisp File" "iswitchb.el"))
(defcustom iswitchb-case case-fold-search
- "*Non-nil if searching of buffer names should ignore case."
+ "*Non-nil if searching of buffer names should ignore case.
+If this is non-nil but the user input has any upper case letters, matching
+is temporarily case sensitive."
:type 'boolean
:group 'iswitchb)
For example, traditional behavior is not to list buffers whose names begin
with a space, for which the regexp is `^ '. See the source file for
example functions that filter buffernames."
- :type '(repeat regexp)
+ :type '(repeat (choice regexp function))
+ :group 'iswitchb)
+
+(defcustom iswitchb-max-to-show nil
+ "*If non-nil, limit the number of names shown in the minibuffer.
+If this value is N, and N is greater than the number of matching
+buffers, the first N/2 and the last N/2 matching buffers are
+shown. This can greatly speed up iswitchb if you have a
+multitude of buffers open."
+ :type '(choice (const :tag "Show all" nil) integer)
:group 'iswitchb)
+(defcustom iswitchb-use-virtual-buffers nil
+ "*If non-nil, refer to past buffers when none match.
+This feature relies upon the `recentf' package, which will be
+enabled if this variable is configured to a non-nil value."
+ :type 'boolean
+ :require 'recentf
+ :set (function
+ (lambda (sym value)
+ (if value (recentf-mode 1))
+ (set sym value)))
+ :group 'iswitchb)
+
+(defvar iswitchb-virtual-buffers nil)
+
+(defcustom iswitchb-cannot-complete-hook 'iswitchb-completion-help
+ "*Hook run when `iswitchb-complete' can't complete any more.
+The most useful values are `iswitchb-completion-help', which pops up a
+window with completion alternatives, or `iswitchb-next-match' or
+`iswitchb-prev-match', which cycle the buffer list."
+ :type 'hook
+ :group 'iswitchb)
;;; Examples for setting the value of iswitchb-buffer-ignore
;(defun iswitchb-ignore-c-mode (name)
frame or in the other frame.
`always-frame' If a buffer is visible in another frame, raise that
frame. Otherwise, visit the buffer in the same window."
- :type '(choice (const samewindow)
+ :type '(choice (const samewindow)
(const otherwindow)
(const display)
- (const otherframe)
+ (const otherframe)
(const maybe-frame)
(const always-frame))
:group 'iswitchb)
-
(defcustom iswitchb-regexp nil
"*Non-nil means that `iswitchb' will do regexp matching.
Value can be toggled within `iswitchb' using `iswitchb-toggle-regexp'."
:type 'boolean
:group 'iswitchb)
-
(defcustom iswitchb-newbuffer t
"*Non-nil means create new buffer if no buffer matches substring.
See also `iswitchb-prompt-newbuffer'."
:type 'boolean
:group 'iswitchb)
-
(defcustom iswitchb-prompt-newbuffer t
"*Non-nil means prompt user to confirm before creating new buffer.
See also `iswitchb-newbuffer'."
:type 'boolean
:group 'iswitchb)
-
-(defcustom iswitchb-define-mode-map-hook nil
- "*Hook to define keys in `iswitchb-mode-map' for extra keybindings."
- :type 'hook
- :group 'iswitchb)
-
-
-
(defcustom iswitchb-use-fonts t
"*Non-nil means use font-lock fonts for showing first match."
:type 'boolean
:group 'iswitchb)
+(defcustom iswitchb-use-frame-buffer-list nil
+ "*Non-nil means use the currently selected frame's buffer list."
+ :type 'boolean
+ :group 'iswitchb)
(defcustom iswitchb-make-buflist-hook nil
- "*Hook to run when list of matching buffers is created."
+ "Hook to run when list of matching buffers is created."
:type 'hook
:group 'iswitchb)
See documentation of `walk-windows' for useful values.")
(defcustom iswitchb-minibuffer-setup-hook nil
- "*Iswitchb-specific customization of minibuffer setup.
+ "Iswitchb-specific customization of minibuffer setup.
This hook is run during minibuffer setup iff `iswitchb' will be active.
-It is intended for use in customizing iswitchb for interoperation
-with other packages. For instance:
-
- \(add-hook 'iswitchb-minibuffer-setup-hook
- \(function
- \(lambda ()
- \(make-local-variable 'resize-minibuffer-window-max-height)
- \(setq resize-minibuffer-window-max-height 3))))
-
-will constrain rsz-mini to a maximum minibuffer height of 3 lines when
-iswitchb is running. Copied from `icomplete-minibuffer-setup-hook'."
+For instance:
+\(add-hook 'iswitchb-minibuffer-setup-hook
+ '\(lambda () (set (make-local-variable 'max-mini-window-height) 3)))
+will constrain the minibuffer to a maximum height of 3 lines when
+iswitchb is running."
:type 'hook
:group 'iswitchb)
;; Do we need the variable iswitchb-use-mycompletion?
-
;;; Internal Variables
(defvar iswitchb-method nil
- "Stores the method for viewing the selected buffer.
+ "Stores the method for viewing the selected buffer.
Its value is one of `samewindow', `otherwindow', `display', `otherframe',
`maybe-frame' or `always-frame'. See `iswitchb-default-method' for
details of values.")
Copied from `icomplete-eoinput'.")
(make-variable-buffer-local 'iswitchb-eoinput)
-
(defvar iswitchb-buflist nil
"Stores the current list of buffers that will be searched through.
The list is ordered, so that the most recent buffers come first,
;; todo -- is this necessary?
(defvar iswitchb-use-mycompletion nil
- "Non-nil means use `iswitchb-buffer' completion feedback.
+ "Non-nil means use `iswitchb-buffer' completion feedback.
Should only be set to t by iswitchb functions, so that it doesn't
interfere with other minibuffer usage.")
-(defvar iswitchb-change-word-sub nil
+(defvar iswitchb-change-word-sub nil
"Private variable used by `iswitchb-word-matching-substring'.")
(defvar iswitchb-common-match-string nil
(defvar iswitchb-matches nil
"List of buffers currently matching `iswitchb-text'.")
-(defvar iswitchb-mode-map nil
- "Keymap for `iswitchb-buffer'.")
-
-(defvar iswitchb-history nil
+(defvar iswitchb-mode-map
+ (let ((map (make-sparse-keymap)))
+ (set-keymap-parent map minibuffer-local-map)
+ (define-key map "?" 'iswitchb-completion-help)
+ (define-key map "\C-s" 'iswitchb-next-match)
+ (define-key map "\C-r" 'iswitchb-prev-match)
+ (define-key map "\t" 'iswitchb-complete)
+ (define-key map "\C-j" 'iswitchb-select-buffer-text)
+ (define-key map "\C-t" 'iswitchb-toggle-regexp)
+ (define-key map "\C-x\C-f" 'iswitchb-find-file)
+ (define-key map "\C-c" 'iswitchb-toggle-case)
+ (define-key map "\C-k" 'iswitchb-kill-buffer)
+ (define-key map "\C-m" 'iswitchb-exit-minibuffer)
+ map)
+ "Minibuffer keymap for `iswitchb-buffer'.")
+
+(defvar iswitchb-global-map
+ (let ((map (make-sparse-keymap)))
+ (substitute-key-definition 'switch-to-buffer ; normally C-x b
+ 'iswitchb-buffer map global-map)
+ (substitute-key-definition 'switch-to-buffer-other-window ; C-x 4 b
+ 'iswitchb-buffer-other-window map global-map)
+ (substitute-key-definition 'switch-to-buffer-other-frame ; C-x 5 b
+ 'iswitchb-buffer-other-frame map global-map)
+ (substitute-key-definition 'display-buffer ; C-x 4 C-o
+ 'iswitchb-display-buffer map global-map)
+ map)
+ "Global keymap for `iswitchb-mode'.")
+
+(defvar iswitchb-history nil
"History of buffers selected using `iswitchb-buffer'.")
-(defvar iswitchb-exit nil
- "Flag to monitor how `iswitchb-buffer' exits.
+(defvar iswitchb-exit nil
+ "Flag to monitor how `iswitchb-buffer' exits.
If equal to `takeprompt', we use the prompt as the buffer name to be
selected.")
(defvar iswitchb-buffer-ignore-orig nil
"Stores original value of `iswitchb-buffer-ignore'.")
-(defvar iswitchb-xemacs (string-match "XEmacs" (emacs-version))
- "Non-nil if we are running XEmacs. Otherwise, assume we are running Emacs.")
-
(defvar iswitchb-default nil
"Default buffer for iswitchb.")
-;;; FUNCTIONS
+;; The following variables are needed to keep the byte compiler quiet.
+(defvar iswitchb-require-match nil
+ "Non-nil if matching buffer must be selected.")
+
+(defvar iswitchb-temp-buflist nil
+ "Stores a temporary version of the buffer list being created.")
+
+(defvar iswitchb-bufs-in-frame nil
+ "List of the buffers visible in the current frame.")
+(defvar iswitchb-minibuf-depth nil
+ "Value we expect to be returned by `minibuffer-depth' in the minibuffer.")
-;;; ISWITCHB KEYMAP
+;;; FUNCTIONS
+
+;;; ISWITCHB KEYMAP
(defun iswitchb-define-mode-map ()
- "Set up the keymap for `iswitchb-buffer'."
+ "Set up the keymap for `iswitchb-buffer'.
+This is obsolete. Use \\[iswitchb-mode] or customize the
+variable `iswitchb-mode'."
(interactive)
(let (map)
;; generated every time so that it can inherit new functions.
(define-key map "\C-k" 'iswitchb-kill-buffer)
(define-key map "\C-m" 'iswitchb-exit-minibuffer)
(setq iswitchb-mode-map map)
- (run-hooks 'iswitchb-define-mode-map-hook)
- ))
-
-
+ (run-hooks 'iswitchb-define-mode-map-hook)))
;;; MAIN FUNCTION
(defun iswitchb ()
\\[iswitchb-next-match] Put the first element at the end of the list.
\\[iswitchb-prev-match] Put the last element at the start of the list.
-\\[iswitchb-complete] Complete a common suffix to the current string that
+\\[iswitchb-complete] Complete a common suffix to the current string that
matches all buffers. If there is only one match, select that buffer.
If there is no common suffix, show a list of all matching buffers
in a separate window.
\\[iswitchb-toggle-regexp] Toggle regexp searching.
\\[iswitchb-toggle-case] Toggle case-sensitive searching of buffer names.
\\[iswitchb-completion-help] Show list of matching buffers in separate window.
-\\[iswitchb-find-file] Exit iswitchb and drop into find-file.
+\\[iswitchb-find-file] Exit iswitchb and drop into `find-file'.
\\[iswitchb-kill-buffer] Kill buffer at head of buffer list."
;;\\[iswitchb-toggle-ignore] Toggle ignoring certain buffers (see \
;;`iswitchb-buffer-ignore')
-
- (let
- (prompt buf)
-
- (setq prompt (format "iswitch "))
-
- (setq buf (iswitchb-read-buffer prompt))
+ (let* ((prompt "iswitch ")
+ (buf (iswitchb-read-buffer prompt)))
;;(message "chosen text %s" iswitchb-final-text)
;; Choose the buffer name: either the text typed in, or the head
(iswitchb-visit-buffer buf)
;; else buffer doesn't exist
(iswitchb-possible-new-buffer buf)))
- ))
-
- ))
+ ))))
-
-
-(defun iswitchb-read-buffer (prompt &optional default require-match)
+(defun iswitchb-read-buffer (prompt &optional default require-match
+ start matches-set)
"Replacement for the built-in `read-buffer'.
-Return the name of a buffer selected.
-PROMPT is the prompt to give to the user. DEFAULT if given is the default
-buffer to be selected, which will go to the front of the list.
-If REQUIRE-MATCH is non-nil, an existing-buffer must be selected."
+Return the name of a buffer selected.
+PROMPT is the prompt to give to the user.
+DEFAULT if given is the default buffer to be selected, which will
+go to the front of the list.
+If REQUIRE-MATCH is non-nil, an existing-buffer must be selected.
+If START is a string, the selection process is started with that
+string.
+If MATCHES-SET is non-nil, the buflist is not updated before
+the selection process begins. Used by isearchb.el."
(let
(
buf-sel
(iswitchb-define-mode-map)
(setq iswitchb-exit nil)
- (setq iswitchb-rescan t)
- (setq iswitchb-text "")
(setq iswitchb-default
(if (bufferp default)
(buffer-name default)
default))
- (iswitchb-make-buflist iswitchb-default)
- (iswitchb-set-matches)
- (let
+ (setq iswitchb-text (or start ""))
+ (unless matches-set
+ (setq iswitchb-rescan t)
+ (iswitchb-make-buflist iswitchb-default)
+ (iswitchb-set-matches))
+ (let
((minibuffer-local-completion-map iswitchb-mode-map)
- (iswitchb-prepost-hooks t)
- (iswitchb-require-match require-match)
- )
+ ;; Record the minibuffer depth that we expect to find once
+ ;; the minibuffer is set up and iswitchb-entryfn-p is called.
+ (iswitchb-minibuf-depth (1+ (minibuffer-depth)))
+ (iswitchb-require-match require-match))
;; prompt the user for the buffer name
- (setq iswitchb-final-text (completing-read
- prompt ;the prompt
- '(("dummy".1)) ;table
- nil ;predicate
- nil ;require-match [handled elsewhere]
- nil ;initial-contents
+ (setq iswitchb-final-text (completing-read
+ prompt ;the prompt
+ '(("dummy" . 1)) ;table
+ nil ;predicate
+ nil ;require-match [handled elsewhere]
+ start ;initial-contents
'iswitchb-history)))
+ (if (and (not (eq iswitchb-exit 'usefirst))
+ (get-buffer iswitchb-final-text))
+ ;; This happens for example if the buffer was chosen with the mouse.
+ (setq iswitchb-matches (list iswitchb-final-text)
+ iswitchb-virtual-buffers nil))
+
+ ;; If no buffer matched, but a virtual buffer was selected, visit
+ ;; that file now and act as though that buffer had been selected.
+ (if (and iswitchb-virtual-buffers
+ (not (iswitchb-existing-buffer-p)))
+ (let ((virt (car iswitchb-virtual-buffers)))
+ (find-file-noselect (cdr virt))
+ (setq iswitchb-matches (list (car virt))
+ iswitchb-virtual-buffers nil)))
+
;; Handling the require-match must be done in a better way.
- (if (and require-match (not (iswitchb-existing-buffer-p)))
- (error "must specify valid buffer"))
+ (if (and require-match
+ (not (iswitchb-existing-buffer-p)))
+ (error "Must specify valid buffer"))
- (if (or
- (eq iswitchb-exit 'takeprompt)
- (null iswitchb-matches))
+ (if (or (eq iswitchb-exit 'takeprompt)
+ (null iswitchb-matches))
(setq buf-sel iswitchb-final-text)
;; else take head of list
(setq buf-sel (car iswitchb-matches)))
-
+
;; Or possibly choose the default buffer
- (if (equal iswitchb-final-text "")
- (setq buf-sel
- (car iswitchb-matches)))
+ (if (equal iswitchb-final-text "")
+ (setq buf-sel (car iswitchb-matches)))
buf-sel))
-
(defun iswitchb-existing-buffer-p ()
"Return non-nil if there is a matching buffer."
(not (null iswitchb-matches)))
(if (setq val (iswitchb-find-common-substring
iswitchb-matches iswitchb-text))
(setq iswitchb-common-match-string val)))
- val
- ))
-
+ val))
(defun iswitchb-complete ()
"Try and complete the current pattern amongst the buffer names."
(interactive)
(let (res)
(cond ((not iswitchb-matches)
- (iswitchb-completion-help)
- )
-
+ (run-hooks 'iswitchb-cannot-complete-hook))
+
((= 1 (length iswitchb-matches))
;; only one choice, so select it.
(exit-minibuffer))
-
+
(t
;; else there could be some completions
(setq res iswitchb-common-match-string)
;; found something to complete, so put it in the minibuffer.
(progn
(setq iswitchb-rescan nil)
- (delete-region (point-min) (point))
+ (delete-region (minibuffer-prompt-end) (point))
(insert res))
;; else nothing to complete
- (iswitchb-completion-help)
- )
- )
- )))
-
-
+ (run-hooks 'iswitchb-cannot-complete-hook)
+ )))))
;;; TOGGLE FUNCTIONS
(defun iswitchb-toggle-case ()
- "Toggle the value of `iswitchb-case'."
+ "Toggle the value of variable `iswitchb-case'."
(interactive)
(setq iswitchb-case (not iswitchb-case))
;; ask for list to be regenerated.
- (setq iswitchb-rescan t)
- )
+ (setq iswitchb-rescan t))
(defun iswitchb-toggle-regexp ()
"Toggle the value of `iswitchb-regexp'."
(interactive)
(setq iswitchb-regexp (not iswitchb-regexp))
;; ask for list to be regenerated.
- (setq iswitchb-rescan t)
- )
-
+ (setq iswitchb-rescan t))
(defun iswitchb-toggle-ignore ()
"Toggle ignoring buffers specified with `iswitchb-buffer-ignore'."
(if iswitchb-buffer-ignore
(progn
(setq iswitchb-buffer-ignore-orig iswitchb-buffer-ignore)
- (setq iswitchb-buffer-ignore nil)
- )
+ (setq iswitchb-buffer-ignore nil))
;; else
- (setq iswitchb-buffer-ignore iswitchb-buffer-ignore-orig)
- )
+ (setq iswitchb-buffer-ignore iswitchb-buffer-ignore-orig))
(iswitchb-make-buflist iswitchb-default)
;; ask for list to be regenerated.
- (setq iswitchb-rescan t)
- )
+ (setq iswitchb-rescan t))
(defun iswitchb-exit-minibuffer ()
"Exit minibuffer, but make sure we have a match if one is needed."
(interactive)
(if (or (not iswitchb-require-match)
(iswitchb-existing-buffer-p))
- (throw 'exit nil)
- ))
+ (progn
+ (setq iswitchb-exit 'usefirst)
+ (throw 'exit nil))))
(defun iswitchb-select-buffer-text ()
"Select the buffer named by the prompt.
(setq iswitchb-exit 'takeprompt)
(exit-minibuffer))
-
-
(defun iswitchb-find-file ()
- "Drop into find-file from buffer switching."
+ "Drop into `find-file' from buffer switching."
(interactive)
(setq iswitchb-exit 'findfile)
(exit-minibuffer))
-(defun iswitchb-next-match ()
+(eval-when-compile
+ (defvar recentf-list))
+
+(defun iswitchb-next-match ()
"Put first element of `iswitchb-matches' at the end of the list."
(interactive)
(let ((next (cadr iswitchb-matches)))
- (setq iswitchb-buflist (iswitchb-chop iswitchb-buflist next))
- (setq iswitchb-rescan t)
- ))
-
-(defun iswitchb-prev-match ()
+ (if (and (null next) iswitchb-virtual-buffers)
+ (setq recentf-list
+ (iswitchb-chop recentf-list
+ (cdr (cadr iswitchb-virtual-buffers))))
+ (setq iswitchb-buflist (iswitchb-chop iswitchb-buflist next)))
+ (setq iswitchb-rescan t)))
+
+(defun iswitchb-prev-match ()
"Put last element of `iswitchb-matches' at the front of the list."
(interactive)
(let ((prev (car (last iswitchb-matches))))
- (setq iswitchb-buflist (iswitchb-chop iswitchb-buflist prev))
- (setq iswitchb-rescan t)
- ))
-
-
-
+ (if (and (null prev) iswitchb-virtual-buffers)
+ (setq recentf-list
+ (iswitchb-chop recentf-list
+ (cdr (car (last iswitchb-virtual-buffers)))))
+ (setq iswitchb-buflist (iswitchb-chop iswitchb-buflist prev)))
+ (setq iswitchb-rescan t)))
(defun iswitchb-chop (list elem)
"Remove all elements before ELEM and put them at the end of LIST."
(setq sofar (cons next sofar)))))
ret))
-
-
-
;;; CREATE LIST OF ALL CURRENT BUFFERS
-
(defun iswitchb-make-buflist (default)
"Set `iswitchb-buflist' to the current list of buffers.
Currently visible buffers are put at the end of the list.
-The hook `iswitchb-make-buflist-hook' is run after the list has been
+The hook `iswitchb-make-buflist-hook' is run after the list has been
created to allow the user to further modify the order of the buffer names
in this list. If DEFAULT is non-nil, and corresponds to an existing buffer,
it is put to the start of the list."
- (setq iswitchb-buflist
+ (setq iswitchb-buflist
(let* ((iswitchb-current-buffers (iswitchb-get-buffers-in-frames))
- (buflist
- (delq nil
- (mapcar
- (lambda (x)
- (let ((b-name (buffer-name x)))
- (if (not
- (or
- (iswitchb-ignore-buffername-p b-name)
- (memq b-name iswitchb-current-buffers)))
- b-name)))
- (buffer-list)))))
- (nconc buflist iswitchb-current-buffers)
+ (iswitchb-temp-buflist
+ (delq nil
+ (mapcar
+ (lambda (x)
+ (let ((b-name (buffer-name x)))
+ (if (not
+ (or
+ (iswitchb-ignore-buffername-p b-name)
+ (memq b-name iswitchb-current-buffers)))
+ b-name)))
+ (buffer-list (and iswitchb-use-frame-buffer-list
+ (selected-frame)))))))
+ (setq iswitchb-temp-buflist
+ (nconc iswitchb-temp-buflist iswitchb-current-buffers))
(run-hooks 'iswitchb-make-buflist-hook)
- ;; Should this be after the hooks, or should the hooks be the
+ ;; Should this be after the hooks, or should the hooks be the
;; final thing to be run?
(if default
(progn
- (setq buflist (delete default buflist))
- (setq buflist (cons default buflist))
- ))
- buflist)))
+ (setq iswitchb-temp-buflist
+ (delete default iswitchb-temp-buflist))
+ (setq iswitchb-temp-buflist
+ (cons default iswitchb-temp-buflist))))
+ iswitchb-temp-buflist)))
(defun iswitchb-to-end (lst)
- "Move the elements from LST to the end of BUFLIST."
- (mapcar
- (lambda (elem)
- (setq buflist (delq elem buflist)))
+ "Move the elements from LST to the end of `iswitchb-temp-buflist'."
+ (mapcar
+ (lambda (elem)
+ (setq iswitchb-temp-buflist (delq elem iswitchb-temp-buflist)))
lst)
- (nconc buflist lst))
-
-
+ (setq iswitchb-temp-buflist (nconc iswitchb-temp-buflist lst)))
(defun iswitchb-get-buffers-in-frames (&optional current)
"Return the list of buffers that are visible in the current frame.
-If optional argument `current' is given, restrict searching to the
+If optional argument CURRENT is given, restrict searching to the
current frame, rather than all frames, regardless of value of
`iswitchb-all-frames'."
(let ((iswitchb-bufs-in-frame nil))
(walk-windows 'iswitchb-get-bufname nil
- (if current
+ (if current
nil
iswitchb-all-frames))
iswitchb-bufs-in-frame))
-
(defun iswitchb-get-bufname (win)
"Used by `iswitchb-get-buffers-in-frames' to walk through all windows."
(let ((buf (buffer-name (window-buffer win))))
(setq iswitchb-bufs-in-frame
(cons buf iswitchb-bufs-in-frame)))))
-
;;; FIND MATCHING BUFFERS
-
(defun iswitchb-set-matches ()
"Set `iswitchb-matches' to the list of buffers matching prompt."
(if iswitchb-rescan
(setq iswitchb-matches
- (let* ((buflist iswitchb-buflist)
- )
+ (let* ((buflist iswitchb-buflist))
(iswitchb-get-matched-buffers iswitchb-text iswitchb-regexp
- buflist)))))
+ buflist))
+ iswitchb-virtual-buffers nil)))
(defun iswitchb-get-matched-buffers (regexp
&optional string-format buffer-list)
"Return buffers matching REGEXP.
If STRING-FORMAT is nil, consider REGEXP as just a string.
BUFFER-LIST can be list of buffers or list of strings."
- (let* ((case-fold-search iswitchb-case)
+ (let* ((case-fold-search (iswitchb-case))
;; need reverse since we are building up list backwards
(list (reverse buffer-list))
(do-string (stringp (car list)))
name
- ret
- )
+ ret)
(mapcar
(lambda (x)
-
+
(if do-string
(setq name x) ;We already have the name
(setq name (buffer-name x)))
-
+
(cond
((and (or (and string-format (string-match regexp name))
(and (null string-format)
(string-match (regexp-quote regexp) name)))
-
- (not (iswitchb-ignore-buffername-p name))
- )
+
+ (not (iswitchb-ignore-buffername-p name)))
(setq ret (cons name ret))
)))
list)
- ret
- ))
-
-
-
+ ret))
(defun iswitchb-ignore-buffername-p (bufname)
"Return t if the buffer BUFNAME should be ignored."
(let ((data (match-data))
(re-list iswitchb-buffer-ignore)
ignorep
- nextstr
- )
+ nextstr)
(while re-list
(setq nextstr (car re-list))
(cond
(if (funcall nextstr bufname)
(progn
(setq ignorep t)
- (setq re-list nil))
- ))
- )
+ (setq re-list nil)))))
(setq re-list (cdr re-list)))
(set-match-data data)
;; return the result
- ignorep)
- )
+ ignorep))
(defun iswitchb-word-matching-substring (word)
"Return part of WORD before 1st match to `iswitchb-change-word-sub'.
If `iswitchb-change-word-sub' cannot be found in WORD, return nil."
- (let ((case-fold-search iswitchb-case))
+ (let ((case-fold-search (iswitchb-case)))
(let ((m (string-match iswitchb-change-word-sub word)))
(if m
(substring word m)
"Return common string following SUBS in each element of LIS."
(let (res
alist
- iswitchb-change-word-sub
- )
+ iswitchb-change-word-sub)
(setq iswitchb-change-word-sub
(if iswitchb-regexp
subs
(setq alist (mapcar 'iswitchb-makealist res)) ;; could use an OBARRAY
;; try-completion returns t if there is an exact match.
- (let ((completion-ignore-case iswitchb-case))
-
- (try-completion subs alist)
- )))
+ (let ((completion-ignore-case (iswitchb-case)))
+ (try-completion subs alist))))
(defun iswitchb-makealist (res)
"Return dotted pair (RES . 1)."
;; from Wayne Mesard <wmesard@esd.sgi.com>
(defun iswitchb-rotate-list (lis)
- "Destructively removes the last element from LIS.
+ "Destructively remove the last element from LIS.
Return the modified list with the last element prepended to it."
(if (<= (length lis) 1)
lis
(setq prev las
las (cdr las)))
(setcdr prev nil)
- (cons (car las) lis))
- ))
-
+ (cons (car las) lis))))
(defun iswitchb-completion-help ()
- "Show possible completions in a *Buffer Completions* buffer."
+ "Show possible completions in a *Completions* buffer."
;; we could allow this buffer to be used to select match, but I think
;; choose-completion-string will need redefining, so it just inserts
- ;; choice with out any previous input.
+ ;; choice with out any previous input.
(interactive)
(setq iswitchb-rescan nil)
- (let ((completion-setup-hook nil) ;disable fancy highlight/selection.
- (buf (current-buffer))
- (temp-buf "*Buffer Completions*")
- (win)
- (again (eq last-command this-command)))
+ (let ((buf (current-buffer))
+ (temp-buf "*Completions*")
+ (win))
- (if again
+ (if (eq last-command this-command)
;; scroll buffer
(progn
(set-buffer temp-buf)
(if (pos-visible-in-window-p (point-max) win)
(set-window-start win (point-min))
(scroll-other-window))
- (set-buffer buf)
- )
+ (set-buffer buf))
-
(with-output-to-temp-buffer temp-buf
- (if iswitchb-xemacs
-
+ (if (featurep 'xemacs)
+
;; XEmacs extents are put on by default, doesn't seem to be
;; any way of switching them off.
(display-completion-list (if iswitchb-matches
iswitchb-matches
iswitchb-buflist)
:help-string "iswitchb "
- :activate-callback
- '(lambda (x y z)
- (message "doesn't work yet, sorry!")))
+ :activate-callback
+ (lambda (x y z)
+ (message "doesn't work yet, sorry!")))
;; else running Emacs
+ (with-current-buffer standard-output
+ (fundamental-mode))
(display-completion-list (if iswitchb-matches
- iswitchb-matches
+ iswitchb-matches
iswitchb-buflist))
)))))
-
-
;;; KILL CURRENT BUFFER
(defun iswitchb-kill-buffer ()
;; killed, so we can't rely on kill-buffer return value.
(if (get-buffer buf)
;; buffer couldn't be killed.
- (setq iswitchb-rescan t)
+ (setq iswitchb-rescan t)
;; else buffer was killed so remove name from list.
(setq iswitchb-buflist (delq buf iswitchb-buflist)))))))
-
;;; VISIT CHOSEN BUFFER
(defun iswitchb-visit-buffer (buffer)
"Visit buffer named BUFFER according to `iswitchb-method'."
(or (eq iswitchb-method 'always-frame)
(y-or-n-p "Jump to frame? ")))
(setq newframe (window-frame win))
- (raise-frame newframe)
- (select-frame newframe)
- (select-window win)
- (if (not iswitchb-xemacs)
- ;; reposition mouse to make frame active. not needed in XEmacs
- ;; This line came from the other-frame defun in Emacs.
- (set-mouse-position (selected-frame) (1- (frame-width)) 0))
- )
+ (if (fboundp 'select-frame-set-input-focus)
+ (select-frame-set-input-focus newframe)
+ (raise-frame newframe)
+ (select-frame newframe)
+ )
+ (select-window win))
(t
;; No buffer in other frames...
(switch-to-buffer buffer)
)))
-
-
((eq iswitchb-method 'otherwindow)
(switch-to-buffer-other-window buffer))
((eq iswitchb-method 'otherframe)
(progn
(switch-to-buffer-other-frame buffer)
- (if (not iswitchb-xemacs)
- (set-mouse-position (selected-frame) (1- (frame-width)) 0))
- )
- ) )))
+ (if (fboundp 'select-frame-set-input-focus)
+ (select-frame-set-input-focus (selected-frame)))
+ )))))
(defun iswitchb-possible-new-buffer (buf)
"Possibly create and visit a new buffer called BUF."
(if (and iswitchb-newbuffer
(or
(not iswitchb-prompt-newbuffer)
-
+
(and iswitchb-prompt-newbuffer
(y-or-n-p
(format
(set-buffer-major-mode newbufcreated))
(iswitchb-visit-buffer newbufcreated))
;; else wont create new buffer
- (message (format "no buffer matching `%s'" buf))
- )))
+ (message (format "no buffer matching `%s'" buf)))))
(defun iswitchb-window-buffer-p (buffer)
"Return window pointer if BUFFER is visible in another frame.
(get-buffer-window buffer 0) ; better than 'visible
)))
-;;;###autoload
(defun iswitchb-default-keybindings ()
"Set up default keybindings for `iswitchb-buffer'.
-Call this function to override the normal bindings."
- (interactive)
- (global-set-key (read-kbd-macro "C-x b") 'iswitchb-buffer)
- (global-set-key (read-kbd-macro "C-x 4 b") 'iswitchb-buffer-other-window)
- (global-set-key (read-kbd-macro "C-x 4 C-o") 'iswitchb-display-buffer)
- (global-set-key (read-kbd-macro "C-x 5 b") 'iswitchb-buffer-other-frame))
+Call this function to override the normal bindings. This function also
+adds a hook to the minibuffer.
+Obsolescent. Use `iswitchb-mode'."
+ (interactive)
+ (add-hook 'minibuffer-setup-hook 'iswitchb-minibuffer-setup)
+ (global-set-key "\C-xb" 'iswitchb-buffer)
+ (global-set-key "\C-x4b" 'iswitchb-buffer-other-window)
+ (global-set-key "\C-x4\C-o" 'iswitchb-display-buffer)
+ (global-set-key "\C-x5b" 'iswitchb-buffer-other-frame))
-;;;###autoload
(defun iswitchb-buffer ()
"Switch to another buffer.
(setq iswitchb-method iswitchb-default-method)
(iswitchb))
-
-;;;###autoload
(defun iswitchb-buffer-other-window ()
"Switch to another buffer and show it in another window.
The buffer name is selected interactively by typing a substring.
(setq iswitchb-method 'otherwindow)
(iswitchb))
-
-
-;;;###autoload
(defun iswitchb-display-buffer ()
"Display a buffer in another window but don't select it.
The buffer name is selected interactively by typing a substring.
(setq iswitchb-method 'display)
(iswitchb))
-
-
-;;;###autoload
(defun iswitchb-buffer-other-frame ()
"Switch to another buffer and show it in another frame.
The buffer name is selected interactively by typing a substring.
(iswitchb-exhibit)
(goto-char (point-min)))))
-
;; add this hook for XEmacs only.
-(if iswitchb-xemacs
- (add-hook 'iswitchb-minibuffer-setup-hook
+(if (featurep 'xemacs)
+ (add-hook 'iswitchb-minibuffer-setup-hook
'iswitchb-init-XEmacs-trick))
-
;;; XEmacs / backspace key
;; For some reason, if the backspace key is pressed in XEmacs, the
;; line gets confused, so I've added a simple key definition to make
-;; backspace act like the normal delete key.
+;; backspace act like the normal delete key.
(defun iswitchb-xemacs-backspacekey ()
"Bind backspace to `backward-delete-char'."
(define-key iswitchb-mode-map '[backspace] 'backward-delete-char)
- (define-key iswitchb-mode-map '[(meta backspace)] 'backward-kill-word)
- )
-
+ (define-key iswitchb-mode-map '[(meta backspace)] 'backward-kill-word))
-(if iswitchb-xemacs
- (add-hook 'iswitchb-define-mode-map-hook
+(if (featurep 'xemacs)
+ (add-hook 'iswitchb-define-mode-map-hook
'iswitchb-xemacs-backspacekey))
-
-
;;; ICOMPLETE TYPE CODE
(defun iswitchb-exhibit ()
Copied from `icomplete-exhibit' with two changes:
1. It prints a default buffer name when there is no text yet entered.
2. It calls my completion routine rather than the standard completion."
-
(if iswitchb-use-mycompletion
- (let ((contents (buffer-substring (point-min)(point-max)))
+ (let ((contents (buffer-substring (minibuffer-prompt-end) (point-max)))
(buffer-undo-list t))
(save-excursion
(goto-char (point-max))
(iswitchb-set-common-completion)
;; Insert the match-status information:
- (insert-string
- (iswitchb-completions
- contents
- minibuffer-completion-table
- minibuffer-completion-predicate
- (not minibuffer-completion-confirm)))
- ))))
-
-
-
-(defun iswitchb-completions
- (name candidates predicate require-match)
+ (insert (iswitchb-completions
+ contents
+ (not minibuffer-completion-confirm)))))))
+
+(eval-when-compile
+ (defvar most-len)
+ (defvar most-is-exact))
+
+(defun iswitchb-output-completion (com)
+ (if (= (length com) most-len)
+ ;; Most is one exact match,
+ ;; note that and leave out
+ ;; for later indication:
+ (ignore
+ (setq most-is-exact t))
+ (substring com most-len)))
+
+(defun iswitchb-completions (name require-match)
"Return the string that is displayed after the user's text.
Modified from `icomplete-completions'."
-
+
(let ((comps iswitchb-matches)
; "-determined" - only one candidate
(open-bracket-determined (if require-match "(" "["))
;"-prospects" - more than one candidate
(open-bracket-prospects "{")
(close-bracket-prospects "}")
- first
- )
+ first)
(if (and iswitchb-use-fonts comps)
(progn
(setq first (car comps))
(setq first (format "%s" first))
(put-text-property 0 (length first) 'face
- (if (= (length comps) 1)
+ (if (= (length comps) 1)
'font-lock-comment-face
'font-lock-function-name-face)
- first)
- (setq comps (cons first (cdr comps)))
- ))
+ first)
+ (setq comps (cons first (cdr comps)))))
+
+ ;; If no buffers matched, and virtual buffers are being used, then
+ ;; consult the list of past visited files, to see if we can find
+ ;; the file which the user might thought was still open.
+ (when (and iswitchb-use-virtual-buffers (null comps)
+ recentf-list)
+ (setq iswitchb-virtual-buffers nil)
+ (let ((head recentf-list) name)
+ (while head
+ (if (and (setq name (file-name-nondirectory (car head)))
+ (string-match (if iswitchb-regexp
+ iswitchb-text
+ (regexp-quote iswitchb-text)) name)
+ (null (get-file-buffer (car head)))
+ (not (assoc name iswitchb-virtual-buffers))
+ (not (iswitchb-ignore-buffername-p name))
+ (file-exists-p (car head)))
+ (setq iswitchb-virtual-buffers
+ (cons (cons name (car head))
+ iswitchb-virtual-buffers)))
+ (setq head (cdr head)))
+ (setq iswitchb-virtual-buffers (nreverse iswitchb-virtual-buffers)
+ comps (mapcar 'car iswitchb-virtual-buffers))
+ (let ((comp comps))
+ (while comp
+ (put-text-property 0 (length (car comp))
+ 'face 'font-lock-builtin-face
+ (car comp))
+ (setq comp (cdr comp))))))
(cond ((null comps) (format " %sNo match%s"
open-bracket-determined
(concat (if (and (> (length (car comps))
(length name)))
(concat open-bracket-determined
- ;; when there is one match, show the
+ ;; when there is one match, show the
;; matching buffer name in full
(car comps)
close-bracket-determined)
"")
- (if (not iswitchb-use-fonts) " [Matched]")
- ))
+ (if (not iswitchb-use-fonts) " [Matched]")))
(t ;multiple matches
+ (if (and iswitchb-max-to-show
+ (> (length comps) iswitchb-max-to-show))
+ (setq comps
+ (append
+ (let ((res nil)
+ (comp comps)
+ (end (/ iswitchb-max-to-show 2)))
+ (while (>= (setq end (1- end)) 0)
+ (setq res (cons (car comp) res)
+ comp (cdr comp)))
+ (nreverse res))
+ (list "...")
+ (nthcdr (- (length comps)
+ (/ iswitchb-max-to-show 2)) comps))))
(let* (
;;(most (try-completion name candidates predicate))
(most nil)
(most-len (length most))
most-is-exact
- first
(alternatives
- (apply
- (function concat)
- (cdr (apply
- (function nconc)
- (mapcar '(lambda (com)
- (if (= (length com) most-len)
- ;; Most is one exact match,
- ;; note that and leave out
- ;; for later indication:
- (progn
- (setq most-is-exact t)
- ())
- (list ","
- (substring com
- most-len))))
- comps))))))
+ (mapconcat (if most 'iswitchb-output-completion
+ 'identity) comps ",")))
(concat
;; put in common completion item -- what you get by
;; pressing tab
- (if (> (length iswitchb-common-match-string) (length name))
+ (if (and (stringp iswitchb-common-match-string)
+ (> (length iswitchb-common-match-string) (length name)))
(concat open-bracket-determined
- (substring iswitchb-common-match-string
+ (substring iswitchb-common-match-string
(length name))
- close-bracket-determined)
- )
+ close-bracket-determined))
;; end of partial matches...
;; think this bit can be ignored.
(concat open-bracket-determined
(substring most (length name))
close-bracket-determined))
-
+
;; list all alternatives
open-bracket-prospects
(if most-is-exact
(concat "," alternatives)
alternatives)
- close-bracket-prospects)))
- )))
+ close-bracket-prospects))))))
(defun iswitchb-minibuffer-setup ()
"Set up minibuffer for `iswitchb-buffer'.
Copied from `icomplete-minibuffer-setup-hook'."
- (if (iswitchb-entryfn-p)
- (progn
-
- (make-local-variable 'iswitchb-use-mycompletion)
- (setq iswitchb-use-mycompletion t)
- (make-local-hook 'pre-command-hook)
- (add-hook 'pre-command-hook
- 'iswitchb-pre-command
- nil t)
- (make-local-hook 'post-command-hook)
- (add-hook 'post-command-hook
- 'iswitchb-post-command
- nil t)
-
- (run-hooks 'iswitchb-minibuffer-setup-hook)
- )
- ))
-
+ (when (iswitchb-entryfn-p)
+ (set (make-local-variable 'iswitchb-use-mycompletion) t)
+ (add-hook 'pre-command-hook 'iswitchb-pre-command nil t)
+ (add-hook 'post-command-hook 'iswitchb-post-command nil t)
+ (run-hooks 'iswitchb-minibuffer-setup-hook)))
(defun iswitchb-pre-command ()
"Run before command in `iswitchb-buffer'."
(iswitchb-tidy))
-
(defun iswitchb-post-command ()
"Run after command in `iswitchb-buffer'."
- (iswitchb-exhibit)
- )
-
-
+ (iswitchb-exhibit))
(defun iswitchb-tidy ()
"Remove completions display, if any, prior to new user input.
(if (and (boundp 'iswitchb-eoinput)
iswitchb-eoinput)
-
+
(if (> iswitchb-eoinput (point-max))
;; Oops, got rug pulled out from under us - reinit:
(setq iswitchb-eoinput (point-max))
(let ((buffer-undo-list buffer-undo-list )) ; prevent entry
(delete-region iswitchb-eoinput (point-max))))
-
+
;; Reestablish the local variable 'cause minibuffer-setup is weird:
(make-local-variable 'iswitchb-eoinput)
(setq iswitchb-eoinput 1)))
-
(defun iswitchb-entryfn-p ()
- "Return non-nil if `this-command' shows we are using `iswitchb-buffer'."
- (or (boundp 'iswitchb-prepost-hooks)
- ;; I think the of this may be redundant, since the prepost hooks
- ;; will always be set in the iswitchb defuns.
- ;;(and (symbolp this-command) ; ignore lambda functions
- ;;(memq this-command
- ;; '(iswitchb-buffer
- ;; iswitchb-buffer-other-frame
- ;; iswitchb-display-buffer
- ;; iswitchb-buffer-other-window))))
- ))
-
-
-
-
+ "Return non-nil if we are using `iswitchb-buffer'."
+ (eq iswitchb-minibuf-depth (minibuffer-depth)))
(defun iswitchb-summaries-to-end ()
"Move the summaries to the end of the list.
This is an example function which can be hooked on to
`iswitchb-make-buflist-hook'. Any buffer matching the regexps
`Summary' or `output\*$'are put to the end of the list."
- (let ((summaries (delq nil (mapcar
- (lambda (x)
- (if (or
- (string-match "Summary" x)
- (string-match "output\\*$" x))
- x))
- buflist)
- )))
-
+ (let ((summaries (delq nil
+ (mapcar
+ (lambda (x)
+ (if (string-match "Summary\\|output\\*$" x)
+ x))
+ iswitchb-temp-buflist))))
(iswitchb-to-end summaries)))
+(defun iswitchb-case ()
+ "Return non-nil iff we should ignore case when matching.
+See the variable `iswitchb-case' for details."
+ (if iswitchb-case
+ (if (featurep 'xemacs)
+ (isearch-no-upper-case-p iswitchb-text)
+ (isearch-no-upper-case-p iswitchb-text t))))
-
-;;; HOOKS
-(add-hook 'minibuffer-setup-hook 'iswitchb-minibuffer-setup)
+;;;###autoload
+(define-minor-mode iswitchb-mode
+ "Toggle Iswitchb global minor mode.
+With arg, turn Iswitchb mode on if and only iff ARG is positive.
+This mode enables switching between buffers using substrings. See
+`iswitchb' for details."
+ nil nil iswitchb-global-map :global t :group 'iswitchb
+ (if iswitchb-mode
+ (add-hook 'minibuffer-setup-hook 'iswitchb-minibuffer-setup)
+ (remove-hook 'minibuffer-setup-hook 'iswitchb-minibuffer-setup)))
(provide 'iswitchb)
+;;; arch-tag: d74198ae-753f-44f2-b34f-0c515398d90a
;;; iswitchb.el ends here