1 ;;; ido.el --- interactively do things with buffers and files.
3 ;; Copyright (C) 1996-2002 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 2, or (at your option)
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; see the file COPYING. If not, write to the
23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 ;; Boston, MA 02111-1307, USA.
28 ;; Infinite amounts of gratitude goes to Stephen Eglen <stephen@cns.ed.ac.uk>
29 ;; who wrote iswitch-buffer mode - from which I ripped off 99% of the code
30 ;; for ido-switch-buffer and found the inspiration for ido-find-file.
31 ;; The ido package would never have existed without his work.
33 ;; Also thanks to Klaus Berndl, Rohit Namjoshi, Robert Fenk, Alex Schroeder,
34 ;; Bill Benedetto, and Stephen Eglen for bug fixes and improvements.
38 ;; Since I discovered Stephen Eglen's excellent iswitchb package, I just
39 ;; couldn't live without it, but once being addicted to switching buffers
40 ;; with a minimum of keystrokes, I soon found that opening files in the
41 ;; old-fashioned way was just too slow - so I decided to write a package
42 ;; which could open files with the same speed and ease as iswitchb could
45 ;; I originally wrote a separate ifindf.el package based on a copy of
46 ;; iswitchb.el, which did for opening files what iswitchb did for
47 ;; switching buffers. Along the way, I corrected a few errors in
48 ;; ifindf which could have found its way back into iswitchb, but since
49 ;; most of the functionality of the two package was practically
50 ;; identical, I decided that the proper thing to do was to merge my
51 ;; ifindf package back into iswitchb.
53 ;; This is basically what ido (interactively do) is all about; but I
54 ;; found it ackward to merge my changes into the "iswitchb-" namespace,
55 ;; so I invented a common "ido-" namespace for the merged packages.
57 ;; This version is based on ido.el version 1.57 released on
58 ;; gnu.emacs.sources adapted for emacs 21.4 to use command remapping
59 ;; and optionally hooking the read-buffer and read-file-name functions.
61 ;; Prefix matching was added by Klaus Berndl <klaus.berndl@sdm.de> based on
62 ;; an idea of Yuji Minejima <ggb01164@nifty.ne.jp> and his mcomplete-package.
67 ;; Ido - interactive do - switches between buffers and opens files and
68 ;; directories with a minimum of keystrokes. It is a superset of
69 ;; iswitchb, the interactive buffer switching package by Stephen Eglen.
71 ;; Interactive substring matching
72 ;; ------------------------------
74 ;; As you type in a substring, the list of buffers or files currently
75 ;; matching the substring are displayed as you type. The list is
76 ;; ordered so that the most recent buffers or files visited come at
77 ;; the start of the list.
79 ;; The buffer or file at the start of the list will be the one visited
80 ;; when you press RETURN. By typing more of the substring, the list is
81 ;; narrowed down so that gradually the buffer or file you want will be
82 ;; at the top of the list. Alternatively, you can use C-s and C-r (or
83 ;; the right and left arrow keys) to rotate buffer or file names in the
84 ;; list until the one you want is at the top of the list.
86 ;; Completion is also available so that you can see what is common to
87 ;; all of the matching buffers or files as you type.
91 ;; If I have two buffers called "123456" and "123", with "123456" the
92 ;; most recent, when I use ido-switch-buffer, I first of all get
93 ;; presented with the list of all the buffers
95 ;; Buffer: {123456,123}
98 ;; Buffer: 2[3]{123456,123}
100 ;; The list in {...} are the matching buffers, most recent first
101 ;; (buffers visible in the current frame are put at the end of the
102 ;; list by default). At any time I can select the item at the head of
103 ;; the list by pressing RET. I can also bring the put the first
104 ;; element at the end of the list by pressing C-s or [right], or put
105 ;; the last element at the head of the list by pressing C-r or [left].
107 ;; The item in [...] indicates what can be added to my input by
108 ;; pressing TAB. In this case, I will get "3" added to my input.
111 ;; Buffer: 23{123456,123}
113 ;; At this point, I still have two matching buffers.
114 ;; If I want the first buffer in the list, I simply press RET. If I
115 ;; wanted the second in the list, I could press C-s to move it to the
116 ;; top of the list and then RET to select it.
118 ;; However, if I type 4, I only have one match left:
119 ;; Buffer: 234[123456] [Matched]
121 ;; Since there is only one matching buffer left, it is given in [] and we
122 ;; see the text [Matched] afterwards. I can now press TAB or RET to go
125 ;; If however, I now type "a":
126 ;; Buffer: 234a [No match]
127 ;; There are no matching buffers. If I press RET or TAB, I can be
128 ;; prompted to create a new buffer called "234a".
130 ;; Of course, where this function comes in really useful is when you
131 ;; can specify the buffer using only a few keystrokes. In the above
132 ;; example, the quickest way to get to the "123456" file would be
133 ;; just to type 4 and then RET (assuming there isn't any newer buffer
134 ;; with 4 in its name).
136 ;; Likewise, if you use C-x C-f (ido-find-file), the list of files and
137 ;; directories in the current directory is provided in the same
138 ;; fashion as the buffers above. The files and directories are
139 ;; normally sorted in alphabetical order, but the most recently
140 ;; visited directory is placed first to speed up navigating to
141 ;; directories that you have visited recently.
143 ;; In addition to scrolling through the list using [right] and [left],
144 ;; you can use [up] and [down] to quickly scroll the list to the next
145 ;; or previous subdirectory.
147 ;; To go down into a subdirectory, and continue the file selection on
148 ;; the files in that directory, simply move the directory to the head
149 ;; of the list and hit RET.
151 ;; To go up to the parent directory, delete any partial file name
152 ;; already specified (e.g. using [backspace]) and hit [backspace].
154 ;; To go to the root directory (on the current drive), enter two
155 ;; slashes. On MS-DOS or Windows, to select the root of another
156 ;; drive, enter X:/ where X is the drive letter. You can also visit
157 ;; files on other hosts using the ange-ftp notations `/host:' and
158 ;; `/user@host:'. See the variable `ido-slow-ftp-hosts' if you want
159 ;; to inhibit the ido substring matching for ftp access.
161 ;; If for some reason you cannot specify the proper file using
162 ;; ido-find-file, you can press C-f to enter the normal find-file.
163 ;; You can also press C-b to drop into ido-switch-buffer.
165 ;; See the doc string of ido-switch-buffer and ido-find-file for full
166 ;; keybindings and features.
167 ;; (describe-function 'ido-find-file)
169 ;; Hidden buffers and files
170 ;; ------------------------
172 ;; Normally, ido does not include hidden buffers (whose name starts
173 ;; with a space) and hidden files and directories (whose name starts
174 ;; with `.') in the list of possible completions. However, if the
175 ;; substring you enter does not match any of the visible buffers or
176 ;; files, ido will automatically look for completions among the hidden
179 ;; You can toggle display of the hidden buffers and files with C-a.
181 ;; Additional functionality
182 ;; ------------------------
184 ;; After C-x b, the buffer at the head of the list can be killed by
185 ;; pressing C-k. If the buffer needs saving, you will be queried
186 ;; before the buffer is killed.
188 ;; Likewise, after C-x C-f, you can delete (i.e. physically remove)
189 ;; the file at the head of the list with C-k. You will always be
190 ;; asked for confirmation before the file is deleted.
192 ;; If you enter C-x b to switch to a buffer visiting a given file, and
193 ;; you find that the file you are after is not in any buffer, you can
194 ;; press C-f to immediately drop into ido-find-file. And you can
195 ;; switch back to buffer selection with C-b.
200 ;; The standard way of completion with Unix-shells and Emacs is to insert a
201 ;; PREFIX and then hitting TAB (or another completion key). Cause of this
202 ;; behavior has become second nature to a lot of emacs users `ido' offers in
203 ;; addition to the default substring-matching-method (look above) also the
204 ;; prefix-matching-method. The kind of matching is the only difference to
205 ;; the description of the substring-matching above.
207 ;; You can toggle prefix matching with C-p.
211 ;; If you have again two Buffers "123456" and "123" then hitting "2" does
212 ;; not match because "2" is not a PREFIX in any of the buffer-names. This
213 ;; is the only difference between the substring and prefix matching.
218 ;; If you set ido-enable-flex-matching, ido will do a more flexible
219 ;; matching (unless regexp matching is active) to find possible matches
220 ;; among the available buffer or file names if no matches are found using
221 ;; the normal prefix or substring matching.
223 ;; The flexible matching implies that any item which simply contains all
224 ;; of the entered characters in the specified sequence will match.
228 ;; If you have four files "alpha", "beta", "gamma", and "delta",
229 ;; entering "aa" will match "alpha" and "gamma", while "ea" matches
230 ;; "beta" and "delta". If prefix matching is also active, "aa" only
231 ;; matches "alpha", while "ea" does not match any files.
236 ;; There is limited provision for regexp matching within ido,
237 ;; enabled through `ido-enable-regexp' (toggle with C-t).
238 ;; This allows you to type `c$' for example and see all file names
239 ;; ending in `c'. This facility is quite limited though in two
240 ;; respects. First, you can't currently type in expressions like
241 ;; `[0-9]' directly -- you have to type them in when ido-enable-regexp
242 ;; is nil and then toggle on the regexp functionality. Likewise,
243 ;; don't enter an expression containing `\' in regexp mode. If you
244 ;; try, ido gets confused, so just hit C-g and try again. Secondly,
245 ;; no completion mechanism is currently offered with regexp searching.
251 ;; Customize the `ido' group to change the `ido' functionality.
253 ;; To modify the keybindings, use the hook provided. For example:
254 ;;(add-hook 'ido-define-mode-map-hook 'ido-my-keys)
256 ;;(defun ido-my-keys ()
257 ;; "Add my keybindings for ido."
258 ;; (define-key ido-mode-map " " 'ido-next-match)
261 ;; Seeing all the matching buffers or files
262 ;; ----------------------------------------
264 ;; If you have many matching files, they may not all fit onto one
265 ;; line of the minibuffer. Normally, the minibuffer window will grow
266 ;; to show you more of the matching files (depending on the setting
267 ;; of the variables `resize-mini-windows' and `max-mini-window-height').
268 ;; If you want ido to behave differently from the default minibuffer
269 ;; resizing behaviour, set the variable `ido-max-window-height'.
271 ;; Also, to improve the responsiveness of ido, the maximum number of
272 ;; matching items is limited to 12, but you can increase or removed
273 ;; this limit via the `ido-max-prospects' variable.
275 ;; To see a full list of all matching buffers in a separate buffer,
276 ;; hit ? or press TAB when there are no further completions to the
277 ;; substring. Repeated TAB presses will scroll you through this
280 ;; Changing the list of files
281 ;; --------------------------
283 ;; By default, the list of current files is most recent first,
284 ;; oldest last, with the exception that the files visible in the
285 ;; current frame are put at the end of the list. A hook exists to
286 ;; allow other functions to order the list. For example, if you add:
288 ;; (add-hook 'ido-make-buffer-list-hook 'ido-summary-buffers-to-end)
290 ;; then all files matching "Summary" are moved to the end of the
291 ;; list. (I find this handy for keeping the INBOX Summary and so on
292 ;; out of the way.) It also moves files matching "output\*$" to the
293 ;; end of the list (these are created by AUC TeX when compiling.)
294 ;; Other functions could be made available which alter the list of
295 ;; matching files (either deleting or rearranging elements.)
300 ;; The highlighting of matching items is controlled via ido-use-faces.
301 ;; The faces used are ido-first-match-face, ido-only-match-face and
303 ;; Colouring of the matching item was suggested by
304 ;; Carsten Dominik (dominik@strw.leidenuniv.nl).
306 ;; Replacement for read-buffer and read-file-name
307 ;; ----------------------------------------------
309 ;; ido-read-buffer and ido-read-file-name have been written to be drop
310 ;; in replacements for the normal buffer and file name reading
311 ;; functions `read-buffer' and `read-file-name'.
313 ;; To use ido for all buffer and file selections in Emacs, customize the
314 ;; variable `ido-everywhere'.
316 ;; Using ido-like behaviour in other lisp packages
317 ;; -----------------------------------------------
319 ;; If you don't want to rely on the `ido-everywhere' functionality,
320 ;; ido-read-buffer, ido-read-file-name, and ido-read-directory-name
321 ;; can be used by other packages to read a buffer name, a file name,
322 ;; or a directory name in the `ido' way.
331 ;; These are some things you might want to change.
333 (defun ido-fractionp (n)
334 (and (numberp n
) (> n
0.0) (<= n
1.0)))
337 "Switch between files using substrings."
340 :link
'(emacs-commentary-link :tag
"Commentary" "ido.el")
341 :link
'(emacs-library-link :tag
"Lisp File" "ido.el"))
344 (defcustom ido-mode nil
345 "Determines for which functional group \(buffer and files) ido behavior
346 should be enabled. The following values are possible:
347 - 'buffer: Turn only on ido buffer behavior \(switching, killing,
349 - 'file: Turn only on ido file behavior \(finding, writing, inserting...)
350 - 'both: Turn on ido buffer and file behavior.
351 - nil: Turn off any ido switching.
353 Setting this variable directly does not take effect;
354 use either \\[customize] or the function `ido-mode'."
355 :set
#'(lambda (symbol value
)
357 :initialize
'custom-initialize-default
359 :link
'(emacs-commentary-link "ido.el")
360 :set-after
'(ido-save-directory-list-file)
362 :type
'(choice (const :tag
"Turn on only buffer" buffer
)
363 (const :tag
"Turn on only file" file
)
364 (const :tag
"Turn on both buffer and file" both
)
365 (const :tag
"Switch off all" nil
))
368 (defcustom ido-everywhere nil
369 "Use ido everywhere for reading file names and directories.
370 Setting this variable directly does not work. Use `customize' or
371 call the function `ido-everywhere'."
372 :set
#'(lambda (symbol value
)
373 (ido-everywhere value
))
374 :initialize
'custom-initialize-default
378 (defcustom ido-case-fold case-fold-search
379 "*Non-nil if searching of buffer and file names should ignore case."
383 (defcustom ido-ignore-buffers
385 "*List of regexps or functions matching buffer names to ignore.
386 For example, traditional behavior is not to list buffers whose names begin
387 with a space, for which the regexp is `\\` '. See the source file for
388 example functions that filter buffernames."
389 :type
'(repeat (choice regexp function
))
392 (defcustom ido-ignore-files
393 '("\\`CVS/" "\\`#" "\\`.#" "\\`\\.\\./" "\\`\\./")
394 "*List of regexps or functions matching file names to ignore.
395 For example, traditional behavior is not to list files whose names begin
396 with a #, for which the regexp is `\\`#'. See the source file for
397 example functions that filter filenames."
398 :type
'(repeat (choice regexp function
))
401 (defcustom ido-ignore-extensions t
402 "*Non-nil means ignore files in completion-ignored-extensions list."
406 (defcustom ido-show-dot-for-dired nil
407 "*Non-nil means to always put . as the first item in file name lists.
408 This allows the current directory to be opened immediate with `dired'."
412 (defcustom ido-ignore-directories
413 '("\\`CVS/" "\\`\\.\\./" "\\`\\./")
414 "*List of regexps or functions matching sub-directory names to ignore."
415 :type
'(repeat (choice regexp function
))
418 (defcustom ido-ignore-directories-merge nil
419 "*List of regexps or functions matching directory path names to ignore during merge.
420 Directory paths matched by one of the regexps in this list are not inserted
421 in merged file and directory lists."
422 :type
'(repeat (choice regexp function
))
425 ;;; Examples for setting the value of ido-ignore-buffers
426 ;(defun ido-ignore-c-mode (name)
427 ; "Ignore all c mode buffers -- example function for ido."
430 ; (string-match "^C$" mode-name)))
432 ;(setq ido-ignore-buffers '("^ " ido-ignore-c-mode))
434 ;;; Examples for setting the value of ido-ignore-files
435 ;(setq ido-ignore-files '("^ " "\\.c$" "\\.h$"))
437 (defcustom ido-default-file-method
'always-frame
438 "*How to switch to new file when using `ido-find-file'.
440 `samewindow' Show new file in same window
441 `otherwindow' Show new file in another window (same frame)
442 `display' Display file in another window without switching to it
443 `otherframe' Show new file in another frame
444 `maybe-frame' If a file is visible in another frame, prompt to ask if you
445 you want to see the file in the same window of the current
446 frame or in the other frame.
447 `always-frame' If a file is visible in another frame, raise that
448 frame. Otherwise, visit the file in the same window."
449 :type
'(choice (const samewindow
)
454 (const always-frame
))
457 (defcustom ido-default-buffer-method
'always-frame
458 "*How to switch to new buffer when using `ido-switch-buffer'.
459 See ido-default-file-method for details."
460 :type
'(choice (const samewindow
)
465 (const always-frame
))
468 (defcustom ido-enable-flex-matching nil
469 "*Non-nil means that `ido' will do flexible string matching.
470 Flexible matching means that if the entered string does not
471 match any item, any item containing the entered characters
472 in the given sequence will match."
477 (defcustom ido-enable-regexp nil
478 "*Non-nil means that `ido' will do regexp matching.
479 Value can be toggled within `ido' using `ido-toggle-regexp'."
483 (defcustom ido-enable-prefix nil
484 "*Nil means that `ido' will match if the inserted text is an
485 arbitrary substring (default). If non-nil `ido' will only match if the inserted
486 text is a prefix \(this behavior is like the standard unix- or
487 emacs-completion works).
488 Value can be toggled within `ido' using `ido-toggle-prefix'."
492 (defcustom ido-cannot-complete-command
'ido-completion-help
493 "*Command run when `ido-complete' can't complete any more.
494 The most useful values are `ido-completion-help', which pops up a
495 window with completion alternatives, or `ido-next-match' or
496 `ido-prev-match', which cycle the buffer list."
501 (defcustom ido-record-commands t
502 "*Non-nil means that `ido' will record commands in command history.
503 Note that the non-ido equivalent command is recorded."
507 (defcustom ido-max-prospects
12
508 "*Non-zero means that the prospect list will be limited to than number of items.
509 For a long list of prospects, building the full list for the minibuffer can take a
510 non-negletable amount of time; setting this variable reduces that time."
514 (defcustom ido-max-prompt-path
0.35
515 "*Non-zero means that the prompt string be limited to than number of characters.
516 If value is a floating point number, it specifies a fraction of the frame width."
518 (integer :tag
"Characters" :value
20)
519 (restricted-sexp :tag
"Fraction of frame width"
521 :match-alternatives
(ido-fractionp)))
524 (defcustom ido-max-window-height nil
525 "*Non-nil specifies a value to override `max-mini-window-height'."
527 (const :tag
"Don't override" nil
)
528 (integer :tag
"Number of lines" :value
1)
530 :tag
"Fraction of window height"
532 :match-alternatives
(ido-fractionp)))
535 (defcustom ido-enable-last-directory-history t
536 "*Non-nil means that `ido' will remember latest selected directory paths.
537 See `ido-last-directory-list' and `ido-save-directory-list-file'."
541 (defcustom ido-max-work-directory-list
50
542 "*Maximum number of working directories to record.
543 This is the list of directories where files have most recently been opened.
544 See `ido-work-directory-list' and `ido-save-directory-list-file'."
548 (defcustom ido-work-directory-list-ignore-regexps nil
549 "*List of regexps matching directories which should not be recorded.
550 Directory paths matched by one of the regexps in this list are not inserted in
551 the `ido-work-directory-list' list."
552 :type
'(repeat regexp
)
555 (defcustom ido-record-ftp-work-directories t
556 "*Non-nil means that ftp paths are recorded in work directory list."
560 (defcustom ido-merge-ftp-work-directories nil
561 "*Nil means that ftp paths in work directory list are ignored during merge."
565 (defcustom ido-cache-ftp-work-directory-time
1.0
566 "*Maximum time to cache contents of an ftp directory (in hours).
567 If zero, ftp directories are not cached."
571 (defcustom ido-slow-ftp-hosts nil
572 "*List of slow ftp hosts where ido prompting should not be used.
573 If an ftp host is on this list, ido automatically switches to the non-ido
574 equivalent function, e.g. find-file rather than ido-find-file."
575 :type
'(repeat string
)
578 (defcustom ido-slow-ftp-host-regexps nil
579 "*List of regexps matching slow ftp hosts (see `ido-slow-ftp-hosts')."
580 :type
'(repeat regexp
)
583 (defcustom ido-max-work-file-list
10
584 "*Maximum number of names of recently opened files to record.
585 This is the list the file names (sans directory) which have most recently
586 been opened. See `ido-work-file-list' and `ido-save-directory-list-file'."
590 (defcustom ido-work-directory-match-only t
591 "*Non-nil means to skip non-matching directories in the directory history.
592 When some text is already entered at the `ido-find-file' prompt, using
593 \\[ido-prev-work-directory] or \\[ido-next-work-directory] will skip directories
594 without any matching entries."
598 (defcustom ido-auto-merge-work-directories-length
0
599 "*Automatically switch to merged work directories during file name input.
600 The value is number of characters to type before switching to merged mode.
601 If zero, the switch happens when no matches are found in the current directory.
602 Automatic merging is disabled if the value is negative."
606 (defcustom ido-auto-merge-delay-time
0.70
607 "*Delay in seconds to wait for more input before doing auto merge."
611 (defcustom ido-auto-merge-inhibit-characters-regexp
"[][*?~]"
612 "*Regexp matching characters which should inhibit automatic merging.
613 When a (partial) file name matches this regexp, merging is inhibited."
617 (defcustom ido-merged-indicator
"^"
618 "The string appended to first choice if it has multiple directory choices."
622 (defcustom ido-max-dir-file-cache
100
623 "*Maximum number of working directories to be cached.
624 This is the size of the cache of file-name-all-completions results.
625 Each cache entry is time stamped with the modification time of the
626 directory. Some systems, like Windows, have unreliable directory
627 modification times, so you may choose to disable caching on such
628 systems, or explicitly refresh the cache contents using the command
629 `ido-reread-directory' command (C-l) in the minibuffer.
630 See also `ido-dir-file-cache' and `ido-save-directory-list-file'."
634 (defcustom ido-rotate-file-list-default nil
635 "*Non-nil means that `ido' will always rotate file list to get default in front."
639 (defcustom ido-enter-single-matching-directory nil
640 "*Automatically enter sub-directory if it is the only matching item, if non-nil.
641 If value is 'slash, only enter if typing final slash, else do it always."
642 :type
'(choice (const :tag
"Never" nil
)
643 (const :tag
"When typing /" slash
)
644 (other :tag
"Always" t
))
647 (defcustom ido-create-new-buffer
'prompt
648 "*Specify whether a new buffer is created if no buffer matches substring.
649 Choices are 'always to create new buffers unconditionally, 'prompt to
650 ask user whether to create buffer, or 'never to never create new buffer."
651 :type
'(choice (const always
)
656 (defcustom ido-define-mode-map-hook nil
657 "*Hook to define keys in `ido-mode-map' for extra keybindings."
661 (defcustom ido-separator nil
662 "*String used by ido to separate the alternatives in the minibuffer.
663 Obsolete. Set 3rd element of `ido-decorations' instead."
664 :type
'(choice string
(const nil
))
667 (defcustom ido-decorations
'( "{" "}" " | " " | ..." "[" "]" " [No match]" " [Matched]")
668 "*List of strings used by ido to display the alternatives in the minibuffer.
669 There are 8 elements in this list, each is a pair of strings:
670 1st and 2nd elements are used as brackets around the prospect list,
671 3rd element is the separator between prospects (ignored if ido-separator is set),
672 4th element is the string inserted at the end of a truncated list of prospects,
673 5th and 6th elements are used as brackets around the common match string which
674 can be completed using TAB,
675 7th element is the string displayed when there are a no matches, and
676 8th element displayed if there is a single match (and faces are not used)."
677 :type
'(repeat string
)
680 (defcustom ido-use-faces t
681 "*Non-nil means use ido faces to highlighting first match, only match and
682 subdirs in the alternatives."
686 (defface ido-first-match-face
'((t (:bold t
)))
687 "*Font used by ido for highlighting first match."
690 (defface ido-only-match-face
'((((class color
))
691 (:foreground
"ForestGreen"))
693 "*Font used by ido for highlighting only match."
696 (defface ido-subdir-face
'((((class color
))
699 "*Font used by ido for highlighting subdirs in the alternatives."
702 (defface ido-indicator-face
'((((class color
))
703 (:foreground
"yellow"
706 (t (:inverse-video t
)))
707 "*Font used by ido for highlighting its indicators."
710 (defcustom ido-make-file-list-hook nil
711 "*List of functions to run when the list of matching files is created.
712 Each function on the list may modify the dynamically bound variable
713 `ido-temp-list' which contains the current list of matching files."
717 (defcustom ido-make-dir-list-hook nil
718 "*List of functions to run when the list of matching directories is created.
719 Each function on the list may modify the dynamically bound variable
720 `ido-temp-list' which contains the current list of matching directories."
724 (defcustom ido-make-buffer-list-hook nil
725 "*List of functions to run when the list of matching buffers is created.
726 Each function on the list may modify the dynamically bound variable
727 `ido-temp-list' which contains the current list of matching buffer names."
731 (defcustom ido-make-file-prompt-hook nil
732 "*List of functions to run when the find-file prompt is created.
733 Each function on the list may modify the following dynamically bound
735 path - the (abbreviated) directory path
736 max-width - the max width of the path; set to nil to inhibit truncation
737 prompt - the basic prompt (e.g. \"Find File: \")
738 literal - the string shown if doing `literal' find; set to nil to omit
739 vc-off - the string shown if version control is inhibited; set to nit to omit
740 prefix - normally nil, but may be set to a fixed prefix for the path
741 The following variables are available, but should not be changed:
742 ido-current-directory - the unabbreviated directory path
743 item - equals 'file or 'dir depending on the current mode."
747 (defvar ido-rewrite-prompt-path-rules nil
748 "*Alist of rewriting rules for file paths.
749 A list of elements of the form (FROM . TO) or (FROM . FUNC),
750 each meaning to rewrite the path if matched by FROM by either
751 substituting the matched string by TO or calling the function
752 FUNC with the current path as its only argument and using the
753 return value as the new path. In addition, each FUNC may
754 also modify the dynamic variables described for the
755 variable `ido-make-file-prompt-hook'.")
757 (defcustom ido-completion-buffer
"*Ido Completions*"
758 "*Name of completion buffer used by ido.
759 Set to nil to disable completion buffers popping up."
763 (defcustom ido-completion-buffer-all-completions nil
764 "*Non-nil means to show all completions in completion buffer.
765 Otherwise, only the current list of matches is shown."
769 (defvar ido-all-frames
'visible
770 "*Argument to pass to `walk-windows' when finding visible files.
771 See documentation of `walk-windows' for useful values.")
773 (defcustom ido-minibuffer-setup-hook nil
774 "*Ido-specific customization of minibuffer setup.
776 This hook is run during minibuffer setup iff `ido' will be active.
777 It is intended for use in customizing ido for interoperation
778 with other packages. For instance:
780 \(add-hook 'ido-minibuffer-setup-hook
783 \(make-local-variable 'max-mini-window-height)
784 \(setq max-mini-window-height 3))))
786 will constrain Emacs to a maximum minibuffer height of 3 lines when
787 ido is running. Copied from `icomplete-minibuffer-setup-hook'."
791 (defcustom ido-save-directory-list-file
"~/.ido.last"
792 "File in which the ido state is saved between invocations.
793 Variables stored are: `ido-last-directory-list', `ido-work-directory-list',
794 `ido-work-file-list', and `ido-dir-file-cache'.
795 Must be set before enabling ido mode."
799 (defcustom ido-read-file-name-as-directory-commands
'()
800 "List of commands which uses read-file-name to read a directory path.
801 When `ido-everywhere' is non-nil, the commands in this list will read
802 the directory using ido-read-directory-name."
803 :type
'(repeat symbol
)
806 (defcustom ido-read-file-name-non-ido
'()
807 "List of commands which shall not read file names the ido way.
808 When `ido-everywhere' is non-nil, the commands in this list will read
809 the file name using normal read-file-name style."
810 :type
'(repeat symbol
)
813 ;;; Internal Variables
815 ;; Persistent variables
817 (defvar ido-mode-map nil
818 "Keymap for `ido-find-file' and `ido-switch-buffer'.")
820 (defvar ido-file-history nil
821 "History of files selected using `ido-find-file'.")
823 (defvar ido-buffer-history nil
824 "History of buffers selected using `ido-switch-buffer'.")
826 (defvar ido-last-directory-list nil
827 "List of last selected directory paths.
828 See `ido-enable-last-directory-history' for details.")
830 (defvar ido-work-directory-list nil
831 "List of actual working directory paths.
832 The current directory is inserted at the front of this list whenever a
833 file is opened with ido-find-file and family.")
835 (defvar ido-work-file-list nil
836 "List of actual work file names.
837 The current file name (sans path) is inserted at the front of this list
838 whenever a file is opened with ido-find-file and family.")
840 (defvar ido-dir-file-cache nil
841 "List of file-name-all-completions results.
842 Each element in the list is of the form (dir (mtime) file...).")
844 (defvar ido-ignore-item-temp-list nil
845 "List of items to ignore in current ido invocation.
846 Intended to be let-bound by functions which calls ido repeatedly.
847 Should never be set permanently.")
851 (defvar ido-eoinput
1
852 "Point where minibuffer input ends and completion info begins.
853 Copied from `icomplete-eoinput'.")
854 (make-variable-buffer-local 'ido-eoinput
)
856 (defvar ido-common-match-string nil
857 "Stores the string that is common to all matching files.")
859 (defvar ido-rescan nil
860 "Non-nil means we need to regenerate the list of matching items.")
862 (defvar ido-rotate nil
863 "Non-nil means we are rotating list of matches.")
866 "Stores the users string as it is typed in.")
868 (defvar ido-text-init nil
869 "The initial string for the users string it is typed in.")
871 (defvar ido-matches nil
872 "List of files currently matching `ido-text'.")
874 (defvar ido-report-no-match t
875 "Report [No Match] when no completions matches ido-text.")
878 "Flag to monitor how `ido-find-file' exits.
879 If equal to `takeprompt', we use the prompt as the file name to be
882 (defvar ido-current-directory nil
883 "Current directory for ido-find-file.")
885 (defvar ido-auto-merge-timer nil
886 "Delay timer for auto merge.")
888 (defvar ido-use-mycompletion-depth
0
889 "Non-nil means use `ido' completion feedback.
890 Is set by ido functions to the current minibuffer-depth, so that
891 it doesn't interfere with other minibuffer usage.")
894 ;;; Variables with dynamic bindings.
895 ;;; Declared here to keep the byte compiler quiet.
897 ;; Stores the current ido item type ('file, 'dir or 'buffer).
898 (defvar ido-cur-item
)
900 ;; Stores the current list of items that will be searched through.
901 ;; The list is ordered, so that the most interesting item comes first,
902 ;; although by default, the files visible in the current frame are put
903 ;; at the end of the list. Created by `ido-make-item-list'.
904 (defvar ido-cur-list
)
906 ;; Stores the list of items which are ignored when building
907 ;; `ido-cur-list'. It is in no specific order.
908 (defvar ido-ignored-list
)
910 ;; Keep current item list if non-nil.
911 (defvar ido-keep-item-list
)
913 ;; Process ido-ignore-* lists.
914 (defvar ido-process-ignore-lists
)
916 ;; Don't process ido-ignore- lists once.
917 (defvar ido-process-ignore-lists-inhibit
)
919 ;; Buffer from which ido was entered.
920 (defvar ido-entry-buffer
)
922 ;; Non-nil if matching file must be selected.
923 (defvar ido-require-match
)
925 ;; Stores a temporary version of the file list being created.
926 (defvar ido-temp-list
)
928 ;; Non-nil if default list element should be rotated into place.
929 (defvar ido-rotate-temp
)
931 ;; Stores current index in ido-work-directory-list.
932 (defvar ido-work-directory-index
)
934 ;; Stores current index in ido-work-file-list.
935 (defvar ido-work-file-index
)
937 ;; Set when merged work directory list is in use.
938 (defvar ido-use-merged-list
)
940 ;; Set when merged work directory list not yet built.
941 (defvar ido-try-merged-list
)
943 ;; Saved state prior to last work directory merge.
944 ;; Value is a list (ido-text dir cur-list ignored-list matches).
945 (defvar ido-pre-merge-state
)
947 ;; Original value of vc-master-templates for use in ido-toggle-vc.
948 (defvar ido-saved-vc-mt
)
950 ;; Stores temporary state of literal find file.
951 (defvar ido-find-literal
)
956 (defun ido-active (&optional merge
)
959 (and (boundp 'ido-completing-read
) (= ido-use-mycompletion-depth
(minibuffer-depth)))))
961 (defvar ido-trace-enable nil
)
963 (defun ido-trace (p &optional s retval
)
965 (let ((b (get-buffer-create " *IDO Trace*"))
966 (deactivate-mark deactivate-mark
))
970 (insert p
": " (if (stringp s
) s
(format "%S" s
)) "\n")))))
973 (defun ido-toggle-trace (arg)
975 (setq ido-trace-enable
(or arg
(not ido-trace-enable
)))
976 (let ((b (get-buffer " *IDO Trace*")))
980 (pop-to-buffer b t t
)))))
982 (defun ido-is-root-directory (&optional dir
)
983 (setq dir
(or dir ido-current-directory
))
984 (if (memq system-type
'(windows-nt ms-dos
))
985 (string-match "\\`[a-zA-Z]:[/\\]\\'" dir
)
986 (string-equal "/" dir
)))
988 (defun ido-is-ftp-directory (&optional dir
)
989 (string-match "\\`/[^/:][^/:]+:/" (or dir ido-current-directory
)))
991 (defun ido-is-slow-ftp-host (&optional dir
)
992 (and (or ido-slow-ftp-hosts ido-slow-ftp-host-regexps
)
993 (setq dir
(or dir ido-current-directory
))
994 ;; (featurep 'ange-ftp)
995 ;; (ange-ftp-ftp-name dir)
996 (string-match "\\`/\\([^/:]*@\\)?\\([^@/:][^@/:]+\\):/" dir
)
997 (let ((host (substring dir
(match-beginning 2) (match-end 2))))
998 (or (member host ido-slow-ftp-hosts
)
999 (let ((re ido-slow-ftp-host-regexps
))
1000 (while (and re
(not (string-match (car re
) host
)))
1004 (defun ido-time-stamp (&optional time
)
1005 ;; Time is a floating point number (fractions of 1 hour)
1006 (setq time
(or time
(current-time)))
1007 (/ (+ (* (car time
) 65536.0) (car (cdr time
))) 3600.0))
1009 (defun ido-cache-ftp-valid (&optional time
)
1010 (and (numberp ido-cache-ftp-work-directory-time
)
1011 (> ido-cache-ftp-work-directory-time
0)
1013 (< (- (ido-time-stamp) time
) ido-cache-ftp-work-directory-time
))))
1015 (defun ido-may-cache-directory (&optional dir
)
1016 (setq dir
(or dir ido-current-directory
))
1017 (if (and (memq system-type
'(windows-nt ms-dos
))
1018 (string-match "\\`[a-zA-Z]:[/\\]\\'" dir
))
1020 (or (not (ido-is-ftp-directory dir
))
1021 (ido-cache-ftp-valid))))
1023 (defun ido-pp (list &optional sep
)
1024 (let ((print-level nil
) (eval-expression-print-level nil
)
1025 (print-length nil
) (eval-expression-print-length nil
))
1026 (insert "\n;; ----- " (symbol-name list
) " -----\n(\n ")
1027 (setq list
(symbol-value list
))
1029 (let* ((elt (car list
))
1030 (s (if (consp elt
) (car elt
) elt
)))
1031 (if (and (stringp s
) (= (length s
) 0))
1034 (prin1 elt
(current-buffer)))
1035 (if (and (setq list
(cdr list
)) s
)
1036 (insert (or sep
"\n ")))))
1039 (defun ido-save-history ()
1040 "Save ido history and cache information between sessions."
1042 (if (and ido-last-directory-list ido-save-directory-list-file
)
1044 (save-window-excursion
1045 (if (find-buffer-visiting ido-save-directory-list-file
)
1046 (kill-buffer (find-buffer-visiting ido-save-directory-list-file
)))
1047 (if (file-exists-p ido-save-directory-list-file
)
1048 (delete-file ido-save-directory-list-file
))
1049 (set-buffer (let ((enable-local-variables nil
))
1050 (find-file-noselect ido-save-directory-list-file t
)))
1051 (goto-char (point-min))
1052 (delete-region (point-min) (point-max))
1053 (ido-pp 'ido-last-directory-list
)
1054 (ido-pp 'ido-work-directory-list
)
1055 (ido-pp 'ido-work-file-list
)
1056 (ido-pp 'ido-dir-file-cache
"\n\n ")
1058 (let ((version-control 'never
))
1059 (write-file ido-save-directory-list-file nil
))
1060 (kill-buffer (current-buffer))))))
1062 (defun ido-load-history (&optional arg
)
1063 "Load ido history and cache information from previous session.
1064 With prefix argument, reload history unconditionally."
1066 (if (or arg
(and ido-save-directory-list-file
(not ido-last-directory-list
)))
1067 (let ((file (expand-file-name ido-save-directory-list-file
))
1069 (when (file-readable-p file
)
1071 (save-window-excursion
1072 (setq buf
(set-buffer (let ((enable-local-variables nil
))
1073 (find-file-noselect file
))))
1074 (goto-char (point-min))
1076 (setq ido-last-directory-list
(read (current-buffer))
1077 ido-work-directory-list
(read (current-buffer))
1078 ido-work-file-list
(read (current-buffer))
1079 ido-dir-file-cache
(read (current-buffer)))
1081 (kill-buffer buf
))))
1084 (defun ido-wash-history ()
1085 "Clean-up ido history and cache information.
1086 Removes badly formatted data and ignored directories."
1088 ;; Check format of each of our lists, discard bogus elements
1089 (setq ido-last-directory-list
1090 (and (listp ido-last-directory-list
)
1091 (let ((l ido-last-directory-list
) r
)
1093 (if (and (consp (car l
))
1094 (stringp (car (car l
)))
1095 (stringp (cdr (car l
))))
1096 (setq r
(cons (car l
) r
)))
1099 (setq ido-work-directory-list
1100 (and (listp ido-work-directory-list
)
1101 (let ((l ido-work-directory-list
) r
)
1103 (if (and (stringp (car l
))
1104 (or ido-record-ftp-work-directories
1105 (not (ido-is-ftp-directory (car l
)))))
1106 (setq r
(cons (car l
) r
)))
1109 (setq ido-work-file-list
1110 (and (listp ido-work-file-list
)
1111 (let ((l ido-work-file-list
) r
)
1113 (if (stringp (car l
))
1114 (setq r
(cons (car l
) r
)))
1117 (setq ido-dir-file-cache
1118 (and (listp ido-dir-file-cache
)
1119 (let ((l ido-dir-file-cache
) r
)
1121 (if (and (listp (car l
))
1122 (> (length (car l
)) 2)
1123 (let ((dir (car (car l
)))
1124 (time (car (cdr (car l
))))
1125 (files (cdr (cdr (car l
)))))
1129 (if (integerp (car time
))
1130 (and (/= (car time
) 0)
1131 (integerp (car (cdr time
)))
1132 (/= (car (cdr time
)) 0)
1133 (ido-may-cache-directory dir
))
1134 (and (eq (car time
) 'ftp
)
1135 (numberp (cdr time
))
1136 (ido-is-ftp-directory dir
)
1137 (ido-cache-ftp-valid (cdr time
))))
1138 (let ((s files
) (ok t
))
1140 (if (stringp (car s
))
1142 (setq s nil ok nil
)))
1144 (setq r
(cons (car l
) r
)))
1148 ;; Remove ignored directories from work directory list
1149 ;; according to ido-work-directory-list-ignore-regexps
1150 (if ido-work-directory-list
1151 (let ((dirs (reverse ido-work-directory-list
)))
1152 (setq ido-work-directory-list nil
)
1154 (ido-record-work-directory (car dirs
))
1155 (setq dirs
(cdr dirs
)))))
1156 ;; Get rid of text properties
1157 (let ((l ido-last-directory-list
) e
)
1159 (setq e
(car l
) l
(cdr l
))
1160 (set-text-properties 0 (length (car e
)) nil
(car e
))
1161 (set-text-properties 0 (length (cdr e
)) nil
(cdr e
))))
1162 (let ((l ido-work-directory-list
) e
)
1164 (setq e
(car l
) l
(cdr l
))
1165 (set-text-properties 0 (length e
) nil e
)))
1166 (let ((l ido-work-file-list
) e
)
1168 (setq e
(car l
) l
(cdr l
))
1169 (set-text-properties 0 (length e
) nil e
)))
1170 (let ((l ido-dir-file-cache
) e d
)
1172 (setq e
(car l
) l
(cdr l
))
1175 (setq d
(car e
) e
(cdr e
))
1177 (set-text-properties 0 (length d
) nil d
))))))
1181 (defun ido-kill-emacs-hook ()
1182 ;; ido kill emacs hook
1185 (defvar ido-minor-mode-map-entry nil
)
1188 (defun ido-mode (&optional arg nobind
)
1189 "Toggle ido speed-ups on or off.
1190 With ARG, turn ido speed-up on if arg is positive, off otherwise.
1191 If second argument NOBIND is non-nil, no keys are rebound; otherwise,
1192 turning on ido-mode will modify the default keybindings for the
1193 find-file and switch-to-buffer families of commands to the ido
1194 versions of these functions.
1195 However, if second arg equals 'files, bind only for files, or if it
1196 equals 'buffers, bind only for buffers.
1197 This function also adds a hook to the minibuffer."
1201 ((null arg
) (if ido-mode nil
'both
))
1203 ((eq arg
'files
) 'file
)
1204 ((eq arg
'buffers
) 'buffer
)
1205 ((memq arg
'(file buffer both
)) arg
)
1206 ((> (prefix-numeric-value arg
) 0) 'both
)
1209 (ido-everywhere (if ido-everywhere
1 -
1))
1212 (add-hook 'minibuffer-setup-hook
'ido-minibuffer-setup
)
1213 (add-hook 'choose-completion-string-functions
'ido-choose-completion-string
)
1216 (add-hook 'kill-emacs-hook
'ido-kill-emacs-hook
)
1218 (unless ido-minor-mode-map-entry
1219 (setq ido-minor-mode-map-entry
(cons 'ido-mode
(make-sparse-keymap)))
1220 (add-to-list 'minor-mode-map-alist ido-minor-mode-map-entry
))
1222 (let ((map (cdr ido-minor-mode-map-entry
)))
1223 (when (memq ido-mode
'(file both
))
1224 (define-key map
[remap find-file
] 'ido-find-file
)
1225 (define-key map
[remap find-file-read-only
] 'ido-find-file-read-only
)
1226 (define-key map
[remap find-alternate-file
] 'ido-find-alternate-file
)
1227 (define-key map
[remap write-file
] 'ido-write-file
)
1228 (define-key map
[remap insert-file
] 'ido-insert-file
)
1229 (define-key map
[remap list-directory
] 'ido-list-directory
)
1230 (define-key map
[remap dired
] 'ido-dired
)
1231 (define-key map
[remap find-file-other-window
] 'ido-find-file-other-window
)
1232 (define-key map
[remap find-file-read-only-other-window
] 'ido-find-file-read-only-other-window
)
1233 (define-key map
[remap find-file-other-frame
] 'ido-find-file-other-frame
)
1234 (define-key map
[remap find-file-read-only-other-frame
] 'ido-find-file-read-only-other-frame
))
1236 (when (memq ido-mode
'(buffer both
))
1237 (define-key map
[remap switch-to-buffer
] 'ido-switch-buffer
)
1238 (define-key map
[remap switch-to-buffer-other-window
] 'ido-switch-buffer-other-window
)
1239 (define-key map
[remap switch-to-buffer-other-frame
] 'ido-switch-buffer-other-frame
)
1240 (define-key map
[remap insert-buffer
] 'ido-insert-buffer
)
1241 (define-key map
[remap kill-buffer
] 'ido-kill-buffer
)
1242 (define-key map
[remap display-buffer
] 'ido-display-buffer
)))))
1244 (defun ido-everywhere (arg)
1245 "Enable ido everywhere file and directory names are read."
1247 (setq ido-everywhere
(if arg
1248 (> (prefix-numeric-value arg
) 0)
1249 (not ido-everywhere
)))
1250 (setq read-file-name-function
1251 (and ido-everywhere
(memq ido-mode
'(both file
))
1252 'ido-read-file-name
))
1253 (setq read-buffer-function
1254 (and ido-everywhere
(memq ido-mode
'(both buffer
))
1259 (defun ido-define-mode-map ()
1260 "Set up the keymap for `ido'."
1262 ;; generated every time so that it can inherit new functions.
1264 (setq map
(copy-keymap minibuffer-local-map
))
1265 (define-key map
"\C-a" 'ido-toggle-ignore
)
1266 (define-key map
"\C-c" 'ido-toggle-case
)
1267 (define-key map
"\C-e" 'ido-edit-input
)
1268 (define-key map
"\t" 'ido-complete
)
1269 (define-key map
" " 'ido-complete-space
)
1270 (define-key map
"\C-j" 'ido-select-text
)
1271 (define-key map
"\C-m" 'ido-exit-minibuffer
)
1272 (define-key map
"\C-p" 'ido-toggle-prefix
)
1273 (define-key map
"\C-r" 'ido-prev-match
)
1274 (define-key map
"\C-s" 'ido-next-match
)
1275 (define-key map
"\C-t" 'ido-toggle-regexp
)
1276 (define-key map
"\C-z" 'ido-undo-merge-work-directory
)
1277 (define-key map
[(control ?
)] 'ido-restrict-to-matches
)
1278 (define-key map
[(control ?
@)] 'ido-restrict-to-matches
)
1279 (define-key map
[right] 'ido-next-match)
1280 (define-key map [left] 'ido-prev-match)
1281 (define-key map "?" 'ido-completion-help)
1283 (when (memq ido-cur-item '(file dir))
1284 (define-key map "\C-b" 'ido-enter-switch-buffer)
1285 (define-key map "\C-d" 'ido-enter-dired)
1286 (define-key map "\C-f" 'ido-fallback-command)
1287 (define-key map [down] 'ido-next-match-dir)
1288 (define-key map [up] 'ido-prev-match-dir)
1289 (define-key map [(meta up)] 'ido-prev-work-directory)
1290 (define-key map [(meta down)] 'ido-next-work-directory)
1291 (define-key map [backspace] 'ido-delete-backward-updir)
1292 (define-key map "\d" 'ido-delete-backward-updir)
1293 (define-key map [(meta backspace)] 'ido-delete-backward-word-updir)
1294 (define-key map [(control backspace)] 'ido-up-directory)
1295 (define-key map [(meta ?b)] 'ido-next-work-file)
1296 (define-key map [(meta ?d)] 'ido-wide-find-dir)
1297 (define-key map [(meta ?f)] 'ido-wide-find-file)
1298 (define-key map [(meta ?k)] 'ido-forget-work-directory)
1299 (define-key map [(meta ?m)] 'ido-make-directory)
1300 (define-key map [(meta ?n)] 'ido-next-work-directory)
1301 (define-key map [(meta ?o)] 'ido-prev-work-file)
1302 (define-key map [(meta ?p)] 'ido-prev-work-directory)
1303 (define-key map [(meta ?s)] 'ido-merge-work-directories)
1306 (when (eq ido-cur-item 'file)
1307 (define-key map "\C-k" 'ido-delete-file-at-head)
1308 (define-key map "\C-o" 'ido-copy-current-word)
1309 (define-key map "\C-l" 'ido-reread-directory)
1310 (define-key map "\C-w" 'ido-copy-current-file-name)
1311 (define-key map [(meta ?l)] 'ido-toggle-literal)
1312 (define-key map "\C-v" 'ido-toggle-vc)
1315 (when (eq ido-cur-item 'buffer)
1316 (define-key map "\C-b" 'ido-fallback-command)
1317 (define-key map "\C-f" 'ido-enter-find-file)
1318 (define-key map "\C-k" 'ido-kill-buffer-at-head)
1321 (setq ido-mode-map map)
1322 (run-hooks 'ido-define-mode-map-hook)))
1324 (defun ido-final-slash (dir &optional fix-it)
1325 ;; return DIR if DIR has final slash.
1326 ;; else if FIX-IT is non-nil, return DIR/
1328 (setq dir (ido-name dir))
1330 ((string-match "/\\'" dir) dir)
1331 (fix-it (concat dir "/"))
1334 (defun ido-set-current-directory (dir &optional subdir no-merge)
1335 ;; Set ido's current directory to DIR or DIR/SUBDIR
1336 (setq dir (ido-final-slash dir t))
1337 (setq ido-use-merged-list nil
1338 ido-try-merged-list (not no-merge))
1340 (setq dir (ido-final-slash (concat dir subdir) t)))
1341 (if (equal dir ido-current-directory)
1343 (ido-trace "cd" dir)
1344 (setq ido-current-directory dir)
1345 (if (get-buffer ido-completion-buffer)
1346 (kill-buffer ido-completion-buffer))
1349 (defun ido-set-current-home (&optional dir)
1350 ;; Set ido's current directory to user's home directory
1351 (ido-set-current-directory (expand-file-name (or dir "~/"))))
1353 (defun ido-record-command (command arg)
1354 ;; Add (command arg) to command-history if ido-record-commands is t
1355 (if ido-record-commands
1356 (let ((cmd (list command arg)))
1357 (if (or (not command-history)
1358 (not (equal cmd (car command-history))))
1359 (setq command-history (cons cmd command-history))))))
1361 (defun ido-make-prompt (item prompt)
1362 ;; Make the prompt for ido-read-internal
1364 ((and (memq item '(file dir)) ido-current-directory)
1365 (let ((path (abbreviate-file-name ido-current-directory))
1366 (max-width (if (and ido-max-prompt-path (floatp ido-max-prompt-path))
1367 (floor (* (frame-width) ido-max-prompt-path))
1368 ido-max-prompt-path))
1369 (literal (and (boundp 'ido-find-literal) ido-find-literal "(literal) "))
1370 (vc-off (and ido-saved-vc-mt (not vc-master-templates) "[-VC] "))
1372 (rule ido-rewrite-prompt-path-rules))
1373 (let ((case-fold-search nil))
1375 (if (and (consp (car rule))
1376 (string-match (car (car rule)) path))
1378 (if (stringp (cdr (car rule)))
1379 (replace-match (cdr (car rule)) t nil path)
1380 (funcall (cdr (car rule)) path))))
1381 (setq rule (cdr rule))))
1382 (run-hooks 'ido-make-file-prompt-hook)
1384 ; (if ido-process-ignore-lists "" "&")
1388 (let ((l (length path)))
1389 (if (and max-width (> max-width 0) (> l max-width))
1390 (let* ((s (substring path (- max-width)))
1391 (i (string-match "/" s)))
1392 (concat "..." (if i (substring s i) s)))
1396 ;; Here is very briefly how ido-find-file works:
1399 ;; (ido-file-internal method)
1400 ;; set ido-current-directory
1401 ;; (ido-read-internal 'file ...)
1403 ;; (ido-make-item-list ...)
1404 ;; (ido-set-matches)
1405 ;; (completing-read ... ido-text-init ...)
1407 ;; ... here user is allowed to type characters and commands
1408 ;; a command may set ido-exit and call (exit-minibuffer)
1409 ;; to make ido-read-internal do advanced tasks (or return)
1411 ;; ... ido-tidy and ido-exhibit are pre- and post-hooks
1412 ;; which are run before and after each user command.
1414 ;; return value from completing-read is stored in ido-final-text
1415 ;; - ido-exit may cause further actions to be taken:
1416 ;; 'refresh - repeat loop (make-item-list, set-matches)
1417 ;; 'edit - edit the prompt string, then repeat loop
1418 ;; 'keep - repeat loop but don't (re)make-item-list
1419 ;; 'updir - go up one directory, repeat loop
1420 ;; else set ido-selected based on ido-final-text,
1421 ;; optionally update ido-current-directory and repeat loop, or
1422 ;; exit with the return value of ido-selected (file name)
1423 ;; selected file name is returned from ido-read-internal,
1424 ;; ido-exit and method determines what action is taken
1425 ;; e.g. the file name may be ignored or joined with ido-current-directory, and
1426 ;; the relevant function is called (find-file, write-file, etc).
1428 (defun ido-read-internal (item prompt history &optional default require-match initial)
1429 "Perform the ido-read-buffer and ido-read-file-name functions.
1430 Return the name of a buffer or file selected.
1431 PROMPT is the prompt to give to the user.
1432 DEFAULT if given is the default directory to start with.
1433 If REQUIRE-MATCH is non-nil, an existing file must be selected.
1434 If INITIAL is non-nil, it specifies the initial input string."
1436 ((ido-cur-item item)
1437 (ido-entry-buffer (current-buffer))
1438 (ido-process-ignore-lists t)
1439 (ido-process-ignore-lists-inhibit nil)
1440 (ido-set-default-item t)
1445 (icomplete-mode nil) ;; prevent icomplete starting up
1446 ;; Exported dynamic variables:
1449 (ido-rotate-temp nil)
1450 (ido-keep-item-list nil)
1451 (ido-use-merged-list nil)
1452 (ido-try-merged-list t)
1453 (ido-pre-merge-state nil)
1454 (ido-case-fold ido-case-fold)
1455 (ido-enable-prefix ido-enable-prefix)
1456 (ido-enable-regexp ido-enable-regexp)
1459 (ido-define-mode-map)
1460 (setq ido-text-init initial)
1462 (ido-trace "\n_LOOP_")
1465 (setq ido-rotate nil)
1467 (when ido-set-default-item
1468 (setq ido-default-item
1471 (if (bufferp default) (buffer-name default) default))
1472 ((stringp default) default)
1474 (and ido-enable-last-directory-history
1475 (let ((d (assoc ido-current-directory ido-last-directory-list)))
1476 (and d (cdr d)))))))
1477 (if (member ido-default-item ido-ignore-item-temp-list)
1478 (setq ido-default-item nil))
1479 (setq ido-set-default-item nil))
1481 (if ido-process-ignore-lists-inhibit
1482 (setq ido-process-ignore-lists nil))
1484 (if (and ido-use-merged-list (memq ido-try-merged-list '(t wide)) (not ido-keep-item-list))
1485 (let ((olist ido-cur-list)
1486 (oign ido-ignored-list)
1488 (l (ido-make-merged-file-list ido-text-init
1489 (eq ido-use-merged-list 'auto)
1490 (eq ido-try-merged-list 'wide))))
1493 (if (eq ido-try-merged-list 'wide)
1494 (setq ido-pre-merge-state
1495 (list "" ido-current-directory olist oign omat)
1497 ido-ignored-list nil
1499 ido-keep-item-list t
1500 ido-try-merged-list (if (eq ido-use-merged-list 'auto) 'auto nil)
1501 ido-use-merged-list nil)
1502 (setq ido-cur-list olist
1503 ido-ignored-list oign
1505 ido-keep-item-list t
1506 ido-try-merged-list (if (eq ido-use-merged-list 'auto) 'auto nil)
1507 ido-use-merged-list nil)))
1509 (setq ido-use-merged-list nil))
1511 (setq ido-pre-merge-state
1512 (list ido-text-init ido-current-directory olist oign omat))
1513 (ido-set-current-directory (car (cdr (car l))))
1514 (if (ido-final-slash ido-text-init)
1515 (setq ido-text-init ""))
1516 (setq ido-cur-list l
1517 ido-ignored-list nil
1520 ido-keep-item-list t
1521 ido-use-merged-list t)
1522 (ido-trace "Merged" t)
1527 (setq ido-keep-item-list nil
1529 ((eq ido-cur-item 'file)
1530 (setq ido-ignored-list nil
1531 ido-cur-list (ido-make-file-list ido-default-item)))
1532 ((eq ido-cur-item 'dir)
1533 (setq ido-ignored-list nil
1534 ido-cur-list (ido-make-dir-list ido-default-item)))
1535 ((eq ido-cur-item 'buffer)
1536 (setq ido-ignored-list nil
1537 ido-cur-list (ido-make-buffer-list ido-default-item)))
1539 (setq ido-rotate-temp nil)
1541 (if ido-process-ignore-lists-inhibit
1542 (setq ido-process-ignore-lists t
1543 ido-process-ignore-lists-inhibit nil))
1546 (if (and ido-matches (eq ido-try-merged-list 'auto))
1547 (setq ido-try-merged-list t))
1549 ((minibuffer-local-completion-map ido-mode-map)
1550 (max-mini-window-height (or ido-max-window-height
1551 (and (boundp 'max-mini-window-height) max-mini-window-height)))
1552 (ido-completing-read t)
1553 (ido-require-match require-match)
1554 (ido-use-mycompletion-depth (1+ (minibuffer-depth)))
1555 (show-paren-mode nil))
1556 ;; prompt the user for the file name
1558 (setq ido-final-text
1561 (ido-make-prompt item prompt)
1562 '(("dummy" . 1)) nil nil ; table predicate require-match
1563 (prog1 ido-text-init (setq ido-text-init nil)) ;initial-contents
1565 (ido-trace "completing-read" ido-final-text)
1566 (if (get-buffer ido-completion-buffer)
1567 (kill-buffer ido-completion-buffer))
1569 (ido-trace "\n_EXIT_" ido-exit)
1572 ((eq ido-exit 'refresh)
1573 (if (and (eq ido-use-merged-list 'auto)
1574 (or (input-pending-p)))
1575 (setq ido-use-merged-list nil
1576 ido-keep-item-list t))
1579 ((eq ido-exit 'done)
1581 ido-selected ido-text
1584 ((memq ido-exit '(edit chdir))
1586 ((memq ido-cur-item '(file dir))
1587 (let* ((process-environment (cons "HOME=/" process-environment)) ;; cheat read-file-name
1588 (read-file-name-function nil)
1589 (edit (eq ido-exit 'edit))
1590 (d ido-current-directory)
1593 (setq ido-text-init "")
1596 (read-file-name (concat prompt "[EDIT] ") d (concat d f) nil f)
1598 d (or (file-name-directory path) "/")
1599 f (file-name-nondirectory path)
1602 (file-directory-p d)
1603 (and (yes-or-no-p (format "Create directory %s? " d))
1605 (progn (make-directory d t) t)
1607 (message "Could not create directory")
1611 (ido-set-current-directory d nil (eq ido-exit 'chdir))
1612 (setq ido-text-init f
1615 (setq ido-text-init nil)
1616 (setq ido-text-init (read-string (concat prompt "[EDIT] ") ido-final-text))))
1619 ((eq ido-exit 'keep)
1620 (setq ido-keep-item-list t))
1622 ((memq ido-exit '(dired fallback findfile findbuffer))
1625 ((eq ido-exit 'updir)
1626 ;; cannot go up if already at the root-dir (Unix) or at the
1627 ;; root-dir of a certain drive (Windows or MS-DOS).
1628 (or (ido-is-root-directory)
1629 (ido-set-current-directory (file-name-directory (substring ido-current-directory 0 -1))))
1630 (setq ido-set-default-item t))
1632 ;; Handling the require-match must be done in a better way.
1633 ((and require-match (not (ido-existing-item-p)))
1634 (error "must specify valid item"))
1638 (if (or (eq ido-exit 'takeprompt)
1641 ;; else take head of list
1642 (ido-name (car ido-matches))))
1648 ((string-equal "./" ido-selected)
1651 ((string-equal "../" ido-selected)
1652 ;; cannot go up if already at the root-dir (Unix) or at the
1653 ;; root-dir of a certain drive (Windows or MS-DOS).
1654 (or (ido-is-root-directory)
1655 (ido-set-current-directory (file-name-directory (substring ido-current-directory 0 -1))))
1656 (setq ido-set-default-item t))
1657 ((and (string-equal ido-current-directory "/")
1658 (string-match "..:\\'" ido-selected)) ;; Ange-ftp
1659 (ido-set-current-directory "/" ido-selected)
1660 (if (ido-is-slow-ftp-host)
1661 (setq ido-exit 'fallback
1663 (setq ido-set-default-item t)))
1665 ((or (string-match "[/\\][^/\\]" ido-selected)
1666 (and (memq system-type '(windows-nt ms-dos))
1667 (string-match "\\`.:" ido-selected)))
1668 (ido-set-current-directory (file-name-directory ido-selected))
1669 (setq ido-set-default-item t))
1671 ((string-match "\\`~" ido-selected)
1672 (ido-set-current-home ido-selected))
1674 ((ido-final-slash ido-selected)
1675 (if ido-enable-last-directory-history
1676 (let ((x (assoc ido-current-directory ido-last-directory-list)))
1678 (setcdr x ido-selected)
1679 (setq ido-last-directory-list
1680 (cons (cons ido-current-directory ido-selected) ido-last-directory-list)))))
1681 (ido-set-current-directory ido-current-directory ido-selected)
1682 (setq ido-set-default-item t))
1688 (defun ido-edit-input ()
1689 "Edit ido path and input string. Terminate by RET."
1691 (setq ido-text-init ido-text)
1692 (setq ido-exit 'edit)
1696 (defun ido-buffer-internal (method &optional fallback prompt default initial)
1697 ;; Internal function for ido-switch-buffer and friends
1699 (call-interactively (or fallback 'switch-to-buffer))
1700 (let ((buf (ido-read-buffer (or prompt "Buffer: ") default nil initial)))
1702 ;; Choose the buffer name: either the text typed in, or the head
1703 ;; of the list of matches
1706 ((eq ido-exit 'findfile)
1707 (ido-file-internal ido-default-file-method nil nil nil nil ido-text))
1709 ((eq ido-exit 'fallback)
1710 (let ((read-buffer-function nil))
1711 (call-interactively (or fallback 'switch-to-buffer))))
1713 ;; Check buf is non-nil.
1715 ((= (length buf) 0) nil)
1717 ;; View buffer if it exists
1719 (if (eq method 'insert)
1721 (ido-record-command 'insert-buffer buf)
1722 (insert-buffer buf))
1723 (ido-visit-buffer buf method t)))
1725 ;; buffer doesn't exist
1726 ((eq ido-create-new-buffer 'never)
1727 (message "no buffer matching `%s'" buf))
1729 ((and (eq ido-create-new-buffer 'prompt)
1730 (not (y-or-n-p (format "No buffer matching `%s', create one? " buf))))
1733 ;; create a new buffer
1735 (setq buf (get-buffer-create buf))
1736 (if (fboundp 'set-buffer-major-mode)
1737 (set-buffer-major-mode buf))
1738 (ido-visit-buffer buf method t))))))
1741 (defun ido-read-buffer (prompt &optional default require-match initial)
1742 "Replacement for the built-in `read-buffer'.
1743 Return the name of a buffer selected.
1744 PROMPT is the prompt to give to the user. DEFAULT if given is the default
1745 buffer to be selected, which will go to the front of the list.
1746 If REQUIRE-MATCH is non-nil, an existing-buffer must be selected.
1747 If INITIAL is non-nil, it specifies the initial input string."
1748 (let ((ido-current-directory nil))
1749 (ido-read-internal 'buffer prompt 'ido-buffer-history default require-match initial)))
1751 (defun ido-record-work-directory (&optional dir)
1752 (when (and (numberp ido-max-work-directory-list) (> ido-max-work-directory-list 0))
1753 (if (and (setq dir (or dir ido-current-directory)) (> (length dir) 0))
1754 (let ((items ido-work-directory-list-ignore-regexps)
1755 (case-fold-search nil))
1756 (while (and items dir)
1757 (if (string-match (car items) dir)
1759 (setq items (cdr items)))
1761 (setq ido-work-directory-list (cons dir (delete dir ido-work-directory-list))))))
1762 (if (> (length ido-work-directory-list) ido-max-work-directory-list)
1763 (setcdr (nthcdr (1- ido-max-work-directory-list) ido-work-directory-list) nil))))
1765 (defun ido-forget-work-directory ()
1767 (when (and ido-current-directory ido-work-directory-list)
1768 (setq ido-work-directory-list (delete ido-current-directory ido-work-directory-list))
1769 (when ido-use-merged-list
1770 (ido-undo-merge-work-directory)
1771 (setq ido-exit 'refresh
1772 ido-try-merged-list t
1773 ido-use-merged-list t
1774 ido-text-init ido-text
1776 (exit-minibuffer))))
1778 (defun ido-record-work-file (name)
1779 ;; Save NAME in ido-work-file-list
1780 (when (and (numberp ido-max-work-file-list) (> ido-max-work-file-list 0))
1782 (and ido-work-file-list (equal (car ido-work-file-list) name))
1783 (setq ido-work-file-list (cons name (delete name ido-work-file-list))))
1784 (if (> (length ido-work-file-list) ido-max-work-file-list)
1785 (setcdr (nthcdr (1- ido-max-work-file-list) ido-work-file-list) nil))))
1787 (defun ido-file-internal (method &optional fallback default prompt item initial)
1788 ;; Internal function for ido-find-file and friends
1789 (let ((ido-current-directory (expand-file-name (or default default-directory)))
1792 (if (or (not ido-mode) (ido-is-slow-ftp-host))
1794 ido-exit 'fallback))
1796 (let (ido-saved-vc-mt
1797 (vc-master-templates (and (boundp 'vc-master-templates) vc-master-templates))
1798 (ido-work-directory-index -1)
1799 (ido-work-file-index -1)
1800 (ido-find-literal nil))
1803 (setq ido-saved-vc-mt vc-master-templates)
1804 (setq filename (ido-read-internal (or item 'file)
1805 (or prompt "Find file: ")
1806 'ido-file-history nil nil initial)))
1808 ;; Choose the file name: either the text typed in, or the head
1809 ;; of the list of matches
1812 ((eq ido-exit 'fallback)
1813 ;; Need to guard setting of default-directory here, since
1814 ;; we don't want to change directory of current buffer.
1815 (let ((default-directory ido-current-directory)
1816 (read-file-name-function nil))
1817 (call-interactively (or fallback 'find-file))))
1819 ((eq ido-exit 'findbuffer)
1820 (ido-buffer-internal ido-default-buffer-method nil nil nil ido-text))
1822 ((eq ido-exit 'dired)
1823 (dired (concat ido-current-directory (or ido-text ""))))
1825 ((eq method 'alt-file)
1826 (ido-record-work-file filename)
1827 (setq default-directory ido-current-directory)
1828 (ido-record-work-directory)
1829 (find-alternate-file filename))
1831 ((memq method '(dired list-directory))
1832 (if (equal filename ".")
1834 (let* ((path (ido-final-slash (concat ido-current-directory filename) t))
1835 (file (substring path 0 -1)))
1837 ((file-directory-p path)
1838 (ido-record-command method path)
1839 (ido-record-work-directory path)
1840 (funcall method path))
1841 ((file-directory-p ido-current-directory)
1843 ((file-exists-p file)
1844 (ido-record-command method ido-current-directory)
1845 (ido-record-work-directory)
1846 (funcall method ido-current-directory)
1847 (if (eq method 'dired)
1848 (dired-goto-file (expand-file-name file))))
1849 ((string-match "[[*?]" filename)
1850 (setq path (concat ido-current-directory filename))
1851 (ido-record-command method path)
1852 (ido-record-work-directory)
1853 (funcall method path))
1854 ((y-or-n-p (format "Directory %s does not exist. Create it " filename))
1855 (ido-record-command method path)
1856 (ido-record-work-directory path)
1857 (make-directory-internal path)
1858 (funcall method path))
1860 ;; put make-directory command on history
1861 (ido-record-command 'make-directory path))))
1862 (t (error "No such directory")))))
1865 (ido-record-work-file filename)
1866 (setq default-directory ido-current-directory)
1867 (ido-record-command 'write-file (concat ido-current-directory filename))
1868 (ido-record-work-directory)
1869 (write-file filename))
1871 ((eq method 'read-only)
1872 (ido-record-work-file filename)
1873 (setq filename (concat ido-current-directory filename))
1874 (ido-record-command fallback filename)
1875 (ido-record-work-directory)
1876 (funcall fallback filename))
1878 ((eq method 'insert)
1879 (ido-record-work-file filename)
1880 (setq filename (concat ido-current-directory filename))
1882 (if ido-find-literal 'insert-file-literally 'insert-file)
1884 (ido-record-work-directory)
1885 (if ido-find-literal
1886 (insert-file-contents-literally filename)
1887 (insert-file-contents filename)))
1890 (ido-record-work-file filename)
1891 (setq filename (concat ido-current-directory filename))
1892 (ido-record-command 'find-file filename)
1893 (ido-record-work-directory)
1894 (ido-visit-buffer (find-file-noselect filename nil ido-find-literal) method))))))
1896 (defun ido-existing-item-p ()
1897 ;; Return non-nil if there is a matching item
1898 (not (null ido-matches)))
1902 (defun ido-set-common-completion ()
1903 ;; Find common completion of `ido-text' in `ido-matches'
1904 ;; The result is stored in `ido-common-match-string'
1906 (setq ido-common-match-string nil)
1907 (if (and ido-matches
1908 (not ido-enable-regexp) ;; testing
1910 (> (length ido-text) 0))
1911 (if (setq val (ido-find-common-substring ido-matches ido-text))
1912 (setq ido-common-match-string val)))
1915 (defun ido-complete ()
1916 "Try and complete the current pattern amongst the file names."
1920 ((and (memq ido-cur-item '(file dir))
1921 (string-match "[$]" ido-text))
1922 (let ((evar (substitute-in-file-name (concat ido-current-directory ido-text))))
1923 (if (not (file-exists-p (file-name-directory evar)))
1924 (message "Expansion generates non-existing directory path")
1925 (if (file-directory-p evar)
1926 (ido-set-current-directory evar)
1927 (let ((d (or (file-name-directory evar) "/"))
1928 (f (file-name-nondirectory evar)))
1929 (when (file-directory-p d)
1930 (ido-set-current-directory d)
1931 (setq ido-text-init f))))
1932 (setq ido-exit 'refresh)
1933 (exit-minibuffer))))
1936 (when ido-completion-buffer
1937 (call-interactively (setq this-command ido-cannot-complete-command))))
1939 ((= 1 (length ido-matches))
1940 ;; only one choice, so select it.
1943 (t ;; else there could be some completions
1944 (setq res ido-common-match-string)
1945 (if (and (not (memq res '(t nil)))
1946 (not (equal res ido-text)))
1947 ;; found something to complete, so put it in the minibuffer.
1949 ;; move exact match to front if not in prefix mode
1950 (setq ido-rescan (not ido-enable-prefix))
1951 (delete-region (minibuffer-prompt-end) (point))
1953 ;; else nothing to complete
1954 (call-interactively (setq this-command ido-cannot-complete-command))
1957 (defun ido-complete-space ()
1958 "Try completion unless inserting the space makes sense."
1960 (if (and (stringp ido-common-match-string)
1963 ((> (length ido-common-match-string) (length ido-text))
1964 (= (aref ido-common-match-string (length ido-text)) ? ))
1967 (re (concat (regexp-quote ido-text) " "))
1970 (if (string-match re (ido-name (car comp)))
1971 (setq comp nil insert-space t)
1972 (setq comp (cdr comp))))
1978 (defun ido-undo-merge-work-directory (&optional text try refresh)
1979 "Undo or redo last ido directory merge operation.
1980 If no merge has yet taken place, toggle automatic merging option."
1983 (ido-pre-merge-state
1984 (ido-set-current-directory (nth 1 ido-pre-merge-state))
1985 (setq ido-text-init (or text (car ido-pre-merge-state))
1986 ido-cur-list (nth 2 ido-pre-merge-state)
1987 ido-ignored-list (nth 3 ido-pre-merge-state)
1988 ido-matches (nth 4 ido-pre-merge-state)
1989 ido-use-merged-list nil
1990 ido-try-merged-list try
1991 ido-keep-item-list (not refresh)
1994 ido-pre-merge-state nil)
1998 (ido-try-merged-list
1999 (setq ido-try-merged-list nil))
2001 (setq ido-try-merged-list t))
2002 ((not ido-use-merged-list)
2003 (ido-merge-work-directories))))
2005 ;;; TOGGLE FUNCTIONS
2007 (defun ido-toggle-case ()
2008 "Toggle the value of `ido-case-fold'."
2010 (setq ido-case-fold (not ido-case-fold))
2011 ;; ask for list to be regenerated.
2012 (setq ido-rescan t))
2014 (defun ido-toggle-regexp ()
2015 "Toggle the value of `ido-enable-regexp'."
2017 (setq ido-enable-regexp (not ido-enable-regexp))
2018 ;; ask for list to be regenerated.
2019 (setq ido-rescan t))
2021 (defun ido-toggle-prefix ()
2022 "Toggle the value of `ido-enable-prefix'."
2024 (setq ido-enable-prefix (not ido-enable-prefix))
2025 ;; ask for list to be regenerated.
2026 (setq ido-rescan t))
2028 (defun ido-toggle-ignore ()
2029 "Toggle ignoring files specified with `ido-ignore-files'."
2031 (setq ido-process-ignore-lists (not ido-process-ignore-lists))
2032 (setq ido-text-init ido-text)
2033 (setq ido-exit 'refresh)
2036 (defun ido-toggle-vc ()
2037 "Disable version control for this file."
2039 (if (and ido-mode (eq ido-cur-item 'file))
2041 (setq vc-master-templates
2042 (if vc-master-templates nil ido-saved-vc-mt))
2043 (setq ido-text-init ido-text)
2044 (setq ido-exit 'keep)
2045 (exit-minibuffer))))
2047 (defun ido-toggle-literal ()
2048 "Toggle literal reading of this file."
2050 (if (and ido-mode (eq ido-cur-item 'file))
2052 (setq ido-find-literal (not ido-find-literal))
2053 (setq ido-text-init ido-text)
2054 (setq ido-exit 'keep)
2055 (exit-minibuffer))))
2057 (defun ido-reread-directory ()
2058 "Read current directory again.
2059 May be useful if cached version is no longer valid, but directory
2060 timestamp has not changed (e.g. with ftp or on Windows)."
2062 (if (and ido-mode (eq ido-cur-item 'file))
2064 (ido-remove-cached-dir ido-current-directory)
2065 (setq ido-text-init ido-text)
2066 (setq ido-rotate-temp t)
2067 (setq ido-exit 'refresh)
2068 (exit-minibuffer))))
2070 (defun ido-exit-minibuffer ()
2071 "Exit minibuffer, but make sure we have a match if one is needed."
2073 (if (or (not ido-require-match)
2074 (ido-existing-item-p))
2077 (defun ido-select-text ()
2078 "Select the buffer or file named by the prompt.
2079 If no buffer or file exactly matching the prompt exists, maybe create a new one."
2081 (setq ido-exit 'takeprompt)
2084 (defun ido-fallback-command ()
2085 "Fallback to non-ido version of current command."
2087 (setq ido-exit 'fallback)
2090 (defun ido-enter-find-file ()
2091 "Drop into find-file from buffer switching."
2093 (setq ido-exit 'findfile)
2096 (defun ido-enter-switch-buffer ()
2097 "Drop into ido-switch-buffer from file switching."
2099 (setq ido-exit 'findbuffer)
2102 (defun ido-enter-dired ()
2103 "Drop into dired from file switching."
2105 (setq ido-exit 'dired)
2109 (defun ido-up-directory (&optional clear)
2110 "Go up one directory level."
2112 (setq ido-text-init (if clear nil ido-text))
2113 (setq ido-exit 'updir)
2114 (setq ido-rotate-temp t)
2117 (defun ido-delete-backward-updir (count)
2118 "Delete char backwards, or at beginning of buffer, go up one level."
2121 ((= (minibuffer-prompt-end) (point))
2123 (ido-up-directory t)))
2124 ((and ido-pre-merge-state (string-equal (car ido-pre-merge-state) ido-text))
2125 (ido-undo-merge-work-directory (substring ido-text 0 -1) t t))
2127 (delete-backward-char (prefix-numeric-value count)))))
2129 (defun ido-delete-backward-word-updir (count)
2130 "Delete all chars backwards, or at beginning of buffer, go up one level."
2132 (if (= (minibuffer-prompt-end) (point))
2134 (ido-up-directory t))
2135 (backward-kill-word (prefix-numeric-value count))))
2137 (defun ido-get-work-directory (&optional incr must-match)
2138 (let ((n (length ido-work-directory-list))
2139 (i ido-work-directory-index)
2142 (if (or (not ido-text) (= (length ido-text) 0))
2143 (setq must-match nil))
2148 (if (>= i n) (setq i 0))
2149 (if (< i 0) (setq i (1- n))))
2150 (setq dir (nth i ido-work-directory-list))
2152 (not (equal dir ido-current-directory))
2153 (file-directory-p dir)
2154 (or (not must-match)
2156 (if (eq ido-cur-item 'file)
2157 (ido-make-file-list1 dir)
2158 (ido-make-dir-list1 dir)))))
2162 (setq ido-work-directory-index i))
2165 (defun ido-prev-work-directory ()
2166 "Change to next working directory in list."
2168 (let ((dir (ido-get-work-directory 1 ido-work-directory-match-only)))
2170 (ido-set-current-directory dir)
2171 (setq ido-exit 'refresh)
2172 (setq ido-text-init ido-text)
2173 (setq ido-rotate-temp t)
2174 (exit-minibuffer))))
2176 (defun ido-next-work-directory ()
2177 "Change to previous working directory in list."
2179 (let ((dir (ido-get-work-directory -1 ido-work-directory-match-only)))
2181 (ido-set-current-directory dir)
2182 (setq ido-exit 'refresh)
2183 (setq ido-text-init ido-text)
2184 (setq ido-rotate-temp t)
2185 (exit-minibuffer))))
2187 (defun ido-merge-work-directories ()
2188 "Search (and merge) work directories for files matching the current input string."
2190 (setq ido-use-merged-list t ido-try-merged-list t)
2191 (setq ido-exit 'refresh)
2192 (setq ido-text-init ido-text)
2193 (setq ido-rotate-temp t)
2196 (defun ido-wide-find-file (&optional file)
2197 "Prompt for FILE to search for using find, starting from current directory."
2200 (setq file (read-string (concat "Wide find file: " ido-current-directory) ido-text)))
2201 (when (> (length file) 0)
2202 (setq ido-use-merged-list t ido-try-merged-list 'wide)
2203 (setq ido-exit 'refresh)
2204 (setq ido-text-init file)
2205 (setq ido-rotate-temp t)
2208 (defun ido-wide-find-dir (&optional dir)
2209 "Prompt for DIR to search for using find, starting from current directory."
2212 (setq dir (read-string (concat "Wide find directory: " ido-current-directory) ido-text)))
2213 (when (> (length dir) 0)
2214 (setq ido-use-merged-list t ido-try-merged-list 'wide)
2215 (setq ido-exit 'refresh)
2216 (setq ido-text-init (ido-final-slash dir t))
2217 (setq ido-rotate-temp t)
2220 (defun ido-make-directory (&optional dir)
2221 "Prompt for DIR to create in current directory."
2224 (setq dir (read-string (concat "Make directory: " ido-current-directory) ido-text)))
2225 (when (> (length dir) 0)
2226 (setq dir (concat ido-current-directory dir))
2227 (unless (file-exists-p dir)
2228 (make-directory dir t)
2229 (ido-set-current-directory dir)
2230 (setq ido-exit 'refresh)
2231 (setq ido-text-init nil)
2232 (setq ido-rotate-temp t)
2233 (exit-minibuffer))))
2235 (defun ido-get-work-file (incr)
2236 (let ((n (length ido-work-file-list))
2237 (i (+ ido-work-file-index incr))
2240 (if (>= i n) (setq i 0))
2241 (if (< i 0) (setq i (1- n))))
2242 (setq name (nth i ido-work-file-list))
2243 (setq ido-work-file-index i)
2246 (defun ido-prev-work-file ()
2247 "Change to next working file name in list."
2249 (let ((name (ido-get-work-file 1)))
2251 (setq ido-text-init name)
2252 (setq ido-exit 'refresh)
2253 (exit-minibuffer))))
2255 (defun ido-next-work-file ()
2256 "Change to previous working file name in list."
2258 (let ((name (ido-get-work-file -1)))
2260 (setq ido-text-init name)
2261 (setq ido-exit 'refresh)
2262 (exit-minibuffer))))
2264 (defun ido-copy-current-file-name (all)
2265 "Insert file name of current buffer.
2266 If repeated, insert text from buffer instead."
2268 (let* ((path (buffer-file-name ido-entry-buffer))
2269 (name (and path (file-name-nondirectory path))))
2273 (not (equal (file-name-directory path) ido-current-directory))
2274 (not (string-match "\\.[^.]*\\'" name)))
2276 (substring name 0 (1+ (match-beginning 0)))))
2277 (setq ido-exit 'refresh
2278 ido-try-merged-list nil)
2279 (exit-minibuffer))))
2281 (defun ido-copy-current-word (all)
2282 "Insert current word (file name or path) from current buffer."
2284 (let ((word (save-excursion
2285 (set-buffer ido-entry-buffer)
2286 (let ((p (point)) start-line end-line start-name name)
2288 (setq start-line (point))
2290 (setq end-line (point))
2292 (if (re-search-backward "[^-_a-zA-Z0-9:./\\~@]" start-line 1)
2294 (setq start-name (point))
2295 (re-search-forward "[-_a-zA-Z0-9:./\\~@]*" end-line 1)
2296 (if (= start-name (point))
2298 (buffer-substring-no-properties start-name (point)))))))
2301 ((string-match "\\`[~/]" word)
2302 (setq ido-text-init word
2303 ido-try-merged-list nil
2305 ((string-match "/" word)
2306 (setq ido-text-init (concat ido-current-directory word)
2307 ido-try-merged-list nil
2310 (setq ido-text-init word
2311 ido-try-merged-list nil
2312 ido-exit 'refresh)))
2313 (exit-minibuffer))))
2315 (defun ido-next-match ()
2316 "Put first element of `ido-matches' at the end of the list."
2319 (let ((next (cadr ido-matches)))
2320 (setq ido-cur-list (ido-chop ido-cur-list next))
2322 (setq ido-rotate t))))
2324 (defun ido-prev-match ()
2325 "Put last element of `ido-matches' at the front of the list."
2328 (let ((prev (car (last ido-matches))))
2329 (setq ido-cur-list (ido-chop ido-cur-list prev))
2331 (setq ido-rotate t))))
2333 (defun ido-next-match-dir ()
2334 "Find next directory in match list.
2335 If work directories have been merged, cycle through directories for
2336 first matching file."
2338 (if ido-use-merged-list
2340 (let* ((elt (car ido-matches))
2342 (when (> (length dirs) 1)
2343 (setcdr elt (ido-chop dirs (cadr dirs))))
2344 (setq ido-rescan nil)))
2345 (let ((cnt (length ido-matches))
2347 (while (and (< i cnt) (not (ido-final-slash (nth i ido-matches))))
2350 (setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
2352 (defun ido-prev-match-dir ()
2353 "Find previous directory in match list.
2354 If work directories have been merged, cycle through directories
2355 for first matching file."
2357 (if ido-use-merged-list
2359 (let* ((elt (car ido-matches))
2361 (when (> (length dirs) 1)
2362 (setcdr elt (ido-chop dirs (car (last dirs)))))
2363 (setq ido-rescan nil)))
2364 (let* ((cnt (length ido-matches))
2366 (while (and (> i 0) (not (ido-final-slash (nth i ido-matches))))
2369 (setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
2371 (defun ido-restrict-to-matches ()
2372 "Set current item list to the currently matched items."
2375 (setq ido-cur-list ido-matches
2381 (defun ido-chop (items elem)
2382 "Remove all elements before ELEM and put them at the end of ITEMS."
2387 (setq next (car items))
2388 (if (equal next elem)
2389 (setq ret (append items (nreverse sofar)))
2392 (setq items (cdr items))
2393 (setq sofar (cons next sofar)))))
2396 (defun ido-name (item)
2397 ;; Return file name for current item, whether in a normal list
2398 ;; or a merged work directory list.
2399 (if (consp item) (car item) item))
2402 ;;; CREATE LIST OF ALL CURRENT FILES
2404 (defun ido-all-completions ()
2405 ;; Return unsorted list of all competions.
2406 (let ((ido-process-ignore-lists nil))
2408 ((eq ido-cur-item 'file)
2409 (ido-make-file-list1 ido-current-directory))
2410 ((eq ido-cur-item 'dir)
2411 (ido-make-dir-list1 ido-current-directory))
2412 ((eq ido-cur-item 'buffer)
2413 (ido-make-buffer-list1))
2417 (defun ido-sort-list (items)
2418 ;; Simple list of file or buffer names
2419 (sort items (lambda (a b) (string-lessp a b))))
2421 (defun ido-sort-merged-list (items promote)
2422 ;; Input is list of ("file" . "dir") cons cells.
2423 ;; Output is sorted list of ("file "dir" ...) lists
2424 (let ((l (sort items (lambda (a b) (string-lessp (car b) (car a)))))
2429 (if (and res (string-equal (car (car res)) (car a)))
2431 (setcdr (car (if cur (cdr res) res)) (cons (cdr a) (cdr (car res))))
2432 (if (and promote (string-equal ido-current-directory (cdr a)))
2434 (setq res (cons (list (car a) (cdr a)) res)
2438 (defun ido-wide-find-dirs-or-files (dir file &optional prefix finddir)
2439 ;; As ido-run-find-command, but returns a list of cons pairs ("file" . "dir")
2442 (shell-command-to-string
2443 (concat "find " dir " -name \"" (if prefix "" "*") file "*\" -type " (if finddir "d" "f") " -print"))))
2447 (setq path (car paths)
2449 (if (and (string-match "^/" path)
2450 (file-exists-p path))
2451 (setq d (file-name-directory path)
2452 f (file-name-nondirectory path)
2453 res (cons (cons (if finddir (ido-final-slash f t) f) d) res))))
2456 (defun ido-flatten-merged-list (items)
2457 ;; Create a list of path names based on a merged directory list.
2460 (let* ((item (car items))
2464 (setq res (cons (concat (car dirs) file) res)
2466 (setq items (cdr items)))
2469 (defun ido-make-merged-file-list (text auto wide)
2471 (message "Searching for `%s'...." text)
2472 (if (and (ido-final-slash text) ido-dir-file-cache)
2474 (setq res (ido-wide-find-dirs-or-files
2475 ido-current-directory (substring text 0 -1) ido-enable-prefix t))
2476 ;; Use list of cached directories
2477 (let ((re (concat (regexp-quote (substring text 0 -1)) "[^/:]*/\\'"))
2478 (dirs ido-dir-file-cache)
2482 (setq dir (car (car dirs))
2484 (when (and (string-match re dir)
2485 (not (ido-ignore-item-p dir ido-ignore-directories-merge))
2486 (file-directory-p dir))
2487 (setq b (substring dir 0 -1)
2488 f (concat (file-name-nondirectory b) "/")
2489 d (file-name-directory b)
2490 res (cons (cons f d) res))))
2492 (setq dir (car dirs)
2495 (when (not (ido-ignore-item-p d ido-ignore-directories-merge))
2496 (setq dir (cdr (cdr dir)))
2500 (if (and (string-match re f)
2501 (not (ido-ignore-item-p f ido-ignore-directories)))
2502 (setq res (cons (cons f d) res)))))
2503 (if (and auto (input-pending-p))
2507 (setq res (ido-wide-find-dirs-or-files
2508 ido-current-directory text ido-enable-prefix nil))
2509 (let ((ido-text text)
2510 (dirs ido-work-directory-list)
2511 (must-match (and text (> (length text) 0)))
2513 (if (and auto (not (member ido-current-directory dirs)))
2514 (setq dirs (cons ido-current-directory dirs)))
2516 (setq dir (car dirs)
2518 (when (and dir (stringp dir)
2519 (or ido-merge-ftp-work-directories
2520 (not (ido-is-ftp-directory dir)))
2521 (file-directory-p dir)
2522 (setq fl (if (eq ido-cur-item 'file)
2523 (ido-make-file-list1 dir t)
2524 (ido-make-dir-list1 dir t))))
2526 (setq fl (ido-set-matches1 fl)))
2528 (setq res (nconc fl res))))
2529 (if (and auto (input-pending-p))
2532 (if (and res (not (eq res t)))
2533 (setq res (ido-sort-merged-list res auto)))
2534 (when (and (or ido-rotate-temp ido-rotate-file-list-default)
2536 (> (length text) 0))
2537 (let ((elt (assoc text res)))
2538 (when (and elt (not (eq elt (car res))))
2539 (setq res (delq elt res))
2540 (setq res (cons elt res)))))
2544 (defun ido-make-buffer-list1 (&optional frame visible)
2545 ;; Return list of non-ignored buffer names
2549 (let ((name (buffer-name x)))
2550 (if (not (or (ido-ignore-item-p name ido-ignore-buffers) (member name visible)))
2552 (buffer-list frame))))
2554 (defun ido-make-buffer-list (default)
2555 ;; Return the current list of buffers.
2556 ;; Currently visible buffers are put at the end of the list.
2557 ;; The hook `ido-make-buflist-hook' is run after the list has been
2558 ;; created to allow the user to further modify the order of the buffer names
2559 ;; in this list. If DEFAULT is non-nil, and corresponds to an existing buffer,
2560 ;; it is put to the start of the list.
2561 (let* ((ido-current-buffers (ido-get-buffers-in-frames 'current))
2562 (ido-temp-list (ido-make-buffer-list1 (selected-frame) ido-current-buffers)))
2564 (nconc ido-temp-list ido-current-buffers)
2565 (setq ido-temp-list ido-current-buffers))
2569 (delete default ido-temp-list))
2571 (cons default ido-temp-list))))
2572 (run-hooks 'ido-make-buffer-list-hook)
2575 (defun ido-to-end (items)
2576 ;; Move the elements from ITEMS to the end of `ido-temp-list'
2579 (setq ido-temp-list (delq elem ido-temp-list)))
2582 (nconc ido-temp-list items)
2583 (setq ido-temp-list items)))
2585 (defun ido-file-name-all-completions (dir)
2586 ;; Return name of all files in DIR
2587 ;; Uses and updates ido-dir-file-cache
2588 (if (and (numberp ido-max-dir-file-cache) (> ido-max-dir-file-cache 0)
2589 (stringp dir) (> (length dir) 0)
2590 (ido-may-cache-directory dir))
2591 (let* ((cached (assoc dir ido-dir-file-cache))
2592 (ctime (nth 1 cached))
2593 (ftp (ido-is-ftp-directory dir))
2594 (attr (if ftp nil (file-attributes dir)))
2595 (mtime (nth 5 attr))
2597 (when cached ; should we use the cached entry ?
2599 (setq valid (and (eq (car ctime) 'ftp)
2600 (ido-cache-ftp-valid (cdr ctime))))
2602 (setq valid (and (= (car ctime) (car mtime))
2603 (= (car (cdr ctime)) (car (cdr mtime)))))))
2605 (setq ido-dir-file-cache (delq cached ido-dir-file-cache)
2608 (if (and ftp (file-readable-p dir))
2609 (setq mtime (cons 'ftp (ido-time-stamp))))
2611 (setq cached (cons dir (cons mtime (file-name-all-completions "" dir)))
2612 ido-dir-file-cache (cons cached ido-dir-file-cache)))
2613 (if (> (length ido-dir-file-cache) ido-max-dir-file-cache)
2614 (setcdr (nthcdr (1- ido-max-dir-file-cache) ido-dir-file-cache) nil)))
2616 (cdr (cdr cached))))
2617 (file-name-all-completions "" dir)))
2619 (defun ido-remove-cached-dir (dir)
2620 ;; Remove dir from ido-dir-file-cache
2621 (if (and ido-dir-file-cache
2622 (stringp dir) (> (length dir) 0))
2623 (let ((cached (assoc dir ido-dir-file-cache)))
2625 (setq ido-dir-file-cache (delq cached ido-dir-file-cache))))))
2628 (defun ido-make-file-list1 (dir &optional merged)
2629 ;; Return list of non-ignored files in DIR
2630 ;; If MERGED is non-nil, each file is cons'ed with DIR
2631 (and (file-directory-p dir)
2635 (if (not (ido-ignore-item-p name ido-ignore-files t))
2636 (if merged (cons name dir) name)))
2637 (ido-file-name-all-completions dir)))))
2639 (defun ido-make-file-list (default)
2640 ;; Return the current list of files.
2641 ;; Currently visible files are put at the end of the list.
2642 ;; The hook `ido-make-file-list-hook' is run after the list has been
2643 ;; created to allow the user to further modify the order of the file names
2645 (let ((ido-temp-list (ido-make-file-list1 ido-current-directory)))
2646 (setq ido-temp-list (ido-sort-list ido-temp-list))
2647 (let ((default-directory ido-current-directory))
2648 (ido-to-end ;; move ftp hosts and visited files to end
2650 (lambda (x) (if (or (string-match "..:\\'" x) (get-file-buffer x)) x))
2652 (ido-to-end ;; move . files to end
2654 (lambda (x) (if (string-equal (substring x 0 1) ".") x))
2656 (if (and default (member default ido-temp-list))
2657 (if (or ido-rotate-temp ido-rotate-file-list-default)
2658 (unless (equal default (car ido-temp-list))
2659 (let ((l ido-temp-list) k)
2660 (while (and l (cdr l) (not (equal default (car (cdr l)))))
2664 (nconc k ido-temp-list)
2665 (setq ido-temp-list k)))
2667 (delete default ido-temp-list))
2669 (cons default ido-temp-list))))
2670 (when ido-show-dot-for-dired
2671 (setq ido-temp-list (delete "." ido-temp-list))
2672 (setq ido-temp-list (cons "." ido-temp-list)))
2673 (run-hooks 'ido-make-file-list-hook)
2676 (defun ido-make-dir-list1 (dir &optional merged)
2677 ;; Return list of non-ignored subdirs in DIR
2678 ;; If MERGED is non-nil, each subdir is cons'ed with DIR
2679 (and (file-directory-p dir)
2683 (and (ido-final-slash name) (not (ido-ignore-item-p name ido-ignore-directories))
2684 (if merged (cons name dir) name)))
2685 (ido-file-name-all-completions dir)))))
2687 (defun ido-make-dir-list (default)
2688 ;; Return the current list of directories.
2689 ;; The hook `ido-make-dir-list-hook' is run after the list has been
2690 ;; created to allow the user to further modify the order of the
2691 ;; directory names in this list.
2692 (let ((ido-temp-list (ido-make-dir-list1 ido-current-directory)))
2693 (setq ido-temp-list (ido-sort-list ido-temp-list))
2694 (let ((default-directory ido-current-directory))
2695 (ido-to-end ;; move visited files to end
2697 (lambda (x) (if (get-file-buffer x) x))
2699 (ido-to-end ;; move . files to end
2701 (lambda (x) (if (string-equal (substring x 0 1) ".") x))
2703 (if (and default (member default ido-temp-list))
2704 (if (or ido-rotate-temp ido-rotate-file-list-default)
2705 (unless (equal default (car ido-temp-list))
2706 (let ((l ido-temp-list) k)
2707 (while (and l (cdr l) (not (equal default (car (cdr l)))))
2711 (nconc k ido-temp-list)
2712 (setq ido-temp-list k)))
2714 (delete default ido-temp-list))
2716 (cons default ido-temp-list))))
2717 (setq ido-temp-list (delete "." ido-temp-list))
2718 (setq ido-temp-list (cons "." ido-temp-list))
2719 (run-hooks 'ido-make-dir-list-hook)
2722 ;; List of the files visible in the current frame.
2723 (defvar ido-bufs-in-frame)
2725 (defun ido-get-buffers-in-frames (&optional current)
2726 ;; Return the list of buffers that are visible in the current frame.
2727 ;; If optional argument `current' is given, restrict searching to the
2728 ;; current frame, rather than all frames, regardless of value of
2729 ;; `ido-all-frames'.
2730 (let ((ido-bufs-in-frame nil))
2731 (walk-windows 'ido-get-bufname nil
2737 (defun ido-get-bufname (win)
2738 ;; Used by `ido-get-buffers-in-frames' to walk through all windows
2739 (let ((buf (buffer-name (window-buffer win))))
2740 (unless (or (member buf ido-bufs-in-frame)
2741 (member buf ido-ignore-item-temp-list))
2742 ;; Only add buf if it is not already in list.
2743 ;; This prevents same buf in two different windows being
2744 ;; put into the list twice.
2745 (setq ido-bufs-in-frame
2746 (cons buf ido-bufs-in-frame)))))
2748 ;;; FIND MATCHING ITEMS
2750 (defun ido-set-matches1 (items &optional do-full)
2751 ;; Return list of matches in items
2752 (let* ((case-fold-search ido-case-fold)
2753 (rexq (if ido-enable-regexp ido-text (regexp-quote ido-text)))
2754 (re (if ido-enable-prefix (concat "\\`" rexq) rexq))
2755 (full-re (and do-full (not ido-enable-regexp) (not (string-match "\$\\'" re))
2756 (concat "\\`" re "\\'")))
2757 (prefix-re (and full-re (not ido-enable-prefix)
2758 (concat "\\`" rexq)))
2764 (let ((name (ido-name item)))
2765 (if (string-match re name)
2767 ((and full-re (string-match full-re name))
2768 (setq full-matches (cons item full-matches)))
2769 ((and prefix-re (string-match prefix-re name))
2770 (setq prefix-matches (cons item prefix-matches)))
2771 (t (setq matches (cons item matches))))))
2775 (setq matches (nconc prefix-matches matches)))
2777 (setq matches (nconc full-matches matches)))
2778 (when (and (null matches)
2779 ido-enable-flex-matching
2780 (> (length ido-text) 1)
2781 (not ido-enable-regexp))
2782 (setq re (mapconcat #'regexp-quote (split-string ido-text "") ".*"))
2783 (if ido-enable-prefix
2784 (setq re (concat "\\`" re)))
2787 (let ((name (ido-name item)))
2788 (if (string-match re name)
2789 (setq matches (cons item matches)))))
2794 (defun ido-set-matches ()
2795 ;; Set `ido-matches' to the list of items matching prompt
2797 (setq ido-matches (ido-set-matches1 (reverse ido-cur-list) (not ido-rotate))
2800 (defun ido-ignore-item-p (name re-list &optional ignore-ext)
2801 ;; Return t if the buffer or file NAME should be ignored.
2802 (or (member name ido-ignore-item-temp-list)
2804 ido-process-ignore-lists re-list
2805 (let ((data (match-data))
2806 (ext-list (and ignore-ext ido-ignore-extensions
2807 completion-ignored-extensions))
2809 (flen (length name)) slen)
2811 (setq nextstr (car ext-list))
2814 (and (>= flen (setq slen (length nextstr)))
2815 (string-equal (substring name (- flen slen)) nextstr)))
2816 ((fboundp nextstr) (funcall nextstr name))
2821 (setq ext-list (cdr ext-list))))
2823 (setq nextstr (car re-list))
2825 ((stringp nextstr) (string-match nextstr name))
2826 ((fboundp nextstr) (funcall nextstr name))
2830 (setq re-list (cdr re-list))))
2831 ;; return the result
2833 (setq ido-ignored-list (cons name ido-ignored-list)))
2834 (set-match-data data)
2838 ;; Private variable used by `ido-word-matching-substring'.
2839 (defvar ido-change-word-sub)
2841 (defun ido-find-common-substring (items subs)
2842 ;; Return common string following SUBS in each element of ITEMS.
2845 ido-change-word-sub)
2846 (setq ido-change-word-sub
2847 (if ido-enable-regexp
2849 (regexp-quote subs)))
2850 (setq res (mapcar #'ido-word-matching-substring items))
2851 (setq res (delq nil res)) ;; remove any nil elements (shouldn't happen)
2852 (setq alist (mapcar #'ido-makealist res)) ;; could use an OBARRAY
2854 ;; try-completion returns t if there is an exact match.
2855 (let* ((completion-ignore-case ido-case-fold)
2856 (comp (try-completion subs alist)))
2861 (defun ido-word-matching-substring (word)
2862 ;; Return part of WORD before 1st match to `ido-change-word-sub'.
2863 ;; If `ido-change-word-sub' cannot be found in WORD, return nil.
2864 (let ((case-fold-search ido-case-fold))
2865 (let ((m (string-match ido-change-word-sub (ido-name word))))
2867 (substring (ido-name word) m)
2871 (defun ido-makealist (res)
2872 ;; Return dotted pair (RES . 1).
2875 (defun ido-choose-completion-string (choice buffer mini-p base-size)
2877 ;; Insert the completion into the buffer where completion was requested.
2878 (if (get-buffer ido-completion-buffer)
2879 (kill-buffer ido-completion-buffer))
2881 ((ido-active t) ;; ido-use-merged-list
2882 (setq ido-current-directory ""
2885 ((not (ido-final-slash choice))
2886 (setq ido-text choice
2889 (ido-set-current-directory ido-current-directory choice)
2890 (setq ido-exit 'refresh)))
2894 (defun ido-completion-help ()
2895 "Show possible completions in a *File Completions* buffer."
2897 (setq ido-rescan nil)
2898 (let ((temp-buf (get-buffer ido-completion-buffer))
2899 display-it full-list)
2900 (if (and (eq last-command this-command) temp-buf)
2902 (let (win (buf (current-buffer)))
2903 (display-buffer temp-buf nil nil)
2904 (set-buffer temp-buf)
2905 (setq win (get-buffer-window temp-buf))
2906 (if (pos-visible-in-window-p (point-max) win)
2907 (if (or ido-completion-buffer-all-completions (boundp 'ido-completion-buffer-full))
2908 (set-window-start win (point-min))
2909 (set (make-local-variable 'ido-completion-buffer-full) t)
2912 (scroll-other-window))
2914 (setq display-it t))
2916 (with-output-to-temp-buffer ido-completion-buffer
2917 (let ((completion-list (ido-sort-list
2919 (ido-use-merged-list
2920 (ido-flatten-merged-list (or ido-matches ido-cur-list)))
2921 ((or full-list ido-completion-buffer-all-completions)
2922 (ido-all-completions))
2924 (copy-sequence (or ido-matches ido-cur-list)))))))
2925 (if (featurep 'xemacs)
2926 ;; XEmacs extents are put on by default, doesn't seem to be
2927 ;; any way of switching them off.
2928 ;; This obscure code avoids a byte compiler warning in Emacs.
2929 (let ((f 'display-completion-list))
2930 (funcall f completion-list
2933 '(lambda (x y z) (message "doesn't work yet, sorry!"))))
2934 ;; else running Emacs
2935 ;;(add-hook 'completion-setup-hook 'completion-setup-function)
2936 (display-completion-list completion-list)))))))
2938 ;;; KILL CURRENT BUFFER
2939 (defun ido-kill-buffer-at-head ()
2940 "Kill the buffer at the head of `ido-matches'."
2942 (let ((enable-recursive-minibuffers t)
2943 (buf (car ido-matches)))
2946 ;; Check if buffer still exists.
2947 (if (get-buffer buf)
2948 ;; buffer couldn't be killed.
2950 ;; else buffer was killed so remove name from list.
2951 (setq ido-cur-list (delq buf ido-cur-list))))))
2953 ;;; DELETE CURRENT FILE
2954 (defun ido-delete-file-at-head ()
2955 "Delete the file at the head of `ido-matches'."
2957 (let ((enable-recursive-minibuffers t)
2958 (file (car ido-matches)))
2960 (setq file (concat ido-current-directory file)))
2962 (file-exists-p file)
2963 (not (file-directory-p file))
2964 (file-writable-p ido-current-directory)
2965 (yes-or-no-p (concat "Delete " file " ")))
2967 ;; Check if file still exists.
2968 (if (file-exists-p file)
2969 ;; file could not be deleted
2971 ;; else file was killed so remove name from list.
2972 (setq ido-cur-list (delq (car ido-matches) ido-cur-list))))))
2975 ;;; VISIT CHOSEN BUFFER
2976 (defun ido-visit-buffer (buffer method &optional record)
2977 "Visit file named FILE according to METHOD.
2978 Record command in command-history if optional RECORD is non-nil."
2984 (ido-record-command 'kill-buffer buffer))
2985 (kill-buffer buffer))
2987 ((eq method 'samewindow)
2989 (ido-record-command 'switch-to-buffer buffer))
2990 (switch-to-buffer buffer))
2992 ((memq method '(always-frame maybe-frame))
2995 (setq win (ido-window-buffer-p buffer))
2996 (or (eq method 'always-frame)
2997 (y-or-n-p "Jump to frame? ")))
2998 (setq newframe (window-frame win))
2999 (if (fboundp 'select-frame-set-input-focus)
3000 (select-frame-set-input-focus newframe)
3001 (raise-frame newframe)
3002 (select-frame newframe)
3003 (unless (featurep 'xemacs)
3004 (set-mouse-position (selected-frame) (1- (frame-width)) 0)))
3005 (select-window win))
3007 ;; No buffer in other frames...
3009 (ido-record-command 'switch-to-buffer buffer))
3010 (switch-to-buffer buffer)
3013 ((eq method 'otherwindow)
3015 (ido-record-command 'switch-to-buffer buffer))
3016 (switch-to-buffer-other-window buffer))
3018 ((eq method 'display)
3019 (display-buffer buffer))
3021 ((eq method 'otherframe)
3022 (switch-to-buffer-other-frame buffer)
3023 (unless (featurep 'xemacs)
3024 (select-frame-set-input-focus (selected-frame)))
3028 (defun ido-window-buffer-p (buffer)
3029 ;; Return window pointer if BUFFER is visible in another frame.
3030 ;; If BUFFER is visible in the current frame, return nil.
3031 (let ((blist (ido-get-buffers-in-frames 'current)))
3032 ;;If the buffer is visible in current frame, return nil
3033 (if (member buffer blist)
3035 ;; maybe in other frame or icon
3036 (get-buffer-window buffer 0) ; better than 'visible
3040 ;;; ----------- IDONIZED FUNCTIONS ------------
3043 (defun ido-switch-buffer ()
3044 "Switch to another buffer.
3045 The buffer is displayed according to `ido-default-buffer-method' -- the
3046 default is to show it in the same window, unless it is already visible
3049 As you type in a string, all of the buffers matching the string are
3050 displayed if substring-matching is used \(default). Look at
3051 `ido-enable-prefix' and `ido-toggle-prefix'. When you have found the
3052 buffer you want, it can then be selected. As you type, most keys have their
3053 normal keybindings, except for the following: \\<ido-mode-map>
3055 RET Select the buffer at the front of the list of matches. If the
3056 list is empty, possibly prompt to create new buffer.
3058 \\[ido-select-text] Select the current prompt as the buffer.
3059 If no buffer is found, prompt for a new one.
3061 \\[ido-next-match] Put the first element at the end of the list.
3062 \\[ido-prev-match] Put the last element at the start of the list.
3063 \\[ido-complete] Complete a common suffix to the current string that
3064 matches all buffers. If there is only one match, select that buffer.
3065 If there is no common suffix, show a list of all matching buffers
3066 in a separate window.
3067 \\[ido-edit-input] Edit input string.
3068 \\[ido-fallback-command] Fallback to non-ido version of current command.
3069 \\[ido-toggle-regexp] Toggle regexp searching.
3070 \\[ido-toggle-prefix] Toggle between substring and prefix matching.
3071 \\[ido-toggle-case] Toggle case-sensitive searching of buffer names.
3072 \\[ido-completion-help] Show list of matching buffers in separate window.
3073 \\[ido-enter-find-file] Drop into ido-find-file.
3074 \\[ido-kill-buffer-at-head] Kill buffer at head of buffer list.
3075 \\[ido-toggle-ignore] Toggle ignoring buffers listed in `ido-ignore-buffers'."
3077 (ido-buffer-internal ido-default-buffer-method))
3080 (defun ido-switch-buffer-other-window ()
3081 "Switch to another buffer and show it in another window.
3082 The buffer name is selected interactively by typing a substring.
3083 For details of keybindings, do `\\[describe-function] ido'."
3085 (ido-buffer-internal 'otherwindow 'switch-to-buffer-other-window))
3088 (defun ido-display-buffer ()
3089 "Display a buffer in another window but don't select it.
3090 The buffer name is selected interactively by typing a substring.
3091 For details of keybindings, do `\\[describe-function] ido'."
3093 (ido-buffer-internal 'display 'display-buffer))
3096 (defun ido-kill-buffer ()
3098 The buffer name is selected interactively by typing a substring.
3099 For details of keybindings, do `\\[describe-function] ido'."
3101 (ido-buffer-internal 'kill 'kill-buffer "Kill buffer: " (buffer-name (current-buffer))))
3104 (defun ido-insert-buffer ()
3105 "Insert contents of a buffer in current buffer after point.
3106 The buffer name is selected interactively by typing a substring.
3107 For details of keybindings, do `\\[describe-function] ido'."
3109 (ido-buffer-internal 'insert 'insert-buffer "Insert buffer: "))
3112 (defun ido-switch-buffer-other-frame ()
3113 "Switch to another buffer and show it in another frame.
3114 The buffer name is selected interactively by typing a substring.
3115 For details of keybindings, do `\\[describe-function] ido'."
3118 (ido-buffer-internal 'otherframe)
3119 (call-interactively 'switch-to-buffer-other-frame)))
3122 (defun ido-find-file-in-dir (dir)
3123 "Switch to another file starting from DIR."
3124 (interactive "DDir: ")
3125 (if (not (equal (substring dir -1) "/"))
3126 (setq dir (concat dir "/")))
3127 (ido-file-internal ido-default-file-method nil dir))
3130 (defun ido-find-file ()
3131 "Edit file with name obtained via minibuffer.
3132 The file is displayed according to `ido-default-file-method' -- the
3133 default is to show it in the same window, unless it is already
3134 visible in another frame.
3136 The file name is selected interactively by typing a substring. As you type
3137 in a string, all of the filenames matching the string are displayed if
3138 substring-matching is used \(default). Look at `ido-enable-prefix' and
3139 `ido-toggle-prefix'. When you have found the filename you want, it can
3140 then be selected. As you type, most keys have their normal keybindings,
3141 except for the following: \\<ido-mode-map>
3143 RET Select the file at the front of the list of matches. If the
3144 list is empty, possibly prompt to create new file.
3146 \\[ido-select-text] Select the current prompt as the buffer or file.
3147 If no buffer or file is found, prompt for a new one.
3149 \\[ido-next-match] Put the first element at the end of the list.
3150 \\[ido-prev-match] Put the last element at the start of the list.
3151 \\[ido-complete] Complete a common suffix to the current string that
3152 matches all files. If there is only one match, select that file.
3153 If there is no common suffix, show a list of all matching files
3154 in a separate window.
3155 \\[ido-edit-input] Edit input string (including path).
3156 \\[ido-prev-work-directory] or \\[ido-next-work-directory] go to previous/next directory in work directory history.
3157 \\[ido-merge-work-directories] search for file in the work directory history.
3158 \\[ido-forget-work-directory] removes current directory from the work directory history.
3159 \\[ido-prev-work-file] or \\[ido-next-work-file] cycle through the work file history.
3160 \\[ido-wide-find-file] and \\[ido-wide-find-dir] prompts and uses find to locate files or directories.
3161 \\[ido-make-directory] prompts for a directory to create in current directory.
3162 \\[ido-fallback-command] Fallback to non-ido version of current command.
3163 \\[ido-toggle-regexp] Toggle regexp searching.
3164 \\[ido-toggle-prefix] Toggle between substring and prefix matching.
3165 \\[ido-toggle-case] Toggle case-sensitive searching of file names.
3166 \\[ido-toggle-vc] Toggle version control for this file.
3167 \\[ido-toggle-literal] Toggle literal reading of this file.
3168 \\[ido-completion-help] Show list of matching files in separate window.
3169 \\[ido-toggle-ignore] Toggle ignoring files listed in `ido-ignore-files'."
3172 (ido-file-internal ido-default-file-method))
3175 (defun ido-find-file-other-window ()
3176 "Switch to another file and show it in another window.
3177 The file name is selected interactively by typing a substring.
3178 For details of keybindings, do `\\[describe-function] ido-find-file'."
3180 (ido-file-internal 'otherwindow 'find-file-other-window))
3183 (defun ido-find-alternate-file ()
3184 "Switch to another file and show it in another window.
3185 The file name is selected interactively by typing a substring.
3186 For details of keybindings, do `\\[describe-function] ido-find-file'."
3188 (ido-file-internal 'alt-file 'find-alternate-file nil "Find alternate file: "))
3191 (defun ido-find-file-read-only ()
3192 "Edit file read-only with name obtained via minibuffer.
3193 The file name is selected interactively by typing a substring.
3194 For details of keybindings, do `\\[describe-function] ido-find-file'."
3196 (ido-file-internal 'read-only 'find-file-read-only nil "Find file read-only: "))
3199 (defun ido-find-file-read-only-other-window ()
3200 "Edit file read-only in other window with name obtained via minibuffer.
3201 The file name is selected interactively by typing a substring.
3202 For details of keybindings, do `\\[describe-function] ido-find-file'."
3204 (ido-file-internal 'read-only 'find-file-read-only-other-window nil "Find file read-only other window: "))
3207 (defun ido-find-file-read-only-other-frame ()
3208 "Edit file read-only in other frame with name obtained via minibuffer.
3209 The file name is selected interactively by typing a substring.
3210 For details of keybindings, do `\\[describe-function] ido-find-file'."
3212 (ido-file-internal 'read-only 'find-file-read-only-other-frame nil "Find file read-only other frame: "))
3215 (defun ido-display-file ()
3216 "Display a file in another window but don't select it.
3217 The file name is selected interactively by typing a substring.
3218 For details of keybindings, do `\\[describe-function] ido-find-file'."
3220 (ido-file-internal 'display))
3223 (defun ido-find-file-other-frame ()
3224 "Switch to another file and show it in another frame.
3225 The file name is selected interactively by typing a substring.
3226 For details of keybindings, do `\\[describe-function] ido-find-file'."
3228 (ido-file-internal 'otherframe 'find-file-other-frame))
3231 (defun ido-write-file ()
3232 "Write current buffer to a file.
3233 The file name is selected interactively by typing a substring.
3234 For details of keybindings, do `\\[describe-function] ido-find-file'."
3236 (let ((ido-process-ignore-lists t)
3237 (ido-work-directory-match-only nil)
3238 (ido-ignore-files (cons "[^/]\\'" ido-ignore-files))
3239 (ido-report-no-match nil)
3240 (ido-auto-merge-work-directories-length -1))
3241 (ido-file-internal 'write 'write-file nil "Write file: ")))
3244 (defun ido-insert-file ()
3245 "Insert contents of file in current buffer.
3246 The file name is selected interactively by typing a substring.
3247 For details of keybindings, do `\\[describe-function] ido-find-file'."
3249 (ido-file-internal 'insert 'insert-file nil "Insert file: "))
3253 "Call dired the ido way.
3254 The directory is selected interactively by typing a substring.
3255 For details of keybindings, do `\\[describe-function] ido-find-file'."
3257 (let ((ido-report-no-match nil)
3258 (ido-auto-merge-work-directories-length -1))
3259 (ido-file-internal 'dired 'dired nil "Dired: " 'dir)))
3261 (defun ido-list-directory ()
3262 "Call list-directory the ido way.
3263 The directory is selected interactively by typing a substring.
3264 For details of keybindings, do `\\[describe-function] ido-find-file'."
3266 (let ((ido-report-no-match nil)
3267 (ido-auto-merge-work-directories-length -1))
3268 (ido-file-internal 'list-directory 'list-directory nil "List directory: " 'dir)))
3270 ;;; XEmacs hack for showing default buffer
3272 ;; The first time we enter the minibuffer, Emacs puts up the default
3273 ;; buffer to switch to, but XEmacs doesn't -- presumably there is a
3274 ;; subtle difference in the two versions of post-command-hook. The
3275 ;; default is shown for both whenever we delete all of our text
3276 ;; though, indicating its just a problem the first time we enter the
3277 ;; function. To solve this, we use another entry hook for emacs to
3278 ;; show the default the first time we enter the minibuffer.
3281 ;;; ICOMPLETE TYPE CODE
3283 (defun ido-initiate-auto-merge (buffer)
3284 (ido-trace "\n*merge timeout*" buffer)
3285 (setq ido-auto-merge-timer nil)
3286 (when (and (buffer-live-p buffer)
3287 (= ido-use-mycompletion-depth (minibuffer-depth))
3288 (boundp 'ido-eoinput) ido-eoinput)
3289 (let ((contents (buffer-substring-no-properties (minibuffer-prompt-end) ido-eoinput)))
3290 (ido-trace "request merge")
3291 (setq ido-use-merged-list 'auto
3292 ido-text-init contents
3298 (throw 'ido contents))))
3300 (defun ido-exhibit ()
3301 "Post command hook for `ido'."
3302 ;; Find matching files and display a list in the minibuffer.
3303 ;; Copied from `icomplete-exhibit' with two changes:
3304 ;; 1. It prints a default file name when there is no text yet entered.
3305 ;; 2. It calls my completion routine rather than the standard completion.
3307 (if (= ido-use-mycompletion-depth (minibuffer-depth))
3308 (let ((contents (buffer-substring-no-properties (minibuffer-prompt-end) (point-max)))
3309 (buffer-undo-list t)
3310 try-single-dir-match)
3312 (ido-trace "\nexhibit" this-command)
3313 (ido-trace "dir" ido-current-directory)
3314 (ido-trace "contents" contents)
3315 (ido-trace "list" ido-cur-list)
3316 (ido-trace "matches" ido-matches)
3317 (ido-trace "rescan" ido-rescan)
3320 (goto-char (point-max))
3321 ;; Register the end of input, so we know where the extra stuff (match-status info) begins:
3322 (if (not (boundp 'ido-eoinput))
3323 ;; In case it got wiped out by major mode business:
3324 (make-local-variable 'ido-eoinput))
3325 (setq ido-eoinput (point))
3327 ;; Handle explicit directory changes
3329 (memq ido-cur-item '(file dir))
3330 (> (length contents) 1)
3332 ((ido-final-slash contents) ;; xxx/
3333 (ido-trace "final slash" contents)
3335 ((string-equal contents "~/")
3336 (ido-set-current-home)
3338 ((string-equal contents "../")
3339 (ido-up-directory t)
3341 ((string-equal contents "./")
3343 ((string-match contents "\\`~[a-zA-Z0-9]/\\'")
3344 (ido-set-current-home contents)
3346 ((string-match "[$][A-Za-z0-9_]+/\\'" contents)
3347 (let ((exp (condition-case ()
3349 (substitute-in-file-name (substring contents 0 -1))
3350 ido-current-directory)
3352 (ido-trace contents exp)
3353 (if (and exp (file-directory-p exp))
3355 (ido-set-current-directory (file-name-directory exp))
3356 (setq ido-text-init (file-name-nondirectory exp))
3359 ((and (memq system-type '(windows-nt ms-dos))
3360 (string-equal (substring contents 1) ":/"))
3361 (ido-set-current-directory (file-name-directory contents))
3363 ((string-equal (substring contents -2 -1) "/")
3364 (ido-set-current-directory
3365 (if (memq system-type '(windows-nt ms-dos))
3366 (expand-file-name "/" ido-current-directory)
3370 (setq try-single-dir-match t)
3373 ((and (string-equal ido-current-directory "/")
3374 (string-match "..:\\'" contents)) ;; Ange-ftp
3375 (ido-set-current-directory "/" contents)
3376 (when (ido-is-slow-ftp-host)
3377 (setq ido-exit 'fallback)
3381 ((and (string-equal (substring contents -2 -1) "/")
3382 (not (string-match "[$]" contents)))
3383 (ido-set-current-directory
3385 ((= (length contents) 2)
3388 (concat ido-current-directory (car ido-matches)))
3390 (concat ido-current-directory (substring contents 0 -1)))))
3391 (setq ido-text-init (substring contents -1))
3394 ((and (not ido-use-merged-list)
3395 (not (ido-final-slash contents))
3396 (eq ido-try-merged-list t)
3397 (numberp ido-auto-merge-work-directories-length)
3398 (> ido-auto-merge-work-directories-length 0)
3399 (= (length contents) ido-auto-merge-work-directories-length)
3400 (not (and ido-auto-merge-inhibit-characters-regexp
3401 (string-match ido-auto-merge-inhibit-characters-regexp contents)))
3402 (not (input-pending-p)))
3403 (setq ido-use-merged-list 'auto
3404 ido-text-init contents
3408 (ido-trace "refresh on /" ido-text-init)
3409 (setq ido-exit 'refresh)
3412 ;; Update the list of matches
3413 (setq ido-text contents)
3415 (ido-trace "new " ido-matches)
3417 (when (and ido-enter-single-matching-directory
3419 (null (cdr ido-matches))
3420 (ido-final-slash (car ido-matches))
3421 (or try-single-dir-match
3422 (eq ido-enter-single-matching-directory t)))
3423 (ido-trace "single match" (car ido-matches))
3424 (ido-set-current-directory
3425 (concat ido-current-directory (car ido-matches)))
3426 (setq ido-exit 'refresh)
3429 (when (and (not ido-matches)
3431 ido-process-ignore-lists
3433 (let ((ido-process-ignore-lists nil)
3434 (ido-rotate ido-rotate)
3435 (ido-cur-list ido-ignored-list))
3436 (ido-trace "try all" ido-ignored-list)
3439 (ido-trace "found " ido-matches)
3441 (setq ido-process-ignore-lists-inhibit t)
3442 (setq ido-text-init ido-text)
3443 (setq ido-exit 'refresh)
3449 (memq ido-cur-item '(file dir))
3450 (not (ido-is-root-directory))
3451 (> (length contents) 1)
3452 (not (string-match "[$]" contents)))
3453 (ido-trace "merge?")
3454 (if ido-use-merged-list
3455 (ido-undo-merge-work-directory contents nil)
3456 (when (and (eq ido-try-merged-list t)
3457 (numberp ido-auto-merge-work-directories-length)
3458 (= ido-auto-merge-work-directories-length 0)
3459 (not (and ido-auto-merge-inhibit-characters-regexp
3460 (string-match ido-auto-merge-inhibit-characters-regexp contents)))
3461 (not (input-pending-p)))
3462 (ido-trace "\n*start timer*")
3463 (setq ido-auto-merge-timer
3464 (run-with-timer ido-auto-merge-delay-time nil 'ido-initiate-auto-merge (current-buffer))))))
3468 (if (and ido-use-merged-list
3470 (not (string-equal (car (cdr (car ido-matches))) ido-current-directory)))
3472 (ido-set-current-directory (car (cdr (car ido-matches))))
3473 (setq ido-use-merged-list t
3475 ido-text-init ido-text)
3478 ;; Insert the match-status information:
3479 (ido-set-common-completion)
3480 (let ((inf (ido-completions
3482 minibuffer-completion-table
3483 minibuffer-completion-predicate
3484 (not minibuffer-completion-confirm))))
3485 (ido-trace "inf" inf)
3490 (defun ido-completions (name candidates predicate require-match)
3491 ;; Return the string that is displayed after the user's text.
3492 ;; Modified from `icomplete-completions'.
3494 (let* ((comps ido-matches)
3495 (ind (and (consp (car comps)) (> (length (cdr (car comps))) 1)
3496 ido-merged-indicator))
3499 (if (and ind ido-use-faces)
3500 (put-text-property 0 1 'face 'ido-indicator-face ind))
3502 (if (and ido-use-faces comps)
3503 (let* ((fn (ido-name (car comps)))
3505 (setq first (format "%s" fn))
3506 (put-text-property 0 ln 'face
3507 (if (= (length comps) 1)
3508 'ido-only-match-face
3509 'ido-first-match-face)
3511 (if ind (setq first (concat first ind)))
3512 (setq comps (cons first (cdr comps)))))
3515 (if ido-report-no-match
3516 (nth 6 ido-decorations) ;; [No Match]
3519 ((null (cdr comps)) ;one match
3520 (concat (if (> (length (ido-name (car comps))) (length name))
3521 ;; when there is one match, show the matching file name in full
3522 (concat (nth 4 ido-decorations) ;; [ ... ]
3523 (ido-name (car comps))
3524 (nth 5 ido-decorations))
3526 (if (not ido-use-faces) (nth 7 ido-decorations)))) ;; [Matched]
3527 (t ;multiple matches
3528 (let* ((items (if (> ido-max-prospects 0) (1+ ido-max-prospects) 999))
3536 (setq com (ido-name com))
3537 (setq items (1- items))
3540 ((= items 0) (list (nth 3 ido-decorations))) ; " | ..."
3542 (list (or ido-separator (nth 2 ido-decorations)) ; " | "
3543 (let ((str (substring com 0)))
3544 (if (and ido-use-faces
3545 (not (string= str first))
3546 (ido-final-slash str))
3547 (put-text-property 0 (length str) 'face 'ido-subdir-face str))
3552 ;; put in common completion item -- what you get by pressing tab
3553 (if (and (stringp ido-common-match-string)
3554 (> (length ido-common-match-string) (length name)))
3555 (concat (nth 4 ido-decorations) ;; [ ... ]
3556 (substring ido-common-match-string (length name))
3557 (nth 5 ido-decorations)))
3558 ;; list all alternatives
3559 (nth 0 ido-decorations) ;; { ... }
3561 (nth 1 ido-decorations)))))))
3563 (defun ido-minibuffer-setup ()
3564 "Minibuffer setup hook for `ido'."
3565 ;; Copied from `icomplete-minibuffer-setup-hook'.
3566 (when (and (boundp 'ido-completing-read)
3567 (or (featurep 'xemacs)
3568 (= ido-use-mycompletion-depth (minibuffer-depth))))
3569 (add-hook 'pre-command-hook 'ido-tidy nil t)
3570 (add-hook 'post-command-hook 'ido-exhibit nil t)
3571 (setq cua-inhibit-cua-keys t)
3572 (when (featurep 'xemacs)
3574 (goto-char (point-min)))
3575 (run-hooks 'ido-minibuffer-setup-hook)))
3578 "Pre command hook for `ido'."
3579 ;; Remove completions display, if any, prior to new user input.
3580 ;; Copied from `icomplete-tidy'."
3582 (when ido-auto-merge-timer
3583 (ido-trace "\n*cancel timer*" this-command)
3584 (cancel-timer ido-auto-merge-timer)
3585 (setq ido-auto-merge-timer nil))
3587 (if (and (boundp 'ido-use-mycompletion-depth)
3588 (= ido-use-mycompletion-depth (minibuffer-depth)))
3589 (if (and (boundp 'ido-eoinput)
3592 (if (> ido-eoinput (point-max))
3593 ;; Oops, got rug pulled out from under us - reinit:
3594 (setq ido-eoinput (point-max))
3595 (let ((buffer-undo-list t))
3596 (delete-region ido-eoinput (point-max))))
3598 ;; Reestablish the local variable 'cause minibuffer-setup is weird:
3599 (make-local-variable 'ido-eoinput)
3600 (setq ido-eoinput 1))))
3602 (defun ido-summary-buffers-to-end ()
3603 ;; Move the summaries to the end of the buffer list.
3604 ;; This is an example function which can be hooked on to
3605 ;; `ido-make-buffer-list-hook'. Any buffer matching the regexps
3606 ;; `Summary' or `output\*$'are put to the end of the list.
3607 (let ((summaries (delq nil (mapcar
3610 (string-match "Summary" x)
3611 (string-match "output\\*\\'" x))
3614 (ido-to-end summaries)))
3616 ;;; Helper functions for other programs
3619 (defun ido-read-file-name (prompt &optional dir default-filename mustmatch initial predicate)
3620 "Read file name, prompting with PROMPT and completing in directory DIR.
3621 See `read-file-name' for additional parameters."
3622 (message "%S %S %S %S" this-command ido-read-file-name-non-ido
3623 predicate (memq this-command ido-read-file-name-non-ido))
3625 ((or (eq predicate 'file-directory-p)
3626 (memq this-command ido-read-file-name-as-directory-commands))
3627 (ido-read-directory-name prompt dir default-filename mustmatch initial))
3628 ((and (not (memq this-command ido-read-file-name-non-ido))
3629 (or (null predicate) (eq predicate 'file-exists-p)))
3632 (vc-master-templates (and (boundp 'vc-master-templates) vc-master-templates))
3633 (ido-current-directory (expand-file-name (or dir default-directory)))
3634 (ido-work-directory-index -1)
3635 (ido-work-file-index -1)
3636 (ido-find-literal nil))
3638 (ido-read-internal 'file prompt 'ido-file-history default-filename mustmatch initial))
3640 (concat ido-current-directory filename))))
3642 (let ((read-file-name-function nil))
3643 (read-file-name prompt dir default-filename mustmatch initial predicate)))))
3646 (defun ido-read-directory-name (prompt &optional dir default-dirname mustmatch initial)
3647 "Read directory name, prompting with PROMPT and completing in directory DIR.
3648 See `read-file-name' for additional parameters."
3651 (ido-current-directory (expand-file-name (or dir default-directory)))
3652 (ido-work-directory-index -1)
3653 (ido-work-file-index -1))
3655 (ido-read-internal 'dir prompt 'ido-file-history default-dirname mustmatch initial))
3657 (if (and (stringp filename) (string-equal filename "."))
3658 ido-current-directory
3659 (concat ido-current-directory filename)))))
3661 ;;; ido.el ends here