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