;;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
;;; Special formatting conventions are used in this file!
;;;
-;;; a backslash-newline is used at the beginning of a documentation string
+;;; A backslash-newline is used at the beginning of a documentation string
;;; when that string should be stored in the file etc/DOCnnn, not in core.
;;;
;;; Such strings read into Lisp as numbers (during the pure-loading phase).
"Local keymap for the coding-system part of the mode line.")
+(defun mode-line-change-eol ()
+ "Cycle through the various possible kinds of end-of-line styles."
+ (interactive)
+ (let ((eol (coding-system-eol-type buffer-file-coding-system)))
+ (set-buffer-file-coding-system
+ (cond ((eq eol 0) 'dos) ((eq eol 1) 'mac) (t 'unix)))))
+
+(defvar mode-line-eol-desc-cache nil)
+
+(defun mode-line-eol-desc ()
+ (let* ((eol (coding-system-eol-type buffer-file-coding-system))
+ (mnemonic (coding-system-eol-type-mnemonic buffer-file-coding-system))
+ (desc (assq eol mode-line-eol-desc-cache)))
+ (if (and desc (eq (cadr desc) mnemonic))
+ (cddr desc)
+ (if desc (setq mode-line-eol-desc-cache nil)) ;Flush the cache if stale.
+ (setq desc
+ (propertize
+ mnemonic
+ 'help-echo (format "%s end-of-line; mouse-3 to cycle"
+ (if (eq eol 0) "Unix-style LF"
+ (if (eq eol 1) "Dos-style CRLF"
+ (if (eq eol 2) "Mac-style CR"
+ "Undecided"))))
+ 'keymap
+ (eval-when-compile
+ (let ((map (make-sparse-keymap)))
+ (define-key map [mode-line mouse-3] 'mode-line-change-eol)
+ map))))
+ (push (cons eol (cons mnemonic desc)) mode-line-eol-desc-cache)
+ desc)))
+
(defvar mode-line-mule-info
`(""
(current-input-method
- (:eval
- ,(purecopy
- '(propertize current-input-method-title
- 'help-echo (concat
- "Input method: "
- current-input-method
- ". mouse-2: disable, mouse-3: describe")
- 'local-map mode-line-input-method-map))))
+ (:propertize ("" current-input-method-title)
+ help-echo (concat
+ "Input method: "
+ current-input-method
+ ". mouse-2: disable, mouse-3: describe")
+ local-map ,mode-line-input-method-map))
,(propertize
- "%Z"
+ "%z"
'help-echo
- (purecopy (lambda (window object point)
- (save-window-excursion
- (select-window window)
- ;; Don't show this tip if the coding system is nil,
- ;; it reads like a bug, and is not useful anyway.
- (when buffer-file-coding-system
- (if enable-multibyte-characters
- (concat (symbol-name buffer-file-coding-system)
- " buffer; mouse-3: describe coding system")
- (concat "Unibyte "
- (symbol-name buffer-file-coding-system)
- " buffer"))))))
- 'local-map mode-line-coding-system-map))
+ #'(lambda (window object point)
+ (with-current-buffer (window-buffer window)
+ ;; Don't show this tip if the coding system is nil,
+ ;; it reads like a bug, and is not useful anyway.
+ (when buffer-file-coding-system
+ (if enable-multibyte-characters
+ (concat (symbol-name buffer-file-coding-system)
+ " buffer; mouse-3: describe coding system")
+ (concat "Unibyte " (symbol-name buffer-file-coding-system)
+ " buffer")))))
+ 'local-map mode-line-coding-system-map)
+ (:eval (mode-line-eol-desc)))
"Mode-line control for displaying information of multilingual environment.
Normally it displays current input method (if any activated) and
mnemonics of the following coding systems:
coding system for saving or writing the current buffer
coding system for keyboard input (if Emacs is running on terminal)
coding system for terminal output (if Emacs is running on terminal)"
-;;; Currently not:
-;;; coding system for decoding output of buffer process (if any)
-;;; coding system for encoding text to send to buffer process (if any)."
+ ;; Currently not:
+ ;; coding system for decoding output of buffer process (if any)
+ ;; coding system for encoding text to send to buffer process (if any)."
)
(make-variable-buffer-local 'mode-line-mule-info)
(defvar mode-line-modes nil
"Mode-line control for displaying major and minor modes.")
-(defvar mode-line-minor-mode-keymap nil "\
-Keymap to display on major and minor modes.")
+(defvar mode-line-major-mode-keymap
+ (let ((map (make-sparse-keymap)))
+ (define-key map [mode-line mouse-2] 'describe-mode)
+ (define-key map [mode-line down-mouse-3] 'mode-line-mode-menu-1)
+ map) "\
+Keymap to display on major mode.")
-;; Menu of minor modes.
-(let ((map (make-sparse-keymap)))
- (define-key map [mode-line down-mouse-3] 'mode-line-mode-menu-1)
- (define-key map [header-line down-mouse-3] 'mode-line-mode-menu-1)
- (setq mode-line-minor-mode-keymap map))
+(defvar mode-line-minor-mode-keymap
+ (let ((map (make-sparse-keymap)))
+ (define-key map [mode-line mouse-2] 'mode-line-minor-mode-help)
+ (define-key map [mode-line down-mouse-3] 'mode-line-mode-menu-1)
+ (define-key map [header-line down-mouse-3] 'mode-line-mode-menu-1)
+ map) "\
+Keymap to display on minor modes.")
(let* ((help-echo
;; The multi-line message doesn't work terribly well on the
;; "\
;; mouse-1: select window, mouse-2: delete others, mouse-3: delete,
;; drag-mouse-1: resize, C-mouse-2: split horizontally"
- "mouse-1: select (drag to resize), mouse-2: delete others, mouse-3: delete")
+ "mouse-1: select (drag to resize), mouse-2: delete others, mouse-3: delete this")
(dashes (propertize "--" 'help-echo help-echo)))
(setq-default mode-line-format
(list
'mode-line-frame-identification
'mode-line-buffer-identification
(propertize " " 'help-echo help-echo)
- 'global-mode-string
+ 'mode-line-position
+ '(vc-mode vc-mode)
+ (propertize " " 'help-echo help-echo)
'mode-line-modes
`(which-func-mode ("" which-func-format ,dashes))
- 'mode-line-position
+ `(global-mode-string (,dashes global-mode-string))
(propertize "-%-" 'help-echo help-echo)))
(setq-default mode-line-modes
(list
- (propertize " %[(" 'help-echo help-echo)
- `(:propertize ("" mode-name mode-line-process minor-mode-alist)
- help-echo "mouse-3: minor mode menu"
+ (propertize "%[(" 'help-echo help-echo)
+ `(:propertize ("" mode-name)
+ help-echo "mouse-2: help for current major mode"
+ local-map ,mode-line-major-mode-keymap)
+ `(:propertize ("" mode-line-process))
+ `(:propertize ("" minor-mode-alist)
+ help-echo "mouse-2: help for minor modes, mouse-3: minor mode menu"
local-map ,mode-line-minor-mode-keymap)
(propertize "%n" 'help-echo "mouse-2: widen"
'local-map (make-mode-line-mouse-map
(propertize ")%]--" 'help-echo help-echo)))
(setq-default mode-line-position
- `((line-number-mode (,(propertize "L%l" 'help-echo help-echo) ,dashes))
- (column-number-mode (,(propertize "C%c" 'help-echo help-echo) ,dashes))
- (-3 . ,(propertize "%p" 'help-echo help-echo)))))
+ `((-3 . ,(propertize "%p" 'help-echo help-echo))
+ (line-number-mode
+ ((column-number-mode
+ (10 ,(propertize " (%l,%c)" 'help-echo help-echo))
+ (6 ,(propertize " L%l" 'help-echo help-echo))))
+ ((column-number-mode
+ (5 ,(propertize " C%c" 'help-echo help-echo))))))))
(defvar mode-line-buffer-identification-keymap nil "\
Keymap for what is displayed by `mode-line-buffer-identification'.")
(defun last-buffer () "\
Return the last non-hidden buffer in the buffer list."
- (let ((list (reverse (buffer-list))))
- (while (eq (aref (buffer-name (car list)) 0) ? )
- (setq list (cdr list)))
- (car list)))
+ ;; This logic is more or less copied from bury-buffer,
+ ;; except that we reverse the buffer list.
+ (let ((list (nreverse (buffer-list (selected-frame))))
+ (pred (frame-parameter nil 'buffer-predicate))
+ found notsogood)
+ (while (and list (not found))
+ (unless (or (eq (aref (buffer-name (car list)) 0) ? )
+ ;; If the selected frame has a buffer_predicate,
+ ;; disregard buffers that don't fit the predicate.
+ (and pred (not (funcall pred (car list)))))
+ (if (get-buffer-window (car list) 'visible)
+ (or notsogood (eq (car list) (current-buffer)))
+ (setq found (car list))))
+ (pop list))
+ (or found notsogood
+ (get-buffer "*scratch*")
+ (progn
+ (set-buffer-major-mode
+ (get-buffer-create "*scratch*"))
+ (get-buffer "*scratch*")))))
(defun unbury-buffer () "\
Switch to the last buffer in the buffer list."
`(menu-item ,(purecopy "Hide ifdef (Ifdef)") hide-ifdef-mode
:button (:toggle . (bound-and-true-p hide-ifdef-mode))))
(define-key mode-line-mode-menu [font-lock-mode]
- `(menu-item ,(purecopy "Font-lock") font-lock-mode
+ `(menu-item ,(purecopy "Font Lock") font-lock-mode
:button (:toggle . font-lock-mode)))
(define-key mode-line-mode-menu [flyspell-mode]
`(menu-item ,(purecopy "Flyspell (Fly)") flyspell-mode
`(menu-item ,(purecopy "Column number") column-number-mode
:button (:toggle . column-number-mode)))
(define-key mode-line-mode-menu [auto-fill-mode]
- `(menu-item ,(purecopy "Auto-fill (Fill)") auto-fill-mode
+ `(menu-item ,(purecopy "Auto Fill (Fill)") auto-fill-mode
:button (:toggle . auto-fill-function)))
(define-key mode-line-mode-menu [auto-revert-mode]
`(menu-item ,(purecopy "Auto revert (ARev)") auto-revert-mode
(interactive "@e")
(x-popup-menu event mode-line-mode-menu))
+(defun mode-line-minor-mode-help (event)
+ "Describe minor mode for EVENT occured on minor modes area of the mode line."
+ (interactive "@e")
+ (let ((indicator (car (nth 4 (car (cdr event))))))
+ (describe-minor-mode-from-indicator indicator)))
+
;; Add menu of buffer operations to the buffer identification part
;; of the mode line.or header line.
;
".fasl" ".ufsl" ".fsl" ".dxl"
;; Libtool
".lo" ".la"
+ ;; Gettext
+ ".gmo" ".mo"
;; Texinfo-related
".toc" ".log" ".aux"
".cp" ".fn" ".ky" ".pg" ".tp" ".vr"
(make-variable-buffer-local 'minor-mode-overriding-map-alist)
-;; From macros.c
-(define-key ctl-x-map "(" 'start-kbd-macro)
-(define-key ctl-x-map ")" 'end-kbd-macro)
-(define-key ctl-x-map "e" 'call-last-kbd-macro)
;; From frame.c
(global-set-key [switch-frame] 'handle-switch-frame)
+(global-set-key [select-window] 'handle-select-window)
+
+;; FIXME: Do those 3 events really ever reach the global-map ?
+;; It seems that they can't because they're handled via
+;; special-event-map which is used at very low-level. -stef
(global-set-key [delete-frame] 'handle-delete-frame)
(global-set-key [iconify-frame] 'ignore-event)
(global-set-key [make-frame-visible] 'ignore-event)
;(define-key global-map [delete] 'backward-delete-char)
;; natural bindings for terminal keycaps --- defined in X keysym order
+(define-key global-map [C-S-backspace] 'kill-whole-line)
(define-key global-map [home] 'beginning-of-line)
(define-key global-map [C-home] 'beginning-of-buffer)
(define-key global-map [M-home] 'beginning-of-buffer-other-window)
(define-key esc-map [?\C-\ ] 'mark-sexp)
(define-key esc-map "\C-d" 'down-list)
(define-key esc-map "\C-k" 'kill-sexp)
-(define-key global-map [C-M-delete] 'backward-kill-sexp)
-(define-key global-map [C-M-backspace] 'backward-kill-sexp)
+;;; These are dangerous in various situations,
+;;; so let's not encourage anyone to use them.
+;;;(define-key global-map [C-M-delete] 'backward-kill-sexp)
+;;;(define-key global-map [C-M-backspace] 'backward-kill-sexp)
(define-key esc-map [C-delete] 'backward-kill-sexp)
(define-key esc-map [C-backspace] 'backward-kill-sexp)
(define-key esc-map "\C-n" 'forward-list)