lisp/bindings.el

   1 ;;; bindings.el --- define standard key bindings and some variables
   2
   3 ;; Copyright (C) 1985-1987, 1992-1996, 1999-2012
   4 ;;   Free Software Foundation, Inc.
   5
   6 ;; Maintainer: FSF
   7 ;; Keywords: internal
   8 ;; Package: emacs
   9
  10 ;; This file is part of GNU Emacs.
  11
  12 ;; GNU Emacs is free software: you can redistribute it and/or modify
  13 ;; it under the terms of the GNU General Public License as published by
  14 ;; the Free Software Foundation, either version 3 of the License, or
  15 ;; (at your option) any later version.
  16
  17 ;; GNU Emacs is distributed in the hope that it will be useful,
  18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;; GNU General Public License for more details.
  21
  22 ;; You should have received a copy of the GNU General Public License
  23 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  24
  25 ;;; Commentary:
  26
  27 ;;; Code:
  28
  29 (defun make-mode-line-mouse-map (mouse function) "\
  30 Return a keymap with single entry for mouse key MOUSE on the mode line.
  31 MOUSE is defined to run function FUNCTION with no args in the buffer
  32 corresponding to the mode line clicked."
  33   (let ((map (make-sparse-keymap)))
  34     (define-key map (vector 'mode-line mouse) function)
  35     map))
  36
  37
  38 (defun mode-line-toggle-read-only (event)
  39   "Like `toggle-read-only', for the mode-line."
  40   (interactive "e")
  41   (with-selected-window (posn-window (event-start event))
  42     (read-only-mode 'toggle)))
  43
  44 (defun mode-line-toggle-modified (event)
  45   "Toggle the buffer-modified flag from the mode-line."
  46   (interactive "e")
  47   (with-selected-window (posn-window (event-start event))
  48     (set-buffer-modified-p (not (buffer-modified-p)))
  49     (force-mode-line-update)))
  50
  51 (defun mode-line-widen (event)
  52   "Widen a buffer from the mode-line."
  53   (interactive "e")
  54   (with-selected-window (posn-window (event-start event))
  55     (widen)
  56     (force-mode-line-update)))
  57
  58 (defvar mode-line-input-method-map
  59   (let ((map (make-sparse-keymap)))
  60     (define-key map [mode-line mouse-2]
  61       (lambda (e)
  62         (interactive "e")
  63         (with-selected-window (posn-window (event-start e))
  64           (toggle-input-method)
  65           (force-mode-line-update))))
  66     (define-key map [mode-line mouse-3]
  67       (lambda (e)
  68         (interactive "e")
  69         (with-selected-window (posn-window (event-start e))
  70           (describe-current-input-method))))
  71     (purecopy map)))
  72
  73 (defvar mode-line-coding-system-map
  74   (let ((map (make-sparse-keymap)))
  75     (define-key map [mode-line mouse-1]
  76       (lambda (e)
  77         (interactive "e")
  78         (with-selected-window (posn-window (event-start e))
  79           (when (and enable-multibyte-characters
  80                      buffer-file-coding-system)
  81             (describe-coding-system buffer-file-coding-system)))))
  82     (define-key map [mode-line mouse-3]
  83       (lambda (e)
  84         (interactive "e")
  85         (with-selected-window (posn-window (event-start e))
  86           (call-interactively 'set-buffer-file-coding-system))))
  87     (purecopy map))
  88   "Local keymap for the coding-system part of the mode line.")
  89
  90 (defun mode-line-change-eol (event)
  91   "Cycle through the various possible kinds of end-of-line styles."
  92   (interactive "e")
  93   (with-selected-window (posn-window (event-start event))
  94     (let ((eol (coding-system-eol-type buffer-file-coding-system)))
  95       (set-buffer-file-coding-system
  96        (cond ((eq eol 0) 'dos) ((eq eol 1) 'mac) (t 'unix))))))
  97
  98 (defvar mode-line-eol-desc-cache nil)
  99
 100 (defun mode-line-eol-desc ()
 101   (let* ((eol (coding-system-eol-type buffer-file-coding-system))
 102          (mnemonic (coding-system-eol-type-mnemonic buffer-file-coding-system))
 103          (desc (assoc eol mode-line-eol-desc-cache)))
 104     (if (and desc (eq (cadr desc) mnemonic))
 105         (cddr desc)
 106       (if desc (setq mode-line-eol-desc-cache nil)) ;Flush the cache if stale.
 107       (setq desc
 108             (propertize
 109              mnemonic
 110              'help-echo (format "End-of-line style: %s\nmouse-1: Cycle"
 111                                 (if (eq eol 0) "Unix-style LF"
 112                                   (if (eq eol 1) "DOS-style CRLF"
 113                                     (if (eq eol 2) "Mac-style CR"
 114                                       "Undecided"))))
 115              'keymap
 116              (eval-when-compile
 117                (let ((map (make-sparse-keymap)))
 118                  (define-key map [mode-line mouse-1] 'mode-line-change-eol)
 119                  map))
 120              'mouse-face 'mode-line-highlight))
 121       (push (cons eol (cons mnemonic desc)) mode-line-eol-desc-cache)
 122       desc)))
 123
 124 \f
 125 ;;; Mode line contents
 126
 127 (defcustom mode-line-default-help-echo
 128   "mouse-1: Select (drag to resize)\n\
 129 mouse-2: Make current window occupy the whole frame\n\
 130 mouse-3: Remove current window from display"
 131   "Default help text for the mode line.
 132 If the value is a string, it specifies the tooltip or echo area
 133 message to display when the mouse is moved over the mode line.
 134 If the text at the mouse position has a `help-echo' text
 135 property, that overrides this variable."
 136   :type '(choice (const :tag "No help" :value nil) string)
 137   :version "24.3"
 138   :group 'mode-line)
 139
 140 (defvar mode-line-front-space '(:eval (if (display-graphic-p) " " "-"))
 141   "Mode line construct to put at the front of the mode line.
 142 By default, this construct is displayed right at the beginning of
 143 the mode line, except that if there is a memory-full message, it
 144 is displayed first.")
 145 (put 'mode-line-front-space 'risky-local-variable t)
 146
 147 (defun mode-line-mule-info-help-echo (window _object _point)
 148   "Return help text specifying WINDOW's buffer coding system."
 149   (with-current-buffer (window-buffer window)
 150     (if buffer-file-coding-system
 151         (format "Buffer coding system (%s): %s
 152 mouse-1: Describe coding system
 153 mouse-3: Set coding system"
 154                 (if enable-multibyte-characters "multi-byte" "unibyte")
 155                 (symbol-name buffer-file-coding-system))
 156       "Buffer coding system: none specified")))
 157
 158 (defvar mode-line-mule-info
 159   `(""
 160     (current-input-method
 161      (:propertize ("" current-input-method-title)
 162                   help-echo (concat
 163                              ,(purecopy "Current input method: ")
 164                              current-input-method
 165                              ,(purecopy "\n\
 166 mouse-2: Disable input method\n\
 167 mouse-3: Describe current input method"))
 168                   local-map ,mode-line-input-method-map
 169                   mouse-face mode-line-highlight))
 170     ,(propertize
 171       "%z"
 172       'help-echo 'mode-line-mule-info-help-echo
 173       'mouse-face 'mode-line-highlight
 174       'local-map mode-line-coding-system-map)
 175     (:eval (mode-line-eol-desc)))
 176   "Mode line construct to report the multilingual environment.
 177 Normally it displays current input method (if any activated) and
 178 mnemonics of the following coding systems:
 179   coding system for saving or writing the current buffer
 180   coding system for keyboard input (on a text terminal)
 181   coding system for terminal output (on a text terminal)")
 182 ;;;###autoload
 183 (put 'mode-line-mule-info 'risky-local-variable t)
 184 (make-variable-buffer-local 'mode-line-mule-info)
 185
 186 (defvar mode-line-client
 187   `(""
 188     (:propertize ("" (:eval (if (frame-parameter nil 'client) "@" "")))
 189                  help-echo ,(purecopy "emacsclient frame")))
 190   "Mode line construct for identifying emacsclient frames.")
 191 ;;;###autoload
 192 (put 'mode-line-client 'risky-local-variable t)
 193
 194 (defun mode-line-read-only-help-echo (window _object _point)
 195   "Return help text specifying WINDOW's buffer read-only status."
 196   (format "Buffer is %s\nmouse-1: Toggle"
 197           (if (buffer-local-value 'buffer-read-only (window-buffer window))
 198               "read-only"
 199             "writable")))
 200
 201 (defun mode-line-modified-help-echo (window _object _point)
 202   "Return help text specifying WINDOW's buffer modification status."
 203   (format "Buffer is %smodified\nmouse-1: Toggle modification state"
 204           (if (buffer-modified-p (window-buffer window)) "" "not ")))
 205
 206 (defvar mode-line-modified
 207   (list (propertize
 208          "%1*"
 209          'help-echo 'mode-line-read-only-help-echo
 210          'local-map (purecopy (make-mode-line-mouse-map
 211                                'mouse-1
 212                                #'mode-line-toggle-read-only))
 213          'mouse-face 'mode-line-highlight)
 214         (propertize
 215          "%1+"
 216          'help-echo 'mode-line-modified-help-echo
 217          'local-map (purecopy (make-mode-line-mouse-map
 218                                'mouse-1 #'mode-line-toggle-modified))
 219          'mouse-face 'mode-line-highlight))
 220   "Mode line construct for displaying whether current buffer is modified.")
 221 ;;;###autoload
 222 (put 'mode-line-modified 'risky-local-variable t)
 223 (make-variable-buffer-local 'mode-line-modified)
 224
 225 (defvar mode-line-remote
 226   (list (propertize
 227          "%1@"
 228          'mouse-face 'mode-line-highlight
 229          'help-echo (purecopy (lambda (window _object _point)
 230                                 (format "%s"
 231                                         (with-selected-window window
 232                                           (concat
 233                                            (if (file-remote-p default-directory)
 234                                                "Current directory is remote: "
 235                                              "Current directory is local: ")
 236                                            default-directory)))))))
 237   "Mode line construct to indicate a remote buffer.")
 238 ;;;###autoload
 239 (put 'mode-line-remote 'risky-local-variable t)
 240 (make-variable-buffer-local 'mode-line-remote)
 241
 242 ;; MSDOS frames have window-system, but want the Fn identification.
 243 (defun mode-line-frame-control ()
 244   "Compute mode line construct for frame identification.
 245 Value is used for `mode-line-frame-identification', which see."
 246   (if (or (null window-system)
 247           (eq window-system 'pc))
 248       "-%F  "
 249     "  "))
 250
 251 ;; We need to defer the call to mode-line-frame-control to the time
 252 ;; the mode line is actually displayed.
 253 (defvar mode-line-frame-identification '(:eval (mode-line-frame-control))
 254   "Mode line construct to describe the current frame.")
 255 ;;;###autoload
 256 (put 'mode-line-frame-identification 'risky-local-variable t)
 257
 258 (defvar mode-line-process nil
 259   "Mode line construct for displaying info on process status.
 260 Normally nil in most modes, since there is no process to display.")
 261 ;;;###autoload
 262 (put 'mode-line-process 'risky-local-variable t)
 263 (make-variable-buffer-local 'mode-line-process)
 264
 265 (defun bindings--define-key (map key item)
 266   "Make as much as possible of the menus pure."
 267   (declare (indent 2))
 268   (define-key map key
 269     (cond
 270      ((not (consp item)) item)     ;Not sure that could be other than a symbol.
 271      ;; Keymaps can't be made pure otherwise users can't remove/add elements
 272      ;; from/to them any more.
 273      ((keymapp item) item)
 274      ((stringp (car item))
 275       (if (keymapp (cdr item))
 276           (cons (purecopy (car item)) (cdr item))
 277         (purecopy item)))
 278      ((eq 'menu-item (car item))
 279       (if (keymapp (nth 2 item))
 280           `(menu-item ,(purecopy (nth 1 item)) ,(nth 2 item)
 281                       ,@(purecopy (nthcdr 3 item)))
 282         (purecopy item)))
 283      (t (message "non-menu-item: %S" item) item))))
 284
 285 (defvar mode-line-mode-menu (make-sparse-keymap "Minor Modes") "\
 286 Menu of mode operations in the mode line.")
 287
 288 (defvar mode-line-major-mode-keymap
 289   (let ((map (make-sparse-keymap)))
 290     (bindings--define-key map [mode-line down-mouse-1]
 291       `(menu-item "Menu Bar" ignore
 292         :filter ,(lambda (_) (mouse-menu-major-mode-map))))
 293     (define-key map [mode-line mouse-2] 'describe-mode)
 294     (define-key map [mode-line down-mouse-3] mode-line-mode-menu)
 295     map) "\
 296 Keymap to display on major mode.")
 297
 298 (defvar mode-line-minor-mode-keymap
 299   (let ((map (make-sparse-keymap)))
 300     (define-key map [mode-line down-mouse-1] 'mouse-minor-mode-menu)
 301     (define-key map [mode-line mouse-2] 'mode-line-minor-mode-help)
 302     (define-key map [mode-line down-mouse-3] mode-line-mode-menu)
 303     (define-key map [header-line down-mouse-3] mode-line-mode-menu)
 304     map) "\
 305 Keymap to display on minor modes.")
 306
 307 (defvar mode-line-modes
 308   (let ((recursive-edit-help-echo "Recursive edit, type C-M-c to get out"))
 309     (list (propertize "%[" 'help-echo recursive-edit-help-echo)
 310           "("
 311           `(:propertize ("" mode-name)
 312                         help-echo "Major mode\n\
 313 mouse-1: Display major mode menu\n\
 314 mouse-2: Show help for major mode\n\
 315 mouse-3: Toggle minor modes"
 316                         mouse-face mode-line-highlight
 317                         local-map ,mode-line-major-mode-keymap)
 318           '("" mode-line-process)
 319           `(:propertize ("" minor-mode-alist)
 320                         mouse-face mode-line-highlight
 321                         help-echo "Minor mode\n\
 322 mouse-1: Display minor mode menu\n\
 323 mouse-2: Show help for minor mode\n\
 324 mouse-3: Toggle minor modes"
 325                         local-map ,mode-line-minor-mode-keymap)
 326           (propertize "%n" 'help-echo "mouse-2: Remove narrowing from buffer"
 327                       'mouse-face 'mode-line-highlight
 328                       'local-map (make-mode-line-mouse-map
 329                                   'mouse-2 #'mode-line-widen))
 330           ")"
 331           (propertize "%]" 'help-echo recursive-edit-help-echo)
 332           " "))
 333   "Mode line construct for displaying major and minor modes.")
 334 (put 'mode-line-modes 'risky-local-variable t)
 335
 336 (defvar mode-line-column-line-number-mode-map
 337   (let ((map (make-sparse-keymap))
 338         (menu-map (make-sparse-keymap "Toggle Line and Column Number Display")))
 339     (bindings--define-key menu-map [line-number-mode]
 340       '(menu-item "Display Line Numbers" line-number-mode
 341                   :help "Toggle displaying line numbers in the mode-line"
 342                   :button (:toggle . line-number-mode)))
 343     (bindings--define-key menu-map [column-number-mode]
 344       '(menu-item "Display Column Numbers" column-number-mode
 345                   :help "Toggle displaying column numbers in the mode-line"
 346                   :button (:toggle . column-number-mode)))
 347     (define-key map [mode-line down-mouse-1] menu-map)
 348     map) "\
 349 Keymap to display on column and line numbers.")
 350
 351 (defvar mode-line-position
 352   `((-3 ,(propertize
 353           "%p"
 354           'local-map mode-line-column-line-number-mode-map
 355           'mouse-face 'mode-line-highlight
 356           ;; XXX needs better description
 357           'help-echo "Size indication mode\n\
 358 mouse-1: Display Line and Column Mode Menu"))
 359     (size-indication-mode
 360      (8 ,(propertize
 361           " of %I"
 362           'local-map mode-line-column-line-number-mode-map
 363           'mouse-face 'mode-line-highlight
 364           ;; XXX needs better description
 365           'help-echo "Size indication mode\n\
 366 mouse-1: Display Line and Column Mode Menu")))
 367     (line-number-mode
 368      ((column-number-mode
 369        (10 ,(propertize
 370              " (%l,%c)"
 371              'local-map mode-line-column-line-number-mode-map
 372              'mouse-face 'mode-line-highlight
 373              'help-echo "Line number and Column number\n\
 374 mouse-1: Display Line and Column Mode Menu"))
 375        (6 ,(propertize
 376             " L%l"
 377             'local-map mode-line-column-line-number-mode-map
 378             'mouse-face 'mode-line-highlight
 379             'help-echo "Line Number\n\
 380 mouse-1: Display Line and Column Mode Menu"))))
 381      ((column-number-mode
 382        (5 ,(propertize
 383             " C%c"
 384             'local-map mode-line-column-line-number-mode-map
 385             'mouse-face 'mode-line-highlight
 386             'help-echo "Column number\n\
 387 mouse-1: Display Line and Column Mode Menu"))))))
 388   "Mode line construct for displaying the position in the buffer.
 389 Normally displays the buffer percentage and, optionally, the
 390 buffer size, the line number and the column number.")
 391 (put 'mode-line-position 'risky-local-variable t)
 392
 393 (defvar mode-line-buffer-identification-keymap
 394   ;; Add menu of buffer operations to the buffer identification part
 395   ;; of the mode line.or header line.
 396   (let ((map (make-sparse-keymap)))
 397     ;; Bind down- events so that the global keymap won't ``shine
 398     ;; through''.
 399     (define-key map [mode-line mouse-1] 'mode-line-previous-buffer)
 400     (define-key map [header-line down-mouse-1] 'ignore)
 401     (define-key map [header-line mouse-1] 'mode-line-previous-buffer)
 402     (define-key map [mode-line mouse-3] 'mode-line-next-buffer)
 403     (define-key map [header-line down-mouse-3] 'ignore)
 404     (define-key map [header-line mouse-3] 'mode-line-next-buffer)
 405     map) "\
 406 Keymap for what is displayed by `mode-line-buffer-identification'.")
 407
 408 (defun propertized-buffer-identification (fmt)
 409   "Return a list suitable for `mode-line-buffer-identification'.
 410 FMT is a format specifier such as \"%12b\".  This function adds
 411 text properties for face, help-echo, and local-map to it."
 412   (list (propertize fmt
 413                     'face 'mode-line-buffer-id
 414                     'help-echo
 415                     (purecopy "Buffer name
 416 mouse-1: Previous buffer\nmouse-3: Next buffer")
 417                     'mouse-face 'mode-line-highlight
 418                     'local-map mode-line-buffer-identification-keymap)))
 419
 420 (defvar mode-line-buffer-identification
 421   (propertized-buffer-identification "%12b")
 422   "Mode line construct for identifying the buffer being displayed.
 423 Its default value is (\"%12b\") with some text properties added.
 424 Major modes that edit things other than ordinary files may change this
 425 \(e.g. Info, Dired,...)")
 426 ;;;###autoload
 427 (put 'mode-line-buffer-identification 'risky-local-variable t)
 428 (make-variable-buffer-local 'mode-line-buffer-identification)
 429
 430 (defvar mode-line-misc-info
 431   '((which-func-mode ("" which-func-format " "))
 432     (global-mode-string ("" global-mode-string " ")))
 433   "Mode line construct for miscellaneous information.
 434 By default, this shows the information specified by
 435 `which-func-mode' and `global-mode-string'.")
 436 (put 'mode-line-misc-info 'risky-local-variable t)
 437
 438 (defvar mode-line-end-spaces '(:eval (unless (display-graphic-p) "-%-"))
 439   "Mode line construct to put at the end of the mode line.")
 440 (put 'mode-line-end-spaces 'risky-local-variable t)
 441
 442 ;; Default value of the top-level `mode-line-format' variable:
 443 (let ((standard-mode-line-format
 444        (list "%e"
 445              'mode-line-front-space
 446              'mode-line-mule-info
 447              'mode-line-client
 448              'mode-line-modified
 449              'mode-line-remote
 450              'mode-line-frame-identification
 451              'mode-line-buffer-identification
 452              "   "
 453              'mode-line-position
 454              '(vc-mode vc-mode)
 455              "  "
 456              'mode-line-modes
 457              'mode-line-misc-info
 458              'mode-line-end-spaces)))
 459   (setq-default mode-line-format standard-mode-line-format)
 460   (put 'mode-line-format 'standard-value
 461        (list `(quote ,standard-mode-line-format))))
 462
 463 \f
 464 (defun mode-line-unbury-buffer (event) "\
 465 Call `unbury-buffer' in this window."
 466   (interactive "e")
 467   (with-selected-window (posn-window (event-start event))
 468     (unbury-buffer)))
 469
 470 (defun mode-line-bury-buffer (event) "\
 471 Like `bury-buffer', but temporarily select EVENT's window."
 472   (interactive "e")
 473   (with-selected-window (posn-window (event-start event))
 474     (bury-buffer)))
 475
 476 (defun mode-line-other-buffer () "\
 477 Switch to the most recently selected buffer other than the current one."
 478   (interactive)
 479   (switch-to-buffer (other-buffer) nil t))
 480
 481 (defun mode-line-next-buffer (event)
 482   "Like `next-buffer', but temporarily select EVENT's window."
 483   (interactive "e")
 484   (with-selected-window (posn-window (event-start event))
 485     (next-buffer)))
 486
 487 (defun mode-line-previous-buffer (event)
 488   "Like `previous-buffer', but temporarily select EVENT's window."
 489   (interactive "e")
 490   (with-selected-window (posn-window (event-start event))
 491     (previous-buffer)))
 492
 493 (defmacro bound-and-true-p (var)
 494   "Return the value of symbol VAR if it is bound, else nil."
 495   `(and (boundp (quote ,var)) ,var))
 496
 497 ;; Use mode-line-mode-menu for local minor-modes only.
 498 ;; Global ones can go on the menubar (Options --> Show/Hide).
 499 (bindings--define-key mode-line-mode-menu [overwrite-mode]
 500   '(menu-item "Overwrite (Ovwrt)" overwrite-mode
 501               :help "Overwrite mode: typed characters replace existing text"
 502               :button (:toggle . overwrite-mode)))
 503 (bindings--define-key mode-line-mode-menu [outline-minor-mode]
 504   '(menu-item "Outline (Outl)" outline-minor-mode
 505               ;; XXX: This needs a good, brief description.
 506               :help ""
 507               :button (:toggle . (bound-and-true-p outline-minor-mode))))
 508 (bindings--define-key mode-line-mode-menu [highlight-changes-mode]
 509   '(menu-item "Highlight changes (Chg)" highlight-changes-mode
 510               :help "Show changes in the buffer in a distinctive color"
 511               :button (:toggle . (bound-and-true-p highlight-changes-mode))))
 512 (bindings--define-key mode-line-mode-menu [hide-ifdef-mode]
 513   '(menu-item "Hide ifdef (Ifdef)" hide-ifdef-mode
 514               :help "Show/Hide code within #ifdef constructs"
 515               :button (:toggle . (bound-and-true-p hide-ifdef-mode))))
 516 (bindings--define-key mode-line-mode-menu [glasses-mode]
 517   '(menu-item "Glasses (o^o)" glasses-mode
 518               :help "Insert virtual separators to make long identifiers easy to read"
 519               :button (:toggle . (bound-and-true-p glasses-mode))))
 520 (bindings--define-key mode-line-mode-menu [font-lock-mode]
 521   '(menu-item "Font Lock" font-lock-mode
 522               :help "Syntax coloring"
 523               :button (:toggle . font-lock-mode)))
 524 (bindings--define-key mode-line-mode-menu [flyspell-mode]
 525   '(menu-item "Flyspell (Fly)" flyspell-mode
 526               :help "Spell checking on the fly"
 527               :button (:toggle . (bound-and-true-p flyspell-mode))))
 528 (bindings--define-key mode-line-mode-menu [auto-revert-tail-mode]
 529   '(menu-item "Auto revert tail (Tail)" auto-revert-tail-mode
 530               :help "Revert the tail of the buffer when buffer grows"
 531               :enable (buffer-file-name)
 532               :button (:toggle . (bound-and-true-p auto-revert-tail-mode))))
 533 (bindings--define-key mode-line-mode-menu [auto-revert-mode]
 534   '(menu-item "Auto revert (ARev)" auto-revert-mode
 535               :help "Revert the buffer when the file on disk changes"
 536               :button (:toggle . (bound-and-true-p auto-revert-mode))))
 537 (bindings--define-key mode-line-mode-menu [auto-fill-mode]
 538   '(menu-item "Auto fill (Fill)" auto-fill-mode
 539               :help "Automatically insert new lines"
 540               :button (:toggle . auto-fill-function)))
 541 (bindings--define-key mode-line-mode-menu [abbrev-mode]
 542   '(menu-item "Abbrev (Abbrev)" abbrev-mode
 543               :help "Automatically expand abbreviations"
 544               :button (:toggle . abbrev-mode)))
 545
 546 (defun mode-line-minor-mode-help (event)
 547   "Describe minor mode for EVENT on minor modes area of the mode line."
 548   (interactive "@e")
 549   (let ((indicator (car (nth 4 (car (cdr event))))))
 550     (describe-minor-mode-from-indicator indicator)))
 551
 552 (defvar minor-mode-alist nil "\
 553 Alist saying how to show minor modes in the mode line.
 554 Each element looks like (VARIABLE STRING);
 555 STRING is included in the mode line if VARIABLE's value is non-nil.
 556
 557 Actually, STRING need not be a string; any mode-line construct is
 558 okay.  See `mode-line-format'.")
 559 ;;;###autoload
 560 (put 'minor-mode-alist 'risky-local-variable t)
 561 ;; Don't use purecopy here--some people want to change these strings.
 562 (setq minor-mode-alist
 563       '((abbrev-mode " Abbrev")
 564         (overwrite-mode overwrite-mode)
 565         (auto-fill-function " Fill")
 566         ;; not really a minor mode...
 567         (defining-kbd-macro " Def")))
 568
 569 ;; These variables are used by autoloadable packages.
 570 ;; They are defined here so that they do not get overridden
 571 ;; by the loading of those packages.
 572
 573 ;; Names in directory that end in one of these
 574 ;; are ignored in completion,
 575 ;; making it more likely you will get a unique match.
 576 (setq completion-ignored-extensions
 577       (append
 578        (cond ((memq system-type '(ms-dos windows-nt))
 579               (mapcar 'purecopy
 580               '(".o" "~" ".bin" ".bak" ".obj" ".map" ".ico" ".pif" ".lnk"
 581                 ".a" ".ln" ".blg" ".bbl" ".dll" ".drv" ".vxd" ".386")))
 582              (t
 583               (mapcar 'purecopy
 584               '(".o" "~" ".bin" ".lbin" ".so"
 585                 ".a" ".ln" ".blg" ".bbl"))))
 586        (mapcar 'purecopy
 587        '(".elc" ".lof"
 588          ".glo" ".idx" ".lot"
 589          ;; VCS metadata directories
 590          ".svn/" ".hg/" ".git/" ".bzr/" "CVS/" "_darcs/" "_MTN/"
 591          ;; TeX-related
 592          ".fmt" ".tfm"
 593          ;; Java compiled
 594          ".class"
 595          ;; CLISP
 596          ".fas" ".lib" ".mem"
 597          ;; CMUCL
 598          ".x86f" ".sparcf"
 599          ;; OpenMCL / Clozure CL
 600          ".dfsl" ".pfsl" ".d64fsl" ".p64fsl" ".lx64fsl" ".lx32fsl"
 601          ".dx64fsl" ".dx32fsl" ".fx64fsl" ".fx32fsl" ".sx64fsl"
 602          ".sx32fsl" ".wx64fsl" ".wx32fsl"
 603          ;; Other CL implementations (Allegro, LispWorks)
 604          ".fasl" ".ufsl" ".fsl" ".dxl"
 605          ;; Libtool
 606          ".lo" ".la"
 607          ;; Gettext
 608          ".gmo" ".mo"
 609          ;; Texinfo-related
 610          ;; This used to contain .log, but that's commonly used for log
 611          ;; files you do want to see, not just TeX stuff.  -- fx
 612          ".toc" ".aux"
 613          ".cp" ".fn" ".ky" ".pg" ".tp" ".vr"
 614          ".cps" ".fns" ".kys" ".pgs" ".tps" ".vrs"
 615          ;; Python byte-compiled
 616          ".pyc" ".pyo"))))
 617
 618 ;; Suffixes used for executables.
 619 (setq exec-suffixes
 620       (cond
 621        ((memq system-type '(ms-dos windows-nt))
 622         '(".exe" ".com" ".bat" ".cmd" ".btm" ""))
 623        (t
 624         '(""))))
 625
 626 ;; Packages should add to this list appropriately when they are
 627 ;; loaded, rather than listing everything here.
 628 (setq debug-ignored-errors
 629       ;; FIXME: Maybe beginning-of-line, beginning-of-buffer, end-of-line,
 630       ;; end-of-buffer, end-of-file, buffer-read-only, and
 631       ;; file-supersession should all be user-errors!
 632       `(beginning-of-line beginning-of-buffer end-of-line
 633         end-of-buffer end-of-file buffer-read-only
 634         file-supersession
 635         user-error ;; That's the main one!
 636         ))
 637
 638 (make-variable-buffer-local 'indent-tabs-mode)
 639
 640 ;; These per-buffer variables are never reset by
 641 ;; `kill-all-local-variables', because they have no default value.
 642 ;; For consistency, we give them the `permanent-local' property, even
 643 ;; though `kill-all-local-variables' does not actually consult it.
 644
 645 (mapc (lambda (sym) (put sym 'permanent-local t))
 646       '(buffer-file-name default-directory buffer-backed-up
 647         buffer-saved-size buffer-auto-save-file-name
 648         buffer-read-only buffer-undo-list mark-active
 649         point-before-scroll buffer-file-truename
 650         buffer-file-format buffer-auto-save-file-format
 651         buffer-display-count buffer-display-time
 652         enable-multibyte-characters))
 653
 654 ;; We have base64, md5 and sha1 functions built in now.
 655 (provide 'base64)
 656 (provide 'md5)
 657 (provide 'sha1)
 658 (provide 'overlay '(display syntax-table field))
 659 (provide 'text-properties '(display syntax-table field point-entered))
 660
 661 (define-key esc-map "\t" 'complete-symbol)
 662
 663 (defun complete-symbol (arg)
 664   "Perform completion on the text around point.
 665 The completion method is determined by `completion-at-point-functions'.
 666
 667 With a prefix argument, this command does completion within
 668 the collection of symbols listed in the index of the manual for the
 669 language you are using."
 670   (interactive "P")
 671   (if arg (info-complete-symbol) (completion-at-point)))
 672
 673 ;; Reduce total amount of space we must allocate during this function
 674 ;; that we will not need to keep permanently.
 675 (garbage-collect)
 676 \f
 677
 678 (setq help-event-list '(help f1))
 679
 680 (make-variable-buffer-local 'minor-mode-overriding-map-alist)
 681
 682 ;; From frame.c
 683 (global-set-key [switch-frame] 'handle-switch-frame)
 684 (global-set-key [select-window] 'handle-select-window)
 685
 686 ;; FIXME: Do those 3 events really ever reach the global-map ?
 687 ;;        It seems that they can't because they're handled via
 688 ;;        special-event-map which is used at very low-level.  -stef
 689 (global-set-key [delete-frame] 'handle-delete-frame)
 690 (global-set-key [iconify-frame] 'ignore-event)
 691 (global-set-key [make-frame-visible] 'ignore-event)
 692
 693
 694 ;These commands are defined in editfns.c
 695 ;but they are not assigned to keys there.
 696 (put 'narrow-to-region 'disabled t)
 697
 698 ;; Moving with arrows in bidi-sensitive direction.
 699 (defun right-char (&optional n)
 700   "Move point N characters to the right (to the left if N is negative).
 701 On reaching beginning or end of buffer, stop and signal error.
 702
 703 Depending on the bidirectional context, this may move either forward
 704 or backward in the buffer.  This is in contrast with \\[forward-char]
 705 and \\[backward-char], which see."
 706   (interactive "^p")
 707   (if (eq (current-bidi-paragraph-direction) 'left-to-right)
 708       (forward-char n)
 709     (backward-char n)))
 710
 711 (defun left-char ( &optional n)
 712   "Move point N characters to the left (to the right if N is negative).
 713 On reaching beginning or end of buffer, stop and signal error.
 714
 715 Depending on the bidirectional context, this may move either backward
 716 or forward in the buffer.  This is in contrast with \\[backward-char]
 717 and \\[forward-char], which see."
 718   (interactive "^p")
 719   (if (eq (current-bidi-paragraph-direction) 'left-to-right)
 720       (backward-char n)
 721     (forward-char n)))
 722
 723 (defun right-word (&optional n)
 724   "Move point N words to the right (to the left if N is negative).
 725
 726 Depending on the bidirectional context, this may move either forward
 727 or backward in the buffer.  This is in contrast with \\[forward-word]
 728 and \\[backward-word], which see.
 729
 730 Value is normally t.
 731 If an edge of the buffer or a field boundary is reached, point is left there
 732 there and the function returns nil.  Field boundaries are not noticed
 733 if `inhibit-field-text-motion' is non-nil."
 734   (interactive "^p")
 735   (if (eq (current-bidi-paragraph-direction) 'left-to-right)
 736       (forward-word n)
 737     (backward-word n)))
 738
 739 (defun left-word (&optional n)
 740   "Move point N words to the left (to the right if N is negative).
 741
 742 Depending on the bidirectional context, this may move either backward
 743 or forward in the buffer.  This is in contrast with \\[backward-word]
 744 and \\[forward-word], which see.
 745
 746 Value is normally t.
 747 If an edge of the buffer or a field boundary is reached, point is left there
 748 there and the function returns nil.  Field boundaries are not noticed
 749 if `inhibit-field-text-motion' is non-nil."
 750   (interactive "^p")
 751   (if (eq (current-bidi-paragraph-direction) 'left-to-right)
 752       (backward-word n)
 753     (forward-word n)))
 754
 755 (defvar narrow-map (make-sparse-keymap)
 756   "Keymap for narrowing commands.")
 757 (define-key ctl-x-map "n" narrow-map)
 758
 759 (define-key narrow-map "n" 'narrow-to-region)
 760 (define-key narrow-map "w" 'widen)
 761
 762 ;; Quitting
 763 (define-key global-map "\e\e\e" 'keyboard-escape-quit)
 764 (define-key global-map "\C-g" 'keyboard-quit)
 765
 766 ;; Used to be in termdev.el: when using several terminals, make C-z
 767 ;; suspend only the relevant terminal.
 768 (substitute-key-definition 'suspend-emacs 'suspend-frame global-map)
 769
 770 (define-key global-map "\C-j" 'newline-and-indent)
 771 (define-key global-map "\C-m" 'newline)
 772 (define-key global-map "\C-o" 'open-line)
 773 (define-key esc-map "\C-o" 'split-line)
 774 (define-key global-map "\C-q" 'quoted-insert)
 775 (define-key esc-map "^" 'delete-indentation)
 776 (define-key esc-map "\\" 'delete-horizontal-space)
 777 (define-key esc-map "m" 'back-to-indentation)
 778 (define-key ctl-x-map "\C-o" 'delete-blank-lines)
 779 (define-key esc-map " " 'just-one-space)
 780 (define-key esc-map "z" 'zap-to-char)
 781 (define-key esc-map "=" 'count-words-region)
 782 (define-key ctl-x-map "=" 'what-cursor-position)
 783 (define-key esc-map ":" 'eval-expression)
 784 ;; Define ESC ESC : like ESC : for people who type ESC ESC out of habit.
 785 (define-key esc-map "\M-:" 'eval-expression)
 786 ;; Changed from C-x ESC so that function keys work following C-x.
 787 (define-key ctl-x-map "\e\e" 'repeat-complex-command)
 788 ;; New binding analogous to M-:.
 789 (define-key ctl-x-map "\M-:" 'repeat-complex-command)
 790 (define-key ctl-x-map "u" 'undo)
 791 (put 'undo :advertised-binding [?\C-x ?u])
 792 ;; Many people are used to typing C-/ on X terminals and getting C-_.
 793 (define-key global-map [?\C-/] 'undo)
 794 (define-key global-map "\C-_" 'undo)
 795 ;; Richard said that we should not use C-x <uppercase letter> and I have
 796 ;; no idea whereas to bind it.  Any suggestion welcome.  -stef
 797 ;; (define-key ctl-x-map "U" 'undo-only)
 798
 799 (define-key esc-map "!" 'shell-command)
 800 (define-key esc-map "|" 'shell-command-on-region)
 801 (define-key esc-map "&" 'async-shell-command)
 802
 803 (define-key ctl-x-map [right] 'next-buffer)
 804 (define-key ctl-x-map [C-right] 'next-buffer)
 805 (define-key global-map [XF86Forward] 'next-buffer)
 806 (define-key ctl-x-map [left] 'previous-buffer)
 807 (define-key ctl-x-map [C-left] 'previous-buffer)
 808 (define-key global-map [XF86Back] 'previous-buffer)
 809
 810 (let ((map minibuffer-local-map))
 811   (define-key map "\en"   'next-history-element)
 812   (define-key map [next]  'next-history-element)
 813   (define-key map [down]  'next-history-element)
 814   (define-key map [XF86Forward] 'next-history-element)
 815   (define-key map "\ep"   'previous-history-element)
 816   (define-key map [prior] 'previous-history-element)
 817   (define-key map [up]    'previous-history-element)
 818   (define-key map [XF86Back] 'previous-history-element)
 819   (define-key map "\es"   'next-matching-history-element)
 820   (define-key map "\er"   'previous-matching-history-element)
 821   ;; Override the global binding (which calls indent-relative via
 822   ;; indent-for-tab-command).  The alignment that indent-relative tries to
 823   ;; do doesn't make much sense here since the prompt messes it up.
 824   (define-key map "\t"    'self-insert-command)
 825   (define-key map [C-tab] 'file-cache-minibuffer-complete))
 826
 827 (define-key global-map "\C-u" 'universal-argument)
 828 (let ((i ?0))
 829   (while (<= i ?9)
 830     (define-key esc-map (char-to-string i) 'digit-argument)
 831     (setq i (1+ i))))
 832 (define-key esc-map "-" 'negative-argument)
 833 ;; Define control-digits.
 834 (let ((i ?0))
 835   (while (<= i ?9)
 836     (define-key global-map (read (format "[?\\C-%c]" i)) 'digit-argument)
 837     (setq i (1+ i))))
 838 (define-key global-map [?\C--] 'negative-argument)
 839 ;; Define control-meta-digits.
 840 (let ((i ?0))
 841   (while (<= i ?9)
 842     (define-key esc-map (read (format "[?\\C-%c]" i)) 'digit-argument)
 843     (setq i (1+ i))))
 844 (define-key global-map [?\C-\M--] 'negative-argument)
 845
 846 ;; Update tutorial--default-keys if you change these.
 847 (define-key global-map "\177" 'delete-backward-char)
 848 (define-key global-map "\C-d" 'delete-char)
 849
 850 (define-key global-map "\C-k" 'kill-line)
 851 (define-key global-map "\C-w" 'kill-region)
 852 (define-key esc-map "w" 'kill-ring-save)
 853 (define-key esc-map "\C-w" 'append-next-kill)
 854 (define-key global-map "\C-y" 'yank)
 855 (define-key esc-map "y" 'yank-pop)
 856
 857 ;; (define-key ctl-x-map "a" 'append-to-buffer)
 858
 859 (define-key global-map "\C-@" 'set-mark-command)
 860 ;; Many people are used to typing C-SPC and getting C-@.
 861 (define-key global-map [?\C- ] 'set-mark-command)
 862 (put 'set-mark-command :advertised-binding [?\C- ])
 863
 864 (define-key ctl-x-map "\C-x" 'exchange-point-and-mark)
 865 (define-key ctl-x-map "\C-@" 'pop-global-mark)
 866 (define-key ctl-x-map [?\C- ] 'pop-global-mark)
 867
 868 (define-key global-map "\C-n" 'next-line)
 869 (define-key global-map "\C-p" 'previous-line)
 870 (define-key ctl-x-map "\C-n" 'set-goal-column)
 871 (define-key global-map "\C-a" 'move-beginning-of-line)
 872 (define-key global-map "\C-e" 'move-end-of-line)
 873
 874 (define-key ctl-x-map "`" 'next-error)
 875
 876 (defvar goto-map (make-sparse-keymap)
 877   "Keymap for navigation commands.")
 878 (define-key esc-map "g" goto-map)
 879
 880 (define-key goto-map    "c" 'goto-char)
 881 (define-key goto-map    "g" 'goto-line)
 882 (define-key goto-map "\M-g" 'goto-line)
 883 (define-key goto-map    "n" 'next-error)
 884 (define-key goto-map "\M-n" 'next-error)
 885 (define-key goto-map    "p" 'previous-error)
 886 (define-key goto-map "\M-p" 'previous-error)
 887 (define-key goto-map   "\t" 'move-to-column)
 888
 889 (defvar search-map (make-sparse-keymap)
 890   "Keymap for search related commands.")
 891 (define-key esc-map "s" search-map)
 892
 893 (define-key search-map "o"  'occur)
 894 (define-key search-map "hr" 'highlight-regexp)
 895 (define-key search-map "hp" 'highlight-phrase)
 896 (define-key search-map "hl" 'highlight-lines-matching-regexp)
 897 (define-key search-map "hu" 'unhighlight-regexp)
 898 (define-key search-map "hf" 'hi-lock-find-patterns)
 899 (define-key search-map "hw" 'hi-lock-write-interactive-patterns)
 900
 901 ;;(defun function-key-error ()
 902 ;;  (interactive)
 903 ;;  (error "That function key is not bound to anything"))
 904
 905 (define-key global-map [menu] 'execute-extended-command)
 906 (define-key global-map [find] 'search-forward)
 907
 908 ;; Don't do this.  We define <delete> in function-key-map instead.
 909 ;(define-key global-map [delete] 'backward-delete-char)
 910
 911 ;; natural bindings for terminal keycaps --- defined in X keysym order
 912 (define-key global-map [C-S-backspace]  'kill-whole-line)
 913 (define-key global-map [home]           'move-beginning-of-line)
 914 (define-key global-map [C-home]         'beginning-of-buffer)
 915 (define-key global-map [M-home]         'beginning-of-buffer-other-window)
 916 (define-key esc-map    [home]           'beginning-of-buffer-other-window)
 917 (define-key global-map [left]           'left-char)
 918 (define-key global-map [up]             'previous-line)
 919 (define-key global-map [right]          'right-char)
 920 (define-key global-map [down]           'next-line)
 921 (define-key global-map [prior]          'scroll-down-command)
 922 (define-key global-map [next]           'scroll-up-command)
 923 (define-key global-map [C-up]           'backward-paragraph)
 924 (define-key global-map [C-down]         'forward-paragraph)
 925 (define-key global-map [C-prior]        'scroll-right)
 926 (put 'scroll-left 'disabled t)
 927 (define-key global-map [C-next]         'scroll-left)
 928 (define-key global-map [M-next]         'scroll-other-window)
 929 (define-key esc-map    [next]           'scroll-other-window)
 930 (define-key global-map [M-prior]        'scroll-other-window-down)
 931 (define-key esc-map    [prior]          'scroll-other-window-down)
 932 (define-key esc-map [?\C-\S-v]          'scroll-other-window-down)
 933 (define-key global-map [end]            'move-end-of-line)
 934 (define-key global-map [C-end]          'end-of-buffer)
 935 (define-key global-map [M-end]          'end-of-buffer-other-window)
 936 (define-key esc-map    [end]            'end-of-buffer-other-window)
 937 (define-key global-map [begin]          'beginning-of-buffer)
 938 (define-key global-map [M-begin]        'beginning-of-buffer-other-window)
 939 (define-key esc-map    [begin]          'beginning-of-buffer-other-window)
 940 ;; (define-key global-map [select]      'function-key-error)
 941 ;; (define-key global-map [print]       'function-key-error)
 942 (define-key global-map [execute]        'execute-extended-command)
 943 (define-key global-map [insert]         'overwrite-mode)
 944 (define-key global-map [C-insert]       'kill-ring-save)
 945 (define-key global-map [S-insert]       'yank)
 946 ;; `insertchar' is what term.c produces.  Should we change term.c
 947 ;; to produce `insert' instead?
 948 (define-key global-map [insertchar]     'overwrite-mode)
 949 (define-key global-map [C-insertchar]   'kill-ring-save)
 950 (define-key global-map [S-insertchar]   'yank)
 951 (define-key global-map [undo]           'undo)
 952 (define-key global-map [redo]           'repeat-complex-command)
 953 (define-key global-map [again]          'repeat-complex-command) ; Sun keyboard
 954 (define-key global-map [open]           'find-file) ; Sun
 955 ;; The following wouldn't work to interrupt running code since C-g is
 956 ;; treated specially in the event loop.
 957 ;; (define-key global-map [stop]                'keyboard-quit) ; Sun
 958 ;; (define-key global-map [clearline]   'function-key-error)
 959 (define-key global-map [insertline]     'open-line)
 960 (define-key global-map [deleteline]     'kill-line)
 961 (define-key global-map [deletechar]     'delete-forward-char)
 962 ;; (define-key global-map [backtab]     'function-key-error)
 963 ;; (define-key global-map [f1]          'function-key-error)
 964 ;; (define-key global-map [f2]          'function-key-error)
 965 ;; (define-key global-map [f3]          'function-key-error)
 966 ;; (define-key global-map [f4]          'function-key-error)
 967 ;; (define-key global-map [f5]          'function-key-error)
 968 ;; (define-key global-map [f6]          'function-key-error)
 969 ;; (define-key global-map [f7]          'function-key-error)
 970 ;; (define-key global-map [f8]          'function-key-error)
 971 ;; (define-key global-map [f9]          'function-key-error)
 972 ;; (define-key global-map [f10]         'function-key-error)
 973 ;; (define-key global-map [f11]         'function-key-error)
 974 ;; (define-key global-map [f12]         'function-key-error)
 975 ;; (define-key global-map [f13]         'function-key-error)
 976 ;; (define-key global-map [f14]         'function-key-error)
 977 ;; (define-key global-map [f15]         'function-key-error)
 978 ;; (define-key global-map [f16]         'function-key-error)
 979 ;; (define-key global-map [f17]         'function-key-error)
 980 ;; (define-key global-map [f18]         'function-key-error)
 981 ;; (define-key global-map [f19]         'function-key-error)
 982 ;; (define-key global-map [f20]         'function-key-error)
 983 ;; (define-key global-map [f21]         'function-key-error)
 984 ;; (define-key global-map [f22]         'function-key-error)
 985 ;; (define-key global-map [f23]         'function-key-error)
 986 ;; (define-key global-map [f24]         'function-key-error)
 987 ;; (define-key global-map [f25]         'function-key-error)
 988 ;; (define-key global-map [f26]         'function-key-error)
 989 ;; (define-key global-map [f27]         'function-key-error)
 990 ;; (define-key global-map [f28]         'function-key-error)
 991 ;; (define-key global-map [f29]         'function-key-error)
 992 ;; (define-key global-map [f30]         'function-key-error)
 993 ;; (define-key global-map [f31]         'function-key-error)
 994 ;; (define-key global-map [f32]         'function-key-error)
 995 ;; (define-key global-map [f33]         'function-key-error)
 996 ;; (define-key global-map [f34]         'function-key-error)
 997 ;; (define-key global-map [f35]         'function-key-error)
 998 ;; (define-key global-map [kp-backtab]  'function-key-error)
 999 ;; (define-key global-map [kp-space]    'function-key-error)
1000 ;; (define-key global-map [kp-tab]              'function-key-error)
1001 ;; (define-key global-map [kp-enter]    'function-key-error)
1002 ;; (define-key global-map [kp-f1]               'function-key-error)
1003 ;; (define-key global-map [kp-f2]               'function-key-error)
1004 ;; (define-key global-map [kp-f3]               'function-key-error)
1005 ;; (define-key global-map [kp-f4]               'function-key-error)
1006 ;; (define-key global-map [kp-multiply] 'function-key-error)
1007 ;; (define-key global-map [kp-add]              'function-key-error)
1008 ;; (define-key global-map [kp-separator]        'function-key-error)
1009 ;; (define-key global-map [kp-subtract] 'function-key-error)
1010 ;; (define-key global-map [kp-decimal]  'function-key-error)
1011 ;; (define-key global-map [kp-divide]   'function-key-error)
1012 ;; (define-key global-map [kp-0]                'function-key-error)
1013 ;; (define-key global-map [kp-1]                'function-key-error)
1014 ;; (define-key global-map [kp-2]                'function-key-error)
1015 ;; (define-key global-map [kp-3]                'function-key-error)
1016 ;; (define-key global-map [kp-4]                'function-key-error)
1017 ;; (define-key global-map [kp-5]                'recenter)
1018 ;; (define-key global-map [kp-6]                'function-key-error)
1019 ;; (define-key global-map [kp-7]                'function-key-error)
1020 ;; (define-key global-map [kp-8]                'function-key-error)
1021 ;; (define-key global-map [kp-9]                'function-key-error)
1022 ;; (define-key global-map [kp-equal]    'function-key-error)
1023
1024 ;; X11R6 distinguishes these keys from the non-kp keys.
1025 ;; Make them behave like the non-kp keys unless otherwise bound.
1026 ;; FIXME: rather than list such mappings for every modifier-combination,
1027 ;;   we should come up with a way to do it generically, something like
1028 ;;   (define-key function-key-map [*-kp-home] [*-home])
1029 (define-key function-key-map [kp-home] [home])
1030 (define-key function-key-map [kp-left] [left])
1031 (define-key function-key-map [kp-up] [up])
1032 (define-key function-key-map [kp-right] [right])
1033 (define-key function-key-map [kp-down] [down])
1034 (define-key function-key-map [kp-prior] [prior])
1035 (define-key function-key-map [kp-next] [next])
1036 (define-key function-key-map [M-kp-next] [M-next])
1037 (define-key function-key-map [kp-end] [end])
1038 (define-key function-key-map [kp-begin] [begin])
1039 (define-key function-key-map [kp-insert] [insert])
1040 (define-key function-key-map [backspace] [?\C-?])
1041 (define-key function-key-map [delete] [?\C-?])
1042 (define-key function-key-map [kp-delete] [?\C-?])
1043 (define-key function-key-map [S-kp-end] [S-end])
1044 (define-key function-key-map [S-kp-down] [S-down])
1045 (define-key function-key-map [S-kp-next] [S-next])
1046 (define-key function-key-map [S-kp-left] [S-left])
1047 (define-key function-key-map [S-kp-right] [S-right])
1048 (define-key function-key-map [S-kp-home] [S-home])
1049 (define-key function-key-map [S-kp-up] [S-up])
1050 (define-key function-key-map [S-kp-prior] [S-prior])
1051 (define-key function-key-map [C-S-kp-end] [C-S-end])
1052 (define-key function-key-map [C-S-kp-down] [C-S-down])
1053 (define-key function-key-map [C-S-kp-next] [C-S-next])
1054 (define-key function-key-map [C-S-kp-left] [C-S-left])
1055 (define-key function-key-map [C-S-kp-right] [C-S-right])
1056 (define-key function-key-map [C-S-kp-home] [C-S-home])
1057 (define-key function-key-map [C-S-kp-up] [C-S-up])
1058 (define-key function-key-map [C-S-kp-prior] [C-S-prior])
1059 ;; Don't bind shifted keypad numeric keys, they reportedly
1060 ;; interfere with the feature of some keyboards to produce
1061 ;; numbers when NumLock is off.
1062 ;(define-key function-key-map [S-kp-1] [S-end])
1063 ;(define-key function-key-map [S-kp-2] [S-down])
1064 ;(define-key function-key-map [S-kp-3] [S-next])
1065 ;(define-key function-key-map [S-kp-4] [S-left])
1066 ;(define-key function-key-map [S-kp-6] [S-right])
1067 ;(define-key function-key-map [S-kp-7] [S-home])
1068 ;(define-key function-key-map [S-kp-8] [S-up])
1069 ;(define-key function-key-map [S-kp-9] [S-prior])
1070 (define-key function-key-map [C-S-kp-1] [C-S-end])
1071 (define-key function-key-map [C-S-kp-2] [C-S-down])
1072 (define-key function-key-map [C-S-kp-3] [C-S-next])
1073 (define-key function-key-map [C-S-kp-4] [C-S-left])
1074 (define-key function-key-map [C-S-kp-6] [C-S-right])
1075 (define-key function-key-map [C-S-kp-7] [C-S-home])
1076 (define-key function-key-map [C-S-kp-8] [C-S-up])
1077 (define-key function-key-map [C-S-kp-9] [C-S-prior])
1078
1079 ;; Hitting C-SPC on text terminals, usually sends the ascii code 0 (aka C-@),
1080 ;; so we can't distinguish those two keys, but usually we consider C-SPC
1081 ;; (rather than C-@) as the "canonical" binding.
1082 (define-key function-key-map [?\C-@] [?\C-\s])
1083 ;; Many keyboards don't have a `backtab' key, so by convention the user
1084 ;; can use S-tab instead to access that binding.
1085 (define-key function-key-map [S-tab] [backtab])
1086
1087 (define-key global-map [mouse-movement] 'ignore)
1088
1089 (define-key global-map "\C-t" 'transpose-chars)
1090 (define-key esc-map "t" 'transpose-words)
1091 (define-key esc-map "\C-t" 'transpose-sexps)
1092 (define-key ctl-x-map "\C-t" 'transpose-lines)
1093
1094 (define-key esc-map ";" 'comment-dwim)
1095 (define-key esc-map "j" 'indent-new-comment-line)
1096 (define-key esc-map "\C-j" 'indent-new-comment-line)
1097 (define-key ctl-x-map ";" 'comment-set-column)
1098 (define-key ctl-x-map "f" 'set-fill-column)
1099 (define-key ctl-x-map "$" 'set-selective-display)
1100
1101 (define-key esc-map "@" 'mark-word)
1102 (define-key esc-map "f" 'forward-word)
1103 (define-key esc-map "b" 'backward-word)
1104 (define-key esc-map "d" 'kill-word)
1105 (define-key esc-map "\177" 'backward-kill-word)
1106
1107 (define-key esc-map "<" 'beginning-of-buffer)
1108 (define-key esc-map ">" 'end-of-buffer)
1109 (define-key ctl-x-map "h" 'mark-whole-buffer)
1110 (define-key esc-map "\\" 'delete-horizontal-space)
1111
1112 (defalias 'mode-specific-command-prefix (make-sparse-keymap))
1113 (defvar mode-specific-map (symbol-function 'mode-specific-command-prefix)
1114   "Keymap for characters following C-c.")
1115 (define-key global-map "\C-c" 'mode-specific-command-prefix)
1116
1117 (global-set-key [M-right]  'right-word)
1118 (define-key esc-map [right] 'forward-word)
1119 (global-set-key [M-left]   'left-word)
1120 (define-key esc-map [left] 'backward-word)
1121 ;; ilya@math.ohio-state.edu says these bindings are standard on PC editors.
1122 (global-set-key [C-right]  'right-word)
1123 (global-set-key [C-left]   'left-word)
1124 ;; This is not quite compatible, but at least is analogous
1125 (global-set-key [C-delete] 'kill-word)
1126 (global-set-key [C-backspace] 'backward-kill-word)
1127 ;; This is "move to the clipboard", or as close as we come.
1128 (global-set-key [S-delete] 'kill-region)
1129
1130 (global-set-key [C-M-left]    'backward-sexp)
1131 (define-key esc-map [C-left]  'backward-sexp)
1132 (global-set-key [C-M-right]   'forward-sexp)
1133 (define-key esc-map [C-right] 'forward-sexp)
1134 (global-set-key [C-M-up]      'backward-up-list)
1135 (define-key esc-map [C-up]    'backward-up-list)
1136 (global-set-key [C-M-down]    'down-list)
1137 (define-key esc-map [C-down]  'down-list)
1138 (global-set-key [C-M-home]    'beginning-of-defun)
1139 (define-key esc-map [C-home]  'beginning-of-defun)
1140 (global-set-key [C-M-end]     'end-of-defun)
1141 (define-key esc-map [C-end]   'end-of-defun)
1142
1143 (define-key esc-map "\C-f" 'forward-sexp)
1144 (define-key esc-map "\C-b" 'backward-sexp)
1145 (define-key esc-map "\C-u" 'backward-up-list)
1146 (define-key esc-map "\C-@" 'mark-sexp)
1147 (define-key esc-map [?\C-\ ] 'mark-sexp)
1148 (define-key esc-map "\C-d" 'down-list)
1149 (define-key esc-map "\C-k" 'kill-sexp)
1150 ;;; These are dangerous in various situations,
1151 ;;; so let's not encourage anyone to use them.
1152 ;;;(define-key global-map [C-M-delete] 'backward-kill-sexp)
1153 ;;;(define-key global-map [C-M-backspace] 'backward-kill-sexp)
1154 (define-key esc-map [C-delete] 'backward-kill-sexp)
1155 (define-key esc-map [C-backspace] 'backward-kill-sexp)
1156 (define-key esc-map "\C-n" 'forward-list)
1157 (define-key esc-map "\C-p" 'backward-list)
1158 (define-key esc-map "\C-a" 'beginning-of-defun)
1159 (define-key esc-map "\C-e" 'end-of-defun)
1160 (define-key esc-map "\C-h" 'mark-defun)
1161 (define-key ctl-x-map "nd" 'narrow-to-defun)
1162 (define-key esc-map "(" 'insert-parentheses)
1163 (define-key esc-map ")" 'move-past-close-and-reindent)
1164
1165 (define-key ctl-x-map "\C-e" 'eval-last-sexp)
1166
1167 (define-key ctl-x-map "m" 'compose-mail)
1168 (define-key ctl-x-4-map "m" 'compose-mail-other-window)
1169 (define-key ctl-x-5-map "m" 'compose-mail-other-frame)
1170 \f
1171
1172 (defvar ctl-x-r-map
1173   (let ((map (make-sparse-keymap)))
1174     (define-key map "c" 'clear-rectangle)
1175     (define-key map "k" 'kill-rectangle)
1176     (define-key map "d" 'delete-rectangle)
1177     (define-key map "y" 'yank-rectangle)
1178     (define-key map "o" 'open-rectangle)
1179     (define-key map "t" 'string-rectangle)
1180     (define-key map "N" 'rectangle-number-lines)
1181     (define-key map "\M-w" 'copy-rectangle-as-kill)
1182     (define-key map "\C-@" 'point-to-register)
1183     (define-key map [?\C-\ ] 'point-to-register)
1184     (define-key map " " 'point-to-register)
1185     (define-key map "j" 'jump-to-register)
1186     (define-key map "s" 'copy-to-register)
1187     (define-key map "x" 'copy-to-register)
1188     (define-key map "i" 'insert-register)
1189     (define-key map "g" 'insert-register)
1190     (define-key map "r" 'copy-rectangle-to-register)
1191     (define-key map "n" 'number-to-register)
1192     (define-key map "+" 'increment-register)
1193     (define-key map "w" 'window-configuration-to-register)
1194     (define-key map "f" 'frame-configuration-to-register)
1195     map)
1196   "Keymap for subcommands of C-x r.")
1197 (define-key ctl-x-map "r" ctl-x-r-map)
1198
1199 (define-key esc-map "q" 'fill-paragraph)
1200 (define-key ctl-x-map "." 'set-fill-prefix)
1201 \f
1202 (define-key esc-map "{" 'backward-paragraph)
1203 (define-key esc-map "}" 'forward-paragraph)
1204 (define-key esc-map "h" 'mark-paragraph)
1205 (define-key esc-map "a" 'backward-sentence)
1206 (define-key esc-map "e" 'forward-sentence)
1207 (define-key esc-map "k" 'kill-sentence)
1208 (define-key ctl-x-map "\177" 'backward-kill-sentence)
1209
1210 (define-key ctl-x-map "[" 'backward-page)
1211 (define-key ctl-x-map "]" 'forward-page)
1212 (define-key ctl-x-map "\C-p" 'mark-page)
1213 (define-key ctl-x-map "l" 'count-lines-page)
1214 (define-key ctl-x-map "np" 'narrow-to-page)
1215 ;; (define-key ctl-x-map "p" 'narrow-to-page)
1216 \f
1217 (defvar abbrev-map (make-sparse-keymap)
1218   "Keymap for abbrev commands.")
1219 (define-key ctl-x-map "a" abbrev-map)
1220
1221 (define-key abbrev-map "l" 'add-mode-abbrev)
1222 (define-key abbrev-map "\C-a" 'add-mode-abbrev)
1223 (define-key abbrev-map "g" 'add-global-abbrev)
1224 (define-key abbrev-map "+" 'add-mode-abbrev)
1225 (define-key abbrev-map "ig" 'inverse-add-global-abbrev)
1226 (define-key abbrev-map "il" 'inverse-add-mode-abbrev)
1227 ;; (define-key abbrev-map "\C-h" 'inverse-add-global-abbrev)
1228 (define-key abbrev-map "-" 'inverse-add-global-abbrev)
1229 (define-key abbrev-map "e" 'expand-abbrev)
1230 (define-key abbrev-map "'" 'expand-abbrev)
1231 ;; (define-key ctl-x-map "\C-a" 'add-mode-abbrev)
1232 ;; (define-key ctl-x-map "\+" 'add-global-abbrev)
1233 ;; (define-key ctl-x-map "\C-h" 'inverse-add-mode-abbrev)
1234 ;; (define-key ctl-x-map "\-" 'inverse-add-global-abbrev)
1235 (define-key esc-map "'" 'abbrev-prefix-mark)
1236 (define-key ctl-x-map "'" 'expand-abbrev)
1237 (define-key ctl-x-map "\C-b" 'list-buffers)
1238
1239 (define-key ctl-x-map "z" 'repeat)
1240
1241 (define-key esc-map "\C-l" 'reposition-window)
1242
1243 (define-key ctl-x-4-map "a" 'add-change-log-entry-other-window)
1244 (define-key ctl-x-4-map "c" 'clone-indirect-buffer-other-window)
1245
1246 ;; Signal handlers
1247 (define-key special-event-map [sigusr1] 'ignore)
1248 (define-key special-event-map [sigusr2] 'ignore)
1249
1250 ;; Don't look for autoload cookies in this file.
1251 ;; Local Variables:
1252 ;; no-update-autoloads: t
1253 ;; End:
1254
1255 ;;; bindings.el ends here