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