key binding question

key binding question

[Kevin Reeder]

When using the python interpreter within emacs, I'd like to have the
up/down arrows echo previous commands. Can anyone give me the code for
this?

Kevin

Re: key binding question

[maierh]

Kevin Reeder <avail@uponrequest.org> writes:

> When using the python interpreter within emacs, I'd like to have the
> up/down arrows echo previous commands. Can anyone give me the code for
> this?

The common philosophy on this subject is to use M-p and M-n because
with down and up or C-n and C-p you might move in the buffer. Anyway,
I don't know the python interpreter mode, but if it's derived from
comint then you can set in the interpreter mode hook the function
'comint-previous-input' and 'comint-next-input' to your favorite keys.

Here an example that sets in general for all comint modes new function
keys. But you can set this too only for a special mode such as
'shell-mode-hook' or maybe 'py-mode-hook' (?).

(add-hook 
 'comint-mode-hook 
 (lambda () 
   (interactive)
   (define-key comint-mode-map [up]   'comint-previous-input)
   (define-key comint-mode-map [down] 'comint-next-input)
   ))


Harald

Re: key binding question

[Jerome Besnard]

> When using the python interpreter within emacs, I'd like to have the
> up/down arrows echo previous commands. Can anyone give me the code for
> this?

The pyhton shell uses comint-mode (for input-output in shell-like modes). In
comint mode, previous commands are echoed via C-up and C-down.
But if you really prefer to have these with up/down arrows, you should set
comint-previous-command and comint-next-command to up/down.
Something (untested) like:
(define-key comint-mode-map [up] 'comint-previous-command)
(define-key comint-mode-map [down] 'comint-next-command)

should do the trick.
-- 
Jerome

Re: key binding question

[Kevin Reeder]

On Mon, 07 Apr 2003 03:10:36 -0700, Jerome Besnard wrote:

>> When using the python interpreter within emacs, I'd like to have the
>> up/down arrows echo previous commands. Can anyone give me the code for
>> this?
> 
> The pyhton shell uses comint-mode (for input-output in shell-like
> modes). In comint mode, previous commands are echoed via C-up and
> C-down. But if you really prefer to have these with up/down arrows, you
> should set comint-previous-command and comint-next-command to up/down.
> Something (untested) like:
> (define-key comint-mode-map [up] 'comint-previous-command) (define-key
> comint-mode-map [down] 'comint-next-command)
> 
> should do the trick.

I'll try C-up/down and add make the change to my init file later if
necessary. It's second nature to hit up or down when I'm using the
shell, but adding the C- shouldn't take much getting used to.
Thanks.

Kevin

key binding question

[Hadron]

Is it to add a new key binding to be local to a specific mode by adding
a hook e.g


(add-hook 'html-mode-hook
	  (lambda ()
	    (local-set-key [f10] 'myfunc)))


or to use define-key on the specific mode-map?e.g

(define-key html-mode-map [f11] 'myfunc)

(assume the html-mode-map variable is instantiated/inscope.

Or to ask another way, why would you choose one over the other and what
might the pitfalls be?

Re: key binding question

[Kevin Rodgers]

Hadron wrote:
> Is it to add a new key binding to be local to a specific mode by adding
> a hook e.g
> 
> 
> (add-hook 'html-mode-hook
> 	  (lambda ()
> 	    (local-set-key [f10] 'myfunc)))
> 
> 
> or to use define-key on the specific mode-map?e.g
> 
> (define-key html-mode-map [f11] 'myfunc)
> 
> (assume the html-mode-map variable is instantiated/inscope.
> 
> Or to ask another way, why would you choose one over the other and what
> might the pitfalls be?

I use the mode hook, because I have an aversion to keymap variable names
:-) and because it doesn't require the package to be loaded.

-- 
Kevin Rodgers
Denver, Colorado, USA

Re: key binding question

[Hadron]

Kevin Rodgers <kevin.d.rodgers@gmail.com> writes:

> Hadron wrote:
>> Is it to add a new key binding to be local to a specific mode by adding
>> a hook e.g
>>
>>
>> (add-hook 'html-mode-hook
>> 	  (lambda ()
>> 	    (local-set-key [f10] 'myfunc)))
>>
>>
>> or to use define-key on the specific mode-map?e.g
>>
>> (define-key html-mode-map [f11] 'myfunc)
>>
>> (assume the html-mode-map variable is instantiated/inscope.
>>
>> Or to ask another way, why would you choose one over the other and what
>> might the pitfalls be?
>
> I use the mode hook, because I have an aversion to keymap variable names
> :-) and because it doesn't require the package to be loaded.

Makes sense, and doesn't add it multiple times I assume :-;

Re: key binding question

[Kevin Rodgers]

Hadron wrote:
> Kevin Rodgers <kevin.d.rodgers@gmail.com> writes:
> 
>> Hadron wrote:
>>> Is it to add a new key binding to be local to a specific mode by adding
>>> a hook e.g
>>>
>>>
>>> (add-hook 'html-mode-hook
>>> 	  (lambda ()
>>> 	    (local-set-key [f10] 'myfunc)))
>>>
>>>
>>> or to use define-key on the specific mode-map?e.g
>>>
>>> (define-key html-mode-map [f11] 'myfunc)
>>>
>>> (assume the html-mode-map variable is instantiated/inscope.
>>>
>>> Or to ask another way, why would you choose one over the other and what
>>> might the pitfalls be?
>> I use the mode hook, because I have an aversion to keymap variable names
>> :-) and because it doesn't require the package to be loaded.
> 
> Makes sense, and doesn't add it multiple times I assume :-;

No need to assume: C-h f add-hook

-- 
Kevin Rodgers
Denver, Colorado, USA

key binding question

[Drew Adams]

I have a user variable `foo' whose value has the same form as a key-sequence
argument to `define-key'. That's all I know.

So, for example, `foo' might have value [S-iso-lefftab] or "\C-e" or [?\C-x
?] or "^E" (i.e. Control-E) or whatever might be acceptable to `define-key'.

How can I, in Lisp, bind command `bar' to `foo's key, but with the Control
and Meta modifiers added. So, for example, if `foo' = [S-iso-lefftab], then
the code would bind `bar' to [C-M-S-iso-lefttab].

If this is too difficult, suppose that `foo's value were guaranteed to
always be a vector - same question.

Can anyone help with this?

Re: key binding question

[Lennart Borgman (gmail)]

Drew Adams wrote:
> I have a user variable `foo' whose value has the same form as a key-sequence
> argument to `define-key'. That's all I know.
> 
> So, for example, `foo' might have value [S-iso-lefftab] or "\C-e" or [?\C-x
> ?] or "^E" (i.e. Control-E) or whatever might be acceptable to `define-key'.
> 
> How can I, in Lisp, bind command `bar' to `foo's key, but with the Control
> and Meta modifiers added. So, for example, if `foo' = [S-iso-lefftab], then
> the code would bind `bar' to [C-M-S-iso-lefttab].
> 
> If this is too difficult, suppose that `foo's value were guaranteed to
> always be a vector - same question.
> 
> Can anyone help with this?

I think you can do it with key-description and kbd. And some work.

Re: key binding question

[Stefan Monnier]

> How can I, in Lisp, bind command `bar' to `foo's key, but with the Control
> and Meta modifiers added. So, for example, if `foo' = [S-iso-lefftab], then
> the code would bind `bar' to [C-M-S-iso-lefttab].

You first have to define what "add control and meta modifiers" mean when
applied not to a key but to a key-sequence.

Then you might be able to use something like

  (define-key map
              (apply 'vector (mapcar (lambda (k) (list 'meta 'control k)) foo))
              'bar)


-- Stefan

RE: key binding question

[Drew Adams]

> > How can I, in Lisp, bind command `bar' to `foo's key, but with
> > the Control and Meta modifiers added. So, for example, if
> > `foo' = [S-iso-lefftab], then the code would bind `bar' to
> > [C-M-S-iso-lefttab].
>
> You first have to define what "add control and meta modifiers" mean when
> applied not to a key but to a key-sequence.

Apply them only to the first key of the sequence (in my case).

> Then you might be able to use something like
>
>   (define-key map
>       (apply 'vector
>              (mapcar (lambda (k)
>                         (list 'meta 'control k)) foo))
>       'bar)

Thank you. This seems to do it:

(define-key map
    (apply 'vector
           (let ((k (elt foo 0)))
             (cons (if (listp k)
                       `(control meta ,@k)
                     `(control meta ,k))
                   (mapcar #'identity (substring foo 1)))))
    'bar)

(It seems that any extra `control' and `meta' don't matter, so I didn't
bother to remove them.)