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

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