This config redefines the numeric keypad and a few other keys for compatability
with Brief, LSE and various other commonly-used editors.  It is not an
emulation of any specific editor, rather, it is an attempt to make the keypad
safe for folks like myself whose fingers have been irreversibly trained, and
who know kp7, kp1, kp9 and kp3 only as Home, End, PageUp and PageDown.

All competing functions in the standard Uedit configs have been preserved, and
moved somewhere, not necessarily anywhere convenient.

Key assignments:

Numeric keypad

    kp0 (Ins)  - normal - toggle overstrike
                 shift  - "
    kp. (Del)  - normal - delete character at cursor
                 shift  - delete word right
                 alt    - delete to end of line (alt-End on PC)
                 ctl    - delete cursor line
    kp1 (End)  - normal - move cursor to end of line
                 shift  - move cursor to bottom of screen
                 alt    - " (not on PC)
                 ctl    - move cursor to end of file
    kp3 (PgDn) - normal - move display down 1 page (one line overlap)
                 shift  - move current line to bottom of screen
                 alt    - " (not on PC)
                 ctl    - move cursor to end of file
    kp4 ([-)   - normal - move left one character
                 shift  - move cursor to start of word
    kp6 (->)   - normal - move right one character
                 shift  - move cursor to end of word
    kp7 (Home) - normal - move cursor to start of line
                 shift  - move cursor to top of screen
                 alt    - " (not on PC)
                 ctl    - move cursor to start of file
                 SA     - delete to start of line (original alt-kp7)
                 SC     - delete to start of page (original ctl-kp7)
                 SAC    - delete char left (original shift-kp7)
                          (on the PC I use Home rather than KP7 for these)
    kp9 (PgUp) - normal - move display up 1 page (one line overlap)
                 shift  - move current line to top of screen
                 alt    - " (not on PC)
                 ctl    - move cursor to start of file
                 SA     - delete to end of line (original alt-kp9)
                 SC     - delete to end of page (original ctl-kp7)
                 SAC    - delete char lat cursor (original shift-kp9)
                          (on the PC I use PgUp rather than KP9 for these)

Other keypad:

(I find these definitions more mnemonic than the Uedit ones, but they are
hardly essential.  They depend on the Amiga 2000 keyboard.  Note that the
normal- keys are line-oriented, that is, they mark the line containing the
cursor, no the character position.)

    kp(   - normal - start hilite region at start of line
            shift  - start hilite region at cursor
            alt    - "
            ctl    - start invert region at cursor
                     (on the PC, I use F11 instead)
    kp)   - normal - end hilite region at end of line
            shift  - end hilite region at cursor
            alt    - "
            ctl    - end invert region at cursor
                     (on the PC, I use F12 instead)
    kp/   - normal - copy to hilite buffer
            shift  - uncolor hilite region
            alt    - uncolor invert region
            ctl    - copy to invert buffer
    kp*   - normal - undo deletes
            shift  - "
            alt    - "
            ctl    - "
    kp-   - normal - copy to hilite buffer, then delete
            shift  - "
            alt    - erase invert region, no copy
            ctl    - copy to invert buffer, then delete
    kp+   - normal - copy hilite buffer before start of line
            shift  - copy hilite buffer at cursor
            alt    - "
            ctl    - copy invert buffer at cursor
    kpEnt - normal - split line at cursor
            shift  - "
            alt    - join next line to cursor line
            ctl    - "

Miscellaneous

    bs   - normal - backspace (in overstrike mode, blank out old character)
           shift  - delete word left
           lAmiga - open space before word (original shift-bs)

Toggle overstrike typing mode
<normal-kp0:       flipFlag(curFile,overstrike) >
                   
Move cursor down 1 page
<normal-kp3:         if (!eqloc(curFile, ePage, eFile)) {
                        runKey(shft-kp7)
                        vScroll(ePage)
                        if (is(curFile,eLine))
                           vScroll(upLine) .. I don't know why ..!
                        vScroll(upLine) 
                        if (!onScreen(sPage)) updateDisplay
                        runKey(shft-kp7) }
                     else runKey(ctl-kp3) >
                     
Move cursor up one page 
<normal-kp9:         runKey(shft-kp1)
                     vScroll(sPage)
                     if(!eqloc(curFile,sPage,sFile)) 
                        vScroll(downLine) 
                     runKey(shft-kp7) >
                     
Move current line to top of screen
<shft-kp9: vScroll(atCursor)
           if (!is(curFile, sLine))
              moveCursor(curFile, sLine)
           while(!is(curFile,sPage)) 
              vscroll(1) >
              
Move cursor to top of screen
<shft-kp7:           moveCursor(curFile,sPage) >

.. No alt-kp on PC

Move cursor to top of screen
<alt-kp7:            moveCursor(curFile,sPage) >

Move current line to top of screen
<alt-kp9:            runKey(shft-kp9) >
             
Move cursor to bottom of screen
<shft-kp1:           moveCursor(curFile,ePage) 
                     moveCursor(curFile,upLine) >
                     
Move current line to bottom of screen
<shft-kp3: runKey(alt-kp9)
           runKey(normal-kp9) 
           updateDisplay
           runKey(shft-kp1) >

.. No alt-kp on PC

Move cursor to bottom of screen
<alt-kp1:            moveCursor(curFile,ePage) 
                     moveCursor(curFile,upLine) >
                     
Move current line to top of screen
<alt-kp3:            runKey(shft-kp1) >
          
Cursor to start of file
<ctl-kp9:            moveCursor(curFile,sFile)>

Cursor to end of file
<ctl-kp3:            moveCursor(curFile,eFile)>

Cursor to start of file
<ctl-kp7:            moveCursor(curFile,sFile)>

Cursor to end of file
<ctl-kp1:            moveCursor(curFile,eFile)>

.. This definition slows down the backspace key considerably.  Do not use
.. unless you use overstrike mode frequently!

Overstrike-mode backspace
<normal-bs:
               moveCursor(curFile,sChar)
               clearchar(curFile)
               if (getFlag(curFile, overstrike)) 
                  runKey(shft-del) >
                  
Delete word left, storing it in Undo buffer
<shft-bs:      
               if (!eqLoc(curFile,locB,atCursor)) freeBuf(buf45)
               equateLoc(curFile,locB,atCursor)
               moveCursor(curFile,sWord)
               equateLoc(curFile,locA,atCursor)
               insertRgn(buf45,sFile,curFile,loc)
               equateLoc(buf45,sPage,sFile)
               clearRgn(curFile,loc) >

Open a space for typing in front of current word
<lAmiga-bs:  
		   if (!is(curFile,sWord)) moveCursor(curFile,sWord)
           runKey(shft-del)>

Delete word right, storing it in Undo buffer
<shft-kpDot:   
               if (!eqLoc(curFile,locB,atCursor)) freeBuf(buf45)
               equateLoc(curFile,locA,atCursor)
               moveCursor(curFile,eWord)
               equateLoc(curFile,locB,atCursor)
               insertRgn(buf45,eFile,curFile,loc)
               equateLoc(buf45,sPage,sFile)
               clearRgn(curFile,loc) >
               
Move cursor to start of word
<shft-kp4:   moveCursor(curFile,sWord) >

Move cursor to end of word
<shft-kp6:   moveCursor(curFile,eWord) >

.. kpLParen -> f11 on PC

Set start of hilite region at start of line
<normal-kpLParen:   if (!is(curFile,sLine)) runKey(normal-kp7)
                    runKey(alt-kpLParen) >

.. kpRParen -> f12 on PC

Set end of hilite region at end of line
<normal-kpRParen:   if (!is(curFile,eLine)) runKey(normal-kp1)
                    moveCursor(curFile, eChar)
                    runKey(alt-kpRparen) >

UNDO scratch deletes, inserting scratch delete buffer at cursor
<normal-kpStar:   insertRgn(curFile,atCursor,buf45,all) >

Copy hilite region into buffer
<normal-kpSlash: if (getFlag(curFile,columnar)) { runKey(shftCtl-3) return }
               if (gtLoc(curFile,eHilite,sHilite))
                   { freeBuf(buf47) insertRgn(buf47,sFile,curFile,hilite)
                     equateLoc(buf47,sPage,sFile) }
               else returnFalse >

Copy hilite region into buffer, then delete hilite region
<normal-kpMinus:    if (getFlag(curFile,columnar)) { runKey(shftCtl-1) return }
                    if (runKey(normal-kpSlash)) clearRgn(curFile,hilite) >

.. kpEnter -> kpReturn on PC

Split line at cursor
<normal-kpEnter:    insertChar(curFile,10) 
                    runKey(alt-4) >
                    
Insert copied hilite at start of line
<normal-kpPlus: runKey(normal-kp7)
                runKey(shft-kpPlus) >

Delete char to left of cursor, storing it in Undo buffer
<shftAltCtl-kp7:     .. shftAltCtl-home on PC
               if (!eqLoc(curFile,locB,atCursor)) freeBuf(buf45)
               equateLoc(curFile,locB,atCursor)
               moveCursor(curFile,sChar)
               equateLoc(curFile,locA,atCursor)
               insertRgn(buf45,sFile,curFile,loc)
               equateLoc(buf45,sPage,sFile)
               clearRgn(curFile,loc) >

Delete char under cursor, storing it in Undo buffer
<shftAltCtl-kp9:     .. shftAltCtl-pgup on PC
               if (!eqLoc(curFile,locB,atCursor)) freeBuf(buf45)
               equateLoc(curFile,locA,atCursor)
               moveCursor(curFile,eChar)
               equateLoc(curFile,locB,atCursor)
               insertRgn(buf45,eFile,curFile,loc)
               equateLoc(buf45,sPage,sFile)
               clearRgn(curFile,loc) >

Delete char under cursor, storing it in Undo buffer
<normal-kpDot: runKey(shftAltCtl-kp9) >

Move cursor left 1 char
<normal-kp4:     moveCursor(curFile,sChar) >

Move cursor right 1 char
<normal-kp6:     moveCursor(curFile,eChar) >

Set start of hilite region at cursor
<shft-kpLParen:     runKey(alt-kpLParen) >

Set end of hilite region at cursor
<shft-kpRParen:     runKey(alt-kpRParen) >

UNDO scratch deletes, inserting scratch delete buffer at cursor
<shft-kpStar:     runKey(normal-kpStar) >

Uncolor the hilite region
<shft-kpSlash:    equateLoc(curFile,sHilite,eHilite) refreshDisplay >

Split line at cursor
<shft-kpEnter: runKey(normal-kpEnter) >

Insert copied hilite at cursor
<shft-kpPlus:   if (getFlag(curFile,columnar)) { runKey(shftCtl-4) return }
                   if (is(curFile,sFile)) {
                        equateLoc(curFile,sHilite,atCursor)
                        equateLoc(curFile,eHilite,sHilite)
                   } else {
                        equateLoc(curFile,sHilite,atCursor)
                        decLoc(curFile,sHilite)
                        equateLoc(curFile,eHilite,atCursor)
                   }
                   insertRgn(curFile,atCursor,buf47,all)
                   if (eqLoc(curFile,atCursor,sHilite)) equateLoc(curFile,sHilite,sFile)
                   else incLoc(curFile,sHilite)
                   if (!onScreen(atCursor)) vScroll(atCursor) >
                   
Delete to start of line, storing it in Undo buffer
<shftAlt-kp7:      .. shftAlt-home on PC
               if (!eqLoc(curFile,locB,atCursor)) freeBuf(buf45)
               if (is(curFile,sLine)) runKey(shftAltCtl-kp7)
               else {
                   equateLoc(curFile,locB,atCursor)
                   moveCursor(curFile,sLine)
                   equateLoc(curFile,locA,atCursor)
                   insertRgn(buf45,sFile,curFile,loc)
                   equateLoc(buf45,sPage,sFile)
                   clearRgn(curFile,loc)
               } >
               
Delete to end of line, storing it in Undo buffer
<shftAlt-kp9:       .. shftAlt-pgup on PC
            if (!eqLoc(curFile,locB,atCursor)) freeBuf(buf45)
            if (is(curFile,eLine)) runKey(shftAltCtl-kp9)
            else {
               equateLoc(curFile,locA,atCursor)
               moveCursor(curFile,eLine)
               equateLoc(curFile,locB,atCursor)
               insertRgn(buf45,eFile,curFile,loc)
               equateLoc(buf45,sPage,sFile)
               clearRgn(curFile,loc)
            } >
            
Move cursor to start of line
<normal-kp7:if (!is(curFile,sLine))   
            moveCursor(curFile,sLine) >
            
Move cursor to end of line
<normal-kp1:if (!is(curFile,eLine))   
            moveCursor(curFile,eLine) >
            
Set start of hilite region at cursor
<alt-kpLParen:   equateLoc(curFile,sHilite,atCursor) refreshDisplay >

Set end of hilite region at cursor
<alt-kpRParen:   equateLoc(curFile,eHilite,atCursor) refreshDisplay >

Toggle insert/overstrike mode
<shft-kp0:      runKey(normal-kp0) >

Uncolor the invert region
<alt-kpSlash:    equateLoc(curFile,sInvert,eInvert) refreshDisplay >

Join next line to cursor line
<alt-kpEnter:    runKey(ctl-j) >

UNDO scratch deletes, inserting scratch delete buffer at cursor
<alt-kpStar:     runKey(normal-kpStar) >

Erase the invert region.  No Copy is made!
<alt-kpMinus:    clearRgn(curFile,invert) >

Insert copied hilite at cursor
<alt-kpPlus: runKey(shft-kpPlus) >

Delete from cursor to start of page, storing it in Undo buffer
<shftCtl-kp7:      .. shftCtl-home on PC
               if (!eqLoc(curFile,locB,atCursor)) freeBuf(buf45)
               equateLoc(curFile,locB,atCursor)
               moveCursor(curFile,sPage)
               equateLoc(curFile,locA,atCursor)
               insertRgn(buf45,sFile,curFile,loc)
               equateLoc(buf45,sPage,sFile)
               clearRgn(curFile,loc)
               vScroll(atCursor)
               updateDisplay >
               
Delete from cursor to end of page, storing it in Undo buffer
<shftCtl-kp9:      .. shftCtl-pgup on PC
               if (!eqLoc(curFile,locB,atCursor)) freeBuf(buf45)
               equateLoc(curFile,locA,atCursor)
               moveCursor(curFile,ePage)
               equateLoc(curFile,locB,atCursor)
               insertRgn(buf45,eFile,curFile,loc)
               equateLoc(buf45,sPage,sFile)
               clearRgn(curFile,loc)
               updateDisplay >
               
Set start of invert region at cursor
<ctl-kpLParen:      equateLoc(curFile,sInvert,atCursor) refreshDisplay >

Set end of invert region at cursor
<ctl-kpRParen:      equateLoc(curFile,eInvert,atCursor) refreshDisplay >

UNDO scratch deletes, inserting scratch delete buffer at cursor
<ctl-kpStar:      runKey(normal-kpStar) >
        
Copy invert region into buffer
<ctl-kpSlash:    
               runKey(virtual-kpDot)
               if (gtLoc(curFile,eInvert,sInvert)) {
                   freeBuf(buf46) 
                   insertRgn(buf46,sFile,curFile,invert)
                   equateLoc(buf46,sPage,sFile) 
               } else returnFalse >

Copy invert region into buffer, then delete invert region
<ctl-kpMinus:  
               runKey(virtual-kpDot)
               runKey(ctl-kpSlash) 
               clearRgn(curFile,invert) >

Insert copied invert region at cursor
<ctl-kpPlus:      runKey(virtual-kpDot)
                   if (is(curFile,sFile)) {
                        equateLoc(curFile,sInvert,atCursor)
                        equateLoc(curFile,eInvert,sInvert)
                   } else {
                        equateLoc(curFile,sInvert,atCursor)
                        decLoc(curFile,sInvert)
                        equateLoc(curFile,eInvert,atCursor)
                   }
                   insertRgn(curFile,atCursor,buf46,all)
                   if (eqLoc(curFile,atCursor,sInvert)) equateLoc(curFile,sInvert,sFile)
                   else incLoc(curFile,sInvert)
                   if (!onScreen(atCursor)) vScroll(atCursor) >
                   
Join next line to cursor line
<ctl-kpEnter: runKey(ctl-j) >

Delete cursor line, storing it in Undo buffer.  
<ctl-kpDot:   runKey(virtual-x) >

.. alt-end on PC

Delete to end of line, storing it in Undo buffer
<alt-kpDot: runKey(shftAlt-kp9) >

Fix up menu cut & paste references

<startup:

menu("Files",1,normal-f1)
   menu("Next file      f1",1,normal-f1)
   menu("Prev file    S-f1",1,shft-f1)
   menu("Open             ",1,alt-f1)
SUBmenu("Open         A-f1",1,alt-f1)
SUBmenu("File request L-f1",1,lAmiga-f1)
SUBmenu("New file     C-f1",1,ctl-f1)
SUBmenu("Insert file SA-f1",1,shftAlt-f1)
SUBmenu("Restore     SC-f1",1,shftCtl-f1)
SUBmenu("Rename        A-n",1,alt-n)
   menu("Save             ",1,normal-f2)
SUBmenu("Save           f2",1,normal-f2)
SUBmenu("Save changes A-f2",1,alt-f2)
SUBmenu("Save as...   S-f2",1,shft-f2)
SUBmenu("Save hilite SC-f2",1,shftCtl-f2)
SUBmenu("Abort save  SA-f2",1,shftAlt-f2)

   menu("Close            ",1,normal-f3)
SUBmenu("Close          f3",1,normal-f3)
SUBmenu("Auto-close   S-f3",1,shft-f3)
   menu("Quit             ",1,normal-f4)
SUBmenu("Quit           f4",1,normal-f4)
SUBmenu("Auto-quit    S-f4",1,shft-f4)
SUBmenu("ABORT Uedit! A-f4",1,alt-f4)
   menu("AmigaDOS         ",1,ctl-y)
SUBmenu("AmigaDOS      C-y",1,ctl-y)
SUBmenu("DOS + result  C-z",1,ctl-z)
SUBmenu("Directory     A-z",1,alt-z)
SUBmenu("CD (Chg dir) AC-z",1,altCtl-z)
   menu("About...         ",1,shftAltCtl-a)

menu("Search",2,normal-f1)
   menu("Search           ",2,normal-f9)
SUBmenu("Search fwd     f9",2,normal-f9)
SUBmenu("Search bkwd  S-f9",2,shft-f9)
SUBmenu("Set search     f7",2,normal-f7)
   menu("Replace          ",2,normal-f10)
SUBmenu("Replace fwd   f10",2,normal-f10)
SUBmenu("Rpl all fwd A-f10",2,alt-f10)
SUBmenu("Rpl bkwd    S-f10",2,shft-f10)
SUBmenu("Set replace    f8",2,normal-f8)
   menu("Settings         ",2,ctl-8)
checkedSUBmenu("Case sensitiv C-8",2,ctl-8,searchCaps)
SUBmenu("Wildcards    A-f7",2,alt-f7)
SUBmenu("Either-or    C-f7",2,ctl-f7)
   menu("Grep             ",2,lAmiga-f9)
SUBmenu("Grep fwd     L-f9",2,lAmiga-f9)
SUBmenu("Grep bkwd    R-f9",2,rAmiga-f9)
SUBmenu("Set Grep     L-f7",2,lAmiga-f7)
SUBmenu("Grep repl-> L-f10",2,lAmiga-f10)
SUBmenu("Grep repl<- R-f10",2,rAmiga-f10)
   menu("Bookmarks        ",2,shft-gadget1)
SUBmenu("Goto->mark S-gad1",2,shft-gadget1)
SUBmenu("Goto<-mark S-gad2",2,shft-gadget2)
SUBmenu("Set mark   S-gad3",2,shft-gadget3)

menu("Buffers",3,normal-f1)
   menu("Buffers          ",3,alt-w)
   SUBmenu("Swap buf #0   A-w",3,alt-w)
   SUBmenu("Swap buf #41  C-w",3,ctl-w)
   SUBmenu("See buffers SC-f6",3,shftCtl-f6)
   SUBmenu("Edit buffer SA-f6",3,shftAlt-f6)
   SUBmenu("Free buffers A-f3",3,alt-f3)
   SUBmenu("Push buffer   L-w",3,lAmiga-w)
   SUBmenu("Pop buffer    R-w",3,rAmiga-w)
   SUBmenu("Roll stack   SA-w",3,shftAlt-w)
	  menu("Data file        ",3,alt-f6)
   ..SUBmenu("UStar            ",3,virtual-u)
   ..SUBmenu("Directory Utility",3,virtual-d)
   ..SUBmenu("Regular UE data  ",3,virtual-e)
   SUBmenu("Save data    A-f6",3,alt-f6)
   SUBmenu("Load data    C-f6",3,ctl-f6)
	  menu("Compile          ",3,normal-f6)
   SUBmenu("Compile        f6",3,normal-f6)
   SUBmenu("Cfg defalts AC-f6",3,altCtl-f6)
   SUBmenu("Make command S-f6",3,shft-f6)
	  menu("Keys             ",3,normal-f5)
   SUBmenu("Swap keys      f5",3,normal-f5)
   SUBmenu("Swap mouseUp  A-m",3,alt-m)
   SUBmenu("Kill key   SAC-f6",3,shftAltCtl-f6)
   SUBmenu("Find key     L-f6",3,lAmiga-f6)
	  menu("Learn            ",3,ctl-s)
   checkedSUBmenu("Start learn   C-s",3,ctl-s,learnMode)
   SUBmenu("End/Run learn C-r",3,ctl-r)
   SUBmenu("Save learn    C-5",3,ctl-5)
   SUBmenu("Load learn    C-6",3,ctl-6)
   SUBmenu("Load & run    C-7",3,ctl-7)
      menu("Save state   R-f5",3,rAmiga-f5)
      menu("Load state   R-f6",3,rAmiga-f6)
	  menu("Name gadget C-esc",3,ctl-esc)
	  menu("Speak hilite  A-s",3,alt-s)

menu("Edits",4,normal-f1)
checkedmenu("Col display  SC-`",4,shftCtl-`,columnar)
      menu("Cut&Paste Hilite ",4,normal-kpSlash)
   SUBmenu("Copy          kp/",4,normal-kpSlash)
   SUBmenu("Cut           kp-",4,normal-kpMinus)
   SUBmenu("Paste         kp+",4,normal-kpPlus)
   SUBmenu("Clear         C-h",4,ctl-h)
   menu("Cut&Paste Invert ",4,ctl-kpSlash)
   SUBmenu("I-Copy      C-kp/",4,ctl-kpSlash)
   SUBmenu("I-Cut       C-kp-",4,ctl-kpMinus)
   SUBmenu("I-Paste     C-kp+",4,ctl-kpPlus)
   SUBmenu("I-Clear       C-i",4,ctl-i)
   menu("Columnar         ",4,shftCtl-1)
   SUBmenu("Col Cut      SC-1",4,shftCtl-1)
   SUBmenu("Col Erase    SC-2",4,shftCtl-2)
   SUBmenu("Col Copy     SC-3",4,shftCtl-3)
   SUBmenu("Col Insert   SC-4",4,shftCtl-4)
   SUBmenu("Col Overlay  SC-5",4,shftCtl-5)
   SUBmenu("Ins Hil->Csr SC-6",4,shftCtl-6)
   SUBmenu("Ovl Hil->Csr SC-7",4,shftCtl-7)
	  menu("Text reformats   ",4,ctl-3)
   SUBmenu("Paragraph     C-3",4,ctl-3)
   SUBmenu("Del white-spc C-4",4,ctl-4)
   SUBmenu("Tabs->spaces  L-t",4,lAmiga-t)
   SUBmenu("Spaces->tabs  R-t",4,rAmiga-t)
	  menu("Printing         ",4,alt-p)
   SUBmenu("Print select  A-p",4,alt-p)
   SUBmenu("Print hilite  C-p",4,ctl-p)
   SUBmenu("Print file   AC-p",4,altCtl-p)
   SUBmenu("Restart print L-s",4,lAmiga-s)
   SUBmenu("Abort print   L-a",4,lAmiga-a)
   SUBmenu("Stop all prts R-a",4,rAmiga-a)
   SUBmenu("Code help   SAC-p",4,shftAltCtl-p)
   SUBmenu("Bracket hiliteL-p",4,lAmiga-p)
   SUBmenu("Find code     R-g",4,rAmiga-g)
   SUBmenu("Embed code    L-g",4,lAmiga-g)
   SUBmenu("Type formfeed L-f",4,lAmiga-f)
	  menu("Paging           ",4,alt-3)
   SUBmenu("Go to page #  A-3",4,alt-3)
   SUBmenu("Top of page   L-h",4,lAmiga-h)
   SUBmenu("Bottom page   L-b",4,lAmiga-b)
   SUBmenu("Divide page   L-v",4,lAmiga-v)
   SUBmenu("Auto page div L-r",4,lAmiga-r)
   SUBmenu("Del page div  L-d",4,lAmiga-d)
   SUBmenu("Del page #    L-y",4,lAmiga-y)
	  menu("Spelling         ",4,rAmiga-u)
   SUBmenu("Load speller  R-u",4,rAmiga-u)
   SUBmenu("Check fwd     R-c",4,rAmiga-c)
   SUBmenu("Chk&mark fwd  R-m",4,rAmiga-m)
   SUBmenu("Chk & collect R-l",4,rAmiga-l)
   SUBmenu("Merge w/ dict R-d",4,rAmiga-d)
   SUBmenu("Del from dict R-e",4,rAmiga-e)
   SUBmenu("Free Speller  R-f",4,rAmiga-f)
	  menu("Rexx             ",4,altCtl-1)
   SUBmenu("Ed out buf62 AC-1",4,altCtl-1)
   SUBmenu("Ed in buf61  AC-2",4,altCtl-2)
   SUBmenu("Buf62->Rexx  AC-3",4,altCtl-3)
   SUBmenu("Buf61<-Rexx  AC-4",4,altCtl-4)
   SUBmenu("hilite->Rexx AC-5",4,altCtl-5)
   SUBmenu("Cursor<-Rexx AC-6",4,altCtl-6)
   SUBmenu("Reply OKAY-> AC-7",4,altCtl-7)
   SUBmenu("Reply text-> AC-8",4,altCtl-8)
   checkedSUBmenu("Auto-traffic AC-9",4,altCtl-9,userGlobalB)
   SUBmenu("Make x.rexx  AC-0",4,altCtl-0)

menu("Modes",5,normal-f1)
			 menu("HYPER TEXT       ",5,lAmiga-gadget1)
		  SUBmenu("Hyper Text L-gad1",5,lAmiga-gadget1)
		  SUBmenu("Open HT    L-gad3",5,lAmiga-gadget3)
		  SUBmenu("Close HT   L-gad4",5,lAmiga-gadget4)
			 menu("TEACH KEYS       ",5,ctl-help)
   checkedSUBmenu("Teach keys C-help",5,ctl-help,teachKeys)
		  SUBmenu("Teach one     C-t",5,ctl-t)
             menu("Local modes      ",5,normal-kp0)			
   checkedSUBmenu("OverStrike    kp0",5,normal-kp0,overStrike)	
   checkedSUBmenu("WordWrap     C-f5",5,ctl-f5,wordWrap)
   checkedSUBmenu("Right justify A-j",5,alt-j,rightJustify)
   checkedSUBmenu("AutoIndent   A-f5",5,alt-f5,autoIndent)
   checkedSUBmenu("Read-only   SA-f5",5,shftAlt-f5,readOnly)
   checkedSUBmenu("Changed flag L-f5",5,lAmiga-f5,changed)
   checkedSUBmenu("Use tabs   AC-tab",5,altCtl-tab,trueTabs)
   checkedSUBmenu("AutoBackup SAC-f5",5,shftAltCtl-f5,autoBackup)
   checkedSUBmenu("Map illegals SA-m",5,shftAlt-m,mapChars)
   checkedSUBmenu("Save on idle C-f2",5,ctl-f2,userLocalA)
			 menu("Global modes     ",5,ctl-2)
   checkedSUBmenu("Row/Column    C-2",5,ctl-2,rowCol)
   checkedSUBmenu("Mark gadgets  C-g",5,ctl-g,markGadgets)
   checkedSUBmenu("Invisibles    C-v",5,ctl-v,spooks)
   checkedSUBmenu("Busies        C-b",5,ctl-b,busies)
   checkedSUBmenu("Use keys      A-u",5,alt-u,useKeys)
   checkedSUBmenu("Make icons   AC-i",5,altCtl-i,icons)

menu("Numbers",6,normal-f1)
	  menu("Show vals  S-help",6,shft-help)
   menu("Tab ruler        ",6,shftAlt-tab)
   SUBmenu("See ruler  SA-tab",6,shftAlt-tab)
   SUBmenu("Set ruler  SC-tab",6,shftCtl-tab)
   SUBmenu("Tab ruler SAC-tab",6,shftAltCtl-tab)
	  menu("Line-Page        ",6,ctl-return)
   SUBmenu("Line length C-rtn",6,ctl-return)
   SUBmenu("Lines/page    A-g",6,alt-g)
   SUBmenu("Left margin   L-m",6,lAmiga-m)
   SUBmenu("Top margin    L-u",6,lAmiga-u)
   SUBmenu("Bottom margin L-l",6,lAmiga-l)
   SUBmenu("End of line   C-e",6,ctl-e)
	  menu("Command mult  C-m",6,ctl-m)
	  menu("Max files   AC-f1",6,altCtl-f1)
	  menu("Idle timer  SAC-i",6,shftAltCtl-i)
	  menu("PM terminator ESC",6,normal-esc)
	  menu("File size     C-1",6,ctl-1)

menu("Display",7,normal-f1)
   menu("Colors     A-help",7,alt-help)
   menu("Tune RGB    A-esc",7,alt-esc)
   checkedMenu("Hide display  R-h",7,rAmiga-h,hideDisplay)
   menu("Scroll type   R-s",7,rAmiga-s)
   menu("Split windows    ",7,lAmiga-9)
SUBmenu("Next split    L-9",7,lAmiga-9)
SUBmenu("Drop split    L-0",7,lAmiga-0)
SUBmenu("Split lines   L-8",7,lAmiga-8)
SUBmenu("Mouse size    L-=",7,lAmiga-=)
SUBmenu("Curr buf      L-c",7,lAmiga-c)
SUBmenu("Undo buf      L-1",7,lAmiga-1)
SUBmenu("Search buf    L-2",7,lAmiga-2)
SUBmenu("Replac buf    L-3",7,lAmiga-3)
SUBmenu("Hilite buf    L-4",7,lAmiga-4)
SUBmenu("Invert buf    L-5",7,lAmiga-5)
SUBmenu("Columnar      L-6",7,lAmiga-6)
SUBmenu("Directories   L-7",7,lAmiga-7)
   menu("Lace/planes      ",7,shft-esc)
SUBmenu("Toggle      S-esc",7,shft-esc)
SUBmenu("Reg 1 plane  R-f1",7,rAmiga-f1)
SUBmenu("Reg 2 planes R-f2",7,rAmiga-f2)
SUBmenu("Lace 1 plane R-f3",7,rAmiga-f3)
SUBmenu("Lace 2 plane R-f4",7,rAmiga-f4)
   menu("Refresh   SC-help",7,shftCtl-help)
   menu("Do menus SAC-help",7,shftAltCtl-help)
   menu("Unhilite      A-h",7,alt-h)
   menu("Uninvert      A-i",7,alt-i)

	 nameBuffer(37,"Copied Columnar")
	 nameBuffer(38,"S:Directories")
	 nameBuffer(42,"Help!")
	 nameBuffer(45,"Scratch Deletes")
	 nameBuffer(46,"Copied Invert")
	 nameBuffer(47,"Copied Hilite")
	 nameBuffer(48,"Replace String")
	 nameBuffer(49,"Search String")
	 nameBuffer(61,"Rexx Msg/Reply IN")
	 nameBuffer(62,"Rexx Msg/Reply OUT")
	 ..refreshdisplay
	 ..runKey(shftAltCtl-a)
	 ..toggle(toTiny)
	 >
