Support long URLs in w32-shell-execute
[emacs.git] / lisp / ido.el
blob1f12fbfa9ee77ab6c9f969e10a00aa7a9fd7162e
1 ;;; ido.el --- interactively do things with buffers and files
3 ;; Copyright (C) 1996-2015 Free Software Foundation, Inc.
5 ;; Author: Kim F. Storm <storm@cua.dk>
6 ;; Based on: iswitchb by Stephen Eglen <stephen@cns.ed.ac.uk>
7 ;; Keywords: extensions convenience
9 ;; This file is part of GNU Emacs.
11 ;; GNU Emacs is free software: you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation, either version 3 of the License, or
14 ;; (at your option) any later version.
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 ;; GNU General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
25 ;;; Commentary:
27 ;; Ido - interactive do - switches between buffers and opens files and
28 ;; directories with a minimum of keystrokes. It is a superset of
29 ;; iswitchb, the interactive buffer switching package by Stephen Eglen.
31 ;; Interactive substring matching
32 ;; ------------------------------
34 ;; As you type in a substring, the list of buffers or files currently
35 ;; matching the substring are displayed as you type. The list is
36 ;; ordered so that the most recent buffers or files visited come at
37 ;; the start of the list.
39 ;; The buffer or file at the start of the list will be the one visited
40 ;; when you press RETURN. By typing more of the substring, the list is
41 ;; narrowed down so that gradually the buffer or file you want will be
42 ;; at the top of the list. Alternatively, you can use C-s and C-r (or
43 ;; the right and left arrow keys) to rotate buffer or file names in the
44 ;; list until the one you want is at the top of the list.
46 ;; Completion is also available so that you can see what is common to
47 ;; all of the matching buffers or files as you type.
49 ;; Example:
51 ;; If I have two buffers called "123456" and "123", with "123456" the
52 ;; most recent, when I use ido-switch-buffer, I first of all get
53 ;; presented with the list of all the buffers
55 ;; Buffer: {123456 | 123}
57 ;; If I then press 2:
58 ;; Buffer: 2[3]{123456 | 123}
60 ;; The list in {...} are the matching buffers, most recent first
61 ;; (buffers visible in the current frame are put at the end of the
62 ;; list by default). At any time I can select the item at the head of
63 ;; the list by pressing RET. I can also put the first element at the
64 ;; end of the list by pressing C-s or [right], or bring the last
65 ;; element to the head of the list by pressing C-r or [left].
67 ;; The item in [...] indicates what can be added to my input by
68 ;; pressing TAB. In this case, I will get "3" added to my input.
70 ;; So, I press TAB:
71 ;; Buffer: 23{123456 | 123}
73 ;; At this point, I still have two matching buffers.
74 ;; If I want the first buffer in the list, I simply press RET. If I
75 ;; wanted the second in the list, I could press C-s to move it to the
76 ;; top of the list and then RET to select it.
78 ;; However, if I type 4, I only have one match left:
79 ;; Buffer: 234[123456]
81 ;; Since there is only one matching buffer left, it is given in [] and
82 ;; it is shown in the `ido-only-match' face (ForestGreen). I can now
83 ;; press TAB or RET to go to that buffer.
85 ;; If I want to create a new buffer named "234", I press C-j instead of
86 ;; TAB or RET.
88 ;; If instead, I type "a":
89 ;; Buffer: 234a [No match]
90 ;; There are no matching buffers. If I press RET or TAB, I can be
91 ;; prompted to create a new buffer called "234a".
93 ;; Of course, where this function comes in really useful is when you
94 ;; can specify the buffer using only a few keystrokes. In the above
95 ;; example, the quickest way to get to the "123456" file would be
96 ;; just to type 4 and then RET (assuming there isn't any newer buffer
97 ;; with 4 in its name).
99 ;; Likewise, if you use C-x C-f (ido-find-file), the list of files and
100 ;; directories in the current directory is provided in the same
101 ;; fashion as the buffers above. The files and directories are
102 ;; normally sorted in alphabetical order, but the most recently
103 ;; visited directory is placed first to speed up navigating to
104 ;; directories that you have visited recently.
106 ;; In addition to scrolling through the list using [right] and [left],
107 ;; you can use [up] and [down] to quickly scroll the list to the next
108 ;; or previous subdirectory.
110 ;; To go down into a subdirectory, and continue the file selection on
111 ;; the files in that directory, simply move the directory to the head
112 ;; of the list and hit RET.
114 ;; To go up to the parent directory, delete any partial file name
115 ;; already specified (e.g. using [backspace]) and hit [backspace].
117 ;; To go to the root directory (on the current drive), enter two
118 ;; slashes. On MS-DOS or Windows, to select the root of another
119 ;; drive, enter X:/ where X is the drive letter. You can also visit
120 ;; files on other hosts using the ange-ftp notations `/host:' and
121 ;; `/user@host:'. See the variable `ido-slow-ftp-hosts' if you want
122 ;; to inhibit the ido substring matching for ftp access.
124 ;; If for some reason you cannot specify the proper file using
125 ;; ido-find-file, you can press C-f to enter the normal find-file.
126 ;; You can also press C-b to drop into ido-switch-buffer.
128 ;; See the doc string of ido-switch-buffer and ido-find-file for full
129 ;; keybindings and features.
130 ;; (describe-function 'ido-find-file)
132 ;; Hidden buffers and files
133 ;; ------------------------
135 ;; Normally, ido does not include hidden buffers (whose name starts
136 ;; with a space) and hidden files and directories (whose name starts
137 ;; with `.') in the list of possible completions. However, if the
138 ;; substring you enter does not match any of the visible buffers or
139 ;; files, ido will automatically look for completions among the hidden
140 ;; buffers or files.
142 ;; You can toggle display of the hidden buffers and files with C-a.
144 ;; Additional functionality
145 ;; ------------------------
147 ;; After C-x b, the buffer at the head of the list can be killed by
148 ;; pressing C-k. If the buffer needs saving, you will be queried
149 ;; before the buffer is killed.
151 ;; Likewise, after C-x C-f, you can delete (i.e. physically remove)
152 ;; the file at the head of the list with C-k. You will always be
153 ;; asked for confirmation before the file is deleted.
155 ;; If you enter C-x b to switch to a buffer visiting a given file, and
156 ;; you find that the file you are after is not in any buffer, you can
157 ;; press C-f to immediately drop into ido-find-file. And you can
158 ;; switch back to buffer selection with C-b.
160 ;; Prefix matching
161 ;; ---------------
163 ;; The standard way of completion with Unix-shells and Emacs is to insert a
164 ;; PREFIX and then hitting TAB (or another completion key). Cause of this
165 ;; behavior has become second nature to a lot of Emacs users, Ido offers in
166 ;; addition to the default substring-matching-method (look above) also the
167 ;; prefix-matching-method. The kind of matching is the only difference to
168 ;; the description of the substring-matching above.
170 ;; You can toggle prefix matching with C-p.
172 ;; Example:
174 ;; If you have again two Buffers "123456" and "123" then hitting "2" does
175 ;; not match because "2" is not a PREFIX in any of the buffer-names.
177 ;; Flexible matching
178 ;; -----------------
180 ;; If you set ido-enable-flex-matching, ido will do a more flexible
181 ;; matching (unless regexp matching is active) to find possible matches
182 ;; among the available buffer or file names if no matches are found using
183 ;; the normal prefix or substring matching.
185 ;; The flexible matching implies that any item which simply contains all
186 ;; of the entered characters in the specified sequence will match.
188 ;; Example:
190 ;; If you have four files "alpha", "beta", "gamma", and "delta",
191 ;; entering "aa" will match "alpha" and "gamma", while "ea" matches
192 ;; "beta" and "delta". If prefix matching is also active, "aa" only
193 ;; matches "alpha", while "ea" does not match any files.
195 ;; Regexp matching
196 ;; ---------------
198 ;; There is limited provision for regexp matching within ido,
199 ;; enabled through `ido-enable-regexp' (toggle with C-t).
200 ;; This allows you to type `[ch]$' for example and see all file names
201 ;; ending in `c' or `h'.
203 ;; Note: ido-style completion is inhibited when you enable regexp matching.
206 ;; Customization
207 ;; -------------
209 ;; Customize the Ido group to change the Ido functionality.
211 ;; To modify the keybindings, use `define-key' on
212 ;; `ido-common-completion-map' or one of the specialized keymaps:
213 ;; `ido-file-dir-completion-map', `ido-file-completion-map' or
214 ;; `ido-buffer-completion-map'.
216 ;; (with-eval-after-load 'ido
217 ;; (define-key ido-common-completion-map " " 'ido-next-match))
219 ;; Seeing all the matching buffers or files
220 ;; ----------------------------------------
222 ;; If you have many matching files, they may not all fit onto one
223 ;; line of the minibuffer. Normally, the minibuffer window will grow
224 ;; to show you more of the matching files (depending on the setting
225 ;; of the variables `resize-mini-windows' and `max-mini-window-height').
226 ;; If you want ido to behave differently from the default minibuffer
227 ;; resizing behavior, set the variable `ido-max-window-height'.
229 ;; Also, to improve the responsiveness of ido, the maximum number of
230 ;; matching items is limited to 12, but you can increase or removed
231 ;; this limit via the `ido-max-prospects' variable.
233 ;; To see a full list of all matching buffers in a separate buffer,
234 ;; hit ? or press TAB when there are no further completions to the
235 ;; substring. Repeated TAB presses will scroll you through this
236 ;; separate buffer.
238 ;; Changing the list of files
239 ;; --------------------------
241 ;; By default, the list of current files is most recent first,
242 ;; oldest last, with the exception that the files visible in the
243 ;; current frame are put at the end of the list. A hook exists to
244 ;; allow other functions to order the list. For example, if you add:
246 ;; (add-hook 'ido-make-buffer-list-hook 'ido-summary-buffers-to-end)
248 ;; then all files matching "Summary" are moved to the end of the
249 ;; list. (I find this handy for keeping the INBOX Summary and so on
250 ;; out of the way.) It also moves files matching "output\*$" to the
251 ;; end of the list (these are created by AUCTeX when compiling.)
252 ;; Other functions could be made available which alter the list of
253 ;; matching files (either deleting or rearranging elements.)
255 ;; Highlighting
256 ;; ------------
258 ;; The highlighting of matching items is controlled via ido-use-faces.
259 ;; The faces used are ido-first-match, ido-only-match and
260 ;; ido-subdir.
261 ;; Coloring of the matching item was suggested by
262 ;; Carsten Dominik (dominik@strw.leidenuniv.nl).
264 ;; Replacement for read-buffer and read-file-name
265 ;; ----------------------------------------------
267 ;; ido-read-buffer and ido-read-file-name have been written to be drop
268 ;; in replacements for the normal buffer and file name reading
269 ;; functions `read-buffer' and `read-file-name'.
271 ;; To use ido for all buffer and file selections in Emacs, customize the
272 ;; variable `ido-everywhere'.
274 ;; Using ido-like behavior in other Lisp packages
275 ;; -----------------------------------------------
277 ;; If you don't want to rely on the `ido-everywhere' functionality,
278 ;; ido-read-buffer, ido-read-file-name, and ido-read-directory-name
279 ;; can be used by other packages to read a buffer name, a file name,
280 ;; or a directory name in the Ido way.
282 ;;; Acknowledgments
284 ;; Infinite amounts of gratitude goes to Stephen Eglen <stephen@cns.ed.ac.uk>
285 ;; who wrote iswitch-buffer mode - from which I ripped off 99% of the code
286 ;; for ido-switch-buffer and found the inspiration for ido-find-file.
287 ;; The ido package would never have existed without his work.
289 ;; Also thanks to Klaus Berndl, Rohit Namjoshi, Robert Fenk, Alex
290 ;; Schroeder, Bill Benedetto, Stephen Eglen, and many others for bug
291 ;; fixes and improvements.
293 ;;; History
295 ;; Since I discovered Stephen Eglen's excellent iswitchb package, I just
296 ;; couldn't live without it, but once being addicted to switching buffers
297 ;; with a minimum of keystrokes, I soon found that opening files in the
298 ;; old-fashioned way was just too slow - so I decided to write a package
299 ;; which could open files with the same speed and ease as iswitchb could
300 ;; switch buffers.
302 ;; I originally wrote a separate ifindf.el package based on a copy of
303 ;; iswitchb.el, which did for opening files what iswitchb did for
304 ;; switching buffers. Along the way, I corrected a few errors in
305 ;; ifindf which could have found its way back into iswitchb, but since
306 ;; most of the functionality of the two package was practically
307 ;; identical, I decided that the proper thing to do was to merge my
308 ;; ifindf package back into iswitchb.
310 ;; This is basically what ido (interactively do) is all about; but I
311 ;; found it awkward to merge my changes into the "iswitchb-" namespace,
312 ;; so I invented a common "ido-" namespace for the merged packages.
314 ;; This version is based on ido.el version 1.57 released on
315 ;; gnu.emacs.sources adapted for Emacs 22.1 to use command remapping
316 ;; and optionally hooking the read-buffer and read-file-name functions.
318 ;; Prefix matching was added by Klaus Berndl <klaus.berndl@sdm.de> based on
319 ;; an idea of Yuji Minejima <ggb01164@nifty.ne.jp> and his mcomplete-package.
322 ;;; Code:
324 (defvar recentf-list)
325 (require 'seq)
327 ;;;; Options
329 ;; These are some things you might want to change.
331 (defun ido-fractionp (n)
332 "Return t if N is a fraction."
333 (and (numberp n) (> n 0.0) (<= n 1.0)))
335 (defgroup ido nil
336 "Switch between files using substrings."
337 :group 'extensions
338 :group 'convenience
339 :version "22.1"
340 :link '(emacs-commentary-link :tag "Commentary" "ido.el")
341 :link '(emacs-library-link :tag "Lisp File" "ido.el")
342 :link '(custom-manual "(ido) Top")
343 :link '(info-link "(ido) Customization"))
345 ;;;###autoload
346 (defcustom ido-mode nil
347 "Determines for which buffer/file Ido should be enabled.
348 The following values are possible:
349 - `buffer': Turn only on Ido buffer behavior (switching, killing,
350 displaying...)
351 - `file': Turn only on Ido file behavior (finding, writing, inserting...)
352 - `both': Turn on Ido buffer and file behavior.
353 - nil: Turn off any Ido switching.
355 Setting this variable directly does not take effect;
356 use either \\[customize] or the function `ido-mode'."
357 :set #'(lambda (_symbol value)
358 (ido-mode value))
359 :initialize 'custom-initialize-default
360 :require 'ido
361 :link '(emacs-commentary-link "ido.el")
362 :set-after '(ido-save-directory-list-file
363 ;; This will clear ido-unc-hosts-cache, so set it
364 ;; before loading history file.
365 ido-unc-hosts)
366 :type '(choice (const :tag "Turn on only buffer" buffer)
367 (const :tag "Turn on only file" file)
368 (const :tag "Turn on both buffer and file" both)
369 (const :tag "Switch off all" nil))
370 :group 'ido)
372 (defcustom ido-case-fold case-fold-search
373 "Non-nil if searching of buffer and file names should ignore case."
374 :type 'boolean
375 :group 'ido)
377 (defcustom ido-ignore-buffers
378 '("\\` ")
379 "List of regexps or functions matching buffer names to ignore.
380 For example, traditional behavior is not to list buffers whose names begin
381 with a space, for which the regexp is ‘\\\\=` ’. See the source file for
382 example functions that filter buffer names."
383 :type '(repeat (choice regexp function))
384 :group 'ido)
386 (defcustom ido-ignore-files
387 '("\\`CVS/" "\\`#" "\\`.#" "\\`\\.\\./" "\\`\\./")
388 "List of regexps or functions matching file names to ignore.
389 For example, traditional behavior is not to list files whose names begin
390 with a #, for which the regexp is ‘\\\\=`#’. See the source file for
391 example functions that filter filenames."
392 :type '(repeat (choice regexp function))
393 :group 'ido)
395 (defcustom ido-ignore-extensions t
396 "Non-nil means ignore files in `completion-ignored-extensions' list."
397 :type 'boolean
398 :group 'ido)
400 (defcustom ido-show-dot-for-dired nil
401 "Non-nil means to always put . as the first item in file name lists.
402 This allows the current directory to be opened immediately with `dired'."
403 :type 'boolean
404 :group 'ido)
406 (defcustom ido-file-extensions-order nil
407 "List of file extensions specifying preferred order of file selections.
408 Each element is either a string with `.' as the first char, an empty
409 string matching files without extension, or t which is the default order
410 for files with an unlisted file extension."
411 :type '(repeat (choice string
412 (const :tag "Default order" t)))
413 :group 'ido)
415 (defcustom ido-ignore-directories
416 '("\\`CVS/" "\\`\\.\\./" "\\`\\./")
417 "List of regexps or functions matching sub-directory names to ignore."
418 :type '(repeat (choice regexp function))
419 :group 'ido)
421 (defcustom ido-ignore-directories-merge nil
422 "List of regexps or functions matching directory names to ignore during merge.
423 Directory names matched by one of the regexps in this list are not inserted
424 in merged file and directory lists."
425 :type '(repeat (choice regexp function))
426 :group 'ido)
428 ;; Examples for setting the value of ido-ignore-buffers
429 ;;(defun ido-ignore-c-mode (name)
430 ;; "Ignore all c mode buffers -- example function for ido."
431 ;; (with-current-buffer name
432 ;; (derived-mode-p 'c-mode)))
434 ;;(setq ido-ignore-buffers '("\\` " ido-ignore-c-mode))
436 ;; Examples for setting the value of ido-ignore-files
437 ;;(setq ido-ignore-files '("\\` " "\\.c\\'" "\\.h\\'"))
439 (defcustom ido-default-file-method 'raise-frame
440 "How to visit a new file when using `ido-find-file'.
441 Possible values:
442 `selected-window' Show new file in selected window
443 `other-window' Show new file in another window (same frame)
444 `display' Display file in another window without selecting to it
445 `other-frame' Show new file in another frame
446 `maybe-frame' If a file is visible in another frame, prompt to ask if you
447 you want to see the file in the same window of the current
448 frame or in the other frame
449 `raise-frame' If a file is visible in another frame, raise that
450 frame; otherwise, visit the file in the same window"
451 :type '(choice (const :tag "Visit in selected window" selected-window)
452 (const :tag "Visit in other window" other-window)
453 (const :tag "Display (no select) in other window" display)
454 (const :tag "Visit in other frame" other-frame)
455 (const :tag "Ask to visit in other frame" maybe-frame)
456 (const :tag "Raise frame if already visited" raise-frame))
457 :group 'ido)
459 (defcustom ido-default-buffer-method 'raise-frame
460 "How to switch to new buffer when using `ido-switch-buffer'.
461 See `ido-default-file-method' for details."
462 :type '(choice (const :tag "Show in selected window" selected-window)
463 (const :tag "Show in other window" other-window)
464 (const :tag "Display (no select) in other window" display)
465 (const :tag "Show in other frame" other-frame)
466 (const :tag "Ask to show in other frame" maybe-frame)
467 (const :tag "Raise frame if already shown" raise-frame))
468 :group 'ido)
470 (defcustom ido-enable-flex-matching nil
471 "Non-nil means that Ido will do flexible string matching.
472 Flexible matching means that if the entered string does not
473 match any item, any item containing the entered characters
474 in the given sequence will match."
475 :type 'boolean
476 :group 'ido)
479 (defcustom ido-enable-regexp nil
480 "Non-nil means that Ido will do regexp matching.
481 Value can be toggled within Ido using `ido-toggle-regexp'."
482 :type 'boolean
483 :group 'ido)
485 (defcustom ido-enable-prefix nil
486 "Non-nil means only match if the entered text is a prefix of file name.
487 This behavior is like the standard Emacs completion.
488 If nil, match if the entered text is an arbitrary substring.
489 Value can be toggled within Ido using `ido-toggle-prefix'."
490 :type 'boolean
491 :group 'ido)
493 (defcustom ido-enable-dot-prefix nil
494 "Non-nil means to match leading dot as prefix.
495 I.e. hidden files and buffers will match only if you type a dot
496 as first char even if `ido-enable-prefix' is nil."
497 :type 'boolean
498 :group 'ido)
500 ;; See http://debbugs.gnu.org/2042 for more info.
501 (defcustom ido-buffer-disable-smart-matches t
502 "Non-nil means not to re-order matches for buffer switching.
503 By default, Ido arranges matches in the following order:
505 full-matches > suffix matches > prefix matches > remaining matches
507 which can get in the way for buffer switching."
508 :version "24.3"
509 :type 'boolean
510 :group 'ido)
512 (defcustom ido-confirm-unique-completion nil
513 "Non-nil means that even a unique completion must be confirmed.
514 This means that \\[ido-complete] must always be followed by \\[ido-exit-minibuffer]
515 even when there is only one unique completion."
516 :type 'boolean
517 :group 'ido)
519 (defcustom ido-cannot-complete-command 'ido-completion-help
520 "Command run when `ido-complete' can't complete any more.
521 The most useful values are `ido-completion-help', which pops up a
522 window with completion alternatives, or `ido-next-match' or
523 `ido-prev-match', which cycle the buffer list."
524 :type 'function
525 :group 'ido)
528 (defcustom ido-record-commands t
529 "Non-nil means that Ido will record commands in command history.
530 Note that the non-Ido equivalent command is recorded."
531 :type 'boolean
532 :group 'ido)
534 (defcustom ido-max-prospects 12
535 "Upper limit of the prospect list if non-zero.
536 Zero means no limit for the prospect list.
537 For a long list of prospects, building the full list for the
538 minibuffer can take a non-negligible amount of time; setting this
539 variable reduces that time."
540 :type 'integer
541 :group 'ido)
543 (defcustom ido-max-file-prompt-width 0.35
544 "Upper limit of the prompt string.
545 If value is an integer, it specifies the number of characters of
546 the string.
547 If value is a floating point number, it specifies a fraction of
548 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, 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 \\<ido-file-completion-map>
625 Use \\[ido-reread-directory] in prompt to refresh list.
626 If zero, FTP directories are not cached."
627 :type 'number
628 :group 'ido)
630 (defcustom ido-slow-ftp-hosts nil
631 "List of slow FTP hosts where Ido prompting should not be used.
632 If an FTP host is on this list, Ido automatically switches to the non-Ido
633 equivalent function, e.g. `find-file' rather than `ido-find-file'."
634 :type '(repeat string)
635 :group 'ido)
637 (defcustom ido-slow-ftp-host-regexps nil
638 "List of regexps matching slow FTP hosts (see `ido-slow-ftp-hosts')."
639 :type '(repeat regexp)
640 :group 'ido)
642 (defvar ido-unc-hosts-cache t
643 "Cached value from the function `ido-unc-hosts'.")
645 (defcustom ido-unc-hosts nil
646 "List of known UNC host names to complete after initial //.
647 If value is a function, that function is called to search network for
648 hosts on first use of UNC path."
649 :type '(choice (repeat :tag "List of UNC host names" string)
650 (function-item :tag "Use `NET VIEW'"
651 :value ido-unc-hosts-net-view)
652 (function :tag "Your own function"))
653 :set #'(lambda (symbol value)
654 (set symbol value)
655 (setq ido-unc-hosts-cache t))
656 :group 'ido)
658 (defcustom ido-downcase-unc-hosts t
659 "Non-nil if UNC host names should be downcased."
660 :type 'boolean
661 :group 'ido)
663 (defcustom ido-ignore-unc-host-regexps nil
664 "List of regexps matching UNC hosts to ignore.
665 Case is ignored if `ido-downcase-unc-hosts' is set."
666 :type '(repeat regexp)
667 :group 'ido)
669 (defcustom ido-cache-unc-host-shares-time 8.0
670 "Maximum time to cache shares of an UNC host (in hours).
671 \\<ido-file-completion-map>
672 Use \\[ido-reread-directory] in prompt to refresh list.
673 If zero, UNC host shares are not cached."
674 :type 'number
675 :group 'ido)
677 (defcustom ido-max-work-file-list 10
678 "Maximum number of names of recently opened files to record.
679 This is the list of the file names (sans directory) which have most recently
680 been opened. See `ido-work-file-list' and `ido-save-directory-list-file'."
681 :type 'integer
682 :group 'ido)
684 (defcustom ido-work-directory-match-only t
685 "Non-nil means to skip non-matching directories in the directory history.
686 When some text is already entered at the `ido-find-file' prompt, using
687 \\[ido-prev-work-directory] or \\[ido-next-work-directory] will skip directories
688 without any matching entries."
689 :type 'boolean
690 :group 'ido)
692 (defcustom ido-auto-merge-work-directories-length 0
693 "Automatically switch to merged work directories during file name input.
694 The value is number of characters to type before switching to merged mode.
695 If zero, the switch happens when no matches are found in the current directory.
696 Automatic merging is disabled if the value is negative."
697 :type 'integer
698 :group 'ido)
700 (defcustom ido-auto-merge-delay-time 0.70
701 "Delay in seconds to wait for more input before doing auto merge."
702 :type 'number
703 :group 'ido)
705 (defcustom ido-auto-merge-inhibit-characters-regexp "[][*?~]"
706 "Regexp matching characters which should inhibit automatic merging.
707 When a (partial) file name matches this regexp, merging is inhibited."
708 :type 'regexp
709 :group 'ido)
711 (defcustom ido-merged-indicator "^"
712 "The string appended to first choice if it has multiple directory choices."
713 :type 'string
714 :group 'ido)
716 (defcustom ido-max-dir-file-cache 100
717 "Maximum number of working directories to be cached.
718 \\<ido-file-completion-map>
719 This is the size of the cache of `file-name-all-completions' results.
720 Each cache entry is time stamped with the modification time of the
721 directory. Some systems, like Windows, have unreliable directory
722 modification times, so you may choose to disable caching on such
723 systems, or explicitly refresh the cache contents using the command
724 `ido-reread-directory' command (\\[ido-reread-directory]) in the minibuffer.
725 See also `ido-dir-file-cache' and `ido-save-directory-list-file'."
726 :type 'integer
727 :group 'ido)
729 (defcustom ido-max-directory-size nil
730 "Maximum size (in bytes) for directories to use Ido completion.
731 \\<ido-completion-map>
732 If you enter a directory with a size larger than this size, Ido will
733 not provide the normal completion. To show the completions, use \\[ido-toggle-ignore]."
734 :type '(choice (const :tag "No limit" nil)
735 (integer :tag "Size in bytes" 30000))
736 :group 'ido)
738 (defcustom ido-rotate-file-list-default nil
739 "Non-nil means that Ido will always rotate file list to get default in front."
740 :type 'boolean
741 :group 'ido)
743 (defcustom ido-enter-matching-directory 'only
744 "Additional methods to enter sub-directory of first/only matching item.
745 If value is 'first, enter first matching sub-directory when typing a slash.
746 If value is 'only, typing a slash only enters the sub-directory if it is
747 the only matching item.
748 If value is t, automatically enter a sub-directory when it is the only
749 matching item, even without typing a slash."
750 :type '(choice (const :tag "Never" nil)
751 (const :tag "Slash enters first directory" first)
752 (const :tag "Slash enters first and only directory" only)
753 (other :tag "Always enter unique directory" t))
754 :group 'ido)
756 (defcustom ido-create-new-buffer 'prompt
757 "Specify whether a new buffer is created if no buffer matches substring.
758 Choices are 'always to create new buffers unconditionally, 'prompt to
759 ask user whether to create buffer, or 'never to never create new buffer."
760 :type '(choice (const always)
761 (const prompt)
762 (const never))
763 :group 'ido)
765 (defcustom ido-setup-hook nil
766 "Hook run after the Ido variables and keymap have been setup.
767 The dynamic variable `ido-cur-item' contains the current type of item that
768 is read by Ido; possible values are file, dir, buffer, and list.
769 Additional keys can be defined in `ido-completion-map'."
770 :type 'hook
771 :group 'ido)
773 (defcustom ido-separator nil
774 "String used by Ido to separate the alternatives in the minibuffer."
775 :type '(choice string (const nil))
776 :group 'ido)
777 (make-obsolete-variable 'ido-separator
778 "set 3rd element of `ido-decorations' instead." nil)
780 (defcustom ido-decorations '("{" "}" " | " " | ..." "[" "]" " [No match]"
781 " [Matched]" " [Not readable]" " [Too big]" " [Confirm]")
782 "List of strings used by Ido to display the alternatives in the minibuffer.
783 There are between 11 and 13 elements in this list:
784 1st and 2nd elements are used as brackets around the prospect list,
785 3rd element is the separator between prospects (ignored if
786 `ido-separator' is set),
787 4th element is the string inserted at the end of a truncated list of prospects,
788 5th and 6th elements are used as brackets around the common match string which
789 can be completed using TAB,
790 7th element is the string displayed when there are no matches, and
791 8th element is displayed if there is a single match (and faces are not used),
792 9th element is displayed when the current directory is non-readable,
793 10th element is displayed when directory exceeds `ido-max-directory-size',
794 11th element is displayed to confirm creating new file or buffer.
795 12th and 13th elements (if present) are used as brackets around the sole
796 remaining completion. If absent, elements 5 and 6 are used instead."
797 :type '(repeat string)
798 :group 'ido)
800 (defcustom ido-use-virtual-buffers nil
801 "If non-nil, refer to past (\"virtual\") buffers as well as existing ones.
802 The options are:
803 nil: Do not use virtual buffers.
804 t: Always use virtual buffers.
805 auto: Use virtual buffers if the current input matches no existing buffer.
807 Essentially it works as follows: Say you are visiting a file and
808 the buffer gets cleaned up by midnight.el. Later, you want to
809 switch to that buffer, but find it's no longer open. With virtual
810 buffers enabled, the buffer name stays in the buffer list (using
811 the `ido-virtual' face, and always at the end), and if you select
812 it, it opens the file back up again. This allows you to think
813 less about whether recently opened files are still open or not.
814 Most of the time you can quit Emacs, restart, and then switch to
815 a file buffer that was previously open as if it still were.
817 This feature relies upon the `recentf' package, which will be
818 enabled if this variable is configured to a non-nil value."
819 :version "24.1"
820 :type '(choice (const :tag "Always" t)
821 (const :tag "Automatic" auto)
822 (const :tag "Never" nil))
823 :group 'ido)
825 (defcustom ido-use-faces t
826 "Non-nil means use Ido faces to highlighting first match, only match and
827 subdirs in the alternatives."
828 :type 'boolean
829 :group 'ido)
831 (defface ido-first-match '((t :weight bold))
832 "Face used by Ido for highlighting first match."
833 :group 'ido)
835 (defface ido-only-match '((((class color))
836 :foreground "ForestGreen")
837 (t :slant italic))
838 "Face used by Ido for highlighting only match."
839 :group 'ido)
841 (defface ido-subdir '((((min-colors 88) (class color))
842 :foreground "red1")
843 (((class color))
844 :foreground "red")
845 (t :underline t))
846 "Face used by Ido for highlighting subdirs in the alternatives."
847 :group 'ido)
849 (defface ido-virtual '((t :inherit font-lock-builtin-face))
850 "Face used by Ido for matching virtual buffer names."
851 :version "24.1"
852 :group 'ido)
854 (defface ido-indicator '((((min-colors 88) (class color))
855 :foreground "yellow1" :background "red1" :width condensed)
856 (((class color))
857 :foreground "yellow" :background "red" :width condensed)
858 (t :inverse-video t))
859 "Face used by Ido for highlighting its indicators."
860 :group 'ido)
862 (defface ido-incomplete-regexp
863 '((t :inherit font-lock-warning-face))
864 "Ido face for indicating incomplete regexps."
865 :group 'ido)
867 (defcustom ido-make-file-list-hook nil
868 "List of functions to run when the list of matching files is created.
869 Each function on the list may modify the dynamically bound variable
870 `ido-temp-list' which contains the current list of matching files."
871 :type 'hook
872 :group 'ido)
874 (defcustom ido-make-dir-list-hook nil
875 "List of functions to run when the list of matching directories is created.
876 Each function on the list may modify the dynamically bound variable
877 `ido-temp-list' which contains the current list of matching directories."
878 :type 'hook
879 :group 'ido)
881 (defcustom ido-make-buffer-list-hook nil
882 "List of functions to run when the list of matching buffers is created.
883 Each function on the list may modify the dynamically bound variable
884 `ido-temp-list' which contains the current list of matching buffer names."
885 :type 'hook
886 :group 'ido)
888 (defcustom ido-rewrite-file-prompt-functions nil
889 "List of functions to run when the find-file prompt is created.
890 Each function on the list may modify the following dynamically bound
891 variables:
892 dirname - the (abbreviated) directory name
893 to be modified by the hook functions
894 max-width - the max width of the resulting dirname; nil means no limit
895 prompt - the basic prompt (e.g. \"Find File: \")
896 literal - the string shown if doing \"literal\" find; set to nil to omit
897 vc-off - the string shown if version control is inhibited; set to nil to omit
898 prefix - either nil or a fixed prefix for the dirname
900 The following variables are available, but should not be changed:
901 `ido-current-directory' - the unabbreviated directory name
902 item - equals `file' or `dir' depending on the current mode."
903 :type 'hook
904 :group 'ido)
906 (defvar ido-rewrite-file-prompt-rules nil
907 "Alist of rewriting rules for directory names in Ido prompts.
908 A list of elements of the form (FROM . TO) or (FROM . FUNC), each
909 meaning to rewrite the directory name if matched by FROM by either
910 substituting the matched string by TO or calling the function FUNC
911 with the current directory name as its only argument and using the
912 return value as the new directory name. In addition, each FUNC may
913 also modify the dynamic variables described for the variable
914 `ido-rewrite-file-prompt-functions'.")
916 (defcustom ido-completion-buffer "*Ido Completions*"
917 "Name of completion buffer used by Ido.
918 Set to nil to disable completion buffers popping up."
919 :type 'string
920 :group 'ido)
922 (defcustom ido-completion-buffer-all-completions nil
923 "Non-nil means to show all completions in completion buffer.
924 Otherwise, only the current list of matches is shown."
925 :type 'boolean
926 :group 'ido)
928 (defcustom ido-all-frames 'visible
929 "Argument to pass to `walk-windows' when Ido is finding buffers.
930 See documentation of `walk-windows' for useful values."
931 :type '(choice (const :tag "Selected frame only" nil)
932 (const :tag "All existing frames" t)
933 (const :tag "All visible frames" visible)
934 (const :tag "All frames on this terminal" 0))
935 :group 'ido)
937 (defcustom ido-minibuffer-setup-hook nil
938 "Ido-specific customization of minibuffer setup.
940 This hook is run during minibuffer setup if Ido is active.
941 It is intended for use in customizing Ido for interoperation
942 with other packages. For instance:
944 (add-hook 'ido-minibuffer-setup-hook
945 (lambda () (setq-local max-mini-window-height 3)))
947 will constrain Emacs to a maximum minibuffer height of 3 lines when
948 Ido is running. Copied from `icomplete-minibuffer-setup-hook'."
949 :type 'hook
950 :group 'ido)
952 (defcustom ido-save-directory-list-file
953 (locate-user-emacs-file "ido.last" ".ido.last")
954 "File in which the Ido state is saved between invocations.
955 Variables stored are: `ido-last-directory-list', `ido-work-directory-list',
956 `ido-work-file-list', and `ido-dir-file-cache'.
957 Must be set before enabling Ido mode."
958 :version "24.4" ; added locate-user-emacs-file
959 :type 'string
960 :group 'ido)
962 (defcustom ido-read-file-name-as-directory-commands '()
963 "List of commands which use `read-file-name' to read a directory name.
964 When `ido-everywhere' is non-nil, the commands in this list will read
965 the directory using `ido-read-directory-name'."
966 :type '(repeat symbol)
967 :group 'ido)
969 (defcustom ido-read-file-name-non-ido '()
970 "List of commands which shall not read file names the Ido way.
971 When `ido-everywhere' is non-nil, the commands in this list will read
972 the file name using normal `read-file-name' style."
973 :type '(repeat symbol)
974 :group 'ido)
976 (defcustom ido-before-fallback-functions '()
977 "List of functions to call before calling a fallback command.
978 The fallback command is passed as an argument to the functions."
979 :type 'hook
980 :group 'ido)
982 ;;;; Keymaps
984 (defvar ido-common-completion-map
985 (let ((map (make-sparse-keymap)))
986 (set-keymap-parent map minibuffer-local-map)
987 (define-key map "\C-a" 'ido-toggle-ignore)
988 (define-key map "\C-c" 'ido-toggle-case)
989 (define-key map "\C-e" 'ido-edit-input)
990 (define-key map "\t" 'ido-complete)
991 (define-key map " " 'ido-complete-space)
992 (define-key map "\C-j" 'ido-select-text)
993 (define-key map "\C-m" 'ido-exit-minibuffer)
994 (define-key map "\C-p" 'ido-toggle-prefix)
995 (define-key map "\C-r" 'ido-prev-match)
996 (define-key map "\C-s" 'ido-next-match)
997 (define-key map [?\C-.] 'ido-next-match)
998 (define-key map [?\C-,] 'ido-prev-match)
999 (define-key map "\C-t" 'ido-toggle-regexp)
1000 (define-key map "\C-z" 'ido-undo-merge-work-directory)
1001 (define-key map [(control ?\s)] 'ido-restrict-to-matches)
1002 (define-key map [(meta ?\s)] 'ido-take-first-match)
1003 (define-key map [(control ?@)] 'ido-restrict-to-matches)
1004 (define-key map [right] 'ido-next-match)
1005 (define-key map [left] 'ido-prev-match)
1006 (define-key map "?" 'ido-completion-help)
1007 (define-key map "\C-b" 'ido-magic-backward-char)
1008 (define-key map "\C-f" 'ido-magic-forward-char)
1009 (define-key map "\C-d" 'ido-magic-delete-char)
1010 map)
1011 "Keymap for all Ido commands.")
1013 (defvar ido-file-dir-completion-map
1014 (let ((map (make-sparse-keymap)))
1015 (set-keymap-parent map ido-common-completion-map)
1016 (define-key map "\C-x\C-b" 'ido-enter-switch-buffer)
1017 (define-key map "\C-x\C-f" 'ido-fallback-command)
1018 (define-key map "\C-x\C-d" 'ido-enter-dired)
1019 (define-key map [down] 'ido-next-match-dir)
1020 (define-key map [up] 'ido-prev-match-dir)
1021 (define-key map [(meta up)] 'ido-prev-work-directory)
1022 (define-key map [(meta down)] 'ido-next-work-directory)
1023 (define-key map [backspace] 'ido-delete-backward-updir)
1024 (define-key map "\d" 'ido-delete-backward-updir)
1025 (define-key map [remap delete-backward-char] 'ido-delete-backward-updir) ; BS
1026 (define-key map [remap backward-kill-word] 'ido-delete-backward-word-updir) ; M-DEL
1027 (define-key map [(control backspace)] 'ido-up-directory)
1028 (define-key map "\C-l" 'ido-reread-directory)
1029 (define-key map [(meta ?d)] 'ido-wide-find-dir-or-delete-dir)
1030 (define-key map [(meta ?b)] 'ido-push-dir)
1031 (define-key map [(meta ?v)] 'ido-push-dir-first)
1032 (define-key map [(meta ?f)] 'ido-wide-find-file-or-pop-dir)
1033 (define-key map [(meta ?k)] 'ido-forget-work-directory)
1034 (define-key map [(meta ?m)] 'ido-make-directory)
1035 (define-key map [(meta ?n)] 'ido-next-work-directory)
1036 (define-key map [(meta ?o)] 'ido-prev-work-file)
1037 (define-key map [(meta control ?o)] 'ido-next-work-file)
1038 (define-key map [(meta ?p)] 'ido-prev-work-directory)
1039 (define-key map [(meta ?s)] 'ido-merge-work-directories)
1040 map)
1041 "Keymap for Ido file and directory commands.")
1043 (defvar ido-file-completion-map
1044 (let ((map (make-sparse-keymap)))
1045 (set-keymap-parent map ido-file-dir-completion-map)
1046 (define-key map "\C-k" 'ido-delete-file-at-head)
1047 (define-key map "\C-o" 'ido-copy-current-word)
1048 (define-key map "\C-w" 'ido-copy-current-file-name)
1049 (define-key map [(meta ?l)] 'ido-toggle-literal)
1050 map)
1051 "Keymap for Ido file commands.")
1053 (defvar ido-buffer-completion-map
1054 (let ((map (make-sparse-keymap)))
1055 (set-keymap-parent map ido-common-completion-map)
1056 (define-key map "\C-x\C-f" 'ido-enter-find-file)
1057 (define-key map "\C-x\C-b" 'ido-fallback-command)
1058 (define-key map "\C-k" 'ido-kill-buffer-at-head)
1059 (define-key map [?\C-\S-b] 'ido-bury-buffer-at-head)
1060 (define-key map "\C-o" 'ido-toggle-virtual-buffers)
1061 map)
1062 "Keymap for Ido buffer commands.")
1064 ;;;; Persistent variables
1066 (defvar ido-file-history nil
1067 "History of files selected using `ido-find-file'.")
1069 (defvar ido-buffer-history nil
1070 "History of buffers selected using `ido-switch-buffer'.")
1072 (defvar ido-last-directory-list nil
1073 "List of last selected directory names.
1074 See `ido-enable-last-directory-history' for details.")
1076 (defvar ido-work-directory-list nil
1077 "List of actual working directory names.
1078 The current directory is inserted at the front of this list whenever a
1079 file is opened with `ido-find-file' and family.")
1081 (defvar ido-work-file-list nil
1082 "List of actual work file names.
1083 Opening a file with `ido-find-file' and similar functions
1084 inserts the current file name (relative to its containing directory)
1085 at the front of this list.")
1087 (defvar ido-dir-file-cache nil
1088 "List of `file-name-all-completions' results.
1089 Each element in the list is of the form (DIR (MTIME) FILE...).")
1091 (defvar ido-ignore-item-temp-list nil
1092 "List of items to ignore in current Ido invocation.
1093 Intended to be let-bound by functions which call Ido repeatedly.
1094 Should never be set permanently.")
1096 ;;;; Temporary storage
1098 (defvar ido-completion-map nil
1099 "Currently active keymap for Ido commands.")
1101 (defvar ido-eoinput 1
1102 "Point where minibuffer input ends and completion info begins.
1103 Copied from `icomplete-eoinput'.")
1104 (make-variable-buffer-local 'ido-eoinput)
1106 (defvar ido-common-match-string nil
1107 "Stores the string that is common to all matching files.")
1109 (defvar ido-rescan nil
1110 "Non-nil means we need to regenerate the list of matching items.")
1112 (defvar ido-rotate nil
1113 "Non-nil means we are rotating list of matches.")
1115 (defvar ido-text nil
1116 "Stores the user's string as it is typed in.")
1118 (defvar ido-text-init nil
1119 "The initial string for the user's string it is typed in.")
1121 (defvar ido-input-stack nil
1122 "Stores the user's strings when user hits M-b/M-f.")
1124 (defvar ido-matches nil
1125 "List of files currently matching `ido-text'.")
1127 (defvar ido-report-no-match t
1128 "Report \"[No Match]\" when no completions matches `ido-text'.")
1130 (defvar ido-exit nil
1131 "Flag to monitor how `ido-find-file' exits.
1132 If equal to `takeprompt', we use the prompt as the file name to be
1133 selected.")
1135 (defvar ido-current-directory nil
1136 "Current directory for `ido-find-file'.")
1138 (defvar ido-auto-merge-timer nil
1139 "Delay timer for auto merge.")
1141 (defvar ido-use-mycompletion-depth 0
1142 "Non-nil means use Ido completion feedback.
1143 Is set by Ido functions to the current `minibuffer-depth',
1144 so that it doesn't interfere with other minibuffer usage.")
1146 (defvar ido-incomplete-regexp nil
1147 "Non-nil if an incomplete regexp is entered.")
1149 (defvar ido-initial-position nil
1150 "Non-nil means to explicitly cursor on entry to minibuffer.
1151 Value is an integer which is number of chars to right of prompt.")
1153 (defvar ido-virtual-buffers nil
1154 "List of virtual buffers, that is, past visited files.
1155 This is a copy of `recentf-list', pared down and with faces applied.
1156 Only used if `ido-use-virtual-buffers' is non-nil.")
1158 ;;;; Variables with dynamic bindings.
1160 ;; These are declared here to keep the byte compiler quiet.
1162 ;; Stores the current ido item type ('file, 'dir, 'buffer, or 'list).
1163 (defvar ido-cur-item)
1165 ;; Stores the current default item.
1166 (defvar ido-default-item)
1168 ;; Stores the current list of items that will be searched through.
1169 ;; The list is ordered, so that the most interesting item comes first,
1170 ;; although by default, the files visible in the current frame are put
1171 ;; at the end of the list. Created by `ido-make-item-list'.
1172 (defvar ido-cur-list)
1174 ;; Stores the choice list for ido-completing-read
1175 (defvar ido-choice-list)
1177 ;; Stores the list of items which are ignored when building
1178 ;; `ido-cur-list'. It is in no specific order.
1179 (defvar ido-ignored-list)
1181 ;; Remember if current directory is non-readable (so we cannot do completion).
1182 (defvar ido-directory-nonreadable)
1184 ;; Remember if current directory is 'huge' (so we don't want to do completion).
1185 (defvar ido-directory-too-big)
1187 ;; Keep current item list if non-nil.
1188 (defvar ido-keep-item-list)
1190 ;; Process ido-ignore-* lists.
1191 (defvar ido-process-ignore-lists)
1193 ;; Don't process ido-ignore- lists once.
1194 (defvar ido-process-ignore-lists-inhibit)
1196 ;; Is ido using virtual buffers?
1197 (defvar ido-enable-virtual-buffers)
1199 ;; Buffer from which ido was entered.
1200 (defvar ido-entry-buffer)
1202 ;; Non-nil if matching file must be selected.
1203 (defvar ido-require-match)
1205 ;; Non-nil if we should add [confirm] to prompt
1206 (defvar ido-show-confirm-message)
1208 ;; Stores a temporary version of the file list being created.
1209 (defvar ido-temp-list)
1211 ;; Non-nil if default list element should be rotated into place.
1212 (defvar ido-rotate-temp)
1214 ;; Stores current index in ido-work-directory-list.
1215 (defvar ido-work-directory-index)
1217 ;; Stores current index in ido-work-file-list.
1218 (defvar ido-work-file-index)
1220 ;; Set when merged work directory list is in use.
1221 (defvar ido-use-merged-list)
1223 ;; Set when merged work directory list not yet built.
1224 (defvar ido-try-merged-list)
1226 ;; Saved state prior to last work directory merge.
1227 ;; Value is a list (ido-text dir cur-list ignored-list matches).
1228 (defvar ido-pre-merge-state)
1230 ;; Original value of vc-handled-backends for use in ido-toggle-vc.
1231 (defvar ido-saved-vc-hb)
1233 ;; Stores temporary state of literal find file.
1234 (defvar ido-find-literal)
1236 ;; Set to 'ignore to inhibit switching between find-file/switch-buffer.
1237 (defvar ido-context-switch-command)
1239 ;; Dynamically bound in ido-read-internal.
1240 (defvar ido-completing-read)
1242 ;;; FUNCTIONS
1244 (defun ido-active (&optional merge)
1245 (if merge
1246 ido-use-merged-list
1247 (and (boundp 'ido-completing-read)
1248 (or (featurep 'xemacs)
1249 (= ido-use-mycompletion-depth (minibuffer-depth))))))
1251 (defvar ido-trace-enable nil)
1253 (defun ido-trace (p &optional s retval)
1254 (if ido-trace-enable
1255 (let ((b (get-buffer-create " *IDO Trace*"))
1256 (deactivate-mark deactivate-mark))
1257 (save-excursion
1258 (save-restriction
1259 (set-buffer b)
1260 (insert p ": " (if (stringp s) s (format "%S" s)) "\n")))))
1261 retval)
1263 (defun ido-toggle-trace (arg)
1264 (interactive "P")
1265 (setq ido-trace-enable (or arg (not ido-trace-enable)))
1266 (if ido-trace-enable
1267 (message "IDO trace on"))
1268 (let ((b (get-buffer " *IDO Trace*")))
1269 (if b
1270 (if ido-trace-enable
1271 (kill-buffer b)
1272 (pop-to-buffer b t t)
1273 (setq truncate-lines t)))))
1275 (defun ido-local-file-exists-p (file)
1276 "Tell if FILE exists locally."
1277 (let (file-name-handler-alist)
1278 (file-exists-p file)))
1280 (defun ido-unc-hosts (&optional query)
1281 "Return list of UNC host names."
1282 (let ((hosts
1283 (cond
1284 ((listp ido-unc-hosts)
1285 ido-unc-hosts) ;; static list or nil
1286 ((listp ido-unc-hosts-cache)
1287 ido-unc-hosts-cache) ;; result of net search
1288 ((and query (fboundp ido-unc-hosts))
1289 (message (propertize "Searching for UNC hosts..." 'face 'highlight))
1290 (setq ido-unc-hosts-cache (funcall ido-unc-hosts))
1291 (message nil)
1292 ido-unc-hosts-cache)
1293 (query
1294 (setq ido-unc-hosts-cache nil))
1295 (t (fboundp ido-unc-hosts)))))
1296 (when query
1297 (let ((case-fold-search ido-downcase-unc-hosts)
1298 res host re-list re)
1299 (while hosts
1300 (setq host (car hosts)
1301 hosts (cdr hosts)
1302 re-list (and ido-process-ignore-lists
1303 ido-ignore-unc-host-regexps))
1304 (while re-list
1305 (setq re (car re-list)
1306 re-list (cdr re-list))
1307 (if (string-match re host)
1308 (setq re-list nil
1309 host nil)))
1310 (when host
1311 (when ido-downcase-unc-hosts
1312 (setq host (downcase host)))
1313 (setq res (cons host res))))
1314 (setq hosts (sort res #'string<))))
1315 hosts))
1317 (defun ido-unc-hosts-net-view ()
1318 "Query network for list of UNC host names using `NET VIEW'."
1319 (let (hosts)
1320 (with-temp-buffer
1321 (shell-command "net view" t)
1322 (goto-char (point-min))
1323 (while (re-search-forward "^\\\\\\\\\\([[:graph:]]+\\)" nil t)
1324 (setq hosts (cons (match-string 1) hosts))))
1325 hosts))
1327 (defun ido-is-tramp-root (&optional dir)
1328 (and ido-enable-tramp-completion
1329 (string-match "\\`/[^/]+[@:]\\'"
1330 (or dir ido-current-directory))))
1332 (defun ido-is-unc-root (&optional dir)
1333 (and (ido-unc-hosts)
1334 (string-equal "//"
1335 (or dir ido-current-directory))))
1337 (defun ido-is-unc-host (&optional dir)
1338 (and (ido-unc-hosts)
1339 (string-match "\\`//[^/]+/\\'"
1340 (or dir ido-current-directory))))
1342 (defun ido-is-root-directory (&optional dir)
1343 (setq dir (or dir ido-current-directory))
1345 (string-equal "/" dir)
1346 (and (memq system-type '(windows-nt ms-dos))
1347 (string-match "\\`[a-zA-Z]:[/\\]\\'" dir))
1348 (if ido-enable-tramp-completion
1349 (ido-is-tramp-root dir)
1350 (string-match "\\`/[^:/][^:/]+:\\'" dir))))
1352 (defun ido-is-ftp-directory (&optional dir)
1353 (string-match
1354 (if ido-enable-tramp-completion
1355 ;; like tramp-file-name-regexp-unified, but doesn't match single drive letters
1356 "\\`/[^/:][^/:]+:"
1357 "\\`/[^/:][^/:]+:/")
1358 (or dir ido-current-directory)))
1360 (defun ido-is-slow-ftp-host (&optional dir)
1361 (and (or ido-slow-ftp-hosts ido-slow-ftp-host-regexps)
1362 (setq dir (or dir ido-current-directory))
1363 ;; (featurep 'ange-ftp)
1364 ;; (ange-ftp-ftp-name dir)
1365 (string-match
1366 (if ido-enable-tramp-completion
1367 "\\`/\\([^/]+[@:]\\)*\\([^@/:][^@/:]+\\):"
1368 "\\`/\\([^/:]*@\\)?\\([^@/:][^@/:]+\\):/")
1369 dir)
1370 (let ((host (substring dir (match-beginning 2) (match-end 2))))
1371 (or (member host ido-slow-ftp-hosts)
1372 (let ((re ido-slow-ftp-host-regexps))
1373 (while (and re (not (string-match (car re) host)))
1374 (setq re (cdr re)))
1375 re)))))
1377 (defun ido-time-stamp (&optional time)
1378 ;; Time is a floating point number (fractions of 1 hour)
1379 (/ (float-time time) 3600))
1381 (defun ido-cache-ftp-valid (&optional time)
1382 (and (numberp ido-cache-ftp-work-directory-time)
1383 (> ido-cache-ftp-work-directory-time 0)
1384 (or (not time)
1385 (< (- (ido-time-stamp) time) ido-cache-ftp-work-directory-time))))
1387 (defun ido-cache-unc-valid (&optional time)
1388 (and (numberp ido-cache-unc-host-shares-time)
1389 (> ido-cache-unc-host-shares-time 0)
1390 (or (not time)
1391 (< (- (ido-time-stamp) time) ido-cache-unc-host-shares-time))))
1393 (defun ido-may-cache-directory (&optional dir)
1394 (setq dir (or dir ido-current-directory))
1395 (cond
1396 ((and (ido-is-root-directory dir)
1397 (or ido-enable-tramp-completion
1398 (memq system-type '(windows-nt ms-dos))))
1399 nil)
1400 ((ido-is-unc-host dir)
1401 (ido-cache-unc-valid))
1402 ((ido-is-ftp-directory dir)
1403 (ido-cache-ftp-valid))
1404 ((ido-directory-too-big-p dir)
1405 nil)
1406 (t t)))
1408 (defun ido-pp (list &optional sep)
1409 (let ((print-level nil) (eval-expression-print-level nil)
1410 (print-length nil) (eval-expression-print-length nil))
1411 (insert "\n;; ----- " (symbol-name list) " -----\n(\n ")
1412 (setq list (symbol-value list))
1413 (while list
1414 (let* ((elt (car list))
1415 (s (if (consp elt) (car elt) elt)))
1416 (if (and (stringp s) (= (length s) 0))
1417 (setq s nil))
1418 (if s
1419 (prin1 elt (current-buffer)))
1420 (if (and (setq list (cdr list)) s)
1421 (insert (or sep "\n ")))))
1422 (insert "\n)\n")))
1424 (defun ido-save-history ()
1425 "Save Ido history and cache information between sessions."
1426 (interactive)
1427 (when (and ido-last-directory-list ido-save-directory-list-file)
1428 (let ((buf (get-buffer-create " *ido session*"))
1429 (version-control 'never))
1430 (unwind-protect
1431 (with-current-buffer buf
1432 (erase-buffer)
1433 (insert ";;; -*- coding: utf-8 -*-\n")
1434 (setq buffer-file-coding-system 'utf-8)
1435 (ido-pp 'ido-last-directory-list)
1436 (ido-pp 'ido-work-directory-list)
1437 (ido-pp 'ido-work-file-list)
1438 (ido-pp 'ido-dir-file-cache "\n\n ")
1439 (if (listp ido-unc-hosts-cache)
1440 (ido-pp 'ido-unc-hosts-cache)
1441 (insert "\n;; ----- ido-unc-hosts-cache -----\nt\n"))
1442 (write-file ido-save-directory-list-file nil))
1443 (kill-buffer buf)))))
1445 (defun ido-load-history (&optional arg)
1446 "Load Ido history and cache information from previous session.
1447 With prefix argument, reload history unconditionally."
1448 (interactive "P")
1449 (if (or arg (and ido-save-directory-list-file (not ido-last-directory-list)))
1450 (let ((file (expand-file-name ido-save-directory-list-file))
1451 buf)
1452 (when (file-readable-p file)
1453 (setq buf (get-buffer-create " *ido session*"))
1454 (unwind-protect
1455 (with-current-buffer buf
1456 (erase-buffer)
1457 (insert-file-contents file)
1458 (condition-case nil
1459 (setq ido-last-directory-list (read (current-buffer))
1460 ido-work-directory-list (read (current-buffer))
1461 ido-work-file-list (read (current-buffer))
1462 ido-dir-file-cache (read (current-buffer))
1463 ido-unc-hosts-cache (read (current-buffer)))
1464 (error nil)))
1465 (kill-buffer buf)))))
1466 (ido-wash-history))
1468 (defun ido-wash-history ()
1469 "Clean-up Ido history and cache information.
1470 Removes badly formatted data and ignored directories."
1471 (interactive)
1472 ;; Check format of each of our lists, discard bogus elements
1473 (setq ido-last-directory-list
1474 (and (listp ido-last-directory-list)
1475 (let ((l ido-last-directory-list) r)
1476 (while l
1477 (if (and (consp (car l))
1478 (stringp (car (car l)))
1479 (stringp (cdr (car l))))
1480 (setq r (cons (car l) r)))
1481 (setq l (cdr l)))
1482 (nreverse r))))
1483 (setq ido-work-directory-list
1484 (and (listp ido-work-directory-list)
1485 (let ((l ido-work-directory-list) r)
1486 (while l
1487 (if (and (stringp (car l))
1488 (or ido-record-ftp-work-directories
1489 (not (ido-is-ftp-directory (car l)))))
1490 (setq r (cons (car l) r)))
1491 (setq l (cdr l)))
1492 (nreverse r))))
1493 (setq ido-work-file-list
1494 (and (listp ido-work-file-list)
1495 (let ((l ido-work-file-list) r)
1496 (while l
1497 (if (stringp (car l))
1498 (setq r (cons (car l) r)))
1499 (setq l (cdr l)))
1500 (nreverse r))))
1501 (setq ido-dir-file-cache
1502 (and (listp ido-dir-file-cache)
1503 (let ((l ido-dir-file-cache) r)
1504 (while l
1505 (if (and (listp (car l))
1506 (> (length (car l)) 2)
1507 (let ((dir (car (car l)))
1508 (time (car (cdr (car l))))
1509 (files (cdr (cdr (car l)))))
1510 (and
1511 (stringp dir)
1512 (consp time)
1513 (cond
1514 ((integerp (car time))
1515 (and (/= (car time) 0)
1516 (integerp (car (cdr time)))
1517 (/= (car (cdr time)) 0)
1518 (ido-may-cache-directory dir)))
1519 ((eq (car time) 'ftp)
1520 (and (numberp (cdr time))
1521 (ido-is-ftp-directory dir)
1522 (ido-cache-ftp-valid (cdr time))))
1523 ((eq (car time) 'unc)
1524 (and (numberp (cdr time))
1525 (ido-is-unc-host dir)
1526 (ido-cache-unc-valid (cdr time))))
1527 (t nil))
1528 (let ((s files) (ok t))
1529 (while s
1530 (if (stringp (car s))
1531 (setq s (cdr s))
1532 (setq s nil ok nil)))
1533 ok))))
1534 (setq r (cons (car l) r)))
1535 (setq l (cdr l)))
1536 (nreverse r))))
1538 ;; Remove ignored directories from work directory list
1539 ;; according to ido-work-directory-list-ignore-regexps
1540 (if ido-work-directory-list
1541 (let ((dirs (reverse ido-work-directory-list)))
1542 (setq ido-work-directory-list nil)
1543 (while dirs
1544 (ido-record-work-directory (car dirs))
1545 (setq dirs (cdr dirs)))))
1546 ;; Get rid of text properties
1547 (let ((l ido-last-directory-list) e)
1548 (while l
1549 (setq e (car l) l (cdr l))
1550 (set-text-properties 0 (length (car e)) nil (car e))
1551 (set-text-properties 0 (length (cdr e)) nil (cdr e))))
1552 (let ((l ido-work-directory-list) e)
1553 (while l
1554 (setq e (car l) l (cdr l))
1555 (set-text-properties 0 (length e) nil e)))
1556 (let ((l ido-work-file-list) e)
1557 (while l
1558 (setq e (car l) l (cdr l))
1559 (set-text-properties 0 (length e) nil e)))
1560 (let ((l ido-dir-file-cache) e d)
1561 (while l
1562 (setq e (car l) l (cdr l))
1563 (if (listp e)
1564 (while e
1565 (setq d (car e) e (cdr e))
1566 (if (not (consp d))
1567 (set-text-properties 0 (length d) nil d)))))))
1570 (defun ido-kill-emacs-hook ()
1571 ;; ido kill emacs hook
1572 (ido-save-history))
1574 (defun ido-common-initialization ()
1575 (add-hook 'minibuffer-setup-hook 'ido-minibuffer-setup)
1576 (add-hook 'choose-completion-string-functions 'ido-choose-completion-string))
1578 (define-minor-mode ido-everywhere
1579 "Toggle use of Ido for all buffer/file reading.
1580 With a prefix argument ARG, enable this feature if ARG is
1581 positive, and disable it otherwise. If called from Lisp,
1582 enable the mode if ARG is omitted or nil."
1583 :global t
1584 :group 'ido
1585 (when (get 'ido-everywhere 'file)
1586 (setq read-file-name-function (car (get 'ido-everywhere 'file)))
1587 (put 'ido-everywhere 'file nil))
1588 (when (get 'ido-everywhere 'buffer)
1589 (setq read-buffer-function (car (get 'ido-everywhere 'buffer)))
1590 (put 'ido-everywhere 'buffer nil))
1591 (when ido-everywhere
1592 (when (memq ido-mode '(both file))
1593 (put 'ido-everywhere 'file (cons read-file-name-function nil))
1594 (setq read-file-name-function #'ido-read-file-name))
1595 (when (memq ido-mode '(both buffer))
1596 (put 'ido-everywhere 'buffer (cons read-buffer-function nil))
1597 (setq read-buffer-function #'ido-read-buffer))))
1599 (defvar ido-minor-mode-map-entry nil)
1601 ;;;###autoload
1602 (defun ido-mode (&optional arg)
1603 "Toggle Ido mode on or off.
1604 With ARG, turn Ido mode on if arg is positive, off otherwise.
1605 Turning on Ido mode will remap (via a minor-mode keymap) the default
1606 keybindings for the `find-file' and `switch-to-buffer' families of
1607 commands to the Ido versions of these functions.
1608 However, if ARG arg equals 'files, remap only commands for files, or
1609 if it equals 'buffers, remap only commands for buffer switching.
1610 This function also adds a hook to the minibuffer."
1611 (interactive "P")
1612 (setq ido-mode
1613 (cond
1614 ((null arg) (if ido-mode nil 'both))
1615 ((eq arg t) 'both)
1616 ((eq arg 'files) 'file)
1617 ((eq arg 'buffers) 'buffer)
1618 ((memq arg '(file buffer both)) arg)
1619 ((> (prefix-numeric-value arg) 0) 'both)
1620 (t nil)))
1622 (ido-everywhere (if ido-everywhere 1 -1))
1624 (when ido-mode
1625 (ido-common-initialization)
1626 (ido-load-history)
1628 (add-hook 'kill-emacs-hook 'ido-kill-emacs-hook)
1630 (let ((map (make-sparse-keymap)))
1631 (when (memq ido-mode '(file both))
1632 (define-key map [remap find-file] 'ido-find-file)
1633 (define-key map [remap find-file-read-only] 'ido-find-file-read-only)
1634 (define-key map [remap find-alternate-file] 'ido-find-alternate-file)
1635 (define-key map [remap write-file] 'ido-write-file)
1636 (define-key map [remap insert-file] 'ido-insert-file)
1637 (define-key map [remap list-directory] 'ido-list-directory)
1638 (define-key map [remap dired] 'ido-dired)
1639 (define-key map [remap find-file-other-window]
1640 'ido-find-file-other-window)
1641 (define-key map [remap find-file-read-only-other-window]
1642 'ido-find-file-read-only-other-window)
1643 (define-key map [remap find-file-other-frame]
1644 'ido-find-file-other-frame)
1645 (define-key map [remap find-file-read-only-other-frame]
1646 'ido-find-file-read-only-other-frame))
1648 (when (memq ido-mode '(buffer both))
1649 (define-key map [remap switch-to-buffer] 'ido-switch-buffer)
1650 (define-key map [remap switch-to-buffer-other-window]
1651 'ido-switch-buffer-other-window)
1652 (define-key map [remap switch-to-buffer-other-frame]
1653 'ido-switch-buffer-other-frame)
1654 (define-key map [remap insert-buffer] 'ido-insert-buffer)
1655 (define-key map [remap kill-buffer] 'ido-kill-buffer)
1656 (define-key map [remap display-buffer] 'ido-display-buffer))
1658 (if ido-minor-mode-map-entry
1659 (setcdr ido-minor-mode-map-entry map)
1660 (setq ido-minor-mode-map-entry (cons 'ido-mode map))
1661 (add-to-list 'minor-mode-map-alist ido-minor-mode-map-entry))))
1663 (when (called-interactively-p 'any)
1664 (message "Ido mode %s" (if ido-mode "enabled" "disabled"))))
1667 ;;; IDO KEYMAP
1669 (defalias 'ido-init-completion-maps 'ignore "")
1670 (make-obsolete 'ido-init-completion-maps "it does nothing." "25.1")
1672 (defun ido-setup-completion-map ()
1673 "Set up the completion keymap used by Ido.
1675 Create a keymap, bind `ido-completion-map' to it, and depending
1676 on what is being completed (`ido-cur-item') set its parent keymap
1677 to one of:
1679 `ido-common-completion-map'
1680 `ido-file-dir-completion-map'
1681 `ido-file-completion-map'
1682 `ido-buffer-completion-map'
1684 If option `ido-context-switch-command' is non-nil or `viper-mode'
1685 is enabled then some keybindings are changed in the keymap."
1686 ;; generated every time so that it can inherit new functions.
1687 (let ((map (make-sparse-keymap))
1688 (viper-p (if (boundp 'viper-mode) viper-mode)))
1689 (when viper-p
1690 (define-key map [remap viper-intercept-ESC-key] 'ignore))
1691 (pcase ido-cur-item
1692 ((or `file `dir)
1693 (when ido-context-switch-command
1694 (define-key map "\C-x\C-b" ido-context-switch-command)
1695 (define-key map "\C-x\C-d" 'ignore))
1696 (when viper-p
1697 (define-key map [remap viper-backward-char]
1698 'ido-delete-backward-updir)
1699 (define-key map [remap viper-del-backward-char-in-insert]
1700 'ido-delete-backward-updir)
1701 (define-key map [remap viper-delete-backward-word]
1702 'ido-delete-backward-word-updir))
1703 (set-keymap-parent map
1704 (if (eq ido-cur-item 'file)
1705 ido-file-completion-map
1706 ido-file-dir-completion-map)))
1707 (`buffer
1708 (when ido-context-switch-command
1709 (define-key map "\C-x\C-f" ido-context-switch-command))
1710 (set-keymap-parent map ido-buffer-completion-map))
1712 (set-keymap-parent map ido-common-completion-map)))
1713 (setq ido-completion-map map)))
1715 (defun ido-final-slash (dir &optional fix-it)
1716 ;; return DIR if DIR has final slash.
1717 ;; else if FIX-IT is non-nil, return DIR/
1718 ;; else return nil.
1719 (setq dir (ido-name dir))
1720 (cond
1721 ((string-match "/\\'" dir) dir)
1722 ((ido-is-tramp-root dir) dir)
1723 (fix-it (concat dir "/"))
1724 (t nil)))
1726 (defun ido-no-final-slash (s)
1727 ;; Remove optional final slash from string S
1728 (let ((l (1- (length s))))
1729 (if (and (> l 0) (eq (aref s l) ?/))
1730 (substring s 0 l)
1731 s)))
1733 (defun ido-nonreadable-directory-p (dir)
1734 ;; Return t if dir is a directory, but not readable
1735 ;; Do not check for non-readable directories via tramp, as this causes a premature
1736 ;; connect on incomplete tramp paths (after entering just method:).
1737 (let ((ido-enable-tramp-completion nil))
1738 (and (ido-final-slash dir)
1739 (not (ido-is-unc-host dir))
1740 (file-directory-p dir)
1741 (not (file-readable-p dir)))))
1743 (defun ido-directory-too-big-p (dir)
1744 ;; Return t if dir is a directory, but too big to show
1745 ;; Do not check for non-readable directories via tramp, as this causes a premature
1746 ;; connect on incomplete tramp paths (after entering just method:).
1747 (let ((ido-enable-tramp-completion nil))
1748 (and (numberp ido-max-directory-size)
1749 (ido-final-slash dir)
1750 (not (ido-is-unc-host dir))
1751 (file-directory-p dir)
1752 (> (nth 7 (file-attributes (file-truename dir))) ido-max-directory-size))))
1754 (defun ido-set-current-directory (dir &optional subdir no-merge)
1755 ;; Set ido's current directory to DIR or DIR/SUBDIR
1756 (unless (and ido-enable-tramp-completion
1757 (string-match "\\`/[^/]*@\\'" dir))
1758 (setq dir (ido-final-slash dir t)))
1759 (setq ido-use-merged-list nil
1760 ido-try-merged-list (not no-merge))
1761 (when subdir
1762 (setq dir (concat dir subdir))
1763 (unless (and ido-enable-tramp-completion
1764 (string-match "\\`/[^/]*@\\'" dir))
1765 (setq dir (ido-final-slash dir t))))
1766 (and ido-completion-buffer
1767 (get-buffer ido-completion-buffer)
1768 (kill-buffer ido-completion-buffer))
1769 (cond
1770 ((equal dir ido-current-directory)
1771 nil)
1772 ((ido-is-unc-root dir)
1773 (ido-trace "unc" dir)
1774 (setq ido-current-directory dir)
1775 (setq ido-directory-nonreadable nil)
1776 (setq ido-directory-too-big nil)
1779 (ido-trace "cd" dir)
1780 (setq ido-current-directory dir)
1781 (and ido-completion-buffer
1782 (get-buffer ido-completion-buffer)
1783 (kill-buffer ido-completion-buffer))
1784 (setq ido-directory-nonreadable (ido-nonreadable-directory-p dir))
1785 (setq ido-directory-too-big (and (not ido-directory-nonreadable)
1786 (ido-directory-too-big-p dir)))
1787 t)))
1789 (defun ido-set-current-home (&optional dir)
1790 ;; Set ido's current directory to user's home directory
1791 (ido-set-current-directory (expand-file-name (or dir "~/"))))
1793 (defun ido-record-command (command arg)
1794 "Add (COMMAND ARG) to `command-history' if `ido-record-commands' is non-nil."
1795 (if ido-record-commands ; FIXME: use `when' instead of `if'?
1796 (let ((cmd (list command arg)))
1797 (if (or (not command-history) ; FIXME: ditto
1798 (not (equal cmd (car command-history))))
1799 (setq command-history (cons cmd command-history))))))
1801 (defun ido-make-prompt (item prompt)
1802 ;; Make the prompt for ido-read-internal
1803 (cond
1804 ((and (memq item '(file dir)) ido-current-directory)
1805 (let ((dirname (abbreviate-file-name ido-current-directory))
1806 (max-width (if (and ido-max-file-prompt-width (floatp ido-max-file-prompt-width))
1807 (floor (* (frame-width) ido-max-file-prompt-width))
1808 ido-max-file-prompt-width))
1809 (literal (and (boundp 'ido-find-literal) ido-find-literal "(literal) "))
1810 (vc-off (and ido-saved-vc-hb (not vc-handled-backends) "[-VC] "))
1811 (prefix nil)
1812 (rule ido-rewrite-file-prompt-rules))
1813 (let ((case-fold-search nil))
1814 (while rule
1815 (if (and (consp (car rule))
1816 (string-match (car (car rule)) dirname))
1817 (setq dirname
1818 (if (stringp (cdr (car rule)))
1819 (replace-match (cdr (car rule)) t nil dirname)
1820 (funcall (cdr (car rule)) dirname))))
1821 (setq rule (cdr rule))))
1822 (run-hooks 'ido-rewrite-file-prompt-functions)
1823 (concat prompt
1824 ; (if ido-process-ignore-lists "" "&")
1825 (or literal "")
1826 (or vc-off "")
1827 (or prefix "")
1828 (let ((l (length dirname)))
1829 (if (and max-width (> max-width 0) (> l max-width))
1830 (let* ((s (substring dirname (- max-width)))
1831 (i (string-match "/" s)))
1832 (concat "..." (if i (substring s i) s)))
1833 dirname)))))
1834 (t prompt)))
1836 ;; Here is very briefly how ido-find-file works:
1838 ;; (ido-find-file)
1839 ;; (ido-file-internal method)
1840 ;; set ido-current-directory
1841 ;; (ido-read-internal 'file ...)
1842 ;; (while ...
1843 ;; (ido-make-item-list ...)
1844 ;; (ido-set-matches)
1845 ;; (completing-read ... ido-text-init ...)
1847 ;; ... here user is allowed to type characters and commands
1848 ;; a command may set ido-exit and call (exit-minibuffer)
1849 ;; to make ido-read-internal do advanced tasks (or return)
1851 ;; ... ido-tidy and ido-exhibit are pre- and post-hooks
1852 ;; which are run before and after each user command.
1854 ;; return value from completing-read is stored in ido-final-text
1855 ;; - ido-exit may cause further actions to be taken:
1856 ;; 'refresh - repeat loop (make-item-list, set-matches)
1857 ;; 'edit - edit the prompt string, then repeat loop
1858 ;; 'keep - repeat loop but don't (re)make-item-list
1859 ;; 'updir - go up one directory, repeat loop
1860 ;; else set ido-selected based on ido-final-text,
1861 ;; optionally update ido-current-directory and repeat loop, or
1862 ;; exit with the return value of ido-selected (file name)
1863 ;; selected file name is returned from ido-read-internal,
1864 ;; ido-exit and method determines what action is taken
1865 ;; e.g. the file name may be ignored or joined with ido-current-directory, and
1866 ;; the relevant function is called (find-file, write-file, etc).
1868 (defun ido-read-internal (item prompt hist &optional default require-match initial)
1869 "Perform the `ido-read-buffer' and `ido-read-file-name' functions.
1870 Return the name of a buffer or file selected.
1871 PROMPT is the prompt to give to the user.
1872 DEFAULT if given is the default item to start with.
1873 If REQUIRE-MATCH is non-nil, an existing file must be selected.
1874 If INITIAL is non-nil, it specifies the initial input string."
1875 (let
1876 ((ido-cur-item item)
1877 (ido-entry-buffer (current-buffer))
1878 (ido-process-ignore-lists t)
1879 (ido-process-ignore-lists-inhibit nil)
1880 (ido-set-default-item t)
1881 ido-default-item
1882 ido-selected
1883 ido-final-text
1884 (done nil)
1885 (icomplete-mode nil) ;; prevent icomplete starting up
1886 ;; Exported dynamic variables:
1887 ido-cur-list
1888 ido-ignored-list
1889 (ido-rotate-temp nil)
1890 (ido-keep-item-list nil)
1891 (ido-use-merged-list nil)
1892 (ido-try-merged-list t)
1893 (ido-pre-merge-state nil)
1894 (ido-case-fold ido-case-fold)
1895 (ido-enable-prefix ido-enable-prefix)
1896 (ido-enable-regexp ido-enable-regexp)
1897 (ido-show-confirm-message nil)
1900 (ido-setup-completion-map)
1901 (setq ido-text-init initial)
1902 (setq ido-input-stack nil)
1904 (run-hooks 'ido-setup-hook)
1906 (while (not done)
1907 (ido-trace "\n_LOOP_" ido-text-init)
1908 (setq ido-exit nil)
1909 (setq ido-rescan t)
1910 (setq ido-rotate nil)
1911 (setq ido-text "")
1912 (when ido-set-default-item
1913 (setq ido-default-item
1914 (cond
1915 ((eq item 'buffer)
1916 (if (bufferp default) (buffer-name default) default))
1917 ((stringp default)
1918 (if (memq item '(file dir))
1919 (file-name-nondirectory default)
1920 default))
1921 ((eq item 'file)
1922 (and ido-enable-last-directory-history
1923 (let ((d (assoc ido-current-directory ido-last-directory-list)))
1924 (and d (cdr d)))))))
1925 (if (member ido-default-item ido-ignore-item-temp-list)
1926 (setq ido-default-item nil))
1927 (ido-trace "new default" ido-default-item)
1928 (if ido-default-item
1929 (setq ido-initial-position 0))
1930 (setq ido-set-default-item nil))
1932 (if ido-process-ignore-lists-inhibit
1933 (setq ido-process-ignore-lists nil))
1935 (if (and ido-use-merged-list (memq ido-try-merged-list '(t wide)) (not ido-keep-item-list))
1936 (let ((olist ido-cur-list)
1937 (oign ido-ignored-list)
1938 (omat ido-matches)
1939 (l (ido-make-merged-file-list ido-text-init
1940 (eq ido-use-merged-list 'auto)
1941 (eq ido-try-merged-list 'wide))))
1942 (ido-trace "merged" l)
1943 (cond
1944 ((not l)
1945 (if (eq ido-try-merged-list 'wide)
1946 (setq ido-pre-merge-state
1947 (list "" ido-current-directory olist oign omat)
1948 ido-cur-list nil
1949 ido-ignored-list nil
1950 ido-matches nil
1951 ido-keep-item-list t
1952 ido-try-merged-list (if (eq ido-use-merged-list 'auto) 'auto nil)
1953 ido-use-merged-list nil)
1954 (setq ido-cur-list olist
1955 ido-ignored-list oign
1956 ido-matches omat
1957 ido-keep-item-list t
1958 ido-try-merged-list (if (eq ido-use-merged-list 'auto) 'auto nil)
1959 ido-use-merged-list nil)))
1960 ((eq l t)
1961 (setq ido-use-merged-list nil))
1962 ((eq l 'input-pending-p)
1963 (setq ido-try-merged-list t
1964 ido-use-merged-list nil))
1966 (setq ido-pre-merge-state
1967 (list ido-text-init ido-current-directory olist oign omat))
1968 (ido-set-current-directory (car (cdr (car l))))
1969 (if (ido-final-slash ido-text-init)
1970 (setq ido-text-init ""))
1971 (setq ido-cur-list l
1972 ido-ignored-list nil
1973 ido-matches l
1974 ido-rescan nil
1975 ido-keep-item-list t
1976 ido-use-merged-list t)
1977 (ido-trace "Merged" t)
1978 ))))
1980 (cond
1981 (ido-keep-item-list
1982 (setq ido-keep-item-list nil
1983 ido-rescan nil))
1984 ((eq ido-cur-item 'file)
1985 (setq ido-ignored-list nil
1986 ido-cur-list (and (not ido-directory-nonreadable)
1987 (not ido-directory-too-big)
1988 (ido-make-file-list ido-default-item))))
1989 ((eq ido-cur-item 'dir)
1990 (setq ido-ignored-list nil
1991 ido-cur-list (and (not ido-directory-nonreadable)
1992 (not ido-directory-too-big)
1993 (ido-make-dir-list ido-default-item))))
1994 ((eq ido-cur-item 'buffer)
1995 (setq ido-ignored-list nil
1996 ido-cur-list (ido-make-buffer-list ido-default-item)))
1997 ((eq ido-cur-item 'list)
1998 (setq ido-ignored-list nil
1999 ido-cur-list (ido-make-choice-list ido-default-item)))
2000 (t nil))
2001 (setq ido-rotate-temp nil)
2003 (if ido-process-ignore-lists-inhibit
2004 (setq ido-process-ignore-lists t
2005 ido-process-ignore-lists-inhibit nil))
2007 (ido-set-matches)
2008 (if (and ido-matches (eq ido-try-merged-list 'auto))
2009 (setq ido-try-merged-list t))
2010 (let ((max-mini-window-height (or ido-max-window-height
2011 (and (boundp 'max-mini-window-height)
2012 max-mini-window-height)))
2013 (ido-completing-read t)
2014 (ido-require-match require-match)
2015 (ido-use-mycompletion-depth (1+ (minibuffer-depth)))
2016 (show-paren-mode nil)
2017 ;; Postpone history adding till later
2018 (history-add-new-input nil))
2019 ;; prompt the user for the file name
2020 (setq ido-exit nil)
2021 (setq ido-final-text
2022 (catch 'ido
2023 (read-from-minibuffer (ido-make-prompt item prompt)
2024 (prog1 ido-text-init
2025 (setq ido-text-init nil))
2026 ido-completion-map nil hist))))
2027 (ido-trace "read-from-minibuffer" ido-final-text)
2028 (and ido-completion-buffer
2029 (get-buffer ido-completion-buffer)
2030 (kill-buffer ido-completion-buffer))
2032 (ido-trace "\n_EXIT_" ido-exit)
2034 (cond
2035 ((eq ido-exit 'refresh)
2036 (if (and (eq ido-use-merged-list 'auto)
2037 (or (input-pending-p)))
2038 (setq ido-use-merged-list nil
2039 ido-keep-item-list t))
2040 nil)
2042 ((eq ido-exit 'done)
2043 (setq done t
2044 ido-selected ido-text
2045 ido-exit nil))
2047 ((memq ido-exit '(edit chdir))
2048 (cond
2049 ((memq ido-cur-item '(file dir))
2050 (let* ((read-file-name-function nil)
2051 (edit (eq ido-exit 'edit))
2052 (d ido-current-directory)
2053 (f ido-text-init)
2054 (new t))
2055 (setq ido-text-init "")
2056 (while new
2057 (setq new (if edit
2058 (condition-case nil
2059 (read-file-name (concat prompt "[EDIT] ")
2060 (expand-file-name d)
2061 (concat d f) nil f)
2062 (quit (concat d f)))
2064 d (or (file-name-directory new) "/")
2065 f (file-name-nondirectory new)
2066 edit t)
2067 (if (or
2068 (file-directory-p d)
2069 (and (yes-or-no-p (format "Create directory %s? " d))
2070 (condition-case nil
2071 (progn (make-directory d t) t)
2072 (error
2073 (message "Could not create directory")
2074 (sit-for 1)
2075 nil))))
2076 (progn
2077 (ido-set-current-directory d nil (eq ido-exit 'chdir))
2078 (setq ido-text-init f
2079 new nil))))))
2081 (setq ido-text-init
2082 (condition-case nil
2083 (read-string (concat prompt "[EDIT] ") ido-final-text)
2084 (quit ido-final-text)))))
2086 nil)
2088 ((eq ido-exit 'keep)
2089 (setq ido-keep-item-list t))
2091 ((memq ido-exit '(dired fallback find-file switch-to-buffer insert-buffer insert-file))
2092 (setq done t))
2094 ((memq ido-exit '(updir push))
2095 ;; cannot go up if already at the root-dir (Unix) or at the
2096 ;; root-dir of a certain drive (Windows or MS-DOS).
2097 (if (ido-is-tramp-root)
2098 (when (string-match "\\`\\(/\\([^/]+[:@]\\)*\\)\\([^/]+\\)[:@]\\'" ido-current-directory)
2099 (setq ido-text-init (match-string 3 ido-current-directory))
2100 (ido-set-current-directory (match-string 1 ido-current-directory))
2101 (setq ido-set-default-item t))
2102 (unless (ido-is-root-directory)
2103 (when (eq ido-exit 'push)
2104 (setq ido-input-stack (cons (cons ido-cur-item ido-text) ido-input-stack))
2105 (setq ido-cur-item 'dir)
2106 (setq ido-text-init (file-name-nondirectory (substring ido-current-directory 0 -1)))
2107 (ido-trace "push" ido-input-stack))
2108 (ido-set-current-directory (file-name-directory (substring ido-current-directory 0 -1)))
2109 (setq ido-set-default-item t))))
2111 ((eq ido-exit 'pop)
2112 (ido-trace "pop" ido-input-stack)
2113 (let ((elt (car ido-input-stack)))
2114 (setq ido-input-stack (cdr ido-input-stack))
2115 (ido-set-current-directory (concat ido-current-directory ido-text))
2116 (setq ido-cur-item (car elt))
2117 (setq ido-text-init (cdr elt))))
2119 ((eq ido-exit 'pop-all)
2120 (ido-trace "pop-all" ido-input-stack)
2121 (while ido-input-stack
2122 (let ((elt (car ido-input-stack)))
2123 (setq ido-input-stack (cdr ido-input-stack))
2124 (ido-set-current-directory (concat ido-current-directory ido-text))
2125 (setq ido-cur-item (car elt))
2126 (setq ido-text-init (cdr elt)))))
2128 ;; Handling the require-match must be done in a better way.
2129 ((and require-match
2130 (not (memq require-match '(confirm confirm-after-completion)))
2131 (not (if ido-directory-too-big
2132 (file-exists-p (concat ido-current-directory ido-final-text))
2133 (ido-existing-item-p))))
2134 (error "Must specify valid item"))
2137 (setq ido-selected
2138 (if (or (eq ido-exit 'takeprompt)
2139 (null ido-matches))
2140 ido-final-text
2141 ;; else take head of list
2142 (ido-name (car ido-matches))))
2144 (cond
2145 ((memq item '(buffer list))
2146 (setq done t))
2148 ((string-equal "./" ido-selected)
2149 nil)
2151 ((string-equal "../" ido-selected)
2152 ;; cannot go up if already at the root-dir (Unix) or at the
2153 ;; root-dir of a certain drive (Windows or MS-DOS).
2154 (or (ido-is-root-directory)
2155 (ido-set-current-directory (file-name-directory (substring ido-current-directory 0 -1))))
2156 (setq ido-set-default-item t))
2158 ((and (string-match (if ido-enable-tramp-completion ".[:@]\\'" ".:\\'") ido-selected)
2159 (ido-is-root-directory) ;; Ange-ftp or Tramp
2160 (not (ido-local-file-exists-p ido-selected)))
2161 (ido-set-current-directory ido-current-directory ido-selected)
2162 (ido-trace "tramp prefix" ido-selected)
2163 (if (ido-is-slow-ftp-host)
2164 (setq ido-exit 'fallback
2165 done t)
2166 (setq ido-set-default-item t)))
2168 ((string-match (if (memq system-type '(windows-nt ms-dos))
2169 "\\`[a-zA-Z]:\\|[/\\][^/\\]"
2170 "/[^/]")
2171 ido-selected)
2172 (ido-set-current-directory (file-name-directory ido-selected))
2173 (setq ido-set-default-item t))
2175 ((string-match "\\`~" ido-selected)
2176 (ido-set-current-home ido-selected))
2178 ((ido-final-slash ido-selected)
2179 (if ido-enable-last-directory-history
2180 (let ((x (assoc ido-current-directory ido-last-directory-list)))
2181 (if x
2182 (setcdr x ido-selected)
2183 (setq ido-last-directory-list
2184 (cons (cons ido-current-directory ido-selected) ido-last-directory-list)))))
2185 (ido-set-current-directory ido-current-directory ido-selected)
2186 (if ido-input-stack
2187 ; automatically pop stack elements which match existing files or directories
2188 (let (elt)
2189 (while (and (setq elt (car ido-input-stack))
2190 (file-exists-p (concat ido-current-directory (cdr elt))))
2191 (if (setq ido-input-stack (cdr ido-input-stack))
2192 (ido-set-current-directory ido-current-directory (cdr elt))
2193 (setq ido-text-init (cdr elt)))
2194 (setq ido-cur-item (car elt))))
2195 (setq ido-set-default-item t)))
2198 (setq done t))))))
2199 (add-to-history (cond
2200 ((consp hist)
2201 (or (car hist) 'minibuffer-history))
2202 (hist hist)
2203 (t 'minibuffer-history))
2204 ido-selected)
2205 ido-selected))
2207 (defun ido-edit-input ()
2208 "Edit absolute file name entered so far with Ido; terminate by RET.
2209 If cursor is not at the end of the user input, move to end of input."
2210 (interactive)
2211 (if (not (eobp))
2212 (end-of-line)
2213 (setq ido-text-init (if ido-matches (ido-name (car ido-matches)) ido-text))
2214 (setq ido-exit 'edit)
2215 (exit-minibuffer)))
2217 ;;; MAIN FUNCTIONS
2218 (defun ido-buffer-internal (method &optional fallback prompt default initial switch-cmd)
2219 ;; Internal function for ido-switch-buffer and friends
2220 (if (not ido-mode)
2221 (progn
2222 (run-hook-with-args 'ido-before-fallback-functions
2223 (or fallback 'switch-to-buffer))
2224 (call-interactively (or fallback 'switch-to-buffer)))
2225 (let* ((ido-context-switch-command switch-cmd)
2226 (ido-current-directory nil)
2227 (ido-directory-nonreadable nil)
2228 (ido-directory-too-big nil)
2229 (ido-enable-virtual-buffers (and ido-use-virtual-buffers
2230 (not (eq ido-use-virtual-buffers 'auto))))
2231 (require-match (confirm-nonexistent-file-or-buffer))
2232 (buf (ido-read-internal 'buffer (or prompt "Buffer: ") 'ido-buffer-history default
2233 require-match initial))
2234 filename)
2236 ;; Choose the buffer name: either the text typed in, or the head
2237 ;; of the list of matches
2239 (cond
2240 ((eq ido-exit 'find-file)
2241 (ido-file-internal
2242 (if (memq method '(other-window other-frame)) method ido-default-file-method)
2243 nil nil nil nil ido-text))
2245 ((eq ido-exit 'insert-file)
2246 (ido-file-internal 'insert 'insert-file nil "Insert file: " nil ido-text 'ido-enter-insert-buffer))
2248 ((eq ido-exit 'fallback)
2249 (let ((read-buffer-function nil))
2250 (setq this-command (or fallback 'switch-to-buffer))
2251 (run-hook-with-args 'ido-before-fallback-functions this-command)
2252 (call-interactively this-command)))
2254 ;; Check buf is non-nil.
2255 ((not buf) nil)
2256 ((= (length buf) 0) nil)
2258 ;; View buffer if it exists
2259 ((get-buffer buf)
2260 (add-to-history 'buffer-name-history buf)
2261 (if (eq method 'insert)
2262 (progn
2263 (ido-record-command 'insert-buffer buf)
2264 (push-mark
2265 (save-excursion
2266 (insert-buffer-substring (get-buffer buf))
2267 (point))))
2268 (ido-visit-buffer buf method t)))
2270 ;; check for a virtual buffer reference
2271 ((and ido-enable-virtual-buffers
2272 ido-virtual-buffers
2273 (setq filename (assoc buf ido-virtual-buffers)))
2274 (ido-visit-buffer (find-file-noselect (cdr filename)) method t))
2276 ((and (eq ido-create-new-buffer 'prompt)
2277 (null require-match)
2278 (not (y-or-n-p (format "No buffer matching `%s', create one? " buf))))
2279 nil)
2281 ;; buffer doesn't exist
2282 ((and (eq ido-create-new-buffer 'never)
2283 (null require-match))
2284 (message "No buffer matching `%s'" buf))
2286 ((and (eq ido-create-new-buffer 'prompt)
2287 (null require-match)
2288 (not (y-or-n-p (format "No buffer matching `%s', create one? " buf))))
2289 nil)
2291 ;; create a new buffer
2293 (add-to-history 'buffer-name-history buf)
2294 (setq buf (get-buffer-create buf))
2295 (if (fboundp 'set-buffer-major-mode)
2296 (set-buffer-major-mode buf))
2297 (ido-visit-buffer buf method t))))))
2299 (defun ido-record-work-directory (&optional dir)
2300 (when (and (numberp ido-max-work-directory-list) (> ido-max-work-directory-list 0))
2301 (if (and (setq dir (or dir ido-current-directory)) (> (length dir) 0))
2302 (let ((items ido-work-directory-list-ignore-regexps)
2303 (case-fold-search nil))
2304 (while (and items dir)
2305 (if (string-match (car items) dir)
2306 (setq dir nil))
2307 (setq items (cdr items)))
2308 (if dir
2309 (setq ido-work-directory-list (cons dir (delete dir ido-work-directory-list))))))
2310 (if (> (length ido-work-directory-list) ido-max-work-directory-list)
2311 (setcdr (nthcdr (1- ido-max-work-directory-list) ido-work-directory-list) nil))))
2313 (defun ido-forget-work-directory ()
2314 (interactive)
2315 (when (and ido-current-directory ido-work-directory-list)
2316 (setq ido-work-directory-list (delete ido-current-directory ido-work-directory-list))
2317 (when ido-use-merged-list
2318 (ido-undo-merge-work-directory)
2319 (setq ido-exit 'refresh
2320 ido-try-merged-list t
2321 ido-use-merged-list t
2322 ido-text-init ido-text
2323 ido-rotate-temp t)
2324 (exit-minibuffer))))
2326 (defun ido-record-work-file (name)
2327 ;; Save NAME in ido-work-file-list
2328 (when (and (numberp ido-max-work-file-list) (> ido-max-work-file-list 0))
2330 (and ido-work-file-list (equal (car ido-work-file-list) name))
2331 (setq ido-work-file-list (cons name (delete name ido-work-file-list))))
2332 (if (> (length ido-work-file-list) ido-max-work-file-list)
2333 (setcdr (nthcdr (1- ido-max-work-file-list) ido-work-file-list) nil))))
2335 (defun ido-expand-directory (dir)
2336 ;; Expand DIR or use DEFAULT-DIRECTORY if nil.
2337 ;; Add final slash to result in case it was missing from DEFAULT-DIRECTORY.
2338 (ido-final-slash (expand-file-name (or dir default-directory)) t))
2340 (defun ido-file-internal (method &optional fallback default prompt item initial switch-cmd)
2341 ;; Internal function for ido-find-file and friends
2342 (unless item
2343 (setq item 'file))
2344 (let ((ido-current-directory (ido-expand-directory default))
2345 (ido-context-switch-command switch-cmd)
2346 ido-directory-nonreadable ido-directory-too-big
2347 filename)
2349 (if (or (not ido-mode) (ido-is-slow-ftp-host))
2350 (setq filename t
2351 ido-exit 'fallback)
2352 (setq ido-directory-nonreadable
2353 (ido-nonreadable-directory-p ido-current-directory)
2354 ido-directory-too-big
2355 (and (not ido-directory-nonreadable)
2356 (ido-directory-too-big-p ido-current-directory))))
2358 (when (and (eq item 'file)
2359 (or ido-use-url-at-point ido-use-filename-at-point))
2360 (let (fn)
2361 (require 'ffap)
2362 ;; Duplicate code from ffap-guesser as we want different
2363 ;; behavior for files and URLs.
2364 (cond
2365 ((with-no-warnings
2366 (and ido-use-url-at-point
2367 ffap-url-regexp
2368 (ffap-fixup-url (or (ffap-url-at-point)
2369 (ffap-gopher-at-point)))))
2370 (setq ido-exit 'ffap
2371 filename t))
2373 ((and ido-use-filename-at-point
2374 (setq fn (with-no-warnings
2375 (if (eq ido-use-filename-at-point 'guess)
2376 (ffap-guesser)
2377 (ffap-string-at-point))))
2378 (not (string-match "\\`http:/" fn)))
2379 (let ((absolute-fn (expand-file-name fn)))
2380 (cond
2381 ((file-directory-p absolute-fn)
2382 (setq ido-current-directory
2383 (file-name-as-directory absolute-fn)))
2384 ((file-directory-p (file-name-directory absolute-fn))
2385 (setq ido-current-directory (file-name-directory absolute-fn))
2386 (setq initial (file-name-nondirectory absolute-fn)))))))))
2388 (let (ido-saved-vc-hb
2389 (vc-handled-backends (and (boundp 'vc-handled-backends)
2390 vc-handled-backends))
2391 (ido-work-directory-index -1)
2392 (ido-work-file-index -1)
2393 (ido-find-literal nil))
2395 (unless filename
2396 (setq ido-saved-vc-hb vc-handled-backends)
2397 (let ((minibuffer-completing-file-name t))
2398 (setq filename
2399 (ido-read-internal item
2400 (or prompt "Find file: ")
2401 'ido-file-history
2402 (and (eq method 'alt-file) buffer-file-name)
2403 (confirm-nonexistent-file-or-buffer)
2404 initial))))
2406 ;; Choose the file name: either the text typed in, or the head
2407 ;; of the list of matches
2409 (cond
2410 ((eq ido-exit 'fallback)
2411 ;; Need to guard setting of default-directory here, since
2412 ;; we don't want to change directory of current buffer.
2413 (let ((default-directory ido-current-directory)
2414 (read-file-name-function nil))
2415 (setq this-command (or fallback 'find-file))
2416 (run-hook-with-args 'ido-before-fallback-functions this-command)
2417 (call-interactively this-command)))
2419 ((eq ido-exit 'switch-to-buffer)
2420 (ido-buffer-internal
2421 (if (memq method '(other-window other-frame))
2422 method ido-default-buffer-method)
2423 nil nil nil ido-text))
2425 ((eq ido-exit 'insert-buffer)
2426 (ido-buffer-internal 'insert 'insert-buffer "Insert buffer: "
2427 nil ido-text 'ido-enter-insert-file))
2429 ((eq ido-exit 'dired)
2430 (funcall (cond ((eq method 'other-window) 'dired-other-window)
2431 ((eq method 'other-frame) 'dired-other-frame)
2432 (t 'dired))
2433 (concat ido-current-directory (or ido-text ""))))
2435 ((eq ido-exit 'ffap)
2436 (find-file-at-point))
2438 ((eq method 'alt-file)
2439 (ido-record-work-file filename)
2440 (setq default-directory ido-current-directory)
2441 (ido-record-work-directory)
2442 (find-alternate-file filename))
2444 ((memq method '(dired list-directory))
2445 (if (equal filename ".")
2446 (setq filename ""))
2447 (let* ((dirname (ido-final-slash
2448 (concat ido-current-directory filename) t))
2449 (file (substring dirname 0 -1)))
2450 (cond
2451 ((file-directory-p dirname)
2452 (ido-record-command method dirname)
2453 (ido-record-work-directory dirname)
2454 (funcall method dirname))
2455 ((file-directory-p ido-current-directory)
2456 (cond
2457 ((file-exists-p file)
2458 (ido-record-command method ido-current-directory)
2459 (ido-record-work-directory)
2460 (funcall method ido-current-directory)
2461 (if (eq method 'dired)
2462 (with-no-warnings
2463 (dired-goto-file (expand-file-name file)))))
2464 ((string-match "[[*?]" filename)
2465 (setq dirname (concat ido-current-directory filename))
2466 (ido-record-command method dirname)
2467 (ido-record-work-directory)
2468 (funcall method dirname))
2469 ((y-or-n-p (format "Directory %s does not exist. Create it? "
2470 filename))
2471 (ido-record-command method dirname)
2472 (ido-record-work-directory dirname)
2473 (make-directory-internal dirname)
2474 (funcall method dirname))
2476 ;; put make-directory command on history
2477 (ido-record-command 'make-directory dirname))))
2478 (t (error "No such directory")))))
2480 ((eq method 'write)
2481 (ido-record-work-file filename)
2482 (setq default-directory ido-current-directory)
2483 (setq filename (concat ido-current-directory filename))
2484 (ido-record-command 'write-file filename)
2485 (add-to-history 'file-name-history filename)
2486 (ido-record-work-directory)
2487 (write-file filename t))
2489 ((eq method 'read-only)
2490 (ido-record-work-file filename)
2491 (setq filename (concat ido-current-directory filename))
2492 (ido-record-command fallback filename)
2493 (ido-record-work-directory)
2494 (run-hook-with-args 'ido-before-fallback-functions fallback)
2495 (funcall fallback filename))
2497 ((eq method 'insert)
2498 (ido-record-work-file filename)
2499 (setq filename (concat ido-current-directory filename))
2500 (ido-record-command
2501 (if ido-find-literal 'insert-file-literally 'insert-file)
2502 filename)
2503 (add-to-history 'file-name-history filename)
2504 (ido-record-work-directory)
2505 (insert-file-1 filename
2506 (if ido-find-literal
2507 #'insert-file-contents-literally
2508 #'insert-file-contents)))
2510 (filename
2511 (ido-record-work-file filename)
2512 (setq filename (concat ido-current-directory filename))
2513 (ido-record-command 'find-file filename)
2514 (add-to-history 'file-name-history filename)
2515 (ido-record-work-directory)
2516 (ido-visit-buffer (find-file-noselect filename nil ido-find-literal)
2517 method))))))
2519 (defun ido-existing-item-p ()
2520 ;; Return non-nil if there is a matching item
2521 (not (null ido-matches)))
2523 ;;; COMPLETION CODE
2525 (defun ido-set-common-completion ()
2526 ;; Find common completion of `ido-text' in `ido-matches'
2527 ;; The result is stored in `ido-common-match-string'
2528 (let (val)
2529 (setq ido-common-match-string nil)
2530 (if (and ido-matches
2531 (not ido-enable-regexp) ;; testing
2532 (stringp ido-text)
2533 (> (length ido-text) 0))
2534 (if (setq val (ido-find-common-substring ido-matches ido-text))
2535 (setq ido-common-match-string val)))
2536 val))
2538 (defun ido-complete ()
2539 "Try and complete the current pattern amongst the file names."
2540 (interactive)
2541 (let (res)
2542 (cond
2543 (ido-incomplete-regexp
2544 ;; Do nothing
2546 ((and (memq ido-cur-item '(file dir))
2547 (string-match "[$]" ido-text))
2548 (let ((evar (substitute-in-file-name (concat ido-current-directory ido-text))))
2549 (if (not (file-exists-p (file-name-directory evar)))
2550 (message "Expansion generates non-existing directory name")
2551 (if (file-directory-p evar)
2552 (ido-set-current-directory evar)
2553 (let ((d (or (file-name-directory evar) "/"))
2554 (f (file-name-nondirectory evar)))
2555 (when (file-directory-p d)
2556 (ido-set-current-directory d)
2557 (setq ido-text-init f))))
2558 (setq ido-exit 'refresh)
2559 (exit-minibuffer))))
2561 (ido-directory-too-big
2562 (setq ido-directory-too-big nil)
2563 (setq ido-text-init ido-text)
2564 (setq ido-exit 'refresh)
2565 (exit-minibuffer))
2567 ((not ido-matches)
2568 (when ido-completion-buffer
2569 (call-interactively (setq this-command ido-cannot-complete-command))))
2571 ((and (= 1 (length ido-matches))
2572 (not (and ido-enable-tramp-completion
2573 (string-equal ido-current-directory "/")
2574 (string-match ".[@:]\\'" (ido-name (car ido-matches)))))
2575 (not (ido-local-file-exists-p (ido-name (car ido-matches)))))
2576 ;; only one choice, so select it.
2577 (if (not ido-confirm-unique-completion)
2578 (exit-minibuffer)
2579 (setq ido-rescan (not ido-enable-prefix))
2580 (delete-region (minibuffer-prompt-end) (point))
2581 (insert (ido-name (car ido-matches)))))
2583 (t ;; else there could be some completions
2584 (setq res ido-common-match-string)
2585 (if (and (not (memq res '(t nil)))
2586 (not (equal res ido-text)))
2587 ;; found something to complete, so put it in the minibuffer.
2588 (progn
2589 ;; move exact match to front if not in prefix mode
2590 (setq ido-rescan (not ido-enable-prefix))
2591 (delete-region (minibuffer-prompt-end) (point))
2592 (insert res))
2593 ;; else nothing to complete
2594 (call-interactively (setq this-command ido-cannot-complete-command))
2595 )))))
2597 (defun ido-complete-space ()
2598 "Try completion unless inserting the space makes sense."
2599 (interactive)
2600 (if (and (stringp ido-common-match-string)
2601 (stringp ido-text)
2602 (cond
2603 ((> (length ido-common-match-string) (length ido-text))
2604 (= (aref ido-common-match-string (length ido-text)) ? ))
2605 (ido-matches
2606 (let (insert-space
2607 (re (concat (regexp-quote ido-text) " "))
2608 (comp ido-matches))
2609 (while comp
2610 (if (string-match re (ido-name (car comp)))
2611 (setq comp nil insert-space t)
2612 (setq comp (cdr comp))))
2613 insert-space))
2614 (t nil)))
2615 (insert " ")
2616 (ido-complete)))
2618 (defun ido-undo-merge-work-directory (&optional text try refresh)
2619 "Undo or redo last Ido directory merge operation.
2620 If no merge has yet taken place, toggle automatic merging option."
2621 (interactive)
2622 (cond
2623 (ido-pre-merge-state
2624 (ido-set-current-directory (nth 1 ido-pre-merge-state))
2625 (setq ido-text-init (or text (car ido-pre-merge-state))
2626 ido-cur-list (nth 2 ido-pre-merge-state)
2627 ido-ignored-list (nth 3 ido-pre-merge-state)
2628 ido-matches (nth 4 ido-pre-merge-state)
2629 ido-use-merged-list nil
2630 ido-try-merged-list try
2631 ido-keep-item-list (not refresh)
2632 ido-rescan nil
2633 ido-exit 'refresh
2634 ido-pre-merge-state nil)
2635 (exit-minibuffer))
2636 (text
2637 nil)
2638 (ido-try-merged-list
2639 (setq ido-try-merged-list nil))
2640 (ido-matches
2641 (setq ido-try-merged-list t))
2642 ((not ido-use-merged-list)
2643 (ido-merge-work-directories))))
2645 ;;; Magic C-f
2647 (defun ido-magic-forward-char (arg)
2648 "Move forward in user input or perform magic action.
2649 If no user input is present, or at end of input, perform magic actions:
2650 C-x C-b ... C-f switch to `ido-find-file'.
2651 C-x C-f ... C-f fallback to non-Ido `find-file'.
2652 C-x C-d ... C-f fallback to non-Ido brief `dired'.
2653 C-x d ... C-f fallback to non-Ido `dired'."
2654 (interactive "P")
2655 (cond
2656 ((or arg (not (eobp)))
2657 (forward-char (min (prefix-numeric-value arg)
2658 (- (point-max) (point)))))
2659 ((memq ido-cur-item '(file dir))
2660 (ido-fallback-command))
2661 (ido-context-switch-command
2662 (call-interactively ido-context-switch-command))
2663 ((eq ido-cur-item 'buffer)
2664 (ido-enter-find-file))))
2666 ;;; Magic C-b
2668 (defun ido-magic-backward-char (arg)
2669 "Move backward in user input or perform magic action.
2670 If no user input is present, or at start of input, perform magic actions:
2671 C-x C-f C-b switch to `ido-switch-buffer'.
2672 C-x C-d C-b switch to `ido-switch-buffer'.
2673 C-x d C-b switch to `ido-switch-buffer'.
2674 C-x C-b C-b fallback to non-Ido `switch-to-buffer'."
2675 (interactive "P")
2676 (cond
2677 ((or arg (> (point) (minibuffer-prompt-end)))
2678 (forward-char
2679 (- (min (prefix-numeric-value arg)
2680 (- (point) (minibuffer-prompt-end))))))
2681 ((eq last-command this-command)
2682 (when (and (memq ido-cur-item '(file dir))
2683 (not (bobp)))
2684 (ido-push-dir))) ; else do nothing
2685 ((eq ido-cur-item 'buffer)
2686 (ido-fallback-command))
2687 (ido-context-switch-command
2688 (call-interactively ido-context-switch-command))
2690 (ido-enter-switch-buffer))))
2692 ;;; Magic C-d
2694 (defun ido-magic-delete-char (arg)
2695 "Delete following char in user input or perform magic action.
2696 If at end of user input, perform magic actions:
2697 C-x C-f ... C-d enter `dired' on current directory."
2698 (interactive "P")
2699 (cond
2700 ((or arg (not (eobp)))
2701 (delete-char (min (prefix-numeric-value arg)
2702 (- (point-max) (point)))))
2703 (ido-context-switch-command
2704 nil)
2705 ((memq ido-cur-item '(file dir))
2706 (ido-enter-dired))))
2709 ;;; TOGGLE FUNCTIONS
2711 (defun ido-toggle-case ()
2712 "Toggle the value of `ido-case-fold'."
2713 (interactive)
2714 (setq ido-case-fold (not ido-case-fold))
2715 ;; ask for list to be regenerated.
2716 (setq ido-rescan t))
2718 (defun ido-toggle-regexp ()
2719 "Toggle the value of `ido-enable-regexp'."
2720 (interactive)
2721 (setq ido-enable-regexp (not ido-enable-regexp))
2722 ;; ask for list to be regenerated.
2723 (setq ido-rescan t))
2725 (defun ido-toggle-prefix ()
2726 "Toggle the value of `ido-enable-prefix'."
2727 (interactive)
2728 (setq ido-enable-prefix (not ido-enable-prefix))
2729 ;; ask for list to be regenerated.
2730 (setq ido-rescan t))
2732 (defun ido-toggle-ignore ()
2733 "Toggle ignoring files specified with `ido-ignore-files'."
2734 (interactive)
2735 (if (and (not (eobp)) (> (point) (minibuffer-prompt-end)))
2736 (goto-char (minibuffer-prompt-end))
2737 (if ido-directory-too-big
2738 (progn
2739 (message "Reading directory...")
2740 (setq ido-directory-too-big nil))
2741 (setq ido-process-ignore-lists (not ido-process-ignore-lists)))
2742 (setq ido-text-init ido-text)
2743 (setq ido-exit 'refresh)
2744 (exit-minibuffer)))
2746 (defun ido-toggle-vc ()
2747 "Toggle version control for this file."
2748 (interactive)
2749 (if (and ido-mode (eq ido-cur-item 'file))
2750 (progn
2751 (setq vc-handled-backends
2752 (if vc-handled-backends nil ido-saved-vc-hb))
2753 (setq ido-text-init ido-text)
2754 (setq ido-exit 'keep)
2755 (exit-minibuffer))))
2757 (defun ido-toggle-literal ()
2758 "Toggle literal reading of this file."
2759 (interactive)
2760 (if (and ido-mode (eq ido-cur-item 'file))
2761 (progn
2762 (setq ido-find-literal (not ido-find-literal))
2763 (setq ido-text-init ido-text)
2764 (setq ido-exit 'keep)
2765 (exit-minibuffer))))
2767 (defun ido-toggle-virtual-buffers ()
2768 "Toggle the use of virtual buffers.
2769 See `ido-use-virtual-buffers' for explanation of virtual buffer."
2770 (interactive)
2771 (when (and ido-mode (eq ido-cur-item 'buffer))
2772 (setq ido-enable-virtual-buffers
2773 (if ido-enable-virtual-buffers
2775 ;; Use `always' instead of t for `ido-exhibit'.
2776 'always))
2777 (setq ido-text-init ido-text)
2778 (setq ido-exit 'refresh)
2779 (exit-minibuffer)))
2781 (defun ido-reread-directory ()
2782 "Read current directory again.
2783 May be useful if cached version is no longer valid, but directory
2784 timestamp has not changed (e.g. with FTP or on Windows)."
2785 (interactive)
2786 (if (and ido-mode (memq ido-cur-item '(file dir)))
2787 (progn
2788 (if (ido-is-unc-root)
2789 (setq ido-unc-hosts-cache t)
2790 (ido-remove-cached-dir ido-current-directory))
2791 (setq ido-text-init ido-text)
2792 (setq ido-rotate-temp t)
2793 (setq ido-exit 'refresh)
2794 (exit-minibuffer))))
2796 (defun ido-exit-minibuffer ()
2797 "Exit minibuffer, but make sure we have a match if one is needed."
2798 (interactive)
2799 (if (and (or (not ido-require-match)
2800 (if (memq ido-require-match '(confirm confirm-after-completion))
2801 (if (or (eq ido-cur-item 'dir)
2802 (eq last-command this-command))
2804 (setq ido-show-confirm-message t)
2805 nil))
2806 (ido-existing-item-p))
2807 (not ido-incomplete-regexp))
2808 (exit-minibuffer)))
2810 (defun ido-select-text ()
2811 "Select the buffer or file named by the prompt.
2812 If no buffer or file exactly matching the prompt exists, maybe create a new one."
2813 (interactive)
2814 (setq ido-exit 'takeprompt)
2815 (exit-minibuffer))
2817 (defun ido-fallback-command ()
2818 "Fallback to non-Ido version of current command."
2819 (interactive)
2820 (let ((i (length ido-text)))
2821 (while (> i 0)
2822 (push (aref ido-text (setq i (1- i))) unread-command-events)))
2823 (setq ido-exit 'fallback)
2824 (exit-minibuffer))
2826 (defun ido-enter-find-file ()
2827 "Drop into `find-file' from buffer switching."
2828 (interactive)
2829 (setq ido-exit 'find-file)
2830 (exit-minibuffer))
2832 (defun ido-enter-switch-buffer ()
2833 "Drop into `ido-switch-buffer' from file switching."
2834 (interactive)
2835 (setq ido-exit 'switch-to-buffer)
2836 (exit-minibuffer))
2838 (defun ido-enter-dired ()
2839 "Drop into `dired' from file switching."
2840 (interactive)
2841 (setq ido-exit 'dired)
2842 (exit-minibuffer))
2844 (defun ido-enter-insert-buffer ()
2845 "Drop into `insert-buffer' from insert file."
2846 (interactive)
2847 (setq ido-exit 'insert-buffer)
2848 (exit-minibuffer))
2850 (defun ido-enter-insert-file ()
2851 "Drop into `insert-file' from insert buffer."
2852 (interactive)
2853 (setq ido-exit 'insert-file)
2854 (exit-minibuffer))
2857 (defun ido-up-directory (&optional clear)
2858 "Go up one directory level."
2859 (interactive "P")
2860 (setq ido-text-init (if clear nil ido-text))
2861 (setq ido-exit 'updir)
2862 (setq ido-rotate-temp t)
2863 (exit-minibuffer))
2865 (defun ido-delete-backward-updir (count)
2866 "Delete char backwards, or at beginning of buffer, go up one level."
2867 (interactive "P")
2868 (cond
2869 ((= (minibuffer-prompt-end) (point))
2870 (if (not count)
2871 (ido-up-directory t)))
2872 ((and ido-pre-merge-state (string-equal (car ido-pre-merge-state) ido-text))
2873 (ido-undo-merge-work-directory (substring ido-text 0 -1) t t))
2874 ((eq this-original-command 'viper-backward-char)
2875 (funcall this-original-command (prefix-numeric-value count)))
2876 ((eq this-original-command 'viper-del-backward-char-in-insert)
2877 (funcall this-original-command))
2879 (delete-char (- (prefix-numeric-value count))))))
2881 (defun ido-delete-backward-word-updir (count)
2882 "Delete all chars backwards, or at beginning of buffer, go up one level."
2883 (interactive "P")
2884 (if (= (minibuffer-prompt-end) (point))
2885 (if (not count)
2886 (ido-up-directory t))
2887 (if (eq this-original-command 'viper-delete-backward-word)
2888 (funcall this-original-command (prefix-numeric-value count))
2889 (backward-kill-word (prefix-numeric-value count)))))
2891 (defun ido-get-work-directory (&optional incr must-match)
2892 (let ((n (length ido-work-directory-list))
2893 (i ido-work-directory-index)
2894 (j 0)
2895 dir)
2896 (if (or (not ido-text) (= (length ido-text) 0))
2897 (setq must-match nil))
2898 (while (< j n)
2899 (setq i (+ i incr)
2900 j (1+ j))
2901 (if (> incr 0)
2902 (if (>= i n) (setq i 0))
2903 (if (< i 0) (setq i (1- n))))
2904 (setq dir (nth i ido-work-directory-list))
2905 (if (and dir
2906 (not (equal dir ido-current-directory))
2907 (file-directory-p dir)
2908 (or (not must-match)
2909 ;; TODO. check for nonreadable and too-big.
2910 (ido-set-matches-1
2911 (if (eq ido-cur-item 'file)
2912 (ido-make-file-list-1 dir)
2913 (ido-make-dir-list-1 dir)))))
2914 (setq j n)
2915 (setq dir nil)))
2916 (if dir
2917 (setq ido-work-directory-index i))
2918 dir))
2920 (defun ido-prev-work-directory ()
2921 "Change to next working directory in list."
2922 (interactive)
2923 (let ((dir (ido-get-work-directory 1 ido-work-directory-match-only)))
2924 (when dir
2925 (ido-set-current-directory dir)
2926 (setq ido-exit 'refresh)
2927 (setq ido-text-init ido-text)
2928 (setq ido-rotate-temp t)
2929 (exit-minibuffer))))
2931 (defun ido-next-work-directory ()
2932 "Change to previous working directory in list."
2933 (interactive)
2934 (let ((dir (ido-get-work-directory -1 ido-work-directory-match-only)))
2935 (when dir
2936 (ido-set-current-directory dir)
2937 (setq ido-exit 'refresh)
2938 (setq ido-text-init ido-text)
2939 (setq ido-rotate-temp t)
2940 (exit-minibuffer))))
2942 (defun ido-merge-work-directories ()
2943 "Search (and merge) work directories for files matching the current input string."
2944 (interactive)
2945 (setq ido-use-merged-list t ido-try-merged-list t)
2946 (setq ido-exit 'refresh)
2947 (setq ido-text-init ido-text)
2948 (setq ido-rotate-temp t)
2949 (exit-minibuffer))
2951 (defun ido-wide-find-file (&optional file)
2952 "Prompt for FILE to search for using `find', starting from current directory."
2953 (interactive)
2954 (unless file
2955 (let ((enable-recursive-minibuffers t))
2956 (setq file
2957 (condition-case nil
2958 (read-string (concat "Wide find file: " ido-current-directory) ido-text)
2959 (quit "")))))
2960 (when (> (length file) 0)
2961 (setq ido-use-merged-list t ido-try-merged-list 'wide)
2962 (setq ido-exit 'refresh)
2963 (setq ido-text-init file)
2964 (setq ido-rotate-temp t)
2965 (exit-minibuffer)))
2967 (defun ido-wide-find-dir (&optional dir)
2968 "Prompt for DIR to search for using `find', starting from current directory."
2969 (interactive)
2970 (unless dir
2971 (let ((enable-recursive-minibuffers t))
2972 (setq dir
2973 (condition-case nil
2974 (read-string (concat "Wide find directory: " ido-current-directory) ido-text)
2975 (quit "")))))
2976 (when (> (length dir) 0)
2977 (setq ido-use-merged-list t ido-try-merged-list 'wide)
2978 (setq ido-exit 'refresh)
2979 (setq ido-text-init (ido-final-slash dir t))
2980 (setq ido-rotate-temp t)
2981 (exit-minibuffer)))
2983 (defun ido-wide-find-dir-or-delete-dir (&optional _dir)
2984 "Prompt for DIR to search for using `find', starting from current directory.
2985 If input stack is non-empty, delete current directory component."
2986 (interactive)
2987 (if ido-input-stack
2988 (ido-delete-backward-word-updir 1)
2989 (ido-wide-find-dir)))
2991 (defun ido-take-first-match ()
2992 "Use first matching item as input text."
2993 (interactive)
2994 (when ido-matches
2995 (setq ido-text-init (ido-name (car ido-matches)))
2996 (setq ido-exit 'refresh)
2997 (exit-minibuffer)))
2999 (defun ido-push-dir ()
3000 "Move to previous directory in file name, push current input on stack."
3001 (interactive)
3002 (setq ido-exit 'push)
3003 (exit-minibuffer))
3005 (defun ido-push-dir-first ()
3006 "Move to previous directory in file name, push first match on stack."
3007 (interactive)
3008 (if ido-matches
3009 (setq ido-text (ido-name (car ido-matches))))
3010 (setq ido-exit 'push)
3011 (exit-minibuffer))
3013 (defun ido-pop-dir (arg)
3014 "Pop directory from input stack back to input.
3015 With \\[universal-argument], pop all elements."
3016 (interactive "P")
3017 (when ido-input-stack
3018 (setq ido-exit (if arg 'pop-all 'pop))
3019 (exit-minibuffer)))
3021 (defun ido-wide-find-file-or-pop-dir (arg)
3022 (interactive "P")
3023 (if ido-input-stack
3024 (ido-pop-dir arg)
3025 (ido-wide-find-file)))
3027 (defun ido-make-directory (&optional dir)
3028 "Prompt for DIR to create in current directory."
3029 (interactive)
3030 (unless dir
3031 (let ((enable-recursive-minibuffers t))
3032 (setq dir
3033 (read-string (concat "Make directory: " ido-current-directory) ido-text))))
3034 (when (> (length dir) 0)
3035 (setq dir (concat ido-current-directory dir))
3036 (unless (file-exists-p dir)
3037 (make-directory dir t)
3038 (ido-set-current-directory dir)
3039 (setq ido-exit 'refresh)
3040 (setq ido-text-init nil)
3041 (setq ido-rotate-temp t)
3042 (exit-minibuffer))))
3044 (defun ido-get-work-file (incr)
3045 (let ((n (length ido-work-file-list))
3046 (i (+ ido-work-file-index incr))
3047 name)
3048 (if (> incr 0)
3049 (if (>= i n) (setq i 0))
3050 (if (< i 0) (setq i (1- n))))
3051 (setq name (nth i ido-work-file-list))
3052 (setq ido-work-file-index i)
3053 name))
3055 (defun ido-prev-work-file ()
3056 "Change to next working file name in list."
3057 (interactive)
3058 (let ((name (ido-get-work-file 1)))
3059 (when name
3060 (setq ido-text-init name)
3061 (setq ido-exit 'refresh)
3062 (exit-minibuffer))))
3064 (defun ido-next-work-file ()
3065 "Change to previous working file name in list."
3066 (interactive)
3067 (let ((name (ido-get-work-file -1)))
3068 (when name
3069 (setq ido-text-init name)
3070 (setq ido-exit 'refresh)
3071 (exit-minibuffer))))
3073 (defun ido-copy-current-file-name (all)
3074 "Insert file name of current buffer.
3075 If repeated, insert text from buffer instead."
3076 (interactive "P")
3077 (let* ((bfname (or (buffer-file-name ido-entry-buffer)
3078 (buffer-name ido-entry-buffer)))
3079 (name (and bfname (file-name-nondirectory bfname))))
3080 (when name
3081 (setq ido-text-init
3082 (if (or all
3083 (eq last-command this-command)
3084 (not (equal (file-name-directory bfname) ido-current-directory))
3085 (not (string-match "\\.[^.]*\\'" name)))
3086 name
3087 (substring name 0 (1+ (match-beginning 0)))))
3088 (setq ido-exit 'refresh
3089 ido-try-merged-list nil)
3090 (exit-minibuffer))))
3092 (defun ido-copy-current-word (_all)
3093 "Insert current word (file or directory name) from current buffer."
3094 (interactive "P")
3095 (let ((word (with-current-buffer ido-entry-buffer
3096 (let ((p (point)) start-line end-line start-name)
3097 (if (and mark-active (/= p (mark)))
3098 (setq start-name (mark))
3099 (beginning-of-line)
3100 (setq start-line (point))
3101 (end-of-line)
3102 (setq end-line (point))
3103 (goto-char p)
3104 (if (re-search-backward "[^-_a-zA-Z0-9:./\\~@]" start-line 1)
3105 (forward-char 1))
3106 (setq start-name (point))
3107 (re-search-forward "[-_a-zA-Z0-9:./\\~@]*" end-line 1)
3108 (if (= start-name (point))
3109 (setq start-name nil)))
3110 (and start-name
3111 (buffer-substring-no-properties start-name (point)))))))
3112 (if (cond
3113 ((not word) nil)
3114 ((string-match "\\`[~/]" word)
3115 (setq ido-text-init word
3116 ido-try-merged-list nil
3117 ido-exit 'chdir))
3118 ((string-match "/" word)
3119 (setq ido-text-init (concat ido-current-directory word)
3120 ido-try-merged-list nil
3121 ido-exit 'chdir))
3123 (setq ido-text-init word
3124 ido-try-merged-list nil
3125 ido-exit 'refresh)))
3126 (exit-minibuffer))))
3128 (defun ido-next-match ()
3129 "Put first element of `ido-matches' at the end of the list."
3130 (interactive)
3131 (if ido-matches
3132 (let ((next (cadr ido-matches)))
3133 (setq ido-cur-list (ido-chop ido-cur-list next))
3134 (setq ido-matches (ido-chop ido-matches next))
3135 (setq ido-rescan nil))))
3137 (defun ido-prev-match ()
3138 "Put last element of `ido-matches' at the front of the list."
3139 (interactive)
3140 (if ido-matches
3141 (let ((prev (car (last ido-matches))))
3142 (setq ido-cur-list (ido-chop ido-cur-list prev))
3143 (setq ido-matches (ido-chop ido-matches prev))
3144 (setq ido-rescan nil))))
3146 (defun ido-next-match-dir ()
3147 "Find next directory in match list.
3148 If work directories have been merged, cycle through directories for
3149 first matching file."
3150 (interactive)
3151 (if ido-use-merged-list
3152 (if ido-matches
3153 (let* ((elt (car ido-matches))
3154 (dirs (cdr elt)))
3155 (when (> (length dirs) 1)
3156 (setcdr elt (ido-chop dirs (cadr dirs))))
3157 (setq ido-rescan nil)))
3158 (let ((cnt (length ido-matches))
3159 (i 1))
3160 (while (and (< i cnt) (not (ido-final-slash (nth i ido-matches))))
3161 (setq i (1+ i)))
3162 (if (< i cnt)
3163 (setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
3165 (defun ido-prev-match-dir ()
3166 "Find previous directory in match list.
3167 If work directories have been merged, cycle through directories
3168 for first matching file."
3169 (interactive)
3170 (if ido-use-merged-list
3171 (if ido-matches
3172 (let* ((elt (car ido-matches))
3173 (dirs (cdr elt)))
3174 (when (> (length dirs) 1)
3175 (setcdr elt (ido-chop dirs (car (last dirs)))))
3176 (setq ido-rescan nil)))
3177 (let* ((cnt (length ido-matches))
3178 (i (1- cnt)))
3179 (while (and (> i 0) (not (ido-final-slash (nth i ido-matches))))
3180 (setq i (1- i)))
3181 (if (> i 0)
3182 (setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
3184 (defun ido-restrict-to-matches (&optional removep)
3185 "Set current item list to the currently matched items.
3187 When argument REMOVEP is non-nil, the currently matched items are
3188 instead removed from the current item list."
3189 (interactive "P")
3190 (when ido-matches
3191 (setq ido-cur-list (if removep
3192 ;; An important feature is to preserve the
3193 ;; order of the elements.
3194 (seq-difference ido-cur-list ido-matches)
3195 ido-matches)
3196 ido-matches ido-cur-list
3197 ido-text-init ""
3198 ido-rescan nil
3199 ido-exit 'keep)
3200 (exit-minibuffer)))
3202 (defun ido-chop (items elem)
3203 "Remove all elements before ELEM and put them at the end of ITEMS."
3204 (let ((ret nil)
3205 (next nil)
3206 (sofar nil))
3207 (while (not ret)
3208 (setq next (car items))
3209 (if (equal next elem)
3210 (setq ret (append items (nreverse sofar)))
3211 ;; else
3212 (progn
3213 (setq items (cdr items))
3214 (setq sofar (cons next sofar)))))
3215 ret))
3217 (defun ido-name (item)
3218 ;; Return file name for current item, whether in a normal list
3219 ;; or a merged work directory list.
3220 (if (consp item) (car item) item))
3223 ;;; CREATE LIST OF ALL CURRENT FILES
3225 (defun ido-all-completions ()
3226 ;; Return unsorted list of all completions.
3227 (let ((ido-process-ignore-lists nil)
3228 (ido-directory-too-big nil))
3229 (cond
3230 ((eq ido-cur-item 'file)
3231 (ido-make-file-list-1 ido-current-directory))
3232 ((eq ido-cur-item 'dir)
3233 (ido-make-dir-list-1 ido-current-directory))
3234 ((eq ido-cur-item 'buffer)
3235 (ido-make-buffer-list-1))
3236 ((eq ido-cur-item 'list)
3237 ido-choice-list)
3238 (t nil))))
3241 ;; File list sorting
3243 (defun ido-file-lessp (a b)
3244 ;; Simple compare two file names.
3245 (string-lessp (ido-no-final-slash a) (ido-no-final-slash b)))
3248 (defun ido-file-extension-lessp (a b)
3249 ;; Compare file names according to ido-file-extensions-order list.
3250 (let ((n (compare-strings a 0 nil b 0 nil nil))
3251 lessp p)
3252 (if (eq n t)
3254 (if (< n 0)
3255 (setq n (1- (- n))
3256 p a a b b p
3257 lessp t)
3258 (setq n (1- n)))
3259 (cond
3260 ((= n 0)
3261 lessp)
3262 ((= (aref a n) ?.)
3263 (ido-file-extension-aux a b n lessp))
3265 (while (and (> n 2) (/= (aref a n) ?.))
3266 (setq n (1- n)))
3267 (if (> n 1)
3268 (ido-file-extension-aux a b n lessp)
3269 lessp))))))
3271 (defun ido-file-extension-aux (a b n lessp)
3272 (let ((oa (ido-file-extension-order a n))
3273 (ob (ido-file-extension-order b n)))
3274 (cond
3275 ((and oa ob)
3276 (cond
3277 ((= oa ob)
3278 lessp)
3279 (lessp
3280 (> oa ob))
3282 (< oa ob))))
3284 (not lessp))
3286 lessp)
3288 lessp))))
3290 (defun ido-file-extension-order (s n)
3291 (let ((l ido-file-extensions-order)
3292 (i 0) o do)
3293 (while l
3294 (cond
3295 ((eq (car l) t)
3296 (setq do i
3297 l (cdr l)))
3298 ((eq (compare-strings s n nil (car l) 0 nil nil) t)
3299 (setq o i
3300 l nil))
3302 (setq l (cdr l))))
3303 (setq i (1+ i)))
3304 (or o do)))
3307 (defun ido-sort-merged-list (items promote)
3308 ;; Input is list of ("file" . "dir") cons cells.
3309 ;; Output is sorted list of ("file "dir" ...) lists
3310 (let ((l (sort items (lambda (a b) (string-lessp (car b) (car a)))))
3311 res a cur)
3312 (while l
3313 (setq a (car l)
3314 l (cdr l))
3315 (if (and res (string-equal (car (car res)) (car a)))
3316 (progn
3317 (setcdr (car (if cur (cdr res) res)) (cons (cdr a) (cdr (car res))))
3318 (if (and promote (string-equal ido-current-directory (cdr a)))
3319 (setq cur t)))
3320 (setq res (cons (list (car a) (cdr a)) res)
3321 cur nil)))
3322 res))
3324 (defun ido-wide-find-dirs-or-files (dir file &optional prefix finddir)
3325 ;; As ido-run-find-command, but returns a list of cons pairs ("file" . "dir")
3326 (let ((filenames
3327 (delq nil
3328 (mapcar (lambda (name)
3329 (unless (ido-ignore-item-p name ido-ignore-files t)
3330 name))
3331 (split-string
3332 (shell-command-to-string
3333 (concat "find "
3334 (shell-quote-argument dir)
3335 (if ido-case-fold " -iname " " -name ")
3336 (shell-quote-argument
3337 (concat (if prefix "" "*") file "*"))
3338 " -type " (if finddir "d" "f") " -print"))))))
3339 filename d f
3340 res)
3341 (while filenames
3342 (setq filename (car filenames)
3343 filenames (cdr filenames))
3344 (if (and (file-name-absolute-p filename)
3345 (file-exists-p filename))
3346 (setq d (file-name-directory filename)
3347 f (file-name-nondirectory filename)
3348 res (cons (cons (if finddir (ido-final-slash f t) f) d) res))))
3349 res))
3351 (defun ido-flatten-merged-list (items)
3352 "Create a list of directory names based on a merged directory list."
3353 (let (res)
3354 (while items
3355 (let* ((item (car items))
3356 (file (car item))
3357 (dirs (cdr item)))
3358 (while dirs
3359 (setq res (cons (concat (car dirs) file) res)
3360 dirs (cdr dirs))))
3361 (setq items (cdr items)))
3362 res))
3365 (defun ido-make-merged-file-list-1 (text auto wide)
3366 (let (res)
3367 (if (and (ido-final-slash text) ido-dir-file-cache)
3368 (if wide
3369 (setq res (ido-wide-find-dirs-or-files
3370 ido-current-directory (substring text 0 -1) ido-enable-prefix t))
3371 ;; Use list of cached directories
3372 (let ((re (concat (regexp-quote (substring text 0 -1)) "[^/:]*/\\'"))
3373 (dirs ido-dir-file-cache)
3374 dir b d f)
3375 (if nil ;; simple
3376 (while dirs
3377 (setq dir (car (car dirs))
3378 dirs (cdr dirs))
3379 (when (and (string-match re dir)
3380 (not (ido-ignore-item-p dir ido-ignore-directories-merge))
3381 (file-directory-p dir))
3382 (setq b (substring dir 0 -1)
3383 f (concat (file-name-nondirectory b) "/")
3384 d (file-name-directory b)
3385 res (cons (cons f d) res))))
3386 (while dirs
3387 (setq dir (car dirs)
3388 d (car dir)
3389 dirs (cdr dirs))
3390 (when (not (ido-ignore-item-p d ido-ignore-directories-merge))
3391 (setq dir (cdr (cdr dir)))
3392 (while dir
3393 (setq f (car dir)
3394 dir (cdr dir))
3395 (if (and (string-match re f)
3396 (not (ido-ignore-item-p f ido-ignore-directories)))
3397 (setq res (cons (cons f d) res)))))
3398 (if (and auto (input-pending-p))
3399 (setq dirs nil
3400 res t))))))
3401 (if wide
3402 (setq res (ido-wide-find-dirs-or-files
3403 ido-current-directory text ido-enable-prefix nil))
3404 (let ((ido-text text)
3405 (dirs ido-work-directory-list)
3406 (must-match (and text (> (length text) 0)))
3407 dir fl)
3408 (if (and auto (not (member ido-current-directory dirs)))
3409 (setq dirs (cons ido-current-directory dirs)))
3410 (while dirs
3411 (setq dir (car dirs)
3412 dirs (cdr dirs))
3413 (when (and dir (stringp dir)
3414 (or ido-merge-ftp-work-directories
3415 (not (ido-is-ftp-directory dir)))
3416 (file-directory-p dir)
3417 ;; TODO. check for nonreadable and too-big.
3418 (setq fl (if (eq ido-cur-item 'file)
3419 (ido-make-file-list-1 dir t)
3420 (ido-make-dir-list-1 dir t))))
3421 (if must-match
3422 (setq fl (ido-set-matches-1 fl)))
3423 (if fl
3424 (setq res (nconc fl res))))
3425 (if (and auto (input-pending-p))
3426 (setq dirs nil
3427 res t))))))
3428 res))
3430 (defun ido-make-merged-file-list (text auto wide)
3431 (let (res)
3432 (message "Searching for `%s'...." text)
3433 (condition-case nil
3434 (if (eq t (setq res
3435 (while-no-input
3436 (ido-make-merged-file-list-1 text auto wide))))
3437 (setq res 'input-pending-p))
3438 (quit
3439 (setq res t
3440 ido-try-merged-list nil
3441 ido-use-merged-list nil)))
3442 (when (and res (listp res))
3443 (setq res (ido-sort-merged-list res auto)))
3444 (when (and (or ido-rotate-temp ido-rotate-file-list-default)
3445 (listp res)
3446 (> (length text) 0))
3447 (let ((elt (assoc text res)))
3448 (when (and elt (not (eq elt (car res))))
3449 (setq res (delq elt res))
3450 (setq res (cons elt res)))))
3451 (message nil)
3452 res))
3454 (defun ido-make-buffer-list-1 (&optional frame visible)
3455 "Return list of non-ignored buffer names."
3456 (delq nil
3457 (mapcar
3458 (lambda (x)
3459 (let ((name (buffer-name x)))
3460 (if (not (or (ido-ignore-item-p name ido-ignore-buffers) (member name visible)))
3461 name)))
3462 (buffer-list frame))))
3464 (defun ido-make-buffer-list (default)
3465 "Return the current list of buffers.
3466 Currently visible buffers are put at the end of the list.
3467 The hook `ido-make-buffer-list-hook' is run after the list has been
3468 created to allow the user to further modify the order of the buffer names
3469 in this list. If DEFAULT is non-nil, and corresponds to an existing buffer,
3470 it is put to the start of the list."
3471 (let* ((ido-current-buffers (ido-get-buffers-in-frames 'current))
3472 (ido-temp-list (ido-make-buffer-list-1 (selected-frame) ido-current-buffers)))
3473 (if ido-temp-list
3474 (nconc ido-temp-list ido-current-buffers)
3475 (setq ido-temp-list ido-current-buffers))
3476 (if default
3477 (setq ido-temp-list
3478 (cons default (delete default ido-temp-list))))
3479 (if (bound-and-true-p ido-enable-virtual-buffers)
3480 (ido-add-virtual-buffers-to-list))
3481 (run-hooks 'ido-make-buffer-list-hook)
3482 ido-temp-list))
3484 (defun ido-add-virtual-buffers-to-list ()
3485 "Add recently visited files, and bookmark files, to the buffer list.
3486 This is to make them appear as if they were \"virtual buffers\"."
3487 ;; If no buffers matched, and virtual buffers are being used, then
3488 ;; consult the list of past visited files, to see if we can find
3489 ;; the file which the user might thought was still open.
3490 (unless recentf-mode (recentf-mode 1))
3491 (setq ido-virtual-buffers nil)
3492 (let ((bookmarks (and (boundp 'bookmark-alist)
3493 bookmark-alist))
3494 name)
3495 (dolist (head (append
3496 recentf-list
3497 (delq nil (mapcar (lambda (bookmark)
3498 (cdr (assoc 'filename bookmark)))
3499 bookmarks))))
3500 (setq name (file-name-nondirectory head))
3501 ;; In case HEAD is a directory with trailing /. See bug#14552.
3502 (when (equal name "")
3503 (setq name (file-name-nondirectory (directory-file-name head))))
3504 (when (equal name "")
3505 (setq name head))
3506 (and (not (equal name ""))
3507 (null (get-file-buffer head))
3508 (not (assoc name ido-virtual-buffers))
3509 (not (member name ido-temp-list))
3510 (not (ido-ignore-item-p name ido-ignore-buffers))
3511 ;;(file-exists-p head)
3512 (push (cons name head) ido-virtual-buffers))))
3513 (when ido-virtual-buffers
3514 (if ido-use-faces
3515 (dolist (comp ido-virtual-buffers)
3516 (put-text-property 0 (length (car comp))
3517 'face 'ido-virtual
3518 (car comp))))
3519 (setq ido-temp-list
3520 (nconc ido-temp-list
3521 (nreverse (mapcar #'car ido-virtual-buffers))))))
3523 (defun ido-make-choice-list (default)
3524 "Return the current list of choices.
3525 If DEFAULT is non-nil, and corresponds to an element of choices,
3526 it is put to the start of the list."
3527 (let ((ido-temp-list ido-choice-list))
3528 (if default
3529 (progn
3530 (setq ido-temp-list
3531 (delete default ido-temp-list))
3532 (setq ido-temp-list
3533 (cons default ido-temp-list))))
3534 ; (run-hooks 'ido-make-choice-list-hook)
3535 ido-temp-list))
3537 (defun ido-to-end (items)
3538 "Move the elements from ITEMS to the end of `ido-temp-list'."
3539 (mapc
3540 (lambda (elem)
3541 (setq ido-temp-list (delq elem ido-temp-list)))
3542 items)
3543 (if ido-temp-list
3544 (nconc ido-temp-list items)
3545 (setq ido-temp-list items)))
3547 (defun ido-file-name-all-completions-1 (dir)
3548 (cond
3549 ((ido-nonreadable-directory-p dir) '())
3550 ;; do not check (ido-directory-too-big-p dir) here.
3551 ;; Caller must have done that if necessary.
3553 ((and ido-enable-tramp-completion
3554 (string-match "\\`/[^/]+[:@]\\'" dir))
3555 ;; Strip method:user@host: part of tramp completions.
3556 ;; Tramp completions do not include leading slash.
3557 (let* ((len (1- (length dir)))
3558 (non-essential t)
3559 (compl
3560 (or (file-name-all-completions "" dir)
3561 ;; work around bug in ange-ftp.
3562 ;; /ftp:user@host: => nil
3563 ;; /ftp:user@host:./ => ok
3564 (and
3565 (not (string= "/ftp:" dir))
3566 (file-remote-p dir)
3567 ;; tramp-ftp-file-name-p is available only when tramp
3568 ;; has been loaded.
3569 (fboundp 'tramp-ftp-file-name-p)
3570 (funcall 'tramp-ftp-file-name-p dir)
3571 (string-match ":\\'" dir)
3572 (file-name-all-completions "" (concat dir "./"))))))
3573 (if (and compl
3574 (> (length (car compl)) len)
3575 (string= (substring (car compl) 0 len) (substring dir 1)))
3576 (mapcar (lambda (c) (substring c len)) compl)
3577 compl)))
3579 (file-name-all-completions "" dir))))
3581 (defun ido-file-name-all-completions (dir)
3582 "Return name of all files in DIR.
3583 Uses and updates `ido-dir-file-cache'."
3584 (cond
3585 ((ido-is-unc-root dir)
3586 (mapcar
3587 (lambda (host)
3588 (if (string-match "/\\'" host) host (concat host "/")))
3589 (ido-unc-hosts t)))
3590 ((and (numberp ido-max-dir-file-cache) (> ido-max-dir-file-cache 0)
3591 (stringp dir) (> (length dir) 0)
3592 (ido-may-cache-directory dir))
3593 (let* ((cached (assoc dir ido-dir-file-cache))
3594 (ctime (nth 1 cached))
3595 (ftp (ido-is-ftp-directory dir))
3596 (unc (ido-is-unc-host dir))
3597 (attr (if (or ftp unc) nil (file-attributes dir)))
3598 (mtime (nth 5 attr))
3599 valid)
3600 (when cached ; should we use the cached entry ?
3601 (cond
3602 (ftp
3603 (setq valid (and (eq (car ctime) 'ftp)
3604 (ido-cache-ftp-valid (cdr ctime)))))
3605 (unc
3606 (setq valid (and (eq (car ctime) 'unc)
3607 (ido-cache-unc-valid (cdr ctime)))))
3609 (if attr
3610 (setq valid (and (= (car ctime) (car mtime))
3611 (= (car (cdr ctime)) (car (cdr mtime))))))))
3612 (unless valid
3613 (setq ido-dir-file-cache (delq cached ido-dir-file-cache)
3614 cached nil)))
3615 (unless cached
3616 (cond
3617 (unc
3618 (setq mtime (cons 'unc (ido-time-stamp))))
3619 ((and ftp (file-readable-p dir))
3620 (setq mtime (cons 'ftp (ido-time-stamp)))))
3621 (if mtime
3622 (setq cached (cons dir (cons mtime (ido-file-name-all-completions-1 dir)))
3623 ido-dir-file-cache (cons cached ido-dir-file-cache)))
3624 (if (> (length ido-dir-file-cache) ido-max-dir-file-cache)
3625 (setcdr (nthcdr (1- ido-max-dir-file-cache) ido-dir-file-cache) nil)))
3626 (and cached
3627 (cdr (cdr cached)))))
3629 (ido-file-name-all-completions-1 dir))))
3631 (defun ido-remove-cached-dir (dir)
3632 "Remove DIR from `ido-dir-file-cache'."
3633 (if (and ido-dir-file-cache
3634 (stringp dir) (> (length dir) 0))
3635 (let ((cached (assoc dir ido-dir-file-cache)))
3636 (if cached
3637 (setq ido-dir-file-cache (delq cached ido-dir-file-cache))))))
3640 (defun ido-make-file-list-1 (dir &optional merged)
3641 "Return list of non-ignored files in DIR
3642 If MERGED is non-nil, each file is cons'ed with DIR."
3643 (and (or (ido-is-tramp-root dir) (ido-is-unc-root dir)
3644 (file-directory-p dir))
3645 (delq nil
3646 (mapcar
3647 (lambda (name)
3648 (if (not (ido-ignore-item-p name ido-ignore-files t))
3649 (if merged (cons name dir) name)))
3650 (ido-file-name-all-completions dir)))))
3652 (defun ido-make-file-list (default)
3653 "Return the current list of files.
3654 Currently visible files are put at the end of the list.
3655 The hook `ido-make-file-list-hook' is run after the list has been
3656 created to allow the user to further modify the order of the file names
3657 in this list."
3658 (let ((ido-temp-list (ido-make-file-list-1 ido-current-directory)))
3659 (setq ido-temp-list (sort ido-temp-list
3660 (if ido-file-extensions-order
3661 #'ido-file-extension-lessp
3662 #'ido-file-lessp)))
3663 (unless (ido-is-tramp-root ido-current-directory)
3664 (let ((default-directory ido-current-directory))
3665 (ido-to-end ;; move ftp hosts and visited files to end
3666 (delq nil (mapcar
3667 (lambda (x) (if (or (and (string-match ".:\\'" x)
3668 (not (ido-local-file-exists-p x)))
3669 (and (not (ido-final-slash x))
3670 (let (file-name-handler-alist)
3671 (get-file-buffer x)))) x))
3672 ido-temp-list)))))
3673 (ido-to-end ;; move . files to end
3674 (delq nil (mapcar
3675 (lambda (x) (if (string-equal (substring x 0 1) ".") x))
3676 ido-temp-list)))
3677 (if (and default (member default ido-temp-list))
3678 (if (or ido-rotate-temp ido-rotate-file-list-default)
3679 (unless (equal default (car ido-temp-list))
3680 (let ((l ido-temp-list) k)
3681 (while (and l (cdr l) (not (equal default (car (cdr l)))))
3682 (setq l (cdr l)))
3683 (setq k (cdr l))
3684 (setcdr l nil)
3685 (nconc k ido-temp-list)
3686 (setq ido-temp-list k)))
3687 (setq ido-temp-list
3688 (delete default ido-temp-list))
3689 (setq ido-temp-list
3690 (cons default ido-temp-list))))
3691 (when ido-show-dot-for-dired
3692 (setq ido-temp-list (delete "." ido-temp-list))
3693 (setq ido-temp-list (cons "." ido-temp-list)))
3694 (run-hooks 'ido-make-file-list-hook)
3695 ido-temp-list))
3697 (defun ido-make-dir-list-1 (dir &optional merged)
3698 "Return list of non-ignored subdirs in DIR.
3699 If MERGED is non-nil, each subdir is cons'ed with DIR."
3700 (and (or (ido-is-tramp-root dir) (file-directory-p dir))
3701 (delq nil
3702 (mapcar
3703 (lambda (name)
3704 (and (ido-final-slash name) (not (ido-ignore-item-p name ido-ignore-directories))
3705 (if merged (cons name dir) name)))
3706 (ido-file-name-all-completions dir)))))
3708 (defun ido-make-dir-list (default)
3709 "Return the current list of directories.
3710 The hook `ido-make-dir-list-hook' is run after the list has been
3711 created to allow the user to further modify the order of the
3712 directory names in this list."
3713 (let ((ido-temp-list (ido-make-dir-list-1 ido-current-directory)))
3714 (setq ido-temp-list (sort ido-temp-list #'ido-file-lessp))
3715 (ido-to-end ;; move . files to end
3716 (delq nil (mapcar
3717 (lambda (x) (if (string-equal (substring x 0 1) ".") x))
3718 ido-temp-list)))
3719 (if (and default (member default ido-temp-list))
3720 (if (or ido-rotate-temp ido-rotate-file-list-default)
3721 (unless (equal default (car ido-temp-list))
3722 (let ((l ido-temp-list) k)
3723 (while (and l (cdr l) (not (equal default (car (cdr l)))))
3724 (setq l (cdr l)))
3725 (setq k (cdr l))
3726 (setcdr l nil)
3727 (nconc k ido-temp-list)
3728 (setq ido-temp-list k)))
3729 (setq ido-temp-list
3730 (delete default ido-temp-list))
3731 (setq ido-temp-list
3732 (cons default ido-temp-list))))
3733 (setq ido-temp-list (delete "." ido-temp-list))
3734 (unless ido-input-stack
3735 (setq ido-temp-list (cons "." ido-temp-list)))
3736 (run-hooks 'ido-make-dir-list-hook)
3737 ido-temp-list))
3739 ;; List of the files visible in the current frame.
3740 (defvar ido-bufs-in-frame)
3742 (defun ido-get-buffers-in-frames (&optional current)
3743 "Return the list of buffers that are visible in the current frame.
3744 If optional argument CURRENT is given, restrict searching to the current
3745 frame, rather than all frames, regardless of value of `ido-all-frames'."
3746 (let ((ido-bufs-in-frame nil))
3747 (walk-windows 'ido-get-bufname nil
3748 (if current
3750 ido-all-frames))
3751 ido-bufs-in-frame))
3753 (defun ido-get-bufname (win)
3754 "Used by `ido-get-buffers-in-frames' to walk through all windows."
3755 (let ((buf (buffer-name (window-buffer win))))
3756 (unless (or (member buf ido-bufs-in-frame)
3757 (member buf ido-ignore-item-temp-list))
3758 ;; Only add buf if it is not already in list.
3759 ;; This prevents same buf in two different windows being
3760 ;; put into the list twice.
3761 (setq ido-bufs-in-frame
3762 (cons buf ido-bufs-in-frame)))))
3764 ;;; FIND MATCHING ITEMS
3766 (defun ido-set-matches-1 (items &optional do-full)
3767 "Return list of matches in ITEMS."
3768 (let* ((case-fold-search ido-case-fold)
3769 (slash (and (not ido-enable-prefix) (ido-final-slash ido-text)))
3770 (text (if slash (substring ido-text 0 -1) ido-text))
3771 (rex0 (if ido-enable-regexp text (regexp-quote text)))
3772 (rexq (concat rex0 (if slash ".*/" "")))
3773 (re (if ido-enable-prefix (concat "\\`" rexq) rexq))
3774 (full-re (and do-full
3775 (not (and (eq ido-cur-item 'buffer)
3776 ido-buffer-disable-smart-matches))
3777 (not ido-enable-regexp)
3778 (not (string-match "\$\\'" rex0))
3779 (concat "\\`" rex0 (if slash "/" "") "\\'")))
3780 (suffix-re (and do-full slash
3781 (not (and (eq ido-cur-item 'buffer)
3782 ido-buffer-disable-smart-matches))
3783 (not ido-enable-regexp)
3784 (not (string-match "\$\\'" rex0))
3785 (concat rex0 "/\\'")))
3786 (prefix-re (and full-re (not ido-enable-prefix)
3787 (concat "\\`" rexq)))
3788 (non-prefix-dot (or (not ido-enable-dot-prefix)
3789 (not ido-process-ignore-lists)
3790 ido-enable-prefix
3791 (= (length ido-text) 0)))
3792 full-matches suffix-matches prefix-matches matches)
3793 (setq ido-incomplete-regexp nil)
3794 (condition-case error
3795 (mapc
3796 (lambda (item)
3797 (let ((name (ido-name item)))
3798 (if (and (or non-prefix-dot
3799 (if (= (aref ido-text 0) ?.)
3800 (= (aref name 0) ?.)
3801 (/= (aref name 0) ?.)))
3802 (string-match re name))
3803 (cond
3804 ((and (eq ido-cur-item 'buffer)
3805 (or (not (stringp ido-default-item))
3806 (not (string= name ido-default-item)))
3807 (string= name (buffer-name ido-entry-buffer)))
3808 (setq matches (cons item matches)))
3809 ((and full-re (string-match full-re name))
3810 (setq full-matches (cons item full-matches)))
3811 ((and suffix-re (string-match suffix-re name))
3812 (setq suffix-matches (cons item suffix-matches)))
3813 ((and prefix-re (string-match prefix-re name))
3814 (setq prefix-matches (cons item prefix-matches)))
3815 (t (setq matches (cons item matches))))))
3817 items)
3818 (invalid-regexp
3819 (setq ido-incomplete-regexp t
3820 ;; Consider the invalid regexp message internally as a
3821 ;; special-case single match, and handle appropriately
3822 ;; elsewhere.
3823 matches (cdr error))))
3824 (when prefix-matches
3825 (ido-trace "prefix match" prefix-matches)
3826 ;; Bug#2042.
3827 (setq matches (nconc prefix-matches matches)))
3828 (when suffix-matches
3829 (ido-trace "suffix match" (list text suffix-re suffix-matches))
3830 (setq matches (nconc suffix-matches matches)))
3831 (when full-matches
3832 (ido-trace "full match" (list text full-re full-matches))
3833 (setq matches (nconc full-matches matches)))
3834 (when (and (null matches)
3835 ido-enable-flex-matching
3836 (> (length ido-text) 1)
3837 (not ido-enable-regexp))
3838 (setq re (concat (regexp-quote (string (aref ido-text 0)))
3839 (mapconcat (lambda (c)
3840 (concat "[^" (string c) "]*"
3841 (regexp-quote (string c))))
3842 (substring ido-text 1) "")))
3843 (if ido-enable-prefix
3844 (setq re (concat "\\`" re)))
3845 (mapc
3846 (lambda (item)
3847 (let ((name (ido-name item)))
3848 (if (string-match re name)
3849 (setq matches (cons item matches)))))
3850 items))
3851 (delete-consecutive-dups matches t)))
3854 (defun ido-set-matches ()
3855 "Set `ido-matches' to the list of items matching prompt."
3856 (when ido-rescan
3857 (setq ido-matches (ido-set-matches-1 (reverse ido-cur-list) (not ido-rotate))
3858 ido-rotate nil)))
3860 (defun ido-ignore-item-p (name re-list &optional ignore-ext)
3861 "Return t if the buffer or file NAME should be ignored."
3862 (or (member name ido-ignore-item-temp-list)
3863 (and
3864 ido-process-ignore-lists re-list
3865 (save-match-data
3866 (let ((ext-list (and ignore-ext ido-ignore-extensions
3867 completion-ignored-extensions))
3868 (case-fold-search ido-case-fold)
3869 ignorep nextstr
3870 (flen (length name)) slen)
3871 (while ext-list
3872 (setq nextstr (car ext-list))
3873 (if (cond
3874 ((stringp nextstr)
3875 (and (>= flen (setq slen (length nextstr)))
3876 (string-equal (substring name (- flen slen)) nextstr)))
3877 ((functionp nextstr) (funcall nextstr name))
3878 (t nil))
3879 (setq ignorep t
3880 ext-list nil
3881 re-list nil)
3882 (setq ext-list (cdr ext-list))))
3883 (while re-list
3884 (setq nextstr (car re-list))
3885 (if (cond
3886 ((stringp nextstr) (string-match nextstr name))
3887 ((functionp nextstr) (funcall nextstr name))
3888 (t nil))
3889 (setq ignorep t
3890 re-list nil)
3891 (setq re-list (cdr re-list))))
3892 ;; return the result
3893 (if ignorep
3894 (setq ido-ignored-list (cons name ido-ignored-list)))
3895 ignorep)))))
3897 ;; Private variable used by `ido-word-matching-substring'.
3898 (defvar ido-change-word-sub)
3900 (defun ido-find-common-substring (items subs)
3901 "Return common string following SUBS in each element of ITEMS."
3902 (let (res
3903 alist
3904 ido-change-word-sub)
3905 (setq ido-change-word-sub
3906 (if ido-enable-regexp
3907 subs
3908 (regexp-quote subs)))
3909 (setq res (mapcar #'ido-word-matching-substring items))
3910 (setq res (delq nil res)) ;; remove any nil elements (shouldn't happen)
3911 (setq alist (mapcar #'ido-makealist res)) ;; could use an OBARRAY
3913 ;; try-completion returns t if there is an exact match.
3914 (let* ((completion-ignore-case ido-case-fold)
3915 (comp (try-completion subs alist)))
3916 (if (eq comp t)
3917 subs
3918 comp))))
3920 (defun ido-word-matching-substring (word)
3921 "Return part of WORD before first match to `ido-change-word-sub'.
3922 If `ido-change-word-sub' cannot be found in WORD, return nil."
3923 (let ((case-fold-search ido-case-fold))
3924 (let ((m (string-match ido-change-word-sub (ido-name word))))
3925 (if m
3926 (substring (ido-name word) m)
3927 ;; else no match
3928 nil))))
3930 (defun ido-makealist (res)
3931 "Return dotted pair (RES . 1)."
3932 (cons res 1))
3934 (defun ido-choose-completion-string (choice &rest ignored)
3935 (when (ido-active)
3936 ;; Insert the completion into the buffer where completion was requested.
3937 (and ido-completion-buffer
3938 (get-buffer ido-completion-buffer)
3939 (kill-buffer ido-completion-buffer))
3940 (cond
3941 ((ido-active t) ;; ido-use-merged-list
3942 (setq ido-current-directory ""
3943 ido-text choice
3944 ido-exit 'done))
3945 ((not (ido-final-slash choice))
3946 (setq ido-text choice
3947 ido-exit 'done))
3949 (ido-set-current-directory ido-current-directory choice)
3950 (setq ido-exit 'refresh)))
3951 (exit-minibuffer)
3954 (defun ido-completion-help ()
3955 "Show possible completions in a \"*File Completions*\" buffer."
3956 (interactive)
3957 (setq ido-rescan nil)
3958 (let ((temp-buf (and ido-completion-buffer
3959 (get-buffer ido-completion-buffer)))
3960 display-it full-list)
3961 (if (and (eq last-command this-command) temp-buf)
3962 ;; scroll buffer
3963 (let (win (buf (current-buffer)))
3964 (display-buffer temp-buf nil nil)
3965 (set-buffer temp-buf)
3966 (setq win (get-buffer-window temp-buf))
3967 (if (pos-visible-in-window-p (point-max) win)
3968 (if (or ido-completion-buffer-all-completions
3969 (boundp 'ido-completion-buffer-full))
3970 (set-window-start win (point-min))
3971 (with-no-warnings
3972 (set (make-local-variable 'ido-completion-buffer-full) t))
3973 (setq full-list t
3974 display-it t))
3975 (scroll-other-window))
3976 (set-buffer buf))
3977 (setq display-it t))
3978 (if (and ido-completion-buffer display-it)
3979 (with-output-to-temp-buffer ido-completion-buffer
3980 (let ((completion-list (sort
3981 (cond
3982 (ido-directory-too-big
3983 (message "Reading directory...")
3984 (setq ido-directory-too-big nil
3985 ido-ignored-list nil
3986 ido-cur-list (ido-all-completions)
3987 ido-rescan t)
3988 (ido-set-matches)
3989 (or ido-matches ido-cur-list))
3990 (ido-use-merged-list
3991 (ido-flatten-merged-list (or ido-matches ido-cur-list)))
3992 ((or full-list ido-completion-buffer-all-completions)
3993 (ido-all-completions))
3995 (copy-sequence (or ido-matches ido-cur-list))))
3996 #'ido-file-lessp)))
3997 (if (featurep 'xemacs)
3998 ;; XEmacs extents are put on by default, doesn't seem to be
3999 ;; any way of switching them off.
4000 (display-completion-list
4001 completion-list
4002 :help-string "ido "
4003 :activate-callback
4004 (lambda (&rest _) (message "Doesn't work yet, sorry!")))
4005 ;; else running Emacs
4006 ;;(add-hook 'completion-setup-hook 'completion-setup-function)
4007 (display-completion-list completion-list)))))))
4009 ;;; KILL CURRENT BUFFER
4010 (defun ido-kill-buffer-at-head ()
4011 "Kill the buffer at the head of `ido-matches'.
4012 If cursor is not at the end of the user input, delete to end of input."
4013 (interactive)
4014 (if (not (eobp))
4015 (delete-region (point) (line-end-position))
4016 (let ((enable-recursive-minibuffers t)
4017 (buf (ido-name (car ido-matches)))
4018 (nextbuf (cadr ido-matches)))
4019 (cond
4020 ((get-buffer buf)
4021 ;; If next match names a buffer use the buffer object; buffer
4022 ;; name may be changed by packages such as uniquify.
4023 (when (and nextbuf (get-buffer nextbuf))
4024 (setq nextbuf (get-buffer nextbuf)))
4025 (if (null (kill-buffer buf))
4026 ;; Buffer couldn't be killed.
4027 (setq ido-rescan t)
4028 ;; Else `kill-buffer' succeeds so re-make the buffer list
4029 ;; taking into account packages like uniquify may rename
4030 ;; buffers.
4031 (if (bufferp nextbuf)
4032 (setq nextbuf (buffer-name nextbuf)))
4033 (setq ido-default-item nextbuf
4034 ido-text-init ido-text
4035 ido-exit 'refresh)
4036 (exit-minibuffer)))
4037 ;; Handle virtual buffers
4038 ((assoc buf ido-virtual-buffers)
4039 (setq recentf-list
4040 (delete (cdr (assoc buf ido-virtual-buffers)) recentf-list))
4041 (setq ido-cur-list (delete buf ido-cur-list))
4042 (setq ido-rescan t))))))
4044 ;;; BURY CURRENT BUFFER
4045 (defun ido-bury-buffer-at-head ()
4046 "Bury the buffer at the head of `ido-matches'."
4047 (interactive)
4048 (let ((enable-recursive-minibuffers t)
4049 (buf (ido-name (car ido-matches)))
4050 (nextbuf (cadr ido-matches)))
4051 (when (get-buffer buf)
4052 (bury-buffer buf)
4053 (setq ido-default-item nextbuf
4054 ido-text-init ido-text
4055 ido-exit 'refresh)
4056 (exit-minibuffer))))
4058 ;;; DELETE CURRENT FILE
4059 (defun ido-delete-file-at-head ()
4060 "Delete the file at the head of `ido-matches'.
4061 Trash the file if `delete-by-moving-to-trash' is non-nil.
4062 If cursor is not at the end of the user input, delete to end of input."
4063 (interactive)
4064 (if (not (eobp))
4065 (delete-region (point) (line-end-position))
4066 (let ((enable-recursive-minibuffers t)
4067 (file (ido-name (car ido-matches))))
4068 (if file
4069 (setq file (concat ido-current-directory file)))
4070 (when (and file
4071 (file-exists-p file)
4072 (not (file-directory-p file))
4073 (file-writable-p ido-current-directory)
4074 (or delete-by-moving-to-trash
4075 (yes-or-no-p (concat "Delete " file "? "))))
4076 (delete-file file 'trash)
4077 ;; Check if file still exists.
4078 (if (file-exists-p file)
4079 ;; file could not be deleted
4080 (setq ido-rescan t)
4081 ;; else file was killed so remove name from list.
4082 (setq ido-cur-list (delq (car ido-matches) ido-cur-list)))))))
4085 ;;; VISIT CHOSEN BUFFER
4086 (defun ido-visit-buffer (buffer method &optional record)
4087 "Switch to BUFFER according to METHOD.
4088 Record command in `command-history' if optional RECORD is non-nil."
4089 (if (bufferp buffer)
4090 (setq buffer (buffer-name buffer)))
4091 (let (win newframe)
4092 (cond
4093 ((eq method 'kill)
4094 (if record
4095 (ido-record-command 'kill-buffer buffer))
4096 (kill-buffer buffer))
4098 ((eq method 'other-window)
4099 (if record
4100 (ido-record-command 'switch-to-buffer buffer))
4101 (switch-to-buffer-other-window buffer))
4103 ((eq method 'display)
4104 (display-buffer buffer))
4106 ((eq method 'other-frame)
4107 (switch-to-buffer-other-frame buffer)
4108 (select-frame-set-input-focus (selected-frame)))
4110 ((and (memq method '(raise-frame maybe-frame))
4111 window-system
4112 (setq win (ido-buffer-window-other-frame buffer))
4113 (or (eq method 'raise-frame)
4114 (y-or-n-p "Jump to frame? ")))
4115 (setq newframe (window-frame win))
4116 (select-frame-set-input-focus newframe)
4117 (select-window win))
4119 ;; (eq method 'selected-window)
4121 ;; No buffer in other frames...
4122 (if record
4123 (ido-record-command 'switch-to-buffer buffer))
4124 (switch-to-buffer buffer)
4125 ))))
4128 (defun ido-buffer-window-other-frame (buffer)
4129 "Return window pointer if BUFFER is visible in another frame.
4130 If BUFFER is visible in the current frame, return nil."
4131 (let ((blist (ido-get-buffers-in-frames 'current)))
4132 ;;If the buffer is visible in current frame, return nil
4133 (if (member buffer blist)
4135 ;; maybe in other frame or icon
4136 (get-buffer-window buffer 0) ; better than 'visible
4140 ;;; ----------- IDONIZED FUNCTIONS ------------
4142 ;;;###autoload
4143 (defun ido-switch-buffer ()
4144 "Switch to another buffer.
4145 The buffer is displayed according to `ido-default-buffer-method' -- the
4146 default is to show it in the same window, unless it is already visible
4147 in another frame.
4149 As you type in a string, all of the buffers matching the string are
4150 displayed if substring-matching is used (default). Look at
4151 `ido-enable-prefix' and `ido-toggle-prefix'. When you have found the
4152 buffer you want, it can then be selected. As you type, most keys have
4153 their normal keybindings, except for the following: \\<ido-buffer-completion-map>
4155 RET\tSelect the buffer at the front of the list of matches.
4156 \tIf the list is empty, possibly prompt to create new buffer.
4158 \\[ido-select-text]\tUse the current input string verbatim.
4160 \\[ido-next-match]\tPut the first element at the end of the list.
4161 \\[ido-prev-match]\tPut the last element at the start of the list.
4162 \\[ido-complete]\tComplete a common suffix to the current string that matches
4163 \tall buffers. If there is only one match, select that buffer.
4164 \tIf there is no common suffix, show a list of all matching buffers
4165 \tin a separate window.
4166 \\[ido-edit-input]\tEdit input string.
4167 \\[ido-fallback-command]\tFallback to non-ido version of current command.
4168 \\[ido-toggle-regexp]\tToggle regexp searching.
4169 \\[ido-toggle-prefix]\tToggle between substring and prefix matching.
4170 \\[ido-toggle-case]\tToggle case-sensitive searching of buffer names.
4171 \\[ido-completion-help]\tShow list of matching buffers in separate window.
4172 \\[ido-enter-find-file]\tDrop into `ido-find-file'.
4173 \\[ido-kill-buffer-at-head]\tKill buffer at head of buffer list.
4174 \\[ido-toggle-ignore]\tToggle ignoring buffers listed in `ido-ignore-buffers'."
4175 (interactive)
4176 (ido-buffer-internal ido-default-buffer-method))
4178 ;;;###autoload
4179 (defun ido-switch-buffer-other-window ()
4180 "Switch to another buffer and show it in another window.
4181 The buffer name is selected interactively by typing a substring.
4182 For details of keybindings, see `ido-switch-buffer'."
4183 (interactive)
4184 (ido-buffer-internal 'other-window 'switch-to-buffer-other-window))
4186 ;;;###autoload
4187 (defun ido-display-buffer ()
4188 "Display a buffer in another window but don't select it.
4189 The buffer name is selected interactively by typing a substring.
4190 For details of keybindings, see `ido-switch-buffer'."
4191 (interactive)
4192 (ido-buffer-internal 'display 'display-buffer nil nil nil 'ignore))
4194 ;;;###autoload
4195 (defun ido-kill-buffer ()
4196 "Kill a buffer.
4197 The buffer name is selected interactively by typing a substring.
4198 For details of keybindings, see `ido-switch-buffer'."
4199 (interactive)
4200 (ido-buffer-internal 'kill 'kill-buffer "Kill buffer: "
4201 (buffer-name (current-buffer)) nil 'ignore))
4203 ;;;###autoload
4204 (defun ido-insert-buffer ()
4205 "Insert contents of a buffer in current buffer after point.
4206 The buffer name is selected interactively by typing a substring.
4207 For details of keybindings, see `ido-switch-buffer'."
4208 (interactive)
4209 (ido-buffer-internal 'insert 'insert-buffer "Insert buffer: "
4210 nil nil 'ido-enter-insert-file))
4212 ;;;###autoload
4213 (defun ido-switch-buffer-other-frame ()
4214 "Switch to another buffer and show it in another frame.
4215 The buffer name is selected interactively by typing a substring.
4216 For details of keybindings, see `ido-switch-buffer'."
4217 (interactive)
4218 (if ido-mode
4219 (ido-buffer-internal 'other-frame)
4220 (call-interactively 'switch-to-buffer-other-frame)))
4222 ;;;###autoload
4223 (defun ido-find-file-in-dir (dir)
4224 "Switch to another file starting from DIR."
4225 (interactive "DDir: ")
4226 (setq dir (file-name-as-directory dir))
4227 (ido-file-internal ido-default-file-method nil dir nil nil nil 'ignore))
4229 ;;;###autoload
4230 (defun ido-find-file ()
4231 "Edit file with name obtained via minibuffer.
4232 The file is displayed according to `ido-default-file-method' -- the
4233 default is to show it in the same window, unless it is already visible
4234 in another frame.
4236 The file name is selected interactively by typing a substring. As you
4237 type in a string, all of the filenames matching the string are displayed
4238 if substring-matching is used (default). Look at `ido-enable-prefix' and
4239 `ido-toggle-prefix'. When you have found the filename you want, it can
4240 then be selected. As you type, most keys have their normal keybindings,
4241 except for the following: \\<ido-file-completion-map>
4243 RET\tSelect the file at the front of the list of matches.
4244 \tIf the list is empty, possibly prompt to create new file.
4246 \\[ido-select-text]\tUse the current input string verbatim.
4248 \\[ido-next-match]\tPut the first element at the end of the list.
4249 \\[ido-prev-match]\tPut the last element at the start of the list.
4250 \\[ido-complete]\tComplete a common suffix to the current string that matches
4251 \tall files. If there is only one match, select that file.
4252 \tIf there is no common suffix, show a list of all matching files
4253 \tin a separate window.
4254 \\[ido-magic-delete-char]\tOpen the specified directory in Dired mode.
4255 \\[ido-edit-input]\tEdit input string (including directory).
4256 \\[ido-prev-work-directory]\tGo to previous directory in work directory history.
4257 \\[ido-next-work-directory]\tGo to next directory in work directory history.
4258 \\[ido-merge-work-directories]\tSearch for file in the work directory history.
4259 \\[ido-forget-work-directory]\tRemove current directory from the work directory history.
4260 \\[ido-prev-work-file]\tCycle to previous file in work file history.
4261 \\[ido-next-work-file]\tCycle to next file in work file history.
4262 \\[ido-wide-find-file-or-pop-dir]\tPrompt for a file and use find to locate it.
4263 \\[ido-wide-find-dir-or-delete-dir]\tPrompt for a directory and use find to locate it.
4264 \\[ido-make-directory]\tPrompt for a directory to create in current directory.
4265 \\[ido-fallback-command]\tFallback to non-Ido version of current command.
4266 \\[ido-toggle-regexp]\tToggle regexp searching.
4267 \\[ido-toggle-prefix]\tToggle between substring and prefix matching.
4268 \\[ido-toggle-case]\tToggle case-sensitive searching of file names.
4269 \\[ido-toggle-literal]\tToggle literal reading of this file.
4270 \\[ido-completion-help]\tShow list of matching files in separate window.
4271 \\[ido-toggle-ignore]\tToggle ignoring files listed in `ido-ignore-files'."
4273 (interactive)
4274 (ido-file-internal ido-default-file-method))
4276 ;;;###autoload
4277 (defun ido-find-file-other-window ()
4278 "Switch to another file and show it in another window.
4279 The file name is selected interactively by typing a substring.
4280 For details of keybindings, see `ido-find-file'."
4281 (interactive)
4282 (ido-file-internal 'other-window 'find-file-other-window))
4284 ;;;###autoload
4285 (defun ido-find-alternate-file ()
4286 "Switch to another file and show it in another window.
4287 The file name is selected interactively by typing a substring.
4288 For details of keybindings, see `ido-find-file'."
4289 (interactive)
4290 (ido-file-internal 'alt-file 'find-alternate-file nil "Find alternate file: "))
4292 ;;;###autoload
4293 (defun ido-find-file-read-only ()
4294 "Edit file read-only with name obtained via minibuffer.
4295 The file name is selected interactively by typing a substring.
4296 For details of keybindings, see `ido-find-file'."
4297 (interactive)
4298 (ido-file-internal 'read-only 'find-file-read-only nil "Find file read-only: "))
4300 ;;;###autoload
4301 (defun ido-find-file-read-only-other-window ()
4302 "Edit file read-only in other window with name obtained via minibuffer.
4303 The file name is selected interactively by typing a substring.
4304 For details of keybindings, see `ido-find-file'."
4305 (interactive)
4306 (ido-file-internal 'read-only 'find-file-read-only-other-window nil
4307 "Find file read-only other window: "))
4309 ;;;###autoload
4310 (defun ido-find-file-read-only-other-frame ()
4311 "Edit file read-only in other frame with name obtained via minibuffer.
4312 The file name is selected interactively by typing a substring.
4313 For details of keybindings, see `ido-find-file'."
4314 (interactive)
4315 (ido-file-internal 'read-only 'find-file-read-only-other-frame nil
4316 "Find file read-only other frame: "))
4318 ;;;###autoload
4319 (defun ido-display-file ()
4320 "Display a file in another window but don't select it.
4321 The file name is selected interactively by typing a substring.
4322 For details of keybindings, see `ido-find-file'."
4323 (interactive)
4324 (ido-file-internal 'display nil nil nil nil nil 'ignore))
4326 ;;;###autoload
4327 (defun ido-find-file-other-frame ()
4328 "Switch to another file and show it in another frame.
4329 The file name is selected interactively by typing a substring.
4330 For details of keybindings, see `ido-find-file'."
4331 (interactive)
4332 (ido-file-internal 'other-frame 'find-file-other-frame))
4334 ;;;###autoload
4335 (defun ido-write-file ()
4336 "Write current buffer to a file.
4337 The file name is selected interactively by typing a substring.
4338 For details of keybindings, see `ido-find-file'."
4339 (interactive)
4340 (let ((ido-process-ignore-lists t)
4341 (ido-work-directory-match-only nil)
4342 (ido-ignore-files (cons "[^/]\\'" ido-ignore-files))
4343 (ido-report-no-match nil)
4344 (ido-confirm-unique-completion t)
4345 (ido-auto-merge-work-directories-length -1))
4346 (ido-file-internal 'write 'write-file nil "Write file: " nil nil 'ignore)))
4348 ;;;###autoload
4349 (defun ido-insert-file ()
4350 "Insert contents of file in current buffer.
4351 The file name is selected interactively by typing a substring.
4352 For details of keybindings, see `ido-find-file'."
4353 (interactive)
4354 (ido-file-internal 'insert 'insert-file nil "Insert file: " nil nil 'ido-enter-insert-buffer))
4356 ;;;###autoload
4357 (defun ido-dired ()
4358 "Call `dired' the Ido way.
4359 The directory is selected interactively by typing a substring.
4360 For details of keybindings, see `ido-find-file'."
4361 (interactive)
4362 (let ((ido-report-no-match nil)
4363 (ido-auto-merge-work-directories-length -1))
4364 (ido-file-internal 'dired 'dired nil "Dired: " 'dir)))
4366 (defun ido-list-directory ()
4367 "Call `list-directory' the Ido way.
4368 The directory is selected interactively by typing a substring.
4369 For details of keybindings, see `ido-find-file'."
4370 (interactive)
4371 (let ((ido-report-no-match nil)
4372 (ido-auto-merge-work-directories-length -1))
4373 (ido-file-internal 'list-directory 'list-directory nil "List directory: " 'dir)))
4375 ;;; XEmacs hack for showing default buffer
4377 ;; The first time we enter the minibuffer, Emacs puts up the default
4378 ;; buffer to switch to, but XEmacs doesn't -- presumably there is a
4379 ;; subtle difference in the two versions of post-command-hook. The
4380 ;; default is shown for both whenever we delete all of our text
4381 ;; though, indicating its just a problem the first time we enter the
4382 ;; function. To solve this, we use another entry hook for emacs to
4383 ;; show the default the first time we enter the minibuffer.
4386 ;;; ICOMPLETE TYPE CODE
4388 (defun ido-initiate-auto-merge (buffer)
4389 (ido-trace "\n*merge timeout*" buffer)
4390 (setq ido-auto-merge-timer nil)
4391 (when (and (buffer-live-p buffer)
4392 (ido-active)
4393 (boundp 'ido-eoinput) ido-eoinput)
4394 (let ((contents (buffer-substring-no-properties (minibuffer-prompt-end) ido-eoinput)))
4395 (ido-trace "request merge")
4396 (setq ido-use-merged-list 'auto
4397 ido-text-init contents
4398 ido-rotate-temp t
4399 ido-exit 'refresh)
4400 (with-current-buffer buffer
4401 (ido-tidy))
4402 (throw 'ido contents))))
4404 (defun ido-exhibit ()
4405 "Post command hook for Ido."
4406 ;; Find matching files and display a list in the minibuffer.
4407 ;; Copied from `icomplete-exhibit' with two changes:
4408 ;; 1. It prints a default file name when there is no text yet entered.
4409 ;; 2. It calls my completion routine rather than the standard completion.
4411 (when (ido-active)
4412 (let ((contents (buffer-substring-no-properties (minibuffer-prompt-end) (point-max)))
4413 (buffer-undo-list t)
4414 try-single-dir-match
4415 refresh)
4417 (when ido-trace-enable
4418 (ido-trace "\nexhibit" this-command)
4419 (ido-trace "dir" ido-current-directory)
4420 (ido-trace "contents" contents)
4421 (ido-trace "list" ido-cur-list)
4422 (ido-trace "matches" ido-matches)
4423 (ido-trace "rescan" ido-rescan))
4425 (save-excursion
4426 (goto-char (point-max))
4427 ;; Register the end of input, so we know where the extra stuff (match-status info) begins:
4428 (unless (boundp 'ido-eoinput)
4429 ;; In case it got wiped out by major mode business:
4430 (make-local-variable 'ido-eoinput))
4431 (setq ido-eoinput (point))
4433 ;; Handle explicit directory changes
4434 (cond
4435 ((memq ido-cur-item '(buffer list))
4438 ((= (length contents) 0)
4441 ((= (length contents) 1)
4442 (cond
4443 ((and (ido-is-tramp-root) (string-equal contents "/"))
4444 (ido-set-current-directory ido-current-directory contents)
4445 (setq refresh t))
4446 ((and (ido-unc-hosts) (string-equal contents "/")
4447 (let ((ido-enable-tramp-completion nil))
4448 (ido-is-root-directory)))
4449 (ido-set-current-directory "//")
4450 (setq refresh t))
4453 ((and (string-match (if ido-enable-tramp-completion ".[:@]\\'" ".:\\'") contents)
4454 (ido-is-root-directory) ;; Ange-ftp or tramp
4455 (not (ido-local-file-exists-p contents)))
4456 (ido-set-current-directory ido-current-directory contents)
4457 (when (ido-is-slow-ftp-host)
4458 (setq ido-exit 'fallback)
4459 (exit-minibuffer))
4460 (setq refresh t))
4462 ((ido-final-slash contents) ;; xxx/
4463 (ido-trace "final slash" contents)
4464 (cond
4465 ((string-equal contents "~/")
4466 (ido-set-current-home)
4467 (setq refresh t))
4468 ((string-equal contents "../")
4469 (ido-up-directory t)
4470 (setq refresh t))
4471 ((string-equal contents "./")
4472 (setq refresh t))
4473 ((string-match "\\`~[-_a-zA-Z0-9]+[$]?/\\'" contents)
4474 (ido-trace "new home" contents)
4475 (ido-set-current-home contents)
4476 (setq refresh t))
4477 ((string-match "[$][A-Za-z0-9_]+/\\'" contents)
4478 (let ((exp (condition-case ()
4479 (expand-file-name
4480 (substitute-in-file-name (substring contents 0 -1))
4481 ido-current-directory)
4482 (error nil))))
4483 (ido-trace contents exp)
4484 (when (and exp (file-directory-p exp))
4485 (ido-set-current-directory (file-name-directory exp))
4486 (setq ido-text-init (file-name-nondirectory exp))
4487 (setq refresh t))))
4488 ((and (memq system-type '(windows-nt ms-dos))
4489 (string-equal (substring contents 1) ":/"))
4490 (ido-set-current-directory (file-name-directory contents))
4491 (setq refresh t))
4492 ((string-equal (substring contents -2 -1) "/")
4493 (ido-set-current-directory
4494 (if (memq system-type '(windows-nt ms-dos))
4495 (expand-file-name "/" ido-current-directory)
4496 "/"))
4497 (setq refresh t))
4498 ((and (or ido-directory-nonreadable ido-directory-too-big)
4499 (file-directory-p (concat ido-current-directory (file-name-directory contents))))
4500 (ido-set-current-directory
4501 (concat ido-current-directory (file-name-directory contents)))
4502 (setq refresh t))
4504 (ido-trace "try single dir")
4505 (setq try-single-dir-match t))))
4507 ((and (string-equal (substring contents -2 -1) "/")
4508 (not (string-match "[$]" contents)))
4509 (ido-set-current-directory
4510 (cond
4511 ((= (length contents) 2)
4512 "/")
4513 (ido-matches
4514 (concat ido-current-directory (ido-name (car ido-matches))))
4516 (concat ido-current-directory (substring contents 0 -1)))))
4517 (setq ido-text-init (substring contents -1))
4518 (setq refresh t))
4520 ((and (not ido-use-merged-list)
4521 (not (ido-final-slash contents))
4522 (eq ido-try-merged-list t)
4523 (numberp ido-auto-merge-work-directories-length)
4524 (> ido-auto-merge-work-directories-length 0)
4525 (= (length contents) ido-auto-merge-work-directories-length)
4526 (not (and ido-auto-merge-inhibit-characters-regexp
4527 (string-match ido-auto-merge-inhibit-characters-regexp contents)))
4528 (not (input-pending-p)))
4529 (setq ido-use-merged-list 'auto
4530 ido-text-init contents
4531 ido-rotate-temp t)
4532 (setq refresh t))
4534 (t nil))
4536 (when refresh
4537 (ido-trace "refresh on /" ido-text-init)
4538 (setq ido-exit 'refresh)
4539 (exit-minibuffer))
4541 (when (and ido-enter-matching-directory
4542 ido-matches
4543 (or (eq ido-enter-matching-directory 'first)
4544 (null (cdr ido-matches)))
4545 (ido-final-slash (ido-name (car ido-matches)))
4546 (or try-single-dir-match
4547 (eq ido-enter-matching-directory t)))
4548 (ido-trace "single match" (car ido-matches))
4549 (ido-set-current-directory
4550 (concat ido-current-directory (ido-name (car ido-matches))))
4551 (setq ido-exit 'refresh)
4552 (exit-minibuffer))
4554 ;; Update the list of matches
4555 (setq ido-text contents)
4556 (ido-set-matches)
4557 (ido-trace "new " ido-matches)
4559 (when (and (boundp 'ido-enable-virtual-buffers)
4560 (not (eq ido-enable-virtual-buffers 'always))
4561 (eq ido-cur-item 'buffer)
4562 (eq ido-use-virtual-buffers 'auto))
4564 (when (and (not ido-enable-virtual-buffers)
4565 (not ido-matches))
4566 (setq ido-text-init ido-text)
4567 (setq ido-enable-virtual-buffers t)
4568 (setq ido-exit 'refresh)
4569 (exit-minibuffer))
4571 ;; If input matches real buffers turn off virtual buffers.
4572 (when (and ido-enable-virtual-buffers
4573 ido-matches
4574 (ido-set-matches-1 (ido-make-buffer-list-1)))
4575 (setq ido-enable-virtual-buffers nil)
4576 (setq ido-text-init ido-text)
4577 (setq ido-exit 'refresh)
4578 (exit-minibuffer)))
4580 (when (and (not ido-matches)
4581 (not ido-directory-nonreadable)
4582 (not ido-directory-too-big)
4583 ;; ido-rescan ?
4584 ido-process-ignore-lists
4585 ido-ignored-list)
4586 (let ((ido-process-ignore-lists nil)
4587 (ido-rotate ido-rotate)
4588 (ido-cur-list ido-ignored-list))
4589 (ido-trace "try all" ido-ignored-list)
4590 (ido-set-matches))
4591 (when ido-matches
4592 (ido-trace "found " ido-matches)
4593 (setq ido-rescan t)
4594 (setq ido-process-ignore-lists-inhibit t)
4595 (setq ido-text-init ido-text)
4596 (setq ido-exit 'refresh)
4597 (exit-minibuffer)))
4599 (when (and
4600 ido-rescan
4601 (not ido-matches)
4602 (memq ido-cur-item '(file dir))
4603 (not (ido-is-root-directory))
4604 (> (length contents) 1)
4605 (not (string-match "[$]" contents))
4606 (not ido-directory-nonreadable)
4607 (not ido-directory-too-big))
4608 (ido-trace "merge?")
4609 (if ido-use-merged-list
4610 (ido-undo-merge-work-directory contents nil)
4611 (when (and (eq ido-try-merged-list t)
4612 (numberp ido-auto-merge-work-directories-length)
4613 (= ido-auto-merge-work-directories-length 0)
4614 (not (and ido-auto-merge-inhibit-characters-regexp
4615 (string-match ido-auto-merge-inhibit-characters-regexp contents)))
4616 (not (input-pending-p)))
4617 (ido-trace "\n*start timer*")
4618 (setq ido-auto-merge-timer
4619 (run-with-timer ido-auto-merge-delay-time nil 'ido-initiate-auto-merge (current-buffer))))))
4621 (setq ido-rescan t)
4623 (if (and ido-use-merged-list
4624 ido-matches
4625 (not (string-equal (car (cdr (car ido-matches))) ido-current-directory)))
4626 (progn
4627 (ido-set-current-directory (car (cdr (car ido-matches))))
4628 (setq ido-use-merged-list t
4629 ido-exit 'keep
4630 ido-text-init ido-text)
4631 (exit-minibuffer)))
4633 ;; Insert the match-status information:
4634 (ido-set-common-completion)
4635 (let ((inf (ido-completions contents)))
4636 (setq ido-show-confirm-message nil)
4637 (ido-trace "inf" inf)
4638 (insert inf))
4639 ))))
4641 (defun ido-completions (name)
4642 "Return the string that is displayed after the user's text.
4643 Modified from `icomplete-completions'."
4644 (let* ((comps ido-matches)
4645 (ind (and (consp (car comps)) (> (length (cdr (car comps))) 1)
4646 ido-merged-indicator))
4647 first)
4649 (if (and ind ido-use-faces)
4650 (put-text-property 0 1 'face 'ido-indicator ind))
4652 (if (and ido-use-faces comps)
4653 (let* ((fn (ido-name (car comps)))
4654 (ln (length fn)))
4655 (setq first (format "%s" fn))
4656 (put-text-property 0 ln 'face
4657 (if (= (length comps) 1)
4658 (if ido-incomplete-regexp
4659 'ido-incomplete-regexp
4660 'ido-only-match)
4661 'ido-first-match)
4662 first)
4663 (if ind (setq first (concat first ind)))
4664 (setq comps (cons first (cdr comps)))))
4666 (cond ((null comps)
4667 (cond
4668 (ido-show-confirm-message
4669 (or (nth 10 ido-decorations) " [Confirm]"))
4670 (ido-directory-nonreadable
4671 (or (nth 8 ido-decorations) " [Not readable]"))
4672 (ido-directory-too-big
4673 (or (nth 9 ido-decorations) " [Too big]"))
4674 (ido-report-no-match
4675 (nth 6 ido-decorations)) ;; [No match]
4676 (t "")))
4677 (ido-incomplete-regexp
4678 (concat " " (car comps)))
4679 ((null (cdr comps)) ;one match
4680 (concat (if (if (not ido-enable-regexp)
4681 (= (length (ido-name (car comps))) (length name))
4682 ;; We can't rely on the length of the input
4683 ;; for regexps, so explicitly check for a
4684 ;; complete match
4685 (string-match name (ido-name (car comps)))
4686 (string-equal (match-string 0 (ido-name (car comps)))
4687 (ido-name (car comps))))
4689 ;; When there is only one match, show the matching file
4690 ;; name in full, wrapped in [ ... ].
4691 (concat
4692 (or (nth 11 ido-decorations) (nth 4 ido-decorations))
4693 (ido-name (car comps))
4694 (or (nth 12 ido-decorations) (nth 5 ido-decorations))))
4695 (if (not ido-use-faces) (nth 7 ido-decorations)))) ;; [Matched]
4696 (t ;multiple matches
4697 (let* ((items (if (> ido-max-prospects 0) (1+ ido-max-prospects) 999))
4698 (alternatives
4699 (apply
4700 #'concat
4701 (cdr (apply
4702 #'nconc
4703 (mapcar
4704 (lambda (com)
4705 (setq com (ido-name com))
4706 (setq items (1- items))
4707 (cond
4708 ((< items 0) ())
4709 ((= items 0) (list (nth 3 ido-decorations))) ; " | ..."
4711 (list (or ido-separator (nth 2 ido-decorations)) ; " | "
4712 (let ((str (substring com 0)))
4713 (if (and ido-use-faces
4714 (not (string= str first))
4715 (ido-final-slash str))
4716 (put-text-property 0 (length str) 'face 'ido-subdir str))
4717 str)))))
4718 comps))))))
4720 (concat
4721 ;; put in common completion item -- what you get by pressing tab
4722 (if (and (stringp ido-common-match-string)
4723 (> (length ido-common-match-string) (length name)))
4724 (concat (nth 4 ido-decorations) ;; [ ... ]
4725 (substring ido-common-match-string (length name))
4726 (nth 5 ido-decorations)))
4727 ;; list all alternatives
4728 (nth 0 ido-decorations) ;; { ... }
4729 alternatives
4730 (nth 1 ido-decorations)))))))
4732 (defun ido-minibuffer-setup ()
4733 "Minibuffer setup hook for Ido."
4734 ;; Copied from `icomplete-minibuffer-setup-hook'.
4735 (when (ido-active)
4736 (add-hook 'pre-command-hook 'ido-tidy nil t)
4737 (add-hook 'post-command-hook 'ido-exhibit nil t)
4738 (when (featurep 'xemacs)
4739 (ido-exhibit)
4740 (goto-char (point-min)))
4741 (run-hooks 'ido-minibuffer-setup-hook)
4742 (when ido-initial-position
4743 (goto-char (+ (minibuffer-prompt-end) ido-initial-position))
4744 (setq ido-initial-position nil))))
4746 (defun ido-tidy ()
4747 "Pre command hook for Ido."
4748 ;; Remove completions display, if any, prior to new user input.
4749 ;; Copied from `icomplete-tidy'."
4751 (when ido-auto-merge-timer
4752 (ido-trace "\n*cancel timer*" this-command)
4753 (cancel-timer ido-auto-merge-timer)
4754 (setq ido-auto-merge-timer nil))
4756 (when (ido-active)
4757 (if (bound-and-true-p ido-eoinput)
4758 (if (> ido-eoinput (point-max))
4759 ;; Oops, got rug pulled out from under us - reinit:
4760 (setq ido-eoinput (point-max))
4761 (let ((inhibit-read-only t)
4762 (buffer-undo-list t))
4763 (delete-region ido-eoinput (point-max))))
4765 ;; Reestablish the local variable 'cause minibuffer-setup is weird:
4766 (make-local-variable 'ido-eoinput)
4767 (setq ido-eoinput 1))))
4769 (defun ido-summary-buffers-to-end ()
4770 ;; Move the summaries to the end of the buffer list.
4771 ;; This is an example function which can be hooked on to
4772 ;; `ido-make-buffer-list-hook'. Any buffer matching the regexps
4773 ;; `Summary' or `output\*$'are put to the end of the list.
4774 (let ((summaries (delq nil (mapcar
4775 (lambda (x)
4776 (if (or
4777 (string-match "Summary" x)
4778 (string-match "output\\*\\'" x))
4780 ido-temp-list))))
4781 (ido-to-end summaries)))
4783 ;;; Helper functions for other programs
4785 (put 'ibuffer-find-file 'ido 'find-file)
4786 (put 'dired 'ido 'dir)
4787 (put 'dired-other-window 'ido 'dir)
4788 (put 'dired-other-frame 'ido 'dir)
4789 ;; See http://debbugs.gnu.org/11954 for reasons.
4790 (put 'dired-do-copy 'ido 'ignore)
4791 (put 'dired-do-rename 'ido 'ignore)
4793 ;;;###autoload
4794 (defun ido-read-buffer (prompt &optional default require-match predicate)
4795 "Ido replacement for the built-in `read-buffer'.
4796 Return the name of a buffer selected.
4797 PROMPT is the prompt to give to the user. DEFAULT if given is the default
4798 buffer to be selected, which will go to the front of the list.
4799 If REQUIRE-MATCH is non-nil, an existing buffer must be selected."
4800 (let* ((ido-current-directory nil)
4801 (ido-directory-nonreadable nil)
4802 (ido-directory-too-big nil)
4803 (ido-context-switch-command 'ignore)
4804 (buf (ido-read-internal 'buffer prompt 'ido-buffer-history default require-match)))
4805 (if (eq ido-exit 'fallback)
4806 (let ((read-buffer-function nil))
4807 (run-hook-with-args 'ido-before-fallback-functions 'read-buffer)
4808 (read-buffer prompt default require-match predicate))
4809 buf)))
4811 ;;;###autoload
4812 (defun ido-read-file-name (prompt &optional dir default-filename mustmatch initial predicate)
4813 "Ido replacement for the built-in `read-file-name'.
4814 Read file name, prompting with PROMPT and completing in directory DIR.
4815 See `read-file-name' for additional parameters."
4816 (let (filename)
4817 (cond
4818 ((or (eq predicate 'file-directory-p)
4819 (eq (and (symbolp this-command)
4820 (get this-command 'ido)) 'dir)
4821 (memq this-command ido-read-file-name-as-directory-commands))
4822 (setq filename
4823 (ido-read-directory-name prompt dir default-filename mustmatch initial)))
4824 ((and (not (eq (and (symbolp this-command)
4825 (get this-command 'ido)) 'ignore))
4826 (not (memq this-command ido-read-file-name-non-ido))
4827 (or (null predicate) (eq predicate 'file-exists-p)))
4828 (let* (ido-saved-vc-hb
4829 (ido-context-switch-command
4830 (if (eq (and (symbolp this-command)
4831 (get this-command 'ido)) 'find-file)
4832 nil 'ignore))
4833 (vc-handled-backends (and (boundp 'vc-handled-backends) vc-handled-backends))
4834 (minibuffer-completing-file-name t)
4835 (ido-current-directory (ido-expand-directory dir))
4836 (ido-directory-nonreadable (not (file-readable-p ido-current-directory)))
4837 (ido-directory-too-big (and (not ido-directory-nonreadable)
4838 (ido-directory-too-big-p ido-current-directory)))
4839 (ido-work-directory-index -1)
4840 (ido-show-dot-for-dired (and ido-show-dot-for-dired
4841 (not default-filename)))
4842 (ido-work-file-index -1)
4843 (ido-find-literal nil))
4844 (setq ido-exit nil)
4845 (setq filename
4846 (ido-read-internal 'file prompt 'ido-file-history
4847 (cond ; Bug#11861.
4848 ((stringp default-filename) default-filename)
4849 ((consp default-filename) (car default-filename))
4850 ((and (not default-filename) initial)
4851 (expand-file-name initial dir))
4852 (buffer-file-name buffer-file-name))
4853 mustmatch initial))
4854 (setq dir ido-current-directory) ; See bug#1516.
4855 (cond
4856 ((eq ido-exit 'fallback)
4857 (setq filename 'fallback))
4858 ((eq ido-exit 'dired)
4859 (setq filename ido-current-directory))
4860 (filename
4861 (setq filename
4862 (concat ido-current-directory filename))))))
4864 (setq filename 'fallback)))
4865 (if (eq filename 'fallback)
4866 (let ((read-file-name-function nil))
4867 (run-hook-with-args 'ido-before-fallback-functions 'read-file-name)
4868 (read-file-name prompt dir default-filename mustmatch initial predicate))
4869 filename)))
4871 ;;;###autoload
4872 (defun ido-read-directory-name (prompt &optional dir default-dirname mustmatch initial)
4873 "Ido replacement for the built-in `read-directory-name'.
4874 Read directory name, prompting with PROMPT and completing in directory DIR.
4875 See `read-directory-name' for additional parameters."
4876 (let* (filename
4877 (minibuffer-completing-file-name t)
4878 (ido-context-switch-command 'ignore)
4879 ido-saved-vc-hb
4880 (ido-current-directory (ido-expand-directory dir))
4881 (ido-directory-nonreadable (not (file-readable-p ido-current-directory)))
4882 (ido-directory-too-big (and (not ido-directory-nonreadable)
4883 (ido-directory-too-big-p ido-current-directory)))
4884 (ido-work-directory-index -1)
4885 (ido-work-file-index -1))
4886 (setq filename (ido-read-internal
4887 'dir prompt 'ido-file-history
4888 (or default-dirname ; Bug#11861.
4889 (if initial
4890 (expand-file-name initial ido-current-directory)
4891 ido-current-directory))
4892 mustmatch initial))
4893 (cond
4894 ((eq ido-exit 'fallback)
4895 (let ((read-file-name-function nil))
4896 (run-hook-with-args 'ido-before-fallback-functions 'read-directory-name)
4897 (read-directory-name prompt ido-current-directory
4898 default-dirname mustmatch initial)))
4899 ((equal filename ".") ido-current-directory)
4900 (t (concat ido-current-directory filename)))))
4902 ;;;###autoload
4903 (defun ido-completing-read (prompt choices &optional _predicate require-match
4904 initial-input hist def _inherit-input-method)
4905 "Ido replacement for the built-in `completing-read'.
4906 Read a string in the minibuffer with Ido-style completion.
4907 PROMPT is a string to prompt with; normally it ends in a colon and a space.
4908 CHOICES is a list of strings which are the possible completions.
4909 PREDICATE and INHERIT-INPUT-METHOD are currently ignored; they are included
4910 to be compatible with `completing-read'.
4911 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
4912 the input is (or completes to) an element of CHOICES or is null.
4913 If the input is null, `ido-completing-read' returns DEF, or an empty
4914 string if DEF is nil, regardless of the value of REQUIRE-MATCH.
4915 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
4916 with point positioned at the end.
4917 HIST, if non-nil, specifies a history list.
4918 DEF, if non-nil, is the default value."
4919 (let ((ido-current-directory nil)
4920 (ido-directory-nonreadable nil)
4921 (ido-directory-too-big nil)
4922 (ido-context-switch-command 'ignore)
4923 (ido-choice-list choices))
4924 ;; Initialize ido before invoking ido-read-internal
4925 (ido-common-initialization)
4926 (ido-read-internal 'list prompt hist def require-match initial-input)))
4928 (defun ido-unload-function ()
4929 "Unload the Ido library."
4930 (ido-mode -1)
4931 (setq minor-mode-map-alist (assq-delete-all 'ido-mode minor-mode-map-alist))
4932 ;; continue standard unloading
4933 nil)
4935 (provide 'ido)
4937 ;;; ido.el ends here