;;; iswitchb.el --- switch between buffers using substrings
-;; Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+;; Copyright (C) 1996, 1997, 2000 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@anc.ed.ac.uk>
+;; Maintainer: Stephen Eglen <stephen@anc.ed.ac.uk>
+;; 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'.
;; 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
;;
-;; iswitch {123456,123}
+;; iswitch {123456,123}
;;
;; If I then press 2:
;; iswitch 2[3]{123456,123}
;; 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:
+;; will get "3" added to my input. So, press TAB:
;; iswitch 23{123456,123}
;;
;; At this point, I still have two matching buffers.
;; 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:
+;;
+;; 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
;; (define-key iswitchb-mode-map " " 'iswitchb-next-match)
;; )
;;
-;; Seeing all the matching buffers.
+;; 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
;; only shows a certain number of lines -- see the documentation for
;; `iswitchb-minibuffer-setup-hook'.
-
-;; Changing the list of buffers.
+;; Changing the list of buffers
;; By default, the list of current buffers is most recent first,
;; oldest last, with the exception that the buffers visible in the
;; 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.
+;; 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
;; (setq read-buffer-function 'iswitchb-read-buffer)
;; (This variable should be present 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.
+;; Regexp matching
+
+;; There is limited provision for regexp matching within iswitchb,
+;; enabled through `iswitchb-regexp'. This allows you to type `c$'
+;; for example and see all buffer names ending in `c'. This facility
+;; is quite limited though in two respects. First, you can't
+;; currently type in expressions like `[0-9]' directly -- you have to
+;; type them in when iswitchb-regexp is nil and then toggle on the
+;; regexp functionality. Likewise, don't enter an expression
+;; containing `\' in regexp mode. If you try, iswitchb gets confused,
+;; so just hit C-g and try again. Secondly, no completion mechanism
+;; is currently offered when regexp searching.
+
;;; TODO
;;; Acknowledgements
;;; 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"))
+;;;###autoload
+(defcustom iswitchb-mode nil
+ "Toggle Iswitchb mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `iswitchb-mode'."
+ :set (lambda (symbol value)
+ (iswitchb-mode (or value 0)))
+ :initialize 'custom-initialize-default
+ :group 'iswitchb
+ :require 'iswitchb
+ :version "21.1"
+ :type 'boolean)
+
+(defcustom iswitchb-mode-hook nil
+ "Hook run at the end of function `iswitchb-mode'."
+ :group 'iswitchb
+ :type 'hook)
(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)
:type '(repeat regexp)
:group 'iswitchb)
-
;;; Examples for setting the value of iswitchb-buffer-ignore
-;(defun -c-mode (name)
+;(defun iswitchb-ignore-c-mode (name)
; "Ignore all c mode buffers -- example function for iswitchb."
; (save-excursion
; (set-buffer name)
; (string-match "^C$" mode-name)))
-;(setq iswitchb-buffer-ignore '("^ " ignore-c-mode))
+;(setq iswitchb-buffer-ignore '("^ " iswitchb-ignore-c-mode))
;(setq iswitchb-buffer-ignore '("^ " "\\.c$" "\\.h$"))
(defcustom iswitchb-default-method 'always-frame
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'."
+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."
+ "Hook to define keys in `iswitchb-mode-map' for extra keybindings."
:type 'hook
:group 'iswitchb)
-
-
(defcustom iswitchb-use-fonts t
- "*Non-nil means use fonts for showing first match."
+ "*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)
-
-
-(defvar iswitchb-method nil
- "*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.")
-
(defvar iswitchb-all-frames 'visible
"*Argument to pass to `walk-windows' when finding visible buffers.
See documentation of `walk-windows' for useful values.")
-
-
-;; Do we need the variable iswitchb-use-mycompletion?
-
-
-;;; Internal Variables
-(defvar iswitchb-minibuffer-setup-hook nil
+(defcustom iswitchb-minibuffer-setup-hook nil
"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:
+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))))
+;;; \(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'.")
+;;; will constrain rsz-mini to a maximum minibuffer height of 3 lines when
+;;; iswitchb is running. Copied from `icomplete-minibuffer-setup-hook'."
+ :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.
+Its value is one of `samewindow', `otherwindow', `display', `otherframe',
+`maybe-frame' or `always-frame'. See `iswitchb-default-method' for
+details of values.")
(defvar iswitchb-eoinput 1
"Point where minibuffer input ends and completion info begins.
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
"Stores the string that is common to all matching buffers.")
-
(defvar iswitchb-rescan nil
"Non-nil means we need to regenerate the list of matching buffers.")
(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 `iswtichb-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-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.")
+
+;;; FUNCTIONS
-;;; ISWITCHB KEYMAP
+;;; 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 ()
"Switch to buffer matching a substring.
\\[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')
(setq buf (iswitchb-read-buffer prompt))
-
;;(message "chosen text %s" iswitchb-final-text)
;; Choose the buffer name: either the text typed in, or the head
;; of the list of matches
(iswitchb-visit-buffer buf)
;; else buffer doesn't exist
(iswitchb-possible-new-buffer buf)))
- ))
-
- ))
-
-
+ ))))
+;;;###autoload
(defun iswitchb-read-buffer (prompt &optional default require-match)
"Replacement for the built-in `read-buffer'.
-Return the name of a buffer 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."
(setq iswitchb-exit nil)
(setq iswitchb-rescan t)
(setq iswitchb-text "")
- (iswitchb-make-buflist
- (if (bufferp default)
- (buffer-name default)
- default))
+ (setq iswitchb-default
+ (if (bufferp default)
+ (buffer-name default)
+ default))
+ (iswitchb-make-buflist iswitchb-default)
(iswitchb-set-matches)
- (let
+ (let
((minibuffer-local-completion-map iswitchb-mode-map)
(iswitchb-prepost-hooks t)
- (iswitchb-require-match require-match)
- )
+ (iswitchb-require-match require-match))
;; prompt the user for the buffer name
- (setq iswitchb-final-text (completing-read
+ (setq iswitchb-final-text (completing-read
prompt ;the prompt
- '(("dummy".1)) ;table
+ '(("dummy" . 1)) ;table
nil ;predicate
nil ;require-match [handled elsewhere]
nil ;initial-contents
'iswitchb-history)))
;; 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"))
+ (error "Must specify valid buffer"))
- (if (or
+ (if (or
(eq iswitchb-exit 'takeprompt)
(null iswitchb-matches))
(setq buf-sel iswitchb-final-text)
(setq buf-sel (car iswitchb-matches)))
;; Or possibly choose the default buffer
- (if (equal iswitchb-final-text "")
- (setq buf-sel
+ (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)))
(let* (val)
(setq iswitchb-common-match-string nil)
(if (and iswitchb-matches
+ (not iswitchb-regexp) ;; testing
(stringp iswitchb-text)
(> (length iswitchb-text) 0))
(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)
- )
+ (iswitchb-completion-help))
((= 1 (length iswitchb-matches))
;; only one choice, so select it.
(t
;; else there could be some completions
-
- (setq res (iswitchb-find-common-substring
- iswitchb-matches iswitchb-text))
+ (setq res iswitchb-common-match-string)
(if (and (not (memq res '(t nil)))
(not (equal res iswitchb-text)))
;; 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)
- )
- )
- )))
-
-
+ )))))
;;; 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)
- ))
+ (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 ()
+(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)
- ))
+ (setq iswitchb-rescan t)))
-(defun iswitchb-prev-match ()
+(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)
- ))
-
-
-
+ (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
+ (iswitchb-temp-buflist
+ (delq nil
(mapcar
(lambda (x)
(let ((b-name (buffer-name x)))
- (if (not
- (or
+ (if (not
+ (or
(iswitchb-ignore-buffername-p b-name)
(memq b-name iswitchb-current-buffers)))
b-name)))
- (buffer-list)))))
- (nconc buflist iswitchb-current-buffers)
+ (buffer-list (and iswitchb-use-frame-buffer-list
+ (selected-frame)))))))
+ (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
;; 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))
-
-
+ (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)))))
(defun iswitchb-get-matched-buffers (regexp
&optional string-format buffer-list)
- "Return buffers matching REGEXP.
-If STRING-FORMAT is non-nil, consider REGEXP as string.
+ "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)))
+ (do-string (stringp (car list)))
name
- ret
- )
+ ret)
(mapcar
(lambda (x)
(and (null string-format)
(string-match (regexp-quote regexp) name)))
- ;; todo (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)))
- (store-match-data data)
+ (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)
;; else no match
nil))))
-
-
-
-
-
(defun iswitchb-find-common-substring (lis subs)
"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."
;; 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.
(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 iswitchb-xemacs
;; XEmacs extents are put on by default, doesn't seem to be
;; any way of switching them off.
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'."
(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))
- )
+ (set-mouse-position (selected-frame) (1- (frame-width)) 0)))
(t
;; No buffer in other frames...
(switch-to-buffer buffer)
)))
-
-
((eq iswitchb-method 'otherwindow)
(switch-to-buffer-other-window buffer))
(switch-to-buffer-other-frame buffer)
(if (not iswitchb-xemacs)
(set-mouse-position (selected-frame) (1- (frame-width)) 0))
- )
- ) )))
+ )))))
(defun iswitchb-possible-new-buffer (buf)
"Possibly create and visit a new buffer called BUF."
(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.
;;;###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 ()
(setq iswitchb-method iswitchb-default-method)
(iswitchb))
-
;;;###autoload
(defun iswitchb-buffer-other-window ()
"Switch to another buffer and show it in another window.
(setq iswitchb-method 'otherwindow)
(iswitchb))
-
-
;;;###autoload
(defun iswitchb-display-buffer ()
"Display a buffer in another window but don't select it.
(setq iswitchb-method 'display)
(iswitchb))
-
-
;;;###autoload
(defun iswitchb-buffer-other-frame ()
"Switch to another buffer and show it in another frame.
;; function. To solve this, we use another entry hook for emacs to
;; show the default the first time we enter the minibuffer.
-(defun iswitchb-init-Xemacs-trick ()
+(defun iswitchb-init-XEmacs-trick ()
"Display default buffer when first entering minibuffer.
This is a hack for XEmacs, and should really be handled by `iswitchb-exhibit'."
(if (iswitchb-entryfn-p)
(iswitchb-exhibit)
(goto-char (point-min)))))
-
;; add this hook for XEmacs only.
(if iswitchb-xemacs
- (add-hook 'iswitchb-minibuffer-setup-hook
- 'iswitchb-init-Xemacs-trick))
-
+ (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
+ (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)))
- ))))
-
-
+ (insert-string (iswitchb-completions
+ contents
+ minibuffer-completion-table
+ minibuffer-completion-predicate
+ (not minibuffer-completion-confirm)))))))
-(defun iswitchb-completions
- (name candidates predicate require-match)
+(defun iswitchb-completions (name candidates predicate require-match)
"Return the string that is displayed after the user's text.
Modified from `icomplete-completions'."
;"-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)))))
(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
(let* (
;;(most (try-completion name candidates predicate))
;; pressing tab
(if (> (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.
(if most-is-exact
(concat "," alternatives)
alternatives)
- close-bracket-prospects)))
- )))
+ close-bracket-prospects))))))
(defun iswitchb-minibuffer-setup ()
"Set up minibuffer for `iswitchb-buffer'.
'iswitchb-post-command
nil t)
- (run-hooks 'iswitchb-minibuffer-setup-hook)
- )
- ))
-
+ (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.
(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'."
+ ;; Testing if `iswitchb-prepost-hooks' is bound does not work when
+ ;; we're invoking a recursive mini-buffer from an Iswitchb buffer.
+ ;; In this case, `iswitchb-prepost-hooks' is bound in the second
+ ;; mini-buffer, although it's not an Iswitchb buffer.
+ (memq this-command
+ '(iswitchb-buffer iswitchb-buffer-other-frame
+ iswitchb-display-buffer
+ iswitchb-buffer-other-window)))
(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 iswitchb-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
+(defun iswitchb-mode (&optional arg)
+ "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."
+ (interactive "P")
+ (setq iswitchb-mode
+ (if arg
+ (> (prefix-numeric-value arg) 0)
+ (not iswitchb-mode)))
+ (if iswitchb-mode
+ (add-hook 'minibuffer-setup-hook 'iswitchb-minibuffer-setup)
+ (remove-hook 'minibuffer-setup-hook 'iswitchb-minibuffer-setup))
+ (run-hooks 'iswitchb-mode-hook)
+ (if (interactive-p)
+ (message "Iswitchb mode %sabled"
+ (if iswitchb-mode "en" "dis"))))
+
+(unless (assq 'iswitchb-mode minor-mode-map-alist)
+ (push (cons 'iswitchb-mode iswitchb-global-map)
+ minor-mode-map-alist))
(provide 'iswitchb)
HCoop / bpt / emacs.git / blobdiff