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