WINGs/WINGs/WUtil.h

   1 #ifndef _WUTIL_H_
   2 #define _WUTIL_H_
   3
   4 #include <X11/Xlib.h>
   5 #include <limits.h>
   6 #include <sys/types.h>
   7
   8 /* SunOS 4.x Blargh.... */
   9 #ifndef NULL
  10 #define NULL ((void*)0)
  11 #endif
  12
  13
  14 #ifndef WMAX
  15 # define WMAX(a,b)      ((a)>(b) ? (a) : (b))
  16 #endif
  17 #ifndef WMIN
  18 # define WMIN(a,b)      ((a)<(b) ? (a) : (b))
  19 #endif
  20
  21
  22 #ifndef __ASSERT_FUNCTION
  23 # if (!defined (__GNUC__) || (__GNUC__ < 2 && \
  24       __GNUC_MINOR__ < (defined (__cplusplus) ? 6 : 4)))
  25 #  define __ASSERT_FUNCTION       ((char *) 0)
  26 # else
  27 #  define __ASSERT_FUNCTION       __PRETTY_FUNCTION__
  28 # endif
  29 #endif
  30
  31 #ifndef __GNUC__
  32 #define  __attribute__(x)  /*NOTHING*/
  33 #endif
  34
  35 #ifdef NDEBUG
  36
  37 #define wassertr(expr)          {}
  38 #define wassertrv(expr, val)    {}
  39
  40 #else /* !NDEBUG */
  41
  42 #ifdef DEBUG
  43
  44 #include <assert.h>
  45
  46 #define wassertr(expr)  assert(expr)
  47
  48 #define wassertrv(expr, val)    assert(expr)
  49
  50 #else /* !DEBUG */
  51
  52 #define wassertr(expr) \
  53     if (!(expr)) { \
  54         wwarning("%s line %i (%s): assertion %s failed",\
  55                  __FILE__, __LINE__, __ASSERT_FUNCTION, #expr);\
  56         return;\
  57     }
  58
  59 #define wassertrv(expr, val) \
  60     if (!(expr)) { \
  61         wwarning("%s line %i (%s): assertion %s failed",\
  62                  __FILE__, __LINE__, __ASSERT_FUNCTION, #expr);\
  63         return (val);\
  64     }
  65 #endif /* !DEBUG */
  66
  67 #endif /* !NDEBUG */
  68
  69
  70 #ifdef __cplusplus
  71 extern "C" {
  72 #endif /* __cplusplus */
  73
  74
  75 typedef enum {
  76     WMPostWhenIdle = 1,
  77     WMPostASAP = 2,
  78     WMPostNow = 3
  79 } WMPostingStyle;
  80
  81
  82 typedef enum {
  83     WNCNone = 0,
  84     WNCOnName = 1,
  85     WNCOnSender = 2
  86 } WMNotificationCoalescing;
  87
  88
  89
  90 enum {
  91     WBNotFound = INT_MIN, /* element was not found in WMBag   */
  92     WANotFound = -1       /* element was not found in WMArray */
  93 };
  94
  95
  96 typedef struct W_Array WMArray;
  97 typedef struct W_Bag WMBag;
  98 typedef struct W_Data WMData;
  99 typedef struct W_TreeNode WMTreeNode;
 100 typedef struct W_HashTable WMHashTable;
 101 typedef struct W_UserDefaults WMUserDefaults;
 102 typedef struct W_Notification WMNotification;
 103 typedef struct W_NotificationQueue WMNotificationQueue;
 104 typedef struct W_Host WMHost;
 105 typedef struct W_Connection WMConnection;
 106 typedef struct W_PropList WMPropList;
 107
 108
 109
 110 /* Some typedefs for the handler stuff */
 111 typedef void *WMHandlerID;
 112
 113 typedef void WMCallback(void *data);
 114
 115 typedef void WMInputProc(int fd, int mask, void *clientData);
 116
 117
 118
 119 typedef int WMCompareDataProc(const void *item1, const void *item2);
 120
 121 typedef void WMFreeDataProc(void *data);
 122
 123 /* Used by WMBag or WMArray for matching data */
 124 typedef int WMMatchDataProc(const void *item, const void *cdata);
 125
 126
 127
 128 typedef struct {
 129     int position;
 130     int count;
 131 } WMRange;
 132
 133
 134
 135 /* DO NOT ACCESS THE CONTENTS OF THIS STRUCT */
 136 typedef struct {
 137     void *table;
 138     void *nextItem;
 139     int index;
 140 } WMHashEnumerator;
 141
 142
 143 typedef struct {
 144     /* NULL is pointer hash */
 145     unsigned    (*hash)(const void *);
 146     /* NULL is pointer compare */
 147     Bool        (*keyIsEqual)(const void *, const void *);
 148     /* NULL does nothing */
 149     void*       (*retainKey)(const void *);
 150     /* NULL does nothing */
 151     void        (*releaseKey)(const void *);
 152 } WMHashTableCallbacks;
 153
 154
 155 typedef int WMArrayIterator;
 156 typedef void *WMBagIterator;
 157
 158
 159 #if 0
 160 typedef struct {
 161     char character;                    /* the escape character */
 162     char *value;                       /* value to place */
 163 } WMSEscapes;
 164 #endif
 165
 166
 167
 168 typedef void WMNotificationObserverAction(void *observerData,
 169                                           WMNotification *notification);
 170
 171
 172
 173 /*......................................................................*/
 174
 175 typedef void waborthandler(int);
 176
 177 waborthandler* wsetabort(waborthandler* handler);
 178
 179
 180 /* don't free the returned string */
 181 char* wstrerror(int errnum);
 182
 183 enum {
 184         WMESSAGE_TYPE_MESSAGE,
 185         WMESSAGE_TYPE_WARNING,
 186         WMESSAGE_TYPE_FATAL,
 187         WMESSAGE_TYPE_WSYSERROR,
 188         WMESSAGE_TYPE_WSYSERRORWITHCODE
 189 };
 190
 191 #define wmessage(fmt, args...) __wmessage( WMESSAGE_TYPE_MESSAGE, NULL, fmt, ## args)
 192 #define wwarning(fmt, args...) __wmessage( WMESSAGE_TYPE_WARNING, NULL, fmt, ## args)
 193 #define wfatal(fmt, args...) __wmessage( WMESSAGE_TYPE_FATAL, NULL, fmt, ## args)
 194 #define wsyserror(fmt, args...) __wmessage( WMESSAGE_TYPE_WSYSERROR, NULL, fmt, ## args)
 195 #define wsyserrorwithcode(errno, fmt, args...) \
 196         __wmessage( WMESSAGE_TYPE_WSYSERRORWITHCODE, &errno, fmt, ## args)
 197
 198 void __wmessage(int type, void *extra, const char *msg, ...) __attribute__((__format__(printf,3,4)));
 199
 200 char* wfindfile(char *paths, char *file);
 201
 202 char* wfindfileinlist(char **path_list, char *file);
 203
 204 char* wfindfileinarray(WMPropList* array, char *file);
 205
 206 char* wexpandpath(char *path);
 207
 208 int wmkdirhier(const char *path);
 209 int wrmdirhier(const char *path);
 210
 211 /* don't free the returned string */
 212 char* wgethomedir();
 213
 214 void* wmalloc(size_t size);
 215 void* wrealloc(void *ptr, size_t newsize);
 216 void wfree(void *ptr);
 217
 218 #define wnew(type, count) wmalloc(sizeof(type)*count)
 219
 220 void wrelease(void *ptr);
 221 void* wretain(void *ptr);
 222
 223 char *wstrdup(const char *str);
 224 char* wstrndup(const char *str, size_t len);
 225
 226 /* Concatenate str1 with str2 and return that in a newly malloc'ed string.
 227  * str1 and str2 can be any strings including static and constant strings.
 228  * str1 and str2 will not be modified.
 229  * Free the returned string when you're done with it. */
 230 char* wstrconcat(char *str1, char *str2);
 231
 232 /* This will append src to dst, and return dst. dst MUST be either NULL
 233  * or a string that was a result of a dynamic allocation (malloc, realloc
 234  * wmalloc, wrealloc, ...). dst CANNOT be a static or a constant string!
 235  * Modifies dst (no new string is created except if dst==NULL in which case
 236  * it is equivalent to calling wstrdup(src) ).
 237  * The returned address may be different from the original address of dst,
 238  * so always assign the returned address to avoid dangling pointers. */
 239 char* wstrappend(char *dst, char *src);
 240
 241
 242 void wtokensplit(char *command, char ***argv, int *argc);
 243
 244 char* wtokennext(char *word, char **next);
 245
 246 char* wtokenjoin(char **list, int count);
 247
 248 void wtokenfree(char **tokens, int count);
 249
 250 char* wtrimspace(const char *s);
 251
 252
 253 WMRange wmkrange(int start, int count);
 254 #ifdef ANSI_C_DOESNT_LIKE_IT_THIS_WAY
 255 #define wmkrange(position, count) (WMRange){(position), (count)}
 256 #endif
 257
 258
 259 char* wusergnusteppath();
 260
 261 char* wdefaultspathfordomain(char *domain);
 262 char* wglobaldefaultspathfordomain(const char *domain);
 263
 264 void wusleep(unsigned int microsec);
 265
 266 #if 0
 267 int wsprintesc(char *buffer, int length, char *format, WMSEscapes **escapes,
 268                int count);
 269 #endif
 270
 271 /*......................................................................*/
 272
 273 /* Event handlers: timer, idle, input */
 274
 275 WMHandlerID WMAddTimerHandler(int milliseconds, WMCallback *callback,
 276                               void *cdata);
 277
 278 WMHandlerID WMAddPersistentTimerHandler(int milliseconds, WMCallback *callback,
 279                                         void *cdata);
 280
 281 void WMDeleteTimerWithClientData(void *cdata);
 282
 283 void WMDeleteTimerHandler(WMHandlerID handlerID);
 284
 285 WMHandlerID WMAddIdleHandler(WMCallback *callback, void *cdata);
 286
 287 void WMDeleteIdleHandler(WMHandlerID handlerID);
 288
 289 WMHandlerID WMAddInputHandler(int fd, int condition, WMInputProc *proc,
 290                               void *clientData);
 291
 292 void WMDeleteInputHandler(WMHandlerID handlerID);
 293
 294
 295 /* This function is used _only_ if you create a non-GUI program.
 296  * For GUI based programs use WMNextEvent()/WMHandleEvent() instead.
 297  * This function will handle all input/timer/idle events, then return.
 298  */
 299
 300 void WHandleEvents();
 301
 302 /*......................................................................*/
 303
 304
 305 WMHashTable* WMCreateHashTable(WMHashTableCallbacks callbacks);
 306
 307 void WMFreeHashTable(WMHashTable *table);
 308
 309 void WMResetHashTable(WMHashTable *table);
 310
 311 unsigned WMCountHashTable(WMHashTable *table);
 312
 313 void* WMHashGet(WMHashTable *table, const void *key);
 314
 315 /* Returns True if there is a value associated with <key> in the table, in
 316  * which case <retKey> and <retItem> will contain the item's internal key
 317  * address and the item's value respectively.
 318  * If there is no value associated with <key> it will return False and in
 319  * this case <retKey> and <retItem> will be undefined.
 320  * Use this when you need to perform your own custom retain/release mechanism
 321  * which requires access to the keys too.
 322  */
 323 Bool WMHashGetItemAndKey(WMHashTable *table, const void *key,
 324                          void **retItem, void **retKey);
 325
 326 /* put data in table, replacing already existing data and returning
 327  * the old value */
 328 void* WMHashInsert(WMHashTable *table, const void *key, const void *data);
 329
 330 void WMHashRemove(WMHashTable *table, const void *key);
 331
 332 /* warning: do not manipulate the table while using the enumerator functions */
 333 WMHashEnumerator WMEnumerateHashTable(WMHashTable *table);
 334
 335 void* WMNextHashEnumeratorItem(WMHashEnumerator *enumerator);
 336
 337 void* WMNextHashEnumeratorKey(WMHashEnumerator *enumerator);
 338
 339 /* Returns True if there is a next element, in which case key and item
 340  * will contain the next element's key and value respectively.
 341  * If there is no next element available it will return False and in this
 342  * case key and item will be undefined.
 343  */
 344 Bool WMNextHashEnumeratorItemAndKey(WMHashEnumerator *enumerator,
 345                                     void **item, void **key);
 346
 347
 348
 349
 350 /* some predefined callback sets */
 351
 352 extern const WMHashTableCallbacks WMIntHashCallbacks;
 353 /* sizeof(keys) are <= sizeof(void*) */
 354
 355 extern const WMHashTableCallbacks WMStringHashCallbacks;
 356 /* keys are strings. Strings will be copied with wstrdup()
 357  * and freed with wfree() */
 358
 359 extern const WMHashTableCallbacks WMStringPointerHashCallbacks;
 360 /* keys are strings, but they are not copied */
 361
 362
 363 /*......................................................................*/
 364
 365 /*
 366  * WMArray use an array to store the elements.
 367  * Item indexes may be only positive integer numbers.
 368  * The array cannot contain holes in it.
 369  *
 370  * Pros:
 371  * Fast [O(1)] access to elements
 372  * Fast [O(1)] push/pop
 373  *
 374  * Cons:
 375  * A little slower [O(n)] for insertion/deletion of elements that
 376  *      aren't in the end
 377  */
 378
 379 WMArray* WMCreateArray(int initialSize);
 380
 381 WMArray* WMCreateArrayWithDestructor(int initialSize, WMFreeDataProc *destructor);
 382
 383 WMArray* WMCreateArrayWithArray(WMArray *array);
 384
 385 #define WMDuplicateArray(array) WMCreateArrayWithArray(array)
 386
 387 void WMEmptyArray(WMArray *array);
 388
 389 void WMFreeArray(WMArray *array);
 390
 391 int WMGetArrayItemCount(WMArray *array);
 392
 393 /* appends other to array. other remains unchanged */
 394 void WMAppendArray(WMArray *array, WMArray *other);
 395
 396 /* add will place the element at the end of the array */
 397 void WMAddToArray(WMArray *array, void *item);
 398
 399 #define WMPushInArray(array, item) WMAddToArray(array, item)
 400
 401 /* insert will increment the index of elements after it by 1 */
 402 void WMInsertInArray(WMArray *array, int index, void *item);
 403
 404 /* replace and set will return the old item WITHOUT calling the
 405  * destructor on it even if its available. Free the returned item yourself.
 406  */
 407 void* WMReplaceInArray(WMArray *array, int index, void *item);
 408
 409 #define WMSetInArray(array, index, item) WMReplaceInArray(array, index, item)
 410
 411 /* delete and remove will remove the elements and cause the elements
 412  * after them to decrement their indexes by 1. Also will call the
 413  * destructor on the deleted element if there's one available.
 414  */
 415 int WMDeleteFromArray(WMArray *array, int index);
 416
 417 #define WMRemoveFromArray(array, item) WMRemoveFromArrayMatching(array, NULL, item)
 418
 419 int WMRemoveFromArrayMatching(WMArray *array, WMMatchDataProc *match, void *cdata);
 420
 421 void* WMGetFromArray(WMArray *array, int index);
 422
 423 #define WMGetFirstInArray(array, item) WMFindInArray(array, NULL, item)
 424
 425 /* pop will return the last element from the array, also removing it
 426  * from the array. The destructor is NOT called, even if available.
 427  * Free the returned element if needed by yourself
 428  */
 429 void* WMPopFromArray(WMArray *array);
 430
 431 int WMFindInArray(WMArray *array, WMMatchDataProc *match, void *cdata);
 432
 433 int WMCountInArray(WMArray *array, void *item);
 434
 435 /* comparer must return:
 436  * < 0 if a < b
 437  * > 0 if a > b
 438  * = 0 if a = b
 439  */
 440 void WMSortArray(WMArray *array, WMCompareDataProc *comparer);
 441
 442 void WMMapArray(WMArray *array, void (*function)(void*, void*), void *data);
 443
 444 WMArray* WMGetSubarrayWithRange(WMArray* array, WMRange aRange);
 445
 446 void* WMArrayFirst(WMArray *array, WMArrayIterator *iter);
 447
 448 void* WMArrayLast(WMArray *array, WMArrayIterator *iter);
 449
 450 /* The following 2 functions assume that the array doesn't change between calls */
 451 void* WMArrayNext(WMArray *array, WMArrayIterator *iter);
 452
 453 void* WMArrayPrevious(WMArray *array, WMArrayIterator *iter);
 454
 455
 456 /* The following 2 macros assume that the array doesn't change in the for loop */
 457 #define WM_ITERATE_ARRAY(array, var, i) \
 458     for (var = WMArrayFirst(array, &(i)); (i) != WANotFound; \
 459     var = WMArrayNext(array, &(i)))
 460
 461 #define WM_ETARETI_ARRAY(array, var, i) \
 462     for (var = WMArrayLast(array, &(i)); (i) != WANotFound; \
 463     var = WMArrayPrevious(array, &(i)))
 464
 465 /*..........................................................................*/
 466
 467 /*
 468  * Tree bags use a red-black tree for storage.
 469  * Item indexes may be any integer number.
 470  *
 471  * Pros:
 472  * O(lg n) insertion/deletion/search
 473  * Good for large numbers of elements with sparse indexes
 474  *
 475  * Cons:
 476  * O(lg n) insertion/deletion/search
 477  * Slow for storing small numbers of elements
 478  */
 479
 480 #define WMCreateBag(size) WMCreateTreeBag()
 481
 482 #define WMCreateBagWithDestructor(size, d) WMCreateTreeBagWithDestructor(d)
 483
 484 WMBag* WMCreateTreeBag(void);
 485
 486 WMBag* WMCreateTreeBagWithDestructor(WMFreeDataProc *destructor);
 487
 488 int WMGetBagItemCount(WMBag *bag);
 489
 490 void WMAppendBag(WMBag *bag, WMBag *other);
 491
 492 void WMPutInBag(WMBag *bag, void *item);
 493
 494 /* insert will increment the index of elements after it by 1 */
 495 void WMInsertInBag(WMBag *bag, int index, void *item);
 496
 497 /* erase will remove the element from the bag,
 498  * but will keep the index of the other elements unchanged */
 499 int WMEraseFromBag(WMBag *bag, int index);
 500
 501 /* delete and remove will remove the elements and cause the elements
 502  * after them to decrement their indexes by 1 */
 503 int WMDeleteFromBag(WMBag *bag, int index);
 504
 505 int WMRemoveFromBag(WMBag *bag, void *item);
 506
 507 void* WMGetFromBag(WMBag *bag, int index);
 508
 509 void* WMReplaceInBag(WMBag *bag, int index, void *item);
 510
 511 #define WMSetInBag(bag, index, item) WMReplaceInBag(bag, index, item)
 512
 513 /* comparer must return:
 514  * < 0 if a < b
 515  * > 0 if a > b
 516  * = 0 if a = b
 517  */
 518 void WMSortBag(WMBag *bag, WMCompareDataProc *comparer);
 519
 520 void WMEmptyBag(WMBag *bag);
 521
 522 void WMFreeBag(WMBag *bag);
 523
 524 void WMMapBag(WMBag *bag, void (*function)(void*, void*), void *data);
 525
 526 int WMGetFirstInBag(WMBag *bag, void *item);
 527
 528 int WMCountInBag(WMBag *bag, void *item);
 529
 530 int WMFindInBag(WMBag *bag, WMMatchDataProc *match, void *cdata);
 531
 532 void* WMBagFirst(WMBag *bag, WMBagIterator *ptr);
 533
 534 void* WMBagLast(WMBag *bag, WMBagIterator *ptr);
 535
 536 /* The following 4 functions assume that the bag doesn't change between calls */
 537 void* WMBagNext(WMBag *bag, WMBagIterator *ptr);
 538
 539 void* WMBagPrevious(WMBag *bag, WMBagIterator *ptr);
 540
 541 void* WMBagIteratorAtIndex(WMBag *bag, int index, WMBagIterator *ptr);
 542
 543 int WMBagIndexForIterator(WMBag *bag, WMBagIterator ptr);
 544
 545
 546 /* The following 2 macros assume that the bag doesn't change in the for loop */
 547 #define WM_ITERATE_BAG(bag, var, i) \
 548     for (var = WMBagFirst(bag, &(i)); (i) != NULL; \
 549     var = WMBagNext(bag, &(i)))
 550
 551 #define WM_ETARETI_BAG(bag, var, i) \
 552     for (var = WMBagLast(bag, &(i)); (i) != NULL; \
 553     var = WMBagPrevious(bag, &(i)))
 554
 555
 556
 557 /*-------------------------------------------------------------------------*/
 558
 559 /* WMData handling */
 560
 561 /* Creating/destroying data */
 562
 563 WMData* WMCreateDataWithCapacity(unsigned capacity);
 564
 565 WMData* WMCreateDataWithLength(unsigned length);
 566
 567 WMData* WMCreateDataWithBytes(void *bytes, unsigned length);
 568
 569 /* destructor is a function called to free the data when releasing the data
 570  * object, or NULL if no freeing of data is necesary. */
 571 WMData* WMCreateDataWithBytesNoCopy(void *bytes, unsigned length,
 572                                     WMFreeDataProc *destructor);
 573
 574 WMData* WMCreateDataWithData(WMData *aData);
 575
 576 WMData* WMRetainData(WMData *aData);
 577
 578 void WMReleaseData(WMData *aData);
 579
 580 /* Adjusting capacity */
 581
 582 void WMSetDataCapacity(WMData *aData, unsigned capacity);
 583
 584 void WMSetDataLength(WMData *aData, unsigned length);
 585
 586 void WMIncreaseDataLengthBy(WMData *aData, unsigned extraLength);
 587
 588 /* Accessing data */
 589
 590 const void* WMDataBytes(WMData *aData);
 591
 592 void WMGetDataBytes(WMData *aData, void *buffer);
 593
 594 void WMGetDataBytesWithLength(WMData *aData, void *buffer, unsigned length);
 595
 596 void WMGetDataBytesWithRange(WMData *aData, void *buffer, WMRange aRange);
 597
 598 WMData* WMGetSubdataWithRange(WMData *aData, WMRange aRange);
 599
 600 /* Testing data */
 601
 602 Bool WMIsDataEqualToData(WMData *aData, WMData *anotherData);
 603
 604 unsigned WMGetDataLength(WMData *aData);
 605
 606 /* Adding data */
 607
 608 void WMAppendDataBytes(WMData *aData, void *bytes, unsigned length);
 609
 610 void WMAppendData(WMData *aData, WMData *anotherData);
 611
 612 /* Modifying data */
 613
 614 void WMReplaceDataBytesInRange(WMData *aData, WMRange aRange, void *bytes);
 615
 616 void WMResetDataBytesInRange(WMData *aData, WMRange aRange);
 617
 618 void WMSetData(WMData *aData, WMData *anotherData);
 619
 620
 621 void WMSetDataFormat(WMData *aData, unsigned format);
 622
 623 unsigned WMGetDataFormat(WMData *aData);
 624 /* Storing data */
 625
 626
 627 /*--------------------------------------------------------------------------*/
 628
 629 /* Generic Tree and TreeNode */
 630
 631 WMTreeNode* WMCreateTreeNode(void *data);
 632
 633 WMTreeNode* WMCreateTreeNodeWithDestructor(void *data, WMFreeDataProc *destructor);
 634
 635 WMTreeNode* WMInsertItemInTree(WMTreeNode *parent, int index, void *item);
 636
 637 #define WMAddItemToTree(parent, item)  WMInsertItemInTree(parent, -1, item)
 638
 639 WMTreeNode* WMInsertNodeInTree(WMTreeNode *parent, int index, WMTreeNode *aNode);
 640
 641 #define WMAddNodeToTree(parent, aNode)  WMInsertNodeInTree(parent, -1, aNode)
 642
 643 void WMDestroyTreeNode(WMTreeNode *aNode);
 644
 645 void WMDeleteLeafForTreeNode(WMTreeNode *aNode, int index);
 646
 647 void WMRemoveLeafForTreeNode(WMTreeNode *aNode, void *leaf);
 648
 649 void* WMReplaceDataForTreeNode(WMTreeNode *aNode, void *newData);
 650
 651 void* WMGetDataForTreeNode(WMTreeNode *aNode);
 652
 653 int WMGetTreeNodeDepth(WMTreeNode *aNode);
 654
 655 WMTreeNode* WMGetParentForTreeNode(WMTreeNode *aNode);
 656
 657 /* Sort only the leaves of the passed node */
 658 void WMSortLeavesForTreeNode(WMTreeNode *aNode, WMCompareDataProc *comparer);
 659
 660 /* Sort all tree recursively starting from the passed node */
 661 void WMSortTree(WMTreeNode *aNode, WMCompareDataProc *comparer);
 662
 663 /* Returns the first node which matches node's data with cdata by 'match' */
 664 WMTreeNode* WMFindInTree(WMTreeNode *aTree, WMMatchDataProc *match, void *cdata);
 665
 666 /* Returns first tree node that has data == cdata */
 667 #define WMGetFirstInTree(aTree, cdata) WMFindInTree(aTree, NULL, cdata)
 668
 669
 670 /*--------------------------------------------------------------------------*/
 671
 672
 673 WMNotification* WMCreateNotification(const char *name, void *object, void *clientData);
 674
 675 void WMReleaseNotification(WMNotification *notification);
 676
 677 WMNotification* WMRetainNotification(WMNotification *notification);
 678
 679 void* WMGetNotificationClientData(WMNotification *notification);
 680
 681 void* WMGetNotificationObject(WMNotification *notification);
 682
 683 const char* WMGetNotificationName(WMNotification *notification);
 684
 685
 686 void WMAddNotificationObserver(WMNotificationObserverAction *observerAction,
 687                                void *observer, const char *name, void *object);
 688
 689 void WMPostNotification(WMNotification *notification);
 690
 691 void WMRemoveNotificationObserver(void *observer);
 692
 693 void WMRemoveNotificationObserverWithName(void *observer, const char *name,
 694                                           void *object);
 695
 696 void WMPostNotificationName(const char *name, void *object, void *clientData);
 697
 698 WMNotificationQueue* WMGetDefaultNotificationQueue(void);
 699
 700 WMNotificationQueue* WMCreateNotificationQueue(void);
 701
 702 void WMDequeueNotificationMatching(WMNotificationQueue *queue,
 703                                    WMNotification *notification,
 704                                    unsigned mask);
 705
 706 void WMEnqueueNotification(WMNotificationQueue *queue,
 707                            WMNotification *notification,
 708                            WMPostingStyle postingStyle);
 709
 710 void WMEnqueueCoalesceNotification(WMNotificationQueue *queue,
 711                                    WMNotification *notification,
 712                                    WMPostingStyle postingStyle,
 713                                    unsigned coalesceMask);
 714
 715
 716 /*......................................................................*/
 717
 718 /* Property Lists handling */
 719
 720 void WMPLSetCaseSensitive(Bool caseSensitive);
 721
 722 WMPropList* WMCreatePLString(char *str);
 723
 724 WMPropList* WMCreatePLData(WMData *data);
 725
 726 WMPropList* WMCreatePLDataWithBytes(unsigned char *bytes, unsigned int length);
 727
 728 WMPropList* WMCreatePLDataWithBytesNoCopy(unsigned char *bytes,
 729                                           unsigned int length,
 730                                           WMFreeDataProc *destructor);
 731
 732 WMPropList* WMCreatePLArray(WMPropList *elem, ...);
 733
 734 WMPropList* WMCreatePLDictionary(WMPropList *key, WMPropList *value, ...);
 735
 736 WMPropList* WMRetainPropList(WMPropList *plist);
 737
 738 void WMReleasePropList(WMPropList *plist);
 739
 740 /* Objects inserted in arrays and dictionaries will be retained,
 741  * so you can safely release them after insertion.
 742  * For dictionaries both the key and value are retained.
 743  * Objects removed from arrays or dictionaries are released */
 744 void WMInsertInPLArray(WMPropList *plist, int index, WMPropList *item);
 745
 746 void WMAddToPLArray(WMPropList *plist, WMPropList *item);
 747
 748 void WMDeleteFromPLArray(WMPropList *plist, int index);
 749
 750 void WMRemoveFromPLArray(WMPropList *plist, WMPropList *item);
 751
 752 void WMPutInPLDictionary(WMPropList *plist, WMPropList *key, WMPropList *value);
 753
 754 void WMRemoveFromPLDictionary(WMPropList *plist, WMPropList *key);
 755
 756 /* It will insert all key/value pairs from source into dest, overwriting
 757  * the values with the same keys from dest, keeping all values with keys
 758  * only present in dest unchanged */
 759 WMPropList* WMMergePLDictionaries(WMPropList *dest, WMPropList *source,
 760                                   Bool recursive);
 761
 762 /* It will remove all key/value pairs from dest for which there is an
 763  * identical key/value present in source. Entires only present in dest, or
 764  * which have different values in dest than in source will be preserved. */
 765 WMPropList* WMSubtractPLDictionaries(WMPropList *dest, WMPropList *source,
 766                                      Bool recursive);
 767
 768 int WMGetPropListItemCount(WMPropList *plist);
 769
 770 Bool WMIsPLString(WMPropList *plist);
 771
 772 Bool WMIsPLData(WMPropList *plist);
 773
 774 Bool WMIsPLArray(WMPropList *plist);
 775
 776 Bool WMIsPLDictionary(WMPropList *plist);
 777
 778 Bool WMIsPropListEqualTo(WMPropList *plist, WMPropList *other);
 779
 780 /* Returns a reference. Do not free it! */
 781 char* WMGetFromPLString(WMPropList *plist);
 782
 783 /* Returns a reference. Do not free it! */
 784 WMData* WMGetFromPLData(WMPropList *plist);
 785
 786 /* Returns a reference. Do not free it! */
 787 const unsigned char* WMGetPLDataBytes(WMPropList *plist);
 788
 789 int WMGetPLDataLength(WMPropList *plist);
 790
 791 /* Returns a reference. */
 792 WMPropList* WMGetFromPLArray(WMPropList *plist, int index);
 793
 794 /* Returns a reference. */
 795 WMPropList* WMGetFromPLDictionary(WMPropList *plist, WMPropList *key);
 796
 797 /* Returns a PropList array with all the dictionary keys. Release it when
 798  * you're done. Keys in array are retained from the original dictionary
 799  * not copied and need NOT to be released individually. */
 800 WMPropList* WMGetPLDictionaryKeys(WMPropList *plist);
 801
 802 /* Creates only the first level deep object. All the elements inside are
 803  * retained from the original */
 804 WMPropList* WMShallowCopyPropList(WMPropList *plist);
 805
 806 /* Makes a completely separate replica of the original proplist */
 807 WMPropList* WMDeepCopyPropList(WMPropList *plist);
 808
 809 WMPropList* WMCreatePropListFromDescription(char *desc);
 810
 811 /* Free the returned string when you no longer need it */
 812 char* WMGetPropListDescription(WMPropList *plist, Bool indented);
 813
 814 WMPropList* WMReadPropListFromFile(char *file);
 815
 816 Bool WMWritePropListToFile(WMPropList *plist, char *path);
 817
 818 /*......................................................................*/
 819
 820 WMUserDefaults* WMGetStandardUserDefaults(void);
 821
 822 WMUserDefaults* WMGetDefaultsFromPath(char *path);
 823
 824 void WMSynchronizeUserDefaults(WMUserDefaults *database);
 825
 826 void WMSaveUserDefaults(WMUserDefaults *database);
 827
 828 void WMEnableUDPeriodicSynchronization(WMUserDefaults *database, Bool enable);
 829
 830 /* Returns a WMPropList array with all the keys in the user defaults database.
 831  * Free the array with WMReleasePropList() when no longer needed.
 832  * Keys in array are just retained references to the original keys */
 833 WMPropList* WMGetUDKeys(WMUserDefaults *database);
 834
 835 WMPropList* WMGetUDObjectForKey(WMUserDefaults *database, char *defaultName);
 836
 837 void WMSetUDObjectForKey(WMUserDefaults *database, WMPropList *object,
 838                          char *defaultName);
 839
 840 void WMRemoveUDObjectForKey(WMUserDefaults *database, char *defaultName);
 841
 842 char* WMGetUDStringForKey(WMUserDefaults *database, char *defaultName);
 843
 844 int WMGetUDIntegerForKey(WMUserDefaults *database, char *defaultName);
 845
 846 float WMGetUDFloatForKey(WMUserDefaults *database, char *defaultName);
 847
 848 Bool WMGetUDBoolForKey(WMUserDefaults *database, char *defaultName);
 849
 850 void WMSetUDStringForKey(WMUserDefaults *database, char *value,
 851                          char *defaultName);
 852
 853 void WMSetUDIntegerForKey(WMUserDefaults *database, int value,
 854                           char *defaultName);
 855
 856 void WMSetUDFloatForKey(WMUserDefaults *database, float value,
 857                         char *defaultName);
 858
 859 void WMSetUDBoolForKey(WMUserDefaults *database, Bool value,
 860                        char *defaultName);
 861
 862 WMPropList* WMGetUDSearchList(WMUserDefaults *database);
 863
 864 void WMSetUDSearchList(WMUserDefaults *database, WMPropList *list);
 865
 866 extern char *WMUserDefaultsDidChangeNotification;
 867
 868
 869 /*-------------------------------------------------------------------------*/
 870
 871 /* Global variables */
 872
 873 extern int WCErrorCode;
 874
 875
 876 /*-------------------------------------------------------------------------*/
 877
 878
 879
 880 #ifdef __cplusplus
 881 }
 882 #endif /* __cplusplus */
 883
 884
 885 #endif