* ansi-color.el (ansi-color-faces-vector): Change default faces.
* cus-edit.el (mode-line):
* dframe.el (dframe-mouse-hscroll):
* emacs-lisp/re-builder.el:
* emacs-lisp/easy-mmode.el (define-minor-mode):
* frame.el (set-frame-name):
* help.el (lookup-minor-mode-from-indicator):
* net/rcirc.el (rcirc-activity-string, rcirc-short-buffer-name):
* progmodes/cc-cmds.el (c-toggle-auto-newline)
(c-toggle-hungry-state):
* progmodes/antlr-mode.el (antlr-language-alist):
* progmodes/idlw-shell.el (idlwave-shell-electric-stop-line-face):
* progmodes/vhdl-mode.el (vhdl-mode):
* progmodes/which-func.el (which-func, which-func-cleanup-function):
* term/ns-win.el (ns-face-at-pos):
* term/sup-mouse.el (sup-mouse-report):
* textmodes/flyspell.el (flyspell-mode-line-string):
* textmodes/ispell.el (ispell-highlight-face):
* textmodes/reftex-global.el:
* vc/vc-arch.el (vc-arch-mode-line-string):
* vc/vc-cvs.el (vc-cvs-mode-line-string):
* vc/vc-git.el (vc-git-mode-line-string):
* vc/vc-hooks.el (vc-display-status)
(vc-default-mode-line-string):
* vc/vc-mtn.el (vc-mtn-mode-line-string): Doc fixes.
* dired.el (dired-sort-set-mode-line): Rename from
dired-sort-set-modeline. All callers changed.
* foldout.el (foldout-mode-line-string): Rename from
foldout-modeline-string. All callers changed.
(foldout-update-mode-line): Rename from foldout-update-modeline.
* strokes.el (strokes-lighter): Rename from
strokes-modeline-string.
* subr.el (redraw-modeline): Make into obsolete alias.
* calendar/timeclock.el (timeclock-mode-line-display): Rename from
timeclock-modeline-display. Make old name an alias.
(timeclock-update-mode-line): Likewise. All callers changed.
(timeclock-mode-line-display): No need to check before using
add-hook.
(timeclock-relative, timeclock-day-over-hook)
(timeclock-use-elapsed, timeclock-mode-string)
(timeclock-mode-line-display): Doc fix, "modeline" -> "mode line".
* emulation/crisp.el (crisp-mode-mode-line-string): Rename from
crisp-mode-modeline-string.
* erc-track.el (erc-track, erc-track-faces-priority-list)
(erc-track-faces-normal-list, erc-track-find-face)
(erc-track-modified-channels): Fix modeline -> mode line in docs.
* eshell/esh-mode.el (eshell-status-in-mode-line): Rename from
eshell-status-in-modeline.
* org-clock.el (org-clock-string-limit)
(org-clock-modeline-total, org-clock-task-overrun-text)
(org-clock-mode-line-entry): Doc fix, "modeline" -> "mode line".
* play/solitaire.el (solitaire-build-mode-line): Rename from
solitaire-build-modeline. All callers changed.
* play/zone.el (zone-hiding-mode-line): Rename from
zone-hiding-modeline. All callers changed.
(zone): Remove unusued `modeline-hidden-level' property.
* progmodes/xscheme.el (xscheme-mode-line-initialize): Rename from
xscheme-modeline-initialize. All callers changed.
* textmodes/sgml-mode.el (html-face-tag-alist)
(html-tag-face-alist): Use mode-line face instead of obsolete
alias modeline.
Fixes: debbugs:10329
+2012-06-02 Chong Yidong <cyd@gnu.org>
+
+ Remove incorrect uses of "modeline" in comments, docstrings, and
+ function/variable names (Bug#10329).
+
+ * cus-edit.el (mode-line):
+ * dframe.el (dframe-mouse-hscroll):
+ * emacs-lisp/re-builder.el:
+ * emacs-lisp/easy-mmode.el (define-minor-mode):
+ * frame.el (set-frame-name):
+ * help.el (lookup-minor-mode-from-indicator):
+ * net/rcirc.el (rcirc-activity-string, rcirc-short-buffer-name):
+ * progmodes/cc-cmds.el (c-toggle-auto-newline)
+ (c-toggle-hungry-state):
+ * progmodes/antlr-mode.el (antlr-language-alist):
+ * progmodes/idlw-shell.el (idlwave-shell-electric-stop-line-face):
+ * progmodes/vhdl-mode.el (vhdl-mode):
+ * progmodes/which-func.el (which-func, which-func-cleanup-function):
+ * term/ns-win.el (ns-face-at-pos):
+ * term/sup-mouse.el (sup-mouse-report):
+ * textmodes/flyspell.el (flyspell-mode-line-string):
+ * textmodes/ispell.el (ispell-highlight-face):
+ * textmodes/reftex-global.el:
+ * vc/vc-arch.el (vc-arch-mode-line-string):
+ * vc/vc-cvs.el (vc-cvs-mode-line-string):
+ * vc/vc-git.el (vc-git-mode-line-string):
+ * vc/vc-hooks.el (vc-display-status)
+ (vc-default-mode-line-string):
+ * vc/vc-mtn.el (vc-mtn-mode-line-string): Doc fixes.
+
+ * ansi-color.el (ansi-color-faces-vector): Change default faces.
+
+ * dired.el (dired-sort-set-mode-line): Rename from
+ dired-sort-set-modeline. All callers changed.
+
+ * eshell/esh-mode.el (eshell-status-in-mode-line): Rename from
+ eshell-status-in-modeline.
+
+ * foldout.el (foldout-mode-line-string): Rename from
+ foldout-modeline-string. All callers changed.
+ (foldout-update-mode-line): Rename from foldout-update-modeline.
+
+ * subr.el (redraw-modeline): Make into obsolete alias.
+
+ * calendar/timeclock.el (timeclock-mode-line-display): Rename from
+ timeclock-modeline-display. Make old name an alias.
+ (timeclock-update-mode-line): Likewise. All callers changed.
+ (timeclock-mode-line-display): No need to check before using
+ add-hook.
+ (timeclock-relative, timeclock-day-over-hook)
+ (timeclock-use-elapsed, timeclock-mode-string)
+ (timeclock-mode-line-display): Doc fix, "modeline" -> "mode line".
+
+ * emulation/crisp.el (crisp-mode-mode-line-string): Rename from
+ crisp-mode-modeline-string.
+
+ * play/solitaire.el (solitaire-build-mode-line): Rename from
+ solitaire-build-modeline. All callers changed.
+
+ * play/zone.el (zone-hiding-mode-line): Rename from
+ zone-hiding-modeline. All callers changed.
+ (zone): Remove unusued `modeline-hidden-level' property.
+
+ * progmodes/xscheme.el (xscheme-mode-line-initialize): Rename from
+ xscheme-modeline-initialize. All callers changed.
+
+ * strokes.el (strokes-lighter): Rename from
+ strokes-modeline-string.
+
+ * textmodes/sgml-mode.el (html-face-tag-alist)
+ (html-tag-face-alist): Use mode-line face instead of obsolete
+ alias modeline.
+
2012-06-02 Stefan Merten <smerten@oekonux.de>
* textmodes/rst.el: Always require `cl'.
:group 'processes)
(defcustom ansi-color-faces-vector
- [default bold default italic underline bold bold-italic modeline]
+ [default bold default italic underline success warning error]
"Faces used for SGR control sequences determining a face.
This vector holds the faces used for SGR control sequence parameters 0
to 7.
2 faint default
3 italic italic
4 underlined underline
- 5 slowly blinking bold
- 6 rapidly blinking bold-italic
- 7 negative image modeline
+ 5 slowly blinking success
+ 6 rapidly blinking warning
+ 7 negative image error
Note that the symbol `default' is special: It will not be combined
with the current face.
(cond
((not (get-buffer-window calculator-buffer))
(let ((window-min-height 2))
- ;; maybe leave two lines for our window because of the normal
- ;; `raised' modeline in Emacs 21
+ ;; maybe leave two lines for our window because of the
+ ;; normal `raised' mode line
(select-window
(split-window-below
- ;; If the modeline might interfere with the calculator buffer,
- ;; use 3 lines instead.
+ ;; If the mode line might interfere with the calculator
+ ;; buffer, use 3 lines instead.
(if (and (fboundp 'face-attr-construct)
(let* ((dh (plist-get (face-attr-construct 'default) :height))
- (mf (face-attr-construct 'modeline))
+ (mf (face-attr-construct 'mode-line))
(mh (plist-get mf :height)))
- ;; If the modeline is shorter than the default,
+ ;; If the mode line is shorter than the default,
;; stick with 2 lines. (It may be necessary to
;; check how much shorter.)
(and
(not (integerp mh))
(< mh 1))))
(or
- ;; If the modeline is taller than the default,
+ ;; If the mode line is taller than the default,
;; use 3 lines.
(and (integerp dh)
(integerp mh)
(and (numberp mh)
(not (integerp mh))
(> mh 1))
- ;; If the modeline has a box with non-negative line-width,
+ ;; If the mode line has a box with non-negative line-width,
;; use 3 lines.
(let* ((bx (plist-get mf :box))
(lh (plist-get bx :line-width)))
(or
(not lh)
(> lh 0))))
- ;; If the modeline has an overline, use 3 lines.
- (plist-get (face-attr-construct 'modeline) :overline)))))
+ ;; If the mode line has an overline, use 3 lines.
+ (plist-get (face-attr-construct 'mode-line) :overline)))))
-3 -2)))
(switch-to-buffer calculator-buffer)))
((not (eq (current-buffer) calculator-buffer))
;; (define-key ctl-x-map "to" 'timeclock-out)
;; (define-key ctl-x-map "tc" 'timeclock-change)
;; (define-key ctl-x-map "tr" 'timeclock-reread-log)
-;; (define-key ctl-x-map "tu" 'timeclock-update-modeline)
+;; (define-key ctl-x-map "tu" 'timeclock-update-mode-line)
;; (define-key ctl-x-map "tw" 'timeclock-when-to-leave-string)
;; If you want Emacs to display the amount of time "left" to your
-;; workday in the modeline, you can either set the value of
-;; `timeclock-modeline-display' to t using M-x customize, or you
-;; can add this code to your .emacs file:
+;; workday in the mode-line, you can either set the value of
+;; `timeclock-mode-line-display' to t using M-x customize, or you can
+;; add this code to your .emacs file:
;;
;; (require 'timeclock)
-;; (timeclock-modeline-display)
+;; (timeclock-mode-line-display)
;;
-;; To cancel this modeline display at any time, just call
-;; `timeclock-modeline-display' again.
+;; To cancel this mode line display at any time, just call
+;; `timeclock-mode-line-display' again.
;; You may also want Emacs to ask you before exiting, if you are
;; currently working on a project. This can be done either by setting
Tuesday is twelve hours -- relative to an averaged work period of
eight hours -- or eight hours, non-relative. So relative time takes
into account any discrepancy of time under-worked or over-worked on
-previous days. This only affects the timeclock modeline display."
+previous days. This only affects the timeclock mode line display."
:type 'boolean
:group 'timeclock)
;; For byte-compiler.
(defvar display-time-hook)
-(defvar timeclock-modeline-display)
+(defvar timeclock-mode-line-display)
(defcustom timeclock-use-display-time t
- "If non-nil, use `display-time-hook' for doing modeline updates.
+ "If non-nil, use `display-time-hook' for doing mode line updates.
The advantage of this is that one less timer has to be set running
amok in Emacs's process space. The disadvantage is that it requires
you to have `display-time' running. If you don't want to use
-`display-time', but still want the modeline to show how much time is
+`display-time', but still want the mode line to show how much time is
left, set this variable to nil. Changing the value of this variable
-while timeclock information is being displayed in the modeline has no
-effect. You should call the function `timeclock-modeline-display' with
+while timeclock information is being displayed in the mode line has no
+effect. You should call the function `timeclock-mode-line-display' with
a positive argument to force an update."
:set (lambda (symbol value)
(let ((currently-displaying
- (and (boundp 'timeclock-modeline-display)
- timeclock-modeline-display)))
+ (and (boundp 'timeclock-mode-line-display)
+ timeclock-mode-line-display)))
;; if we're changing to the state that
- ;; `timeclock-modeline-display' is already using, don't
+ ;; `timeclock-mode-line-display' is already using, don't
;; bother toggling it. This happens on the initial loading
;; of timeclock.el.
(if (and currently-displaying
(or (and value
(boundp 'display-time-hook)
- (memq 'timeclock-update-modeline
+ (memq 'timeclock-update-mode-line
display-time-hook))
(and (not value)
timeclock-update-timer)))
(setq currently-displaying nil))
(and currently-displaying
- (set-variable 'timeclock-modeline-display nil))
+ (set-variable 'timeclock-mode-line-display nil))
(setq timeclock-use-display-time value)
(and currently-displaying
- (set-variable 'timeclock-modeline-display t))
+ (set-variable 'timeclock-mode-line-display t))
timeclock-use-display-time))
:type 'boolean
:group 'timeclock
(defcustom timeclock-day-over-hook nil
"A hook that is run when the workday has been completed.
This hook is only run if the current time remaining is being displayed
-in the modeline. See the variable `timeclock-modeline-display'."
+in the mode line. See the variable `timeclock-mode-line-display'."
:type 'hook
:group 'timeclock)
will be the same as `timeclock-discrepancy'.")
(defvar timeclock-use-elapsed nil
- "Non-nil if the modeline should display time elapsed, not remaining.")
+ "Non-nil if the mode line should display time elapsed, not remaining.")
(defvar timeclock-last-period nil
"Integer representing the number of seconds in the last period.
function `timeclock-last-period'.")
(defvar timeclock-mode-string nil
- "The timeclock string (optionally) displayed in the modeline.
+ "The timeclock string (optionally) displayed in the mode line.
The time is bracketed by <> if you are clocked in, otherwise by [].")
(defvar timeclock-day-over nil
;;; User Functions:
+(define-obsolete-function-alias 'timeclock-modeline-display
+ 'timeclock-mode-line-display "24.2")
+
;;;###autoload
-(defun timeclock-modeline-display (&optional arg)
- "Toggle display of the amount of time left today in the modeline.
+(defun timeclock-mode-line-display (&optional arg)
+ "Toggle display of the amount of time left today in the mode line.
If `timeclock-use-display-time' is non-nil (the default), then
-the function `display-time-mode' must be active, and the modeline
+the function `display-time-mode' must be active, and the mode line
will be updated whenever the time display is updated. Otherwise,
the timeclock will use its own sixty second timer to do its
-updating. With prefix ARG, turn modeline display on if and only
-if ARG is positive. Returns the new status of timeclock modeline
+updating. With prefix ARG, turn mode line display on if and only
+if ARG is positive. Returns the new status of timeclock mode line
display (non-nil means on)."
(interactive "P")
;; cf display-time-mode.
(or global-mode-string (setq global-mode-string '("")))
(let ((on-p (if arg
(> (prefix-numeric-value arg) 0)
- (not timeclock-modeline-display))))
+ (not timeclock-mode-line-display))))
(if on-p
(progn
(or (memq 'timeclock-mode-string global-mode-string)
(setq global-mode-string
(append global-mode-string '(timeclock-mode-string))))
- (unless (memq 'timeclock-update-modeline timeclock-event-hook)
- (add-hook 'timeclock-event-hook 'timeclock-update-modeline))
+ (add-hook 'timeclock-event-hook 'timeclock-update-mode-line)
(when timeclock-update-timer
(cancel-timer timeclock-update-timer)
(setq timeclock-update-timer nil))
(if (boundp 'display-time-hook)
- (remove-hook 'display-time-hook 'timeclock-update-modeline))
+ (remove-hook 'display-time-hook 'timeclock-update-mode-line))
(if timeclock-use-display-time
(progn
;; Update immediately so there is a visible change
;; on calling this function.
- (if display-time-mode (timeclock-update-modeline)
+ (if display-time-mode
+ (timeclock-update-mode-line)
(message "Activate `display-time-mode' or turn off \
`timeclock-use-display-time' to see timeclock information"))
- (add-hook 'display-time-hook 'timeclock-update-modeline))
+ (add-hook 'display-time-hook 'timeclock-update-mode-line))
(setq timeclock-update-timer
- (run-at-time nil 60 'timeclock-update-modeline))))
+ (run-at-time nil 60 'timeclock-update-mode-line))))
(setq global-mode-string
(delq 'timeclock-mode-string global-mode-string))
- (remove-hook 'timeclock-event-hook 'timeclock-update-modeline)
+ (remove-hook 'timeclock-event-hook 'timeclock-update-mode-line)
(if (boundp 'display-time-hook)
(remove-hook 'display-time-hook
- 'timeclock-update-modeline))
+ 'timeclock-update-mode-line))
(when timeclock-update-timer
(cancel-timer timeclock-update-timer)
(setq timeclock-update-timer nil)))
(force-mode-line-update)
- (setq timeclock-modeline-display on-p)))
+ (setq timeclock-mode-line-display on-p)))
;; This has to be here so that the function definition of
-;; `timeclock-modeline-display' is known to the "set" function.
-(defcustom timeclock-modeline-display nil
- "Toggle modeline display of time remaining.
+;; `timeclock-mode-line-display' is known to the "set" function.
+(defcustom timeclock-mode-line-display nil
+ "Toggle mode line display of time remaining.
You must modify via \\[customize] for this variable to have an effect."
:set (lambda (symbol value)
- (setq timeclock-modeline-display
- (timeclock-modeline-display (or value 0))))
+ (setq timeclock-mode-line-display
+ (timeclock-mode-line-display (or value 0))))
:type 'boolean
:group 'timeclock
:require 'timeclock)
(interactive)
(setq timeclock-discrepancy nil)
(timeclock-find-discrep)
- (if (and timeclock-discrepancy timeclock-modeline-display)
- (timeclock-update-modeline))
+ (if (and timeclock-discrepancy timeclock-mode-line-display)
+ (timeclock-update-mode-line))
timeclock-discrepancy)
(defun timeclock-seconds-to-string (seconds &optional show-seconds
(timeclock-completing-read "Reason for clocking out: "
(mapcar 'list timeclock-reason-list)))
-(defun timeclock-update-modeline ()
- "Update the `timeclock-mode-string' displayed in the modeline.
+(define-obsolete-function-alias 'timeclock-update-modeline
+ 'timeclock-update-mode-line "24.2")
+
+(defun timeclock-update-mode-line ()
+ "Update the `timeclock-mode-string' displayed in the mode line.
The value of `timeclock-relative' affects the display as described in
that variable's documentation."
(interactive)
:group 'editing)
(defgroup mode-line nil
- "Content of the modeline."
+ "Contents of the mode line."
:group 'environment)
(defgroup editing-basics nil
;;; The `custom' Widget.
(defface custom-button
- '((((type x w32 ns) (class color)) ; Like default modeline
+ '((((type x w32 ns) (class color)) ; Like default mode line
(:box (:line-width 2 :style released-button)
:background "lightgrey" :foreground "black"))
(t
(defun dframe-needed-height (&optional frame)
"The needed height for the tool bar FRAME (in characters)."
(or frame (setq frame (selected-frame)))
- ;; The 1 is the missing modeline/minibuffer
+ ;; The 1 is the missing mode line or minibuffer
(+ 1 (/ (frame-pixel-height frame)
;; This obscure code avoids a byte compiler warning in Emacs.
(let ((f 'face-height))
(switch-to-buffer buffer)
(call-interactively 'switch-to-buffer nil nil)))
-;; XEmacs: this can be implemented using modeline keymaps, but there
+;; XEmacs: this can be implemented using mode line keymaps, but there
;; is no use, as we have horizontal scrollbar (as the docstring
;; hints.)
(defun dframe-mouse-hscroll (e)
((> click-col (- (window-width) 5))
(scroll-right 2))
(t (dframe-message
- "Click on the edge of the modeline to scroll left/right")))
- ))
+ "Click on the edge of the mode line to scroll left/right")))))
(provide 'dframe)
(hack-local-variables))
;; Delete this stuff: `eobp' is used to find last subdir by dired.el.
(delete-region opoint (point-max)))
- ;; Make sure that the modeline shows the proper information.
- (dired-sort-set-modeline))))
+ ;; Make sure that the mode line shows the proper information.
+ (dired-sort-set-mode-line))))
(make-obsolete 'dired-hack-local-variables
'hack-dir-local-variables-non-file-buffer "24.1")
"Non-nil means the Dired sort command is disabled.
The idea is to set this buffer-locally in special dired buffers.")
-(defun dired-sort-set-modeline ()
- ;; Set modeline display according to dired-actual-switches.
- ;; Modeline display of "by name" or "by date" guarantees the user a
+(defun dired-sort-set-mode-line ()
+ ;; Set mode line display according to dired-actual-switches.
+ ;; Mode line display of "by name" or "by date" guarantees the user a
;; match with the corresponding regexps. Non-matching switches are
;; shown literally.
(when (eq major-mode 'dired-mode)
(concat "Dired " dired-actual-switches)))))
(force-mode-line-update)))
+(define-obsolete-function-alias 'dired-sort-set-modeline
+ 'dired-sort-set-mode-line "24.2")
+
(defun dired-sort-toggle-or-edit (&optional arg)
"Toggle sorting by date, and refresh the Dired buffer.
With a prefix argument, edit the current listing switches instead."
;; Now, if we weren't sorting by date before, add the -t switch.
(unless sorting-by-date
(setq dired-actual-switches (concat dired-actual-switches " -t"))))
- (dired-sort-set-modeline)
+ (dired-sort-set-mode-line)
(revert-buffer))
;; Some user code loads dired especially for this.
With optional second arg NO-REVERT, don't refresh the listing afterwards."
(dired-sort-R-check switches)
(setq dired-actual-switches switches)
- (dired-sort-set-modeline)
+ (dired-sort-set-mode-line)
(or no-revert (revert-buffer)))
(defvar dired-subdir-alist-pre-R nil
;;;***
\f
;;;### (autoloads (dired-do-relsymlink dired-jump-other-window dired-jump)
-;;;;;; "dired-x" "dired-x.el" "d09d49d54080e60ad6ecee5573b4e517")
+;;;;;; "dired-x" "dired-x.el" "d2461aa6efb8c1d7de8f245728ab448e")
;;; Generated autoloads from dired-x.el
(autoload 'dired-jump "dired-x" "\
function adds a basic doc-string stating these facts.
Optional INIT-VALUE is the initial value of the mode's variable.
-Optional LIGHTER is displayed in the modeline when the mode is on.
+Optional LIGHTER is displayed in the mode line when the mode is on.
Optional KEYMAP is the default keymap bound to the mode keymap.
If non-nil, it should be a variable name (whose value is a keymap),
or an expression that returns either a keymap or a list of
;; the target buffer are marked automatically with colored overlays
;; (for non-color displays see below) giving you feedback over the
;; extents of the matched (sub) expressions. The (non-)validity is
-;; shown only in the modeline without throwing the errors at you. If
+;; shown only in the mode line without throwing the errors at you. If
;; you want to know the reason why RE Builder considers it as invalid
;; call `reb-force-update' ("\C-c\C-u") which should reveal the error.
;; by default run `save-buffers-kill-emacs' instead of the command
;; `execute-extended-command'.
-;; Finally, if you want to change the string displayed in the modeline
-;; when this mode is in effect, override the definition of
-;; `crisp-mode-modeline-string' in your .emacs. The default value is
+;; Finally, if you want to change the string displayed in the mode
+;; line when this mode is in effect, override the definition of
+;; `crisp-mode-mode-line-string' in your .emacs. The default value is
;; " *Crisp*" which may be a bit lengthy if you have a lot of things
;; being displayed there.
All the bindings are done here instead of globally to try and be
nice to the world.")
-(defcustom crisp-mode-modeline-string " *CRiSP*"
- "String to display in the modeline when CRiSP emulation mode is enabled."
+(defcustom crisp-mode-mode-line-string " *CRiSP*"
+ "String to display in the mode line when CRiSP emulation mode is enabled."
:type 'string
:group 'crisp)
+(define-obsolete-variable-alias 'crisp-mode-modeline-string
+ 'crisp-mode-mode-line-string "24.2")
+
;;;###autoload
(defcustom crisp-mode nil
"Track status of CRiSP emulation mode.
and disable it otherwise. If called from Lisp, enable the mode
if ARG is omitted or nil."
:keymap crisp-mode-map
- :lighter crisp-mode-modeline-string
+ :lighter crisp-mode-mode-line-string
(when crisp-mode
;; Make menu entries show M-u or f14 in preference to C-x u.
(put 'undo :advertised-binding
(defun viper-adjust-window ()
(let ((win-height (if (featurep 'xemacs)
(window-displayed-height)
- (1- (window-height)))) ; adjust for modeline
+ (1- (window-height)))) ; adjust for mode line
(pt (point))
at-top-p at-bottom-p
min-scroll direction)
+2012-06-02 Chong Yidong <cyd@gnu.org>
+
+ * erc-track.el (erc-track, erc-track-faces-priority-list)
+ (erc-track-faces-normal-list, erc-track-find-face)
+ (erc-track-modified-channels): Fix modeline -> mode line in docs.
+
2012-05-14 Mike Kazantsev <mk.fraggod@gmail.com> (tiny change)
* erc-dcc.el (erc-dcc-handle-ctcp-send): Fix a regression
;;; Code:
(defgroup erc-track nil
- "Track active buffers and show activity in the modeline."
+ "Track active buffers and show activity in the mode line."
:group 'erc)
(defcustom erc-track-enable-keybindings 'ask
erc-notice-face
erc-input-face
erc-prompt-face)
- "A list of faces used to highlight active buffer names in the modeline.
+ "A list of faces used to highlight active buffer names in the mode line.
If a message contains one of the faces in this list, the buffer name will
be highlighted using that face. The first matching face is used."
:group 'erc-track
erc-default-face
erc-action-face)
"A list of faces considered to be part of normal conversations.
-This list is used to highlight active buffer names in the modeline.
+This list is used to highlight active buffer names in the mode line.
If a message contains one of the faces in this list, and the
-previous modeline face for this buffer is also in this list, then
+previous mode line face for this buffer is also in this list, then
the buffer name will be highlighted using the face from the
message. This gives a rough indication that active conversations
are occurring in these channels.
(erc-modified-channels-display)))
(defun erc-track-find-face (faces)
- "Return the face to use in the modeline from the faces in FACES.
+ "Return the face to use in the mode line from the faces in FACES.
If `erc-track-faces-priority-list' is set, the one from FACES who
is first in that list will be used. If nothing matches or if
`erc-track-faces-priority-list' is not set, the default mode-line
(defun erc-track-modified-channels ()
"Hook function for `erc-insert-post-hook' to check if the current
-buffer should be added to the modeline as a hidden, modified
+buffer should be added to the mode line as a hidden, modified
channel. Assumes it will only be called when current-buffer
is in `erc-mode'."
(let ((this-channel (or (erc-default-target)
:type '(choice (const nil) function)
:group 'eshell-mode)
-(defcustom eshell-status-in-modeline t
- "If non-nil, let the user know a command is running in the modeline."
+(defcustom eshell-status-in-mode-line t
+ "If non-nil, let the user know a command is running in the mode line."
:type 'boolean
:group 'eshell-mode)
+(define-obsolete-variable-alias 'eshell-status-in-modeline
+ 'eshell-status-in-mode-line "24.2")
+
(defvar eshell-first-time-p t
"A variable which is non-nil the first time Eshell is loaded.")
(setq eshell-mode-map (make-sparse-keymap))
(use-local-map eshell-mode-map)
- (when eshell-status-in-modeline
+ (when eshell-status-in-mode-line
(make-local-variable 'eshell-command-running-string)
(let ((fmt (copy-sequence mode-line-format)))
(make-local-variable 'mode-line-format)
(setq mode-line-format fmt))
- (let ((modeline (memq 'mode-line-modified mode-line-format)))
- (if modeline
- (setcar modeline 'eshell-command-running-string))))
+ (let ((mode-line-elt (memq 'mode-line-modified mode-line-format)))
+ (if mode-line-elt
+ (setcar mode-line-elt 'eshell-command-running-string))))
(define-key eshell-mode-map [return] 'eshell-send-input)
(define-key eshell-mode-map [(control ?m)] 'eshell-send-input)
(when eshell-scroll-show-maximum-output
(set (make-local-variable 'scroll-conservatively) 1000))
- (when eshell-status-in-modeline
+ (when eshell-status-in-mode-line
(add-hook 'eshell-pre-command-hook 'eshell-command-started nil t)
(add-hook 'eshell-post-command-hook 'eshell-command-finished nil t))
(put 'eshell-mode 'mode-class 'special)
(defun eshell-command-started ()
- "Indicate in the modeline that a command has started."
+ "Indicate in the mode line that a command has started."
(setq eshell-command-running-string "**")
(force-mode-line-update))
(defun eshell-command-finished ()
- "Indicate in the modeline that a command has finished."
+ "Indicate in the mode line that a command has finished."
(setq eshell-command-running-string "--")
(force-mode-line-update))
;; look under one of the level-2 headings, position the cursor on it and do C-c
;; C-z again. This exposes the level-2 body and its level-3 child subheadings
;; and narrows the buffer again. You can keep on zooming in on successive
-;; subheadings as much as you like. A string in the modeline tells you how
+;; subheadings as much as you like. A string in the mode line tells you how
;; deep you've gone.
;;
;; When zooming in on a heading you might only want to see the child
;; shows only the subheadings.
;; 1.2 28-Jan-94
-;; Fixed a dumb bug - didn't make `foldout-modeline-string' buffer-local :-(
+;; Fixed a dumb bug - didn't make `foldout-mode-line-string' buffer-local :-(
;;
;; Changed `foldout-exit-fold' to use prefix arg to say how many folds to exit.
;; Negative arg means exit but don't hide text. Zero arg means exit all folds.
An end marker of nil means the fold ends after (point-max).")
(make-variable-buffer-local 'foldout-fold-list)
-(defvar foldout-modeline-string nil
- "Modeline string announcing that we are in an outline fold.")
-(make-variable-buffer-local 'foldout-modeline-string)
+(defvar foldout-mode-line-string nil
+ "Mode line string announcing that we are in an outline fold.")
+(make-variable-buffer-local 'foldout-mode-line-string)
;; put our minor mode string immediately following outline-minor-mode's
-(or (assq 'foldout-modeline-string minor-mode-alist)
+(or (assq 'foldout-mode-line-string minor-mode-alist)
(let ((outl-entry (memq (assq 'outline-minor-mode minor-mode-alist)
minor-mode-alist))
- (foldout-entry '((foldout-modeline-string foldout-modeline-string))))
+ (foldout-entry '((foldout-mode-line-string foldout-mode-line-string))))
;; something's wrong with outline if we can't find it
(if (null outl-entry)
(setq foldout-fold-list (cons (cons start-marker end-marker)
foldout-fold-list))
- ;; update the modeline
- (foldout-update-modeline)
+ ;; update the mode line
+ (foldout-update-mode-line)
)))
\f
;; zap the markers so they don't slow down editing
(set-marker start-marker nil)
- (if end-marker (set-marker end-marker nil))
- )
+ (if end-marker (set-marker end-marker nil)))
;; narrow to the enclosing fold if there is one
(if foldout-fold-list
(narrow-to-region start-marker
(if end-marker
(1- (marker-position end-marker))
- (point-max)))
- ))
+ (point-max)))))
(recenter)
- ;; update the modeline
- (foldout-update-modeline)
- ))
+ ;; update the mode line
+ (foldout-update-mode-line)))
\f
-(defun foldout-update-modeline ()
- "Set the modeline string to indicate our fold depth."
+(defun foldout-update-mode-line ()
+ "Set the mode line to indicate our fold depth."
(let ((depth (length foldout-fold-list)))
- (setq foldout-modeline-string
+ (setq foldout-mode-line-string
(cond
;; if we're not in a fold, keep quiet
((zerop depth)
nil)
- ;; in outline-minor-mode we're after "Outl:xx" in the modeline
+ ;; in outline-minor-mode we're after "Outl:xx" in the mode line
(outline-minor-mode
(format ":%d" depth))
;; otherwise just announce the depth (I guess we're in outline-mode)
((= depth 1)
" Inside 1 fold")
(t
- (format " Inside %d folds" depth))
- ))))
+ (format " Inside %d folds" depth))))))
\f
(defun foldout-mouse-zoom (event)
;;(message "forms: proceeding setup...")
- ;; Since we aren't really implementing a minor mode, we hack the modeline
+ ;; Since we aren't really implementing a minor mode, we hack the mode line
;; directly to get the text " View " into forms-read-only form buffers. For
;; that reason, this variable must be buffer only.
(make-local-variable 'minor-mode-alist)
(defun set-frame-name (name)
"Set the name of the selected frame to NAME.
When called interactively, prompt for the name of the frame.
-The frame name is displayed on the modeline if the terminal displays only
-one frame, otherwise the name is displayed on the frame's caption bar."
+On text terminals, the frame name is displayed on the mode line.
+On graphical displays, it is displayed on the frame's title bar."
(interactive "sFrame name: ")
(modify-frame-parameters (selected-frame)
(list (cons 'name name))))
(error "Cannot find minor mode for `%s'" indicator))))
(defun lookup-minor-mode-from-indicator (indicator)
- "Return a minor mode symbol from its indicator on the modeline."
+ "Return a minor mode symbol from its indicator on the mode line."
;; remove first space if existed
(if (and (< 0 (length indicator))
(eq (aref indicator 0) ?\s))
;; Use the symbol `robin-use-package' as the third argument.
-;; The fourth argument is the prompt that appears in modeline when this
+;; The fourth argument is the prompt that appears in mode line when this
;; input method is active.
;; The fifth argument is a documentation string; it may or may not be
;;; Load the options file
(if (and (not noninteractive)
(and (locate-library eudc-options-file)
- (progn (message "") t)) ; Remove modeline message
+ (progn (message "") t)) ; Remove mode line message
(not (featurep 'eudc-options-file)))
(load eudc-options-file))
-;; newst-ticker.el --- modeline ticker for newsticker.
+;; newst-ticker.el --- mode line ticker for newsticker.
;; Copyright (C) 2003-2012 Free Software Foundation, Inc.
;; -----
;; The command newsticker-show-news will display all available headlines in
;; a special buffer, called `*newsticker*'. It will also start the
-;; asynchronous download of headlines. The modeline in the `*newsticker*'
+;; asynchronous download of headlines. The mode line in the `*newsticker*'
;; buffer informs whenever new headlines have arrived. Clicking
;; mouse-button 2 or pressing RET in this buffer on a headline will call
;; browse-url to load the corresponding news story in your favorite web
;; one-to-one communication.
;; Rcirc has simple defaults and clear and consistent behavior.
-;; Message arrival timestamps, activity notification on the modeline,
+;; Message arrival timestamps, activity notification on the mode line,
;; message filling, nick completion, and keepalive pings are all
;; enabled by default, but can easily be adjusted or turned off. Each
;; discussion takes place in its own buffer and there is a single
"List of buffers with unviewed activity.")
(defvar rcirc-activity-string ""
- "String displayed in modeline representing `rcirc-activity'.")
+ "String displayed in mode line representing `rcirc-activity'.")
(put 'rcirc-activity-string 'risky-local-variable t)
(defvar rcirc-server-buffer nil
(buffer-disable-undo)
(buffer-enable-undo))
- ;; record modeline activity
+ ;; record mode line activity
(when (and activity
(not rcirc-ignore-buffer-activity-flag)
(not (and rcirc-dim-nicks sender
buffers ","))
(defun rcirc-short-buffer-name (buffer)
- "Return a short name for BUFFER to use in the modeline indicator."
+ "Return a short name for BUFFER to use in the mode line indicator."
(with-current-buffer buffer
(or rcirc-short-buffer-name (buffer-name))))
;; 4. Spaces followed by a TAB. (Almost always, we never want that).
;; 5. Spaces or TABS at the end of a line.
;;
-;; Whitespace errors are reported in a buffer, and on the modeline.
+;; Whitespace errors are reported in a buffer, and on the mode line.
;;
-;; Modeline will show a W:<x>!<y> to denote a particular type of whitespace,
+;; Mode line will show a W:<x>!<y> to denote a particular type of whitespace,
;; where `x' and `y' can be one (or more) of:
;;
;; e - End-of-Line whitespace.
;; s - Space followed by Tab.
;; t - Trailing whitespace.
;;
-;; If any of the whitespace checks is turned off, the modeline will display a
+;; If any of the whitespace checks is turned off, the mode line will display a
;; !<y>.
;;
;; (since (3) is the most controversial one, here is the rationale: Most
:group 'whitespace)
(defcustom whitespace-silent nil
- "All whitespace errors will be shown only in the modeline when t.
+ "All whitespace errors will be shown only in the mode line when t.
Note that setting this may cause all whitespaces introduced in a file to go
unnoticed when the buffer is killed, unless the user visits the `*Whitespace
nil)))
(defun whitespace-update-modeline (&optional whitespace-err)
- "Update modeline with whitespace errors.
+ "Update mode line with whitespace errors.
Also with whitespaces whose testing has been turned off."
(if whitespace-display-in-modeline
(progn
+2012-06-02 Chong Yidong <cyd@gnu.org>
+
+ * org-clock.el (org-clock-string-limit)
+ (org-clock-modeline-total, org-clock-task-overrun-text)
+ (org-clock-mode-line-entry): Doc fix, "modeline" -> "mode line".
+
2012-05-27 Mark Shoulson <mark@kli.org> (tiny change)
* org.el (org-fontify-entities): Fix bug: The entities \sup[123] and
:type 'function)
(defcustom org-clock-string-limit 0
- "Maximum length of clock strings in the modeline. 0 means no limit."
+ "Maximum length of clock strings in the mode line. 0 means no limit."
:group 'org-clock
:type 'integer)
(file :tag "Play sound file")))
(defcustom org-clock-modeline-total 'auto
- "Default setting for the time included for the modeline clock.
+ "Default setting for the time included for the mode line clock.
This can be overruled locally using the CLOCK_MODELINE_TOTAL property.
Allowed values are:
(defvaralias 'org-task-overrun-text 'org-clock-task-overrun-text)
(defcustom org-clock-task-overrun-text nil
- "The extra modeline text that should indicate that the clock is overrun.
+ "Extra mode line text to indicate that the clock is overrun.
The can be nil to indicate that instead of adding text, the clock time
should get a different face (`org-mode-line-clock-overrun').
When this is a string, it is prepended to the clock string as an indication,
(= 0 (call-process "which" nil nil nil program-name))))
(defvar org-clock-mode-line-entry nil
- "Information for the modeline about the running clock.")
+ "Information for the mode line about the running clock.")
(defun org-find-open-clocks (file)
"Search through the given file and find all open clocks."
(setq buffer-read-only t)
(setq solitaire-stones 32)
(solitaire-insert-board)
- (solitaire-build-modeline)
+ (solitaire-build-mode-line)
(goto-char (point-max))
(setq solitaire-center (search-backward "."))
(setq buffer-undo-list (list (point)))))
-(defun solitaire-build-modeline ()
+(defun solitaire-build-mode-line ()
(setq mode-line-format
(list "" "---" 'mode-line-buffer-identification
(if (< 1 solitaire-stones)
(insert ?o)
(goto-char target)
(setq solitaire-stones (1- solitaire-stones))
- (solitaire-build-modeline)
+ (solitaire-build-mode-line)
(if solitaire-auto-eval (solitaire-do-check))))))
(defun solitaire-undo (arg)
(<= (solitaire-current-line) solitaire-end-y)
(setq count (1+ count))))
count)))
- (solitaire-build-modeline)
+ (solitaire-build-mode-line)
(when solitaire-auto-eval (solitaire-do-check)))
(defun solitaire-check ()
;; Bored by the zone pyrotechnics? Write your own! Add it to
;; `zone-programs'. See `zone-call' for higher-ordered zoning.
-;; WARNING: Not appropriate for Emacs sessions over modems or
-;; computers as slow as mine.
-
;; THANKS: Christopher Mayer, Scott Flinchbaugh,
;; Rachel Kalmar, Max Froumentin, Juri Linkov,
;; Luigi Panzeri, John Paul Wallington.
`(with-current-buffer (get 'zone 'orig-buffer)
,@body))
-(defmacro zone-hiding-modeline (&rest body)
+(defmacro zone-hiding-mode-line (&rest body)
;; This formerly worked by temporarily altering face `mode-line',
;; which did not even work right, it seems.
`(let (mode-line-format)
(wp (1+ (- (window-point (selected-window))
(window-start)))))
(put 'zone 'orig-buffer (current-buffer))
- (put 'zone 'modeline-hidden-level 0)
(switch-to-buffer outbuf)
(setq mode-name "Zone")
(erase-buffer)
(setq ok (zerop (forward-line 1))
lines (cons (buffer-substring p (point)) lines))))
(sit-for 5)
- (zone-hiding-modeline
+ (zone-hiding-mode-line
(let ((msg "Zoning... (zone-pgm-stress)"))
(while (not (string= msg ""))
(message (setq msg (substring msg 1)))
(defun zone-pgm-stress-destress ()
(zone-call 'zone-pgm-stress 25)
- (zone-hiding-modeline
+ (zone-hiding-mode-line
(sit-for 3)
(erase-buffer)
(sit-for 3)
(goto-char new-pos)
(goto-char (point-min))
(proced-move-to-goal-column)))
- ;; update modeline
- ;; Does the long `mode-name' clutter the modeline? It would be nice
+ ;; update mode line
+ ;; Does the long `mode-name' clutter the mode line? It would be nice
;; to have some other location for displaying the values of the various
;; flags that affect the behavior of proced (flags one might want
;; to change on the fly). Where??
;; should be loaded before the ada-mode, which will then setup some variables
;; to improve the support for Ada code.
;; Here is the list of these modes:
-;; `which-function-mode': Display in the modeline the name of the subprogram
+;; `which-function-mode': Display in the mode line the name of the subprogram
;; the cursor is in.
;; `outline-mode': Provides the capability to collapse or expand the code
;; for specific language constructs, for instance if you want to hide the
(re-search-backward ada-imenu-subprogram-menu-re nil t))
;; Get the function name, but not the properties, or this changes
- ;; the face in the modeline on Emacs 21
+ ;; the face in the mode line on Emacs 21
(setq func-name (match-string-no-properties 3))
(if (and (not (ada-in-comment-p))
(not (save-excursion
value of `antlr-language' if the first group in the string matched by
REGEXP in `antlr-language-limit-n-regexp' is one of the OPTION-VALUEs.
An OPTION-VALUE of nil denotes the fallback element. MODELINE-STRING is
-also displayed in the modeline next to \"Antlr\"."
+also displayed in the mode line next to \"Antlr\"."
:group 'antlr
:type '(repeat (group :value (java-mode "")
(function :tag "Major mode")
- (string :tag "Modeline string")
+ (string :tag "Mode line string")
(repeat :tag "ANTLR language option" :inline t
(choice (const :tag "Default" nil)
string )))))
Turning on auto-newline automatically enables electric indentation.
When the auto-newline feature is enabled (indicated by \"/la\" on the
-modeline after the mode name) newlines are automatically inserted
+mode line after the mode name) newlines are automatically inserted
after special characters such as brace, comma, semi-colon, and colon."
(interactive "P")
(setq c-auto-newline
left out.
When the hungry-delete-key feature is enabled (indicated by \"/h\" on
-the modeline after the mode name) the delete key gobbles all preceding
+the mode line after the mode name) the delete key gobbles all preceding
whitespace in one fell swoop."
(interactive "P")
(setq c-hungry-delete-key (c-calculate-state arg c-hungry-delete-key))
(cons proc compilation-in-progress)))
;; No asynchronous processes available.
(message "Executing `%s'..." command)
- ;; Fake modeline display as if `start-process' were run.
+ ;; Fake mode line display as if `start-process' were run.
(setq mode-line-process
(list (propertize ":run" 'face 'compilation-warning)))
(force-mode-line-update)
(defcustom idlwave-shell-electric-stop-line-face
(prog1
- (copy-face 'modeline 'idlwave-shell-electric-stop-line)
+ (copy-face 'mode-line 'idlwave-shell-electric-stop-line)
(set-face-background 'idlwave-shell-electric-stop-line
idlwave-shell-electric-stop-color)
(condition-case nil
In addition, if an inferior Scheme process is running, some additional
commands will be defined, for evaluating expressions and controlling
the interpreter, and the state of the process will be displayed in the
-modeline of all Scheme buffers. The names of commands that interact
+mode line of all Scheme buffers. The names of commands that interact
with the Scheme process start with \"xscheme-\" if you use the MIT
Scheme-specific `xscheme' package; for more information see the
documentation for `xscheme-interaction-mode'. Use \\[run-scheme] to
brackets and removed if the queried string is left empty. Prompts for
mandatory arguments remain in the code if the queried string is left
empty. They can be queried again by `C-c C-t C-q'. Enabled
- electrification is indicated by `/e' in the modeline.
+ electrification is indicated by `/e' in the mode line.
Typing `M-SPC' after a keyword inserts a space without calling the
template generator. Automatic template generation (i.e.
Double striking of some keys inserts cumbersome VHDL syntax elements.
Stuttering can be disabled (enabled) by typing `C-c C-m C-s' or by
option `vhdl-stutter-mode'. Enabled stuttering is indicated by `/s' in
- the modeline. The stuttering keys and their effects are:
+ the mode line. The stuttering keys and their effects are:
;; --> \" : \" [ --> ( -- --> comment
;;; --> \" := \" [[ --> [ --CR --> comment-out code
"String to display in the mode line when current function is unknown.")
(defgroup which-func nil
- "Display the current function name in the modeline."
+ "Display the current function name in the mode line."
:group 'tools
:version "20.3")
(defvar which-func-cleanup-function nil
"Function to transform a string before displaying it in the mode line.
The function is called with one argument, the string to display.
-Its return value is displayed in the modeline.
+Its return value is displayed in the mode line.
If nil, no function is called. The default value is nil.
This feature can be useful if Imenu is set up to make more
(defconst default-xscheme-runlight
'(": " xscheme-runlight-string)
- "Default global (shared) xscheme-runlight modeline format.")
+ "Default global (shared) xscheme-runlight mode line format.")
(defvar xscheme-runlight "")
(defvar xscheme-runlight-string nil)
in the minibuffer. If an error occurs, the process buffer will
automatically pop up to show you the error message.
-While the Scheme process is running, the modelines of all buffers in
+While the Scheme process is running, the mode lines of all buffers in
scheme-mode are modified to show the state of the process. The
possible states and their meanings are:
run evaluating
gc garbage collecting
-The process buffer's modeline contains additional information where
+The process buffer's mode line contains additional information where
the buffer's name is normally displayed: the command interpreter level
and type.
(cons (process-filter process)
(process-sentinel process)))
(xscheme-process-filter-initialize t)
- (xscheme-modeline-initialize xscheme-buffer-name)
+ (xscheme-mode-line-initialize xscheme-buffer-name)
(set-process-sentinel process 'xscheme-process-sentinel)
(set-process-filter process 'xscheme-process-filter))
(setq xscheme-previous-process-state (cons nil nil)))))))
xscheme-buffer-name)
(set-marker (process-mark process) (point-max))
(xscheme-process-filter-initialize t)
- (xscheme-modeline-initialize xscheme-buffer-name)
+ (xscheme-mode-line-initialize xscheme-buffer-name)
(set-process-sentinel process 'xscheme-process-sentinel)
(set-process-filter process 'xscheme-process-filter)
(run-hooks 'xscheme-start-hook)))))
(if running-p
(let ((name (buffer-name (current-buffer))))
(setq scheme-mode-line-process '(": " xscheme-runlight-string))
- (xscheme-modeline-initialize name)
+ (xscheme-mode-line-initialize name)
(if (equal name (default-value 'xscheme-buffer-name))
(setq-default xscheme-runlight default-xscheme-runlight))))
(if (or (eq xscheme-runlight default-xscheme-runlight)
(set-buffer (process-buffer process))
(goto-char (process-mark process))))
-(defun xscheme-modeline-initialize (name)
+(defun xscheme-mode-line-initialize (name)
(setq xscheme-runlight-string "")
(if (equal name (default-value 'xscheme-buffer-name))
(setq-default xscheme-runlight-string ""))
;; do the narrowing.
(narrow-to-region (point-min) ses--data-marker)
(setq ses--deferred-narrow nil))
- ;; Update the modeline.
+ ;; Update the mode line.
(let ((oldcell ses--curcell))
(ses-set-curcell)
(unless (eq ses--curcell oldcell)
:link '(emacs-commentary-link "strokes")
:group 'mouse)
-(defcustom strokes-modeline-string " Strokes"
- "Modeline identification when Strokes mode is on \(default is \" Strokes\"\)."
+(defcustom strokes-lighter " Strokes"
+ "Mode line identifier for Strokes mode."
:type 'string
:group 'strokes)
+(define-obsolete-variable-alias 'strokes-modeline-string 'strokes-lighter "24.2")
+
(defcustom strokes-character ?@
"Character used when drawing strokes in the strokes buffer.
\(The default is `@', which works well.\)"
\\[strokes-decode-buffer].
\\{strokes-mode-map}"
- nil strokes-modeline-string strokes-mode-map
+ nil strokes-lighter strokes-mode-map
:group 'strokes :global t
(cond ((not (display-mouse-p))
(error "Can't use Strokes without a mouse"))
;;;; Display-related functions.
;; For compatibility.
-(defalias 'redraw-modeline 'force-mode-line-update)
+(define-obsolete-function-alias 'redraw-modeline
+ 'force-mode-line-update "24.2")
(defun force-mode-line-update (&optional all)
"Force redisplay of the current buffer's mode line and header line.
parameters))))))))
;; frame will be focused anyway, so select it
-;; (if this is not done, modeline is dimmed until first interaction)
+;; (if this is not done, mode line is dimmed until first interaction)
(add-hook 'after-make-frame-functions 'select-frame)
(defvar tool-bar-mode)
((not window-pos)
nil)
((eq window-pos 'mode-line)
- 'modeline)
+ 'mode-line)
((eq window-pos 'vertical-line)
'default)
((consp window-pos)
2R delete region |
3R copy region |
-on modeline on \"scroll bar\" in minibuffer
+on mode line on \"scroll bar\" in minibuffer
L scroll-up line to top execute-extended-command
C proportional goto-char line to middle mouse-help
R scroll-down line to bottom eval-expression"
(old-window (selected-window))
(in-minibuf-p (eq y (1- (frame-height))))
(same-window-p (and (not in-minibuf-p) (eq window old-window)))
- (in-modeline-p (eq y (1- (nth 3 edges))))
+ (in-mode-line-p (eq y (1- (nth 3 edges))))
(in-scrollbar-p (>= x (1- (nth 2 edges)))))
(setq x (- x (nth 0 edges)))
(setq y (- y (nth 1 edges)))
; (error "mouse-hit %d %d %d" buttons x y) ;;;; debug
- (cond (in-modeline-p
+ (cond (in-mode-line-p
(select-window window)
(cond ((= buttons mouse-left)
(scroll-up))
:type 'boolean)
(defcustom flyspell-mode-line-string " Fly"
- "String displayed on the modeline when flyspell is active.
-Set this to nil if you don't want a modeline indicator."
+ "String displayed on the mode line when flyspell is active.
+Set this to nil if you don't want a mode line indicator."
:group 'flyspell
:type '(choice string (const :tag "None" nil)))
:version "22.1")
(defcustom ispell-highlight-face (if ispell-lazy-highlight 'isearch 'highlight)
- "The face used for Ispell highlighting. For Emacsen with overlays.
-Possible values are `highlight', `modeline', `secondary-selection',
-`region', and `underline'.
+ "Face used for Ispell highlighting.
This variable can be set by the user to whatever face they desire.
It's most convenient if the cursor color and highlight color are
slightly different."
; LocalWords: alists minibuffer bufferp autoload loaddefs aff Dansk KOI SPC op
; LocalWords: Francais Nederlands charset autoloaded popup nonmenu regexp num
; LocalWords: AMStex hspace includeonly nocite epsfig displaymath eqnarray reg
-; LocalWords: minipage modeline pers dict unhighlight buf grep sync prev inc
+; LocalWords: minipage pers dict unhighlight buf grep sync prev inc
; LocalWords: fn oldot NB AIX msg init read's bufs pt cmd Quinlan eg
; LocalWords: uuencoded unidiff sc nn VM SGML eval IspellPersDict
; LocalWords: lns XEmacs HTML casechars Multibyte
(kill-local-variable 'isearch-next-buffer-function))
(setq reftex-isearch-minor-mode nil))))
(remove-hook 'reftex-mode-hook 'reftex-isearch-minor-mode)))
- ;; Force modeline redisplay.
+ ;; Force mode line redisplay.
(set-buffer-modified-p (buffer-modified-p))))
(add-minor-mode 'reftex-isearch-minor-mode "/I" nil nil
'((bold . "b")
(italic . "i")
(underline . "u")
- (modeline . "rev"))
+ (mode-line . "rev"))
"Value of `sgml-face-tag-alist' for HTML mode.")
(defvar html-tag-face-alist
("h5" . underline)
("h6" . underline)
("i" . italic)
- ("rev" . modeline)
+ ("rev" . mode-line)
("s" . underline)
("small" . default)
("strong" . bold)
(and (eq this-command 'ediff-toggle-help)
dont-iconify-ctl-frame))
- ;; 1 more line for the modeline
+ ;; 1 more line for the mode line
(setq lines (1+ (count-lines (point-min) (point-max)))
fheight lines
fwidth (max (+ (ediff-help-message-line-length) 2)
;; Revise the mode line to display which difference we have selected
-;; Also resets modelines of buffers A/B, since they may be clobbered by
+;; Also resets mode lines of buffers A/B, since they may be clobbered by
;; other invocations of Ediff.
(defun ediff-refresh-mode-lines ()
(let (buf-A-state-diff buf-B-state-diff buf-C-state-diff buf-C-state-merge)
:group 'vc-arch)
(defun vc-arch-mode-line-string (file)
- "Return string for placement in modeline by `vc-mode-line' for FILE."
+ "Return a string for `vc-mode-line' to put in the mode line for FILE."
(let ((rev (vc-working-revision file)))
(dolist (rule vc-arch-mode-line-rewrite)
(if (string-match (car rule) rev)
(vc-file-getprop file 'vc-working-revision))
(defun vc-cvs-mode-line-string (file)
- "Return string for placement into the modeline for FILE.
+ "Return a string for `vc-mode-line' to put in the mode line for FILE.
Compared to the default implementation, this function does two things:
Handle the special case of a CVS file that is added but not yet
committed and support display of sticky tags."
(eq 'up-to-date (vc-git-state file)))
(defun vc-git-mode-line-string (file)
- "Return string for placement into the modeline for FILE."
+ "Return a string for `vc-mode-line' to put in the mode line for FILE."
(let* ((branch (vc-git-working-revision file))
(def-ml (vc-default-mode-line-string 'Git file))
(help-echo (get-text-property 0 'help-echo def-ml)))
:group 'vc)
(defcustom vc-display-status t
- "If non-nil, display revision number and lock status in modeline.
+ "If non-nil, display revision number and lock status in mode line.
Otherwise, not displayed."
:type 'boolean
:group 'vc)
backend)
(defun vc-default-mode-line-string (backend file)
- "Return string for placement in modeline by `vc-mode-line' for FILE.
+ "Return a string for `vc-mode-line' to put in the mode line for FILE.
Format:
\"BACKEND-REV\" if the file is up-to-date
(let (backend)
(cond
((setq backend (with-demoted-errors (vc-backend buffer-file-name)))
- ;; Compute the state and put it in the modeline.
+ ;; Compute the state and put it in the mode line.
(vc-mode-line buffer-file-name backend)
(unless vc-make-backup-files
;; Use this variable, not make-backup-files,
:group 'vc-mtn)
(defun vc-mtn-mode-line-string (file)
- "Return string for placement in modeline by `vc-mode-line' for FILE."
+ "Return a string for `vc-mode-line' to put in the mode line for FILE."
(let ((branch (vc-mtn-workfile-branch file)))
(dolist (rule vc-mtn-mode-line-rewrite)
(if (string-match (car rule) branch)
;; There are also the following useful commands:
;;
;; `whitespace-newline-mode'
-;; Toggle NEWLINE minor mode visualization ("nl" on modeline).
+;; Toggle NEWLINE minor mode visualization ("nl" on mode line).
;;
;; `global-whitespace-newline-mode'
-;; Toggle NEWLINE global minor mode visualization ("NL" on modeline).
+;; Toggle NEWLINE global minor mode visualization ("NL" on mode line).
;;
;; `whitespace-report'
;; Report some blank problems in buffer.
;; A window can be split vertically when its height is not
;; fixed, it is at least `split-height-threshold' lines high,
;; and it is at least twice as high as `window-min-height' and 2
- ;; if it has a modeline or 1.
+ ;; if it has a mode line or 1.
(and (memq window-size-fixed '(nil width))
(numberp split-height-threshold)
(>= (window-height window)
(unless (zerop delta)
;; Setting window-min-height to a value like 1 can lead to very
;; bizarre displays because it also allows Emacs to make *other*
- ;; windows 1-line tall, which means that there's no more space for
- ;; the modeline.
- (let ((window-min-height (min 2 height))) ; One text line plus a modeline.
+ ;; windows one line tall, which means that there's no more space
+ ;; for the mode line.
+ (let ((window-min-height (min 2 height)))
(window-resize window delta)))))
(defun enlarge-window-horizontally (delta)
HCoop / bpt / emacs.git / commitdiff