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