comparison lisp/ido.el @ 67362:ca155a6d12ad

(ido-completion-map): Renamed from ido-mode-map. (ido-common-completion-map, ido-file-completion-map) (ido-file-dir-completion-map, ido-buffer-completion-map): Renamed from ido-mode-....-map. (ido-init-completion-maps): Renamed from ido-init-mode-maps. (ido-setup-completion-map): Renamed from ido-define-mode-map. (ido-read-internal): Bind minibuffer-local-filename-completion-map to ido-completion-map.

67361:ffb9f78665a0

;; 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."
;;  (define-key ido-mode-map " " 'ido-next-match)
;;  )

;; Seeing all the matching buffers or files
;; ----------------------------------------
;;

(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.

;;; Internal Variables

;; Persistent variables

(defvar ido-mode-map nil
  "Currently active keymap for ido commands.")

(defvar ido-mode-common-map nil
  "Keymap for all ido commands.")

(defvar ido-mode-file-map nil
  "Keymap for ido file commands.")

(defvar ido-mode-file-dir-map nil
  "Keymap for ido file and directory commands.")

(defvar ido-mode-buffer-map nil
  "Keymap for ido buffer commands.")

(defvar  ido-file-history nil
  "History of files selected using `ido-find-file'.")

	 ((> (prefix-numeric-value arg) 0) 'both)
	 (t nil)))

  (ido-everywhere (if ido-everywhere 1 -1))
  (when ido-mode
    (ido-init-mode-maps))

  (when ido-mode
    (add-hook 'minibuffer-setup-hook 'ido-minibuffer-setup)
    (add-hook 'choose-completion-string-functions 'ido-choose-completion-string)
    (ido-load-history)

    (add-hook 'kill-emacs-hook 'ido-kill-emacs-hook)

    (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))

    (let ((map (cdr ido-minor-mode-map-entry)))
      (when (memq ido-mode '(file both))
	(define-key map [remap find-file] 'ido-find-file)
	(define-key map [remap find-file-read-only] 'ido-find-file-read-only)
	(define-key map [remap find-alternate-file] 'ido-find-alternate-file)
	(define-key map [remap write-file] 'ido-write-file)

	(define-key map [remap switch-to-buffer] 'ido-switch-buffer)
	(define-key map [remap switch-to-buffer-other-window] 'ido-switch-buffer-other-window)
	(define-key map [remap switch-to-buffer-other-frame] 'ido-switch-buffer-other-frame)
	(define-key map [remap insert-buffer] 'ido-insert-buffer)
	(define-key map [remap kill-buffer] 'ido-kill-buffer)
	(define-key map [remap display-buffer] 'ido-display-buffer)))))

(defun ido-everywhere (arg)
  "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")

      (put 'ido-everywhere 'buffer (cons read-buffer-function nil))
      (setq read-buffer-function 'ido-read-buffer))))


;;; IDO KEYMAP
(defun ido-init-mode-maps ()
  "Set up the keymaps used by `ido'."

  ;; Common map
  (let ((map (make-sparse-keymap)))
    (define-key map "\C-a" 'ido-toggle-ignore)
    (define-key map "\C-c" 'ido-toggle-case)

    ;; 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)
    (set-keymap-parent map minibuffer-local-map)
    (setq ido-mode-common-map map))

  ;; File and directory map
  (let ((map (make-sparse-keymap)))
    (define-key map "\C-x\C-b" 'ido-enter-switch-buffer)
    (define-key map "\C-x\C-f" 'ido-fallback-command)

    (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)
    (set-keymap-parent map ido-mode-common-map)
    (setq ido-mode-file-dir-map map))

  ;; File only map
  (let ((map (make-sparse-keymap)))
    (define-key map "\C-k" 'ido-delete-file-at-head)
    (define-key map "\C-o" 'ido-copy-current-word)
    (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)
    (set-keymap-parent map ido-mode-file-dir-map)
    (setq ido-mode-file-map map))

  ;; Buffer map
  (let ((map (make-sparse-keymap)))
    (define-key map "\C-x\C-f" 'ido-enter-find-file)
    (define-key map "\C-x\C-b" 'ido-fallback-command)
    (define-key map "\C-k" 'ido-kill-buffer-at-head)
    (set-keymap-parent map ido-mode-common-map)
    (setq ido-mode-buffer-map map)))


(defun ido-define-mode-map ()
  "Set up the keymap for `ido'."

  ;; generated every time so that it can inherit new functions.
  (let ((map (make-sparse-keymap))
	(viper-p (if (boundp 'viper-mode) viper-mode)))

	(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))
      (set-keymap-parent map
			 (if (eq ido-cur-item 'file)
			     ido-mode-file-map
			   ido-mode-file-dir-map)))

     ((eq ido-cur-item 'buffer)
      (when ido-context-switch-command
	(define-key map "\C-x\C-f" ido-context-switch-command))
      (set-keymap-parent map ido-mode-buffer-map))

     (t
      (set-keymap-parent map ido-mode-common-map)))

    (setq ido-mode-map map)))

(defun ido-final-slash (dir &optional fix-it)
  ;; return DIR if DIR has final slash.
  ;; else if FIX-IT is non-nil, return DIR/
  ;; else return nil.

       (ido-case-fold ido-case-fold)
       (ido-enable-prefix ido-enable-prefix)
       (ido-enable-regexp ido-enable-regexp)
       )

    (ido-define-mode-map)
    (setq ido-text-init initial)
    (setq ido-input-stack nil)

    (run-hooks 'ido-setup-hook)

      (ido-set-matches)
      (if (and ido-matches (eq ido-try-merged-list 'auto))
	  (setq ido-try-merged-list t))
      (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)))
	   (ido-completing-read t)
	   (ido-require-match require-match)
	   (ido-use-mycompletion-depth (1+ (minibuffer-depth)))

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-buffer-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-select-text] Select the current prompt as the buffer.

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-file-map>

RET Select the file at the front of the list of matches.  If the
list is empty, possibly prompt to create new file.

\\[ido-select-text] Select the current prompt as the buffer or file.

67362:ca155a6d12ad

;; 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."
;;  (define-key ido-completion-map " " 'ido-next-match)
;;  )

;; Seeing all the matching buffers or files
;; ----------------------------------------
;;

(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-completion-map'."
  :type 'hook
  :group 'ido)

(defcustom ido-separator nil
  "*String used by ido to separate the alternatives in the minibuffer.

;;; Internal Variables

;; Persistent variables

(defvar ido-completion-map nil
  "Currently active keymap for ido commands.")

(defvar ido-common-completion-map nil
  "Keymap for all ido commands.")

(defvar ido-file-completion-map nil
  "Keymap for ido file commands.")

(defvar ido-file-dir-completion-map nil
  "Keymap for ido file and directory commands.")

(defvar ido-buffer-completion-map nil
  "Keymap for ido buffer commands.")

(defvar  ido-file-history nil
  "History of files selected using `ido-find-file'.")

	 ((> (prefix-numeric-value arg) 0) 'both)
	 (t nil)))

  (ido-everywhere (if ido-everywhere 1 -1))
  (when ido-mode
    (ido-init-completion-maps))

  (when ido-mode
    (add-hook 'minibuffer-setup-hook 'ido-minibuffer-setup)
    (add-hook 'choose-completion-string-functions 'ido-choose-completion-string)
    (ido-load-history)

    (add-hook 'kill-emacs-hook 'ido-kill-emacs-hook)

    (let ((map (make-sparse-keymap)))
      (when (memq ido-mode '(file both))
	(define-key map [remap find-file] 'ido-find-file)
	(define-key map [remap find-file-read-only] 'ido-find-file-read-only)
	(define-key map [remap find-alternate-file] 'ido-find-alternate-file)
	(define-key map [remap write-file] 'ido-write-file)

	(define-key map [remap switch-to-buffer] 'ido-switch-buffer)
	(define-key map [remap switch-to-buffer-other-window] 'ido-switch-buffer-other-window)
	(define-key map [remap switch-to-buffer-other-frame] 'ido-switch-buffer-other-frame)
	(define-key map [remap insert-buffer] 'ido-insert-buffer)
	(define-key map [remap kill-buffer] 'ido-kill-buffer)
	(define-key map [remap display-buffer] 'ido-display-buffer))

      (if ido-minor-mode-map-entry
	  (setcdr ido-minor-mode-map-entry map)
	(setq ido-minor-mode-map-entry (cons 'ido-mode map))
	(add-to-list 'minor-mode-map-alist ido-minor-mode-map-entry)))))


(defun ido-everywhere (arg)
  "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")

      (put 'ido-everywhere 'buffer (cons read-buffer-function nil))
      (setq read-buffer-function 'ido-read-buffer))))


;;; IDO KEYMAP
(defun ido-init-completion-maps ()
  "Set up the completion keymaps used by `ido'."

  ;; Common map
  (let ((map (make-sparse-keymap)))
    (define-key map "\C-a" 'ido-toggle-ignore)
    (define-key map "\C-c" 'ido-toggle-case)

    ;; 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)
    (set-keymap-parent map minibuffer-local-map)
    (setq ido-common-completion-map map))

  ;; File and directory map
  (let ((map (make-sparse-keymap)))
    (define-key map "\C-x\C-b" 'ido-enter-switch-buffer)
    (define-key map "\C-x\C-f" 'ido-fallback-command)

    (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)
    (set-keymap-parent map ido-common-completion-map)
    (setq ido-file-dir-completion-map map))

  ;; File only map
  (let ((map (make-sparse-keymap)))
    (define-key map "\C-k" 'ido-delete-file-at-head)
    (define-key map "\C-o" 'ido-copy-current-word)
    (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)
    (set-keymap-parent map ido-file-dir-completion-map)
    (setq ido-file-completion-map map))

  ;; Buffer map
  (let ((map (make-sparse-keymap)))
    (define-key map "\C-x\C-f" 'ido-enter-find-file)
    (define-key map "\C-x\C-b" 'ido-fallback-command)
    (define-key map "\C-k" 'ido-kill-buffer-at-head)
    (set-keymap-parent map ido-common-completion-map)
    (setq ido-buffer-completion-map map)))


(defun ido-setup-completion-map ()
  "Set up the keymap for `ido'."

  ;; generated every time so that it can inherit new functions.
  (let ((map (make-sparse-keymap))
	(viper-p (if (boundp 'viper-mode) viper-mode)))

	(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))
      (set-keymap-parent map
			 (if (eq ido-cur-item 'file)
			     ido-file-completion-map
			   ido-file-dir-completion-map)))

     ((eq ido-cur-item 'buffer)
      (when ido-context-switch-command
	(define-key map "\C-x\C-f" ido-context-switch-command))
      (set-keymap-parent map ido-buffer-completion-map))

     (t
      (set-keymap-parent map ido-common-completion-map)))

    (setq ido-completion-map map)))

(defun ido-final-slash (dir &optional fix-it)
  ;; return DIR if DIR has final slash.
  ;; else if FIX-IT is non-nil, return DIR/
  ;; else return nil.

       (ido-case-fold ido-case-fold)
       (ido-enable-prefix ido-enable-prefix)
       (ido-enable-regexp ido-enable-regexp)
       )

    (ido-setup-completion-map)
    (setq ido-text-init initial)
    (setq ido-input-stack nil)

    (run-hooks 'ido-setup-hook)

      (ido-set-matches)
      (if (and ido-matches (eq ido-try-merged-list 'auto))
	  (setq ido-try-merged-list t))
      (let
	  ((minibuffer-local-completion-map ido-completion-map)
	   (minibuffer-local-filename-completion-map ido-completion-map)
	   (max-mini-window-height (or ido-max-window-height
				       (and (boundp 'max-mini-window-height) max-mini-window-height)))
	   (ido-completing-read t)
	   (ido-require-match require-match)
	   (ido-use-mycompletion-depth (1+ (minibuffer-depth)))

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-buffer-completion-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-select-text] Select the current prompt as the buffer.

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-file-completion-map>

RET Select the file at the front of the list of matches.  If the
list is empty, possibly prompt to create new file.

\\[ido-select-text] Select the current prompt as the buffer or file.