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