(if (not (and (fboundp 'cadr)
(fboundp 'last)))
(require 'cl))
(eval-and-compile
(condition-case ()
(require 'custom)
(error nil))
(if (and (featurep 'custom) (fboundp 'custom-declare-variable))
nil (defmacro defgroup (&rest args)
nil)
(defmacro defcustom (var value doc &rest args)
`(defvar ,var ,value ,doc))))
(defgroup iswitchb nil
"Switch between buffers using substrings."
:group 'convenience
:group 'completion
:link '(emacs-commentary-link :tag "Commentary" "iswitchb.el")
:link '(url-link "http://www.anc.ed.ac.uk/~stephen/emacs/")
:link '(emacs-library-link :tag "Lisp File" "iswitchb.el"))
(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.
If this is non-nil but the user input has any upper case letters, matching
is temporarily case sensitive."
:type 'boolean
:group 'iswitchb)
(defcustom iswitchb-buffer-ignore
'("^ ")
"*List of regexps or functions matching buffer names to ignore.
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)
:group 'iswitchb)
(defcustom iswitchb-default-method 'always-frame
"*How to switch to new buffer when using `iswitchb-buffer'.
Possible values:
`samewindow' Show new buffer in same window
`otherwindow' Show new buffer in another window (same frame)
`display' Display buffer in another window without switching to it
`otherframe' Show new buffer in another frame
`maybe-frame' If a buffer is visible in another frame, prompt to ask if you
you want to see the buffer in the same window of the current
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)
(const otherwindow)
(const display)
(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."
:type 'hook
:group 'iswitchb)
(defvar iswitchb-all-frames 'visible
"*Argument to pass to `walk-windows' when finding visible buffers.
See documentation of `walk-windows' for useful values.")
(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."
: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-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,
although by default, the buffers visible in the current frame are put
at the end of the list. Created by `iswitchb-make-buflist'.")
(defvar iswitchb-use-mycompletion nil
"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
"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-text nil
"Stores the users string as it is typed in.")
(defvar iswitchb-matches nil
"List of buffers currently matching `iswitchb-text'.")
(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 'iswitchb-buffer map global-map)
(substitute-key-definition 'switch-to-buffer-other-window 'iswitchb-buffer-other-window map global-map)
(substitute-key-definition 'switch-to-buffer-other-frame 'iswitchb-buffer-other-frame map global-map)
(substitute-key-definition 'display-buffer '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.
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.")
(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.")
(defun iswitchb-define-mode-map ()
"Set up the keymap for `iswitchb-buffer'.
This is obsolete. Use \\[iswitchb-mode] or customize the
variable `iswitchb-mode'."
(interactive)
(let (map)
(setq map (copy-keymap 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)
(setq iswitchb-mode-map map)
(run-hooks 'iswitchb-define-mode-map-hook)))
(defun iswitchb ()
"Switch to buffer matching a substring.
As you type in a string, all of the buffers matching the string are
displayed. When you have found the buffer you want, it can then be
selected. As you type, most keys have their normal keybindings,
except for the following:
\\<iswitchb-mode-map>
RET Select the buffer at the front of the list of matches. If the
list is empty, possibly prompt to create new buffer.
\\[iswitchb-select-buffer-text] Select the current prompt as the buffer.
If no buffer is found, prompt for a new one.
\\[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
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-kill-buffer] Kill buffer at head of buffer list."
(let
(prompt buf)
(setq prompt (format "iswitch "))
(setq buf (iswitchb-read-buffer prompt))
(cond ( (eq iswitchb-exit 'findfile)
(call-interactively 'find-file))
(t
(if buf
(if (get-buffer buf)
(iswitchb-visit-buffer buf)
(iswitchb-possible-new-buffer buf)))
))))
(defun iswitchb-read-buffer (prompt &optional default require-match)
"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."
(let
(
buf-sel
iswitchb-final-text
(icomplete-mode nil) (iswitchb-use-fonts (and iswitchb-use-fonts
(boundp 'font-lock-comment-face)
(boundp 'font-lock-function-name-face))))
(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
((minibuffer-local-completion-map iswitchb-mode-map)
(iswitchb-prepost-hooks t)
(iswitchb-minibuf-depth (1+ (minibuffer-depth)))
(iswitchb-require-match require-match))
(setq iswitchb-final-text (completing-read
prompt '(("dummy" . 1)) nil nil nil 'iswitchb-history)))
(if (and require-match (not (iswitchb-existing-buffer-p)))
(error "Must specify valid buffer"))
(if (or
(eq iswitchb-exit 'takeprompt)
(null iswitchb-matches))
(setq buf-sel 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)))
(defun iswitchb-set-common-completion ()
"Find common completion of `iswitchb-text' in `iswitchb-matches'.
The result is stored in `iswitchb-common-match-string'."
(let* (val)
(setq iswitchb-common-match-string nil)
(if (and iswitchb-matches
(not iswitchb-regexp) (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))
(defun iswitchb-complete ()
"Try and complete the current pattern amongst the buffer names."
(interactive)
(let (res)
(cond ((not iswitchb-matches)
(iswitchb-completion-help))
((= 1 (length iswitchb-matches))
(exit-minibuffer))
(t
(setq res iswitchb-common-match-string)
(if (and (not (memq res '(t nil)))
(not (equal res iswitchb-text)))
(progn
(setq iswitchb-rescan nil)
(delete-region (minibuffer-prompt-end) (point))
(insert res))
(iswitchb-completion-help)
)))))
(defun iswitchb-toggle-case ()
"Toggle the value of variable `iswitchb-case'."
(interactive)
(setq iswitchb-case (not iswitchb-case))
(setq iswitchb-rescan t))
(defun iswitchb-toggle-regexp ()
"Toggle the value of `iswitchb-regexp'."
(interactive)
(setq iswitchb-regexp (not iswitchb-regexp))
(setq iswitchb-rescan t))
(defun iswitchb-toggle-ignore ()
"Toggle ignoring buffers specified with `iswitchb-buffer-ignore'."
(interactive)
(if iswitchb-buffer-ignore
(progn
(setq iswitchb-buffer-ignore-orig iswitchb-buffer-ignore)
(setq iswitchb-buffer-ignore nil))
(setq iswitchb-buffer-ignore iswitchb-buffer-ignore-orig))
(iswitchb-make-buflist iswitchb-default)
(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)))
(defun iswitchb-select-buffer-text ()
"Select the buffer named by the prompt.
If no buffer exactly matching the prompt exists, maybe create a new one."
(interactive)
(setq iswitchb-exit 'takeprompt)
(exit-minibuffer))
(defun iswitchb-find-file ()
"Drop into `find-file' from buffer switching."
(interactive)
(setq iswitchb-exit 'findfile)
(exit-minibuffer))
(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 ()
"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)))
(defun iswitchb-chop (list elem)
"Remove all elements before ELEM and put them at the end of LIST."
(let ((ret nil)
(next nil)
(sofar nil))
(while (not ret)
(setq next (car list))
(if (equal next elem)
(setq ret (append list (nreverse sofar)))
(progn
(setq list (cdr list))
(setq sofar (cons next sofar)))))
ret))
(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
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
(let* ((iswitchb-current-buffers (iswitchb-get-buffers-in-frames))
(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)
(if default
(progn
(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 `iswitchb-temp-buflist'."
(mapcar
(lambda (elem)
(setq iswitchb-temp-buflist (delq elem iswitchb-temp-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
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
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))))
(if (not (member buf iswitchb-bufs-in-frame))
(setq iswitchb-bufs-in-frame
(cons buf iswitchb-bufs-in-frame)))))
(defun iswitchb-set-matches ()
"Set `iswitchb-matches' to the list of buffers matching prompt."
(if iswitchb-rescan
(setq iswitchb-matches
(let* ((buflist iswitchb-buflist))
(iswitchb-get-matched-buffers iswitchb-text iswitchb-regexp
buflist)))))
(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))
(list (reverse buffer-list))
(do-string (stringp (car list)))
name
ret)
(mapcar
(lambda (x)
(if do-string
(setq name x) (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)))
(setq ret (cons name ret))
)))
list)
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)
(while re-list
(setq nextstr (car re-list))
(cond
((stringp nextstr)
(if (string-match nextstr bufname)
(progn
(setq ignorep t)
(setq re-list nil))))
((fboundp nextstr)
(if (funcall nextstr bufname)
(progn
(setq ignorep t)
(setq re-list nil)))))
(setq re-list (cdr re-list)))
(set-match-data data)
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 ((m (string-match iswitchb-change-word-sub word)))
(if m
(substring word m)
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)
(setq iswitchb-change-word-sub
(if iswitchb-regexp
subs
(regexp-quote subs)))
(setq res (mapcar 'iswitchb-word-matching-substring lis))
(setq res (delq nil res)) (setq alist (mapcar 'iswitchb-makealist res))
(let ((completion-ignore-case (iswitchb-case)))
(try-completion subs alist))))
(defun iswitchb-makealist (res)
"Return dotted pair (RES . 1)."
(cons res 1))
(defun iswitchb-rotate-list (lis)
"Destructively remove the last element from LIS.
Return the modified list with the last element prepended to it."
(if (<= (length lis) 1)
lis
(let ((las lis)
(prev lis))
(while (consp (cdr las))
(setq prev las
las (cdr las)))
(setcdr prev nil)
(cons (car las) lis))))
(defun iswitchb-completion-help ()
"Show possible completions in a *Buffer Completions* buffer."
(interactive)
(setq iswitchb-rescan nil)
(let ((completion-setup-hook nil) (buf (current-buffer))
(temp-buf "*Buffer Completions*")
(win)
(again (eq last-command this-command)))
(if again
(progn
(set-buffer temp-buf)
(setq win (get-buffer-window temp-buf))
(if (pos-visible-in-window-p (point-max) win)
(set-window-start win (point-min))
(scroll-other-window))
(set-buffer buf))
(with-output-to-temp-buffer temp-buf
(if iswitchb-xemacs
(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!")))
(with-current-buffer standard-output
(fundamental-mode))
(display-completion-list (if iswitchb-matches
iswitchb-matches
iswitchb-buflist))
)))))
(defun iswitchb-kill-buffer ()
"Kill the buffer at the head of `iswitchb-matches'."
(interactive)
(let ( (enable-recursive-minibuffers t)
buf)
(setq buf (car iswitchb-matches))
(if buf
(progn
(kill-buffer buf)
(if (get-buffer buf)
(setq iswitchb-rescan t)
(setq iswitchb-buflist (delq buf iswitchb-buflist)))))))
(defun iswitchb-visit-buffer (buffer)
"Visit buffer named BUFFER according to `iswitchb-method'."
(let* (win newframe)
(cond
((eq iswitchb-method 'samewindow)
(switch-to-buffer buffer))
((memq iswitchb-method '(always-frame maybe-frame))
(cond
((and (setq win (iswitchb-window-buffer-p buffer))
(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)
(set-mouse-position (selected-frame) (1- (frame-width)) 0)))
(t
(switch-to-buffer buffer)
)))
((eq iswitchb-method 'otherwindow)
(switch-to-buffer-other-window buffer))
((eq iswitchb-method 'display)
(display-buffer 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))
)))))
(defun iswitchb-possible-new-buffer (buf)
"Possibly create and visit a new buffer called BUF."
(let ((newbufcreated))
(if (and iswitchb-newbuffer
(or
(not iswitchb-prompt-newbuffer)
(and iswitchb-prompt-newbuffer
(y-or-n-p
(format
"No buffer matching `%s', create one? "
buf)))))
(progn
(setq newbufcreated (get-buffer-create buf))
(if (fboundp 'set-buffer-major-mode)
(set-buffer-major-mode newbufcreated))
(iswitchb-visit-buffer newbufcreated))
(message (format "no buffer matching `%s'" buf)))))
(defun iswitchb-window-buffer-p (buffer)
"Return window pointer if BUFFER is visible in another frame.
If BUFFER is visible in the current frame, return nil."
(interactive)
(let ((blist (iswitchb-get-buffers-in-frames 'current)))
(if (memq buffer blist)
nil
(get-buffer-window buffer 0) )))
(defun iswitchb-default-keybindings ()
"Set up default keybindings for `iswitchb-buffer'.
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))
(defun iswitchb-buffer ()
"Switch to another buffer.
The buffer name is selected interactively by typing a substring. The
buffer is displayed according to `iswitchb-default-method' -- the
default is to show it in the same window, unless it is already visible
in another frame.
For details of keybindings, do `\\[describe-function] iswitchb'."
(interactive)
(setq iswitchb-method iswitchb-default-method)
(iswitchb))
(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.
For details of keybindings, do `\\[describe-function] iswitchb'."
(interactive)
(setq iswitchb-method 'otherwindow)
(iswitchb))
(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.
For details of keybindings, do `\\[describe-function] iswitchb'."
(interactive)
(setq iswitchb-method 'display)
(iswitchb))
(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.
For details of keybindings, do `\\[describe-function] iswitchb'."
(interactive)
(setq iswitchb-method 'otherframe)
(iswitchb))
(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)
(progn
(iswitchb-exhibit)
(goto-char (point-min)))))
(if iswitchb-xemacs
(add-hook 'iswitchb-minibuffer-setup-hook
'iswitchb-init-XEmacs-trick))
(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))
(if iswitchb-xemacs
(add-hook 'iswitchb-define-mode-map-hook
'iswitchb-xemacs-backspacekey))
(defun iswitchb-exhibit ()
"Find matching buffers and display a list in the minibuffer.
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 (minibuffer-prompt-end) (point-max)))
(buffer-undo-list t))
(save-excursion
(goto-char (point-max))
(if (not (boundp 'iswitchb-eoinput))
(make-local-variable 'iswitchb-eoinput))
(setq iswitchb-eoinput (point))
(setq iswitchb-text contents)
(iswitchb-set-matches)
(setq iswitchb-rescan t)
(iswitchb-set-common-completion)
(insert-string (iswitchb-completions
contents
minibuffer-completion-table
minibuffer-completion-predicate
(not minibuffer-completion-confirm)))))))
(defun iswitchb-completions (name candidates predicate require-match)
"Return the string that is displayed after the user's text.
Modified from `icomplete-completions'."
(let ((comps iswitchb-matches)
(open-bracket-determined (if require-match "(" "["))
(close-bracket-determined (if require-match ")" "]"))
(open-bracket-prospects "{")
(close-bracket-prospects "}")
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)
'font-lock-comment-face
'font-lock-function-name-face)
first)
(setq comps (cons first (cdr comps)))))
(cond ((null comps) (format " %sNo match%s"
open-bracket-determined
close-bracket-determined))
((null (cdr comps)) (concat (if (and (> (length (car comps))
(length name)))
(concat open-bracket-determined
(car comps)
close-bracket-determined)
"")
(if (not iswitchb-use-fonts) " [Matched]")))
(t (let* (
(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)
(progn
(setq most-is-exact t)
())
(list ","
(substring com
most-len))))
comps))))))
(concat
(if (> (length iswitchb-common-match-string) (length name))
(concat open-bracket-determined
(substring iswitchb-common-match-string
(length name))
close-bracket-determined))
(and (> most-len (length name))
(concat open-bracket-determined
(substring most (length name))
close-bracket-determined))
open-bracket-prospects
(if most-is-exact
(concat "," alternatives)
alternatives)
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))))
(defun iswitchb-pre-command ()
"Run before command in `iswitchb-buffer'."
(iswitchb-tidy))
(defun iswitchb-post-command ()
"Run after command in `iswitchb-buffer'."
(iswitchb-exhibit))
(defun iswitchb-tidy ()
"Remove completions display, if any, prior to new user input.
Copied from `icomplete-tidy'."
(if (and (boundp 'iswitchb-eoinput)
iswitchb-eoinput)
(if (> iswitchb-eoinput (point-max))
(setq iswitchb-eoinput (point-max))
(let ((buffer-undo-list buffer-undo-list )) (delete-region iswitchb-eoinput (point-max))))
(make-local-variable 'iswitchb-eoinput)
(setq iswitchb-eoinput 1)))
(defun iswitchb-entryfn-p ()
"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 (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))))
(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)