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