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