home *** CD-ROM | disk | FTP | other *** search
/ gondwana.ecr.mu.oz.au/pub/ / Graphics.tar / Graphics / voglw.zip / queue.c < prev    next >
C/C++ Source or Header  |  1997-02-13  |  9KB  |  419 lines
  1. #include <stdio.h>
  2. #include "vogl.h"
  3. #include "vodevice.h"
  4.  
  5. /*
  6.  * qdevice
  7.  *
  8.  *    enable an input device.
  9.  */
  10. void
  11. qdevice(dev)
  12.     Device    dev;
  13. {
  14.     int    i, redraw_enabled;
  15.  
  16.     if (!vdevice.initialised)
  17.         verror("qdevice: vogl not initialised\n");
  18.  
  19.     if (dev > (Device)MAXDEV)
  20.         verror("qdevice: bad device number passed\n");
  21.  
  22.     switch (dev) {
  23.     case AKEY:
  24.     case BKEY:
  25.     case CKEY:
  26.     case DKEY:
  27.     case EKEY:
  28.     case FKEY:
  29.     case GKEY:
  30.     case HKEY:
  31.     case IKEY:
  32.     case JKEY:
  33.     case KKEY:
  34.     case LKEY:
  35.     case MKEY:
  36.     case NKEY:
  37.     case OKEY:
  38.     case PKEY:
  39.     case QKEY:
  40.     case RKEY:
  41.     case SKEY:
  42.     case TKEY:
  43.     case UKEY:
  44.     case VKEY:
  45.     case WKEY:
  46.     case XKEY:
  47.     case YKEY:
  48.     case ZKEY:
  49.         vdevice.kbdevents = 1;
  50.         vdevice.enabled[dev / 8] |= 1 << (dev & 0x7);
  51.         vdevice.enabled[(int)(dev - 'A' + 'a') / 8] |= 1 << ((dev - 'A' + 'a') & 0x7);
  52.         break;
  53.     case KEYBD:
  54.         vdevice.kbdmode = 1;
  55.         vdevice.kbdevents = 1;
  56.         /* HACK! (Isn't this whole file a hack?)
  57.          * Maintain status of REDRAW event here as well
  58.          */
  59.         redraw_enabled = (vdevice.enabled[REDRAW / 8] & (1 << (REDRAW & 0x7)));
  60.         for (i = 0; i != MAXDEVTABSIZE; i++)
  61.             vdevice.enabled[i] = 0xff;
  62.  
  63.         vdevice.enabled[0] &= 0xfe;    /* make sure 0 disabled for qtest */
  64.  
  65.         /* If it wasn't enabled, then reset it to be not enabled */
  66.         if (!redraw_enabled)
  67.             vdevice.enabled[REDRAW / 8] &= ~(1 << (REDRAW & 0x7));
  68.  
  69.         break;
  70.     case MOUSE1:
  71.     case MOUSE2:
  72.     case MOUSE3:
  73.         vdevice.mouseevents = 1;
  74.         vdevice.enabled[dev / 8] |= 1 << (dev & 0x7);
  75.         break;
  76.     case MINUSKEY:
  77.         vdevice.kbdevents = 1;
  78.         vdevice.enabled['-' / 8] |= 1 << ('-' & 0x7);
  79.         vdevice.enabled['_' / 8] |= 1 << ('_' & 0x7);
  80.         break;
  81.     case BACKSLASHKEY:
  82.         vdevice.kbdevents = 1;
  83.         vdevice.enabled['\\' / 8] |= 1 << ('\\' & 0x7);
  84.         vdevice.enabled['|' / 8] |= 1 << ('|' & 0x7);
  85.         break;
  86.     case EQUALKEY:
  87.         vdevice.kbdevents = 1;
  88.         vdevice.enabled['=' / 8] |= 1 << ('=' & 0x7);
  89.         vdevice.enabled['+' / 8] |= 1 << ('+' & 0x7);
  90.         break;
  91.     case LEFTBRACKETKEY:
  92.         vdevice.kbdevents = 1;
  93.         vdevice.enabled['[' / 8] |= 1 << ('[' & 0x7);
  94.         vdevice.enabled['{' / 8] |= 1 << ('{' & 0x7);
  95.         break;
  96.     case RIGHTBRACKETKEY:
  97.         vdevice.kbdevents = 1;
  98.         vdevice.enabled[']' / 8] |= 1 << (']' & 0x7);
  99.         vdevice.enabled['}' / 8] |= 1 << ('}' & 0x7);
  100.         break;
  101.     case INPUTCHANGE:
  102.         break;
  103.     case REDRAW:
  104.     default:
  105.         vdevice.kbdevents = 1;
  106.         vdevice.enabled[dev / 8] |= 1 << (dev & 0x7);
  107.     }
  108. }
  109.  
  110. /*
  111.  * unqdevice
  112.  *
  113.  *    disable an input device.
  114.  */
  115. void
  116. unqdevice(dev)
  117.     Device    dev;
  118. {
  119.     int    i;
  120.  
  121.     if (!vdevice.initialised)
  122.         verror("qdevice: vogl not initialised\n");
  123.  
  124.     if (dev > (Device)MAXDEV)
  125.         verror("qdevice: bad device number passed\n");
  126.  
  127.     switch (dev) {
  128.     case AKEY:
  129.     case BKEY:
  130.     case CKEY:
  131.     case DKEY:
  132.     case EKEY:
  133.     case FKEY:
  134.     case GKEY:
  135.     case HKEY:
  136.     case IKEY:
  137.     case JKEY:
  138.     case KKEY:
  139.     case LKEY:
  140.     case MKEY:
  141.     case NKEY:
  142.     case OKEY:
  143.     case PKEY:
  144.     case QKEY:
  145.     case RKEY:
  146.     case SKEY:
  147.     case TKEY:
  148.     case UKEY:
  149.     case VKEY:
  150.     case WKEY:
  151.     case XKEY:
  152.     case YKEY:
  153.     case ZKEY:
  154.         vdevice.enabled[dev / 8] &= ~(1 << (dev & 0x7));
  155.         vdevice.enabled[(int)(dev - 'A' + 'a') / 8] &= ~(1 << ((dev - 'A' + 'a') & 0x7));
  156.         break;
  157.     case KEYBD:
  158.         vdevice.kbdmode = 0;
  159.         for (i = 0; i != MAXDEVTABSIZE; i++)
  160.             vdevice.enabled[i] = 0x00;
  161.         break;
  162.     case MOUSE1:
  163.     case MOUSE2:
  164.     case MOUSE3:
  165.         vdevice.enabled[dev / 8] &= ~(1 << (dev & 0x7));
  166.         break;
  167.     case MINUSKEY:
  168.         vdevice.enabled['-' / 8] &= ~(1 << ('-' & 0x7));
  169.         vdevice.enabled['_' / 8] &= ~(1 << ('_' & 0x7));
  170.         break;
  171.     case BACKSLASHKEY:
  172.         vdevice.enabled['\\' / 8] &= ~(1 << ('\\' & 0x7));
  173.         vdevice.enabled['|' / 8] &= ~(1 << ('|' & 0x7));
  174.         break;
  175.     case EQUALKEY:
  176.         vdevice.enabled['=' / 8] &= ~(1 << ('=' & 0x7));
  177.         vdevice.enabled['+' / 8] &= ~(1 << ('+' & 0x7));
  178.         break;
  179.     case LEFTBRACKETKEY:
  180.         vdevice.enabled['[' / 8] &= ~(1 << ('[' & 0x7));
  181.         vdevice.enabled['{' / 8] &= ~(1 << ('{' & 0x7));
  182.         break;
  183.     case RIGHTBRACKETKEY:
  184.         vdevice.enabled[']' / 8] &= ~(1 << (']' & 0x7));
  185.         vdevice.enabled['}' / 8] &= ~(1 << ('}' & 0x7));
  186.         break;
  187.     case INPUTCHANGE:
  188.         return;
  189.     default:
  190.         vdevice.enabled[dev / 8] &= ~(1 << (dev & 0x7));
  191.     }
  192.  
  193.     vdevice.mouseevents = vdevice.kbdevents = 0;
  194.  
  195.     for (i = 0; i != MAXDEVTABSIZE; i++)
  196.         if (vdevice.enabled[i] != 0) {
  197.             if (i < 32)        /* max bits for keyboard */
  198.                 vdevice.kbdevents = 1;
  199.             else                /* must be mouse */
  200.                 vdevice.mouseevents = 1;
  201.         }
  202. }
  203.  
  204. /*
  205.  * qread
  206.  *
  207.  *    a poor man's qread, we only have a device queue one deep.
  208.  * Just sit and poll in case something happens. If nothing is
  209.  * enabled or there are no devices this returns -1.
  210.  */
  211. long
  212. qread(ret)
  213.     short    *ret;
  214. {
  215.     int    a, b, c1, c2, val;
  216.     int    eventind, eventmask, retvalue;
  217.  
  218.     if (!vdevice.initialised)
  219.         verror("qread: vogl not initialised\n");
  220.  
  221.     if (vdevice.alreadyread) {
  222.         /* May have been 'unqdevice'd by the time we get here */
  223.         eventind = vdevice.devno / 8;
  224.         eventmask = 1 << (vdevice.devno & 0x7);
  225.         if (vdevice.enabled[eventind] & eventmask) {
  226.             *ret = vdevice.data;
  227.             if (!vdevice.kbdmode && vdevice.data == 1)
  228.                 vdevice.data = 0;
  229.             else
  230.                 vdevice.alreadyread = 0;
  231.             return(vdevice.devno);
  232.         }
  233.     }
  234.  
  235.     val = c1 = c2 = 0;
  236.  
  237.     eventind = 0;
  238.     eventmask = 0;
  239.  
  240.     if (!vdevice.mouseevents && vdevice.kbdevents) {
  241.         while (!(vdevice.enabled[eventind] & eventmask)) {
  242.             if ((val = c1 = (*vdevice.dev.Vgetkey)()) < 0)
  243.                 return(val);
  244.  
  245.             eventind = c1 / 8;
  246.             eventmask = 1 << (c1 & 0x7);
  247.             *ret = c1;
  248.             if (c1 >= 'a' && c1 <= 'z')
  249.                 retvalue = c1 - 'a' + 'A';
  250.             else
  251.                 retvalue = c1;
  252.         }
  253.     } else if (vdevice.mouseevents && !vdevice.kbdevents) {
  254.         while (!(vdevice.enabled[eventind] & eventmask)) {
  255.             if ((c2 = (*vdevice.dev.Vlocator)(&a, &b)) < 0)
  256.                 return(c2);
  257.  
  258.             if (c2 != 0) {
  259.                 if (c2 & 0x01)
  260.                     c2 = MOUSE3;
  261.                 else if (c2 & 0x02)
  262.                     c2 = MOUSE2;
  263.                 else if (c2 & 0x04)
  264.                     c2 = MOUSE1;
  265.  
  266.                 eventind = c2 / 8;
  267.                 eventmask = 1 << (c2 & 0x7);
  268.                 *ret = c2;
  269.                 retvalue = c2;
  270.             }
  271.         }
  272.     } else if (vdevice.mouseevents && vdevice.kbdevents) {
  273.         while (!(vdevice.enabled[eventind] & eventmask)) {
  274.             while (c1 == 0 && c2 == 0) {
  275.                 val = c1 = (*vdevice.dev.Vcheckkey)();
  276.  
  277.                 c2 = (*vdevice.dev.Vlocator)(&a, &b);
  278.             }
  279.  
  280.             if (c1 < 0 && c2 < 0)
  281.                 return(-1);
  282.  
  283.             if (c1 != 0) {
  284.                 eventind = c1 / 8;
  285.                 eventmask = 1 << (c1 & 0x7);
  286.                 *ret = c1;
  287.                 if (c1 >= 'a' && c1 <= 'z')
  288.                     retvalue = c1 - 'a' + 'A';
  289.                 else
  290.                     retvalue = c1;
  291.             } else {
  292.                 if (c2 & 0x01)
  293.                     c2 = MOUSE3;
  294.                 else if (c2 & 0x02)
  295.                     c2 = MOUSE2;
  296.                 else if (c2 & 0x04)
  297.                     c2 = MOUSE1;
  298.                 eventind = c2 / 8;
  299.                 eventmask = 1 << (c2 & 0x7);
  300.                 *ret = c2;
  301.                 retvalue = c2;
  302.             }
  303.  
  304.             c1 = c2 = 0;
  305.         }
  306.     } else
  307.         return(-1);
  308.  
  309.     if (vdevice.kbdmode && val != 0) {
  310.         *ret = val;
  311.         return(KEYBD);
  312.     } else {
  313.         *ret = 1;            /* insert the up event */
  314.         vdevice.data = 0;
  315.         vdevice.devno = retvalue;
  316.         vdevice.alreadyread = 1;
  317.     }
  318.  
  319.     return(retvalue);
  320. }
  321.  
  322. /*
  323.  * qreset
  324.  *
  325.  *    as the queue is rather short this is easy.
  326.  */
  327. void
  328. qreset()
  329. {
  330.     while (((*vdevice.dev.Vcheckkey)()))
  331.         ;
  332.  
  333.     vdevice.alreadyread = 0;
  334. }
  335.  
  336. /*
  337.  * qtest
  338.  *
  339.  *    Check if there is anything in the event queue. As our reads are
  340.  * destructive at the moment, we have to save what we get in the device
  341.  * structure.
  342.  */
  343. long
  344. qtest()
  345. {
  346.     int    a, b, c1, c2, val;
  347.     int    eventind, eventmask;
  348.  
  349.     if (!vdevice.initialised)
  350.         verror("qtest: vogl not initialised\n");
  351.  
  352.     if (vdevice.alreadyread)
  353.         return((long)vdevice.devno);
  354.  
  355.     eventind = 0;
  356.     eventmask = 0;
  357.  
  358.     val = c1 = (*vdevice.dev.Vcheckkey)();
  359.  
  360.     c2 = (*vdevice.dev.Vlocator)(&a, &b);
  361.  
  362.     if (c1 != 0) {
  363.         eventind = c1 / 8;
  364.         eventmask = 1 << (c1 & 0x7);
  365.         if (vdevice.kbdmode) {
  366.             vdevice.data = val;
  367.             vdevice.devno = KEYBD;
  368.         } else {
  369.             vdevice.data = 1;
  370.             if (c1 >= 'a' && c1 <= 'z')
  371.                 vdevice.devno = c1 - 'a' + 'A';
  372.             else
  373.                 vdevice.devno = c1;
  374.         }
  375.     } else {
  376.         if (c2 & 0x01)
  377.             c2 = MOUSE3;
  378.         else if (c2 & 0x02)
  379.             c2 = MOUSE2;
  380.         else if (c2 & 0x04)
  381.             c2 = MOUSE1;
  382.         eventind = c2 / 8;
  383.         eventmask = 1 << (c2 & 0x7);
  384.         vdevice.data = 1;
  385.         vdevice.devno = c2;
  386.     }
  387.  
  388.     if (vdevice.enabled[eventind] & eventmask) {
  389.         vdevice.alreadyread = 1;
  390.         return(1L);
  391.     }
  392.  
  393.     return(0L);
  394. }
  395.  
  396. /*
  397.  * isqueued
  398.  *
  399.  *    return non-zero if a device is queued
  400.  */
  401. Boolean
  402. isqueued(dev)
  403.     Device    dev;
  404. {
  405.     return((long)vdevice.enabled[dev / 8] & (1 << (dev & 0x7)));
  406. }
  407.  
  408. /*
  409.  * qenter
  410.  *
  411.  *    Basically, does nothing....
  412.  */
  413. void
  414. qenter(dev, val)
  415.     Device    dev;
  416.     short    val;
  417. {
  418. }
  419.