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
 222
 223 void
 224 WMRemoveNotificationObserver(void *observer)
 225 {
 226     NotificationObserver *orec, *tmp, *rec;
 227
 228     /* get the list of actions the observer is doing */
 229     orec = WMHashGet(notificationCenter->observerTable, observer);
 230
 231     /*
 232      * FOREACH orec IN actionlist for observer
 233      * DO
 234      *   remove from respective lists/tables
 235      *   free
 236      * END
 237      */
 238     while (orec) {
 239         tmp = orec->nextAction;
 240
 241         if (!orec->name && !orec->object) {
 242             /* catch-all */
 243             if (notificationCenter->nilList==orec)
 244                 notificationCenter->nilList = orec->next;
 245         } else if (!orec->name) {
 246             /* any message coming from object */
 247             rec = WMHashGet(notificationCenter->objectTable, orec->object);
 248             if (rec==orec) {
 249                 /* replace table entry */
 250                 if (orec->next) {
 251                     WMHashInsert(notificationCenter->objectTable, orec->object,
 252                                  orec->next);
 253                 } else {
 254                     WMHashRemove(notificationCenter->objectTable, orec->object);
 255                 }
 256             }
 257         } else {
 258             /* name && (object || !object) */
 259             rec = WMHashGet(notificationCenter->nameTable, orec->name);
 260             if (rec==orec) {
 261                 /* replace table entry */
 262                 if (orec->next) {
 263                     WMHashInsert(notificationCenter->nameTable, orec->name,
 264                                  orec->next);
 265                 } else {
 266                     WMHashRemove(notificationCenter->nameTable, orec->name);
 267                 }
 268             }
 269         }
 270         if (orec->prev)
 271             orec->prev->next = orec->next;
 272         if (orec->next)
 273             orec->next->prev = orec->prev;
 274
 275         wfree(orec);
 276
 277         orec = tmp;
 278     }
 279
 280     WMHashRemove(notificationCenter->observerTable, observer);
 281 }
 282
 283
 284 void
 285 WMRemoveNotificationObserverWithName(void *observer, char *name, void *object)
 286 {
 287     NotificationObserver *orec, *tmp, *rec;
 288     NotificationObserver *newList = NULL;
 289
 290     /* get the list of actions the observer is doing */
 291     orec = WMHashGet(notificationCenter->observerTable, observer);
 292
 293     WMHashRemove(notificationCenter->observerTable, observer);
 294
 295     /* rebuild the list of actions for the observer */
 296
 297     while (orec) {
 298         tmp = orec->nextAction;
 299         if (orec->name == name && orec->object == object) {
 300             if (!name && !object) {
 301                 if (notificationCenter->nilList == orec)
 302                     notificationCenter->nilList = orec->next;
 303             } else if (!name) {
 304                 rec = WMHashGet(notificationCenter->objectTable, orec->object);
 305                 if (rec==orec) {
 306                     assert(rec->prev==NULL);
 307                     /* replace table entry */
 308                     if (orec->next) {
 309                         WMHashInsert(notificationCenter->objectTable,
 310                                      orec->object, orec->next);
 311                     } else {
 312                         WMHashRemove(notificationCenter->objectTable,
 313                                      orec->object);
 314                     }
 315                 }
 316             } else {
 317                 rec = WMHashGet(notificationCenter->nameTable, orec->name);
 318                 if (rec==orec) {
 319                     assert(rec->prev==NULL);
 320                     /* replace table entry */
 321                     if (orec->next) {
 322                         WMHashInsert(notificationCenter->nameTable,
 323                                      orec->name, orec->next);
 324                     } else {
 325                         WMHashRemove(notificationCenter->nameTable,
 326                                      orec->name);
 327                     }
 328                 }
 329             }
 330
 331             if (orec->prev)
 332                 orec->prev->next = orec->next;
 333             if (orec->next)
 334                 orec->next->prev = orec->prev;
 335             wfree(orec);
 336         } else {
 337             /* append this action in the new action list */
 338             orec->nextAction = NULL;
 339             if (!newList) {
 340                 newList = orec;
 341             } else {
 342                 NotificationObserver *p;
 343
 344                 p = newList;
 345                 while (p->nextAction) {
 346                     p = p->nextAction;
 347                 }
 348                 p->nextAction = orec;
 349             }
 350         }
 351         orec = tmp;
 352     }
 353
 354     /* reinsert the list to the table */
 355     if (newList) {
 356         WMHashInsert(notificationCenter->observerTable, observer, newList);
 357     }
 358 }
 359
 360
 361 void
 362 WMPostNotificationName(char *name, void *object, void *clientData)
 363 {
 364     WMNotification *notification;
 365
 366     notification = WMCreateNotification(name, object, clientData);
 367
 368     WMPostNotification(notification);
 369
 370     WMReleaseNotification(notification);
 371 }
 372
 373
 374
 375 /**************** Notification Queues ****************/
 376
 377
 378 typedef struct W_NotificationQueue {
 379     WMBag *asapQueue;
 380     WMBag *idleQueue;
 381
 382     struct W_NotificationQueue *next;
 383 } NotificationQueue;
 384
 385
 386 static WMNotificationQueue *notificationQueueList = NULL;
 387
 388 /* default queue */
 389 static WMNotificationQueue *notificationQueue = NULL;
 390
 391
 392 WMNotificationQueue*
 393 WMGetDefaultNotificationQueue(void)
 394 {
 395     if (!notificationQueue)
 396         notificationQueue = WMCreateNotificationQueue();
 397
 398     return notificationQueue;
 399 }
 400
 401
 402 WMNotificationQueue*
 403 WMCreateNotificationQueue(void)
 404 {
 405     NotificationQueue *queue;
 406
 407     queue = wmalloc(sizeof(NotificationQueue));
 408
 409     queue->asapQueue = WMCreateBag(8);
 410     queue->idleQueue = WMCreateBag(8);
 411     queue->next = notificationQueueList;
 412
 413     notificationQueueList = queue;
 414
 415     return queue;
 416 }
 417
 418
 419
 420 void
 421 WMEnqueueNotification(WMNotificationQueue *queue, WMNotification *notification,
 422                       WMPostingStyle postingStyle)
 423 {
 424     WMEnqueueCoalesceNotification(queue, notification, postingStyle,
 425                                   WNCOnName|WNCOnSender);
 426 }
 427
 428
 429
 430 void
 431 WMDequeueNotificationMatching(WMNotificationQueue *queue,
 432                               WMNotification *notification, unsigned mask)
 433 {
 434     WMBagIterator i;
 435     WMNotification *tmp;
 436
 437     if ((mask & WNCOnName) && (mask & WNCOnSender)) {
 438         WM_ITERATE_BAG(queue->asapQueue, tmp, i) {
 439             if (notification->object == tmp->object &&
 440                 strcmp(notification->name, tmp->name) == 0) {
 441                 WMRemoveFromBag(queue->asapQueue, tmp);
 442                 WMReleaseNotification(tmp);
 443                 break;
 444             }
 445         }
 446         WM_ITERATE_BAG(queue->idleQueue, tmp, i) {
 447             if (notification->object == tmp->object &&
 448                 strcmp(notification->name, tmp->name) == 0) {
 449                 WMRemoveFromBag(queue->idleQueue, tmp);
 450                 WMReleaseNotification(tmp);
 451                 break;
 452             }
 453         }
 454     } else if (mask & WNCOnName) {
 455         WM_ITERATE_BAG(queue->asapQueue, tmp, i) {
 456             if (strcmp(notification->name, tmp->name) == 0) {
 457                 WMRemoveFromBag(queue->asapQueue, tmp);
 458                 WMReleaseNotification(tmp);
 459                 break;
 460             }
 461         }
 462         WM_ITERATE_BAG(queue->idleQueue, tmp, i) {
 463             if (strcmp(notification->name, tmp->name) == 0) {
 464                 WMRemoveFromBag(queue->idleQueue, tmp);
 465                 WMReleaseNotification(tmp);
 466                 break;
 467             }
 468         }
 469     } else if (mask & WNCOnSender) {
 470         WM_ITERATE_BAG(queue->asapQueue, tmp, i) {
 471             if (notification->object == tmp->object) {
 472                 WMRemoveFromBag(queue->asapQueue, tmp);
 473                 WMReleaseNotification(tmp);
 474                 break;
 475             }
 476         }
 477         WM_ITERATE_BAG(queue->idleQueue, tmp, i) {
 478             if (notification->object == tmp->object) {
 479                 WMRemoveFromBag(queue->idleQueue, tmp);
 480                 WMReleaseNotification(tmp);
 481                 break;
 482             }
 483         }
 484     }
 485 }
 486
 487
 488 void
 489 WMEnqueueCoalesceNotification(WMNotificationQueue *queue,
 490                               WMNotification *notification,
 491                               WMPostingStyle postingStyle,
 492                               unsigned coalesceMask)
 493 {
 494     if (coalesceMask != WNCNone)
 495         WMDequeueNotificationMatching(queue, notification, coalesceMask);
 496
 497     switch (postingStyle) {
 498      case WMPostNow:
 499         WMPostNotification(notification);
 500         WMReleaseNotification(notification);
 501         break;
 502
 503      case WMPostASAP:
 504         WMPutInBag(queue->asapQueue, notification);
 505         break;
 506
 507      case WMPostWhenIdle:
 508         WMPutInBag(queue->idleQueue, notification);
 509         break;
 510     }
 511 }
 512
 513
 514 void
 515 W_FlushASAPNotificationQueue()
 516 {
 517     WMNotificationQueue *queue = notificationQueueList;
 518
 519     while (queue) {
 520         while (WMGetBagItemCount(queue->asapQueue)) {
 521             WMNotification *tmp = WMGetFromBag(queue->asapQueue, 0);
 522
 523             WMPostNotification(tmp);
 524             WMReleaseNotification(tmp);
 525             WMDeleteFromBag(queue->asapQueue, 0);
 526         }
 527
 528         queue = queue->next;
 529     }
 530 }
 531
 532
 533 void
 534 W_FlushIdleNotificationQueue()
 535 {
 536     WMNotificationQueue *queue = notificationQueueList;
 537
 538     while (queue) {
 539         while (WMGetBagItemCount(queue->idleQueue)) {
 540             WMNotification *tmp = WMGetFromBag(queue->idleQueue, 0);
 541
 542             WMPostNotification(tmp);
 543             WMReleaseNotification(tmp);
 544             WMDeleteFromBag(queue->idleQueue, 0);
 545         }
 546
 547         queue = queue->next;
 548     }
 549 }
 550