WINGs/wutil.c

   1
   2
   3 /*
   4  * This event handling stuff was based on Tk.
   5  * adapted from wevent.c
   6  */
   7
   8 #include "WINGsP.h"
   9
  10 #include "../src/config.h"
  11
  12 #include <sys/types.h>
  13 #include <unistd.h>
  14
  15 #ifdef HAVE_POLL_H
  16 #include <poll.h>
  17 #endif
  18
  19
  20 #include <X11/Xos.h>
  21
  22 #ifdef HAVE_SYS_SELECT_H
  23 # include <sys/select.h>
  24 #endif
  25
  26 #include <time.h>
  27
  28 #ifndef X_GETTIMEOFDAY
  29 #define X_GETTIMEOFDAY(t) gettimeofday(t, (struct timezone*)0)
  30 #endif
  31
  32
  33
  34
  35 typedef struct TimerHandler {
  36     WMCallback          *callback;             /* procedure to call */
  37     struct timeval      when;                  /* when to call the callback */
  38     void                *clientData;
  39     struct TimerHandler *next;
  40 } TimerHandler;
  41
  42
  43 typedef struct IdleHandler {
  44     WMCallback          *callback;
  45     void                *clientData;
  46 } IdleHandler;
  47
  48
  49 typedef struct InputHandler {
  50     WMInputProc         *callback;
  51     void                *clientData;
  52     int                 fd;
  53     int                 mask;
  54 } InputHandler;
  55
  56
  57 /* queue of timer event handlers */
  58 static TimerHandler *timerHandler=NULL;
  59
  60 static WMBag *idleHandler=NULL;
  61
  62 static WMBag *inputHandler=NULL;
  63
  64
  65
  66 #define timerPending()  (timerHandler)
  67
  68
  69 static void
  70 rightNow(struct timeval *tv) {
  71     X_GETTIMEOFDAY(tv);
  72 }
  73
  74 /* is t1 after t2 ? */
  75 #define IS_AFTER(t1, t2)        (((t1).tv_sec > (t2).tv_sec) || \
  76                                  (((t1).tv_sec == (t2).tv_sec) \
  77                                   && ((t1).tv_usec > (t2).tv_usec)))
  78
  79
  80 static void
  81 addmillisecs(struct timeval *tv, int milliseconds)
  82 {
  83     tv->tv_usec += milliseconds*1000;
  84
  85     tv->tv_sec += tv->tv_usec/1000000;
  86     tv->tv_usec = tv->tv_usec%1000000;
  87 }
  88
  89
  90 WMHandlerID
  91 WMAddTimerHandler(int milliseconds, WMCallback *callback, void *cdata)
  92 {
  93     TimerHandler *handler, *tmp;
  94
  95     handler = malloc(sizeof(TimerHandler));
  96     if (!handler)
  97       return NULL;
  98
  99     rightNow(&handler->when);
 100     addmillisecs(&handler->when, milliseconds);
 101     handler->callback = callback;
 102     handler->clientData = cdata;
 103     /* insert callback in queue, sorted by time left */
 104     if (!timerHandler || !IS_AFTER(handler->when, timerHandler->when)) {
 105         /* first in the queue */
 106         handler->next = timerHandler;
 107         timerHandler = handler;
 108     } else {
 109         tmp = timerHandler;
 110         while (tmp->next && IS_AFTER(handler->when, tmp->next->when)) {
 111             tmp = tmp->next;
 112         }
 113         handler->next = tmp->next;
 114         tmp->next = handler;
 115     }
 116     return handler;
 117 }
 118
 119
 120
 121 void
 122 WMDeleteTimerWithClientData(void *cdata)
 123 {
 124     TimerHandler *handler, *tmp;
 125
 126     if (!cdata || !timerHandler)
 127         return;
 128
 129     tmp = timerHandler;
 130     if (tmp->clientData==cdata) {
 131         timerHandler = tmp->next;
 132         wfree(tmp);
 133     } else {
 134         while (tmp->next) {
 135             if (tmp->next->clientData==cdata) {
 136                 handler = tmp->next;
 137                 tmp->next = handler->next;
 138                 wfree(handler);
 139                 break;
 140             }
 141             tmp = tmp->next;
 142         }
 143     }
 144 }
 145
 146
 147
 148 void
 149 WMDeleteTimerHandler(WMHandlerID handlerID)
 150 {
 151     TimerHandler *tmp, *handler=(TimerHandler*)handlerID;
 152
 153     if (!handler || !timerHandler)
 154       return;
 155
 156     tmp = timerHandler;
 157     if (tmp==handler) {
 158         timerHandler = handler->next;
 159         wfree(handler);
 160     } else {
 161         while (tmp->next) {
 162             if (tmp->next==handler) {
 163                 tmp->next=handler->next;
 164                 wfree(handler);
 165                 break;
 166             }
 167             tmp = tmp->next;
 168         }
 169     }
 170 }
 171
 172
 173
 174 WMHandlerID
 175 WMAddIdleHandler(WMCallback *callback, void *cdata)
 176 {
 177     IdleHandler *handler;
 178
 179     handler = malloc(sizeof(IdleHandler));
 180     if (!handler)
 181         return NULL;
 182
 183     handler->callback = callback;
 184     handler->clientData = cdata;
 185     /* add handler at end of queue */
 186     if (!idleHandler) {
 187         idleHandler = WMCreateBag(16);
 188     }
 189     WMPutInBag(idleHandler, handler);
 190
 191     return handler;
 192 }
 193
 194
 195
 196 void
 197 WMDeleteIdleHandler(WMHandlerID handlerID)
 198 {
 199     IdleHandler *handler = (IdleHandler*)handlerID;
 200     int pos;
 201
 202     if (!handler || !idleHandler)
 203         return;
 204
 205     pos = WMGetFirstInBag(idleHandler, handler);
 206     if (pos >= 0) {
 207         wfree(handler);
 208         WMDeleteFromBag(idleHandler, pos);
 209     }
 210 }
 211
 212
 213
 214 WMHandlerID
 215 WMAddInputHandler(int fd, int condition, WMInputProc *proc, void *clientData)
 216 {
 217     InputHandler *handler;
 218
 219     handler = wmalloc(sizeof(InputHandler));
 220
 221     handler->fd = fd;
 222     handler->mask = condition;
 223     handler->callback = proc;
 224     handler->clientData = clientData;
 225
 226     if (!inputHandler)
 227         inputHandler = WMCreateBag(16);
 228     WMPutInBag(inputHandler, handler);
 229
 230     return handler;
 231 }
 232
 233
 234
 235 void
 236 WMDeleteInputHandler(WMHandlerID handlerID)
 237 {
 238     InputHandler *handler = (InputHandler*)handlerID;
 239     int pos;
 240
 241     if (!handler || !inputHandler)
 242         return;
 243
 244     pos = WMGetFirstInBag(inputHandler, handler);
 245     if (pos >= 0) {
 246         wfree(handler);
 247         WMDeleteFromBag(inputHandler, pos);
 248     }
 249 }
 250
 251
 252
 253 static Bool
 254 checkIdleHandlers()
 255 {
 256     IdleHandler *handler;
 257     WMBag *handlerCopy;
 258     int i, n;
 259
 260     if (!idleHandler || WMGetBagItemCount(idleHandler)==0) {
 261         W_FlushIdleNotificationQueue();
 262         /* make sure an observer in queue didn't added an idle handler */
 263         return (idleHandler!=NULL && WMGetBagItemCount(idleHandler)>0);
 264     }
 265
 266     n = WMGetBagItemCount(idleHandler);
 267     handlerCopy = WMCreateBag(n);
 268     for (i=0; i<n; i++)
 269         WMPutInBag(handlerCopy, WMGetFromBag(idleHandler, i));
 270
 271     for (i=0; i<n; i++) {
 272         handler = WMGetFromBag(handlerCopy, i);
 273         /* check if the handler still exist or was removed by a callback */
 274         if (WMGetFirstInBag(idleHandler, handler)<0)
 275             continue;
 276
 277         (*handler->callback)(handler->clientData);
 278         WMDeleteIdleHandler(handler);
 279         wfree(handler);
 280     }
 281
 282     WMFreeBag(handlerCopy);
 283
 284     W_FlushIdleNotificationQueue();
 285
 286     /* this is not necesarrily False, because one handler can re-add itself */
 287     return (WMGetBagItemCount(idleHandler)>0);
 288 }
 289
 290
 291
 292 static void
 293 checkTimerHandlers()
 294 {
 295     TimerHandler *handler;
 296     struct timeval now;
 297
 298     if (!timerHandler) {
 299         W_FlushASAPNotificationQueue();
 300         return;
 301     }
 302
 303     rightNow(&now);
 304
 305     while (timerHandler && IS_AFTER(now, timerHandler->when)) {
 306         handler = timerHandler;
 307         timerHandler = timerHandler->next;
 308         handler->next = NULL;
 309         (*handler->callback)(handler->clientData);
 310         wfree(handler);
 311     }
 312
 313     W_FlushASAPNotificationQueue();
 314 }
 315
 316
 317
 318 static void
 319 delayUntilNextTimerEvent(struct timeval *delay)
 320 {
 321     struct timeval now;
 322
 323     if (!timerHandler) {
 324         /* The return value of this function is only valid if there _are_
 325          * active timers. */
 326         delay->tv_sec = 0;
 327         delay->tv_usec = 0;
 328         return;
 329     }
 330
 331     rightNow(&now);
 332     if (IS_AFTER(now, timerHandler->when)) {
 333         delay->tv_sec = 0;
 334         delay->tv_usec = 0;
 335     } else {
 336         delay->tv_sec = timerHandler->when.tv_sec - now.tv_sec;
 337         delay->tv_usec = timerHandler->when.tv_usec - now.tv_usec;
 338         if (delay->tv_usec < 0) {
 339             delay->tv_usec += 1000000;
 340             delay->tv_sec--;
 341         }
 342     }
 343 }
 344
 345
 346 /*
 347  * This functions will handle input events on all registered file descriptors.
 348  * Input:
 349  *    - waitForInput - True if we want the function to wait until an event
 350  *                     appears on a file descriptor we watch, False if we
 351  *                     want the function to immediately return if there is
 352  *                     no data available on the file descriptors we watch.
 353  * Output:
 354  *    if waitForInput is False, the function will return False if there are no
 355  *                     input handlers registered, or if there is no data
 356  *                     available on the registered ones, and will return True
 357  *                     if there is at least one input handler that has data
 358  *                     available.
 359  *    if waitForInput is True, the function will return False if there are no
 360  *                     input handlers registered, else it will block until an
 361  *                     event appears on one of the file descriptors it watches
 362  *                     and then it will return True.
 363  *
 364  * If the retured value is True, the input handlers for the corresponding file
 365  * descriptors are also called.
 366  *
 367  */
 368 static Bool
 369 handleInputEvents(Bool waitForInput)
 370 {
 371 #if defined(HAVE_POLL) && defined(HAVE_POLL_H) && !defined(HAVE_SELECT)
 372     struct pollfd *fds;
 373     InputHandler *handler;
 374     int count, timeout, nfds, i;
 375
 376     if (!inputHandler || (nfds=WMGetBagItemCount(inputHandler))==0) {
 377         W_FlushASAPNotificationQueue();
 378         return False;
 379     }
 380
 381     fds = wmalloc(nfds * sizeof(struct pollfd));
 382
 383     for (i = 0; i<nfds; i++) {
 384         handler = WMGetFromBag(inputHandler, i);
 385         fds[i].fd = handler->fd;
 386         fds[i].events = 0;
 387         if (handler->mask & WIReadMask)
 388             fds[i].events |= POLLIN;
 389
 390         if (handler->mask & WIWriteMask)
 391             fds[i].events |= POLLOUT;
 392
 393 #if 0 /* FIXME */
 394         if (handler->mask & WIExceptMask)
 395             FD_SET(handler->fd, &eset);
 396 #endif
 397     }
 398
 399     /*
 400      * If we don't wait for input, set timeout to return immediately,
 401      * else setup the timeout to the estimated time until the
 402      * next timer expires or if no timer is pending to infinite.
 403      */
 404     if (!waitForInput) {
 405         timeout = 0;
 406     } else if (timerPending()) {
 407         struct timeval tv;
 408         delayUntilNextTimerEvent(&tv);
 409         timeout = tv.tv_sec * 1000 + tv.tv_usec / 1000;
 410     } else {
 411         timeout = -1;
 412     }
 413
 414     count = poll(fds, nfds, timeout);
 415
 416     if (count > 0) {
 417         WMBag *handlerCopy = WMCreateBag(nfds);
 418
 419         for (i=0; i<nfds, i++)
 420             WMPutInBag(handlerCopy, WMGetFromBag(inputHandler, i));
 421
 422         for (i=0; i<nfds; i++) {
 423             int mask;
 424
 425             handler = WMGetFromBag(handlerCopy, i);
 426             /* check if the handler still exist or was removed by a callback */
 427             if (WMGetFirstInBag(inputHandler, handler)<0)
 428                 continue;
 429
 430             mask = 0;
 431
 432             if ((handler->mask & WIReadMask) &&
 433                 (fds[i].revents & (POLLIN|POLLRDNORM|POLLRDBAND|POLLPRI)))
 434                 mask |= WIReadMask;
 435
 436             if ((handler->mask & WIWriteMask) &&
 437                 (fds[i].revents & (POLLOUT | POLLWRBAND)))
 438                 mask |= WIWriteMask;
 439
 440             if ((handler->mask & WIExceptMask) &&
 441                 (fds[i].revents & (POLLHUP | POLLNVAL | POLLERR)))
 442                 mask |= WIExceptMask;
 443
 444             if (mask!=0 && handler->callback) {
 445                 (*handler->callback)(handler->fd, mask,
 446                                      handler->clientData);
 447             }
 448         }
 449
 450         WMFreeBag(handlerCopy);
 451     }
 452
 453     wfree(fds);
 454
 455     W_FlushASAPNotificationQueue();
 456
 457     return (count > 0);
 458 #else /* not HAVE_POLL */
 459 #ifdef HAVE_SELECT
 460     struct timeval timeout;
 461     struct timeval *timeoutPtr;
 462     fd_set rset, wset, eset;
 463     int maxfd, nfds, i;
 464     int count;
 465     InputHandler *handler;
 466
 467     if (!inputHandler || (nfds=WMGetBagItemCount(inputHandler))==0) {
 468         W_FlushASAPNotificationQueue();
 469         return False;
 470     }
 471
 472     FD_ZERO(&rset);
 473     FD_ZERO(&wset);
 474     FD_ZERO(&eset);
 475
 476     maxfd = 0;
 477
 478     for (i=0; i<nfds; i++) {
 479         handler = WMGetFromBag(inputHandler, i);
 480         if (handler->mask & WIReadMask)
 481             FD_SET(handler->fd, &rset);
 482
 483         if (handler->mask & WIWriteMask)
 484             FD_SET(handler->fd, &wset);
 485
 486         if (handler->mask & WIExceptMask)
 487             FD_SET(handler->fd, &eset);
 488
 489         if (maxfd < handler->fd)
 490             maxfd = handler->fd;
 491     }
 492
 493     /*
 494      * If we don't wait for input, set timeout to return immediately,
 495      * else setup the timeout to the estimated time until the
 496      * next timer expires or if no timer is pending to infinite.
 497      */
 498     if (!waitForInput) {
 499         timeout.tv_sec = 0;
 500         timeout.tv_usec = 0;
 501         timeoutPtr = &timeout;
 502     } else if (timerPending()) {
 503         delayUntilNextTimerEvent(&timeout);
 504         timeoutPtr = &timeout;
 505     } else {
 506         timeoutPtr = (struct timeval*)0;
 507     }
 508
 509     count = select(1 + maxfd, &rset, &wset, &eset, timeoutPtr);
 510
 511     if (count > 0) {
 512         WMBag *handlerCopy = WMCreateBag(nfds);
 513
 514         for (i=0; i<nfds; i++)
 515             WMPutInBag(handlerCopy, WMGetFromBag(inputHandler, i));
 516
 517         for (i=0; i<nfds; i++) {
 518             int mask;
 519
 520             handler = WMGetFromBag(handlerCopy, i);
 521             /* check if the handler still exist or was removed by a callback */
 522             if (WMGetFirstInBag(inputHandler, handler)<0)
 523                 continue;
 524
 525             mask = 0;
 526
 527             if ((handler->mask & WIReadMask) && FD_ISSET(handler->fd, &rset))
 528                 mask |= WIReadMask;
 529
 530             if ((handler->mask & WIWriteMask) && FD_ISSET(handler->fd, &wset))
 531                 mask |= WIWriteMask;
 532
 533             if ((handler->mask & WIExceptMask) && FD_ISSET(handler->fd, &eset))
 534                 mask |= WIExceptMask;
 535
 536             if (mask!=0 && handler->callback) {
 537                 (*handler->callback)(handler->fd, mask,
 538                                      handler->clientData);
 539             }
 540         }
 541
 542         WMFreeBag(handlerCopy);
 543     }
 544
 545     W_FlushASAPNotificationQueue();
 546
 547     return (count > 0);
 548 #else /* not HAVE_SELECT, not HAVE_POLL */
 549 Neither select nor poll. You lose.
 550 #endif /* HAVE_SELECT */
 551 #endif /* HAVE_POLL */
 552 }
 553
 554
 555 void
 556 WHandleEvents()
 557 {
 558     /* Check any expired timers */
 559     checkTimerHandlers();
 560
 561     /* We need to make sure that we have some input handler before calling
 562      * checkIdleHandlers() in a while loop, because else the while loop
 563      * can run forever (if some idle handler reinitiates itself).
 564      */
 565     if (inputHandler && WMGetBagItemCount(inputHandler)>0) {
 566         /* Do idle and timer stuff while there are no input events */
 567         /* Check again if there are still input handlers, because some idle
 568          * handler could have removed them */
 569         while (checkIdleHandlers() && WMGetBagItemCount(inputHandler)>0 &&
 570                !handleInputEvents(False)) {
 571             /* dispatch timer events */
 572             checkTimerHandlers();
 573         }
 574     } else {
 575         checkIdleHandlers();
 576         /* dispatch timer events */
 577         checkTimerHandlers();
 578     }
 579
 580     handleInputEvents(True);
 581
 582     /* Check any expired timers */
 583     checkTimerHandlers();
 584 }
 585
 586