Bind `q' to `quit-window' or similar in *Messages*

Bind `q' to `quit-window' or similar in *Messages*

[Deniz Dogan]

In a lot of buffers that are not associated with files, such as
*Occur*, *Help*, etc.,  `q' is bound to `quit-window', `View-quit', or
similar.

Why is this not the case in *Messages*?

-- 
Deniz Dogan

Re: Bind `q' to `quit-window' or similar in *Messages*

[Tassilo Horn]

Deniz Dogan <deniz.a.m.dogan@gmail.com> writes:

> In a lot of buffers that are not associated with files, such as
> *Occur*, *Help*, etc., `q' is bound to `quit-window', `View-quit', or
> similar.
>
> Why is this not the case in *Messages*?

Cause *Messages* is not read-only, and maybe you want to insert a q
there.  But does that anybody really want?  I guess no.  So I'd be in
favor of making *Messages* read-only and bind `q' to `quit-window'
there.

Bye,
Tassilo

RE: Bind `q' to `quit-window' or similar in *Messages*

[Drew Adams]

> Cause *Messages* is not read-only, and maybe you want to insert a q
> there.  But does that anybody really want?  I guess no.  So I'd be in
> favor of making *Messages* read-only and bind `q' to `quit-window'
> there.

Absolutely I want that. I want to be able to write in *Messages*. Yes, I can
toggle read-only, but if `q' quits, then that defeats the purpose.

I sometimes find myself with tons of messages being logged, and when I make
several successive tests I sometimes type stuff in Messages to distinguish test
sequences etc. And I kill sections of text there, or copy text (including text
I've added) to other buffers, and so on.

What's wrong with `C-x 0' (or `C-x k')?

Please do not make *Messages* read-only. Likewise, *Pp Eval Output*.

Re: Bind `q' to `quit-window' or similar in *Messages*

[Lennart Borgman]

On Wed, Feb 3, 2010 at 4:48 PM, Drew Adams <drew.adams@oracle.com> wrote:
>
> Please do not make *Messages* read-only. Likewise, *Pp Eval Output*.

I agree.

Re: Bind `q' to `quit-window' or similar in *Messages*

[Tassilo Horn]

"Drew Adams" <drew.adams@oracle.com> writes:

>> Cause *Messages* is not read-only, and maybe you want to insert a q
>> there.  But does that anybody really want?  I guess no.  So I'd be in
>> favor of making *Messages* read-only and bind `q' to `quit-window'
>> there.
>
> Absolutely I want that. I want to be able to write in *Messages*. Yes,
> I can toggle read-only, but if `q' quits, then that defeats the
> purpose.
>
> I sometimes find myself with tons of messages being logged, and when I
> make several successive tests I sometimes type stuff in Messages to
> distinguish test sequences etc.

Hm, you could also do M-: (message "#############"), but of course
that's not as fast.

> And I kill sections of text there, or copy text (including text I've
> added) to other buffers, and so on.

I see.

> What's wrong with `C-x 0' (or `C-x k')?

Nothing.

Bye,
Tassilo

RE: Bind `q' to `quit-window' or similar in *Messages*

[Drew Adams]

I said:

> Absolutely I want that. I want to be able to write in 
> *Messages*. Yes, I can toggle read-only, but if `q' quits,
> then that defeats the purpose.

I take back that last part. Toggling read-only makes `q' self-insert again. I do
that in *Help*, for instance.

So this comes down to a choice, I think:

1. View-mode by default, so `q' quits, and you need to do `C-x C-q' to make it
writable.

2. Writable by default, and you need to do `C-x 0' (or `C-x k') to get rid of
it.

And the same or similar considerations probably apply to *Pp Eval Output*.

I still vote for #2, but I don't feel strongly about it.

RE: Bind `q' to `quit-window' or similar in *Messages*

[Roland Winkler]

> Absolutely I want that. I want to be able to write in *Messages*.
> Yes, I can toggle read-only, but if `q' quits, then that defeats
> the purpose.
> 
> I sometimes find myself with tons of messages being logged, and
> when I make several successive tests I sometimes type stuff in
> Messages to distinguish test sequences etc. And I kill sections of
> text there, or copy text (including text I've added) to other
> buffers, and so on.

I understand your point. Yet my typing in this buffer is purely
accidental / unintentional. And I find it annoying that the
*Messages* buffer does not have an undo history. So from that
perspective, it appears to me that the original design did not have
in mind the possibility of editing this buffer. So I want to suggest
two things:

- *Messages* should not have buffer-undo-list set to t

  (Of course, I do not know whether this would collide with anything
  else.)

- Some customization that allows one to toggle between a read-only
  *Messages* buffer (with q bound to quit-window) and an edit mode
  where one can do whatever one likes to do. 

  (How do the normal entries in *Messages* find their way into this
  buffer? Does this mechanism care whether this buffer is read-only
  or not? I just tried it and it appears to gives no errors.)

Roland

RE: Bind `q' to `quit-window' or similar in *Messages*

[Drew Adams]

> I understand your point. Yet my typing in this buffer is purely
> accidental / unintentional. And I find it annoying that the
> *Messages* buffer does not have an undo history. So from that
> perspective, it appears to me that the original design did not have
> in mind the possibility of editing this buffer. So I want to suggest
> two things:
> 
> - *Messages* should not have buffer-undo-list set to t
> 
>   (Of course, I do not know whether this would collide with anything
>   else.)
> 
> - Some customization that allows one to toggle between a read-only
>   *Messages* buffer (with q bound to quit-window) and an edit mode
>   where one can do whatever one likes to do. 

Sounds good to me.

But I imagine that the reason for no undo is that saving undo can be expensive,
and most of the time *Messages* is used for output only (not editing).

Re: Bind `q' to `quit-window' or similar in *Messages*

[Miles Bader]

Roland Winkler <roland.winkler@physik.uni-erlangen.de> writes:
> - *Messages* should not have buffer-undo-list set to t

It's set to t to avoid generating zillions of useless undo entries.

That's pretty reasonable given that 99.99% of the time, people _don't_
edit *Messages*, and yet it changes a lot.

It's silly to start changing *Messages* with the idea that people are
editing it, because that's almost never the case.

-Miles

-- 
Road, n. A strip of land along which one may pass from where it is too
tiresome to be to where it is futile to go.

Re: Bind `q' to `quit-window' or similar in *Messages*

[Roland Winkler]

> It's set to t to avoid generating zillions of useless undo entries.
> 
> That's pretty reasonable given that 99.99% of the time, people
> _don't_ edit *Messages*, and yet it changes a lot.
> 
> It's silly to start changing *Messages* with the idea that people
> are editing it, because that's almost never the case.
 
...which brings us back to the original request: most often it is
used for viewing what is happening, so that most people probably
were happy if `q' had the same quit-window binding it has in other
buffers that are not intended for editing.

Re: Bind `q' to `quit-window' or similar in *Messages*

[Miles Bader]

Roland Winkler <rwinkler@niu.edu> writes:
> ...which brings us back to the original request: most often it is
> used for viewing what is happening, so that most people probably
> were happy if `q' had the same quit-window binding it has in other
> buffers that are not intended for editing.

Indeed.

-Miles

-- 
"Nah, there's no bigger atheist than me.  Well, I take that back.
I'm a cancer screening away from going agnostic and a biopsy away
from full-fledged Christian."  [Adam Carolla]

Re: Bind `q' to `quit-window' or similar in *Messages*

[Tassilo Horn]

Miles Bader <miles@gnu.org> writes:

> Roland Winkler <rwinkler@niu.edu> writes:
>> ...which brings us back to the original request: most often it is
>> used for viewing what is happening, so that most people probably were
>> happy if `q' had the same quit-window binding it has in other buffers
>> that are not intended for editing.
>
> Indeed.

99% of the time, I use it that way, too.  But when debugging some elisp
code, I sometimes add markers there, like Drew pointed out.  So how
about this idea:

  - *Messages* is read-only
  - `q' buries the buffer
  - `m' is bound to a new command that provides an interface to 

Re: Bind `q' to `quit-window' or similar in *Messages*

[Tassilo Horn]

Tassilo Horn <tassilo@member.fsf.org> writes:

Ups, sorry.  I'm sick, and my head fell on the keyboard sending the
message before it was finished... :-)

>> Roland Winkler <rwinkler@niu.edu> writes:
>>> ...which brings us back to the original request: most often it is
>>> used for viewing what is happening, so that most people probably were
>>> happy if `q' had the same quit-window binding it has in other buffers
>>> that are not intended for editing.
>>
>> Indeed.
>
> 99% of the time, I use it that way, too.  But when debugging some elisp
> code, I sometimes add markers there, like Drew pointed out.  So how
> about this idea:
>
>   - *Messages* is read-only
>   - `q' buries the buffer
>   - `m' is bound to a new command that provides an interface to 

Ok, `m' would be bound to a new command that provides an interface to
`message'.  It would read a format string, and if that contains %s and
friends, it would read those (with elisp completion).

That way, I could quickly add a marker with

  m ##################### RET

or get some more useful informations with

  m %d^2 = %d RET 3 RET (* 3 3) RET.

One problem I see, is that would always append to *Messages*, and I
guess some users want to be able to write anywhere...

Bye,
Tassilo

RE: Bind `q' to `quit-window' or similar in *Messages*

[Drew Adams]

> 99% of the time, I use it that way, too.  But when debugging 
> some elisp code, I sometimes add markers there, like Drew
> pointed out.  So how about this idea:
> 
>   - *Messages* is read-only
>   - `q' buries the buffer
>   - `m' is bound to a new command that... provides an
>     interface to `message' 

I said:

> So this comes down to a choice, I think:
> 
> 1. View-mode by default, so `q' quits, and you need to do 
>    `C-x C-q' to make it writable.
> 
> 2. Writable by default, and you need to do `C-x 0' (or `C-x 
>    k') to get rid of it.
> 
> And the same or similar considerations probably apply to *Pp 
> Eval Output*. I still vote for #2, but I don't feel strongly about it.

Again, I'm OK with either. I too use it without editing most of the time.
And I don't think we need undo (with its cost) in *Messages*.

The same applies to *Pp Eval Output*. But undo there would be useful. Quitting
read-only should put *Pp Eval Output* back in Emacs-Lisp mode.

I don't see the point (need) for the proposed `m' binding in `Messages'. If it's
just in order to be able to add to the buffer text without turning off read-only
(C-x C-q), then turning it off and editing is handier, IMO. But I'm probably
missing the point here.

If we choose #1, then `q' should do what it does in other, similar situations. I
think that's more likely to be `quit-window' than `bury-buffer'. (FWIW, with my
use of frames, `bury-buffer' is almost never the behavior I want.) Let `q' do
what it does in Dired, for instance (`quit-window').

Re: Bind `q' to `quit-window' or similar in *Messages*

[Stefan Monnier]

>> ...which brings us back to the original request: most often it is
>> used for viewing what is happening, so that most people probably
>> were happy if `q' had the same quit-window binding it has in other
>> buffers that are not intended for editing.
> Indeed.

Agreed.  I think we need:
1- define a major mode for it with `q' bound to quit-window.
2- default it to read-only.

The major-mode will make it possible for people to add keybindings
and things.


        Stefan


PS: BTW, I've often felt that C-x C-q should turn on the undo-log when
making a buffer writeable.  It hasn't bothered me enough to actually
code it up and try it, but maybe people could try it out and see if it
leads to problems.

Re: Bind `q' to `quit-window' or similar in *Messages*

[Tassilo Horn]

"Drew Adams" <drew.adams@oracle.com> writes:

Hi Drew,

> I don't see the point (need) for the proposed `m' binding in
> `Messages'.

The point is being able to quickly eval some code and have the result
displayed nicely.  But thinking about it a bit more, it's not any better
than

  M-: (message "%s" (do-funky-stuff 17)) RET

and if I want to do that many times, I'd probably do that in *scratch*
anyway, so forget it.  I'm fine with you toggle idea. :-)

Bye,
Tassilo

C-x C-q and undo [was: Bind `q' to `quit-window' or similar in *Messages*]

[Drew Adams]

> I've often felt that C-x C-q should turn on the undo-log when
> making a buffer writeable.  It hasn't bothered me enough to actually
> code it up and try it, but maybe people could try it out and see if it
> leads to problems.

I was wondering the same thing.
But maybe the two should not always be coupled.

It's easy enough to enable undo, with command `buffer-enable-undo'. Of course,
that's not bound to a key, by default. (Likewise, disabling.)

The prefix arg for `C-x C-q' is used only to specify on or off explicitly. One
possibility would be to have plain `C-u' toggle read-only and call
`buffer-enable-undo' or `buffer-disable-undo' as appropriate. So:

C-1 C-x C-q would turn read-only ON (and not affect undo)
C-  C-x C-q would turn read-only OFF   "   "   "   "
C-u C-x C-q would toggle read-only and turn undo on/off accordingly

Even more flexible: We could have an option, `toggle-read-only-affects-undo'. If
non-nil, then `C-x C-q' without `C-u' would affect undo; with `C-u' it would not
affect undo. If nil, the behavior would be reversed: without `C-u' would not
affect undo; with `C-u' it would affect undo.

Re: Bind `q' to `quit-window' or similar in *Messages*

[Thierry Volpiatto]

Tassilo Horn <tassilo@member.fsf.org> writes:

> "Drew Adams" <drew.adams@oracle.com> writes:
>
> Hi Drew,
>
>> I don't see the point (need) for the proposed `m' binding in
>> `Messages'.
>
> The point is being able to quickly eval some code and have the result
> displayed nicely.  But thinking about it a bit more, it's not any better
> than
>
>   M-: (message "%s" (do-funky-stuff 17)) RET
>
> and if I want to do that many times, I'd probably do that in *scratch*
> anyway, so forget it.  I'm fine with you toggle idea. :-)

Hi Tassilo, i use that:

(defun tv-tail-echo-area-messages ()
  (interactive)
  (save-window-excursion
    (delete-other-windows)
    (pop-to-buffer (get-buffer-create "*Messages*") t)
    (View-scroll-to-buffer-end)
    (sit-for 10)))

For most evaluation it's enough for a quick look, but if output is too
large, you will have to C-h e as usual.(idem if you want to kill/yank)
You don't need to wait 10s, when you hit key messages buffer go away.

> Bye,
> Tassilo
>
>
>

-- 
Thierry Volpiatto

Re: Bind `q' to `quit-window' or similar in *Messages*

[Miles Bader]

Stefan Monnier <monnier@iro.umontreal.ca> writes:
> PS: BTW, I've often felt that C-x C-q should turn on the undo-log when
> making a buffer writeable.  It hasn't bothered me enough to actually
> code it up and try it, but maybe people could try it out and see if it
> leads to problems.

Undo in a buffer that's frequently updated automatically can be
pretty annoying...

It would actually be nice if there were some way to make undo only
operate on user edits, and simply ignore automatic insertions etc
(this is a problem in comint too), but I get the impression that's not
entirely trivial, since the undo-list contains absolute positions.

[There was a previous thread on this too; forget what the resolution
was, but I think there was some existing code written for some mode or
another to do this.]

-Miles

-- 
"Most attacks seem to take place at night, during a rainstorm, uphill,
 where four map sheets join."   -- Anon. British Officer in WW I

Re: Bind `q' to `quit-window' or similar in *Messages*

[Deniz Dogan]

2010/2/3 Deniz Dogan <deniz.a.m.dogan@gmail.com>:
> In a lot of buffers that are not associated with files, such as
> *Occur*, *Help*, etc.,  `q' is bound to `quit-window', `View-quit', or
> similar.
>
> Why is this not the case in *Messages*?
>

Inspired by this proposal I set off to write a function which binds
`q' to `quit-window' in any read-only buffer. However, I was unable to
find a suitable hook to call the function from.

Any ideas?

-- 
Deniz Dogan

Re: Bind `q' to `quit-window' or similar in *Messages*

[Davis Herring]

> Inspired by this proposal I set off to write a function which binds
> `q' to `quit-window' in any read-only buffer. However, I was unable to
> find a suitable hook to call the function from.
>
> Any ideas?

`diff-mode' achieves a similar effect by adding an element to
`minor-mode-map-alist' with the variable `buffer-read-only' as the key.

Davis

-- 
This product is sold by volume, not by mass.  If it appears too dense or
too sparse, it is because mass-energy conversion has occurred during
shipping.