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_HashTable WMHashTable;
 124 typedef struct W_UserDefaults WMUserDefaults;
 125 typedef struct W_Notification WMNotification;
 126 typedef struct W_NotificationQueue WMNotificationQueue;
 127 typedef struct W_Host WMHost;
 128 typedef struct W_Connection WMConnection;
 129
 130
 131
 132 typedef int WMCompareDataProc(const void *item1, const void *item2);
 133
 134 typedef void WMFreeDataProc(void *data);
 135
 136 /* Used by WMBag or WMArray for matching data */
 137 typedef int WMMatchDataProc(void *item, void *cdata);
 138
 139
 140
 141
 142 typedef struct {
 143     int position;
 144     int count;
 145 } WMRange;
 146
 147
 148
 149 /* DO NOT ACCESS THE CONTENTS OF THIS STRUCT */
 150 typedef struct {
 151     void *table;
 152     void *nextItem;
 153     int index;
 154 } WMHashEnumerator;
 155
 156
 157 typedef struct {
 158     /* NULL is pointer hash */
 159     unsigned    (*hash)(const void *);
 160     /* NULL is pointer compare */
 161     Bool        (*keyIsEqual)(const void *, const void *);
 162     /* NULL does nothing */
 163     void*       (*retainKey)(const void *);
 164     /* NULL does nothing */
 165     void        (*releaseKey)(const void *);
 166 } WMHashTableCallbacks;
 167
 168
 169 typedef void *WMBagIterator;
 170
 171
 172 #if 0
 173 typedef struct {
 174     char character;                    /* the escape character */
 175     char *value;                       /* value to place */
 176 } WMSEscapes;
 177 #endif
 178
 179
 180 /* The connection callbacks */
 181 typedef struct ConnectionDelegate {
 182     void *data;
 183
 184     void (*didCatchException)(struct ConnectionDelegate *self,
 185                               WMConnection *cPtr);
 186
 187     void (*didDie)(struct ConnectionDelegate *self, WMConnection *cPtr);
 188
 189     void (*didInitialize)(struct ConnectionDelegate *self, WMConnection *cPtr);
 190
 191     void (*didReceiveInput)(struct ConnectionDelegate *self, WMConnection *cPtr);
 192
 193     void (*didTimeout)(struct ConnectionDelegate *self, WMConnection *cPtr);
 194
 195 } ConnectionDelegate;
 196
 197
 198 typedef void WMNotificationObserverAction(void *observerData,
 199                                           WMNotification *notification);
 200
 201
 202
 203 /*......................................................................*/
 204
 205 typedef void (waborthandler)(int);
 206
 207 waborthandler* wsetabort(waborthandler*);
 208
 209
 210 /* don't free the returned string */
 211 char* wstrerror(int errnum);
 212
 213 void wmessage(const char *msg, ...);
 214 void wwarning(const char *msg, ...);
 215 void wfatal(const char *msg, ...);
 216 void wsyserror(const char *msg, ...);
 217 void wsyserrorwithcode(int error, const char *msg, ...);
 218
 219 char* wfindfile(char *paths, char *file);
 220
 221 char* wfindfileinlist(char **path_list, char *file);
 222
 223 char* wfindfileinarray(proplist_t array, char *file);
 224
 225 char* wexpandpath(char *path);
 226
 227 /* don't free the returned string */
 228 char* wgethomedir();
 229
 230 void* wmalloc(size_t size);
 231 void* wrealloc(void *ptr, size_t newsize);
 232 void wfree(void *ptr);
 233
 234
 235 void wrelease(void *ptr);
 236 void* wretain(void *ptr);
 237
 238 char* wstrdup(char *str);
 239
 240 /* Concatenate str1 with str2 and return that in a newly malloc'ed string.
 241  * str1 and str2 can be any strings including static and constant strings.
 242  * str1 and str2 will not be modified.
 243  * Free the returned string when you're done with it. */
 244 char* wstrconcat(char *str1, char *str2);
 245
 246 /* This will append src to dst, and return dst. dst MUST be either NULL
 247  * or a string that was a result of a dynamic allocation (malloc, realloc
 248  * wmalloc, wrealloc, ...). dst CANNOT be a static or a constant string!
 249  * Modifies dst (no new string is created except if dst==NULL in which case
 250  * it is equivalent to calling wstrdup(src) ).
 251  * The returned address may be different from the original address of dst,
 252  * so always assign the returned address to avoid dangling pointers. */
 253 char* wstrappend(char *dst, char *src);
 254
 255
 256 void wtokensplit(char *command, char ***argv, int *argc);
 257
 258 char* wtokennext(char *word, char **next);
 259
 260 char* wtokenjoin(char **list, int count);
 261
 262 void wtokenfree(char **tokens, int count);
 263
 264 char* wtrimspace(char *s);
 265
 266
 267
 268 char* wusergnusteppath();
 269
 270 char* wdefaultspathfordomain(char *domain);
 271
 272 void wusleep(unsigned int microsec);
 273
 274 #if 0
 275 int wsprintesc(char *buffer, int length, char *format, WMSEscapes **escapes,
 276                int count);
 277 #endif
 278
 279 /*......................................................................*/
 280
 281 /* This function is used _only_ if you create a NON-GUI program.
 282  * For GUI based programs use WMNextEvent()/WMHandleEvent() instead.
 283  * This function will handle all input/timer/idle events, then return.
 284  */
 285
 286 void WHandleEvents();
 287
 288 /*......................................................................*/
 289
 290
 291 WMHashTable* WMCreateHashTable(WMHashTableCallbacks callbacks);
 292
 293 void WMFreeHashTable(WMHashTable *table);
 294
 295 void WMResetHashTable(WMHashTable *table);
 296
 297 const void* WMHashGet(WMHashTable *table, const void *key);
 298
 299 /* put data in table, replacing already existing data and returning
 300  * the old value */
 301 const void* WMHashInsert(WMHashTable *table, const void *key, const void *data);
 302
 303 void WMHashRemove(WMHashTable *table, const void *key);
 304
 305 /* warning: do not manipulate the table while using these functions */
 306 WMHashEnumerator WMEnumerateHashTable(WMHashTable *table);
 307
 308 const void* WMNextHashEnumeratorItem(WMHashEnumerator *enumerator);
 309
 310 unsigned WMCountHashTable(WMHashTable *table);
 311
 312
 313
 314
 315 /* some predefined callback sets */
 316
 317 extern const WMHashTableCallbacks WMIntHashCallbacks;
 318 /* sizeof(keys) are <= sizeof(void*) */
 319
 320 extern const WMHashTableCallbacks WMStringHashCallbacks;
 321 /* keys are strings. Strings will be copied with wstrdup()
 322  * and freed with wfree() */
 323
 324 extern const WMHashTableCallbacks WMStringPointerHashCallbacks;
 325 /* keys are strings, bug they are not copied */
 326
 327
 328 /*......................................................................*/
 329
 330 /*
 331  * WMArray use an array to store the elements.
 332  * Item indexes may be only positive integer numbers.
 333  * The array cannot contain holes in it.
 334  *
 335  * Pros:
 336  * Fast [O(1)] access to elements
 337  * Fast [O(1)] push/pop
 338  *
 339  * Cons:
 340  * A little slower [O(n)] for insertion/deletion of elements that
 341  *      aren't in the end
 342  */
 343
 344 WMArray* WMCreateArray(int initialSize);
 345
 346 WMArray* WMCreateArrayWithDestructor(int initialSize, WMFreeDataProc *destructor);
 347
 348 WMArray* WMCreateArrayWithArray(WMArray *array);
 349
 350 #define WMDuplicateArray(array) WMCreateArrayWithArray(array)
 351
 352 void WMEmptyArray(WMArray *array);
 353
 354 void WMFreeArray(WMArray *array);
 355
 356 int WMGetArrayItemCount(WMArray *array);
 357
 358 /* appends other to array. other remains unchanged */
 359 void WMAppendArray(WMArray *array, WMArray *other);
 360
 361 /* add will place the element at the end of the array */
 362 void WMAddToArray(WMArray *array, void *item);
 363
 364 #define WMPushInArray(array, item) WMAddToArray(array, item)
 365
 366 /* insert will increment the index of elements after it by 1 */
 367 void WMInsertInArray(WMArray *array, int index, void *item);
 368
 369 /* replace and set will return the old item WITHOUT calling the
 370  * destructor on it even if its available. Free the returned item yourself.
 371  */
 372 void* WMReplaceInArray(WMArray *array, int index, void *item);
 373
 374 #define WMSetInArray(array, index, item) WMReplaceInArray(array, index, item)
 375
 376 /* delete and remove will remove the elements and cause the elements
 377  * after them to decrement their indexes by 1. Also will call the
 378  * destructor on the deleted element if there's one available.
 379  */
 380 int WMDeleteFromArray(WMArray *array, int index);
 381
 382 int WMRemoveFromArray(WMArray *array, void *item);
 383
 384 void* WMGetFromArray(WMArray *array, int index);
 385
 386 #define WMGetFirstInArray(array, item) WMFindInArray(array, NULL, item)
 387
 388 /* pop will return the last element from the array, also removing it
 389  * from the array. The destructor is NOT called, even if available.
 390  * Free the returned element if needed by yourself
 391  */
 392 void* WMPopFromArray(WMArray *array);
 393
 394 int WMFindInArray(WMArray *array, WMMatchDataProc *match, void *cdata);
 395
 396 int WMCountInArray(WMArray *array, void *item);
 397
 398 /* comparer must return:
 399  * < 0 if a < b
 400  * > 0 if a > b
 401  * = 0 if a = b
 402  */
 403 void WMSortArray(WMArray *array, WMCompareDataProc *comparer);
 404
 405 void WMMapArray(WMArray *array, void (*function)(void*, void*), void *data);
 406
 407 WMArray* WMGetSubarrayWithRange(WMArray* array, WMRange aRange);
 408
 409
 410 /*..........................................................................*/
 411
 412 /*
 413  * Tree bags use a red-black tree for storage.
 414  * Item indexes may be any integer number.
 415  *
 416  * Pros:
 417  * O(lg n) insertion/deletion/search
 418  * Good for large numbers of elements with sparse indexes
 419  *
 420  * Cons:
 421  * O(lg n) insertion/deletion/search
 422  * Slow for storing small numbers of elements
 423  */
 424
 425 #define WMCreateBag(size) WMCreateTreeBag()
 426
 427 #define WMCreateBagWithDestructor(size, d) WMCreateTreeBagWithDestructor(d)
 428
 429 WMBag* WMCreateTreeBag(void);
 430
 431 WMBag* WMCreateTreeBagWithDestructor(WMFreeDataProc *destructor);
 432
 433 int WMGetBagItemCount(WMBag *bag);
 434
 435 void WMAppendBag(WMBag *bag, WMBag *other);
 436
 437 void WMPutInBag(WMBag *bag, void *item);
 438
 439 /* insert will increment the index of elements after it by 1 */
 440 void WMInsertInBag(WMBag *bag, int index, void *item);
 441
 442 /* this is slow */
 443 /* erase will remove the element from the bag,
 444  * but will keep the index of the other elements unchanged */
 445 int WMEraseFromBag(WMBag *bag, int index);
 446
 447 /* delete and remove will remove the elements and cause the elements
 448  * after them to decrement their indexes by 1 */
 449 int WMDeleteFromBag(WMBag *bag, int index);
 450
 451 int WMRemoveFromBag(WMBag *bag, void *item);
 452
 453 void* WMGetFromBag(WMBag *bag, int index);
 454
 455 void* WMReplaceInBag(WMBag *bag, int index, void *item);
 456
 457 #define WMSetInBag(bag, index, item) WMReplaceInBag(bag, index, item)
 458
 459 /* comparer must return:
 460  * < 0 if a < b
 461  * > 0 if a > b
 462  * = 0 if a = b
 463  */
 464 void WMSortBag(WMBag *bag, WMCompareDataProc *comparer);
 465
 466 void WMEmptyBag(WMBag *bag);
 467
 468 void WMFreeBag(WMBag *bag);
 469
 470 void WMMapBag(WMBag *bag, void (*function)(void*, void*), void *data);
 471
 472 int WMGetFirstInBag(WMBag *bag, void *item);
 473
 474 int WMCountInBag(WMBag *bag, void *item);
 475
 476 int WMFindInBag(WMBag *bag, WMMatchDataProc *match, void *cdata);
 477
 478 void* WMBagFirst(WMBag *bag, WMBagIterator *ptr);
 479
 480 void* WMBagLast(WMBag *bag, WMBagIterator *ptr);
 481
 482 void* WMBagNext(WMBag *bag, WMBagIterator *ptr);
 483
 484 void* WMBagPrevious(WMBag *bag, WMBagIterator *ptr);
 485
 486 void* WMBagIteratorAtIndex(WMBag *bag, int index, WMBagIterator *ptr);
 487
 488 int WMBagIndexForIterator(WMBag *bag, WMBagIterator ptr);
 489
 490
 491 #define WM_ITERATE_BAG(bag, var, i) \
 492         for (var = WMBagFirst(bag, &(i)); (i) != NULL; \
 493                 var = WMBagNext(bag, &(i)))
 494
 495 #define WM_ETARETI_BAG(bag, var, i) \
 496         for (var = WMBagLast(bag, &(i)); (i) != NULL; \
 497                 var = WMBagPrevious(bag, &(i)))
 498
 499
 500
 501 /*-------------------------------------------------------------------------*/
 502
 503 /* WMData handling */
 504
 505 /* Creating/destroying data */
 506
 507 WMData* WMCreateDataWithCapacity(unsigned capacity);
 508
 509 WMData* WMCreateDataWithLength(unsigned length);
 510
 511 WMData* WMCreateDataWithBytes(void *bytes, unsigned length);
 512
 513 /* destructor is a function called to free the data when releasing the data
 514  * object, or NULL if no freeing of data is necesary. */
 515 WMData* WMCreateDataWithBytesNoCopy(void *bytes, unsigned length,
 516                                     WMFreeDataProc *destructor);
 517
 518 WMData* WMCreateDataWithData(WMData *aData);
 519
 520 WMData* WMRetainData(WMData *aData);
 521
 522 void WMReleaseData(WMData *aData);
 523
 524 /* Adjusting capacity */
 525
 526 void WMSetDataCapacity(WMData *aData, unsigned capacity);
 527
 528 void WMSetDataLength(WMData *aData, unsigned length);
 529
 530 void WMIncreaseDataLengthBy(WMData *aData, unsigned extraLength);
 531
 532 /* Accessing data */
 533
 534 const void* WMDataBytes(WMData *aData);
 535
 536 void WMGetDataBytes(WMData *aData, void *buffer);
 537
 538 void WMGetDataBytesWithLength(WMData *aData, void *buffer, unsigned length);
 539
 540 void WMGetDataBytesWithRange(WMData *aData, void *buffer, WMRange aRange);
 541
 542 WMData* WMGetSubdataWithRange(WMData *aData, WMRange aRange);
 543
 544 /* Testing data */
 545
 546 Bool WMIsDataEqualToData(WMData *aData, WMData *anotherData);
 547
 548 unsigned WMGetDataLength(WMData *aData);
 549
 550 /* Adding data */
 551
 552 void WMAppendDataBytes(WMData *aData, void *bytes, unsigned length);
 553
 554 void WMAppendData(WMData *aData, WMData *anotherData);
 555
 556 /* Modifying data */
 557
 558 void WMReplaceDataBytesInRange(WMData *aData, WMRange aRange, void *bytes);
 559
 560 void WMResetDataBytesInRange(WMData *aData, WMRange aRange);
 561
 562 void WMSetData(WMData *aData, WMData *anotherData);
 563
 564
 565 void WMSetDataFormat(WMData *aData, unsigned format);
 566
 567 unsigned WMGetDataFormat(WMData *aData);
 568 /* Storing data */
 569
 570
 571 /*--------------------------------------------------------------------------*/
 572
 573
 574 WMNotification* WMCreateNotification(const char *name, void *object, void *clientData);
 575
 576 void WMReleaseNotification(WMNotification *notification);
 577
 578 WMNotification* WMRetainNotification(WMNotification *notification);
 579
 580 void* WMGetNotificationClientData(WMNotification *notification);
 581
 582 void* WMGetNotificationObject(WMNotification *notification);
 583
 584 const char* WMGetNotificationName(WMNotification *notification);
 585
 586
 587 void WMAddNotificationObserver(WMNotificationObserverAction *observerAction,
 588                                void *observer, const char *name, void *object);
 589
 590 void WMPostNotification(WMNotification *notification);
 591
 592 void WMRemoveNotificationObserver(void *observer);
 593
 594 void WMRemoveNotificationObserverWithName(void *observer, const char *name,
 595                                           void *object);
 596
 597 void WMPostNotificationName(const char *name, void *object, void *clientData);
 598
 599 WMNotificationQueue* WMGetDefaultNotificationQueue(void);
 600
 601 WMNotificationQueue* WMCreateNotificationQueue(void);
 602
 603 void WMDequeueNotificationMatching(WMNotificationQueue *queue,
 604                                    WMNotification *notification,
 605                                    unsigned mask);
 606
 607 void WMEnqueueNotification(WMNotificationQueue *queue,
 608                            WMNotification *notification,
 609                            WMPostingStyle postingStyle);
 610
 611 void WMEnqueueCoalesceNotification(WMNotificationQueue *queue,
 612                                    WMNotification *notification,
 613                                    WMPostingStyle postingStyle,
 614                                    unsigned coalesceMask);
 615
 616
 617 /*......................................................................*/
 618
 619 WMUserDefaults* WMGetStandardUserDefaults(void);
 620
 621 WMUserDefaults* WMGetDefaultsFromPath(char *path);
 622
 623 void WMSynchronizeUserDefaults(WMUserDefaults *database);
 624
 625 void WMSaveUserDefaults(WMUserDefaults *database);
 626
 627 void WMEnableUDPeriodicSynchronization(WMUserDefaults *database, Bool enable);
 628
 629 /* Returns a PLArray with all keys in the user defaults database.
 630  * Free the returned array with PLRelease() when no longer needed,
 631  * but do not free the elements of the array! They're just references. */
 632 proplist_t WMGetUDAllKeys(WMUserDefaults *database);
 633
 634 proplist_t WMGetUDObjectForKey(WMUserDefaults *database, char *defaultName);
 635
 636 void WMSetUDObjectForKey(WMUserDefaults *database, proplist_t object,
 637                          char *defaultName);
 638
 639 void WMRemoveUDObjectForKey(WMUserDefaults *database, char *defaultName);
 640
 641 char* WMGetUDStringForKey(WMUserDefaults *database, char *defaultName);
 642
 643 int WMGetUDIntegerForKey(WMUserDefaults *database, char *defaultName);
 644
 645 float WMGetUDFloatForKey(WMUserDefaults *database, char *defaultName);
 646
 647 Bool WMGetUDBoolForKey(WMUserDefaults *database, char *defaultName);
 648
 649 void WMSetUDStringForKey(WMUserDefaults *database, char *value,
 650                          char *defaultName);
 651
 652 void WMSetUDIntegerForKey(WMUserDefaults *database, int value,
 653                           char *defaultName);
 654
 655 void WMSetUDFloatForKey(WMUserDefaults *database, float value,
 656                         char *defaultName);
 657
 658 void WMSetUDBoolForKey(WMUserDefaults *database, Bool value,
 659                        char *defaultName);
 660
 661 proplist_t WMGetUDSearchList(WMUserDefaults *database);
 662
 663 void WMSetUDSearchList(WMUserDefaults *database, proplist_t list);
 664
 665 extern char *WMUserDefaultsDidChangeNotification;
 666
 667
 668 /*-------------------------------------------------------------------------*/
 669
 670 /* WMHost: host handling */
 671
 672 WMHost* WMGetCurrentHost();
 673
 674 WMHost* WMGetHostWithName(char* name);
 675
 676 WMHost* WMGetHostWithAddress(char* address);
 677
 678 WMHost* WMRetainHost(WMHost *hPtr);
 679
 680 void WMReleaseHost(WMHost *hPtr);
 681
 682 /*
 683  * Host cache management
 684  * If enabled, only one object representing each host will be created, and
 685  * a shared instance will be returned by all methods that return a host.
 686  * Enabled by default.
 687  */
 688 void WMSetHostCacheEnabled(Bool flag);
 689
 690 Bool WMIsHostCacheEnabled();
 691
 692 void WMFlushHostCache();
 693
 694 /*
 695  * Compare hosts: Hosts are equal if they share at least one address
 696  */
 697 Bool WMIsHostEqualToHost(WMHost* hPtr, WMHost* anotherHost);
 698
 699 /*
 700  * Host names.
 701  * WMGetHostName() will return first name (official) if a host has several.
 702  * WMGetHostNames() will return a R/O WMArray with all the names of the host.
 703  */
 704 char* WMGetHostName(WMHost* hPtr);
 705
 706 /* The returned array is R/O. Do not modify it, and do not free it! */
 707 WMArray* WMGetHostNames(WMHost* hPtr);
 708
 709 /*
 710  * Host addresses.
 711  * Addresses are represented as "Dotted Decimal" strings, e.g. "192.42.172.1"
 712  * WMGetHostAddress() will return an arbitrary address if a host has several.
 713  * WMGetHostAddresses() will return a R/O WMArray with all addresses of the host.
 714  */
 715 char* WMGetHostAddress(WMHost* hPtr);
 716
 717 /* The returned array is R/O. Do not modify it, and do not free it! */
 718 WMArray* WMGetHostAddresses(WMHost* hPtr);
 719
 720
 721 /*-------------------------------------------------------------------------*/
 722
 723 /* WMConnection functions */
 724
 725 WMConnection* WMCreateConnectionAsServerAtAddress(char *host, char *service,
 726                                                   char *protocol);
 727
 728 WMConnection* WMCreateConnectionToAddress(char *host, char *service,
 729                                           char *protocol);
 730
 731 WMConnection* WMCreateConnectionToAddressAndNotify(char *host, char *service,
 732                                                    char *protocol);
 733
 734 void WMCloseConnection(WMConnection *cPtr);
 735
 736 void WMDestroyConnection(WMConnection *cPtr);
 737
 738 WMConnection* WMAcceptConnection(WMConnection *listener);
 739
 740 /* Release the returned data! */
 741 WMData* WMGetConnectionAvailableData(WMConnection *cPtr);
 742
 743 int WMSendConnectionData(WMConnection *cPtr, WMData *data);
 744
 745 Bool WMEnqueueConnectionData(WMConnection *cPtr, WMData *data);
 746
 747 #define WMFlushConnection(cPtr)  WMSendConnectionData((cPtr), NULL)
 748
 749 void WMSetConnectionDelegate(WMConnection *cPtr, ConnectionDelegate *delegate);
 750
 751 /* Connection info */
 752
 753 char* WMGetConnectionAddress(WMConnection *cPtr);
 754
 755 char* WMGetConnectionService(WMConnection *cPtr);
 756
 757 char* WMGetConnectionProtocol(WMConnection *cPtr);
 758
 759 Bool WMSetConnectionNonBlocking(WMConnection *cPtr, Bool flag);
 760
 761 Bool WMSetConnectionCloseOnExec(WMConnection *cPtr, Bool flag);
 762
 763 void* WMGetConnectionClientData(WMConnection *cPtr);
 764
 765 void WMSetConnectionClientData(WMConnection *cPtr, void *data);
 766
 767 unsigned int WMGetConnectionFlags(WMConnection *cPtr);
 768
 769 void WMSetConnectionFlags(WMConnection *cPtr, unsigned int flags);
 770
 771 int WMGetConnectionSocket(WMConnection *cPtr);
 772
 773 WMConnectionState WMGetConnectionState(WMConnection *cPtr);
 774
 775 WMConnectionTimeoutState WMGetConnectionTimeoutState(WMConnection *cPtr);
 776
 777 WMArray* WMGetConnectionUnsentData(WMConnection *cPtr);
 778
 779 #define WMGetConnectionQueuedData(cPtr) WMGetConnectionUnsentData(cPtr)
 780
 781
 782 /*
 783  * Passing timeout==0 in the SetTimeout functions below, will reset that
 784  * timeout to its default value.
 785  */
 786
 787 /* The default timeout inherited by all WMConnection operations, if none set */
 788 void WMSetConnectionDefaultTimeout(unsigned int timeout);
 789
 790 /* Global timeout for all WMConnection objects, for opening a new connection */
 791 void WMSetConnectionOpenTimeout(unsigned int timeout);
 792
 793 /* Connection specific timeout for sending out data */
 794 void WMSetConnectionSendTimeout(WMConnection *cPtr, unsigned int timeout);
 795
 796
 797 /* Global variables */
 798
 799 extern int WCErrorCode;
 800
 801
 802 /*-------------------------------------------------------------------------*/
 803
 804
 805
 806 #ifdef __cplusplus
 807 }
 808 #endif /* __cplusplus */
 809
 810
 811 #endif