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