New directory
[bpt/emacs.git] / lisp / ido.el
1 ;;; ido.el --- interactively do things with buffers and files.
2
3 ;; Copyright (C) 1996-2003 Free Software Foundation, Inc.
4
5 ;; Author: Kim F. Storm <storm@cua.dk>
6 ;; Based on: iswitchb by Stephen Eglen <stephen@cns.ed.ac.uk>
7 ;; Keywords: extensions convenience
8
9 ;; This file is part of GNU Emacs.
10
11 ;; GNU Emacs is free software; you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation; either version 2, or (at your option)
14 ;; any later version.
15
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 ;; GNU General Public License for more details.
20
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs; see the file COPYING. If not, write to the
23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 ;; Boston, MA 02111-1307, USA.
25
26 ;;; Acknowledgements
27
28 ;; Infinite amounts of gratitude goes to Stephen Eglen <stephen@cns.ed.ac.uk>
29 ;; who wrote iswitch-buffer mode - from which I ripped off 99% of the code
30 ;; for ido-switch-buffer and found the inspiration for ido-find-file.
31 ;; The ido package would never have existed without his work.
32
33 ;; Also thanks to Klaus Berndl, Rohit Namjoshi, Robert Fenk, Alex Schroeder,
34 ;; Bill Benedetto, and Stephen Eglen for bug fixes and improvements.
35
36 ;;; History
37
38 ;; Since I discovered Stephen Eglen's excellent iswitchb package, I just
39 ;; couldn't live without it, but once being addicted to switching buffers
40 ;; with a minimum of keystrokes, I soon found that opening files in the
41 ;; old-fashioned way was just too slow - so I decided to write a package
42 ;; which could open files with the same speed and ease as iswitchb could
43 ;; switch buffers.
44
45 ;; I originally wrote a separate ifindf.el package based on a copy of
46 ;; iswitchb.el, which did for opening files what iswitchb did for
47 ;; switching buffers. Along the way, I corrected a few errors in
48 ;; ifindf which could have found its way back into iswitchb, but since
49 ;; most of the functionality of the two package was practically
50 ;; identical, I decided that the proper thing to do was to merge my
51 ;; ifindf package back into iswitchb.
52 ;;
53 ;; This is basically what ido (interactively do) is all about; but I
54 ;; found it ackward to merge my changes into the "iswitchb-" namespace,
55 ;; so I invented a common "ido-" namespace for the merged packages.
56 ;;
57 ;; This version is based on ido.el version 1.57 released on
58 ;; gnu.emacs.sources adapted for emacs 21.4 to use command remapping
59 ;; and optionally hooking the read-buffer and read-file-name functions.
60 ;;
61 ;; Prefix matching was added by Klaus Berndl <klaus.berndl@sdm.de> based on
62 ;; an idea of Yuji Minejima <ggb01164@nifty.ne.jp> and his mcomplete-package.
63
64
65 ;;; Commentary:
66
67 ;; Ido - interactive do - switches between buffers and opens files and
68 ;; directories with a minimum of keystrokes. It is a superset of
69 ;; iswitchb, the interactive buffer switching package by Stephen Eglen.
70
71 ;; Interactive substring matching
72 ;; ------------------------------
73 ;;
74 ;; As you type in a substring, the list of buffers or files currently
75 ;; matching the substring are displayed as you type. The list is
76 ;; ordered so that the most recent buffers or files visited come at
77 ;; the start of the list.
78 ;;
79 ;; The buffer or file at the start of the list will be the one visited
80 ;; when you press RETURN. By typing more of the substring, the list is
81 ;; narrowed down so that gradually the buffer or file you want will be
82 ;; at the top of the list. Alternatively, you can use C-s and C-r (or
83 ;; the right and left arrow keys) to rotate buffer or file names in the
84 ;; list until the one you want is at the top of the list.
85 ;;
86 ;; Completion is also available so that you can see what is common to
87 ;; all of the matching buffers or files as you type.
88 ;;
89 ;; Example:
90 ;;
91 ;; If I have two buffers called "123456" and "123", with "123456" the
92 ;; most recent, when I use ido-switch-buffer, I first of all get
93 ;; presented with the list of all the buffers
94 ;;
95 ;; Buffer: {123456,123}
96 ;;
97 ;; If I then press 2:
98 ;; Buffer: 2[3]{123456,123}
99 ;;
100 ;; The list in {...} are the matching buffers, most recent first
101 ;; (buffers visible in the current frame are put at the end of the
102 ;; list by default). At any time I can select the item at the head of
103 ;; the list by pressing RET. I can also bring the put the first
104 ;; element at the end of the list by pressing C-s or [right], or put
105 ;; the last element at the head of the list by pressing C-r or [left].
106 ;;
107 ;; The item in [...] indicates what can be added to my input by
108 ;; pressing TAB. In this case, I will get "3" added to my input.
109
110 ;; So, I press TAB:
111 ;; Buffer: 23{123456,123}
112 ;;
113 ;; At this point, I still have two matching buffers.
114 ;; If I want the first buffer in the list, I simply press RET. If I
115 ;; wanted the second in the list, I could press C-s to move it to the
116 ;; top of the list and then RET to select it.
117 ;;
118 ;; However, if I type 4, I only have one match left:
119 ;; Buffer: 234[123456] [Matched]
120 ;;
121 ;; Since there is only one matching buffer left, it is given in [] and we
122 ;; see the text [Matched] afterwards. I can now press TAB or RET to go
123 ;; to that buffer.
124 ;;
125 ;; If however, I now type "a":
126 ;; Buffer: 234a [No match]
127 ;; There are no matching buffers. If I press RET or TAB, I can be
128 ;; prompted to create a new buffer called "234a".
129 ;;
130 ;; Of course, where this function comes in really useful is when you
131 ;; can specify the buffer using only a few keystrokes. In the above
132 ;; example, the quickest way to get to the "123456" file would be
133 ;; just to type 4 and then RET (assuming there isn't any newer buffer
134 ;; with 4 in its name).
135
136 ;; Likewise, if you use C-x C-f (ido-find-file), the list of files and
137 ;; directories in the current directory is provided in the same
138 ;; fashion as the buffers above. The files and directories are
139 ;; normally sorted in alphabetical order, but the most recently
140 ;; visited directory is placed first to speed up navigating to
141 ;; directories that you have visited recently.
142 ;;
143 ;; In addition to scrolling through the list using [right] and [left],
144 ;; you can use [up] and [down] to quickly scroll the list to the next
145 ;; or previous subdirectory.
146 ;;
147 ;; To go down into a subdirectory, and continue the file selection on
148 ;; the files in that directory, simply move the directory to the head
149 ;; of the list and hit RET.
150 ;;
151 ;; To go up to the parent directory, delete any partial file name
152 ;; already specified (e.g. using [backspace]) and hit [backspace].
153 ;;
154 ;; To go to the root directory (on the current drive), enter two
155 ;; slashes. On MS-DOS or Windows, to select the root of another
156 ;; drive, enter X:/ where X is the drive letter. You can also visit
157 ;; files on other hosts using the ange-ftp notations `/host:' and
158 ;; `/user@host:'. See the variable `ido-slow-ftp-hosts' if you want
159 ;; to inhibit the ido substring matching for ftp access.
160 ;;
161 ;; If for some reason you cannot specify the proper file using
162 ;; ido-find-file, you can press C-f to enter the normal find-file.
163 ;; You can also press C-b to drop into ido-switch-buffer.
164
165 ;; See the doc string of ido-switch-buffer and ido-find-file for full
166 ;; keybindings and features.
167 ;; (describe-function 'ido-find-file)
168
169 ;; Hidden buffers and files
170 ;; ------------------------
171 ;;
172 ;; Normally, ido does not include hidden buffers (whose name starts
173 ;; with a space) and hidden files and directories (whose name starts
174 ;; with `.') in the list of possible completions. However, if the
175 ;; substring you enter does not match any of the visible buffers or
176 ;; files, ido will automatically look for completions among the hidden
177 ;; buffers or files.
178 ;;
179 ;; You can toggle display of the hidden buffers and files with C-a.
180
181 ;; Additional functionality
182 ;; ------------------------
183 ;;
184 ;; After C-x b, the buffer at the head of the list can be killed by
185 ;; pressing C-k. If the buffer needs saving, you will be queried
186 ;; before the buffer is killed.
187 ;;
188 ;; Likewise, after C-x C-f, you can delete (i.e. physically remove)
189 ;; the file at the head of the list with C-k. You will always be
190 ;; asked for confirmation before the file is deleted.
191 ;;
192 ;; If you enter C-x b to switch to a buffer visiting a given file, and
193 ;; you find that the file you are after is not in any buffer, you can
194 ;; press C-f to immediately drop into ido-find-file. And you can
195 ;; switch back to buffer selection with C-b.
196
197 ;; Prefix matching
198 ;; ---------------
199 ;;
200 ;; The standard way of completion with Unix-shells and Emacs is to insert a
201 ;; PREFIX and then hitting TAB (or another completion key). Cause of this
202 ;; behavior has become second nature to a lot of emacs users `ido' offers in
203 ;; addition to the default substring-matching-method (look above) also the
204 ;; prefix-matching-method. The kind of matching is the only difference to
205 ;; the description of the substring-matching above.
206 ;;
207 ;; You can toggle prefix matching with C-p.
208 ;;
209 ;; Example:
210 ;;
211 ;; If you have again two Buffers "123456" and "123" then hitting "2" does
212 ;; not match because "2" is not a PREFIX in any of the buffer-names. This
213 ;; is the only difference between the substring and prefix matching.
214
215 ;; Flexible matching
216 ;; -----------------
217 ;;
218 ;; If you set ido-enable-flex-matching, ido will do a more flexible
219 ;; matching (unless regexp matching is active) to find possible matches
220 ;; among the available buffer or file names if no matches are found using
221 ;; the normal prefix or substring matching.
222 ;;
223 ;; The flexible matching implies that any item which simply contains all
224 ;; of the entered characters in the specified sequence will match.
225 ;;
226 ;; Example:
227 ;;
228 ;; If you have four files "alpha", "beta", "gamma", and "delta",
229 ;; entering "aa" will match "alpha" and "gamma", while "ea" matches
230 ;; "beta" and "delta". If prefix matching is also active, "aa" only
231 ;; matches "alpha", while "ea" does not match any files.
232
233 ;; Regexp matching
234 ;; ---------------
235 ;;
236 ;; There is limited provision for regexp matching within ido,
237 ;; enabled through `ido-enable-regexp' (toggle with C-t).
238 ;; This allows you to type `c$' for example and see all file names
239 ;; ending in `c'. This facility is quite limited though in two
240 ;; respects. First, you can't currently type in expressions like
241 ;; `[0-9]' directly -- you have to type them in when ido-enable-regexp
242 ;; is nil and then toggle on the regexp functionality. Likewise,
243 ;; don't enter an expression containing `\' in regexp mode. If you
244 ;; try, ido gets confused, so just hit C-g and try again. Secondly,
245 ;; no completion mechanism is currently offered with regexp searching.
246
247
248 ;; Customization
249 ;; -------------
250 ;;
251 ;; Customize the `ido' group to change the `ido' functionality.
252 ;;
253 ;; To modify the keybindings, use the hook provided. For example:
254 ;;(add-hook 'ido-define-mode-map-hook 'ido-my-keys)
255 ;;
256 ;;(defun ido-my-keys ()
257 ;; "Add my keybindings for ido."
258 ;; (define-key ido-mode-map " " 'ido-next-match)
259 ;; )
260
261 ;; Seeing all the matching buffers or files
262 ;; ----------------------------------------
263 ;;
264 ;; If you have many matching files, they may not all fit onto one
265 ;; line of the minibuffer. Normally, the minibuffer window will grow
266 ;; to show you more of the matching files (depending on the setting
267 ;; of the variables `resize-mini-windows' and `max-mini-window-height').
268 ;; If you want ido to behave differently from the default minibuffer
269 ;; resizing behaviour, set the variable `ido-max-window-height'.
270 ;;
271 ;; Also, to improve the responsiveness of ido, the maximum number of
272 ;; matching items is limited to 12, but you can increase or removed
273 ;; this limit via the `ido-max-prospects' variable.
274
275 ;; To see a full list of all matching buffers in a separate buffer,
276 ;; hit ? or press TAB when there are no further completions to the
277 ;; substring. Repeated TAB presses will scroll you through this
278 ;; separate buffer.
279
280 ;; Changing the list of files
281 ;; --------------------------
282
283 ;; By default, the list of current files is most recent first,
284 ;; oldest last, with the exception that the files visible in the
285 ;; current frame are put at the end of the list. A hook exists to
286 ;; allow other functions to order the list. For example, if you add:
287 ;;
288 ;; (add-hook 'ido-make-buffer-list-hook 'ido-summary-buffers-to-end)
289 ;;
290 ;; then all files matching "Summary" are moved to the end of the
291 ;; list. (I find this handy for keeping the INBOX Summary and so on
292 ;; out of the way.) It also moves files matching "output\*$" to the
293 ;; end of the list (these are created by AUC TeX when compiling.)
294 ;; Other functions could be made available which alter the list of
295 ;; matching files (either deleting or rearranging elements.)
296
297 ;; Highlighting
298 ;; ------------
299
300 ;; The highlighting of matching items is controlled via ido-use-faces.
301 ;; The faces used are ido-first-match-face, ido-only-match-face and
302 ;; ido-subdir-face.
303 ;; Colouring of the matching item was suggested by
304 ;; Carsten Dominik (dominik@strw.leidenuniv.nl).
305
306 ;; Replacement for read-buffer and read-file-name
307 ;; ----------------------------------------------
308
309 ;; ido-read-buffer and ido-read-file-name have been written to be drop
310 ;; in replacements for the normal buffer and file name reading
311 ;; functions `read-buffer' and `read-file-name'.
312
313 ;; To use ido for all buffer and file selections in Emacs, customize the
314 ;; variable `ido-everywhere'.
315
316 ;; Using ido-like behaviour in other lisp packages
317 ;; -----------------------------------------------
318
319 ;; If you don't want to rely on the `ido-everywhere' functionality,
320 ;; ido-read-buffer, ido-read-file-name, and ido-read-directory-name
321 ;; can be used by other packages to read a buffer name, a file name,
322 ;; or a directory name in the `ido' way.
323
324
325 ;;; Code:
326
327 (provide 'ido)
328
329 ;;; User Variables
330 ;;
331 ;; These are some things you might want to change.
332
333 (defun ido-fractionp (n)
334 (and (numberp n) (> n 0.0) (<= n 1.0)))
335
336 (defgroup ido nil
337 "Switch between files using substrings."
338 :group 'extensions
339 :group 'convenience
340 :link '(emacs-commentary-link :tag "Commentary" "ido.el")
341 :link '(emacs-library-link :tag "Lisp File" "ido.el"))
342
343 ;;;###autoload
344 (defcustom ido-mode nil
345 "Determines for which functional group \(buffer and files) ido behavior
346 should be enabled. The following values are possible:
347 - `buffer': Turn only on ido buffer behavior \(switching, killing,
348 displaying...)
349 - `file': Turn only on ido file behavior \(finding, writing, inserting...)
350 - `both': Turn on ido buffer and file behavior.
351 - `nil': Turn off any ido switching.
352
353 Setting this variable directly does not take effect;
354 use either \\[customize] or the function `ido-mode'."
355 :set #'(lambda (symbol value)
356 (ido-mode value))
357 :initialize 'custom-initialize-default
358 :require 'ido
359 :link '(emacs-commentary-link "ido.el")
360 :set-after '(ido-save-directory-list-file)
361 :version "21.4"
362 :type '(choice (const :tag "Turn on only buffer" buffer)
363 (const :tag "Turn on only file" file)
364 (const :tag "Turn on both buffer and file" both)
365 (const :tag "Switch off all" nil))
366 :group 'ido)
367
368 (defcustom ido-everywhere nil
369 "Use ido everywhere for reading file names and directories.
370 Setting this variable directly does not work. Use `customize' or
371 call the function `ido-everywhere'."
372 :set #'(lambda (symbol value)
373 (ido-everywhere value))
374 :initialize 'custom-initialize-default
375 :type 'boolean
376 :group 'ido)
377
378 (defcustom ido-case-fold case-fold-search
379 "*Non-nil if searching of buffer and file names should ignore case."
380 :type 'boolean
381 :group 'ido)
382
383 (defcustom ido-ignore-buffers
384 '("\\` ")
385 "*List of regexps or functions matching buffer names to ignore.
386 For example, traditional behavior is not to list buffers whose names begin
387 with a space, for which the regexp is `\\` '. See the source file for
388 example functions that filter buffernames."
389 :type '(repeat (choice regexp function))
390 :group 'ido)
391
392 (defcustom ido-ignore-files
393 '("\\`CVS/" "\\`#" "\\`.#" "\\`\\.\\./" "\\`\\./")
394 "*List of regexps or functions matching file names to ignore.
395 For example, traditional behavior is not to list files whose names begin
396 with a #, for which the regexp is `\\`#'. See the source file for
397 example functions that filter filenames."
398 :type '(repeat (choice regexp function))
399 :group 'ido)
400
401 (defcustom ido-ignore-extensions t
402 "*Non-nil means ignore files in completion-ignored-extensions list."
403 :type 'boolean
404 :group 'ido)
405
406 (defcustom ido-show-dot-for-dired nil
407 "*Non-nil means to always put . as the first item in file name lists.
408 This allows the current directory to be opened immediate with `dired'."
409 :type 'boolean
410 :group 'ido)
411
412 (defcustom ido-ignore-directories
413 '("\\`CVS/" "\\`\\.\\./" "\\`\\./")
414 "*List of regexps or functions matching sub-directory names to ignore."
415 :type '(repeat (choice regexp function))
416 :group 'ido)
417
418 (defcustom ido-ignore-directories-merge nil
419 "*List of regexps or functions matching directory names to ignore during merge.
420 Directory names matched by one of the regexps in this list are not inserted
421 in merged file and directory lists."
422 :type '(repeat (choice regexp function))
423 :group 'ido)
424
425 ;;; Examples for setting the value of ido-ignore-buffers
426 ;(defun ido-ignore-c-mode (name)
427 ; "Ignore all c mode buffers -- example function for ido."
428 ; (save-excursion
429 ; (set-buffer name)
430 ; (string-match "^C$" mode-name)))
431 ;
432 ;(setq ido-ignore-buffers '("^ " ido-ignore-c-mode))
433
434 ;;; Examples for setting the value of ido-ignore-files
435 ;(setq ido-ignore-files '("^ " "\\.c$" "\\.h$"))
436
437 (defcustom ido-default-file-method 'always-frame
438 "*How to switch to new file when using `ido-find-file'.
439 Possible values:
440 `samewindow' Show new file in same window
441 `otherwindow' Show new file in another window (same frame)
442 `display' Display file in another window without switching to it
443 `otherframe' Show new file in another frame
444 `maybe-frame' If a file is visible in another frame, prompt to ask if you
445 you want to see the file in the same window of the current
446 frame or in the other frame.
447 `always-frame' If a file is visible in another frame, raise that
448 frame. Otherwise, visit the file in the same window."
449 :type '(choice (const samewindow)
450 (const otherwindow)
451 (const display)
452 (const otherframe)
453 (const maybe-frame)
454 (const always-frame))
455 :group 'ido)
456
457 (defcustom ido-default-buffer-method 'always-frame
458 "*How to switch to new buffer when using `ido-switch-buffer'.
459 See ido-default-file-method for details."
460 :type '(choice (const samewindow)
461 (const otherwindow)
462 (const display)
463 (const otherframe)
464 (const maybe-frame)
465 (const always-frame))
466 :group 'ido)
467
468 (defcustom ido-enable-flex-matching nil
469 "*Non-nil means that `ido' will do flexible string matching.
470 Flexible matching means that if the entered string does not
471 match any item, any item containing the entered characters
472 in the given sequence will match."
473 :type 'boolean
474 :group 'ido)
475
476
477 (defcustom ido-enable-regexp nil
478 "*Non-nil means that `ido' will do regexp matching.
479 Value can be toggled within `ido' using `ido-toggle-regexp'."
480 :type 'boolean
481 :group 'ido)
482
483 (defcustom ido-enable-prefix nil
484 "*Nil means that `ido' will match if the inserted text is an
485 arbitrary substring (default). If non-nil `ido' will only match if the inserted
486 text is a prefix \(this behavior is like the standard unix- or
487 emacs-completion works).
488 Value can be toggled within `ido' using `ido-toggle-prefix'."
489 :type 'boolean
490 :group 'ido)
491
492 (defcustom ido-cannot-complete-command 'ido-completion-help
493 "*Command run when `ido-complete' can't complete any more.
494 The most useful values are `ido-completion-help', which pops up a
495 window with completion alternatives, or `ido-next-match' or
496 `ido-prev-match', which cycle the buffer list."
497 :type 'function
498 :group 'ido)
499
500
501 (defcustom ido-record-commands t
502 "*Non-nil means that `ido' will record commands in command history.
503 Note that the non-ido equivalent command is recorded."
504 :type 'boolean
505 :group 'ido)
506
507 (defcustom ido-max-prospects 12
508 "*Non-zero means that the prospect list will be limited to than number of items.
509 For a long list of prospects, building the full list for the minibuffer can take a
510 non-negletable amount of time; setting this variable reduces that time."
511 :type 'integer
512 :group 'ido)
513
514 (defcustom ido-max-file-prompt-width 0.35
515 "*Non-zero means that the prompt string be limited to than number of characters.
516 If value is a floating point number, it specifies a fraction of the frame width."
517 :type '(choice
518 (integer :tag "Characters" :value 20)
519 (restricted-sexp :tag "Fraction of frame width"
520 :value 0.35
521 :match-alternatives (ido-fractionp)))
522 :group 'ido)
523
524 (defcustom ido-max-window-height nil
525 "*Non-nil specifies a value to override `max-mini-window-height'."
526 :type '(choice
527 (const :tag "Don't override" nil)
528 (integer :tag "Number of lines" :value 1)
529 (restricted-sexp
530 :tag "Fraction of window height"
531 :value 0.25
532 :match-alternatives (ido-fractionp)))
533 :group 'ido)
534
535 (defcustom ido-enable-last-directory-history t
536 "*Non-nil means that `ido' will remember latest selected directory names.
537 See `ido-last-directory-list' and `ido-save-directory-list-file'."
538 :type 'boolean
539 :group 'ido)
540
541 (defcustom ido-max-work-directory-list 50
542 "*Maximum number of working directories to record.
543 This is the list of directories where files have most recently been opened.
544 See `ido-work-directory-list' and `ido-save-directory-list-file'."
545 :type 'integer
546 :group 'ido)
547
548 (defcustom ido-work-directory-list-ignore-regexps nil
549 "*List of regexps matching directories which should not be recorded.
550 Directory names matched by one of the regexps in this list are not inserted in
551 the `ido-work-directory-list' list."
552 :type '(repeat regexp)
553 :group 'ido)
554
555
556 (defcustom ido-enable-tramp-completion t
557 "*Non-nil means that ido shall perform tramp method and server name completion.
558 A tramp file name uses the following syntax: /method:user@host:filename."
559 :type 'boolean
560 :group 'ido)
561
562 (defcustom ido-record-ftp-work-directories t
563 "*Non-nil means record ftp file names in the work directory list."
564 :type 'boolean
565 :group 'ido)
566
567 (defcustom ido-merge-ftp-work-directories nil
568 "*If nil means merging ignores ftp file names in the work directory list."
569 :type 'boolean
570 :group 'ido)
571
572 (defcustom ido-cache-ftp-work-directory-time 1.0
573 "*Maximum time to cache contents of an ftp directory (in hours).
574 If zero, ftp directories are not cached."
575 :type 'number
576 :group 'ido)
577
578 (defcustom ido-slow-ftp-hosts nil
579 "*List of slow ftp hosts where ido prompting should not be used.
580 If an ftp host is on this list, ido automatically switches to the non-ido
581 equivalent function, e.g. find-file rather than ido-find-file."
582 :type '(repeat string)
583 :group 'ido)
584
585 (defcustom ido-slow-ftp-host-regexps nil
586 "*List of regexps matching slow ftp hosts (see `ido-slow-ftp-hosts')."
587 :type '(repeat regexp)
588 :group 'ido)
589
590 (defcustom ido-max-work-file-list 10
591 "*Maximum number of names of recently opened files to record.
592 This is the list the file names (sans directory) which have most recently
593 been opened. See `ido-work-file-list' and `ido-save-directory-list-file'."
594 :type 'integer
595 :group 'ido)
596
597 (defcustom ido-work-directory-match-only t
598 "*Non-nil means to skip non-matching directories in the directory history.
599 When some text is already entered at the `ido-find-file' prompt, using
600 \\[ido-prev-work-directory] or \\[ido-next-work-directory] will skip directories
601 without any matching entries."
602 :type 'boolean
603 :group 'ido)
604
605 (defcustom ido-auto-merge-work-directories-length 0
606 "*Automatically switch to merged work directories during file name input.
607 The value is number of characters to type before switching to merged mode.
608 If zero, the switch happens when no matches are found in the current directory.
609 Automatic merging is disabled if the value is negative."
610 :type 'integer
611 :group 'ido)
612
613 (defcustom ido-auto-merge-delay-time 0.70
614 "*Delay in seconds to wait for more input before doing auto merge."
615 :type 'number
616 :group 'ido)
617
618 (defcustom ido-auto-merge-inhibit-characters-regexp "[][*?~]"
619 "*Regexp matching characters which should inhibit automatic merging.
620 When a (partial) file name matches this regexp, merging is inhibited."
621 :type 'regexp
622 :group 'ido)
623
624 (defcustom ido-merged-indicator "^"
625 "The string appended to first choice if it has multiple directory choices."
626 :type 'string
627 :group 'ido)
628
629 (defcustom ido-max-dir-file-cache 100
630 "*Maximum number of working directories to be cached.
631 This is the size of the cache of file-name-all-completions results.
632 Each cache entry is time stamped with the modification time of the
633 directory. Some systems, like Windows, have unreliable directory
634 modification times, so you may choose to disable caching on such
635 systems, or explicitly refresh the cache contents using the command
636 `ido-reread-directory' command (C-l) in the minibuffer.
637 See also `ido-dir-file-cache' and `ido-save-directory-list-file'."
638 :type 'integer
639 :group 'ido)
640
641 (defcustom ido-rotate-file-list-default nil
642 "*Non-nil means that `ido' will always rotate file list to get default in front."
643 :type 'boolean
644 :group 'ido)
645
646 (defcustom ido-enter-single-matching-directory 'slash
647 "*Automatically enter sub-directory if it is the only matching item, if non-nil.
648 If value is 'slash, only enter if typing final slash, else do it always."
649 :type '(choice (const :tag "Never" nil)
650 (const :tag "When typing /" slash)
651 (other :tag "Always" t))
652 :group 'ido)
653
654 (defcustom ido-create-new-buffer 'prompt
655 "*Specify whether a new buffer is created if no buffer matches substring.
656 Choices are 'always to create new buffers unconditionally, 'prompt to
657 ask user whether to create buffer, or 'never to never create new buffer."
658 :type '(choice (const always)
659 (const prompt)
660 (const never))
661 :group 'ido)
662
663 (defcustom ido-define-mode-map-hook nil
664 "*Hook to define keys in `ido-mode-map' for extra keybindings."
665 :type 'hook
666 :group 'ido)
667
668 (defcustom ido-separator nil
669 "*String used by ido to separate the alternatives in the minibuffer.
670 Obsolete. Set 3rd element of `ido-decorations' instead."
671 :type '(choice string (const nil))
672 :group 'ido)
673
674 (defcustom ido-decorations '( "{" "}" " | " " | ..." "[" "]" " [No match]" " [Matched]")
675 "*List of strings used by ido to display the alternatives in the minibuffer.
676 There are 8 elements in this list, each is a pair of strings:
677 1st and 2nd elements are used as brackets around the prospect list,
678 3rd element is the separator between prospects (ignored if ido-separator is set),
679 4th element is the string inserted at the end of a truncated list of prospects,
680 5th and 6th elements are used as brackets around the common match string which
681 can be completed using TAB,
682 7th element is the string displayed when there are a no matches, and
683 8th element displayed if there is a single match (and faces are not used)."
684 :type '(repeat string)
685 :group 'ido)
686
687 (defcustom ido-use-faces t
688 "*Non-nil means use ido faces to highlighting first match, only match and
689 subdirs in the alternatives."
690 :type 'boolean
691 :group 'ido)
692
693 (defface ido-first-match-face '((t (:bold t)))
694 "*Font used by ido for highlighting first match."
695 :group 'ido)
696
697 (defface ido-only-match-face '((((class color))
698 (:foreground "ForestGreen"))
699 (t (:italic t)))
700 "*Font used by ido for highlighting only match."
701 :group 'ido)
702
703 (defface ido-subdir-face '((((class color))
704 (:foreground "red"))
705 (t (:underline t)))
706 "*Font used by ido for highlighting subdirs in the alternatives."
707 :group 'ido)
708
709 (defface ido-indicator-face '((((class color))
710 (:foreground "yellow"
711 :background "red"
712 :width condensed))
713 (t (:inverse-video t)))
714 "*Font used by ido for highlighting its indicators."
715 :group 'ido)
716
717 (defcustom ido-make-file-list-hook nil
718 "*List of functions to run when the list of matching files is created.
719 Each function on the list may modify the dynamically bound variable
720 `ido-temp-list' which contains the current list of matching files."
721 :type 'hook
722 :group 'ido)
723
724 (defcustom ido-make-dir-list-hook nil
725 "*List of functions to run when the list of matching directories is created.
726 Each function on the list may modify the dynamically bound variable
727 `ido-temp-list' which contains the current list of matching directories."
728 :type 'hook
729 :group 'ido)
730
731 (defcustom ido-make-buffer-list-hook nil
732 "*List of functions to run when the list of matching buffers is created.
733 Each function on the list may modify the dynamically bound variable
734 `ido-temp-list' which contains the current list of matching buffer names."
735 :type 'hook
736 :group 'ido)
737
738 (defcustom ido-rewrite-file-prompt-functions nil
739 "*List of functions to run when the find-file prompt is created.
740 Each function on the list may modify the following dynamically bound
741 variables:
742 dirname - the (abbreviated) directory name
743 to be modified by the hook functions
744 max-width - the max width of the resulting dirname; nil means no limit
745 prompt - the basic prompt (e.g. \"Find File: \")
746 literal - the string shown if doing \"literal\" find; set to nil to omit
747 vc-off - the string shown if version control is inhibited; set to nit to omit
748 prefix - either nil or a fixed prefix for the dirname
749
750 The following variables are available, but should not be changed:
751 ido-current-directory - the unabbreviated directory name
752 item - equals `file' or `dir' depending on the current mode."
753 :type 'hook
754 :group 'ido)
755
756 (defvar ido-rewrite-file-prompt-rules nil
757 "*Alist of rewriting rules for directory names in ido prompts.
758 A list of elements of the form (FROM . TO) or (FROM . FUNC), each
759 meaning to rewrite the directory name if matched by FROM by either
760 substituting the matched string by TO or calling the function FUNC
761 with the current directory name as its only argument and using the
762 return value as the new directory name. In addition, each FUNC may
763 also modify the dynamic variables described for the variable
764 `ido-rewrite-file-prompt-functions'.")
765
766 (defcustom ido-completion-buffer "*Ido Completions*"
767 "*Name of completion buffer used by ido.
768 Set to nil to disable completion buffers popping up."
769 :type 'string
770 :group 'ido)
771
772 (defcustom ido-completion-buffer-all-completions nil
773 "*Non-nil means to show all completions in completion buffer.
774 Otherwise, only the current list of matches is shown."
775 :type 'boolean
776 :group 'ido)
777
778 (defvar ido-all-frames 'visible
779 "*Argument to pass to `walk-windows' when finding visible files.
780 See documentation of `walk-windows' for useful values.")
781
782 (defcustom ido-minibuffer-setup-hook nil
783 "*Ido-specific customization of minibuffer setup.
784
785 This hook is run during minibuffer setup iff `ido' will be active.
786 It is intended for use in customizing ido for interoperation
787 with other packages. For instance:
788
789 \(add-hook 'ido-minibuffer-setup-hook
790 \(function
791 \(lambda ()
792 \(make-local-variable 'max-mini-window-height)
793 \(setq max-mini-window-height 3))))
794
795 will constrain Emacs to a maximum minibuffer height of 3 lines when
796 ido is running. Copied from `icomplete-minibuffer-setup-hook'."
797 :type 'hook
798 :group 'ido)
799
800 (defcustom ido-save-directory-list-file "~/.ido.last"
801 "File in which the ido state is saved between invocations.
802 Variables stored are: `ido-last-directory-list', `ido-work-directory-list',
803 `ido-work-file-list', and `ido-dir-file-cache'.
804 Must be set before enabling ido mode."
805 :type 'string
806 :group 'ido)
807
808 (defcustom ido-read-file-name-as-directory-commands '()
809 "List of commands which uses read-file-name to read a directory name.
810 When `ido-everywhere' is non-nil, the commands in this list will read
811 the directory using ido-read-directory-name."
812 :type '(repeat symbol)
813 :group 'ido)
814
815 (defcustom ido-read-file-name-non-ido '()
816 "List of commands which shall not read file names the ido way.
817 When `ido-everywhere' is non-nil, the commands in this list will read
818 the file name using normal read-file-name style."
819 :type '(repeat symbol)
820 :group 'ido)
821
822 ;;; Internal Variables
823
824 ;; Persistent variables
825
826 (defvar ido-mode-map nil
827 "Keymap for `ido-find-file' and `ido-switch-buffer'.")
828
829 (defvar ido-file-history nil
830 "History of files selected using `ido-find-file'.")
831
832 (defvar ido-buffer-history nil
833 "History of buffers selected using `ido-switch-buffer'.")
834
835 (defvar ido-last-directory-list nil
836 "List of last selected directory names.
837 See `ido-enable-last-directory-history' for details.")
838
839 (defvar ido-work-directory-list nil
840 "List of actual working directory names.
841 The current directory is inserted at the front of this list whenever a
842 file is opened with ido-find-file and family.")
843
844 (defvar ido-work-file-list nil
845 "List of actual work file names.
846 Opening a file with `ido-find-file' and similar functions
847 inserts the current file name (relative to its containing directory)
848 at the front of this list.")
849
850 (defvar ido-dir-file-cache nil
851 "List of `file-name-all-completions' results.
852 Each element in the list is of the form (DIR (MTIME) FILE...).")
853
854 (defvar ido-ignore-item-temp-list nil
855 "List of items to ignore in current ido invocation.
856 Intended to be let-bound by functions which calls ido repeatedly.
857 Should never be set permanently.")
858
859 ;; Temporary storage
860
861 (defvar ido-eoinput 1
862 "Point where minibuffer input ends and completion info begins.
863 Copied from `icomplete-eoinput'.")
864 (make-variable-buffer-local 'ido-eoinput)
865
866 (defvar ido-common-match-string nil
867 "Stores the string that is common to all matching files.")
868
869 (defvar ido-rescan nil
870 "Non-nil means we need to regenerate the list of matching items.")
871
872 (defvar ido-rotate nil
873 "Non-nil means we are rotating list of matches.")
874
875 (defvar ido-text nil
876 "Stores the users string as it is typed in.")
877
878 (defvar ido-text-init nil
879 "The initial string for the users string it is typed in.")
880
881 (defvar ido-matches nil
882 "List of files currently matching `ido-text'.")
883
884 (defvar ido-report-no-match t
885 "Report [No Match] when no completions matches ido-text.")
886
887 (defvar ido-exit nil
888 "Flag to monitor how `ido-find-file' exits.
889 If equal to `takeprompt', we use the prompt as the file name to be
890 selected.")
891
892 (defvar ido-current-directory nil
893 "Current directory for ido-find-file.")
894
895 (defvar ido-auto-merge-timer nil
896 "Delay timer for auto merge.")
897
898 (defvar ido-use-mycompletion-depth 0
899 "Non-nil means use `ido' completion feedback.
900 Is set by ido functions to the current minibuffer-depth, so that
901 it doesn't interfere with other minibuffer usage.")
902
903
904 ;;; Variables with dynamic bindings.
905 ;;; Declared here to keep the byte compiler quiet.
906
907 ;; Stores the current ido item type ('file, 'dir or 'buffer).
908 (defvar ido-cur-item)
909
910 ;; Stores the current list of items that will be searched through.
911 ;; The list is ordered, so that the most interesting item comes first,
912 ;; although by default, the files visible in the current frame are put
913 ;; at the end of the list. Created by `ido-make-item-list'.
914 (defvar ido-cur-list)
915
916 ;; Stores the list of items which are ignored when building
917 ;; `ido-cur-list'. It is in no specific order.
918 (defvar ido-ignored-list)
919
920 ;; Keep current item list if non-nil.
921 (defvar ido-keep-item-list)
922
923 ;; Process ido-ignore-* lists.
924 (defvar ido-process-ignore-lists)
925
926 ;; Don't process ido-ignore- lists once.
927 (defvar ido-process-ignore-lists-inhibit)
928
929 ;; Buffer from which ido was entered.
930 (defvar ido-entry-buffer)
931
932 ;; Non-nil if matching file must be selected.
933 (defvar ido-require-match)
934
935 ;; Stores a temporary version of the file list being created.
936 (defvar ido-temp-list)
937
938 ;; Non-nil if default list element should be rotated into place.
939 (defvar ido-rotate-temp)
940
941 ;; Stores current index in ido-work-directory-list.
942 (defvar ido-work-directory-index)
943
944 ;; Stores current index in ido-work-file-list.
945 (defvar ido-work-file-index)
946
947 ;; Set when merged work directory list is in use.
948 (defvar ido-use-merged-list)
949
950 ;; Set when merged work directory list not yet built.
951 (defvar ido-try-merged-list)
952
953 ;; Saved state prior to last work directory merge.
954 ;; Value is a list (ido-text dir cur-list ignored-list matches).
955 (defvar ido-pre-merge-state)
956
957 ;; Original value of vc-master-templates for use in ido-toggle-vc.
958 (defvar ido-saved-vc-mt)
959
960 ;; Stores temporary state of literal find file.
961 (defvar ido-find-literal)
962
963
964 ;;; FUNCTIONS
965
966 (defun ido-active (&optional merge)
967 (if merge
968 ido-use-merged-list
969 (and (boundp 'ido-completing-read) (= ido-use-mycompletion-depth (minibuffer-depth)))))
970
971 (defvar ido-trace-enable nil)
972
973 (defun ido-trace (p &optional s retval)
974 (if ido-trace-enable
975 (let ((b (get-buffer-create " *IDO Trace*"))
976 (deactivate-mark deactivate-mark))
977 (save-excursion
978 (save-restriction
979 (set-buffer b)
980 (insert p ": " (if (stringp s) s (format "%S" s)) "\n")))))
981 retval)
982
983 (defun ido-toggle-trace (arg)
984 (interactive "P")
985 (setq ido-trace-enable (or arg (not ido-trace-enable)))
986 (if ido-trace-enable
987 (message "IDO trace on"))
988 (let ((b (get-buffer " *IDO Trace*")))
989 (if b
990 (if ido-trace-enable
991 (kill-buffer b)
992 (pop-to-buffer b t t)
993 (setq truncate-lines t)))))
994
995 (defun ido-is-tramp-root (&optional dir)
996 (setq dir (or dir ido-current-directory))
997 (and ido-enable-tramp-completion
998 (string-match "\\`/[^/][^/]+:\\([^/:@]+@\\)?\\'" dir)))
999
1000 (defun ido-is-root-directory (&optional dir)
1001 (setq dir (or dir ido-current-directory))
1002 (or
1003 (string-equal "/" dir)
1004 (and (memq system-type '(windows-nt ms-dos))
1005 (string-match "\\`[a-zA-Z]:[/\\]\\'" dir))
1006 (if ido-enable-tramp-completion
1007 (ido-is-tramp-root dir)
1008 (string-match "\\`/[^:/][^:/]+:\\'" dir))))
1009
1010 (defun ido-is-ftp-directory (&optional dir)
1011 (string-match
1012 (if ido-enable-tramp-completion
1013 "\\`/[^/:][^/:]+:" ;; like tramp-file-name-regexp-unified, but doesn't match single drive letters
1014 "\\`/[^/:][^/:]+:/")
1015 (or dir ido-current-directory)))
1016
1017 (defun ido-is-slow-ftp-host (&optional dir)
1018 (and (or ido-slow-ftp-hosts ido-slow-ftp-host-regexps)
1019 (setq dir (or dir ido-current-directory))
1020 ;; (featurep 'ange-ftp)
1021 ;; (ange-ftp-ftp-name dir)
1022 (string-match
1023 (if ido-enable-tramp-completion
1024 "\\`/\\([^/]+[@:]\\)*\\([^@/:][^@/:]+\\):"
1025 "\\`/\\([^/:]*@\\)?\\([^@/:][^@/:]+\\):/")
1026 dir)
1027 (let ((host (substring dir (match-beginning 2) (match-end 2))))
1028 (or (member host ido-slow-ftp-hosts)
1029 (let ((re ido-slow-ftp-host-regexps))
1030 (while (and re (not (string-match (car re) host)))
1031 (setq re (cdr re)))
1032 re)))))
1033
1034 (defun ido-time-stamp (&optional time)
1035 ;; Time is a floating point number (fractions of 1 hour)
1036 (setq time (or time (current-time)))
1037 (/ (+ (* (car time) 65536.0) (car (cdr time))) 3600.0))
1038
1039 (defun ido-cache-ftp-valid (&optional time)
1040 (and (numberp ido-cache-ftp-work-directory-time)
1041 (> ido-cache-ftp-work-directory-time 0)
1042 (or (not time)
1043 (< (- (ido-time-stamp) time) ido-cache-ftp-work-directory-time))))
1044
1045 (defun ido-may-cache-directory (&optional dir)
1046 (setq dir (or dir ido-current-directory))
1047 (cond
1048 ((and (ido-is-root-directory dir)
1049 (or ido-enable-tramp-completion
1050 (memq system-type '(windows-nt ms-dos))))
1051 nil)
1052 ((not (ido-is-ftp-directory dir))
1053 t)
1054 ((ido-cache-ftp-valid)
1055 t)))
1056
1057 (defun ido-pp (list &optional sep)
1058 (let ((print-level nil) (eval-expression-print-level nil)
1059 (print-length nil) (eval-expression-print-length nil))
1060 (insert "\n;; ----- " (symbol-name list) " -----\n(\n ")
1061 (setq list (symbol-value list))
1062 (while list
1063 (let* ((elt (car list))
1064 (s (if (consp elt) (car elt) elt)))
1065 (if (and (stringp s) (= (length s) 0))
1066 (setq s nil))
1067 (if s
1068 (prin1 elt (current-buffer)))
1069 (if (and (setq list (cdr list)) s)
1070 (insert (or sep "\n ")))))
1071 (insert "\n)\n")))
1072
1073 (defun ido-save-history ()
1074 "Save ido history and cache information between sessions."
1075 (interactive)
1076 (if (and ido-last-directory-list ido-save-directory-list-file)
1077 (save-excursion
1078 (save-window-excursion
1079 (if (find-buffer-visiting ido-save-directory-list-file)
1080 (kill-buffer (find-buffer-visiting ido-save-directory-list-file)))
1081 (if (file-exists-p ido-save-directory-list-file)
1082 (delete-file ido-save-directory-list-file))
1083 (set-buffer (let ((enable-local-variables nil))
1084 (find-file-noselect ido-save-directory-list-file t)))
1085 (goto-char (point-min))
1086 (delete-region (point-min) (point-max))
1087 (ido-pp 'ido-last-directory-list)
1088 (ido-pp 'ido-work-directory-list)
1089 (ido-pp 'ido-work-file-list)
1090 (ido-pp 'ido-dir-file-cache "\n\n ")
1091 (insert "\n")
1092 (let ((version-control 'never))
1093 (write-file ido-save-directory-list-file nil))
1094 (kill-buffer (current-buffer))))))
1095
1096 (defun ido-load-history (&optional arg)
1097 "Load ido history and cache information from previous session.
1098 With prefix argument, reload history unconditionally."
1099 (interactive "P")
1100 (if (or arg (and ido-save-directory-list-file (not ido-last-directory-list)))
1101 (let ((file (expand-file-name ido-save-directory-list-file))
1102 buf)
1103 (when (file-readable-p file)
1104 (save-excursion
1105 (save-window-excursion
1106 (setq buf (set-buffer (let ((enable-local-variables nil))
1107 (find-file-noselect file))))
1108 (goto-char (point-min))
1109 (condition-case nil
1110 (setq ido-last-directory-list (read (current-buffer))
1111 ido-work-directory-list (read (current-buffer))
1112 ido-work-file-list (read (current-buffer))
1113 ido-dir-file-cache (read (current-buffer)))
1114 (error nil))))
1115 (kill-buffer buf))))
1116 (ido-wash-history))
1117
1118 (defun ido-wash-history ()
1119 "Clean-up ido history and cache information.
1120 Removes badly formatted data and ignored directories."
1121 (interactive)
1122 ;; Check format of each of our lists, discard bogus elements
1123 (setq ido-last-directory-list
1124 (and (listp ido-last-directory-list)
1125 (let ((l ido-last-directory-list) r)
1126 (while l
1127 (if (and (consp (car l))
1128 (stringp (car (car l)))
1129 (stringp (cdr (car l))))
1130 (setq r (cons (car l) r)))
1131 (setq l (cdr l)))
1132 (nreverse r))))
1133 (setq ido-work-directory-list
1134 (and (listp ido-work-directory-list)
1135 (let ((l ido-work-directory-list) r)
1136 (while l
1137 (if (and (stringp (car l))
1138 (or ido-record-ftp-work-directories
1139 (not (ido-is-ftp-directory (car l)))))
1140 (setq r (cons (car l) r)))
1141 (setq l (cdr l)))
1142 (nreverse r))))
1143 (setq ido-work-file-list
1144 (and (listp ido-work-file-list)
1145 (let ((l ido-work-file-list) r)
1146 (while l
1147 (if (stringp (car l))
1148 (setq r (cons (car l) r)))
1149 (setq l (cdr l)))
1150 (nreverse r))))
1151 (setq ido-dir-file-cache
1152 (and (listp ido-dir-file-cache)
1153 (let ((l ido-dir-file-cache) r)
1154 (while l
1155 (if (and (listp (car l))
1156 (> (length (car l)) 2)
1157 (let ((dir (car (car l)))
1158 (time (car (cdr (car l))))
1159 (files (cdr (cdr (car l)))))
1160 (and
1161 (stringp dir)
1162 (consp time)
1163 (if (integerp (car time))
1164 (and (/= (car time) 0)
1165 (integerp (car (cdr time)))
1166 (/= (car (cdr time)) 0)
1167 (ido-may-cache-directory dir))
1168 (and (eq (car time) 'ftp)
1169 (numberp (cdr time))
1170 (ido-is-ftp-directory dir)
1171 (ido-cache-ftp-valid (cdr time))))
1172 (let ((s files) (ok t))
1173 (while s
1174 (if (stringp (car s))
1175 (setq s (cdr s))
1176 (setq s nil ok nil)))
1177 ok))))
1178 (setq r (cons (car l) r)))
1179 (setq l (cdr l)))
1180 (nreverse r))))
1181
1182 ;; Remove ignored directories from work directory list
1183 ;; according to ido-work-directory-list-ignore-regexps
1184 (if ido-work-directory-list
1185 (let ((dirs (reverse ido-work-directory-list)))
1186 (setq ido-work-directory-list nil)
1187 (while dirs
1188 (ido-record-work-directory (car dirs))
1189 (setq dirs (cdr dirs)))))
1190 ;; Get rid of text properties
1191 (let ((l ido-last-directory-list) e)
1192 (while l
1193 (setq e (car l) l (cdr l))
1194 (set-text-properties 0 (length (car e)) nil (car e))
1195 (set-text-properties 0 (length (cdr e)) nil (cdr e))))
1196 (let ((l ido-work-directory-list) e)
1197 (while l
1198 (setq e (car l) l (cdr l))
1199 (set-text-properties 0 (length e) nil e)))
1200 (let ((l ido-work-file-list) e)
1201 (while l
1202 (setq e (car l) l (cdr l))
1203 (set-text-properties 0 (length e) nil e)))
1204 (let ((l ido-dir-file-cache) e d)
1205 (while l
1206 (setq e (car l) l (cdr l))
1207 (if (listp e)
1208 (while e
1209 (setq d (car e) e (cdr e))
1210 (if (not (consp d))
1211 (set-text-properties 0 (length d) nil d))))))
1212 )
1213
1214
1215 (defun ido-kill-emacs-hook ()
1216 ;; ido kill emacs hook
1217 (ido-save-history))
1218
1219 (defvar ido-minor-mode-map-entry nil)
1220
1221 ;;;###autoload
1222 (defun ido-mode (&optional arg)
1223 "Toggle ido speed-ups on or off.
1224 With ARG, turn ido speed-up on if arg is positive, off otherwise.
1225 Turning on ido-mode will remap (via a minor-mode keymap) the default
1226 keybindings for the `find-file' and `switch-to-buffer' families of
1227 commands to the ido versions of these functions.
1228 However, if ARG arg equals 'files, remap only commands for files, or
1229 if it equals 'buffers, remap only commands for buffer switching.
1230 This function also adds a hook to the minibuffer."
1231 (interactive "P")
1232 (setq ido-mode
1233 (cond
1234 ((null arg) (if ido-mode nil 'both))
1235 ((eq arg t) 'both)
1236 ((eq arg 'files) 'file)
1237 ((eq arg 'buffers) 'buffer)
1238 ((memq arg '(file buffer both)) arg)
1239 ((> (prefix-numeric-value arg) 0) 'both)
1240 (t nil)))
1241
1242 (ido-everywhere (if ido-everywhere 1 -1))
1243
1244 (when ido-mode
1245 (add-hook 'minibuffer-setup-hook 'ido-minibuffer-setup)
1246 (add-hook 'choose-completion-string-functions 'ido-choose-completion-string)
1247 (ido-load-history)
1248
1249 (add-hook 'kill-emacs-hook 'ido-kill-emacs-hook)
1250
1251 (unless ido-minor-mode-map-entry
1252 (setq ido-minor-mode-map-entry (cons 'ido-mode (make-sparse-keymap)))
1253 (add-to-list 'minor-mode-map-alist ido-minor-mode-map-entry))
1254
1255 (let ((map (cdr ido-minor-mode-map-entry)))
1256 (when (memq ido-mode '(file both))
1257 (define-key map [remap find-file] 'ido-find-file)
1258 (define-key map [remap find-file-read-only] 'ido-find-file-read-only)
1259 (define-key map [remap find-alternate-file] 'ido-find-alternate-file)
1260 (define-key map [remap write-file] 'ido-write-file)
1261 (define-key map [remap insert-file] 'ido-insert-file)
1262 (define-key map [remap list-directory] 'ido-list-directory)
1263 (define-key map [remap dired] 'ido-dired)
1264 (define-key map [remap find-file-other-window] 'ido-find-file-other-window)
1265 (define-key map [remap find-file-read-only-other-window] 'ido-find-file-read-only-other-window)
1266 (define-key map [remap find-file-other-frame] 'ido-find-file-other-frame)
1267 (define-key map [remap find-file-read-only-other-frame] 'ido-find-file-read-only-other-frame))
1268
1269 (when (memq ido-mode '(buffer both))
1270 (define-key map [remap switch-to-buffer] 'ido-switch-buffer)
1271 (define-key map [remap switch-to-buffer-other-window] 'ido-switch-buffer-other-window)
1272 (define-key map [remap switch-to-buffer-other-frame] 'ido-switch-buffer-other-frame)
1273 (define-key map [remap insert-buffer] 'ido-insert-buffer)
1274 (define-key map [remap kill-buffer] 'ido-kill-buffer)
1275 (define-key map [remap display-buffer] 'ido-display-buffer)))))
1276
1277 (defun ido-everywhere (arg)
1278 "Enable ido everywhere file and directory names are read."
1279 (interactive "P")
1280 (setq ido-everywhere (if arg
1281 (> (prefix-numeric-value arg) 0)
1282 (not ido-everywhere)))
1283 (setq read-file-name-function
1284 (and ido-everywhere (memq ido-mode '(both file))
1285 'ido-read-file-name))
1286 (setq read-buffer-function
1287 (and ido-everywhere (memq ido-mode '(both buffer))
1288 'ido-read-buffer)))
1289
1290
1291 ;;; IDO KEYMAP
1292 (defun ido-define-mode-map ()
1293 "Set up the keymap for `ido'."
1294 (let (map)
1295 ;; generated every time so that it can inherit new functions.
1296
1297 (setq map (copy-keymap minibuffer-local-map))
1298 (define-key map "\C-a" 'ido-toggle-ignore)
1299 (define-key map "\C-c" 'ido-toggle-case)
1300 (define-key map "\C-e" 'ido-edit-input)
1301 (define-key map "\t" 'ido-complete)
1302 (define-key map " " 'ido-complete-space)
1303 (define-key map "\C-j" 'ido-select-text)
1304 (define-key map "\C-m" 'ido-exit-minibuffer)
1305 (define-key map "\C-p" 'ido-toggle-prefix)
1306 (define-key map "\C-r" 'ido-prev-match)
1307 (define-key map "\C-s" 'ido-next-match)
1308 (define-key map "\C-t" 'ido-toggle-regexp)
1309 (define-key map "\C-z" 'ido-undo-merge-work-directory)
1310 (define-key map [(control ? )] 'ido-restrict-to-matches)
1311 (define-key map [(control ?@)] 'ido-restrict-to-matches)
1312 (define-key map [right] 'ido-next-match)
1313 (define-key map [left] 'ido-prev-match)
1314 (define-key map "?" 'ido-completion-help)
1315
1316 (when (memq ido-cur-item '(file dir))
1317 (define-key map "\C-b" 'ido-enter-switch-buffer)
1318 (define-key map "\C-d" 'ido-enter-dired)
1319 (define-key map "\C-f" 'ido-fallback-command)
1320 (define-key map [down] 'ido-next-match-dir)
1321 (define-key map [up] 'ido-prev-match-dir)
1322 (define-key map [(meta up)] 'ido-prev-work-directory)
1323 (define-key map [(meta down)] 'ido-next-work-directory)
1324 (define-key map [backspace] 'ido-delete-backward-updir)
1325 (define-key map "\d" 'ido-delete-backward-updir)
1326 (define-key map [(meta backspace)] 'ido-delete-backward-word-updir)
1327 (define-key map [(control backspace)] 'ido-up-directory)
1328 (define-key map "\C-l" 'ido-reread-directory)
1329 (define-key map [(meta ?b)] 'ido-next-work-file)
1330 (define-key map [(meta ?d)] 'ido-wide-find-dir)
1331 (define-key map [(meta ?f)] 'ido-wide-find-file)
1332 (define-key map [(meta ?k)] 'ido-forget-work-directory)
1333 (define-key map [(meta ?m)] 'ido-make-directory)
1334 (define-key map [(meta ?n)] 'ido-next-work-directory)
1335 (define-key map [(meta ?o)] 'ido-prev-work-file)
1336 (define-key map [(meta ?p)] 'ido-prev-work-directory)
1337 (define-key map [(meta ?s)] 'ido-merge-work-directories)
1338 )
1339
1340 (when (eq ido-cur-item 'file)
1341 (define-key map "\C-k" 'ido-delete-file-at-head)
1342 (define-key map "\C-o" 'ido-copy-current-word)
1343 (define-key map "\C-w" 'ido-copy-current-file-name)
1344 (define-key map [(meta ?l)] 'ido-toggle-literal)
1345 (define-key map "\C-v" 'ido-toggle-vc)
1346 )
1347
1348 (when (eq ido-cur-item 'buffer)
1349 (define-key map "\C-b" 'ido-fallback-command)
1350 (define-key map "\C-f" 'ido-enter-find-file)
1351 (define-key map "\C-k" 'ido-kill-buffer-at-head)
1352 )
1353
1354 (when (if (boundp 'viper-mode) viper-mode)
1355 (define-key map [remap viper-intercept-ESC-key] 'ignore)
1356 (when (memq ido-cur-item '(file dir))
1357 (define-key map [remap viper-backward-char] 'ido-delete-backward-updir)
1358 (define-key map [remap viper-del-backward-char-in-insert] 'ido-delete-backward-updir)
1359 (define-key map [remap viper-delete-backward-word] 'ido-delete-backward-word-updir)))
1360
1361 (setq ido-mode-map map)
1362 (run-hooks 'ido-define-mode-map-hook)))
1363
1364 (defun ido-final-slash (dir &optional fix-it)
1365 ;; return DIR if DIR has final slash.
1366 ;; else if FIX-IT is non-nil, return DIR/
1367 ;; else return nil.
1368 (setq dir (ido-name dir))
1369 (cond
1370 ((string-match "/\\'" dir) dir)
1371 ((ido-is-tramp-root dir) dir)
1372 (fix-it (concat dir "/"))
1373 (t nil)))
1374
1375 (defun ido-set-current-directory (dir &optional subdir no-merge)
1376 ;; Set ido's current directory to DIR or DIR/SUBDIR
1377 (setq dir (ido-final-slash dir t))
1378 (setq ido-use-merged-list nil
1379 ido-try-merged-list (not no-merge))
1380 (if subdir
1381 (setq dir (ido-final-slash (concat dir subdir) t)))
1382 (if (equal dir ido-current-directory)
1383 nil
1384 (ido-trace "cd" dir)
1385 (setq ido-current-directory dir)
1386 (if (get-buffer ido-completion-buffer)
1387 (kill-buffer ido-completion-buffer))
1388 t))
1389
1390 (defun ido-set-current-home (&optional dir)
1391 ;; Set ido's current directory to user's home directory
1392 (ido-set-current-directory (expand-file-name (or dir "~/"))))
1393
1394 (defun ido-record-command (command arg)
1395 ;; Add (command arg) to command-history if ido-record-commands is t
1396 (if ido-record-commands
1397 (let ((cmd (list command arg)))
1398 (if (or (not command-history)
1399 (not (equal cmd (car command-history))))
1400 (setq command-history (cons cmd command-history))))))
1401
1402 (defun ido-make-prompt (item prompt)
1403 ;; Make the prompt for ido-read-internal
1404 (cond
1405 ((and (memq item '(file dir)) ido-current-directory)
1406 (let ((dirname (abbreviate-file-name ido-current-directory))
1407 (max-width (if (and ido-max-file-prompt-width (floatp ido-max-file-prompt-width))
1408 (floor (* (frame-width) ido-max-file-prompt-width))
1409 ido-max-file-prompt-width))
1410 (literal (and (boundp 'ido-find-literal) ido-find-literal "(literal) "))
1411 (vc-off (and ido-saved-vc-mt (not vc-master-templates) "[-VC] "))
1412 (prefix nil)
1413 (rule ido-rewrite-file-prompt-rules))
1414 (let ((case-fold-search nil))
1415 (while rule
1416 (if (and (consp (car rule))
1417 (string-match (car (car rule)) dirname))
1418 (setq dirname
1419 (if (stringp (cdr (car rule)))
1420 (replace-match (cdr (car rule)) t nil dirname)
1421 (funcall (cdr (car rule)) dirname))))
1422 (setq rule (cdr rule))))
1423 (run-hooks 'ido-rewrite-file-prompt-functions)
1424 (concat prompt
1425 ; (if ido-process-ignore-lists "" "&")
1426 (or literal "")
1427 (or vc-off "")
1428 (or prefix "")
1429 (let ((l (length dirname)))
1430 (if (and max-width (> max-width 0) (> l max-width))
1431 (let* ((s (substring dirname (- max-width)))
1432 (i (string-match "/" s)))
1433 (concat "..." (if i (substring s i) s)))
1434 dirname)))))
1435 (t prompt)))
1436
1437 ;; Here is very briefly how ido-find-file works:
1438 ;;
1439 ;; (ido-find-file)
1440 ;; (ido-file-internal method)
1441 ;; set ido-current-directory
1442 ;; (ido-read-internal 'file ...)
1443 ;; (while ...
1444 ;; (ido-make-item-list ...)
1445 ;; (ido-set-matches)
1446 ;; (completing-read ... ido-text-init ...)
1447 ;;
1448 ;; ... here user is allowed to type characters and commands
1449 ;; a command may set ido-exit and call (exit-minibuffer)
1450 ;; to make ido-read-internal do advanced tasks (or return)
1451 ;;
1452 ;; ... ido-tidy and ido-exhibit are pre- and post-hooks
1453 ;; which are run before and after each user command.
1454 ;;
1455 ;; return value from completing-read is stored in ido-final-text
1456 ;; - ido-exit may cause further actions to be taken:
1457 ;; 'refresh - repeat loop (make-item-list, set-matches)
1458 ;; 'edit - edit the prompt string, then repeat loop
1459 ;; 'keep - repeat loop but don't (re)make-item-list
1460 ;; 'updir - go up one directory, repeat loop
1461 ;; else set ido-selected based on ido-final-text,
1462 ;; optionally update ido-current-directory and repeat loop, or
1463 ;; exit with the return value of ido-selected (file name)
1464 ;; selected file name is returned from ido-read-internal,
1465 ;; ido-exit and method determines what action is taken
1466 ;; e.g. the file name may be ignored or joined with ido-current-directory, and
1467 ;; the relevant function is called (find-file, write-file, etc).
1468
1469 (defun ido-read-internal (item prompt history &optional default require-match initial)
1470 "Perform the ido-read-buffer and ido-read-file-name functions.
1471 Return the name of a buffer or file selected.
1472 PROMPT is the prompt to give to the user.
1473 DEFAULT if given is the default directory to start with.
1474 If REQUIRE-MATCH is non-nil, an existing file must be selected.
1475 If INITIAL is non-nil, it specifies the initial input string."
1476 (let
1477 ((ido-cur-item item)
1478 (ido-entry-buffer (current-buffer))
1479 (ido-process-ignore-lists t)
1480 (ido-process-ignore-lists-inhibit nil)
1481 (ido-set-default-item t)
1482 ido-default-item
1483 ido-selected
1484 ido-final-text
1485 (done nil)
1486 (icomplete-mode nil) ;; prevent icomplete starting up
1487 ;; Exported dynamic variables:
1488 ido-cur-list
1489 ido-ignored-list
1490 (ido-rotate-temp nil)
1491 (ido-keep-item-list nil)
1492 (ido-use-merged-list nil)
1493 (ido-try-merged-list t)
1494 (ido-pre-merge-state nil)
1495 (ido-case-fold ido-case-fold)
1496 (ido-enable-prefix ido-enable-prefix)
1497 (ido-enable-regexp ido-enable-regexp)
1498 )
1499
1500 (ido-define-mode-map)
1501 (setq ido-text-init initial)
1502 (while (not done)
1503 (ido-trace "\n_LOOP_" ido-text-init)
1504 (setq ido-exit nil)
1505 (setq ido-rescan t)
1506 (setq ido-rotate nil)
1507 (setq ido-text "")
1508 (when ido-set-default-item
1509 (setq ido-default-item
1510 (cond
1511 ((eq item 'buffer)
1512 (if (bufferp default) (buffer-name default) default))
1513 ((stringp default) default)
1514 ((eq item 'file)
1515 (and ido-enable-last-directory-history
1516 (let ((d (assoc ido-current-directory ido-last-directory-list)))
1517 (and d (cdr d)))))))
1518 (if (member ido-default-item ido-ignore-item-temp-list)
1519 (setq ido-default-item nil))
1520 (setq ido-set-default-item nil))
1521
1522 (if ido-process-ignore-lists-inhibit
1523 (setq ido-process-ignore-lists nil))
1524
1525 (if (and ido-use-merged-list (memq ido-try-merged-list '(t wide)) (not ido-keep-item-list))
1526 (let ((olist ido-cur-list)
1527 (oign ido-ignored-list)
1528 (omat ido-matches)
1529 (l (ido-make-merged-file-list ido-text-init
1530 (eq ido-use-merged-list 'auto)
1531 (eq ido-try-merged-list 'wide))))
1532 (cond
1533 ((not l)
1534 (if (eq ido-try-merged-list 'wide)
1535 (setq ido-pre-merge-state
1536 (list "" ido-current-directory olist oign omat)
1537 ido-cur-list nil
1538 ido-ignored-list nil
1539 ido-matches nil
1540 ido-keep-item-list t
1541 ido-try-merged-list (if (eq ido-use-merged-list 'auto) 'auto nil)
1542 ido-use-merged-list nil)
1543 (setq ido-cur-list olist
1544 ido-ignored-list oign
1545 ido-matches omat
1546 ido-keep-item-list t
1547 ido-try-merged-list (if (eq ido-use-merged-list 'auto) 'auto nil)
1548 ido-use-merged-list nil)))
1549 ((eq l t)
1550 (setq ido-use-merged-list nil))
1551 (t
1552 (setq ido-pre-merge-state
1553 (list ido-text-init ido-current-directory olist oign omat))
1554 (ido-set-current-directory (car (cdr (car l))))
1555 (if (ido-final-slash ido-text-init)
1556 (setq ido-text-init ""))
1557 (setq ido-cur-list l
1558 ido-ignored-list nil
1559 ido-matches l
1560 ido-rescan nil
1561 ido-keep-item-list t
1562 ido-use-merged-list t)
1563 (ido-trace "Merged" t)
1564 ))))
1565
1566 (cond
1567 (ido-keep-item-list
1568 (setq ido-keep-item-list nil
1569 ido-rescan nil))
1570 ((eq ido-cur-item 'file)
1571 (setq ido-ignored-list nil
1572 ido-cur-list (ido-make-file-list ido-default-item)))
1573 ((eq ido-cur-item 'dir)
1574 (setq ido-ignored-list nil
1575 ido-cur-list (ido-make-dir-list ido-default-item)))
1576 ((eq ido-cur-item 'buffer)
1577 (setq ido-ignored-list nil
1578 ido-cur-list (ido-make-buffer-list ido-default-item)))
1579 (t nil))
1580 (setq ido-rotate-temp nil)
1581
1582 (if ido-process-ignore-lists-inhibit
1583 (setq ido-process-ignore-lists t
1584 ido-process-ignore-lists-inhibit nil))
1585
1586 (ido-set-matches)
1587 (if (and ido-matches (eq ido-try-merged-list 'auto))
1588 (setq ido-try-merged-list t))
1589 (let
1590 ((minibuffer-local-completion-map ido-mode-map)
1591 (max-mini-window-height (or ido-max-window-height
1592 (and (boundp 'max-mini-window-height) max-mini-window-height)))
1593 (ido-completing-read t)
1594 (ido-require-match require-match)
1595 (ido-use-mycompletion-depth (1+ (minibuffer-depth)))
1596 (show-paren-mode nil))
1597 ;; prompt the user for the file name
1598 (setq ido-exit nil)
1599 (setq ido-final-text
1600 (catch 'ido
1601 (completing-read
1602 (ido-make-prompt item prompt)
1603 '(("dummy" . 1)) nil nil ; table predicate require-match
1604 (prog1 ido-text-init (setq ido-text-init nil)) ;initial-contents
1605 history))))
1606 (ido-trace "completing-read" ido-final-text)
1607 (if (get-buffer ido-completion-buffer)
1608 (kill-buffer ido-completion-buffer))
1609
1610 (ido-trace "\n_EXIT_" ido-exit)
1611
1612 (cond
1613 ((eq ido-exit 'refresh)
1614 (if (and (eq ido-use-merged-list 'auto)
1615 (or (input-pending-p)))
1616 (setq ido-use-merged-list nil
1617 ido-keep-item-list t))
1618 nil)
1619
1620 ((eq ido-exit 'done)
1621 (setq done t
1622 ido-selected ido-text
1623 ido-exit nil))
1624
1625 ((memq ido-exit '(edit chdir))
1626 (cond
1627 ((memq ido-cur-item '(file dir))
1628 (let* ((process-environment (cons "HOME=/" process-environment)) ;; cheat read-file-name
1629 (read-file-name-function nil)
1630 (edit (eq ido-exit 'edit))
1631 (d ido-current-directory)
1632 (f ido-text-init)
1633 (new t))
1634 (setq ido-text-init "")
1635 (while new
1636 (setq new (if edit
1637 (read-file-name (concat prompt "[EDIT] ") d (concat d f) nil f)
1638 f)
1639 d (or (file-name-directory new) "/")
1640 f (file-name-nondirectory new)
1641 edit t)
1642 (if (or
1643 (file-directory-p d)
1644 (and (yes-or-no-p (format "Create directory %s? " d))
1645 (condition-case nil
1646 (progn (make-directory d t) t)
1647 (error
1648 (message "Could not create directory")
1649 (sit-for 1)
1650 nil))))
1651 (progn
1652 (ido-set-current-directory d nil (eq ido-exit 'chdir))
1653 (setq ido-text-init f
1654 new nil))))))
1655 (t
1656 (setq ido-text-init (read-string (concat prompt "[EDIT] ") ido-final-text))))
1657 nil)
1658
1659 ((eq ido-exit 'keep)
1660 (setq ido-keep-item-list t))
1661
1662 ((memq ido-exit '(dired fallback findfile findbuffer))
1663 (setq done t))
1664
1665 ((eq ido-exit 'updir)
1666 ;; cannot go up if already at the root-dir (Unix) or at the
1667 ;; root-dir of a certain drive (Windows or MS-DOS).
1668 (if (ido-is-tramp-root)
1669 (when (string-match "\\`\\(/\\([^/]+[:@]\\)*\\)\\([^/]+\\)[:@]\\'" ido-current-directory)
1670 (setq ido-text-init (match-string 3 ido-current-directory))
1671 (ido-set-current-directory (match-string 1 ido-current-directory))
1672 (setq ido-set-default-item t))
1673 (unless (ido-is-root-directory)
1674 (ido-set-current-directory (file-name-directory (substring ido-current-directory 0 -1)))
1675 (setq ido-set-default-item t))))
1676
1677 ;; Handling the require-match must be done in a better way.
1678 ((and require-match (not (ido-existing-item-p)))
1679 (error "must specify valid item"))
1680
1681 (t
1682 (setq ido-selected
1683 (if (or (eq ido-exit 'takeprompt)
1684 (null ido-matches))
1685 ido-final-text
1686 ;; else take head of list
1687 (ido-name (car ido-matches))))
1688
1689 (cond
1690 ((eq item 'buffer)
1691 (setq done t))
1692
1693 ((string-equal "./" ido-selected)
1694 nil)
1695
1696 ((string-equal "../" ido-selected)
1697 ;; cannot go up if already at the root-dir (Unix) or at the
1698 ;; root-dir of a certain drive (Windows or MS-DOS).
1699 (or (ido-is-root-directory)
1700 (ido-set-current-directory (file-name-directory (substring ido-current-directory 0 -1))))
1701 (setq ido-set-default-item t))
1702
1703 ((and (string-match (if ido-enable-tramp-completion "..[:@]\\'" "..:\\'") ido-selected)
1704 (ido-is-root-directory)) ;; Ange-ftp or Tramp
1705 (ido-set-current-directory ido-current-directory ido-selected)
1706 (ido-trace "tramp prefix" ido-selected)
1707 (if (ido-is-slow-ftp-host)
1708 (setq ido-exit 'fallback
1709 done t)
1710 (setq ido-set-default-item t)))
1711 ((or (string-match "[/\\][^/\\]" ido-selected)
1712 (and (memq system-type '(windows-nt ms-dos))
1713 (string-match "\\`.:" ido-selected)))
1714 (ido-set-current-directory (file-name-directory ido-selected))
1715 (setq ido-set-default-item t))
1716
1717 ((string-match "\\`~" ido-selected)
1718 (ido-set-current-home ido-selected))
1719
1720 ((ido-final-slash ido-selected)
1721 (if ido-enable-last-directory-history
1722 (let ((x (assoc ido-current-directory ido-last-directory-list)))
1723 (if x
1724 (setcdr x ido-selected)
1725 (setq ido-last-directory-list
1726 (cons (cons ido-current-directory ido-selected) ido-last-directory-list)))))
1727 (ido-set-current-directory ido-current-directory ido-selected)
1728 (setq ido-set-default-item t))
1729
1730 (t
1731 (setq done t))))))
1732 ido-selected))
1733
1734 (defun ido-edit-input ()
1735 "Edit absolute file name entered so far with ido; terminate by RET."
1736 (interactive)
1737 (setq ido-text-init ido-text)
1738 (setq ido-exit 'edit)
1739 (exit-minibuffer))
1740
1741 ;;; MAIN FUNCTIONS
1742 (defun ido-buffer-internal (method &optional fallback prompt default initial)
1743 ;; Internal function for ido-switch-buffer and friends
1744 (if (not ido-mode)
1745 (call-interactively (or fallback 'switch-to-buffer))
1746 (let ((buf (ido-read-buffer (or prompt "Buffer: ") default nil initial)))
1747
1748 ;; Choose the buffer name: either the text typed in, or the head
1749 ;; of the list of matches
1750
1751 (cond
1752 ((eq ido-exit 'findfile)
1753 (ido-file-internal ido-default-file-method nil nil nil nil ido-text))
1754
1755 ((eq ido-exit 'fallback)
1756 (let ((read-buffer-function nil))
1757 (call-interactively (or fallback 'switch-to-buffer))))
1758
1759 ;; Check buf is non-nil.
1760 ((not buf) nil)
1761 ((= (length buf) 0) nil)
1762
1763 ;; View buffer if it exists
1764 ((get-buffer buf)
1765 (if (eq method 'insert)
1766 (progn
1767 (ido-record-command 'insert-buffer buf)
1768 (insert-buffer buf))
1769 (ido-visit-buffer buf method t)))
1770
1771 ;; buffer doesn't exist
1772 ((eq ido-create-new-buffer 'never)
1773 (message "no buffer matching `%s'" buf))
1774
1775 ((and (eq ido-create-new-buffer 'prompt)
1776 (not (y-or-n-p (format "No buffer matching `%s', create one? " buf))))
1777 nil)
1778
1779 ;; create a new buffer
1780 (t
1781 (setq buf (get-buffer-create buf))
1782 (if (fboundp 'set-buffer-major-mode)
1783 (set-buffer-major-mode buf))
1784 (ido-visit-buffer buf method t))))))
1785
1786 ;;;###autoload
1787 (defun ido-read-buffer (prompt &optional default require-match initial)
1788 "Replacement for the built-in `read-buffer'.
1789 Return the name of a buffer selected.
1790 PROMPT is the prompt to give to the user. DEFAULT if given is the default
1791 buffer to be selected, which will go to the front of the list.
1792 If REQUIRE-MATCH is non-nil, an existing-buffer must be selected.
1793 If INITIAL is non-nil, it specifies the initial input string."
1794 (let ((ido-current-directory nil))
1795 (ido-read-internal 'buffer prompt 'ido-buffer-history default require-match initial)))
1796
1797 (defun ido-record-work-directory (&optional dir)
1798 (when (and (numberp ido-max-work-directory-list) (> ido-max-work-directory-list 0))
1799 (if (and (setq dir (or dir ido-current-directory)) (> (length dir) 0))
1800 (let ((items ido-work-directory-list-ignore-regexps)
1801 (case-fold-search nil))
1802 (while (and items dir)
1803 (if (string-match (car items) dir)
1804 (setq dir nil))
1805 (setq items (cdr items)))
1806 (if dir
1807 (setq ido-work-directory-list (cons dir (delete dir ido-work-directory-list))))))
1808 (if (> (length ido-work-directory-list) ido-max-work-directory-list)
1809 (setcdr (nthcdr (1- ido-max-work-directory-list) ido-work-directory-list) nil))))
1810
1811 (defun ido-forget-work-directory ()
1812 (interactive)
1813 (when (and ido-current-directory ido-work-directory-list)
1814 (setq ido-work-directory-list (delete ido-current-directory ido-work-directory-list))
1815 (when ido-use-merged-list
1816 (ido-undo-merge-work-directory)
1817 (setq ido-exit 'refresh
1818 ido-try-merged-list t
1819 ido-use-merged-list t
1820 ido-text-init ido-text
1821 ido-rotate-temp t)
1822 (exit-minibuffer))))
1823
1824 (defun ido-record-work-file (name)
1825 ;; Save NAME in ido-work-file-list
1826 (when (and (numberp ido-max-work-file-list) (> ido-max-work-file-list 0))
1827 (or
1828 (and ido-work-file-list (equal (car ido-work-file-list) name))
1829 (setq ido-work-file-list (cons name (delete name ido-work-file-list))))
1830 (if (> (length ido-work-file-list) ido-max-work-file-list)
1831 (setcdr (nthcdr (1- ido-max-work-file-list) ido-work-file-list) nil))))
1832
1833 (defun ido-file-internal (method &optional fallback default prompt item initial)
1834 ;; Internal function for ido-find-file and friends
1835 (let ((ido-current-directory (expand-file-name (or default default-directory)))
1836 filename)
1837
1838 (if (or (not ido-mode) (ido-is-slow-ftp-host))
1839 (setq filename t
1840 ido-exit 'fallback))
1841
1842 (let (ido-saved-vc-mt
1843 (vc-master-templates (and (boundp 'vc-master-templates) vc-master-templates))
1844 (ido-work-directory-index -1)
1845 (ido-work-file-index -1)
1846 (ido-find-literal nil))
1847
1848 (unless filename
1849 (setq ido-saved-vc-mt vc-master-templates)
1850 (setq filename (ido-read-internal (or item 'file)
1851 (or prompt "Find file: ")
1852 'ido-file-history nil nil initial)))
1853
1854 ;; Choose the file name: either the text typed in, or the head
1855 ;; of the list of matches
1856
1857 (cond
1858 ((eq ido-exit 'fallback)
1859 ;; Need to guard setting of default-directory here, since
1860 ;; we don't want to change directory of current buffer.
1861 (let ((default-directory ido-current-directory)
1862 (read-file-name-function nil))
1863 (call-interactively (or fallback 'find-file))))
1864
1865 ((eq ido-exit 'findbuffer)
1866 (ido-buffer-internal ido-default-buffer-method nil nil nil ido-text))
1867
1868 ((eq ido-exit 'dired)
1869 (dired (concat ido-current-directory (or ido-text ""))))
1870
1871 ((eq method 'alt-file)
1872 (ido-record-work-file filename)
1873 (setq default-directory ido-current-directory)
1874 (ido-record-work-directory)
1875 (find-alternate-file filename))
1876
1877 ((memq method '(dired list-directory))
1878 (if (equal filename ".")
1879 (setq filename ""))
1880 (let* ((dirname (ido-final-slash (concat ido-current-directory filename) t))
1881 (file (substring dirname 0 -1)))
1882 (cond
1883 ((file-directory-p dirname)
1884 (ido-record-command method dirname)
1885 (ido-record-work-directory dirname)
1886 (funcall method dirname))
1887 ((file-directory-p ido-current-directory)
1888 (cond
1889 ((file-exists-p file)
1890 (ido-record-command method ido-current-directory)
1891 (ido-record-work-directory)
1892 (funcall method ido-current-directory)
1893 (if (eq method 'dired)
1894 (dired-goto-file (expand-file-name file))))
1895 ((string-match "[[*?]" filename)
1896 (setq dirname (concat ido-current-directory filename))
1897 (ido-record-command method dirname)
1898 (ido-record-work-directory)
1899 (funcall method dirname))
1900 ((y-or-n-p (format "Directory %s does not exist. Create it " filename))
1901 (ido-record-command method dirname)
1902 (ido-record-work-directory dirname)
1903 (make-directory-internal dirname)
1904 (funcall method dirname))
1905 (t
1906 ;; put make-directory command on history
1907 (ido-record-command 'make-directory dirname))))
1908 (t (error "No such directory")))))
1909
1910 ((eq method 'write)
1911 (ido-record-work-file filename)
1912 (setq default-directory ido-current-directory)
1913 (ido-record-command 'write-file (concat ido-current-directory filename))
1914 (ido-record-work-directory)
1915 (write-file filename))
1916
1917 ((eq method 'read-only)
1918 (ido-record-work-file filename)
1919 (setq filename (concat ido-current-directory filename))
1920 (ido-record-command fallback filename)
1921 (ido-record-work-directory)
1922 (funcall fallback filename))
1923
1924 ((eq method 'insert)
1925 (ido-record-work-file filename)
1926 (setq filename (concat ido-current-directory filename))
1927 (ido-record-command
1928 (if ido-find-literal 'insert-file-literally 'insert-file)
1929 filename)
1930 (ido-record-work-directory)
1931 (if ido-find-literal
1932 (insert-file-contents-literally filename)
1933 (insert-file-contents filename)))
1934
1935 (filename
1936 (ido-record-work-file filename)
1937 (setq filename (concat ido-current-directory filename))
1938 (ido-record-command 'find-file filename)
1939 (ido-record-work-directory)
1940 (ido-visit-buffer (find-file-noselect filename nil ido-find-literal) method))))))
1941
1942 (defun ido-existing-item-p ()
1943 ;; Return non-nil if there is a matching item
1944 (not (null ido-matches)))
1945
1946 ;;; COMPLETION CODE
1947
1948 (defun ido-set-common-completion ()
1949 ;; Find common completion of `ido-text' in `ido-matches'
1950 ;; The result is stored in `ido-common-match-string'
1951 (let* (val)
1952 (setq ido-common-match-string nil)
1953 (if (and ido-matches
1954 (not ido-enable-regexp) ;; testing
1955 (stringp ido-text)
1956 (> (length ido-text) 0))
1957 (if (setq val (ido-find-common-substring ido-matches ido-text))
1958 (setq ido-common-match-string val)))
1959 val))
1960
1961 (defun ido-complete ()
1962 "Try and complete the current pattern amongst the file names."
1963 (interactive)
1964 (let (res)
1965 (cond
1966 ((and (memq ido-cur-item '(file dir))
1967 (string-match "[$]" ido-text))
1968 (let ((evar (substitute-in-file-name (concat ido-current-directory ido-text))))
1969 (if (not (file-exists-p (file-name-directory evar)))
1970 (message "Expansion generates non-existing directory name")
1971 (if (file-directory-p evar)
1972 (ido-set-current-directory evar)
1973 (let ((d (or (file-name-directory evar) "/"))
1974 (f (file-name-nondirectory evar)))
1975 (when (file-directory-p d)
1976 (ido-set-current-directory d)
1977 (setq ido-text-init f))))
1978 (setq ido-exit 'refresh)
1979 (exit-minibuffer))))
1980
1981 ((not ido-matches)
1982 (when ido-completion-buffer
1983 (call-interactively (setq this-command ido-cannot-complete-command))))
1984
1985 ((and (= 1 (length ido-matches))
1986 (not (and ido-enable-tramp-completion
1987 (string-equal ido-current-directory "/")
1988 (string-match "..[@:]\\'" (car ido-matches)))))
1989 ;; only one choice, so select it.
1990 (exit-minibuffer))
1991
1992 (t ;; else there could be some completions
1993 (setq res ido-common-match-string)
1994 (if (and (not (memq res '(t nil)))
1995 (not (equal res ido-text)))
1996 ;; found something to complete, so put it in the minibuffer.
1997 (progn
1998 ;; move exact match to front if not in prefix mode
1999 (setq ido-rescan (not ido-enable-prefix))
2000 (delete-region (minibuffer-prompt-end) (point))
2001 (insert res))
2002 ;; else nothing to complete
2003 (call-interactively (setq this-command ido-cannot-complete-command))
2004 )))))
2005
2006 (defun ido-complete-space ()
2007 "Try completion unless inserting the space makes sense."
2008 (interactive)
2009 (if (and (stringp ido-common-match-string)
2010 (stringp ido-text)
2011 (cond
2012 ((> (length ido-common-match-string) (length ido-text))
2013 (= (aref ido-common-match-string (length ido-text)) ? ))
2014 (ido-matches
2015 (let (insert-space
2016 (re (concat (regexp-quote ido-text) " "))
2017 (comp ido-matches))
2018 (while comp
2019 (if (string-match re (ido-name (car comp)))
2020 (setq comp nil insert-space t)
2021 (setq comp (cdr comp))))
2022 insert-space))
2023 (t nil)))
2024 (insert " ")
2025 (ido-complete)))
2026
2027 (defun ido-undo-merge-work-directory (&optional text try refresh)
2028 "Undo or redo last ido directory merge operation.
2029 If no merge has yet taken place, toggle automatic merging option."
2030 (interactive)
2031 (cond
2032 (ido-pre-merge-state
2033 (ido-set-current-directory (nth 1 ido-pre-merge-state))
2034 (setq ido-text-init (or text (car ido-pre-merge-state))
2035 ido-cur-list (nth 2 ido-pre-merge-state)
2036 ido-ignored-list (nth 3 ido-pre-merge-state)
2037 ido-matches (nth 4 ido-pre-merge-state)
2038 ido-use-merged-list nil
2039 ido-try-merged-list try
2040 ido-keep-item-list (not refresh)
2041 ido-rescan nil
2042 ido-exit 'refresh
2043 ido-pre-merge-state nil)
2044 (exit-minibuffer))
2045 (text
2046 nil)
2047 (ido-try-merged-list
2048 (setq ido-try-merged-list nil))
2049 (ido-matches
2050 (setq ido-try-merged-list t))
2051 ((not ido-use-merged-list)
2052 (ido-merge-work-directories))))
2053
2054 ;;; TOGGLE FUNCTIONS
2055
2056 (defun ido-toggle-case ()
2057 "Toggle the value of `ido-case-fold'."
2058 (interactive)
2059 (setq ido-case-fold (not ido-case-fold))
2060 ;; ask for list to be regenerated.
2061 (setq ido-rescan t))
2062
2063 (defun ido-toggle-regexp ()
2064 "Toggle the value of `ido-enable-regexp'."
2065 (interactive)
2066 (setq ido-enable-regexp (not ido-enable-regexp))
2067 ;; ask for list to be regenerated.
2068 (setq ido-rescan t))
2069
2070 (defun ido-toggle-prefix ()
2071 "Toggle the value of `ido-enable-prefix'."
2072 (interactive)
2073 (setq ido-enable-prefix (not ido-enable-prefix))
2074 ;; ask for list to be regenerated.
2075 (setq ido-rescan t))
2076
2077 (defun ido-toggle-ignore ()
2078 "Toggle ignoring files specified with `ido-ignore-files'."
2079 (interactive)
2080 (setq ido-process-ignore-lists (not ido-process-ignore-lists))
2081 (setq ido-text-init ido-text)
2082 (setq ido-exit 'refresh)
2083 (exit-minibuffer))
2084
2085 (defun ido-toggle-vc ()
2086 "Disable version control for this file."
2087 (interactive)
2088 (if (and ido-mode (eq ido-cur-item 'file))
2089 (progn
2090 (setq vc-master-templates
2091 (if vc-master-templates nil ido-saved-vc-mt))
2092 (setq ido-text-init ido-text)
2093 (setq ido-exit 'keep)
2094 (exit-minibuffer))))
2095
2096 (defun ido-toggle-literal ()
2097 "Toggle literal reading of this file."
2098 (interactive)
2099 (if (and ido-mode (eq ido-cur-item 'file))
2100 (progn
2101 (setq ido-find-literal (not ido-find-literal))
2102 (setq ido-text-init ido-text)
2103 (setq ido-exit 'keep)
2104 (exit-minibuffer))))
2105
2106 (defun ido-reread-directory ()
2107 "Read current directory again.
2108 May be useful if cached version is no longer valid, but directory
2109 timestamp has not changed (e.g. with ftp or on Windows)."
2110 (interactive)
2111 (if (and ido-mode (eq ido-cur-item 'file))
2112 (progn
2113 (ido-remove-cached-dir ido-current-directory)
2114 (setq ido-text-init ido-text)
2115 (setq ido-rotate-temp t)
2116 (setq ido-exit 'refresh)
2117 (exit-minibuffer))))
2118
2119 (defun ido-exit-minibuffer ()
2120 "Exit minibuffer, but make sure we have a match if one is needed."
2121 (interactive)
2122 (if (or (not ido-require-match)
2123 (ido-existing-item-p))
2124 (throw 'exit nil)))
2125
2126 (defun ido-select-text ()
2127 "Select the buffer or file named by the prompt.
2128 If no buffer or file exactly matching the prompt exists, maybe create a new one."
2129 (interactive)
2130 (setq ido-exit 'takeprompt)
2131 (exit-minibuffer))
2132
2133 (defun ido-fallback-command ()
2134 "Fallback to non-ido version of current command."
2135 (interactive)
2136 (setq ido-exit 'fallback)
2137 (exit-minibuffer))
2138
2139 (defun ido-enter-find-file ()
2140 "Drop into find-file from buffer switching."
2141 (interactive)
2142 (setq ido-exit 'findfile)
2143 (exit-minibuffer))
2144
2145 (defun ido-enter-switch-buffer ()
2146 "Drop into ido-switch-buffer from file switching."
2147 (interactive)
2148 (setq ido-exit 'findbuffer)
2149 (exit-minibuffer))
2150
2151 (defun ido-enter-dired ()
2152 "Drop into dired from file switching."
2153 (interactive)
2154 (setq ido-exit 'dired)
2155 (exit-minibuffer))
2156
2157
2158 (defun ido-up-directory (&optional clear)
2159 "Go up one directory level."
2160 (interactive "P")
2161 (setq ido-text-init (if clear nil ido-text))
2162 (setq ido-exit 'updir)
2163 (setq ido-rotate-temp t)
2164 (exit-minibuffer))
2165
2166 (defun ido-delete-backward-updir (count)
2167 "Delete char backwards, or at beginning of buffer, go up one level."
2168 (interactive "P")
2169 (cond
2170 ((= (minibuffer-prompt-end) (point))
2171 (if (not count)
2172 (ido-up-directory t)))
2173 ((and ido-pre-merge-state (string-equal (car ido-pre-merge-state) ido-text))
2174 (ido-undo-merge-work-directory (substring ido-text 0 -1) t t))
2175 ((eq this-original-command 'viper-backward-char)
2176 (funcall this-original-command (prefix-numeric-value count)))
2177 ((eq this-original-command 'viper-del-backward-char-in-insert)
2178 (funcall this-original-command))
2179 (t
2180 (delete-backward-char (prefix-numeric-value count)))))
2181
2182 (defun ido-delete-backward-word-updir (count)
2183 "Delete all chars backwards, or at beginning of buffer, go up one level."
2184 (interactive "P")
2185 (if (= (minibuffer-prompt-end) (point))
2186 (if (not count)
2187 (ido-up-directory t))
2188 (if (eq this-original-command 'viper-delete-backward-word)
2189 (funcall this-original-command (prefix-numeric-value count))
2190 (backward-kill-word (prefix-numeric-value count)))))
2191
2192 (defun ido-get-work-directory (&optional incr must-match)
2193 (let ((n (length ido-work-directory-list))
2194 (i ido-work-directory-index)
2195 (j 0)
2196 dir)
2197 (if (or (not ido-text) (= (length ido-text) 0))
2198 (setq must-match nil))
2199 (while (< j n)
2200 (setq i (+ i incr)
2201 j (1+ j))
2202 (if (> incr 0)
2203 (if (>= i n) (setq i 0))
2204 (if (< i 0) (setq i (1- n))))
2205 (setq dir (nth i ido-work-directory-list))
2206 (if (and dir
2207 (not (equal dir ido-current-directory))
2208 (file-directory-p dir)
2209 (or (not must-match)
2210 (ido-set-matches1
2211 (if (eq ido-cur-item 'file)
2212 (ido-make-file-list1 dir)
2213 (ido-make-dir-list1 dir)))))
2214 (setq j n)
2215 (setq dir nil)))
2216 (if dir
2217 (setq ido-work-directory-index i))
2218 dir))
2219
2220 (defun ido-prev-work-directory ()
2221 "Change to next working directory in list."
2222 (interactive)
2223 (let ((dir (ido-get-work-directory 1 ido-work-directory-match-only)))
2224 (when dir
2225 (ido-set-current-directory dir)
2226 (setq ido-exit 'refresh)
2227 (setq ido-text-init ido-text)
2228 (setq ido-rotate-temp t)
2229 (exit-minibuffer))))
2230
2231 (defun ido-next-work-directory ()
2232 "Change to previous working directory in list."
2233 (interactive)
2234 (let ((dir (ido-get-work-directory -1 ido-work-directory-match-only)))
2235 (when dir
2236 (ido-set-current-directory dir)
2237 (setq ido-exit 'refresh)
2238 (setq ido-text-init ido-text)
2239 (setq ido-rotate-temp t)
2240 (exit-minibuffer))))
2241
2242 (defun ido-merge-work-directories ()
2243 "Search (and merge) work directories for files matching the current input string."
2244 (interactive)
2245 (setq ido-use-merged-list t ido-try-merged-list t)
2246 (setq ido-exit 'refresh)
2247 (setq ido-text-init ido-text)
2248 (setq ido-rotate-temp t)
2249 (exit-minibuffer))
2250
2251 (defun ido-wide-find-file (&optional file)
2252 "Prompt for FILE to search for using find, starting from current directory."
2253 (interactive)
2254 (unless file
2255 (let ((enable-recursive-minibuffers t))
2256 (setq file
2257 (read-string (concat "Wide find file: " ido-current-directory) ido-text))))
2258 (when (> (length file) 0)
2259 (setq ido-use-merged-list t ido-try-merged-list 'wide)
2260 (setq ido-exit 'refresh)
2261 (setq ido-text-init file)
2262 (setq ido-rotate-temp t)
2263 (exit-minibuffer)))
2264
2265 (defun ido-wide-find-dir (&optional dir)
2266 "Prompt for DIR to search for using find, starting from current directory."
2267 (interactive)
2268 (unless dir
2269 (let ((enable-recursive-minibuffers t))
2270 (setq dir
2271 (read-string (concat "Wide find directory: " ido-current-directory) ido-text))))
2272 (when (> (length dir) 0)
2273 (setq ido-use-merged-list t ido-try-merged-list 'wide)
2274 (setq ido-exit 'refresh)
2275 (setq ido-text-init (ido-final-slash dir t))
2276 (setq ido-rotate-temp t)
2277 (exit-minibuffer)))
2278
2279 (defun ido-make-directory (&optional dir)
2280 "Prompt for DIR to create in current directory."
2281 (interactive)
2282 (unless dir
2283 (let ((enable-recursive-minibuffers t))
2284 (setq dir
2285 (read-string (concat "Make directory: " ido-current-directory) ido-text))))
2286 (when (> (length dir) 0)
2287 (setq dir (concat ido-current-directory dir))
2288 (unless (file-exists-p dir)
2289 (make-directory dir t)
2290 (ido-set-current-directory dir)
2291 (setq ido-exit 'refresh)
2292 (setq ido-text-init nil)
2293 (setq ido-rotate-temp t)
2294 (exit-minibuffer))))
2295
2296 (defun ido-get-work-file (incr)
2297 (let ((n (length ido-work-file-list))
2298 (i (+ ido-work-file-index incr))
2299 name)
2300 (if (> incr 0)
2301 (if (>= i n) (setq i 0))
2302 (if (< i 0) (setq i (1- n))))
2303 (setq name (nth i ido-work-file-list))
2304 (setq ido-work-file-index i)
2305 name))
2306
2307 (defun ido-prev-work-file ()
2308 "Change to next working file name in list."
2309 (interactive)
2310 (let ((name (ido-get-work-file 1)))
2311 (when name
2312 (setq ido-text-init name)
2313 (setq ido-exit 'refresh)
2314 (exit-minibuffer))))
2315
2316 (defun ido-next-work-file ()
2317 "Change to previous working file name in list."
2318 (interactive)
2319 (let ((name (ido-get-work-file -1)))
2320 (when name
2321 (setq ido-text-init name)
2322 (setq ido-exit 'refresh)
2323 (exit-minibuffer))))
2324
2325 (defun ido-copy-current-file-name (all)
2326 "Insert file name of current buffer.
2327 If repeated, insert text from buffer instead."
2328 (interactive "P")
2329 (let* ((bfname (buffer-file-name ido-entry-buffer))
2330 (name (and bfname (file-name-nondirectory bfname))))
2331 (when name
2332 (setq ido-text-init
2333 (if (or all
2334 (not (equal (file-name-directory bfname) ido-current-directory))
2335 (not (string-match "\\.[^.]*\\'" name)))
2336 name
2337 (substring name 0 (1+ (match-beginning 0)))))
2338 (setq ido-exit 'refresh
2339 ido-try-merged-list nil)
2340 (exit-minibuffer))))
2341
2342 (defun ido-copy-current-word (all)
2343 "Insert current word (file or directory name) from current buffer."
2344 (interactive "P")
2345 (let ((word (save-excursion
2346 (set-buffer ido-entry-buffer)
2347 (let ((p (point)) start-line end-line start-name name)
2348 (beginning-of-line)
2349 (setq start-line (point))
2350 (end-of-line)
2351 (setq end-line (point))
2352 (goto-char p)
2353 (if (re-search-backward "[^-_a-zA-Z0-9:./\\~@]" start-line 1)
2354 (forward-char 1))
2355 (setq start-name (point))
2356 (re-search-forward "[-_a-zA-Z0-9:./\\~@]*" end-line 1)
2357 (if (= start-name (point))
2358 nil
2359 (buffer-substring-no-properties start-name (point)))))))
2360 (if (cond
2361 ((not word) nil)
2362 ((string-match "\\`[~/]" word)
2363 (setq ido-text-init word
2364 ido-try-merged-list nil
2365 ido-exit 'chdir))
2366 ((string-match "/" word)
2367 (setq ido-text-init (concat ido-current-directory word)
2368 ido-try-merged-list nil
2369 ido-exit 'chdir))
2370 (t
2371 (setq ido-text-init word
2372 ido-try-merged-list nil
2373 ido-exit 'refresh)))
2374 (exit-minibuffer))))
2375
2376 (defun ido-next-match ()
2377 "Put first element of `ido-matches' at the end of the list."
2378 (interactive)
2379 (if ido-matches
2380 (let ((next (cadr ido-matches)))
2381 (setq ido-cur-list (ido-chop ido-cur-list next))
2382 (setq ido-rescan t)
2383 (setq ido-rotate t))))
2384
2385 (defun ido-prev-match ()
2386 "Put last element of `ido-matches' at the front of the list."
2387 (interactive)
2388 (if ido-matches
2389 (let ((prev (car (last ido-matches))))
2390 (setq ido-cur-list (ido-chop ido-cur-list prev))
2391 (setq ido-rescan t)
2392 (setq ido-rotate t))))
2393
2394 (defun ido-next-match-dir ()
2395 "Find next directory in match list.
2396 If work directories have been merged, cycle through directories for
2397 first matching file."
2398 (interactive)
2399 (if ido-use-merged-list
2400 (if ido-matches
2401 (let* ((elt (car ido-matches))
2402 (dirs (cdr elt)))
2403 (when (> (length dirs) 1)
2404 (setcdr elt (ido-chop dirs (cadr dirs))))
2405 (setq ido-rescan nil)))
2406 (let ((cnt (length ido-matches))
2407 (i 1))
2408 (while (and (< i cnt) (not (ido-final-slash (nth i ido-matches))))
2409 (setq i (1+ i)))
2410 (if (< i cnt)
2411 (setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
2412
2413 (defun ido-prev-match-dir ()
2414 "Find previous directory in match list.
2415 If work directories have been merged, cycle through directories
2416 for first matching file."
2417 (interactive)
2418 (if ido-use-merged-list
2419 (if ido-matches
2420 (let* ((elt (car ido-matches))
2421 (dirs (cdr elt)))
2422 (when (> (length dirs) 1)
2423 (setcdr elt (ido-chop dirs (car (last dirs)))))
2424 (setq ido-rescan nil)))
2425 (let* ((cnt (length ido-matches))
2426 (i (1- cnt)))
2427 (while (and (> i 0) (not (ido-final-slash (nth i ido-matches))))
2428 (setq i (1- i)))
2429 (if (> i 0)
2430 (setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
2431
2432 (defun ido-restrict-to-matches ()
2433 "Set current item list to the currently matched items."
2434 (interactive)
2435 (when ido-matches
2436 (setq ido-cur-list ido-matches
2437 ido-text-init ""
2438 ido-rescan nil
2439 ido-exit 'keep)
2440 (exit-minibuffer)))
2441
2442 (defun ido-chop (items elem)
2443 "Remove all elements before ELEM and put them at the end of ITEMS."
2444 (let ((ret nil)
2445 (next nil)
2446 (sofar nil))
2447 (while (not ret)
2448 (setq next (car items))
2449 (if (equal next elem)
2450 (setq ret (append items (nreverse sofar)))
2451 ;; else
2452 (progn
2453 (setq items (cdr items))
2454 (setq sofar (cons next sofar)))))
2455 ret))
2456
2457 (defun ido-name (item)
2458 ;; Return file name for current item, whether in a normal list
2459 ;; or a merged work directory list.
2460 (if (consp item) (car item) item))
2461
2462
2463 ;;; CREATE LIST OF ALL CURRENT FILES
2464
2465 (defun ido-all-completions ()
2466 ;; Return unsorted list of all competions.
2467 (let ((ido-process-ignore-lists nil))
2468 (cond
2469 ((eq ido-cur-item 'file)
2470 (ido-make-file-list1 ido-current-directory))
2471 ((eq ido-cur-item 'dir)
2472 (ido-make-dir-list1 ido-current-directory))
2473 ((eq ido-cur-item 'buffer)
2474 (ido-make-buffer-list1))
2475 (t nil))))
2476
2477
2478 (defun ido-sort-list (items)
2479 ;; Simple list of file or buffer names
2480 (sort items (lambda (a b) (string-lessp a b))))
2481
2482 (defun ido-sort-merged-list (items promote)
2483 ;; Input is list of ("file" . "dir") cons cells.
2484 ;; Output is sorted list of ("file "dir" ...) lists
2485 (let ((l (sort items (lambda (a b) (string-lessp (car b) (car a)))))
2486 res a cur dirs)
2487 (while l
2488 (setq a (car l)
2489 l (cdr l))
2490 (if (and res (string-equal (car (car res)) (car a)))
2491 (progn
2492 (setcdr (car (if cur (cdr res) res)) (cons (cdr a) (cdr (car res))))
2493 (if (and promote (string-equal ido-current-directory (cdr a)))
2494 (setq cur t)))
2495 (setq res (cons (list (car a) (cdr a)) res)
2496 cur nil)))
2497 res))
2498
2499 (defun ido-wide-find-dirs-or-files (dir file &optional prefix finddir)
2500 ;; As ido-run-find-command, but returns a list of cons pairs ("file" . "dir")
2501 (let ((filenames
2502 (split-string
2503 (shell-command-to-string
2504 (concat "find " dir " -name \"" (if prefix "" "*") file "*\" -type " (if finddir "d" "f") " -print"))))
2505 filename d f
2506 res)
2507 (while filenames
2508 (setq filename (car filenames)
2509 filenames (cdr filenames))
2510 (if (and (string-match "^/" filename)
2511 (file-exists-p filename))
2512 (setq d (file-name-directory filename)
2513 f (file-name-nondirectory filename)
2514 res (cons (cons (if finddir (ido-final-slash f t) f) d) res))))
2515 res))
2516
2517 (defun ido-flatten-merged-list (items)
2518 ;; Create a list of directory names based on a merged directory list.
2519 (let (res)
2520 (while items
2521 (let* ((item (car items))
2522 (file (car item))
2523 (dirs (cdr item)))
2524 (while dirs
2525 (setq res (cons (concat (car dirs) file) res)
2526 dirs (cdr dirs))))
2527 (setq items (cdr items)))
2528 res))
2529
2530 (defun ido-make-merged-file-list (text auto wide)
2531 (let (res)
2532 (message "Searching for `%s'...." text)
2533 (if (and (ido-final-slash text) ido-dir-file-cache)
2534 (if wide
2535 (setq res (ido-wide-find-dirs-or-files
2536 ido-current-directory (substring text 0 -1) ido-enable-prefix t))
2537 ;; Use list of cached directories
2538 (let ((re (concat (regexp-quote (substring text 0 -1)) "[^/:]*/\\'"))
2539 (dirs ido-dir-file-cache)
2540 dir b d f)
2541 (if nil ;; simple
2542 (while dirs
2543 (setq dir (car (car dirs))
2544 dirs (cdr dirs))
2545 (when (and (string-match re dir)
2546 (not (ido-ignore-item-p dir ido-ignore-directories-merge))
2547 (file-directory-p dir))
2548 (setq b (substring dir 0 -1)
2549 f (concat (file-name-nondirectory b) "/")
2550 d (file-name-directory b)
2551 res (cons (cons f d) res))))
2552 (while dirs
2553 (setq dir (car dirs)
2554 d (car dir)
2555 dirs (cdr dirs))
2556 (when (not (ido-ignore-item-p d ido-ignore-directories-merge))
2557 (setq dir (cdr (cdr dir)))
2558 (while dir
2559 (setq f (car dir)
2560 dir (cdr dir))
2561 (if (and (string-match re f)
2562 (not (ido-ignore-item-p f ido-ignore-directories)))
2563 (setq res (cons (cons f d) res)))))
2564 (if (and auto (input-pending-p))
2565 (setq dirs nil
2566 res t))))))
2567 (if wide
2568 (setq res (ido-wide-find-dirs-or-files
2569 ido-current-directory text ido-enable-prefix nil))
2570 (let ((ido-text text)
2571 (dirs ido-work-directory-list)
2572 (must-match (and text (> (length text) 0)))
2573 dir fl)
2574 (if (and auto (not (member ido-current-directory dirs)))
2575 (setq dirs (cons ido-current-directory dirs)))
2576 (while dirs
2577 (setq dir (car dirs)
2578 dirs (cdr dirs))
2579 (when (and dir (stringp dir)
2580 (or ido-merge-ftp-work-directories
2581 (not (ido-is-ftp-directory dir)))
2582 (file-directory-p dir)
2583 (setq fl (if (eq ido-cur-item 'file)
2584 (ido-make-file-list1 dir t)
2585 (ido-make-dir-list1 dir t))))
2586 (if must-match
2587 (setq fl (ido-set-matches1 fl)))
2588 (if fl
2589 (setq res (nconc fl res))))
2590 (if (and auto (input-pending-p))
2591 (setq dirs nil
2592 res t))))))
2593 (if (and res (not (eq res t)))
2594 (setq res (ido-sort-merged-list res auto)))
2595 (when (and (or ido-rotate-temp ido-rotate-file-list-default)
2596 (listp res)
2597 (> (length text) 0))
2598 (let ((elt (assoc text res)))
2599 (when (and elt (not (eq elt (car res))))
2600 (setq res (delq elt res))
2601 (setq res (cons elt res)))))
2602 (message nil)
2603 res))
2604
2605 (defun ido-make-buffer-list1 (&optional frame visible)
2606 ;; Return list of non-ignored buffer names
2607 (delq nil
2608 (mapcar
2609 (lambda (x)
2610 (let ((name (buffer-name x)))
2611 (if (not (or (ido-ignore-item-p name ido-ignore-buffers) (member name visible)))
2612 name)))
2613 (buffer-list frame))))
2614
2615 (defun ido-make-buffer-list (default)
2616 ;; Return the current list of buffers.
2617 ;; Currently visible buffers are put at the end of the list.
2618 ;; The hook `ido-make-buflist-hook' is run after the list has been
2619 ;; created to allow the user to further modify the order of the buffer names
2620 ;; in this list. If DEFAULT is non-nil, and corresponds to an existing buffer,
2621 ;; it is put to the start of the list.
2622 (let* ((ido-current-buffers (ido-get-buffers-in-frames 'current))
2623 (ido-temp-list (ido-make-buffer-list1 (selected-frame) ido-current-buffers)))
2624 (if ido-temp-list
2625 (nconc ido-temp-list ido-current-buffers)
2626 (setq ido-temp-list ido-current-buffers))
2627 (if default
2628 (progn
2629 (setq ido-temp-list
2630 (delete default ido-temp-list))
2631 (setq ido-temp-list
2632 (cons default ido-temp-list))))
2633 (run-hooks 'ido-make-buffer-list-hook)
2634 ido-temp-list))
2635
2636 (defun ido-to-end (items)
2637 ;; Move the elements from ITEMS to the end of `ido-temp-list'
2638 (mapcar
2639 (lambda (elem)
2640 (setq ido-temp-list (delq elem ido-temp-list)))
2641 items)
2642 (if ido-temp-list
2643 (nconc ido-temp-list items)
2644 (setq ido-temp-list items)))
2645
2646 (defun ido-file-name-all-completions1 (dir)
2647 (if (and ido-enable-tramp-completion
2648 (string-match "\\`/\\([^/:]+:\\([^/:@]+@\\)?\\)\\'" dir))
2649
2650 ;; Trick tramp's file-name-all-completions handler to DTRT, as it
2651 ;; has some pretty obscure requirements. This seems to work...
2652 ;; /ftp: => (f-n-a-c "/ftp:" "")
2653 ;; /ftp:kfs: => (f-n-a-c "" "/ftp:kfs:")
2654 ;; /ftp:kfs@ => (f-n-a-c "ftp:kfs@" "/")
2655 ;; /ftp:kfs@kfs: => (f-n-a-c "" "/ftp:kfs@kfs:")
2656 ;; Currently no attempt is made to handle multi: stuff.
2657
2658 (let* ((prefix (match-string 1 dir))
2659 (user-flag (match-beginning 2))
2660 (len (and prefix (length prefix)))
2661 compl)
2662 (if user-flag
2663 (setq dir (substring dir 1)))
2664 (require 'tramp nil t)
2665 (ido-trace "tramp complete" dir)
2666 (setq compl (file-name-all-completions dir (if user-flag "/" "")))
2667 (if (> len 0)
2668 (mapcar (lambda (c) (substring c len)) compl)
2669 compl))
2670 (file-name-all-completions "" dir)))
2671
2672 (defun ido-file-name-all-completions (dir)
2673 ;; Return name of all files in DIR
2674 ;; Uses and updates ido-dir-file-cache
2675 (if (and (numberp ido-max-dir-file-cache) (> ido-max-dir-file-cache 0)
2676 (stringp dir) (> (length dir) 0)
2677 (ido-may-cache-directory dir))
2678 (let* ((cached (assoc dir ido-dir-file-cache))
2679 (ctime (nth 1 cached))
2680 (ftp (ido-is-ftp-directory dir))
2681 (attr (if ftp nil (file-attributes dir)))
2682 (mtime (nth 5 attr))
2683 valid)
2684 (when cached ; should we use the cached entry ?
2685 (if ftp
2686 (setq valid (and (eq (car ctime) 'ftp)
2687 (ido-cache-ftp-valid (cdr ctime))))
2688 (if attr
2689 (setq valid (and (= (car ctime) (car mtime))
2690 (= (car (cdr ctime)) (car (cdr mtime)))))))
2691 (if (not valid)
2692 (setq ido-dir-file-cache (delq cached ido-dir-file-cache)
2693 cached nil)))
2694 (unless cached
2695 (if (and ftp (file-readable-p dir))
2696 (setq mtime (cons 'ftp (ido-time-stamp))))
2697 (if mtime
2698 (setq cached (cons dir (cons mtime (ido-file-name-all-completions1 dir)))
2699 ido-dir-file-cache (cons cached ido-dir-file-cache)))
2700 (if (> (length ido-dir-file-cache) ido-max-dir-file-cache)
2701 (setcdr (nthcdr (1- ido-max-dir-file-cache) ido-dir-file-cache) nil)))
2702 (and cached
2703 (cdr (cdr cached))))
2704 (ido-file-name-all-completions1 dir)))
2705
2706 (defun ido-remove-cached-dir (dir)
2707 ;; Remove dir from ido-dir-file-cache
2708 (if (and ido-dir-file-cache
2709 (stringp dir) (> (length dir) 0))
2710 (let ((cached (assoc dir ido-dir-file-cache)))
2711 (if cached
2712 (setq ido-dir-file-cache (delq cached ido-dir-file-cache))))))
2713
2714
2715 (defun ido-make-file-list1 (dir &optional merged)
2716 ;; Return list of non-ignored files in DIR
2717 ;; If MERGED is non-nil, each file is cons'ed with DIR
2718 (and (or (ido-is-tramp-root dir) (file-directory-p dir))
2719 (delq nil
2720 (mapcar
2721 (lambda (name)
2722 (if (not (ido-ignore-item-p name ido-ignore-files t))
2723 (if merged (cons name dir) name)))
2724 (ido-file-name-all-completions dir)))))
2725
2726 (defun ido-make-file-list (default)
2727 ;; Return the current list of files.
2728 ;; Currently visible files are put at the end of the list.
2729 ;; The hook `ido-make-file-list-hook' is run after the list has been
2730 ;; created to allow the user to further modify the order of the file names
2731 ;; in this list.
2732 (let ((ido-temp-list (ido-make-file-list1 ido-current-directory)))
2733 (setq ido-temp-list (ido-sort-list ido-temp-list))
2734 (let ((default-directory ido-current-directory))
2735 (ido-to-end ;; move ftp hosts and visited files to end
2736 (delq nil (mapcar
2737 (lambda (x) (if (or (string-match "..:\\'" x)
2738 (and (not (ido-final-slash x))
2739 (get-file-buffer x))) x))
2740 ido-temp-list))))
2741 (ido-to-end ;; move . files to end
2742 (delq nil (mapcar
2743 (lambda (x) (if (string-equal (substring x 0 1) ".") x))
2744 ido-temp-list)))
2745 (if (and default (member default ido-temp-list))
2746 (if (or ido-rotate-temp ido-rotate-file-list-default)
2747 (unless (equal default (car ido-temp-list))
2748 (let ((l ido-temp-list) k)
2749 (while (and l (cdr l) (not (equal default (car (cdr l)))))
2750 (setq l (cdr l)))
2751 (setq k (cdr l))
2752 (setcdr l nil)
2753 (nconc k ido-temp-list)
2754 (setq ido-temp-list k)))
2755 (setq ido-temp-list
2756 (delete default ido-temp-list))
2757 (setq ido-temp-list
2758 (cons default ido-temp-list))))
2759 (when ido-show-dot-for-dired
2760 (setq ido-temp-list (delete "." ido-temp-list))
2761 (setq ido-temp-list (cons "." ido-temp-list)))
2762 (run-hooks 'ido-make-file-list-hook)
2763 ido-temp-list))
2764
2765 (defun ido-make-dir-list1 (dir &optional merged)
2766 ;; Return list of non-ignored subdirs in DIR
2767 ;; If MERGED is non-nil, each subdir is cons'ed with DIR
2768 (and (or (ido-is-tramp-root dir) (file-directory-p dir))
2769 (delq nil
2770 (mapcar
2771 (lambda (name)
2772 (and (ido-final-slash name) (not (ido-ignore-item-p name ido-ignore-directories))
2773 (if merged (cons name dir) name)))
2774 (ido-file-name-all-completions dir)))))
2775
2776 (defun ido-make-dir-list (default)
2777 ;; Return the current list of directories.
2778 ;; The hook `ido-make-dir-list-hook' is run after the list has been
2779 ;; created to allow the user to further modify the order of the
2780 ;; directory names in this list.
2781 (let ((ido-temp-list (ido-make-dir-list1 ido-current-directory)))
2782 (setq ido-temp-list (ido-sort-list ido-temp-list))
2783 (ido-to-end ;; move . files to end
2784 (delq nil (mapcar
2785 (lambda (x) (if (string-equal (substring x 0 1) ".") x))
2786 ido-temp-list)))
2787 (if (and default (member default ido-temp-list))
2788 (if (or ido-rotate-temp ido-rotate-file-list-default)
2789 (unless (equal default (car ido-temp-list))
2790 (let ((l ido-temp-list) k)
2791 (while (and l (cdr l) (not (equal default (car (cdr l)))))
2792 (setq l (cdr l)))
2793 (setq k (cdr l))
2794 (setcdr l nil)
2795 (nconc k ido-temp-list)
2796 (setq ido-temp-list k)))
2797 (setq ido-temp-list
2798 (delete default ido-temp-list))
2799 (setq ido-temp-list
2800 (cons default ido-temp-list))))
2801 (setq ido-temp-list (delete "." ido-temp-list))
2802 (setq ido-temp-list (cons "." ido-temp-list))
2803 (run-hooks 'ido-make-dir-list-hook)
2804 ido-temp-list))
2805
2806 ;; List of the files visible in the current frame.
2807 (defvar ido-bufs-in-frame)
2808
2809 (defun ido-get-buffers-in-frames (&optional current)
2810 ;; Return the list of buffers that are visible in the current frame.
2811 ;; If optional argument `current' is given, restrict searching to the
2812 ;; current frame, rather than all frames, regardless of value of
2813 ;; `ido-all-frames'.
2814 (let ((ido-bufs-in-frame nil))
2815 (walk-windows 'ido-get-bufname nil
2816 (if current
2817 nil
2818 ido-all-frames))
2819 ido-bufs-in-frame))
2820
2821 (defun ido-get-bufname (win)
2822 ;; Used by `ido-get-buffers-in-frames' to walk through all windows
2823 (let ((buf (buffer-name (window-buffer win))))
2824 (unless (or (member buf ido-bufs-in-frame)
2825 (member buf ido-ignore-item-temp-list))
2826 ;; Only add buf if it is not already in list.
2827 ;; This prevents same buf in two different windows being
2828 ;; put into the list twice.
2829 (setq ido-bufs-in-frame
2830 (cons buf ido-bufs-in-frame)))))
2831
2832 ;;; FIND MATCHING ITEMS
2833
2834 (defun ido-set-matches1 (items &optional do-full)
2835 ;; Return list of matches in items
2836 (let* ((case-fold-search ido-case-fold)
2837 (slash (and (not ido-enable-prefix) (ido-final-slash ido-text)))
2838 (text (if slash (substring ido-text 0 -1) ido-text))
2839 (rexq (concat (if ido-enable-regexp text (regexp-quote text)) (if slash ".*/" "")))
2840 (re (if ido-enable-prefix (concat "\\`" rexq) rexq))
2841 (full-re (and do-full (not ido-enable-regexp) (not (string-match "\$\\'" re))
2842 (concat "\\`" re "\\'")))
2843 (prefix-re (and full-re (not ido-enable-prefix)
2844 (concat "\\`" rexq)))
2845 full-matches
2846 prefix-matches
2847 matches)
2848 (mapcar
2849 (lambda (item)
2850 (let ((name (ido-name item)))
2851 (if (string-match re name)
2852 (cond
2853 ((and full-re (string-match full-re name))
2854 (setq full-matches (cons item full-matches)))
2855 ((and prefix-re (string-match prefix-re name))
2856 (setq prefix-matches (cons item prefix-matches)))
2857 (t (setq matches (cons item matches))))))
2858 t)
2859 items)
2860 (if prefix-matches
2861 (setq matches (nconc prefix-matches matches)))
2862 (if full-matches
2863 (setq matches (nconc full-matches matches)))
2864 (when (and (null matches)
2865 ido-enable-flex-matching
2866 (> (length ido-text) 1)
2867 (not ido-enable-regexp))
2868 (setq re (mapconcat #'regexp-quote (split-string ido-text "") ".*"))
2869 (if ido-enable-prefix
2870 (setq re (concat "\\`" re)))
2871 (mapcar
2872 (lambda (item)
2873 (let ((name (ido-name item)))
2874 (if (string-match re name)
2875 (setq matches (cons item matches)))))
2876 items))
2877 matches))
2878
2879
2880 (defun ido-set-matches ()
2881 ;; Set `ido-matches' to the list of items matching prompt
2882 (when ido-rescan
2883 (setq ido-matches (ido-set-matches1 (reverse ido-cur-list) (not ido-rotate))
2884 ido-rotate nil)))
2885
2886 (defun ido-ignore-item-p (name re-list &optional ignore-ext)
2887 ;; Return t if the buffer or file NAME should be ignored.
2888 (or (member name ido-ignore-item-temp-list)
2889 (and
2890 ido-process-ignore-lists re-list
2891 (let ((data (match-data))
2892 (ext-list (and ignore-ext ido-ignore-extensions
2893 completion-ignored-extensions))
2894 ignorep nextstr
2895 (flen (length name)) slen)
2896 (while ext-list
2897 (setq nextstr (car ext-list))
2898 (if (cond
2899 ((stringp nextstr)
2900 (and (>= flen (setq slen (length nextstr)))
2901 (string-equal (substring name (- flen slen)) nextstr)))
2902 ((fboundp nextstr) (funcall nextstr name))
2903 (t nil))
2904 (setq ignorep t
2905 ext-list nil
2906 re-list nil)
2907 (setq ext-list (cdr ext-list))))
2908 (while re-list
2909 (setq nextstr (car re-list))
2910 (if (cond
2911 ((stringp nextstr) (string-match nextstr name))
2912 ((fboundp nextstr) (funcall nextstr name))
2913 (t nil))
2914 (setq ignorep t
2915 re-list nil)
2916 (setq re-list (cdr re-list))))
2917 ;; return the result
2918 (if ignorep
2919 (setq ido-ignored-list (cons name ido-ignored-list)))
2920 (set-match-data data)
2921 ignorep))))
2922
2923
2924 ;; Private variable used by `ido-word-matching-substring'.
2925 (defvar ido-change-word-sub)
2926
2927 (defun ido-find-common-substring (items subs)
2928 ;; Return common string following SUBS in each element of ITEMS.
2929 (let (res
2930 alist
2931 ido-change-word-sub)
2932 (setq ido-change-word-sub
2933 (if ido-enable-regexp
2934 subs
2935 (regexp-quote subs)))
2936 (setq res (mapcar #'ido-word-matching-substring items))
2937 (setq res (delq nil res)) ;; remove any nil elements (shouldn't happen)
2938 (setq alist (mapcar #'ido-makealist res)) ;; could use an OBARRAY
2939
2940 ;; try-completion returns t if there is an exact match.
2941 (let* ((completion-ignore-case ido-case-fold)
2942 (comp (try-completion subs alist)))
2943 (if (eq comp t)
2944 subs
2945 comp))))
2946
2947 (defun ido-word-matching-substring (word)
2948 ;; Return part of WORD before 1st match to `ido-change-word-sub'.
2949 ;; If `ido-change-word-sub' cannot be found in WORD, return nil.
2950 (let ((case-fold-search ido-case-fold))
2951 (let ((m (string-match ido-change-word-sub (ido-name word))))
2952 (if m
2953 (substring (ido-name word) m)
2954 ;; else no match
2955 nil))))
2956
2957 (defun ido-makealist (res)
2958 ;; Return dotted pair (RES . 1).
2959 (cons res 1))
2960
2961 (defun ido-choose-completion-string (choice buffer mini-p base-size)
2962 (when (ido-active)
2963 ;; Insert the completion into the buffer where completion was requested.
2964 (if (get-buffer ido-completion-buffer)
2965 (kill-buffer ido-completion-buffer))
2966 (cond
2967 ((ido-active t) ;; ido-use-merged-list
2968 (setq ido-current-directory ""
2969 ido-text choice
2970 ido-exit 'done))
2971 ((not (ido-final-slash choice))
2972 (setq ido-text choice
2973 ido-exit 'done))
2974 (t
2975 (ido-set-current-directory ido-current-directory choice)
2976 (setq ido-exit 'refresh)))
2977 (exit-minibuffer)
2978 t))
2979
2980 (defun ido-completion-help ()
2981 "Show possible completions in a *File Completions* buffer."
2982 (interactive)
2983 (setq ido-rescan nil)
2984 (let ((temp-buf (get-buffer ido-completion-buffer))
2985 display-it full-list)
2986 (if (and (eq last-command this-command) temp-buf)
2987 ;; scroll buffer
2988 (let (win (buf (current-buffer)))
2989 (display-buffer temp-buf nil nil)
2990 (set-buffer temp-buf)
2991 (setq win (get-buffer-window temp-buf))
2992 (if (pos-visible-in-window-p (point-max) win)
2993 (if (or ido-completion-buffer-all-completions (boundp 'ido-completion-buffer-full))
2994 (set-window-start win (point-min))
2995 (set (make-local-variable 'ido-completion-buffer-full) t)
2996 (setq full-list t
2997 display-it t))
2998 (scroll-other-window))
2999 (set-buffer buf))
3000 (setq display-it t))
3001 (if display-it
3002 (with-output-to-temp-buffer ido-completion-buffer
3003 (let ((completion-list (ido-sort-list
3004 (cond
3005 (ido-use-merged-list
3006 (ido-flatten-merged-list (or ido-matches ido-cur-list)))
3007 ((or full-list ido-completion-buffer-all-completions)
3008 (ido-all-completions))
3009 (t
3010 (copy-sequence (or ido-matches ido-cur-list)))))))
3011 (if (featurep 'xemacs)
3012 ;; XEmacs extents are put on by default, doesn't seem to be
3013 ;; any way of switching them off.
3014 ;; This obscure code avoids a byte compiler warning in Emacs.
3015 (let ((f 'display-completion-list))
3016 (funcall f completion-list
3017 :help-string "ido "
3018 :activate-callback
3019 '(lambda (x y z) (message "doesn't work yet, sorry!"))))
3020 ;; else running Emacs
3021 ;;(add-hook 'completion-setup-hook 'completion-setup-function)
3022 (display-completion-list completion-list)))))))
3023
3024 ;;; KILL CURRENT BUFFER
3025 (defun ido-kill-buffer-at-head ()
3026 "Kill the buffer at the head of `ido-matches'."
3027 (interactive)
3028 (let ((enable-recursive-minibuffers t)
3029 (buf (car ido-matches)))
3030 (when buf
3031 (kill-buffer buf)
3032 ;; Check if buffer still exists.
3033 (if (get-buffer buf)
3034 ;; buffer couldn't be killed.
3035 (setq ido-rescan t)
3036 ;; else buffer was killed so remove name from list.
3037 (setq ido-cur-list (delq buf ido-cur-list))))))
3038
3039 ;;; DELETE CURRENT FILE
3040 (defun ido-delete-file-at-head ()
3041 "Delete the file at the head of `ido-matches'."
3042 (interactive)
3043 (let ((enable-recursive-minibuffers t)
3044 (file (car ido-matches)))
3045 (if file
3046 (setq file (concat ido-current-directory file)))
3047 (when (and file
3048 (file-exists-p file)
3049 (not (file-directory-p file))
3050 (file-writable-p ido-current-directory)
3051 (yes-or-no-p (concat "Delete " file " ")))
3052 (delete-file file)
3053 ;; Check if file still exists.
3054 (if (file-exists-p file)
3055 ;; file could not be deleted
3056 (setq ido-rescan t)
3057 ;; else file was killed so remove name from list.
3058 (setq ido-cur-list (delq (car ido-matches) ido-cur-list))))))
3059
3060
3061 ;;; VISIT CHOSEN BUFFER
3062 (defun ido-visit-buffer (buffer method &optional record)
3063 "Visit file named FILE according to METHOD.
3064 Record command in command-history if optional RECORD is non-nil."
3065
3066 (let (win newframe)
3067 (cond
3068 ((eq method 'kill)
3069 (if record
3070 (ido-record-command 'kill-buffer buffer))
3071 (kill-buffer buffer))
3072
3073 ((eq method 'samewindow)
3074 (if record
3075 (ido-record-command 'switch-to-buffer buffer))
3076 (switch-to-buffer buffer))
3077
3078 ((memq method '(always-frame maybe-frame))
3079 (cond
3080 ((and window-system
3081 (setq win (ido-window-buffer-p buffer))
3082 (or (eq method 'always-frame)
3083 (y-or-n-p "Jump to frame? ")))
3084 (setq newframe (window-frame win))
3085 (if (fboundp 'select-frame-set-input-focus)
3086 (select-frame-set-input-focus newframe)
3087 (raise-frame newframe)
3088 (select-frame newframe)
3089 (unless (featurep 'xemacs)
3090 (set-mouse-position (selected-frame) (1- (frame-width)) 0)))
3091 (select-window win))
3092 (t
3093 ;; No buffer in other frames...
3094 (if record
3095 (ido-record-command 'switch-to-buffer buffer))
3096 (switch-to-buffer buffer)
3097 )))
3098
3099 ((eq method 'otherwindow)
3100 (if record
3101 (ido-record-command 'switch-to-buffer buffer))
3102 (switch-to-buffer-other-window buffer))
3103
3104 ((eq method 'display)
3105 (display-buffer buffer))
3106
3107 ((eq method 'otherframe)
3108 (switch-to-buffer-other-frame buffer)
3109 (unless (featurep 'xemacs)
3110 (select-frame-set-input-focus (selected-frame)))
3111 ))))
3112
3113
3114 (defun ido-window-buffer-p (buffer)
3115 ;; Return window pointer if BUFFER is visible in another frame.
3116 ;; If BUFFER is visible in the current frame, return nil.
3117 (let ((blist (ido-get-buffers-in-frames 'current)))
3118 ;;If the buffer is visible in current frame, return nil
3119 (if (member buffer blist)
3120 nil
3121 ;; maybe in other frame or icon
3122 (get-buffer-window buffer 0) ; better than 'visible
3123 )))
3124
3125
3126 ;;; ----------- IDONIZED FUNCTIONS ------------
3127
3128 ;;;###autoload
3129 (defun ido-switch-buffer ()
3130 "Switch to another buffer.
3131 The buffer is displayed according to `ido-default-buffer-method' -- the
3132 default is to show it in the same window, unless it is already visible
3133 in another frame.
3134
3135 As you type in a string, all of the buffers matching the string are
3136 displayed if substring-matching is used \(default). Look at
3137 `ido-enable-prefix' and `ido-toggle-prefix'. When you have found the
3138 buffer you want, it can then be selected. As you type, most keys have their
3139 normal keybindings, except for the following: \\<ido-mode-map>
3140
3141 RET Select the buffer at the front of the list of matches. If the
3142 list is empty, possibly prompt to create new buffer.
3143
3144 \\[ido-select-text] Select the current prompt as the buffer.
3145 If no buffer is found, prompt for a new one.
3146
3147 \\[ido-next-match] Put the first element at the end of the list.
3148 \\[ido-prev-match] Put the last element at the start of the list.
3149 \\[ido-complete] Complete a common suffix to the current string that
3150 matches all buffers. If there is only one match, select that buffer.
3151 If there is no common suffix, show a list of all matching buffers
3152 in a separate window.
3153 \\[ido-edit-input] Edit input string.
3154 \\[ido-fallback-command] Fallback to non-ido version of current command.
3155 \\[ido-toggle-regexp] Toggle regexp searching.
3156 \\[ido-toggle-prefix] Toggle between substring and prefix matching.
3157 \\[ido-toggle-case] Toggle case-sensitive searching of buffer names.
3158 \\[ido-completion-help] Show list of matching buffers in separate window.
3159 \\[ido-enter-find-file] Drop into ido-find-file.
3160 \\[ido-kill-buffer-at-head] Kill buffer at head of buffer list.
3161 \\[ido-toggle-ignore] Toggle ignoring buffers listed in `ido-ignore-buffers'."
3162 (interactive)
3163 (ido-buffer-internal ido-default-buffer-method))
3164
3165 ;;;###autoload
3166 (defun ido-switch-buffer-other-window ()
3167 "Switch to another buffer and show it in another window.
3168 The buffer name is selected interactively by typing a substring.
3169 For details of keybindings, do `\\[describe-function] ido'."
3170 (interactive)
3171 (ido-buffer-internal 'otherwindow 'switch-to-buffer-other-window))
3172
3173 ;;;###autoload
3174 (defun ido-display-buffer ()
3175 "Display a buffer in another window but don't select it.
3176 The buffer name is selected interactively by typing a substring.
3177 For details of keybindings, do `\\[describe-function] ido'."
3178 (interactive)
3179 (ido-buffer-internal 'display 'display-buffer))
3180
3181 ;;;###autoload
3182 (defun ido-kill-buffer ()
3183 "Kill a buffer.
3184 The buffer name is selected interactively by typing a substring.
3185 For details of keybindings, do `\\[describe-function] ido'."
3186 (interactive)
3187 (ido-buffer-internal 'kill 'kill-buffer "Kill buffer: " (buffer-name (current-buffer))))
3188
3189 ;;;###autoload
3190 (defun ido-insert-buffer ()
3191 "Insert contents of a buffer in current buffer after point.
3192 The buffer name is selected interactively by typing a substring.
3193 For details of keybindings, do `\\[describe-function] ido'."
3194 (interactive)
3195 (ido-buffer-internal 'insert 'insert-buffer "Insert buffer: "))
3196
3197 ;;;###autoload
3198 (defun ido-switch-buffer-other-frame ()
3199 "Switch to another buffer and show it in another frame.
3200 The buffer name is selected interactively by typing a substring.
3201 For details of keybindings, do `\\[describe-function] ido'."
3202 (interactive)
3203 (if ido-mode
3204 (ido-buffer-internal 'otherframe)
3205 (call-interactively 'switch-to-buffer-other-frame)))
3206
3207 ;;;###autoload
3208 (defun ido-find-file-in-dir (dir)
3209 "Switch to another file starting from DIR."
3210 (interactive "DDir: ")
3211 (if (not (equal (substring dir -1) "/"))
3212 (setq dir (concat dir "/")))
3213 (ido-file-internal ido-default-file-method nil dir))
3214
3215 ;;;###autoload
3216 (defun ido-find-file ()
3217 "Edit file with name obtained via minibuffer.
3218 The file is displayed according to `ido-default-file-method' -- the
3219 default is to show it in the same window, unless it is already
3220 visible in another frame.
3221
3222 The file name is selected interactively by typing a substring. As you type
3223 in a string, all of the filenames matching the string are displayed if
3224 substring-matching is used \(default). Look at `ido-enable-prefix' and
3225 `ido-toggle-prefix'. When you have found the filename you want, it can
3226 then be selected. As you type, most keys have their normal keybindings,
3227 except for the following: \\<ido-mode-map>
3228
3229 RET Select the file at the front of the list of matches. If the
3230 list is empty, possibly prompt to create new file.
3231
3232 \\[ido-select-text] Select the current prompt as the buffer or file.
3233 If no buffer or file is found, prompt for a new one.
3234
3235 \\[ido-next-match] Put the first element at the end of the list.
3236 \\[ido-prev-match] Put the last element at the start of the list.
3237 \\[ido-complete] Complete a common suffix to the current string that
3238 matches all files. If there is only one match, select that file.
3239 If there is no common suffix, show a list of all matching files
3240 in a separate window.
3241 \\[ido-edit-input] Edit input string (including directory).
3242 \\[ido-prev-work-directory] or \\[ido-next-work-directory] go to previous/next directory in work directory history.
3243 \\[ido-merge-work-directories] search for file in the work directory history.
3244 \\[ido-forget-work-directory] removes current directory from the work directory history.
3245 \\[ido-prev-work-file] or \\[ido-next-work-file] cycle through the work file history.
3246 \\[ido-wide-find-file] and \\[ido-wide-find-dir] prompts and uses find to locate files or directories.
3247 \\[ido-make-directory] prompts for a directory to create in current directory.
3248 \\[ido-fallback-command] Fallback to non-ido version of current command.
3249 \\[ido-toggle-regexp] Toggle regexp searching.
3250 \\[ido-toggle-prefix] Toggle between substring and prefix matching.
3251 \\[ido-toggle-case] Toggle case-sensitive searching of file names.
3252 \\[ido-toggle-vc] Toggle version control for this file.
3253 \\[ido-toggle-literal] Toggle literal reading of this file.
3254 \\[ido-completion-help] Show list of matching files in separate window.
3255 \\[ido-toggle-ignore] Toggle ignoring files listed in `ido-ignore-files'."
3256
3257 (interactive)
3258 (ido-file-internal ido-default-file-method))
3259
3260 ;;;###autoload
3261 (defun ido-find-file-other-window ()
3262 "Switch to another file and show it in another window.
3263 The file name is selected interactively by typing a substring.
3264 For details of keybindings, do `\\[describe-function] ido-find-file'."
3265 (interactive)
3266 (ido-file-internal 'otherwindow 'find-file-other-window))
3267
3268 ;;;###autoload
3269 (defun ido-find-alternate-file ()
3270 "Switch to another file and show it in another window.
3271 The file name is selected interactively by typing a substring.
3272 For details of keybindings, do `\\[describe-function] ido-find-file'."
3273 (interactive)
3274 (ido-file-internal 'alt-file 'find-alternate-file nil "Find alternate file: "))
3275
3276 ;;;###autoload
3277 (defun ido-find-file-read-only ()
3278 "Edit file read-only with name obtained via minibuffer.
3279 The file name is selected interactively by typing a substring.
3280 For details of keybindings, do `\\[describe-function] ido-find-file'."
3281 (interactive)
3282 (ido-file-internal 'read-only 'find-file-read-only nil "Find file read-only: "))
3283
3284 ;;;###autoload
3285 (defun ido-find-file-read-only-other-window ()
3286 "Edit file read-only in other window with name obtained via minibuffer.
3287 The file name is selected interactively by typing a substring.
3288 For details of keybindings, do `\\[describe-function] ido-find-file'."
3289 (interactive)
3290 (ido-file-internal 'read-only 'find-file-read-only-other-window nil "Find file read-only other window: "))
3291
3292 ;;;###autoload
3293 (defun ido-find-file-read-only-other-frame ()
3294 "Edit file read-only in other frame with name obtained via minibuffer.
3295 The file name is selected interactively by typing a substring.
3296 For details of keybindings, do `\\[describe-function] ido-find-file'."
3297 (interactive)
3298 (ido-file-internal 'read-only 'find-file-read-only-other-frame nil "Find file read-only other frame: "))
3299
3300 ;;;###autoload
3301 (defun ido-display-file ()
3302 "Display a file in another window but don't select it.
3303 The file name is selected interactively by typing a substring.
3304 For details of keybindings, do `\\[describe-function] ido-find-file'."
3305 (interactive)
3306 (ido-file-internal 'display))
3307
3308 ;;;###autoload
3309 (defun ido-find-file-other-frame ()
3310 "Switch to another file and show it in another frame.
3311 The file name is selected interactively by typing a substring.
3312 For details of keybindings, do `\\[describe-function] ido-find-file'."
3313 (interactive)
3314 (ido-file-internal 'otherframe 'find-file-other-frame))
3315
3316 ;;;###autoload
3317 (defun ido-write-file ()
3318 "Write current buffer to a file.
3319 The file name is selected interactively by typing a substring.
3320 For details of keybindings, do `\\[describe-function] ido-find-file'."
3321 (interactive)
3322 (let ((ido-process-ignore-lists t)
3323 (ido-work-directory-match-only nil)
3324 (ido-ignore-files (cons "[^/]\\'" ido-ignore-files))
3325 (ido-report-no-match nil)
3326 (ido-auto-merge-work-directories-length -1))
3327 (ido-file-internal 'write 'write-file nil "Write file: ")))
3328
3329 ;;;###autoload
3330 (defun ido-insert-file ()
3331 "Insert contents of file in current buffer.
3332 The file name is selected interactively by typing a substring.
3333 For details of keybindings, do `\\[describe-function] ido-find-file'."
3334 (interactive)
3335 (ido-file-internal 'insert 'insert-file nil "Insert file: "))
3336
3337 ;;;###autoload
3338 (defun ido-dired ()
3339 "Call dired the ido way.
3340 The directory is selected interactively by typing a substring.
3341 For details of keybindings, do `\\[describe-function] ido-find-file'."
3342 (interactive)
3343 (let ((ido-report-no-match nil)
3344 (ido-auto-merge-work-directories-length -1))
3345 (ido-file-internal 'dired 'dired nil "Dired: " 'dir)))
3346
3347 (defun ido-list-directory ()
3348 "Call list-directory the ido way.
3349 The directory is selected interactively by typing a substring.
3350 For details of keybindings, do `\\[describe-function] ido-find-file'."
3351 (interactive)
3352 (let ((ido-report-no-match nil)
3353 (ido-auto-merge-work-directories-length -1))
3354 (ido-file-internal 'list-directory 'list-directory nil "List directory: " 'dir)))
3355
3356 ;;; XEmacs hack for showing default buffer
3357
3358 ;; The first time we enter the minibuffer, Emacs puts up the default
3359 ;; buffer to switch to, but XEmacs doesn't -- presumably there is a
3360 ;; subtle difference in the two versions of post-command-hook. The
3361 ;; default is shown for both whenever we delete all of our text
3362 ;; though, indicating its just a problem the first time we enter the
3363 ;; function. To solve this, we use another entry hook for emacs to
3364 ;; show the default the first time we enter the minibuffer.
3365
3366
3367 ;;; ICOMPLETE TYPE CODE
3368
3369 (defun ido-initiate-auto-merge (buffer)
3370 (ido-trace "\n*merge timeout*" buffer)
3371 (setq ido-auto-merge-timer nil)
3372 (when (and (buffer-live-p buffer)
3373 (= ido-use-mycompletion-depth (minibuffer-depth))
3374 (boundp 'ido-eoinput) ido-eoinput)
3375 (let ((contents (buffer-substring-no-properties (minibuffer-prompt-end) ido-eoinput)))
3376 (ido-trace "request merge")
3377 (setq ido-use-merged-list 'auto
3378 ido-text-init contents
3379 ido-rotate-temp t
3380 ido-exit 'refresh)
3381 (save-excursion
3382 (set-buffer buffer)
3383 (ido-tidy))
3384 (throw 'ido contents))))
3385
3386 (defun ido-exhibit ()
3387 "Post command hook for `ido'."
3388 ;; Find matching files and display a list in the minibuffer.
3389 ;; Copied from `icomplete-exhibit' with two changes:
3390 ;; 1. It prints a default file name when there is no text yet entered.
3391 ;; 2. It calls my completion routine rather than the standard completion.
3392
3393 (when (= ido-use-mycompletion-depth (minibuffer-depth))
3394 (let ((contents (buffer-substring-no-properties (minibuffer-prompt-end) (point-max)))
3395 (buffer-undo-list t)
3396 try-single-dir-match
3397 refresh)
3398
3399 (ido-trace "\nexhibit" this-command)
3400 (ido-trace "dir" ido-current-directory)
3401 (ido-trace "contents" contents)
3402 (ido-trace "list" ido-cur-list)
3403 (ido-trace "matches" ido-matches)
3404 (ido-trace "rescan" ido-rescan)
3405
3406 (save-excursion
3407 (goto-char (point-max))
3408 ;; Register the end of input, so we know where the extra stuff (match-status info) begins:
3409 (unless (boundp 'ido-eoinput)
3410 ;; In case it got wiped out by major mode business:
3411 (make-local-variable 'ido-eoinput))
3412 (setq ido-eoinput (point))
3413
3414 ;; Handle explicit directory changes
3415 (cond
3416 ((eq ido-cur-item 'buffer)
3417 )
3418
3419 ((= (length contents) 0)
3420 )
3421
3422 ((= (length contents) 1)
3423 (when (and (ido-is-tramp-root) (string-equal contents "/"))
3424 (ido-set-current-directory ido-current-directory contents)
3425 (setq refresh t))
3426 )
3427
3428 ((and (string-match (if ido-enable-tramp-completion "..[:@]\\'" "..:\\'") contents)
3429 (ido-is-root-directory)) ;; Ange-ftp or tramp
3430 (ido-set-current-directory ido-current-directory contents)
3431 (when (ido-is-slow-ftp-host)
3432 (setq ido-exit 'fallback)
3433 (exit-minibuffer))
3434 (setq refresh t))
3435
3436 ((ido-final-slash contents) ;; xxx/
3437 (ido-trace "final slash" contents)
3438 (cond
3439 ((string-equal contents "~/")
3440 (ido-set-current-home)
3441 (setq refresh t))
3442 ((string-equal contents "../")
3443 (ido-up-directory t)
3444 (setq refresh t))
3445 ((string-equal contents "./")
3446 (setq refresh t))
3447 ((string-match "\\`~[a-zA-Z0-9]+/\\'" contents)
3448 (ido-trace "new home" contents)
3449 (ido-set-current-home contents)
3450 (setq refresh t))
3451 ((string-match "[$][A-Za-z0-9_]+/\\'" contents)
3452 (let ((exp (condition-case ()
3453 (expand-file-name
3454 (substitute-in-file-name (substring contents 0 -1))
3455 ido-current-directory)
3456 (error nil))))
3457 (ido-trace contents exp)
3458 (when (and exp (file-directory-p exp))
3459 (ido-set-current-directory (file-name-directory exp))
3460 (setq ido-text-init (file-name-nondirectory exp))
3461 (setq refresh t))))
3462 ((and (memq system-type '(windows-nt ms-dos))
3463 (string-equal (substring contents 1) ":/"))
3464 (ido-set-current-directory (file-name-directory contents))
3465 (setq refresh t))
3466 ((string-equal (substring contents -2 -1) "/")
3467 (ido-set-current-directory
3468 (if (memq system-type '(windows-nt ms-dos))
3469 (expand-file-name "/" ido-current-directory)
3470 "/"))
3471 (setq refresh t))
3472 (t
3473 (ido-trace "try single dir")
3474 (setq try-single-dir-match t))))
3475
3476 ((and (string-equal (substring contents -2 -1) "/")
3477 (not (string-match "[$]" contents)))
3478 (ido-set-current-directory
3479 (cond
3480 ((= (length contents) 2)
3481 "/")
3482 (ido-matches
3483 (concat ido-current-directory (car ido-matches)))
3484 (t
3485 (concat ido-current-directory (substring contents 0 -1)))))
3486 (setq ido-text-init (substring contents -1))
3487 (setq refresh t))
3488
3489 ((and (not ido-use-merged-list)
3490 (not (ido-final-slash contents))
3491 (eq ido-try-merged-list t)
3492 (numberp ido-auto-merge-work-directories-length)
3493 (> ido-auto-merge-work-directories-length 0)
3494 (= (length contents) ido-auto-merge-work-directories-length)
3495 (not (and ido-auto-merge-inhibit-characters-regexp
3496 (string-match ido-auto-merge-inhibit-characters-regexp contents)))
3497 (not (input-pending-p)))
3498 (setq ido-use-merged-list 'auto
3499 ido-text-init contents
3500 ido-rotate-temp t)
3501 (setq refresh t))
3502
3503 (t nil))
3504
3505 (when refresh
3506 (ido-trace "refresh on /" ido-text-init)
3507 (setq ido-exit 'refresh)
3508 (exit-minibuffer))
3509
3510 ;; Update the list of matches
3511 (setq ido-text contents)
3512 (ido-set-matches)
3513 (ido-trace "new " ido-matches)
3514
3515 (when (and ido-enter-single-matching-directory
3516 ido-matches
3517 (null (cdr ido-matches))
3518 (ido-final-slash (car ido-matches))
3519 (or try-single-dir-match
3520 (eq ido-enter-single-matching-directory t)))
3521 (ido-trace "single match" (car ido-matches))
3522 (ido-set-current-directory
3523 (concat ido-current-directory (car ido-matches)))
3524 (setq ido-exit 'refresh)
3525 (exit-minibuffer))
3526
3527 (when (and (not ido-matches)
3528 ;; ido-rescan ?
3529 ido-process-ignore-lists
3530 ido-ignored-list)
3531 (let ((ido-process-ignore-lists nil)
3532 (ido-rotate ido-rotate)
3533 (ido-cur-list ido-ignored-list))
3534 (ido-trace "try all" ido-ignored-list)
3535 (ido-set-matches))
3536 (when ido-matches
3537 (ido-trace "found " ido-matches)
3538 (setq ido-rescan t)
3539 (setq ido-process-ignore-lists-inhibit t)
3540 (setq ido-text-init ido-text)
3541 (setq ido-exit 'refresh)
3542 (exit-minibuffer)))
3543
3544 (when (and
3545 ido-rescan
3546 (not ido-matches)
3547 (memq ido-cur-item '(file dir))
3548 (not (ido-is-root-directory))
3549 (> (length contents) 1)
3550 (not (string-match "[$]" contents)))
3551 (ido-trace "merge?")
3552 (if ido-use-merged-list
3553 (ido-undo-merge-work-directory contents nil)
3554 (when (and (eq ido-try-merged-list t)
3555 (numberp ido-auto-merge-work-directories-length)
3556 (= ido-auto-merge-work-directories-length 0)
3557 (not (and ido-auto-merge-inhibit-characters-regexp
3558 (string-match ido-auto-merge-inhibit-characters-regexp contents)))
3559 (not (input-pending-p)))
3560 (ido-trace "\n*start timer*")
3561 (setq ido-auto-merge-timer
3562 (run-with-timer ido-auto-merge-delay-time nil 'ido-initiate-auto-merge (current-buffer))))))
3563
3564 (setq ido-rescan t)
3565
3566 (if (and ido-use-merged-list
3567 ido-matches
3568 (not (string-equal (car (cdr (car ido-matches))) ido-current-directory)))
3569 (progn
3570 (ido-set-current-directory (car (cdr (car ido-matches))))
3571 (setq ido-use-merged-list t
3572 ido-exit 'keep
3573 ido-text-init ido-text)
3574 (exit-minibuffer)))
3575
3576 ;; Insert the match-status information:
3577 (ido-set-common-completion)
3578 (let ((inf (ido-completions
3579 contents
3580 minibuffer-completion-table
3581 minibuffer-completion-predicate
3582 (not minibuffer-completion-confirm))))
3583 (ido-trace "inf" inf)
3584 (insert inf))
3585 ))))
3586
3587 (defun ido-completions (name candidates predicate require-match)
3588 ;; Return the string that is displayed after the user's text.
3589 ;; Modified from `icomplete-completions'.
3590
3591 (let* ((comps ido-matches)
3592 (ind (and (consp (car comps)) (> (length (cdr (car comps))) 1)
3593 ido-merged-indicator))
3594 first)
3595
3596 (if (and ind ido-use-faces)
3597 (put-text-property 0 1 'face 'ido-indicator-face ind))
3598
3599 (if (and ido-use-faces comps)
3600 (let* ((fn (ido-name (car comps)))
3601 (ln (length fn)))
3602 (setq first (format "%s" fn))
3603 (put-text-property 0 ln 'face
3604 (if (= (length comps) 1)
3605 'ido-only-match-face
3606 'ido-first-match-face)
3607 first)
3608 (if ind (setq first (concat first ind)))
3609 (setq comps (cons first (cdr comps)))))
3610
3611 (cond ((null comps)
3612 (if ido-report-no-match
3613 (nth 6 ido-decorations) ;; [No Match]
3614 ""))
3615
3616 ((null (cdr comps)) ;one match
3617 (concat (if (> (length (ido-name (car comps))) (length name))
3618 ;; when there is one match, show the matching file name in full
3619 (concat (nth 4 ido-decorations) ;; [ ... ]
3620 (ido-name (car comps))
3621 (nth 5 ido-decorations))
3622 "")
3623 (if (not ido-use-faces) (nth 7 ido-decorations)))) ;; [Matched]
3624 (t ;multiple matches
3625 (let* ((items (if (> ido-max-prospects 0) (1+ ido-max-prospects) 999))
3626 (alternatives
3627 (apply
3628 #'concat
3629 (cdr (apply
3630 #'nconc
3631 (mapcar
3632 (lambda (com)
3633 (setq com (ido-name com))
3634 (setq items (1- items))
3635 (cond
3636 ((< items 0) ())
3637 ((= items 0) (list (nth 3 ido-decorations))) ; " | ..."
3638 (t
3639 (list (or ido-separator (nth 2 ido-decorations)) ; " | "
3640 (let ((str (substring com 0)))
3641 (if (and ido-use-faces
3642 (not (string= str first))
3643 (ido-final-slash str))
3644 (put-text-property 0 (length str) 'face 'ido-subdir-face str))
3645 str)))))
3646 comps))))))
3647
3648 (concat
3649 ;; put in common completion item -- what you get by pressing tab
3650 (if (and (stringp ido-common-match-string)
3651 (> (length ido-common-match-string) (length name)))
3652 (concat (nth 4 ido-decorations) ;; [ ... ]
3653 (substring ido-common-match-string (length name))
3654 (nth 5 ido-decorations)))
3655 ;; list all alternatives
3656 (nth 0 ido-decorations) ;; { ... }
3657 alternatives
3658 (nth 1 ido-decorations)))))))
3659
3660 (defun ido-minibuffer-setup ()
3661 "Minibuffer setup hook for `ido'."
3662 ;; Copied from `icomplete-minibuffer-setup-hook'.
3663 (when (and (boundp 'ido-completing-read)
3664 (or (featurep 'xemacs)
3665 (= ido-use-mycompletion-depth (minibuffer-depth))))
3666 (add-hook 'pre-command-hook 'ido-tidy nil t)
3667 (add-hook 'post-command-hook 'ido-exhibit nil t)
3668 (setq cua-inhibit-cua-keys t)
3669 (when (featurep 'xemacs)
3670 (ido-exhibit)
3671 (goto-char (point-min)))
3672 (run-hooks 'ido-minibuffer-setup-hook)))
3673
3674 (defun ido-tidy ()
3675 "Pre command hook for `ido'."
3676 ;; Remove completions display, if any, prior to new user input.
3677 ;; Copied from `icomplete-tidy'."
3678
3679 (when ido-auto-merge-timer
3680 (ido-trace "\n*cancel timer*" this-command)
3681 (cancel-timer ido-auto-merge-timer)
3682 (setq ido-auto-merge-timer nil))
3683
3684 (if (and (boundp 'ido-use-mycompletion-depth)
3685 (= ido-use-mycompletion-depth (minibuffer-depth)))
3686 (if (and (boundp 'ido-eoinput)
3687 ido-eoinput)
3688
3689 (if (> ido-eoinput (point-max))
3690 ;; Oops, got rug pulled out from under us - reinit:
3691 (setq ido-eoinput (point-max))
3692 (let ((buffer-undo-list t))
3693 (delete-region ido-eoinput (point-max))))
3694
3695 ;; Reestablish the local variable 'cause minibuffer-setup is weird:
3696 (make-local-variable 'ido-eoinput)
3697 (setq ido-eoinput 1))))
3698
3699 (defun ido-summary-buffers-to-end ()
3700 ;; Move the summaries to the end of the buffer list.
3701 ;; This is an example function which can be hooked on to
3702 ;; `ido-make-buffer-list-hook'. Any buffer matching the regexps
3703 ;; `Summary' or `output\*$'are put to the end of the list.
3704 (let ((summaries (delq nil (mapcar
3705 (lambda (x)
3706 (if (or
3707 (string-match "Summary" x)
3708 (string-match "output\\*\\'" x))
3709 x))
3710 ido-temp-list))))
3711 (ido-to-end summaries)))
3712
3713 ;;; Helper functions for other programs
3714
3715 ;;;###autoload
3716 (defun ido-read-file-name (prompt &optional dir default-filename mustmatch initial predicate)
3717 "Read file name, prompting with PROMPT and completing in directory DIR.
3718 See `read-file-name' for additional parameters."
3719 (cond
3720 ((or (eq predicate 'file-directory-p)
3721 (memq this-command ido-read-file-name-as-directory-commands))
3722 (ido-read-directory-name prompt dir default-filename mustmatch initial))
3723 ((and (not (memq this-command ido-read-file-name-non-ido))
3724 (or (null predicate) (eq predicate 'file-exists-p)))
3725 (let (filename
3726 ido-saved-vc-mt
3727 (vc-master-templates (and (boundp 'vc-master-templates) vc-master-templates))
3728 (ido-current-directory (expand-file-name (or dir default-directory)))
3729 (ido-work-directory-index -1)
3730 (ido-work-file-index -1)
3731 (ido-find-literal nil))
3732 (setq filename
3733 (ido-read-internal 'file prompt 'ido-file-history default-filename mustmatch initial))
3734 (if filename
3735 (concat ido-current-directory filename))))
3736 (t
3737 (let ((read-file-name-function nil))
3738 (read-file-name prompt dir default-filename mustmatch initial predicate)))))
3739
3740 ;;;###autoload
3741 (defun ido-read-directory-name (prompt &optional dir default-dirname mustmatch initial)
3742 "Read directory name, prompting with PROMPT and completing in directory DIR.
3743 See `read-file-name' for additional parameters."
3744 (let (filename
3745 ido-saved-vc-mt
3746 (ido-current-directory (expand-file-name (or dir default-directory)))
3747 (ido-work-directory-index -1)
3748 (ido-work-file-index -1))
3749 (setq filename
3750 (ido-read-internal 'dir prompt 'ido-file-history default-dirname mustmatch initial))
3751 (if filename
3752 (if (and (stringp filename) (string-equal filename "."))
3753 ido-current-directory
3754 (concat ido-current-directory filename)))))
3755
3756 ;;; ido.el ends here