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  * Warning: proplist.h #defines BOOL which will clash with the
  15  * typedef BOOL in Xmd.h
  16  * proplist.h should use Bool (which is a #define in Xlib.h) instead.
  17  *
  18  */
  19 #include <proplist.h>
  20
  21
  22 #ifndef WMAX
  23 # define WMAX(a,b)      ((a)>(b) ? (a) : (b))
  24 #endif
  25 #ifndef WMIN
  26 # define WMIN(a,b)      ((a)<(b) ? (a) : (b))
  27 #endif
  28
  29
  30 #if (!defined (__GNUC__) || __GNUC__ < 2 || \
  31      __GNUC_MINOR__ < (defined (__cplusplus) ? 6 : 4))
  32 #define __ASSERT_FUNCTION       ((char *) 0)
  33 #else
  34 #define __ASSERT_FUNCTION       __PRETTY_FUNCTION__
  35 #endif
  36
  37
  38 #ifdef NDEBUG
  39
  40 #define wassertr(expr)          {}
  41 #define wassertrv(expr, val)    {}
  42
  43 #else /* !NDEBUG */
  44
  45 #ifdef DEBUG
  46
  47 #include <assert.h>
  48
  49 #define wassertr(expr)  assert(expr)
  50
  51 #define wassertrv(expr, val)    assert(expr)
  52
  53 #else /* !DEBUG */
  54
  55 #define wassertr(expr) \
  56         if (!(expr)) { \
  57                 wwarning("%s line %i (%s): assertion %s failed",\
  58                         __FILE__, __LINE__, __ASSERT_FUNCTION, #expr);\
  59                 return;\
  60         }
  61
  62 #define wassertrv(expr, val) \
  63         if (!(expr)) { \
  64                 wwarning("%s line %i (%s): assertion %s failed",\
  65                         __FILE__, __LINE__, __ASSERT_FUNCTION, #expr);\
  66                 return (val);\
  67         }
  68 #endif /* !DEBUG */
  69
  70 #endif /* !NDEBUG */
  71
  72
  73 #ifdef __cplusplus
  74 extern "C" {
  75 #endif /* __cplusplus */
  76
  77
  78 typedef enum {
  79     WMPostWhenIdle = 1,
  80         WMPostASAP = 2,
  81         WMPostNow = 3
  82 } WMPostingStyle;
  83
  84
  85 typedef enum {
  86     WNCNone = 0,
  87         WNCOnName = 1,
  88         WNCOnSender = 2
  89 } WMNotificationCoalescing;
  90
  91
  92 /* The possible states for connections */
  93 typedef enum {
  94     WCNotConnected=0,
  95     WCListening,
  96     WCInProgress,
  97     WCFailed,
  98     WCConnected,
  99     WCTimedOut,
 100     WCDied,
 101     WCClosed
 102 } WMConnectionState;
 103
 104
 105 /* The possible states for connection timeouts */
 106 typedef enum {
 107     WCTNone=0,
 108     WCTWhileOpening,
 109     WCTWhileSending
 110 } WMConnectionTimeoutState;
 111
 112
 113
 114 enum {
 115     WBNotFound = INT_MIN, /* element was not found in WMBag   */
 116     WANotFound = -1       /* element was not found in WMArray */
 117 };
 118
 119
 120 typedef struct W_Array WMArray;
 121 typedef struct W_Bag WMBag;
 122 typedef struct W_Data WMData;
 123 typedef struct W_TreeNode WMTreeNode;
 124 typedef struct W_HashTable WMHashTable;
 125 typedef struct W_UserDefaults WMUserDefaults;
 126 typedef struct W_Notification WMNotification;
 127 typedef struct W_NotificationQueue WMNotificationQueue;
 128 typedef struct W_Host WMHost;
 129 typedef struct W_Connection WMConnection;
 130 typedef struct W_PropList WMPropList;
 131
 132
 133
 134 /* Some typedefs for the handler stuff */
 135 typedef void *WMHandlerID;
 136
 137 typedef void WMCallback(void *data);
 138
 139 typedef void WMInputProc(int fd, int mask, void *clientData);
 140
 141
 142
 143 typedef int WMCompareDataProc(const void *item1, const void *item2);
 144
 145 typedef void WMFreeDataProc(void *data);
 146
 147 /* Used by WMBag or WMArray for matching data */
 148 typedef int WMMatchDataProc(void *item, void *cdata);
 149
 150
 151
 152 typedef struct {
 153     int position;
 154     int count;
 155 } WMRange;
 156
 157
 158
 159 /* DO NOT ACCESS THE CONTENTS OF THIS STRUCT */
 160 typedef struct {
 161     void *table;
 162     void *nextItem;
 163     int index;
 164 } WMHashEnumerator;
 165
 166
 167 typedef struct {
 168     /* NULL is pointer hash */
 169     unsigned    (*hash)(const void *);
 170     /* NULL is pointer compare */
 171     Bool        (*keyIsEqual)(const void *, const void *);
 172     /* NULL does nothing */
 173     void*       (*retainKey)(const void *);
 174     /* NULL does nothing */
 175     void        (*releaseKey)(const void *);
 176 } WMHashTableCallbacks;
 177
 178
 179 typedef int WMArrayIterator;
 180 typedef void *WMBagIterator;
 181
 182
 183 #if 0
 184 typedef struct {
 185     char character;                    /* the escape character */
 186     char *value;                       /* value to place */
 187 } WMSEscapes;
 188 #endif
 189
 190
 191 /* The connection callbacks */
 192 typedef struct ConnectionDelegate {
 193     void *data;
 194
 195     void (*didCatchException)(struct ConnectionDelegate *self,
 196                               WMConnection *cPtr);
 197
 198     void (*didDie)(struct ConnectionDelegate *self, WMConnection *cPtr);
 199
 200     void (*didInitialize)(struct ConnectionDelegate *self, WMConnection *cPtr);
 201
 202     void (*didReceiveInput)(struct ConnectionDelegate *self, WMConnection *cPtr);
 203
 204     void (*didTimeout)(struct ConnectionDelegate *self, WMConnection *cPtr);
 205
 206 } ConnectionDelegate;
 207
 208
 209 typedef void WMNotificationObserverAction(void *observerData,
 210                                           WMNotification *notification);
 211
 212
 213
 214 /*......................................................................*/
 215
 216 typedef void (waborthandler)(int);
 217
 218 waborthandler* wsetabort(waborthandler*);
 219
 220
 221 /* don't free the returned string */
 222 char* wstrerror(int errnum);
 223
 224 void wmessage(const char *msg, ...);
 225 void wwarning(const char *msg, ...);
 226 void wfatal(const char *msg, ...);
 227 void wsyserror(const char *msg, ...);
 228 void wsyserrorwithcode(int error, const char *msg, ...);
 229
 230 char* wfindfile(char *paths, char *file);
 231
 232 char* wfindfileinlist(char **path_list, char *file);
 233
 234 char* wfindfileinarray(proplist_t array, char *file);
 235
 236 char* wexpandpath(char *path);
 237
 238 /* don't free the returned string */
 239 char* wgethomedir();
 240
 241 void* wmalloc(size_t size);
 242 void* wrealloc(void *ptr, size_t newsize);
 243 void wfree(void *ptr);
 244
 245
 246 void wrelease(void *ptr);
 247 void* wretain(void *ptr);
 248
 249 char* wstrdup(char *str);
 250
 251 /* Concatenate str1 with str2 and return that in a newly malloc'ed string.
 252  * str1 and str2 can be any strings including static and constant strings.
 253  * str1 and str2 will not be modified.
 254  * Free the returned string when you're done with it. */
 255 char* wstrconcat(char *str1, char *str2);
 256
 257 /* This will append src to dst, and return dst. dst MUST be either NULL
 258  * or a string that was a result of a dynamic allocation (malloc, realloc
 259  * wmalloc, wrealloc, ...). dst CANNOT be a static or a constant string!
 260  * Modifies dst (no new string is created except if dst==NULL in which case
 261  * it is equivalent to calling wstrdup(src) ).
 262  * The returned address may be different from the original address of dst,
 263  * so always assign the returned address to avoid dangling pointers. */
 264 char* wstrappend(char *dst, char *src);
 265
 266
 267 void wtokensplit(char *command, char ***argv, int *argc);
 268
 269 char* wtokennext(char *word, char **next);
 270
 271 char* wtokenjoin(char **list, int count);
 272
 273 void wtokenfree(char **tokens, int count);
 274
 275 char* wtrimspace(char *s);
 276
 277
 278 WMRange wmkrange(int start, int count);
 279 #ifdef ANSI_C_DOESNT_LIKE_IT_THIS_WAY
 280 #define wmkrange(position, count) (WMRange){(position), (count)}
 281 #endif
 282
 283
 284 char* wusergnusteppath();
 285
 286 char* wdefaultspathfordomain(char *domain);
 287
 288 void wusleep(unsigned int microsec);
 289
 290 #if 0
 291 int wsprintesc(char *buffer, int length, char *format, WMSEscapes **escapes,
 292                int count);
 293 #endif
 294
 295 /*......................................................................*/
 296
 297 /* Event handlers: timer, idle, input */
 298
 299 WMHandlerID WMAddTimerHandler(int milliseconds, WMCallback *callback,
 300                               void *cdata);
 301
 302 WMHandlerID WMAddPersistentTimerHandler(int milliseconds, WMCallback *callback,
 303                                         void *cdata);
 304
 305 void WMDeleteTimerWithClientData(void *cdata);
 306
 307 void WMDeleteTimerHandler(WMHandlerID handlerID);
 308
 309 WMHandlerID WMAddIdleHandler(WMCallback *callback, void *cdata);
 310
 311 void WMDeleteIdleHandler(WMHandlerID handlerID);
 312
 313 WMHandlerID WMAddInputHandler(int fd, int condition, WMInputProc *proc,
 314                               void *clientData);
 315
 316 void WMDeleteInputHandler(WMHandlerID handlerID);
 317
 318
 319 /* This function is used _only_ if you create a non-GUI program.
 320  * For GUI based programs use WMNextEvent()/WMHandleEvent() instead.
 321  * This function will handle all input/timer/idle events, then return.
 322  */
 323
 324 void WHandleEvents();
 325
 326 /*......................................................................*/
 327
 328
 329 WMHashTable* WMCreateHashTable(WMHashTableCallbacks callbacks);
 330
 331 void WMFreeHashTable(WMHashTable *table);
 332
 333 void WMResetHashTable(WMHashTable *table);
 334
 335 unsigned WMCountHashTable(WMHashTable *table);
 336
 337 void* WMHashGet(WMHashTable *table, const void *key);
 338
 339 /* Returns True if there is a value associated with <key> in the table, in
 340  * which case <retKey> and <retItem> will contain the item's internal key
 341  * address and the item's value respectively.
 342  * If there is no value associated with <key> it will return False and in
 343  * this case <retKey> and <retItem> will be undefined.
 344  * Use this when you need to perform your own custom retain/release mechanism
 345  * which requires access to the keys too.
 346  */
 347 Bool WMHashGetItemAndKey(WMHashTable *table, const void *key,
 348                          void **retItem, void **retKey);
 349
 350 /* put data in table, replacing already existing data and returning
 351  * the old value */
 352 void* WMHashInsert(WMHashTable *table, const void *key, const void *data);
 353
 354 void WMHashRemove(WMHashTable *table, const void *key);
 355
 356 /* warning: do not manipulate the table while using the enumerator functions */
 357 WMHashEnumerator WMEnumerateHashTable(WMHashTable *table);
 358
 359 void* WMNextHashEnumeratorItem(WMHashEnumerator *enumerator);
 360
 361 void* WMNextHashEnumeratorKey(WMHashEnumerator *enumerator);
 362
 363 /* Returns True if there is a next element, in which case key and item
 364  * will contain the next element's key and value respectively.
 365  * If there is no next element available it will return False and in this
 366  * case key and item will be undefined.
 367  */
 368 Bool WMNextHashEnumeratorItemAndKey(WMHashEnumerator *enumerator,
 369                                     void **item, void **key);
 370
 371
 372
 373
 374 /* some predefined callback sets */
 375
 376 extern const WMHashTableCallbacks WMIntHashCallbacks;
 377 /* sizeof(keys) are <= sizeof(void*) */
 378
 379 extern const WMHashTableCallbacks WMStringHashCallbacks;
 380 /* keys are strings. Strings will be copied with wstrdup()
 381  * and freed with wfree() */
 382
 383 extern const WMHashTableCallbacks WMStringPointerHashCallbacks;
 384 /* keys are strings, bug they are not copied */
 385
 386
 387 /*......................................................................*/
 388
 389 /*
 390  * WMArray use an array to store the elements.
 391  * Item indexes may be only positive integer numbers.
 392  * The array cannot contain holes in it.
 393  *
 394  * Pros:
 395  * Fast [O(1)] access to elements
 396  * Fast [O(1)] push/pop
 397  *
 398  * Cons:
 399  * A little slower [O(n)] for insertion/deletion of elements that
 400  *      aren't in the end
 401  */
 402
 403 WMArray* WMCreateArray(int initialSize);
 404
 405 WMArray* WMCreateArrayWithDestructor(int initialSize, WMFreeDataProc *destructor);
 406
 407 WMArray* WMCreateArrayWithArray(WMArray *array);
 408
 409 #define WMDuplicateArray(array) WMCreateArrayWithArray(array)
 410
 411 void WMEmptyArray(WMArray *array);
 412
 413 void WMFreeArray(WMArray *array);
 414
 415 int WMGetArrayItemCount(WMArray *array);
 416
 417 /* appends other to array. other remains unchanged */
 418 void WMAppendArray(WMArray *array, WMArray *other);
 419
 420 /* add will place the element at the end of the array */
 421 void WMAddToArray(WMArray *array, void *item);
 422
 423 #define WMPushInArray(array, item) WMAddToArray(array, item)
 424
 425 /* insert will increment the index of elements after it by 1 */
 426 void WMInsertInArray(WMArray *array, int index, void *item);
 427
 428 /* replace and set will return the old item WITHOUT calling the
 429  * destructor on it even if its available. Free the returned item yourself.
 430  */
 431 void* WMReplaceInArray(WMArray *array, int index, void *item);
 432
 433 #define WMSetInArray(array, index, item) WMReplaceInArray(array, index, item)
 434
 435 /* delete and remove will remove the elements and cause the elements
 436  * after them to decrement their indexes by 1. Also will call the
 437  * destructor on the deleted element if there's one available.
 438  */
 439 int WMDeleteFromArray(WMArray *array, int index);
 440
 441 #define WMRemoveFromArray(array, item) WMRemoveFromArrayMatching(array, NULL, item)
 442
 443 int WMRemoveFromArrayMatching(WMArray *array, WMMatchDataProc *match, void *cdata);
 444
 445 void* WMGetFromArray(WMArray *array, int index);
 446
 447 #define WMGetFirstInArray(array, item) WMFindInArray(array, NULL, item)
 448
 449 /* pop will return the last element from the array, also removing it
 450  * from the array. The destructor is NOT called, even if available.
 451  * Free the returned element if needed by yourself
 452  */
 453 void* WMPopFromArray(WMArray *array);
 454
 455 int WMFindInArray(WMArray *array, WMMatchDataProc *match, void *cdata);
 456
 457 int WMCountInArray(WMArray *array, void *item);
 458
 459 /* comparer must return:
 460  * < 0 if a < b
 461  * > 0 if a > b
 462  * = 0 if a = b
 463  */
 464 void WMSortArray(WMArray *array, WMCompareDataProc *comparer);
 465
 466 void WMMapArray(WMArray *array, void (*function)(void*, void*), void *data);
 467
 468 WMArray* WMGetSubarrayWithRange(WMArray* array, WMRange aRange);
 469
 470 void* WMArrayFirst(WMArray *array, WMArrayIterator *iter);
 471
 472 void* WMArrayLast(WMArray *array, WMArrayIterator *iter);
 473
 474 /* The following 2 functions assume that the array doesn't change between calls */
 475 void* WMArrayNext(WMArray *array, WMArrayIterator *iter);
 476
 477 void* WMArrayPrevious(WMArray *array, WMArrayIterator *iter);
 478
 479
 480 /* The following 2 macros assume that the array doesn't change in the for loop */
 481 #define WM_ITERATE_ARRAY(array, var, i) \
 482         for (var = WMArrayFirst(array, &(i)); (i) != WANotFound; \
 483                 var = WMArrayNext(array, &(i)))
 484
 485 #define WM_ETARETI_ARRAY(array, var, i) \
 486         for (var = WMArrayLast(array, &(i)); (i) != WANotFound; \
 487                 var = WMArrayPrevious(array, &(i)))
 488
 489 /*..........................................................................*/
 490
 491 /*
 492  * Tree bags use a red-black tree for storage.
 493  * Item indexes may be any integer number.
 494  *
 495  * Pros:
 496  * O(lg n) insertion/deletion/search
 497  * Good for large numbers of elements with sparse indexes
 498  *
 499  * Cons:
 500  * O(lg n) insertion/deletion/search
 501  * Slow for storing small numbers of elements
 502  */
 503
 504 #define WMCreateBag(size) WMCreateTreeBag()
 505
 506 #define WMCreateBagWithDestructor(size, d) WMCreateTreeBagWithDestructor(d)
 507
 508 WMBag* WMCreateTreeBag(void);
 509
 510 WMBag* WMCreateTreeBagWithDestructor(WMFreeDataProc *destructor);
 511
 512 int WMGetBagItemCount(WMBag *bag);
 513
 514 void WMAppendBag(WMBag *bag, WMBag *other);
 515
 516 void WMPutInBag(WMBag *bag, void *item);
 517
 518 /* insert will increment the index of elements after it by 1 */
 519 void WMInsertInBag(WMBag *bag, int index, void *item);
 520
 521 /* erase will remove the element from the bag,
 522  * but will keep the index of the other elements unchanged */
 523 int WMEraseFromBag(WMBag *bag, int index);
 524
 525 /* delete and remove will remove the elements and cause the elements
 526  * after them to decrement their indexes by 1 */
 527 int WMDeleteFromBag(WMBag *bag, int index);
 528
 529 int WMRemoveFromBag(WMBag *bag, void *item);
 530
 531 void* WMGetFromBag(WMBag *bag, int index);
 532
 533 void* WMReplaceInBag(WMBag *bag, int index, void *item);
 534
 535 #define WMSetInBag(bag, index, item) WMReplaceInBag(bag, index, item)
 536
 537 /* comparer must return:
 538  * < 0 if a < b
 539  * > 0 if a > b
 540  * = 0 if a = b
 541  */
 542 void WMSortBag(WMBag *bag, WMCompareDataProc *comparer);
 543
 544 void WMEmptyBag(WMBag *bag);
 545
 546 void WMFreeBag(WMBag *bag);
 547
 548 void WMMapBag(WMBag *bag, void (*function)(void*, void*), void *data);
 549
 550 int WMGetFirstInBag(WMBag *bag, void *item);
 551
 552 int WMCountInBag(WMBag *bag, void *item);
 553
 554 int WMFindInBag(WMBag *bag, WMMatchDataProc *match, void *cdata);
 555
 556 void* WMBagFirst(WMBag *bag, WMBagIterator *ptr);
 557
 558 void* WMBagLast(WMBag *bag, WMBagIterator *ptr);
 559
 560 /* The following 4 functions assume that the bag doesn't change between calls */
 561 void* WMBagNext(WMBag *bag, WMBagIterator *ptr);
 562
 563 void* WMBagPrevious(WMBag *bag, WMBagIterator *ptr);
 564
 565 void* WMBagIteratorAtIndex(WMBag *bag, int index, WMBagIterator *ptr);
 566
 567 int WMBagIndexForIterator(WMBag *bag, WMBagIterator ptr);
 568
 569
 570 /* The following 2 macros assume that the bag doesn't change in the for loop */
 571 #define WM_ITERATE_BAG(bag, var, i) \
 572         for (var = WMBagFirst(bag, &(i)); (i) != NULL; \
 573                 var = WMBagNext(bag, &(i)))
 574
 575 #define WM_ETARETI_BAG(bag, var, i) \
 576         for (var = WMBagLast(bag, &(i)); (i) != NULL; \
 577                 var = WMBagPrevious(bag, &(i)))
 578
 579
 580
 581 /*-------------------------------------------------------------------------*/
 582
 583 /* WMData handling */
 584
 585 /* Creating/destroying data */
 586
 587 WMData* WMCreateDataWithCapacity(unsigned capacity);
 588
 589 WMData* WMCreateDataWithLength(unsigned length);
 590
 591 WMData* WMCreateDataWithBytes(void *bytes, unsigned length);
 592
 593 /* destructor is a function called to free the data when releasing the data
 594  * object, or NULL if no freeing of data is necesary. */
 595 WMData* WMCreateDataWithBytesNoCopy(void *bytes, unsigned length,
 596                                     WMFreeDataProc *destructor);
 597
 598 WMData* WMCreateDataWithData(WMData *aData);
 599
 600 WMData* WMRetainData(WMData *aData);
 601
 602 void WMReleaseData(WMData *aData);
 603
 604 /* Adjusting capacity */
 605
 606 void WMSetDataCapacity(WMData *aData, unsigned capacity);
 607
 608 void WMSetDataLength(WMData *aData, unsigned length);
 609
 610 void WMIncreaseDataLengthBy(WMData *aData, unsigned extraLength);
 611
 612 /* Accessing data */
 613
 614 const void* WMDataBytes(WMData *aData);
 615
 616 void WMGetDataBytes(WMData *aData, void *buffer);
 617
 618 void WMGetDataBytesWithLength(WMData *aData, void *buffer, unsigned length);
 619
 620 void WMGetDataBytesWithRange(WMData *aData, void *buffer, WMRange aRange);
 621
 622 WMData* WMGetSubdataWithRange(WMData *aData, WMRange aRange);
 623
 624 /* Testing data */
 625
 626 Bool WMIsDataEqualToData(WMData *aData, WMData *anotherData);
 627
 628 unsigned WMGetDataLength(WMData *aData);
 629
 630 /* Adding data */
 631
 632 void WMAppendDataBytes(WMData *aData, void *bytes, unsigned length);
 633
 634 void WMAppendData(WMData *aData, WMData *anotherData);
 635
 636 /* Modifying data */
 637
 638 void WMReplaceDataBytesInRange(WMData *aData, WMRange aRange, void *bytes);
 639
 640 void WMResetDataBytesInRange(WMData *aData, WMRange aRange);
 641
 642 void WMSetData(WMData *aData, WMData *anotherData);
 643
 644
 645 void WMSetDataFormat(WMData *aData, unsigned format);
 646
 647 unsigned WMGetDataFormat(WMData *aData);
 648 /* Storing data */
 649
 650
 651 /*--------------------------------------------------------------------------*/
 652
 653 /* Generic Tree and TreeNode */
 654
 655 WMTreeNode* WMCreateTreeNode(void *data);
 656
 657 WMTreeNode* WMCreateTreeNodeWithDestructor(void *data, WMFreeDataProc *destructor);
 658
 659 WMTreeNode* WMInsertItemInTree(WMTreeNode *parent, int index, void *item);
 660
 661 #define WMAddItemToTree(parent, item)  WMInsertItemInTree(parent, -1, item)
 662
 663 WMTreeNode* WMInsertNodeInTree(WMTreeNode *parent, int index, WMTreeNode *aNode);
 664
 665 #define WMAddNodeToTree(parent, aNode)  WMInsertNodeInTree(parent, -1, aNode)
 666
 667 void WMDestroyTreeNode(WMTreeNode *aNode);
 668
 669 void WMDeleteLeafForTreeNode(WMTreeNode *aNode, int index);
 670
 671 void WMRemoveLeafForTreeNode(WMTreeNode *aNode, void *leaf);
 672
 673 void* WMReplaceDataForTreeNode(WMTreeNode *aNode, void *newData);
 674
 675 void* WMGetDataForTreeNode(WMTreeNode *aNode);
 676
 677 int WMGetTreeNodeDepth(WMTreeNode *aNode);
 678
 679 WMTreeNode* WMGetParentForTreeNode(WMTreeNode *aNode);
 680
 681 /* Sort only the leaves of the passed node */
 682 void WMSortLeavesForTreeNode(WMTreeNode *aNode, WMCompareDataProc *comparer);
 683
 684 /* Sort all tree recursively starting from the passed node */
 685 void WMSortTree(WMTreeNode *aNode, WMCompareDataProc *comparer);
 686
 687 /* Returns the first node which matches node's data with cdata by 'match' */
 688 WMTreeNode* WMFindInTree(WMTreeNode *aTree, WMMatchDataProc *match, void *cdata);
 689
 690 /* Returns first tree node that has data == cdata */
 691 #define WMGetFirstInTree(aTree, cdata) WMFindInTree(atree, NULL, cdata)
 692
 693
 694 /*--------------------------------------------------------------------------*/
 695
 696
 697 WMNotification* WMCreateNotification(const char *name, void *object, void *clientData);
 698
 699 void WMReleaseNotification(WMNotification *notification);
 700
 701 WMNotification* WMRetainNotification(WMNotification *notification);
 702
 703 void* WMGetNotificationClientData(WMNotification *notification);
 704
 705 void* WMGetNotificationObject(WMNotification *notification);
 706
 707 const char* WMGetNotificationName(WMNotification *notification);
 708
 709
 710 void WMAddNotificationObserver(WMNotificationObserverAction *observerAction,
 711                                void *observer, const char *name, void *object);
 712
 713 void WMPostNotification(WMNotification *notification);
 714
 715 void WMRemoveNotificationObserver(void *observer);
 716
 717 void WMRemoveNotificationObserverWithName(void *observer, const char *name,
 718                                           void *object);
 719
 720 void WMPostNotificationName(const char *name, void *object, void *clientData);
 721
 722 WMNotificationQueue* WMGetDefaultNotificationQueue(void);
 723
 724 WMNotificationQueue* WMCreateNotificationQueue(void);
 725
 726 void WMDequeueNotificationMatching(WMNotificationQueue *queue,
 727                                    WMNotification *notification,
 728                                    unsigned mask);
 729
 730 void WMEnqueueNotification(WMNotificationQueue *queue,
 731                            WMNotification *notification,
 732                            WMPostingStyle postingStyle);
 733
 734 void WMEnqueueCoalesceNotification(WMNotificationQueue *queue,
 735                                    WMNotification *notification,
 736                                    WMPostingStyle postingStyle,
 737                                    unsigned coalesceMask);
 738
 739
 740 /*......................................................................*/
 741
 742 /* Property Lists handling */
 743
 744 void WMSetPropListStringComparer(WMCompareDataProc *comparer);
 745
 746 WMPropList* WMCreatePropListString(char *str);
 747
 748 WMPropList* WMCreatePropListDataWithBytes(unsigned char *bytes,
 749                                           unsigned int length);
 750 WMPropList* WMCreatePropListDataWithBytesNoCopy(unsigned char *bytes,
 751                                                 unsigned int length,
 752                                                 WMFreeDataProc *destructor);
 753
 754 WMPropList* WMCreatePropListDataWithData(WMData *data);
 755
 756 WMPropList* WMCreatePropListArrayFromElements(WMPropList *elem, ...);
 757
 758 WMPropList* WMCreatePropListDictionaryFromEntries(WMPropList *key,
 759                                                   WMPropList *value, ...);
 760
 761 void WMInsertPropListArrayElement(WMPropList *plist, WMPropList *item, int index);
 762
 763 void WMAppendPropListArrayElement(WMPropList *plist, WMPropList *item);
 764
 765 void WMRemovePropListArrayElement(WMPropList *plist, int index);
 766
 767 void WMInsertPropListDictionaryEntry(WMPropList *plist, WMPropList *key,
 768                                      WMPropList *value);
 769
 770 void WMRemovePropListDictionaryEntry(WMPropList *plist, WMPropList *key);
 771
 772 WMPropList* WMMergePropListDictionaries(WMPropList *dest, WMPropList *source);
 773
 774 WMPropList* WMRetainPropList(WMPropList *plist);
 775
 776 void WMReleasePropList(WMPropList *plist);
 777
 778 Bool WMPropListIsString(WMPropList *plist);
 779
 780 Bool WMPropListIsData(WMPropList *plist);
 781
 782 Bool WMPropListIsArray(WMPropList *plist);
 783
 784 Bool WMPropListIsDictionary(WMPropList *plist);
 785
 786 Bool WMPropListIsSimple(WMPropList *plist);
 787
 788 Bool WMPropListIsCompound(WMPropList *plist);
 789
 790 Bool WMIsPropListEqualToPropList(WMPropList *plist, WMPropList *other);
 791
 792 int WMGetPropListNumberOfElements(WMPropList *plist);
 793
 794 char* WMGetPropListString(WMPropList *plist);
 795
 796 WMData* WMGetPropListData(WMPropList *plist);
 797
 798 const unsigned char* WMGetPropListDataBytes(WMPropList *plist);
 799
 800 int WMGetPropListDataLength(WMPropList *plist);
 801
 802 WMPropList* WMGetPropListArrayElement(WMPropList *plist, int index);
 803
 804 WMPropList* WMGetPropListDictionaryEntry(WMPropList *plist, WMPropList *key);
 805
 806 WMPropList* WMGetPropListAllDictionaryKeys(WMPropList *plist);
 807
 808 char* WMGetPropListDescription(WMPropList *plist, Bool indented);
 809
 810 Bool WMSavePropListToFile(WMPropList *plist, char *path, Bool atomically);
 811
 812 WMPropList* WMShallowCopyPropList(WMPropList *plist);
 813
 814 WMPropList* WMDeepCopyPropList(WMPropList *plist);
 815
 816 /*......................................................................*/
 817
 818 WMUserDefaults* WMGetStandardUserDefaults(void);
 819
 820 WMUserDefaults* WMGetDefaultsFromPath(char *path);
 821
 822 void WMSynchronizeUserDefaults(WMUserDefaults *database);
 823
 824 void WMSaveUserDefaults(WMUserDefaults *database);
 825
 826 void WMEnableUDPeriodicSynchronization(WMUserDefaults *database, Bool enable);
 827
 828 /* Returns a PLArray with all keys in the user defaults database.
 829  * Free the returned array with PLRelease() when no longer needed,
 830  * but do not free the elements of the array! They're just references. */
 831 proplist_t WMGetUDAllKeys(WMUserDefaults *database);
 832
 833 proplist_t WMGetUDObjectForKey(WMUserDefaults *database, char *defaultName);
 834
 835 void WMSetUDObjectForKey(WMUserDefaults *database, proplist_t object,
 836                          char *defaultName);
 837
 838 void WMRemoveUDObjectForKey(WMUserDefaults *database, char *defaultName);
 839
 840 char* WMGetUDStringForKey(WMUserDefaults *database, char *defaultName);
 841
 842 int WMGetUDIntegerForKey(WMUserDefaults *database, char *defaultName);
 843
 844 float WMGetUDFloatForKey(WMUserDefaults *database, char *defaultName);
 845
 846 Bool WMGetUDBoolForKey(WMUserDefaults *database, char *defaultName);
 847
 848 void WMSetUDStringForKey(WMUserDefaults *database, char *value,
 849                          char *defaultName);
 850
 851 void WMSetUDIntegerForKey(WMUserDefaults *database, int value,
 852                           char *defaultName);
 853
 854 void WMSetUDFloatForKey(WMUserDefaults *database, float value,
 855                         char *defaultName);
 856
 857 void WMSetUDBoolForKey(WMUserDefaults *database, Bool value,
 858                        char *defaultName);
 859
 860 proplist_t WMGetUDSearchList(WMUserDefaults *database);
 861
 862 void WMSetUDSearchList(WMUserDefaults *database, proplist_t list);
 863
 864 extern char *WMUserDefaultsDidChangeNotification;
 865
 866
 867 /*-------------------------------------------------------------------------*/
 868
 869 /* WMHost: host handling */
 870
 871 WMHost* WMGetCurrentHost();
 872
 873 WMHost* WMGetHostWithName(char* name);
 874
 875 WMHost* WMGetHostWithAddress(char* address);
 876
 877 WMHost* WMRetainHost(WMHost *hPtr);
 878
 879 void WMReleaseHost(WMHost *hPtr);
 880
 881 /*
 882  * Host cache management
 883  * If enabled, only one object representing each host will be created, and
 884  * a shared instance will be returned by all methods that return a host.
 885  * Enabled by default.
 886  */
 887 void WMSetHostCacheEnabled(Bool flag);
 888
 889 Bool WMIsHostCacheEnabled();
 890
 891 void WMFlushHostCache();
 892
 893 /*
 894  * Compare hosts: Hosts are equal if they share at least one address
 895  */
 896 Bool WMIsHostEqualToHost(WMHost* hPtr, WMHost* anotherHost);
 897
 898 /*
 899  * Host names.
 900  * WMGetHostName() will return first name (official) if a host has several.
 901  * WMGetHostNames() will return a R/O WMArray with all the names of the host.
 902  */
 903 char* WMGetHostName(WMHost* hPtr);
 904
 905 /* The returned array is R/O. Do not modify it, and do not free it! */
 906 WMArray* WMGetHostNames(WMHost* hPtr);
 907
 908 /*
 909  * Host addresses.
 910  * Addresses are represented as "Dotted Decimal" strings, e.g. "192.42.172.1"
 911  * WMGetHostAddress() will return an arbitrary address if a host has several.
 912  * WMGetHostAddresses() will return a R/O WMArray with all addresses of the host.
 913  */
 914 char* WMGetHostAddress(WMHost* hPtr);
 915
 916 /* The returned array is R/O. Do not modify it, and do not free it! */
 917 WMArray* WMGetHostAddresses(WMHost* hPtr);
 918
 919
 920 /*-------------------------------------------------------------------------*/
 921
 922 /* WMConnection functions */
 923
 924 WMConnection* WMCreateConnectionAsServerAtAddress(char *host, char *service,
 925                                                   char *protocol);
 926
 927 WMConnection* WMCreateConnectionToAddress(char *host, char *service,
 928                                           char *protocol);
 929
 930 WMConnection* WMCreateConnectionToAddressAndNotify(char *host, char *service,
 931                                                    char *protocol);
 932
 933 void WMCloseConnection(WMConnection *cPtr);
 934
 935 void WMDestroyConnection(WMConnection *cPtr);
 936
 937 WMConnection* WMAcceptConnection(WMConnection *listener);
 938
 939 /* Release the returned data! */
 940 WMData* WMGetConnectionAvailableData(WMConnection *cPtr);
 941
 942 int WMSendConnectionData(WMConnection *cPtr, WMData *data);
 943
 944 Bool WMEnqueueConnectionData(WMConnection *cPtr, WMData *data);
 945
 946 #define WMFlushConnection(cPtr)  WMSendConnectionData((cPtr), NULL)
 947
 948 void WMSetConnectionDelegate(WMConnection *cPtr, ConnectionDelegate *delegate);
 949
 950 /* Connection info */
 951
 952 char* WMGetConnectionAddress(WMConnection *cPtr);
 953
 954 char* WMGetConnectionService(WMConnection *cPtr);
 955
 956 char* WMGetConnectionProtocol(WMConnection *cPtr);
 957
 958 Bool WMSetConnectionNonBlocking(WMConnection *cPtr, Bool flag);
 959
 960 Bool WMSetConnectionCloseOnExec(WMConnection *cPtr, Bool flag);
 961
 962 void* WMGetConnectionClientData(WMConnection *cPtr);
 963
 964 void WMSetConnectionClientData(WMConnection *cPtr, void *data);
 965
 966 unsigned int WMGetConnectionFlags(WMConnection *cPtr);
 967
 968 void WMSetConnectionFlags(WMConnection *cPtr, unsigned int flags);
 969
 970 int WMGetConnectionSocket(WMConnection *cPtr);
 971
 972 WMConnectionState WMGetConnectionState(WMConnection *cPtr);
 973
 974 WMConnectionTimeoutState WMGetConnectionTimeoutState(WMConnection *cPtr);
 975
 976 WMArray* WMGetConnectionUnsentData(WMConnection *cPtr);
 977
 978 #define WMGetConnectionQueuedData(cPtr) WMGetConnectionUnsentData(cPtr)
 979
 980
 981 /*
 982  * Passing timeout==0 in the SetTimeout functions below, will reset that
 983  * timeout to its default value.
 984  */
 985
 986 /* The default timeout inherited by all WMConnection operations, if none set */
 987 void WMSetConnectionDefaultTimeout(unsigned int timeout);
 988
 989 /* Global timeout for all WMConnection objects, for opening a new connection */
 990 void WMSetConnectionOpenTimeout(unsigned int timeout);
 991
 992 /* Connection specific timeout for sending out data */
 993 void WMSetConnectionSendTimeout(WMConnection *cPtr, unsigned int timeout);
 994
 995
 996 /* Global variables */
 997
 998 extern int WCErrorCode;
 999
1000
1001 /*-------------------------------------------------------------------------*/
1002
1003
1004
1005 #ifdef __cplusplus
1006 }
1007 #endif /* __cplusplus */
1008
1009
1010 #endif