You are looking to adjust the value of the
You can read its docstring by entering C-h v echo-keystrokes (or
M-x describe-variable echo-keystrokes):
Nonzero means echo unfinished commands after this many seconds of pause.
The value may be integer or floating point.
If the value is zero, don't echo at all.
Bind message-log-max to nil:
(defun foo ()
(let ((message-log-max nil))
M-x foo RET
[P.S. Don't be misled by tests using things such as M-: (let ((message-log-max nil)) (message "EEEEEEEEEEEEEEEEEE")) into thinking that the EEEEEEEEEEEEEEEEEE from evaluating the let sexp is the message that was output ...
No they don't get printed as text. :-)
Evaluate the following function, then call M-x mes. Doesn't it work?
(defun mes ()
(message (propertize "text" 'face 'font-lock-warning-face)))
The problem, I imagine, is that you're evaluating your snippet with
something like eval-last-sexp (C-x C-e). This function (and its
(setq echo-keystrokes 0.01)
will result in near-instantaneous echoing of the keystrokes. Alternatively, you could customize the variable (M-x customize-variable RET echo-keystrokes).
The variable determines the delay, in seconds, before echoing unfinished commands. If the value is 0, then do not echo at all (which is why you need to choose a very short ...
Yes, you can disable these messages by setting command-error-function to a function that ignores buffer-read-only signals.
(defun my-command-error-function (data context caller)
"Ignore the buffer-read-only signal; pass the rest to the default handler."
(when (not (eq (car data) 'buffer-read-only))
(command-error-default-function data context caller)...
As others have indicated, and as was explained in the page you link to, output messages to the echo area are logged in buffer *Messages*. Clicking in the echo area brings up *Messages*, where you can copy text normally.
In the minibuffer, which is for input (as opposed to the echo area, which is in the same place, and which is for output), if you use normal,...
use C-u M-: insert the result into current buffer instead of printing it in the echo area.
(eval-expression EXP &optional INSERT-VALUE)
Evaluate EXP and print value in the echo area.
When called interactively, read an Emacs Lisp expression and evaluate it.
Value is also consed on to front of the variable ‘values’.
If the resulting value is an integer, ...
As was pointed out by @phils the "Wrote file" comes from write-region. If you don't use the inhibit-message variable introduced in Emacs 25, you could replace the original write-region with a function that sets VISIT to neither t nor nil nor a string. As the docstring of write-region tells us, this will avoid displaying the message. In the following example ...
That message is printed when the beginning of the sexp is not visible in the window; otherwise, the opening paren is temporarily highlighted.
This behavior is implemented in simple.el and is not associated with any minor mode. It is implemented using a hook that runs when a character is inserted.
The actual blinking/message comes from command blink-...
Sure you can, (see this SO question) although it seems a bit heavy-handed.
(defun nadvice/message-color (old-fun &optional str &rest args)
(if (not str)
(funcall old-fun "%s" (propertize (apply #'format str args)
'face '(:foreground "red")))))
(advice-add 'message :around #'nadvice/...
You can select and copy the text of the prompt in the minibuffer (normally), if you move the point using any moving commands just one position after the prompt, and then C-b to move the point over the right boundary of the prompt. After you do it, you can use other navigation and selection commands on the prompt text. This can be achieved normally by using ...
As @TuDo's comment indicates (and he can change it to an answer if he likes, in which case I'll remove this answer), you can at least use a standalone minibuffer frame, and you can position it where you like.
One advantage over the default setup is that you have only a single place to look, always, for output messages (echo area) and for input editing (...
When you evaluate a function with M-:, the function gets run, and then its return value is displayed in the echo area. The return value of test-fn is the value returned by message, which is the string that was printed. Thus, though message did actually display the message, it was overwritten by M-: displaying the return value. (You can confirm that both ...
What you see printed in the echo area when evaluating the command is its return value - a string. The print syntax for strings includes quotation marks.
When you call the command non-interactively from another function/command, you shouldn't see the quotation marks:
(defun test-test-fn ()
Then call M-x test-test-fn RET to test....
A comment on this question mentions that a package named symon makes use of such a feature.
It is achieved by spamming non-logged messages when the minibuffer is inactive, and by stopping the redisplay everytime a command is issued. The boilerplate for that is rather short, and after a few minutes of usage, I couldn't notice any problems with that: messages ...
You can override eval-expression-print-format to return "" or nil:
(defun eval-expression-print-format (value)
; return an empty string
See the answer by @Harald Hanche-Olsen for a way to override it temporarily.
You can hack just about any function with defadvice, although debugging advised functions is quite difficult:
(defadvice message (around my-message-filter activate)
(unless (string-match "Text is read-only" (or (ad-get-arg 0) ""))
You can use M-x blink-matching-open RET to display the message if you're right after a paren. To do it more "on the fly" you might like to try M-x show-paren-mode, tho it doesn't actually give you this message.
Otherwise, you could use something like
(if (and (not (bobp))
You can use following
(defmacro with-suppressed-message (&rest body)
"Suppress new messages temporarily in the echo area and the `*Messages*' buffer while BODY is evaluated."
(declare (indent 0))
(let ((message-log-max nil))
`(with-temp-message (or (current-message) "") ,@body)))
instead of (save-...
The echo area is not really a buffer. It is an area of a window. It is used to display messages and to display the minibuffer (which is a buffer).
You cannot "visit" the echo area and select text there, as you would a buffer.
You or your code needs instead to visit buffer *Messages*, where messages are logged. (Not everything displayed in the echo area gets ...
These variables may be relevant: eval-expression-print-level and eval-expression-print-length: https://www.gnu.org/software/emacs/manual/html_node/emacs/Lisp-Eval.html
See also the variables: print-level and print-length: https://www.gnu.org/software/emacs/manual/html_node/elisp/Output-Variables.html
The *Messages* buffer may contain more information ...
Source of the 'buffer read-only' error
I believe that the source of that error: Buffer is read-only: <#BUFFER-NAME> is in the C source code.
So the solution to this would be to tweak the source code and build emacs locally by commenting out this specific line.
For reference, here is that code snippet that throws that error:
if (!NILP (BVAR (...
You can use the minibuffer-line package from GNU ELPA for this.
(setq minibuffer-line-format '((:eval
(let ((time-string (format-time-string "%l:%M %b %d %a")))
(make-string (- (frame-text-cols)
The echo area explicitly uses the minibuffer window, so unless that changes the answer is "no, it's not possible" (or at minimum not very practical).
Refer to https://stackoverflow.com/questions/10063410/is-it-possible-to-separate-minibuffer-and-echo-area-in-emacs
If you don't want a permanent change, you can arrange things with a bit of advice:
(defvar mute-eval-expression-print-format nil
"Set to t to mute eval-expression-print-format")
(defun mute-eval-expression-print-format (orig-fun value)
(funcall orig-fun value)))
You can suppress display in the minibuffer by setting minibuffer-message-timeout to 0.
For example, I use something like this in a few places where I want to toggle a minor mode while in a minibuffer prompt (like ido find-file) without being interrupted by a 'mode enabled' message:
(let ((minibuffer-message-timeout 0))
First Rough Draft (January 3, 2015): Revised initial draft based on the helpful comment of @phils regarding using the function messages-buffer to locate or create the appropriate buffer (and put it into messages-buffer-mode); and, added a check for whether point-max is at the beginning of the line (if not, then inset a new line before inserting the message ...
You could try something like:
(run-with-timer 2 nil
(message "Some message")
(run-with-timer 3 nil
run-with-timer will call a function of your choice after a delay (there's a run-with-idle-timer variant if you want to only show the message when Emacs ...
You probably have the variable visible-bell set to a non-nil
value (have a look at the manual node on Beeping for more information). Here's the docstring:
Non-nil means try to flash the frame to represent a bell.
See also ring-bell-function.
You can customize this variable.
You may also wish to set the ring-bell-function. ...