lisp/iswitchb.el

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