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