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

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