code.delx.au - gnu-emacs/blob - lisp/emulation/viper-keym.el

   1 ;;; viper-keym.el --- Viper keymaps
   2
   3 ;; Copyright (C) 1994, 95, 96, 97, 2000, 01, 02 Free Software Foundation, Inc.
   4
   5 ;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
   6
   7 ;; This file is part of GNU Emacs.
   8
   9 ;; GNU Emacs is free software; you can redistribute it and/or modify
  10 ;; it under the terms of the GNU General Public License as published by
  11 ;; the Free Software Foundation; either version 2, or (at your option)
  12 ;; any later version.
  13
  14 ;; GNU Emacs is distributed in the hope that it will be useful,
  15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 ;; GNU General Public License for more details.
  18
  19 ;; You should have received a copy of the GNU General Public License
  20 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  21 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22 ;; Boston, MA 02111-1307, USA.
  23
  24 ;;; Commentary:
  25
  26 ;;; Code:
  27
  28 (provide 'viper-keym)
  29
  30 ;; compiler pacifier
  31 (defvar viper-always)
  32 (defvar viper-current-state)
  33 (defvar viper-mode-string)
  34 (defvar viper-expert-level)
  35 (defvar viper-ex-style-editing)
  36 (defvar viper-ex-style-motion)
  37
  38 ;; loading happens only in non-interactive compilation
  39 ;; in order to spare non-viperized emacs from being viperized
  40 (if noninteractive
  41     (eval-when-compile
  42       (let ((load-path (cons (expand-file-name ".") load-path)))
  43         (or (featurep 'viper-util)
  44             (load "viper-util.el" nil nil 'nosuffix))
  45         )))
  46 ;; end pacifier
  47
  48 (require 'viper-util)
  49
  50
  51 ;;; Variables
  52
  53 (defvar viper-toggle-key "\C-z"
  54   "The key used to change states from emacs to Vi and back.
  55 In insert mode, this key also functions as Meta.
  56 Must be set in .viper file or prior to loading Viper.
  57 This setting cannot be changed interactively.")
  58
  59 (defvar viper-ESC-key "\e"
  60   "Key used to ESC.
  61 Must be set in .viper file or prior to loading Viper.
  62 This setting cannot be changed interactively.")
  63
  64 ;;; Emacs keys in other states.
  65
  66 (defcustom viper-want-emacs-keys-in-insert t
  67   "*Set to nil if you want complete Vi compatibility in insert mode.
  68 Complete compatibility with Vi is not recommended for power use of Viper."
  69   :type 'boolean
  70   :group 'viper)
  71
  72 (defcustom viper-want-emacs-keys-in-vi t
  73   "*Set to nil if you want complete Vi compatibility in Vi mode.
  74 Full Vi compatibility is not recommended for power use of Viper."
  75   :type 'boolean
  76   :group 'viper)
  77
  78 (defcustom viper-no-multiple-ESC  t
  79   "*If true, multiple ESC in Vi mode will cause bell to ring.
  80 This is set to t on a windowing terminal and to 'twice on a dumb
  81 terminal (unless the user level is 1, 2, or 5).  On a dumb terminal, this
  82 enables cursor keys and is generally more convenient, as terminals usually
  83 don't have a convenient Meta key.
  84 Setting viper-no-multiple-ESC to nil will allow as many multiple ESC,
  85 as is allowed by the major mode in effect."
  86   :type 'boolean
  87   :group 'viper)
  88
  89 (defcustom viper-want-ctl-h-help nil
  90   "*If non-nil, C-h gets bound to help-command; otherwise, C-h gets the usual Vi bindings."
  91   :type 'boolean
  92   :group 'viper)
  93
  94
  95 ;;; Keymaps
  96
  97 ;; Keymaps for vital things like \e and C-z.
  98 ;; Not for users
  99 (defvar viper-vi-intercept-map (make-sparse-keymap))
 100 (defvar viper-insert-intercept-map (make-sparse-keymap))
 101 (defvar viper-emacs-intercept-map (make-sparse-keymap))
 102
 103 ;; keymap used to zap all keymaps other than function-key-map,
 104 ;; device-function-key-map, etc.
 105 (defvar viper-overriding-map (make-sparse-keymap))
 106
 107 (viper-deflocalvar viper-vi-local-user-map (make-sparse-keymap)
 108   "Keymap for user-defined local bindings.
 109 Useful for changing bindings such as ZZ in certain major modes.
 110 For instance, in letter-mode, one may want to bind ZZ to
 111 mh-send-letter.  In a newsreader such as gnus, tin, or rn, ZZ could be bound
 112 to save-buffers-kill-emacs then post article, etc.")
 113 (put 'viper-vi-local-user-map 'permanent-local t)
 114
 115 (defvar viper-vi-global-user-map (make-sparse-keymap)
 116   "Keymap for user-defined global bindings.
 117 These bindings are seen in all Viper buffers.")
 118
 119 (defvar viper-vi-basic-map (make-keymap)
 120   "This is the main keymap in effect in Viper's Vi state.
 121 This map is global, shared by all buffers.")
 122
 123 (defvar  viper-vi-kbd-map (make-sparse-keymap)
 124   "This keymap keeps keyboard macros defined via the :map command.")
 125
 126 (defvar viper-vi-diehard-map (make-sparse-keymap)
 127   "This keymap is in use when the user asks Viper to simulate Vi very closely.
 128 This happens when viper-expert-level is 1 or 2.  See viper-set-expert-level.")
 129
 130
 131 (viper-deflocalvar viper-insert-local-user-map (make-sparse-keymap)
 132   "Auxiliary map for per-buffer user-defined keybindings in Insert state.")
 133 (put 'viper-insert-local-user-map 'permanent-local t)
 134
 135 (defvar viper-insert-global-user-map (make-sparse-keymap)
 136   "Auxiliary map for global user-defined bindings in Insert state.")
 137
 138 (defvar viper-insert-basic-map (make-sparse-keymap)
 139   "The basic insert-mode keymap.")
 140
 141 (defvar viper-insert-diehard-map (make-keymap)
 142   "Map used when user wants vi-style keys in insert mode.
 143 Most of the Emacs keys are suppressed.  This map overshadows
 144 viper-insert-basic-map.  Not recommended, except for novice users.")
 145
 146 (defvar  viper-insert-kbd-map  (make-sparse-keymap)
 147   "This keymap keeps VI-style kbd macros for insert mode.")
 148
 149 (defvar viper-replace-map (make-sparse-keymap)
 150   "Map used in Viper's replace state.")
 151
 152 (defvar viper-emacs-global-user-map (make-sparse-keymap)
 153   "Auxiliary map for global user-defined bindings in Emacs state.")
 154
 155 (defvar  viper-emacs-kbd-map  (make-sparse-keymap)
 156   "This keymap keeps Vi-style kbd macros for emacs mode.")
 157
 158 (viper-deflocalvar viper-emacs-local-user-map  (make-sparse-keymap)
 159   "Auxiliary map for local user-defined bindings in Emacs state.")
 160 (put 'viper-emacs-local-user-map 'permanent-local t)
 161
 162 ;; This keymap should stay empty
 163 (defvar viper-empty-keymap (make-sparse-keymap))
 164
 165 ;; This was the main Vi mode in old versions of VIP which may have been
 166 ;; extensively used by VIP users.  We declare it as a global var
 167 ;; and, after .viper is loaded, we add this keymap to viper-vi-basic-map.
 168 (defvar viper-mode-map (make-sparse-keymap))
 169
 170
 171 ;;; Variables used by minor modes
 172
 173 ;; Association list of the form
 174 ;; ((major-mode . keymap) (major-mode . keymap) ...)
 175 ;; Viper uses these keymaps to make user-requested adjustments
 176 ;; to its Vi state in various major modes.")
 177 (defvar viper-vi-state-modifier-alist nil)
 178
 179 ;; Association list of the form
 180 ;; ((major-mode . keymap) (major-mode . keymap) ...)
 181 ;; Viper uses these keymaps to make user-requested adjustments
 182 ;; to its Insert state in various major modes.")
 183 (defvar viper-insert-state-modifier-alist nil)
 184
 185 ;; Association list of the form
 186 ;; ((major-mode . keymap) (major-mode . keymap) ...)
 187 ;; Viper uses these keymaps to make user-requested adjustments
 188 ;; to its Emacs state in various major modes.
 189 (defvar viper-emacs-state-modifier-alist nil)
 190
 191 ;; Tells viper-add-local-keys to create a new viper-vi-local-user-map for new
 192 ;; buffers.  Not a user option.
 193 (viper-deflocalvar viper-need-new-vi-local-map t "")
 194 (put 'viper-need-new-vi-local-map  'permanent-local t)
 195
 196 ;; Tells viper-add-local-keys to create a new viper-insert-local-user-map for
 197 ;; new buffers.  Not a user option.
 198 (viper-deflocalvar viper-need-new-insert-local-map t "")
 199 (put 'viper-need-new-insert-local-map  'permanent-local t)
 200
 201 ;; Tells viper-add-local-keys to create a new viper-emacs-local-user-map for
 202 ;; new buffers.  Not a user option.
 203 (viper-deflocalvar viper-need-new-emacs-local-map t "")
 204 (put 'viper-need-new-emacs-local-map  'permanent-local t)
 205
 206
 207 \f
 208 ;; Insert mode keymap
 209
 210 ;; for novice users, pretend you are the real vi.
 211 (define-key viper-insert-diehard-map "\t"   'viper-insert-tab)
 212 (define-key viper-insert-diehard-map "\C-a" 'self-insert-command)
 213 (define-key viper-insert-diehard-map "\C-b" 'self-insert-command)
 214 (define-key viper-insert-diehard-map "\C-c" 'viper-change-state-to-vi)
 215 (define-key viper-insert-diehard-map "\C-e" 'self-insert-command)
 216 (define-key viper-insert-diehard-map "\C-f" 'self-insert-command)
 217 (define-key viper-insert-diehard-map "\C-g" 'self-insert-command)
 218 (define-key viper-insert-diehard-map "\C-i" 'self-insert-command)
 219 (define-key viper-insert-diehard-map "\C-k" 'self-insert-command)
 220 (define-key viper-insert-diehard-map "\C-l" 'self-insert-command)
 221 (define-key viper-insert-diehard-map "\C-n" 'self-insert-command)
 222 (define-key viper-insert-diehard-map "\C-o" 'self-insert-command)
 223 (define-key viper-insert-diehard-map "\C-p" 'self-insert-command)
 224 (define-key viper-insert-diehard-map "\C-q" 'self-insert-command)
 225 (define-key viper-insert-diehard-map "\C-r" 'self-insert-command)
 226 (define-key viper-insert-diehard-map "\C-s" 'self-insert-command)
 227 (define-key viper-insert-diehard-map "\C-u" 'viper-erase-line)
 228 (define-key viper-insert-diehard-map "\C-x" 'self-insert-command)
 229 (define-key viper-insert-diehard-map "\C-y" 'self-insert-command)
 230 (define-key viper-insert-diehard-map "\C-z" 'self-insert-command)
 231 (define-key viper-insert-diehard-map "\C-]" 'self-insert-command)
 232 (define-key viper-insert-diehard-map "\C-_" 'self-insert-command)
 233
 234 (let ((i ?\ ))
 235   (while (<= i ?~)
 236     (define-key viper-insert-diehard-map (make-string 1 i) 'self-insert-command)
 237     (setq i (1+ i))))
 238
 239 ;; Insert mode map when user wants emacs style
 240 (define-key viper-insert-basic-map "\C-d" 'viper-backward-indent)
 241 (define-key viper-insert-basic-map "\C-w" 'viper-delete-backward-word)
 242 (define-key viper-insert-basic-map "\C-t" 'viper-forward-indent)
 243 (define-key viper-insert-basic-map
 244   (if viper-xemacs-p [(shift tab)] [S-tab]) 'viper-insert-tab)
 245 (define-key viper-insert-basic-map "\C-v" 'quoted-insert)
 246 (define-key viper-insert-basic-map "\C-?" 'viper-del-backward-char-in-insert)
 247 (define-key viper-insert-basic-map [backspace] 'viper-del-backward-char-in-insert)
 248 (define-key viper-insert-basic-map "\C-\\" 'viper-alternate-Meta-key)
 249 (define-key viper-insert-basic-map viper-toggle-key 'viper-escape-to-vi)
 250 (define-key viper-insert-basic-map "\C-c\M-p"
 251   'viper-insert-prev-from-insertion-ring)
 252 (define-key viper-insert-basic-map "\C-c\M-n"
 253   'viper-insert-next-from-insertion-ring)
 254
 255
 256 ;; Replace keymap
 257 (define-key viper-replace-map "\C-t" 'viper-forward-indent)
 258 (define-key viper-replace-map "\C-j" 'viper-replace-state-carriage-return)
 259 (define-key viper-replace-map "\C-m" 'viper-replace-state-carriage-return)
 260 (define-key viper-replace-map "\C-?" 'viper-del-backward-char-in-replace)
 261 (define-key viper-replace-map [backspace] 'viper-del-backward-char-in-replace)
 262
 263
 264 \f
 265 ;; Vi keymaps
 266
 267 (define-key viper-vi-basic-map "\C-^" (lambda ()
 268                                         (interactive) (viper-ex nil "e#")))
 269 (define-key viper-vi-basic-map "\C-b" 'viper-scroll-screen-back)
 270 (define-key viper-vi-basic-map "\C-d" 'viper-scroll-up)
 271 (define-key viper-vi-basic-map "\C-e" 'viper-scroll-up-one)
 272 (define-key viper-vi-basic-map "\C-f" 'viper-scroll-screen)
 273 (define-key viper-vi-basic-map "\C-m" 'viper-next-line-at-bol)
 274 (define-key viper-vi-basic-map "\C-u" 'viper-scroll-down)
 275 (define-key viper-vi-basic-map "\C-y" 'viper-scroll-down-one)
 276 (define-key viper-vi-basic-map "\C-s" 'viper-isearch-forward)
 277 (define-key viper-vi-basic-map "\C-r" 'viper-isearch-backward)
 278 (define-key viper-vi-basic-map "\C-c/" 'viper-toggle-search-style)
 279 (define-key viper-vi-basic-map "\C-c\C-g" 'viper-info-on-file)
 280
 281 (define-key viper-vi-basic-map "\C-c\M-p" 'viper-prev-destructive-command)
 282 (define-key viper-vi-basic-map "\C-c\M-n" 'viper-next-destructive-command)
 283
 284
 285 (define-key viper-vi-basic-map " " 'viper-forward-char)
 286 (define-key viper-vi-basic-map "!" 'viper-command-argument)
 287 (define-key viper-vi-basic-map "\"" 'viper-command-argument)
 288 (define-key viper-vi-basic-map "#" 'viper-command-argument)
 289 (define-key viper-vi-basic-map "$" 'viper-goto-eol)
 290 (define-key viper-vi-basic-map "%" 'viper-paren-match)
 291 (define-key viper-vi-basic-map "&" (lambda ()
 292                                      (interactive) (viper-ex nil "&")))
 293 (define-key viper-vi-basic-map "'" 'viper-goto-mark-and-skip-white)
 294 (define-key viper-vi-basic-map "(" 'viper-backward-sentence)
 295 (define-key viper-vi-basic-map ")" 'viper-forward-sentence)
 296 (define-key viper-vi-basic-map "*" 'call-last-kbd-macro)
 297 (define-key viper-vi-basic-map "+" 'viper-next-line-at-bol)
 298 (define-key viper-vi-basic-map "," 'viper-repeat-find-opposite)
 299 (define-key viper-vi-basic-map "-" 'viper-previous-line-at-bol)
 300 (define-key viper-vi-basic-map "." 'viper-repeat)
 301 (define-key viper-vi-basic-map "/" 'viper-search-forward)
 302
 303 (define-key viper-vi-basic-map "0" 'viper-beginning-of-line)
 304 (define-key viper-vi-basic-map "1" 'viper-digit-argument)
 305 (define-key viper-vi-basic-map "2" 'viper-digit-argument)
 306 (define-key viper-vi-basic-map "3" 'viper-digit-argument)
 307 (define-key viper-vi-basic-map "4" 'viper-digit-argument)
 308 (define-key viper-vi-basic-map "5" 'viper-digit-argument)
 309 (define-key viper-vi-basic-map "6" 'viper-digit-argument)
 310 (define-key viper-vi-basic-map "7" 'viper-digit-argument)
 311 (define-key viper-vi-basic-map "8" 'viper-digit-argument)
 312 (define-key viper-vi-basic-map "9" 'viper-digit-argument)
 313
 314 (define-key viper-vi-basic-map ":" 'viper-ex)
 315 (define-key viper-vi-basic-map ";" 'viper-repeat-find)
 316 (define-key viper-vi-basic-map "<" 'viper-command-argument)
 317 (define-key viper-vi-basic-map "=" 'viper-command-argument)
 318 (define-key viper-vi-basic-map ">" 'viper-command-argument)
 319 (define-key viper-vi-basic-map "?" 'viper-search-backward)
 320 (define-key viper-vi-basic-map "@" 'viper-register-macro)
 321
 322 (define-key viper-vi-basic-map "A" 'viper-Append)
 323 (define-key viper-vi-basic-map "B" 'viper-backward-Word)
 324 (define-key viper-vi-basic-map "C" 'viper-change-to-eol)
 325 (define-key viper-vi-basic-map "D" 'viper-kill-line)
 326 (define-key viper-vi-basic-map "E" 'viper-end-of-Word)
 327 (define-key viper-vi-basic-map "F" 'viper-find-char-backward)
 328 (define-key viper-vi-basic-map "G" 'viper-goto-line)
 329 (define-key viper-vi-basic-map "H" 'viper-window-top)
 330 (define-key viper-vi-basic-map "I" 'viper-Insert)
 331 (define-key viper-vi-basic-map "J" 'viper-join-lines)
 332 (define-key viper-vi-basic-map "K" 'viper-nil)
 333 (define-key viper-vi-basic-map "L" 'viper-window-bottom)
 334 (define-key viper-vi-basic-map "M" 'viper-window-middle)
 335 (define-key viper-vi-basic-map "N" 'viper-search-Next)
 336 (define-key viper-vi-basic-map "O" 'viper-Open-line)
 337 (define-key viper-vi-basic-map "P" 'viper-Put-back)
 338 (define-key viper-vi-basic-map "Q" 'viper-query-replace)
 339 (define-key viper-vi-basic-map "R" 'viper-overwrite)
 340 (define-key viper-vi-basic-map "S" 'viper-substitute-line)
 341 (define-key viper-vi-basic-map "T" 'viper-goto-char-backward)
 342 (define-key viper-vi-basic-map "U" 'viper-undo)
 343 (define-key viper-vi-basic-map "V" 'find-file-other-window)
 344 (define-key viper-vi-basic-map "W" 'viper-forward-Word)
 345 (define-key viper-vi-basic-map "X" 'viper-delete-backward-char)
 346 (define-key viper-vi-basic-map "Y" 'viper-yank-line)
 347 (define-key viper-vi-basic-map "ZZ" 'viper-save-kill-buffer)
 348
 349 (define-key viper-vi-basic-map "\\" 'viper-escape-to-emacs)
 350 (define-key viper-vi-basic-map "[" 'viper-brac-function)
 351 (define-key viper-vi-basic-map "]" 'viper-ket-function)
 352 (define-key viper-vi-basic-map "\C-\\" 'viper-alternate-Meta-key)
 353 (define-key viper-vi-basic-map "^" 'viper-bol-and-skip-white)
 354 (define-key viper-vi-basic-map "`" 'viper-goto-mark)
 355
 356 (define-key viper-vi-basic-map "a" 'viper-append)
 357 (define-key viper-vi-basic-map "b" 'viper-backward-word)
 358 (define-key viper-vi-basic-map "c" 'viper-command-argument)
 359 (define-key viper-vi-basic-map "d" 'viper-command-argument)
 360 (define-key viper-vi-basic-map "e" 'viper-end-of-word)
 361 (define-key viper-vi-basic-map "f" 'viper-find-char-forward)
 362 (define-key viper-vi-basic-map "g" 'viper-nil)
 363 (define-key viper-vi-basic-map "h" 'viper-backward-char)
 364 (define-key viper-vi-basic-map [backspace] 'viper-backward-char)
 365 (define-key viper-vi-basic-map "i" 'viper-insert)
 366 (define-key viper-vi-basic-map "j" 'viper-next-line)
 367 (define-key viper-vi-basic-map "k" 'viper-previous-line)
 368 (define-key viper-vi-basic-map "l" 'viper-forward-char)
 369 (define-key viper-vi-basic-map "m" 'viper-mark-point)
 370 (define-key viper-vi-basic-map "n" 'viper-search-next)
 371 (define-key viper-vi-basic-map "o" 'viper-open-line)
 372 (define-key viper-vi-basic-map "p" 'viper-put-back)
 373 (define-key viper-vi-basic-map "q" 'viper-nil)
 374 (define-key viper-vi-basic-map "r" 'viper-replace-char)
 375 (define-key viper-vi-basic-map "s" 'viper-substitute)
 376 (define-key viper-vi-basic-map "t" 'viper-goto-char-forward)
 377 (define-key viper-vi-basic-map "u" 'viper-undo)
 378 (define-key viper-vi-basic-map "v" 'find-file)
 379 (define-key viper-vi-basic-map "\C-v" 'find-file-other-frame)
 380 (define-key viper-vi-basic-map "w" 'viper-forward-word)
 381 (define-key viper-vi-basic-map "x" 'viper-delete-char)
 382 (define-key viper-vi-basic-map "y" 'viper-command-argument)
 383 (define-key viper-vi-basic-map "zH" 'viper-line-to-top)
 384 (define-key viper-vi-basic-map "zM" 'viper-line-to-middle)
 385 (define-key viper-vi-basic-map "zL" 'viper-line-to-bottom)
 386 (define-key viper-vi-basic-map "z\C-m" 'viper-line-to-top)
 387 (define-key viper-vi-basic-map "z." 'viper-line-to-middle)
 388 (define-key viper-vi-basic-map "z-" 'viper-line-to-bottom)
 389
 390 (define-key viper-vi-basic-map "{" 'viper-backward-paragraph)
 391 (define-key viper-vi-basic-map "|" 'viper-goto-col)
 392 (define-key viper-vi-basic-map "}" 'viper-forward-paragraph)
 393 (define-key viper-vi-basic-map "~" 'viper-toggle-case)
 394 (define-key viper-vi-basic-map "\C-?" 'viper-backward-char)
 395 (define-key viper-vi-basic-map "_" 'viper-nil)
 396
 397 ;;; This is viper-vi-diehard-map.  Used when viper-vi-diehard-minor-mode is on.
 398
 399 (define-key viper-vi-diehard-map "\C-a" 'viper-nil)
 400 (define-key viper-vi-diehard-map "\C-c" 'viper-nil)
 401 (define-key viper-vi-diehard-map "\C-g" 'viper-info-on-file)
 402 (define-key viper-vi-diehard-map "\C-i" 'viper-nil)
 403 (define-key viper-vi-diehard-map "\C-k" 'viper-nil)
 404 (define-key viper-vi-diehard-map "\C-l" 'redraw-display)
 405 (define-key viper-vi-diehard-map "\C-n" 'viper-next-line)
 406 (define-key viper-vi-diehard-map "\C-o" 'viper-nil)
 407 (define-key viper-vi-diehard-map "\C-p" 'viper-previous-line)
 408 (define-key viper-vi-diehard-map "\C-q" 'viper-nil)
 409 (define-key viper-vi-diehard-map "\C-r" 'redraw-display)
 410 (define-key viper-vi-diehard-map "\C-s" 'viper-nil)
 411 (define-key viper-vi-diehard-map "\C-t" 'viper-nil)
 412 (define-key viper-vi-diehard-map "\C-v" 'viper-nil)
 413 (define-key viper-vi-diehard-map "\C-w" 'viper-nil)
 414 (define-key viper-vi-diehard-map "@" 'viper-nil)
 415 (define-key viper-vi-diehard-map "_" 'viper-nil)
 416 (define-key viper-vi-diehard-map "*" 'viper-nil)
 417 (define-key viper-vi-diehard-map "#" 'viper-nil)
 418 (define-key viper-vi-diehard-map "\C-_" 'viper-nil)
 419 (define-key viper-vi-diehard-map "\C-]" 'viper-nil) ; This is actually tags.
 420
 421 \f
 422 ;;; Minibuffer keymap
 423
 424
 425 (defvar viper-minibuffer-map (make-sparse-keymap)
 426   "Keymap used to modify keys when Minibuffer is in Insert state.")
 427
 428 (define-key viper-minibuffer-map "\C-m" 'viper-exit-minibuffer)
 429 (define-key viper-minibuffer-map "\C-j" 'viper-exit-minibuffer)
 430
 431 ;; Map used to read Ex-style commands.
 432 (defvar viper-ex-cmd-map (make-sparse-keymap))
 433 (define-key viper-ex-cmd-map " "  'ex-cmd-read-exit)
 434 (define-key viper-ex-cmd-map "\t" 'ex-cmd-complete)
 435
 436 ;; Keymap for reading file names in Ex-style commands.
 437 (defvar ex-read-filename-map (make-sparse-keymap))
 438 (define-key ex-read-filename-map " " 'viper-complete-filename-or-exit)
 439 (define-key ex-read-filename-map "!" 'viper-handle-!)
 440
 441 ;; Some other maps
 442 (defvar viper-slash-and-colon-map (make-sparse-keymap)
 443   "This map redefines `/' and `:' to behave as in Vi.
 444 Useful in some modes, such as Gnus, MH, etc.")
 445 (define-key viper-slash-and-colon-map ":" 'viper-ex)
 446 (define-key viper-slash-and-colon-map "/" 'viper-search-forward)
 447
 448 (defvar viper-comint-mode-modifier-map (make-sparse-keymap)
 449   "This map modifies comint mode.")
 450 (define-key viper-comint-mode-modifier-map "\C-m" 'viper-exec-key-in-emacs)
 451 (define-key viper-comint-mode-modifier-map "\C-d" 'viper-exec-key-in-emacs)
 452
 453 (defvar viper-dired-modifier-map (make-sparse-keymap)
 454   "This map modifies Dired behavior.")
 455 (define-key viper-dired-modifier-map ":" 'viper-ex)
 456 (define-key viper-dired-modifier-map "/" 'viper-search-forward)
 457
 458 (defvar viper-gnus-modifier-map (make-sparse-keymap)
 459   "This map modifies Gnus behavior.")
 460 (define-key viper-gnus-modifier-map ":" 'viper-ex)
 461
 462
 463 \f
 464 ;;; Code
 465
 466 (defun viper-add-local-keys (state alist)
 467   "Override some vi-state or insert-state bindings in the current buffer.
 468 The effect is seen in the current buffer only.
 469 Useful for customizing  mailer buffers, gnus, etc.
 470 STATE is 'vi-state, 'insert-state, or 'emacs-state
 471 ALIST is of the form ((key . func) (key . func) ...)
 472 Normally, this would be called from a hook to a major mode or
 473 on a per buffer basis.
 474 Usage:
 475       (viper-add-local-keys state '((key-str . func) (key-str . func)...))   "
 476
 477   (let (map)
 478     (cond ((eq state 'vi-state)
 479            (if viper-need-new-vi-local-map
 480                (setq viper-vi-local-user-map (make-sparse-keymap)))
 481            (setq viper-need-new-vi-local-map nil
 482                  map viper-vi-local-user-map))
 483           ((eq state 'insert-state)
 484            (if viper-need-new-insert-local-map
 485                (setq viper-insert-local-user-map (make-sparse-keymap)))
 486            (setq viper-need-new-insert-local-map nil
 487                  map viper-insert-local-user-map))
 488           ((eq state 'emacs-state)
 489            (if viper-need-new-emacs-local-map
 490                (setq viper-emacs-local-user-map (make-sparse-keymap)))
 491            (setq viper-need-new-emacs-local-map nil
 492                  map viper-emacs-local-user-map))
 493           (t
 494            (error
 495             "Invalid state in viper-add-local-keys: %S.  Valid states: vi-state, insert-state or emacs-state" state)))
 496
 497     (viper-modify-keymap map alist)
 498     (viper-normalize-minor-mode-map-alist)
 499     (viper-set-mode-vars-for viper-current-state)))
 500
 501 (defun viper-zap-local-keys ()
 502   "Unconditionally reset Viper viper-*-local-user-map's.
 503 Rarely useful, but if u made a mistake by switching to a mode that adds
 504 undesirable local keys, e.g., comint-mode, then this function can restore
 505 sanity."
 506   (interactive)
 507   (setq viper-vi-local-user-map (make-sparse-keymap)
 508         viper-need-new-vi-local-map nil
 509         viper-insert-local-user-map (make-sparse-keymap)
 510         viper-need-new-insert-local-map nil
 511         viper-emacs-local-user-map (make-sparse-keymap)
 512         viper-need-new-emacs-local-map nil)
 513   (viper-normalize-minor-mode-map-alist))
 514
 515
 516 (defun viper-modify-major-mode (mode state keymap)
 517   "Modify key bindings in a major-mode in a Viper state using a keymap.
 518
 519 If the default for a major mode is emacs-state, then modifications to this
 520 major mode may not take effect until the buffer switches state to Vi,
 521 Insert or Emacs.  If this happens, add viper-change-state-to-emacs to this
 522 major mode's hook.  If no such hook exists, you may have to put an advice on
 523 the function that invokes the major mode.  See viper-set-hooks for hints.
 524
 525 The above needs not to be done for major modes that come up in Vi or Insert
 526 state by default.
 527
 528 Arguments: (major-mode viper-state keymap)"
 529   (let ((alist
 530          (cond ((eq state 'vi-state) 'viper-vi-state-modifier-alist)
 531                ((eq state 'insert-state) 'viper-insert-state-modifier-alist)
 532                ((eq state 'emacs-state) 'viper-emacs-state-modifier-alist)))
 533         elt)
 534     (if (setq elt (assoc mode (eval alist)))
 535         (set alist (delq elt (eval alist))))
 536     (set alist (cons (cons mode keymap) (eval alist)))
 537
 538     ;; Normalization usually doesn't help here, since one needs to
 539     ;; normalize in the actual buffer where changes to the keymap are
 540     ;; to take place.  However, it doesn't hurt, and it helps whenever this
 541     ;; function is actually called from within the affected buffer.
 542     (viper-normalize-minor-mode-map-alist)
 543
 544     (viper-set-mode-vars-for viper-current-state)))
 545
 546
 547 ;; Displays variables that control Viper's keymaps
 548 (defun viper-debug-keymaps ()
 549   (interactive)
 550   (with-output-to-temp-buffer " *viper-debug*"
 551     (princ (format "Buffer name:  %s\n\n" (buffer-name)))
 552     (princ "Variables:  \n")
 553     (princ (format "major-mode:  %S\n" major-mode))
 554     (princ (format "viper-current-state:  %S\n" viper-current-state))
 555     (princ (format "viper-mode-string:  %S\n\n" viper-mode-string))
 556     (princ (format "viper-vi-intercept-minor-mode:  %S\n"
 557                    viper-vi-intercept-minor-mode))
 558     (princ (format "viper-insert-intercept-minor-mode:  %S\n"
 559                    viper-insert-intercept-minor-mode))
 560     (princ (format "viper-emacs-intercept-minor-mode:  %S\n"
 561                    viper-emacs-intercept-minor-mode))
 562     (princ (format "viper-vi-minibuffer-minor-mode:  %S\n"
 563                    viper-vi-minibuffer-minor-mode))
 564     (princ (format "viper-insert-minibuffer-minor-mode:  %S\n\n"
 565                    viper-insert-minibuffer-minor-mode))
 566     (princ (format "viper-vi-local-user-minor-mode:  %S\n"
 567                    viper-vi-local-user-minor-mode))
 568     (princ (format "viper-vi-global-user-minor-mode:  %S\n"
 569                    viper-vi-global-user-minor-mode))
 570     (princ (format "viper-vi-kbd-minor-mode:  %S\n" viper-vi-kbd-minor-mode))
 571     (princ (format "viper-vi-state-modifier-minor-mode:  %S\n"
 572                    viper-vi-state-modifier-minor-mode))
 573     (princ (format "viper-vi-diehard-minor-mode:  %S\n"
 574                    viper-vi-diehard-minor-mode))
 575     (princ (format "viper-vi-basic-minor-mode:  %S\n" viper-vi-basic-minor-mode))
 576     (princ (format "viper-replace-minor-mode:  %S\n" viper-replace-minor-mode))
 577     (princ (format "viper-insert-local-user-minor-mode:  %S\n"
 578                    viper-insert-local-user-minor-mode))
 579     (princ (format "viper-insert-global-user-minor-mode:  %S\n"
 580                    viper-insert-global-user-minor-mode))
 581     (princ (format "viper-insert-kbd-minor-mode:  %S\n"
 582                    viper-insert-kbd-minor-mode))
 583     (princ (format "viper-insert-state-modifier-minor-mode:  %S\n"
 584                    viper-insert-state-modifier-minor-mode))
 585     (princ (format "viper-insert-diehard-minor-mode:  %S\n"
 586                    viper-insert-diehard-minor-mode))
 587     (princ (format "viper-insert-basic-minor-mode:  %S\n"
 588                    viper-insert-basic-minor-mode))
 589     (princ (format "viper-emacs-local-user-minor-mode:  %S\n"
 590                    viper-emacs-local-user-minor-mode))
 591     (princ (format "viper-emacs-kbd-minor-mode:  %S\n"
 592                    viper-emacs-kbd-minor-mode))
 593     (princ (format "viper-emacs-global-user-minor-mode:  %S\n"
 594                    viper-emacs-global-user-minor-mode))
 595     (princ (format "viper-emacs-state-modifier-minor-mode:  %S\n"
 596                    viper-emacs-state-modifier-minor-mode))
 597
 598     (princ (format "\nviper-expert-level  %S\n" viper-expert-level))
 599     (princ (format "viper-no-multiple-ESC  %S\n" viper-no-multiple-ESC))
 600     (princ (format "viper-always  %S\n" viper-always))
 601     (princ (format "viper-ex-style-motion  %S\n"
 602                    viper-ex-style-motion))
 603     (princ (format "viper-ex-style-editing  %S\n"
 604                    viper-ex-style-editing))
 605     (princ (format "viper-want-emacs-keys-in-vi  %S\n"
 606                    viper-want-emacs-keys-in-vi))
 607     (princ (format "viper-want-emacs-keys-in-insert  %S\n"
 608                    viper-want-emacs-keys-in-insert))
 609     (princ (format "viper-want-ctl-h-help  %S\n" viper-want-ctl-h-help))
 610
 611     (princ "\n\n\n")
 612     (princ (format "Default value for minor-mode-map-alist:  \n%S\n\n"
 613                    (default-value 'minor-mode-map-alist)))
 614     (princ (format "Actual value for minor-mode-map-alist:  \n%S\n"
 615                    minor-mode-map-alist))
 616     ))
 617
 618
 619 ;;; Keymap utils
 620
 621 (defun viper-add-keymap (mapsrc mapdst)
 622   "Add contents of mapsrc to mapdst.  It is assumed that mapsrc is sparse."
 623   (viper-cond-compile-for-xemacs-or-emacs
 624    ;; xemacs
 625    (map-keymap (lambda (key binding) (define-key mapdst key binding))
 626                mapsrc)
 627    ;; emacs
 628    (mapcar (lambda (p) (define-key mapdst (vector (car p)) (cdr p)))
 629            (cdr mapsrc))
 630    ))
 631
 632 (defun viper-modify-keymap (map alist)
 633    "Modifies MAP with bindings specified in the ALIST.  The alist has the
 634 form ((key . function) (key . function) ... )."
 635    (mapcar (lambda (p) (define-key map (eval (car p)) (cdr p)))
 636            alist))
 637
 638
 639 ;;; Local Variables:
 640 ;;; eval: (put 'viper-deflocalvar 'lisp-indent-hook 'defun)
 641 ;;; End:
 642
 643
 644 ;;; arch-tag: 43af4b2f-0bea-400b-889e-221ebc00acb1
 645 ;;; viper-keym.el ends here