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