🚀 go-pugleaf

Chi-Sharn Wu writes:
> 
>  
> Did anyone know how to define the bindings on sun-4 function keys  
> under epoch ?
> 
> Chi-Sharn Wu
> swu@probe.att.com

After I finally figured out how to deal with key bindings under epoch, I
wrote and posted to our local emacs newsgroup this short monograph.  I'll
post it again here, FYI.  Remember, though, this is only one of many ways
to deal with the problem.

Hope this helps.

				* * *		

When I first started using Xemacs here I learned how to bind the
function keys on my Sun-4 keyboard to bits of elisp code.  But I also
wanted to get modifier information on the keys so that Shift-F1 would
invoke a different lisp function than (unmodified) F1;  ditto for
Meta-F1 and Control-F1.  (Emacs stands for Esc Meta Alt Control Shift,
you know.)  To do this in Xemacs, I had to modify the X event
processing in the C source code.

In Epoch, fortunately, setting up for modified function keys is much
easier because Epoch gives you access to X primitives.  You can do it
all in elisp, no C-source hacking necessary.  Here, then, are some
bits of elisp code that will allow Epoch to discriminate between
modified and unmodified function keys.

				* * *

Back when I first hacked up the C code for Xemacs I settled on a
scheme for the values (character strings) that would be returned by
modified function keys, and I have continued to use that scheme for
the Epoch-elisp version.  That scheme was based on the processing
already in place in Xemacs for function keys, and that processing was
in turn based on the character sequences emitted by the Sun console
for function keys.

The standard Sun sequences for function keys is as follows:

	ESC  [  0  0  0  z

where the digits 000 vary from key to key.  For example, F1 transmits 

	ESC  [  2  2  4  z.

There are some variations from this.  The num-lock key doesn't
transmit anything, nor does the Stop key, and the arrow keys transmit
sequences such as 

	ESC [ A

for up, with A being replaced by B, C, and D for down, right and left,
respectively.

In my scheme for numbering, however, I wanted to have access to every
key, and I wanted the values as consistent as possible.  So I overrode
the Sun-terminal standard and gave ESC-[-digit-digit-digit-z codes to
the arrow keys and the other "missing' keys.  Fortunately, the
numbering convention chosen by Sun was consistent, and deducing the
values to use for the missing keys was easy.

To encode modifier information, I chose to vary the terminating
letter, working my way backward through the alphabet.  Thus, Shift-
modified keys would transmit 'y' instead of 'z' as their terminal
letter, Control-modified keys, 'x', and Meta-modified keys, 'w'.  (I
did not make provisions for multiply-modified keys, but the same
scheme could be extended, with 'v' representing Shift-Control, etc.)

So the scheme, then is: ESC [ identies a function or special key,
three ASCII digits identify which key, and a terminal letter
identifies the modifier.

				* * *

Two sections of elisp code are needed to use the function keys.  The
first assigns character sequences to the keys, and the second assigns
character sequences to lisp functions.

In this first section, the elisp function rebind-key is a lisp
encapsulation of the X function XRebindKeysym.  After a keysym is
rebound, the string, such as "\033[224z" for F1, is stored in the X
server, not in Epoch.  This bit of code can be used, unmodified, by
all who wish to use this scheme.

; Function keys
(rebind-key "F1"	nil		"\033[224z")
(rebind-key "F1"	'shift		"\033[224y")
(rebind-key "F1"	'control	"\033[224x")
(rebind-key "F1"	'meta		"\033[224w")

(rebind-key "F2"	nil		"\033[225z")
(rebind-key "F2"	'shift		"\033[225y")
(rebind-key "F2"	'control	"\033[225x")
(rebind-key "F2"	'meta		"\033[225w")

(rebind-key "F3"	nil		"\033[226z")
(rebind-key "F3"	'shift		"\033[226y")
(rebind-key "F3"	'control	"\033[226x")
(rebind-key "F3"	'meta		"\033[226w")

(rebind-key "F4"	nil		"\033[227z")
(rebind-key "F4"	'shift		"\033[227y")
(rebind-key "F4"	'control	"\033[227x")
(rebind-key "F4"	'meta		"\033[227w")

(rebind-key "F5"	nil		"\033[228z")
(rebind-key "F5"	'shift		"\033[228y")
(rebind-key "F5"	'control	"\033[228x")
(rebind-key "F5"	'meta		"\033[228w")

(rebind-key "F6"	nil		"\033[229z")
(rebind-key "F6"	'shift		"\033[229y")
(rebind-key "F6"	'control	"\033[229x")
(rebind-key "F6"	'meta		"\033[229w")

(rebind-key "F7"	nil		"\033[230z")
(rebind-key "F7"	'shift		"\033[230y")
(rebind-key "F7"	'control	"\033[230x")
(rebind-key "F7"	'meta		"\033[230w")

(rebind-key "F8"	nil		"\033[231z")
(rebind-key "F8"	'shift		"\033[231y")
(rebind-key "F8"	'control	"\033[231x")
(rebind-key "F8"	'meta		"\033[231w")

(rebind-key "F9"	nil		"\033[233z")
(rebind-key "F9"	'shift		"\033[233y")
(rebind-key "F9"	'control	"\033[233x")
(rebind-key "F9"	'meta		"\033[233w")

(rebind-key "F10"	nil		"\033[233z")
(rebind-key "F10"	'shift		"\033[233y")
(rebind-key "F10"	'control	"\033[233x")
(rebind-key "F10"	'meta		"\033[233w")

(rebind-key "F11"	nil		"\033[192z")
(rebind-key "F11"	'shift		"\033[192y")
(rebind-key "F11"	'control	"\033[192x")
(rebind-key "F11"	'meta		"\033[192w")

;Left-side function keys
(rebind-key "F12"	nil		"\033[193z")
(rebind-key "F12"	'shift		"\033[193y")
(rebind-key "F12"	'control	"\033[193x")
(rebind-key "F12"	'meta		"\033[193w")

(rebind-key "F13"	nil		"\033[194z")
(rebind-key "F13"	'shift		"\033[194y")
(rebind-key "F13"	'control	"\033[194x")
(rebind-key "F13"	'meta		"\033[194w")

(rebind-key "F14"	nil		"\033[195z")
(rebind-key "F14"	'shift		"\033[195y")
(rebind-key "F14"	'control	"\033[195x")
(rebind-key "F14"	'meta		"\033[195w")

(rebind-key "F15"	nil		"\033[196z")
(rebind-key "F15"	'shift		"\033[196y")
(rebind-key "F15"	'control	"\033[196x")
(rebind-key "F15"	'meta		"\033[196w")

(rebind-key "F16"	nil		"\033[197z")
(rebind-key "F16"	'shift		"\033[197y")
(rebind-key "F16"	'control	"\033[197x")
(rebind-key "F16"	'meta		"\033[197w")

(rebind-key "F17"	nil		"\033[198z")
(rebind-key "F17"	'shift		"\033[198y")
(rebind-key "F17"	'control	"\033[198x")
(rebind-key "F17"	'meta		"\033[198w")

(rebind-key "F18"	nil		"\033[199z")
(rebind-key "F18"	'shift		"\033[199y")
(rebind-key "F18"	'control	"\033[199x")
(rebind-key "F18"	'meta		"\033[199w")

(rebind-key "F19"	nil		"\033[200z")
(rebind-key "F19"	'shift		"\033[200y")
(rebind-key "F19"	'control	"\033[200x")
(rebind-key "F19"	'meta		"\033[200w")

(rebind-key "F20"	nil		"\033[201z")
(rebind-key "F20"	'shift		"\033[201y")
(rebind-key "F20"	'control	"\033[201x")
(rebind-key "F20"	'meta		"\033[201w")

(rebind-key "Help"	nil		"\033[207z")
(rebind-key "Help"	'shift		"\033[207y")
(rebind-key "Help"	'control	"\033[207x")
(rebind-key "Help"	'meta		"\033[207w")

;Right-side keys (keypad)
(rebind-key "F21"	nil		"\033[208z")
(rebind-key "Pause"	'shift		"\033[208y")
(rebind-key "F21"	'control	"\033[208x")
(rebind-key "F21"	'meta		"\033[208w")

(rebind-key "F22"	nil		"\033[209z")
(rebind-key "F22"	'shift		"\033[209y")
(rebind-key "F22"	'control	"\033[209x")
(rebind-key "F22"	'meta		"\033[209w")

(rebind-key "F23"	nil		"\033[210z")
(rebind-key "F23"	'shift		"\033[210y")
(rebind-key "F23"	'control	"\033[210x")
(rebind-key "F23"	'meta		"\033[210w")

(rebind-key "F24"	nil		"\033[211z")
(rebind-key "KP_Equal"	'shift		"\033[211y")
(rebind-key "F24"	'control	"\033[211x")
(rebind-key "F24"	'meta		"\033[211w")

(rebind-key "F25"	nil		"\033[212z")
(rebind-key "KP_Divide"	'shift		"\033[212y")
(rebind-key "F25"	'control	"\033[212x")
(rebind-key "F25"	'meta		"\033[212w")

(rebind-key "F26"	nil		"\033[213z")
(rebind-key "KP_Multiply" 'shift	"\033[213y")
(rebind-key "F26"	'control	"\033[213x")
(rebind-key "F26"	'meta		"\033[213w")

(rebind-key "F27"	nil		"\033[214z")
(rebind-key "KP_7"	'shift		"\033[214y")
(rebind-key "F27"	'control	"\033[214x")
(rebind-key "F27"	'meta		"\033[214w")

(rebind-key "Up"	nil		"\033[215z")
(rebind-key "KP_8"	'shift		"\033[215y")
(rebind-key "Up"	'control	"\033[215x")
(rebind-key "Up"	'meta		"\033[215w")

(rebind-key "F29"	nil		"\033[216z")
(rebind-key "KP_9"	'shift		"\033[216y")
(rebind-key "F29"	'control	"\033[216x")
(rebind-key "F29"	'meta		"\033[216w")

(rebind-key "Left"	nil		"\033[217z")
(rebind-key "KP_4"	'shift		"\033[217y")
(rebind-key "Left"	'control	"\033[217x")
(rebind-key "Left"	'meta		"\033[217w")

(rebind-key "F31"	nil		"\033[218z")
(rebind-key "KP_5"	'shift		"\033[218y")
(rebind-key "F31"	'control	"\033[218x")
(rebind-key "F31"	'meta		"\033[218w")

(rebind-key "Right"	nil		"\033[219z")
(rebind-key "KP_6"	'shift		"\033[219y")
(rebind-key "Right"	'control	"\033[219x")
(rebind-key "Right"	'meta		"\033[219w")

(rebind-key "F33"	nil		"\033[220z")
(rebind-key "KP_1"	'shift		"\033[220y")
(rebind-key "F33"	'control	"\033[220x")
(rebind-key "F33"	'meta		"\033[220w")

(rebind-key "Down"	nil		"\033[221z")
(rebind-key "KP_2"	'shift		"\033[221y")
(rebind-key "Down"	'control	"\033[221x")
(rebind-key "Down"	'meta		"\033[221w")

(rebind-key "F35"	nil		"\033[222z")
(rebind-key "KP_3"	'shift		"\033[222y")
(rebind-key "F35"	'control	"\033[222x")
(rebind-key "F35"	'meta		"\033[222w")

(rebind-key "Insert"	nil		"\033[247z")
(rebind-key "KP_0"	'shift		"\033[247y")
(rebind-key "Insert"	'control	"\033[247x")
(rebind-key "Insert"	'meta		"\033[247w")

;(rebind-key "Delete"	nil		"\033[249z")
(rebind-key "KP_Decimal" 'shift		"\033[249y")
;(rebind-key "Delete"	'control	"\033[249x")
;(rebind-key "Delete"	'meta		"\033[249w")

(rebind-key "KP_Enter"	nil		"\033[250z")
(rebind-key "KP_Enter"	'shift		"\033[250y")
(rebind-key "KP_Enter"	'control	"\033[250x")
(rebind-key "KP_Enter"	'meta		"\033[250w")

(rebind-key "KP_Add"	nil		"\033[252z")
(rebind-key "KP_Add"	'shift		"\033[252y")
(rebind-key "KP_Add"	'control	"\033[252x")
(rebind-key "KP_Add"	'meta		"\033[252w")

(rebind-key "KP_Subtract" nil		"\033[254z")
(rebind-key "KP_Subtract" 'shift	"\033[254y")
(rebind-key "KP_Subtract" 'control	"\033[254x")
(rebind-key "KP_Subtract" 'meta		"\033[254w")

(rebind-key "Num_Lock"	nil		"\033[255z")
(rebind-key "Num_Lock"	'shift		"\033[255y")
(rebind-key "Num_Lock"	'control	"\033[255x")
(rebind-key "Num_Lock"	'meta		"\033[255w")

				* * *

The second section of will vary greatly from person to person as
preferences for key functions vary.  The following code fragment comes
from my .emacs; I have deleted most of the actual define-key
statements for the sake of brevity.

;; This code shamelessly stolen from Jeff Peck's sun.el:
;;  Jeff Peck, Sun Microsystems Inc  <peck@sun.com>
;;

;; This function can be bound to unused keys
(defun unbound-key () (interactive))

;; Define a new keymap for the Sun function keys
(defvar sun-raw-map (make-sparse-keymap) "*Keymap for ESC-[ encoded keyboard")

;; Place bindings to useful functions into the new map
; Left group of function keys
(define-key sun-raw-map "233z" 'start-kbd-macro)	; F10
(define-key sun-raw-map "192z" 'end-kbd-macro)		; F11 & L1
(define-key sun-raw-map "193z" 'call-last-kbd-macro)	; L2
(define-key sun-raw-map "193y" 'repeat-complex-command) ; S-L2

; ... many other assignments deleted

;; Tell Emacs that "ESC-[" sequences should divert to the new map for
;; further interpretation
(define-key esc-map "[" sun-raw-map)

;; Keep the default bindings for the arrow keys, so this code can be
;; used with Epoch or with plain Emacs running in a Sun terminal
(define-key esc-map "[A" 'previous-line )		; R8
(define-key esc-map "[B" 'next-line)		; R14
(define-key esc-map "[C" 'forward-char)		; R12
(define-key esc-map "[D" 'backward-char)		; R10
(define-key esc-map "[[" 'backward-paragraph)	; the original esc-[

				* * *

My suggestions for using all this are as follows.  First, put the
entire first section into a file called "epokeys.el" and place this
file somewhere in your load-path.  Byte-compile epokeys.el; it won't
make a great deal of difference in the speed of loading, but it will
make you feel better.  In your .emacs, load epokeys if you're running
Epoch: 

(defvar running-epoch (boundp 'epoch::version))

(if running-epoch
    (progn
      (setq load-path (cons (expand-file-name "~/Epoch") load-path))
      (load "epokeys")

      ;; other epoch-specific processing

     ))

How to load the second bit of code depends upon personal preference;
I have the entire section in my .emacs, since I'm always running
either in Epoch or from a sun terminal.

Which reminds me, there's a set of translations that you can place in
your .Xdefaults to make your xterm function keys look like sunterm
function keys; by using it you still have access to modified function
keys even in xterm.  (Except for Meta-modified keys; for some reason,
I didn't include that set of definitions.  It shouldn't be hard to add,
though.)

				* * *

Place the following resource definition in your .Xdefaults:

xterm*vt100*Translations: #override \n\
		Shift	<Key>L1:	string("0x1b") string("[192y") \n\
		Shift	<Key>L2:	string("0x1b") string("[193y") \n\
		Shift	<Key>L3:	string("0x1b") string("[194y") \n\
		Shift	<Key>L4:	string("0x1b") string("[195y") \n\
		Shift	<Key>L5:	string("0x1b") string("[196y") \n\
		Shift	<Key>L6:	string("0x1b") string("[197y") \n\
		Shift	<Key>L7:	string("0x1b") string("[198y") \n\
		Shift	<Key>L8:	string("0x1b") string("[199y") \n\
		Shift	<Key>L9:	string("0x1b") string("[200y") \n\
		Shift	<Key>L10:	string("0x1b") string("[201y") \n\
		Shift	<Key>Help:	string("0x1b") string("[207y") \n\
		Shift	<Key>R1:	string("0x1b") string("[208y") \n\
		Shift	<Key>R2:	string("0x1b") string("[209y") \n\
		Shift	<Key>R3:	string("0x1b") string("[210y") \n\
		Shift	<Key>R4:	string("0x1b") string("[211y") \n\
		Shift	<Key>R5:	string("0x1b") string("[212y") \n\
		Shift	<Key>R6:	string("0x1b") string("[213y") \n\
		Shift	<Key>R7:	string("0x1b") string("[214y") \n\
		Shift	<Key>Up:	string("0x1b") string("[215y") \n\
		Shift	<Key>R9:	string("0x1b") string("[216y") \n\
		Shift	<Key>Left:	string("0x1b") string("[217y") \n\
		Shift	<Key>R11:	string("0x1b") string("[218y") \n\
		Shift	<Key>Right:	string("0x1b") string("[219y") \n\
		Shift	<Key>R13:	string("0x1b") string("[220y") \n\
		Shift	<Key>Down:	string("0x1b") string("[221y") \n\
		Shift	<Key>R15:	string("0x1b") string("[222y") \n\
		Shift	<Key>F1:	string("0x1b") string("[224y") \n\
		Shift	<Key>F2:	string("0x1b") string("[225y") \n\
		Shift	<Key>F3:	string("0x1b") string("[226y") \n\
		Shift	<Key>F4:	string("0x1b") string("[227y") \n\
		Shift	<Key>F5:	string("0x1b") string("[228y") \n\
		Shift	<Key>F6:	string("0x1b") string("[229y") \n\
		Shift	<Key>F7:	string("0x1b") string("[230y") \n\
		Shift	<Key>F8:	string("0x1b") string("[231y") \n\
		Shift	<Key>F9:	string("0x1b") string("[232y") \n\
		Shift	<Key>F10:	string("0x1b") string("[233y") \n\
		Shift	<Key>Insert:	  string("0x1b") string("[247y") \n\
		Shift	<Key>KP_Decimal:  string("0x1b") string("[249y") \n\
		Shift	<Key>KP_Enter:	  string("0x1b") string("[250y") \n\
		Shift	<Key>KP_Add:	  string("0x1b") string("[253y") \n\
		Shift	<Key>KP_Subtract: string("0x1b") string("[254y") \n\
		Shift	<Key>Num_Lock:	  string("0x1b") string("[255y") \n\
		Ctrl	<Key>L1:	string("0x1b") string("[192x") \n\
		Ctrl	<Key>L2:	string("0x1b") string("[193x") \n\
		Ctrl	<Key>L3:	string("0x1b") string("[194x") \n\
		Ctrl	<Key>L4:	string("0x1b") string("[195x") \n\
		Ctrl	<Key>L5:	string("0x1b") string("[196x") \n\
		Ctrl	<Key>L6:	string("0x1b") string("[197x") \n\
		Ctrl	<Key>L7:	string("0x1b") string("[198x") \n\
		Ctrl	<Key>L8:	string("0x1b") string("[199x") \n\
		Ctrl	<Key>L9:	string("0x1b") string("[200x") \n\
		Ctrl	<Key>L10:	string("0x1b") string("[201x") \n\
		Ctrl	<Key>Help:	string("0x1b") string("[207x") \n\
		Ctrl	<Key>R1:	string("0x1b") string("[208x") \n\
		Ctrl	<Key>R2:	string("0x1b") string("[209x") \n\
		Ctrl	<Key>R3:	string("0x1b") string("[210x") \n\
		Ctrl	<Key>R4:	string("0x1b") string("[211x") \n\
		Ctrl	<Key>R5:	string("0x1b") string("[212x") \n\
		Ctrl	<Key>R6:	string("0x1b") string("[213x") \n\
		Ctrl	<Key>R7:	string("0x1b") string("[214x") \n\
		Ctrl	<Key>Up:	string("0x1b") string("[215x") \n\
		Ctrl	<Key>R9:	string("0x1b") string("[216x") \n\
		Ctrl	<Key>Left:	string("0x1b") string("[217x") \n\
		Ctrl	<Key>R11:	string("0x1b") string("[218x") \n\
		Ctrl	<Key>Right:	string("0x1b") string("[219x") \n\
		Ctrl	<Key>R13:	string("0x1b") string("[220x") \n\
		Ctrl	<Key>Down:	string("0x1b") string("[221x") \n\
		Ctrl	<Key>R15:	string("0x1b") string("[222x") \n\
		Ctrl	<Key>F1:	string("0x1b") string("[224x") \n\
		Ctrl	<Key>F2:	string("0x1b") string("[225x") \n\
		Ctrl	<Key>F3:	string("0x1b") string("[226x") \n\
		Ctrl	<Key>F4:	string("0x1b") string("[227x") \n\
		Ctrl	<Key>F5:	string("0x1b") string("[228x") \n\
		Ctrl	<Key>F6:	string("0x1b") string("[229x") \n\
		Ctrl	<Key>F7:	string("0x1b") string("[230x") \n\
		Ctrl	<Key>F8:	string("0x1b") string("[231x") \n\
		Ctrl	<Key>F9:	string("0x1b") string("[232x") \n\
		Ctrl	<Key>F10:	string("0x1b") string("[233x") \n\
		Ctrl	<Key>Insert:	  string("0x1b") string("[247x") \n\
		Ctrl	<Key>KP_Decimal:  string("0x1b") string("[249x") \n\
		Ctrl	<Key>KP_Enter:	  string("0x1b") string("[250x") \n\
		Ctrl	<Key>KP_Add:	  string("0x1b") string("[253x") \n\
		Ctrl	<Key>KP_Subtract: string("0x1b") string("[254x") \n\
		Ctrl	<Key>Num_Lock:	  string("0x1b") string("[255x") \n\
			<Key>L1:	string("0x1b") string("[192z") \n\
			<Key>L2:	string("0x1b") string("[193z") \n\
			<Key>L3:	string("0x1b") string("[194z") \n\
			<Key>L4:	string("0x1b") string("[195z") \n\
			<Key>L5:	string("0x1b") string("[196z") \n\
			<Key>L6:	string("0x1b") string("[197z") \n\
			<Key>L7:	string("0x1b") string("[198z") \n\
			<Key>L8:	string("0x1b") string("[199z") \n\
			<Key>L9:	string("0x1b") string("[200z") \n\
			<Key>L10:	string("0x1b") string("[201z") \n\
			<Key>Help:	string("0x1b") string("[207z") \n\
			<Key>R1:	string("0x1b") string("[208z") \n\
			<Key>R2:	string("0x1b") string("[209z") \n\
			<Key>R3:	string("0x1b") string("[210z") \n\
			<Key>R4:	string("0x1b") string("[211z") \n\
			<Key>R5:	string("0x1b") string("[212z") \n\
			<Key>R6:	string("0x1b") string("[213z") \n\
			<Key>R7:	string("0x1b") string("[214z") \n\
			<Key>Up:	string("0x1b") string("[215z") \n\
			<Key>R9:	string("0x1b") string("[216z") \n\
			<Key>Left:	string("0x1b") string("[217z") \n\
			<Key>R11:	string("0x1b") string("[218z") \n\
			<Key>Right:	string("0x1b") string("[219z") \n\
			<Key>R13:	string("0x1b") string("[220z") \n\
			<Key>Down:	string("0x1b") string("[221z") \n\
			<Key>R15:	string("0x1b") string("[222z") \n\
			<Key>F1:	string("0x1b") string("[224z") \n\
			<Key>F2:	string("0x1b") string("[225z") \n\
			<Key>F3:	string("0x1b") string("[226z") \n\
			<Key>F4:	string("0x1b") string("[227z") \n\
			<Key>F5:	string("0x1b") string("[228z") \n\
			<Key>F6:	string("0x1b") string("[229z") \n\
			<Key>F7:	string("0x1b") string("[230z") \n\
			<Key>F8:	string("0x1b") string("[231z") \n\
			<Key>F9:	string("0x1b") string("[232z") \n\
			<Key>F10:	string("0x1b") string("[233z") \n\
			<Key>Insert:	  string("0x1b") string("[247z") \n\
			<Key>KP_Decimal:  string("0x1b") string("[249z") \n\
			<Key>KP_Enter:	  string("0x1b") string("[250z") \n\
			<Key>KP_Add:	  string("0x1b") string("[253z") \n\
			<Key>KP_Subtract: string("0x1b") string("[254z") \n\
			<Key>Num_Lock:	  string("0x1b") string("[255z") \n

--
   _     Jim Thompson           |  Western Geophysical
 _| ~-   thompson@wg2.waii.com  |  Exploration Products
 \,  _}  jimt@sugar.neosoft.com |  3600 Briarpark
   \(    (713) 964-6213         |  Houston, TX 77042