Unquote lambda functions. Add autoload cookies to functions formerly
[emacs.git] / lisp / ido.el
blob314f495a7b1437993b901eeec9f5e946517c71c3
1 ;;; ido.el --- interactively do things with buffers and files.
3 ;; Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 ;; 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
6 ;; Author: Kim F. Storm <storm@cua.dk>
7 ;; Based on: iswitchb by Stephen Eglen <stephen@cns.ed.ac.uk>
8 ;; Keywords: extensions convenience
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is free software; you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation; either version 3, or (at your option)
15 ;; any later version.
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs; see the file COPYING. If not, write to the
24 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
25 ;; Boston, MA 02110-1301, USA.
28 ;;; Commentary:
30 ;; Ido - interactive do - switches between buffers and opens files and
31 ;; directories with a minimum of keystrokes. It is a superset of
32 ;; iswitchb, the interactive buffer switching package by Stephen Eglen.
34 ;; Interactive substring matching
35 ;; ------------------------------
37 ;; As you type in a substring, the list of buffers or files currently
38 ;; matching the substring are displayed as you type. The list is
39 ;; ordered so that the most recent buffers or files visited come at
40 ;; the start of the list.
42 ;; The buffer or file at the start of the list will be the one visited
43 ;; when you press RETURN. By typing more of the substring, the list is
44 ;; narrowed down so that gradually the buffer or file you want will be
45 ;; at the top of the list. Alternatively, you can use C-s and C-r (or
46 ;; the right and left arrow keys) to rotate buffer or file names in the
47 ;; list until the one you want is at the top of the list.
49 ;; Completion is also available so that you can see what is common to
50 ;; all of the matching buffers or files as you type.
52 ;; Example:
54 ;; If I have two buffers called "123456" and "123", with "123456" the
55 ;; most recent, when I use ido-switch-buffer, I first of all get
56 ;; presented with the list of all the buffers
58 ;; Buffer: {123456 | 123}
60 ;; If I then press 2:
61 ;; Buffer: 2[3]{123456 | 123}
63 ;; The list in {...} are the matching buffers, most recent first
64 ;; (buffers visible in the current frame are put at the end of the
65 ;; list by default). At any time I can select the item at the head of
66 ;; the list by pressing RET. I can also put the first element at the
67 ;; end of the list by pressing C-s or [right], or bring the last
68 ;; element to the head of the list by pressing C-r or [left].
70 ;; The item in [...] indicates what can be added to my input by
71 ;; pressing TAB. In this case, I will get "3" added to my input.
73 ;; So, I press TAB:
74 ;; Buffer: 23{123456 | 123}
76 ;; At this point, I still have two matching buffers.
77 ;; If I want the first buffer in the list, I simply press RET. If I
78 ;; wanted the second in the list, I could press C-s to move it to the
79 ;; top of the list and then RET to select it.
81 ;; However, if I type 4, I only have one match left:
82 ;; Buffer: 234[123456]
84 ;; Since there is only one matching buffer left, it is given in [] and
85 ;; it is shown in the `ido-only-match' face (ForestGreen). I can now
86 ;; press TAB or RET to go to that buffer.
88 ;; If I want to create a new buffer named "234", I press C-j instead of
89 ;; TAB or RET.
91 ;; If instead, I type "a":
92 ;; Buffer: 234a [No match]
93 ;; There are no matching buffers. If I press RET or TAB, I can be
94 ;; prompted to create a new buffer called "234a".
96 ;; Of course, where this function comes in really useful is when you
97 ;; can specify the buffer using only a few keystrokes. In the above
98 ;; example, the quickest way to get to the "123456" file would be
99 ;; just to type 4 and then RET (assuming there isn't any newer buffer
100 ;; with 4 in its name).
102 ;; Likewise, if you use C-x C-f (ido-find-file), the list of files and
103 ;; directories in the current directory is provided in the same
104 ;; fashion as the buffers above. The files and directories are
105 ;; normally sorted in alphabetical order, but the most recently
106 ;; visited directory is placed first to speed up navigating to
107 ;; directories that you have visited recently.
109 ;; In addition to scrolling through the list using [right] and [left],
110 ;; you can use [up] and [down] to quickly scroll the list to the next
111 ;; or previous subdirectory.
113 ;; To go down into a subdirectory, and continue the file selection on
114 ;; the files in that directory, simply move the directory to the head
115 ;; of the list and hit RET.
117 ;; To go up to the parent directory, delete any partial file name
118 ;; already specified (e.g. using [backspace]) and hit [backspace].
120 ;; To go to the root directory (on the current drive), enter two
121 ;; slashes. On MS-DOS or Windows, to select the root of another
122 ;; drive, enter X:/ where X is the drive letter. You can also visit
123 ;; files on other hosts using the ange-ftp notations `/host:' and
124 ;; `/user@host:'. See the variable `ido-slow-ftp-hosts' if you want
125 ;; to inhibit the ido substring matching for ftp access.
127 ;; If for some reason you cannot specify the proper file using
128 ;; ido-find-file, you can press C-f to enter the normal find-file.
129 ;; You can also press C-b to drop into ido-switch-buffer.
131 ;; See the doc string of ido-switch-buffer and ido-find-file for full
132 ;; keybindings and features.
133 ;; (describe-function 'ido-find-file)
135 ;; Hidden buffers and files
136 ;; ------------------------
138 ;; Normally, ido does not include hidden buffers (whose name starts
139 ;; with a space) and hidden files and directories (whose name starts
140 ;; with `.') in the list of possible completions. However, if the
141 ;; substring you enter does not match any of the visible buffers or
142 ;; files, ido will automatically look for completions among the hidden
143 ;; buffers or files.
145 ;; You can toggle display of the hidden buffers and files with C-a.
147 ;; Additional functionality
148 ;; ------------------------
150 ;; After C-x b, the buffer at the head of the list can be killed by
151 ;; pressing C-k. If the buffer needs saving, you will be queried
152 ;; before the buffer is killed.
154 ;; Likewise, after C-x C-f, you can delete (i.e. physically remove)
155 ;; the file at the head of the list with C-k. You will always be
156 ;; asked for confirmation before the file is deleted.
158 ;; If you enter C-x b to switch to a buffer visiting a given file, and
159 ;; you find that the file you are after is not in any buffer, you can
160 ;; press C-f to immediately drop into ido-find-file. And you can
161 ;; switch back to buffer selection with C-b.
163 ;; Prefix matching
164 ;; ---------------
166 ;; The standard way of completion with Unix-shells and Emacs is to insert a
167 ;; PREFIX and then hitting TAB (or another completion key). Cause of this
168 ;; behavior has become second nature to a lot of emacs users `ido' offers in
169 ;; addition to the default substring-matching-method (look above) also the
170 ;; prefix-matching-method. The kind of matching is the only difference to
171 ;; the description of the substring-matching above.
173 ;; You can toggle prefix matching with C-p.
175 ;; Example:
177 ;; If you have again two Buffers "123456" and "123" then hitting "2" does
178 ;; not match because "2" is not a PREFIX in any of the buffer-names.
180 ;; Flexible matching
181 ;; -----------------
183 ;; If you set ido-enable-flex-matching, ido will do a more flexible
184 ;; matching (unless regexp matching is active) to find possible matches
185 ;; among the available buffer or file names if no matches are found using
186 ;; the normal prefix or substring matching.
188 ;; The flexible matching implies that any item which simply contains all
189 ;; of the entered characters in the specified sequence will match.
191 ;; Example:
193 ;; If you have four files "alpha", "beta", "gamma", and "delta",
194 ;; entering "aa" will match "alpha" and "gamma", while "ea" matches
195 ;; "beta" and "delta". If prefix matching is also active, "aa" only
196 ;; matches "alpha", while "ea" does not match any files.
198 ;; Regexp matching
199 ;; ---------------
201 ;; There is limited provision for regexp matching within ido,
202 ;; enabled through `ido-enable-regexp' (toggle with C-t).
203 ;; This allows you to type `[ch]$' for example and see all file names
204 ;; ending in `c' or `h'.
206 ;; Note: ido-style completion is inhibited when you enable regexp matching.
209 ;; Customization
210 ;; -------------
212 ;; Customize the `ido' group to change the `ido' functionality.
214 ;; To modify the keybindings, use the ido-setup-hook. For example:
215 ;;(add-hook 'ido-setup-hook 'ido-my-keys)
217 ;;(defun ido-my-keys ()
218 ;; "Add my keybindings for ido."
219 ;; (define-key ido-completion-map " " 'ido-next-match)
220 ;; )
222 ;; Seeing all the matching buffers or files
223 ;; ----------------------------------------
225 ;; If you have many matching files, they may not all fit onto one
226 ;; line of the minibuffer. Normally, the minibuffer window will grow
227 ;; to show you more of the matching files (depending on the setting
228 ;; of the variables `resize-mini-windows' and `max-mini-window-height').
229 ;; If you want ido to behave differently from the default minibuffer
230 ;; resizing behaviour, set the variable `ido-max-window-height'.
232 ;; Also, to improve the responsiveness of ido, the maximum number of
233 ;; matching items is limited to 12, but you can increase or removed
234 ;; this limit via the `ido-max-prospects' variable.
236 ;; To see a full list of all matching buffers in a separate buffer,
237 ;; hit ? or press TAB when there are no further completions to the
238 ;; substring. Repeated TAB presses will scroll you through this
239 ;; separate buffer.
241 ;; Changing the list of files
242 ;; --------------------------
244 ;; By default, the list of current files is most recent first,
245 ;; oldest last, with the exception that the files visible in the
246 ;; current frame are put at the end of the list. A hook exists to
247 ;; allow other functions to order the list. For example, if you add:
249 ;; (add-hook 'ido-make-buffer-list-hook 'ido-summary-buffers-to-end)
251 ;; then all files matching "Summary" are moved to the end of the
252 ;; list. (I find this handy for keeping the INBOX Summary and so on
253 ;; out of the way.) It also moves files matching "output\*$" to the
254 ;; end of the list (these are created by AUCTeX when compiling.)
255 ;; Other functions could be made available which alter the list of
256 ;; matching files (either deleting or rearranging elements.)
258 ;; Highlighting
259 ;; ------------
261 ;; The highlighting of matching items is controlled via ido-use-faces.
262 ;; The faces used are ido-first-match, ido-only-match and
263 ;; ido-subdir.
264 ;; Colouring of the matching item was suggested by
265 ;; Carsten Dominik (dominik@strw.leidenuniv.nl).
267 ;; Replacement for read-buffer and read-file-name
268 ;; ----------------------------------------------
270 ;; ido-read-buffer and ido-read-file-name have been written to be drop
271 ;; in replacements for the normal buffer and file name reading
272 ;; functions `read-buffer' and `read-file-name'.
274 ;; To use ido for all buffer and file selections in Emacs, customize the
275 ;; variable `ido-everywhere'.
277 ;; Using ido-like behaviour in other lisp packages
278 ;; -----------------------------------------------
280 ;; If you don't want to rely on the `ido-everywhere' functionality,
281 ;; ido-read-buffer, ido-read-file-name, and ido-read-directory-name
282 ;; can be used by other packages to read a buffer name, a file name,
283 ;; or a directory name in the `ido' way.
285 ;;; Acknowledgements
287 ;; Infinite amounts of gratitude goes to Stephen Eglen <stephen@cns.ed.ac.uk>
288 ;; who wrote iswitch-buffer mode - from which I ripped off 99% of the code
289 ;; for ido-switch-buffer and found the inspiration for ido-find-file.
290 ;; The ido package would never have existed without his work.
292 ;; Also thanks to Klaus Berndl, Rohit Namjoshi, Robert Fenk, Alex
293 ;; Schroeder, Bill Benedetto, Stephen Eglen, and many others for bug
294 ;; fixes and improvements.
296 ;;; History
298 ;; Since I discovered Stephen Eglen's excellent iswitchb package, I just
299 ;; couldn't live without it, but once being addicted to switching buffers
300 ;; with a minimum of keystrokes, I soon found that opening files in the
301 ;; old-fashioned way was just too slow - so I decided to write a package
302 ;; which could open files with the same speed and ease as iswitchb could
303 ;; switch buffers.
305 ;; I originally wrote a separate ifindf.el package based on a copy of
306 ;; iswitchb.el, which did for opening files what iswitchb did for
307 ;; switching buffers. Along the way, I corrected a few errors in
308 ;; ifindf which could have found its way back into iswitchb, but since
309 ;; most of the functionality of the two package was practically
310 ;; identical, I decided that the proper thing to do was to merge my
311 ;; ifindf package back into iswitchb.
313 ;; This is basically what ido (interactively do) is all about; but I
314 ;; found it ackward to merge my changes into the "iswitchb-" namespace,
315 ;; so I invented a common "ido-" namespace for the merged packages.
317 ;; This version is based on ido.el version 1.57 released on
318 ;; gnu.emacs.sources adapted for emacs 22.1 to use command remapping
319 ;; and optionally hooking the read-buffer and read-file-name functions.
321 ;; Prefix matching was added by Klaus Berndl <klaus.berndl@sdm.de> based on
322 ;; an idea of Yuji Minejima <ggb01164@nifty.ne.jp> and his mcomplete-package.
325 ;;; Code:
327 (provide 'ido)
329 (defvar cua-inhibit-cua-keys)
331 ;;; User Variables
333 ;; These are some things you might want to change.
335 (defun ido-fractionp (n)
336 (and (numberp n) (> n 0.0) (<= n 1.0)))
338 (defgroup ido nil
339 "Switch between files using substrings."
340 :group 'extensions
341 :group 'convenience
342 :version "22.1"
343 :link '(emacs-commentary-link :tag "Commentary" "ido.el")
344 :link '(emacs-library-link :tag "Lisp File" "ido.el"))
346 ;;;###autoload
347 (defcustom ido-mode nil
348 "Determines for which functional group \(buffer and files) ido behavior
349 should be enabled. The following values are possible:
350 - `buffer': Turn only on ido buffer behavior \(switching, killing,
351 displaying...)
352 - `file': Turn only on ido file behavior \(finding, writing, inserting...)
353 - `both': Turn on ido buffer and file behavior.
354 - `nil': Turn off any ido switching.
356 Setting this variable directly does not take effect;
357 use either \\[customize] or the function `ido-mode'."
358 :set #'(lambda (symbol value)
359 (ido-mode value))
360 :initialize 'custom-initialize-set
361 :require 'ido
362 :link '(emacs-commentary-link "ido.el")
363 :set-after '(ido-save-directory-list-file
364 ;; This will clear ido-unc-hosts-cache, so set it
365 ;; before loading history file.
366 ido-unc-hosts)
367 :type '(choice (const :tag "Turn on only buffer" buffer)
368 (const :tag "Turn on only file" file)
369 (const :tag "Turn on both buffer and file" both)
370 (const :tag "Switch off all" nil))
371 :group 'ido)
373 (defcustom ido-everywhere nil
374 "Use ido everywhere for reading file names and directories.
375 Setting this variable directly does not work. Use `customize' or
376 call the function `ido-everywhere'."
377 :set #'(lambda (symbol value)
378 (ido-everywhere (if value 1 -1)))
379 :initialize 'custom-initialize-default
380 :type 'boolean
381 :group 'ido)
383 (defcustom ido-case-fold case-fold-search
384 "*Non-nil if searching of buffer and file names should ignore case."
385 :type 'boolean
386 :group 'ido)
388 (defcustom ido-ignore-buffers
389 '("\\` ")
390 "*List of regexps or functions matching buffer names to ignore.
391 For example, traditional behavior is not to list buffers whose names begin
392 with a space, for which the regexp is `\\` '. See the source file for
393 example functions that filter buffernames."
394 :type '(repeat (choice regexp function))
395 :group 'ido)
397 (defcustom ido-ignore-files
398 '("\\`CVS/" "\\`#" "\\`.#" "\\`\\.\\./" "\\`\\./")
399 "*List of regexps or functions matching file names to ignore.
400 For example, traditional behavior is not to list files whose names begin
401 with a #, for which the regexp is `\\`#'. See the source file for
402 example functions that filter filenames."
403 :type '(repeat (choice regexp function))
404 :group 'ido)
406 (defcustom ido-ignore-extensions t
407 "*Non-nil means ignore files in `completion-ignored-extensions' list."
408 :type 'boolean
409 :group 'ido)
411 (defcustom ido-show-dot-for-dired nil
412 "*Non-nil means to always put . as the first item in file name lists.
413 This allows the current directory to be opened immediately with `dired'."
414 :type 'boolean
415 :group 'ido)
417 (defcustom ido-file-extensions-order nil
418 "*List of file extensions specifying preferred order of file selections.
419 Each element is either a string with `.' as the first char, an empty
420 string matching files without extension, or t which is the default order
421 for files with an unlisted file extension."
422 :type '(repeat (choice string
423 (const :tag "Default order" t)))
424 :group 'ido)
426 (defcustom ido-ignore-directories
427 '("\\`CVS/" "\\`\\.\\./" "\\`\\./")
428 "*List of regexps or functions matching sub-directory names to ignore."
429 :type '(repeat (choice regexp function))
430 :group 'ido)
432 (defcustom ido-ignore-directories-merge nil
433 "*List of regexps or functions matching directory names to ignore during merge.
434 Directory names matched by one of the regexps in this list are not inserted
435 in merged file and directory lists."
436 :type '(repeat (choice regexp function))
437 :group 'ido)
439 ;; Examples for setting the value of ido-ignore-buffers
440 ;;(defun ido-ignore-c-mode (name)
441 ;; "Ignore all c mode buffers -- example function for ido."
442 ;; (with-current-buffer name
443 ;; (derived-mode-p 'c-mode)))
445 ;;(setq ido-ignore-buffers '("^ " ido-ignore-c-mode))
447 ;; Examples for setting the value of ido-ignore-files
448 ;;(setq ido-ignore-files '("^ " "\\.c\\'" "\\.h\\'"))
450 (defcustom ido-default-file-method 'raise-frame
451 "*How to visit a new file when using `ido-find-file'.
452 Possible values:
453 `selected-window' Show new file in selected window
454 `other-window' Show new file in another window (same frame)
455 `display' Display file in another window without selecting to it
456 `other-frame' Show new file in another frame
457 `maybe-frame' If a file is visible in another frame, prompt to ask if you
458 you want to see the file in the same window of the current
459 frame or in the other frame
460 `raise-frame' If a file is visible in another frame, raise that
461 frame; otherwise, visit the file in the same window"
462 :type '(choice (const :tag "Visit in selected window" selected-window)
463 (const :tag "Visit in other window" other-window)
464 (const :tag "Display (no select) in other window" display)
465 (const :tag "Visit in other frame" other-frame)
466 (const :tag "Ask to visit in other frame" maybe-frame)
467 (const :tag "Raise frame if already visited" raise-frame))
468 :group 'ido)
470 (defcustom ido-default-buffer-method 'raise-frame
471 "*How to switch to new buffer when using `ido-switch-buffer'.
472 See `ido-default-file-method' for details."
473 :type '(choice (const :tag "Show in selected window" selected-window)
474 (const :tag "Show in other window" other-window)
475 (const :tag "Display (no select) in other window" display)
476 (const :tag "Show in other frame" other-frame)
477 (const :tag "Ask to show in other frame" maybe-frame)
478 (const :tag "Raise frame if already shown" raise-frame))
479 :type '(choice (const selected-window)
480 (const other-window)
481 (const display)
482 (const other-frame)
483 (const maybe-frame)
484 (const raise-frame))
485 :group 'ido)
487 (defcustom ido-enable-flex-matching nil
488 "*Non-nil means that `ido' will do flexible string matching.
489 Flexible matching means that if the entered string does not
490 match any item, any item containing the entered characters
491 in the given sequence will match."
492 :type 'boolean
493 :group 'ido)
496 (defcustom ido-enable-regexp nil
497 "*Non-nil means that `ido' will do regexp matching.
498 Value can be toggled within `ido' using `ido-toggle-regexp'."
499 :type 'boolean
500 :group 'ido)
502 (defcustom ido-enable-prefix nil
503 "*Non-nil means only match if the entered text is a prefix of file name.
504 This behavior is like the standard emacs-completion.
505 If nil, match if the entered text is an arbitrary substring.
506 Value can be toggled within `ido' using `ido-toggle-prefix'."
507 :type 'boolean
508 :group 'ido)
510 (defcustom ido-enable-dot-prefix nil
511 "*Non-nil means to match leading dot as prefix.
512 I.e. hidden files and buffers will match only if you type a dot
513 as first char even if `ido-enable-prefix' is nil."
514 :type 'boolean
515 :group 'ido)
517 (defcustom ido-confirm-unique-completion nil
518 "*Non-nil means that even a unique completion must be confirmed.
519 This means that \\[ido-complete] must always be followed by \\[ido-exit-minibuffer]
520 even when there is only one unique completion."
521 :type 'boolean
522 :group 'ido)
524 (defcustom ido-cannot-complete-command 'ido-completion-help
525 "*Command run when `ido-complete' can't complete any more.
526 The most useful values are `ido-completion-help', which pops up a
527 window with completion alternatives, or `ido-next-match' or
528 `ido-prev-match', which cycle the buffer list."
529 :type 'function
530 :group 'ido)
533 (defcustom ido-record-commands t
534 "*Non-nil means that `ido' will record commands in command history.
535 Note that the non-ido equivalent command is recorded."
536 :type 'boolean
537 :group 'ido)
539 (defcustom ido-max-prospects 12
540 "*Non-zero means that the prospect list will be limited to than number of items.
541 For a long list of prospects, building the full list for the minibuffer can take a
542 non-negligible amount of time; setting this variable reduces that time."
543 :type 'integer
544 :group 'ido)
546 (defcustom ido-max-file-prompt-width 0.35
547 "*Non-zero means that the prompt string be limited to than number of characters.
548 If value is a floating point number, it specifies a fraction of the frame width."
549 :type '(choice
550 (integer :tag "Characters" :value 20)
551 (restricted-sexp :tag "Fraction of frame width"
552 :value 0.35
553 :match-alternatives (ido-fractionp)))
554 :group 'ido)
556 (defcustom ido-max-window-height nil
557 "*Non-nil specifies a value to override `max-mini-window-height'."
558 :type '(choice
559 (const :tag "Don't override" nil)
560 (integer :tag "Number of lines" :value 1)
561 (restricted-sexp
562 :tag "Fraction of window height"
563 :value 0.25
564 :match-alternatives (ido-fractionp)))
565 :group 'ido)
567 (defcustom ido-enable-last-directory-history t
568 "*Non-nil means that `ido' will remember latest selected directory names.
569 See `ido-last-directory-list' and `ido-save-directory-list-file'."
570 :type 'boolean
571 :group 'ido)
573 (defcustom ido-max-work-directory-list 50
574 "*Maximum number of working directories to record.
575 This is the list of directories where files have most recently been opened.
576 See `ido-work-directory-list' and `ido-save-directory-list-file'."
577 :type 'integer
578 :group 'ido)
580 (defcustom ido-work-directory-list-ignore-regexps nil
581 "*List of regexps matching directories which should not be recorded.
582 Directory names matched by one of the regexps in this list are not inserted in
583 the `ido-work-directory-list' list."
584 :type '(repeat regexp)
585 :group 'ido)
588 (defcustom ido-use-filename-at-point nil
589 "*Non-nil means that ido shall look for a filename at point.
590 May use `ffap-guesser' to guess whether text at point is a filename.
591 If found, use that as the starting point for filename selection."
592 :type '(choice
593 (const :tag "Disabled" nil)
594 (const :tag "Guess filename" guess)
595 (other :tag "Use literal filename" t))
596 :group 'ido)
599 (defcustom ido-use-url-at-point nil
600 "*Non-nil means that ido shall look for a URL at point.
601 If found, call `find-file-at-point' to visit it."
602 :type 'boolean
603 :group 'ido)
606 (defcustom ido-enable-tramp-completion t
607 "*Non-nil means that ido shall perform tramp method and server name completion.
608 A tramp file name uses the following syntax: /method:user@host:filename."
609 :type 'boolean
610 :group 'ido)
612 (defcustom ido-record-ftp-work-directories t
613 "*Non-nil means record ftp file names in the work directory list."
614 :type 'boolean
615 :group 'ido)
617 (defcustom ido-merge-ftp-work-directories nil
618 "*If nil means merging ignores ftp file names in the work directory list."
619 :type 'boolean
620 :group 'ido)
622 (defcustom ido-cache-ftp-work-directory-time 1.0
623 "*Maximum time to cache contents of an ftp directory (in hours).
624 Use C-l in prompt to refresh list.
625 If zero, ftp directories are not cached."
626 :type 'number
627 :group 'ido)
629 (defcustom ido-slow-ftp-hosts nil
630 "*List of slow ftp hosts where ido prompting should not be used.
631 If an ftp host is on this list, ido automatically switches to the non-ido
632 equivalent function, e.g. `find-file' rather than `ido-find-file'."
633 :type '(repeat string)
634 :group 'ido)
636 (defcustom ido-slow-ftp-host-regexps nil
637 "*List of regexps matching slow ftp hosts (see `ido-slow-ftp-hosts')."
638 :type '(repeat regexp)
639 :group 'ido)
641 (defvar ido-unc-hosts-cache t
642 "Cached value from `ido-unc-hosts' function.")
644 (defcustom ido-unc-hosts nil
645 "*List of known UNC host names to complete after initial //.
646 If value is a function, that function is called to search network for
647 hosts on first use of UNC path."
648 :type '(choice (repeat :tag "List of UNC host names" string)
649 (function-item :tag "Use `NET VIEW'"
650 :value ido-unc-hosts-net-view)
651 (function :tag "Your own function"))
652 :set #'(lambda (symbol value)
653 (set symbol value)
654 (setq ido-unc-hosts-cache t))
655 :group 'ido)
657 (defcustom ido-downcase-unc-hosts t
658 "*Non-nil if UNC host names should be downcased."
659 :type 'boolean
660 :group 'ido)
662 (defcustom ido-ignore-unc-host-regexps nil
663 "*List of regexps matching UNC hosts to ignore.
664 Case is ignored if `ido-downcase-unc-hosts' is set."
665 :type '(repeat regexp)
666 :group 'ido)
668 (defcustom ido-cache-unc-host-shares-time 8.0
669 "*Maximum time to cache shares of an UNC host (in hours).
670 Use C-l in prompt to refresh list.
671 If zero, UNC host shares are not cached."
672 :type 'number
673 :group 'ido)
675 (defcustom ido-max-work-file-list 10
676 "*Maximum number of names of recently opened files to record.
677 This is the list the file names (sans directory) which have most recently
678 been opened. See `ido-work-file-list' and `ido-save-directory-list-file'."
679 :type 'integer
680 :group 'ido)
682 (defcustom ido-work-directory-match-only t
683 "*Non-nil means to skip non-matching directories in the directory history.
684 When some text is already entered at the `ido-find-file' prompt, using
685 \\[ido-prev-work-directory] or \\[ido-next-work-directory] will skip directories
686 without any matching entries."
687 :type 'boolean
688 :group 'ido)
690 (defcustom ido-auto-merge-work-directories-length 0
691 "*Automatically switch to merged work directories during file name input.
692 The value is number of characters to type before switching to merged mode.
693 If zero, the switch happens when no matches are found in the current directory.
694 Automatic merging is disabled if the value is negative."
695 :type 'integer
696 :group 'ido)
698 (defcustom ido-auto-merge-delay-time 0.70
699 "*Delay in seconds to wait for more input before doing auto merge."
700 :type 'number
701 :group 'ido)
703 (defcustom ido-auto-merge-inhibit-characters-regexp "[][*?~]"
704 "*Regexp matching characters which should inhibit automatic merging.
705 When a (partial) file name matches this regexp, merging is inhibited."
706 :type 'regexp
707 :group 'ido)
709 (defcustom ido-merged-indicator "^"
710 "The string appended to first choice if it has multiple directory choices."
711 :type 'string
712 :group 'ido)
714 (defcustom ido-max-dir-file-cache 100
715 "*Maximum number of working directories to be cached.
716 This is the size of the cache of `file-name-all-completions' results.
717 Each cache entry is time stamped with the modification time of the
718 directory. Some systems, like Windows, have unreliable directory
719 modification times, so you may choose to disable caching on such
720 systems, or explicitly refresh the cache contents using the command
721 `ido-reread-directory' command (C-l) in the minibuffer.
722 See also `ido-dir-file-cache' and `ido-save-directory-list-file'."
723 :type 'integer
724 :group 'ido)
726 (defcustom ido-max-directory-size 30000
727 "*Maximum size (in bytes) for directories to use ido completion.
728 If you enter a directory with a size larger than this size, ido will
729 not provide the normal completion. To show the completions, use C-a."
730 :type '(choice (const :tag "No limit" nil)
731 (integer :tag "Size in bytes" 30000))
732 :group 'ido)
734 (defcustom ido-rotate-file-list-default nil
735 "*Non-nil means that `ido' will always rotate file list to get default in front."
736 :type 'boolean
737 :group 'ido)
739 (defcustom ido-enter-matching-directory 'only
740 "*Additional methods to enter sub-directory of first/only matching item.
741 If value is 'first, enter first matching sub-directory when typing a slash.
742 If value is 'only, typing a slash only enters the sub-directory if it is
743 the only matching item.
744 If value is t, automatically enter a sub-directory when it is the only
745 matching item, even without typing a slash."
746 :type '(choice (const :tag "Never" nil)
747 (const :tag "Slash enters first directory" first)
748 (const :tag "Slash enters first and only directory" only)
749 (other :tag "Always enter unique directory" t))
750 :group 'ido)
752 (defcustom ido-create-new-buffer 'prompt
753 "*Specify whether a new buffer is created if no buffer matches substring.
754 Choices are 'always to create new buffers unconditionally, 'prompt to
755 ask user whether to create buffer, or 'never to never create new buffer."
756 :type '(choice (const always)
757 (const prompt)
758 (const never))
759 :group 'ido)
761 (defcustom ido-setup-hook nil
762 "*Hook run after the ido variables and keymap have been setup.
763 The dynamic variable `ido-cur-item' contains the current type of item that
764 is read by ido, possible values are file, dir, buffer, and list.
765 Additional keys can be defined in `ido-completion-map'."
766 :type 'hook
767 :group 'ido)
769 (defcustom ido-separator nil
770 "*String used by ido to separate the alternatives in the minibuffer.
771 Obsolete. Set 3rd element of `ido-decorations' instead."
772 :type '(choice string (const nil))
773 :group 'ido)
775 (defcustom ido-decorations '( "{" "}" " | " " | ..." "[" "]" " [No match]" " [Matched]" " [Not readable]" " [Too big]")
776 "*List of strings used by ido to display the alternatives in the minibuffer.
777 There are 10 elements in this list:
778 1st and 2nd elements are used as brackets around the prospect list,
779 3rd element is the separator between prospects (ignored if `ido-separator' is set),
780 4th element is the string inserted at the end of a truncated list of prospects,
781 5th and 6th elements are used as brackets around the common match string which
782 can be completed using TAB,
783 7th element is the string displayed when there are no matches, and
784 8th element is displayed if there is a single match (and faces are not used),
785 9th element is displayed when the current directory is non-readable,
786 10th element is displayed when directory exceeds `ido-max-directory-size'."
787 :type '(repeat string)
788 :group 'ido)
790 (defcustom ido-use-faces t
791 "*Non-nil means use ido faces to highlighting first match, only match and
792 subdirs in the alternatives."
793 :type 'boolean
794 :group 'ido)
796 (defface ido-first-match '((t (:bold t)))
797 "*Face used by ido for highlighting first match."
798 :group 'ido)
800 (defface ido-only-match '((((class color))
801 (:foreground "ForestGreen"))
802 (t (:italic t)))
803 "*Face used by ido for highlighting only match."
804 :group 'ido)
806 (defface ido-subdir '((((min-colors 88) (class color))
807 (:foreground "red1"))
808 (((class color))
809 (:foreground "red"))
810 (t (:underline t)))
811 "*Face used by ido for highlighting subdirs in the alternatives."
812 :group 'ido)
814 (defface ido-indicator '((((min-colors 88) (class color))
815 (:foreground "yellow1"
816 :background "red1"
817 :width condensed))
818 (((class color))
819 (:foreground "yellow"
820 :background "red"
821 :width condensed))
822 (t (:inverse-video t)))
823 "*Face used by ido for highlighting its indicators."
824 :group 'ido)
826 (defface ido-incomplete-regexp
827 '((t
828 (:inherit font-lock-warning-face)))
829 "Ido face for indicating incomplete regexps."
830 :group 'ido)
832 (defcustom ido-make-file-list-hook nil
833 "*List of functions to run when the list of matching files is created.
834 Each function on the list may modify the dynamically bound variable
835 `ido-temp-list' which contains the current list of matching files."
836 :type 'hook
837 :group 'ido)
839 (defcustom ido-make-dir-list-hook nil
840 "*List of functions to run when the list of matching directories is created.
841 Each function on the list may modify the dynamically bound variable
842 `ido-temp-list' which contains the current list of matching directories."
843 :type 'hook
844 :group 'ido)
846 (defcustom ido-make-buffer-list-hook nil
847 "*List of functions to run when the list of matching buffers is created.
848 Each function on the list may modify the dynamically bound variable
849 `ido-temp-list' which contains the current list of matching buffer names."
850 :type 'hook
851 :group 'ido)
853 (defcustom ido-rewrite-file-prompt-functions nil
854 "*List of functions to run when the find-file prompt is created.
855 Each function on the list may modify the following dynamically bound
856 variables:
857 dirname - the (abbreviated) directory name
858 to be modified by the hook functions
859 max-width - the max width of the resulting dirname; nil means no limit
860 prompt - the basic prompt (e.g. \"Find File: \")
861 literal - the string shown if doing \"literal\" find; set to nil to omit
862 vc-off - the string shown if version control is inhibited; set to nit to omit
863 prefix - either nil or a fixed prefix for the dirname
865 The following variables are available, but should not be changed:
866 `ido-current-directory' - the unabbreviated directory name
867 item - equals `file' or `dir' depending on the current mode."
868 :type 'hook
869 :group 'ido)
871 (defvar ido-rewrite-file-prompt-rules nil
872 "*Alist of rewriting rules for directory names in ido prompts.
873 A list of elements of the form (FROM . TO) or (FROM . FUNC), each
874 meaning to rewrite the directory name if matched by FROM by either
875 substituting the matched string by TO or calling the function FUNC
876 with the current directory name as its only argument and using the
877 return value as the new directory name. In addition, each FUNC may
878 also modify the dynamic variables described for the variable
879 `ido-rewrite-file-prompt-functions'.")
881 (defcustom ido-completion-buffer "*Ido Completions*"
882 "*Name of completion buffer used by ido.
883 Set to nil to disable completion buffers popping up."
884 :type 'string
885 :group 'ido)
887 (defcustom ido-completion-buffer-all-completions nil
888 "*Non-nil means to show all completions in completion buffer.
889 Otherwise, only the current list of matches is shown."
890 :type 'boolean
891 :group 'ido)
893 (defvar ido-all-frames 'visible
894 "*Argument to pass to `walk-windows' when finding visible files.
895 See documentation of `walk-windows' for useful values.")
897 (defcustom ido-minibuffer-setup-hook nil
898 "*Ido-specific customization of minibuffer setup.
900 This hook is run during minibuffer setup if `ido' is active.
901 It is intended for use in customizing ido for interoperation
902 with other packages. For instance:
904 \(add-hook 'ido-minibuffer-setup-hook
905 \(function
906 \(lambda ()
907 \(make-local-variable 'max-mini-window-height)
908 \(setq max-mini-window-height 3))))
910 will constrain Emacs to a maximum minibuffer height of 3 lines when
911 ido is running. Copied from `icomplete-minibuffer-setup-hook'."
912 :type 'hook
913 :group 'ido)
915 (defcustom ido-save-directory-list-file "~/.ido.last"
916 "File in which the ido state is saved between invocations.
917 Variables stored are: `ido-last-directory-list', `ido-work-directory-list',
918 `ido-work-file-list', and `ido-dir-file-cache'.
919 Must be set before enabling ido mode."
920 :type 'string
921 :group 'ido)
923 (defcustom ido-read-file-name-as-directory-commands '()
924 "List of commands which uses `read-file-name' to read a directory name.
925 When `ido-everywhere' is non-nil, the commands in this list will read
926 the directory using `ido-read-directory-name'."
927 :type '(repeat symbol)
928 :group 'ido)
930 (defcustom ido-read-file-name-non-ido '()
931 "List of commands which shall not read file names the ido way.
932 When `ido-everywhere' is non-nil, the commands in this list will read
933 the file name using normal `read-file-name' style."
934 :type '(repeat symbol)
935 :group 'ido)
937 (defcustom ido-before-fallback-functions '()
938 "List of functions to call before calling a fallback command.
939 The fallback command is passed as an argument to the functions."
940 :type 'hook
941 :group 'ido)
943 ;;; Internal Variables
945 ;; Persistent variables
947 (defvar ido-completion-map nil
948 "Currently active keymap for ido commands.")
950 (defvar ido-common-completion-map nil
951 "Keymap for all ido commands.")
953 (defvar ido-file-completion-map nil
954 "Keymap for ido file commands.")
956 (defvar ido-file-dir-completion-map nil
957 "Keymap for ido file and directory commands.")
959 (defvar ido-buffer-completion-map nil
960 "Keymap for ido buffer commands.")
962 (defvar ido-file-history nil
963 "History of files selected using `ido-find-file'.")
965 (defvar ido-buffer-history nil
966 "History of buffers selected using `ido-switch-buffer'.")
968 (defvar ido-last-directory-list nil
969 "List of last selected directory names.
970 See `ido-enable-last-directory-history' for details.")
972 (defvar ido-work-directory-list nil
973 "List of actual working directory names.
974 The current directory is inserted at the front of this list whenever a
975 file is opened with `ido-find-file' and family.")
977 (defvar ido-work-file-list nil
978 "List of actual work file names.
979 Opening a file with `ido-find-file' and similar functions
980 inserts the current file name (relative to its containing directory)
981 at the front of this list.")
983 (defvar ido-dir-file-cache nil
984 "List of `file-name-all-completions' results.
985 Each element in the list is of the form (DIR (MTIME) FILE...).")
987 (defvar ido-ignore-item-temp-list nil
988 "List of items to ignore in current ido invocation.
989 Intended to be let-bound by functions which call ido repeatedly.
990 Should never be set permanently.")
992 ;; Temporary storage
994 (defvar ido-eoinput 1
995 "Point where minibuffer input ends and completion info begins.
996 Copied from `icomplete-eoinput'.")
997 (make-variable-buffer-local 'ido-eoinput)
999 (defvar ido-common-match-string nil
1000 "Stores the string that is common to all matching files.")
1002 (defvar ido-rescan nil
1003 "Non-nil means we need to regenerate the list of matching items.")
1005 (defvar ido-rotate nil
1006 "Non-nil means we are rotating list of matches.")
1008 (defvar ido-text nil
1009 "Stores the users string as it is typed in.")
1011 (defvar ido-text-init nil
1012 "The initial string for the users string it is typed in.")
1014 (defvar ido-input-stack nil
1015 "Stores the users strings when user hits M-b/M-f.")
1017 (defvar ido-matches nil
1018 "List of files currently matching `ido-text'.")
1020 (defvar ido-report-no-match t
1021 "Report [No Match] when no completions matches `ido-text'.")
1023 (defvar ido-exit nil
1024 "Flag to monitor how `ido-find-file' exits.
1025 If equal to `takeprompt', we use the prompt as the file name to be
1026 selected.")
1028 (defvar ido-current-directory nil
1029 "Current directory for `ido-find-file'.")
1031 (defvar ido-auto-merge-timer nil
1032 "Delay timer for auto merge.")
1034 (defvar ido-use-mycompletion-depth 0
1035 "Non-nil means use `ido' completion feedback.
1036 Is set by ido functions to the current `minibuffer-depth',
1037 so that it doesn't interfere with other minibuffer usage.")
1039 (defvar ido-incomplete-regexp nil
1040 "Non-nil if an incomplete regexp is entered.")
1042 (defvar ido-initial-position nil
1043 "Non-nil means to explicitly cursor on entry to minibuffer.
1044 Value is an integer which is number of chars to right of prompt.")
1046 ;;; Variables with dynamic bindings.
1047 ;;; Declared here to keep the byte compiler quiet.
1049 ;; Stores the current ido item type ('file, 'dir, 'buffer, or 'list).
1050 (defvar ido-cur-item)
1052 ;;; Stores the current default item
1053 (defvar ido-default-item)
1055 ;; Stores the current list of items that will be searched through.
1056 ;; The list is ordered, so that the most interesting item comes first,
1057 ;; although by default, the files visible in the current frame are put
1058 ;; at the end of the list. Created by `ido-make-item-list'.
1059 (defvar ido-cur-list)
1061 ;; Stores the choice list for ido-completing-read
1062 (defvar ido-choice-list)
1064 ;; Stores the list of items which are ignored when building
1065 ;; `ido-cur-list'. It is in no specific order.
1066 (defvar ido-ignored-list)
1068 ;; Remember if current directory is non-readable (so we cannot do completion).
1069 (defvar ido-directory-nonreadable)
1071 ;; Remember if current directory is 'huge' (so we don't want to do completion).
1072 (defvar ido-directory-too-big)
1074 ;; Keep current item list if non-nil.
1075 (defvar ido-keep-item-list)
1077 ;; Process ido-ignore-* lists.
1078 (defvar ido-process-ignore-lists)
1080 ;; Don't process ido-ignore- lists once.
1081 (defvar ido-process-ignore-lists-inhibit)
1083 ;; Buffer from which ido was entered.
1084 (defvar ido-entry-buffer)
1086 ;; Non-nil if matching file must be selected.
1087 (defvar ido-require-match)
1089 ;; Stores a temporary version of the file list being created.
1090 (defvar ido-temp-list)
1092 ;; Non-nil if default list element should be rotated into place.
1093 (defvar ido-rotate-temp)
1095 ;; Stores current index in ido-work-directory-list.
1096 (defvar ido-work-directory-index)
1098 ;; Stores current index in ido-work-file-list.
1099 (defvar ido-work-file-index)
1101 ;; Set when merged work directory list is in use.
1102 (defvar ido-use-merged-list)
1104 ;; Set when merged work directory list not yet built.
1105 (defvar ido-try-merged-list)
1107 ;; Saved state prior to last work directory merge.
1108 ;; Value is a list (ido-text dir cur-list ignored-list matches).
1109 (defvar ido-pre-merge-state)
1111 ;; Original value of vc-handled-backends for use in ido-toggle-vc.
1112 (defvar ido-saved-vc-hb)
1114 ;; Stores temporary state of literal find file.
1115 (defvar ido-find-literal)
1117 ;; Set to 'ignore to inhibit switching between find-file/switch-buffer.
1118 (defvar ido-context-switch-command)
1120 ;;; FUNCTIONS
1122 (defun ido-active (&optional merge)
1123 (if merge
1124 ido-use-merged-list
1125 (and (boundp 'ido-completing-read)
1126 (or (featurep 'xemacs)
1127 (= ido-use-mycompletion-depth (minibuffer-depth))))))
1129 (defvar ido-trace-enable nil)
1131 (defun ido-trace (p &optional s retval)
1132 (if ido-trace-enable
1133 (let ((b (get-buffer-create " *IDO Trace*"))
1134 (deactivate-mark deactivate-mark))
1135 (save-excursion
1136 (save-restriction
1137 (set-buffer b)
1138 (insert p ": " (if (stringp s) s (format "%S" s)) "\n")))))
1139 retval)
1141 (defun ido-toggle-trace (arg)
1142 (interactive "P")
1143 (setq ido-trace-enable (or arg (not ido-trace-enable)))
1144 (if ido-trace-enable
1145 (message "IDO trace on"))
1146 (let ((b (get-buffer " *IDO Trace*")))
1147 (if b
1148 (if ido-trace-enable
1149 (kill-buffer b)
1150 (pop-to-buffer b t t)
1151 (setq truncate-lines t)))))
1153 (defun ido-local-file-exists-p (file)
1154 "Tell if FILE exists locally."
1155 (let (file-name-handler-alist)
1156 (file-exists-p file)))
1158 (defun ido-unc-hosts (&optional query)
1159 "Return list of UNC host names."
1160 (let ((hosts
1161 (cond
1162 ((listp ido-unc-hosts)
1163 ido-unc-hosts) ;; static list or nil
1164 ((listp ido-unc-hosts-cache)
1165 ido-unc-hosts-cache) ;; result of net search
1166 ((and query (fboundp ido-unc-hosts))
1167 (message (propertize "Searching for UNC hosts..." 'face 'highlight))
1168 (setq ido-unc-hosts-cache (funcall ido-unc-hosts))
1169 (message nil)
1170 ido-unc-hosts-cache)
1171 (query
1172 (setq ido-unc-hosts-cache nil))
1173 (t (fboundp ido-unc-hosts)))))
1174 (when query
1175 (let ((case-fold-search ido-downcase-unc-hosts)
1176 res host re-list re)
1177 (while hosts
1178 (setq host (car hosts)
1179 hosts (cdr hosts)
1180 re-list (and ido-process-ignore-lists
1181 ido-ignore-unc-host-regexps))
1182 (while re-list
1183 (setq re (car re-list)
1184 re-list (cdr re-list))
1185 (if (string-match re host)
1186 (setq re-list nil
1187 host nil)))
1188 (when host
1189 (when ido-downcase-unc-hosts
1190 (setq host (downcase host)))
1191 (setq res (cons host res))))
1192 (setq hosts (sort res #'string<))))
1193 hosts))
1195 (defun ido-unc-hosts-net-view ()
1196 "Query network for list of UNC host names using `NET VIEW'."
1197 (let (hosts)
1198 (with-temp-buffer
1199 (shell-command "net view" t)
1200 (goto-char (point-min))
1201 (while (re-search-forward "^\\\\\\\\\\([[:graph:]]+\\)" nil t)
1202 (setq hosts (cons (match-string 1) hosts))))
1203 hosts))
1205 (defun ido-is-tramp-root (&optional dir)
1206 (and ido-enable-tramp-completion
1207 (string-match "\\`/[^/]+[@:]\\'"
1208 (or dir ido-current-directory))))
1210 (defun ido-is-unc-root (&optional dir)
1211 (and (ido-unc-hosts)
1212 (string-equal "//"
1213 (or dir ido-current-directory))))
1215 (defun ido-is-unc-host (&optional dir)
1216 (and (ido-unc-hosts)
1217 (string-match "\\`//[^/]+/\\'"
1218 (or dir ido-current-directory))))
1220 (defun ido-is-root-directory (&optional dir)
1221 (setq dir (or dir ido-current-directory))
1223 (string-equal "/" dir)
1224 (and (memq system-type '(windows-nt ms-dos))
1225 (string-match "\\`[a-zA-Z]:[/\\]\\'" dir))
1226 (if ido-enable-tramp-completion
1227 (ido-is-tramp-root dir)
1228 (string-match "\\`/[^:/][^:/]+:\\'" dir))))
1230 (defun ido-is-ftp-directory (&optional dir)
1231 (string-match
1232 (if ido-enable-tramp-completion
1233 "\\`/[^/:][^/:]+:" ;; like tramp-file-name-regexp-unified, but doesn't match single drive letters
1234 "\\`/[^/:][^/:]+:/")
1235 (or dir ido-current-directory)))
1237 (defun ido-is-slow-ftp-host (&optional dir)
1238 (and (or ido-slow-ftp-hosts ido-slow-ftp-host-regexps)
1239 (setq dir (or dir ido-current-directory))
1240 ;; (featurep 'ange-ftp)
1241 ;; (ange-ftp-ftp-name dir)
1242 (string-match
1243 (if ido-enable-tramp-completion
1244 "\\`/\\([^/]+[@:]\\)*\\([^@/:][^@/:]+\\):"
1245 "\\`/\\([^/:]*@\\)?\\([^@/:][^@/:]+\\):/")
1246 dir)
1247 (let ((host (substring dir (match-beginning 2) (match-end 2))))
1248 (or (member host ido-slow-ftp-hosts)
1249 (let ((re ido-slow-ftp-host-regexps))
1250 (while (and re (not (string-match (car re) host)))
1251 (setq re (cdr re)))
1252 re)))))
1254 (defun ido-time-stamp (&optional time)
1255 ;; Time is a floating point number (fractions of 1 hour)
1256 (setq time (or time (current-time)))
1257 (/ (+ (* (car time) 65536.0) (car (cdr time))) 3600.0))
1259 (defun ido-cache-ftp-valid (&optional time)
1260 (and (numberp ido-cache-ftp-work-directory-time)
1261 (> ido-cache-ftp-work-directory-time 0)
1262 (or (not time)
1263 (< (- (ido-time-stamp) time) ido-cache-ftp-work-directory-time))))
1265 (defun ido-cache-unc-valid (&optional time)
1266 (and (numberp ido-cache-unc-host-shares-time)
1267 (> ido-cache-unc-host-shares-time 0)
1268 (or (not time)
1269 (< (- (ido-time-stamp) time) ido-cache-unc-host-shares-time))))
1271 (defun ido-may-cache-directory (&optional dir)
1272 (setq dir (or dir ido-current-directory))
1273 (cond
1274 ((ido-directory-too-big-p dir)
1275 nil)
1276 ((and (ido-is-root-directory dir)
1277 (or ido-enable-tramp-completion
1278 (memq system-type '(windows-nt ms-dos))))
1279 nil)
1280 ((ido-is-unc-host dir)
1281 (ido-cache-unc-valid))
1282 ((ido-is-ftp-directory dir)
1283 (ido-cache-ftp-valid))
1284 (t t)))
1286 (defun ido-pp (list &optional sep)
1287 (let ((print-level nil) (eval-expression-print-level nil)
1288 (print-length nil) (eval-expression-print-length nil))
1289 (insert "\n;; ----- " (symbol-name list) " -----\n(\n ")
1290 (setq list (symbol-value list))
1291 (while list
1292 (let* ((elt (car list))
1293 (s (if (consp elt) (car elt) elt)))
1294 (if (and (stringp s) (= (length s) 0))
1295 (setq s nil))
1296 (if s
1297 (prin1 elt (current-buffer)))
1298 (if (and (setq list (cdr list)) s)
1299 (insert (or sep "\n ")))))
1300 (insert "\n)\n")))
1302 (defun ido-save-history ()
1303 "Save ido history and cache information between sessions."
1304 (interactive)
1305 (when (and ido-last-directory-list ido-save-directory-list-file)
1306 (let ((buf (get-buffer-create " *ido session*"))
1307 (version-control 'never))
1308 (unwind-protect
1309 (with-current-buffer buf
1310 (erase-buffer)
1311 (insert ";;; -*- coding: utf-8 -*-\n")
1312 (setq buffer-file-coding-system 'utf-8)
1313 (ido-pp 'ido-last-directory-list)
1314 (ido-pp 'ido-work-directory-list)
1315 (ido-pp 'ido-work-file-list)
1316 (ido-pp 'ido-dir-file-cache "\n\n ")
1317 (if (listp ido-unc-hosts-cache)
1318 (ido-pp 'ido-unc-hosts-cache)
1319 (insert "\n;; ----- ido-unc-hosts-cache -----\nt\n"))
1320 (insert "\n")
1321 (write-file ido-save-directory-list-file nil))
1322 (kill-buffer buf)))))
1324 (defun ido-load-history (&optional arg)
1325 "Load ido history and cache information from previous session.
1326 With prefix argument, reload history unconditionally."
1327 (interactive "P")
1328 (if (or arg (and ido-save-directory-list-file (not ido-last-directory-list)))
1329 (let ((file (expand-file-name ido-save-directory-list-file))
1330 buf)
1331 (when (file-readable-p file)
1332 (setq buf (get-buffer-create " *ido session*"))
1333 (unwind-protect
1334 (with-current-buffer buf
1335 (erase-buffer)
1336 (insert-file-contents file)
1337 (condition-case nil
1338 (setq ido-last-directory-list (read (current-buffer))
1339 ido-work-directory-list (read (current-buffer))
1340 ido-work-file-list (read (current-buffer))
1341 ido-dir-file-cache (read (current-buffer))
1342 ido-unc-hosts-cache (read (current-buffer)))
1343 (error nil)))
1344 (kill-buffer buf)))))
1345 (ido-wash-history))
1347 (defun ido-wash-history ()
1348 "Clean-up ido history and cache information.
1349 Removes badly formatted data and ignored directories."
1350 (interactive)
1351 ;; Check format of each of our lists, discard bogus elements
1352 (setq ido-last-directory-list
1353 (and (listp ido-last-directory-list)
1354 (let ((l ido-last-directory-list) r)
1355 (while l
1356 (if (and (consp (car l))
1357 (stringp (car (car l)))
1358 (stringp (cdr (car l))))
1359 (setq r (cons (car l) r)))
1360 (setq l (cdr l)))
1361 (nreverse r))))
1362 (setq ido-work-directory-list
1363 (and (listp ido-work-directory-list)
1364 (let ((l ido-work-directory-list) r)
1365 (while l
1366 (if (and (stringp (car l))
1367 (or ido-record-ftp-work-directories
1368 (not (ido-is-ftp-directory (car l)))))
1369 (setq r (cons (car l) r)))
1370 (setq l (cdr l)))
1371 (nreverse r))))
1372 (setq ido-work-file-list
1373 (and (listp ido-work-file-list)
1374 (let ((l ido-work-file-list) r)
1375 (while l
1376 (if (stringp (car l))
1377 (setq r (cons (car l) r)))
1378 (setq l (cdr l)))
1379 (nreverse r))))
1380 (setq ido-dir-file-cache
1381 (and (listp ido-dir-file-cache)
1382 (let ((l ido-dir-file-cache) r)
1383 (while l
1384 (if (and (listp (car l))
1385 (> (length (car l)) 2)
1386 (let ((dir (car (car l)))
1387 (time (car (cdr (car l))))
1388 (files (cdr (cdr (car l)))))
1389 (and
1390 (stringp dir)
1391 (consp time)
1392 (cond
1393 ((integerp (car time))
1394 (and (/= (car time) 0)
1395 (integerp (car (cdr time)))
1396 (/= (car (cdr time)) 0)
1397 (ido-may-cache-directory dir)))
1398 ((eq (car time) 'ftp)
1399 (and (numberp (cdr time))
1400 (ido-is-ftp-directory dir)
1401 (ido-cache-ftp-valid (cdr time))))
1402 ((eq (car time) 'unc)
1403 (and (numberp (cdr time))
1404 (ido-is-unc-host dir)
1405 (ido-cache-unc-valid (cdr time))))
1406 (t nil))
1407 (let ((s files) (ok t))
1408 (while s
1409 (if (stringp (car s))
1410 (setq s (cdr s))
1411 (setq s nil ok nil)))
1412 ok))))
1413 (setq r (cons (car l) r)))
1414 (setq l (cdr l)))
1415 (nreverse r))))
1417 ;; Remove ignored directories from work directory list
1418 ;; according to ido-work-directory-list-ignore-regexps
1419 (if ido-work-directory-list
1420 (let ((dirs (reverse ido-work-directory-list)))
1421 (setq ido-work-directory-list nil)
1422 (while dirs
1423 (ido-record-work-directory (car dirs))
1424 (setq dirs (cdr dirs)))))
1425 ;; Get rid of text properties
1426 (let ((l ido-last-directory-list) e)
1427 (while l
1428 (setq e (car l) l (cdr l))
1429 (set-text-properties 0 (length (car e)) nil (car e))
1430 (set-text-properties 0 (length (cdr e)) nil (cdr e))))
1431 (let ((l ido-work-directory-list) e)
1432 (while l
1433 (setq e (car l) l (cdr l))
1434 (set-text-properties 0 (length e) nil e)))
1435 (let ((l ido-work-file-list) e)
1436 (while l
1437 (setq e (car l) l (cdr l))
1438 (set-text-properties 0 (length e) nil e)))
1439 (let ((l ido-dir-file-cache) e d)
1440 (while l
1441 (setq e (car l) l (cdr l))
1442 (if (listp e)
1443 (while e
1444 (setq d (car e) e (cdr e))
1445 (if (not (consp d))
1446 (set-text-properties 0 (length d) nil d)))))))
1449 (defun ido-kill-emacs-hook ()
1450 ;; ido kill emacs hook
1451 (ido-save-history))
1453 (defvar ido-minor-mode-map-entry nil)
1455 ;;;###autoload
1456 (defun ido-mode (&optional arg)
1457 "Toggle ido speed-ups on or off.
1458 With ARG, turn ido speed-up on if arg is positive, off otherwise.
1459 Turning on ido-mode will remap (via a minor-mode keymap) the default
1460 keybindings for the `find-file' and `switch-to-buffer' families of
1461 commands to the ido versions of these functions.
1462 However, if ARG arg equals 'files, remap only commands for files, or
1463 if it equals 'buffers, remap only commands for buffer switching.
1464 This function also adds a hook to the minibuffer."
1465 (interactive "P")
1466 (setq ido-mode
1467 (cond
1468 ((null arg) (if ido-mode nil 'both))
1469 ((eq arg t) 'both)
1470 ((eq arg 'files) 'file)
1471 ((eq arg 'buffers) 'buffer)
1472 ((memq arg '(file buffer both)) arg)
1473 ((> (prefix-numeric-value arg) 0) 'both)
1474 (t nil)))
1476 (ido-everywhere (if ido-everywhere 1 -1))
1477 (when ido-mode
1478 (ido-init-completion-maps))
1480 (when ido-mode
1481 (add-hook 'minibuffer-setup-hook 'ido-minibuffer-setup)
1482 (add-hook 'choose-completion-string-functions 'ido-choose-completion-string)
1483 (ido-load-history)
1485 (add-hook 'kill-emacs-hook 'ido-kill-emacs-hook)
1487 (let ((map (make-sparse-keymap)))
1488 (when (memq ido-mode '(file both))
1489 (define-key map [remap find-file] 'ido-find-file)
1490 (define-key map [remap find-file-read-only] 'ido-find-file-read-only)
1491 (define-key map [remap find-alternate-file] 'ido-find-alternate-file)
1492 (define-key map [remap write-file] 'ido-write-file)
1493 (define-key map [remap insert-file] 'ido-insert-file)
1494 (define-key map [remap list-directory] 'ido-list-directory)
1495 (define-key map [remap dired] 'ido-dired)
1496 (define-key map [remap find-file-other-window] 'ido-find-file-other-window)
1497 (define-key map [remap find-file-read-only-other-window] 'ido-find-file-read-only-other-window)
1498 (define-key map [remap find-file-other-frame] 'ido-find-file-other-frame)
1499 (define-key map [remap find-file-read-only-other-frame] 'ido-find-file-read-only-other-frame))
1501 (when (memq ido-mode '(buffer both))
1502 (define-key map [remap switch-to-buffer] 'ido-switch-buffer)
1503 (define-key map [remap switch-to-buffer-other-window] 'ido-switch-buffer-other-window)
1504 (define-key map [remap switch-to-buffer-other-frame] 'ido-switch-buffer-other-frame)
1505 (define-key map [remap insert-buffer] 'ido-insert-buffer)
1506 (define-key map [remap kill-buffer] 'ido-kill-buffer)
1507 (define-key map [remap display-buffer] 'ido-display-buffer))
1509 (if ido-minor-mode-map-entry
1510 (setcdr ido-minor-mode-map-entry map)
1511 (setq ido-minor-mode-map-entry (cons 'ido-mode map))
1512 (add-to-list 'minor-mode-map-alist ido-minor-mode-map-entry)))))
1515 (defun ido-everywhere (arg)
1516 "Toggle using ido speed-ups everywhere file and directory names are read.
1517 With ARG, turn ido speed-up on if arg is positive, off otherwise."
1518 (interactive "P")
1519 (setq ido-everywhere (if arg
1520 (> (prefix-numeric-value arg) 0)
1521 (not ido-everywhere)))
1522 (when (get 'ido-everywhere 'file)
1523 (setq read-file-name-function (car (get 'ido-everywhere 'file)))
1524 (put 'ido-everywhere 'file nil))
1525 (when (get 'ido-everywhere 'buffer)
1526 (setq read-buffer-function (car (get 'ido-everywhere 'buffer)))
1527 (put 'ido-everywhere 'buffer nil))
1528 (when ido-everywhere
1529 (when (memq ido-mode '(both file))
1530 (put 'ido-everywhere 'file (cons read-file-name-function nil))
1531 (setq read-file-name-function 'ido-read-file-name))
1532 (when (memq ido-mode '(both buffer))
1533 (put 'ido-everywhere 'buffer (cons read-buffer-function nil))
1534 (setq read-buffer-function 'ido-read-buffer))))
1537 ;;; IDO KEYMAP
1538 (defun ido-init-completion-maps ()
1539 "Set up the completion keymaps used by `ido'."
1541 ;; Common map
1542 (let ((map (make-sparse-keymap)))
1543 (define-key map "\C-a" 'ido-toggle-ignore)
1544 (define-key map "\C-c" 'ido-toggle-case)
1545 (define-key map "\C-e" 'ido-edit-input)
1546 (define-key map "\t" 'ido-complete)
1547 (define-key map " " 'ido-complete-space)
1548 (define-key map "\C-j" 'ido-select-text)
1549 (define-key map "\C-m" 'ido-exit-minibuffer)
1550 (define-key map "\C-p" 'ido-toggle-prefix)
1551 (define-key map "\C-r" 'ido-prev-match)
1552 (define-key map "\C-s" 'ido-next-match)
1553 (define-key map "\C-t" 'ido-toggle-regexp)
1554 (define-key map "\C-z" 'ido-undo-merge-work-directory)
1555 (define-key map [(control ?\s)] 'ido-restrict-to-matches)
1556 (define-key map [(meta ?\s)] 'ido-take-first-match)
1557 (define-key map [(control ?@)] 'ido-restrict-to-matches)
1558 (define-key map [right] 'ido-next-match)
1559 (define-key map [left] 'ido-prev-match)
1560 (define-key map "?" 'ido-completion-help)
1561 ;; Magic commands.
1562 (define-key map "\C-b" 'ido-magic-backward-char)
1563 (define-key map "\C-f" 'ido-magic-forward-char)
1564 (define-key map "\C-d" 'ido-magic-delete-char)
1565 (set-keymap-parent map minibuffer-local-map)
1566 (setq ido-common-completion-map map))
1568 ;; File and directory map
1569 (let ((map (make-sparse-keymap)))
1570 (define-key map "\C-x\C-b" 'ido-enter-switch-buffer)
1571 (define-key map "\C-x\C-f" 'ido-fallback-command)
1572 (define-key map "\C-x\C-d" 'ido-enter-dired)
1573 (define-key map [down] 'ido-next-match-dir)
1574 (define-key map [up] 'ido-prev-match-dir)
1575 (define-key map [(meta up)] 'ido-prev-work-directory)
1576 (define-key map [(meta down)] 'ido-next-work-directory)
1577 (define-key map [backspace] 'ido-delete-backward-updir)
1578 (define-key map "\d" 'ido-delete-backward-updir)
1579 (define-key map [remap delete-backward-char] 'ido-delete-backward-updir) ; BS
1580 (define-key map [remap backward-kill-word] 'ido-delete-backward-word-updir) ; M-DEL
1582 (define-key map [(control backspace)] 'ido-up-directory)
1583 (define-key map "\C-l" 'ido-reread-directory)
1584 (define-key map [(meta ?d)] 'ido-wide-find-dir-or-delete-dir)
1585 (define-key map [(meta ?b)] 'ido-push-dir)
1586 (define-key map [(meta ?v)] 'ido-push-dir-first)
1587 (define-key map [(meta ?f)] 'ido-wide-find-file-or-pop-dir)
1588 (define-key map [(meta ?k)] 'ido-forget-work-directory)
1589 (define-key map [(meta ?m)] 'ido-make-directory)
1590 (define-key map [(meta ?n)] 'ido-next-work-directory)
1591 (define-key map [(meta ?o)] 'ido-prev-work-file)
1592 (define-key map [(meta control ?o)] 'ido-next-work-file)
1593 (define-key map [(meta ?p)] 'ido-prev-work-directory)
1594 (define-key map [(meta ?s)] 'ido-merge-work-directories)
1595 (set-keymap-parent map ido-common-completion-map)
1596 (setq ido-file-dir-completion-map map))
1598 ;; File only map
1599 (let ((map (make-sparse-keymap)))
1600 (define-key map "\C-k" 'ido-delete-file-at-head)
1601 (define-key map "\C-o" 'ido-copy-current-word)
1602 (define-key map "\C-w" 'ido-copy-current-file-name)
1603 (define-key map [(meta ?l)] 'ido-toggle-literal)
1604 (define-key map "\C-v" 'ido-toggle-vc)
1605 (set-keymap-parent map ido-file-dir-completion-map)
1606 (setq ido-file-completion-map map))
1608 ;; Buffer map
1609 (let ((map (make-sparse-keymap)))
1610 (define-key map "\C-x\C-f" 'ido-enter-find-file)
1611 (define-key map "\C-x\C-b" 'ido-fallback-command)
1612 (define-key map "\C-k" 'ido-kill-buffer-at-head)
1613 (set-keymap-parent map ido-common-completion-map)
1614 (setq ido-buffer-completion-map map)))
1617 (defun ido-setup-completion-map ()
1618 "Set up the keymap for `ido'."
1620 ;; generated every time so that it can inherit new functions.
1621 (let ((map (make-sparse-keymap))
1622 (viper-p (if (boundp 'viper-mode) viper-mode)))
1624 (when viper-p
1625 (define-key map [remap viper-intercept-ESC-key] 'ignore))
1627 (cond
1628 ((memq ido-cur-item '(file dir))
1629 (when ido-context-switch-command
1630 (define-key map "\C-x\C-b" ido-context-switch-command)
1631 (define-key map "\C-x\C-d" 'ignore))
1632 (when viper-p
1633 (define-key map [remap viper-backward-char] 'ido-delete-backward-updir)
1634 (define-key map [remap viper-del-backward-char-in-insert] 'ido-delete-backward-updir)
1635 (define-key map [remap viper-delete-backward-word] 'ido-delete-backward-word-updir))
1636 (set-keymap-parent map
1637 (if (eq ido-cur-item 'file)
1638 ido-file-completion-map
1639 ido-file-dir-completion-map)))
1641 ((eq ido-cur-item 'buffer)
1642 (when ido-context-switch-command
1643 (define-key map "\C-x\C-f" ido-context-switch-command))
1644 (set-keymap-parent map ido-buffer-completion-map))
1647 (set-keymap-parent map ido-common-completion-map)))
1649 (setq ido-completion-map map)))
1651 (defun ido-final-slash (dir &optional fix-it)
1652 ;; return DIR if DIR has final slash.
1653 ;; else if FIX-IT is non-nil, return DIR/
1654 ;; else return nil.
1655 (setq dir (ido-name dir))
1656 (cond
1657 ((string-match "/\\'" dir) dir)
1658 ((ido-is-tramp-root dir) dir)
1659 (fix-it (concat dir "/"))
1660 (t nil)))
1662 (defun ido-no-final-slash (s)
1663 ;; Remove optional final slash from string S
1664 (let ((l (1- (length s))))
1665 (if (and (> l 0) (eq (aref s l) ?/))
1666 (substring s 0 l)
1667 s)))
1669 (defun ido-nonreadable-directory-p (dir)
1670 ;; Return t if dir is a directory, but not readable
1671 ;; Do not check for non-readable directories via tramp, as this causes a premature
1672 ;; connect on incomplete tramp paths (after entring just method:).
1673 (let ((ido-enable-tramp-completion nil))
1674 (and (ido-final-slash dir)
1675 (not (ido-is-unc-host dir))
1676 (file-directory-p dir)
1677 (not (file-readable-p dir)))))
1679 (defun ido-directory-too-big-p (dir)
1680 ;; Return t if dir is a directory, but too big to show
1681 ;; Do not check for non-readable directories via tramp, as this causes a premature
1682 ;; connect on incomplete tramp paths (after entring just method:).
1683 (let ((ido-enable-tramp-completion nil))
1684 (and (numberp ido-max-directory-size)
1685 (ido-final-slash dir)
1686 (not (ido-is-unc-host dir))
1687 (file-directory-p dir)
1688 (> (nth 7 (file-attributes dir)) ido-max-directory-size))))
1690 (defun ido-set-current-directory (dir &optional subdir no-merge)
1691 ;; Set ido's current directory to DIR or DIR/SUBDIR
1692 (unless (and ido-enable-tramp-completion
1693 (string-match "\\`/[^/]*@\\'" dir))
1694 (setq dir (ido-final-slash dir t)))
1695 (setq ido-use-merged-list nil
1696 ido-try-merged-list (not no-merge))
1697 (when subdir
1698 (setq dir (concat dir subdir))
1699 (unless (and ido-enable-tramp-completion
1700 (string-match "\\`/[^/]*@\\'" dir))
1701 (setq dir (ido-final-slash dir t))))
1702 (if (get-buffer ido-completion-buffer)
1703 (kill-buffer ido-completion-buffer))
1704 (cond
1705 ((equal dir ido-current-directory)
1706 nil)
1707 ((ido-is-unc-root dir)
1708 (ido-trace "unc" dir)
1709 (setq ido-current-directory dir)
1710 (setq ido-directory-nonreadable nil)
1711 (setq ido-directory-too-big nil)
1714 (ido-trace "cd" dir)
1715 (setq ido-current-directory dir)
1716 (if (get-buffer ido-completion-buffer)
1717 (kill-buffer ido-completion-buffer))
1718 (setq ido-directory-nonreadable (ido-nonreadable-directory-p dir))
1719 (setq ido-directory-too-big (and (not ido-directory-nonreadable)
1720 (ido-directory-too-big-p dir)))
1721 t)))
1723 (defun ido-set-current-home (&optional dir)
1724 ;; Set ido's current directory to user's home directory
1725 (ido-set-current-directory (expand-file-name (or dir "~/"))))
1727 (defun ido-record-command (command arg)
1728 ;; Add (command arg) to command-history if ido-record-commands is t
1729 (if ido-record-commands
1730 (let ((cmd (list command arg)))
1731 (if (or (not command-history)
1732 (not (equal cmd (car command-history))))
1733 (setq command-history (cons cmd command-history))))))
1735 (defun ido-make-prompt (item prompt)
1736 ;; Make the prompt for ido-read-internal
1737 (cond
1738 ((and (memq item '(file dir)) ido-current-directory)
1739 (let ((dirname (abbreviate-file-name ido-current-directory))
1740 (max-width (if (and ido-max-file-prompt-width (floatp ido-max-file-prompt-width))
1741 (floor (* (frame-width) ido-max-file-prompt-width))
1742 ido-max-file-prompt-width))
1743 (literal (and (boundp 'ido-find-literal) ido-find-literal "(literal) "))
1744 (vc-off (and ido-saved-vc-hb (not vc-handled-backends) "[-VC] "))
1745 (prefix nil)
1746 (rule ido-rewrite-file-prompt-rules))
1747 (let ((case-fold-search nil))
1748 (while rule
1749 (if (and (consp (car rule))
1750 (string-match (car (car rule)) dirname))
1751 (setq dirname
1752 (if (stringp (cdr (car rule)))
1753 (replace-match (cdr (car rule)) t nil dirname)
1754 (funcall (cdr (car rule)) dirname))))
1755 (setq rule (cdr rule))))
1756 (run-hooks 'ido-rewrite-file-prompt-functions)
1757 (concat prompt
1758 ; (if ido-process-ignore-lists "" "&")
1759 (or literal "")
1760 (or vc-off "")
1761 (or prefix "")
1762 (let ((l (length dirname)))
1763 (if (and max-width (> max-width 0) (> l max-width))
1764 (let* ((s (substring dirname (- max-width)))
1765 (i (string-match "/" s)))
1766 (concat "..." (if i (substring s i) s)))
1767 dirname)))))
1768 (t prompt)))
1770 ;; Here is very briefly how ido-find-file works:
1772 ;; (ido-find-file)
1773 ;; (ido-file-internal method)
1774 ;; set ido-current-directory
1775 ;; (ido-read-internal 'file ...)
1776 ;; (while ...
1777 ;; (ido-make-item-list ...)
1778 ;; (ido-set-matches)
1779 ;; (completing-read ... ido-text-init ...)
1781 ;; ... here user is allowed to type characters and commands
1782 ;; a command may set ido-exit and call (exit-minibuffer)
1783 ;; to make ido-read-internal do advanced tasks (or return)
1785 ;; ... ido-tidy and ido-exhibit are pre- and post-hooks
1786 ;; which are run before and after each user command.
1788 ;; return value from completing-read is stored in ido-final-text
1789 ;; - ido-exit may cause further actions to be taken:
1790 ;; 'refresh - repeat loop (make-item-list, set-matches)
1791 ;; 'edit - edit the prompt string, then repeat loop
1792 ;; 'keep - repeat loop but don't (re)make-item-list
1793 ;; 'updir - go up one directory, repeat loop
1794 ;; else set ido-selected based on ido-final-text,
1795 ;; optionally update ido-current-directory and repeat loop, or
1796 ;; exit with the return value of ido-selected (file name)
1797 ;; selected file name is returned from ido-read-internal,
1798 ;; ido-exit and method determines what action is taken
1799 ;; e.g. the file name may be ignored or joined with ido-current-directory, and
1800 ;; the relevant function is called (find-file, write-file, etc).
1802 (defun ido-read-internal (item prompt history &optional default require-match initial)
1803 "Perform the `ido-read-buffer' and `ido-read-file-name' functions.
1804 Return the name of a buffer or file selected.
1805 PROMPT is the prompt to give to the user.
1806 DEFAULT if given is the default item to start with.
1807 If REQUIRE-MATCH is non-nil, an existing file must be selected.
1808 If INITIAL is non-nil, it specifies the initial input string."
1809 (let
1810 ((ido-cur-item item)
1811 (ido-entry-buffer (current-buffer))
1812 (ido-process-ignore-lists t)
1813 (ido-process-ignore-lists-inhibit nil)
1814 (ido-set-default-item t)
1815 ido-default-item
1816 ido-selected
1817 ido-final-text
1818 (done nil)
1819 (icomplete-mode nil) ;; prevent icomplete starting up
1820 ;; Exported dynamic variables:
1821 ido-cur-list
1822 ido-ignored-list
1823 (ido-rotate-temp nil)
1824 (ido-keep-item-list nil)
1825 (ido-use-merged-list nil)
1826 (ido-try-merged-list t)
1827 (ido-pre-merge-state nil)
1828 (ido-case-fold ido-case-fold)
1829 (ido-enable-prefix ido-enable-prefix)
1830 (ido-enable-regexp ido-enable-regexp)
1833 (ido-setup-completion-map)
1834 (setq ido-text-init initial)
1835 (setq ido-input-stack nil)
1837 (run-hooks 'ido-setup-hook)
1839 (while (not done)
1840 (ido-trace "\n_LOOP_" ido-text-init)
1841 (setq ido-exit nil)
1842 (setq ido-rescan t)
1843 (setq ido-rotate nil)
1844 (setq ido-text "")
1845 (when ido-set-default-item
1846 (setq ido-default-item
1847 (cond
1848 ((eq item 'buffer)
1849 (if (bufferp default) (buffer-name default) default))
1850 ((stringp default)
1851 (if (memq item '(file dir))
1852 (file-name-nondirectory default)
1853 default))
1854 ((eq item 'file)
1855 (and ido-enable-last-directory-history
1856 (let ((d (assoc ido-current-directory ido-last-directory-list)))
1857 (and d (cdr d)))))))
1858 (if (member ido-default-item ido-ignore-item-temp-list)
1859 (setq ido-default-item nil))
1860 (ido-trace "new default" ido-default-item)
1861 (if ido-default-item
1862 (setq ido-initial-position 0))
1863 (setq ido-set-default-item nil))
1865 (if ido-process-ignore-lists-inhibit
1866 (setq ido-process-ignore-lists nil))
1868 (if (and ido-use-merged-list (memq ido-try-merged-list '(t wide)) (not ido-keep-item-list))
1869 (let ((olist ido-cur-list)
1870 (oign ido-ignored-list)
1871 (omat ido-matches)
1872 (l (ido-make-merged-file-list ido-text-init
1873 (eq ido-use-merged-list 'auto)
1874 (eq ido-try-merged-list 'wide))))
1875 (ido-trace "merged" l)
1876 (cond
1877 ((not l)
1878 (if (eq ido-try-merged-list 'wide)
1879 (setq ido-pre-merge-state
1880 (list "" ido-current-directory olist oign omat)
1881 ido-cur-list nil
1882 ido-ignored-list nil
1883 ido-matches nil
1884 ido-keep-item-list t
1885 ido-try-merged-list (if (eq ido-use-merged-list 'auto) 'auto nil)
1886 ido-use-merged-list nil)
1887 (setq ido-cur-list olist
1888 ido-ignored-list oign
1889 ido-matches omat
1890 ido-keep-item-list t
1891 ido-try-merged-list (if (eq ido-use-merged-list 'auto) 'auto nil)
1892 ido-use-merged-list nil)))
1893 ((eq l t)
1894 (setq ido-use-merged-list nil))
1895 ((eq l 'input-pending-p)
1896 (setq ido-try-merged-list t
1897 ido-use-merged-list nil))
1899 (setq ido-pre-merge-state
1900 (list ido-text-init ido-current-directory olist oign omat))
1901 (ido-set-current-directory (car (cdr (car l))))
1902 (if (ido-final-slash ido-text-init)
1903 (setq ido-text-init ""))
1904 (setq ido-cur-list l
1905 ido-ignored-list nil
1906 ido-matches l
1907 ido-rescan nil
1908 ido-keep-item-list t
1909 ido-use-merged-list t)
1910 (ido-trace "Merged" t)
1911 ))))
1913 (cond
1914 (ido-keep-item-list
1915 (setq ido-keep-item-list nil
1916 ido-rescan nil))
1917 ((eq ido-cur-item 'file)
1918 (setq ido-ignored-list nil
1919 ido-cur-list (and (not ido-directory-nonreadable)
1920 (not ido-directory-too-big)
1921 (ido-make-file-list ido-default-item))))
1922 ((eq ido-cur-item 'dir)
1923 (setq ido-ignored-list nil
1924 ido-cur-list (and (not ido-directory-nonreadable)
1925 (not ido-directory-too-big)
1926 (ido-make-dir-list ido-default-item))))
1927 ((eq ido-cur-item 'buffer)
1928 (setq ido-ignored-list nil
1929 ido-cur-list (ido-make-buffer-list ido-default-item)))
1930 ((eq ido-cur-item 'list)
1931 (setq ido-ignored-list nil
1932 ido-cur-list (ido-make-choice-list ido-default-item)))
1933 (t nil))
1934 (setq ido-rotate-temp nil)
1936 (if ido-process-ignore-lists-inhibit
1937 (setq ido-process-ignore-lists t
1938 ido-process-ignore-lists-inhibit nil))
1940 (ido-set-matches)
1941 (if (and ido-matches (eq ido-try-merged-list 'auto))
1942 (setq ido-try-merged-list t))
1943 (let
1944 ((minibuffer-local-completion-map
1945 (if (memq ido-cur-item '(file dir))
1946 minibuffer-local-completion-map
1947 ido-completion-map))
1948 (minibuffer-local-filename-completion-map
1949 (if (memq ido-cur-item '(file dir))
1950 ido-completion-map
1951 minibuffer-local-filename-completion-map))
1952 (max-mini-window-height (or ido-max-window-height
1953 (and (boundp 'max-mini-window-height) max-mini-window-height)))
1954 (ido-completing-read t)
1955 (ido-require-match require-match)
1956 (ido-use-mycompletion-depth (1+ (minibuffer-depth)))
1957 (show-paren-mode nil))
1958 ;; prompt the user for the file name
1959 (setq ido-exit nil)
1960 (setq ido-final-text
1961 (catch 'ido
1962 (completing-read
1963 (ido-make-prompt item prompt)
1964 '(("dummy" . 1)) nil nil ; table predicate require-match
1965 (prog1 ido-text-init (setq ido-text-init nil)) ;initial-contents
1966 history))))
1967 (ido-trace "completing-read" ido-final-text)
1968 (if (get-buffer ido-completion-buffer)
1969 (kill-buffer ido-completion-buffer))
1971 (ido-trace "\n_EXIT_" ido-exit)
1973 (cond
1974 ((eq ido-exit 'refresh)
1975 (if (and (eq ido-use-merged-list 'auto)
1976 (or (input-pending-p)))
1977 (setq ido-use-merged-list nil
1978 ido-keep-item-list t))
1979 nil)
1981 ((eq ido-exit 'done)
1982 (setq done t
1983 ido-selected ido-text
1984 ido-exit nil))
1986 ((memq ido-exit '(edit chdir))
1987 (cond
1988 ((memq ido-cur-item '(file dir))
1989 (let* ((read-file-name-function nil)
1990 (edit (eq ido-exit 'edit))
1991 (d ido-current-directory)
1992 (f ido-text-init)
1993 (new t))
1994 (setq ido-text-init "")
1995 (while new
1996 (setq new (if edit
1997 (condition-case nil
1998 (read-file-name (concat prompt "[EDIT] ")
1999 (expand-file-name d)
2000 (concat d f) nil f)
2001 (quit (concat d f)))
2003 d (or (file-name-directory new) "/")
2004 f (file-name-nondirectory new)
2005 edit t)
2006 (if (or
2007 (file-directory-p d)
2008 (and (yes-or-no-p (format "Create directory %s? " d))
2009 (condition-case nil
2010 (progn (make-directory d t) t)
2011 (error
2012 (message "Could not create directory")
2013 (sit-for 1)
2014 nil))))
2015 (progn
2016 (ido-set-current-directory d nil (eq ido-exit 'chdir))
2017 (setq ido-text-init f
2018 new nil))))))
2020 (setq ido-text-init
2021 (condition-case nil
2022 (read-string (concat prompt "[EDIT] ") ido-final-text)
2023 (quit ido-final-text)))))
2025 nil)
2027 ((eq ido-exit 'keep)
2028 (setq ido-keep-item-list t))
2030 ((memq ido-exit '(dired fallback find-file switch-to-buffer insert-buffer insert-file))
2031 (setq done t))
2033 ((memq ido-exit '(updir push))
2034 ;; cannot go up if already at the root-dir (Unix) or at the
2035 ;; root-dir of a certain drive (Windows or MS-DOS).
2036 (if (ido-is-tramp-root)
2037 (when (string-match "\\`\\(/\\([^/]+[:@]\\)*\\)\\([^/]+\\)[:@]\\'" ido-current-directory)
2038 (setq ido-text-init (match-string 3 ido-current-directory))
2039 (ido-set-current-directory (match-string 1 ido-current-directory))
2040 (setq ido-set-default-item t))
2041 (unless (ido-is-root-directory)
2042 (when (eq ido-exit 'push)
2043 (setq ido-input-stack (cons (cons ido-cur-item ido-text) ido-input-stack))
2044 (setq ido-cur-item 'dir)
2045 (setq ido-text-init (file-name-nondirectory (substring ido-current-directory 0 -1)))
2046 (ido-trace "push" ido-input-stack))
2047 (ido-set-current-directory (file-name-directory (substring ido-current-directory 0 -1)))
2048 (setq ido-set-default-item t))))
2050 ((eq ido-exit 'pop)
2051 (ido-trace "pop" ido-input-stack)
2052 (let ((elt (car ido-input-stack)))
2053 (setq ido-input-stack (cdr ido-input-stack))
2054 (ido-set-current-directory (concat ido-current-directory ido-text))
2055 (setq ido-cur-item (car elt))
2056 (setq ido-text-init (cdr elt))))
2058 ((eq ido-exit 'pop-all)
2059 (ido-trace "pop-all" ido-input-stack)
2060 (while ido-input-stack
2061 (let ((elt (car ido-input-stack)))
2062 (setq ido-input-stack (cdr ido-input-stack))
2063 (ido-set-current-directory (concat ido-current-directory ido-text))
2064 (setq ido-cur-item (car elt))
2065 (setq ido-text-init (cdr elt)))))
2067 ;; Handling the require-match must be done in a better way.
2068 ((and require-match
2069 (not (if ido-directory-too-big
2070 (file-exists-p (concat ido-current-directory ido-final-text))
2071 (ido-existing-item-p))))
2072 (error "Must specify valid item"))
2075 (setq ido-selected
2076 (if (or (eq ido-exit 'takeprompt)
2077 (null ido-matches))
2078 ido-final-text
2079 ;; else take head of list
2080 (ido-name (car ido-matches))))
2082 (cond
2083 ((memq item '(buffer list))
2084 (setq done t))
2086 ((string-equal "./" ido-selected)
2087 nil)
2089 ((string-equal "../" ido-selected)
2090 ;; cannot go up if already at the root-dir (Unix) or at the
2091 ;; root-dir of a certain drive (Windows or MS-DOS).
2092 (or (ido-is-root-directory)
2093 (ido-set-current-directory (file-name-directory (substring ido-current-directory 0 -1))))
2094 (setq ido-set-default-item t))
2096 ((and (string-match (if ido-enable-tramp-completion ".[:@]\\'" ".:\\'") ido-selected)
2097 (ido-is-root-directory) ;; Ange-ftp or Tramp
2098 (not (ido-local-file-exists-p ido-selected)))
2099 (ido-set-current-directory ido-current-directory ido-selected)
2100 (ido-trace "tramp prefix" ido-selected)
2101 (if (ido-is-slow-ftp-host)
2102 (setq ido-exit 'fallback
2103 done t)
2104 (setq ido-set-default-item t)))
2106 ((or (string-match "[/\\][^/\\]" ido-selected)
2107 (and (memq system-type '(windows-nt ms-dos))
2108 (string-match "\\`[a-zA-Z]:" ido-selected)))
2109 (ido-set-current-directory (file-name-directory ido-selected))
2110 (setq ido-set-default-item t))
2112 ((string-match "\\`~" ido-selected)
2113 (ido-set-current-home ido-selected))
2115 ((ido-final-slash ido-selected)
2116 (if ido-enable-last-directory-history
2117 (let ((x (assoc ido-current-directory ido-last-directory-list)))
2118 (if x
2119 (setcdr x ido-selected)
2120 (setq ido-last-directory-list
2121 (cons (cons ido-current-directory ido-selected) ido-last-directory-list)))))
2122 (ido-set-current-directory ido-current-directory ido-selected)
2123 (if ido-input-stack
2124 ; automatically pop stack elements which match existing files or directories
2125 (let (elt)
2126 (while (and (setq elt (car ido-input-stack))
2127 (file-exists-p (concat ido-current-directory (cdr elt))))
2128 (if (setq ido-input-stack (cdr ido-input-stack))
2129 (ido-set-current-directory ido-current-directory (cdr elt))
2130 (setq ido-text-init (cdr elt)))
2131 (setq ido-cur-item (car elt))))
2132 (setq ido-set-default-item t)))
2135 (setq done t))))))
2136 ido-selected))
2138 (defun ido-edit-input ()
2139 "Edit absolute file name entered so far with ido; terminate by RET.
2140 If cursor is not at the end of the user input, move to end of input."
2141 (interactive)
2142 (if (not (eobp))
2143 (end-of-line)
2144 (setq ido-text-init (if ido-matches (ido-name (car ido-matches)) ido-text))
2145 (setq ido-exit 'edit)
2146 (exit-minibuffer)))
2148 ;;; MAIN FUNCTIONS
2149 (defun ido-buffer-internal (method &optional fallback prompt default initial switch-cmd)
2150 ;; Internal function for ido-switch-buffer and friends
2151 (if (not ido-mode)
2152 (progn
2153 (run-hook-with-args 'ido-before-fallback-functions
2154 (or fallback 'switch-to-buffer))
2155 (call-interactively (or fallback 'switch-to-buffer)))
2156 (let* ((ido-context-switch-command switch-cmd)
2157 (ido-current-directory nil)
2158 (ido-directory-nonreadable nil)
2159 (ido-directory-too-big nil)
2160 (buf (ido-read-internal 'buffer (or prompt "Buffer: ") 'ido-buffer-history default nil initial)))
2162 ;; Choose the buffer name: either the text typed in, or the head
2163 ;; of the list of matches
2165 (cond
2166 ((eq ido-exit 'find-file)
2167 (ido-file-internal ido-default-file-method nil nil nil nil ido-text))
2169 ((eq ido-exit 'insert-file)
2170 (ido-file-internal 'insert 'insert-file nil "Insert file: " nil ido-text 'ido-enter-insert-buffer))
2172 ((eq ido-exit 'fallback)
2173 (let ((read-buffer-function nil))
2174 (setq this-command (or fallback 'switch-to-buffer))
2175 (run-hook-with-args 'ido-before-fallback-functions this-command)
2176 (call-interactively this-command)))
2178 ;; Check buf is non-nil.
2179 ((not buf) nil)
2180 ((= (length buf) 0) nil)
2182 ;; View buffer if it exists
2183 ((get-buffer buf)
2184 (add-to-history 'buffer-name-history buf)
2185 (if (eq method 'insert)
2186 (progn
2187 (ido-record-command 'insert-buffer buf)
2188 (push-mark
2189 (save-excursion
2190 (insert-buffer-substring (get-buffer buf))
2191 (point))))
2192 (ido-visit-buffer buf method t)))
2194 ;; buffer doesn't exist
2195 ((eq ido-create-new-buffer 'never)
2196 (message "No buffer matching `%s'" buf))
2198 ((and (eq ido-create-new-buffer 'prompt)
2199 (not (y-or-n-p (format "No buffer matching `%s', create one? " buf))))
2200 nil)
2202 ;; create a new buffer
2204 (add-to-history 'buffer-name-history buf)
2205 (setq buf (get-buffer-create buf))
2206 (if (fboundp 'set-buffer-major-mode)
2207 (set-buffer-major-mode buf))
2208 (ido-visit-buffer buf method t))))))
2210 (defun ido-record-work-directory (&optional dir)
2211 (when (and (numberp ido-max-work-directory-list) (> ido-max-work-directory-list 0))
2212 (if (and (setq dir (or dir ido-current-directory)) (> (length dir) 0))
2213 (let ((items ido-work-directory-list-ignore-regexps)
2214 (case-fold-search nil))
2215 (while (and items dir)
2216 (if (string-match (car items) dir)
2217 (setq dir nil))
2218 (setq items (cdr items)))
2219 (if dir
2220 (setq ido-work-directory-list (cons dir (delete dir ido-work-directory-list))))))
2221 (if (> (length ido-work-directory-list) ido-max-work-directory-list)
2222 (setcdr (nthcdr (1- ido-max-work-directory-list) ido-work-directory-list) nil))))
2224 (defun ido-forget-work-directory ()
2225 (interactive)
2226 (when (and ido-current-directory ido-work-directory-list)
2227 (setq ido-work-directory-list (delete ido-current-directory ido-work-directory-list))
2228 (when ido-use-merged-list
2229 (ido-undo-merge-work-directory)
2230 (setq ido-exit 'refresh
2231 ido-try-merged-list t
2232 ido-use-merged-list t
2233 ido-text-init ido-text
2234 ido-rotate-temp t)
2235 (exit-minibuffer))))
2237 (defun ido-record-work-file (name)
2238 ;; Save NAME in ido-work-file-list
2239 (when (and (numberp ido-max-work-file-list) (> ido-max-work-file-list 0))
2241 (and ido-work-file-list (equal (car ido-work-file-list) name))
2242 (setq ido-work-file-list (cons name (delete name ido-work-file-list))))
2243 (if (> (length ido-work-file-list) ido-max-work-file-list)
2244 (setcdr (nthcdr (1- ido-max-work-file-list) ido-work-file-list) nil))))
2246 (defun ido-expand-directory (dir)
2247 ;; Expand DIR or use DEFAULT-DIRECTORY if nil.
2248 ;; Add final slash to result in case it was missing from DEFAULT-DIRECTORY.
2249 (ido-final-slash (expand-file-name (or dir default-directory)) t))
2251 (defun ido-file-internal (method &optional fallback default prompt item initial switch-cmd)
2252 ;; Internal function for ido-find-file and friends
2253 (unless item
2254 (setq item 'file))
2255 (let ((ido-current-directory (ido-expand-directory default))
2256 (ido-context-switch-command switch-cmd)
2257 ido-directory-nonreadable ido-directory-too-big
2258 filename)
2260 (if (or (not ido-mode) (ido-is-slow-ftp-host))
2261 (setq filename t
2262 ido-exit 'fallback)
2263 (setq ido-directory-nonreadable
2264 (ido-nonreadable-directory-p ido-current-directory)
2265 ido-directory-too-big
2266 (and (not ido-directory-nonreadable)
2267 (ido-directory-too-big-p ido-current-directory))))
2269 (when (and (eq item 'file)
2270 (or ido-use-url-at-point ido-use-filename-at-point))
2271 (let (fn d)
2272 (require 'ffap)
2273 ;; Duplicate code from ffap-guesser as we want different behaviour for files and URLs.
2274 (cond
2275 ((with-no-warnings
2276 (and ido-use-url-at-point
2277 ffap-url-regexp
2278 (ffap-fixup-url (or (ffap-url-at-point)
2279 (ffap-gopher-at-point)))))
2280 (setq ido-exit 'ffap
2281 filename t))
2283 ((and ido-use-filename-at-point
2284 (setq fn (with-no-warnings
2285 (if (eq ido-use-filename-at-point 'guess)
2286 (ffap-guesser)
2287 (ffap-string-at-point))))
2288 (not (string-match "^http:/" fn))
2289 (setq d (file-name-directory fn))
2290 (file-directory-p d))
2291 (setq ido-current-directory d)
2292 (setq initial (file-name-nondirectory fn))))))
2294 (let (ido-saved-vc-hb
2295 (vc-handled-backends (and (boundp 'vc-handled-backends) vc-handled-backends))
2296 (ido-work-directory-index -1)
2297 (ido-work-file-index -1)
2298 (ido-find-literal nil))
2300 (unless filename
2301 (setq ido-saved-vc-hb vc-handled-backends)
2302 (let ((minibuffer-completing-file-name t))
2303 (setq filename (ido-read-internal item
2304 (or prompt "Find file: ")
2305 'ido-file-history
2306 (and (eq method 'alt-file) buffer-file-name)
2307 nil initial))))
2309 ;; Choose the file name: either the text typed in, or the head
2310 ;; of the list of matches
2312 (cond
2313 ((eq ido-exit 'fallback)
2314 ;; Need to guard setting of default-directory here, since
2315 ;; we don't want to change directory of current buffer.
2316 (let ((default-directory ido-current-directory)
2317 (read-file-name-function nil))
2318 (setq this-command (or fallback 'find-file))
2319 (run-hook-with-args 'ido-before-fallback-functions this-command)
2320 (call-interactively this-command)))
2322 ((eq ido-exit 'switch-to-buffer)
2323 (ido-buffer-internal ido-default-buffer-method nil nil nil ido-text))
2325 ((eq ido-exit 'insert-buffer)
2326 (ido-buffer-internal 'insert 'insert-buffer "Insert buffer: " nil ido-text 'ido-enter-insert-file))
2328 ((eq ido-exit 'dired)
2329 (dired (concat ido-current-directory (or ido-text ""))))
2331 ((eq ido-exit 'ffap)
2332 (find-file-at-point))
2334 ((eq method 'alt-file)
2335 (ido-record-work-file filename)
2336 (setq default-directory ido-current-directory)
2337 (ido-record-work-directory)
2338 (find-alternate-file filename))
2340 ((memq method '(dired list-directory))
2341 (if (equal filename ".")
2342 (setq filename ""))
2343 (let* ((dirname (ido-final-slash (concat ido-current-directory filename) t))
2344 (file (substring dirname 0 -1)))
2345 (cond
2346 ((file-directory-p dirname)
2347 (ido-record-command method dirname)
2348 (ido-record-work-directory dirname)
2349 (funcall method dirname))
2350 ((file-directory-p ido-current-directory)
2351 (cond
2352 ((file-exists-p file)
2353 (ido-record-command method ido-current-directory)
2354 (ido-record-work-directory)
2355 (funcall method ido-current-directory)
2356 (if (eq method 'dired)
2357 (with-no-warnings
2358 (dired-goto-file (expand-file-name file)))))
2359 ((string-match "[[*?]" filename)
2360 (setq dirname (concat ido-current-directory filename))
2361 (ido-record-command method dirname)
2362 (ido-record-work-directory)
2363 (funcall method dirname))
2364 ((y-or-n-p (format "Directory %s does not exist. Create it? " filename))
2365 (ido-record-command method dirname)
2366 (ido-record-work-directory dirname)
2367 (make-directory-internal dirname)
2368 (funcall method dirname))
2370 ;; put make-directory command on history
2371 (ido-record-command 'make-directory dirname))))
2372 (t (error "No such directory")))))
2374 ((eq method 'write)
2375 (ido-record-work-file filename)
2376 (setq default-directory ido-current-directory)
2377 (setq filename (concat ido-current-directory filename))
2378 (ido-record-command 'write-file filename)
2379 (add-to-history 'file-name-history filename)
2380 (ido-record-work-directory)
2381 (write-file filename))
2383 ((eq method 'read-only)
2384 (ido-record-work-file filename)
2385 (setq filename (concat ido-current-directory filename))
2386 (ido-record-command fallback filename)
2387 (ido-record-work-directory)
2388 (run-hook-with-args 'ido-before-fallback-functions fallback)
2389 (funcall fallback filename))
2391 ((eq method 'insert)
2392 (ido-record-work-file filename)
2393 (setq filename (concat ido-current-directory filename))
2394 (ido-record-command
2395 (if ido-find-literal 'insert-file-literally 'insert-file)
2396 filename)
2397 (add-to-history 'file-name-history filename)
2398 (ido-record-work-directory)
2399 (insert-file-1 filename
2400 (if ido-find-literal
2401 #'insert-file-contents-literally
2402 #'insert-file-contents)))
2404 (filename
2405 (ido-record-work-file filename)
2406 (setq filename (concat ido-current-directory filename))
2407 (ido-record-command 'find-file filename)
2408 (add-to-history 'file-name-history filename)
2409 (ido-record-work-directory)
2410 (ido-visit-buffer (find-file-noselect filename nil ido-find-literal) method))))))
2412 (defun ido-existing-item-p ()
2413 ;; Return non-nil if there is a matching item
2414 (not (null ido-matches)))
2416 ;;; COMPLETION CODE
2418 (defun ido-set-common-completion ()
2419 ;; Find common completion of `ido-text' in `ido-matches'
2420 ;; The result is stored in `ido-common-match-string'
2421 (let (val)
2422 (setq ido-common-match-string nil)
2423 (if (and ido-matches
2424 (not ido-enable-regexp) ;; testing
2425 (stringp ido-text)
2426 (> (length ido-text) 0))
2427 (if (setq val (ido-find-common-substring ido-matches ido-text))
2428 (setq ido-common-match-string val)))
2429 val))
2431 (defun ido-complete ()
2432 "Try and complete the current pattern amongst the file names."
2433 (interactive)
2434 (let (res)
2435 (cond
2436 (ido-incomplete-regexp
2437 ;; Do nothing
2439 ((and (memq ido-cur-item '(file dir))
2440 (string-match "[$]" ido-text))
2441 (let ((evar (substitute-in-file-name (concat ido-current-directory ido-text))))
2442 (if (not (file-exists-p (file-name-directory evar)))
2443 (message "Expansion generates non-existing directory name")
2444 (if (file-directory-p evar)
2445 (ido-set-current-directory evar)
2446 (let ((d (or (file-name-directory evar) "/"))
2447 (f (file-name-nondirectory evar)))
2448 (when (file-directory-p d)
2449 (ido-set-current-directory d)
2450 (setq ido-text-init f))))
2451 (setq ido-exit 'refresh)
2452 (exit-minibuffer))))
2454 (ido-directory-too-big
2455 (setq ido-directory-too-big nil)
2456 (setq ido-text-init ido-text)
2457 (setq ido-exit 'refresh)
2458 (exit-minibuffer))
2460 ((not ido-matches)
2461 (when ido-completion-buffer
2462 (call-interactively (setq this-command ido-cannot-complete-command))))
2464 ((and (= 1 (length ido-matches))
2465 (not (and ido-enable-tramp-completion
2466 (string-equal ido-current-directory "/")
2467 (string-match ".[@:]\\'" (ido-name (car ido-matches)))))
2468 (not (ido-local-file-exists-p (ido-name (car ido-matches)))))
2469 ;; only one choice, so select it.
2470 (if (not ido-confirm-unique-completion)
2471 (exit-minibuffer)
2472 (setq ido-rescan (not ido-enable-prefix))
2473 (delete-region (minibuffer-prompt-end) (point))
2474 (insert (ido-name (car ido-matches)))))
2476 (t ;; else there could be some completions
2477 (setq res ido-common-match-string)
2478 (if (and (not (memq res '(t nil)))
2479 (not (equal res ido-text)))
2480 ;; found something to complete, so put it in the minibuffer.
2481 (progn
2482 ;; move exact match to front if not in prefix mode
2483 (setq ido-rescan (not ido-enable-prefix))
2484 (delete-region (minibuffer-prompt-end) (point))
2485 (insert res))
2486 ;; else nothing to complete
2487 (call-interactively (setq this-command ido-cannot-complete-command))
2488 )))))
2490 (defun ido-complete-space ()
2491 "Try completion unless inserting the space makes sense."
2492 (interactive)
2493 (if (and (stringp ido-common-match-string)
2494 (stringp ido-text)
2495 (cond
2496 ((> (length ido-common-match-string) (length ido-text))
2497 (= (aref ido-common-match-string (length ido-text)) ? ))
2498 (ido-matches
2499 (let (insert-space
2500 (re (concat (regexp-quote ido-text) " "))
2501 (comp ido-matches))
2502 (while comp
2503 (if (string-match re (ido-name (car comp)))
2504 (setq comp nil insert-space t)
2505 (setq comp (cdr comp))))
2506 insert-space))
2507 (t nil)))
2508 (insert " ")
2509 (ido-complete)))
2511 (defun ido-undo-merge-work-directory (&optional text try refresh)
2512 "Undo or redo last ido directory merge operation.
2513 If no merge has yet taken place, toggle automatic merging option."
2514 (interactive)
2515 (cond
2516 (ido-pre-merge-state
2517 (ido-set-current-directory (nth 1 ido-pre-merge-state))
2518 (setq ido-text-init (or text (car ido-pre-merge-state))
2519 ido-cur-list (nth 2 ido-pre-merge-state)
2520 ido-ignored-list (nth 3 ido-pre-merge-state)
2521 ido-matches (nth 4 ido-pre-merge-state)
2522 ido-use-merged-list nil
2523 ido-try-merged-list try
2524 ido-keep-item-list (not refresh)
2525 ido-rescan nil
2526 ido-exit 'refresh
2527 ido-pre-merge-state nil)
2528 (exit-minibuffer))
2529 (text
2530 nil)
2531 (ido-try-merged-list
2532 (setq ido-try-merged-list nil))
2533 (ido-matches
2534 (setq ido-try-merged-list t))
2535 ((not ido-use-merged-list)
2536 (ido-merge-work-directories))))
2538 ;;; Magic C-f
2540 (defun ido-magic-forward-char (arg)
2541 "Move forward in user input or perform magic action.
2542 If no user input is present, or at end of input, perform magic actions:
2543 C-x C-b ... C-f switch to ido-find-file.
2544 C-x C-f ... C-f fallback to non-ido find-file.
2545 C-x C-d ... C-f fallback to non-ido brief dired.
2546 C-x d ... C-f fallback to non-ido dired."
2547 (interactive "P")
2548 (cond
2549 ((or arg (not (eobp)))
2550 (forward-char (min (prefix-numeric-value arg)
2551 (- (point-max) (point)))))
2552 ((memq ido-cur-item '(file dir))
2553 (ido-fallback-command))
2554 (ido-context-switch-command
2555 (call-interactively ido-context-switch-command))
2556 ((eq ido-cur-item 'buffer)
2557 (ido-enter-find-file))))
2559 ;;; Magic C-b
2561 (defun ido-magic-backward-char (arg)
2562 "Move backward in user input or perform magic action.
2563 If no user input is present, or at start of input, perform magic actions:
2564 C-x C-f C-b switch to `ido-switch-buffer'.
2565 C-x C-d C-b switch to `ido-switch-buffer'.
2566 C-x d C-b switch to `ido-switch-buffer'.
2567 C-x C-b C-b fallback to non-ido `switch-to-buffer'."
2568 (interactive "P")
2569 (cond
2570 ((or arg (> (point) (minibuffer-prompt-end)))
2571 (forward-char
2572 (- (min (prefix-numeric-value arg)
2573 (- (point) (minibuffer-prompt-end))))))
2574 ((eq last-command this-command)
2575 (when (and (memq ido-cur-item '(file dir))
2576 (not (bobp)))
2577 (ido-push-dir))) ; else do nothing
2578 ((eq ido-cur-item 'buffer)
2579 (ido-fallback-command))
2580 (ido-context-switch-command
2581 (call-interactively ido-context-switch-command))
2583 (ido-enter-switch-buffer))))
2585 ;;; Magic C-d
2587 (defun ido-magic-delete-char (arg)
2588 "Delete following char in user input or perform magic action.
2589 If at end of user input, perform magic actions:
2590 C-x C-f ... C-d enter dired on current directory."
2591 (interactive "P")
2592 (cond
2593 ((or arg (not (eobp)))
2594 (delete-char (min (prefix-numeric-value arg)
2595 (- (point-max) (point)))))
2596 (ido-context-switch-command
2597 nil)
2598 ((memq ido-cur-item '(file dir))
2599 (ido-enter-dired))))
2602 ;;; TOGGLE FUNCTIONS
2604 (defun ido-toggle-case ()
2605 "Toggle the value of `ido-case-fold'."
2606 (interactive)
2607 (setq ido-case-fold (not ido-case-fold))
2608 ;; ask for list to be regenerated.
2609 (setq ido-rescan t))
2611 (defun ido-toggle-regexp ()
2612 "Toggle the value of `ido-enable-regexp'."
2613 (interactive)
2614 (setq ido-enable-regexp (not ido-enable-regexp))
2615 ;; ask for list to be regenerated.
2616 (setq ido-rescan t))
2618 (defun ido-toggle-prefix ()
2619 "Toggle the value of `ido-enable-prefix'."
2620 (interactive)
2621 (setq ido-enable-prefix (not ido-enable-prefix))
2622 ;; ask for list to be regenerated.
2623 (setq ido-rescan t))
2625 (defun ido-toggle-ignore ()
2626 "Toggle ignoring files specified with `ido-ignore-files'."
2627 (interactive)
2628 (if (and (not (eobp)) (> (point) (minibuffer-prompt-end)))
2629 (goto-char (minibuffer-prompt-end))
2630 (if ido-directory-too-big
2631 (progn
2632 (message "Reading directory...")
2633 (setq ido-directory-too-big nil))
2634 (setq ido-process-ignore-lists (not ido-process-ignore-lists)))
2635 (setq ido-text-init ido-text)
2636 (setq ido-exit 'refresh)
2637 (exit-minibuffer)))
2639 (defun ido-toggle-vc ()
2640 "Disable version control for this file."
2641 (interactive)
2642 (if (and ido-mode (eq ido-cur-item 'file))
2643 (progn
2644 (setq vc-handled-backends
2645 (if vc-handled-backends nil ido-saved-vc-hb))
2646 (setq ido-text-init ido-text)
2647 (setq ido-exit 'keep)
2648 (exit-minibuffer))))
2650 (defun ido-toggle-literal ()
2651 "Toggle literal reading of this file."
2652 (interactive)
2653 (if (and ido-mode (eq ido-cur-item 'file))
2654 (progn
2655 (setq ido-find-literal (not ido-find-literal))
2656 (setq ido-text-init ido-text)
2657 (setq ido-exit 'keep)
2658 (exit-minibuffer))))
2660 (defun ido-reread-directory ()
2661 "Read current directory again.
2662 May be useful if cached version is no longer valid, but directory
2663 timestamp has not changed (e.g. with ftp or on Windows)."
2664 (interactive)
2665 (if (and ido-mode (memq ido-cur-item '(file dir)))
2666 (progn
2667 (if (ido-is-unc-root)
2668 (setq ido-unc-hosts-cache t)
2669 (ido-remove-cached-dir ido-current-directory))
2670 (setq ido-text-init ido-text)
2671 (setq ido-rotate-temp t)
2672 (setq ido-exit 'refresh)
2673 (exit-minibuffer))))
2675 (defun ido-exit-minibuffer ()
2676 "Exit minibuffer, but make sure we have a match if one is needed."
2677 (interactive)
2678 (if (and (or (not ido-require-match)
2679 (ido-existing-item-p))
2680 (not ido-incomplete-regexp))
2681 (exit-minibuffer)))
2683 (defun ido-select-text ()
2684 "Select the buffer or file named by the prompt.
2685 If no buffer or file exactly matching the prompt exists, maybe create a new one."
2686 (interactive)
2687 (setq ido-exit 'takeprompt)
2688 (exit-minibuffer))
2690 (defun ido-fallback-command ()
2691 "Fallback to non-ido version of current command."
2692 (interactive)
2693 (let ((i (length ido-text)))
2694 (while (> i 0)
2695 (push (aref ido-text (setq i (1- i))) unread-command-events)))
2696 (setq ido-exit 'fallback)
2697 (exit-minibuffer))
2699 (defun ido-enter-find-file ()
2700 "Drop into `find-file' from buffer switching."
2701 (interactive)
2702 (setq ido-exit 'find-file)
2703 (exit-minibuffer))
2705 (defun ido-enter-switch-buffer ()
2706 "Drop into `ido-switch-buffer' from file switching."
2707 (interactive)
2708 (setq ido-exit 'switch-to-buffer)
2709 (exit-minibuffer))
2711 (defun ido-enter-dired ()
2712 "Drop into `dired' from file switching."
2713 (interactive)
2714 (setq ido-exit 'dired)
2715 (exit-minibuffer))
2717 (defun ido-enter-insert-buffer ()
2718 "Drop into `insert-buffer' from insert file."
2719 (interactive)
2720 (setq ido-exit 'insert-buffer)
2721 (exit-minibuffer))
2723 (defun ido-enter-insert-file ()
2724 "Drop into `insert-file' from insert buffer."
2725 (interactive)
2726 (setq ido-exit 'insert-file)
2727 (exit-minibuffer))
2730 (defun ido-up-directory (&optional clear)
2731 "Go up one directory level."
2732 (interactive "P")
2733 (setq ido-text-init (if clear nil ido-text))
2734 (setq ido-exit 'updir)
2735 (setq ido-rotate-temp t)
2736 (exit-minibuffer))
2738 (defun ido-delete-backward-updir (count)
2739 "Delete char backwards, or at beginning of buffer, go up one level."
2740 (interactive "P")
2741 (cond
2742 ((= (minibuffer-prompt-end) (point))
2743 (if (not count)
2744 (ido-up-directory t)))
2745 ((and ido-pre-merge-state (string-equal (car ido-pre-merge-state) ido-text))
2746 (ido-undo-merge-work-directory (substring ido-text 0 -1) t t))
2747 ((eq this-original-command 'viper-backward-char)
2748 (funcall this-original-command (prefix-numeric-value count)))
2749 ((eq this-original-command 'viper-del-backward-char-in-insert)
2750 (funcall this-original-command))
2752 (delete-backward-char (prefix-numeric-value count)))))
2754 (defun ido-delete-backward-word-updir (count)
2755 "Delete all chars backwards, or at beginning of buffer, go up one level."
2756 (interactive "P")
2757 (if (= (minibuffer-prompt-end) (point))
2758 (if (not count)
2759 (ido-up-directory t))
2760 (if (eq this-original-command 'viper-delete-backward-word)
2761 (funcall this-original-command (prefix-numeric-value count))
2762 (backward-kill-word (prefix-numeric-value count)))))
2764 (defun ido-get-work-directory (&optional incr must-match)
2765 (let ((n (length ido-work-directory-list))
2766 (i ido-work-directory-index)
2767 (j 0)
2768 dir)
2769 (if (or (not ido-text) (= (length ido-text) 0))
2770 (setq must-match nil))
2771 (while (< j n)
2772 (setq i (+ i incr)
2773 j (1+ j))
2774 (if (> incr 0)
2775 (if (>= i n) (setq i 0))
2776 (if (< i 0) (setq i (1- n))))
2777 (setq dir (nth i ido-work-directory-list))
2778 (if (and dir
2779 (not (equal dir ido-current-directory))
2780 (file-directory-p dir)
2781 (or (not must-match)
2782 ;; TODO. check for nonreadable and too-big.
2783 (ido-set-matches-1
2784 (if (eq ido-cur-item 'file)
2785 (ido-make-file-list-1 dir)
2786 (ido-make-dir-list-1 dir)))))
2787 (setq j n)
2788 (setq dir nil)))
2789 (if dir
2790 (setq ido-work-directory-index i))
2791 dir))
2793 (defun ido-prev-work-directory ()
2794 "Change to next working directory in list."
2795 (interactive)
2796 (let ((dir (ido-get-work-directory 1 ido-work-directory-match-only)))
2797 (when dir
2798 (ido-set-current-directory dir)
2799 (setq ido-exit 'refresh)
2800 (setq ido-text-init ido-text)
2801 (setq ido-rotate-temp t)
2802 (exit-minibuffer))))
2804 (defun ido-next-work-directory ()
2805 "Change to previous working directory in list."
2806 (interactive)
2807 (let ((dir (ido-get-work-directory -1 ido-work-directory-match-only)))
2808 (when dir
2809 (ido-set-current-directory dir)
2810 (setq ido-exit 'refresh)
2811 (setq ido-text-init ido-text)
2812 (setq ido-rotate-temp t)
2813 (exit-minibuffer))))
2815 (defun ido-merge-work-directories ()
2816 "Search (and merge) work directories for files matching the current input string."
2817 (interactive)
2818 (setq ido-use-merged-list t ido-try-merged-list t)
2819 (setq ido-exit 'refresh)
2820 (setq ido-text-init ido-text)
2821 (setq ido-rotate-temp t)
2822 (exit-minibuffer))
2824 (defun ido-wide-find-file (&optional file)
2825 "Prompt for FILE to search for using find, starting from current directory."
2826 (interactive)
2827 (unless file
2828 (let ((enable-recursive-minibuffers t))
2829 (setq file
2830 (condition-case nil
2831 (read-string (concat "Wide find file: " ido-current-directory) ido-text)
2832 (quit "")))))
2833 (when (> (length file) 0)
2834 (setq ido-use-merged-list t ido-try-merged-list 'wide)
2835 (setq ido-exit 'refresh)
2836 (setq ido-text-init file)
2837 (setq ido-rotate-temp t)
2838 (exit-minibuffer)))
2840 (defun ido-wide-find-dir (&optional dir)
2841 "Prompt for DIR to search for using find, starting from current directory."
2842 (interactive)
2843 (unless dir
2844 (let ((enable-recursive-minibuffers t))
2845 (setq dir
2846 (condition-case nil
2847 (read-string (concat "Wide find directory: " ido-current-directory) ido-text)
2848 (quit "")))))
2849 (when (> (length dir) 0)
2850 (setq ido-use-merged-list t ido-try-merged-list 'wide)
2851 (setq ido-exit 'refresh)
2852 (setq ido-text-init (ido-final-slash dir t))
2853 (setq ido-rotate-temp t)
2854 (exit-minibuffer)))
2856 (defun ido-wide-find-dir-or-delete-dir (&optional dir)
2857 "Prompt for DIR to search for using find, starting from current directory.
2858 If input stack is non-empty, delete current directory component."
2859 (interactive)
2860 (if ido-input-stack
2861 (ido-delete-backward-word-updir 1)
2862 (ido-wide-find-dir)))
2864 (defun ido-take-first-match ()
2865 "Use first matching item as input text."
2866 (interactive)
2867 (when ido-matches
2868 (setq ido-text-init (ido-name (car ido-matches)))
2869 (setq ido-exit 'refresh)
2870 (exit-minibuffer)))
2872 (defun ido-push-dir ()
2873 "Move to previous directory in file name, push current input on stack."
2874 (interactive)
2875 (setq ido-exit 'push)
2876 (exit-minibuffer))
2878 (defun ido-push-dir-first ()
2879 "Move to previous directory in file name, push first match on stack."
2880 (interactive)
2881 (if ido-matches
2882 (setq ido-text (ido-name (car ido-matches))))
2883 (setq ido-exit 'push)
2884 (exit-minibuffer))
2886 (defun ido-pop-dir (arg)
2887 "Pop directory from input stack back to input.
2888 With \\[universal-argument], pop all element."
2889 (interactive "P")
2890 (when ido-input-stack
2891 (setq ido-exit (if arg 'pop-all 'pop))
2892 (exit-minibuffer)))
2894 (defun ido-wide-find-file-or-pop-dir (arg)
2895 (interactive "P")
2896 (if ido-input-stack
2897 (ido-pop-dir arg)
2898 (ido-wide-find-file)))
2900 (defun ido-make-directory (&optional dir)
2901 "Prompt for DIR to create in current directory."
2902 (interactive)
2903 (unless dir
2904 (let ((enable-recursive-minibuffers t))
2905 (setq dir
2906 (read-string (concat "Make directory: " ido-current-directory) ido-text))))
2907 (when (> (length dir) 0)
2908 (setq dir (concat ido-current-directory dir))
2909 (unless (file-exists-p dir)
2910 (make-directory dir t)
2911 (ido-set-current-directory dir)
2912 (setq ido-exit 'refresh)
2913 (setq ido-text-init nil)
2914 (setq ido-rotate-temp t)
2915 (exit-minibuffer))))
2917 (defun ido-get-work-file (incr)
2918 (let ((n (length ido-work-file-list))
2919 (i (+ ido-work-file-index incr))
2920 name)
2921 (if (> incr 0)
2922 (if (>= i n) (setq i 0))
2923 (if (< i 0) (setq i (1- n))))
2924 (setq name (nth i ido-work-file-list))
2925 (setq ido-work-file-index i)
2926 name))
2928 (defun ido-prev-work-file ()
2929 "Change to next working file name in list."
2930 (interactive)
2931 (let ((name (ido-get-work-file 1)))
2932 (when name
2933 (setq ido-text-init name)
2934 (setq ido-exit 'refresh)
2935 (exit-minibuffer))))
2937 (defun ido-next-work-file ()
2938 "Change to previous working file name in list."
2939 (interactive)
2940 (let ((name (ido-get-work-file -1)))
2941 (when name
2942 (setq ido-text-init name)
2943 (setq ido-exit 'refresh)
2944 (exit-minibuffer))))
2946 (defun ido-copy-current-file-name (all)
2947 "Insert file name of current buffer.
2948 If repeated, insert text from buffer instead."
2949 (interactive "P")
2950 (let* ((bfname (or (buffer-file-name ido-entry-buffer)
2951 (buffer-name ido-entry-buffer)))
2952 (name (and bfname (file-name-nondirectory bfname))))
2953 (when name
2954 (setq ido-text-init
2955 (if (or all
2956 (eq last-command this-command)
2957 (not (equal (file-name-directory bfname) ido-current-directory))
2958 (not (string-match "\\.[^.]*\\'" name)))
2959 name
2960 (substring name 0 (1+ (match-beginning 0)))))
2961 (setq ido-exit 'refresh
2962 ido-try-merged-list nil)
2963 (exit-minibuffer))))
2965 (defun ido-copy-current-word (all)
2966 "Insert current word (file or directory name) from current buffer."
2967 (interactive "P")
2968 (let ((word (save-excursion
2969 (set-buffer ido-entry-buffer)
2970 (let ((p (point)) start-line end-line start-name name)
2971 (if (and mark-active (/= p (mark)))
2972 (setq start-name (mark))
2973 (beginning-of-line)
2974 (setq start-line (point))
2975 (end-of-line)
2976 (setq end-line (point))
2977 (goto-char p)
2978 (if (re-search-backward "[^-_a-zA-Z0-9:./\\~@]" start-line 1)
2979 (forward-char 1))
2980 (setq start-name (point))
2981 (re-search-forward "[-_a-zA-Z0-9:./\\~@]*" end-line 1)
2982 (if (= start-name (point))
2983 (setq start-name nil)))
2984 (and start-name
2985 (buffer-substring-no-properties start-name (point)))))))
2986 (if (cond
2987 ((not word) nil)
2988 ((string-match "\\`[~/]" word)
2989 (setq ido-text-init word
2990 ido-try-merged-list nil
2991 ido-exit 'chdir))
2992 ((string-match "/" word)
2993 (setq ido-text-init (concat ido-current-directory word)
2994 ido-try-merged-list nil
2995 ido-exit 'chdir))
2997 (setq ido-text-init word
2998 ido-try-merged-list nil
2999 ido-exit 'refresh)))
3000 (exit-minibuffer))))
3002 (defun ido-next-match ()
3003 "Put first element of `ido-matches' at the end of the list."
3004 (interactive)
3005 (if ido-matches
3006 (let ((next (cadr ido-matches)))
3007 (setq ido-cur-list (ido-chop ido-cur-list next))
3008 (setq ido-rescan t)
3009 (setq ido-rotate t))))
3011 (defun ido-prev-match ()
3012 "Put last element of `ido-matches' at the front of the list."
3013 (interactive)
3014 (if ido-matches
3015 (let ((prev (car (last ido-matches))))
3016 (setq ido-cur-list (ido-chop ido-cur-list prev))
3017 (setq ido-rescan t)
3018 (setq ido-rotate t))))
3020 (defun ido-next-match-dir ()
3021 "Find next directory in match list.
3022 If work directories have been merged, cycle through directories for
3023 first matching file."
3024 (interactive)
3025 (if ido-use-merged-list
3026 (if ido-matches
3027 (let* ((elt (car ido-matches))
3028 (dirs (cdr elt)))
3029 (when (> (length dirs) 1)
3030 (setcdr elt (ido-chop dirs (cadr dirs))))
3031 (setq ido-rescan nil)))
3032 (let ((cnt (length ido-matches))
3033 (i 1))
3034 (while (and (< i cnt) (not (ido-final-slash (nth i ido-matches))))
3035 (setq i (1+ i)))
3036 (if (< i cnt)
3037 (setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
3039 (defun ido-prev-match-dir ()
3040 "Find previous directory in match list.
3041 If work directories have been merged, cycle through directories
3042 for first matching file."
3043 (interactive)
3044 (if ido-use-merged-list
3045 (if ido-matches
3046 (let* ((elt (car ido-matches))
3047 (dirs (cdr elt)))
3048 (when (> (length dirs) 1)
3049 (setcdr elt (ido-chop dirs (car (last dirs)))))
3050 (setq ido-rescan nil)))
3051 (let* ((cnt (length ido-matches))
3052 (i (1- cnt)))
3053 (while (and (> i 0) (not (ido-final-slash (nth i ido-matches))))
3054 (setq i (1- i)))
3055 (if (> i 0)
3056 (setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
3058 (defun ido-restrict-to-matches ()
3059 "Set current item list to the currently matched items."
3060 (interactive)
3061 (when ido-matches
3062 (setq ido-cur-list ido-matches
3063 ido-text-init ""
3064 ido-rescan nil
3065 ido-exit 'keep)
3066 (exit-minibuffer)))
3068 (defun ido-chop (items elem)
3069 "Remove all elements before ELEM and put them at the end of ITEMS."
3070 (let ((ret nil)
3071 (next nil)
3072 (sofar nil))
3073 (while (not ret)
3074 (setq next (car items))
3075 (if (equal next elem)
3076 (setq ret (append items (nreverse sofar)))
3077 ;; else
3078 (progn
3079 (setq items (cdr items))
3080 (setq sofar (cons next sofar)))))
3081 ret))
3083 (defun ido-name (item)
3084 ;; Return file name for current item, whether in a normal list
3085 ;; or a merged work directory list.
3086 (if (consp item) (car item) item))
3089 ;;; CREATE LIST OF ALL CURRENT FILES
3091 (defun ido-all-completions ()
3092 ;; Return unsorted list of all competions.
3093 (let ((ido-process-ignore-lists nil)
3094 (ido-directory-too-big nil))
3095 (cond
3096 ((eq ido-cur-item 'file)
3097 (ido-make-file-list-1 ido-current-directory))
3098 ((eq ido-cur-item 'dir)
3099 (ido-make-dir-list-1 ido-current-directory))
3100 ((eq ido-cur-item 'buffer)
3101 (ido-make-buffer-list-1))
3102 ((eq ido-cur-item 'list)
3103 ido-choice-list)
3104 (t nil))))
3107 ;; File list sorting
3109 (defun ido-file-lessp (a b)
3110 ;; Simple compare two file names.
3111 (string-lessp (ido-no-final-slash a) (ido-no-final-slash b)))
3114 (defun ido-file-extension-lessp (a b)
3115 ;; Compare file names according to ido-file-extensions-order list.
3116 (let ((n (compare-strings a 0 nil b 0 nil nil))
3117 lessp p)
3118 (if (eq n t)
3120 (if (< n 0)
3121 (setq n (1- (- n))
3122 p a a b b p
3123 lessp t)
3124 (setq n (1- n)))
3125 (cond
3126 ((= n 0)
3127 lessp)
3128 ((= (aref a n) ?.)
3129 (ido-file-extension-aux a b n lessp))
3131 (while (and (> n 2) (/= (aref a n) ?.))
3132 (setq n (1- n)))
3133 (if (> n 1)
3134 (ido-file-extension-aux a b n lessp)
3135 lessp))))))
3137 (defun ido-file-extension-aux (a b n lessp)
3138 (let ((oa (ido-file-extension-order a n))
3139 (ob (ido-file-extension-order b n)))
3140 (cond
3141 ((and oa ob)
3142 (cond
3143 ((= oa ob)
3144 lessp)
3145 (lessp
3146 (> oa ob))
3148 (< oa ob))))
3150 (not lessp))
3152 lessp)
3154 lessp))))
3156 (defun ido-file-extension-order (s n)
3157 (let ((l ido-file-extensions-order)
3158 (i 0) o do)
3159 (while l
3160 (cond
3161 ((eq (car l) t)
3162 (setq do i
3163 l (cdr l)))
3164 ((eq (compare-strings s n nil (car l) 0 nil nil) t)
3165 (setq o i
3166 l nil))
3168 (setq l (cdr l))))
3169 (setq i (1+ i)))
3170 (or o do)))
3173 (defun ido-sort-merged-list (items promote)
3174 ;; Input is list of ("file" . "dir") cons cells.
3175 ;; Output is sorted list of ("file "dir" ...) lists
3176 (let ((l (sort items (lambda (a b) (string-lessp (car b) (car a)))))
3177 res a cur dirs)
3178 (while l
3179 (setq a (car l)
3180 l (cdr l))
3181 (if (and res (string-equal (car (car res)) (car a)))
3182 (progn
3183 (setcdr (car (if cur (cdr res) res)) (cons (cdr a) (cdr (car res))))
3184 (if (and promote (string-equal ido-current-directory (cdr a)))
3185 (setq cur t)))
3186 (setq res (cons (list (car a) (cdr a)) res)
3187 cur nil)))
3188 res))
3190 (defun ido-wide-find-dirs-or-files (dir file &optional prefix finddir)
3191 ;; As ido-run-find-command, but returns a list of cons pairs ("file" . "dir")
3192 (let ((filenames
3193 (split-string
3194 (shell-command-to-string
3195 (concat "find "
3196 (shell-quote-argument dir)
3197 " -name "
3198 (shell-quote-argument
3199 (concat (if prefix "" "*") file "*"))
3200 " -type " (if finddir "d" "f") " -print"))))
3201 filename d f
3202 res)
3203 (while filenames
3204 (setq filename (car filenames)
3205 filenames (cdr filenames))
3206 (if (and (string-match "^/" filename)
3207 (file-exists-p filename))
3208 (setq d (file-name-directory filename)
3209 f (file-name-nondirectory filename)
3210 res (cons (cons (if finddir (ido-final-slash f t) f) d) res))))
3211 res))
3213 (defun ido-flatten-merged-list (items)
3214 ;; Create a list of directory names based on a merged directory list.
3215 (let (res)
3216 (while items
3217 (let* ((item (car items))
3218 (file (car item))
3219 (dirs (cdr item)))
3220 (while dirs
3221 (setq res (cons (concat (car dirs) file) res)
3222 dirs (cdr dirs))))
3223 (setq items (cdr items)))
3224 res))
3227 (defun ido-make-merged-file-list-1 (text auto wide)
3228 (let (res)
3229 (if (and (ido-final-slash text) ido-dir-file-cache)
3230 (if wide
3231 (setq res (ido-wide-find-dirs-or-files
3232 ido-current-directory (substring text 0 -1) ido-enable-prefix t))
3233 ;; Use list of cached directories
3234 (let ((re (concat (regexp-quote (substring text 0 -1)) "[^/:]*/\\'"))
3235 (dirs ido-dir-file-cache)
3236 dir b d f)
3237 (if nil ;; simple
3238 (while dirs
3239 (setq dir (car (car dirs))
3240 dirs (cdr dirs))
3241 (when (and (string-match re dir)
3242 (not (ido-ignore-item-p dir ido-ignore-directories-merge))
3243 (file-directory-p dir))
3244 (setq b (substring dir 0 -1)
3245 f (concat (file-name-nondirectory b) "/")
3246 d (file-name-directory b)
3247 res (cons (cons f d) res))))
3248 (while dirs
3249 (setq dir (car dirs)
3250 d (car dir)
3251 dirs (cdr dirs))
3252 (when (not (ido-ignore-item-p d ido-ignore-directories-merge))
3253 (setq dir (cdr (cdr dir)))
3254 (while dir
3255 (setq f (car dir)
3256 dir (cdr dir))
3257 (if (and (string-match re f)
3258 (not (ido-ignore-item-p f ido-ignore-directories)))
3259 (setq res (cons (cons f d) res)))))
3260 (if (and auto (input-pending-p))
3261 (setq dirs nil
3262 res t))))))
3263 (if wide
3264 (setq res (ido-wide-find-dirs-or-files
3265 ido-current-directory text ido-enable-prefix nil))
3266 (let ((ido-text text)
3267 (dirs ido-work-directory-list)
3268 (must-match (and text (> (length text) 0)))
3269 dir fl)
3270 (if (and auto (not (member ido-current-directory dirs)))
3271 (setq dirs (cons ido-current-directory dirs)))
3272 (while dirs
3273 (setq dir (car dirs)
3274 dirs (cdr dirs))
3275 (when (and dir (stringp dir)
3276 (or ido-merge-ftp-work-directories
3277 (not (ido-is-ftp-directory dir)))
3278 (file-directory-p dir)
3279 ;; TODO. check for nonreadable and too-big.
3280 (setq fl (if (eq ido-cur-item 'file)
3281 (ido-make-file-list-1 dir t)
3282 (ido-make-dir-list-1 dir t))))
3283 (if must-match
3284 (setq fl (ido-set-matches-1 fl)))
3285 (if fl
3286 (setq res (nconc fl res))))
3287 (if (and auto (input-pending-p))
3288 (setq dirs nil
3289 res t))))))
3290 res))
3292 (defun ido-make-merged-file-list (text auto wide)
3293 (let (res)
3294 (message "Searching for `%s'...." text)
3295 (condition-case nil
3296 (if (eq t (setq res
3297 (while-no-input
3298 (ido-make-merged-file-list-1 text auto wide))))
3299 (setq res 'input-pending-p))
3300 (quit
3301 (setq res t
3302 ido-try-merged-list nil
3303 ido-use-merged-list nil)))
3304 (when (and res (listp res))
3305 (setq res (ido-sort-merged-list res auto)))
3306 (when (and (or ido-rotate-temp ido-rotate-file-list-default)
3307 (listp res)
3308 (> (length text) 0))
3309 (let ((elt (assoc text res)))
3310 (when (and elt (not (eq elt (car res))))
3311 (setq res (delq elt res))
3312 (setq res (cons elt res)))))
3313 (message nil)
3314 res))
3316 (defun ido-make-buffer-list-1 (&optional frame visible)
3317 ;; Return list of non-ignored buffer names
3318 (delq nil
3319 (mapcar
3320 (lambda (x)
3321 (let ((name (buffer-name x)))
3322 (if (not (or (ido-ignore-item-p name ido-ignore-buffers) (member name visible)))
3323 name)))
3324 (buffer-list frame))))
3326 (defun ido-make-buffer-list (default)
3327 ;; Return the current list of buffers.
3328 ;; Currently visible buffers are put at the end of the list.
3329 ;; The hook `ido-make-buffer-list-hook' is run after the list has been
3330 ;; created to allow the user to further modify the order of the buffer names
3331 ;; in this list. If DEFAULT is non-nil, and corresponds to an existing buffer,
3332 ;; it is put to the start of the list.
3333 (let* ((ido-current-buffers (ido-get-buffers-in-frames 'current))
3334 (ido-temp-list (ido-make-buffer-list-1 (selected-frame) ido-current-buffers)))
3335 (if ido-temp-list
3336 (nconc ido-temp-list ido-current-buffers)
3337 (setq ido-temp-list ido-current-buffers))
3338 (if default
3339 (progn
3340 (setq ido-temp-list
3341 (delete default ido-temp-list))
3342 (setq ido-temp-list
3343 (cons default ido-temp-list))))
3344 (run-hooks 'ido-make-buffer-list-hook)
3345 ido-temp-list))
3347 (defun ido-make-choice-list (default)
3348 ;; Return the current list of choices.
3349 ;; If DEFAULT is non-nil, and corresponds to an element of choices,
3350 ;; it is put to the start of the list.
3351 (let ((ido-temp-list ido-choice-list))
3352 (if default
3353 (progn
3354 (setq ido-temp-list
3355 (delete default ido-temp-list))
3356 (setq ido-temp-list
3357 (cons default ido-temp-list))))
3358 ; (run-hooks 'ido-make-choice-list-hook)
3359 ido-temp-list))
3361 (defun ido-to-end (items)
3362 ;; Move the elements from ITEMS to the end of `ido-temp-list'
3363 (mapc
3364 (lambda (elem)
3365 (setq ido-temp-list (delq elem ido-temp-list)))
3366 items)
3367 (if ido-temp-list
3368 (nconc ido-temp-list items)
3369 (setq ido-temp-list items)))
3371 (declare-function tramp-tramp-file-p "tramp" (name))
3373 (defun ido-file-name-all-completions-1 (dir)
3374 (cond
3375 ((ido-nonreadable-directory-p dir) '())
3376 ;; do not check (ido-directory-too-big-p dir) here.
3377 ;; Caller must have done that if necessary.
3379 ((and ido-enable-tramp-completion
3380 (or (fboundp 'tramp-completion-mode-p)
3381 (require 'tramp nil t))
3382 (string-match "\\`/[^/]+[:@]\\'" dir))
3383 ;; Strip method:user@host: part of tramp completions.
3384 ;; Tramp completions do not include leading slash.
3385 (let* ((len (1- (length dir)))
3386 (tramp-completion-mode t)
3387 (compl
3388 (or (file-name-all-completions "" dir)
3389 ;; work around bug in ange-ftp.
3390 ;; /ftp:user@host: => nil
3391 ;; /ftp:user@host:./ => ok
3392 (and
3393 (not (string= "/ftp:" dir))
3394 (tramp-tramp-file-p dir)
3395 (fboundp 'tramp-ftp-file-name-p)
3396 (funcall 'tramp-ftp-file-name-p dir)
3397 (string-match ":\\'" dir)
3398 (file-name-all-completions "" (concat dir "./"))))))
3399 (if (and compl
3400 (> (length (car compl)) len)
3401 (string= (substring (car compl) 0 len) (substring dir 1)))
3402 (mapcar (lambda (c) (substring c len)) compl)
3403 compl)))
3405 (file-name-all-completions "" dir))))
3407 (defun ido-file-name-all-completions (dir)
3408 ;; Return name of all files in DIR
3409 ;; Uses and updates ido-dir-file-cache
3410 (cond
3411 ((ido-is-unc-root dir)
3412 (mapcar
3413 (lambda (host)
3414 (if (string-match "/\\'" host) host (concat host "/")))
3415 (ido-unc-hosts t)))
3416 ((and (numberp ido-max-dir-file-cache) (> ido-max-dir-file-cache 0)
3417 (stringp dir) (> (length dir) 0)
3418 (ido-may-cache-directory dir))
3419 (let* ((cached (assoc dir ido-dir-file-cache))
3420 (ctime (nth 1 cached))
3421 (ftp (ido-is-ftp-directory dir))
3422 (unc (ido-is-unc-host dir))
3423 (attr (if (or ftp unc) nil (file-attributes dir)))
3424 (mtime (nth 5 attr))
3425 valid)
3426 (when cached ; should we use the cached entry ?
3427 (cond
3428 (ftp
3429 (setq valid (and (eq (car ctime) 'ftp)
3430 (ido-cache-ftp-valid (cdr ctime)))))
3431 (unc
3432 (setq valid (and (eq (car ctime) 'unc)
3433 (ido-cache-unc-valid (cdr ctime)))))
3435 (if attr
3436 (setq valid (and (= (car ctime) (car mtime))
3437 (= (car (cdr ctime)) (car (cdr mtime))))))))
3438 (unless valid
3439 (setq ido-dir-file-cache (delq cached ido-dir-file-cache)
3440 cached nil)))
3441 (unless cached
3442 (cond
3443 (unc
3444 (setq mtime (cons 'unc (ido-time-stamp))))
3445 ((and ftp (file-readable-p dir))
3446 (setq mtime (cons 'ftp (ido-time-stamp)))))
3447 (if mtime
3448 (setq cached (cons dir (cons mtime (ido-file-name-all-completions-1 dir)))
3449 ido-dir-file-cache (cons cached ido-dir-file-cache)))
3450 (if (> (length ido-dir-file-cache) ido-max-dir-file-cache)
3451 (setcdr (nthcdr (1- ido-max-dir-file-cache) ido-dir-file-cache) nil)))
3452 (and cached
3453 (cdr (cdr cached)))))
3455 (ido-file-name-all-completions-1 dir))))
3457 (defun ido-remove-cached-dir (dir)
3458 ;; Remove dir from ido-dir-file-cache
3459 (if (and ido-dir-file-cache
3460 (stringp dir) (> (length dir) 0))
3461 (let ((cached (assoc dir ido-dir-file-cache)))
3462 (if cached
3463 (setq ido-dir-file-cache (delq cached ido-dir-file-cache))))))
3466 (defun ido-make-file-list-1 (dir &optional merged)
3467 ;; Return list of non-ignored files in DIR
3468 ;; If MERGED is non-nil, each file is cons'ed with DIR
3469 (and (or (ido-is-tramp-root dir) (ido-is-unc-root dir)
3470 (file-directory-p dir))
3471 (delq nil
3472 (mapcar
3473 (lambda (name)
3474 (if (not (ido-ignore-item-p name ido-ignore-files t))
3475 (if merged (cons name dir) name)))
3476 (ido-file-name-all-completions dir)))))
3478 (defun ido-make-file-list (default)
3479 ;; Return the current list of files.
3480 ;; Currently visible files are put at the end of the list.
3481 ;; The hook `ido-make-file-list-hook' is run after the list has been
3482 ;; created to allow the user to further modify the order of the file names
3483 ;; in this list.
3484 (let ((ido-temp-list (ido-make-file-list-1 ido-current-directory)))
3485 (setq ido-temp-list (sort ido-temp-list
3486 (if ido-file-extensions-order
3487 #'ido-file-extension-lessp
3488 #'ido-file-lessp)))
3489 (unless (ido-is-tramp-root ido-current-directory)
3490 (let ((default-directory ido-current-directory))
3491 (ido-to-end ;; move ftp hosts and visited files to end
3492 (delq nil (mapcar
3493 (lambda (x) (if (or (and (string-match ".:\\'" x)
3494 (not (ido-local-file-exists-p x)))
3495 (and (not (ido-final-slash x))
3496 (let (file-name-handler-alist)
3497 (get-file-buffer x)))) x))
3498 ido-temp-list)))))
3499 (ido-to-end ;; move . files to end
3500 (delq nil (mapcar
3501 (lambda (x) (if (string-equal (substring x 0 1) ".") x))
3502 ido-temp-list)))
3503 (if (and default (member default ido-temp-list))
3504 (if (or ido-rotate-temp ido-rotate-file-list-default)
3505 (unless (equal default (car ido-temp-list))
3506 (let ((l ido-temp-list) k)
3507 (while (and l (cdr l) (not (equal default (car (cdr l)))))
3508 (setq l (cdr l)))
3509 (setq k (cdr l))
3510 (setcdr l nil)
3511 (nconc k ido-temp-list)
3512 (setq ido-temp-list k)))
3513 (setq ido-temp-list
3514 (delete default ido-temp-list))
3515 (setq ido-temp-list
3516 (cons default ido-temp-list))))
3517 (when ido-show-dot-for-dired
3518 (setq ido-temp-list (delete "." ido-temp-list))
3519 (setq ido-temp-list (cons "." ido-temp-list)))
3520 (run-hooks 'ido-make-file-list-hook)
3521 ido-temp-list))
3523 (defun ido-make-dir-list-1 (dir &optional merged)
3524 ;; Return list of non-ignored subdirs in DIR
3525 ;; If MERGED is non-nil, each subdir is cons'ed with DIR
3526 (and (or (ido-is-tramp-root dir) (file-directory-p dir))
3527 (delq nil
3528 (mapcar
3529 (lambda (name)
3530 (and (ido-final-slash name) (not (ido-ignore-item-p name ido-ignore-directories))
3531 (if merged (cons name dir) name)))
3532 (ido-file-name-all-completions dir)))))
3534 (defun ido-make-dir-list (default)
3535 ;; Return the current list of directories.
3536 ;; The hook `ido-make-dir-list-hook' is run after the list has been
3537 ;; created to allow the user to further modify the order of the
3538 ;; directory names in this list.
3539 (let ((ido-temp-list (ido-make-dir-list-1 ido-current-directory)))
3540 (setq ido-temp-list (sort ido-temp-list #'ido-file-lessp))
3541 (ido-to-end ;; move . files to end
3542 (delq nil (mapcar
3543 (lambda (x) (if (string-equal (substring x 0 1) ".") x))
3544 ido-temp-list)))
3545 (if (and default (member default ido-temp-list))
3546 (if (or ido-rotate-temp ido-rotate-file-list-default)
3547 (unless (equal default (car ido-temp-list))
3548 (let ((l ido-temp-list) k)
3549 (while (and l (cdr l) (not (equal default (car (cdr l)))))
3550 (setq l (cdr l)))
3551 (setq k (cdr l))
3552 (setcdr l nil)
3553 (nconc k ido-temp-list)
3554 (setq ido-temp-list k)))
3555 (setq ido-temp-list
3556 (delete default ido-temp-list))
3557 (setq ido-temp-list
3558 (cons default ido-temp-list))))
3559 (setq ido-temp-list (delete "." ido-temp-list))
3560 (unless ido-input-stack
3561 (setq ido-temp-list (cons "." ido-temp-list)))
3562 (run-hooks 'ido-make-dir-list-hook)
3563 ido-temp-list))
3565 ;; List of the files visible in the current frame.
3566 (defvar ido-bufs-in-frame)
3568 (defun ido-get-buffers-in-frames (&optional current)
3569 ;; Return the list of buffers that are visible in the current frame.
3570 ;; If optional argument `current' is given, restrict searching to the
3571 ;; current frame, rather than all frames, regardless of value of
3572 ;; `ido-all-frames'.
3573 (let ((ido-bufs-in-frame nil))
3574 (walk-windows 'ido-get-bufname nil
3575 (if current
3577 ido-all-frames))
3578 ido-bufs-in-frame))
3580 (defun ido-get-bufname (win)
3581 ;; Used by `ido-get-buffers-in-frames' to walk through all windows
3582 (let ((buf (buffer-name (window-buffer win))))
3583 (unless (or (member buf ido-bufs-in-frame)
3584 (member buf ido-ignore-item-temp-list))
3585 ;; Only add buf if it is not already in list.
3586 ;; This prevents same buf in two different windows being
3587 ;; put into the list twice.
3588 (setq ido-bufs-in-frame
3589 (cons buf ido-bufs-in-frame)))))
3591 ;;; FIND MATCHING ITEMS
3593 (defun ido-set-matches-1 (items &optional do-full)
3594 ;; Return list of matches in items
3595 (let* ((case-fold-search ido-case-fold)
3596 (slash (and (not ido-enable-prefix) (ido-final-slash ido-text)))
3597 (text (if slash (substring ido-text 0 -1) ido-text))
3598 (rex0 (if ido-enable-regexp text (regexp-quote text)))
3599 (rexq (concat rex0 (if slash ".*/" "")))
3600 (re (if ido-enable-prefix (concat "\\`" rexq) rexq))
3601 (full-re (and do-full (not ido-enable-regexp) (not (string-match "\$\\'" rex0))
3602 (concat "\\`" rex0 (if slash "/" "") "\\'")))
3603 (suffix-re (and do-full slash
3604 (not ido-enable-regexp) (not (string-match "\$\\'" rex0))
3605 (concat rex0 "/\\'")))
3606 (prefix-re (and full-re (not ido-enable-prefix)
3607 (concat "\\`" rexq)))
3608 (non-prefix-dot (or (not ido-enable-dot-prefix)
3609 (not ido-process-ignore-lists)
3610 ido-enable-prefix
3611 (= (length ido-text) 0)))
3612 full-matches suffix-matches prefix-matches matches)
3613 (setq ido-incomplete-regexp nil)
3614 (condition-case error
3615 (mapc
3616 (lambda (item)
3617 (let ((name (ido-name item)))
3618 (if (and (or non-prefix-dot
3619 (if (= (aref ido-text 0) ?.)
3620 (= (aref name 0) ?.)
3621 (/= (aref name 0) ?.)))
3622 (string-match re name))
3623 (cond
3624 ((and (eq ido-cur-item 'buffer)
3625 (or (not (stringp ido-default-item))
3626 (not (string= name ido-default-item)))
3627 (string= name (buffer-name ido-entry-buffer)))
3628 (setq matches (cons item matches)))
3629 ((and full-re (string-match full-re name))
3630 (setq full-matches (cons item full-matches)))
3631 ((and suffix-re (string-match suffix-re name))
3632 (setq suffix-matches (cons item suffix-matches)))
3633 ((and prefix-re (string-match prefix-re name))
3634 (setq prefix-matches (cons item prefix-matches)))
3635 (t (setq matches (cons item matches))))))
3637 items)
3638 (invalid-regexp
3639 (setq ido-incomplete-regexp t
3640 ;; Consider the invalid regexp message internally as a
3641 ;; special-case single match, and handle appropriately
3642 ;; elsewhere.
3643 matches (cdr error))))
3644 (when prefix-matches
3645 (ido-trace "prefix match" prefix-matches)
3646 (setq matches (nconc prefix-matches matches)))
3647 (when suffix-matches
3648 (ido-trace "suffix match" (list text suffix-re suffix-matches))
3649 (setq matches (nconc suffix-matches matches)))
3650 (when full-matches
3651 (ido-trace "full match" (list text full-re full-matches))
3652 (setq matches (nconc full-matches matches)))
3653 (when (and (null matches)
3654 ido-enable-flex-matching
3655 (> (length ido-text) 1)
3656 (not ido-enable-regexp))
3657 (setq re (mapconcat #'regexp-quote (split-string ido-text "") ".*"))
3658 (if ido-enable-prefix
3659 (setq re (concat "\\`" re)))
3660 (mapc
3661 (lambda (item)
3662 (let ((name (ido-name item)))
3663 (if (string-match re name)
3664 (setq matches (cons item matches)))))
3665 items))
3666 matches))
3669 (defun ido-set-matches ()
3670 ;; Set `ido-matches' to the list of items matching prompt
3671 (when ido-rescan
3672 (setq ido-matches (ido-set-matches-1 (reverse ido-cur-list) (not ido-rotate))
3673 ido-rotate nil)))
3675 (defun ido-ignore-item-p (name re-list &optional ignore-ext)
3676 ;; Return t if the buffer or file NAME should be ignored.
3677 (or (member name ido-ignore-item-temp-list)
3678 (and
3679 ido-process-ignore-lists re-list
3680 (save-match-data
3681 (let ((ext-list (and ignore-ext ido-ignore-extensions
3682 completion-ignored-extensions))
3683 (case-fold-search ido-case-fold)
3684 ignorep nextstr
3685 (flen (length name)) slen)
3686 (while ext-list
3687 (setq nextstr (car ext-list))
3688 (if (cond
3689 ((stringp nextstr)
3690 (and (>= flen (setq slen (length nextstr)))
3691 (string-equal (substring name (- flen slen)) nextstr)))
3692 ((functionp nextstr) (funcall nextstr name))
3693 (t nil))
3694 (setq ignorep t
3695 ext-list nil
3696 re-list nil)
3697 (setq ext-list (cdr ext-list))))
3698 (while re-list
3699 (setq nextstr (car re-list))
3700 (if (cond
3701 ((stringp nextstr) (string-match nextstr name))
3702 ((functionp nextstr) (funcall nextstr name))
3703 (t nil))
3704 (setq ignorep t
3705 re-list nil)
3706 (setq re-list (cdr re-list))))
3707 ;; return the result
3708 (if ignorep
3709 (setq ido-ignored-list (cons name ido-ignored-list)))
3710 ignorep)))))
3712 ;; Private variable used by `ido-word-matching-substring'.
3713 (defvar ido-change-word-sub)
3715 (defun ido-find-common-substring (items subs)
3716 ;; Return common string following SUBS in each element of ITEMS.
3717 (let (res
3718 alist
3719 ido-change-word-sub)
3720 (setq ido-change-word-sub
3721 (if ido-enable-regexp
3722 subs
3723 (regexp-quote subs)))
3724 (setq res (mapcar #'ido-word-matching-substring items))
3725 (setq res (delq nil res)) ;; remove any nil elements (shouldn't happen)
3726 (setq alist (mapcar #'ido-makealist res)) ;; could use an OBARRAY
3728 ;; try-completion returns t if there is an exact match.
3729 (let* ((completion-ignore-case ido-case-fold)
3730 (comp (try-completion subs alist)))
3731 (if (eq comp t)
3732 subs
3733 comp))))
3735 (defun ido-word-matching-substring (word)
3736 ;; Return part of WORD before 1st match to `ido-change-word-sub'.
3737 ;; If `ido-change-word-sub' cannot be found in WORD, return nil.
3738 (let ((case-fold-search ido-case-fold))
3739 (let ((m (string-match ido-change-word-sub (ido-name word))))
3740 (if m
3741 (substring (ido-name word) m)
3742 ;; else no match
3743 nil))))
3745 (defun ido-makealist (res)
3746 ;; Return dotted pair (RES . 1).
3747 (cons res 1))
3749 (defun ido-choose-completion-string (choice buffer mini-p base-size)
3750 (when (ido-active)
3751 ;; Insert the completion into the buffer where completion was requested.
3752 (if (get-buffer ido-completion-buffer)
3753 (kill-buffer ido-completion-buffer))
3754 (cond
3755 ((ido-active t) ;; ido-use-merged-list
3756 (setq ido-current-directory ""
3757 ido-text choice
3758 ido-exit 'done))
3759 ((not (ido-final-slash choice))
3760 (setq ido-text choice
3761 ido-exit 'done))
3763 (ido-set-current-directory ido-current-directory choice)
3764 (setq ido-exit 'refresh)))
3765 (exit-minibuffer)
3768 (defun ido-completion-help ()
3769 "Show possible completions in a *File Completions* buffer."
3770 (interactive)
3771 (setq ido-rescan nil)
3772 (let ((temp-buf (get-buffer ido-completion-buffer))
3773 display-it full-list)
3774 (if (and (eq last-command this-command) temp-buf)
3775 ;; scroll buffer
3776 (let (win (buf (current-buffer)))
3777 (display-buffer temp-buf nil nil)
3778 (set-buffer temp-buf)
3779 (setq win (get-buffer-window temp-buf))
3780 (if (pos-visible-in-window-p (point-max) win)
3781 (if (or ido-completion-buffer-all-completions
3782 (boundp 'ido-completion-buffer-full))
3783 (set-window-start win (point-min))
3784 (with-no-warnings
3785 (set (make-local-variable 'ido-completion-buffer-full) t))
3786 (setq full-list t
3787 display-it t))
3788 (scroll-other-window))
3789 (set-buffer buf))
3790 (setq display-it t))
3791 (if display-it
3792 (with-output-to-temp-buffer ido-completion-buffer
3793 (let ((completion-list (sort
3794 (cond
3795 (ido-directory-too-big
3796 (message "Reading directory...")
3797 (setq ido-directory-too-big nil
3798 ido-ignored-list nil
3799 ido-cur-list (ido-all-completions)
3800 ido-rescan t)
3801 (ido-set-matches)
3802 (or ido-matches ido-cur-list))
3803 (ido-use-merged-list
3804 (ido-flatten-merged-list (or ido-matches ido-cur-list)))
3805 ((or full-list ido-completion-buffer-all-completions)
3806 (ido-all-completions))
3808 (copy-sequence (or ido-matches ido-cur-list))))
3809 #'ido-file-lessp)))
3810 (if (featurep 'xemacs)
3811 ;; XEmacs extents are put on by default, doesn't seem to be
3812 ;; any way of switching them off.
3813 ;; This obscure code avoids a byte compiler warning in Emacs.
3814 (let ((f 'display-completion-list))
3815 (funcall f completion-list
3816 :help-string "ido "
3817 :activate-callback
3818 '(lambda (x y z) (message "Doesn't work yet, sorry!"))))
3819 ;; else running Emacs
3820 ;;(add-hook 'completion-setup-hook 'completion-setup-function)
3821 (display-completion-list completion-list)))))))
3823 ;;; KILL CURRENT BUFFER
3824 (defun ido-kill-buffer-at-head ()
3825 "Kill the buffer at the head of `ido-matches'.
3826 If cursor is not at the end of the user input, delete to end of input."
3827 (interactive)
3828 (if (not (eobp))
3829 (delete-region (point) (line-end-position))
3830 (let ((enable-recursive-minibuffers t)
3831 (buf (ido-name (car ido-matches))))
3832 (when buf
3833 (kill-buffer buf)
3834 ;; Check if buffer still exists.
3835 (if (get-buffer buf)
3836 ;; buffer couldn't be killed.
3837 (setq ido-rescan t)
3838 ;; else buffer was killed so remove name from list.
3839 (setq ido-cur-list (delq buf ido-cur-list)))))))
3841 ;;; DELETE CURRENT FILE
3842 (defun ido-delete-file-at-head ()
3843 "Delete the file at the head of `ido-matches'.
3844 If cursor is not at the end of the user input, delete to end of input."
3845 (interactive)
3846 (if (not (eobp))
3847 (delete-region (point) (line-end-position))
3848 (let ((enable-recursive-minibuffers t)
3849 (file (ido-name (car ido-matches))))
3850 (if file
3851 (setq file (concat ido-current-directory file)))
3852 (when (and file
3853 (file-exists-p file)
3854 (not (file-directory-p file))
3855 (file-writable-p ido-current-directory)
3856 (yes-or-no-p (concat "Delete " file "? ")))
3857 (delete-file file)
3858 ;; Check if file still exists.
3859 (if (file-exists-p file)
3860 ;; file could not be deleted
3861 (setq ido-rescan t)
3862 ;; else file was killed so remove name from list.
3863 (setq ido-cur-list (delq (car ido-matches) ido-cur-list)))))))
3866 ;;; VISIT CHOSEN BUFFER
3867 (defun ido-visit-buffer (buffer method &optional record)
3868 "Switch to BUFFER according to METHOD.
3869 Record command in `command-history' if optional RECORD is non-nil."
3870 (if (bufferp buffer)
3871 (setq buffer (buffer-name buffer)))
3872 (let (win newframe)
3873 (cond
3874 ((eq method 'kill)
3875 (if record
3876 (ido-record-command 'kill-buffer buffer))
3877 (kill-buffer buffer))
3879 ((eq method 'other-window)
3880 (if record
3881 (ido-record-command 'switch-to-buffer buffer))
3882 (switch-to-buffer-other-window buffer))
3884 ((eq method 'display)
3885 (display-buffer buffer))
3887 ((eq method 'other-frame)
3888 (switch-to-buffer-other-frame buffer)
3889 (select-frame-set-input-focus (selected-frame)))
3891 ((and (memq method '(raise-frame maybe-frame))
3892 window-system
3893 (setq win (ido-buffer-window-other-frame buffer))
3894 (or (eq method 'raise-frame)
3895 (y-or-n-p "Jump to frame? ")))
3896 (setq newframe (window-frame win))
3897 (select-frame-set-input-focus newframe)
3898 (select-window win))
3900 ;; (eq method 'selected-window)
3902 ;; No buffer in other frames...
3903 (if record
3904 (ido-record-command 'switch-to-buffer buffer))
3905 (switch-to-buffer buffer)
3906 ))))
3909 (defun ido-buffer-window-other-frame (buffer)
3910 ;; Return window pointer if BUFFER is visible in another frame.
3911 ;; If BUFFER is visible in the current frame, return nil.
3912 (let ((blist (ido-get-buffers-in-frames 'current)))
3913 ;;If the buffer is visible in current frame, return nil
3914 (if (member buffer blist)
3916 ;; maybe in other frame or icon
3917 (get-buffer-window buffer 0) ; better than 'visible
3921 ;;; ----------- IDONIZED FUNCTIONS ------------
3923 ;;;###autoload
3924 (defun ido-switch-buffer ()
3925 "Switch to another buffer.
3926 The buffer is displayed according to `ido-default-buffer-method' -- the
3927 default is to show it in the same window, unless it is already visible
3928 in another frame.
3930 As you type in a string, all of the buffers matching the string are
3931 displayed if substring-matching is used \(default). Look at
3932 `ido-enable-prefix' and `ido-toggle-prefix'. When you have found the
3933 buffer you want, it can then be selected. As you type, most keys have
3934 their normal keybindings, except for the following: \\<ido-buffer-completion-map>
3936 RET Select the buffer at the front of the list of matches. If the
3937 list is empty, possibly prompt to create new buffer.
3939 \\[ido-select-text] Select the current prompt as the buffer.
3940 If no buffer is found, prompt for a new one.
3942 \\[ido-next-match] Put the first element at the end of the list.
3943 \\[ido-prev-match] Put the last element at the start of the list.
3944 \\[ido-complete] Complete a common suffix to the current string that
3945 matches all buffers. If there is only one match, select that buffer.
3946 If there is no common suffix, show a list of all matching buffers
3947 in a separate window.
3948 \\[ido-edit-input] Edit input string.
3949 \\[ido-fallback-command] Fallback to non-ido version of current command.
3950 \\[ido-toggle-regexp] Toggle regexp searching.
3951 \\[ido-toggle-prefix] Toggle between substring and prefix matching.
3952 \\[ido-toggle-case] Toggle case-sensitive searching of buffer names.
3953 \\[ido-completion-help] Show list of matching buffers in separate window.
3954 \\[ido-enter-find-file] Drop into `ido-find-file'.
3955 \\[ido-kill-buffer-at-head] Kill buffer at head of buffer list.
3956 \\[ido-toggle-ignore] Toggle ignoring buffers listed in `ido-ignore-buffers'."
3957 (interactive)
3958 (ido-buffer-internal ido-default-buffer-method))
3960 ;;;###autoload
3961 (defun ido-switch-buffer-other-window ()
3962 "Switch to another buffer and show it in another window.
3963 The buffer name is selected interactively by typing a substring.
3964 For details of keybindings, see `ido-switch-buffer'."
3965 (interactive)
3966 (ido-buffer-internal 'other-window 'switch-to-buffer-other-window))
3968 ;;;###autoload
3969 (defun ido-display-buffer ()
3970 "Display a buffer in another window but don't select it.
3971 The buffer name is selected interactively by typing a substring.
3972 For details of keybindings, see `ido-switch-buffer'."
3973 (interactive)
3974 (ido-buffer-internal 'display 'display-buffer nil nil nil 'ignore))
3976 ;;;###autoload
3977 (defun ido-kill-buffer ()
3978 "Kill a buffer.
3979 The buffer name is selected interactively by typing a substring.
3980 For details of keybindings, see `ido-switch-buffer'."
3981 (interactive)
3982 (ido-buffer-internal 'kill 'kill-buffer "Kill buffer: " (buffer-name (current-buffer)) nil 'ignore))
3984 ;;;###autoload
3985 (defun ido-insert-buffer ()
3986 "Insert contents of a buffer in current buffer after point.
3987 The buffer name is selected interactively by typing a substring.
3988 For details of keybindings, see `ido-switch-buffer'."
3989 (interactive)
3990 (ido-buffer-internal 'insert 'insert-buffer "Insert buffer: " nil nil 'ido-enter-insert-file))
3992 ;;;###autoload
3993 (defun ido-switch-buffer-other-frame ()
3994 "Switch to another buffer and show it in another frame.
3995 The buffer name is selected interactively by typing a substring.
3996 For details of keybindings, see `ido-switch-buffer'."
3997 (interactive)
3998 (if ido-mode
3999 (ido-buffer-internal 'other-frame)
4000 (call-interactively 'switch-to-buffer-other-frame)))
4002 ;;;###autoload
4003 (defun ido-find-file-in-dir (dir)
4004 "Switch to another file starting from DIR."
4005 (interactive "DDir: ")
4006 (setq dir (file-name-as-directory dir))
4007 (ido-file-internal ido-default-file-method nil dir nil nil nil 'ignore))
4009 ;;;###autoload
4010 (defun ido-find-file ()
4011 "Edit file with name obtained via minibuffer.
4012 The file is displayed according to `ido-default-file-method' -- the
4013 default is to show it in the same window, unless it is already
4014 visible in another frame.
4016 The file name is selected interactively by typing a substring. As you
4017 type in a string, all of the filenames matching the string are displayed
4018 if substring-matching is used \(default). Look at `ido-enable-prefix' and
4019 `ido-toggle-prefix'. When you have found the filename you want, it can
4020 then be selected. As you type, most keys have their normal keybindings,
4021 except for the following: \\<ido-file-completion-map>
4023 RET Select the file at the front of the list of matches. If the
4024 list is empty, possibly prompt to create new file.
4026 \\[ido-select-text] Select the current prompt as the buffer or file.
4027 If no buffer or file is found, prompt for a new one.
4029 \\[ido-next-match] Put the first element at the end of the list.
4030 \\[ido-prev-match] Put the last element at the start of the list.
4031 \\[ido-complete] Complete a common suffix to the current string that
4032 matches all files. If there is only one match, select that file.
4033 If there is no common suffix, show a list of all matching files
4034 in a separate window.
4035 \\[ido-edit-input] Edit input string (including directory).
4036 \\[ido-prev-work-directory] or \\[ido-next-work-directory] go to previous/next directory in work directory history.
4037 \\[ido-merge-work-directories] search for file in the work directory history.
4038 \\[ido-forget-work-directory] removes current directory from the work directory history.
4039 \\[ido-prev-work-file] or \\[ido-next-work-file] cycle through the work file history.
4040 \\[ido-wide-find-file-or-pop-dir] and \\[ido-wide-find-dir-or-delete-dir] prompts and uses find to locate files or directories.
4041 \\[ido-make-directory] prompts for a directory to create in current directory.
4042 \\[ido-fallback-command] Fallback to non-ido version of current command.
4043 \\[ido-toggle-regexp] Toggle regexp searching.
4044 \\[ido-toggle-prefix] Toggle between substring and prefix matching.
4045 \\[ido-toggle-case] Toggle case-sensitive searching of file names.
4046 \\[ido-toggle-vc] Toggle version control for this file.
4047 \\[ido-toggle-literal] Toggle literal reading of this file.
4048 \\[ido-completion-help] Show list of matching files in separate window.
4049 \\[ido-toggle-ignore] Toggle ignoring files listed in `ido-ignore-files'."
4051 (interactive)
4052 (ido-file-internal ido-default-file-method))
4054 ;;;###autoload
4055 (defun ido-find-file-other-window ()
4056 "Switch to another file and show it in another window.
4057 The file name is selected interactively by typing a substring.
4058 For details of keybindings, see `ido-find-file'."
4059 (interactive)
4060 (ido-file-internal 'other-window 'find-file-other-window))
4062 ;;;###autoload
4063 (defun ido-find-alternate-file ()
4064 "Switch to another file and show it in another window.
4065 The file name is selected interactively by typing a substring.
4066 For details of keybindings, see `ido-find-file'."
4067 (interactive)
4068 (ido-file-internal 'alt-file 'find-alternate-file nil "Find alternate file: "))
4070 ;;;###autoload
4071 (defun ido-find-file-read-only ()
4072 "Edit file read-only with name obtained via minibuffer.
4073 The file name is selected interactively by typing a substring.
4074 For details of keybindings, see `ido-find-file'."
4075 (interactive)
4076 (ido-file-internal 'read-only 'find-file-read-only nil "Find file read-only: "))
4078 ;;;###autoload
4079 (defun ido-find-file-read-only-other-window ()
4080 "Edit file read-only in other window with name obtained via minibuffer.
4081 The file name is selected interactively by typing a substring.
4082 For details of keybindings, see `ido-find-file'."
4083 (interactive)
4084 (ido-file-internal 'read-only 'find-file-read-only-other-window nil "Find file read-only other window: "))
4086 ;;;###autoload
4087 (defun ido-find-file-read-only-other-frame ()
4088 "Edit file read-only in other frame with name obtained via minibuffer.
4089 The file name is selected interactively by typing a substring.
4090 For details of keybindings, see `ido-find-file'."
4091 (interactive)
4092 (ido-file-internal 'read-only 'find-file-read-only-other-frame nil "Find file read-only other frame: "))
4094 ;;;###autoload
4095 (defun ido-display-file ()
4096 "Display a file in another window but don't select it.
4097 The file name is selected interactively by typing a substring.
4098 For details of keybindings, see `ido-find-file'."
4099 (interactive)
4100 (ido-file-internal 'display nil nil nil nil nil 'ignore))
4102 ;;;###autoload
4103 (defun ido-find-file-other-frame ()
4104 "Switch to another file and show it in another frame.
4105 The file name is selected interactively by typing a substring.
4106 For details of keybindings, see `ido-find-file'."
4107 (interactive)
4108 (ido-file-internal 'other-frame 'find-file-other-frame))
4110 ;;;###autoload
4111 (defun ido-write-file ()
4112 "Write current buffer to a file.
4113 The file name is selected interactively by typing a substring.
4114 For details of keybindings, see `ido-find-file'."
4115 (interactive)
4116 (let ((ido-process-ignore-lists t)
4117 (ido-work-directory-match-only nil)
4118 (ido-ignore-files (cons "[^/]\\'" ido-ignore-files))
4119 (ido-report-no-match nil)
4120 (ido-confirm-unique-completion t)
4121 (ido-auto-merge-work-directories-length -1))
4122 (ido-file-internal 'write 'write-file nil "Write file: " nil nil 'ignore)))
4124 ;;;###autoload
4125 (defun ido-insert-file ()
4126 "Insert contents of file in current buffer.
4127 The file name is selected interactively by typing a substring.
4128 For details of keybindings, see `ido-find-file'."
4129 (interactive)
4130 (ido-file-internal 'insert 'insert-file nil "Insert file: " nil nil 'ido-enter-insert-buffer))
4132 ;;;###autoload
4133 (defun ido-dired ()
4134 "Call `dired' the ido way.
4135 The directory is selected interactively by typing a substring.
4136 For details of keybindings, see `ido-find-file'."
4137 (interactive)
4138 (let ((ido-report-no-match nil)
4139 (ido-auto-merge-work-directories-length -1))
4140 (ido-file-internal 'dired 'dired nil "Dired: " 'dir)))
4142 (defun ido-list-directory ()
4143 "Call `list-directory' the ido way.
4144 The directory is selected interactively by typing a substring.
4145 For details of keybindings, see `ido-find-file'."
4146 (interactive)
4147 (let ((ido-report-no-match nil)
4148 (ido-auto-merge-work-directories-length -1))
4149 (ido-file-internal 'list-directory 'list-directory nil "List directory: " 'dir)))
4151 ;;; XEmacs hack for showing default buffer
4153 ;; The first time we enter the minibuffer, Emacs puts up the default
4154 ;; buffer to switch to, but XEmacs doesn't -- presumably there is a
4155 ;; subtle difference in the two versions of post-command-hook. The
4156 ;; default is shown for both whenever we delete all of our text
4157 ;; though, indicating its just a problem the first time we enter the
4158 ;; function. To solve this, we use another entry hook for emacs to
4159 ;; show the default the first time we enter the minibuffer.
4162 ;;; ICOMPLETE TYPE CODE
4164 (defun ido-initiate-auto-merge (buffer)
4165 (ido-trace "\n*merge timeout*" buffer)
4166 (setq ido-auto-merge-timer nil)
4167 (when (and (buffer-live-p buffer)
4168 (ido-active)
4169 (boundp 'ido-eoinput) ido-eoinput)
4170 (let ((contents (buffer-substring-no-properties (minibuffer-prompt-end) ido-eoinput)))
4171 (ido-trace "request merge")
4172 (setq ido-use-merged-list 'auto
4173 ido-text-init contents
4174 ido-rotate-temp t
4175 ido-exit 'refresh)
4176 (save-excursion
4177 (set-buffer buffer)
4178 (ido-tidy))
4179 (throw 'ido contents))))
4181 (defun ido-exhibit ()
4182 "Post command hook for `ido'."
4183 ;; Find matching files and display a list in the minibuffer.
4184 ;; Copied from `icomplete-exhibit' with two changes:
4185 ;; 1. It prints a default file name when there is no text yet entered.
4186 ;; 2. It calls my completion routine rather than the standard completion.
4188 (when (ido-active)
4189 (let ((contents (buffer-substring-no-properties (minibuffer-prompt-end) (point-max)))
4190 (buffer-undo-list t)
4191 try-single-dir-match
4192 refresh)
4194 (when ido-trace-enable
4195 (ido-trace "\nexhibit" this-command)
4196 (ido-trace "dir" ido-current-directory)
4197 (ido-trace "contents" contents)
4198 (ido-trace "list" ido-cur-list)
4199 (ido-trace "matches" ido-matches)
4200 (ido-trace "rescan" ido-rescan))
4202 (save-excursion
4203 (goto-char (point-max))
4204 ;; Register the end of input, so we know where the extra stuff (match-status info) begins:
4205 (unless (boundp 'ido-eoinput)
4206 ;; In case it got wiped out by major mode business:
4207 (make-local-variable 'ido-eoinput))
4208 (setq ido-eoinput (point))
4210 ;; Handle explicit directory changes
4211 (cond
4212 ((memq ido-cur-item '(buffer list))
4215 ((= (length contents) 0)
4218 ((= (length contents) 1)
4219 (cond
4220 ((and (ido-is-tramp-root) (string-equal contents "/"))
4221 (ido-set-current-directory ido-current-directory contents)
4222 (setq refresh t))
4223 ((and (ido-unc-hosts) (string-equal contents "/")
4224 (let ((ido-enable-tramp-completion nil))
4225 (ido-is-root-directory)))
4226 (ido-set-current-directory "//")
4227 (setq refresh t))
4230 ((and (string-match (if ido-enable-tramp-completion ".[:@]\\'" ".:\\'") contents)
4231 (ido-is-root-directory) ;; Ange-ftp or tramp
4232 (not (ido-local-file-exists-p contents)))
4233 (ido-set-current-directory ido-current-directory contents)
4234 (when (ido-is-slow-ftp-host)
4235 (setq ido-exit 'fallback)
4236 (exit-minibuffer))
4237 (setq refresh t))
4239 ((ido-final-slash contents) ;; xxx/
4240 (ido-trace "final slash" contents)
4241 (cond
4242 ((string-equal contents "~/")
4243 (ido-set-current-home)
4244 (setq refresh t))
4245 ((string-equal contents "../")
4246 (ido-up-directory t)
4247 (setq refresh t))
4248 ((string-equal contents "./")
4249 (setq refresh t))
4250 ((string-match "\\`~[-_a-zA-Z0-9]+[$]?/\\'" contents)
4251 (ido-trace "new home" contents)
4252 (ido-set-current-home contents)
4253 (setq refresh t))
4254 ((string-match "[$][A-Za-z0-9_]+/\\'" contents)
4255 (let ((exp (condition-case ()
4256 (expand-file-name
4257 (substitute-in-file-name (substring contents 0 -1))
4258 ido-current-directory)
4259 (error nil))))
4260 (ido-trace contents exp)
4261 (when (and exp (file-directory-p exp))
4262 (ido-set-current-directory (file-name-directory exp))
4263 (setq ido-text-init (file-name-nondirectory exp))
4264 (setq refresh t))))
4265 ((and (memq system-type '(windows-nt ms-dos))
4266 (string-equal (substring contents 1) ":/"))
4267 (ido-set-current-directory (file-name-directory contents))
4268 (setq refresh t))
4269 ((string-equal (substring contents -2 -1) "/")
4270 (ido-set-current-directory
4271 (if (memq system-type '(windows-nt ms-dos))
4272 (expand-file-name "/" ido-current-directory)
4273 "/"))
4274 (setq refresh t))
4275 ((and (or ido-directory-nonreadable ido-directory-too-big)
4276 (file-directory-p (concat ido-current-directory (file-name-directory contents))))
4277 (ido-set-current-directory
4278 (concat ido-current-directory (file-name-directory contents)))
4279 (setq refresh t))
4281 (ido-trace "try single dir")
4282 (setq try-single-dir-match t))))
4284 ((and (string-equal (substring contents -2 -1) "/")
4285 (not (string-match "[$]" contents)))
4286 (ido-set-current-directory
4287 (cond
4288 ((= (length contents) 2)
4289 "/")
4290 (ido-matches
4291 (concat ido-current-directory (ido-name (car ido-matches))))
4293 (concat ido-current-directory (substring contents 0 -1)))))
4294 (setq ido-text-init (substring contents -1))
4295 (setq refresh t))
4297 ((and (not ido-use-merged-list)
4298 (not (ido-final-slash contents))
4299 (eq ido-try-merged-list t)
4300 (numberp ido-auto-merge-work-directories-length)
4301 (> ido-auto-merge-work-directories-length 0)
4302 (= (length contents) ido-auto-merge-work-directories-length)
4303 (not (and ido-auto-merge-inhibit-characters-regexp
4304 (string-match ido-auto-merge-inhibit-characters-regexp contents)))
4305 (not (input-pending-p)))
4306 (setq ido-use-merged-list 'auto
4307 ido-text-init contents
4308 ido-rotate-temp t)
4309 (setq refresh t))
4311 (t nil))
4313 (when refresh
4314 (ido-trace "refresh on /" ido-text-init)
4315 (setq ido-exit 'refresh)
4316 (exit-minibuffer))
4318 ;; Update the list of matches
4319 (setq ido-text contents)
4320 (ido-set-matches)
4321 (ido-trace "new " ido-matches)
4323 (when (and ido-enter-matching-directory
4324 ido-matches
4325 (or (eq ido-enter-matching-directory 'first)
4326 (null (cdr ido-matches)))
4327 (ido-final-slash (ido-name (car ido-matches)))
4328 (or try-single-dir-match
4329 (eq ido-enter-matching-directory t)))
4330 (ido-trace "single match" (car ido-matches))
4331 (ido-set-current-directory
4332 (concat ido-current-directory (ido-name (car ido-matches))))
4333 (setq ido-exit 'refresh)
4334 (exit-minibuffer))
4336 (when (and (not ido-matches)
4337 (not ido-directory-nonreadable)
4338 (not ido-directory-too-big)
4339 ;; ido-rescan ?
4340 ido-process-ignore-lists
4341 ido-ignored-list)
4342 (let ((ido-process-ignore-lists nil)
4343 (ido-rotate ido-rotate)
4344 (ido-cur-list ido-ignored-list))
4345 (ido-trace "try all" ido-ignored-list)
4346 (ido-set-matches))
4347 (when ido-matches
4348 (ido-trace "found " ido-matches)
4349 (setq ido-rescan t)
4350 (setq ido-process-ignore-lists-inhibit t)
4351 (setq ido-text-init ido-text)
4352 (setq ido-exit 'refresh)
4353 (exit-minibuffer)))
4355 (when (and
4356 ido-rescan
4357 (not ido-matches)
4358 (memq ido-cur-item '(file dir))
4359 (not (ido-is-root-directory))
4360 (> (length contents) 1)
4361 (not (string-match "[$]" contents))
4362 (not ido-directory-nonreadable)
4363 (not ido-directory-too-big))
4364 (ido-trace "merge?")
4365 (if ido-use-merged-list
4366 (ido-undo-merge-work-directory contents nil)
4367 (when (and (eq ido-try-merged-list t)
4368 (numberp ido-auto-merge-work-directories-length)
4369 (= ido-auto-merge-work-directories-length 0)
4370 (not (and ido-auto-merge-inhibit-characters-regexp
4371 (string-match ido-auto-merge-inhibit-characters-regexp contents)))
4372 (not (input-pending-p)))
4373 (ido-trace "\n*start timer*")
4374 (setq ido-auto-merge-timer
4375 (run-with-timer ido-auto-merge-delay-time nil 'ido-initiate-auto-merge (current-buffer))))))
4377 (setq ido-rescan t)
4379 (if (and ido-use-merged-list
4380 ido-matches
4381 (not (string-equal (car (cdr (car ido-matches))) ido-current-directory)))
4382 (progn
4383 (ido-set-current-directory (car (cdr (car ido-matches))))
4384 (setq ido-use-merged-list t
4385 ido-exit 'keep
4386 ido-text-init ido-text)
4387 (exit-minibuffer)))
4389 ;; Insert the match-status information:
4390 (ido-set-common-completion)
4391 (let ((inf (ido-completions
4392 contents
4393 minibuffer-completion-table
4394 minibuffer-completion-predicate
4395 (not minibuffer-completion-confirm))))
4396 (ido-trace "inf" inf)
4397 (insert inf))
4398 ))))
4400 (defun ido-completions (name candidates predicate require-match)
4401 ;; Return the string that is displayed after the user's text.
4402 ;; Modified from `icomplete-completions'.
4404 (let* ((comps ido-matches)
4405 (ind (and (consp (car comps)) (> (length (cdr (car comps))) 1)
4406 ido-merged-indicator))
4407 first)
4409 (if (and ind ido-use-faces)
4410 (put-text-property 0 1 'face 'ido-indicator ind))
4412 (if (and ido-use-faces comps)
4413 (let* ((fn (ido-name (car comps)))
4414 (ln (length fn)))
4415 (setq first (format "%s" fn))
4416 (put-text-property 0 ln 'face
4417 (if (= (length comps) 1)
4418 (if ido-incomplete-regexp
4419 'ido-incomplete-regexp
4420 'ido-only-match)
4421 'ido-first-match)
4422 first)
4423 (if ind (setq first (concat first ind)))
4424 (setq comps (cons first (cdr comps)))))
4426 (cond ((null comps)
4427 (cond
4428 (ido-directory-nonreadable
4429 (or (nth 8 ido-decorations) " [Not readable]"))
4430 (ido-directory-too-big
4431 (or (nth 9 ido-decorations) " [Too big]"))
4432 (ido-report-no-match
4433 (nth 6 ido-decorations)) ;; [No match]
4434 (t "")))
4435 (ido-incomplete-regexp
4436 (concat " " (car comps)))
4437 ((null (cdr comps)) ;one match
4438 (concat (if (if (not ido-enable-regexp)
4439 (= (length (ido-name (car comps))) (length name))
4440 ;; We can't rely on the length of the input
4441 ;; for regexps, so explicitly check for a
4442 ;; complete match
4443 (string-match name (ido-name (car comps)))
4444 (string-equal (match-string 0 (ido-name (car comps)))
4445 (ido-name (car comps))))
4447 ;; when there is one match, show the matching file name in full
4448 (concat (nth 4 ido-decorations) ;; [ ... ]
4449 (ido-name (car comps))
4450 (nth 5 ido-decorations)))
4451 (if (not ido-use-faces) (nth 7 ido-decorations)))) ;; [Matched]
4452 (t ;multiple matches
4453 (let* ((items (if (> ido-max-prospects 0) (1+ ido-max-prospects) 999))
4454 (alternatives
4455 (apply
4456 #'concat
4457 (cdr (apply
4458 #'nconc
4459 (mapcar
4460 (lambda (com)
4461 (setq com (ido-name com))
4462 (setq items (1- items))
4463 (cond
4464 ((< items 0) ())
4465 ((= items 0) (list (nth 3 ido-decorations))) ; " | ..."
4467 (list (or ido-separator (nth 2 ido-decorations)) ; " | "
4468 (let ((str (substring com 0)))
4469 (if (and ido-use-faces
4470 (not (string= str first))
4471 (ido-final-slash str))
4472 (put-text-property 0 (length str) 'face 'ido-subdir str))
4473 str)))))
4474 comps))))))
4476 (concat
4477 ;; put in common completion item -- what you get by pressing tab
4478 (if (and (stringp ido-common-match-string)
4479 (> (length ido-common-match-string) (length name)))
4480 (concat (nth 4 ido-decorations) ;; [ ... ]
4481 (substring ido-common-match-string (length name))
4482 (nth 5 ido-decorations)))
4483 ;; list all alternatives
4484 (nth 0 ido-decorations) ;; { ... }
4485 alternatives
4486 (nth 1 ido-decorations)))))))
4488 (defun ido-minibuffer-setup ()
4489 "Minibuffer setup hook for `ido'."
4490 ;; Copied from `icomplete-minibuffer-setup-hook'.
4491 (when (ido-active)
4492 (add-hook 'pre-command-hook 'ido-tidy nil t)
4493 (add-hook 'post-command-hook 'ido-exhibit nil t)
4494 (setq cua-inhibit-cua-keys t)
4495 (when (featurep 'xemacs)
4496 (ido-exhibit)
4497 (goto-char (point-min)))
4498 (run-hooks 'ido-minibuffer-setup-hook)
4499 (when ido-initial-position
4500 (goto-char (+ (minibuffer-prompt-end) ido-initial-position))
4501 (setq ido-initial-position nil))))
4503 (defun ido-tidy ()
4504 "Pre command hook for `ido'."
4505 ;; Remove completions display, if any, prior to new user input.
4506 ;; Copied from `icomplete-tidy'."
4508 (when ido-auto-merge-timer
4509 (ido-trace "\n*cancel timer*" this-command)
4510 (cancel-timer ido-auto-merge-timer)
4511 (setq ido-auto-merge-timer nil))
4513 (if (ido-active)
4514 (if (and (boundp 'ido-eoinput)
4515 ido-eoinput)
4517 (if (> ido-eoinput (point-max))
4518 ;; Oops, got rug pulled out from under us - reinit:
4519 (setq ido-eoinput (point-max))
4520 (let ((buffer-undo-list t))
4521 (delete-region ido-eoinput (point-max))))
4523 ;; Reestablish the local variable 'cause minibuffer-setup is weird:
4524 (make-local-variable 'ido-eoinput)
4525 (setq ido-eoinput 1))))
4527 (defun ido-summary-buffers-to-end ()
4528 ;; Move the summaries to the end of the buffer list.
4529 ;; This is an example function which can be hooked on to
4530 ;; `ido-make-buffer-list-hook'. Any buffer matching the regexps
4531 ;; `Summary' or `output\*$'are put to the end of the list.
4532 (let ((summaries (delq nil (mapcar
4533 (lambda (x)
4534 (if (or
4535 (string-match "Summary" x)
4536 (string-match "output\\*\\'" x))
4538 ido-temp-list))))
4539 (ido-to-end summaries)))
4541 ;;; Helper functions for other programs
4543 (put 'dired-do-rename 'ido 'ignore)
4544 (put 'ibuffer-find-file 'ido 'find-file)
4545 (put 'dired-other-window 'ido 'dir)
4547 ;;;###autoload
4548 (defun ido-read-buffer (prompt &optional default require-match)
4549 "Ido replacement for the built-in `read-buffer'.
4550 Return the name of a buffer selected.
4551 PROMPT is the prompt to give to the user. DEFAULT if given is the default
4552 buffer to be selected, which will go to the front of the list.
4553 If REQUIRE-MATCH is non-nil, an existing buffer must be selected."
4554 (let* ((ido-current-directory nil)
4555 (ido-directory-nonreadable nil)
4556 (ido-directory-too-big nil)
4557 (ido-context-switch-command 'ignore)
4558 (buf (ido-read-internal 'buffer prompt 'ido-buffer-history default require-match)))
4559 (if (eq ido-exit 'fallback)
4560 (let ((read-buffer-function nil))
4561 (run-hook-with-args 'ido-before-fallback-functions 'read-buffer)
4562 (read-buffer prompt default require-match))
4563 buf)))
4565 ;;;###autoload
4566 (defun ido-read-file-name (prompt &optional dir default-filename mustmatch initial predicate)
4567 "Ido replacement for the built-in `read-file-name'.
4568 Read file name, prompting with PROMPT and completing in directory DIR.
4569 See `read-file-name' for additional parameters."
4570 (let (filename)
4571 (cond
4572 ((or (eq predicate 'file-directory-p)
4573 (eq (get this-command 'ido) 'dir)
4574 (memq this-command ido-read-file-name-as-directory-commands))
4575 (setq filename
4576 (ido-read-directory-name prompt dir default-filename mustmatch initial))
4577 (if (eq ido-exit 'fallback)
4578 (setq filename 'fallback)))
4579 ((and (not (eq (get this-command 'ido) 'ignore))
4580 (not (memq this-command ido-read-file-name-non-ido))
4581 (or (null predicate) (eq predicate 'file-exists-p)))
4582 (let* (ido-saved-vc-hb
4583 (ido-context-switch-command
4584 (if (eq (get this-command 'ido) 'find-file) nil 'ignore))
4585 (vc-handled-backends (and (boundp 'vc-handled-backends) vc-handled-backends))
4586 (minibuffer-completing-file-name t)
4587 (ido-current-directory (ido-expand-directory dir))
4588 (ido-directory-nonreadable (not (file-readable-p ido-current-directory)))
4589 (ido-directory-too-big (and (not ido-directory-nonreadable)
4590 (ido-directory-too-big-p ido-current-directory)))
4591 (ido-work-directory-index -1)
4592 (ido-show-dot-for-dired (and ido-show-dot-for-dired
4593 (not default-filename)))
4594 (ido-work-file-index -1)
4595 (ido-find-literal nil))
4596 (setq ido-exit nil)
4597 (setq filename
4598 (ido-read-internal 'file prompt 'ido-file-history default-filename mustmatch initial))
4599 (cond
4600 ((eq ido-exit 'fallback)
4601 (setq filename 'fallback))
4602 ((eq ido-exit 'dired)
4603 (setq filename ido-current-directory))
4604 (filename
4605 (setq filename
4606 (concat ido-current-directory filename))))))
4608 (setq filename 'fallback)))
4609 (if (eq filename 'fallback)
4610 (let ((read-file-name-function nil))
4611 (run-hook-with-args 'ido-before-fallback-functions 'read-file-name)
4612 (read-file-name prompt dir default-filename mustmatch initial predicate))
4613 filename)))
4615 ;;;###autoload
4616 (defun ido-read-directory-name (prompt &optional dir default-dirname mustmatch initial)
4617 "Ido replacement for the built-in `read-directory-name'.
4618 Read directory name, prompting with PROMPT and completing in directory DIR.
4619 See `read-directory-name' for additional parameters."
4620 (let* (filename
4621 (minibuffer-completing-file-name t)
4622 (ido-context-switch-command 'ignore)
4623 ido-saved-vc-hb
4624 (ido-current-directory (ido-expand-directory dir))
4625 (ido-directory-nonreadable (not (file-readable-p ido-current-directory)))
4626 (ido-directory-too-big (and (not ido-directory-nonreadable)
4627 (ido-directory-too-big-p ido-current-directory)))
4628 (ido-work-directory-index -1)
4629 (ido-work-file-index -1))
4630 (setq filename
4631 (ido-read-internal 'dir prompt 'ido-file-history default-dirname mustmatch initial))
4632 (if filename
4633 (if (and (stringp filename) (string-equal filename "."))
4634 ido-current-directory
4635 (concat ido-current-directory filename)))))
4637 ;;;###autoload
4638 (defun ido-completing-read (prompt choices &optional predicate require-match initial-input hist def)
4639 "Ido replacement for the built-in `completing-read'.
4640 Read a string in the minibuffer with ido-style completion.
4641 PROMPT is a string to prompt with; normally it ends in a colon and a space.
4642 CHOICES is a list of strings which are the possible completions.
4643 PREDICATE is currently ignored; it is included to be compatible
4644 with `completing-read'.
4645 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
4646 the input is (or completes to) an element of CHOICES or is null.
4647 If the input is null, `ido-completing-read' returns DEF, or an empty
4648 string if DEF is nil, regardless of the value of REQUIRE-MATCH.
4649 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
4650 with point positioned at the end.
4651 HIST, if non-nil, specifies a history list.
4652 DEF, if non-nil, is the default value."
4653 (let ((ido-current-directory nil)
4654 (ido-directory-nonreadable nil)
4655 (ido-directory-too-big nil)
4656 (ido-context-switch-command 'ignore)
4657 (ido-choice-list choices))
4658 (ido-read-internal 'list prompt hist def require-match initial-input)))
4661 ;; arch-tag: b63a3500-1735-41bd-8a01-05373f0864da
4662 ;;; ido.el ends here