;;; ido.el --- interactively do things with buffers and files.
-;; Copyright (C) 1996-2002 Free Software Foundation, Inc.
+;; Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
+;; 2004, 2005 Free Software Foundation, Inc.
;; Author: Kim F. Storm <storm@cua.dk>
;; Based on: iswitchb by Stephen Eglen <stephen@cns.ed.ac.uk>
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
;;; Acknowledgements
;; Infinite amounts of gratitude goes to Stephen Eglen <stephen@cns.ed.ac.uk>
-;; who wrote iswitch-buffer mode - from which I ripped off 99% of the code
+;; who wrote iswitch-buffer mode - from which I ripped off 99% of the code
;; for ido-switch-buffer and found the inspiration for ido-find-file.
;; The ido package would never have existed without his work.
-;; Also thanks to Klaus Berndl, Rohit Namjoshi, Robert Fenk, Alex Schroeder,
-;; Bill Benedetto, and Stephen Eglen for bug fixes and improvements.
+;; Also thanks to Klaus Berndl, Rohit Namjoshi, Robert Fenk, Alex
+;; Schroeder, Bill Benedetto, Stephen Eglen, and many others for bug
+;; fixes and improvements.
;;; History
;; so I invented a common "ido-" namespace for the merged packages.
;;
;; This version is based on ido.el version 1.57 released on
-;; gnu.emacs.sources adapted for emacs 21.4 to use command remapping
+;; gnu.emacs.sources adapted for emacs 22.1 to use command remapping
;; and optionally hooking the read-buffer and read-file-name functions.
;;
;; Prefix matching was added by Klaus Berndl <klaus.berndl@sdm.de> based on
;; most recent, when I use ido-switch-buffer, I first of all get
;; presented with the list of all the buffers
;;
-;; Buffer: {123456,123}
+;; Buffer: {123456,123}
;;
;; If I then press 2:
;; Buffer: 2[3]{123456,123}
;; The list in {...} are the matching buffers, most recent first
;; (buffers visible in the current frame are put at the end of the
;; list by default). At any time I can select the item at the head of
-;; the list by pressing RET. I can also bring the put the first
-;; element at the end of the list by pressing C-s or [right], or put
-;; the last element at the head of the list by pressing C-r or [left].
+;; the list by pressing RET. I can also put the first element at the
+;; end of the list by pressing C-s or [right], or bring the last
+;; element to the head of the list by pressing C-r or [left].
;;
;; The item in [...] indicates what can be added to my input by
;; pressing TAB. In this case, I will get "3" added to my input.
;; drive, enter X:/ where X is the drive letter. You can also visit
;; files on other hosts using the ange-ftp notations `/host:' and
;; `/user@host:'. See the variable `ido-slow-ftp-hosts' if you want
-;; to inhibit the ido substring matching for ftp access.
+;; to inhibit the ido substring matching for ftp access.
;;
;; If for some reason you cannot specify the proper file using
;; ido-find-file, you can press C-f to enter the normal find-file.
;; Example:
;;
;; If you have again two Buffers "123456" and "123" then hitting "2" does
-;; not match because "2" is not a PREFIX in any of the buffer-names. This
-;; is the only difference between the substring and prefix matching.
+;; not match because "2" is not a PREFIX in any of the buffer-names.
;; Flexible matching
;; -----------------
;;
;; There is limited provision for regexp matching within ido,
;; enabled through `ido-enable-regexp' (toggle with C-t).
-;; This allows you to type `c$' for example and see all file names
-;; ending in `c'. This facility is quite limited though in two
-;; respects. First, you can't currently type in expressions like
-;; `[0-9]' directly -- you have to type them in when ido-enable-regexp
-;; is nil and then toggle on the regexp functionality. Likewise,
-;; don't enter an expression containing `\' in regexp mode. If you
-;; try, ido gets confused, so just hit C-g and try again. Secondly,
-;; no completion mechanism is currently offered with regexp searching.
+;; This allows you to type `[ch]$' for example and see all file names
+;; ending in `c' or `h'.
+;;
+;; Note: ido-style completion is inhibited when you enable regexp matching.
;; Customization
;;
;; Customize the `ido' group to change the `ido' functionality.
;;
-;; To modify the keybindings, use the hook provided. For example:
-;;(add-hook 'ido-define-mode-map-hook 'ido-my-keys)
+;; To modify the keybindings, use the ido-setup-hook. For example:
+;;(add-hook 'ido-setup-hook 'ido-my-keys)
;;
;;(defun ido-my-keys ()
;; "Add my keybindings for ido."
;; then all files matching "Summary" are moved to the end of the
;; list. (I find this handy for keeping the INBOX Summary and so on
;; out of the way.) It also moves files matching "output\*$" to the
-;; end of the list (these are created by AUC TeX when compiling.)
+;; end of the list (these are created by AUCTeX when compiling.)
;; Other functions could be made available which alter the list of
;; matching files (either deleting or rearranging elements.)
;; ------------
;; The highlighting of matching items is controlled via ido-use-faces.
-;; The faces used are ido-first-match-face, ido-only-match-face and
-;; ido-subdir-face.
+;; The faces used are ido-first-match, ido-only-match and
+;; ido-subdir.
;; Colouring of the matching item was suggested by
;; Carsten Dominik (dominik@strw.leidenuniv.nl).
(provide 'ido)
+(defvar cua-inhibit-cua-keys)
+
;;; User Variables
;;
;; These are some things you might want to change.
"Switch between files using substrings."
:group 'extensions
:group 'convenience
+ :version "22.1"
:link '(emacs-commentary-link :tag "Commentary" "ido.el")
:link '(emacs-library-link :tag "Lisp File" "ido.el"))
;;;###autoload
(defcustom ido-mode nil
"Determines for which functional group \(buffer and files) ido behavior
-should be enabled. The following values are possible:
-- 'buffer: Turn only on ido buffer behavior \(switching, killing,
- displaying...)
-- 'file: Turn only on ido file behavior \(finding, writing, inserting...)
-- 'both: Turn on ido buffer and file behavior.
-- nil: Turn off any ido switching.
+should be enabled. The following values are possible:
+- `buffer': Turn only on ido buffer behavior \(switching, killing,
+ displaying...)
+- `file': Turn only on ido file behavior \(finding, writing, inserting...)
+- `both': Turn on ido buffer and file behavior.
+- `nil': Turn off any ido switching.
Setting this variable directly does not take effect;
use either \\[customize] or the function `ido-mode'."
:require 'ido
:link '(emacs-commentary-link "ido.el")
:set-after '(ido-save-directory-list-file)
- :version "21.4"
- :type '(choice (const :tag "Turn on only buffer" buffer)
+ :type '(choice (const :tag "Turn on only buffer" buffer)
(const :tag "Turn on only file" file)
(const :tag "Turn on both buffer and file" both)
(const :tag "Switch off all" nil))
Setting this variable directly does not work. Use `customize' or
call the function `ido-everywhere'."
:set #'(lambda (symbol value)
- (ido-everywhere value))
+ (ido-everywhere (if value 1 -1)))
:initialize 'custom-initialize-default
:type 'boolean
:group 'ido)
:type 'boolean
:group 'ido)
+(defcustom ido-file-extensions-order nil
+ "*List of file extensions specifying preferred order of file selections.
+Each element is either a string with `.' as the first char, an empty
+string matching files without extension, or t which is the default order
+for files with an unlisted file extension."
+ :type '(repeat (choice string
+ (const :tag "Default order" t)))
+ :group 'ido)
+
(defcustom ido-ignore-directories
'("\\`CVS/" "\\`\\.\\./" "\\`\\./")
"*List of regexps or functions matching sub-directory names to ignore."
:group 'ido)
(defcustom ido-ignore-directories-merge nil
- "*List of regexps or functions matching directory path names to ignore during merge.
-Directory paths matched by one of the regexps in this list are not inserted
+ "*List of regexps or functions matching directory names to ignore during merge.
+Directory names matched by one of the regexps in this list are not inserted
in merged file and directory lists."
:type '(repeat (choice regexp function))
:group 'ido)
`otherframe' Show new file in another frame
`maybe-frame' If a file is visible in another frame, prompt to ask if you
you want to see the file in the same window of the current
- frame or in the other frame.
+ frame or in the other frame
`always-frame' If a file is visible in another frame, raise that
- frame. Otherwise, visit the file in the same window."
- :type '(choice (const samewindow)
+ frame; otherwise, visit the file in the same window"
+ :type '(choice (const samewindow)
(const otherwindow)
(const display)
- (const otherframe)
+ (const otherframe)
(const maybe-frame)
(const always-frame))
:group 'ido)
(defcustom ido-default-buffer-method 'always-frame
"*How to switch to new buffer when using `ido-switch-buffer'.
-See ido-default-file-method for details."
- :type '(choice (const samewindow)
+See `ido-default-file-method' for details."
+ :type '(choice (const samewindow)
(const otherwindow)
(const display)
- (const otherframe)
+ (const otherframe)
(const maybe-frame)
(const always-frame))
:group 'ido)
:group 'ido)
(defcustom ido-enable-prefix nil
- "*Nil means that `ido' will match if the inserted text is an
-arbitrary substring (default). If non-nil `ido' will only match if the inserted
-text is a prefix \(this behavior is like the standard unix- or
-emacs-completion works).
+ "*Non-nil means only match if the entered text is a prefix of file name.
+This behavior is like the standard emacs-completion.
+Nil means to match if the entered text is an arbitrary substring.
Value can be toggled within `ido' using `ido-toggle-prefix'."
:type 'boolean
:group 'ido)
+(defcustom ido-enable-dot-prefix nil
+ "*Non-nil means to match leading dot as prefix.
+I.e. hidden files and buffers will match only if you type a dot
+as first char even if `ido-enable-prefix' is nil."
+ :type 'boolean
+ :group 'ido)
+
+(defcustom ido-confirm-unique-completion nil
+ "*Non-nil means that even a unique completion must be confirmed.
+This means that \\[ido-complete] must always be followed by \\[ido-exit-minibuffer]
+even when there is only one unique completion."
+ :type 'boolean
+ :group 'ido)
+
+(defcustom ido-cannot-complete-command 'ido-completion-help
+ "*Command run when `ido-complete' can't complete any more.
+The most useful values are `ido-completion-help', which pops up a
+window with completion alternatives, or `ido-next-match' or
+`ido-prev-match', which cycle the buffer list."
+ :type 'function
+ :group 'ido)
+
+
(defcustom ido-record-commands t
"*Non-nil means that `ido' will record commands in command history.
Note that the non-ido equivalent command is recorded."
(defcustom ido-max-prospects 12
"*Non-zero means that the prospect list will be limited to than number of items.
For a long list of prospects, building the full list for the minibuffer can take a
-non-negletable amount of time; setting this variable reduces that time."
+non-negligible amount of time; setting this variable reduces that time."
:type 'integer
:group 'ido)
-(defcustom ido-max-prompt-path 0.35
+(defcustom ido-max-file-prompt-width 0.35
"*Non-zero means that the prompt string be limited to than number of characters.
If value is a floating point number, it specifies a fraction of the frame width."
:type '(choice
:group 'ido)
(defcustom ido-enable-last-directory-history t
- "*Non-nil means that `ido' will remember latest selected directory paths.
+ "*Non-nil means that `ido' will remember latest selected directory names.
See `ido-last-directory-list' and `ido-save-directory-list-file'."
:type 'boolean
:group 'ido)
(defcustom ido-work-directory-list-ignore-regexps nil
"*List of regexps matching directories which should not be recorded.
-Directory paths matched by one of the regexps in this list are not inserted in
+Directory names matched by one of the regexps in this list are not inserted in
the `ido-work-directory-list' list."
:type '(repeat regexp)
:group 'ido)
+
+(defcustom ido-use-filename-at-point nil
+ "*Non-nil means that ido shall look for a filename at point.
+May use `ffap-guesser' to guess whether text at point is a filename.
+If found, use that as the starting point for filename selection."
+ :type '(choice
+ (const :tag "Disabled" nil)
+ (const :tag "Guess filename" guess)
+ (other :tag "Use literal filename" t))
+ :group 'ido)
+
+
+(defcustom ido-use-url-at-point nil
+ "*Non-nil means that ido shall look for a URL at point.
+If found, call `find-file-at-point' to visit it."
+ :type 'boolean
+ :group 'ido)
+
+
+(defcustom ido-enable-tramp-completion t
+ "*Non-nil means that ido shall perform tramp method and server name completion.
+A tramp file name uses the following syntax: /method:user@host:filename."
+ :type 'boolean
+ :group 'ido)
+
(defcustom ido-record-ftp-work-directories t
- "*Non-nil means that ftp paths are recorded in work directory list."
+ "*Non-nil means record ftp file names in the work directory list."
:type 'boolean
:group 'ido)
(defcustom ido-merge-ftp-work-directories nil
- "*Nil means that ftp paths in work directory list are ignored during merge."
+ "*If nil means merging ignores ftp file names in the work directory list."
:type 'boolean
:group 'ido)
(defcustom ido-slow-ftp-hosts nil
"*List of slow ftp hosts where ido prompting should not be used.
If an ftp host is on this list, ido automatically switches to the non-ido
-equivalent function, e.g. find-file rather than ido-find-file."
+equivalent function, e.g. `find-file' rather than `ido-find-file'."
:type '(repeat string)
:group 'ido)
:type 'integer
:group 'ido)
+(defcustom ido-max-directory-size 30000
+ "*Maximum size (in bytes) for directories to use ido completion.
+If you enter a directory with a size larger than this size, ido will
+not provide the normal completion. To show the completions, use C-a."
+ :type '(choice (const :tag "No limit" nil)
+ (integer :tag "Size in bytes" 30000))
+ :group 'ido)
+
(defcustom ido-rotate-file-list-default nil
"*Non-nil means that `ido' will always rotate file list to get default in front."
:type 'boolean
:group 'ido)
-(defcustom ido-enter-single-matching-directory nil
- "*Automatically enter sub-directory if it is the only matching item, if non-nil.
-If value is 'slash, only enter if typing final slash, else do it always."
- :type '(choice (const :tag "Never" nil)
- (const :tag "When typing /" slash)
- (other :tag "Always" t))
+(defcustom ido-enter-matching-directory 'only
+ "*Additional methods to enter sub-directory of first/only matching item.
+If value is 'first, enter first matching sub-directory when typing a slash.
+If value is 'only, typing a slash only enters the sub-directory if it is
+the only matching item.
+If value is t, automatically enter a sub-directory when it is the only
+matching item, even without typing a slash."
+ :type '(choice (const :tag "Never" nil)
+ (const :tag "Slash enters first directory" first)
+ (const :tag "Slash enters first and only directory" only)
+ (other :tag "Always enter unique directory" t))
:group 'ido)
(defcustom ido-create-new-buffer 'prompt
"*Specify whether a new buffer is created if no buffer matches substring.
Choices are 'always to create new buffers unconditionally, 'prompt to
ask user whether to create buffer, or 'never to never create new buffer."
- :type '(choice (const always)
+ :type '(choice (const always)
(const prompt)
(const never))
:group 'ido)
-(defcustom ido-define-mode-map-hook nil
- "*Hook to define keys in `ido-mode-map' for extra keybindings."
+(defcustom ido-setup-hook nil
+ "*Hook run after the ido variables and keymap have been setup.
+The dynamic variable `ido-cur-item' contains the current type of item that
+is read by ido, possible values are file, dir, buffer, and list.
+Additional keys can be defined in `ido-mode-map'."
:type 'hook
:group 'ido)
(defcustom ido-separator nil
"*String used by ido to separate the alternatives in the minibuffer.
Obsolete. Set 3rd element of `ido-decorations' instead."
- :type 'string
+ :type '(choice string (const nil))
:group 'ido)
-(defcustom ido-decorations '( "{" "}" " | " " | ..." "[" "]" " [No match]" " [Matched]")
+(defcustom ido-decorations '( "{" "}" " | " " | ..." "[" "]" " [No match]" " [Matched]" " [Not readable]" " [Too big]")
"*List of strings used by ido to display the alternatives in the minibuffer.
-There are 8 elements in this list, each is a pair of strings:
+There are 10 elements in this list:
1st and 2nd elements are used as brackets around the prospect list,
3rd element is the separator between prospects (ignored if ido-separator is set),
4th element is the string inserted at the end of a truncated list of prospects,
5th and 6th elements are used as brackets around the common match string which
can be completed using TAB,
-7th element is the string displayed when there are a no matches, and
-8th element displayed if there is a single match (and faces are not used)."
+7th element is the string displayed when there are no matches, and
+8th element is displayed if there is a single match (and faces are not used),
+9th element is displayed when the current directory is non-readable,
+10th element is displayed when directory exceeds `ido-max-directory-size'."
:type '(repeat string)
:group 'ido)
:type 'boolean
:group 'ido)
-(defface ido-first-match-face '((t (:bold t)))
+(defface ido-first-match '((t (:bold t)))
"*Font used by ido for highlighting first match."
:group 'ido)
-(defface ido-only-match-face '((((class color))
+(defface ido-only-match '((((class color))
(:foreground "ForestGreen"))
(t (:italic t)))
"*Font used by ido for highlighting only match."
:group 'ido)
-(defface ido-subdir-face '((((class color))
+(defface ido-subdir '((((min-colors 88) (class color))
+ (:foreground "red1"))
+ (((class color))
(:foreground "red"))
(t (:underline t)))
"*Font used by ido for highlighting subdirs in the alternatives."
:group 'ido)
-(defface ido-indicator-face '((((class color))
+(defface ido-indicator '((((min-colors 88) (class color))
+ (:foreground "yellow1"
+ :background "red1"
+ :width condensed))
+ (((class color))
(:foreground "yellow"
:background "red"
:width condensed))
"*Font used by ido for highlighting its indicators."
:group 'ido)
+(defface ido-incomplete-regexp
+ '((t
+ (:inherit font-lock-warning-face)))
+ "Ido face for indicating incomplete regexps."
+ :group 'ido)
+
(defcustom ido-make-file-list-hook nil
"*List of functions to run when the list of matching files is created.
Each function on the list may modify the dynamically bound variable
:type 'hook
:group 'ido)
-(defcustom ido-make-file-prompt-hook nil
+(defcustom ido-rewrite-file-prompt-functions nil
"*List of functions to run when the find-file prompt is created.
Each function on the list may modify the following dynamically bound
variables:
- path - the (abbreviated) directory path
- max-width - the max width of the path; set to nil to inhibit truncation
- prompt - the basic prompt (e.g. \"Find File: \")
- literal - the string shown if doing `literal' find; set to nil to omit
- vc-off - the string shown if version control is inhibited; set to nit to omit
- prefix - normally nil, but may be set to a fixed prefix for the path
+ dirname - the (abbreviated) directory name
+ to be modified by the hook functions
+ max-width - the max width of the resulting dirname; nil means no limit
+ prompt - the basic prompt (e.g. \"Find File: \")
+ literal - the string shown if doing \"literal\" find; set to nil to omit
+ vc-off - the string shown if version control is inhibited; set to nit to omit
+ prefix - either nil or a fixed prefix for the dirname
+
The following variables are available, but should not be changed:
- ido-current-directory - the unabbreviated directory path
- item - equals 'file or 'dir depending on the current mode."
+ ido-current-directory - the unabbreviated directory name
+ item - equals `file' or `dir' depending on the current mode."
:type 'hook
:group 'ido)
-(defvar ido-rewrite-prompt-path-rules nil
- "*Alist of rewriting rules for file paths.
-A list of elements of the form (FROM . TO) or (FROM . FUNC),
-each meaning to rewrite the path if matched by FROM by either
-substituting the matched string by TO or calling the function
-FUNC with the current path as its only argument and using the
-return value as the new path. In addition, each FUNC may
-also modify the dynamic variables described for the
-variable `ido-make-file-prompt-hook'.")
+(defvar ido-rewrite-file-prompt-rules nil
+ "*Alist of rewriting rules for directory names in ido prompts.
+A list of elements of the form (FROM . TO) or (FROM . FUNC), each
+meaning to rewrite the directory name if matched by FROM by either
+substituting the matched string by TO or calling the function FUNC
+with the current directory name as its only argument and using the
+return value as the new directory name. In addition, each FUNC may
+also modify the dynamic variables described for the variable
+`ido-rewrite-file-prompt-functions'.")
(defcustom ido-completion-buffer "*Ido Completions*"
"*Name of completion buffer used by ido.
It is intended for use in customizing ido for interoperation
with other packages. For instance:
- \(add-hook 'ido-minibuffer-setup-hook
+ \(add-hook 'ido-minibuffer-setup-hook
\(function
\(lambda ()
\(make-local-variable 'max-mini-window-height)
:group 'ido)
(defcustom ido-read-file-name-as-directory-commands '()
- "List of commands which uses read-file-name to read a directory path.
+ "List of commands which uses read-file-name to read a directory name.
When `ido-everywhere' is non-nil, the commands in this list will read
-the directory using ido-read-directory-name."
+the directory using `ido-read-directory-name'."
:type '(repeat symbol)
:group 'ido)
(defcustom ido-read-file-name-non-ido '()
"List of commands which shall not read file names the ido way.
When `ido-everywhere' is non-nil, the commands in this list will read
-the file name using normal read-file-name style."
+the file name using normal `read-file-name' style."
:type '(repeat symbol)
:group 'ido)
+(defcustom ido-before-fallback-functions '()
+ "List of functions to call before calling a fallback command.
+The fallback command is passed as an argument to the functions."
+ :type 'hook
+ :group 'ido)
+
;;; Internal Variables
;; Persistent variables
(defvar ido-buffer-history nil
"History of buffers selected using `ido-switch-buffer'.")
-(defvar ido-xemacs (string-match "XEmacs" (emacs-version))
- "Non-nil if we are running XEmacs. Otherwise, assume we are running Emacs.")
-
(defvar ido-last-directory-list nil
- "List of last selected directory paths.
+ "List of last selected directory names.
See `ido-enable-last-directory-history' for details.")
(defvar ido-work-directory-list nil
- "List of actual working directory paths.
+ "List of actual working directory names.
The current directory is inserted at the front of this list whenever a
-file is opened with ido-find-file and family.")
+file is opened with `ido-find-file' and family.")
(defvar ido-work-file-list nil
"List of actual work file names.
-The current file name (sans path) is inserted at the front of this list
-whenever a file is opened with ido-find-file and family.")
+Opening a file with `ido-find-file' and similar functions
+inserts the current file name (relative to its containing directory)
+at the front of this list.")
(defvar ido-dir-file-cache nil
- "List of file-name-all-completions results.
-Each element in the list is of the form (dir (mtime) file...).")
+ "List of `file-name-all-completions' results.
+Each element in the list is of the form (DIR (MTIME) FILE...).")
+
+(defvar ido-ignore-item-temp-list nil
+ "List of items to ignore in current ido invocation.
+Intended to be let-bound by functions which call ido repeatedly.
+Should never be set permanently.")
;; Temporary storage
(defvar ido-text-init nil
"The initial string for the users string it is typed in.")
+(defvar ido-input-stack nil
+ "Stores the users strings when user hits M-b/M-f.")
+
(defvar ido-matches nil
"List of files currently matching `ido-text'.")
(defvar ido-report-no-match t
"Report [No Match] when no completions matches ido-text.")
-(defvar ido-exit nil
- "Flag to monitor how `ido-find-file' exits.
+(defvar ido-exit nil
+ "Flag to monitor how `ido-find-file' exits.
If equal to `takeprompt', we use the prompt as the file name to be
selected.")
(defvar ido-current-directory nil
- "Current directory for ido-find-file.")
+ "Current directory for `ido-find-file'.")
(defvar ido-auto-merge-timer nil
"Delay timer for auto merge.")
(defvar ido-use-mycompletion-depth 0
- "Non-nil means use `ido' completion feedback.
+ "Non-nil means use `ido' completion feedback.
Is set by ido functions to the current minibuffer-depth, so that
it doesn't interfere with other minibuffer usage.")
+(defvar ido-incomplete-regexp nil
+ "Non-nil if an incomplete regexp is entered.")
;;; Variables with dynamic bindings.
;;; Declared here to keep the byte compiler quiet.
-;; Stores the current ido item type ('file, 'dir or 'buffer).
+;; Stores the current ido item type ('file, 'dir, 'buffer, or 'list).
(defvar ido-cur-item)
;; Stores the current list of items that will be searched through.
;; at the end of the list. Created by `ido-make-item-list'.
(defvar ido-cur-list)
+;; Stores the choice list for ido-completing-read
+(defvar ido-choice-list)
+
;; Stores the list of items which are ignored when building
;; `ido-cur-list'. It is in no specific order.
(defvar ido-ignored-list)
+;; Remember if current directory is non-readable (so we cannot do completion).
+(defvar ido-directory-nonreadable)
+
+;; Remember if current directory is 'huge' (so we don't want to do completion).
+(defvar ido-directory-too-big)
+
;; Keep current item list if non-nil.
(defvar ido-keep-item-list)
;; Value is a list (ido-text dir cur-list ignored-list matches).
(defvar ido-pre-merge-state)
-;; Original value of vc-master-templates for use in ido-toggle-vc.
-(defvar ido-saved-vc-mt)
+;; Original value of vc-handled-backends for use in ido-toggle-vc.
+(defvar ido-saved-vc-hb)
;; Stores temporary state of literal find file.
(defvar ido-find-literal)
+;; Set to 'ignore to inhibit switching between find-file/switch-buffer.
+(defvar ido-context-switch-command)
;;; FUNCTIONS
(defun ido-toggle-trace (arg)
(interactive "P")
(setq ido-trace-enable (or arg (not ido-trace-enable)))
+ (if ido-trace-enable
+ (message "IDO trace on"))
(let ((b (get-buffer " *IDO Trace*")))
(if b
(if ido-trace-enable
(kill-buffer b)
- (pop-to-buffer b t t)))))
+ (pop-to-buffer b t t)
+ (setq truncate-lines t)))))
+
+(defun ido-is-tramp-root (&optional dir)
+ (setq dir (or dir ido-current-directory))
+ (and ido-enable-tramp-completion
+ (string-match "\\`/[^/][^/]+:\\([^/:@]+@\\)?\\'" dir)))
(defun ido-is-root-directory (&optional dir)
(setq dir (or dir ido-current-directory))
- (if (memq system-type '(windows-nt ms-dos))
- (string-match "\\`[a-zA-Z]:[/\\]\\'" dir)
- (string-equal "/" dir)))
+ (or
+ (string-equal "/" dir)
+ (and (memq system-type '(windows-nt ms-dos))
+ (string-match "\\`[a-zA-Z]:[/\\]\\'" dir))
+ (if ido-enable-tramp-completion
+ (ido-is-tramp-root dir)
+ (string-match "\\`/[^:/][^:/]+:\\'" dir))))
(defun ido-is-ftp-directory (&optional dir)
- (string-match "\\`/[^/:][^/:]+:/" (or dir ido-current-directory)))
+ (string-match
+ (if ido-enable-tramp-completion
+ "\\`/[^/:][^/:]+:" ;; like tramp-file-name-regexp-unified, but doesn't match single drive letters
+ "\\`/[^/:][^/:]+:/")
+ (or dir ido-current-directory)))
(defun ido-is-slow-ftp-host (&optional dir)
(and (or ido-slow-ftp-hosts ido-slow-ftp-host-regexps)
(setq dir (or dir ido-current-directory))
;; (featurep 'ange-ftp)
;; (ange-ftp-ftp-name dir)
- (string-match "\\`/\\([^/:]*@\\)?\\([^@/:][^@/:]+\\):/" dir)
+ (string-match
+ (if ido-enable-tramp-completion
+ "\\`/\\([^/]+[@:]\\)*\\([^@/:][^@/:]+\\):"
+ "\\`/\\([^/:]*@\\)?\\([^@/:][^@/:]+\\):/")
+ dir)
(let ((host (substring dir (match-beginning 2) (match-end 2))))
(or (member host ido-slow-ftp-hosts)
(let ((re ido-slow-ftp-host-regexps))
(defun ido-may-cache-directory (&optional dir)
(setq dir (or dir ido-current-directory))
- (if (and (memq system-type '(windows-nt ms-dos))
- (string-match "\\`[a-zA-Z]:[/\\]\\'" dir))
- nil
- (or (not (ido-is-ftp-directory dir))
- (ido-cache-ftp-valid))))
+ (cond
+ ((ido-directory-too-big-p dir)
+ nil)
+ ((and (ido-is-root-directory dir)
+ (or ido-enable-tramp-completion
+ (memq system-type '(windows-nt ms-dos))))
+ nil)
+ ((not (ido-is-ftp-directory dir))
+ t)
+ ((ido-cache-ftp-valid)
+ t)))
(defun ido-pp (list &optional sep)
(let ((print-level nil) (eval-expression-print-level nil)
(setq r (cons (car l) r)))
(setq l (cdr l)))
(nreverse r))))
- (setq ido-work-directory-list
+ (setq ido-work-directory-list
(and (listp ido-work-directory-list)
(let ((l ido-work-directory-list) r)
(while l
(setq r (cons (car l) r)))
(setq l (cdr l)))
(nreverse r))))
- (setq ido-work-file-list
+ (setq ido-work-file-list
(and (listp ido-work-file-list)
(let ((l ido-work-file-list) r)
(while l
(setq r (cons (car l) r)))
(setq l (cdr l)))
(nreverse r))))
- (setq ido-dir-file-cache
+ (setq ido-dir-file-cache
(and (listp ido-dir-file-cache)
(let ((l ido-dir-file-cache) r)
(while l
(defvar ido-minor-mode-map-entry nil)
;;;###autoload
-(defun ido-mode (&optional arg nobind)
+(defun ido-mode (&optional arg)
"Toggle ido speed-ups on or off.
With ARG, turn ido speed-up on if arg is positive, off otherwise.
-If second argument NOBIND is non-nil, no keys are rebound; otherwise,
-turning on ido-mode will modify the default keybindings for the
-find-file and switch-to-buffer families of commands to the ido
-versions of these functions.
-However, if second arg equals 'files, bind only for files, or if it
-equals 'buffers, bind only for buffers.
+Turning on ido-mode will remap (via a minor-mode keymap) the default
+keybindings for the `find-file' and `switch-to-buffer' families of
+commands to the ido versions of these functions.
+However, if ARG arg equals 'files, remap only commands for files, or
+if it equals 'buffers, remap only commands for buffer switching.
This function also adds a hook to the minibuffer."
(interactive "P")
(setq ido-mode
- (cond
+ (cond
((null arg) (if ido-mode nil 'both))
((eq arg t) 'both)
((eq arg 'files) 'file)
(add-hook 'kill-emacs-hook 'ido-kill-emacs-hook)
- (unless ido-minor-mode-map-entry
+ (if ido-minor-mode-map-entry
+ (setcdr ido-minor-mode-map-entry (make-sparse-keymap))
(setq ido-minor-mode-map-entry (cons 'ido-mode (make-sparse-keymap)))
(add-to-list 'minor-mode-map-alist ido-minor-mode-map-entry))
(define-key map [remap display-buffer] 'ido-display-buffer)))))
(defun ido-everywhere (arg)
- "Enable ido everywhere file and directory names are read."
+ "Toggle using ido speed-ups everywhere file and directory names are read.
+With ARG, turn ido speed-up on if arg is positive, off otherwise."
(interactive "P")
(setq ido-everywhere (if arg
- (> (prefix-numeric-value arg) 0)
+ (> (prefix-numeric-value arg) 0)
(not ido-everywhere)))
- (setq read-file-name-function
- (and ido-everywhere (memq ido-mode '(both file))
- 'ido-read-file-name))
- (setq read-buffer-function
- (and ido-everywhere (memq ido-mode '(both buffer))
- 'ido-read-buffer)))
-
-
-;;; IDO KEYMAP
+ (when (get 'ido-everywhere 'file)
+ (setq read-file-name-function (car (get 'ido-everywhere 'file)))
+ (put 'ido-everywhere 'file nil))
+ (when (get 'ido-everywhere 'buffer)
+ (setq read-buffer-function (car (get 'ido-everywhere 'buffer)))
+ (put 'ido-everywhere 'buffer nil))
+ (when ido-everywhere
+ (when (memq ido-mode '(both file))
+ (put 'ido-everywhere 'file (cons read-file-name-function nil))
+ (setq read-file-name-function 'ido-read-file-name))
+ (when (memq ido-mode '(both buffer))
+ (put 'ido-everywhere 'buffer (cons read-buffer-function nil))
+ (setq read-buffer-function 'ido-read-buffer))))
+
+
+;;; IDO KEYMAP
(defun ido-define-mode-map ()
"Set up the keymap for `ido'."
(let (map)
(define-key map "\C-s" 'ido-next-match)
(define-key map "\C-t" 'ido-toggle-regexp)
(define-key map "\C-z" 'ido-undo-merge-work-directory)
+ (define-key map [(control ?\s)] 'ido-restrict-to-matches)
+ (define-key map [(control ?@)] 'ido-restrict-to-matches)
(define-key map [right] 'ido-next-match)
(define-key map [left] 'ido-prev-match)
(define-key map "?" 'ido-completion-help)
+ ;; Magic commands.
+ (define-key map "\C-b" 'ido-magic-backward-char)
+ (define-key map "\C-f" 'ido-magic-forward-char)
+ (define-key map "\C-d" 'ido-magic-delete-char)
+
(when (memq ido-cur-item '(file dir))
- (define-key map "\C-b" 'ido-enter-switch-buffer)
- (define-key map "\C-d" 'ido-enter-dired)
- (define-key map "\C-f" 'ido-fallback-command)
+ (define-key map "\C-x\C-b" (or ido-context-switch-command 'ido-enter-switch-buffer))
+ (define-key map "\C-x\C-f" 'ido-fallback-command)
+ (define-key map "\C-x\C-d" (or (and ido-context-switch-command 'ignore) 'ido-enter-dired))
(define-key map [down] 'ido-next-match-dir)
(define-key map [up] 'ido-prev-match-dir)
(define-key map [(meta up)] 'ido-prev-work-directory)
(define-key map "\d" 'ido-delete-backward-updir)
(define-key map [(meta backspace)] 'ido-delete-backward-word-updir)
(define-key map [(control backspace)] 'ido-up-directory)
- (define-key map [(meta ?b)] 'ido-next-work-file)
- (define-key map [(meta ?d)] 'ido-wide-find-dir)
- (define-key map [(meta ?f)] 'ido-wide-find-file)
+ (define-key map "\C-l" 'ido-reread-directory)
+ (define-key map [(meta ?d)] 'ido-wide-find-dir-or-delete-dir)
+ (define-key map [(meta ?b)] 'ido-push-dir)
+ (define-key map [(meta ?f)] 'ido-wide-find-file-or-pop-dir)
(define-key map [(meta ?k)] 'ido-forget-work-directory)
(define-key map [(meta ?m)] 'ido-make-directory)
(define-key map [(meta ?n)] 'ido-next-work-directory)
(define-key map [(meta ?o)] 'ido-prev-work-file)
+ (define-key map [(meta control ?o)] 'ido-next-work-file)
(define-key map [(meta ?p)] 'ido-prev-work-directory)
(define-key map [(meta ?s)] 'ido-merge-work-directories)
)
(when (eq ido-cur-item 'file)
(define-key map "\C-k" 'ido-delete-file-at-head)
(define-key map "\C-o" 'ido-copy-current-word)
- (define-key map "\C-l" 'ido-reread-directory)
(define-key map "\C-w" 'ido-copy-current-file-name)
(define-key map [(meta ?l)] 'ido-toggle-literal)
(define-key map "\C-v" 'ido-toggle-vc)
)
(when (eq ido-cur-item 'buffer)
- (define-key map "\C-b" 'ido-fallback-command)
- (define-key map "\C-f" 'ido-enter-find-file)
+ (define-key map "\C-x\C-f" (or ido-context-switch-command 'ido-enter-find-file))
+ (define-key map "\C-x\C-b" 'ido-fallback-command)
(define-key map "\C-k" 'ido-kill-buffer-at-head)
)
- (setq ido-mode-map map)
- (run-hooks 'ido-define-mode-map-hook)))
+ (when (if (boundp 'viper-mode) viper-mode)
+ (define-key map [remap viper-intercept-ESC-key] 'ignore)
+ (when (memq ido-cur-item '(file dir))
+ (define-key map [remap viper-backward-char] 'ido-delete-backward-updir)
+ (define-key map [remap viper-del-backward-char-in-insert] 'ido-delete-backward-updir)
+ (define-key map [remap viper-delete-backward-word] 'ido-delete-backward-word-updir)))
+
+ (setq ido-mode-map map)))
(defun ido-final-slash (dir &optional fix-it)
;; return DIR if DIR has final slash.
(setq dir (ido-name dir))
(cond
((string-match "/\\'" dir) dir)
+ ((ido-is-tramp-root dir) dir)
(fix-it (concat dir "/"))
(t nil)))
+(defun ido-no-final-slash (s)
+ ;; Remove optional final slash from string S
+ (let ((l (1- (length s))))
+ (if (and (> l 0) (eq (aref s l) ?/))
+ (substring s 0 l)
+ s)))
+
+(defun ido-nonreadable-directory-p (dir)
+ ;; Return t if dir is a directory, but not readable
+ ;; Do not check for non-readable directories via tramp, as this causes a premature
+ ;; connect on incomplete tramp paths (after entring just method:).
+ (let ((ido-enable-tramp-completion nil))
+ (and (ido-final-slash dir)
+ (file-directory-p dir)
+ (not (file-readable-p dir)))))
+
+(defun ido-directory-too-big-p (dir)
+ ;; Return t if dir is a directory, but too big to show
+ ;; Do not check for non-readable directories via tramp, as this causes a premature
+ ;; connect on incomplete tramp paths (after entring just method:).
+ (let ((ido-enable-tramp-completion nil))
+ (and (numberp ido-max-directory-size)
+ (ido-final-slash dir)
+ (file-directory-p dir)
+ (> (nth 7 (file-attributes dir)) ido-max-directory-size))))
+
(defun ido-set-current-directory (dir &optional subdir no-merge)
;; Set ido's current directory to DIR or DIR/SUBDIR
(setq dir (ido-final-slash dir t))
(setq ido-current-directory dir)
(if (get-buffer ido-completion-buffer)
(kill-buffer ido-completion-buffer))
+ (setq ido-directory-nonreadable (ido-nonreadable-directory-p dir))
+ (setq ido-directory-too-big (and (not ido-directory-nonreadable)
+ (ido-directory-too-big-p dir)))
t))
(defun ido-set-current-home (&optional dir)
;; Make the prompt for ido-read-internal
(cond
((and (memq item '(file dir)) ido-current-directory)
- (let ((path (abbreviate-file-name ido-current-directory))
- (max-width (if (and ido-max-prompt-path (floatp ido-max-prompt-path))
- (floor (* (frame-width) ido-max-prompt-path))
- ido-max-prompt-path))
+ (let ((dirname (abbreviate-file-name ido-current-directory))
+ (max-width (if (and ido-max-file-prompt-width (floatp ido-max-file-prompt-width))
+ (floor (* (frame-width) ido-max-file-prompt-width))
+ ido-max-file-prompt-width))
(literal (and (boundp 'ido-find-literal) ido-find-literal "(literal) "))
- (vc-off (and ido-saved-vc-mt (not vc-master-templates) "[-VC] "))
+ (vc-off (and ido-saved-vc-hb (not vc-handled-backends) "[-VC] "))
(prefix nil)
- (rule ido-rewrite-prompt-path-rules))
+ (rule ido-rewrite-file-prompt-rules))
(let ((case-fold-search nil))
(while rule
(if (and (consp (car rule))
- (string-match (car (car rule)) path))
- (setq path
+ (string-match (car (car rule)) dirname))
+ (setq dirname
(if (stringp (cdr (car rule)))
- (replace-match (cdr (car rule)) t nil path)
- (funcall (cdr (car rule)) path))))
+ (replace-match (cdr (car rule)) t nil dirname)
+ (funcall (cdr (car rule)) dirname))))
(setq rule (cdr rule))))
- (run-hooks 'ido-make-file-prompt-hook)
- (concat prompt
+ (run-hooks 'ido-rewrite-file-prompt-functions)
+ (concat prompt
; (if ido-process-ignore-lists "" "&")
(or literal "")
(or vc-off "")
(or prefix "")
- (let ((l (length path)))
+ (let ((l (length dirname)))
(if (and max-width (> max-width 0) (> l max-width))
- (let* ((s (substring path (- max-width)))
+ (let* ((s (substring dirname (- max-width)))
(i (string-match "/" s)))
(concat "..." (if i (substring s i) s)))
- path)))))
+ dirname)))))
(t prompt)))
;; Here is very briefly how ido-find-file works:
(defun ido-read-internal (item prompt history &optional default require-match initial)
"Perform the ido-read-buffer and ido-read-file-name functions.
-Return the name of a buffer or file selected.
+Return the name of a buffer or file selected.
PROMPT is the prompt to give to the user.
DEFAULT if given is the default directory to start with.
If REQUIRE-MATCH is non-nil, an existing file must be selected.
(ido-define-mode-map)
(setq ido-text-init initial)
+ (setq ido-input-stack nil)
+
+ (run-hooks 'ido-setup-hook)
+
(while (not done)
- (ido-trace "\n_LOOP_")
+ (ido-trace "\n_LOOP_" ido-text-init)
(setq ido-exit nil)
(setq ido-rescan t)
(setq ido-rotate nil)
(setq ido-text "")
- (if ido-set-default-item
- (setq ido-default-item
- (cond
- ((eq item 'buffer)
- (if (bufferp default) (buffer-name default) default))
- ((stringp default) default)
- ((eq item 'file)
- (and ido-enable-last-directory-history
- (let ((d (assoc ido-current-directory ido-last-directory-list)))
- (and d (cdr d))))))
- ido-set-default-item nil))
+ (when ido-set-default-item
+ (setq ido-default-item
+ (cond
+ ((eq item 'buffer)
+ (if (bufferp default) (buffer-name default) default))
+ ((stringp default) default)
+ ((eq item 'file)
+ (and ido-enable-last-directory-history
+ (let ((d (assoc ido-current-directory ido-last-directory-list)))
+ (and d (cdr d)))))))
+ (if (member ido-default-item ido-ignore-item-temp-list)
+ (setq ido-default-item nil))
+ (setq ido-set-default-item nil))
(if ido-process-ignore-lists-inhibit
(setq ido-process-ignore-lists nil))
(l (ido-make-merged-file-list ido-text-init
(eq ido-use-merged-list 'auto)
(eq ido-try-merged-list 'wide))))
+ (ido-trace "merged" l)
(cond
((not l)
(if (eq ido-try-merged-list 'wide)
ido-use-merged-list nil)))
((eq l t)
(setq ido-use-merged-list nil))
+ ((eq l 'input-pending-p)
+ (setq ido-try-merged-list t
+ ido-use-merged-list nil))
(t
(setq ido-pre-merge-state
(list ido-text-init ido-current-directory olist oign omat))
ido-use-merged-list t)
(ido-trace "Merged" t)
))))
-
+
(cond
(ido-keep-item-list
(setq ido-keep-item-list nil
ido-rescan nil))
((eq ido-cur-item 'file)
(setq ido-ignored-list nil
- ido-cur-list (ido-make-file-list ido-default-item)))
+ ido-cur-list (and (not ido-directory-nonreadable)
+ (not ido-directory-too-big)
+ (ido-make-file-list ido-default-item))))
((eq ido-cur-item 'dir)
(setq ido-ignored-list nil
- ido-cur-list (ido-make-dir-list ido-default-item)))
+ ido-cur-list (and (not ido-directory-nonreadable)
+ (not ido-directory-too-big)
+ (ido-make-dir-list ido-default-item))))
((eq ido-cur-item 'buffer)
(setq ido-ignored-list nil
ido-cur-list (ido-make-buffer-list ido-default-item)))
+ ((eq ido-cur-item 'list)
+ (setq ido-ignored-list nil
+ ido-cur-list (ido-make-choice-list ido-default-item)))
(t nil))
(setq ido-rotate-temp nil)
(ido-set-matches)
(if (and ido-matches (eq ido-try-merged-list 'auto))
(setq ido-try-merged-list t))
- (let
+ (let
((minibuffer-local-completion-map ido-mode-map)
(max-mini-window-height (or ido-max-window-height
(and (boundp 'max-mini-window-height) max-mini-window-height)))
(setq ido-exit nil)
(setq ido-final-text
(catch 'ido
- (completing-read
+ (completing-read
(ido-make-prompt item prompt)
'(("dummy" . 1)) nil nil ; table predicate require-match
(prog1 ido-text-init (setq ido-text-init nil)) ;initial-contents
(cond
((eq ido-exit 'refresh)
- (if (and (eq ido-use-merged-list 'auto)
+ (if (and (eq ido-use-merged-list 'auto)
(or (input-pending-p)))
(setq ido-use-merged-list nil
ido-keep-item-list t))
ido-exit nil))
((memq ido-exit '(edit chdir))
- (cond
+ (cond
((memq ido-cur-item '(file dir))
- (let* ((process-environment (cons "HOME=/" process-environment)) ;; cheat read-file-name
- (read-file-name-function nil)
+ (let* ((read-file-name-function nil)
(edit (eq ido-exit 'edit))
(d ido-current-directory)
(f ido-text-init)
- (path t))
+ (new t))
(setq ido-text-init "")
- (while path
- (setq path (if edit
- (read-file-name (concat prompt "[EDIT] ") d (concat d f) nil f)
+ (while new
+ (setq new (if edit
+ (condition-case nil
+ (read-file-name (concat prompt "[EDIT] ")
+ (expand-file-name d)
+ (concat d f) nil f)
+ (quit (concat d f)))
f)
- d (or (file-name-directory path) "/")
- f (file-name-nondirectory path)
+ d (or (file-name-directory new) "/")
+ f (file-name-nondirectory new)
edit t)
- (if (or
+ (if (or
(file-directory-p d)
(and (yes-or-no-p (format "Create directory %s? " d))
- (condition-case nil
+ (condition-case nil
(progn (make-directory d t) t)
(error
(message "Could not create directory")
(progn
(ido-set-current-directory d nil (eq ido-exit 'chdir))
(setq ido-text-init f
- path nil))))))
+ new nil))))))
(t
- (setq ido-text-init nil)
- (setq ido-text-init (read-string (concat prompt "[EDIT] ") ido-final-text))))
+ (setq ido-text-init
+ (condition-case nil
+ (read-string (concat prompt "[EDIT] ") ido-final-text)
+ (quit ido-final-text)))))
+
nil)
((eq ido-exit 'keep)
(setq ido-keep-item-list t))
- ((memq ido-exit '(dired fallback findfile findbuffer))
+ ((memq ido-exit '(dired fallback find-file switch-to-buffer insert-buffer insert-file))
(setq done t))
- ((eq ido-exit 'updir)
+ ((memq ido-exit '(updir push))
;; cannot go up if already at the root-dir (Unix) or at the
;; root-dir of a certain drive (Windows or MS-DOS).
- (or (ido-is-root-directory)
- (ido-set-current-directory (file-name-directory (substring ido-current-directory 0 -1))))
- (setq ido-set-default-item t))
+ (if (ido-is-tramp-root)
+ (when (string-match "\\`\\(/\\([^/]+[:@]\\)*\\)\\([^/]+\\)[:@]\\'" ido-current-directory)
+ (setq ido-text-init (match-string 3 ido-current-directory))
+ (ido-set-current-directory (match-string 1 ido-current-directory))
+ (setq ido-set-default-item t))
+ (unless (ido-is-root-directory)
+ (when (eq ido-exit 'push)
+ (setq ido-input-stack (cons (cons ido-cur-item ido-text) ido-input-stack))
+ (setq ido-cur-item 'dir)
+ (setq ido-text-init (file-name-nondirectory (substring ido-current-directory 0 -1)))
+ (ido-trace "push" ido-input-stack))
+ (ido-set-current-directory (file-name-directory (substring ido-current-directory 0 -1)))
+ (setq ido-set-default-item t))))
+
+ ((eq ido-exit 'pop)
+ (ido-trace "pop" ido-input-stack)
+ (let ((elt (car ido-input-stack)))
+ (setq ido-input-stack (cdr ido-input-stack))
+ (ido-set-current-directory (concat ido-current-directory ido-text))
+ (setq ido-cur-item (car elt))
+ (setq ido-text-init (cdr elt))))
+
+ ((eq ido-exit 'pop-all)
+ (ido-trace "pop-all" ido-input-stack)
+ (while ido-input-stack
+ (let ((elt (car ido-input-stack)))
+ (setq ido-input-stack (cdr ido-input-stack))
+ (ido-set-current-directory (concat ido-current-directory ido-text))
+ (setq ido-cur-item (car elt))
+ (setq ido-text-init (cdr elt)))))
;; Handling the require-match must be done in a better way.
- ((and require-match (not (ido-existing-item-p)))
+ ((and require-match
+ (not (if ido-directory-too-big
+ (file-exists-p (concat ido-current-directory ido-final-text))
+ (ido-existing-item-p))))
(error "must specify valid item"))
(t
(setq ido-selected
- (if (and ido-matches (equal ido-final-text ""))
- (ido-name (car ido-matches)) ;; possibly choose the default file
- (if (or (eq ido-exit 'takeprompt)
- (null ido-matches))
- ido-final-text
- ;; else take head of list
- (ido-name (car ido-matches)))))
+ (if (or (eq ido-exit 'takeprompt)
+ (null ido-matches))
+ ido-final-text
+ ;; else take head of list
+ (ido-name (car ido-matches))))
(cond
- ((eq item 'buffer)
+ ((memq item '(buffer list))
(setq done t))
((string-equal "./" ido-selected)
(ido-set-current-directory (file-name-directory (substring ido-current-directory 0 -1))))
(setq ido-set-default-item t))
- ((and (string-equal ido-current-directory "/")
- (string-match "..:\\'" ido-selected)) ;; Ange-ftp
- (ido-set-current-directory "/" ido-selected)
+ ((and (string-match (if ido-enable-tramp-completion "..[:@]\\'" "..:\\'") ido-selected)
+ (ido-is-root-directory)) ;; Ange-ftp or Tramp
+ (ido-set-current-directory ido-current-directory ido-selected)
+ (ido-trace "tramp prefix" ido-selected)
(if (ido-is-slow-ftp-host)
(setq ido-exit 'fallback
done t)
(setq ido-set-default-item t)))
-
((or (string-match "[/\\][^/\\]" ido-selected)
(and (memq system-type '(windows-nt ms-dos))
(string-match "\\`.:" ido-selected)))
(setq ido-last-directory-list
(cons (cons ido-current-directory ido-selected) ido-last-directory-list)))))
(ido-set-current-directory ido-current-directory ido-selected)
- (setq ido-set-default-item t))
+ (if ido-input-stack
+ (while ido-input-stack
+ (let ((elt (car ido-input-stack)))
+ (if (setq ido-input-stack (cdr ido-input-stack))
+ (ido-set-current-directory ido-current-directory (cdr elt))
+ (setq ido-text-init (cdr elt)))
+ (setq ido-cur-item (car elt))))
+ (setq ido-set-default-item t)))
(t
(setq done t))))))
ido-selected))
(defun ido-edit-input ()
- "Edit ido path and input string. Terminate by RET."
+ "Edit absolute file name entered so far with ido; terminate by RET."
(interactive)
(setq ido-text-init ido-text)
(setq ido-exit 'edit)
(exit-minibuffer))
;;; MAIN FUNCTIONS
-(defun ido-buffer-internal (method &optional fallback prompt default initial)
+(defun ido-buffer-internal (method &optional fallback prompt default initial switch-cmd)
;; Internal function for ido-switch-buffer and friends
(if (not ido-mode)
- (call-interactively (or fallback 'switch-to-buffer))
- (let ((buf (ido-read-buffer (or prompt "Buffer: ") default nil initial)))
+ (progn
+ (run-hook-with-args 'ido-before-fallback-functions
+ (or fallback 'switch-to-buffer))
+ (call-interactively (or fallback 'switch-to-buffer)))
+ (let* ((ido-context-switch-command switch-cmd)
+ (ido-current-directory nil)
+ (ido-directory-nonreadable nil)
+ (ido-directory-too-big nil)
+ (buf (ido-read-internal 'buffer (or prompt "Buffer: ") 'ido-buffer-history default nil initial)))
;; Choose the buffer name: either the text typed in, or the head
;; of the list of matches
- (cond
- ((eq ido-exit 'findfile)
+ (cond
+ ((eq ido-exit 'find-file)
(ido-file-internal ido-default-file-method nil nil nil nil ido-text))
+ ((eq ido-exit 'insert-file)
+ (ido-file-internal 'insert 'insert-file nil "Insert file: " nil ido-text 'ido-enter-insert-buffer))
+
((eq ido-exit 'fallback)
(let ((read-buffer-function nil))
+ (run-hook-with-args 'ido-before-fallback-functions
+ (or fallback 'switch-to-buffer))
(call-interactively (or fallback 'switch-to-buffer))))
;; Check buf is non-nil.
((not buf) nil)
+ ((= (length buf) 0) nil)
;; View buffer if it exists
((get-buffer buf)
(if (eq method 'insert)
(progn
(ido-record-command 'insert-buffer buf)
- (insert-buffer buf))
+ (with-no-warnings
+ ;; we really want to run insert-buffer here
+ (insert-buffer buf)))
(ido-visit-buffer buf method t)))
;; buffer doesn't exist
(set-buffer-major-mode buf))
(ido-visit-buffer buf method t))))))
-;;;###autoload
-(defun ido-read-buffer (prompt &optional default require-match initial)
- "Replacement for the built-in `read-buffer'.
-Return the name of a buffer selected.
-PROMPT is the prompt to give to the user. DEFAULT if given is the default
-buffer to be selected, which will go to the front of the list.
-If REQUIRE-MATCH is non-nil, an existing-buffer must be selected.
-If INITIAL is non-nil, it specifies the initial input string."
- (let ((ido-current-directory nil))
- (ido-read-internal 'buffer prompt 'ido-buffer-history default require-match initial)))
-
(defun ido-record-work-directory (&optional dir)
(when (and (numberp ido-max-work-directory-list) (> ido-max-work-directory-list 0))
(if (and (setq dir (or dir ido-current-directory)) (> (length dir) 0))
ido-text-init ido-text
ido-rotate-temp t)
(exit-minibuffer))))
-
+
(defun ido-record-work-file (name)
;; Save NAME in ido-work-file-list
(when (and (numberp ido-max-work-file-list) (> ido-max-work-file-list 0))
(if (> (length ido-work-file-list) ido-max-work-file-list)
(setcdr (nthcdr (1- ido-max-work-file-list) ido-work-file-list) nil))))
-(defun ido-file-internal (method &optional fallback default prompt item initial)
+(defun ido-expand-directory (dir)
+ ;; Expand DIR or use DEFAULT-DIRECTORY if nil.
+ ;; Add final slash to result in case it was missing from DEFAULT-DIRECTORY.
+ (ido-final-slash (expand-file-name (or dir default-directory)) t))
+
+(defun ido-file-internal (method &optional fallback default prompt item initial switch-cmd)
;; Internal function for ido-find-file and friends
- (let ((ido-current-directory (expand-file-name (or default default-directory)))
+ (unless item
+ (setq item 'file))
+ (let ((ido-current-directory (ido-expand-directory default))
+ (ido-context-switch-command switch-cmd)
+ ido-directory-nonreadable ido-directory-too-big
+ (minibuffer-completing-file-name t)
filename)
(if (or (not ido-mode) (ido-is-slow-ftp-host))
(setq filename t
- ido-exit 'fallback))
-
- (let (ido-saved-vc-mt
- (vc-master-templates (and (boundp 'vc-master-templates) vc-master-templates))
+ ido-exit 'fallback)
+ (setq ido-directory-nonreadable
+ (ido-nonreadable-directory-p ido-current-directory)
+ ido-directory-too-big
+ (and (not ido-directory-nonreadable)
+ (ido-directory-too-big-p ido-current-directory))))
+
+ (when (and (eq item 'file)
+ (or ido-use-url-at-point ido-use-filename-at-point))
+ (let (fn d)
+ (require 'ffap)
+ ;; Duplicate code from ffap-guesser as we want different behaviour for files and URLs.
+ (cond
+ ((with-no-warnings
+ (and ido-use-url-at-point
+ ffap-url-regexp
+ (ffap-fixup-url (or (ffap-url-at-point)
+ (ffap-gopher-at-point)))))
+ (setq ido-exit 'ffap
+ filename t))
+
+ ((and ido-use-filename-at-point
+ (setq fn (if (eq ido-use-filename-at-point 'guess)
+ (with-no-warnings (ffap-guesser))
+ (ffap-string-at-point)))
+ (not (string-match "^http:/" fn))
+ (setq d (file-name-directory fn))
+ (file-directory-p d))
+ (setq ido-current-directory d)
+ (setq initial (file-name-nondirectory fn))))))
+
+ (let (ido-saved-vc-hb
+ (vc-handled-backends (and (boundp 'vc-handled-backends) vc-handled-backends))
(ido-work-directory-index -1)
(ido-work-file-index -1)
(ido-find-literal nil))
(unless filename
- (setq ido-saved-vc-mt vc-master-templates)
- (setq filename (ido-read-internal (or item 'file)
+ (setq ido-saved-vc-hb vc-handled-backends)
+ (setq filename (ido-read-internal item
(or prompt "Find file: ")
'ido-file-history nil nil initial)))
;; we don't want to change directory of current buffer.
(let ((default-directory ido-current-directory)
(read-file-name-function nil))
+ (run-hook-with-args 'ido-before-fallback-functions
+ (or fallback 'find-file))
(call-interactively (or fallback 'find-file))))
- ((eq ido-exit 'findbuffer)
+ ((eq ido-exit 'switch-to-buffer)
(ido-buffer-internal ido-default-buffer-method nil nil nil ido-text))
+ ((eq ido-exit 'insert-buffer)
+ (ido-buffer-internal 'insert 'insert-buffer "Insert buffer: " nil ido-text 'ido-enter-insert-file))
+
((eq ido-exit 'dired)
(dired (concat ido-current-directory (or ido-text ""))))
+ ((eq ido-exit 'ffap)
+ (find-file-at-point))
+
((eq method 'alt-file)
(ido-record-work-file filename)
(setq default-directory ido-current-directory)
((memq method '(dired list-directory))
(if (equal filename ".")
(setq filename ""))
- (let* ((path (ido-final-slash (concat ido-current-directory filename) t))
- (file (substring path 0 -1)))
+ (let* ((dirname (ido-final-slash (concat ido-current-directory filename) t))
+ (file (substring dirname 0 -1)))
(cond
- ((file-directory-p path)
- (ido-record-command method path)
- (ido-record-work-directory path)
- (funcall method path))
+ ((file-directory-p dirname)
+ (ido-record-command method dirname)
+ (ido-record-work-directory dirname)
+ (funcall method dirname))
((file-directory-p ido-current-directory)
(cond
((file-exists-p file)
(ido-record-work-directory)
(funcall method ido-current-directory)
(if (eq method 'dired)
- (dired-goto-file (expand-file-name file))))
+ (with-no-warnings
+ (dired-goto-file (expand-file-name file)))))
((string-match "[[*?]" filename)
- (setq path (concat ido-current-directory filename))
- (ido-record-command method path)
+ (setq dirname (concat ido-current-directory filename))
+ (ido-record-command method dirname)
(ido-record-work-directory)
- (funcall method path))
+ (funcall method dirname))
((y-or-n-p (format "Directory %s does not exist. Create it " filename))
- (ido-record-command method path)
- (ido-record-work-directory path)
- (make-directory-internal path)
- (funcall method path))
+ (ido-record-command method dirname)
+ (ido-record-work-directory dirname)
+ (make-directory-internal dirname)
+ (funcall method dirname))
(t
;; put make-directory command on history
- (ido-record-command 'make-directory path))))
+ (ido-record-command 'make-directory dirname))))
(t (error "No such directory")))))
((eq method 'write)
(setq filename (concat ido-current-directory filename))
(ido-record-command fallback filename)
(ido-record-work-directory)
+ (run-hook-with-args 'ido-before-fallback-functions fallback)
(funcall fallback filename))
((eq method 'insert)
(ido-record-work-file filename)
(setq filename (concat ido-current-directory filename))
- (ido-record-command
+ (ido-record-command
(if ido-find-literal 'insert-file-literally 'insert-file)
filename)
(ido-record-work-directory)
"Try and complete the current pattern amongst the file names."
(interactive)
(let (res)
- (cond
+ (cond
+ (ido-incomplete-regexp
+ ;; Do nothing
+ )
((and (memq ido-cur-item '(file dir))
(string-match "[$]" ido-text))
(let ((evar (substitute-in-file-name (concat ido-current-directory ido-text))))
(if (not (file-exists-p (file-name-directory evar)))
- (message "Expansion generates non-existing directory path")
+ (message "Expansion generates non-existing directory name")
(if (file-directory-p evar)
(ido-set-current-directory evar)
(let ((d (or (file-name-directory evar) "/"))
(setq ido-exit 'refresh)
(exit-minibuffer))))
+ (ido-directory-too-big
+ (setq ido-directory-too-big nil)
+ (setq ido-text-init ido-text)
+ (setq ido-exit 'refresh)
+ (exit-minibuffer))
+
((not ido-matches)
(when ido-completion-buffer
- (setq this-command 'ido-completion-help)
- (ido-completion-help)))
-
- ((= 1 (length ido-matches))
+ (call-interactively (setq this-command ido-cannot-complete-command))))
+
+ ((and (= 1 (length ido-matches))
+ (not (and ido-enable-tramp-completion
+ (string-equal ido-current-directory "/")
+ (string-match "..[@:]\\'" (car ido-matches)))))
;; only one choice, so select it.
- (exit-minibuffer))
-
+ (if (not ido-confirm-unique-completion)
+ (exit-minibuffer)
+ (setq ido-rescan (not ido-enable-prefix))
+ (delete-region (minibuffer-prompt-end) (point))
+ (insert (car ido-matches))))
+
(t ;; else there could be some completions
(setq res ido-common-match-string)
(if (and (not (memq res '(t nil)))
(delete-region (minibuffer-prompt-end) (point))
(insert res))
;; else nothing to complete
- (ido-completion-help)
+ (call-interactively (setq this-command ido-cannot-complete-command))
)))))
(defun ido-complete-space ()
(setq ido-try-merged-list t))
((not ido-use-merged-list)
(ido-merge-work-directories))))
-
+
+;;; Magic C-f
+
+(defun ido-magic-forward-char ()
+ "Move forward in user input or perform magic action.
+If no user input is present, or at end of input, perform magic actions:
+C-x C-b ... C-f switch to ido-find-file.
+C-x C-f ... C-f fallback to non-ido find-file.
+C-x C-d ... C-f fallback to non-ido brief dired.
+C-x d ... C-f fallback to non-ido dired."
+ (interactive)
+ (cond
+ ((not (eobp))
+ (forward-char 1))
+ ((memq ido-cur-item '(file dir))
+ (ido-fallback-command))
+ (ido-context-switch-command
+ (call-interactively ido-context-switch-command))
+ ((eq ido-cur-item 'buffer)
+ (ido-enter-find-file))))
+
+;;; Magic C-b
+
+(defun ido-magic-backward-char ()
+ "Move backward in user input or perform magic action.
+If no user input is present, or at start of input, perform magic actions:
+C-x C-f C-b switch to ido-switch-buffer.
+C-x C-d C-b switch to ido-switch-buffer.
+C-x d C-b switch to ido-switch-buffer.
+C-x C-b C-b fallback to non-ido switch-to-buffer."
+ (interactive)
+ (cond
+ ((> (point) (minibuffer-prompt-end))
+ (forward-char -1))
+ ((eq ido-cur-item 'buffer)
+ (ido-fallback-command))
+ (ido-context-switch-command
+ (call-interactively ido-context-switch-command))
+ (t
+ (ido-enter-switch-buffer))))
+
+;;; Magic C-d
+
+(defun ido-magic-delete-char ()
+ "Delete following char in user input or perform magic action.
+If at end of user input, perform magic actions:
+C-x C-f ... C-d enter dired on current directory."
+ (interactive)
+ (cond
+ ((not (eobp))
+ (delete-char 1))
+ (ido-context-switch-command
+ nil)
+ ((memq ido-cur-item '(file dir))
+ (ido-enter-dired))))
+
+
;;; TOGGLE FUNCTIONS
(defun ido-toggle-case ()
(defun ido-toggle-ignore ()
"Toggle ignoring files specified with `ido-ignore-files'."
(interactive)
- (setq ido-process-ignore-lists (not ido-process-ignore-lists))
+ (if ido-directory-too-big
+ (setq ido-directory-too-big nil)
+ (setq ido-process-ignore-lists (not ido-process-ignore-lists)))
(setq ido-text-init ido-text)
(setq ido-exit 'refresh)
(exit-minibuffer))
(interactive)
(if (and ido-mode (eq ido-cur-item 'file))
(progn
- (setq vc-master-templates
- (if vc-master-templates nil ido-saved-vc-mt))
+ (setq vc-handled-backends
+ (if vc-handled-backends nil ido-saved-vc-hb))
(setq ido-text-init ido-text)
(setq ido-exit 'keep)
(exit-minibuffer))))
(defun ido-exit-minibuffer ()
"Exit minibuffer, but make sure we have a match if one is needed."
(interactive)
- (if (or (not ido-require-match)
- (ido-existing-item-p))
- (throw 'exit nil)))
+ (if (and (or (not ido-require-match)
+ (ido-existing-item-p))
+ (not ido-incomplete-regexp))
+ (exit-minibuffer)))
(defun ido-select-text ()
"Select the buffer or file named by the prompt.
(defun ido-fallback-command ()
"Fallback to non-ido version of current command."
(interactive)
+ (let ((i (length ido-text)))
+ (while (> i 0)
+ (push (aref ido-text (setq i (1- i))) unread-command-events)))
(setq ido-exit 'fallback)
(exit-minibuffer))
(defun ido-enter-find-file ()
- "Drop into find-file from buffer switching."
+ "Drop into `find-file' from buffer switching."
(interactive)
- (setq ido-exit 'findfile)
+ (setq ido-exit 'find-file)
(exit-minibuffer))
(defun ido-enter-switch-buffer ()
- "Drop into ido-switch-buffer from file switching."
+ "Drop into `ido-switch-buffer' from file switching."
(interactive)
- (setq ido-exit 'findbuffer)
+ (setq ido-exit 'switch-to-buffer)
(exit-minibuffer))
(defun ido-enter-dired ()
(setq ido-exit 'dired)
(exit-minibuffer))
+(defun ido-enter-insert-buffer ()
+ "Drop into insert buffer from insert file."
+ (interactive)
+ (setq ido-exit 'insert-buffer)
+ (exit-minibuffer))
+
+(defun ido-enter-insert-file ()
+ "Drop into insert file from insert buffer."
+ (interactive)
+ (setq ido-exit 'insert-file)
+ (exit-minibuffer))
+
(defun ido-up-directory (&optional clear)
"Go up one directory level."
(ido-up-directory t)))
((and ido-pre-merge-state (string-equal (car ido-pre-merge-state) ido-text))
(ido-undo-merge-work-directory (substring ido-text 0 -1) t t))
+ ((eq this-original-command 'viper-backward-char)
+ (funcall this-original-command (prefix-numeric-value count)))
+ ((eq this-original-command 'viper-del-backward-char-in-insert)
+ (funcall this-original-command))
(t
(delete-backward-char (prefix-numeric-value count)))))
(if (= (minibuffer-prompt-end) (point))
(if (not count)
(ido-up-directory t))
- (backward-kill-word (prefix-numeric-value count))))
+ (if (eq this-original-command 'viper-delete-backward-word)
+ (funcall this-original-command (prefix-numeric-value count))
+ (backward-kill-word (prefix-numeric-value count)))))
(defun ido-get-work-directory (&optional incr must-match)
(let ((n (length ido-work-directory-list))
(not (equal dir ido-current-directory))
(file-directory-p dir)
(or (not must-match)
- (ido-set-matches1
+ ;; TODO. check for nonreadable and too-big.
+ (ido-set-matches-1
(if (eq ido-cur-item 'file)
- (ido-make-file-list1 dir)
- (ido-make-dir-list1 dir)))))
+ (ido-make-file-list-1 dir)
+ (ido-make-dir-list-1 dir)))))
(setq j n)
(setq dir nil)))
(if dir
"Prompt for FILE to search for using find, starting from current directory."
(interactive)
(unless file
- (setq file (read-string (concat "Wide find file: " ido-current-directory) ido-text)))
+ (let ((enable-recursive-minibuffers t))
+ (setq file
+ (condition-case nil
+ (read-string (concat "Wide find file: " ido-current-directory) ido-text)
+ (quit "")))))
(when (> (length file) 0)
(setq ido-use-merged-list t ido-try-merged-list 'wide)
(setq ido-exit 'refresh)
"Prompt for DIR to search for using find, starting from current directory."
(interactive)
(unless dir
- (setq dir (read-string (concat "Wide find directory: " ido-current-directory) ido-text)))
+ (let ((enable-recursive-minibuffers t))
+ (setq dir
+ (condition-case nil
+ (read-string (concat "Wide find directory: " ido-current-directory) ido-text)
+ (quit "")))))
(when (> (length dir) 0)
(setq ido-use-merged-list t ido-try-merged-list 'wide)
(setq ido-exit 'refresh)
(setq ido-rotate-temp t)
(exit-minibuffer)))
+(defun ido-wide-find-dir-or-delete-dir (&optional dir)
+ "Prompt for DIR to search for using find, starting from current directory.
+If input stack is non-empty, delete current directory component."
+ (interactive)
+ (if ido-input-stack
+ (ido-delete-backward-word-updir 1)
+ (ido-wide-find-dir)))
+
+(defun ido-push-dir ()
+ "Move to previous directory in file name, push current input on stack."
+ (interactive)
+ (setq ido-exit 'push)
+ (exit-minibuffer))
+
+(defun ido-pop-dir (arg)
+ "Pop directory from input stack back to input.
+With \\[universal-argument], pop all element."
+ (interactive "P")
+ (when ido-input-stack
+ (setq ido-exit (if arg 'pop-all 'pop))
+ (exit-minibuffer)))
+
+(defun ido-wide-find-file-or-pop-dir (arg)
+ (interactive "P")
+ (if ido-input-stack
+ (ido-pop-dir arg)
+ (ido-wide-find-file)))
+
(defun ido-make-directory (&optional dir)
"Prompt for DIR to create in current directory."
(interactive)
(unless dir
- (setq dir (read-string (concat "Make directory: " ido-current-directory) ido-text)))
+ (let ((enable-recursive-minibuffers t))
+ (setq dir
+ (read-string (concat "Make directory: " ido-current-directory) ido-text))))
(when (> (length dir) 0)
(setq dir (concat ido-current-directory dir))
(unless (file-exists-p dir)
"Insert file name of current buffer.
If repeated, insert text from buffer instead."
(interactive "P")
- (let* ((path (buffer-file-name ido-entry-buffer))
- (name (and path (file-name-nondirectory path))))
+ (let* ((bfname (buffer-file-name ido-entry-buffer))
+ (name (and bfname (file-name-nondirectory bfname))))
(when name
- (setq ido-text-init
- (if (or all
- (not (equal (file-name-directory path) ido-current-directory))
+ (setq ido-text-init
+ (if (or all
+ (not (equal (file-name-directory bfname) ido-current-directory))
(not (string-match "\\.[^.]*\\'" name)))
name
(substring name 0 (1+ (match-beginning 0)))))
(setq ido-exit 'refresh
ido-try-merged-list nil)
(exit-minibuffer))))
-
+
(defun ido-copy-current-word (all)
- "Insert current word (file name or path) from current buffer."
+ "Insert current word (file or directory name) from current buffer."
(interactive "P")
(let ((word (save-excursion
(set-buffer ido-entry-buffer)
ido-exit 'refresh)))
(exit-minibuffer))))
-(defun ido-next-match ()
+(defun ido-next-match ()
"Put first element of `ido-matches' at the end of the list."
(interactive)
(if ido-matches
(setq ido-rescan t)
(setq ido-rotate t))))
-(defun ido-prev-match ()
+(defun ido-prev-match ()
"Put last element of `ido-matches' at the front of the list."
(interactive)
(if ido-matches
(setq ido-rescan t)
(setq ido-rotate t))))
-(defun ido-next-match-dir ()
+(defun ido-next-match-dir ()
"Find next directory in match list.
If work directories have been merged, cycle through directories for
first matching file."
(if (< i cnt)
(setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
-(defun ido-prev-match-dir ()
+(defun ido-prev-match-dir ()
"Find previous directory in match list.
If work directories have been merged, cycle through directories
for first matching file."
(if (> i 0)
(setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
+(defun ido-restrict-to-matches ()
+ "Set current item list to the currently matched items."
+ (interactive)
+ (when ido-matches
+ (setq ido-cur-list ido-matches
+ ido-text-init ""
+ ido-rescan nil
+ ido-exit 'keep)
+ (exit-minibuffer)))
+
(defun ido-chop (items elem)
"Remove all elements before ELEM and put them at the end of ITEMS."
(let ((ret nil)
(defun ido-all-completions ()
;; Return unsorted list of all competions.
- (let ((ido-process-ignore-lists nil))
+ (let ((ido-process-ignore-lists nil)
+ (ido-directory-too-big nil))
(cond
((eq ido-cur-item 'file)
- (ido-make-file-list1 ido-current-directory))
+ (ido-make-file-list-1 ido-current-directory))
((eq ido-cur-item 'dir)
- (ido-make-dir-list1 ido-current-directory))
+ (ido-make-dir-list-1 ido-current-directory))
((eq ido-cur-item 'buffer)
- (ido-make-buffer-list1))
+ (ido-make-buffer-list-1))
+ ((eq ido-cur-item 'list)
+ ido-choice-list)
(t nil))))
-(defun ido-sort-list (items)
- ;; Simple list of file or buffer names
- (sort items (lambda (a b) (string-lessp a b))))
+;; File list sorting
+
+(defun ido-file-lessp (a b)
+ ;; Simple compare two file names.
+ (string-lessp (ido-no-final-slash a) (ido-no-final-slash b)))
+
+
+(defun ido-file-extension-lessp (a b)
+ ;; Compare file names according to ido-file-extensions-order list.
+ (let ((n (compare-strings a 0 nil b 0 nil nil))
+ lessp p)
+ (if (eq n t)
+ nil
+ (if (< n 0)
+ (setq n (1- (- n))
+ p a a b b p
+ lessp t)
+ (setq n (1- n)))
+ (cond
+ ((= n 0)
+ lessp)
+ ((= (aref a n) ?.)
+ (ido-file-extension-aux a b n lessp))
+ (t
+ (while (and (> n 2) (/= (aref a n) ?.))
+ (setq n (1- n)))
+ (if (> n 1)
+ (ido-file-extension-aux a b n lessp)
+ lessp))))))
+
+(defun ido-file-extension-aux (a b n lessp)
+ (let ((oa (ido-file-extension-order a n))
+ (ob (ido-file-extension-order b n)))
+ (cond
+ ((= oa ob)
+ lessp)
+ ((and oa ob)
+ (if lessp
+ (> oa ob)
+ (< oa ob)))
+ (oa
+ (not lessp))
+ (ob
+ lessp)
+ (t
+ lessp))))
+
+(defun ido-file-extension-order (s n)
+ (let ((l ido-file-extensions-order)
+ (i 0) o do)
+ (while l
+ (cond
+ ((eq (car l) t)
+ (setq do i
+ l (cdr l)))
+ ((eq (compare-strings s n nil (car l) 0 nil nil) t)
+ (setq o i
+ l nil))
+ (t
+ (setq l (cdr l))))
+ (setq i (1+ i)))
+ (or o do)))
+
(defun ido-sort-merged-list (items promote)
;; Input is list of ("file" . "dir") cons cells.
(defun ido-wide-find-dirs-or-files (dir file &optional prefix finddir)
;; As ido-run-find-command, but returns a list of cons pairs ("file" . "dir")
- (let ((paths
- (split-string
+ (let ((filenames
+ (split-string
(shell-command-to-string
(concat "find " dir " -name \"" (if prefix "" "*") file "*\" -type " (if finddir "d" "f") " -print"))))
- path d f
+ filename d f
res)
- (while paths
- (setq path (car paths)
- paths (cdr paths)
- paths (cdr paths))
- (if (and (string-match "^/" path)
- (file-exists-p path))
- (setq d (file-name-directory path)
- f (file-name-nondirectory path)
+ (while filenames
+ (setq filename (car filenames)
+ filenames (cdr filenames))
+ (if (and (string-match "^/" filename)
+ (file-exists-p filename))
+ (setq d (file-name-directory filename)
+ f (file-name-nondirectory filename)
res (cons (cons (if finddir (ido-final-slash f t) f) d) res))))
res))
(defun ido-flatten-merged-list (items)
- ;; Create a list of path names based on a merged directory list.
+ ;; Create a list of directory names based on a merged directory list.
(let (res)
(while items
(let* ((item (car items))
(setq items (cdr items)))
res))
-(defun ido-make-merged-file-list (text auto wide)
+
+(defun ido-make-merged-file-list-1 (text auto wide)
(let (res)
- (message "Searching for `%s'...." text)
(if (and (ido-final-slash text) ido-dir-file-cache)
(if wide
(setq res (ido-wide-find-dirs-or-files
(or ido-merge-ftp-work-directories
(not (ido-is-ftp-directory dir)))
(file-directory-p dir)
+ ;; TODO. check for nonreadable and too-big.
(setq fl (if (eq ido-cur-item 'file)
- (ido-make-file-list1 dir t)
- (ido-make-dir-list1 dir t))))
+ (ido-make-file-list-1 dir t)
+ (ido-make-dir-list-1 dir t))))
(if must-match
- (setq fl (ido-set-matches1 fl)))
+ (setq fl (ido-set-matches-1 fl)))
(if fl
(setq res (nconc fl res))))
(if (and auto (input-pending-p))
(setq dirs nil
res t))))))
- (if (and res (not (eq res t)))
- (setq res (ido-sort-merged-list res auto)))
+ res))
+
+(defun ido-make-merged-file-list (text auto wide)
+ (let (res)
+ (message "Searching for `%s'...." text)
+ (condition-case nil
+ (if (eq t (setq res
+ (while-no-input
+ (ido-make-merged-file-list-1 text auto wide))))
+ (setq res 'input-pending-p))
+ (quit
+ (setq res t
+ ido-try-merged-list nil
+ ido-use-merged-list nil)))
+ (when (and res (listp res))
+ (setq res (ido-sort-merged-list res auto)))
(when (and (or ido-rotate-temp ido-rotate-file-list-default)
+ (listp res)
(> (length text) 0))
(let ((elt (assoc text res)))
(when (and elt (not (eq elt (car res))))
(message nil)
res))
-(defun ido-make-buffer-list1 (&optional frame visible)
+(defun ido-make-buffer-list-1 (&optional frame visible)
;; Return list of non-ignored buffer names
- (delq nil
+ (delq nil
(mapcar
(lambda (x)
(let ((name (buffer-name x)))
- (if (not (or (ido-ignore-item-p name ido-ignore-buffers) (memq name visible)))
+ (if (not (or (ido-ignore-item-p name ido-ignore-buffers) (member name visible)))
name)))
(buffer-list frame))))
(defun ido-make-buffer-list (default)
;; Return the current list of buffers.
;; Currently visible buffers are put at the end of the list.
- ;; The hook `ido-make-buflist-hook' is run after the list has been
+ ;; The hook `ido-make-buffer-list-hook' is run after the list has been
;; created to allow the user to further modify the order of the buffer names
;; in this list. If DEFAULT is non-nil, and corresponds to an existing buffer,
;; it is put to the start of the list.
(let* ((ido-current-buffers (ido-get-buffers-in-frames 'current))
- (ido-temp-list (ido-make-buffer-list1 (selected-frame) ido-current-buffers)))
+ (ido-temp-list (ido-make-buffer-list-1 (selected-frame) ido-current-buffers)))
(if ido-temp-list
(nconc ido-temp-list ido-current-buffers)
(setq ido-temp-list ido-current-buffers))
(if default
(progn
- (setq ido-temp-list
+ (setq ido-temp-list
(delete default ido-temp-list))
- (setq ido-temp-list
+ (setq ido-temp-list
(cons default ido-temp-list))))
(run-hooks 'ido-make-buffer-list-hook)
ido-temp-list))
+(defun ido-make-choice-list (default)
+ ;; Return the current list of choices.
+ ;; If DEFAULT is non-nil, and corresponds to an element of choices,
+ ;; it is put to the start of the list.
+ (let ((ido-temp-list ido-choice-list))
+ (if default
+ (progn
+ (setq ido-temp-list
+ (delete default ido-temp-list))
+ (setq ido-temp-list
+ (cons default ido-temp-list))))
+ ; (run-hooks 'ido-make-choice-list-hook)
+ ido-temp-list))
+
(defun ido-to-end (items)
;; Move the elements from ITEMS to the end of `ido-temp-list'
- (mapcar
- (lambda (elem)
+ (mapcar
+ (lambda (elem)
(setq ido-temp-list (delq elem ido-temp-list)))
items)
(if ido-temp-list
(nconc ido-temp-list items)
(setq ido-temp-list items)))
+(defun ido-file-name-all-completions-1 (dir)
+ (cond
+ ((ido-nonreadable-directory-p dir) '())
+ ;; do not check (ido-directory-too-big-p dir) here.
+ ;; Caller must have done that if necessary.
+ ((and ido-enable-tramp-completion
+ (string-match "\\`/\\([^/:]+:\\([^/:@]+@\\)?\\)\\'" dir))
+
+ ;; Trick tramp's file-name-all-completions handler to DTRT, as it
+ ;; has some pretty obscure requirements. This seems to work...
+ ;; /ftp: => (f-n-a-c "/ftp:" "")
+ ;; /ftp:kfs: => (f-n-a-c "" "/ftp:kfs:")
+ ;; /ftp:kfs@ => (f-n-a-c "ftp:kfs@" "/")
+ ;; /ftp:kfs@kfs: => (f-n-a-c "" "/ftp:kfs@kfs:")
+ ;; Currently no attempt is made to handle multi: stuff.
+
+ (let* ((prefix (match-string 1 dir))
+ (user-flag (match-beginning 2))
+ (len (and prefix (length prefix)))
+ compl)
+ (if user-flag
+ (setq dir (substring dir 1)))
+ (require 'tramp nil t)
+ (ido-trace "tramp complete" dir)
+ (setq compl (file-name-all-completions dir (if user-flag "/" "")))
+ (if (> len 0)
+ (mapcar (lambda (c) (substring c len)) compl)
+ compl)))
+ (t
+ (file-name-all-completions "" dir))))
+
(defun ido-file-name-all-completions (dir)
;; Return name of all files in DIR
;; Uses and updates ido-dir-file-cache
(stringp dir) (> (length dir) 0)
(ido-may-cache-directory dir))
(let* ((cached (assoc dir ido-dir-file-cache))
- (ctime (nth 1 cached))
+ (ctime (nth 1 cached))
(ftp (ido-is-ftp-directory dir))
(attr (if ftp nil (file-attributes dir)))
(mtime (nth 5 attr))
(if (and ftp (file-readable-p dir))
(setq mtime (cons 'ftp (ido-time-stamp))))
(if mtime
- (setq cached (cons dir (cons mtime (file-name-all-completions "" dir)))
+ (setq cached (cons dir (cons mtime (ido-file-name-all-completions-1 dir)))
ido-dir-file-cache (cons cached ido-dir-file-cache)))
(if (> (length ido-dir-file-cache) ido-max-dir-file-cache)
(setcdr (nthcdr (1- ido-max-dir-file-cache) ido-dir-file-cache) nil)))
(and cached
(cdr (cdr cached))))
- (file-name-all-completions "" dir)))
+ (ido-file-name-all-completions-1 dir)))
(defun ido-remove-cached-dir (dir)
;; Remove dir from ido-dir-file-cache
(setq ido-dir-file-cache (delq cached ido-dir-file-cache))))))
-(defun ido-make-file-list1 (dir &optional merged)
+(defun ido-make-file-list-1 (dir &optional merged)
;; Return list of non-ignored files in DIR
;; If MERGED is non-nil, each file is cons'ed with DIR
- (and (file-directory-p dir)
- (delq nil
+ (and (or (ido-is-tramp-root dir) (file-directory-p dir))
+ (delq nil
(mapcar
(lambda (name)
(if (not (ido-ignore-item-p name ido-ignore-files t))
(defun ido-make-file-list (default)
;; Return the current list of files.
;; Currently visible files are put at the end of the list.
- ;; The hook `ido-make-file-list-hook' is run after the list has been
+ ;; The hook `ido-make-file-list-hook' is run after the list has been
;; created to allow the user to further modify the order of the file names
;; in this list.
- (let ((ido-temp-list (ido-make-file-list1 ido-current-directory)))
- (setq ido-temp-list (ido-sort-list ido-temp-list))
+ (let ((ido-temp-list (ido-make-file-list-1 ido-current-directory)))
+ (setq ido-temp-list (sort ido-temp-list
+ (if ido-file-extensions-order
+ #'ido-file-extension-lessp
+ #'ido-file-lessp)))
(let ((default-directory ido-current-directory))
(ido-to-end ;; move ftp hosts and visited files to end
- (delq nil (mapcar
- (lambda (x) (if (or (string-match "..:\\'" x) (get-file-buffer x)) x))
+ (delq nil (mapcar
+ (lambda (x) (if (or (string-match "..:\\'" x)
+ (and (not (ido-final-slash x))
+ (get-file-buffer x))) x))
ido-temp-list))))
(ido-to-end ;; move . files to end
- (delq nil (mapcar
+ (delq nil (mapcar
(lambda (x) (if (string-equal (substring x 0 1) ".") x))
ido-temp-list)))
(if (and default (member default ido-temp-list))
(setcdr l nil)
(nconc k ido-temp-list)
(setq ido-temp-list k)))
- (setq ido-temp-list
+ (setq ido-temp-list
(delete default ido-temp-list))
- (setq ido-temp-list
+ (setq ido-temp-list
(cons default ido-temp-list))))
(when ido-show-dot-for-dired
(setq ido-temp-list (delete "." ido-temp-list))
(run-hooks 'ido-make-file-list-hook)
ido-temp-list))
-(defun ido-make-dir-list1 (dir &optional merged)
+(defun ido-make-dir-list-1 (dir &optional merged)
;; Return list of non-ignored subdirs in DIR
;; If MERGED is non-nil, each subdir is cons'ed with DIR
- (and (file-directory-p dir)
- (delq nil
+ (and (or (ido-is-tramp-root dir) (file-directory-p dir))
+ (delq nil
(mapcar
(lambda (name)
(and (ido-final-slash name) (not (ido-ignore-item-p name ido-ignore-directories))
(defun ido-make-dir-list (default)
;; Return the current list of directories.
- ;; The hook `ido-make-dir-list-hook' is run after the list has been
+ ;; The hook `ido-make-dir-list-hook' is run after the list has been
;; created to allow the user to further modify the order of the
;; directory names in this list.
- (let ((ido-temp-list (ido-make-dir-list1 ido-current-directory)))
- (setq ido-temp-list (ido-sort-list ido-temp-list))
- (let ((default-directory ido-current-directory))
- (ido-to-end ;; move visited files to end
- (delq nil (mapcar
- (lambda (x) (if (get-file-buffer x) x))
- ido-temp-list))))
+ (let ((ido-temp-list (ido-make-dir-list-1 ido-current-directory)))
+ (setq ido-temp-list (sort ido-temp-list #'ido-file-lessp))
(ido-to-end ;; move . files to end
- (delq nil (mapcar
+ (delq nil (mapcar
(lambda (x) (if (string-equal (substring x 0 1) ".") x))
ido-temp-list)))
(if (and default (member default ido-temp-list))
(setcdr l nil)
(nconc k ido-temp-list)
(setq ido-temp-list k)))
- (setq ido-temp-list
+ (setq ido-temp-list
(delete default ido-temp-list))
- (setq ido-temp-list
+ (setq ido-temp-list
(cons default ido-temp-list))))
(setq ido-temp-list (delete "." ido-temp-list))
- (setq ido-temp-list (cons "." ido-temp-list))
+ (unless ido-input-stack
+ (setq ido-temp-list (cons "." ido-temp-list)))
(run-hooks 'ido-make-dir-list-hook)
ido-temp-list))
;; `ido-all-frames'.
(let ((ido-bufs-in-frame nil))
(walk-windows 'ido-get-bufname nil
- (if current
+ (if current
nil
ido-all-frames))
ido-bufs-in-frame))
(defun ido-get-bufname (win)
;; Used by `ido-get-buffers-in-frames' to walk through all windows
(let ((buf (buffer-name (window-buffer win))))
- (if (not (member buf ido-bufs-in-frame))
- ;; Only add buf if it is not already in list.
- ;; This prevents same buf in two different windows being
- ;; put into the list twice.
- (setq ido-bufs-in-frame
- (cons buf ido-bufs-in-frame)))))
+ (unless (or (member buf ido-bufs-in-frame)
+ (member buf ido-ignore-item-temp-list))
+ ;; Only add buf if it is not already in list.
+ ;; This prevents same buf in two different windows being
+ ;; put into the list twice.
+ (setq ido-bufs-in-frame
+ (cons buf ido-bufs-in-frame)))))
;;; FIND MATCHING ITEMS
-(defun ido-set-matches1 (items &optional do-full)
+(defun ido-set-matches-1 (items &optional do-full)
;; Return list of matches in items
(let* ((case-fold-search ido-case-fold)
- (rexq (if ido-enable-regexp ido-text (regexp-quote ido-text)))
+ (slash (and (not ido-enable-prefix) (ido-final-slash ido-text)))
+ (text (if slash (substring ido-text 0 -1) ido-text))
+ (rexq (concat (if ido-enable-regexp text (regexp-quote text)) (if slash ".*/" "")))
(re (if ido-enable-prefix (concat "\\`" rexq) rexq))
(full-re (and do-full (not ido-enable-regexp) (not (string-match "\$\\'" re))
(concat "\\`" re "\\'")))
(prefix-re (and full-re (not ido-enable-prefix)
(concat "\\`" rexq)))
+ (non-prefix-dot (or (not ido-enable-dot-prefix)
+ (not ido-process-ignore-lists)
+ ido-enable-prefix
+ (= (length ido-text) 0)))
+
full-matches
prefix-matches
matches)
- (mapcar
- (lambda (item)
- (let ((name (ido-name item)))
- (if (string-match re name)
- (cond
- ((and full-re (string-match full-re name))
- (setq full-matches (cons item full-matches)))
- ((and prefix-re (string-match prefix-re name))
- (setq prefix-matches (cons item prefix-matches)))
- (t (setq matches (cons item matches))))))
- t)
- items)
+ (setq ido-incomplete-regexp nil)
+ (condition-case error
+ (mapcar
+ (lambda (item)
+ (let ((name (ido-name item)))
+ (if (and (or non-prefix-dot
+ (if (= (aref ido-text 0) ?.)
+ (= (aref name 0) ?.)
+ (/= (aref name 0) ?.)))
+ (string-match re name))
+ (cond
+ ((and full-re (string-match full-re name))
+ (setq full-matches (cons item full-matches)))
+ ((and prefix-re (string-match prefix-re name))
+ (setq prefix-matches (cons item prefix-matches)))
+ (t (setq matches (cons item matches))))))
+ t)
+ items)
+ (invalid-regexp
+ (setq ido-incomplete-regexp t
+ ;; Consider the invalid regexp message internally as a
+ ;; special-case single match, and handle appropriately
+ ;; elsewhere.
+ matches (cdr error))))
(if prefix-matches
(setq matches (nconc prefix-matches matches)))
(if full-matches
(setq matches (cons item matches)))))
items))
matches))
-
+
(defun ido-set-matches ()
;; Set `ido-matches' to the list of items matching prompt
(when ido-rescan
- (setq ido-matches (ido-set-matches1 (reverse ido-cur-list) (not ido-rotate))
+ (setq ido-matches (ido-set-matches-1 (reverse ido-cur-list) (not ido-rotate))
ido-rotate nil)))
-
+
(defun ido-ignore-item-p (name re-list &optional ignore-ext)
;; Return t if the buffer or file NAME should be ignored.
- (and ido-process-ignore-lists re-list
- (let ((data (match-data))
- (ext-list (and ignore-ext ido-ignore-extensions
+ (or (member name ido-ignore-item-temp-list)
+ (and
+ ido-process-ignore-lists re-list
+ (save-match-data
+ (let ((ext-list (and ignore-ext ido-ignore-extensions
completion-ignored-extensions))
- ignorep nextstr
- (flen (length name)) slen)
- (while ext-list
- (setq nextstr (car ext-list))
- (if (cond
- ((stringp nextstr)
- (and (>= flen (setq slen (length nextstr)))
- (string-equal (substring name (- flen slen)) nextstr)))
- ((fboundp nextstr) (funcall nextstr name))
- (t nil))
- (setq ignorep t
- ext-list nil
- re-list nil)
- (setq ext-list (cdr ext-list))))
- (while re-list
- (setq nextstr (car re-list))
- (if (cond
- ((stringp nextstr) (string-match nextstr name))
- ((fboundp nextstr) (funcall nextstr name))
- (t nil))
- (setq ignorep t
- re-list nil)
- (setq re-list (cdr re-list))))
- ;; return the result
- (if ignorep
- (setq ido-ignored-list (cons name ido-ignored-list)))
- (set-match-data data)
- ignorep)))
-
+ (case-fold-search ido-case-fold)
+ ignorep nextstr
+ (flen (length name)) slen)
+ (while ext-list
+ (setq nextstr (car ext-list))
+ (if (cond
+ ((stringp nextstr)
+ (and (>= flen (setq slen (length nextstr)))
+ (string-equal (substring name (- flen slen)) nextstr)))
+ ((fboundp nextstr) (funcall nextstr name))
+ (t nil))
+ (setq ignorep t
+ ext-list nil
+ re-list nil)
+ (setq ext-list (cdr ext-list))))
+ (while re-list
+ (setq nextstr (car re-list))
+ (if (cond
+ ((stringp nextstr) (string-match nextstr name))
+ ((fboundp nextstr) (funcall nextstr name))
+ (t nil))
+ (setq ignorep t
+ re-list nil)
+ (setq re-list (cdr re-list))))
+ ;; return the result
+ (if ignorep
+ (setq ido-ignored-list (cons name ido-ignored-list)))
+ ignorep)))))
;; Private variable used by `ido-word-matching-substring'.
(defvar ido-change-word-sub)
(defun ido-word-matching-substring (word)
;; Return part of WORD before 1st match to `ido-change-word-sub'.
;; If `ido-change-word-sub' cannot be found in WORD, return nil.
- (let ((case-fold-search ido-case-fold))
+ (let ((case-fold-search ido-case-fold))
(let ((m (string-match ido-change-word-sub (ido-name word))))
(if m
(substring (ido-name word) m)
(if (pos-visible-in-window-p (point-max) win)
(if (or ido-completion-buffer-all-completions (boundp 'ido-completion-buffer-full))
(set-window-start win (point-min))
- (set (make-local-variable 'ido-completion-buffer-full) t)
+ (with-no-warnings
+ (set (make-local-variable 'ido-completion-buffer-full) t))
(setq full-list t
display-it t))
(scroll-other-window))
(setq display-it t))
(if display-it
(with-output-to-temp-buffer ido-completion-buffer
- (let ((completion-list (ido-sort-list
+ (let ((completion-list (sort
(cond
(ido-use-merged-list
(ido-flatten-merged-list (or ido-matches ido-cur-list)))
((or full-list ido-completion-buffer-all-completions)
(ido-all-completions))
(t
- (copy-sequence (or ido-matches ido-cur-list)))))))
- (if ido-xemacs
+ (copy-sequence (or ido-matches ido-cur-list))))
+ #'ido-file-lessp)))
+ (if (featurep 'xemacs)
;; XEmacs extents are put on by default, doesn't seem to be
;; any way of switching them off.
- ;; This obscure code avoids a byte compiler warning in GNU emacs.
+ ;; This obscure code avoids a byte compiler warning in Emacs.
(let ((f 'display-completion-list))
(funcall f completion-list
:help-string "ido "
- :activate-callback
+ :activate-callback
'(lambda (x y z) (message "doesn't work yet, sorry!"))))
;; else running Emacs
;;(add-hook 'completion-setup-hook 'completion-setup-function)
;; Check if buffer still exists.
(if (get-buffer buf)
;; buffer couldn't be killed.
- (setq ido-rescan t)
+ (setq ido-rescan t)
;; else buffer was killed so remove name from list.
(setq ido-cur-list (delq buf ido-cur-list))))))
;; Check if file still exists.
(if (file-exists-p file)
;; file could not be deleted
- (setq ido-rescan t)
+ (setq ido-rescan t)
;; else file was killed so remove name from list.
(setq ido-cur-list (delq (car ido-matches) ido-cur-list))))))
;;; VISIT CHOSEN BUFFER
(defun ido-visit-buffer (buffer method &optional record)
"Visit file named FILE according to METHOD.
-Record command in command-history if optional RECORD is non-nil."
+Record command in `command-history' if optional RECORD is non-nil."
(let (win newframe)
(cond
(select-frame-set-input-focus newframe)
(raise-frame newframe)
(select-frame newframe)
- (if (not ido-xemacs)
+ (unless (featurep 'xemacs)
(set-mouse-position (selected-frame) (1- (frame-width)) 0)))
(select-window win))
(t
(display-buffer buffer))
((eq method 'otherframe)
- (progn
- (switch-to-buffer-other-frame buffer)
- (if (not ido-xemacs)
- (if (fboundp 'select-frame-set-input-focus)
- (select-frame-set-input-focus (selected-frame))
- (set-mouse-position (selected-frame) (1- (frame-width)) 0)))
- )))))
+ (switch-to-buffer-other-frame buffer)
+ (unless (featurep 'xemacs)
+ (select-frame-set-input-focus (selected-frame)))
+ ))))
(defun ido-window-buffer-p (buffer)
;; If BUFFER is visible in the current frame, return nil.
(let ((blist (ido-get-buffers-in-frames 'current)))
;;If the buffer is visible in current frame, return nil
- (if (memq buffer blist)
+ (if (member buffer blist)
nil
;; maybe in other frame or icon
(get-buffer-window buffer 0) ; better than 'visible
As you type in a string, all of the buffers matching the string are
displayed if substring-matching is used \(default). Look at
-`ido-enable-prefix' and `ido-toggle-prefix'. When you have found the
-buffer you want, it can then be selected. As you type, most keys have their
-normal keybindings, except for the following: \\<ido-mode-map>
+`ido-enable-prefix' and `ido-toggle-prefix'. When you have found the
+buffer you want, it can then be selected. As you type, most keys have
+their normal keybindings, except for the following: \\<ido-mode-map>
RET Select the buffer at the front of the list of matches. If the
list is empty, possibly prompt to create new buffer.
\\[ido-next-match] Put the first element at the end of the list.
\\[ido-prev-match] Put the last element at the start of the list.
-\\[ido-complete] Complete a common suffix to the current string that
+\\[ido-complete] Complete a common suffix to the current string that
matches all buffers. If there is only one match, select that buffer.
If there is no common suffix, show a list of all matching buffers
in a separate window.
The buffer name is selected interactively by typing a substring.
For details of keybindings, do `\\[describe-function] ido'."
(interactive)
- (ido-buffer-internal 'display 'display-buffer))
+ (ido-buffer-internal 'display 'display-buffer nil nil nil 'ignore))
;;;###autoload
(defun ido-kill-buffer ()
The buffer name is selected interactively by typing a substring.
For details of keybindings, do `\\[describe-function] ido'."
(interactive)
- (ido-buffer-internal 'kill 'kill-buffer "Kill buffer: " (buffer-name (current-buffer))))
+ (ido-buffer-internal 'kill 'kill-buffer "Kill buffer: " (buffer-name (current-buffer)) nil 'ignore))
;;;###autoload
(defun ido-insert-buffer ()
The buffer name is selected interactively by typing a substring.
For details of keybindings, do `\\[describe-function] ido'."
(interactive)
- (ido-buffer-internal 'insert 'insert-buffer "Insert buffer: "))
+ (ido-buffer-internal 'insert 'insert-buffer "Insert buffer: " nil nil 'ido-enter-insert-file))
;;;###autoload
(defun ido-switch-buffer-other-frame ()
(interactive "DDir: ")
(if (not (equal (substring dir -1) "/"))
(setq dir (concat dir "/")))
- (ido-file-internal ido-default-file-method nil dir))
+ (ido-file-internal ido-default-file-method nil dir nil nil nil 'ignore))
;;;###autoload
(defun ido-find-file ()
default is to show it in the same window, unless it is already
visible in another frame.
-The file name is selected interactively by typing a substring. As you type
-in a string, all of the filenames matching the string are displayed if
-substring-matching is used \(default). Look at `ido-enable-prefix' and
-`ido-toggle-prefix'. When you have found the filename you want, it can
-then be selected. As you type, most keys have their normal keybindings,
+The file name is selected interactively by typing a substring. As you
+type in a string, all of the filenames matching the string are displayed
+if substring-matching is used \(default). Look at `ido-enable-prefix' and
+`ido-toggle-prefix'. When you have found the filename you want, it can
+then be selected. As you type, most keys have their normal keybindings,
except for the following: \\<ido-mode-map>
RET Select the file at the front of the list of matches. If the
\\[ido-next-match] Put the first element at the end of the list.
\\[ido-prev-match] Put the last element at the start of the list.
-\\[ido-complete] Complete a common suffix to the current string that
+\\[ido-complete] Complete a common suffix to the current string that
matches all files. If there is only one match, select that file.
If there is no common suffix, show a list of all matching files
in a separate window.
-\\[ido-edit-input] Edit input string (including path).
+\\[ido-edit-input] Edit input string (including directory).
\\[ido-prev-work-directory] or \\[ido-next-work-directory] go to previous/next directory in work directory history.
\\[ido-merge-work-directories] search for file in the work directory history.
\\[ido-forget-work-directory] removes current directory from the work directory history.
The file name is selected interactively by typing a substring.
For details of keybindings, do `\\[describe-function] ido-find-file'."
(interactive)
- (ido-file-internal 'display))
+ (ido-file-internal 'display nil nil nil nil nil 'ignore))
;;;###autoload
(defun ido-find-file-other-frame ()
(ido-work-directory-match-only nil)
(ido-ignore-files (cons "[^/]\\'" ido-ignore-files))
(ido-report-no-match nil)
+ (ido-confirm-unique-completion t)
(ido-auto-merge-work-directories-length -1))
- (ido-file-internal 'write 'write-file nil "Write file: ")))
+ (ido-file-internal 'write 'write-file nil "Write file: " nil nil 'ignore)))
;;;###autoload
(defun ido-insert-file ()
The file name is selected interactively by typing a substring.
For details of keybindings, do `\\[describe-function] ido-find-file'."
(interactive)
- (ido-file-internal 'insert 'insert-file nil "Insert file: "))
+ (ido-file-internal 'insert 'insert-file nil "Insert file: " nil nil 'ido-enter-insert-buffer))
;;;###autoload
(defun ido-dired ()
;; 1. It prints a default file name when there is no text yet entered.
;; 2. It calls my completion routine rather than the standard completion.
- (if (= ido-use-mycompletion-depth (minibuffer-depth))
- (let ((contents (buffer-substring-no-properties (minibuffer-prompt-end) (point-max)))
- (buffer-undo-list t)
- try-single-dir-match)
+ (when (= ido-use-mycompletion-depth (minibuffer-depth))
+ (let ((contents (buffer-substring-no-properties (minibuffer-prompt-end) (point-max)))
+ (buffer-undo-list t)
+ try-single-dir-match
+ refresh)
- (ido-trace "\nexhibit" this-command)
- (ido-trace "dir" ido-current-directory)
- (ido-trace "contents" contents)
- (ido-trace "list" ido-cur-list)
- (ido-trace "matches" ido-matches)
- (ido-trace "rescan" ido-rescan)
+ (ido-trace "\nexhibit" this-command)
+ (ido-trace "dir" ido-current-directory)
+ (ido-trace "contents" contents)
+ (ido-trace "list" ido-cur-list)
+ (ido-trace "matches" ido-matches)
+ (ido-trace "rescan" ido-rescan)
- (save-excursion
- (goto-char (point-max))
- ;; Register the end of input, so we know where the extra stuff (match-status info) begins:
- (if (not (boundp 'ido-eoinput))
- ;; In case it got wiped out by major mode business:
- (make-local-variable 'ido-eoinput))
- (setq ido-eoinput (point))
-
- ;; Handle explicit directory changes
- (and
- (memq ido-cur-item '(file dir))
- (> (length contents) 1)
+ (save-excursion
+ (goto-char (point-max))
+ ;; Register the end of input, so we know where the extra stuff (match-status info) begins:
+ (unless (boundp 'ido-eoinput)
+ ;; In case it got wiped out by major mode business:
+ (make-local-variable 'ido-eoinput))
+ (setq ido-eoinput (point))
+
+ ;; Handle explicit directory changes
+ (cond
+ ((memq ido-cur-item '(buffer list))
+ )
+
+ ((= (length contents) 0)
+ )
+
+ ((= (length contents) 1)
+ (when (and (ido-is-tramp-root) (string-equal contents "/"))
+ (ido-set-current-directory ido-current-directory contents)
+ (setq refresh t))
+ )
+
+ ((and (string-match (if ido-enable-tramp-completion "..[:@]\\'" "..:\\'") contents)
+ (ido-is-root-directory)) ;; Ange-ftp or tramp
+ (ido-set-current-directory ido-current-directory contents)
+ (when (ido-is-slow-ftp-host)
+ (setq ido-exit 'fallback)
+ (exit-minibuffer))
+ (setq refresh t))
+
+ ((ido-final-slash contents) ;; xxx/
+ (ido-trace "final slash" contents)
+ (cond
+ ((string-equal contents "~/")
+ (ido-set-current-home)
+ (setq refresh t))
+ ((string-equal contents "../")
+ (ido-up-directory t)
+ (setq refresh t))
+ ((string-equal contents "./")
+ (setq refresh t))
+ ((string-match "\\`~[a-zA-Z0-9]+/\\'" contents)
+ (ido-trace "new home" contents)
+ (ido-set-current-home contents)
+ (setq refresh t))
+ ((string-match "[$][A-Za-z0-9_]+/\\'" contents)
+ (let ((exp (condition-case ()
+ (expand-file-name
+ (substitute-in-file-name (substring contents 0 -1))
+ ido-current-directory)
+ (error nil))))
+ (ido-trace contents exp)
+ (when (and exp (file-directory-p exp))
+ (ido-set-current-directory (file-name-directory exp))
+ (setq ido-text-init (file-name-nondirectory exp))
+ (setq refresh t))))
+ ((and (memq system-type '(windows-nt ms-dos))
+ (string-equal (substring contents 1) ":/"))
+ (ido-set-current-directory (file-name-directory contents))
+ (setq refresh t))
+ ((string-equal (substring contents -2 -1) "/")
+ (ido-set-current-directory
+ (if (memq system-type '(windows-nt ms-dos))
+ (expand-file-name "/" ido-current-directory)
+ "/"))
+ (setq refresh t))
+ ((and (or ido-directory-nonreadable ido-directory-too-big)
+ (file-directory-p (concat ido-current-directory (file-name-directory contents))))
+ (ido-set-current-directory
+ (concat ido-current-directory (file-name-directory contents)))
+ (setq refresh t))
+ (t
+ (ido-trace "try single dir")
+ (setq try-single-dir-match t))))
+
+ ((and (string-equal (substring contents -2 -1) "/")
+ (not (string-match "[$]" contents)))
+ (ido-set-current-directory
(cond
- ((ido-final-slash contents) ;; xxx/
- (ido-trace "final slash" contents)
- (cond
- ((string-equal contents "~/")
- (ido-set-current-home)
- t)
- ((string-equal contents "../")
- (ido-up-directory t)
- t)
- ((string-equal contents "./")
- t)
- ((string-match contents "\\`~[a-zA-Z0-9]/\\'")
- (ido-set-current-home contents)
- t)
- ((string-match "[$][A-Za-z0-9_]+/\\'" contents)
- (let ((exp (condition-case ()
- (expand-file-name
- (substitute-in-file-name (substring contents 0 -1))
- ido-current-directory)
- (error nil))))
- (ido-trace contents exp)
- (if (and exp (file-directory-p exp))
- (progn
- (ido-set-current-directory (file-name-directory exp))
- (setq ido-text-init (file-name-nondirectory exp))
- t)
- nil)))
- ((and (memq system-type '(windows-nt ms-dos))
- (string-equal (substring contents 1) ":/"))
- (ido-set-current-directory (file-name-directory contents))
- t)
- ((string-equal (substring contents -2 -1) "/")
- (ido-set-current-directory
- (if (memq system-type '(windows-nt ms-dos))
- (expand-file-name "/" ido-current-directory)
- "/"))
- t)
- (t
- (setq try-single-dir-match t)
- nil)))
-
- ((and (string-equal ido-current-directory "/")
- (string-match "..:\\'" contents)) ;; Ange-ftp
- (ido-set-current-directory "/" contents)
- (when (ido-is-slow-ftp-host)
- (setq ido-exit 'fallback)
- (exit-minibuffer))
- t)
-
- ((and (string-equal (substring contents -2 -1) "/")
- (not (string-match "[$]" contents)))
- (ido-set-current-directory
- (cond
- ((= (length contents) 2)
- "/")
- (ido-matches
- (concat ido-current-directory (car ido-matches)))
- (t
- (concat ido-current-directory (substring contents 0 -1)))))
- (setq ido-text-init (substring contents -1))
- t)
-
- ((and (not ido-use-merged-list)
- (not (ido-final-slash contents))
- (eq ido-try-merged-list t)
- (numberp ido-auto-merge-work-directories-length)
- (> ido-auto-merge-work-directories-length 0)
- (= (length contents) ido-auto-merge-work-directories-length)
- (not (and ido-auto-merge-inhibit-characters-regexp
- (string-match ido-auto-merge-inhibit-characters-regexp contents)))
- (not (input-pending-p)))
- (setq ido-use-merged-list 'auto
- ido-text-init contents
- ido-rotate-temp t)
- t))
- (progn
- (ido-trace "refresh on /" ido-text-init)
- (setq ido-exit 'refresh)
- (exit-minibuffer)))
-
- ;; Update the list of matches
- (setq ido-text contents)
- (ido-set-matches)
- (ido-trace "new " ido-matches)
-
- (when (and ido-enter-single-matching-directory
- ido-matches
- (null (cdr ido-matches))
- (ido-final-slash (car ido-matches))
- (or try-single-dir-match
- (eq ido-enter-single-matching-directory t)))
- (ido-trace "single match" (car ido-matches))
- (ido-set-current-directory
+ ((= (length contents) 2)
+ "/")
+ (ido-matches
(concat ido-current-directory (car ido-matches)))
- (setq ido-exit 'refresh)
- (exit-minibuffer))
+ (t
+ (concat ido-current-directory (substring contents 0 -1)))))
+ (setq ido-text-init (substring contents -1))
+ (setq refresh t))
+
+ ((and (not ido-use-merged-list)
+ (not (ido-final-slash contents))
+ (eq ido-try-merged-list t)
+ (numberp ido-auto-merge-work-directories-length)
+ (> ido-auto-merge-work-directories-length 0)
+ (= (length contents) ido-auto-merge-work-directories-length)
+ (not (and ido-auto-merge-inhibit-characters-regexp
+ (string-match ido-auto-merge-inhibit-characters-regexp contents)))
+ (not (input-pending-p)))
+ (setq ido-use-merged-list 'auto
+ ido-text-init contents
+ ido-rotate-temp t)
+ (setq refresh t))
+
+ (t nil))
+
+ (when refresh
+ (ido-trace "refresh on /" ido-text-init)
+ (setq ido-exit 'refresh)
+ (exit-minibuffer))
+
+ ;; Update the list of matches
+ (setq ido-text contents)
+ (ido-set-matches)
+ (ido-trace "new " ido-matches)
+
+ (when (and ido-enter-matching-directory
+ ido-matches
+ (or (eq ido-enter-matching-directory 'first)
+ (null (cdr ido-matches)))
+ (ido-final-slash (car ido-matches))
+ (or try-single-dir-match
+ (eq ido-enter-matching-directory t)))
+ (ido-trace "single match" (car ido-matches))
+ (ido-set-current-directory
+ (concat ido-current-directory (car ido-matches)))
+ (setq ido-exit 'refresh)
+ (exit-minibuffer))
- (when (and (not ido-matches)
- ; ido-rescan
+ (when (and (not ido-matches)
+ (not ido-directory-nonreadable)
+ (not ido-directory-too-big)
+ ;; ido-rescan ?
ido-process-ignore-lists
ido-ignored-list)
- (let ((ido-process-ignore-lists nil)
- (ido-rotate ido-rotate)
- (ido-cur-list ido-ignored-list))
- (ido-trace "try all" ido-ignored-list)
- (ido-set-matches))
- (when ido-matches
- (ido-trace "found " ido-matches)
- (setq ido-rescan t)
- (setq ido-process-ignore-lists-inhibit t)
- (setq ido-text-init ido-text)
- (setq ido-exit 'refresh)
- (exit-minibuffer)))
-
- (when (and
- ido-rescan
- (not ido-matches)
- (memq ido-cur-item '(file dir))
- (not (ido-is-root-directory))
- (> (length contents) 1)
- (not (string-match "[$]" contents)))
- (ido-trace "merge?")
- (if ido-use-merged-list
- (ido-undo-merge-work-directory contents nil)
- (when (and (eq ido-try-merged-list t)
- (numberp ido-auto-merge-work-directories-length)
- (= ido-auto-merge-work-directories-length 0)
- (not (and ido-auto-merge-inhibit-characters-regexp
- (string-match ido-auto-merge-inhibit-characters-regexp contents)))
- (not (input-pending-p)))
- (ido-trace "\n*start timer*")
- (setq ido-auto-merge-timer
- (run-with-timer ido-auto-merge-delay-time nil 'ido-initiate-auto-merge (current-buffer))))))
-
- (setq ido-rescan t)
+ (let ((ido-process-ignore-lists nil)
+ (ido-rotate ido-rotate)
+ (ido-cur-list ido-ignored-list))
+ (ido-trace "try all" ido-ignored-list)
+ (ido-set-matches))
+ (when ido-matches
+ (ido-trace "found " ido-matches)
+ (setq ido-rescan t)
+ (setq ido-process-ignore-lists-inhibit t)
+ (setq ido-text-init ido-text)
+ (setq ido-exit 'refresh)
+ (exit-minibuffer)))
+
+ (when (and
+ ido-rescan
+ (not ido-matches)
+ (memq ido-cur-item '(file dir))
+ (not (ido-is-root-directory))
+ (> (length contents) 1)
+ (not (string-match "[$]" contents))
+ (not ido-directory-nonreadable)
+ (not ido-directory-too-big))
+ (ido-trace "merge?")
+ (if ido-use-merged-list
+ (ido-undo-merge-work-directory contents nil)
+ (when (and (eq ido-try-merged-list t)
+ (numberp ido-auto-merge-work-directories-length)
+ (= ido-auto-merge-work-directories-length 0)
+ (not (and ido-auto-merge-inhibit-characters-regexp
+ (string-match ido-auto-merge-inhibit-characters-regexp contents)))
+ (not (input-pending-p)))
+ (ido-trace "\n*start timer*")
+ (setq ido-auto-merge-timer
+ (run-with-timer ido-auto-merge-delay-time nil 'ido-initiate-auto-merge (current-buffer))))))
- (if (and ido-use-merged-list
- ido-matches
- (not (string-equal (car (cdr (car ido-matches))) ido-current-directory)))
- (progn
- (ido-set-current-directory (car (cdr (car ido-matches))))
- (setq ido-use-merged-list t
- ido-exit 'keep
- ido-text-init ido-text)
- (exit-minibuffer)))
-
- ;; Insert the match-status information:
- (ido-set-common-completion)
- (let ((inf (ido-completions
- contents
- minibuffer-completion-table
- minibuffer-completion-predicate
- (not minibuffer-completion-confirm))))
- (ido-trace "inf" inf)
- (insert inf))
-
- ))))
+ (setq ido-rescan t)
+
+ (if (and ido-use-merged-list
+ ido-matches
+ (not (string-equal (car (cdr (car ido-matches))) ido-current-directory)))
+ (progn
+ (ido-set-current-directory (car (cdr (car ido-matches))))
+ (setq ido-use-merged-list t
+ ido-exit 'keep
+ ido-text-init ido-text)
+ (exit-minibuffer)))
+
+ ;; Insert the match-status information:
+ (ido-set-common-completion)
+ (let ((inf (ido-completions
+ contents
+ minibuffer-completion-table
+ minibuffer-completion-predicate
+ (not minibuffer-completion-confirm))))
+ (ido-trace "inf" inf)
+ (insert inf))
+ ))))
(defun ido-completions (name candidates predicate require-match)
;; Return the string that is displayed after the user's text.
;; Modified from `icomplete-completions'.
-
+
(let* ((comps ido-matches)
(ind (and (consp (car comps)) (> (length (cdr (car comps))) 1)
ido-merged-indicator))
first)
(if (and ind ido-use-faces)
- (put-text-property 0 1 'face 'ido-indicator-face ind))
-
+ (put-text-property 0 1 'face 'ido-indicator ind))
+
(if (and ido-use-faces comps)
(let* ((fn (ido-name (car comps)))
(ln (length fn)))
(setq first (format "%s" fn))
(put-text-property 0 ln 'face
(if (= (length comps) 1)
- 'ido-only-match-face
- 'ido-first-match-face)
+ (if ido-incomplete-regexp
+ 'ido-incomplete-regexp
+ 'ido-only-match)
+ 'ido-first-match)
first)
(if ind (setq first (concat first ind)))
(setq comps (cons first (cdr comps)))))
(cond ((null comps)
- (if ido-report-no-match
- (nth 6 ido-decorations) ;; [No Match]
- ""))
-
+ (cond
+ (ido-directory-nonreadable
+ (or (nth 8 ido-decorations) " [Not readable]"))
+ (ido-directory-too-big
+ (or (nth 9 ido-decorations) " [Too big]"))
+ (ido-report-no-match
+ (nth 6 ido-decorations)) ;; [No match]
+ (t "")))
+ (ido-incomplete-regexp
+ (concat " " (car comps)))
((null (cdr comps)) ;one match
- (concat (if (> (length (ido-name (car comps))) (length name))
- ;; when there is one match, show the matching file name in full
- (concat (nth 4 ido-decorations) ;; [ ... ]
- (ido-name (car comps))
- (nth 5 ido-decorations))
- "")
+ (concat (if (if (not ido-enable-regexp)
+ (= (length (ido-name (car comps))) (length name))
+ ;; We can't rely on the length of the input
+ ;; for regexps, so explicitly check for a
+ ;; complete match
+ (string-match name (ido-name (car comps)))
+ (string-equal (match-string 0 (ido-name (car comps)))
+ (ido-name (car comps))))
+ ""
+ ;; when there is one match, show the matching file name in full
+ (concat (nth 4 ido-decorations) ;; [ ... ]
+ (ido-name (car comps))
+ (nth 5 ido-decorations)))
(if (not ido-use-faces) (nth 7 ido-decorations)))) ;; [Matched]
(t ;multiple matches
(let* ((items (if (> ido-max-prospects 0) (1+ ido-max-prospects) 999))
(alternatives
(apply
- #'concat
+ #'concat
(cdr (apply
#'nconc
(mapcar
(if (and ido-use-faces
(not (string= str first))
(ido-final-slash str))
- (put-text-property 0 (length str) 'face 'ido-subdir-face str))
+ (put-text-property 0 (length str) 'face 'ido-subdir str))
str)))))
comps))))))
(defun ido-minibuffer-setup ()
"Minibuffer setup hook for `ido'."
;; Copied from `icomplete-minibuffer-setup-hook'.
- (when (and (boundp 'ido-completing-read)
- (or ido-xemacs (= ido-use-mycompletion-depth (minibuffer-depth))))
+ (when (and (boundp 'ido-completing-read)
+ (or (featurep 'xemacs)
+ (= ido-use-mycompletion-depth (minibuffer-depth))))
(add-hook 'pre-command-hook 'ido-tidy nil t)
(add-hook 'post-command-hook 'ido-exhibit nil t)
(setq cua-inhibit-cua-keys t)
- (when ido-xemacs
+ (when (featurep 'xemacs)
(ido-exhibit)
(goto-char (point-min)))
(run-hooks 'ido-minibuffer-setup-hook)))
(= ido-use-mycompletion-depth (minibuffer-depth)))
(if (and (boundp 'ido-eoinput)
ido-eoinput)
-
+
(if (> ido-eoinput (point-max))
;; Oops, got rug pulled out from under us - reinit:
(setq ido-eoinput (point-max))
(let ((buffer-undo-list t))
(delete-region ido-eoinput (point-max))))
-
+
;; Reestablish the local variable 'cause minibuffer-setup is weird:
(make-local-variable 'ido-eoinput)
(setq ido-eoinput 1))))
;; This is an example function which can be hooked on to
;; `ido-make-buffer-list-hook'. Any buffer matching the regexps
;; `Summary' or `output\*$'are put to the end of the list.
- (let ((summaries (delq nil (mapcar
- (lambda (x)
- (if (or
+ (let ((summaries (delq nil (mapcar
+ (lambda (x)
+ (if (or
(string-match "Summary" x)
(string-match "output\\*\\'" x))
x))
;;; Helper functions for other programs
+(put 'dired-do-rename 'ido 'ignore)
+(put 'ibuffer-find-file 'ido 'find-file)
+(put 'dired-other-window 'ido 'dir)
+
+;;;###autoload
+(defun ido-read-buffer (prompt &optional default require-match)
+ "Ido replacement for the built-in `read-buffer'.
+Return the name of a buffer selected.
+PROMPT is the prompt to give to the user. DEFAULT if given is the default
+buffer to be selected, which will go to the front of the list.
+If REQUIRE-MATCH is non-nil, an existing buffer must be selected."
+ (let* ((ido-current-directory nil)
+ (ido-directory-nonreadable nil)
+ (ido-directory-too-big nil)
+ (ido-context-switch-command 'ignore)
+ (buf (ido-read-internal 'buffer prompt 'ido-buffer-history default require-match)))
+ (if (eq ido-exit 'fallback)
+ (let ((read-buffer-function nil))
+ (run-hook-with-args 'ido-before-fallback-functions 'read-buffer)
+ (read-buffer prompt default require-match))
+ buf)))
+
;;;###autoload
(defun ido-read-file-name (prompt &optional dir default-filename mustmatch initial predicate)
- "Read file name, prompting with PROMPT and completing in directory DIR.
+ "Ido replacement for the built-in `read-file-name'.
+Read file name, prompting with PROMPT and completing in directory DIR.
See `read-file-name' for additional parameters."
- (message "%S %S %S %S" this-command ido-read-file-name-non-ido
- predicate (memq this-command ido-read-file-name-non-ido))
- (cond
- ((or (eq predicate 'file-directory-p)
- (memq this-command ido-read-file-name-as-directory-commands))
- (ido-read-directory-name prompt dir default-filename mustmatch initial))
- ((and (not (memq this-command ido-read-file-name-non-ido))
- (or (null predicate) (eq predicate 'file-exists-p)))
- (message "gotit")
- (let (filename
- ido-saved-vc-mt
- (vc-master-templates (and (boundp 'vc-master-templates) vc-master-templates))
- (ido-current-directory (expand-file-name (or dir default-directory)))
- (ido-work-directory-index -1)
- (ido-work-file-index -1)
- (ido-find-literal nil))
- (setq filename
- (ido-read-internal 'file prompt 'ido-file-history default-filename mustmatch initial))
- (if filename
- (concat ido-current-directory filename))))
- (t
- (let ((read-file-name-function nil))
- (read-file-name prompt dir default-filename mustmatch initial predicate)))))
+ (let (filename)
+ (cond
+ ((or (eq predicate 'file-directory-p)
+ (eq (get this-command 'ido) 'dir)
+ (memq this-command ido-read-file-name-as-directory-commands))
+ (setq filename
+ (ido-read-directory-name prompt dir default-filename mustmatch initial))
+ (if (eq ido-exit 'fallback)
+ (setq filename 'fallback)))
+ ((and (not (eq (get this-command 'ido) 'ignore))
+ (not (memq this-command ido-read-file-name-non-ido))
+ (or (null predicate) (eq predicate 'file-exists-p)))
+ (let* (ido-saved-vc-hb
+ (ido-context-switch-command
+ (if (eq (get this-command 'ido) 'find-file) nil 'ignore))
+ (vc-handled-backends (and (boundp 'vc-handled-backends) vc-handled-backends))
+ (minibuffer-completing-file-name t)
+ (ido-current-directory (ido-expand-directory dir))
+ (ido-directory-nonreadable (not (file-readable-p ido-current-directory)))
+ (ido-directory-too-big (and (not ido-directory-nonreadable)
+ (ido-directory-too-big-p ido-current-directory)))
+ (ido-work-directory-index -1)
+ (ido-work-file-index -1)
+ (ido-find-literal nil))
+ (setq ido-exit nil)
+ (setq filename
+ (ido-read-internal 'file prompt 'ido-file-history default-filename mustmatch initial))
+ (cond
+ ((eq ido-exit 'fallback)
+ (setq filename 'fallback))
+ ((eq ido-exit 'dired)
+ (setq filename ido-current-directory))
+ (filename
+ (setq filename
+ (concat ido-current-directory filename))))))
+ (t
+ (setq filename 'fallback)))
+ (if (eq filename 'fallback)
+ (let ((read-file-name-function nil))
+ (run-hook-with-args 'ido-before-fallback-functions 'read-file-name)
+ (read-file-name prompt dir default-filename mustmatch initial predicate))
+ filename)))
;;;###autoload
(defun ido-read-directory-name (prompt &optional dir default-dirname mustmatch initial)
- "Read directory name, prompting with PROMPT and completing in directory DIR.
-See `read-file-name' for additional parameters."
- (let (filename
- ido-saved-vc-mt
- (ido-current-directory (expand-file-name (or dir default-directory)))
- (ido-work-directory-index -1)
- (ido-work-file-index -1))
+ "Ido replacement for the built-in `read-directory-name'.
+Read directory name, prompting with PROMPT and completing in directory DIR.
+See `read-directory-name' for additional parameters."
+ (let* (filename
+ (minibuffer-completing-file-name t)
+ (ido-context-switch-command 'ignore)
+ ido-saved-vc-hb
+ (ido-current-directory (ido-expand-directory dir))
+ (ido-directory-nonreadable (not (file-readable-p ido-current-directory)))
+ (ido-directory-too-big (and (not ido-directory-nonreadable)
+ (ido-directory-too-big-p ido-current-directory)))
+ (ido-work-directory-index -1)
+ (ido-work-file-index -1))
(setq filename
(ido-read-internal 'dir prompt 'ido-file-history default-dirname mustmatch initial))
(if filename
ido-current-directory
(concat ido-current-directory filename)))))
+;;;###autoload
+(defun ido-completing-read (prompt choices &optional predicate require-match initial-input hist def)
+ "Ido replacement for the built-in `completing-read'.
+Read a string in the minibuffer with ido-style completion.
+PROMPT is a string to prompt with; normally it ends in a colon and a space.
+CHOICES is a list of strings which are the possible completions.
+PREDICATE is currently ignored; it is included to be compatible
+ with `completing-read'.
+If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
+ the input is (or completes to) an element of CHOICES or is null.
+ If the input is null, `ido-completing-read' returns DEF, or an empty
+ string if DEF is nil, regardless of the value of REQUIRE-MATCH.
+If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
+ with point positioned at the end.
+HIST, if non-nil, specifies a history list.
+DEF, if non-nil, is the default value."
+ (let ((ido-current-directory nil)
+ (ido-directory-nonreadable nil)
+ (ido-directory-too-big nil)
+ (ido-context-switch-command 'ignore)
+ (ido-choice-list choices))
+ (ido-read-internal 'list prompt hist def require-match initial-input)))
+
+
+;;; arch-tag: b63a3500-1735-41bd-8a01-05373f0864da
;;; ido.el ends here
HCoop / bpt / emacs.git / blobdiff