home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d1xx / d134 / dme.lha / Dme / keyboard.c < prev    next >
C/C++ Source or Header  |  1988-03-18  |  14KB  |  636 lines
  1.  
  2. /*
  3.  *  KEYBOARD.C
  4.  *
  5.  *    (C)Copyright 1987 by Matthew Dillon
  6.  *
  7.  *  Handle keyboard related stuff such as keyboard mappings.  Every time
  8.  *  a key is pressed, KEYCTL() is called with the code.  KEYCTL() remembers
  9.  *  which qualifier keys are currently held down, and when a non-qualifier
  10.  *  key is pressed finds the hash entry for the key.  If no hash entry
  11.  *  exists (e.g. you type a normal 'a') the default keymap is used.
  12.  */
  13.  
  14. #include "defs.h"
  15. #include <stdio.h>
  16.  
  17. extern ubyte *cqtoa();
  18.  
  19. typedef struct IOStdReq CIO;
  20.  
  21. #define QUAL_SHIFT   0x01
  22. #define QUAL_CTRL    0x02
  23. #define QUAL_AMIGA   0x04
  24. #define QUAL_ALT     0x08
  25. #define QUAL_LMB     0x10
  26. #define QUAL_MMB     0x20
  27. #define QUAL_RMB     0x40
  28.  
  29. #define HASHSIZE  64            /*    power of 2  */
  30. #define HASHMASK  (HASHSIZE-1)
  31.  
  32. typedef struct _HASH {
  33.     struct _HASH *next;     /* next hash   */
  34.     ubyte code;         /* keycode       */
  35.     ubyte mask;         /* qual. mask  */
  36.     ubyte qual;         /* qual. comp  */
  37.     ubyte stat;         /* string static? */
  38.     char *str;            /* command string */
  39. } HASH;
  40.  
  41. HASH *Hash[HASHSIZE];
  42.  
  43. struct Device *ConsoleDevice;
  44.  
  45. ubyte    ctoa[128];
  46. ubyte    cstoa[128];
  47.  
  48. void
  49. keyctl(im, code, qual)
  50. IMESS *im;
  51. register USHORT qual;
  52. {
  53.     ubyte buf[256];
  54.     ubyte c2;
  55.     short blen = 0;
  56.  
  57.     code &= 0xFF;
  58.     if (im) {
  59.     im->Qualifier &= ~IEQUALIFIER_REPEAT;
  60.     blen = DeadKeyConvert(im, buf+1, 254, NULL);
  61.     if (blen < 0)
  62.         return;
  63.     }
  64.     c2 = 0;
  65.     if (qual & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))
  66.     c2 |= QUAL_SHIFT;
  67.     if (qual & (IEQUALIFIER_CONTROL))
  68.     c2 |= QUAL_CTRL;
  69.     if (qual & (IEQUALIFIER_LCOMMAND|IEQUALIFIER_RCOMMAND))
  70.     c2 |= QUAL_AMIGA;
  71.     if (qual & (IEQUALIFIER_LALT|IEQUALIFIER_RALT))
  72.     c2 |= QUAL_ALT;
  73.     if ((qual & IEQUALIFIER_CAPSLOCK) && blen == 1 && buf[1] >= 'a' && buf[1] <= 'z')
  74.     c2 |= QUAL_SHIFT;
  75.     if (qual & IEQUALIFIER_LEFTBUTTON)
  76.     c2 |= QUAL_LMB;
  77.     if (qual & IEQUALIFIER_MIDBUTTON)
  78.     c2 |= QUAL_MMB;
  79.     if (qual & (IEQUALIFIER_RBUTTON))
  80.     c2 |= QUAL_RMB;
  81.  
  82.     {
  83.     register HASH *hash;
  84.     for (hash = Hash[code&HASHMASK]; hash; hash = hash->next) {
  85.         if (hash->code == code && (c2 & hash->mask) == hash->qual)
  86.         break;
  87.     }
  88.  
  89.     /*
  90.      *  Use hash entry only if not in command line mode, or if the
  91.      *  entry does not correspond to an alpha key.
  92.      */
  93.  
  94.     if (hash) {
  95.         if (c2 || !Comlinemode || blen > 1 || !ctoa[code]) {
  96.         strcpy(buf, hash->str);
  97.         do_command(buf);
  98.         return;
  99.         }
  100.     }
  101.     }
  102.  
  103.     /*
  104.      *    No hash entry
  105.      */
  106.  
  107.     if (blen == 1) {
  108.     buf[0] = '\'';
  109.     buf[2] = 0;
  110.     } else {
  111.     buf[0] = '\`';
  112.     buf[blen+1] = '\'';
  113.     }
  114.     if (blen)
  115.     do_command(buf);
  116. }
  117.  
  118. dealloc_hash()
  119. {
  120.     register HASH *hash, *hnext = NULL;
  121.     register short i;
  122.  
  123.     for (i = 0; i < HASHSIZE; ++i) {
  124.     for (hash = Hash[i]; hash; hash = hnext) {
  125.         hnext = hash->next;
  126.         if (!hash->stat)
  127.         FreeMem(hash->str, strlen(hash->str)+1);
  128.         FreeMem(hash, sizeof(HASH));
  129.     }
  130.     Hash[i] = NULL;
  131.     }
  132. }
  133.  
  134. resethash()
  135. {
  136.     register short i;
  137.     CIO cio;
  138.     static struct {
  139.     char *from, *to;
  140.     } defmap[] = {
  141.     "esc",      "esc",
  142.     "c-esc",    "recall",
  143.     "return",   "return insline up firstnb down",
  144.     "enter",    "return",
  145.     "up",       "up",
  146.     "down",     "down",
  147.     "right",    "right",
  148.     "left",     "left",
  149.     "bs",       "bs",
  150.     "del",      "del",
  151.     "tab",      "tab",
  152.     "a-up",     "scrollup",
  153.     "a-down",   "scrolldown",
  154.     "a-r",      "nextr",
  155.     "a-u",      "while cl (tlate -32 right)",
  156.     "a-l",      "while cu (tlate +32 right)",
  157.     "s-up",     "top",
  158.     "s-down",   "bottom",
  159.     "s-right",  "last",
  160.     "s-left",   "first",
  161.     "s-tab",    "backtab",
  162.     "s-del",    "deline",
  163.     "s- ",      "( )",              /* shift space to space */
  164.     "c-1",      "goto block",
  165.     "c-c",      "",                 /* break.. map to a nop */
  166.     "c-l",      "wleft",
  167.     "c-r",      "wright",
  168.     "c-i",      "insertmode on",
  169.     "c-o",      "insertmode off",
  170.     "c-j",      "join",
  171.     "c-s",      "split first down",
  172.     "c-del",    "remeol",
  173.     "c-n",      "next",
  174.     "c-p",      "prev",
  175.     "c-/",      "escimm (find )",
  176.     "c-]",      "ref",
  177.     "c-g",      "escimm (goto )",
  178.     "c-up",     "pageup",
  179.     "c-down",   "pagedown",
  180.     "c-q",      "quit",
  181.     "c-f",      "reformat",
  182.     "c-w",      "wordwrap toggle",
  183.     "f1",       "escimm (insfile )",
  184.     "f2",       "escimm (newfile )",
  185.     "f3",       "escimm (newwindow newfile )",
  186.     "f6",       "saveold iconify",
  187.     "f7",       "escimm (bsave )",
  188.     "f8",       "saveold escimm (newfile )",
  189.     "f9",       "saveold",
  190.     "f10",      "saveold quit",
  191.     "c-b",      "block",
  192.     "c-u",      "unblock",
  193.     "a-d",      "bdelete",
  194.     "a-c",      "bcopy",
  195.     "a-m",      "bmove",
  196.     "a-s",      "bsource",
  197.     "a-S",      "unblock block block bsource",
  198.     "L-lmb",    "tomouse",      /*  left button                 */
  199.     "L-mmo",    "tomouse",      /*  mouse move w/left held down */
  200.     "R-rmb",    "iconify",      /*  right button                */
  201.     NULL, NULL
  202.     };
  203.  
  204.     dealloc_hash();
  205.     OpenDevice("console.device", -1, &cio, 0);
  206.     ConsoleDevice = cio.io_Device;
  207.     keyboard_init();
  208.     for (i = 0; defmap[i].from; ++i) {
  209.     ubyte code, qual;
  210.     if (get_codequal(defmap[i].from, &code, &qual))
  211.         addhash(code, 1, 0xFF, qual, defmap[i].to);
  212.     }
  213. }
  214.  
  215. returnoveride(n)
  216. {
  217.     HASH *hash;
  218.     static ubyte *str;
  219.     static int stat;
  220.  
  221.     for (hash = Hash[0x44&HASHMASK]; hash; hash = hash->next) {
  222.     if (hash->code == 0x44 && hash->qual == 0) {
  223.         if (n) {
  224.         str = (ubyte *)hash->str;
  225.         stat= hash->stat;
  226.         hash->str = "return";
  227.         hash->stat = 1;
  228.         } else {
  229.         if (str == NULL) {
  230.             remhash(0x44, -1, 0);
  231.         } else {
  232.             hash->str = (char *)str;
  233.             hash->stat= stat;
  234.         }
  235.         }
  236.         return(0);
  237.     }
  238.     }
  239.     if (n) {
  240.     addhash(0x44, 1, 0xFF, 0, "return");
  241.     str = NULL;
  242.     }
  243. }
  244.  
  245.  
  246. addhash(code, stat, mask, qual, str)
  247. ubyte code, stat, mask, qual;
  248. ubyte *str;
  249. {
  250.     register HASH **p, *hash;
  251.  
  252.     hash = *(p = &Hash[code&HASHMASK]);
  253.     while (hash) {
  254.     if (hash->code == code && hash->qual == qual && hash->mask == mask) {
  255.         if (!hash->stat)
  256.         FreeMem(hash->str, strlen(hash->str)+1);
  257.         goto newstr;
  258.     }
  259.     hash = *(p = &hash->next);
  260.     }
  261.     *p = hash = (HASH *)AllocMem(sizeof(HASH), 0);
  262.     hash->next = NULL;
  263. newstr:
  264.     hash->code = code;
  265.     hash->stat = stat;
  266.     hash->mask = mask;
  267.     hash->qual = qual;
  268.     hash->str = (char *)str;
  269.     if (!stat)                  /* if not static */
  270.     hash->str = (char *)strcpy(AllocMem(strlen(str)+1, 0), str);
  271. }
  272.  
  273.  
  274. remhash(code, mask, qual)
  275. ubyte code, mask, qual;
  276. {
  277.     register HASH *hash, **p;
  278.  
  279.     hash = *(p = &Hash[code&HASHMASK]);
  280.     while (hash) {
  281.     if (hash->code == code && hash->qual == qual && hash->mask == mask) {
  282.         if (!hash->stat)
  283.         FreeMem(hash->str, strlen(hash->str)+1);
  284.         *p = hash->next;
  285.         FreeMem(hash, sizeof(HASH));
  286.         return(1);
  287.     }
  288.     hash = *(p = &hash->next);
  289.     }
  290.     return(0);
  291. }
  292.  
  293. char *
  294. keyspectomacro(str)
  295. char *str;
  296. {
  297.     HASH *hash;
  298.     ubyte code, qual;
  299.  
  300.     if (get_codequal(str, &code, &qual)) {
  301.     for (hash = Hash[code&HASHMASK]; hash; hash = hash->next) {
  302.         if (hash->code == code) {
  303.         if (hash->qual == (qual & hash->mask)) {
  304.             return(hash->str);
  305.         }
  306.         }
  307.     }
  308.     }
  309.     return(NULL);
  310. }
  311.  
  312.  
  313. do_map()
  314. {
  315.     ubyte code, qual;
  316.  
  317.     if (get_codequal(av[1], &code, &qual)) {
  318.     addhash(code, 0, 0xFF, qual, av[2]);
  319.     } else {
  320.     title("Unknown Key");
  321.     }
  322. }
  323.  
  324. do_unmap()        /* key   */
  325. {
  326.     ubyte code, qual;
  327.  
  328.     if (get_codequal(av[1], &code, &qual)) {
  329.     remhash(code, -1, qual);
  330.     } else {
  331.     title("Unknown Command");
  332.     }
  333. }
  334.  
  335. do_clearmap()
  336. {
  337.     resethash();
  338. }
  339.  
  340. /*
  341.  * SAVEMAP  file
  342.  * SAVESMAP file
  343.  */
  344.  
  345. do_savemap()
  346. {
  347.     char sysalso;
  348.     char err = 0;
  349.     char buf[256];
  350.     long xfi;
  351.     register int i;
  352.     register HASH *hash;
  353.     register ubyte *ptr;
  354.  
  355.     xfi = xfopen(av[1], "w", 512);
  356.     if (xfi) {
  357.     sysalso = av[0][4] == 's';
  358.     for (i = 0; i < HASHSIZE; ++i) {
  359.         for (hash = Hash[i]; hash; hash = hash->next) {
  360.         if (hash->stat == 0 || sysalso) {
  361.             char soc = '(';
  362.             char eoc = ')';
  363.             char ksoc = '(';
  364.             char keoc = ')';
  365.             short len;
  366.  
  367.             for (ptr = (ubyte *)hash->str; *ptr; ++ptr) {
  368.             if (*ptr == '(')
  369.                 break;
  370.             if (*ptr == '\`') {
  371.                 soc = '\`';
  372.                 eoc = '\'';
  373.                 break;
  374.             }
  375.             }
  376.             len = strlen(ptr = cqtoa(hash->code, hash->qual)) - 1;
  377.             if (ptr[len] == '(' || ptr[len] == ')') {
  378.             ksoc = '\`';
  379.             keoc = '\'';
  380.             }
  381.             sprintf(buf, "map %c%s%c %c%s%c\n", ksoc, cqtoa(hash->code, hash->qual), keoc, soc, hash->str, eoc);
  382.             xfwrite(xfi, buf, strlen(buf));
  383.         }
  384.         }
  385.     }
  386.     xfclose(xfi);
  387.     if (err)
  388.         title ("Unable to Write");
  389.     else
  390.         title ("OK");
  391.     } else {
  392.     title("Unable to open file");
  393.     }
  394. }
  395.  
  396.  
  397. DeadKeyConvert(msg,buf,bufsize,keymap)
  398. struct IntuiMessage *msg;
  399. UBYTE *buf;
  400. int bufsize;
  401. struct KeyMap *keymap;
  402. {
  403.     static struct InputEvent ievent = { NULL, IECLASS_RAWKEY };
  404.     if (msg->Class != RAWKEY)
  405.     return(-2);
  406.     ievent.ie_Code = msg->Code;
  407.     ievent.ie_Qualifier = msg->Qualifier;
  408.     ievent.ie_position.ie_addr = *((APTR *)msg->IAddress);
  409.     return(RawKeyConvert(&ievent,buf,bufsize,keymap));
  410. }
  411.  
  412.  
  413. /*
  414.  *  Nitty Gritty.
  415.  *
  416.  *  keyboard_init:  initialize for get_codequal() and cqtoa()
  417.  *  get_codequal:   convert a qualifier-string combo to a keycode and qual.
  418.  *  cqtoa:        convert a keycode and qual to a qual & string
  419.  */
  420.  
  421. #define LN(a,b,c,d)  ((a<<24)|(b<<16)|(c<<8)|d)
  422.  
  423. long lname[] = {
  424.     LN('e','s','c', 0  ), LN('f','1', 0 , 0  ), LN('f','2', 0 , 0  ),
  425.     LN('f','3', 0 , 0  ), LN('f','4', 0 , 0  ), LN('f','5', 0 , 0  ),
  426.     LN('f','6', 0 , 0  ), LN('f','7', 0 , 0  ), LN('f','8', 0 , 0  ),
  427.     LN('f','9', 0 , 0  ), LN('f','1','0', 0  ), LN('d','e','l', 0  ),
  428.     LN('b','a','c', 0  ), LN('b','s', 0 , 0  ), LN('t','a','b', 0  ),
  429.     LN('h','e','l', 0  ), LN('r','e','t', 0  ), LN('u','p', 0 , 0  ),
  430.     LN('d','o','w', 0  ), LN('r','i','g', 0  ), LN('l','e','f', 0  ),
  431.     LN('e','n','t', 0  ), LN('n','k','-', 0  ), LN('n','k','.', 0  ),
  432.     LN('n','k','0', 0  ),   /* 24 */
  433.     LN('n','k','1', 0  ), LN('n','k','2', 0  ), LN('n','k','3', 0  ),
  434.     LN('n','k','4', 0  ), LN('n','k','5', 0  ), LN('n','k','6', 0  ),
  435.     LN('n','k','7', 0  ), LN('n','k','8', 0  ), LN('n','k','9', 0  ),
  436.     LN('n','k','(', 0  ), LN('n','k',')', 0  ), LN('n','k','/', 0  ), /*34-36*/
  437.     LN('n','k','*', 0  ), LN('n','k','+', 0  ),
  438.     LN('l','m','b',0xE8), LN('m','m','b',0xEA), LN('r','m','b',0xE9),
  439.     LN('m','m','o',QMOVE),
  440.     0
  441. };
  442.  
  443.  
  444. /*
  445.  *  ESC:    x1B
  446.  *  FUNCKEYS:    x9B 30 7E to x9B 39 7E
  447.  *  DEL:    x7E
  448.  *  BS:     x08
  449.  *  TAB:    x09
  450.  *  RETURN:    x0D
  451.  *  HELP    x9B 3F 7E
  452.  *  UP/D/L/R    x9B 41/42/44/43
  453.  *  NK0-9,-,.,ENTER
  454.  *
  455.  *  Mouse buttons
  456.  */
  457.  
  458. keyboard_init()
  459. {
  460.     static struct InputEvent ievent = { NULL, IECLASS_RAWKEY };
  461.     ubyte buf[32];
  462.     register short i, q, len;
  463.  
  464.     lname[16] |= 0x44;
  465.     lname[21] |= 0x43;
  466.  
  467.     for (i = 0; i < 128; ++i) {
  468.     ievent.ie_Code = i;
  469.     ievent.ie_Qualifier = 0;
  470.     ievent.ie_position.ie_addr = NULL;
  471.     len = RawKeyConvert(&ievent,buf,32,NULL);
  472.     switch(len) {
  473.     case 1:     /*    ESC/DEL/BS/TAB/NKx  */
  474.         if (buf[0] > 32)
  475.         ctoa[i] = buf[0];
  476.         switch(buf[0]) {
  477.         case 0x1B:    lname[ 0] |= i; break;
  478.         case 0x7F:    lname[11] |= i; break;
  479.         case 0x09:    lname[14] |= i; break;
  480.         case 0x08:    lname[12] |= i; lname[13] |= i; break;
  481.         case '(': if (i > 0x3A) lname[34] |= i; break;
  482.         case ')': if (i > 0x3A) lname[35] |= i; break;
  483.         case '/': if (i > 0x3A) lname[36] |= i; break;
  484.         case '*': if (i > 0x3A) lname[37] |= i; break;
  485.         case '-': if (i > 0x3A) lname[22] |= i; break;
  486.         case '+': if (i > 0x3A) lname[38] |= i; break;
  487.         case '.': if (i > 0x3A) lname[23] |= i; break;
  488.         default:
  489.         if (i >= 0x0F && buf[0] >= '0' && buf[0] <= '9')
  490.             lname[24+buf[0]-'0'] |= i;
  491.         }
  492.         break;
  493.     case 2:     /*    cursor            */
  494.         if (buf[0] == 0x9B) {
  495.         switch(buf[1]) {
  496.         case 0x41:  lname[17] |= i;  break;
  497.         case 0x42:  lname[18] |= i;  break;
  498.         case 0x43:  lname[19] |= i;  break;
  499.         case 0x44:  lname[20] |= i;  break;
  500.         }
  501.         }
  502.         break;
  503.     case 3:     /*    function/help        */
  504.         if (buf[0] == 0x9B && buf[2] == 0x7E) {
  505.         if (buf[1] == 0x3F)
  506.             lname[15] |= i;
  507.         if (buf[1] >= 0x30 && buf[1] <= 0x39)
  508.             lname[buf[1]-0x30+1] |= i;
  509.         }
  510.         break;
  511.     }
  512.     }
  513.     for (i = 0; i < 128; ++i) {
  514.     ievent.ie_Code = i;
  515.     ievent.ie_Qualifier = IEQUALIFIER_LSHIFT;
  516.     ievent.ie_position.ie_addr = NULL;
  517.     len = RawKeyConvert(&ievent,buf,32,NULL);
  518.     if (len == 1)
  519.         cstoa[i] = buf[0];
  520.     }
  521.     {
  522.     ubyte code, qual;
  523.     get_codequal("c", &code, &qual);
  524.     CtlC = code;
  525.     }
  526. }
  527.  
  528.  
  529. ubyte *
  530. cqtoa(code, qual)
  531. register int qual;
  532. {
  533.     static ubyte buf[32];
  534.     register ubyte *ptr = buf;
  535.     register int i;
  536.  
  537.     if (qual & QUAL_SHIFT)
  538.     *ptr++ = 's';
  539.     if (qual & QUAL_CTRL)
  540.     *ptr++ = 'c';
  541.     if (qual & QUAL_ALT)
  542.     *ptr++ = 'a';
  543.     if (qual & QUAL_AMIGA)
  544.     *ptr++ = 'A';
  545.     if (qual & QUAL_LMB)
  546.     *ptr++ = 'L';
  547.     if (qual & QUAL_MMB)
  548.     *ptr++ = 'M';
  549.     if (qual & QUAL_RMB)
  550.     *ptr++ = 'R';
  551.     if (qual)
  552.     *ptr++ = '-';
  553.     for (i = 0; i < sizeof(lname)/sizeof(lname[0]); ++i) {
  554.     if ((lname[i]&0xFF) == code) {
  555.         *ptr++ = (lname[i]>>24);
  556.         *ptr++ = (lname[i]>>16);
  557.         *ptr++ = (lname[i]>>8);
  558.         break;
  559.     }
  560.     }
  561.     if (i == sizeof(lname)/sizeof(lname[0]))
  562.     *ptr++ = ctoa[code];
  563.     *ptr++ = 0;
  564.     return(buf);
  565. }
  566.  
  567.  
  568. get_codequal(str, pcode, pqual)
  569. ubyte *pcode, *pqual;
  570. register ubyte *str;
  571. {
  572.     register ubyte qual;
  573.     register short i;
  574.  
  575.     qual = 0;
  576.     if (strlen(str) > 1) {
  577.     for (; *str && *str != '-'; ++str) {
  578.         if (*str == 's')
  579.         qual |= QUAL_SHIFT;
  580.         if (*str == 'c')
  581.         qual |= QUAL_CTRL;
  582.         if (*str == 'a')
  583.         qual |= QUAL_ALT;
  584.         if (*str == 'A')
  585.         qual |= QUAL_AMIGA;
  586.         if (*str == 'L')
  587.         qual |= QUAL_LMB;
  588.         if (*str == 'M')
  589.         qual |= QUAL_MMB;
  590.         if (*str == 'R')
  591.         qual |= QUAL_RMB;
  592.         if (!qual)
  593.         goto notqual;
  594.     }
  595.     if (*str)
  596.         ++str;
  597.     }
  598. notqual:
  599.     if (strlen(str) != 1) {           /* long name   */
  600.     register short shift = 24;
  601.     register long mult = 0;
  602.  
  603.     *pqual = qual;
  604.     while (*str && shift >= 8) {
  605.         if (*str >= 'A' && *str <= 'Z')
  606.         *str = *str - 'A' + 'a';
  607.         mult |= *str << shift;
  608.         shift -= 8;
  609.         ++str;
  610.     }
  611.     for (i = 0; lname[i]; ++i) {
  612.         if (mult == (lname[i] & 0xFFFFFF00)) {
  613.         *pcode = lname[i] & 0xFF;
  614.         return(1);
  615.         }
  616.     }
  617.     } else {            /*    single character keycap */
  618.     for (i = 0; i < sizeof(ctoa); ++i) {
  619.         if (*str == ctoa[i]) {
  620.         *pcode = i;
  621.         *pqual = qual;
  622.         return(1);
  623.         }
  624.     }
  625.     for (i = 0; i < sizeof(cstoa); ++i) {
  626.         if (*str == cstoa[i]) {
  627.         *pcode = i;
  628.         *pqual = qual|QUAL_SHIFT;
  629.         return(1);
  630.         }
  631.     }
  632.     }
  633.     return(0);
  634. }
  635.  
  636.