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