LCOV - code coverage report
Current view: top level - lisp - bindings.el (source / functions) Hit Total Coverage
Test: tramp-tests-after.info Lines: 20 99 20.2 %
Date: 2017-08-30 10:12:24 Functions: 4 24 16.7 %

          Line data    Source code
       1             : ;;; bindings.el --- define standard key bindings and some variables
       2             : 
       3             : ;; Copyright (C) 1985-1987, 1992-1996, 1999-2017 Free Software
       4             : ;; Foundation, Inc.
       5             : 
       6             : ;; Maintainer: emacs-devel@gnu.org
       7             : ;; Keywords: internal
       8             : ;; Package: emacs
       9             : 
      10             : ;; This file is part of GNU Emacs.
      11             : 
      12             : ;; GNU Emacs is free software: you can redistribute it and/or modify
      13             : ;; it under the terms of the GNU General Public License as published by
      14             : ;; the Free Software Foundation, either version 3 of the License, or
      15             : ;; (at your option) any later version.
      16             : 
      17             : ;; GNU Emacs is distributed in the hope that it will be useful,
      18             : ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
      19             : ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      20             : ;; GNU General Public License for more details.
      21             : 
      22             : ;; You should have received a copy of the GNU General Public License
      23             : ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
      24             : 
      25             : ;;; Commentary:
      26             : 
      27             : ;;; Code:
      28             : 
      29             : (defun make-mode-line-mouse-map (mouse function) "\
      30             : Return a keymap with single entry for mouse key MOUSE on the mode line.
      31             : MOUSE is defined to run function FUNCTION with no args in the buffer
      32             : corresponding to the mode line clicked."
      33           0 :   (let ((map (make-sparse-keymap)))
      34           0 :     (define-key map (vector 'mode-line mouse) function)
      35           0 :     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           0 :   (with-selected-window (posn-window (event-start event))
      42           0 :     (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           0 :   (with-selected-window (posn-window (event-start event))
      48           0 :     (set-buffer-modified-p (not (buffer-modified-p)))
      49           0 :     (force-mode-line-update)))
      50             : 
      51             : (defun mode-line-widen (event)
      52             :   "Widen a buffer from the mode-line."
      53             :   (interactive "e")
      54           0 :   (with-selected-window (posn-window (event-start event))
      55           0 :     (widen)
      56           0 :     (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           0 :   (with-selected-window (posn-window (event-start event))
      94           0 :     (let ((eol (coding-system-eol-type buffer-file-coding-system)))
      95           0 :       (set-buffer-file-coding-system
      96           0 :        (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           0 :   (let* ((eol (coding-system-eol-type buffer-file-coding-system))
     102           0 :          (mnemonic (coding-system-eol-type-mnemonic buffer-file-coding-system))
     103           0 :          (desc (assoc eol mode-line-eol-desc-cache)))
     104           0 :     (if (and desc (eq (cadr desc) mnemonic))
     105           0 :         (cddr desc)
     106           0 :       (if desc (setq mode-line-eol-desc-cache nil)) ;Flush the cache if stale.
     107           0 :       (setq desc
     108           0 :             (propertize
     109           0 :              mnemonic
     110           0 :              'help-echo (format "End-of-line style: %s\nmouse-1: Cycle"
     111           0 :                                 (if (eq eol 0) "Unix-style LF"
     112           0 :                                   (if (eq eol 1) "DOS-style CRLF"
     113           0 :                                     (if (eq eol 2) "Mac-style CR"
     114           0 :                                       "Undecided"))))
     115             :              'keymap
     116           0 :              (eval-when-compile
     117           1 :                (let ((map (make-sparse-keymap)))
     118           1 :                  (define-key map [mode-line mouse-1] 'mode-line-change-eol)
     119           1 :                  map))
     120           0 :              'mouse-face 'mode-line-highlight))
     121           0 :       (push (cons eol (cons mnemonic desc)) mode-line-eol-desc-cache)
     122           0 :       desc)))
     123             : 
     124             : 
     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           0 :   (with-current-buffer (window-buffer window)
     150           0 :     (if buffer-file-coding-system
     151           0 :         (format "Buffer coding system (%s): %s
     152             : mouse-1: Describe coding system
     153             : mouse-3: Set coding system"
     154           0 :                 (if enable-multibyte-characters "multi-byte" "unibyte")
     155           0 :                 (symbol-name buffer-file-coding-system))
     156           0 :       "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           0 :   (format "Buffer is %s\nmouse-1: Toggle"
     197           0 :           (if (buffer-local-value 'buffer-read-only (window-buffer window))
     198             :               "read-only"
     199           0 :             "writable")))
     200             : 
     201             : (defun mode-line-modified-help-echo (window _object _point)
     202             :   "Return help text specifying WINDOW's buffer modification status."
     203           0 :   (format "Buffer is %smodified\nmouse-1: Toggle modification state"
     204           0 :           (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           0 :   (if (or (null window-system)
     249           0 :           (eq window-system 'pc))
     250             :       "-%F  "
     251           0 :     "  "))
     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          28 :   (define-key map key
     271          28 :     (cond
     272          28 :      ((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          28 :      ((keymapp item) item)
     276          28 :      ((stringp (car item))
     277           8 :       (if (keymapp (cdr item))
     278           8 :           (cons (purecopy (car item)) (cdr item))
     279           8 :         (purecopy item)))
     280          20 :      ((eq 'menu-item (car item))
     281          20 :       (if (keymapp (nth 2 item))
     282           0 :           `(menu-item ,(purecopy (nth 1 item)) ,(nth 2 item)
     283           0 :                       ,@(purecopy (nthcdr 3 item)))
     284          20 :         (purecopy item)))
     285          28 :      (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           6 :   (list (propertize fmt
     463             :                     'face 'mode-line-buffer-id
     464             :                     'help-echo
     465           6 :                     (purecopy "Buffer name
     466           6 : mouse-1: Previous buffer\nmouse-3: Next buffer")
     467             :                     'mouse-face 'mode-line-highlight
     468           6 :                     '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             : 
     512             : (defun mode-line-unbury-buffer (event) "\
     513             : Call `unbury-buffer' in this window."
     514             :   (interactive "e")
     515           0 :   (with-selected-window (posn-window (event-start event))
     516           0 :     (unbury-buffer)))
     517             : 
     518             : (defun mode-line-bury-buffer (event) "\
     519             : Like `bury-buffer', but temporarily select EVENT's window."
     520             :   (interactive "e")
     521           0 :   (with-selected-window (posn-window (event-start event))
     522           0 :     (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           0 :   (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           0 :   (with-selected-window (posn-window (event-start event))
     533           0 :     (next-buffer)))
     534             : 
     535             : (defun mode-line-previous-buffer (event)
     536             :   "Like `previous-buffer', but temporarily select EVENT's window."
     537             :   (interactive "e")
     538           0 :   (with-selected-window (posn-window (event-start event))
     539           0 :     (previous-buffer)))
     540             : 
     541             : (defmacro bound-and-true-p (var)
     542             :   "Return the value of symbol VAR if it is bound, else nil."
     543          17 :   `(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           0 :   (let ((indicator (car (nth 4 (car (cdr event))))))
     598           0 :     (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             : 
     693             : (mapc (lambda (sym) (put sym 'permanent-local t))
     694             :       '(buffer-file-name default-directory buffer-backed-up
     695             :         buffer-saved-size buffer-auto-save-file-name
     696             :         buffer-read-only buffer-undo-list mark-active
     697             :         point-before-scroll buffer-file-truename
     698             :         buffer-file-format buffer-auto-save-file-format
     699             :         buffer-display-count buffer-display-time
     700             :         enable-multibyte-characters))
     701             : 
     702             : ;; We have base64, md5 and sha1 functions built in now.
     703             : (provide 'base64)
     704             : (provide 'md5)
     705             : (provide 'sha1)
     706             : (provide 'overlay '(display syntax-table field))
     707             : (provide 'text-properties '(display syntax-table field point-entered))
     708             : 
     709             : (define-key esc-map "\t" 'complete-symbol)
     710             : 
     711             : (defun complete-symbol (arg)
     712             :   "Perform completion on the text around point.
     713             : The completion method is determined by `completion-at-point-functions'.
     714             : 
     715             : With a prefix argument, this command does completion within
     716             : the collection of symbols listed in the index of the manual for the
     717             : language you are using."
     718             :   (interactive "P")
     719           0 :   (if arg (info-complete-symbol) (completion-at-point)))
     720             : 
     721             : ;; Reduce total amount of space we must allocate during this function
     722             : ;; that we will not need to keep permanently.
     723             : (garbage-collect)
     724             : 
     725             : 
     726             : (setq help-event-list '(help f1 ?\?))
     727             : 
     728             : (make-variable-buffer-local 'minor-mode-overriding-map-alist)
     729             : 
     730             : ;; From frame.c
     731             : (global-set-key [switch-frame] 'handle-switch-frame)
     732             : (global-set-key [select-window] 'handle-select-window)
     733             : 
     734             : ;; FIXME: Do those 3 events really ever reach the global-map ?
     735             : ;;        It seems that they can't because they're handled via
     736             : ;;        special-event-map which is used at very low-level.  -stef
     737             : (global-set-key [delete-frame] 'handle-delete-frame)
     738             : (global-set-key [iconify-frame] 'ignore-event)
     739             : (global-set-key [make-frame-visible] 'ignore-event)
     740             : 
     741             : 
     742             : ;These commands are defined in editfns.c
     743             : ;but they are not assigned to keys there.
     744             : (put 'narrow-to-region 'disabled t)
     745             : 
     746             : ;; Moving with arrows in bidi-sensitive direction.
     747             : (defcustom visual-order-cursor-movement nil
     748             :   "If non-nil, moving cursor with arrow keys follows the visual order.
     749             : 
     750             : When this is non-nil, \\[right-char] will move to the character that is
     751             : to the right of point on display, and \\[left-char] will move to the left,
     752             : disregarding the surrounding bidirectional context.  Depending on the
     753             : bidirectional context of the surrounding characters, this can move point
     754             : many buffer positions away.
     755             : 
     756             : When the text is entirely left-to-right, logical-order and visual-order
     757             : cursor movements produce identical results."
     758             :   :type '(choice (const :tag "Logical-order cursor movement" nil)
     759             :                  (const :tag "Visual-order cursor movement" t))
     760             :   :group 'display
     761             :   :version "24.4")
     762             : 
     763             : (defun right-char (&optional n)
     764             :   "Move point N characters to the right (to the left if N is negative).
     765             : On reaching beginning or end of buffer, stop and signal error.
     766             : 
     767             : If `visual-order-cursor-movement' is non-nil, this always moves
     768             : to the right on display, wherever that is in the buffer.
     769             : Otherwise, depending on the bidirectional context, this may move
     770             : one position either forward or backward in the buffer.  This is
     771             : in contrast with \\[forward-char] and \\[backward-char], which
     772             : see."
     773             :   (interactive "^p")
     774           0 :   (if visual-order-cursor-movement
     775           0 :       (dotimes (i (if (numberp n) (abs n) 1))
     776           0 :         (move-point-visually (if (and (numberp n) (< n 0)) -1 1)))
     777           0 :     (if (eq (current-bidi-paragraph-direction) 'left-to-right)
     778           0 :         (forward-char n)
     779           0 :       (backward-char n))))
     780             : 
     781             : (defun left-char ( &optional n)
     782             :   "Move point N characters to the left (to the right if N is negative).
     783             : On reaching beginning or end of buffer, stop and signal error.
     784             : 
     785             : If `visual-order-cursor-movement' is non-nil, this always moves
     786             : to the left on display, wherever that is in the buffer.
     787             : Otherwise, depending on the bidirectional context, this may move
     788             : one position either backward or forward in the buffer.  This is
     789             : in contrast with \\[forward-char] and \\[backward-char], which
     790             : see."
     791             :   (interactive "^p")
     792           0 :   (if visual-order-cursor-movement
     793           0 :       (dotimes (i (if (numberp n) (abs n) 1))
     794           0 :         (move-point-visually (if (and (numberp n) (< n 0)) 1 -1)))
     795           0 :     (if (eq (current-bidi-paragraph-direction) 'left-to-right)
     796           0 :         (backward-char n)
     797           0 :       (forward-char n))))
     798             : 
     799             : (defun right-word (&optional n)
     800             :   "Move point N words to the right (to the left if N is negative).
     801             : 
     802             : Depending on the bidirectional context, this may move either forward
     803             : or backward in the buffer.  This is in contrast with \\[forward-word]
     804             : and \\[backward-word], which see.
     805             : 
     806             : Value is normally t.
     807             : If an edge of the buffer or a field boundary is reached, point is left there
     808             : there and the function returns nil.  Field boundaries are not noticed
     809             : if `inhibit-field-text-motion' is non-nil."
     810             :   (interactive "^p")
     811           0 :   (if (eq (current-bidi-paragraph-direction) 'left-to-right)
     812           0 :       (forward-word n)
     813           0 :     (backward-word n)))
     814             : 
     815             : (defun left-word (&optional n)
     816             :   "Move point N words to the left (to the right if N is negative).
     817             : 
     818             : Depending on the bidirectional context, this may move either backward
     819             : or forward in the buffer.  This is in contrast with \\[backward-word]
     820             : and \\[forward-word], which see.
     821             : 
     822             : Value is normally t.
     823             : If an edge of the buffer or a field boundary is reached, point is left there
     824             : there and the function returns nil.  Field boundaries are not noticed
     825             : if `inhibit-field-text-motion' is non-nil."
     826             :   (interactive "^p")
     827           0 :   (if (eq (current-bidi-paragraph-direction) 'left-to-right)
     828           0 :       (backward-word n)
     829           0 :     (forward-word n)))
     830             : 
     831             : (defvar narrow-map (make-sparse-keymap)
     832             :   "Keymap for narrowing commands.")
     833             : (define-key ctl-x-map "n" narrow-map)
     834             : 
     835             : (define-key narrow-map "n" 'narrow-to-region)
     836             : (define-key narrow-map "w" 'widen)
     837             : 
     838             : ;; Quitting
     839             : (define-key global-map "\e\e\e" 'keyboard-escape-quit)
     840             : (define-key global-map "\C-g" 'keyboard-quit)
     841             : 
     842             : ;; Used to be in termdev.el: when using several terminals, make C-z
     843             : ;; suspend only the relevant terminal.
     844             : (substitute-key-definition 'suspend-emacs 'suspend-frame global-map)
     845             : 
     846             : (define-key global-map "\C-m" 'newline)
     847             : (define-key global-map "\C-o" 'open-line)
     848             : (define-key esc-map "\C-o" 'split-line)
     849             : (define-key global-map "\C-q" 'quoted-insert)
     850             : (define-key esc-map "^" 'delete-indentation)
     851             : (define-key esc-map "\\" 'delete-horizontal-space)
     852             : (define-key esc-map "m" 'back-to-indentation)
     853             : (define-key ctl-x-map "\C-o" 'delete-blank-lines)
     854             : (define-key esc-map " " 'just-one-space)
     855             : (define-key esc-map "z" 'zap-to-char)
     856             : (define-key esc-map "=" 'count-words-region)
     857             : (define-key ctl-x-map "=" 'what-cursor-position)
     858             : (define-key esc-map ":" 'eval-expression)
     859             : ;; Define ESC ESC : like ESC : for people who type ESC ESC out of habit.
     860             : (define-key esc-map "\M-:" 'eval-expression)
     861             : ;; Changed from C-x ESC so that function keys work following C-x.
     862             : (define-key ctl-x-map "\e\e" 'repeat-complex-command)
     863             : ;; New binding analogous to M-:.
     864             : (define-key ctl-x-map "\M-:" 'repeat-complex-command)
     865             : (define-key ctl-x-map "u" 'undo)
     866             : (put 'undo :advertised-binding [?\C-x ?u])
     867             : ;; Many people are used to typing C-/ on X terminals and getting C-_.
     868             : (define-key global-map [?\C-/] 'undo)
     869             : (define-key global-map "\C-_" 'undo)
     870             : ;; Richard said that we should not use C-x <uppercase letter> and I have
     871             : ;; no idea whereas to bind it.  Any suggestion welcome.  -stef
     872             : ;; (define-key ctl-x-map "U" 'undo-only)
     873             : 
     874             : (define-key esc-map "!" 'shell-command)
     875             : (define-key esc-map "|" 'shell-command-on-region)
     876             : (define-key esc-map "&" 'async-shell-command)
     877             : 
     878             : (define-key ctl-x-map [right] 'next-buffer)
     879             : (define-key ctl-x-map [C-right] 'next-buffer)
     880             : (define-key global-map [XF86Forward] 'next-buffer)
     881             : (define-key ctl-x-map [left] 'previous-buffer)
     882             : (define-key ctl-x-map [C-left] 'previous-buffer)
     883             : (define-key global-map [XF86Back] 'previous-buffer)
     884             : 
     885             : (let ((map minibuffer-local-map))
     886             :   (define-key map "\en"   'next-history-element)
     887             :   (define-key map [next]  'next-history-element)
     888             :   (define-key map [down]  'next-line-or-history-element)
     889             :   (define-key map [XF86Forward] 'next-history-element)
     890             :   (define-key map "\ep"   'previous-history-element)
     891             :   (define-key map [prior] 'previous-history-element)
     892             :   (define-key map [up]    'previous-line-or-history-element)
     893             :   (define-key map [XF86Back] 'previous-history-element)
     894             :   (define-key map "\es"   'next-matching-history-element)
     895             :   (define-key map "\er"   'previous-matching-history-element)
     896             :   ;; Override the global binding (which calls indent-relative via
     897             :   ;; indent-for-tab-command).  The alignment that indent-relative tries to
     898             :   ;; do doesn't make much sense here since the prompt messes it up.
     899             :   (define-key map "\t"    'self-insert-command)
     900             :   (define-key map [C-tab] 'file-cache-minibuffer-complete))
     901             : 
     902             : (define-key global-map "\C-u" 'universal-argument)
     903             : (let ((i ?0))
     904             :   (while (<= i ?9)
     905             :     (define-key esc-map (char-to-string i) 'digit-argument)
     906             :     (setq i (1+ i))))
     907             : (define-key esc-map "-" 'negative-argument)
     908             : ;; Define control-digits.
     909             : (let ((i ?0))
     910             :   (while (<= i ?9)
     911             :     (define-key global-map (read (format "[?\\C-%c]" i)) 'digit-argument)
     912             :     (setq i (1+ i))))
     913             : (define-key global-map [?\C--] 'negative-argument)
     914             : ;; Define control-meta-digits.
     915             : (let ((i ?0))
     916             :   (while (<= i ?9)
     917             :     (define-key esc-map (read (format "[?\\C-%c]" i)) 'digit-argument)
     918             :     (setq i (1+ i))))
     919             : (define-key global-map [?\C-\M--] 'negative-argument)
     920             : 
     921             : ;; Update tutorial--default-keys if you change these.
     922             : (define-key global-map "\177" 'delete-backward-char)
     923             : ;; We explicitly want C-d to use `delete-char' instead of
     924             : ;; `delete-forward-char' so that it ignores `delete-active-region':
     925             : ;; Most C-d users are old-timers who don't expect
     926             : ;; `delete-active-region' here, while newer users who expect
     927             : ;; `delete-active-region' use C-d much less.
     928             : (define-key global-map "\C-d" 'delete-char)
     929             : 
     930             : (define-key global-map "\C-k" 'kill-line)
     931             : (define-key global-map "\C-w" 'kill-region)
     932             : (define-key esc-map "w" 'kill-ring-save)
     933             : (define-key esc-map "\C-w" 'append-next-kill)
     934             : (define-key global-map "\C-y" 'yank)
     935             : (define-key esc-map "y" 'yank-pop)
     936             : 
     937             : ;; (define-key ctl-x-map "a" 'append-to-buffer)
     938             : 
     939             : (define-key global-map "\C-@" 'set-mark-command)
     940             : ;; Many people are used to typing C-SPC and getting C-@.
     941             : (define-key global-map [?\C- ] 'set-mark-command)
     942             : (put 'set-mark-command :advertised-binding [?\C- ])
     943             : 
     944             : (define-key ctl-x-map "\C-x" 'exchange-point-and-mark)
     945             : (define-key ctl-x-map "\C-@" 'pop-global-mark)
     946             : (define-key ctl-x-map " " 'rectangle-mark-mode)
     947             : (define-key ctl-x-map [?\C- ] 'pop-global-mark)
     948             : 
     949             : (define-key global-map "\C-n" 'next-line)
     950             : (define-key global-map "\C-p" 'previous-line)
     951             : (define-key ctl-x-map "\C-n" 'set-goal-column)
     952             : (define-key global-map "\C-a" 'move-beginning-of-line)
     953             : (define-key global-map "\C-e" 'move-end-of-line)
     954             : 
     955             : (define-key ctl-x-map "`" 'next-error)
     956             : 
     957             : (defvar goto-map (make-sparse-keymap)
     958             :   "Keymap for navigation commands.")
     959             : (define-key esc-map "g" goto-map)
     960             : 
     961             : (define-key goto-map    "c" 'goto-char)
     962             : (define-key goto-map    "g" 'goto-line)
     963             : (define-key goto-map "\M-g" 'goto-line)
     964             : (define-key goto-map    "n" 'next-error)
     965             : (define-key goto-map "\M-n" 'next-error)
     966             : (define-key goto-map    "p" 'previous-error)
     967             : (define-key goto-map "\M-p" 'previous-error)
     968             : (define-key goto-map   "\t" 'move-to-column)
     969             : 
     970             : (defvar search-map (make-sparse-keymap)
     971             :   "Keymap for search related commands.")
     972             : (define-key esc-map "s" search-map)
     973             : 
     974             : (define-key search-map "o"    'occur)
     975             : (define-key search-map "\M-w" 'eww-search-words)
     976             : (define-key search-map "hr"   'highlight-regexp)
     977             : (define-key search-map "hp"   'highlight-phrase)
     978             : (define-key search-map "hl"   'highlight-lines-matching-regexp)
     979             : (define-key search-map "h."   'highlight-symbol-at-point)
     980             : (define-key search-map "hu"   'unhighlight-regexp)
     981             : (define-key search-map "hf"   'hi-lock-find-patterns)
     982             : (define-key search-map "hw"   'hi-lock-write-interactive-patterns)
     983             : 
     984             : ;;(defun function-key-error ()
     985             : ;;  (interactive)
     986             : ;;  (error "That function key is not bound to anything"))
     987             : 
     988             : (define-key global-map [menu] 'execute-extended-command)
     989             : (define-key global-map [find] 'search-forward)
     990             : 
     991             : ;; Don't do this.  We define <delete> in function-key-map instead.
     992             : ;(define-key global-map [delete] 'backward-delete-char)
     993             : 
     994             : ;; natural bindings for terminal keycaps --- defined in X keysym order
     995             : (define-key global-map [C-S-backspace]  'kill-whole-line)
     996             : (define-key global-map [home]           'move-beginning-of-line)
     997             : (define-key global-map [C-home]         'beginning-of-buffer)
     998             : (define-key global-map [M-home]         'beginning-of-buffer-other-window)
     999             : (define-key esc-map    [home]           'beginning-of-buffer-other-window)
    1000             : (define-key global-map [left]           'left-char)
    1001             : (define-key global-map [up]             'previous-line)
    1002             : (define-key global-map [right]          'right-char)
    1003             : (define-key global-map [down]           'next-line)
    1004             : (define-key global-map [prior]          'scroll-down-command)
    1005             : (define-key global-map [next]           'scroll-up-command)
    1006             : (define-key global-map [C-up]           'backward-paragraph)
    1007             : (define-key global-map [C-down]         'forward-paragraph)
    1008             : (define-key global-map [C-prior]        'scroll-right)
    1009             : (put 'scroll-left 'disabled t)
    1010             : (define-key global-map [C-next]         'scroll-left)
    1011             : (define-key global-map [M-next]         'scroll-other-window)
    1012             : (define-key esc-map    [next]           'scroll-other-window)
    1013             : (define-key global-map [M-prior]        'scroll-other-window-down)
    1014             : (define-key esc-map    [prior]          'scroll-other-window-down)
    1015             : (define-key esc-map [?\C-\S-v]          'scroll-other-window-down)
    1016             : (define-key global-map [end]            'move-end-of-line)
    1017             : (define-key global-map [C-end]          'end-of-buffer)
    1018             : (define-key global-map [M-end]          'end-of-buffer-other-window)
    1019             : (define-key esc-map    [end]            'end-of-buffer-other-window)
    1020             : (define-key global-map [begin]          'beginning-of-buffer)
    1021             : (define-key global-map [M-begin]        'beginning-of-buffer-other-window)
    1022             : (define-key esc-map    [begin]          'beginning-of-buffer-other-window)
    1023             : ;; (define-key global-map [select]      'function-key-error)
    1024             : ;; (define-key global-map [print]       'function-key-error)
    1025             : (define-key global-map [execute]        'execute-extended-command)
    1026             : (define-key global-map [insert]         'overwrite-mode)
    1027             : (define-key global-map [C-insert]       'kill-ring-save)
    1028             : (define-key global-map [S-insert]       'yank)
    1029             : ;; `insertchar' is what term.c produces.  Should we change term.c
    1030             : ;; to produce `insert' instead?
    1031             : (define-key global-map [insertchar]     'overwrite-mode)
    1032             : (define-key global-map [C-insertchar]   'kill-ring-save)
    1033             : (define-key global-map [S-insertchar]   'yank)
    1034             : (define-key global-map [undo]           'undo)
    1035             : (define-key global-map [redo]           'repeat-complex-command)
    1036             : (define-key global-map [again]          'repeat-complex-command) ; Sun keyboard
    1037             : (define-key global-map [open]           'find-file) ; Sun
    1038             : ;; The following wouldn't work to interrupt running code since C-g is
    1039             : ;; treated specially in the event loop.
    1040             : ;; (define-key global-map [stop]                'keyboard-quit) ; Sun
    1041             : ;; (define-key global-map [clearline]   'function-key-error)
    1042             : (define-key global-map [insertline]     'open-line)
    1043             : (define-key global-map [deleteline]     'kill-line)
    1044             : (define-key global-map [deletechar]     'delete-forward-char)
    1045             : ;; (define-key global-map [backtab]     'function-key-error)
    1046             : ;; (define-key global-map [f1]          'function-key-error)
    1047             : ;; (define-key global-map [f2]          'function-key-error)
    1048             : ;; (define-key global-map [f3]          'function-key-error)
    1049             : ;; (define-key global-map [f4]          'function-key-error)
    1050             : ;; (define-key global-map [f5]          'function-key-error)
    1051             : ;; (define-key global-map [f6]          'function-key-error)
    1052             : ;; (define-key global-map [f7]          'function-key-error)
    1053             : ;; (define-key global-map [f8]          'function-key-error)
    1054             : ;; (define-key global-map [f9]          'function-key-error)
    1055             : ;; (define-key global-map [f10]         'function-key-error)
    1056             : ;; (define-key global-map [f11]         'function-key-error)
    1057             : ;; (define-key global-map [f12]         'function-key-error)
    1058             : ;; (define-key global-map [f13]         'function-key-error)
    1059             : ;; (define-key global-map [f14]         'function-key-error)
    1060             : ;; (define-key global-map [f15]         'function-key-error)
    1061             : ;; (define-key global-map [f16]         'function-key-error)
    1062             : ;; (define-key global-map [f17]         'function-key-error)
    1063             : ;; (define-key global-map [f18]         'function-key-error)
    1064             : ;; (define-key global-map [f19]         'function-key-error)
    1065             : ;; (define-key global-map [f20]         'function-key-error)
    1066             : ;; (define-key global-map [f21]         'function-key-error)
    1067             : ;; (define-key global-map [f22]         'function-key-error)
    1068             : ;; (define-key global-map [f23]         'function-key-error)
    1069             : ;; (define-key global-map [f24]         'function-key-error)
    1070             : ;; (define-key global-map [f25]         'function-key-error)
    1071             : ;; (define-key global-map [f26]         'function-key-error)
    1072             : ;; (define-key global-map [f27]         'function-key-error)
    1073             : ;; (define-key global-map [f28]         'function-key-error)
    1074             : ;; (define-key global-map [f29]         'function-key-error)
    1075             : ;; (define-key global-map [f30]         'function-key-error)
    1076             : ;; (define-key global-map [f31]         'function-key-error)
    1077             : ;; (define-key global-map [f32]         'function-key-error)
    1078             : ;; (define-key global-map [f33]         'function-key-error)
    1079             : ;; (define-key global-map [f34]         'function-key-error)
    1080             : ;; (define-key global-map [f35]         'function-key-error)
    1081             : ;; (define-key global-map [kp-backtab]  'function-key-error)
    1082             : ;; (define-key global-map [kp-space]    'function-key-error)
    1083             : ;; (define-key global-map [kp-tab]              'function-key-error)
    1084             : ;; (define-key global-map [kp-enter]    'function-key-error)
    1085             : ;; (define-key global-map [kp-f1]               'function-key-error)
    1086             : ;; (define-key global-map [kp-f2]               'function-key-error)
    1087             : ;; (define-key global-map [kp-f3]               'function-key-error)
    1088             : ;; (define-key global-map [kp-f4]               'function-key-error)
    1089             : ;; (define-key global-map [kp-multiply] 'function-key-error)
    1090             : ;; (define-key global-map [kp-add]              'function-key-error)
    1091             : ;; (define-key global-map [kp-separator]        'function-key-error)
    1092             : ;; (define-key global-map [kp-subtract] 'function-key-error)
    1093             : ;; (define-key global-map [kp-decimal]  'function-key-error)
    1094             : ;; (define-key global-map [kp-divide]   'function-key-error)
    1095             : ;; (define-key global-map [kp-0]                'function-key-error)
    1096             : ;; (define-key global-map [kp-1]                'function-key-error)
    1097             : ;; (define-key global-map [kp-2]                'function-key-error)
    1098             : ;; (define-key global-map [kp-3]                'function-key-error)
    1099             : ;; (define-key global-map [kp-4]                'function-key-error)
    1100             : ;; (define-key global-map [kp-5]                'recenter)
    1101             : ;; (define-key global-map [kp-6]                'function-key-error)
    1102             : ;; (define-key global-map [kp-7]                'function-key-error)
    1103             : ;; (define-key global-map [kp-8]                'function-key-error)
    1104             : ;; (define-key global-map [kp-9]                'function-key-error)
    1105             : ;; (define-key global-map [kp-equal]    'function-key-error)
    1106             : 
    1107             : ;; X11R6 distinguishes these keys from the non-kp keys.
    1108             : ;; Make them behave like the non-kp keys unless otherwise bound.
    1109             : ;; FIXME: rather than list such mappings for every modifier-combination,
    1110             : ;;   we should come up with a way to do it generically, something like
    1111             : ;;   (define-key function-key-map [*-kp-home] [*-home])
    1112             : ;; Currently we add keypad key combinations with basic modifiers
    1113             : ;; (to complement plain bindings in "Keypad support" section in simple.el)
    1114             : ;; Until [*-kp-home] is implemented, for more modifiers we could also use:
    1115             : ;; (todo-powerset '(control meta shift hyper super alt))  (Bug#14397)
    1116             : (let ((modifiers '(nil (control) (meta) (control meta) (shift)
    1117             :                    (control shift) (meta shift) (control meta shift)))
    1118             :       (keys '((kp-delete delete) (kp-insert insert)
    1119             :               (kp-end end) (kp-down down) (kp-next next)
    1120             :               (kp-left left) (kp-begin begin) (kp-right right)
    1121             :               (kp-home home) (kp-up up) (kp-prior prior)
    1122             :               (kp-enter enter) (kp-decimal ?.)
    1123             :               (kp-0 ?0) (kp-1 ?1) (kp-2 ?2) (kp-3 ?3) (kp-4 ?4)
    1124             :               (kp-5 ?5) (kp-6 ?6) (kp-7 ?7) (kp-8 ?8) (kp-9 ?9)
    1125             :               (kp-add ?+) (kp-subtract ?-) (kp-multiply ?*) (kp-divide ?/))))
    1126             :   (dolist (pair keys)
    1127             :     (let ((keypad (nth 0 pair))
    1128             :           (normal (nth 1 pair)))
    1129             :       (when (characterp normal)
    1130             :         (put keypad 'ascii-character normal))
    1131             :       (dolist (mod modifiers)
    1132             :         (define-key function-key-map
    1133             :           (vector (append mod (list keypad)))
    1134             :           (vector (append mod (list normal))))))))
    1135             : 
    1136             : (define-key function-key-map [backspace] [?\C-?])
    1137             : (define-key function-key-map [delete] [?\C-?])
    1138             : (define-key function-key-map [kp-delete] [?\C-?])
    1139             : 
    1140             : ;; Don't bind shifted keypad numeric keys, they reportedly
    1141             : ;; interfere with the feature of some keyboards to produce
    1142             : ;; numbers when NumLock is off.
    1143             : ;(define-key function-key-map [S-kp-1] [S-end])
    1144             : ;(define-key function-key-map [S-kp-2] [S-down])
    1145             : ;(define-key function-key-map [S-kp-3] [S-next])
    1146             : ;(define-key function-key-map [S-kp-4] [S-left])
    1147             : ;(define-key function-key-map [S-kp-6] [S-right])
    1148             : ;(define-key function-key-map [S-kp-7] [S-home])
    1149             : ;(define-key function-key-map [S-kp-8] [S-up])
    1150             : ;(define-key function-key-map [S-kp-9] [S-prior])
    1151             : ;(define-key function-key-map [C-S-kp-1] [C-S-end])
    1152             : ;(define-key function-key-map [C-S-kp-2] [C-S-down])
    1153             : ;(define-key function-key-map [C-S-kp-3] [C-S-next])
    1154             : ;(define-key function-key-map [C-S-kp-4] [C-S-left])
    1155             : ;(define-key function-key-map [C-S-kp-6] [C-S-right])
    1156             : ;(define-key function-key-map [C-S-kp-7] [C-S-home])
    1157             : ;(define-key function-key-map [C-S-kp-8] [C-S-up])
    1158             : ;(define-key function-key-map [C-S-kp-9] [C-S-prior])
    1159             : 
    1160             : ;; Hitting C-SPC on text terminals, usually sends the ascii code 0 (aka C-@),
    1161             : ;; so we can't distinguish those two keys, but usually we consider C-SPC
    1162             : ;; (rather than C-@) as the "canonical" binding.
    1163             : (define-key function-key-map [?\C-@] [?\C-\s])
    1164             : ;; Many keyboards don't have a `backtab' key, so by convention the user
    1165             : ;; can use S-tab instead to access that binding.
    1166             : (define-key function-key-map [S-tab] [backtab])
    1167             : 
    1168             : (define-key global-map [mouse-movement] 'ignore)
    1169             : 
    1170             : (define-key global-map "\C-t" 'transpose-chars)
    1171             : (define-key esc-map "t" 'transpose-words)
    1172             : (define-key esc-map "\C-t" 'transpose-sexps)
    1173             : (define-key ctl-x-map "\C-t" 'transpose-lines)
    1174             : 
    1175             : (define-key esc-map ";" 'comment-dwim)
    1176             : (define-key esc-map "j" 'indent-new-comment-line)
    1177             : (define-key esc-map "\C-j" 'indent-new-comment-line)
    1178             : (define-key ctl-x-map ";" 'comment-set-column)
    1179             : (define-key ctl-x-map [?\C-\;] 'comment-line)
    1180             : (define-key ctl-x-map "f" 'set-fill-column)
    1181             : (define-key ctl-x-map "$" 'set-selective-display)
    1182             : 
    1183             : (define-key esc-map "@" 'mark-word)
    1184             : (define-key esc-map "f" 'forward-word)
    1185             : (define-key esc-map "b" 'backward-word)
    1186             : (define-key esc-map "d" 'kill-word)
    1187             : (define-key esc-map "\177" 'backward-kill-word)
    1188             : 
    1189             : (define-key esc-map "<" 'beginning-of-buffer)
    1190             : (define-key esc-map ">" 'end-of-buffer)
    1191             : (define-key ctl-x-map "h" 'mark-whole-buffer)
    1192             : (define-key esc-map "\\" 'delete-horizontal-space)
    1193             : 
    1194             : (defalias 'mode-specific-command-prefix (make-sparse-keymap))
    1195             : (defvar mode-specific-map (symbol-function 'mode-specific-command-prefix)
    1196             :   "Keymap for characters following C-c.")
    1197             : (define-key global-map "\C-c" 'mode-specific-command-prefix)
    1198             : 
    1199             : (global-set-key [M-right]  'right-word)
    1200             : (define-key esc-map [right] 'forward-word)
    1201             : (global-set-key [M-left]   'left-word)
    1202             : (define-key esc-map [left] 'backward-word)
    1203             : ;; ilya@math.ohio-state.edu says these bindings are standard on PC editors.
    1204             : (global-set-key [C-right]  'right-word)
    1205             : (global-set-key [C-left]   'left-word)
    1206             : ;; This is not quite compatible, but at least is analogous
    1207             : (global-set-key [C-delete] 'kill-word)
    1208             : (global-set-key [C-backspace] 'backward-kill-word)
    1209             : ;; This is "move to the clipboard", or as close as we come.
    1210             : (global-set-key [S-delete] 'kill-region)
    1211             : 
    1212             : (global-set-key [C-M-left]    'backward-sexp)
    1213             : (define-key esc-map [C-left]  'backward-sexp)
    1214             : (global-set-key [C-M-right]   'forward-sexp)
    1215             : (define-key esc-map [C-right] 'forward-sexp)
    1216             : (global-set-key [C-M-up]      'backward-up-list)
    1217             : (define-key esc-map [C-up]    'backward-up-list)
    1218             : (global-set-key [C-M-down]    'down-list)
    1219             : (define-key esc-map [C-down]  'down-list)
    1220             : (global-set-key [C-M-home]    'beginning-of-defun)
    1221             : (define-key esc-map [C-home]  'beginning-of-defun)
    1222             : (global-set-key [C-M-end]     'end-of-defun)
    1223             : (define-key esc-map [C-end]   'end-of-defun)
    1224             : 
    1225             : (define-key esc-map "\C-f" 'forward-sexp)
    1226             : (define-key esc-map "\C-b" 'backward-sexp)
    1227             : (define-key esc-map "\C-u" 'backward-up-list)
    1228             : (define-key esc-map "\C-@" 'mark-sexp)
    1229             : (define-key esc-map [?\C-\ ] 'mark-sexp)
    1230             : (define-key esc-map "\C-d" 'down-list)
    1231             : (define-key esc-map "\C-k" 'kill-sexp)
    1232             : ;;; These are dangerous in various situations,
    1233             : ;;; so let's not encourage anyone to use them.
    1234             : ;;;(define-key global-map [C-M-delete] 'backward-kill-sexp)
    1235             : ;;;(define-key global-map [C-M-backspace] 'backward-kill-sexp)
    1236             : (define-key esc-map [C-delete] 'backward-kill-sexp)
    1237             : (define-key esc-map [C-backspace] 'backward-kill-sexp)
    1238             : (define-key esc-map "\C-n" 'forward-list)
    1239             : (define-key esc-map "\C-p" 'backward-list)
    1240             : (define-key esc-map "\C-a" 'beginning-of-defun)
    1241             : (define-key esc-map "\C-e" 'end-of-defun)
    1242             : (define-key esc-map "\C-h" 'mark-defun)
    1243             : (define-key ctl-x-map "nd" 'narrow-to-defun)
    1244             : (define-key esc-map "(" 'insert-parentheses)
    1245             : (define-key esc-map ")" 'move-past-close-and-reindent)
    1246             : 
    1247             : (define-key ctl-x-map "\C-e" 'eval-last-sexp)
    1248             : 
    1249             : (define-key ctl-x-map "m" 'compose-mail)
    1250             : (define-key ctl-x-4-map "m" 'compose-mail-other-window)
    1251             : (define-key ctl-x-5-map "m" 'compose-mail-other-frame)
    1252             : 
    1253             : 
    1254             : (defvar ctl-x-r-map
    1255             :   (let ((map (make-sparse-keymap)))
    1256             :     (define-key map "c" 'clear-rectangle)
    1257             :     (define-key map "k" 'kill-rectangle)
    1258             :     (define-key map "d" 'delete-rectangle)
    1259             :     (define-key map "y" 'yank-rectangle)
    1260             :     (define-key map "o" 'open-rectangle)
    1261             :     (define-key map "t" 'string-rectangle)
    1262             :     (define-key map "N" 'rectangle-number-lines)
    1263             :     (define-key map "\M-w" 'copy-rectangle-as-kill)
    1264             :     (define-key map "\C-@" 'point-to-register)
    1265             :     (define-key map [?\C-\ ] 'point-to-register)
    1266             :     (define-key map " " 'point-to-register)
    1267             :     (define-key map "j" 'jump-to-register)
    1268             :     (define-key map "s" 'copy-to-register)
    1269             :     (define-key map "x" 'copy-to-register)
    1270             :     (define-key map "i" 'insert-register)
    1271             :     (define-key map "g" 'insert-register)
    1272             :     (define-key map "r" 'copy-rectangle-to-register)
    1273             :     (define-key map "n" 'number-to-register)
    1274             :     (define-key map "+" 'increment-register)
    1275             :     (define-key map "w" 'window-configuration-to-register)
    1276             :     (define-key map "f" 'frameset-to-register)
    1277             :     map)
    1278             :   "Keymap for subcommands of C-x r.")
    1279             : (define-key ctl-x-map "r" ctl-x-r-map)
    1280             : 
    1281             : (define-key esc-map "q" 'fill-paragraph)
    1282             : (define-key ctl-x-map "." 'set-fill-prefix)
    1283             : 
    1284             : (define-key esc-map "{" 'backward-paragraph)
    1285             : (define-key esc-map "}" 'forward-paragraph)
    1286             : (define-key esc-map "h" 'mark-paragraph)
    1287             : (define-key esc-map "a" 'backward-sentence)
    1288             : (define-key esc-map "e" 'forward-sentence)
    1289             : (define-key esc-map "k" 'kill-sentence)
    1290             : (define-key ctl-x-map "\177" 'backward-kill-sentence)
    1291             : 
    1292             : (define-key ctl-x-map "[" 'backward-page)
    1293             : (define-key ctl-x-map "]" 'forward-page)
    1294             : (define-key ctl-x-map "\C-p" 'mark-page)
    1295             : (define-key ctl-x-map "l" 'count-lines-page)
    1296             : (define-key ctl-x-map "np" 'narrow-to-page)
    1297             : ;; (define-key ctl-x-map "p" 'narrow-to-page)
    1298             : 
    1299             : (defvar abbrev-map (make-sparse-keymap)
    1300             :   "Keymap for abbrev commands.")
    1301             : (define-key ctl-x-map "a" abbrev-map)
    1302             : 
    1303             : (define-key abbrev-map "l" 'add-mode-abbrev)
    1304             : (define-key abbrev-map "\C-a" 'add-mode-abbrev)
    1305             : (define-key abbrev-map "g" 'add-global-abbrev)
    1306             : (define-key abbrev-map "+" 'add-mode-abbrev)
    1307             : (define-key abbrev-map "ig" 'inverse-add-global-abbrev)
    1308             : (define-key abbrev-map "il" 'inverse-add-mode-abbrev)
    1309             : ;; (define-key abbrev-map "\C-h" 'inverse-add-global-abbrev)
    1310             : (define-key abbrev-map "-" 'inverse-add-global-abbrev)
    1311             : (define-key abbrev-map "e" 'expand-abbrev)
    1312             : (define-key abbrev-map "'" 'expand-abbrev)
    1313             : ;; (define-key ctl-x-map "\C-a" 'add-mode-abbrev)
    1314             : ;; (define-key ctl-x-map "+" 'add-global-abbrev)
    1315             : ;; (define-key ctl-x-map "\C-h" 'inverse-add-mode-abbrev)
    1316             : ;; (define-key ctl-x-map "-" 'inverse-add-global-abbrev)
    1317             : (define-key esc-map "'" 'abbrev-prefix-mark)
    1318             : (define-key ctl-x-map "'" 'expand-abbrev)
    1319             : (define-key ctl-x-map "\C-b" 'list-buffers)
    1320             : 
    1321             : (define-key ctl-x-map "z" 'repeat)
    1322             : 
    1323             : (define-key esc-map "\C-l" 'reposition-window)
    1324             : 
    1325             : (define-key ctl-x-4-map "a" 'add-change-log-entry-other-window)
    1326             : (define-key ctl-x-4-map "c" 'clone-indirect-buffer-other-window)
    1327             : 
    1328             : ;; Signal handlers
    1329             : (define-key special-event-map [sigusr1] 'ignore)
    1330             : (define-key special-event-map [sigusr2] 'ignore)
    1331             : 
    1332             : ;; Don't look for autoload cookies in this file.
    1333             : ;; Local Variables:
    1334             : ;; no-update-autoloads: t
    1335             : ;; End:
    1336             : 
    1337             : ;;; bindings.el ends here

Generated by: LCOV version 1.12