lisp/bindings.el

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