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