code.delx.au - gnu-emacs/blob - lisp/bindings.el

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