WINGs/wevent.c

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