home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / xgalaga-2_0_tar.gz / xgalaga-2_0_tar / xgalaga-2.0 / libsprite / event.c < prev    next >
C/C++ Source or Header  |  1998-04-12  |  7KB  |  299 lines
  1. #include "allincludes.h"
  2.  
  3. static struct window *
  4. findWindow(window)
  5.     Window  window;
  6. {
  7.     struct windowlist *entry;
  8.  
  9.     entry = hashtable[hash(window)];
  10.     while (entry != NULL) {
  11.     if (entry->window->window == window)
  12.         return (entry->window);
  13.     entry = entry->next;
  14.     }
  15.     return (NULL);
  16. }
  17.  
  18. void
  19. W_GetEvent(wevent)
  20.     W_Event *wevent;
  21. {
  22. /* blocks until an event is received [BDyess] */
  23.     XEvent  event;
  24.  
  25.     if (W_isEvent) {
  26.     *wevent = W_myevent;
  27.     W_isEvent = 0;
  28.     return;
  29.     }
  30.     XNextEvent(W_Display, &event);
  31.     XPutBackEvent(W_Display, &event);
  32.     W_SpNextEvent(wevent);
  33. }
  34.  
  35. int
  36. W_EventsPending()
  37. {
  38.     if (W_isEvent)
  39.     return (1);
  40.     while (XPending(W_Display) || buttonDown) {
  41.     if (W_SpNextEvent(&W_myevent)) {
  42.         W_isEvent = 1;
  43.         return (1);
  44.     }
  45.     }
  46.     return (0);
  47. }
  48.  
  49. void
  50. W_NextEvent(wevent)
  51.     W_Event *wevent;
  52. {
  53.     if (W_isEvent) {
  54.     *wevent = W_myevent;
  55.     W_isEvent = 0;
  56.     return;
  57.     }
  58.     /*while (W_SpNextEvent(wevent) == 0);*/
  59. }
  60.  
  61.  int
  62. W_SpNextEvent(wevent)
  63.     W_Event *wevent;
  64. {
  65.     XEvent  event;
  66.     XKeyEvent *key;
  67.     XButtonEvent *button;
  68.     XExposeEvent *expose;
  69.     XResizeRequestEvent *resize;
  70.     KeySym keysym;
  71.  
  72.     char    ch;
  73.     struct window *win;
  74. #ifdef CONTINUOUS_MOUSE
  75.     static W_Event buttonEvent;
  76.     static int delaytime, cupd = -1;
  77. #endif                /* CONTINUOUS_MOUSE */
  78.  
  79. #ifdef DEBUG
  80.     printf("Getting an event...\n");
  81. #endif
  82.     key = (XKeyEvent *) & event;
  83.     button = (XButtonEvent *) & event;
  84.     expose = (XExposeEvent *) & event;
  85.     resize = (XResizeRequestEvent *) & event;
  86.     for (;;) {
  87.     if (XPending(W_Display))
  88.         XNextEvent(W_Display, &event);
  89. #ifdef CONTINUOUS_MOUSE
  90.     else if (buttonDown) {
  91.         if (continuousMouse && allowContinuousMouse) {
  92.         if (cupd != udcounter) {
  93.             cupd = udcounter;
  94.             if (delaytime == 0) {
  95.             bcopy(&buttonEvent, wevent, sizeof(W_Event));
  96.             delaytime = clickDelay;
  97.             } else {
  98.             delaytime--;
  99.             wevent->type = -1;
  100.             }
  101.         } else
  102.             wevent->type = -1;
  103.         exitInputLoop = 1;
  104.         } else {
  105.         wevent->type = -1;
  106.         buttonDown = 0;
  107.         }
  108.         return (1);
  109.     }
  110. #endif
  111.     else
  112.         return (0);
  113.     /*
  114.        printf("read an event %d\n", event.type);
  115.     */
  116.     win = findWindow(key->window);
  117.     if (win == NULL)
  118.         return (0);
  119.     if ((event.type == KeyPress || event.type == ButtonPress) &&
  120.         win->type == WIN_MENU) {
  121.         if (key->y % (W_Textheight + MENU_PAD * 2 + MENU_BAR) >=
  122.         W_Textheight + MENU_PAD * 2)
  123.         return (0);
  124.         key->y = key->y / (W_Textheight + MENU_PAD * 2 + MENU_BAR);
  125.     }
  126.     switch ((int) event.type) {
  127.     case LeaveNotify:    /* for message window -- jfy */
  128.         return (0);
  129.         break;
  130.     case KeyPress:
  131.         if (key->state & ControlMask) {
  132.         controlkey = 1;
  133.         key->state &= ~ControlMask;
  134.         } else
  135.         controlkey = 0;
  136.         if (key->state & BillsScrewyAltMask) {
  137.         altkey = 1;
  138.         key->state &= ~BillsScrewyAltMask;
  139.         } else
  140.         altkey = 0;
  141.         if (XLookupString(key, &ch, 1, &keysym, NULL) > 0) {
  142.         wevent->type = W_EV_KEY;
  143.         wevent->Window = W_Window2Void(win);
  144.         wevent->x = key->x;
  145.         wevent->y = key->y;
  146.         if (controlkey)
  147.             wevent->key = (int) ch + 128;
  148.         else if (altkey)
  149.             wevent->key = (int) ch + 256;
  150.         else
  151.             wevent->key = ch;
  152.         return (1);
  153.         } else { /* trap arrow keys */
  154.         if(keysym == XK_Left || keysym == XK_Right) {
  155.             wevent->type = W_EV_KEY;
  156.             wevent->Window = W_Window2Void(win);
  157.             wevent->x = key->x;
  158.             wevent->y = key->y;
  159.             switch(keysym) {
  160.               case XK_Left:
  161.             wevent->key = (int)'b'+128; /* Left arrow --> ctrl-b */
  162.             break;
  163.               case XK_Right:
  164.             wevent->key = (int)'f'+128; /* Right arrow --> ctrl-f */
  165.             break;
  166.             }
  167.             return (1);
  168.         }
  169.         }
  170.         return (0);
  171.         break;
  172. #ifdef AUTOKEY
  173.     case KeyRelease:
  174.         if (XLookupString(key, &ch, 1, &keysym, NULL) > 0) {
  175.         wevent->type = W_EV_KEY_OFF;
  176.         wevent->Window = W_Window2Void(win);
  177.         wevent->x = key->x;
  178.         wevent->y = key->y;
  179.         wevent->key = ch;
  180.         return (1);
  181.         } else {
  182.         if(keysym == XK_Right || keysym == XK_Left) {
  183.             wevent->type = W_EV_KEY_OFF;
  184.             wevent->Window = W_Window2Void(win);
  185.             wevent->x = key->x;
  186.             wevent->y = key->y;
  187.             switch(keysym) {
  188.               case XK_Left:
  189.             wevent->key = (int)'b'+128; /* Left arrow --> ctrl-b */
  190.             break;
  191.               case XK_Right:
  192.             wevent->key = (int)'f'+128; /* Right arrow --> ctrl-f */
  193.             break;
  194.             }
  195.             return (1);
  196.         }
  197.         }        
  198.         return (0);
  199.         break;
  200. #endif                /* AUTOKEY */
  201.     case ButtonPress:
  202.         wevent->type = W_EV_BUTTON;
  203.         wevent->Window = W_Window2Void(win);
  204.         wevent->x = button->x;
  205.         wevent->y = button->y;
  206.         switch (button->button & 0xf) {
  207.         case Button3:
  208.         wevent->key = W_RBUTTON;
  209.         break;
  210.         case Button1:
  211.         wevent->key = W_LBUTTON;
  212.         break;
  213.         case Button2:
  214.         wevent->key = W_MBUTTON;
  215.         break;
  216.         }
  217.         if (key->state & ControlMask)
  218.         wevent->key += 6;
  219.         if (key->state & ShiftMask)
  220.         wevent->key += 3;
  221.         if (key->state & BillsScrewyAltMask)
  222.         wevent->key += 12;    /* alt */
  223. #ifdef CONTINUOUS_MOUSE
  224.         if (continuousMouse && allowContinuousMouse &&
  225.         (wevent->Window == w || wevent->Window == mapw) &&
  226.         /*
  227.            buttonRepeatMask allows only certain buttons to repeat
  228.            [BDyess]
  229.         */
  230.         (1 << (wevent->key) & buttonRepeatMask)) {
  231.         buttonDown = 1;
  232.         exitInputLoop = 1;
  233.         delaytime = clickDelay;
  234.         bcopy(wevent, &buttonEvent, sizeof(W_Event));
  235.         }
  236.         return (1);
  237.     case ButtonRelease:
  238.         /* bcopy(&buttonEvent,wevent,sizeof(W_Event)); */
  239.         wevent->type = -1;
  240.         buttonDown = 0;
  241.         return (1);
  242.     case MotionNotify:
  243.         /*
  244.            the !buttonDown ensures that if you press a button and then
  245.            press another, release just the second, and then move the
  246.            mouse that nothing happens.
  247.         */
  248.         if (!(continuousMouse && allowContinuousMouse) || !buttonDown) {
  249.         wevent->type = -1;
  250.         return (1);
  251.         }
  252.         wevent->type = W_EV_BUTTON;
  253.         wevent->Window = W_Window2Void(win);
  254.         wevent->x = button->x;
  255.         wevent->y = button->y;
  256.         wevent->key = buttonEvent.key;
  257.         bcopy(wevent, &buttonEvent, sizeof(W_Event));
  258.         if (cupd == udcounter)
  259.         wevent->type = -1;
  260.         else
  261.         cupd = udcounter;
  262.  
  263.         return (1);
  264. #else
  265.         return (1);
  266. #endif                /* CONTINUOUS_MOUSE */
  267.     case Expose:
  268.         if (expose->count != 0)
  269.         return (0);
  270.         if (win->type == WIN_SCROLL) {
  271.         redrawScrolling(win);
  272.         return (0);
  273.         }
  274.         if (win->type == WIN_MENU) {
  275.         redrawMenu(win);
  276.         return (0);
  277.         }
  278.         if (win->type == WIN_BORDER) {
  279.             redrawBorder(win);
  280.         return (0);
  281.         }
  282.         if (win == W_Void2Window(baseWin)) {
  283.             /* main window has a reverse border [BDyess] */
  284.         /*redrawReversedBorder(win);*/
  285.         }
  286.         wevent->type = W_EV_EXPOSE;
  287.         wevent->Window = W_Window2Void(win);
  288.         return (1);
  289.     case ResizeRequest:
  290.         resizeScrolling(win, resize->width, resize->height);
  291.         break;
  292.     default:
  293.         return (0);
  294.         break;
  295.     }
  296.     }
  297. }
  298.  
  299.