Key-binding clash between gnus and calc

Key-binding clash between gnus and calc

[Sascha Wilde]

`M-#' is normally bound to `calc-dispatch', but in gnus it's bound to
`gnus-topic-unmark-topic' in groups buffer, to
`gnus-summary-unmark-as-processable' in summary and article buffer.

I don't know which of them has the "older rights" to use this binding,
but anyway, to a regular user of both, gnus and calc (as me for
instance) the current state is quite inconvenient.

cheers
sascha
-- 
Sascha Wilde : "Lies, was ich meine, nicht, was ich schreibe."
             : (Urs Traenkner in de.alt.admin)

Re: Key-binding clash between gnus and calc

[David Kastrup]

Sascha Wilde <wilde@sha-bang.de> writes:

> `M-#' is normally bound to `calc-dispatch', but in gnus it's bound to
> `gnus-topic-unmark-topic' in groups buffer, to
> `gnus-summary-unmark-as-processable' in summary and article buffer.
>
> I don't know which of them has the "older rights" to use this binding,
> but anyway, to a regular user of both, gnus and calc (as me for
> instance) the current state is quite inconvenient.

Well, start a reply before you start calculating.  It is not the best
workaround for the situation, but better than nothing.

-- 
David Kastrup, Kriemhildstr. 15, 44793 Bochum

Re: Key-binding clash between gnus and calc

[Sascha Wilde]

David Kastrup <dak@gnu.org> wrote:
> Sascha Wilde <wilde@sha-bang.de> writes:
>
>> `M-#' is normally bound to `calc-dispatch', but in gnus it's bound to
>> `gnus-topic-unmark-topic' in groups buffer, to
>> `gnus-summary-unmark-as-processable' in summary and article buffer.
[...]
> Well, start a reply before you start calculating.  It is not the best
> workaround for the situation, but better than nothing.

Please tell me, that you are joking.

This is not about finding an "workaround", I know about at least halve
a dozen ways of getting calc from within gnus my self.

This is about a inconsistency in emacs which should be fixed.  calc is
part of GNU emacs and it uses and documents M-# as a global binding,
while gnus -- part of gnu emacs, too -- binds it locally.  Of cause I
can use a custom binding for calc as Jay suggested (and in fact, it's
what I'm doing for now), but I think the TRTTD would be to change
either binding.  Global default bindings in emacs should be global.

cheers
sascha
-- 
Sascha Wilde : "Ist es nicht schon schlimm genug, dass ICH hier rumtrolle?"
             : (Henning Leise in d.o.c.)

Re: Key-binding clash between gnus and calc

[Miles Bader]

2005/11/16, Sascha Wilde <wilde@sha-bang.de>:
> This is about a inconsistency in emacs which should be fixed.  calc is
> part of GNU emacs and it uses and documents M-# as a global binding,
> while gnus -- part of gnu emacs, too -- binds it locally.  Of cause I
> can use a custom binding for calc as Jay suggested (and in fact, it's
> what I'm doing for now), but I think the TRTTD would be to change
> either binding.  Global default bindings in emacs should be global.

Both bindings are really old, and are quite commonly used; changing
either one may cause more harm (read: piss off more people) than good.
 It's hardly a tragedy to have to use "M-x calc" when in a gnus
summary buffer.

However, I think if one _must_ be changed, it should be calc, becuase
calc until now has always been an extra add-on to Emacs, and for that
reason probably used by many fewer people than gnus (which has been a
part of emacs for a long time).  Morever, if I recall correctly,
historically the M-# binding for calc has been more of a "suggestion"
than anything else (I seem to remember that the calc installation
instructions told the user to bind it himself).

[Disclaimer:  I always use M-x calc anyway, I don't care much about
M-# for calc...]

-miles
--
Do not taunt Happy Fun Ball.

Re: Key-binding clash between gnus and calc

[Jay Belanger]

Miles Bader <snogglethorpe@gmail.com> writes:

> 2005/11/16, Sascha Wilde <wilde@sha-bang.de>:
>> This is about a inconsistency in emacs which should be fixed.  calc is
>> part of GNU emacs and it uses and documents M-# as a global binding,
>> while gnus -- part of gnu emacs, too -- binds it locally.  Of cause I
>> can use a custom binding for calc as Jay suggested (and in fact, it's
>> what I'm doing for now), but I think the TRTTD would be to change
>> either binding.  Global default bindings in emacs should be global.
>
> Both bindings are really old, and are quite commonly used; changing
> either one may cause more harm (read: piss off more people) than good.
>  It's hardly a tragedy to have to use "M-x calc" when in a gnus
> summary buffer.

No; but it is inconvenient if you have to take into account the
current mode before knowing which method to use.  This can be taken
care of by using M-x calc-dispatch all the time, I suppose, but that's
not as nice as using M-#, especially when you might be doing a lot of
different things with Calc.

> However, I think if one _must_ be changed, it should be calc, becuase
> calc until now has always been an extra add-on to Emacs, and for that
> reason probably used by many fewer people than gnus (which has been a
> part of emacs for a long time).

Yes.  Gnus definitely has precedence for M-#.  
Are there any conventions for global keybindings?  The key bindings
conventions section of the elisp manual don't mention any, and doesn't
even discuss M-... keys.

> Morever, if I recall correctly, historically the M-# binding for
> calc has been more of a "suggestion" than anything else (I seem to
> remember that the calc installation instructions told the user to
> bind it himself).

In the 2.02 manual, the installation procedure sets the keybinding.

Jay

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

    This is about a inconsistency in emacs which should be fixed.  calc is
    part of GNU emacs and it uses and documents M-# as a global binding,
    while gnus -- part of gnu emacs, too -- binds it locally.

I don't think I ever approved allocating M-# globally to this purpose.

    However, I think if one _must_ be changed, it should be calc, becuase
    calc until now has always been an extra add-on to Emacs, and for that
    reason probably used by many fewer people than gnus (which has been a
    part of emacs for a long time).

That is probably what happened: when I decided to include Calc in
Emacs, I didn't know that Calc had a global binding in it.

Jay asked:

    Are there any conventions for global keybindings?

Yes--you should always ask me.

Re: Key-binding clash between gnus and calc

[Jay Belanger]

"Richard M. Stallman" <rms@gnu.org> writes:
...
> Jay asked:
>
>     Are there any conventions for global keybindings?
>
> Yes--you should always ask me.

Okay; I'll follow that convention, then.
Calc shouldn't use M-# as a global binding for calc-dispatch,
and so that binding should be removed.
Is there something that Calc can bind globally to calc-dispatch?

Jay

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

    Is there something that Calc can bind globally to calc-dispatch?

I cannot think of something off hand, but that proves little. My
memory doesn't work well for this kind of task.  I can't call to mind
what bindings might be available.  All I can do is invite you to look
for something and suggest it.  If it is more than one key long, it
might be ok.

Re: Key-binding clash between gnus and calc

[Robert J. Chassell]

    Is there something that Calc can bind globally to calc-dispatch?

M-+ is currently undefined.  You could press M-+ twice (i.e., M-+ M-+)
to start calc, the way you do now with M-# or press M-+ and a letter
for a specific start or for moving data into and out of calc.

I like and am accustomed to M-#, which I have used for a decade and a
half, but I can see the problem.  Many people now use Gnus not only to
read news, but also for email.

Incidentally, as far as I know, Emacs Calc mode came to use the M-#
binding before GNUS.  However, because calc was so big, calc was kept
separate from the standard Emacs distribution for a long time.  Now,
few think that three megabytes additional is `too much'.

-- 
    Robert J. Chassell                         
    bob@rattlesnake.com                         GnuPG Key ID: 004B4AC8
    http://www.rattlesnake.com                  http://www.teak.cc

Re: Key-binding clash between gnus and calc

[Jay Belanger]

"Robert J. Chassell" <bob@rattlesnake.com> writes:

>     Is there something that Calc can bind globally to calc-dispatch?
>
> M-+ is currently undefined.  

Undefined anywhere?  M-# is undefined (apart from Calc) in most major
modes; could there be a mode lurking about that uses M-+? The
keybindings conventions part of the manual doesn't say anything about
the M-symbol keys; are they fair game for major modes? 
Gnus uses them a lot, but I haven't seen them used much in other
modes.

> You could press M-+ twice (i.e., M-+ M-+)
> to start calc, the way you do now with M-# or press M-+ and a letter
> for a specific start or for moving data into and out of calc.

This doesn't meet the "more than one key long" condition, but if it
would be acceptable, it would be an excellent solution.  Calc has
various ways of interacting with buffers in different modes, and so I
think it should have a simple entry point with a simple mnemonic.
M-+ fits the bill nicely.

So, the question is, is M-+ acceptable?

> Incidentally, as far as I know, Emacs Calc mode came to use the M-#
> binding before GNUS.  However, because calc was so big, calc was
> kept separate from the standard Emacs distribution for a long time.
> Now, few think that three megabytes additional is `too much'.

I suspect that you can find running shoes with three megabytes of
memory.

Jay

Re: Key-binding clash between gnus and calc

[David Kastrup]

Jay Belanger <belanger@truman.edu> writes:

> I suspect that you can find running shoes with three megabytes of
> memory.

How deprecatory.  Those "running shoes" would likely in return claim
finding a computer with three ounces of muscle attached in your
apartment.

-- 
David Kastrup, Kriemhildstr. 15, 44793 Bochum

Re: Key-binding clash between gnus and calc

[Robert J. Chassell]

   ... M-# is undefined (apart from Calc) in most major
   modes; could there be a mode lurking about that uses M-+? 

Good point.  I do not know.

   This doesn't meet the "more than one key long" condition, ...

M-# is a prefix; any replacement for a full keystroke is "more than
one key long".  However, the prefix itself should not be "more than
one key long".  

With Calc, except for starting the same interface you previously used,
for which you currently type `M-# M-#', in which the second binding is
non-prefix, every non-prefix key is a letter and, as far as I can see,
can remain as is.

-- 
    Robert J. Chassell                         
    bob@rattlesnake.com                         GnuPG Key ID: 004B4AC8
    http://www.rattlesnake.com                  http://www.teak.cc

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

    M-# is a prefix; any replacement for a full keystroke is "more than
    one key long".  However, the prefix itself should not be "more than
    one key long".  

I think you've misunderstood what I said.  I said that the replacement
for M-# itself probably needs to be more than one key long (if it is
to be considered available).

Re: Key-binding clash between gnus and calc

[Jay Belanger]

 
"Richard M. Stallman" <rms@gnu.org> writes:

>     M-# is a prefix; any replacement for a full keystroke is "more than
>     one key long".  However, the prefix itself should not be "more than
>     one key long".
>
> I think you've misunderstood what I said.  I said that the replacement
> for M-# itself probably needs to be more than one key long (if it is
> to be considered available).

"Probably"?  So M-+ isn't ruled out, then.
Sascha suggested `C-x &'; similarly there are `C-x *' or `C-x \'.
Are any of these acceptable?
But the replacement for M-# will effectively be a prefix and will,
by some users of Calc, be used repeatedly; since `M-+' is short
and a minimal change from M-#, I'm hoping that `M-+' gets the green
light.

Jay

Re: Key-binding clash between gnus and calc

[Stefan Monnier]

> Sascha suggested `C-x &'; similarly there are `C-x *' or `C-x \'.
> Are any of these acceptable?

IIRC These are reserved for minor modes.  Please read the minor and major
mode coding conventions first.


        Stefan

Re: Key-binding clash between gnus and calc

[Jay Belanger]

 
Stefan Monnier <monnier@iro.umontreal.ca> writes:

>> Sascha suggested `C-x &'; similarly there are `C-x *' or `C-x 
>> \'.  Are any of these acceptable?  > > IIRC These are reserved 
>> for minor modes.  Please read the minor and major > mode coding 
>> conventions first.   That's `C-c', not `C-x'. I haven't found 
>> any general conventions for `C-x'.    Jay

Re: Key-binding clash between gnus and calc

[Jay Belanger]

 
[Sorry if this is a duplicate; something strange seems to have 
happened to my last post.]   Stefan Monnier 
<monnier@iro.umontreal.ca> writes:

>> Sascha suggested `C-x &'; similarly there are `C-x *' or `C-x \'.
>> Are any of these acceptable?
>
> IIRC These are reserved for minor modes.  Please read the minor and major
> mode coding conventions first.

The minor and major modes mention `C-c', not `C-x'.  I haven't found
any conventions on `C-x'.

Jay

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

    "Probably"?  So M-+ isn't ruled out, then.

I hesitate to use a single key for this purpose;
it doesn't seem vital enough to get one.

Re: Key-binding clash between gnus and calc

[Jay Belanger]

"Richard M. Stallman" <rms@gnu.org> writes:

>     "Probably"?  So M-+ isn't ruled out, then.
>
> I hesitate to use a single key for this purpose;
> it doesn't seem vital enough to get one.

Okay.
How about `C-x C-0'?

Re: Key-binding clash between gnus and calc

[David Kastrup]

Jay Belanger <belanger@truman.edu> writes:

> "Richard M. Stallman" <rms@gnu.org> writes:
>
>>     "Probably"?  So M-+ isn't ruled out, then.
>>
>> I hesitate to use a single key for this purpose;
>> it doesn't seem vital enough to get one.
>
> Okay.
> How about `C-x C-0'?

C-0 is not available on ttys.

-- 
David Kastrup, Kriemhildstr. 15, 44793 Bochum

Re: Key-binding clash between gnus and calc

[Jay Belanger]

Jay Belanger <belanger@truman.edu> wrote:

>> How about `C-x C-0'?

David Kastrup <dak@gnu.org> replied:

> C-0 is not available on ttys.

Juri Linkov <juri@jurta.org> answered:

>`C-0' is not available on some terminals.

Andreas Schwab <schwab@suse.de> responded:

> C-0 is not available on a tty.

My spider-sense is tingling; perhaps C-xC-0 wouldn't be a good
choice. 

Juri Linkov <juri@jurta.org> writes:

> However, this gave me a good idea: `C-x M-#', i.e. the current `M-#'
> remains unchanged, but with the initial `C-x'.

That is a good idea.  I was trying to avoid changing modifiers too
much; here `C-xM-#' would be `C-x M-S-3'.  If nobody considers this
too awkward, I'll put it forward.

Jay

Re: Key-binding clash between gnus and calc

[Juri Linkov]

>>     "Probably"?  So M-+ isn't ruled out, then.
>>
>> I hesitate to use a single key for this purpose;
>> it doesn't seem vital enough to get one.
>
> Okay.
> How about `C-x C-0'?

`C-0' is not available on some terminals.

However, this gave me a good idea: `C-x M-#', i.e. the current `M-#'
remains unchanged, but with the initial `C-x'.

-- 
Juri Linkov
http://www.jurta.org/emacs/

Re: Key-binding clash between gnus and calc

[David Kastrup]

Juri Linkov <juri@jurta.org> writes:

>>>     "Probably"?  So M-+ isn't ruled out, then.
>>>
>>> I hesitate to use a single key for this purpose;
>>> it doesn't seem vital enough to get one.
>>
>> Okay.
>> How about `C-x C-0'?
>
> `C-0' is not available on some terminals.
>
> However, this gave me a good idea: `C-x M-#', i.e. the current `M-#'
> remains unchanged, but with the initial `C-x'.

What's good about that?  It is really contorted.

-- 
David Kastrup, Kriemhildstr. 15, 44793 Bochum

Re: Key-binding clash between gnus and calc

[Jay Belanger]

David Kastrup <dak@gnu.org> writes:

> Juri Linkov <juri@jurta.org> writes:
...
>> However, this gave me a good idea: `C-x M-#', i.e. the current `M-#'
>> remains unchanged, but with the initial `C-x'.
>
> What's good about that?  It is really contorted.

It preserves some continuity with the old keybinding, which is
nice.  But since I'm not the only person who thinks it's a bit
awkward, something else might be in order.
My best thought right now is `C-xC-,'.  Nothing particularly mnemonic
about it, but it seems off the beaten track enough that it might be
acceptable, and since `,' doesn't require a shift on any keyboards
that I've seen, this key sequence only requires the control key.
Unless there are problems with this or somebody has a better idea,
I'll suggest it.

Jay

Re: Key-binding clash between gnus and calc

[Robert J. Chassell]

   My best thought right now is `C-xC-,'

So the idea is that one starts Calc mode with `C-x C-, C-,'
where the prefix is the two keys, `C-x C-,' 
and for the other 28 or so bindings, do things 
like `C-x C-, g' and `C-x C-, y'

That is doable.

-- 
    Robert J. Chassell                         
    bob@rattlesnake.com                         GnuPG Key ID: 004B4AC8
    http://www.rattlesnake.com                  http://www.teak.cc

Re: Key-binding clash between gnus and calc

[Andreas Schwab]

"Robert J. Chassell" <bob@rattlesnake.com> writes:

>    My best thought right now is `C-xC-,'
>
> So the idea is that one starts Calc mode with `C-x C-, C-,'
> where the prefix is the two keys, `C-x C-,' 
> and for the other 28 or so bindings, do things 
> like `C-x C-, g' and `C-x C-, y'
>
> That is doable.

Except that C-, is not available on a tty.

Andreas.

-- 
Andreas Schwab, SuSE Labs, schwab@suse.de
SuSE Linux Products GmbH, Maxfeldstraße 5, 90409 Nürnberg, Germany
PGP key fingerprint = 58CA 54C7 6D53 942B 1756  01D3 44D5 214B 8276 4ED5
"And now for something completely different."

Re: Key-binding clash between gnus and calc

[Jay Belanger]

Andreas Schwab <schwab@suse.de> writes:
...
>>    My best thought right now is `C-xC-,'
>
> Except that C-, is not available on a tty.

You might have thought that I would have bright enough to check for
that, especially since it came up before.  You would have been wrong.

"Robert J. Chassell" <bob@rattlesnake.com> writes:

> It would be easier to start Emacs Calc mode with `M-+ M-+' than `C-x
> C-, C-,' but `C-x C-, g' is easier to type on my keyboard than `M-+ g'

But M-+ has been pretty much turned down.

Since we pretty much need a two key prefix, one starting with C-x
seems the way to go.  I'm pretty sure C-x <letter or number> or even
C-x C-<letter> would be turned down, so that leaves C-x <other symbol>
or C-x C-<other symbol>.  

For C-x <other symbol>, <other symbol> = `!', `%', `&', `*', `_', `~',
`|', `\', `"', `:' or `,' might work, and some of them might be
accessible without the shift key on most keyboards.  But without the
extra control key, I'm not sure they're "out of the way" enough to get
the green light.

For C-x C-<symbol>, <other symbol>=`\' or `]' might work.  Both
characters are accessible on my keyboard without the shift key, but I
don't think that's the case for all keyboards.

So there is no perfect key sequence; are there any thoughts on which
would be least annoying?

Jay

Re: Key-binding clash between gnus and calc

[Robert J. Chassell]

    You might have thought that I would have bright enough to check for
    that, especially since it came up before.  You would have been wrong.

Same here.  I don't have any good suggestions for a new keybinding,
except that it ought be as easy to type as the default for the past 15
years and preferably better.

(Weirdly enough, nowadays I mostly use Calc mode for units'
conversion, like from feet to meters or BTUs to joules.)

-- 
    Robert J. Chassell                         
    bob@rattlesnake.com                         GnuPG Key ID: 004B4AC8
    http://www.rattlesnake.com                  http://www.teak.cc

Re: Key-binding clash between gnus and calc

[Jay Belanger]

"Robert J. Chassell" <bob@rattlesnake.com> writes:

>     You might have thought that I would have bright enough to check for
>     that, especially since it came up before.  You would have been wrong.
>
> Same here.  I don't have any good suggestions for a new keybinding,
> except that it ought be as easy to type as the default for the past 15
> years and preferably better.

Exactly.  I've tried to narrow it down to some reasonable keybindings,
but I'm only familiar with US keyboards, and I'm hoping that someone
familiar with keyboards from more than one language will come along
and narrow it down some more.

> (Weirdly enough, nowadays I mostly use Calc mode for units'
> conversion, like from feet to meters or BTUs to joules.)

Why is that weird?

Jay

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

    For C-x <other symbol>, <other symbol> = `!', `%', `&', `*', `_', `~',
    `|', `\', `"', `:' or `,' might work, and some of them might be
    accessible without the shift key on most keyboards.  But without the
    extra control key, I'm not sure they're "out of the way" enough to get
    the green light.

One of those might be ok.  Perhaps any of them is ok.
I see no particular reason to oppose the use of any of them.

Re: Key-binding clash between gnus and calc

[Jay Belanger]

"Richard M. Stallman" <rms@gnu.org> writes:

>     For C-x <other symbol>, <other symbol> = `!', `%', `&', `*', `_', `~',
>     `|', `\', `"', `:' or `,' might work, and some of them might be
>     accessible without the shift key on most keyboards.  But without the
>     extra control key, I'm not sure they're "out of the way" enough to get
>     the green light.
>
> One of those might be ok.  Perhaps any of them is ok.
> I see no particular reason to oppose the use of any of them.

Okay, great.
It looks like the only symbol listed above that is consistently
available without a modifier key (to avoid having to change the
modifier keys while typing the key sequence in) is the comma.

Before I formally request the keybinding, are there any objections to
using `C-x,' for `calc-dispatch'?

Jay

Re: Key-binding clash between gnus and calc

[David Kastrup]

Jay Belanger <belanger@truman.edu> writes:

> "Richard M. Stallman" <rms@gnu.org> writes:
>
>>     For C-x <other symbol>, <other symbol> = `!', `%', `&', `*', `_', `~',
>>     `|', `\', `"', `:' or `,' might work, and some of them might be
>>     accessible without the shift key on most keyboards.  But without the
>>     extra control key, I'm not sure they're "out of the way" enough to get
>>     the green light.
>>
>> One of those might be ok.  Perhaps any of them is ok.
>> I see no particular reason to oppose the use of any of them.
>
> Okay, great.
> It looks like the only symbol listed above that is consistently
> available without a modifier key (to avoid having to change the
> modifier keys while typing the key sequence in) is the comma.
>
> Before I formally request the keybinding, are there any objections to
> using `C-x,' for `calc-dispatch'?

It's so unmnemonic.  # at least means "number".  I don't have a better
suggestion, though.

-- 
David Kastrup, Kriemhildstr. 15, 44793 Bochum

Re: Key-binding clash between gnus and calc

[Juri Linkov]

>> It looks like the only symbol listed above that is consistently
>> available without a modifier key (to avoid having to change the
>> modifier keys while typing the key sequence in) is the comma.
>>
>> Before I formally request the keybinding, are there any objections to
>> using `C-x,' for `calc-dispatch'?
>
> It's so unmnemonic.  # at least means "number".

I agree.  `,' has "next, please" mnemonics like e.g. in `M-,' (next-tag).

> I don't have a better suggestion, though.

 From this long discussion I got the impression that the best way to
satisfy everyone and not to annoy long-time calc users is to leave the
old `M-#' calc keybinding unchanged.  The fact that it is not available
in gnus is not a tragedy.  It does nothing disastrous when accidentally
typed in the gnus summary buffer (unlike M-g where rescanning the group
without the user's consent is not desirable).

-- 
Juri Linkov
http://www.jurta.org/emacs/

Re: Key-binding clash between gnus and calc

[David Kastrup]

Juri Linkov <juri@jurta.org> writes:

>>> It looks like the only symbol listed above that is consistently
>>> available without a modifier key (to avoid having to change the
>>> modifier keys while typing the key sequence in) is the comma.
>>>
>>> Before I formally request the keybinding, are there any objections to
>>> using `C-x,' for `calc-dispatch'?
>>
>> It's so unmnemonic.  # at least means "number".
>
> I agree.  `,' has "next, please" mnemonics like e.g. in `M-,' (next-tag).

next please, like in

C-x # runs the command server-edit
   which is an interactive compiled Lisp function in `server.el'.
It is bound to C-x #.
(server-edit &optional ARG)

Switch to next server editing buffer; say "Done" for current buffer.

[...]

Too bad that we are not in keybinding restructuring mode, but it would
look like a candidate after the release.

-- 
David Kastrup, Kriemhildstr. 15, 44793 Bochum

Re: Key-binding clash between gnus and calc

[Juri Linkov]

> Too bad that we are not in keybinding restructuring mode, but it would
> look like a candidate after the release.

I'd rather bind `C-x ,' to the command `next-release'.

-- 
Juri Linkov
http://www.jurta.org/emacs/

Re: Key-binding clash between gnus and calc

[David Kastrup]

Juri Linkov <juri@jurta.org> writes:

>> Too bad that we are not in keybinding restructuring mode, but it
>> would look like a candidate after the release.
>
> I'd rather bind `C-x ,' to the command `next-release'.

I don't think it is used as frequently as to warrant a keybinding of
its own.

-- 
David Kastrup, Kriemhildstr. 15, 44793 Bochum

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

     From this long discussion I got the impression that the best way to
    satisfy everyone and not to annoy long-time calc users is to leave the
    old `M-#' calc keybinding unchanged.

I never agreed to use M-# as a global binding for Calc,
and I don't think I should.  So it cannot stay as it is.

Re: Key-binding clash between gnus and calc

[Jay Belanger]

David Kastrup <dak@gnu.org> writes:

> Jay Belanger <belanger@truman.edu> writes:
...
>> Before I formally request the keybinding, are there any objections to
>> using `C-x,' for `calc-dispatch'?
>
> It's so unmnemonic.  # at least means "number".  I don't have a better
> suggestion, though.

The sequence `C-x*' has the slight advantage of using a math operator
at the cost of being slightly more difficult to type.

Jay

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

    The sequence `C-x*' has the slight advantage of using a math operator
    at the cost of being slightly more difficult to type.

I would not object to using that.

Re: Key-binding clash between gnus and calc

[Jay Belanger]

"Richard M. Stallman" <rms@gnu.org> writes:

>     The sequence `C-x*' has the slight advantage of using a math operator
>     at the cost of being slightly more difficult to type.
>
> I would not object to using that.

`C-x*' it is, then, for `calc-dispatch'.
I'll make the change on Monday.

Jay

Re: Key-binding clash between gnus and calc

[Sascha Wilde]

Jay Belanger <belanger@truman.edu> wrote:

> The sequence `C-x*' has the slight advantage of using a math operator
> at the cost of being slightly more difficult to type.

I like this one. Its mnemonic, easy enough to type (at least on US and
germane Layouts) and Richard said he wouldn't object.

Has anyone checked if it is used in any of the major modes, which are
already part of Emacs?

sascha
-- 
Sascha Wilde
We're Germans and we use Unix. That's a combination of two 
demographic groups known to have no sense of humour whatsoever.
  -- Hanno Mueller in de.comp.os.unix.programming

Re: Key-binding clash between gnus and calc

[Robert J. Chassell]

On an American keyboard, the prefix `C-x*' is harder to type than
`C-x\'.  (I do not know about other keyboards with default bindings.
As far as I know, `C-x\' is undefined.)

Thus, `C-x\g' (calc-grab-region) is not bad for such a command.

-- 
    Robert J. Chassell                         
    bob@rattlesnake.com                         GnuPG Key ID: 004B4AC8
    http://www.rattlesnake.com                  http://www.teak.cc

Re: Key-binding clash between gnus and calc

[Michael Cadilhac]

"Robert J. Chassell" <bob@rattlesnake.com> writes:

> On an American keyboard, the prefix `C-x*' is harder to type than
> `C-x\'.  (I do not know about other keyboards with default bindings.
> As far as I know, `C-x\' is undefined.)
>
> Thus, `C-x\g' (calc-grab-region) is not bad for such a command.

Well, on a french keyboard, the `\' key is AltGR+8 (Yes, it's silly).

In other words, it's one of the harder thing to type (using thumbs
and index of the same hand) :-)

-- 
    Michael Cadilhac, a.k.a. Micha [mika] |
                    Epita/LRDE promo 2007 |   )\._.,--....,'``.
123 av. de Fontainebleau | 08.70.65.13.14 |  /.  _.. \   _\  (` ._,.
94270 Le Kremlin Bicetre | 06.23.20.31.30 | '._.-(,_..'--(,_...`-..'

Re: Key-binding clash between gnus and calc

[Lennart Borgman]

Michael Cadilhac wrote:

>"Robert J. Chassell" <bob@rattlesnake.com> writes:
>
>  
>
>>On an American keyboard, the prefix `C-x*' is harder to type than
>>`C-x\'.  (I do not know about other keyboards with default bindings.
>>As far as I know, `C-x\' is undefined.)
>>
>>Thus, `C-x\g' (calc-grab-region) is not bad for such a command.
>>    
>>
>
>Well, on a french keyboard, the `\' key is AltGR+8 (Yes, it's silly).
>
>In other words, it's one of the harder thing to type (using thumbs
>and index of the same hand) :-)
>  
>
On a swedish keyboard it it AltGr +.

But talking about "hard to type" I wonder if people here does not use 
"StickyKeys"? (This is platform dependent with a bit different names but 
at least exists in w32 and Gnome.) With "StickyKeys" you type the keys 
one-by-one. A real pain-saver when you are using Emacs keys.

Re: Key-binding clash between gnus and calc

[Robert J. Chassell]

    Well, on a french keyboard, the `\' key is AltGR+8

That is bad.  We should avoid it.  Perhaps we could follow Juri
Linkov's suggestion:

    Another variant ... is the equals sign.

    `C-x =' is currently occupied by the help commands
    `what-cursor-position' and `describe-char'.  But Kim recently
    suggested to rebind them to `C-h c', so `C-x =' will be available
    for calc.

    ... we could save `C-x *' for some future use ...

-- 
    Robert J. Chassell                         
    bob@rattlesnake.com                         GnuPG Key ID: 004B4AC8
    http://www.rattlesnake.com                  http://www.teak.cc

Re: Key-binding clash between gnus and calc

[Jay Belanger]

"Robert J. Chassell" <bob@rattlesnake.com> writes:

>     Well, on a french keyboard, the `\' key is AltGR+8
>
> That is bad.  We should avoid it.  Perhaps we could follow Juri
> Linkov's suggestion:
>
>     Another variant ... is the equals sign.
>
>     `C-x =' is currently occupied by the help commands
>     `what-cursor-position' and `describe-char'.  But Kim recently
>     suggested to rebind them to `C-h c', so `C-x =' will be available
>     for calc.

That would be great, if the rebinding of `describe-char' takes place
before the next release.  Perhaps Kim could comment on this.

(Also, is `=' easily accessible on most keyboards?)

Jay

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

    On an American keyboard, the prefix `C-x*' is harder to type than
    `C-x\'.

I would agree to C-x \ for Calc.

Re: Key-binding clash between gnus and calc

[Jay Belanger]

Sascha Wilde <wilde@sha-bang.de> writes:

> Jay Belanger <belanger@truman.edu> wrote:
>
>> The sequence `C-x*' has the slight advantage of using a math operator
>> at the cost of being slightly more difficult to type.
>
> I like this one. Its mnemonic, easy enough to type (at least on US and
> germane Layouts) and Richard said he wouldn't object.

Robert J. Chassell <bob@rattlesnake.com> writes:

> On an American keyboard, the prefix `C-x*' is harder to type than
> `C-x\'.  (I do not know about other keyboards with default bindings.
> As far as I know, `C-x\' is undefined.)

How much harder do you find it?  Given that you agree that `C-x\'
should be avoided, do you find `C-x*' too awkward?

Robert J. Chassell <bob@rattlesnake.com> later wrote:

>>   Well, on a french keyboard, the `\' key is AltGR+8
>
> That is bad.  We should avoid it.  Perhaps we could follow Juri
> Linkov's suggestion:
>
>    Another variant ... is the equals sign.
>
>    `C-x =' is currently occupied by the help commands
>    `what-cursor-position' and `describe-char'.  But Kim recently
>    suggested to rebind them to `C-h c', so `C-x =' will be available
>    for calc.

Since `C-x=' won't be available, it seems to come down to `C-x*' and
`C-x\'.  (There are others available, but none of which seem to have
any advantages, and these two have gotten the green light.)  
The awkwardness of `C-x\' on some keyboards seems to outweigh it's
advantage on the American keyboard.  The `C-x*' isn't as nice for me
as `C-x\', but I still don't find it that bad.
Unless there are serious objections, it looks to me like `C-x*' is the
best choice. 

Jay

Re: Key-binding clash between gnus and calc

[Juri Linkov]

> Since `C-x=' won't be available, it seems to come down to `C-x*' and
> `C-x\'.  (There are others available, but none of which seem to have
> any advantages, and these two have gotten the green light.)
> The awkwardness of `C-x\' on some keyboards seems to outweigh it's
> advantage on the American keyboard.  The `C-x*' isn't as nice for me
> as `C-x\', but I still don't find it that bad.
> Unless there are serious objections, it looks to me like `C-x*' is the
> best choice.

If there is no hurry with the decision, then given the fact that
there are better keybindings, what about the following plan?

1. Bind `C-h =' to `what-cursor-position' and `C-h c' to `describe-char',
but keep `C-x =' bound to `what-cursor-position'.

2. Document everywhere in the documentation that `C-h =' is the new
keybinding for `what-cursor-position' and `C-x =' is deprecated.

3. After the release rebind `C-x =' to `calc-dispatch'.

Or alternatively, as David suggested, bind `C-x ,' to `server-edit' and
rebind `C-x #' to `calc-dispatch' after the release.

-- 
Juri Linkov
http://www.jurta.org/emacs/

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

    If there is no hurry with the decision, then given the fact that
    there are better keybindings, what about the following plan?

    1. Bind `C-h =' to `what-cursor-position' and `C-h c' to `describe-char',
    but keep `C-x =' bound to `what-cursor-position'.

Please let's not devote attention at this point
to ideas for changes in old key bindings.
Let's stick to fixing bugs.

Re: Key-binding clash between gnus and calc

[Juri Linkov]

> The sequence `C-x*' has the slight advantage of using a math operator
> at the cost of being slightly more difficult to type.

Yep, `*' is mnemonic for calc.

Another variant related to calc that could be considered is the equals sign.
It is mnemonic for calc as well since it is used to indicate mathematical
equality, and easy to type.

`C-x =' is currently occupied by the help commands `what-cursor-position'
and `describe-char'.  But Kim recently suggested to rebind them to `C-h c',
so `C-x =' will be available for calc.

Using `C-x =' for calc also has the advantage that no new keybinding
will be occupied, so we could save `C-x *' for some future use that is
more needed.

-- 
Juri Linkov
http://www.jurta.org/emacs/

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

    `C-x =' is currently occupied by the help commands `what-cursor-position'
    and `describe-char'.  But Kim recently suggested to rebind them to `C-h c',

I don't want to change that old traditional binding.
Certainly not now.

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

    Okay, great.
    It looks like the only symbol listed above that is consistently
    available without a modifier key (to avoid having to change the
    modifier keys while typing the key sequence in) is the comma.

    Before I formally request the keybinding, are there any objections to
    using `C-x,' for `calc-dispatch'?

I tend to think we should save that for some future
use that is more needed.

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

C-, also is not available on ttys.

Re: Key-binding clash between gnus and calc

[Robert J. Chassell]

I did a recursive grep for `M-+' starting at emacs/ 

    (igrep "grep" "M\\-\\+" (quote ("*")) "-i")

The key does not appear bound to any command although
lisp/term/iris-ansi.el does make sure it is in 
the function-key-map.

    (define-key function-key-map "\e[201q" [?\M-+])

Also, I did a recursive grep for `C-x C-,' starting at emacs/.  The
key is not bound or noted anywhere.

    (igrep "grep" "\\C\\-x\\C\\-,"(quote ("*")) "-i")

It would be easier to start Emacs Calc mode with `M-+ M-+' than `C-x
C-, C-,' but `C-x C-, g' is easier to type on my keyboard than `M-+ g'

-- 
    Robert J. Chassell                         
    bob@rattlesnake.com                         GnuPG Key ID: 004B4AC8
    http://www.rattlesnake.com                  http://www.teak.cc

Re: Key-binding clash between gnus and calc

[Andreas Schwab]

"Robert J. Chassell" <bob@rattlesnake.com> writes:

> I did a recursive grep for `M-+' starting at emacs/ 
>
>     (igrep "grep" "M\\-\\+" (quote ("*")) "-i")

You won't find bindings in esc-map this way.

> Also, I did a recursive grep for `C-x C-,' starting at emacs/.  The
> key is not bound or noted anywhere.
>
>     (igrep "grep" "\\C\\-x\\C\\-,"(quote ("*")) "-i")

You can never find a binding for C-x C-, this way.  There are many ways to
spell it, but this is not one of them.

Andreas.

-- 
Andreas Schwab, SuSE Labs, schwab@suse.de
SuSE Linux Products GmbH, Maxfeldstraße 5, 90409 Nürnberg, Germany
PGP key fingerprint = 58CA 54C7 6D53 942B 1756  01D3 44D5 214B 8276 4ED5
"And now for something completely different."

Re: Key-binding clash between gnus and calc

[Juri Linkov]

>>> However, this gave me a good idea: `C-x M-#', i.e. the current `M-#'
>>> remains unchanged, but with the initial `C-x'.
>>
>> What's good about that?  It is really contorted.
>
> It preserves some continuity with the old keybinding, which is
> nice.  But since I'm not the only person who thinks it's a bit
> awkward, something else might be in order.

It is not much more awkward then current `M-#'.  Surely it is not
easy to type, but I think that easy to type is not a requirement for
a key sequence to invoke calc.  There are many frequently used
commands in Emacs that require more easy to type keys, but still
miss them.  Just one example of frequently used command without
a convenient keybinding is `other-window'.  I think most users switch
windows more often than invoke calc.  It would be too shortsighted to
allocate short and easy to type keybindings to less frequent commands.

-- 
Juri Linkov
http://www.jurta.org/emacs/

Re: Key-binding clash between gnus and calc

[Jay Belanger]

Juri Linkov <juri@jurta.org> writes:

>>>> However, this gave me a good idea: `C-x M-#', i.e. the current `M-#'
>>>> remains unchanged, but with the initial `C-x'.
>>>
>>> What's good about that?  It is really contorted.
>>
>> It preserves some continuity with the old keybinding, which is
>> nice.  But since I'm not the only person who thinks it's a bit
>> awkward, something else might be in order.
>
> It is not much more awkward then current `M-#'.  Surely it is not
> easy to type, but I think that easy to type is not a requirement for
> a key sequence to invoke calc.  There are many frequently used
> commands in Emacs that require more easy to type keys, but still
> miss them.  Just one example of frequently used command without
> a convenient keybinding is `other-window'.

The `other-window' command is invoked with `C-xo', which seems easy to
type in. `C-xM-#', on the other hand, requires changing from a control
key to a meta and (on my keyboard) shift key.  I think that's a lot
more awkward to type in (but then my fingers are less than nimble).

Jay

Re: Key-binding clash between gnus and calc

[Juri Linkov]

> The `other-window' command is invoked with `C-xo', which seems easy to
> type in. `C-xM-#', on the other hand, requires changing from a control
> key to a meta and (on my keyboard) shift key.  I think that's a lot
> more awkward to type in (but then my fingers are less than nimble).

Ideally, very frequent commands like `other-window' should be very
easy to type like e.g. 1-key `C-o'.  Less frequent commands should have
less easy to type keybindings.

-- 
Juri Linkov
http://www.jurta.org/emacs/

Re: Key-binding clash between gnus and calc

[Robert J. Chassell]

    ... easy to type is not a requirement for a key sequence to invoke
    calc.

That depends on how frequently you invoke Calc.  

Certainly, I invoke `C-x o' (other-window) more often than Calc.  But
I invoke Calc more often than `M-DEL' (backward-kill-word).  Both are
default keybindings in the current distribution.

Besides calculations, such as division or least squares, Calc is
really good for conversions.  Nowadays, I use that feature frequently.
Of course, your meterage may vary -- in the United States, we say
`your _milage_ may vary', and we speak of `barrels' of oil ...

As for using `C-x,' for `calc-dispatch':  it is unmnemonic.  That is
true.

But `C-x,,' does well to turn Calc on or off using the same Calc
interface as before.  Also `C-x,g' does well for calc-grab-region,
`C-x,y' for calc-copy-to-buffer, and so on.

And I just tried `C-x,' in a tty as well as in X (with `-Q -D',
yesterday's CVS snapshot), and in a xterm (`-Q -D -nw').  The
keybinding is undefined in all.  You can invoke it on an American
keyboard; I do not know about others.

-- 
    Robert J. Chassell                         
    bob@rattlesnake.com                         GnuPG Key ID: 004B4AC8
    http://www.rattlesnake.com                  http://www.teak.cc

Re: Key-binding clash between gnus and calc

[Andreas Schwab]

Jay Belanger <belanger@truman.edu> writes:

> How about `C-x C-0'?

C-0 is not available on a tty.

Andreas.

-- 
Andreas Schwab, SuSE Labs, schwab@suse.de
SuSE Linux Products GmbH, Maxfeldstraße 5, 90409 Nürnberg, Germany
PGP key fingerprint = 58CA 54C7 6D53 942B 1756  01D3 44D5 214B 8276 4ED5
"And now for something completely different."

Re: Key-binding clash between gnus and calc

[Ryan Yeske]

       Are there any conventions for global keybindings?

   Yes--you should always ask me.

With all the recent talk about global bindings and calc, I thought I
should mention that the recently added rcirc package includes two
global bindings after it is loaded:

C-c `
C-c C-SPC

both run the command: rcirc-next-active-buffer:
  "Go to the ARGth rcirc buffer with activity.
The function given by `rcirc-switch-to-buffer-function' is used to
show the buffer."

C-c ` was the original binding I used, and C-c C-SPC was added as
people who were familiar ERC preferred that binding.

Re: Key-binding clash between gnus and calc

[David Kastrup]

Ryan Yeske <rcyeske@gmail.com> writes:

>        Are there any conventions for global keybindings?
>
>    Yes--you should always ask me.
>
> With all the recent talk about global bindings and calc, I thought I
> should mention that the recently added rcirc package includes two
> global bindings after it is loaded:
>
> C-c `

Used by AUCTeX.

> C-c C-SPC

Probably hard to enter on some terminals.

> both run the command: rcirc-next-active-buffer:
>   "Go to the ARGth rcirc buffer with activity.
> The function given by `rcirc-switch-to-buffer-function' is used to
> show the buffer."
>
> C-c ` was the original binding I used, and C-c C-SPC was added as
> people who were familiar ERC preferred that binding.

It does not seem like rcirc would be a class of application that would
be predetermined to occupy the global key space in that manner.
Perhaps you could explain the rationale for using a global key binding
here?

-- 
David Kastrup, Kriemhildstr. 15, 44793 Bochum

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

    > With all the recent talk about global bindings and calc, I thought I
    > should mention that the recently added rcirc package includes two
    > global bindings after it is loaded:

I had missed that part.  rcirc should not bind any C-c keys globally.
They are reserved for users, for major modes, or for minor modes.

Remember that loading rcirc can occur even without running it.
It's not right for loading the file to bind any keys.

Re: Key-binding clash between gnus and calc

[Ryan Yeske]

   From: "Richard M. Stallman" <rms@gnu.org>
   CC: rcyeske@gmail.com, emacs-devel@gnu.org
   Reply-to: rms@gnu.org
   Date: Mon, 21 Nov 2005 21:20:58 -0500

       > With all the recent talk about global bindings and calc, I thought I
       > should mention that the recently added rcirc package includes two
       > global bindings after it is loaded:

   I had missed that part.  rcirc should not bind any C-c keys globally.
   They are reserved for users, for major modes, or for minor modes.

What about C-x SPC?

   Remember that loading rcirc can occur even without running it.
   It's not right for loading the file to bind any keys.

Is it acceptable to bind a global key when M-x rcirc is run?

Ryan

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

Practically speaking there is not much difference between rcirc's
binding a key all the time, and rcirc's binding it globally once rcirc
runs.  Either way, for all intents and purposes, that key can't be
used for anything else.

What job do you want this key to do?

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

    C-c C-SPC

That's fine; it's reserved for major modes.

    C-c `

In the Lisp manual it says

    @item
    Sequences consisting of @kbd{C-c} followed by any other punctuation
    character are allocated for minor modes.  Using them in a major mode is
    not absolutely prohibited, but if you do that, the major mode binding
    may be shadowed from time to time by minor modes.

So you might want to change ` to a different character.

Re: Key-binding clash between gnus and calc

[Jay Belanger]

"Richard M. Stallman" <rms@gnu.org> writes:

>     C-c C-SPC
>
> That's fine; it's reserved for major modes.
>
>     C-c `
>
> In the Lisp manual it says
>
>     @item
>     Sequences consisting of @kbd{C-c} followed by any other punctuation
>     character are allocated for minor modes.  Using them in a major mode is
>     not absolutely prohibited, but if you do that, the major mode binding
>     may be shadowed from time to time by minor modes.
>
> So you might want to change ` to a different character.

These aren't major mode bindings, though.  Once rcirc is loaded,
they're global bindings.

Jay

Re: Key-binding clash between gnus and calc

[Jay Belanger]

Sascha Wilde <wilde@sha-bang.de> writes:

> `M-#' is normally bound to `calc-dispatch', but in gnus it's bound to
> `gnus-topic-unmark-topic' in groups buffer, to
> `gnus-summary-unmark-as-processable' in summary and article buffer.
>
> I don't know which of them has the "older rights" to use this binding,
> but anyway, to a regular user of both, gnus and calc (as me for
> instance) the current state is quite inconvenient.

As me for another example.
Gnus has been part of Emacs longer, so if either one has rights, it
would be gnus.  However, gnus uses it only in gnus buffers, while Calc
tries to use it globally.  I don't know if there are any conventions
for global keybindings like there are for major and minor mode
keybindings, or where M-# would fit.  Rebinding it in your init file
may be convenient,
(global-set-key "\C-cm" 'calc-dispatch)
or somesuch.

Jay

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

    As me for another example.
    Gnus has been part of Emacs longer, so if either one has rights, it
    would be gnus.  However, gnus uses it only in gnus buffers, while Calc
    tries to use it globally.

I think Calc had better look for a more obscure binding for this,
or else leave it to users to make key bindings if they want one.

Re: Key-binding clash between gnus and calc

[Sascha Wilde]

[-- Attachment #1.1: Type: text/plain, Size: 846 bytes --]

"Richard M. Stallman" <rms@gnu.org> wrote:

>     As me for another example.
>     Gnus has been part of Emacs longer, so if either one has rights, it
>     would be gnus.  However, gnus uses it only in gnus buffers, while Calc
>     tries to use it globally.
>
> I think Calc had better look for a more obscure binding for this,

How about something like `C-x &'?

> or else leave it to users to make key bindings if they want one.

Maybe this would be actually the best solution.
Key bindings are getting real rare, and most applications coming with
Emacs don't have a default binding to start them either.

I think, having none would be better, than having one, which isn't
really global.

cheers
sascha
-- 
Sascha Wilde : "Lies, was ich meine, nicht, was ich schreibe."
             : (Urs Traenkner in de.alt.admin)

[-- Attachment #1.2: Type: application/pgp-signature, Size: 188 bytes --]

[-- Attachment #2: Type: text/plain, Size: 142 bytes --]

_______________________________________________
Emacs-devel mailing list
Emacs-devel@gnu.org
http://lists.gnu.org/mailman/listinfo/emacs-devel

Re: Key-binding clash between gnus and calc

[Juri Linkov]

> "Richard M. Stallman" <rms@gnu.org> wrote:
>
>>     As me for another example.
>>     Gnus has been part of Emacs longer, so if either one has rights, it
>>     would be gnus.  However, gnus uses it only in gnus buffers, while Calc
>>     tries to use it globally.
>>
>> I think Calc had better look for a more obscure binding for this,
>
> How about something like `C-x &'?

Then why not `C-x #'?

-- 
Juri Linkov
http://www.jurta.org/emacs/

Re: Key-binding clash between gnus and calc

[Sascha Wilde]

Juri Linkov <juri@jurta.org> wrote:

>> "Richard M. Stallman" <rms@gnu.org> wrote:
>>
>>>     As me for another example.
>>>     Gnus has been part of Emacs longer, so if either one has rights, it
>>>     would be gnus.  However, gnus uses it only in gnus buffers, while Calc
>>>     tries to use it globally.
>>>
>>> I think Calc had better look for a more obscure binding for this,
>>
>> How about something like `C-x &'?
>
> Then why not `C-x #'?

`C-h k C-x #' will answer this question...  ;-)

sascha
-- 
Sascha Wilde
Wer HTML postet oder gepostetes HTML quotet oder sich gepostetes oder
gequotetes HTML beschafft, um es in Verkehr zu bringen, wird geplonkt.

Re: Key-binding clash between gnus and calc

[Juri Linkov]

>>> How about something like `C-x &'?
>>
>> Then why not `C-x #'?
>
> `C-h k C-x #' will answer this question...  ;-)

`C-h k C-x #'  =>  C-x # is undefined

I haven't used server-edit for quite a while and forgot about its
keybinding.

This indicates that before accepting a global keybinding for calc,
all Emacs packages (at least, in the Emacs source tree, and also
popular packages not distributed with Emacs) should be carefully
inspected for possible conflicts with a new calc global keybinding.

-- 
Juri Linkov
http://www.jurta.org/emacs/

Re: Key-binding clash between gnus and calc

[Andreas Schwab]

Juri Linkov <juri@jurta.org> writes:

> Then why not `C-x #'?

Already taken for server-edit.

Andreas.

-- 
Andreas Schwab, SuSE Labs, schwab@suse.de
SuSE Linux Products GmbH, Maxfeldstraße 5, 90409 Nürnberg, Germany
PGP key fingerprint = 58CA 54C7 6D53 942B 1756  01D3 44D5 214B 8276 4ED5
"And now for something completely different."

Re: Key-binding clash between gnus and calc

[Juri Linkov]

> `M-#' is normally bound to `calc-dispatch', but in gnus it's bound to
> `gnus-topic-unmark-topic' in groups buffer, to
> `gnus-summary-unmark-as-processable' in summary and article buffer.
>
> I don't know which of them has the "older rights" to use this binding,
> but anyway, to a regular user of both, gnus and calc (as me for
> instance) the current state is quite inconvenient.

I doubt that `M-#' in gnus is used too much, because it has one
inconvenience which is not fixed for a long time.  Unlike `#' which
advances to the next article, `M-#' stays on the same article.
To unmark several articles the user has to type `M-# C-n M-# C-n ...'.

There is another key binding in gnus that conflicts with the global
key binding.  It is `M-g'.

-- 
Juri Linkov
http://www.jurta.org/emacs/

Re: Key-binding clash between gnus and calc

[Miles Bader]

2005/11/17, Juri Linkov <juri@jurta.org>:
> I doubt that `M-#' in gnus is used too much, because it has one
> inconvenience which is not fixed for a long time.  Unlike `#' which
> advances to the next article, `M-#' stays on the same article.

Unmarking commands in Gnus follow a fairly regular pattern -- if key
"foo" marks, then "M-foo" unmarks.  This correspondence is _extremely_
useful, because one uses unmarking commands more rarely than the
corresponding marking command, so a regular naming convention makes it
easy to remember what they're bound to.

However, despite the fact that they are used more rarely, they
certainly are used. Note that unmarking commands are typically used to
correct mistakes, not for large-scale changes, so for "#", being
repeatable is quite important to normal usage; for "M-#", it's not.

> There is another key binding in gnus that conflicts with the global
> key binding.  It is `M-g'.

Yeah, so what?  Another notable non-tragedy.

-miles
--
Do not taunt Happy Fun Ball.

Re: Key-binding clash between gnus and calc

[Sascha Wilde]

Miles Bader <snogglethorpe@gmail.com> wrote:

> 2005/11/17, Juri Linkov <juri@jurta.org>:
>> I doubt that `M-#' in gnus is used too much, because it has one
>> inconvenience which is not fixed for a long time.  Unlike `#' which
>> advances to the next article, `M-#' stays on the same article.
>
> Unmarking commands in Gnus follow a fairly regular pattern -- if key
> "foo" marks, then "M-foo" unmarks.  This correspondence is _extremely_
> useful, because one uses unmarking commands more rarely than the
> corresponding marking command, so a regular naming convention makes it
> easy to remember what they're bound to.

I agree, that the correspondence is quite use full, but I also do
agree with Juri, that the slightly different behavior of M-# is
extremely inconvenient.  IMO this should be fixed, by making M-#
advance to (like M-u does!).

[...]
>> There is another key binding in gnus that conflicts with the global
>> key binding.  It is `M-g'.
>
> Yeah, so what?  Another notable non-tragedy.

I agree, in this special case, that it is not tragic:

  Global Bindings Starting With M-g:
  key             binding
  ---             -------

  M-g p           previous-error
  M-g n           next-error
  M-g g           goto-line
  M-g ESC         Prefix Command

  M-g M-p         previous-error
  M-g M-n         next-error
  M-g M-g         goto-line

previous-error and next-error just don't make any sense in gnus.  (In
fact, I'm not sure why they are global bindings anyway.)  And
goto-line isn't particularly use full in gnus buffers either.

BUT, in general I think, that Emacs as a whole should be as consistent
as possible.  That is one reason why global bindings should be
approved by Richard, and I thin that is a good thing[tm]. ;-)

cheers
sascha
-- 
>++++++[<+++++++++++>-]<+.>+++[<++++++>-]<.---.---------.++++++.++++.---------
-.+++++++++++.+++++.>+++++++[<-------->-]<-.>++++++[<+++++++>-]<+.--.+++..----
---.-.>++++++[<------>-]<.>++++[<+++++++++++++>-]<.------------.---.>++++++[<-
----->-]<-.>+++++[<+++++++>-]<.--.>+++[<++++++>-]<+.>++++++++[<--------->-]<--.

Re: Key-binding clash between gnus and calc

[Miles Bader]

Sascha Wilde <wilde@sha-bang.de> writes:
> agree with Juri, that the slightly different behavior of M-# is
> extremely inconvenient.  IMO this should be fixed, by making M-#
> advance to (like M-u does!).

Sounds fine to me.

> BUT, in general I think, that Emacs as a whole should be as consistent
> as possible.

Sure, consistency, in general, is good.  But absolute consistency is not
necessary; sometimes it's more important to retain historical bindings,
or to favor local consistency over global consistency.

-miles
-- 
o The existentialist, not having a pillow, goes everywhere with the book by
  Sullivan, _I am going to spit on your graves_.

Re: Key-binding clash between gnus and calc

[Andreas Schwab]

Sascha Wilde <wilde@sha-bang.de> writes:

> previous-error and next-error just don't make any sense in gnus.  (In
> fact, I'm not sure why they are global bindings anyway.)

You can use {previous,next}-error from any buffer, it will use the last
used compilation/grep/diff buffer as reference.  This is extremely
convenient.

Andreas.

-- 
Andreas Schwab, SuSE Labs, schwab@suse.de
SuSE Linux Products GmbH, Maxfeldstraße 5, 90409 Nürnberg, Germany
PGP key fingerprint = 58CA 54C7 6D53 942B 1756  01D3 44D5 214B 8276 4ED5
"And now for something completely different."

Re: Key-binding clash between gnus and calc

[Juri Linkov]

[Cc'ed to ding@gnus.org]
> I agree, that the correspondence is quite use full, but I also do
> agree with Juri, that the slightly different behavior of M-# is
> extremely inconvenient.  IMO this should be fixed, by making M-#
> advance to (like M-u does!).

Actually, this is a bug in the the development version of Gnus
(but not in the Gnus version in Emacs CVS).  It also causes
gnus-uu-unmark-thread to fail to unmark the whole thread.

That's because gnus-summary-remove-process-mark doesn't return t
anymore.  The last expression of both gnus-summary-set-process-mark
and gnus-summary-remove-process-mark is the call to
gnus-summary-update-secondary-mark which explicitly returns t.
But in gnus-summary-remove-process-mark this t gets lost due
to dolist which returns nil.  I think the right fix is to add
the return value t as the last expression in
gnus-summary-remove-process-mark.

Could someone with CVS access to the Gnus repository on gnus.org
fix this?

-- 
Juri Linkov
http://www.jurta.org/emacs/

Re: Key-binding clash between gnus and calc

[Kevin Greiner]

Juri Linkov <juri@jurta.org> writes:

> [Cc'ed to ding@gnus.org]
>> I agree, that the correspondence is quite use full, but I also do
>> agree with Juri, that the slightly different behavior of M-# is
>> extremely inconvenient.  IMO this should be fixed, by making M-#
>> advance to (like M-u does!).
>
> Actually, this is a bug in the the development version of Gnus
> (but not in the Gnus version in Emacs CVS).  It also causes
> gnus-uu-unmark-thread to fail to unmark the whole thread.
>
> That's because gnus-summary-remove-process-mark doesn't return t
> anymore.  The last expression of both gnus-summary-set-process-mark
> and gnus-summary-remove-process-mark is the call to
> gnus-summary-update-secondary-mark which explicitly returns t.
> But in gnus-summary-remove-process-mark this t gets lost due
> to dolist which returns nil.  I think the right fix is to add
> the return value t as the last expression in
> gnus-summary-remove-process-mark.
>
> Could someone with CVS access to the Gnus repository on gnus.org
> fix this?

Done.

Kevin

Re: Key-binding clash between gnus and calc

[Juri Linkov]

>> Actually, this is a bug in the the development version of Gnus
>> (but not in the Gnus version in Emacs CVS).  It also causes
>> gnus-uu-unmark-thread to fail to unmark the whole thread.
>>
>> That's because gnus-summary-remove-process-mark doesn't return t
>> anymore.  The last expression of both gnus-summary-set-process-mark
>> and gnus-summary-remove-process-mark is the call to
>> gnus-summary-update-secondary-mark which explicitly returns t.
>> But in gnus-summary-remove-process-mark this t gets lost due
>> to dolist which returns nil.  I think the right fix is to add
>> the return value t as the last expression in
>> gnus-summary-remove-process-mark.
>>
>> Could someone with CVS access to the Gnus repository on gnus.org
>> fix this?
>
> Done.

Thanks.

I've also noticed a difference between gnus-uu-mark-thread and
gnus-uu-unmark-thread: gnus-uu-mark-thread keeps point
at the same place where it was invoked, but gnus-uu-unmark-thread
advances point to the last processed article.  Do you think
they should behave the same in regard to preserving point
after finishing?

-- 
Juri Linkov
http://www.jurta.org/emacs/

Re: Key-binding clash between gnus and calc

[Richard M. Stallman]

    I doubt that `M-#' in gnus is used too much, because it has one
    inconvenience which is not fixed for a long time.  Unlike `#' which
    advances to the next article, `M-#' stays on the same article.
    To unmark several articles the user has to type `M-# C-n M-# C-n ...'.

Because this is a local binding, it is just a Gnus issue,
not a conflict with anything else.

    There is another key binding in gnus that conflicts with the global
    key binding.  It is `M-g'.

What does that do?  (Is the global M-g binding of any use in Gnus
buffers?  Perhaps not much.)

Re: Key-binding clash between gnus and calc

[Reiner Steib]

On Fri, Nov 18 2005, Richard M. Stallman wrote:

>     There is another key binding in gnus that conflicts with the global
>     key binding.  It is `M-g'.
>
> What does that do?

,----[ Group buffer ]
| M-g runs the command gnus-group-get-new-news-this-group
|    which is an interactive compiled Lisp function in `gnus-group.el'.
| It is bound to M-g, <menu-bar> <Group> <Check for new articles>.
| (gnus-group-get-new-news-this-group &optional n dont-scan)
| 
| Check for newly arrived news in the current group (and the n-1 next groups).
`----

,----[ Summary buffer / Article buffer ]
| M-g runs the command gnus-summary-rescan-group
|    which is an interactive compiled Lisp function in `gnus-sum.el'.
| It is bound to M-g, Z G, <menu-bar> <Gnus> <Exit> <Rescan group>.
| (gnus-summary-rescan-group &optional all)
| 
| Exit the newsgroup, ask for new articles, and select the newsgroup.
`----

> (Is the global M-g binding of any use in Gnus buffers?  Perhaps not
> much.)

I don't think the `M-g ...' command are useful in the Gnus buffers
(Group buffer and Summary/Article buffer).

Bye, Reiner.
-- 
       ,,,
      (o o)
---ooO-(_)-Ooo---  |  PGP key available  |  http://rsteib.home.pages.de/

Re: Key-binding clash between gnus and calc

[Juri Linkov]

>>> How about something like `C-x &'?
>>
>> Then why not `C-x #'?
>
> Why not `C-x c'?

I think other packages might pretend to this keybinding (e.g. calendar).

-- 
Juri Linkov
http://www.jurta.org/emacs/

Re: Key-binding clash between gnus and calc

[Chong Yidong]

>> Why not `C-x c'?
>
> I think other packages might pretend to this keybinding (e.g. calendar).

I can't find mention of that keybinding anywhere.

Re: Key-binding clash between gnus and calc

[Henrik Enberg]

> From: Chong Yidong <cyd@stupidchicken.com>
> Date: Tue, 22 Nov 2005 09:15:38 -0500
> 
> >> Why not `C-x c'?
> >
> > I think other packages might pretend to this keybinding (e.g. calendar).
> 
> I can't find mention of that keybinding anywhere.

Way to close to C-x C-c in my opinion.

Re: Key-binding clash between gnus and calc

[Jay Belanger]

Chong Yidong <cyd@stupidchicken.com> writes:

>>> Why not `C-x c'?
>>
>> I think other packages might pretend to this keybinding (e.g. calendar).
>
> I can't find mention of that keybinding anywhere.

In pcvs-defs.el, it's defined as a prefix key for cvs-minor-mode.

Jay