:initialize 'custom-initialize-set
:require 'ido
:link '(emacs-commentary-link "ido.el")
- :set-after '(ido-save-directory-list-file)
+ :set-after '(ido-save-directory-list-file
+ ;; This will clear ido-unc-hosts-cache, so set it
+ ;; before loading history file.
+ ido-unc-hosts)
: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)
;;; Examples for setting the value of ido-ignore-files
;(setq ido-ignore-files '("^ " "\\.c$" "\\.h$"))
-(defcustom ido-default-file-method 'always-frame
- "*How to switch to new file when using `ido-find-file'.
+(defcustom ido-default-file-method 'raise-frame
+ "*How to visit a new file when using `ido-find-file'.
Possible values:
-`samewindow' Show new file in same window
-`otherwindow' Show new file in another window (same frame)
-`display' Display file in another window without switching to it
-`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
-`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)
- (const otherwindow)
- (const display)
- (const otherframe)
- (const maybe-frame)
- (const always-frame))
+`selected-window' Show new file in selected window
+`other-window' Show new file in another window (same frame)
+`display' Display file in another window without selecting to it
+`other-frame' 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
+`raise-frame' If a file is visible in another frame, raise that
+ frame; otherwise, visit the file in the same window"
+ :type '(choice (const :tag "Visit in selected window" selected-window)
+ (const :tag "Visit in other window" other-window)
+ (const :tag "Display (no select) in other window" display)
+ (const :tag "Visit in other frame" other-frame)
+ (const :tag "Ask to visit in other frame" maybe-frame)
+ (const :tag "Raise frame if already visited" raise-frame))
:group 'ido)
-(defcustom ido-default-buffer-method 'always-frame
+(defcustom ido-default-buffer-method 'raise-frame
"*How to switch to new buffer when using `ido-switch-buffer'.
See `ido-default-file-method' for details."
- :type '(choice (const samewindow)
- (const otherwindow)
+ :type '(choice (const :tag "Show in selected window" selected-window)
+ (const :tag "Show in other window" other-window)
+ (const :tag "Display (no select) in other window" display)
+ (const :tag "Show in other frame" other-frame)
+ (const :tag "Ask to show in other frame" maybe-frame)
+ (const :tag "Raise frame if already shown" raise-frame))
+ :type '(choice (const selected-window)
+ (const other-window)
(const display)
- (const otherframe)
+ (const other-frame)
(const maybe-frame)
- (const always-frame))
+ (const raise-frame))
:group 'ido)
(defcustom ido-enable-flex-matching nil
(defcustom ido-cache-ftp-work-directory-time 1.0
"*Maximum time to cache contents of an ftp directory (in hours).
+Use C-l in prompt to refresh list.
If zero, ftp directories are not cached."
:type 'number
:group 'ido)
:type '(repeat regexp)
:group 'ido)
+(defvar ido-unc-hosts-cache t
+ "Cached value from `ido-unc-hosts' function.")
+
+(defcustom ido-unc-hosts nil
+ "*List of known UNC host names to complete after initial //.
+If value is a function, that function is called to search network for
+hosts on first use of UNC path."
+ :type '(choice (repeat :tag "List of UNC host names" string)
+ (function-item :tag "Use `NET VIEW'"
+ :value ido-unc-hosts-net-view)
+ (function :tag "Your own function"))
+ :set #'(lambda (symbol value)
+ (set symbol value)
+ (setq ido-unc-hosts-cache t))
+ :group 'ido)
+
+(defcustom ido-downcase-unc-hosts t
+ "*Non-nil if UNC host names should be downcased."
+ :type 'boolean
+ :group 'ido)
+
+(defcustom ido-ignore-unc-host-regexps nil
+ "*List of regexps matching UNC hosts to ignore.
+Case is ignored if `ido-downcase-unc-hosts' is set."
+ :type '(repeat regexp)
+ :group 'ido)
+
+(defcustom ido-cache-unc-host-shares-time 8.0
+ "*Maximum time to cache shares of an UNC host (in hours).
+Use C-l in prompt to refresh list.
+If zero, UNC host shares are not cached."
+ :type 'number
+ :group 'ido)
+
(defcustom ido-max-work-file-list 10
"*Maximum number of names of recently opened files to record.
This is the list the file names (sans directory) which have most recently
-been opened. See `ido-work-file-list' and `ido-save-directory-list-file'."
+been opened. See `ido-work-file-list' and `ido-save-directory-list-file'."
:type 'integer
:group 'ido)
:group 'ido)
(defcustom ido-read-file-name-as-directory-commands '()
- "List of commands which uses read-file-name to read a directory name.
+ "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'."
:type '(repeat symbol)
"List of files currently matching `ido-text'.")
(defvar ido-report-no-match t
- "Report [No Match] when no completions matches ido-text.")
+ "Report [No Match] when no completions matches `ido-text'.")
(defvar ido-exit nil
"Flag to monitor how `ido-find-file' exits.
(pop-to-buffer b t t)
(setq truncate-lines t)))))
+(defun ido-unc-hosts (&optional query)
+ "Return list of UNC host names."
+ (let ((hosts
+ (cond
+ ((listp ido-unc-hosts)
+ ido-unc-hosts) ;; static list or nil
+ ((listp ido-unc-hosts-cache)
+ ido-unc-hosts-cache) ;; result of net search
+ ((and query (fboundp ido-unc-hosts))
+ (message (propertize "Searching for UNC hosts..." 'face 'highlight))
+ (setq ido-unc-hosts-cache (funcall ido-unc-hosts))
+ (message nil)
+ ido-unc-hosts-cache)
+ (query
+ (setq ido-unc-hosts-cache nil))
+ (t (fboundp ido-unc-hosts)))))
+ (when query
+ (let ((case-fold-search ido-downcase-unc-hosts)
+ res host re-list re)
+ (while hosts
+ (setq host (car hosts)
+ hosts (cdr hosts)
+ re-list (and ido-process-ignore-lists
+ ido-ignore-unc-host-regexps))
+ (while re-list
+ (setq re (car re-list)
+ re-list (cdr re-list))
+ (if (string-match re host)
+ (setq re-list nil
+ host nil)))
+ (when host
+ (when ido-downcase-unc-hosts
+ (setq host (downcase host)))
+ (setq res (cons host res))))
+ (setq hosts (sort res #'string<))))
+ hosts))
+
+(defun ido-unc-hosts-net-view ()
+ "Query network for list of UNC host names using `NET VIEW'."
+ (let (hosts)
+ (with-temp-buffer
+ (shell-command "net view" t)
+ (goto-char (point-min))
+ (while (re-search-forward "^\\\\\\\\\\([[:graph:]]+\\)" nil t)
+ (setq hosts (cons (match-string 1) hosts))))
+ hosts))
+
(defun ido-is-tramp-root (&optional dir)
(and ido-enable-tramp-completion
(string-match "\\`/[^/]+[@:]\\'"
(or dir ido-current-directory))))
+(defun ido-is-unc-root (&optional dir)
+ (and (ido-unc-hosts)
+ (string-equal "//"
+ (or dir ido-current-directory))))
+
+(defun ido-is-unc-host (&optional dir)
+ (and (ido-unc-hosts)
+ (string-match "\\`//[^/]+/\\'"
+ (or dir ido-current-directory))))
+
(defun ido-is-root-directory (&optional dir)
(setq dir (or dir ido-current-directory))
(or
(or (not time)
(< (- (ido-time-stamp) time) ido-cache-ftp-work-directory-time))))
+(defun ido-cache-unc-valid (&optional time)
+ (and (numberp ido-cache-unc-host-shares-time)
+ (> ido-cache-unc-host-shares-time 0)
+ (or (not time)
+ (< (- (ido-time-stamp) time) ido-cache-unc-host-shares-time))))
+
(defun ido-may-cache-directory (&optional dir)
(setq dir (or dir ido-current-directory))
(cond
(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)))
+ ((ido-is-unc-host dir)
+ (ido-cache-unc-valid))
+ ((ido-is-ftp-directory dir)
+ (ido-cache-ftp-valid))
+ (t t)))
(defun ido-pp (list &optional sep)
(let ((print-level nil) (eval-expression-print-level nil)
(ido-pp 'ido-work-directory-list)
(ido-pp 'ido-work-file-list)
(ido-pp 'ido-dir-file-cache "\n\n ")
+ (if (listp ido-unc-hosts-cache)
+ (ido-pp 'ido-unc-hosts-cache)
+ (insert "\n;; ----- ido-unc-hosts-cache -----\nt\n"))
(insert "\n")
(write-file ido-save-directory-list-file nil))
(kill-buffer buf)))))
(setq ido-last-directory-list (read (current-buffer))
ido-work-directory-list (read (current-buffer))
ido-work-file-list (read (current-buffer))
- ido-dir-file-cache (read (current-buffer)))
+ ido-dir-file-cache (read (current-buffer))
+ ido-unc-hosts-cache (read (current-buffer)))
(error nil)))
(kill-buffer buf)))))
(ido-wash-history))
(and
(stringp dir)
(consp time)
- (if (integerp (car time))
- (and (/= (car time) 0)
- (integerp (car (cdr time)))
- (/= (car (cdr time)) 0)
- (ido-may-cache-directory dir))
- (and (eq (car time) 'ftp)
- (numberp (cdr time))
+ (cond
+ ((integerp (car time))
+ (and (/= (car time) 0)
+ (integerp (car (cdr time)))
+ (/= (car (cdr time)) 0)
+ (ido-may-cache-directory dir)))
+ ((eq (car time) 'ftp)
+ (and (numberp (cdr time))
(ido-is-ftp-directory dir)
(ido-cache-ftp-valid (cdr time))))
+ ((eq (car time) 'unc)
+ (and (numberp (cdr time))
+ (ido-is-unc-host dir)
+ (ido-cache-unc-valid (cdr time))))
+ (t nil))
(let ((s files) (ok t))
(while s
(if (stringp (car s))
(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 [(meta ?\s)] 'ido-take-first-match)
(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 "\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 ?v)] 'ido-push-dir-first)
(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)
;; connect on incomplete tramp paths (after entring just method:).
(let ((ido-enable-tramp-completion nil))
(and (ido-final-slash dir)
+ (not (ido-is-unc-host dir))
(file-directory-p dir)
(not (file-readable-p dir)))))
(let ((ido-enable-tramp-completion nil))
(and (numberp ido-max-directory-size)
(ido-final-slash dir)
+ (not (ido-is-unc-host dir))
(file-directory-p dir)
(> (nth 7 (file-attributes dir)) ido-max-directory-size))))
(unless (and ido-enable-tramp-completion
(string-match "\\`/[^/]*@\\'" dir))
(setq dir (ido-final-slash dir t))))
- (if (equal dir ido-current-directory)
- nil
+ (if (get-buffer ido-completion-buffer)
+ (kill-buffer ido-completion-buffer))
+ (cond
+ ((equal dir ido-current-directory)
+ nil)
+ ((ido-is-unc-root dir)
+ (ido-trace "unc" dir)
+ (setq ido-current-directory dir)
+ (setq ido-directory-nonreadable nil)
+ (setq ido-directory-too-big nil)
+ t)
+ (t
(ido-trace "cd" dir)
(setq ido-current-directory dir)
(if (get-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))
+ t)))
(defun ido-set-current-home (&optional dir)
;; Set ido's current directory to user's home directory
;; the relevant function is called (find-file, write-file, etc).
(defun ido-read-internal (item prompt history &optional default require-match initial)
- "Perform the ido-read-buffer and ido-read-file-name functions.
+ "Perform the `ido-read-buffer' and `ido-read-file-name' functions.
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.
+DEFAULT if given is the default item to start with.
If REQUIRE-MATCH is non-nil, an existing file must be selected.
If INITIAL is non-nil, it specifies the initial input string."
(let
(cond
((eq item 'buffer)
(if (bufferp default) (buffer-name default) default))
- ((stringp default) default)
+ ((stringp default)
+ (if (memq item '(file dir))
+ (file-name-nondirectory 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))
+ (ido-trace "new default" ido-default-item)
(setq ido-set-default-item nil))
(if ido-process-ignore-lists-inhibit
(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)))
(cons (cons ido-current-directory ido-selected) ido-last-directory-list)))))
(ido-set-current-directory ido-current-directory ido-selected)
(if ido-input-stack
- (while ido-input-stack
- (let ((elt (car ido-input-stack)))
+ ; automatically pop stack elements which match existing files or directories
+ (let (elt)
+ (while (and (setq elt (car ido-input-stack))
+ (file-exists-p (concat ido-current-directory (cdr elt))))
(if (setq ido-input-stack (cdr ido-input-stack))
(ido-set-current-directory ido-current-directory (cdr elt))
(setq ido-text-init (cdr elt)))
(defun ido-edit-input ()
"Edit absolute file name entered so far with ido; terminate by RET."
(interactive)
- (setq ido-text-init ido-text)
+ (setq ido-text-init (if ido-matches (ido-name (car ido-matches)) ido-text))
(setq ido-exit 'edit)
(exit-minibuffer))
(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))
(unless filename
(setq ido-saved-vc-hb vc-handled-backends)
- (setq filename (ido-read-internal item
- (or prompt "Find file: ")
- 'ido-file-history nil nil initial)))
+ (let ((minibuffer-completing-file-name t))
+ (setq filename (ido-read-internal item
+ (or prompt "Find file: ")
+ 'ido-file-history nil nil initial))))
;; Choose the file name: either the text typed in, or the head
;; of the list of matches
(setq default-directory ido-current-directory)
(ido-record-command 'write-file (concat ido-current-directory filename))
(ido-record-work-directory)
- (write-file filename))
+ (write-file (concat ido-current-directory filename)))
((eq method 'read-only)
(ido-record-work-file filename)
((and (= 1 (length ido-matches))
(not (and ido-enable-tramp-completion
(string-equal ido-current-directory "/")
- (string-match "..[@:]\\'" (car ido-matches)))))
+ (string-match "..[@:]\\'" (ido-name (car ido-matches))))))
;; only one choice, so select it.
(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))))
+ (insert (ido-name (car ido-matches)))))
(t ;; else there could be some completions
(setq res ido-common-match-string)
(interactive)
(if (and ido-mode (eq ido-cur-item 'file))
(progn
- (ido-remove-cached-dir ido-current-directory)
+ (if (ido-is-unc-root)
+ (setq ido-unc-hosts-cache t)
+ (ido-remove-cached-dir ido-current-directory))
(setq ido-text-init ido-text)
(setq ido-rotate-temp t)
(setq ido-exit 'refresh)
(ido-delete-backward-word-updir 1)
(ido-wide-find-dir)))
+(defun ido-take-first-match ()
+ "Use first matching item as input text."
+ (interactive)
+ (when ido-matches
+ (setq ido-text-init (ido-name (car ido-matches)))
+ (setq ido-exit 'refresh)
+ (exit-minibuffer)))
+
(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-push-dir-first ()
+ "Move to previous directory in file name, push first match on stack."
+ (interactive)
+ (if ido-matches
+ (setq ido-text (ido-name (car ido-matches))))
+ (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."
"Insert file name of current buffer.
If repeated, insert text from buffer instead."
(interactive "P")
- (let* ((bfname (buffer-file-name ido-entry-buffer))
+ (let* ((bfname (or (buffer-file-name ido-entry-buffer)
+ (buffer-name ido-entry-buffer)))
(name (and bfname (file-name-nondirectory bfname))))
(when name
(setq ido-text-init
(if (or all
+ (eq last-command this-command)
(not (equal (file-name-directory bfname) ido-current-directory))
(not (string-match "\\.[^.]*\\'" name)))
name
(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)))
+ (cond
+ ((= oa ob)
+ lessp)
+ (lessp
+ (> oa ob))
+ (t
+ (< oa ob))))
(oa
(not lessp))
(ob
(let ((filenames
(split-string
(shell-command-to-string
- (concat "find " dir " -name \"" (if prefix "" "*") file "*\" -type " (if finddir "d" "f") " -print"))))
+ (concat "find "
+ (shell-quote-argument dir)
+ " -name "
+ (shell-quote-argument
+ (concat (if prefix "" "*") file "*"))
+ " -type " (if finddir "d" "f") " -print"))))
filename d f
res)
(while filenames
(defun ido-file-name-all-completions (dir)
;; Return name of all files in DIR
;; Uses and updates ido-dir-file-cache
- (if (and (numberp ido-max-dir-file-cache) (> ido-max-dir-file-cache 0)
- (stringp dir) (> (length dir) 0)
- (ido-may-cache-directory dir))
- (let* ((cached (assoc dir ido-dir-file-cache))
+ (cond
+ ((ido-is-unc-root dir)
+ (mapcar
+ (lambda (host)
+ (if (string-match "/\\'" host) host (concat host "/")))
+ (ido-unc-hosts t)))
+ ((and (numberp ido-max-dir-file-cache) (> ido-max-dir-file-cache 0)
+ (stringp dir) (> (length dir) 0)
+ (ido-may-cache-directory dir))
+ (let* ((cached (assoc dir ido-dir-file-cache))
(ctime (nth 1 cached))
(ftp (ido-is-ftp-directory dir))
- (attr (if ftp nil (file-attributes dir)))
+ (unc (ido-is-unc-host dir))
+ (attr (if (or ftp unc) nil (file-attributes dir)))
(mtime (nth 5 attr))
valid)
(when cached ; should we use the cached entry ?
- (if ftp
- (setq valid (and (eq (car ctime) 'ftp)
- (ido-cache-ftp-valid (cdr ctime))))
+ (cond
+ (ftp
+ (setq valid (and (eq (car ctime) 'ftp)
+ (ido-cache-ftp-valid (cdr ctime)))))
+ (unc
+ (setq valid (and (eq (car ctime) 'unc)
+ (ido-cache-unc-valid (cdr ctime)))))
+ (t
(if attr
(setq valid (and (= (car ctime) (car mtime))
- (= (car (cdr ctime)) (car (cdr mtime)))))))
- (if (not valid)
- (setq ido-dir-file-cache (delq cached ido-dir-file-cache)
- cached nil)))
+ (= (car (cdr ctime)) (car (cdr mtime))))))))
+ (unless valid
+ (setq ido-dir-file-cache (delq cached ido-dir-file-cache)
+ cached nil)))
(unless cached
- (if (and ftp (file-readable-p dir))
- (setq mtime (cons 'ftp (ido-time-stamp))))
+ (cond
+ (unc
+ (setq mtime (cons 'unc (ido-time-stamp))))
+ ((and ftp (file-readable-p dir))
+ (setq mtime (cons 'ftp (ido-time-stamp)))))
(if mtime
(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))))
- (ido-file-name-all-completions-1 dir)))
+ (cdr (cdr cached)))))
+ (t
+ (ido-file-name-all-completions-1 dir))))
(defun ido-remove-cached-dir (dir)
;; Remove dir from ido-dir-file-cache
(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 (or (ido-is-tramp-root dir) (file-directory-p dir))
+ (and (or (ido-is-tramp-root dir) (ido-is-unc-root dir)
+ (file-directory-p dir))
(delq nil
(mapcar
(lambda (name)
(let* ((case-fold-search ido-case-fold)
(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 ".*/" "")))
+ (rex0 (if ido-enable-regexp text (regexp-quote text)))
+ (rexq (concat rex0 (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 "\\'")))
+ (full-re (and do-full (not ido-enable-regexp) (not (string-match "\$\\'" rex0))
+ (concat "\\`" rex0 (if slash "/" "") "\\'")))
+ (suffix-re (and do-full slash
+ (not ido-enable-regexp) (not (string-match "\$\\'" rex0))
+ (concat rex0 "/\\'")))
(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)
+ full-matches suffix-matches prefix-matches matches)
(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)
+ (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 suffix-re (string-match suffix-re name))
+ (setq suffix-matches (cons item suffix-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
;; 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 (nconc full-matches matches)))
+ (when prefix-matches
+ (ido-trace "prefix match" prefix-matches)
+ (setq matches (nconc prefix-matches matches)))
+ (when suffix-matches
+ (ido-trace "suffix match" (list text suffix-re suffix-matches))
+ (setq matches (nconc suffix-matches matches)))
+ (when full-matches
+ (ido-trace "full match" (list text full-re full-matches))
+ (setq matches (nconc full-matches matches)))
(when (and (null matches)
ido-enable-flex-matching
(> (length ido-text) 1)
((stringp nextstr)
(and (>= flen (setq slen (length nextstr)))
(string-equal (substring name (- flen slen)) nextstr)))
- ((fboundp nextstr) (funcall nextstr name))
+ ((functionp nextstr) (funcall nextstr name))
(t nil))
(setq ignorep t
ext-list nil
(setq nextstr (car re-list))
(if (cond
((stringp nextstr) (string-match nextstr name))
- ((fboundp nextstr) (funcall nextstr name))
+ ((functionp nextstr) (funcall nextstr name))
(t nil))
(setq ignorep t
re-list nil)
"Kill the buffer at the head of `ido-matches'."
(interactive)
(let ((enable-recursive-minibuffers t)
- (buf (car ido-matches)))
+ (buf (ido-name (car ido-matches))))
(when buf
(kill-buffer buf)
;; Check if buffer still exists.
"Delete the file at the head of `ido-matches'."
(interactive)
(let ((enable-recursive-minibuffers t)
- (file (car ido-matches)))
+ (file (ido-name (car ido-matches))))
(if file
(setq file (concat ido-current-directory file)))
(when (and file
;;; VISIT CHOSEN BUFFER
(defun ido-visit-buffer (buffer method &optional record)
- "Visit file named FILE according to METHOD.
+ "Switch to BUFFER according to METHOD.
Record command in `command-history' if optional RECORD is non-nil."
-
+ (if (bufferp buffer)
+ (setq buffer (buffer-name buffer)))
(let (win newframe)
(cond
((eq method 'kill)
(ido-record-command 'kill-buffer buffer))
(kill-buffer buffer))
- ((eq method 'samewindow)
- (if record
- (ido-record-command 'switch-to-buffer buffer))
- (switch-to-buffer buffer))
-
- ((memq method '(always-frame maybe-frame))
- (cond
- ((and window-system
- (setq win (ido-window-buffer-p buffer))
- (or (eq method 'always-frame)
- (y-or-n-p "Jump to frame? ")))
- (setq newframe (window-frame win))
- (if (fboundp 'select-frame-set-input-focus)
- (select-frame-set-input-focus newframe)
- (raise-frame newframe)
- (select-frame newframe)
- (unless (featurep 'xemacs)
- (set-mouse-position (selected-frame) (1- (frame-width)) 0)))
- (select-window win))
- (t
- ;; No buffer in other frames...
- (if record
- (ido-record-command 'switch-to-buffer buffer))
- (switch-to-buffer buffer)
- )))
-
- ((eq method 'otherwindow)
+ ((eq method 'other-window)
(if record
(ido-record-command 'switch-to-buffer buffer))
(switch-to-buffer-other-window buffer))
((eq method 'display)
(display-buffer buffer))
- ((eq method 'otherframe)
+ ((eq method 'other-frame)
(switch-to-buffer-other-frame buffer)
- (unless (featurep 'xemacs)
- (select-frame-set-input-focus (selected-frame)))
+ (select-frame-set-input-focus (selected-frame)))
+
+ ((and (memq method '(raise-frame maybe-frame))
+ window-system
+ (setq win (ido-buffer-window-other-frame buffer))
+ (or (eq method 'raise-frame)
+ (y-or-n-p "Jump to frame? ")))
+ (setq newframe (window-frame win))
+ (select-frame-set-input-focus newframe)
+ (select-window win))
+
+ ;; (eq method 'selected-window)
+ (t
+ ;; No buffer in other frames...
+ (if record
+ (ido-record-command 'switch-to-buffer buffer))
+ (switch-to-buffer buffer)
))))
-(defun ido-window-buffer-p (buffer)
+(defun ido-buffer-window-other-frame (buffer)
;; Return window pointer if BUFFER is visible in another frame.
;; If BUFFER is visible in the current frame, return nil.
(let ((blist (ido-get-buffers-in-frames 'current)))
in another frame.
As you type in a string, all of the buffers matching the string are
-displayed if substring-matching is used \(default). Look at
+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-buffer-completion-map>
\\[ido-toggle-prefix] Toggle between substring and prefix matching.
\\[ido-toggle-case] Toggle case-sensitive searching of buffer names.
\\[ido-completion-help] Show list of matching buffers in separate window.
-\\[ido-enter-find-file] Drop into ido-find-file.
+\\[ido-enter-find-file] Drop into `ido-find-file'.
\\[ido-kill-buffer-at-head] Kill buffer at head of buffer list.
\\[ido-toggle-ignore] Toggle ignoring buffers listed in `ido-ignore-buffers'."
(interactive)
The buffer name is selected interactively by typing a substring.
For details of keybindings, do `\\[describe-function] ido'."
(interactive)
- (ido-buffer-internal 'otherwindow 'switch-to-buffer-other-window))
+ (ido-buffer-internal 'other-window 'switch-to-buffer-other-window))
;;;###autoload
(defun ido-display-buffer ()
For details of keybindings, do `\\[describe-function] ido'."
(interactive)
(if ido-mode
- (ido-buffer-internal 'otherframe)
+ (ido-buffer-internal 'other-frame)
(call-interactively 'switch-to-buffer-other-frame)))
;;;###autoload
The file name is selected interactively by typing a substring.
For details of keybindings, do `\\[describe-function] ido-find-file'."
(interactive)
- (ido-file-internal 'otherwindow 'find-file-other-window))
+ (ido-file-internal 'other-window 'find-file-other-window))
;;;###autoload
(defun ido-find-alternate-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 'otherframe 'find-file-other-frame))
+ (ido-file-internal 'other-frame 'find-file-other-frame))
;;;###autoload
(defun ido-write-file ()
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)
+ (when ido-trace-enable
+ (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))
)
((= (length contents) 1)
- (when (and (ido-is-tramp-root) (string-equal contents "/"))
+ (cond
+ ((and (ido-is-tramp-root) (string-equal contents "/"))
(ido-set-current-directory ido-current-directory contents)
(setq refresh t))
- )
+ ((and (ido-unc-hosts) (string-equal contents "/")
+ (let ((ido-enable-tramp-completion nil))
+ (ido-is-root-directory)))
+ (ido-set-current-directory "//")
+ (setq refresh t))
+ ))
((and (string-match (if ido-enable-tramp-completion "..[:@]\\'" "..:\\'") contents)
(ido-is-root-directory)) ;; Ange-ftp or tramp
((= (length contents) 2)
"/")
(ido-matches
- (concat ido-current-directory (car ido-matches)))
+ (concat ido-current-directory (ido-name (car ido-matches))))
(t
(concat ido-current-directory (substring contents 0 -1)))))
(setq ido-text-init (substring contents -1))
ido-matches
(or (eq ido-enter-matching-directory 'first)
(null (cdr ido-matches)))
- (ido-final-slash (car ido-matches))
+ (ido-final-slash (ido-name (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)))
+ (concat ido-current-directory (ido-name (car ido-matches))))
(setq ido-exit 'refresh)
(exit-minibuffer))
(ido-directory-too-big (and (not ido-directory-nonreadable)
(ido-directory-too-big-p ido-current-directory)))
(ido-work-directory-index -1)
+ (ido-show-dot-for-dired (and ido-show-dot-for-dired
+ (not default-filename)))
(ido-work-file-index -1)
(ido-find-literal nil))
(setq ido-exit nil)
HCoop / bpt / emacs.git / blobdiff