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