;;; bindings.el --- define standard key bindings and some variables
-;; Copyright (C) 1985-1987, 1992-1996, 1999-2012
-;; Free Software Foundation, Inc.
+;; Copyright (C) 1985-1987, 1992-1996, 1999-2014 Free Software
+;; Foundation, Inc.
-;; Maintainer: FSF
+;; Maintainer: emacs-devel@gnu.org
;; Keywords: internal
;; Package: emacs
(defun mode-line-toggle-read-only (event)
"Like `toggle-read-only', for the mode-line."
(interactive "e")
- (save-selected-window
- (select-window (posn-window (event-start event)))
- (toggle-read-only nil t)
- (force-mode-line-update)))
+ (with-selected-window (posn-window (event-start event))
+ (read-only-mode 'toggle)))
(defun mode-line-toggle-modified (event)
"Toggle the buffer-modified flag from the mode-line."
(interactive "e")
- (save-selected-window
- (select-window (posn-window (event-start event)))
+ (with-selected-window (posn-window (event-start event))
(set-buffer-modified-p (not (buffer-modified-p)))
(force-mode-line-update)))
(defun mode-line-widen (event)
"Widen a buffer from the mode-line."
(interactive "e")
- (save-selected-window
- (select-window (posn-window (event-start event)))
+ (with-selected-window (posn-window (event-start event))
(widen)
(force-mode-line-update)))
(define-key map [mode-line mouse-2]
(lambda (e)
(interactive "e")
- (save-selected-window
- (select-window
- (posn-window (event-start e)))
+ (with-selected-window (posn-window (event-start e))
(toggle-input-method)
(force-mode-line-update))))
(define-key map [mode-line mouse-3]
(lambda (e)
(interactive "e")
- (save-selected-window
- (select-window
- (posn-window (event-start e)))
+ (with-selected-window (posn-window (event-start e))
(describe-current-input-method))))
(purecopy map)))
(define-key map [mode-line mouse-1]
(lambda (e)
(interactive "e")
- (save-selected-window
- (select-window (posn-window (event-start e)))
+ (with-selected-window (posn-window (event-start e))
(when (and enable-multibyte-characters
buffer-file-coding-system)
(describe-coding-system buffer-file-coding-system)))))
(define-key map [mode-line mouse-3]
(lambda (e)
(interactive "e")
- (save-selected-window
- (select-window (posn-window (event-start e)))
+ (with-selected-window (posn-window (event-start e))
(call-interactively 'set-buffer-file-coding-system))))
(purecopy map))
"Local keymap for the coding-system part of the mode line.")
If the text at the mouse position has a `help-echo' text
property, that overrides this variable."
:type '(choice (const :tag "No help" :value nil) string)
- :version "24.2"
+ :version "24.3"
:group 'mode-line)
(defvar mode-line-front-space '(:eval (if (display-graphic-p) " " "-"))
'mouse-face 'mode-line-highlight
'help-echo (purecopy (lambda (window _object _point)
(format "%s"
- (save-selected-window
- (select-window window)
+ (with-selected-window window
(concat
(if (file-remote-p default-directory)
"Current directory is remote: "
(defun mode-line-unbury-buffer (event) "\
Call `unbury-buffer' in this window."
(interactive "e")
- (save-selected-window
- (select-window (posn-window (event-start event)))
+ (with-selected-window (posn-window (event-start event))
(unbury-buffer)))
(defun mode-line-bury-buffer (event) "\
Like `bury-buffer', but temporarily select EVENT's window."
(interactive "e")
- (save-selected-window
- (select-window (posn-window (event-start event)))
+ (with-selected-window (posn-window (event-start event))
(bury-buffer)))
(defun mode-line-other-buffer () "\
(defun mode-line-next-buffer (event)
"Like `next-buffer', but temporarily select EVENT's window."
(interactive "e")
- (save-selected-window
- (select-window (posn-window (event-start event)))
+ (with-selected-window (posn-window (event-start event))
(next-buffer)))
(defun mode-line-previous-buffer (event)
"Like `previous-buffer', but temporarily select EVENT's window."
(interactive "e")
- (save-selected-window
- (select-window (posn-window (event-start event)))
+ (with-selected-window (posn-window (event-start event))
(previous-buffer)))
(defmacro bound-and-true-p (var)
(garbage-collect)
\f
-(setq help-event-list '(help f1))
+(setq help-event-list '(help f1 ?\?))
(make-variable-buffer-local 'minor-mode-overriding-map-alist)
(put 'narrow-to-region 'disabled t)
;; Moving with arrows in bidi-sensitive direction.
+(defcustom visual-order-cursor-movement nil
+ "If non-nil, moving cursor with arrow keys follows the visual order.
+
+When this is non-nil, \\[right-char] will move to the character that is
+to the right of point on display, and \\[left-char] will move to the left,
+disregarding the surrounding bidirectional context. Depending on the
+bidirectional context of the surrounding characters, this can move point
+many buffer positions away.
+
+When the text is entirely left-to-right, logical-order and visual-order
+cursor movements produce identical results."
+ :type '(choice (const :tag "Logical-order cursor movement" nil)
+ (const :tag "Visual-order cursor movement" t))
+ :group 'display
+ :version "24.4")
+
(defun right-char (&optional n)
"Move point N characters to the right (to the left if N is negative).
On reaching beginning or end of buffer, stop and signal error.
-Depending on the bidirectional context, this may move either forward
-or backward in the buffer. This is in contrast with \\[forward-char]
-and \\[backward-char], which see."
+If `visual-order-cursor-movement' is non-nil, this always moves
+to the right on display, wherever that is in the buffer.
+Otherwise, depending on the bidirectional context, this may move
+one position either forward or backward in the buffer. This is
+in contrast with \\[forward-char] and \\[backward-char], which
+see."
(interactive "^p")
- (if (eq (current-bidi-paragraph-direction) 'left-to-right)
- (forward-char n)
- (backward-char n)))
+ (if visual-order-cursor-movement
+ (dotimes (i (if (numberp n) (abs n) 1))
+ (move-point-visually (if (and (numberp n) (< n 0)) -1 1)))
+ (if (eq (current-bidi-paragraph-direction) 'left-to-right)
+ (forward-char n)
+ (backward-char n))))
(defun left-char ( &optional n)
"Move point N characters to the left (to the right if N is negative).
On reaching beginning or end of buffer, stop and signal error.
-Depending on the bidirectional context, this may move either backward
-or forward in the buffer. This is in contrast with \\[backward-char]
-and \\[forward-char], which see."
+If `visual-order-cursor-movement' is non-nil, this always moves
+to the left on display, wherever that is in the buffer.
+Otherwise, depending on the bidirectional context, this may move
+one position either backward or forward in the buffer. This is
+in contrast with \\[forward-char] and \\[backward-char], which
+see."
(interactive "^p")
- (if (eq (current-bidi-paragraph-direction) 'left-to-right)
- (backward-char n)
- (forward-char n)))
+ (if visual-order-cursor-movement
+ (dotimes (i (if (numberp n) (abs n) 1))
+ (move-point-visually (if (and (numberp n) (< n 0)) 1 -1)))
+ (if (eq (current-bidi-paragraph-direction) 'left-to-right)
+ (backward-char n)
+ (forward-char n))))
(defun right-word (&optional n)
"Move point N words to the right (to the left if N is negative).
;; suspend only the relevant terminal.
(substitute-key-definition 'suspend-emacs 'suspend-frame global-map)
-(define-key global-map "\C-j" 'newline-and-indent)
(define-key global-map "\C-m" 'newline)
(define-key global-map "\C-o" 'open-line)
(define-key esc-map "\C-o" 'split-line)
;; Update tutorial--default-keys if you change these.
(define-key global-map "\177" 'delete-backward-char)
+;; We explicitly want C-d to use `delete-char' instead of
+;; `delete-forward-char' so that it ignores `delete-active-region':
+;; Most C-d users are old-timers who don't expect
+;; `delete-active-region' here, while newer users who expect
+;; `delete-active-region' use C-d much less.
(define-key global-map "\C-d" 'delete-char)
(define-key global-map "\C-k" 'kill-line)
(define-key ctl-x-map "\C-x" 'exchange-point-and-mark)
(define-key ctl-x-map "\C-@" 'pop-global-mark)
+(define-key ctl-x-map " " 'rectangle-mark-mode)
(define-key ctl-x-map [?\C- ] 'pop-global-mark)
(define-key global-map "\C-n" 'next-line)
(define-key goto-map "\M-n" 'next-error)
(define-key goto-map "p" 'previous-error)
(define-key goto-map "\M-p" 'previous-error)
+(define-key goto-map "\t" 'move-to-column)
(defvar search-map (make-sparse-keymap)
"Keymap for search related commands.")
(define-key search-map "hr" 'highlight-regexp)
(define-key search-map "hp" 'highlight-phrase)
(define-key search-map "hl" 'highlight-lines-matching-regexp)
+(define-key search-map "h." 'highlight-symbol-at-point)
(define-key search-map "hu" 'unhighlight-regexp)
(define-key search-map "hf" 'hi-lock-find-patterns)
(define-key search-map "hw" 'hi-lock-write-interactive-patterns)
;; FIXME: rather than list such mappings for every modifier-combination,
;; we should come up with a way to do it generically, something like
;; (define-key function-key-map [*-kp-home] [*-home])
-(define-key function-key-map [kp-home] [home])
-(define-key function-key-map [kp-left] [left])
-(define-key function-key-map [kp-up] [up])
-(define-key function-key-map [kp-right] [right])
-(define-key function-key-map [kp-down] [down])
-(define-key function-key-map [kp-prior] [prior])
-(define-key function-key-map [kp-next] [next])
-(define-key function-key-map [M-kp-next] [M-next])
-(define-key function-key-map [kp-end] [end])
-(define-key function-key-map [kp-begin] [begin])
-(define-key function-key-map [kp-insert] [insert])
+;; Currently we add keypad key combinations with basic modifiers
+;; (to complement plain bindings in "Keypad support" section in simple.el)
+;; Until [*-kp-home] is implemented, for more modifiers we could also use:
+;; (todo-powerset '(control meta shift hyper super alt)) (Bug#14397)
+(let ((modifiers '(nil (control) (meta) (control meta) (shift)
+ (control shift) (meta shift) (control meta shift)))
+ (keys '((kp-delete delete) (kp-insert insert)
+ (kp-end end) (kp-down down) (kp-next next)
+ (kp-left left) (kp-begin begin) (kp-right right)
+ (kp-home home) (kp-up up) (kp-prior prior)
+ (kp-enter enter) (kp-decimal ?.)
+ (kp-0 ?0) (kp-1 ?1) (kp-2 ?2) (kp-3 ?3) (kp-4 ?4)
+ (kp-5 ?5) (kp-6 ?6) (kp-7 ?7) (kp-8 ?8) (kp-9 ?9)
+ (kp-add ?+) (kp-subtract ?-) (kp-multiply ?*) (kp-divide ?/))))
+ (dolist (pair keys)
+ (let ((keypad (nth 0 pair))
+ (normal (nth 1 pair)))
+ (when (characterp normal)
+ (put keypad 'ascii-character normal))
+ (dolist (mod modifiers)
+ (define-key function-key-map
+ (vector (append mod (list keypad)))
+ (vector (append mod (list normal))))))))
+
(define-key function-key-map [backspace] [?\C-?])
(define-key function-key-map [delete] [?\C-?])
(define-key function-key-map [kp-delete] [?\C-?])
-(define-key function-key-map [S-kp-end] [S-end])
-(define-key function-key-map [S-kp-down] [S-down])
-(define-key function-key-map [S-kp-next] [S-next])
-(define-key function-key-map [S-kp-left] [S-left])
-(define-key function-key-map [S-kp-right] [S-right])
-(define-key function-key-map [S-kp-home] [S-home])
-(define-key function-key-map [S-kp-up] [S-up])
-(define-key function-key-map [S-kp-prior] [S-prior])
-(define-key function-key-map [C-S-kp-end] [C-S-end])
-(define-key function-key-map [C-S-kp-down] [C-S-down])
-(define-key function-key-map [C-S-kp-next] [C-S-next])
-(define-key function-key-map [C-S-kp-left] [C-S-left])
-(define-key function-key-map [C-S-kp-right] [C-S-right])
-(define-key function-key-map [C-S-kp-home] [C-S-home])
-(define-key function-key-map [C-S-kp-up] [C-S-up])
-(define-key function-key-map [C-S-kp-prior] [C-S-prior])
+
;; Don't bind shifted keypad numeric keys, they reportedly
;; interfere with the feature of some keyboards to produce
;; numbers when NumLock is off.
;(define-key function-key-map [S-kp-7] [S-home])
;(define-key function-key-map [S-kp-8] [S-up])
;(define-key function-key-map [S-kp-9] [S-prior])
-(define-key function-key-map [C-S-kp-1] [C-S-end])
-(define-key function-key-map [C-S-kp-2] [C-S-down])
-(define-key function-key-map [C-S-kp-3] [C-S-next])
-(define-key function-key-map [C-S-kp-4] [C-S-left])
-(define-key function-key-map [C-S-kp-6] [C-S-right])
-(define-key function-key-map [C-S-kp-7] [C-S-home])
-(define-key function-key-map [C-S-kp-8] [C-S-up])
-(define-key function-key-map [C-S-kp-9] [C-S-prior])
+;(define-key function-key-map [C-S-kp-1] [C-S-end])
+;(define-key function-key-map [C-S-kp-2] [C-S-down])
+;(define-key function-key-map [C-S-kp-3] [C-S-next])
+;(define-key function-key-map [C-S-kp-4] [C-S-left])
+;(define-key function-key-map [C-S-kp-6] [C-S-right])
+;(define-key function-key-map [C-S-kp-7] [C-S-home])
+;(define-key function-key-map [C-S-kp-8] [C-S-up])
+;(define-key function-key-map [C-S-kp-9] [C-S-prior])
;; Hitting C-SPC on text terminals, usually sends the ascii code 0 (aka C-@),
;; so we can't distinguish those two keys, but usually we consider C-SPC
(define-key ctl-x-5-map "m" 'compose-mail-other-frame)
\f
-(defvar ctl-x-r-map (make-sparse-keymap)
+(defvar ctl-x-r-map
+ (let ((map (make-sparse-keymap)))
+ (define-key map "c" 'clear-rectangle)
+ (define-key map "k" 'kill-rectangle)
+ (define-key map "d" 'delete-rectangle)
+ (define-key map "y" 'yank-rectangle)
+ (define-key map "o" 'open-rectangle)
+ (define-key map "t" 'string-rectangle)
+ (define-key map "N" 'rectangle-number-lines)
+ (define-key map "\M-w" 'copy-rectangle-as-kill)
+ (define-key map "\C-@" 'point-to-register)
+ (define-key map [?\C-\ ] 'point-to-register)
+ (define-key map " " 'point-to-register)
+ (define-key map "j" 'jump-to-register)
+ (define-key map "s" 'copy-to-register)
+ (define-key map "x" 'copy-to-register)
+ (define-key map "i" 'insert-register)
+ (define-key map "g" 'insert-register)
+ (define-key map "r" 'copy-rectangle-to-register)
+ (define-key map "n" 'number-to-register)
+ (define-key map "+" 'increment-register)
+ (define-key map "w" 'window-configuration-to-register)
+ (define-key map "f" 'frameset-to-register)
+ map)
"Keymap for subcommands of C-x r.")
(define-key ctl-x-map "r" ctl-x-r-map)
HCoop / bpt / emacs.git / blobdiff