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