WINGs/wevent.c

   1
   2
   3 /*
   4  * This event handling stuff was based on Tk.
   5  */
   6
   7 #include "WINGsP.h"
   8
   9 #include "../src/config.h"
  10
  11 #include <sys/types.h>
  12 #include <unistd.h>
  13
  14 #ifdef HAVE_SYS_SELECT_H
  15 # include <sys/select.h>
  16 #endif
  17
  18 #ifdef HAVE_GETTIMEOFDAY
  19 # include <sys/time.h>
  20 # ifdef TIME_WITH_SYS_TIME
  21 #  include <time.h>
  22 # endif
  23 #else /* ! HAVE_GETTIMEOFDAY */
  24 # include <time.h>
  25 #endif /* ! HAVE_GETTIMEOFDAY */
  26
  27
  28 extern _WINGsConfiguration WINGsConfiguration;
  29
  30
  31
  32 typedef struct TimerHandler {
  33     WMCallback          *callback;             /* procedure to call */
  34     unsigned long       msec;                  /* when to call the callback */
  35     void                *clientData;
  36     struct TimerHandler *next;
  37 } TimerHandler;
  38
  39
  40 typedef struct IdleHandler {
  41     WMCallback          *callback;
  42     void                *clientData;
  43     struct IdleHandler  *next;
  44 } IdleHandler;
  45
  46
  47 typedef struct InputHandler {
  48     WMInputProc         *callback;
  49     void                *clientData;
  50     int                 fd;
  51     int                 mask;
  52     struct InputHandler *next;
  53 } InputHandler;
  54
  55
  56 /* table to map event types to event masks */
  57 static unsigned long eventMasks[] = {
  58     0,
  59     0,
  60     KeyPressMask,                       /* KeyPress */
  61     KeyReleaseMask,                     /* KeyRelease */
  62     ButtonPressMask,                    /* ButtonPress */
  63     ButtonReleaseMask,                  /* ButtonRelease */
  64     PointerMotionMask|PointerMotionHintMask|ButtonMotionMask
  65             |Button1MotionMask|Button2MotionMask|Button3MotionMask
  66             |Button4MotionMask|Button5MotionMask,
  67                                         /* MotionNotify */
  68     EnterWindowMask,                    /* EnterNotify */
  69     LeaveWindowMask,                    /* LeaveNotify */
  70     FocusChangeMask,                    /* FocusIn */
  71     FocusChangeMask,                    /* FocusOut */
  72     KeymapStateMask,                    /* KeymapNotify */
  73     ExposureMask,                       /* Expose */
  74     ExposureMask,                       /* GraphicsExpose */
  75     ExposureMask,                       /* NoExpose */
  76     VisibilityChangeMask,               /* VisibilityNotify */
  77     SubstructureNotifyMask,             /* CreateNotify */
  78     StructureNotifyMask,                /* DestroyNotify */
  79     StructureNotifyMask,                /* UnmapNotify */
  80     StructureNotifyMask,                /* MapNotify */
  81     SubstructureRedirectMask,           /* MapRequest */
  82     StructureNotifyMask,                /* ReparentNotify */
  83     StructureNotifyMask,                /* ConfigureNotify */
  84     SubstructureRedirectMask,           /* ConfigureRequest */
  85     StructureNotifyMask,                /* GravityNotify */
  86     ResizeRedirectMask,                 /* ResizeRequest */
  87     StructureNotifyMask,                /* CirculateNotify */
  88     SubstructureRedirectMask,           /* CirculateRequest */
  89     PropertyChangeMask,                 /* PropertyNotify */
  90     0,                                  /* SelectionClear */
  91     0,                                  /* SelectionRequest */
  92     0,                                  /* SelectionNotify */
  93     ColormapChangeMask,                 /* ColormapNotify */
  94     ClientMessageMask,                  /* ClientMessage */
  95     0,                                  /* Mapping Notify */
  96 };
  97
  98
  99
 100 /* queue of timer event handlers */
 101 static TimerHandler *timerHandler=NULL;
 102
 103 static IdleHandler *idleHandler=NULL;
 104
 105 static InputHandler *inputHandler=NULL;
 106
 107 /* hook for other toolkits or wmaker process their events */
 108 static WMEventHook *extraEventHandler=NULL;
 109
 110
 111
 112 #define timerPending()  (timerHandler)
 113
 114 #define idlePending()   (idleHandler)
 115
 116
 117
 118 /* return current time in milliseconds */
 119 #ifdef HAVE_GETTIMEOFDAY
 120 static unsigned long
 121 rightNow(void) {
 122     struct timeval tv;
 123
 124     gettimeofday(&tv, NULL);
 125
 126     return 1000L*(unsigned long)tv.tv_sec + (unsigned long)tv.tv_usec/1000L;
 127 }
 128 #else /* !HAVE_GETTIMEOFDAY */
 129 # define rightNow()     (1000*(unsigned long)time(NULL))
 130 #endif /* !HAVE_GETTIMEOFDAY */
 131
 132
 133 WMHandlerID
 134 WMAddTimerHandler(int milliseconds, WMCallback *callback, void *cdata)
 135 {
 136     TimerHandler *handler, *tmp;
 137
 138     handler = malloc(sizeof(TimerHandler));
 139     if (!handler)
 140       return NULL;
 141
 142     handler->msec = rightNow()+milliseconds;
 143     handler->callback = callback;
 144     handler->clientData = cdata;
 145     /* insert callback in queue, sorted by time left */
 146     if (!timerHandler || timerHandler->msec >= handler->msec) {
 147         /* first in the queue */
 148         handler->next = timerHandler;
 149         timerHandler = handler;
 150     } else {
 151         tmp = timerHandler;
 152         while (tmp->next && tmp->next->msec < handler->msec) {
 153             tmp = tmp->next;
 154         }
 155         handler->next = tmp->next;
 156         tmp->next = handler;
 157     }
 158     return handler;
 159 }
 160
 161
 162
 163 void
 164 WMDeleteTimerWithClientData(void *cdata)
 165 {
 166     TimerHandler *handler, *tmp;
 167
 168     if (!cdata || !timerHandler)
 169         return;
 170
 171     tmp = timerHandler;
 172     if (tmp->clientData==cdata) {
 173         timerHandler = tmp->next;
 174         free(tmp);
 175     } else {
 176         while (tmp->next) {
 177             if (tmp->next->clientData==cdata) {
 178                 handler = tmp->next;
 179                 tmp->next = handler->next;
 180                 free(handler);
 181                 break;
 182             }
 183             tmp = tmp->next;
 184         }
 185     }
 186 }
 187
 188
 189
 190 void
 191 WMDeleteTimerHandler(WMHandlerID handlerID)
 192 {
 193     TimerHandler *tmp, *handler=(TimerHandler*)handlerID;
 194
 195     if (!handler || !timerHandler)
 196       return;
 197
 198     tmp = timerHandler;
 199     if (tmp==handler) {
 200         timerHandler = handler->next;
 201         free(handler);
 202     } else {
 203         while (tmp->next) {
 204             if (tmp->next==handler) {
 205                 tmp->next=handler->next;
 206                 free(handler);
 207                 break;
 208             }
 209             tmp = tmp->next;
 210         }
 211     }
 212 }
 213
 214
 215
 216 WMHandlerID
 217 WMAddIdleHandler(WMCallback *callback, void *cdata)
 218 {
 219     IdleHandler *handler, *tmp;
 220
 221     handler = malloc(sizeof(IdleHandler));
 222     if (!handler)
 223         return NULL;
 224
 225     handler->callback = callback;
 226     handler->clientData = cdata;
 227     handler->next = NULL;
 228     /* add callback at end of queue */
 229     if (!idleHandler) {
 230         idleHandler = handler;
 231     } else {
 232         tmp = idleHandler;
 233         while (tmp->next) {
 234             tmp = tmp->next;
 235         }
 236         tmp->next = handler;
 237     }
 238
 239     return handler;
 240 }
 241
 242
 243
 244 void
 245 WMDeleteIdleHandler(WMHandlerID handlerID)
 246 {
 247     IdleHandler *tmp, *handler = (IdleHandler*)handlerID;
 248
 249     if (!handler || !idleHandler)
 250         return;
 251
 252     tmp = idleHandler;
 253     if (tmp == handler) {
 254         idleHandler = handler->next;
 255         free(handler);
 256     } else {
 257         while (tmp->next) {
 258             if (tmp->next == handler) {
 259                 tmp->next = handler->next;
 260                 free(handler);
 261                 break;
 262             }
 263             tmp = tmp->next;
 264         }
 265     }
 266 }
 267
 268
 269
 270 WMHandlerID
 271 WMAddInputHandler(int fd, int condition, WMInputProc *proc, void *clientData)
 272 {
 273     InputHandler *handler;
 274
 275     handler = wmalloc(sizeof(InputHandler));
 276
 277     handler->fd = fd;
 278     handler->mask = condition;
 279     handler->callback = proc;
 280     handler->clientData = clientData;
 281
 282     handler->next = inputHandler;
 283
 284     inputHandler = handler;
 285
 286     return handler;
 287 }
 288
 289
 290 void
 291 WMDeleteInputHandler(WMHandlerID handlerID)
 292 {
 293     InputHandler *tmp, *handler = (InputHandler*)handlerID;
 294
 295     if (!handler || !inputHandler)
 296         return;
 297
 298     tmp = inputHandler;
 299     if (tmp == handler) {
 300         inputHandler = handler->next;
 301         free(handler);
 302     } else {
 303         while (tmp->next) {
 304             if (tmp->next == handler) {
 305                 tmp->next = handler->next;
 306                 free(handler);
 307                 break;
 308             }
 309             tmp = tmp->next;
 310         }
 311     }
 312 }
 313
 314
 315 static void
 316 checkIdleHandlers()
 317 {
 318     IdleHandler *handler, *tmp;
 319
 320     if (!idleHandler)
 321       return;
 322
 323     handler = idleHandler;
 324
 325     /* we will process all idleHandlers so, empty the handler list */
 326     idleHandler = NULL;
 327
 328     while (handler) {
 329         tmp = handler->next;
 330         (*handler->callback)(handler->clientData);
 331         /* remove the handler */
 332         free(handler);
 333
 334         handler = tmp;
 335     }
 336 }
 337
 338
 339
 340 static void
 341 checkTimerHandlers()
 342 {
 343     TimerHandler *handler;
 344     unsigned long now = rightNow();
 345
 346     if (!timerHandler || (timerHandler->msec > now))
 347       return;
 348
 349     while (timerHandler && timerHandler->msec <= now) {
 350         handler = timerHandler;
 351         timerHandler = timerHandler->next;
 352         handler->next = NULL;
 353         (*handler->callback)(handler->clientData);
 354         free(handler);
 355     }
 356 }
 357
 358
 359
 360 static unsigned long
 361 msToNextTimerEvent()
 362 {
 363     unsigned long now;
 364
 365     if (!timerHandler) {
 366         /* The return value of this function is only valid if there _are_
 367          timers active. */
 368         return 0;
 369     }
 370
 371     now = rightNow();
 372     if (timerHandler->msec < now) {
 373         return 0;
 374     } else {
 375         return timerHandler->msec - now;
 376     }
 377 }
 378
 379
 380
 381
 382 /*
 383  * WMCreateEventHandler--
 384  *      Create an event handler and put it in the event handler list for the
 385  * view. If the same callback and clientdata are already used in another
 386  * handler, the masks are swapped.
 387  *
 388  */
 389 void
 390 WMCreateEventHandler(WMView *view, unsigned long mask, WMEventProc *eventProc,
 391                      void *clientData)
 392 {
 393     W_EventHandler *handler;
 394     W_EventHandler *ptr = view->handlerList;
 395     unsigned long eventMask;
 396
 397     if (ptr==NULL) {
 398         handler = wmalloc(sizeof(W_EventHandler));
 399
 400         handler->nextHandler = NULL;
 401
 402         view->handlerList = handler;
 403
 404         eventMask = mask;
 405     } else {
 406         handler = NULL;
 407         eventMask = mask;
 408         while (ptr != NULL) {
 409             if (ptr->clientData == clientData && ptr->proc == eventProc) {
 410                 handler = ptr;
 411             }
 412             eventMask |= ptr->eventMask;
 413
 414             ptr = ptr->nextHandler;
 415         }
 416         if (!handler) {
 417             handler = wmalloc(sizeof(W_EventHandler));
 418             handler->nextHandler = view->handlerList;
 419             view->handlerList = handler;
 420         }
 421     }
 422
 423     /* select events for window */
 424     handler->eventMask = mask;
 425     handler->proc = eventProc;
 426     handler->clientData = clientData;
 427 }
 428
 429
 430 /*
 431  * WMDeleteEventHandler--
 432  *      Delete event handler matching arguments from windows
 433  * event handler list.
 434  *
 435  */
 436 void
 437 WMDeleteEventHandler(WMView *view, unsigned long mask, WMEventProc *eventProc,
 438                      void *clientData)
 439 {
 440     W_EventHandler *handler, *ptr, *pptr;
 441
 442     ptr = view->handlerList;
 443
 444     handler = NULL;
 445     pptr = NULL;
 446
 447     while (ptr!=NULL) {
 448         if (ptr->eventMask == mask && ptr->proc == eventProc
 449             && ptr->clientData == clientData) {
 450             handler = ptr;
 451             break;
 452         }
 453         pptr = ptr;
 454         ptr = ptr->nextHandler;
 455     }
 456
 457     if (!handler)
 458         return;
 459
 460     if (!pptr) {
 461         view->handlerList = handler->nextHandler;
 462     } else {
 463         pptr->nextHandler = handler->nextHandler;
 464     }
 465     free(handler);
 466 }
 467
 468
 469
 470 void
 471 W_CleanUpEvents(WMView *view)
 472 {
 473     W_EventHandler *ptr, *nptr;
 474
 475     ptr = view->handlerList;
 476
 477     while (ptr!=NULL) {
 478         nptr = ptr->nextHandler;
 479         free(ptr);
 480         ptr = nptr;
 481     }
 482 }
 483
 484
 485
 486 static Time
 487 getEventTime(WMScreen *screen, XEvent *event)
 488 {
 489     switch (event->type) {
 490      case ButtonPress:
 491      case ButtonRelease:
 492         return event->xbutton.time;
 493      case KeyPress:
 494      case KeyRelease:
 495         return event->xkey.time;
 496      case MotionNotify:
 497         return event->xmotion.time;
 498      case EnterNotify:
 499      case LeaveNotify:
 500         return event->xcrossing.time;
 501      case PropertyNotify:
 502         return event->xproperty.time;
 503      case SelectionClear:
 504         return event->xselectionclear.time;
 505      case SelectionRequest:
 506         return event->xselectionrequest.time;
 507      case SelectionNotify:
 508         return event->xselection.time;
 509      default:
 510         return screen->lastEventTime;
 511     }
 512 }
 513
 514
 515 void
 516 W_CallDestroyHandlers(W_View *view)
 517 {
 518     XEvent event;
 519     W_EventHandler *hPtr;
 520
 521     event.type = DestroyNotify;
 522     event.xdestroywindow.window = view->window;
 523     event.xdestroywindow.event = view->window;
 524     hPtr = view->handlerList;
 525     while (hPtr!=NULL) {
 526         if (hPtr->eventMask & StructureNotifyMask) {
 527             (*hPtr->proc)(&event, hPtr->clientData);
 528         }
 529
 530         hPtr = hPtr->nextHandler;
 531     }
 532 }
 533
 534
 535 int
 536 WMHandleEvent(XEvent *event)
 537 {
 538     W_EventHandler *hPtr;
 539     W_View *view, *vPtr, *toplevel;
 540     unsigned long mask;
 541     Window window;
 542
 543     if (event->type == MappingNotify) {
 544         XRefreshKeyboardMapping(&event->xmapping);
 545         return True;
 546     }
 547
 548     mask = eventMasks[event->xany.type];
 549
 550     window = event->xany.window;
 551
 552     /* diferentiate SubstructureNotify with StructureNotify */
 553     if (mask == StructureNotifyMask) {
 554         if (event->xmap.event != event->xmap.window) {
 555             mask = SubstructureNotifyMask;
 556             window = event->xmap.event;
 557         }
 558     }
 559     view = W_GetViewForXWindow(event->xany.display, window);
 560     if (!view) {
 561         if (extraEventHandler)
 562             (extraEventHandler)(event);
 563
 564         return False;
 565     }
 566
 567     view->screen->lastEventTime = getEventTime(view->screen, event);
 568
 569     toplevel = W_TopLevelOfView(view);
 570
 571     /* if it's a key event, redispatch it to the focused control */
 572     if (mask & (KeyPressMask|KeyReleaseMask)) {
 573         W_View *focused = W_FocusedViewOfToplevel(toplevel);
 574
 575         if (focused) {
 576             view = focused;
 577         }
 578     }
 579
 580     /* compress Motion events */
 581     if (event->type == MotionNotify && !view->flags.dontCompressMotion) {
 582         while (XPending(event->xmotion.display)) {
 583             XEvent ev;
 584             XPeekEvent(event->xmotion.display, &ev);
 585             if (ev.type == MotionNotify
 586                 && event->xmotion.window == ev.xmotion.window
 587                 && event->xmotion.subwindow == ev.xmotion.subwindow) {
 588                 /* replace events */
 589                 XNextEvent(event->xmotion.display, event);
 590             } else break;
 591         }
 592     }
 593
 594     /* compress expose events */
 595     if (event->type == Expose && !view->flags.dontCompressExpose) {
 596         while (XCheckTypedWindowEvent(event->xexpose.display, view->window,
 597                                       Expose, event));
 598     }
 599
 600
 601     if (view->screen->modal && toplevel!=view->screen->modalView
 602         && !toplevel->flags.worksWhenModal) {
 603         if (event->type == KeyPress || event->type == KeyRelease
 604             || event->type == MotionNotify || event->type == ButtonPress
 605             || event->type == ButtonRelease
 606             || event->type == FocusIn || event->type == FocusOut) {
 607             return True;
 608         }
 609     }
 610
 611     /* This is a hack. It will make the panel be secure while
 612      * the event handlers are handled, as some event handler
 613      * might destroy the widget. */
 614     W_RetainView(toplevel);
 615
 616     hPtr = view->handlerList;
 617
 618     while (hPtr!=NULL) {
 619         W_EventHandler *tmp;
 620
 621         tmp = hPtr->nextHandler;
 622
 623         if ((hPtr->eventMask & mask)) {
 624             (*hPtr->proc)(event, hPtr->clientData);
 625         }
 626
 627         hPtr = tmp;
 628     }
 629
 630     /* pass the event to the top level window of the widget */
 631     if (view->parent!=NULL) {
 632         vPtr = view;
 633         while (vPtr->parent!=NULL)
 634             vPtr = vPtr->parent;
 635
 636         hPtr = vPtr->handlerList;
 637
 638         while (hPtr!=NULL) {
 639
 640             if (hPtr->eventMask & mask) {
 641                 (*hPtr->proc)(event, hPtr->clientData);
 642             }
 643             hPtr = hPtr->nextHandler;
 644         }
 645     }
 646
 647     /* save button click info to track double-clicks */
 648     if (view->screen->ignoreNextDoubleClick) {
 649         view->screen->ignoreNextDoubleClick = 0;
 650     } else {
 651         if (event->type == ButtonPress) {
 652             view->screen->lastClickWindow = event->xbutton.window;
 653             view->screen->lastClickTime = event->xbutton.time;
 654         }
 655     }
 656
 657     W_ReleaseView(toplevel);
 658
 659     return True;
 660 }
 661
 662
 663 int
 664 WMIsDoubleClick(XEvent *event)
 665 {
 666     W_View *view;
 667
 668     if (event->type != ButtonPress)
 669         return False;
 670
 671     view = W_GetViewForXWindow(event->xany.display, event->xbutton.window);
 672
 673     if (!view)
 674         return False;
 675
 676     if (view->screen->lastClickWindow != event->xbutton.window)
 677         return False;
 678
 679     if (event->xbutton.time - view->screen->lastClickTime
 680         < WINGsConfiguration.doubleClickDelay) {
 681         view->screen->lastClickTime = 0;
 682         view->screen->lastClickWindow = None;
 683         view->screen->ignoreNextDoubleClick = 1;
 684         return True;
 685     } else
 686         return False;
 687 }
 688
 689
 690 Bool
 691 W_WaitForEvent(Display *dpy, unsigned long xeventmask)
 692 {
 693 #ifndef HAVE_SELECT
 694 #error This_system_does_not_have_select(2)_and_is_not_supported
 695 #endif
 696     unsigned long milliseconds;
 697     struct timeval timeout;
 698     struct timeval *timeoutPtr;
 699     fd_set rset, wset, eset;
 700     int maxfd;
 701     int count;
 702     InputHandler *handler = inputHandler;
 703
 704     FD_ZERO(&rset);
 705     FD_ZERO(&wset);
 706     FD_ZERO(&eset);
 707
 708     FD_SET(ConnectionNumber(dpy), &rset);
 709     maxfd = ConnectionNumber(dpy);
 710
 711     while (handler) {
 712         if (handler->mask & WIReadMask)
 713             FD_SET(handler->fd, &rset);
 714
 715         if (handler->mask & WIWriteMask)
 716             FD_SET(handler->fd, &wset);
 717
 718         if (handler->mask & WIExceptMask)
 719             FD_SET(handler->fd, &eset);
 720
 721         if (maxfd < handler->fd)
 722             maxfd = handler->fd;
 723
 724         handler = handler->next;
 725     }
 726
 727
 728     /*
 729      * Setup the select() timeout to the estimated time until the
 730      * next timer expires.
 731      */
 732     if (timerPending()) {
 733         milliseconds = msToNextTimerEvent();
 734         timeout.tv_sec = milliseconds / 1000;
 735         timeout.tv_usec = (milliseconds % 1000) * 1000;
 736         timeoutPtr = &timeout;
 737     } else {
 738         timeoutPtr = (struct timeval*)0;
 739     }
 740
 741     XSync(dpy, False);
 742     if (xeventmask==0) {
 743         if (XPending(dpy))
 744             return True;
 745     } else {
 746         XEvent ev;
 747         if (XCheckMaskEvent(dpy, xeventmask, &ev)) {
 748             XPutBackEvent(dpy, &ev);
 749             return True;
 750         }
 751     }
 752     /* TODO: port to poll() */
 753     count = select(1 + maxfd, &rset, &wset, &eset, timeoutPtr);
 754
 755     if (count > 0) {
 756         handler = inputHandler;
 757
 758         while (handler) {
 759             int mask;
 760
 761             mask = 0;
 762
 763             if (FD_ISSET(handler->fd, &rset))
 764                 mask |= WIReadMask;
 765
 766             if (FD_ISSET(handler->fd, &wset))
 767                 mask |= WIWriteMask;
 768
 769             if (FD_ISSET(handler->fd, &eset))
 770                 mask |= WIExceptMask;
 771
 772             if (mask!=0 && handler->callback) {
 773                 (*handler->callback)(handler->fd, mask,
 774                                      handler->clientData);
 775             }
 776
 777             handler = handler->next;
 778         }
 779     }
 780
 781     return FD_ISSET(ConnectionNumber(dpy), &rset);
 782 }
 783
 784
 785
 786 void
 787 WMNextEvent(Display *dpy, XEvent *event)
 788 {
 789     /* Check any expired timers */
 790     if (timerPending()) {
 791         checkTimerHandlers();
 792     }
 793
 794     while (XPending(dpy) == 0) {
 795         /* Do idle stuff */
 796         /* Do idle and timer stuff while there are no timer or X events */
 797         while (!XPending(dpy) && idlePending()) {
 798             if (idlePending())
 799                 checkIdleHandlers();
 800             /* dispatch timer events */
 801             if (timerPending())
 802                 checkTimerHandlers();
 803         }
 804
 805         /*
 806          * Make sure that new events did not arrive while we were doing
 807          * timer/idle stuff. Or we might block forever waiting for
 808          * an event that already arrived.
 809          */
 810         /* wait to something happen */
 811         W_WaitForEvent(dpy, 0);
 812
 813         /* Check any expired timers */
 814         if (timerPending()) {
 815             checkTimerHandlers();
 816         }
 817     }
 818
 819     XNextEvent(dpy, event);
 820 }
 821
 822 #if 0
 823 void
 824 WMMaskEvent(Display *dpy, long mask, XEvent *event)
 825 {
 826     unsigned long milliseconds;
 827     struct timeval timeout;
 828     struct timeval *timeoutOrInfty;
 829     fd_set readset;
 830
 831     while (!XCheckMaskEvent(dpy, mask, event)) {
 832         /* Do idle stuff while there are no timer or X events */
 833         while (idlePending()) {
 834             checkIdleHandlers();
 835             if (XCheckMaskEvent(dpy, mask, event))
 836                 return;
 837         }
 838
 839         /*
 840          * Setup the select() timeout to the estimated time until the
 841          * next timer expires.
 842          */
 843         if (timerPending()) {
 844             milliseconds = msToNextTimerEvent();
 845             timeout.tv_sec = milliseconds / 1000;
 846             timeout.tv_usec = (milliseconds % 1000) * 1000;
 847             timeoutOrInfty = &timeout;
 848         } else {
 849             timeoutOrInfty = (struct timeval*)0;
 850         }
 851
 852         if (XCheckMaskEvent(dpy, mask, event))
 853             return;
 854
 855         /* Wait for input on the X connection socket */
 856         FD_ZERO(&readset);
 857         FD_SET(ConnectionNumber(dpy), &readset);
 858         select(1 + ConnectionNumber(dpy), &readset, (fd_set*)0, (fd_set*)0,
 859                timeoutOrInfty);
 860
 861         /* Check any expired timers */
 862         if (timerPending()) {
 863             checkTimerHandlers();
 864         }
 865     }
 866 }
 867 #endif
 868 #if 1
 869 /*
 870  * Cant use this because XPending() will make W_WaitForEvent
 871  * return even if the event in the queue is not what we want,
 872  * and if we block until some new event arrives from the
 873  * server, other events already in the queue (like Expose)
 874  * will be deferred.
 875  */
 876 void
 877 WMMaskEvent(Display *dpy, long mask, XEvent *event)
 878 {
 879     while (!XCheckMaskEvent(dpy, mask, event)) {
 880         /* Do idle stuff while there are no timer or X events */
 881         while (idlePending()) {
 882             checkIdleHandlers();
 883             if (XCheckMaskEvent(dpy, mask, event))
 884                 return;
 885         }
 886
 887         /* Wait for input on the X connection socket */
 888         W_WaitForEvent(dpy, mask);
 889
 890         /* Check any expired timers */
 891         if (timerPending()) {
 892             checkTimerHandlers();
 893         }
 894     }
 895 }
 896 #endif
 897
 898 Bool
 899 WMScreenPending(WMScreen *scr)
 900 {
 901     if (XPending(scr->display))
 902         return True;
 903     else
 904         return False;
 905 }
 906
 907
 908 WMEventHook*
 909 WMHookEventHandler(WMEventHook *handler)
 910 {
 911     WMEventHook *oldHandler = extraEventHandler;
 912
 913     extraEventHandler = handler;
 914
 915     return oldHandler;
 916 }
 917
 918