lisp/bindings.el

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