WINGs/handlers.c

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