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