code.delx.au - gnu-emacs/blob - lisp/iswitchb.el

   1 ;;; iswitchb.el --- switch between buffers using substrings
   2
   3 ;; Copyright (C) 1996, 1997, 2000, 2001, 2002, 2003, 2004,
   4 ;;   2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
   5
   6 ;; Author: Stephen Eglen <stephen@gnu.org>
   7 ;; Maintainer: Stephen Eglen <stephen@gnu.org>
   8 ;; Keywords: completion convenience
   9
  10 ;; This file is part of GNU Emacs.
  11
  12 ;; GNU Emacs is free software: you can redistribute it and/or modify
  13 ;; it under the terms of the GNU General Public License as published by
  14 ;; the Free Software Foundation, either version 3 of the License, or
  15 ;; (at your option) any later version.
  16
  17 ;; GNU Emacs is distributed in the hope that it will be useful,
  18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;; GNU General Public License for more details.
  21
  22 ;; You should have received a copy of the GNU General Public License
  23 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  24
  25 ;;; Commentary:
  26
  27 ;; Installation:
  28 ;; To get the functions in this package bound to keys, use
  29 ;; M-x iswitchb-mode or customize the option `iswitchb-mode'.
  30 ;; Alternatively, add the following line to your .emacs:
  31 ;; (iswitchb-mode 1)
  32
  33 ;; As you type in a substring, the list of buffers currently matching
  34 ;; the substring is displayed as you type.  The list is ordered so
  35 ;; that the most recent buffers visited come at the start of the list.
  36 ;; The buffer at the start of the list will be the one visited when
  37 ;; you press return.  By typing more of the substring, the list is
  38 ;; narrowed down so that gradually the buffer you want will be at the
  39 ;; top of the list.  Alternatively, you can use C-s and C-r to rotate
  40 ;; buffer names in the list until the one you want is at the top of
  41 ;; the list.  Completion is also available so that you can see what is
  42 ;; common to all of the matching buffers as you type.
  43
  44 ;; This code is similar to a couple of other packages.  Michael R Cook
  45 ;; <cook@sightpath.com> wrote a similar buffer switching package, but
  46 ;; does exact matching rather than substring matching on buffer names.
  47 ;; I also modified a couple of functions from icomplete.el to provide
  48 ;; the completion feedback in the minibuffer.
  49
  50 ;;; Example
  51
  52 ;; If I have two buffers called "123456" and "123", with "123456" the
  53 ;; most recent, when I use iswitchb, I first of all get presented with
  54 ;; the list of all the buffers
  55 ;;
  56 ;;       iswitch  {123456,123}
  57 ;;
  58 ;; If I then press 2:
  59 ;;       iswitch 2[3]{123456,123}
  60 ;;
  61 ;; The list in {} are the matching buffers, most recent first (buffers
  62 ;; visible in the current frame are put at the end of the list by
  63 ;; default).  At any time I can select the item at the head of the
  64 ;; list by pressing RET.  I can also put the first element at the end
  65 ;; of the list by pressing C-s, or put the last element at the head of
  66 ;; the list by pressing C-r.  The item in [] indicates what can be
  67 ;; added to my input by pressing TAB.  In this case, I will get "3"
  68 ;; added to my input.  So, press TAB:
  69 ;;       iswitch 23{123456,123}
  70 ;;
  71 ;; At this point, I still have two matching buffers.
  72 ;; If I want the first buffer in the list, I simply press RET.  If I
  73 ;; wanted the second in the list, I could press C-s to move it to the
  74 ;; top of the list and then RET to select it.
  75 ;;
  76 ;; However, if I type 4, I only have one match left:
  77 ;;       iswitch 234[123456] [Matched]
  78 ;;
  79 ;; Since there is only one matching buffer left, it is given in [] and we
  80 ;; see the text [Matched] afterwards.  I can now press TAB or RET to go
  81 ;; to that buffer.
  82 ;;
  83 ;; If however, I now type "a":
  84 ;;       iswitch 234a [No match]
  85 ;; There are no matching buffers.  If I press RET or TAB, I can be
  86 ;; prompted to create a new buffer called "234a".
  87 ;;
  88 ;; Of course, where this function comes in really useful is when you
  89 ;; can specify the buffer using only a few keystrokes.  In the above
  90 ;; example, the quickest way to get to the "123456" buffer would be
  91 ;; just to type 4 and then RET (assuming there isn't any newer buffer
  92 ;; with 4 in its name).
  93
  94 ;; To see a full list of all matching buffers in a separate buffer,
  95 ;; hit ? or press TAB when there are no further completions to the
  96 ;; substring.  Repeated TAB presses will scroll you through this
  97 ;; separate buffer.
  98
  99 ;; The buffer at the head of the list can be killed by pressing C-k.
 100 ;; If the buffer needs saving, you will be queried before the buffer
 101 ;; is killed.
 102
 103 ;; If you find that the file you are after is not in a buffer, you can
 104 ;; press C-x C-f to immediately drop into find-file.
 105
 106 ;; See the doc string of iswitchb for full keybindings and features.
 107 ;; (describe-function 'iswitchb)
 108
 109 ;; Case matching: The case of strings when matching can be ignored or
 110 ;; used depending on the value of iswitchb-case (default is the same
 111 ;; as case-fold-search, normally t).  Imagine you have the following
 112 ;; buffers:
 113 ;;
 114 ;; INBOX *info* *scratch*
 115 ;;
 116 ;; Then these will be the matching buffers, depending on how you type
 117 ;; the two letters `in' and the value of iswitchb-case:
 118 ;;
 119 ;; iswitchb-case   user input  | matching buffers
 120 ;; ----------------------------------------------
 121 ;; nil             in          | *info*
 122 ;; t               in          | INBOX, *info*
 123 ;; t               IN          | INBOX
 124 ;; t               In          | [No match]
 125
 126 ;;; Customisation
 127
 128 ;; See the User Variables section below for easy ways to change the
 129 ;; functionality of the program.  These are accessible using the
 130 ;; custom package.
 131 ;; To modify the keybindings, use something like:
 132 ;;
 133 ;;(add-hook 'iswitchb-mode-hook 'iswitchb-my-keys)
 134 ;;(defun iswitchb-my-keys ()
 135 ;;  "Add my keybindings for iswitchb."
 136 ;;  (define-key iswitchb-mode-map " " 'iswitchb-next-match))
 137 ;;
 138 ;; Seeing all the matching buffers
 139 ;;
 140 ;; If you have many matching buffers, they may not all fit onto one
 141 ;; line of the minibuffer.  In Emacs 21, the variable
 142 ;; `resize-mini-windows' controls how many lines of the minibuffer can
 143 ;; be seen.  For older versions of emacs, you can use
 144 ;; `resize-minibuffer-mode'.  You can also limit iswitchb so that it
 145 ;; only shows a certain number of lines -- see the documentation for
 146 ;; `iswitchb-minibuffer-setup-hook'.
 147
 148 ;; Changing the list of buffers
 149
 150 ;; By default, the list of current buffers is most recent first,
 151 ;; oldest last, with the exception that the buffers visible in the
 152 ;; current frame are put at the end of the list.  A hook exists to
 153 ;; allow other functions to order the list.  For example, if you add:
 154 ;;
 155 ;; (add-hook 'iswitchb-make-buflist-hook 'iswitchb-summaries-to-end)
 156 ;;
 157 ;; then all buffers matching "Summary" are moved to the end of the
 158 ;; list.  (I find this handy for keeping the INBOX Summary and so on
 159 ;; out of the way.)  It also moves buffers matching "output\*$" to the
 160 ;; end of the list (these are created by AUCTeX when compiling.)
 161 ;; Other functions could be made available which alter the list of
 162 ;; matching buffers (either deleting or rearranging elements.)
 163
 164 ;; Font-Lock
 165
 166 ;; font-lock is used to highlight the first matching buffer.  To
 167 ;; switch this off, set (setq iswitchb-use-faces nil).  Colouring of
 168 ;; the matching buffer name was suggested by Carsten Dominik
 169 ;; (dominik@strw.leidenuniv.nl)
 170
 171 ;; Replacement for read-buffer
 172
 173 ;; iswitchb-read-buffer has been written to be a drop in replacement
 174 ;; for the normal buffer selection routine `read-buffer'.  To use
 175 ;; iswitch for all buffer selections in Emacs, add:
 176 ;; (setq read-buffer-function 'iswitchb-read-buffer)
 177 ;; (This variable was introduced in Emacs 20.3.)
 178 ;; XEmacs users can get the same behavior by doing:
 179 ;; (defalias 'read-buffer 'iswitchb-read-buffer)
 180 ;; since `read-buffer' is defined in lisp.
 181
 182 ;; Using iswitchb for other completion tasks.
 183
 184 ;; Kin Cho (kin@neoscale.com) sent the following suggestion to use
 185 ;; iswitchb for other completion tasks.
 186 ;;
 187 ;; (defun my-icompleting-read (prompt choices)
 188 ;;   "Use iswitch as a completing-read replacement to choose from
 189 ;; choices.  PROMPT is a string to prompt with.  CHOICES is a list of
 190 ;; strings to choose from."
 191 ;;   (let ((iswitchb-make-buflist-hook
 192 ;;          (lambda ()
 193 ;;            (setq iswitchb-temp-buflist choices))))
 194 ;;     (iswitchb-read-buffer prompt)))
 195 ;;
 196 ;; example:
 197 ;; (my-icompleting-read "Which fruit? " '
 198 ;;                   ("apple" "pineapple" "pear" "bananas" "oranges") )
 199
 200 ;; Kin Cho also suggested the following defun.  Once you have a subset of
 201 ;; matching buffers matching your current prompt, you can then press
 202 ;; e.g. C-o to restrict matching to those buffers and clearing the prompt:
 203 ;; (defun iswitchb-exclude-nonmatching()
 204 ;;    "Make iswitchb work on only the currently matching names."
 205 ;;    (interactive)
 206 ;;    (setq iswitchb-buflist iswitchb-matches)
 207 ;;    (setq iswitchb-rescan t)
 208 ;;    (delete-minibuffer-contents))
 209 ;;
 210 ;; (add-hook 'iswitchb-define-mode-map-hook
 211 ;;        '(lambda () (define-key
 212 ;;                      iswitchb-mode-map "\C-o"
 213 ;;                      'iswitchb-exclude-nonmatching)))
 214
 215 ;; Other lisp packages extend iswitchb behavior to other tasks.  See
 216 ;; ido.el (by Kim Storm) and mcomplete.el (Yuji Minejima).
 217
 218 ;; Window managers: Switching frames/focus follows mouse; Sawfish.
 219
 220 ;; If you switch to a buffer that is visible in another frame,
 221 ;; iswitchb can switch focus to that frame.  If your window manager
 222 ;; uses "click to focus" policy for window selection, you should also
 223 ;; set focus-follows-mouse to nil.
 224
 225 ;; iswitch functionality has also been implemented for switching
 226 ;; between windows in the Sawfish window manager.
 227
 228 ;; Regexp matching
 229
 230 ;; There is provision for regexp matching within iswitchb, enabled
 231 ;; through `iswitchb-regexp'.  This allows you to type `c$' for
 232 ;; example and see all buffer names ending in `c'.  No completion
 233 ;; mechanism is currently offered when regexp searching.
 234
 235 ;;; TODO
 236
 237 ;;; Acknowledgements
 238
 239 ;; Thanks to Jari Aalto <jari.aalto@poboxes.com> for help with the
 240 ;; first version of this package, iswitch-buffer.  Thanks also to many
 241 ;; others for testing earlier versions.
 242
 243 ;;; Code:
 244
 245 (require 'font-lock)
 246
 247 ;;; User Variables
 248 ;;
 249 ;; These are some things you might want to change.
 250
 251 (defgroup iswitchb nil
 252   "Switch between buffers using substrings."
 253   :group 'convenience
 254   :group 'completion
 255   :link '(emacs-commentary-link :tag "Commentary" "iswitchb.el")
 256   :link '(url-link "http://www.anc.ed.ac.uk/~stephen/emacs/")
 257   :link '(emacs-library-link :tag "Lisp File" "iswitchb.el"))
 258
 259 (defcustom iswitchb-case case-fold-search
 260   "Non-nil if searching of buffer names should ignore case.
 261 If this is non-nil but the user input has any upper case letters, matching
 262 is temporarily case sensitive."
 263   :type 'boolean
 264   :group 'iswitchb)
 265
 266 (defcustom iswitchb-buffer-ignore
 267   '("^ ")
 268   "List of regexps or functions matching buffer names to ignore.
 269 For example, traditional behavior is not to list buffers whose names begin
 270 with a space, for which the regexp is `^ '.  See the source file for
 271 example functions that filter buffer names."
 272   :type '(repeat (choice regexp function))
 273   :group 'iswitchb)
 274 (put 'iswitchb-buffer-ignore 'risky-local-variable t)
 275
 276 (defcustom iswitchb-max-to-show nil
 277   "If non-nil, limit the number of names shown in the minibuffer.
 278 If this value is N, and N is greater than the number of matching
 279 buffers, the first N/2 and the last N/2 matching buffers are
 280 shown.  This can greatly speed up iswitchb if you have a
 281 multitude of buffers open."
 282   :type '(choice (const :tag "Show all" nil) integer)
 283   :group 'iswitchb)
 284
 285 (defcustom iswitchb-use-virtual-buffers nil
 286   "If non-nil, refer to past buffers when none match.
 287 This feature relies upon the `recentf' package, which will be
 288 enabled if this variable is configured to a non-nil value."
 289   :type 'boolean
 290   :require 'recentf
 291   :set (function
 292         (lambda (sym value)
 293           (if value (recentf-mode 1))
 294           (set sym value)))
 295   :group 'iswitchb)
 296
 297 (defvar iswitchb-virtual-buffers nil)
 298
 299 (defcustom iswitchb-cannot-complete-hook 'iswitchb-completion-help
 300   "Hook run when `iswitchb-complete' can't complete any more.
 301 The most useful values are `iswitchb-completion-help', which pops up a
 302 window with completion alternatives, or `iswitchb-next-match' or
 303 `iswitchb-prev-match', which cycle the buffer list."
 304   :type 'hook
 305   :group 'iswitchb)
 306
 307 ;; Examples for setting the value of iswitchb-buffer-ignore
 308 ;;(defun iswitchb-ignore-c-mode (name)
 309 ;;  "Ignore all c mode buffers -- example function for iswitchb."
 310 ;;  (with-current-buffer name
 311 ;;    (derived-mode-p 'c-mode)))
 312
 313 ;;(setq iswitchb-buffer-ignore '("^ " iswitchb-ignore-c-mode))
 314 ;;(setq iswitchb-buffer-ignore '("^ " "\\.c\\'" "\\.h\\'"))
 315
 316 (defcustom iswitchb-default-method  'always-frame
 317     "How to switch to new buffer when using `iswitchb-buffer'.
 318 Possible values:
 319 `samewindow'    Show new buffer in same window
 320 `otherwindow'   Show new buffer in another window (same frame)
 321 `display'       Display buffer in another window without switching to it
 322 `otherframe'    Show new buffer in another frame
 323 `maybe-frame'   If a buffer is visible in another frame, prompt to ask if you
 324                 you want to see the buffer in the same window of the current
 325                 frame or in the other frame.
 326 `always-frame'  If a buffer is visible in another frame, raise that
 327                 frame.  Otherwise, visit the buffer in the same window."
 328     :type '(choice (const samewindow)
 329                    (const otherwindow)
 330                    (const display)
 331                    (const otherframe)
 332                    (const maybe-frame)
 333                    (const always-frame))
 334     :group 'iswitchb)
 335
 336 (defcustom iswitchb-regexp nil
 337   "Non-nil means that `iswitchb' will do regexp matching.
 338 Value can be toggled within `iswitchb' using `iswitchb-toggle-regexp'."
 339   :type 'boolean
 340   :group 'iswitchb)
 341
 342 (defcustom iswitchb-newbuffer t
 343   "Non-nil means create new buffer if no buffer matches substring.
 344 See also `iswitchb-prompt-newbuffer'."
 345   :type 'boolean
 346   :group 'iswitchb)
 347
 348 (defcustom iswitchb-prompt-newbuffer t
 349   "Non-nil means prompt user to confirm before creating new buffer.
 350 See also `iswitchb-newbuffer'."
 351   :type 'boolean
 352   :group 'iswitchb)
 353
 354 (define-obsolete-variable-alias 'iswitchb-use-fonts 'iswitchb-use-faces "22.1")
 355
 356 (defcustom iswitchb-use-faces t
 357   "Non-nil means use font-lock faces for showing first match."
 358   :type 'boolean
 359   :group 'iswitchb)
 360
 361 (defcustom iswitchb-use-frame-buffer-list nil
 362   "Non-nil means use the currently selected frame's buffer list."
 363   :type 'boolean
 364   :group 'iswitchb)
 365
 366 (defcustom iswitchb-make-buflist-hook  nil
 367   "Hook to run when list of matching buffers is created."
 368   :type 'hook
 369   :group 'iswitchb)
 370
 371 (defcustom iswitchb-delim ","
 372   "Delimiter to put between buffer names when displaying results."
 373   :type 'string
 374   :group 'iswitchb)
 375
 376 (defvar iswitchb-all-frames 'visible
 377   "*Argument to pass to `walk-windows' when finding visible buffers.
 378 See documentation of `walk-windows' for useful values.")
 379
 380 (defcustom iswitchb-minibuffer-setup-hook nil
 381   "Iswitchb-specific customization of minibuffer setup.
 382
 383 This hook is run during minibuffer setup if `iswitchb' is active.
 384 For instance:
 385 \(add-hook 'iswitchb-minibuffer-setup-hook
 386           '\(lambda () (set (make-local-variable 'max-mini-window-height) 3)))
 387 will constrain the minibuffer to a maximum height of 3 lines when
 388 iswitchb is running."
 389   :type 'hook
 390   :group 'iswitchb)
 391
 392 (defface iswitchb-single-match
 393   '((t
 394      (:inherit font-lock-comment-face)))
 395   "Iswitchb face for single matching buffer name."
 396   :version "22.1"
 397   :group 'iswitchb)
 398
 399 (defface iswitchb-current-match
 400   '((t
 401      (:inherit font-lock-function-name-face)))
 402   "Iswitchb face for current matching buffer name."
 403   :version "22.1"
 404   :group 'iswitchb)
 405
 406 (defface iswitchb-virtual-matches
 407   '((t
 408      (:inherit font-lock-builtin-face)))
 409   "Iswitchb face for matching virtual buffer names.
 410 See also `iswitchb-use-virtual-buffers'."
 411   :version "22.1"
 412   :group 'iswitchb)
 413
 414 (defface iswitchb-invalid-regexp
 415   '((t
 416      (:inherit font-lock-warning-face)))
 417   "Iswitchb face for indicating invalid regexp. "
 418   :version "22.1"
 419   :group 'iswitchb)
 420
 421 ;; Do we need the variable iswitchb-use-mycompletion?
 422
 423 ;;; Internal Variables
 424
 425 (defvar iswitchb-method nil
 426   "Stores the method for viewing the selected buffer.
 427 Its value is one of `samewindow', `otherwindow', `display', `otherframe',
 428 `maybe-frame' or `always-frame'.  See `iswitchb-default-method' for
 429 details of values.")
 430
 431 (defvar iswitchb-eoinput 1
 432   "Point where minibuffer input ends and completion info begins.
 433 Copied from `icomplete-eoinput'.")
 434 (make-variable-buffer-local 'iswitchb-eoinput)
 435
 436 (defvar iswitchb-buflist nil
 437   "Stores the current list of buffers that will be searched through.
 438 The list is ordered, so that the most recent buffers come first,
 439 although by default, the buffers visible in the current frame are put
 440 at the end of the list.  Created by `iswitchb-make-buflist'.")
 441
 442 ;; todo -- is this necessary?
 443
 444 (defvar iswitchb-use-mycompletion nil
 445   "Non-nil means use `iswitchb-buffer' completion feedback.
 446 Should only be set to t by iswitchb functions, so that it doesn't
 447 interfere with other minibuffer usage.")
 448
 449 (defvar iswitchb-change-word-sub nil
 450   "Private variable used by `iswitchb-word-matching-substring'.")
 451
 452 (defvar iswitchb-common-match-string  nil
 453   "Stores the string that is common to all matching buffers.")
 454
 455 (defvar iswitchb-rescan nil
 456   "Non-nil means we need to regenerate the list of matching buffers.")
 457
 458 (defvar iswitchb-text nil
 459   "Stores the users string as it is typed in.")
 460
 461 (defvar iswitchb-matches nil
 462   "List of buffers currently matching `iswitchb-text'.")
 463
 464 (defvar iswitchb-mode-map
 465   (let ((map (make-sparse-keymap)))
 466     (set-keymap-parent map minibuffer-local-map)
 467     (define-key map "?" 'iswitchb-completion-help)
 468     (define-key map "\C-s" 'iswitchb-next-match)
 469     (define-key map "\C-r" 'iswitchb-prev-match)
 470     (define-key map "\t" 'iswitchb-complete)
 471     (define-key map "\C-j" 'iswitchb-select-buffer-text)
 472     (define-key map "\C-t" 'iswitchb-toggle-regexp)
 473     (define-key map "\C-x\C-f" 'iswitchb-find-file)
 474     (define-key map "\C-c" 'iswitchb-toggle-case)
 475     (define-key map "\C-k" 'iswitchb-kill-buffer)
 476     (define-key map "\C-m" 'iswitchb-exit-minibuffer)
 477     map)
 478   "Minibuffer keymap for `iswitchb-buffer'.")
 479
 480 (defvar iswitchb-global-map
 481   (let ((map (make-sparse-keymap)))
 482     (dolist (b '((switch-to-buffer . iswitchb-buffer)
 483                  (switch-to-buffer-other-window . iswitchb-buffer-other-window)
 484                  (switch-to-buffer-other-frame . iswitchb-buffer-other-frame)
 485                  (display-buffer . iswitchb-display-buffer)))
 486       (if (fboundp 'command-remapping)
 487           (define-key map (vector 'remap (car b)) (cdr b))
 488         (substitute-key-definition (car b) (cdr b) map global-map)))
 489     map)
 490   "Global keymap for `iswitchb-mode'.")
 491
 492 (defvar iswitchb-history nil
 493   "History of buffers selected using `iswitchb-buffer'.")
 494
 495 (defvar iswitchb-exit nil
 496   "Flag to monitor how `iswitchb-buffer' exits.
 497 If equal to `takeprompt', we use the prompt as the buffer name to be
 498 selected.")
 499
 500 (defvar iswitchb-buffer-ignore-orig nil
 501   "Stores original value of `iswitchb-buffer-ignore'.")
 502
 503 (defvar iswitchb-default nil
 504   "Default buffer for iswitchb.")
 505
 506 ;; The following variables are needed to keep the byte compiler quiet.
 507 (defvar iswitchb-require-match nil
 508   "Non-nil if matching buffer must be selected.")
 509
 510 (defvar iswitchb-temp-buflist nil
 511   "Stores a temporary version of the buffer list being created.")
 512
 513 (defvar iswitchb-bufs-in-frame nil
 514   "List of the buffers visible in the current frame.")
 515
 516 (defvar iswitchb-minibuf-depth nil
 517   "Value we expect to be returned by `minibuffer-depth' in the minibuffer.")
 518
 519 (defvar iswitchb-common-match-inserted nil
 520   "Non-nil if we have just inserted a common match in the minibuffer.")
 521
 522 (defvar iswitchb-invalid-regexp)
 523
 524 ;;; FUNCTIONS
 525
 526 ;;; ISWITCHB KEYMAP
 527 (defun iswitchb-define-mode-map ()
 528   "Set up the keymap for `iswitchb-buffer'."
 529   (interactive)
 530   (let (map)
 531     ;; generated every time so that it can inherit new functions.
 532     ;;(or iswitchb-mode-map
 533
 534     (setq map (copy-keymap minibuffer-local-map))
 535     (define-key map "?" 'iswitchb-completion-help)
 536     (define-key map "\C-s" 'iswitchb-next-match)
 537     (define-key map "\C-r" 'iswitchb-prev-match)
 538     (define-key map "\t" 'iswitchb-complete)
 539     (define-key map "\C-j" 'iswitchb-select-buffer-text)
 540     (define-key map "\C-t" 'iswitchb-toggle-regexp)
 541     (define-key map "\C-x\C-f" 'iswitchb-find-file)
 542     (define-key map "\C-n" 'iswitchb-toggle-ignore)
 543     (define-key map "\C-c" 'iswitchb-toggle-case)
 544     (define-key map "\C-k" 'iswitchb-kill-buffer)
 545     (define-key map "\C-m" 'iswitchb-exit-minibuffer)
 546     (setq iswitchb-mode-map map)
 547     (run-hooks 'iswitchb-define-mode-map-hook)))
 548
 549 (make-obsolete 'iswitchb-define-mode-map
 550                "use M-x iswitchb-mode or customize the variable `iswitchb-mode'."
 551                "21.1")
 552
 553 ;;; MAIN FUNCTION
 554 (defun iswitchb ()
 555   "Switch to buffer matching a substring.
 556 As you type in a string, all of the buffers matching the string are
 557 displayed.  When you have found the buffer you want, it can then be
 558 selected.  As you type, most keys have their normal keybindings,
 559 except for the following:
 560 \\<iswitchb-mode-map>
 561
 562 RET Select the buffer at the front of the list of matches.  If the
 563 list is empty, possibly prompt to create new buffer.
 564
 565 \\[iswitchb-select-buffer-text] Select the current prompt as the buffer.
 566 If no buffer is found, prompt for a new one.
 567
 568 \\[iswitchb-next-match] Put the first element at the end of the list.
 569 \\[iswitchb-prev-match] Put the last element at the start of the list.
 570 \\[iswitchb-complete] Complete a common suffix to the current string that
 571 matches all buffers.  If there is only one match, select that buffer.
 572 If there is no common suffix, show a list of all matching buffers
 573 in a separate window.
 574 \\[iswitchb-toggle-regexp] Toggle regexp searching.
 575 \\[iswitchb-toggle-case] Toggle case-sensitive searching of buffer names.
 576 \\[iswitchb-completion-help] Show list of matching buffers in separate window.
 577 \\[iswitchb-find-file] Exit iswitchb and drop into `find-file'.
 578 \\[iswitchb-kill-buffer] Kill buffer at head of buffer list."
 579   ;;\\[iswitchb-toggle-ignore] Toggle ignoring certain buffers (see \
 580   ;;`iswitchb-buffer-ignore')
 581
 582   (let* ((prompt "iswitch ")
 583          iswitchb-invalid-regexp
 584          (buf (iswitchb-read-buffer prompt)))
 585
 586     ;;(message "chosen text %s" iswitchb-final-text)
 587     ;; Choose the buffer name: either the text typed in, or the head
 588     ;; of the list of matches
 589
 590     (cond ( (eq iswitchb-exit 'findfile)
 591             (call-interactively 'find-file))
 592           (iswitchb-invalid-regexp
 593            (message "Won't make invalid regexp named buffer"))
 594           (t
 595            ;; View the buffer
 596            ;;(message "go to buf %s" buf)
 597            ;; Check buf is non-nil.
 598            (if buf
 599                (if (get-buffer buf)
 600                    ;; buffer exists, so view it and then exit
 601                    (iswitchb-visit-buffer buf)
 602                  ;; else buffer doesn't exist
 603                  (iswitchb-possible-new-buffer buf)))
 604            ))))
 605
 606 (defun iswitchb-read-buffer (prompt &optional default require-match
 607                                     start matches-set)
 608   "Replacement for the built-in `read-buffer'.
 609 Return the name of a buffer selected.
 610 PROMPT is the prompt to give to the user.
 611 DEFAULT if given is the default buffer to be selected, which will
 612 go to the front of the list.
 613 If REQUIRE-MATCH is non-nil, an existing buffer must be selected.
 614 If START is a string, the selection process is started with that
 615 string.
 616 If MATCHES-SET is non-nil, the buflist is not updated before
 617 the selection process begins.  Used by isearchb.el."
 618   (let
 619       (
 620        buf-sel
 621        iswitchb-final-text
 622        (icomplete-mode nil) ;; prevent icomplete starting up
 623        )
 624
 625     (iswitchb-define-mode-map)
 626     (setq iswitchb-exit nil)
 627     (setq iswitchb-default
 628           (if (bufferp default)
 629               (buffer-name default)
 630             default))
 631     (setq iswitchb-text (or start ""))
 632     (unless matches-set
 633       (setq iswitchb-rescan t)
 634       (iswitchb-make-buflist iswitchb-default)
 635       (iswitchb-set-matches))
 636     (let
 637         ((minibuffer-local-completion-map iswitchb-mode-map)
 638          ;; Record the minibuffer depth that we expect to find once
 639          ;; the minibuffer is set up and iswitchb-entryfn-p is called.
 640          (iswitchb-minibuf-depth (1+ (minibuffer-depth)))
 641          (iswitchb-require-match require-match))
 642       ;; prompt the user for the buffer name
 643       (setq iswitchb-final-text (completing-read
 644                                  prompt           ;the prompt
 645                                  '(("dummy" . 1)) ;table
 646                                  nil              ;predicate
 647                                  nil ;require-match [handled elsewhere]
 648                                  start  ;initial-contents
 649                                  'iswitchb-history)))
 650     (if (and (not (eq iswitchb-exit 'usefirst))
 651              (get-buffer iswitchb-final-text))
 652         ;; This happens for example if the buffer was chosen with the mouse.
 653         (setq iswitchb-matches (list iswitchb-final-text)
 654               iswitchb-virtual-buffers nil))
 655
 656     ;; If no buffer matched, but a virtual buffer was selected, visit
 657     ;; that file now and act as though that buffer had been selected.
 658     (if (and iswitchb-virtual-buffers
 659              (not (iswitchb-existing-buffer-p)))
 660         (let ((virt (car iswitchb-virtual-buffers)))
 661           (find-file-noselect (cdr virt))
 662           (setq iswitchb-matches (list (car virt))
 663                 iswitchb-virtual-buffers nil)))
 664
 665     ;; Handling the require-match must be done in a better way.
 666     (if (and require-match
 667              (not (iswitchb-existing-buffer-p)))
 668         (error "Must specify valid buffer"))
 669
 670     (if (or (eq iswitchb-exit 'takeprompt)
 671             (null iswitchb-matches))
 672         (setq buf-sel iswitchb-final-text)
 673       ;; else take head of list
 674       (setq buf-sel (car iswitchb-matches)))
 675
 676     ;; Or possibly choose the default buffer
 677     (if  (equal iswitchb-final-text "")
 678         (setq buf-sel (car iswitchb-matches)))
 679
 680     buf-sel))
 681
 682 (defun iswitchb-existing-buffer-p ()
 683   "Return non-nil if there is a matching buffer."
 684   (not (null iswitchb-matches)))
 685
 686 ;;; COMPLETION CODE
 687
 688 (defun iswitchb-set-common-completion  ()
 689   "Find common completion of `iswitchb-text' in `iswitchb-matches'.
 690 The result is stored in `iswitchb-common-match-string'."
 691
 692   (let (val)
 693     (setq  iswitchb-common-match-string nil)
 694     (if (and iswitchb-matches
 695              (not iswitchb-regexp) ;; testing
 696              (stringp iswitchb-text)
 697              (> (length iswitchb-text) 0))
 698         (if (setq val (iswitchb-find-common-substring
 699                        iswitchb-matches iswitchb-text))
 700             (setq iswitchb-common-match-string val)))
 701     val))
 702
 703 (defun iswitchb-complete ()
 704   "Try and complete the current pattern amongst the buffer names."
 705   (interactive)
 706   (let (res)
 707     (cond ((not  iswitchb-matches)
 708            (run-hooks 'iswitchb-cannot-complete-hook))
 709           (iswitchb-invalid-regexp
 710            ;; Do nothing
 711            )
 712           ((= 1 (length iswitchb-matches))
 713            ;; only one choice, so select it.
 714            (exit-minibuffer))
 715
 716           (t
 717            ;; else there could be some completions
 718            (setq res iswitchb-common-match-string)
 719            (if (and (not (memq res '(t nil)))
 720                     (not (equal res iswitchb-text)))
 721                ;; found something to complete, so put it in the minibuffer.
 722                (progn
 723                  (setq iswitchb-rescan nil
 724                        iswitchb-common-match-inserted t)
 725                  (delete-region (minibuffer-prompt-end) (point))
 726                  (insert  res))
 727              ;; else nothing to complete
 728              (run-hooks 'iswitchb-cannot-complete-hook)
 729              )))))
 730
 731 ;;; TOGGLE FUNCTIONS
 732
 733 (defun iswitchb-toggle-case ()
 734   "Toggle the value of variable `iswitchb-case'."
 735   (interactive)
 736   (setq iswitchb-case (not iswitchb-case))
 737   ;; ask for list to be regenerated.
 738   (setq iswitchb-rescan t))
 739
 740 (defun iswitchb-toggle-regexp ()
 741   "Toggle the value of `iswitchb-regexp'."
 742   (interactive)
 743   (setq iswitchb-regexp (not iswitchb-regexp))
 744   ;; ask for list to be regenerated.
 745   (setq iswitchb-rescan t))
 746
 747 (defun iswitchb-toggle-ignore ()
 748   "Toggle ignoring buffers specified with `iswitchb-buffer-ignore'."
 749   (interactive)
 750   (if iswitchb-buffer-ignore
 751       (progn
 752         (setq iswitchb-buffer-ignore-orig iswitchb-buffer-ignore)
 753         (setq iswitchb-buffer-ignore nil))
 754     ;; else
 755     (setq iswitchb-buffer-ignore iswitchb-buffer-ignore-orig))
 756   (iswitchb-make-buflist iswitchb-default)
 757   ;; ask for list to be regenerated.
 758   (setq iswitchb-rescan t))
 759
 760 (defun iswitchb-exit-minibuffer ()
 761   "Exit minibuffer, but make sure we have a match if one is needed."
 762   (interactive)
 763   (if (or (not iswitchb-require-match)
 764            (iswitchb-existing-buffer-p))
 765       (progn
 766         (setq iswitchb-exit 'usefirst)
 767         (throw 'exit nil))))
 768
 769 (defun iswitchb-select-buffer-text ()
 770   "Select the buffer named by the prompt.
 771 If no buffer exactly matching the prompt exists, maybe create a new one."
 772   (interactive)
 773   (setq iswitchb-exit 'takeprompt)
 774   (exit-minibuffer))
 775
 776 (defun iswitchb-find-file ()
 777   "Drop into `find-file' from buffer switching."
 778   (interactive)
 779   (setq iswitchb-exit 'findfile)
 780   (exit-minibuffer))
 781
 782 (defvar recentf-list)
 783
 784 (defun iswitchb-next-match ()
 785   "Put first element of `iswitchb-matches' at the end of the list."
 786   (interactive)
 787   (let ((next  (cadr iswitchb-matches)))
 788     (if (and (null next) iswitchb-virtual-buffers)
 789         (setq recentf-list
 790               (iswitchb-chop recentf-list
 791                              (cdr (cadr iswitchb-virtual-buffers))))
 792       (setq iswitchb-buflist (iswitchb-chop iswitchb-buflist next)))
 793     (setq iswitchb-rescan t)))
 794
 795 (defun iswitchb-prev-match ()
 796   "Put last element of `iswitchb-matches' at the front of the list."
 797   (interactive)
 798   (let ((prev  (car (last iswitchb-matches))))
 799     (if (and (null prev) iswitchb-virtual-buffers)
 800         (setq recentf-list
 801               (iswitchb-chop recentf-list
 802                              (cdr (car (last iswitchb-virtual-buffers)))))
 803       (setq iswitchb-buflist (iswitchb-chop iswitchb-buflist prev)))
 804     (setq iswitchb-rescan t)))
 805
 806 (defun iswitchb-chop (list elem)
 807   "Remove all elements before ELEM and put them at the end of LIST."
 808   (let ((ret nil)
 809         (next nil)
 810         (sofar nil))
 811     (while (not ret)
 812       (setq next (car list))
 813       (if (equal next elem)
 814           (setq ret (append list (nreverse sofar)))
 815         ;; else
 816         (progn
 817           (setq list (cdr list))
 818           (setq sofar (cons next sofar)))))
 819     ret))
 820
 821 ;;; CREATE LIST OF ALL CURRENT BUFFERS
 822
 823 (defun iswitchb-make-buflist (default)
 824   "Set `iswitchb-buflist' to the current list of buffers.
 825 Currently visible buffers are put at the end of the list.
 826 The hook `iswitchb-make-buflist-hook' is run after the list has been
 827 created to allow the user to further modify the order of the buffer names
 828 in this list.  If DEFAULT is non-nil, and corresponds to an existing buffer,
 829 it is put to the start of the list."
 830   (setq iswitchb-buflist
 831         (let* ((iswitchb-current-buffers (iswitchb-get-buffers-in-frames))
 832                (iswitchb-temp-buflist
 833                 (delq nil
 834                       (mapcar
 835                        (lambda (x)
 836                          (let ((b-name (buffer-name x)))
 837                            (if (not
 838                                 (or
 839                                  (iswitchb-ignore-buffername-p b-name)
 840                                  (memq b-name iswitchb-current-buffers)))
 841                                b-name)))
 842                        (buffer-list (and iswitchb-use-frame-buffer-list
 843                                          (selected-frame)))))))
 844           (setq iswitchb-temp-buflist
 845                 (nconc iswitchb-temp-buflist iswitchb-current-buffers))
 846           (run-hooks 'iswitchb-make-buflist-hook)
 847          ;; Should this be after the hooks, or should the hooks be the
 848           ;; final thing to be run?
 849           (if default
 850               (progn
 851                 (setq iswitchb-temp-buflist
 852                       (delete default iswitchb-temp-buflist))
 853                 (setq iswitchb-temp-buflist
 854                       (cons default iswitchb-temp-buflist))))
 855           iswitchb-temp-buflist)))
 856
 857 (defun iswitchb-to-end (lst)
 858   "Move the elements from LST to the end of `iswitchb-temp-buflist'."
 859   (dolist (elem lst)
 860     (setq iswitchb-temp-buflist (delq elem iswitchb-temp-buflist)))
 861   (setq iswitchb-temp-buflist (nconc iswitchb-temp-buflist lst)))
 862
 863 (defun iswitchb-get-buffers-in-frames (&optional current)
 864   "Return the list of buffers that are visible in the current frame.
 865 If optional argument CURRENT is given, restrict searching to the
 866 current frame, rather than all frames, regardless of value of
 867 `iswitchb-all-frames'."
 868   (let ((iswitchb-bufs-in-frame nil))
 869     (walk-windows 'iswitchb-get-bufname nil
 870                   (if current
 871                       nil
 872                     iswitchb-all-frames))
 873     iswitchb-bufs-in-frame))
 874
 875 (defun iswitchb-get-bufname (win)
 876   "Used by `iswitchb-get-buffers-in-frames' to walk through all windows."
 877   (let ((buf (buffer-name (window-buffer win))))
 878         (if (not (member buf iswitchb-bufs-in-frame))
 879             ;; Only add buf if it is not already in list.
 880             ;; This prevents same buf in two different windows being
 881             ;; put into the list twice.
 882             (setq iswitchb-bufs-in-frame
 883                   (cons buf iswitchb-bufs-in-frame)))))
 884
 885 ;;; FIND MATCHING BUFFERS
 886
 887 (defun iswitchb-set-matches ()
 888   "Set `iswitchb-matches' to the list of buffers matching prompt."
 889   (if iswitchb-rescan
 890       (setq iswitchb-matches
 891             (let ((buflist iswitchb-buflist))
 892               (iswitchb-get-matched-buffers iswitchb-text iswitchb-regexp
 893                                             buflist))
 894             iswitchb-virtual-buffers nil)))
 895
 896 (defun iswitchb-get-matched-buffers (regexp
 897                                      &optional string-format buffer-list)
 898   "Return buffers matching REGEXP.
 899 If STRING-FORMAT is nil, consider REGEXP as just a string.
 900 BUFFER-LIST can be list of buffers or list of strings."
 901   (let ((case-fold-search (iswitchb-case))
 902          name ret)
 903     (if (null string-format) (setq regexp (regexp-quote regexp)))
 904     (setq iswitchb-invalid-regexp nil)
 905     (condition-case error
 906         (dolist (x buffer-list (nreverse ret))
 907           (setq name (if (stringp x) x (buffer-name x)))
 908           (when (and (string-match regexp name)
 909                      (not (iswitchb-ignore-buffername-p name)))
 910             (push name ret)))
 911       (invalid-regexp
 912        (setq iswitchb-invalid-regexp t)
 913        (cdr error)))))
 914
 915 (defun iswitchb-ignore-buffername-p (bufname)
 916   "Return t if the buffer BUFNAME should be ignored."
 917   (let ((data       (match-data))
 918         (re-list    iswitchb-buffer-ignore)
 919         ignorep
 920         nextstr)
 921     (while re-list
 922       (setq nextstr (car re-list))
 923       (cond
 924        ((stringp nextstr)
 925         (if (string-match nextstr bufname)
 926             (progn
 927               (setq ignorep t)
 928               (setq re-list nil))))
 929        ((functionp nextstr)
 930         (if (funcall nextstr bufname)
 931             (progn
 932               (setq ignorep t)
 933               (setq re-list nil)))))
 934       (setq re-list (cdr re-list)))
 935     (set-match-data data)
 936
 937     ;; return the result
 938     ignorep))
 939
 940 (defun iswitchb-word-matching-substring (word)
 941   "Return part of WORD before 1st match to `iswitchb-change-word-sub'.
 942 If `iswitchb-change-word-sub' cannot be found in WORD, return nil."
 943   (let ((case-fold-search (iswitchb-case)))
 944     (let ((m (string-match iswitchb-change-word-sub word)))
 945       (if m
 946           (substring word m)
 947         ;; else no match
 948         nil))))
 949
 950 (defun iswitchb-find-common-substring (lis subs)
 951   "Return common string following SUBS in each element of LIS."
 952   (let (res
 953         alist
 954         iswitchb-change-word-sub)
 955     (setq iswitchb-change-word-sub
 956           (if iswitchb-regexp
 957               subs
 958             (regexp-quote subs)))
 959     (setq res (mapcar 'iswitchb-word-matching-substring lis))
 960     (setq res (delq nil res)) ;; remove any nil elements (shouldn't happen)
 961     (setq alist (mapcar 'iswitchb-makealist res)) ;; could use an  OBARRAY
 962
 963     ;; try-completion returns t if there is an exact match.
 964     (let ((completion-ignore-case (iswitchb-case)))
 965
 966     (try-completion subs alist))))
 967
 968 (defun iswitchb-makealist (res)
 969   "Return dotted pair (RES . 1)."
 970   (cons res 1))
 971
 972 ;; from Wayne Mesard <wmesard@esd.sgi.com>
 973 (defun iswitchb-rotate-list (lis)
 974   "Destructively remove the last element from LIS.
 975 Return the modified list with the last element prepended to it."
 976   (if (<= (length lis) 1)
 977       lis
 978     (let ((las lis)
 979           (prev lis))
 980       (while (consp (cdr las))
 981         (setq prev las
 982               las (cdr las)))
 983       (setcdr prev nil)
 984       (cons (car las) lis))))
 985
 986 (defun iswitchb-completion-help ()
 987   "Show possible completions in a *Completions* buffer."
 988   ;; we could allow this buffer to be used to select match, but I think
 989   ;; choose-completion-string will need redefining, so it just inserts
 990   ;; choice with out any previous input.
 991   (interactive)
 992   (setq iswitchb-rescan nil)
 993   (let ((buf (current-buffer))
 994         (temp-buf "*Completions*")
 995         (win))
 996
 997     (if (and (eq last-command this-command)
 998              (not iswitchb-common-match-inserted))
 999         ;; scroll buffer
1000         (progn
1001           (set-buffer temp-buf)
1002           (setq win (get-buffer-window temp-buf))
1003           (if (pos-visible-in-window-p (point-max) win)
1004               (set-window-start win (point-min))
1005             (scroll-other-window))
1006           (set-buffer buf))
1007
1008       (with-output-to-temp-buffer temp-buf
1009         (if (featurep 'xemacs)
1010
1011             ;; XEmacs extents are put on by default, doesn't seem to be
1012             ;; any way of switching them off.
1013             (display-completion-list (if iswitchb-matches
1014                                          iswitchb-matches
1015                                        iswitchb-buflist)
1016                                      :help-string "iswitchb "
1017                                      :activate-callback
1018                                      (lambda (x y z)
1019                                        (message "doesn't work yet, sorry!")))
1020           ;; else running Emacs
1021           (with-current-buffer standard-output
1022             (fundamental-mode))
1023           (display-completion-list (if iswitchb-matches
1024                                        iswitchb-matches
1025                                      iswitchb-buflist))))
1026       (setq iswitchb-common-match-inserted nil))))
1027
1028 ;;; KILL CURRENT BUFFER
1029
1030 (defun iswitchb-kill-buffer ()
1031   "Kill the buffer at the head of `iswitchb-matches'."
1032   (interactive)
1033   (let ( (enable-recursive-minibuffers t)
1034          buf)
1035
1036     (setq buf (car iswitchb-matches))
1037     ;; check to see if buf is non-nil.
1038     (if buf
1039         (progn
1040           (kill-buffer buf)
1041
1042           ;; Check if buffer exists.  XEmacs gnuserv.el makes alias
1043           ;; for kill-buffer which does not return t if buffer is
1044           ;; killed, so we can't rely on kill-buffer return value.
1045           (if (get-buffer buf)
1046               ;; buffer couldn't be killed.
1047               (setq iswitchb-rescan t)
1048             ;; else buffer was killed so remove name from list.
1049             (setq iswitchb-buflist  (delq buf iswitchb-buflist)))))))
1050
1051 ;;; VISIT CHOSEN BUFFER
1052 (defun iswitchb-visit-buffer (buffer)
1053   "Visit buffer named BUFFER according to `iswitchb-method'."
1054   (let (win newframe)
1055     (cond
1056      ((eq iswitchb-method 'samewindow)
1057       (switch-to-buffer buffer))
1058
1059      ((memq iswitchb-method '(always-frame maybe-frame))
1060       (cond
1061        ((and (setq win (iswitchb-window-buffer-p buffer))
1062              (or (eq iswitchb-method 'always-frame)
1063                  (y-or-n-p "Jump to frame? ")))
1064         (setq newframe (window-frame win))
1065         (if (fboundp 'select-frame-set-input-focus)
1066             (select-frame-set-input-focus newframe)
1067           (raise-frame newframe)
1068           (select-frame newframe)
1069           )
1070         (select-window win))
1071        (t
1072         ;;  No buffer in other frames...
1073         (switch-to-buffer buffer)
1074         )))
1075
1076      ((eq iswitchb-method 'otherwindow)
1077       (switch-to-buffer-other-window buffer))
1078
1079      ((eq iswitchb-method 'display)
1080       (display-buffer buffer))
1081
1082      ((eq iswitchb-method 'otherframe)
1083       (progn
1084         (switch-to-buffer-other-frame buffer)
1085         (if (fboundp 'select-frame-set-input-focus)
1086             (select-frame-set-input-focus (selected-frame)))
1087         )))))
1088
1089 (defun iswitchb-possible-new-buffer (buf)
1090   "Possibly create and visit a new buffer called BUF."
1091
1092   (let ((newbufcreated))
1093     (if (and iswitchb-newbuffer
1094              (or
1095               (not iswitchb-prompt-newbuffer)
1096
1097               (and iswitchb-prompt-newbuffer
1098                    (y-or-n-p
1099                     (format
1100                      "No buffer matching `%s', create one? "
1101                      buf)))))
1102         ;; then create a new buffer
1103         (progn
1104           (setq newbufcreated (get-buffer-create buf))
1105           (if (fboundp 'set-buffer-major-mode)
1106               (set-buffer-major-mode newbufcreated))
1107           (iswitchb-visit-buffer newbufcreated))
1108       ;; else wont create new buffer
1109       (message "no buffer matching `%s'" buf))))
1110
1111 (defun iswitchb-window-buffer-p  (buffer)
1112   "Return window pointer if BUFFER is visible in another frame.
1113 If BUFFER is visible in the current frame, return nil."
1114   (interactive)
1115   (let ((blist (iswitchb-get-buffers-in-frames 'current)))
1116     ;;If the buffer is visible in current frame, return nil
1117     (if (memq buffer blist)
1118         nil
1119       ;;  maybe in other frame or icon
1120       (get-buffer-window buffer 0) ; better than 'visible
1121       )))
1122
1123 (defun iswitchb-default-keybindings ()
1124   "Set up default keybindings for `iswitchb-buffer'.
1125 Call this function to override the normal bindings.  This function also
1126 adds a hook to the minibuffer."
1127   (interactive)
1128   (add-hook 'minibuffer-setup-hook 'iswitchb-minibuffer-setup)
1129   (global-set-key "\C-xb" 'iswitchb-buffer)
1130   (global-set-key "\C-x4b" 'iswitchb-buffer-other-window)
1131   (global-set-key "\C-x4\C-o" 'iswitchb-display-buffer)
1132   (global-set-key "\C-x5b" 'iswitchb-buffer-other-frame))
1133
1134 (make-obsolete 'iswitchb-default-keybindings 'iswitchb-mode "21.1")
1135
1136 (defun iswitchb-buffer ()
1137   "Switch to another buffer.
1138
1139 The buffer name is selected interactively by typing a substring.  The
1140 buffer is displayed according to `iswitchb-default-method' -- the
1141 default is to show it in the same window, unless it is already visible
1142 in another frame.
1143 For details of keybindings, do `\\[describe-function] iswitchb'."
1144   (interactive)
1145   (setq iswitchb-method iswitchb-default-method)
1146   (iswitchb))
1147
1148 (defun iswitchb-buffer-other-window ()
1149   "Switch to another buffer and show it in another window.
1150 The buffer name is selected interactively by typing a substring.
1151 For details of keybindings, do `\\[describe-function] iswitchb'."
1152   (interactive)
1153   (setq iswitchb-method 'otherwindow)
1154   (iswitchb))
1155
1156 (defun iswitchb-display-buffer ()
1157   "Display a buffer in another window but don't select it.
1158 The buffer name is selected interactively by typing a substring.
1159 For details of keybindings, do `\\[describe-function] iswitchb'."
1160   (interactive)
1161   (setq iswitchb-method 'display)
1162   (iswitchb))
1163
1164 (defun iswitchb-buffer-other-frame ()
1165   "Switch to another buffer and show it in another frame.
1166 The buffer name is selected interactively by typing a substring.
1167 For details of keybindings, do `\\[describe-function] iswitchb'."
1168   (interactive)
1169   (setq iswitchb-method 'otherframe)
1170   (iswitchb))
1171
1172 ;;; XEmacs hack for showing default buffer
1173
1174 ;; The first time we enter the minibuffer, Emacs puts up the default
1175 ;; buffer to switch to, but XEmacs doesn't -- presumably there is a
1176 ;; subtle difference in the two versions of post-command-hook.  The
1177 ;; default is shown for both whenever we delete all of our text
1178 ;; though, indicating its just a problem the first time we enter the
1179 ;; function.  To solve this, we use another entry hook for emacs to
1180 ;; show the default the first time we enter the minibuffer.
1181
1182 (defun iswitchb-init-XEmacs-trick ()
1183   "Display default buffer when first entering minibuffer.
1184 This is a hack for XEmacs, and should really be handled by `iswitchb-exhibit'."
1185   (if (iswitchb-entryfn-p)
1186       (progn
1187         (iswitchb-exhibit)
1188         (goto-char (point-min)))))
1189
1190 ;; add this hook for XEmacs only.
1191 (if (featurep 'xemacs)
1192     (add-hook 'iswitchb-minibuffer-setup-hook
1193               'iswitchb-init-XEmacs-trick))
1194
1195 ;;; XEmacs / backspace key
1196 ;; For some reason, if the backspace key is pressed in XEmacs, the
1197 ;; line gets confused, so I've added a simple key definition to make
1198 ;; backspace act like the normal delete key.
1199
1200 (defun iswitchb-xemacs-backspacekey ()
1201   "Bind backspace to `backward-delete-char'."
1202   (define-key iswitchb-mode-map '[backspace] 'backward-delete-char)
1203   (define-key iswitchb-mode-map '[(meta backspace)] 'backward-kill-word))
1204
1205 (if (featurep 'xemacs)
1206     (add-hook 'iswitchb-define-mode-map-hook
1207               'iswitchb-xemacs-backspacekey))
1208
1209 ;;; ICOMPLETE TYPE CODE
1210
1211 (defun iswitchb-exhibit ()
1212   "Find matching buffers and display a list in the minibuffer.
1213 Copied from `icomplete-exhibit' with two changes:
1214 1. It prints a default buffer name when there is no text yet entered.
1215 2. It calls my completion routine rather than the standard completion."
1216   (if iswitchb-use-mycompletion
1217       (let ((contents (buffer-substring (minibuffer-prompt-end) (point-max)))
1218             (buffer-undo-list t))
1219         (save-excursion
1220           (goto-char (point-max))
1221                                         ; Register the end of input, so we
1222                                         ; know where the extra stuff
1223                                         ; (match-status info) begins:
1224           (if (not (boundp 'iswitchb-eoinput))
1225               ;; In case it got wiped out by major mode business:
1226               (make-local-variable 'iswitchb-eoinput))
1227           (setq iswitchb-eoinput (point))
1228           ;; Update the list of matches
1229           (setq iswitchb-text contents)
1230           (iswitchb-set-matches)
1231           (setq iswitchb-rescan t)
1232           (iswitchb-set-common-completion)
1233
1234           ;; Insert the match-status information:
1235           (insert (iswitchb-completions
1236                    contents))))))
1237
1238 (defvar most-len)
1239 (defvar most-is-exact)
1240
1241 (defun iswitchb-output-completion (com)
1242   (if (= (length com) most-len)
1243       ;; Most is one exact match,
1244       ;; note that and leave out
1245       ;; for later indication:
1246       (ignore
1247        (setq most-is-exact t))
1248     (substring com most-len)))
1249
1250 (defun iswitchb-completions (name)
1251   "Return the string that is displayed after the user's text.
1252 Modified from `icomplete-completions'."
1253
1254   (let ((comps iswitchb-matches)
1255                                         ; "-determined" - only one candidate
1256         (open-bracket-determined "[")
1257         (close-bracket-determined "]")
1258                                         ;"-prospects" - more than one candidate
1259         (open-bracket-prospects "{")
1260         (close-bracket-prospects "}")
1261         first)
1262
1263     (if (and iswitchb-use-faces comps)
1264         (progn
1265           (setq first (car comps))
1266           (setq first (format "%s" first))
1267           (put-text-property 0 (length first) 'face
1268                              (if (= (length comps) 1)
1269                                  (if iswitchb-invalid-regexp
1270                                      'iswitchb-invalid-regexp
1271                                    'iswitchb-single-match)
1272                                'iswitchb-current-match)
1273                              first)
1274           (setq comps  (cons first (cdr comps)))))
1275
1276     ;; If no buffers matched, and virtual buffers are being used, then
1277     ;; consult the list of past visited files, to see if we can find
1278     ;; the file which the user might thought was still open.
1279     (when (and iswitchb-use-virtual-buffers (null comps)
1280                recentf-list)
1281       (setq iswitchb-virtual-buffers nil)
1282       (let ((head recentf-list) name)
1283         (while head
1284           (if (and (setq name (file-name-nondirectory (car head)))
1285                    (string-match (if iswitchb-regexp
1286                                      iswitchb-text
1287                                    (regexp-quote iswitchb-text)) name)
1288                    (null (get-file-buffer (car head)))
1289                    (not (assoc name iswitchb-virtual-buffers))
1290                    (not (iswitchb-ignore-buffername-p name))
1291                    (file-exists-p (car head)))
1292               (setq iswitchb-virtual-buffers
1293                     (cons (cons name (car head))
1294                           iswitchb-virtual-buffers)))
1295           (setq head (cdr head)))
1296         (setq iswitchb-virtual-buffers (nreverse iswitchb-virtual-buffers)
1297               comps (mapcar 'car iswitchb-virtual-buffers))
1298         (let ((comp comps))
1299           (while comp
1300             (put-text-property 0 (length (car comp))
1301                                'face 'iswitchb-virtual-matches
1302                                (car comp))
1303             (setq comp (cdr comp))))))
1304
1305     (cond ((null comps) (format " %sNo match%s"
1306                                 open-bracket-determined
1307                                 close-bracket-determined))
1308
1309           (iswitchb-invalid-regexp
1310            (concat " " (car comps)))
1311           ((null (cdr comps))           ;one match
1312            (concat
1313             (if (if (not iswitchb-regexp)
1314                     (= (length name)
1315                        (length (car comps)))
1316                   (string-match name (car comps))
1317                   (string-equal (match-string 0 (car comps))
1318                                 (car comps)))
1319                 ""
1320               (concat open-bracket-determined
1321                                ;; when there is one match, show the
1322                                ;; matching buffer name in full
1323                                (car comps)
1324                                close-bracket-determined))
1325                    (if (not iswitchb-use-faces) " [Matched]")))
1326           (t                            ;multiple matches
1327            (if (and iswitchb-max-to-show
1328                     (> (length comps) iswitchb-max-to-show))
1329                (setq comps
1330                      (append
1331                       (let ((res nil)
1332                             (comp comps)
1333                             (end (/ iswitchb-max-to-show 2)))
1334                         (while (>= (setq end (1- end)) 0)
1335                           (setq res (cons (car comp) res)
1336                                 comp (cdr comp)))
1337                         (nreverse res))
1338                       (list "...")
1339                       (nthcdr (- (length comps)
1340                                  (/ iswitchb-max-to-show 2)) comps))))
1341            (let* (
1342                   ;;(most (try-completion name candidates predicate))
1343                   (most nil)
1344                   (most-len (length most))
1345                   most-is-exact
1346                   (alternatives
1347                    (mapconcat (if most 'iswitchb-output-completion
1348                                 'identity) comps iswitchb-delim)))
1349
1350              (concat
1351
1352               ;; put in common completion item -- what you get by
1353               ;; pressing tab
1354               (if (and (stringp iswitchb-common-match-string)
1355                        (> (length iswitchb-common-match-string) (length name)))
1356                   (concat open-bracket-determined
1357                           (substring iswitchb-common-match-string
1358                                      (length name))
1359                           close-bracket-determined))
1360               ;; end of partial matches...
1361
1362               ;; think this bit can be ignored.
1363               (and (> most-len (length name))
1364                    (concat open-bracket-determined
1365                            (substring most (length name))
1366                            close-bracket-determined))
1367
1368               ;; list all alternatives
1369               open-bracket-prospects
1370               (if most-is-exact
1371                   (concat iswitchb-delim alternatives)
1372                 alternatives)
1373               close-bracket-prospects))))))
1374
1375 (defun iswitchb-minibuffer-setup ()
1376   "Set up minibuffer for `iswitchb-buffer'.
1377 Copied from `icomplete-minibuffer-setup-hook'."
1378   (when (iswitchb-entryfn-p)
1379     (set (make-local-variable 'iswitchb-use-mycompletion) t)
1380     (add-hook 'pre-command-hook 'iswitchb-pre-command nil t)
1381     (add-hook 'post-command-hook 'iswitchb-post-command nil t)
1382     (run-hooks 'iswitchb-minibuffer-setup-hook)))
1383
1384 (defun iswitchb-pre-command ()
1385   "Run before command in `iswitchb-buffer'."
1386   (iswitchb-tidy))
1387
1388 (defun iswitchb-post-command ()
1389   "Run after command in `iswitchb-buffer'."
1390   (iswitchb-exhibit))
1391
1392 (defun iswitchb-tidy ()
1393   "Remove completions display, if any, prior to new user input.
1394 Copied from `icomplete-tidy'."
1395
1396   (if (and (boundp 'iswitchb-eoinput)
1397            iswitchb-eoinput)
1398
1399       (if (> iswitchb-eoinput (point-max))
1400           ;; Oops, got rug pulled out from under us - reinit:
1401           (setq iswitchb-eoinput (point-max))
1402         (let ((buffer-undo-list buffer-undo-list )) ; prevent entry
1403           (delete-region iswitchb-eoinput (point-max))))
1404
1405     ;; Reestablish the local variable 'cause minibuffer-setup is weird:
1406     (make-local-variable 'iswitchb-eoinput)
1407     (setq iswitchb-eoinput 1)))
1408
1409 (defun iswitchb-entryfn-p ()
1410   "Return non-nil if we are using `iswitchb-buffer'."
1411   (eq iswitchb-minibuf-depth (minibuffer-depth)))
1412
1413 (defun iswitchb-summaries-to-end ()
1414   "Move the summaries to the end of the list.
1415 This is an example function which can be hooked on to
1416 `iswitchb-make-buflist-hook'.  Any buffer matching the regexps
1417 `Summary' or `output\*$'are put to the end of the list."
1418   (let ((summaries (delq nil
1419                          (mapcar
1420                           (lambda (x)
1421                             (if (string-match "Summary\\|output\\*$" x)
1422                                 x))
1423                           iswitchb-temp-buflist))))
1424     (iswitchb-to-end summaries)))
1425
1426 (defun iswitchb-case ()
1427   "Return non-nil if we should ignore case when matching.
1428 See the variable `iswitchb-case' for details."
1429   (if iswitchb-case
1430       (if (featurep 'xemacs)
1431           (isearch-no-upper-case-p iswitchb-text)
1432         (isearch-no-upper-case-p iswitchb-text t))))
1433
1434 ;;;###autoload
1435 (define-minor-mode iswitchb-mode
1436   "Toggle Iswitchb global minor mode.
1437 With arg, turn Iswitchb mode on if ARG is positive, otherwise turn it off.
1438 This mode enables switching between buffers using substrings.  See
1439 `iswitchb' for details."
1440   nil nil iswitchb-global-map :global t :group 'iswitchb
1441   (if iswitchb-mode
1442       (add-hook 'minibuffer-setup-hook 'iswitchb-minibuffer-setup)
1443     (remove-hook 'minibuffer-setup-hook 'iswitchb-minibuffer-setup)))
1444
1445 (provide 'iswitchb)
1446
1447 ;; arch-tag: d74198ae-753f-44f2-b34f-0c515398d90a
1448 ;;; iswitchb.el ends here