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