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 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 behaviour 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 behaviour 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 (defvar iswitchb-all-frames 'visible
 372   "*Argument to pass to `walk-windows' when finding visible buffers.
 373 See documentation of `walk-windows' for useful values.")
 374
 375 (defcustom iswitchb-minibuffer-setup-hook nil
 376   "Iswitchb-specific customization of minibuffer setup.
 377
 378 This hook is run during minibuffer setup if `iswitchb' is active.
 379 For instance:
 380 \(add-hook 'iswitchb-minibuffer-setup-hook
 381           '\(lambda () (set (make-local-variable 'max-mini-window-height) 3)))
 382 will constrain the minibuffer to a maximum height of 3 lines when
 383 iswitchb is running."
 384   :type 'hook
 385   :group 'iswitchb)
 386
 387 (defface iswitchb-single-match
 388   '((t
 389      (:inherit font-lock-comment-face)))
 390   "Iswitchb face for single matching buffer name."
 391   :version "22.1"
 392   :group 'iswitchb)
 393
 394 (defface iswitchb-current-match
 395   '((t
 396      (:inherit font-lock-function-name-face)))
 397   "Iswitchb face for current matching buffer name."
 398   :version "22.1"
 399   :group 'iswitchb)
 400
 401 (defface iswitchb-virtual-matches
 402   '((t
 403      (:inherit font-lock-builtin-face)))
 404   "Iswitchb face for matching virtual buffer names.
 405 See also `iswitchb-use-virtual-buffers'."
 406   :version "22.1"
 407   :group 'iswitchb)
 408
 409 (defface iswitchb-invalid-regexp
 410   '((t
 411      (:inherit font-lock-warning-face)))
 412   "Iswitchb face for indicating invalid regexp. "
 413   :version "22.1"
 414   :group 'iswitchb)
 415
 416 ;; Do we need the variable iswitchb-use-mycompletion?
 417
 418 ;;; Internal Variables
 419
 420 (defvar iswitchb-method nil
 421   "Stores the method for viewing the selected buffer.
 422 Its value is one of `samewindow', `otherwindow', `display', `otherframe',
 423 `maybe-frame' or `always-frame'.  See `iswitchb-default-method' for
 424 details of values.")
 425
 426 (defvar iswitchb-eoinput 1
 427   "Point where minibuffer input ends and completion info begins.
 428 Copied from `icomplete-eoinput'.")
 429 (make-variable-buffer-local 'iswitchb-eoinput)
 430
 431 (defvar iswitchb-buflist nil
 432   "Stores the current list of buffers that will be searched through.
 433 The list is ordered, so that the most recent buffers come first,
 434 although by default, the buffers visible in the current frame are put
 435 at the end of the list.  Created by `iswitchb-make-buflist'.")
 436
 437 ;; todo -- is this necessary?
 438
 439 (defvar iswitchb-use-mycompletion nil
 440   "Non-nil means use `iswitchb-buffer' completion feedback.
 441 Should only be set to t by iswitchb functions, so that it doesn't
 442 interfere with other minibuffer usage.")
 443
 444 (defvar iswitchb-change-word-sub nil
 445   "Private variable used by `iswitchb-word-matching-substring'.")
 446
 447 (defvar iswitchb-common-match-string  nil
 448   "Stores the string that is common to all matching buffers.")
 449
 450 (defvar iswitchb-rescan nil
 451   "Non-nil means we need to regenerate the list of matching buffers.")
 452
 453 (defvar iswitchb-text nil
 454   "Stores the users string as it is typed in.")
 455
 456 (defvar iswitchb-matches nil
 457   "List of buffers currently matching `iswitchb-text'.")
 458
 459 (defvar iswitchb-mode-map
 460   (let ((map (make-sparse-keymap)))
 461     (set-keymap-parent map minibuffer-local-map)
 462     (define-key map "?" 'iswitchb-completion-help)
 463     (define-key map "\C-s" 'iswitchb-next-match)
 464     (define-key map "\C-r" 'iswitchb-prev-match)
 465     (define-key map "\t" 'iswitchb-complete)
 466     (define-key map "\C-j" 'iswitchb-select-buffer-text)
 467     (define-key map "\C-t" 'iswitchb-toggle-regexp)
 468     (define-key map "\C-x\C-f" 'iswitchb-find-file)
 469     (define-key map "\C-c" 'iswitchb-toggle-case)
 470     (define-key map "\C-k" 'iswitchb-kill-buffer)
 471     (define-key map "\C-m" 'iswitchb-exit-minibuffer)
 472     map)
 473   "Minibuffer keymap for `iswitchb-buffer'.")
 474
 475 (defvar iswitchb-global-map
 476   (let ((map (make-sparse-keymap)))
 477     (dolist (b '((switch-to-buffer . iswitchb-buffer)
 478                  (switch-to-buffer-other-window . iswitchb-buffer-other-window)
 479                  (switch-to-buffer-other-frame . iswitchb-buffer-other-frame)
 480                  (display-buffer . iswitchb-display-buffer)))
 481       (if (fboundp 'command-remapping)
 482           (define-key map (vector 'remap (car b)) (cdr b))
 483         (substitute-key-definition (car b) (cdr b) map global-map)))
 484     map)
 485   "Global keymap for `iswitchb-mode'.")
 486
 487 (defvar iswitchb-history nil
 488   "History of buffers selected using `iswitchb-buffer'.")
 489
 490 (defvar iswitchb-exit nil
 491   "Flag to monitor how `iswitchb-buffer' exits.
 492 If equal to `takeprompt', we use the prompt as the buffer name to be
 493 selected.")
 494
 495 (defvar iswitchb-buffer-ignore-orig nil
 496   "Stores original value of `iswitchb-buffer-ignore'.")
 497
 498 (defvar iswitchb-default nil
 499   "Default buffer for iswitchb.")
 500
 501 ;; The following variables are needed to keep the byte compiler quiet.
 502 (defvar iswitchb-require-match nil
 503   "Non-nil if matching buffer must be selected.")
 504
 505 (defvar iswitchb-temp-buflist nil
 506   "Stores a temporary version of the buffer list being created.")
 507
 508 (defvar iswitchb-bufs-in-frame nil
 509   "List of the buffers visible in the current frame.")
 510
 511 (defvar iswitchb-minibuf-depth nil
 512   "Value we expect to be returned by `minibuffer-depth' in the minibuffer.")
 513
 514 (defvar iswitchb-common-match-inserted nil
 515   "Non-nil if we have just inserted a common match in the minibuffer.")
 516
 517 (defvar iswitchb-invalid-regexp)
 518
 519 ;;; FUNCTIONS
 520
 521 ;;; ISWITCHB KEYMAP
 522 (defun iswitchb-define-mode-map ()
 523   "Set up the keymap for `iswitchb-buffer'."
 524   (interactive)
 525   (let (map)
 526     ;; generated every time so that it can inherit new functions.
 527     ;;(or iswitchb-mode-map
 528
 529     (setq map (copy-keymap minibuffer-local-map))
 530     (define-key map "?" 'iswitchb-completion-help)
 531     (define-key map "\C-s" 'iswitchb-next-match)
 532     (define-key map "\C-r" 'iswitchb-prev-match)
 533     (define-key map "\t" 'iswitchb-complete)
 534     (define-key map "\C-j" 'iswitchb-select-buffer-text)
 535     (define-key map "\C-t" 'iswitchb-toggle-regexp)
 536     (define-key map "\C-x\C-f" 'iswitchb-find-file)
 537     (define-key map "\C-n" 'iswitchb-toggle-ignore)
 538     (define-key map "\C-c" 'iswitchb-toggle-case)
 539     (define-key map "\C-k" 'iswitchb-kill-buffer)
 540     (define-key map "\C-m" 'iswitchb-exit-minibuffer)
 541     (setq iswitchb-mode-map map)
 542     (run-hooks 'iswitchb-define-mode-map-hook)))
 543
 544 (make-obsolete 'iswitchb-define-mode-map
 545                "use M-x iswitchb-mode or customize the variable `iswitchb-mode'."
 546                "21.1")
 547
 548 ;;; MAIN FUNCTION
 549 (defun iswitchb ()
 550   "Switch to buffer matching a substring.
 551 As you type in a string, all of the buffers matching the string are
 552 displayed.  When you have found the buffer you want, it can then be
 553 selected.  As you type, most keys have their normal keybindings,
 554 except for the following:
 555 \\<iswitchb-mode-map>
 556
 557 RET Select the buffer at the front of the list of matches.  If the
 558 list is empty, possibly prompt to create new buffer.
 559
 560 \\[iswitchb-select-buffer-text] Select the current prompt as the buffer.
 561 If no buffer is found, prompt for a new one.
 562
 563 \\[iswitchb-next-match] Put the first element at the end of the list.
 564 \\[iswitchb-prev-match] Put the last element at the start of the list.
 565 \\[iswitchb-complete] Complete a common suffix to the current string that
 566 matches all buffers.  If there is only one match, select that buffer.
 567 If there is no common suffix, show a list of all matching buffers
 568 in a separate window.
 569 \\[iswitchb-toggle-regexp] Toggle regexp searching.
 570 \\[iswitchb-toggle-case] Toggle case-sensitive searching of buffer names.
 571 \\[iswitchb-completion-help] Show list of matching buffers in separate window.
 572 \\[iswitchb-find-file] Exit iswitchb and drop into `find-file'.
 573 \\[iswitchb-kill-buffer] Kill buffer at head of buffer list."
 574   ;;\\[iswitchb-toggle-ignore] Toggle ignoring certain buffers (see \
 575   ;;`iswitchb-buffer-ignore')
 576
 577   (let* ((prompt "iswitch ")
 578          iswitchb-invalid-regexp
 579          (buf (iswitchb-read-buffer prompt)))
 580
 581     ;;(message "chosen text %s" iswitchb-final-text)
 582     ;; Choose the buffer name: either the text typed in, or the head
 583     ;; of the list of matches
 584
 585     (cond ( (eq iswitchb-exit 'findfile)
 586             (call-interactively 'find-file))
 587           (iswitchb-invalid-regexp
 588            (message "Won't make invalid regexp named buffer"))
 589           (t
 590            ;; View the buffer
 591            ;;(message "go to buf %s" buf)
 592            ;; Check buf is non-nil.
 593            (if buf
 594                (if (get-buffer buf)
 595                    ;; buffer exists, so view it and then exit
 596                    (iswitchb-visit-buffer buf)
 597                  ;; else buffer doesn't exist
 598                  (iswitchb-possible-new-buffer buf)))
 599            ))))
 600
 601 (defun iswitchb-read-buffer (prompt &optional default require-match
 602                                     start matches-set)
 603   "Replacement for the built-in `read-buffer'.
 604 Return the name of a buffer selected.
 605 PROMPT is the prompt to give to the user.
 606 DEFAULT if given is the default buffer to be selected, which will
 607 go to the front of the list.
 608 If REQUIRE-MATCH is non-nil, an existing buffer must be selected.
 609 If START is a string, the selection process is started with that
 610 string.
 611 If MATCHES-SET is non-nil, the buflist is not updated before
 612 the selection process begins.  Used by isearchb.el."
 613   (let
 614       (
 615        buf-sel
 616        iswitchb-final-text
 617        (icomplete-mode nil) ;; prevent icomplete starting up
 618        )
 619
 620     (iswitchb-define-mode-map)
 621     (setq iswitchb-exit nil)
 622     (setq iswitchb-default
 623           (if (bufferp default)
 624               (buffer-name default)
 625             default))
 626     (setq iswitchb-text (or start ""))
 627     (unless matches-set
 628       (setq iswitchb-rescan t)
 629       (iswitchb-make-buflist iswitchb-default)
 630       (iswitchb-set-matches))
 631     (let
 632         ((minibuffer-local-completion-map iswitchb-mode-map)
 633          ;; Record the minibuffer depth that we expect to find once
 634          ;; the minibuffer is set up and iswitchb-entryfn-p is called.
 635          (iswitchb-minibuf-depth (1+ (minibuffer-depth)))
 636          (iswitchb-require-match require-match))
 637       ;; prompt the user for the buffer name
 638       (setq iswitchb-final-text (completing-read
 639                                  prompt           ;the prompt
 640                                  '(("dummy" . 1)) ;table
 641                                  nil              ;predicate
 642                                  nil ;require-match [handled elsewhere]
 643                                  start  ;initial-contents
 644                                  'iswitchb-history)))
 645     (if (and (not (eq iswitchb-exit 'usefirst))
 646              (get-buffer iswitchb-final-text))
 647         ;; This happens for example if the buffer was chosen with the mouse.
 648         (setq iswitchb-matches (list iswitchb-final-text)
 649               iswitchb-virtual-buffers nil))
 650
 651     ;; If no buffer matched, but a virtual buffer was selected, visit
 652     ;; that file now and act as though that buffer had been selected.
 653     (if (and iswitchb-virtual-buffers
 654              (not (iswitchb-existing-buffer-p)))
 655         (let ((virt (car iswitchb-virtual-buffers)))
 656           (find-file-noselect (cdr virt))
 657           (setq iswitchb-matches (list (car virt))
 658                 iswitchb-virtual-buffers nil)))
 659
 660     ;; Handling the require-match must be done in a better way.
 661     (if (and require-match
 662              (not (iswitchb-existing-buffer-p)))
 663         (error "Must specify valid buffer"))
 664
 665     (if (or (eq iswitchb-exit 'takeprompt)
 666             (null iswitchb-matches))
 667         (setq buf-sel iswitchb-final-text)
 668       ;; else take head of list
 669       (setq buf-sel (car iswitchb-matches)))
 670
 671     ;; Or possibly choose the default buffer
 672     (if  (equal iswitchb-final-text "")
 673         (setq buf-sel (car iswitchb-matches)))
 674
 675     buf-sel))
 676
 677 (defun iswitchb-existing-buffer-p ()
 678   "Return non-nil if there is a matching buffer."
 679   (not (null iswitchb-matches)))
 680
 681 ;;; COMPLETION CODE
 682
 683 (defun iswitchb-set-common-completion  ()
 684   "Find common completion of `iswitchb-text' in `iswitchb-matches'.
 685 The result is stored in `iswitchb-common-match-string'."
 686
 687   (let (val)
 688     (setq  iswitchb-common-match-string nil)
 689     (if (and iswitchb-matches
 690              (not iswitchb-regexp) ;; testing
 691              (stringp iswitchb-text)
 692              (> (length iswitchb-text) 0))
 693         (if (setq val (iswitchb-find-common-substring
 694                        iswitchb-matches iswitchb-text))
 695             (setq iswitchb-common-match-string val)))
 696     val))
 697
 698 (defun iswitchb-complete ()
 699   "Try and complete the current pattern amongst the buffer names."
 700   (interactive)
 701   (let (res)
 702     (cond ((not  iswitchb-matches)
 703            (run-hooks 'iswitchb-cannot-complete-hook))
 704           (iswitchb-invalid-regexp
 705            ;; Do nothing
 706            )
 707           ((= 1 (length iswitchb-matches))
 708            ;; only one choice, so select it.
 709            (exit-minibuffer))
 710
 711           (t
 712            ;; else there could be some completions
 713            (setq res iswitchb-common-match-string)
 714            (if (and (not (memq res '(t nil)))
 715                     (not (equal res iswitchb-text)))
 716                ;; found something to complete, so put it in the minibuffer.
 717                (progn
 718                  (setq iswitchb-rescan nil
 719                        iswitchb-common-match-inserted t)
 720                  (delete-region (minibuffer-prompt-end) (point))
 721                  (insert  res))
 722              ;; else nothing to complete
 723              (run-hooks 'iswitchb-cannot-complete-hook)
 724              )))))
 725
 726 ;;; TOGGLE FUNCTIONS
 727
 728 (defun iswitchb-toggle-case ()
 729   "Toggle the value of variable `iswitchb-case'."
 730   (interactive)
 731   (setq iswitchb-case (not iswitchb-case))
 732   ;; ask for list to be regenerated.
 733   (setq iswitchb-rescan t))
 734
 735 (defun iswitchb-toggle-regexp ()
 736   "Toggle the value of `iswitchb-regexp'."
 737   (interactive)
 738   (setq iswitchb-regexp (not iswitchb-regexp))
 739   ;; ask for list to be regenerated.
 740   (setq iswitchb-rescan t))
 741
 742 (defun iswitchb-toggle-ignore ()
 743   "Toggle ignoring buffers specified with `iswitchb-buffer-ignore'."
 744   (interactive)
 745   (if iswitchb-buffer-ignore
 746       (progn
 747         (setq iswitchb-buffer-ignore-orig iswitchb-buffer-ignore)
 748         (setq iswitchb-buffer-ignore nil))
 749     ;; else
 750     (setq iswitchb-buffer-ignore iswitchb-buffer-ignore-orig))
 751   (iswitchb-make-buflist iswitchb-default)
 752   ;; ask for list to be regenerated.
 753   (setq iswitchb-rescan t))
 754
 755 (defun iswitchb-exit-minibuffer ()
 756   "Exit minibuffer, but make sure we have a match if one is needed."
 757   (interactive)
 758   (if (or (not iswitchb-require-match)
 759            (iswitchb-existing-buffer-p))
 760       (progn
 761         (setq iswitchb-exit 'usefirst)
 762         (throw 'exit nil))))
 763
 764 (defun iswitchb-select-buffer-text ()
 765   "Select the buffer named by the prompt.
 766 If no buffer exactly matching the prompt exists, maybe create a new one."
 767   (interactive)
 768   (setq iswitchb-exit 'takeprompt)
 769   (exit-minibuffer))
 770
 771 (defun iswitchb-find-file ()
 772   "Drop into `find-file' from buffer switching."
 773   (interactive)
 774   (setq iswitchb-exit 'findfile)
 775   (exit-minibuffer))
 776
 777 (defvar recentf-list)
 778
 779 (defun iswitchb-next-match ()
 780   "Put first element of `iswitchb-matches' at the end of the list."
 781   (interactive)
 782   (let ((next  (cadr iswitchb-matches)))
 783     (if (and (null next) iswitchb-virtual-buffers)
 784         (setq recentf-list
 785               (iswitchb-chop recentf-list
 786                              (cdr (cadr iswitchb-virtual-buffers))))
 787       (setq iswitchb-buflist (iswitchb-chop iswitchb-buflist next)))
 788     (setq iswitchb-rescan t)))
 789
 790 (defun iswitchb-prev-match ()
 791   "Put last element of `iswitchb-matches' at the front of the list."
 792   (interactive)
 793   (let ((prev  (car (last iswitchb-matches))))
 794     (if (and (null prev) iswitchb-virtual-buffers)
 795         (setq recentf-list
 796               (iswitchb-chop recentf-list
 797                              (cdr (car (last iswitchb-virtual-buffers)))))
 798       (setq iswitchb-buflist (iswitchb-chop iswitchb-buflist prev)))
 799     (setq iswitchb-rescan t)))
 800
 801 (defun iswitchb-chop (list elem)
 802   "Remove all elements before ELEM and put them at the end of LIST."
 803   (let ((ret nil)
 804         (next nil)
 805         (sofar nil))
 806     (while (not ret)
 807       (setq next (car list))
 808       (if (equal next elem)
 809           (setq ret (append list (nreverse sofar)))
 810         ;; else
 811         (progn
 812           (setq list (cdr list))
 813           (setq sofar (cons next sofar)))))
 814     ret))
 815
 816 ;;; CREATE LIST OF ALL CURRENT BUFFERS
 817
 818 (defun iswitchb-make-buflist (default)
 819   "Set `iswitchb-buflist' to the current list of buffers.
 820 Currently visible buffers are put at the end of the list.
 821 The hook `iswitchb-make-buflist-hook' is run after the list has been
 822 created to allow the user to further modify the order of the buffer names
 823 in this list.  If DEFAULT is non-nil, and corresponds to an existing buffer,
 824 it is put to the start of the list."
 825   (setq iswitchb-buflist
 826         (let* ((iswitchb-current-buffers (iswitchb-get-buffers-in-frames))
 827                (iswitchb-temp-buflist
 828                 (delq nil
 829                       (mapcar
 830                        (lambda (x)
 831                          (let ((b-name (buffer-name x)))
 832                            (if (not
 833                                 (or
 834                                  (iswitchb-ignore-buffername-p b-name)
 835                                  (memq b-name iswitchb-current-buffers)))
 836                                b-name)))
 837                        (buffer-list (and iswitchb-use-frame-buffer-list
 838                                          (selected-frame)))))))
 839           (setq iswitchb-temp-buflist
 840                 (nconc iswitchb-temp-buflist iswitchb-current-buffers))
 841           (run-hooks 'iswitchb-make-buflist-hook)
 842          ;; Should this be after the hooks, or should the hooks be the
 843           ;; final thing to be run?
 844           (if default
 845               (progn
 846                 (setq iswitchb-temp-buflist
 847                       (delete default iswitchb-temp-buflist))
 848                 (setq iswitchb-temp-buflist
 849                       (cons default iswitchb-temp-buflist))))
 850           iswitchb-temp-buflist)))
 851
 852 (defun iswitchb-to-end (lst)
 853   "Move the elements from LST to the end of `iswitchb-temp-buflist'."
 854   (dolist (elem lst)
 855     (setq iswitchb-temp-buflist (delq elem iswitchb-temp-buflist)))
 856   (setq iswitchb-temp-buflist (nconc iswitchb-temp-buflist lst)))
 857
 858 (defun iswitchb-get-buffers-in-frames (&optional current)
 859   "Return the list of buffers that are visible in the current frame.
 860 If optional argument CURRENT is given, restrict searching to the
 861 current frame, rather than all frames, regardless of value of
 862 `iswitchb-all-frames'."
 863   (let ((iswitchb-bufs-in-frame nil))
 864     (walk-windows 'iswitchb-get-bufname nil
 865                   (if current
 866                       nil
 867                     iswitchb-all-frames))
 868     iswitchb-bufs-in-frame))
 869
 870 (defun iswitchb-get-bufname (win)
 871   "Used by `iswitchb-get-buffers-in-frames' to walk through all windows."
 872   (let ((buf (buffer-name (window-buffer win))))
 873         (if (not (member buf iswitchb-bufs-in-frame))
 874             ;; Only add buf if it is not already in list.
 875             ;; This prevents same buf in two different windows being
 876             ;; put into the list twice.
 877             (setq iswitchb-bufs-in-frame
 878                   (cons buf iswitchb-bufs-in-frame)))))
 879
 880 ;;; FIND MATCHING BUFFERS
 881
 882 (defun iswitchb-set-matches ()
 883   "Set `iswitchb-matches' to the list of buffers matching prompt."
 884   (if iswitchb-rescan
 885       (setq iswitchb-matches
 886             (let ((buflist iswitchb-buflist))
 887               (iswitchb-get-matched-buffers iswitchb-text iswitchb-regexp
 888                                             buflist))
 889             iswitchb-virtual-buffers nil)))
 890
 891 (defun iswitchb-get-matched-buffers (regexp
 892                                      &optional string-format buffer-list)
 893   "Return buffers matching REGEXP.
 894 If STRING-FORMAT is nil, consider REGEXP as just a string.
 895 BUFFER-LIST can be list of buffers or list of strings."
 896   (let ((case-fold-search (iswitchb-case))
 897          name ret)
 898     (if (null string-format) (setq regexp (regexp-quote regexp)))
 899     (setq iswitchb-invalid-regexp nil)
 900     (condition-case error
 901         (dolist (x buffer-list (nreverse ret))
 902           (setq name (if (stringp x) x (buffer-name x)))
 903           (when (and (string-match regexp name)
 904                      (not (iswitchb-ignore-buffername-p name)))
 905             (push name ret)))
 906       (invalid-regexp
 907        (setq iswitchb-invalid-regexp t)
 908        (cdr error)))))
 909
 910 (defun iswitchb-ignore-buffername-p (bufname)
 911   "Return t if the buffer BUFNAME should be ignored."
 912   (let ((data       (match-data))
 913         (re-list    iswitchb-buffer-ignore)
 914         ignorep
 915         nextstr)
 916     (while re-list
 917       (setq nextstr (car re-list))
 918       (cond
 919        ((stringp nextstr)
 920         (if (string-match nextstr bufname)
 921             (progn
 922               (setq ignorep t)
 923               (setq re-list nil))))
 924        ((functionp nextstr)
 925         (if (funcall nextstr bufname)
 926             (progn
 927               (setq ignorep t)
 928               (setq re-list nil)))))
 929       (setq re-list (cdr re-list)))
 930     (set-match-data data)
 931
 932     ;; return the result
 933     ignorep))
 934
 935 (defun iswitchb-word-matching-substring (word)
 936   "Return part of WORD before 1st match to `iswitchb-change-word-sub'.
 937 If `iswitchb-change-word-sub' cannot be found in WORD, return nil."
 938   (let ((case-fold-search (iswitchb-case)))
 939     (let ((m (string-match iswitchb-change-word-sub word)))
 940       (if m
 941           (substring word m)
 942         ;; else no match
 943         nil))))
 944
 945 (defun iswitchb-find-common-substring (lis subs)
 946   "Return common string following SUBS in each element of LIS."
 947   (let (res
 948         alist
 949         iswitchb-change-word-sub)
 950     (setq iswitchb-change-word-sub
 951           (if iswitchb-regexp
 952               subs
 953             (regexp-quote subs)))
 954     (setq res (mapcar 'iswitchb-word-matching-substring lis))
 955     (setq res (delq nil res)) ;; remove any nil elements (shouldn't happen)
 956     (setq alist (mapcar 'iswitchb-makealist res)) ;; could use an  OBARRAY
 957
 958     ;; try-completion returns t if there is an exact match.
 959     (let ((completion-ignore-case (iswitchb-case)))
 960
 961     (try-completion subs alist))))
 962
 963 (defun iswitchb-makealist (res)
 964   "Return dotted pair (RES . 1)."
 965   (cons res 1))
 966
 967 ;; from Wayne Mesard <wmesard@esd.sgi.com>
 968 (defun iswitchb-rotate-list (lis)
 969   "Destructively remove the last element from LIS.
 970 Return the modified list with the last element prepended to it."
 971   (if (<= (length lis) 1)
 972       lis
 973     (let ((las lis)
 974           (prev lis))
 975       (while (consp (cdr las))
 976         (setq prev las
 977               las (cdr las)))
 978       (setcdr prev nil)
 979       (cons (car las) lis))))
 980
 981 (defun iswitchb-completion-help ()
 982   "Show possible completions in a *Completions* buffer."
 983   ;; we could allow this buffer to be used to select match, but I think
 984   ;; choose-completion-string will need redefining, so it just inserts
 985   ;; choice with out any previous input.
 986   (interactive)
 987   (setq iswitchb-rescan nil)
 988   (let ((buf (current-buffer))
 989         (temp-buf "*Completions*")
 990         (win))
 991
 992     (if (and (eq last-command this-command)
 993              (not iswitchb-common-match-inserted))
 994         ;; scroll buffer
 995         (progn
 996           (set-buffer temp-buf)
 997           (setq win (get-buffer-window temp-buf))
 998           (if (pos-visible-in-window-p (point-max) win)
 999               (set-window-start win (point-min))
1000             (scroll-other-window))
1001           (set-buffer buf))
1002
1003       (with-output-to-temp-buffer temp-buf
1004         (if (featurep 'xemacs)
1005
1006             ;; XEmacs extents are put on by default, doesn't seem to be
1007             ;; any way of switching them off.
1008             (display-completion-list (if iswitchb-matches
1009                                          iswitchb-matches
1010                                        iswitchb-buflist)
1011                                      :help-string "iswitchb "
1012                                      :activate-callback
1013                                      (lambda (x y z)
1014                                        (message "doesn't work yet, sorry!")))
1015           ;; else running Emacs
1016           (with-current-buffer standard-output
1017             (fundamental-mode))
1018           (display-completion-list (if iswitchb-matches
1019                                        iswitchb-matches
1020                                      iswitchb-buflist))))
1021       (setq iswitchb-common-match-inserted nil))))
1022
1023 ;;; KILL CURRENT BUFFER
1024
1025 (defun iswitchb-kill-buffer ()
1026   "Kill the buffer at the head of `iswitchb-matches'."
1027   (interactive)
1028   (let ( (enable-recursive-minibuffers t)
1029          buf)
1030
1031     (setq buf (car iswitchb-matches))
1032     ;; check to see if buf is non-nil.
1033     (if buf
1034         (progn
1035           (kill-buffer buf)
1036
1037           ;; Check if buffer exists.  XEmacs gnuserv.el makes alias
1038           ;; for kill-buffer which does not return t if buffer is
1039           ;; killed, so we can't rely on kill-buffer return value.
1040           (if (get-buffer buf)
1041               ;; buffer couldn't be killed.
1042               (setq iswitchb-rescan t)
1043             ;; else buffer was killed so remove name from list.
1044             (setq iswitchb-buflist  (delq buf iswitchb-buflist)))))))
1045
1046 ;;; VISIT CHOSEN BUFFER
1047 (defun iswitchb-visit-buffer (buffer)
1048   "Visit buffer named BUFFER according to `iswitchb-method'."
1049   (let (win newframe)
1050     (cond
1051      ((eq iswitchb-method 'samewindow)
1052       (switch-to-buffer buffer))
1053
1054      ((memq iswitchb-method '(always-frame maybe-frame))
1055       (cond
1056        ((and (setq win (iswitchb-window-buffer-p buffer))
1057              (or (eq iswitchb-method 'always-frame)
1058                  (y-or-n-p "Jump to frame? ")))
1059         (setq newframe (window-frame win))
1060         (if (fboundp 'select-frame-set-input-focus)
1061             (select-frame-set-input-focus newframe)
1062           (raise-frame newframe)
1063           (select-frame newframe)
1064           )
1065         (select-window win))
1066        (t
1067         ;;  No buffer in other frames...
1068         (switch-to-buffer buffer)
1069         )))
1070
1071      ((eq iswitchb-method 'otherwindow)
1072       (switch-to-buffer-other-window buffer))
1073
1074      ((eq iswitchb-method 'display)
1075       (display-buffer buffer))
1076
1077      ((eq iswitchb-method 'otherframe)
1078       (progn
1079         (switch-to-buffer-other-frame buffer)
1080         (if (fboundp 'select-frame-set-input-focus)
1081             (select-frame-set-input-focus (selected-frame)))
1082         )))))
1083
1084 (defun iswitchb-possible-new-buffer (buf)
1085   "Possibly create and visit a new buffer called BUF."
1086
1087   (let ((newbufcreated))
1088     (if (and iswitchb-newbuffer
1089              (or
1090               (not iswitchb-prompt-newbuffer)
1091
1092               (and iswitchb-prompt-newbuffer
1093                    (y-or-n-p
1094                     (format
1095                      "No buffer matching `%s', create one? "
1096                      buf)))))
1097         ;; then create a new buffer
1098         (progn
1099           (setq newbufcreated (get-buffer-create buf))
1100           (if (fboundp 'set-buffer-major-mode)
1101               (set-buffer-major-mode newbufcreated))
1102           (iswitchb-visit-buffer newbufcreated))
1103       ;; else wont create new buffer
1104       (message "no buffer matching `%s'" buf))))
1105
1106 (defun iswitchb-window-buffer-p  (buffer)
1107   "Return window pointer if BUFFER is visible in another frame.
1108 If BUFFER is visible in the current frame, return nil."
1109   (interactive)
1110   (let ((blist (iswitchb-get-buffers-in-frames 'current)))
1111     ;;If the buffer is visible in current frame, return nil
1112     (if (memq buffer blist)
1113         nil
1114       ;;  maybe in other frame or icon
1115       (get-buffer-window buffer 0) ; better than 'visible
1116       )))
1117
1118 (defun iswitchb-default-keybindings ()
1119   "Set up default keybindings for `iswitchb-buffer'.
1120 Call this function to override the normal bindings.  This function also
1121 adds a hook to the minibuffer."
1122   (interactive)
1123   (add-hook 'minibuffer-setup-hook 'iswitchb-minibuffer-setup)
1124   (global-set-key "\C-xb" 'iswitchb-buffer)
1125   (global-set-key "\C-x4b" 'iswitchb-buffer-other-window)
1126   (global-set-key "\C-x4\C-o" 'iswitchb-display-buffer)
1127   (global-set-key "\C-x5b" 'iswitchb-buffer-other-frame))
1128
1129 (make-obsolete 'iswitchb-default-keybindings 'iswitchb-mode "21.1")
1130
1131 (defun iswitchb-buffer ()
1132   "Switch to another buffer.
1133
1134 The buffer name is selected interactively by typing a substring.  The
1135 buffer is displayed according to `iswitchb-default-method' -- the
1136 default is to show it in the same window, unless it is already visible
1137 in another frame.
1138 For details of keybindings, do `\\[describe-function] iswitchb'."
1139   (interactive)
1140   (setq iswitchb-method iswitchb-default-method)
1141   (iswitchb))
1142
1143 (defun iswitchb-buffer-other-window ()
1144   "Switch to another buffer and show it in another window.
1145 The buffer name is selected interactively by typing a substring.
1146 For details of keybindings, do `\\[describe-function] iswitchb'."
1147   (interactive)
1148   (setq iswitchb-method 'otherwindow)
1149   (iswitchb))
1150
1151 (defun iswitchb-display-buffer ()
1152   "Display a buffer in another window but don't select it.
1153 The buffer name is selected interactively by typing a substring.
1154 For details of keybindings, do `\\[describe-function] iswitchb'."
1155   (interactive)
1156   (setq iswitchb-method 'display)
1157   (iswitchb))
1158
1159 (defun iswitchb-buffer-other-frame ()
1160   "Switch to another buffer and show it in another frame.
1161 The buffer name is selected interactively by typing a substring.
1162 For details of keybindings, do `\\[describe-function] iswitchb'."
1163   (interactive)
1164   (setq iswitchb-method 'otherframe)
1165   (iswitchb))
1166
1167 ;;; XEmacs hack for showing default buffer
1168
1169 ;; The first time we enter the minibuffer, Emacs puts up the default
1170 ;; buffer to switch to, but XEmacs doesn't -- presumably there is a
1171 ;; subtle difference in the two versions of post-command-hook.  The
1172 ;; default is shown for both whenever we delete all of our text
1173 ;; though, indicating its just a problem the first time we enter the
1174 ;; function.  To solve this, we use another entry hook for emacs to
1175 ;; show the default the first time we enter the minibuffer.
1176
1177 (defun iswitchb-init-XEmacs-trick ()
1178   "Display default buffer when first entering minibuffer.
1179 This is a hack for XEmacs, and should really be handled by `iswitchb-exhibit'."
1180   (if (iswitchb-entryfn-p)
1181       (progn
1182         (iswitchb-exhibit)
1183         (goto-char (point-min)))))
1184
1185 ;; add this hook for XEmacs only.
1186 (if (featurep 'xemacs)
1187     (add-hook 'iswitchb-minibuffer-setup-hook
1188               'iswitchb-init-XEmacs-trick))
1189
1190 ;;; XEmacs / backspace key
1191 ;; For some reason, if the backspace key is pressed in XEmacs, the
1192 ;; line gets confused, so I've added a simple key definition to make
1193 ;; backspace act like the normal delete key.
1194
1195 (defun iswitchb-xemacs-backspacekey ()
1196   "Bind backspace to `backward-delete-char'."
1197   (define-key iswitchb-mode-map '[backspace] 'backward-delete-char)
1198   (define-key iswitchb-mode-map '[(meta backspace)] 'backward-kill-word))
1199
1200 (if (featurep 'xemacs)
1201     (add-hook 'iswitchb-define-mode-map-hook
1202               'iswitchb-xemacs-backspacekey))
1203
1204 ;;; ICOMPLETE TYPE CODE
1205
1206 (defun iswitchb-exhibit ()
1207   "Find matching buffers and display a list in the minibuffer.
1208 Copied from `icomplete-exhibit' with two changes:
1209 1. It prints a default buffer name when there is no text yet entered.
1210 2. It calls my completion routine rather than the standard completion."
1211   (if iswitchb-use-mycompletion
1212       (let ((contents (buffer-substring (minibuffer-prompt-end) (point-max)))
1213             (buffer-undo-list t))
1214         (save-excursion
1215           (goto-char (point-max))
1216                                         ; Register the end of input, so we
1217                                         ; know where the extra stuff
1218                                         ; (match-status info) begins:
1219           (if (not (boundp 'iswitchb-eoinput))
1220               ;; In case it got wiped out by major mode business:
1221               (make-local-variable 'iswitchb-eoinput))
1222           (setq iswitchb-eoinput (point))
1223           ;; Update the list of matches
1224           (setq iswitchb-text contents)
1225           (iswitchb-set-matches)
1226           (setq iswitchb-rescan t)
1227           (iswitchb-set-common-completion)
1228
1229           ;; Insert the match-status information:
1230           (insert (iswitchb-completions
1231                    contents))))))
1232
1233 (defvar most-len)
1234 (defvar most-is-exact)
1235
1236 (defun iswitchb-output-completion (com)
1237   (if (= (length com) most-len)
1238       ;; Most is one exact match,
1239       ;; note that and leave out
1240       ;; for later indication:
1241       (ignore
1242        (setq most-is-exact t))
1243     (substring com most-len)))
1244
1245 (defun iswitchb-completions (name)
1246   "Return the string that is displayed after the user's text.
1247 Modified from `icomplete-completions'."
1248
1249   (let ((comps iswitchb-matches)
1250                                         ; "-determined" - only one candidate
1251         (open-bracket-determined "[")
1252         (close-bracket-determined "]")
1253                                         ;"-prospects" - more than one candidate
1254         (open-bracket-prospects "{")
1255         (close-bracket-prospects "}")
1256         first)
1257
1258     (if (and iswitchb-use-faces comps)
1259         (progn
1260           (setq first (car comps))
1261           (setq first (format "%s" first))
1262           (put-text-property 0 (length first) 'face
1263                              (if (= (length comps) 1)
1264                                  (if iswitchb-invalid-regexp
1265                                      'iswitchb-invalid-regexp
1266                                    'iswitchb-single-match)
1267                                'iswitchb-current-match)
1268                              first)
1269           (setq comps  (cons first (cdr comps)))))
1270
1271     ;; If no buffers matched, and virtual buffers are being used, then
1272     ;; consult the list of past visited files, to see if we can find
1273     ;; the file which the user might thought was still open.
1274     (when (and iswitchb-use-virtual-buffers (null comps)
1275                recentf-list)
1276       (setq iswitchb-virtual-buffers nil)
1277       (let ((head recentf-list) name)
1278         (while head
1279           (if (and (setq name (file-name-nondirectory (car head)))
1280                    (string-match (if iswitchb-regexp
1281                                      iswitchb-text
1282                                    (regexp-quote iswitchb-text)) name)
1283                    (null (get-file-buffer (car head)))
1284                    (not (assoc name iswitchb-virtual-buffers))
1285                    (not (iswitchb-ignore-buffername-p name))
1286                    (file-exists-p (car head)))
1287               (setq iswitchb-virtual-buffers
1288                     (cons (cons name (car head))
1289                           iswitchb-virtual-buffers)))
1290           (setq head (cdr head)))
1291         (setq iswitchb-virtual-buffers (nreverse iswitchb-virtual-buffers)
1292               comps (mapcar 'car iswitchb-virtual-buffers))
1293         (let ((comp comps))
1294           (while comp
1295             (put-text-property 0 (length (car comp))
1296                                'face 'iswitchb-virtual-matches
1297                                (car comp))
1298             (setq comp (cdr comp))))))
1299
1300     (cond ((null comps) (format " %sNo match%s"
1301                                 open-bracket-determined
1302                                 close-bracket-determined))
1303
1304           (iswitchb-invalid-regexp
1305            (concat " " (car comps)))
1306           ((null (cdr comps))           ;one match
1307            (concat
1308             (if (if (not iswitchb-regexp)
1309                     (= (length name)
1310                        (length (car comps)))
1311                   (string-match name (car comps))
1312                   (string-equal (match-string 0 (car comps))
1313                                 (car comps)))
1314                 ""
1315               (concat open-bracket-determined
1316                                ;; when there is one match, show the
1317                                ;; matching buffer name in full
1318                                (car comps)
1319                                close-bracket-determined))
1320                    (if (not iswitchb-use-faces) " [Matched]")))
1321           (t                            ;multiple matches
1322            (if (and iswitchb-max-to-show
1323                     (> (length comps) iswitchb-max-to-show))
1324                (setq comps
1325                      (append
1326                       (let ((res nil)
1327                             (comp comps)
1328                             (end (/ iswitchb-max-to-show 2)))
1329                         (while (>= (setq end (1- end)) 0)
1330                           (setq res (cons (car comp) res)
1331                                 comp (cdr comp)))
1332                         (nreverse res))
1333                       (list "...")
1334                       (nthcdr (- (length comps)
1335                                  (/ iswitchb-max-to-show 2)) comps))))
1336            (let* (
1337                   ;;(most (try-completion name candidates predicate))
1338                   (most nil)
1339                   (most-len (length most))
1340                   most-is-exact
1341                   (alternatives
1342                    (mapconcat (if most 'iswitchb-output-completion
1343                                 'identity) comps ",")))
1344
1345              (concat
1346
1347               ;; put in common completion item -- what you get by
1348               ;; pressing tab
1349               (if (and (stringp iswitchb-common-match-string)
1350                        (> (length iswitchb-common-match-string) (length name)))
1351                   (concat open-bracket-determined
1352                           (substring iswitchb-common-match-string
1353                                      (length name))
1354                           close-bracket-determined))
1355               ;; end of partial matches...
1356
1357               ;; think this bit can be ignored.
1358               (and (> most-len (length name))
1359                    (concat open-bracket-determined
1360                            (substring most (length name))
1361                            close-bracket-determined))
1362
1363               ;; list all alternatives
1364               open-bracket-prospects
1365               (if most-is-exact
1366                   (concat "," alternatives)
1367                 alternatives)
1368               close-bracket-prospects))))))
1369
1370 (defun iswitchb-minibuffer-setup ()
1371   "Set up minibuffer for `iswitchb-buffer'.
1372 Copied from `icomplete-minibuffer-setup-hook'."
1373   (when (iswitchb-entryfn-p)
1374     (set (make-local-variable 'iswitchb-use-mycompletion) t)
1375     (add-hook 'pre-command-hook 'iswitchb-pre-command nil t)
1376     (add-hook 'post-command-hook 'iswitchb-post-command nil t)
1377     (run-hooks 'iswitchb-minibuffer-setup-hook)))
1378
1379 (defun iswitchb-pre-command ()
1380   "Run before command in `iswitchb-buffer'."
1381   (iswitchb-tidy))
1382
1383 (defun iswitchb-post-command ()
1384   "Run after command in `iswitchb-buffer'."
1385   (iswitchb-exhibit))
1386
1387 (defun iswitchb-tidy ()
1388   "Remove completions display, if any, prior to new user input.
1389 Copied from `icomplete-tidy'."
1390
1391   (if (and (boundp 'iswitchb-eoinput)
1392            iswitchb-eoinput)
1393
1394       (if (> iswitchb-eoinput (point-max))
1395           ;; Oops, got rug pulled out from under us - reinit:
1396           (setq iswitchb-eoinput (point-max))
1397         (let ((buffer-undo-list buffer-undo-list )) ; prevent entry
1398           (delete-region iswitchb-eoinput (point-max))))
1399
1400     ;; Reestablish the local variable 'cause minibuffer-setup is weird:
1401     (make-local-variable 'iswitchb-eoinput)
1402     (setq iswitchb-eoinput 1)))
1403
1404 (defun iswitchb-entryfn-p ()
1405   "Return non-nil if we are using `iswitchb-buffer'."
1406   (eq iswitchb-minibuf-depth (minibuffer-depth)))
1407
1408 (defun iswitchb-summaries-to-end ()
1409   "Move the summaries to the end of the list.
1410 This is an example function which can be hooked on to
1411 `iswitchb-make-buflist-hook'.  Any buffer matching the regexps
1412 `Summary' or `output\*$'are put to the end of the list."
1413   (let ((summaries (delq nil
1414                          (mapcar
1415                           (lambda (x)
1416                             (if (string-match "Summary\\|output\\*$" x)
1417                                 x))
1418                           iswitchb-temp-buflist))))
1419     (iswitchb-to-end summaries)))
1420
1421 (defun iswitchb-case ()
1422   "Return non-nil if we should ignore case when matching.
1423 See the variable `iswitchb-case' for details."
1424   (if iswitchb-case
1425       (if (featurep 'xemacs)
1426           (isearch-no-upper-case-p iswitchb-text)
1427         (isearch-no-upper-case-p iswitchb-text t))))
1428
1429 ;;;###autoload
1430 (define-minor-mode iswitchb-mode
1431   "Toggle Iswitchb global minor mode.
1432 With arg, turn Iswitchb mode on if ARG is positive, otherwise turn it off.
1433 This mode enables switching between buffers using substrings.  See
1434 `iswitchb' for details."
1435   nil nil iswitchb-global-map :global t :group 'iswitchb
1436   (if iswitchb-mode
1437       (add-hook 'minibuffer-setup-hook 'iswitchb-minibuffer-setup)
1438     (remove-hook 'minibuffer-setup-hook 'iswitchb-minibuffer-setup)))
1439
1440 (provide 'iswitchb)
1441
1442 ;; arch-tag: d74198ae-753f-44f2-b34f-0c515398d90a
1443 ;;; iswitchb.el ends here