WINGs/notification.c

   1
   2 #include <stdlib.h>
   3 #include <assert.h>
   4 #include <stdio.h>
   5 #include <string.h>
   6
   7 #include "WUtil.h"
   8
   9
  10 typedef struct W_Notification {
  11     char *name;
  12     void *object;
  13     void *clientData;
  14     int refCount;
  15 } Notification;
  16
  17
  18 extern void W_FlushASAPNotificationQueue();
  19
  20
  21 char*
  22 WMGetNotificationName(WMNotification *notification)
  23 {
  24     return notification->name;
  25 }
  26
  27
  28 void*
  29 WMGetNotificationObject(WMNotification *notification)
  30 {
  31     return notification->object;
  32 }
  33
  34
  35 void*
  36 WMGetNotificationClientData(WMNotification *notification)
  37 {
  38     return notification->clientData;
  39 }
  40
  41
  42 WMNotification*
  43 WMCreateNotification(char *name, void *object, void *clientData)
  44 {
  45     Notification *nPtr;
  46
  47     nPtr = wmalloc(sizeof(Notification));
  48
  49     nPtr->name = name;
  50     nPtr->object = object;
  51     nPtr->clientData = clientData;
  52
  53     nPtr->refCount = 1;
  54
  55     return nPtr;
  56 }
  57
  58
  59 void
  60 WMReleaseNotification(WMNotification *notification)
  61 {
  62     notification->refCount--;
  63
  64     if (notification->refCount < 1) {
  65         wfree(notification);
  66     }
  67 }
  68
  69
  70 WMNotification*
  71 WMRetainNotification(WMNotification *notification)
  72 {
  73     notification->refCount++;
  74
  75     return notification;
  76 }
  77
  78
  79 /***************** Notification Center *****************/
  80
  81 typedef struct NotificationObserver {
  82     WMNotificationObserverAction *observerAction;
  83     void *observer;
  84
  85     char *name;
  86     void *object;
  87
  88     struct NotificationObserver *prev; /* for tables */
  89     struct NotificationObserver *next;
  90     struct NotificationObserver *nextAction;   /* for observerTable */
  91 } NotificationObserver;
  92
  93
  94 typedef struct W_NotificationCenter {
  95     WMHashTable *nameTable;            /* names -> observer lists */
  96     WMHashTable *objectTable;          /* object -> observer lists */
  97     NotificationObserver *nilList;     /* obervers that catch everything */
  98
  99     WMHashTable *observerTable;        /* observer -> NotificationObserver */
 100 } NotificationCenter;
 101
 102
 103 /* default (and only) center */
 104 static NotificationCenter *notificationCenter = NULL;
 105
 106
 107 void
 108 W_InitNotificationCenter(void)
 109 {
 110     notificationCenter = wmalloc(sizeof(NotificationCenter));
 111
 112     notificationCenter->nameTable = WMCreateHashTable(WMStringPointerHashCallbacks);
 113     notificationCenter->objectTable = WMCreateHashTable(WMIntHashCallbacks);
 114     notificationCenter->nilList = NULL;
 115
 116     notificationCenter->observerTable = WMCreateHashTable(WMIntHashCallbacks);
 117 }
 118
 119
 120 void
 121 WMAddNotificationObserver(WMNotificationObserverAction *observerAction,
 122                           void *observer, char *name, void *object)
 123 {
 124     NotificationObserver *oRec, *rec;
 125
 126     oRec = wmalloc(sizeof(NotificationObserver));
 127     oRec->observerAction = observerAction;
 128     oRec->observer = observer;
 129     oRec->name = name;
 130     oRec->object = object;
 131     oRec->next = NULL;
 132     oRec->prev = NULL;
 133
 134
 135     /* put this action in the list of actions for this observer */
 136     rec = WMHashInsert(notificationCenter->observerTable, observer, oRec);
 137
 138     if (rec) {
 139         /* if this is not the first action for the observer */
 140         oRec->nextAction = rec;
 141     } else {
 142         oRec->nextAction = NULL;
 143     }
 144
 145     if (!name && !object) {
 146         /* catch-all */
 147         oRec->next = notificationCenter->nilList;
 148         if (notificationCenter->nilList) {
 149             notificationCenter->nilList->prev = oRec;
 150         }
 151         notificationCenter->nilList = oRec;
 152     } else if (!name) {
 153         /* any message coming from object */
 154         rec = WMHashInsert(notificationCenter->objectTable, object, oRec);
 155         oRec->next = rec;
 156         if (rec) {
 157             rec->prev = oRec;
 158         }
 159     } else {
 160         /* name && (object || !object) */
 161         rec = WMHashInsert(notificationCenter->nameTable, name, oRec);
 162         oRec->next = rec;
 163         if (rec) {
 164             rec->prev = oRec;
 165         }
 166     }
 167 }
 168
 169
 170 void
 171 WMPostNotification(WMNotification *notification)
 172 {
 173     NotificationObserver *orec, *tmp;
 174
 175     WMRetainNotification(notification);
 176
 177     /* tell the observers that want to know about a particular message */
 178     orec = WMHashGet(notificationCenter->nameTable, notification->name);
 179
 180     while (orec) {
 181         tmp = orec->next;
 182
 183         if (!orec->object || !notification->object
 184             || orec->object == notification->object) {
 185             /* tell the observer */
 186             if (orec->observerAction) {
 187                 (*orec->observerAction)(orec->observer, notification);
 188             }
 189         }
 190
 191         orec = tmp;
 192     }
 193
 194     /* tell the observers that want to know about an object */
 195     orec = WMHashGet(notificationCenter->objectTable, notification->object);
 196
 197     while (orec) {
 198         tmp = orec->next;
 199
 200         /* tell the observer */
 201         if (orec->observerAction) {
 202             (*orec->observerAction)(orec->observer, notification);
 203         }
 204         orec = tmp;
 205     }
 206
 207     /* tell the catch all observers */
 208     orec = notificationCenter->nilList;
 209     while (orec) {
 210         tmp = orec->next;
 211
 212         /* tell the observer */
 213         if (orec->observerAction) {
 214             (*orec->observerAction)(orec->observer, notification);
 215         }
 216         orec = tmp;
 217     }
 218
 219     WMReleaseNotification(notification);
 220
 221     W_FlushASAPNotificationQueue();
 222 }
 223
 224
 225 void
 226 WMRemoveNotificationObserver(void *observer)
 227 {
 228     NotificationObserver *orec, *tmp, *rec;
 229
 230     /* get the list of actions the observer is doing */
 231     orec = WMHashGet(notificationCenter->observerTable, observer);
 232
 233     /*
 234      * FOREACH orec IN actionlist for observer
 235      * DO
 236      *   remove from respective lists/tables
 237      *   free
 238      * END
 239      */
 240     while (orec) {
 241         tmp = orec->nextAction;
 242
 243         if (!orec->name && !orec->object) {
 244             /* catch-all */
 245             if (notificationCenter->nilList==orec)
 246                 notificationCenter->nilList = orec->next;
 247         } else if (!orec->name) {
 248             /* any message coming from object */
 249             rec = WMHashGet(notificationCenter->objectTable, orec->object);
 250             if (rec==orec) {
 251                 /* replace table entry */
 252                 if (orec->next) {
 253                     WMHashInsert(notificationCenter->objectTable, orec->object,
 254                                  orec->next);
 255                 } else {
 256                     WMHashRemove(notificationCenter->objectTable, orec->object);
 257                 }
 258             }
 259         } else {
 260             /* name && (object || !object) */
 261             rec = WMHashGet(notificationCenter->nameTable, orec->name);
 262             if (rec==orec) {
 263                 /* replace table entry */
 264                 if (orec->next) {
 265                     WMHashInsert(notificationCenter->nameTable, orec->name,
 266                                  orec->next);
 267                 } else {
 268                     WMHashRemove(notificationCenter->nameTable, orec->name);
 269                 }
 270             }
 271         }
 272         if (orec->prev)
 273             orec->prev->next = orec->next;
 274         if (orec->next)
 275             orec->next->prev = orec->prev;
 276
 277         wfree(orec);
 278
 279         orec = tmp;
 280     }
 281
 282     WMHashRemove(notificationCenter->observerTable, observer);
 283 }
 284
 285
 286 void
 287 WMRemoveNotificationObserverWithName(void *observer, char *name, void *object)
 288 {
 289     NotificationObserver *orec, *tmp, *rec;
 290     NotificationObserver *newList = NULL;
 291
 292     /* get the list of actions the observer is doing */
 293     orec = WMHashGet(notificationCenter->observerTable, observer);
 294
 295     WMHashRemove(notificationCenter->observerTable, observer);
 296
 297     /* rebuild the list of actions for the observer */
 298
 299     while (orec) {
 300         tmp = orec->nextAction;
 301         if (orec->name == name && orec->object == object) {
 302             if (!name && !object) {
 303                 if (notificationCenter->nilList == orec)
 304                     notificationCenter->nilList = orec->next;
 305             } else if (!name) {
 306                 rec = WMHashGet(notificationCenter->objectTable, orec->object);
 307                 if (rec==orec) {
 308                     assert(rec->prev==NULL);
 309                     /* replace table entry */
 310                     if (orec->next) {
 311                         WMHashInsert(notificationCenter->objectTable,
 312                                      orec->object, orec->next);
 313                     } else {
 314                         WMHashRemove(notificationCenter->objectTable,
 315                                      orec->object);
 316                     }
 317                 }
 318             } else {
 319                 rec = WMHashGet(notificationCenter->nameTable, orec->name);
 320                 if (rec==orec) {
 321                     assert(rec->prev==NULL);
 322                     /* replace table entry */
 323                     if (orec->next) {
 324                         WMHashInsert(notificationCenter->nameTable,
 325                                      orec->name, orec->next);
 326                     } else {
 327                         WMHashRemove(notificationCenter->nameTable,
 328                                      orec->name);
 329                     }
 330                 }
 331             }
 332
 333             if (orec->prev)
 334                 orec->prev->next = orec->next;
 335             if (orec->next)
 336                 orec->next->prev = orec->prev;
 337             wfree(orec);
 338         } else {
 339             /* append this action in the new action list */
 340             orec->nextAction = NULL;
 341             if (!newList) {
 342                 newList = orec;
 343             } else {
 344                 NotificationObserver *p;
 345
 346                 p = newList;
 347                 while (p->nextAction) {
 348                     p = p->nextAction;
 349                 }
 350                 p->nextAction = orec;
 351             }
 352         }
 353         orec = tmp;
 354     }
 355
 356     /* reinsert the list to the table */
 357     if (newList) {
 358         WMHashInsert(notificationCenter->observerTable, observer, newList);
 359     }
 360 }
 361
 362
 363 void
 364 WMPostNotificationName(char *name, void *object, void *clientData)
 365 {
 366     WMNotification *notification;
 367
 368     notification = WMCreateNotification(name, object, clientData);
 369
 370     WMPostNotification(notification);
 371
 372     WMReleaseNotification(notification);
 373 }
 374
 375
 376
 377 /**************** Notification Queues ****************/
 378
 379
 380 typedef struct W_NotificationQueue {
 381     WMBag *asapQueue;
 382     WMBag *idleQueue;
 383
 384     struct W_NotificationQueue *next;
 385 } NotificationQueue;
 386
 387
 388 static WMNotificationQueue *notificationQueueList = NULL;
 389
 390 /* default queue */
 391 static WMNotificationQueue *notificationQueue = NULL;
 392
 393
 394 WMNotificationQueue*
 395 WMGetDefaultNotificationQueue(void)
 396 {
 397     if (!notificationQueue)
 398         notificationQueue = WMCreateNotificationQueue();
 399
 400     return notificationQueue;
 401 }
 402
 403
 404 WMNotificationQueue*
 405 WMCreateNotificationQueue(void)
 406 {
 407     NotificationQueue *queue;
 408
 409     queue = wmalloc(sizeof(NotificationQueue));
 410
 411     queue->asapQueue = WMCreateBag(8);
 412     queue->idleQueue = WMCreateBag(8);
 413     queue->next = notificationQueueList;
 414
 415     notificationQueueList = queue;
 416
 417     return queue;
 418 }
 419
 420
 421
 422 void
 423 WMEnqueueNotification(WMNotificationQueue *queue, WMNotification *notification,
 424                       WMPostingStyle postingStyle)
 425 {
 426     WMEnqueueCoalesceNotification(queue, notification, postingStyle,
 427                                   WNCOnName|WNCOnSender);
 428 }
 429
 430
 431
 432 void
 433 WMDequeueNotificationMatching(WMNotificationQueue *queue,
 434                               WMNotification *notification, unsigned mask)
 435 {
 436     int i;
 437     WMNotification *tmp;
 438
 439     if (mask & WNCOnName) {
 440         for (i = 0; i < WMGetBagItemCount(queue->asapQueue); i++) {
 441             tmp = WMGetFromBag(queue->asapQueue, i);
 442
 443             if (strcmp(notification->name, tmp->name) == 0) {
 444                 WMRemoveFromBag(queue->asapQueue, tmp);
 445                 WMReleaseNotification(tmp);
 446                 break;
 447             }
 448         }
 449         for (i = 0; i < WMGetBagItemCount(queue->idleQueue); i++) {
 450             tmp = WMGetFromBag(queue->idleQueue, i);
 451
 452             if (strcmp(notification->name, tmp->name) == 0) {
 453                 WMRemoveFromBag(queue->idleQueue, tmp);
 454                 WMReleaseNotification(tmp);
 455                 break;
 456             }
 457         }
 458     }
 459     if (mask & WNCOnSender) {
 460         for (i = 0; i < WMGetBagItemCount(queue->asapQueue); i++) {
 461             tmp = WMGetFromBag(queue->asapQueue, i);
 462
 463             if (notification->object == tmp->object) {
 464                 WMRemoveFromBag(queue->asapQueue, tmp);
 465                 WMReleaseNotification(tmp);
 466                 break;
 467             }
 468         }
 469         for (i = 0; i < WMGetBagItemCount(queue->idleQueue); i++) {
 470             tmp = WMGetFromBag(queue->idleQueue, i);
 471
 472             if (notification->object == tmp->object) {
 473                 WMRemoveFromBag(queue->idleQueue, tmp);
 474                 WMReleaseNotification(tmp);
 475                 break;
 476             }
 477         }
 478     }
 479 }
 480
 481
 482 void
 483 WMEnqueueCoalesceNotification(WMNotificationQueue *queue,
 484                               WMNotification *notification,
 485                               WMPostingStyle postingStyle,
 486                               unsigned coalesceMask)
 487 {
 488     if (coalesceMask != WNCNone)
 489         WMDequeueNotificationMatching(queue, notification, coalesceMask);
 490
 491     switch (postingStyle) {
 492      case WMPostNow:
 493         WMPostNotification(notification);
 494         break;
 495
 496      case WMPostASAP:
 497         WMPutInBag(queue->asapQueue, notification);
 498         break;
 499
 500      case WMPostWhenIdle:
 501         WMPutInBag(queue->idleQueue, notification);
 502         break;
 503     }
 504 }
 505
 506
 507 void
 508 W_FlushASAPNotificationQueue()
 509 {
 510     WMNotificationQueue *queue = notificationQueueList;
 511
 512     while (queue) {
 513         while (WMGetBagItemCount(queue->asapQueue)) {
 514             WMNotification *tmp = WMGetFromBag(queue->asapQueue, 0);
 515
 516             WMPostNotification(tmp);
 517             WMDeleteFromBag(queue->asapQueue, 0);
 518         }
 519
 520         queue = queue->next;
 521     }
 522 }
 523
 524
 525 void
 526 W_FlushIdleNotificationQueue()
 527 {
 528     WMNotificationQueue *queue = notificationQueueList;
 529
 530     while (queue) {
 531         while (WMGetBagItemCount(queue->idleQueue)) {
 532             WMNotification *tmp = WMGetFromBag(queue->idleQueue, 0);
 533
 534             WMPostNotification(tmp);
 535             WMDeleteFromBag(queue->idleQueue, 0);
 536         }
 537
 538         queue = queue->next;
 539     }
 540 }
 541