lisp/emulation/viper-keym.el

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