include/wx/defs.h

   1 /*
   2  *  Name:        wx/defs.h
   3  *  Purpose:     Declarations/definitions common to all wx source files
   4  *  Author:      Julian Smart and others
   5  *  Modified by: Ryan Norton (Converted to C)
   6  *  Created:     01/02/97
   7  *  RCS-ID:      $Id$
   8  *  Copyright:   (c) Julian Smart
   9  *  Licence:     wxWindows licence
  10  */
  11
  12 /* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
  13
  14 #ifndef _WX_DEFS_H_
  15 #define _WX_DEFS_H_
  16
  17 /*  ---------------------------------------------------------------------------- */
  18 /*  compiler and OS identification */
  19 /*  ---------------------------------------------------------------------------- */
  20
  21 #include "wx/platform.h"
  22
  23 #ifdef __cplusplus
  24 /*  Make sure the environment is set correctly */
  25 #   if defined(__WXMSW__) && defined(__X__)
  26 #       error "Target can't be both X and Windows"
  27 #   elif defined(__WXMSW__) && defined(__PALMOS__)
  28 #       error "Target can't be both PalmOS and Windows"
  29 #   elif !defined(__WXMOTIF__) && \
  30          !defined(__WXMSW__)   && \
  31          !defined(__WXPALMOS__)&& \
  32          !defined(__WXGTK__)   && \
  33          !defined(__WXPM__)    && \
  34          !defined(__WXMAC__)   && \
  35          !defined(__WXCOCOA__) && \
  36          !defined(__X__)       && \
  37          !defined(__WXMGL__)   && \
  38          !defined(__WXDFB__)   && \
  39          !defined(__WXX11__)   && \
  40           wxUSE_GUI
  41 #       ifdef __UNIX__
  42 #           error "No Target! You should use wx-config program for compilation flags!"
  43 #       else /*  !Unix */
  44 #           error "No Target! You should use supplied makefiles for compilation!"
  45 #       endif /*  Unix/!Unix */
  46 #   endif
  47 #endif /*__cplusplus*/
  48
  49 #ifndef __WXWINDOWS__
  50     #define __WXWINDOWS__ 1
  51 #endif
  52
  53 #ifndef wxUSE_BASE
  54     /*  by default consider that this is a monolithic build */
  55     #define wxUSE_BASE 1
  56 #endif
  57
  58 #if !wxUSE_GUI && !defined(__WXBASE__)
  59     #define __WXBASE__
  60 #endif
  61
  62 /*  suppress some Visual C++ warnings */
  63 #ifdef __VISUALC__
  64     /*  the only "real" warning here is 4244 but there are just too many of them */
  65     /*  in our code... one day someone should go and fix them but until then... */
  66 #   pragma warning(disable:4097)    /*  typedef used as class */
  67 #   pragma warning(disable:4201)    /*  nonstandard extension used: nameless struct/union */
  68 #   pragma warning(disable:4244)    /*  conversion from double to float */
  69 #   pragma warning(disable:4355)    /* 'this' used in base member initializer list */
  70 #   pragma warning(disable:4511)    /*  copy ctor couldn't be generated */
  71 #   pragma warning(disable:4512)    /*  operator=() couldn't be generated */
  72 #   pragma warning(disable:4710)    /*  function not inlined */
  73
  74     /* There are too many false positivies for this one, particularly when
  75        using templates like wxVector<T> */
  76     /* class 'foo' needs to have dll-interface to be used by clients of
  77        class 'bar'" */
  78 #   pragma warning(disable:4251)
  79
  80     /* For VC++ 5.0 for release mode, the warning 'C4702: unreachable code */
  81     /* is buggy, and occurs for code that does actually get executed */
  82 #   if !defined __WXDEBUG__ && __VISUALC__ <= 1100
  83 #       pragma warning(disable:4702)    /* unreachable code */
  84 #   endif
  85     /* The VC++ 5.0 warning 'C4003: not enough actual parameters for macro'
  86      * is incompatible with the wxWidgets headers since it is given when
  87      * parameters are empty but not missing. */
  88 #   if __VISUALC__ <= 1100
  89 #       pragma warning(disable:4003)    /* not enough actual parameters for macro */
  90 #   endif
  91
  92     /*
  93        VC++ 8 gives a warning when using standard functions such as sprintf,
  94        localtime, ... -- stop this madness, unless the user had already done it
  95      */
  96     #if __VISUALC__ >= 1400
  97         #ifndef _CRT_SECURE_NO_DEPRECATE
  98             #define _CRT_SECURE_NO_DEPRECATE 1
  99         #endif
 100         #ifndef _CRT_NON_CONFORMING_SWPRINTFS
 101             #define _CRT_NON_CONFORMING_SWPRINTFS 1
 102         #endif
 103     #endif /* VC++ 8 */
 104 #endif /*  __VISUALC__ */
 105
 106 /*  suppress some Salford C++ warnings */
 107 #ifdef __SALFORDC__
 108 #   pragma suppress 353             /*  Possible nested comments */
 109 #   pragma suppress 593             /*  Define not used */
 110 #   pragma suppress 61              /*  enum has no name (doesn't suppress!) */
 111 #   pragma suppress 106             /*  unnamed, unused parameter */
 112 #   pragma suppress 571             /*  Virtual function hiding */
 113 #endif /*  __SALFORDC__ */
 114
 115 /*  suppress some Borland C++ warnings */
 116 #ifdef __BORLANDC__
 117 #   pragma warn -inl                /*  Functions containing reserved words and certain constructs are not expanded inline */
 118 #endif /*  __BORLANDC__ */
 119
 120 /*
 121    g++ gives a warning when a class has private dtor if it has no friends but
 122    this is a perfectly valid situation for a ref-counted class which destroys
 123    itself when its ref count drops to 0, so provide a macro to suppress this
 124    warning
 125  */
 126 #ifdef __GNUG__
 127 #   define wxSUPPRESS_GCC_PRIVATE_DTOR_WARNING(name) \
 128         friend class wxDummyFriendFor ## name;
 129 #else /* !g++ */
 130 #   define wxSUPPRESS_GCC_PRIVATE_DTOR_WARNING(name)
 131 #endif
 132
 133 /*  ---------------------------------------------------------------------------- */
 134 /*  wxWidgets version and compatibility defines */
 135 /*  ---------------------------------------------------------------------------- */
 136
 137 #include "wx/version.h"
 138
 139 /*  ============================================================================ */
 140 /*  non portable C++ features */
 141 /*  ============================================================================ */
 142
 143 /*  ---------------------------------------------------------------------------- */
 144 /*  compiler defects workarounds */
 145 /*  ---------------------------------------------------------------------------- */
 146
 147 /*
 148    Digital Unix C++ compiler only defines this symbol for .cxx and .hxx files,
 149    so define it ourselves (newer versions do it for all files, though, and
 150    don't allow it to be redefined)
 151  */
 152 #if defined(__DECCXX) && !defined(__VMS) && !defined(__cplusplus)
 153 #define __cplusplus
 154 #endif /* __DECCXX */
 155
 156 /*  Resolves linking problems under HP-UX when compiling with gcc/g++ */
 157 #if defined(__HPUX__) && defined(__GNUG__)
 158 #define va_list __gnuc_va_list
 159 #endif /*  HP-UX */
 160
 161 /*  ---------------------------------------------------------------------------- */
 162 /*  check for native bool type and TRUE/FALSE constants */
 163 /*  ---------------------------------------------------------------------------- */
 164
 165 /*  Add more tests here for Windows compilers that already define bool */
 166 /*  (under Unix, configure tests for this) */
 167 #ifndef HAVE_BOOL
 168     #if defined( __MWERKS__ )
 169         #if (__MWERKS__ >= 0x1000) && __option(bool)
 170             #define HAVE_BOOL
 171         #endif
 172     #elif defined(__APPLE__) && defined(__APPLE_CC__)
 173         /*  Apple bundled gcc supports bool */
 174         #define HAVE_BOOL
 175     #elif defined(__VISUALC__) && (__VISUALC__ == 1020)
 176         /*  in VC++ 4.2 the bool keyword is reserved (hence can't be typedefed) */
 177         /*  but not implemented, so we must #define it */
 178         #define bool unsigned int
 179     #elif defined(__VISUALC__) && (__VISUALC__ == 1010)
 180         /*  For VisualC++ 4.1, we need to define */
 181         /*  bool as something between 4.0 & 5.0... */
 182         typedef unsigned int wxbool;
 183         #define bool wxbool
 184         #define HAVE_BOOL
 185     #elif defined(__VISUALC__) && (__VISUALC__ > 1020)
 186         /*  VC++ supports bool since 4.2 */
 187         #define HAVE_BOOL
 188     #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x500)
 189         /*  Borland 5.0+ supports bool */
 190         #define HAVE_BOOL
 191     #elif wxCHECK_WATCOM_VERSION(1,0)
 192         /*  Watcom 11+ supports bool */
 193         #define HAVE_BOOL
 194     #elif defined(__DIGITALMARS__)
 195         /*  DigitalMars supports bool */
 196         #define HAVE_BOOL
 197     #elif defined(__GNUWIN32__) || defined(__MINGW32__) || defined(__CYGWIN__)
 198         /*  Cygwin supports bool */
 199         #define HAVE_BOOL
 200     #elif defined(__VISAGECPP__)
 201         #if __IBMCPP__ < 400
 202             typedef unsigned long bool;
 203             #define true ((bool)1)
 204             #define false ((bool)0)
 205         #endif
 206         #define HAVE_BOOL
 207     #endif /*  compilers */
 208 #endif /*  HAVE_BOOL */
 209
 210 #if !defined(__MWERKS__) || !defined(true)
 211 #if !defined(HAVE_BOOL) && !defined(bool) && !defined(VMS)
 212     /*  NB: of course, this doesn't replace the standard type, because, for */
 213     /*      example, overloading based on bool/int parameter doesn't work and */
 214     /*      so should be avoided in portable programs */
 215     typedef unsigned int bool;
 216 #endif /*  bool */
 217
 218 /*  deal with TRUE/true stuff: we assume that if the compiler supports bool, it */
 219 /*  supports true/false as well and that, OTOH, if it does _not_ support bool, */
 220 /*  it doesn't support these keywords (this is less sure, in particular VC++ */
 221 /*  4.x could be a problem here) */
 222 #ifndef HAVE_BOOL
 223     #define true ((bool)1)
 224     #define false ((bool)0)
 225 #endif
 226 #endif
 227
 228 /*  for backwards compatibility, also define TRUE and FALSE */
 229 /*  */
 230 /*  note that these definitions should work both in C++ and C code, so don't */
 231 /*  use true/false below */
 232 #ifndef TRUE
 233     #define TRUE 1
 234 #endif
 235
 236 #ifndef FALSE
 237     #define FALSE 0
 238 #endif
 239
 240 typedef short int WXTYPE;
 241
 242 /*  special care should be taken with this type under Windows where the real */
 243 /*  window id is unsigned, so we must always do the cast before comparing them */
 244 /*  (or else they would be always different!). Using wxGetWindowId() which does */
 245 /*  the cast itself is recommended. Note that this type can't be unsigned */
 246 /*  because wxID_ANY == -1 is a valid (and largely used) value for window id. */
 247 typedef int wxWindowID;
 248
 249 /*  ---------------------------------------------------------------------------- */
 250 /*  other feature tests */
 251 /*  ---------------------------------------------------------------------------- */
 252
 253 /*  Every ride down a slippery slope begins with a single step.. */
 254 /*  */
 255 /*  Yes, using nested classes is indeed against our coding standards in */
 256 /*  general, but there are places where you can use them to advantage */
 257 /*  without totally breaking ports that cannot use them.  If you do, then */
 258 /*  wrap it in this guard, but such cases should still be relatively rare. */
 259 #define wxUSE_NESTED_CLASSES    1
 260
 261 /*  check for explicit keyword support */
 262 #ifndef HAVE_EXPLICIT
 263     #if defined(__VISUALC__) && (__VISUALC__ >= 1100)
 264         /*  VC++ 6.0 and 5.0 have explicit (what about earlier versions?) */
 265         #define HAVE_EXPLICIT
 266     #elif ( defined(__MINGW32__) || defined(__CYGWIN32__) ) \
 267           && wxCHECK_GCC_VERSION(2, 95)
 268         /*  GCC 2.95 has explicit, what about earlier versions? */
 269         #define HAVE_EXPLICIT
 270     #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x0520)
 271         /*  BC++ 4.52 doesn't support explicit, CBuilder 1 does */
 272         #define HAVE_EXPLICIT
 273     #elif defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
 274         /*  Metrowerks CW6 or higher has explicit */
 275         #define HAVE_EXPLICIT
 276     #elif defined(__DIGITALMARS__)
 277         #define HAVE_EXPLICIT
 278     #elif defined(__WATCOMC__)
 279         #define HAVE_EXPLICIT
 280     #endif
 281 #endif /*  !HAVE_EXPLICIT */
 282
 283 #ifdef HAVE_EXPLICIT
 284     #define wxEXPLICIT explicit
 285 #else /*  !HAVE_EXPLICIT */
 286     #define wxEXPLICIT
 287 #endif /*  HAVE_EXPLICIT/!HAVE_EXPLICIT */
 288
 289 /* check for static/const_cast<>() (we don't use the other ones for now) */
 290 #ifndef HAVE_CXX_CASTS
 291     #if defined(__VISUALC__) && (__VISUALC__ >= 1100)
 292         /*  VC++ 6.0 and 5.0 have C++ casts (what about earlier versions?) */
 293         #define HAVE_CXX_CASTS
 294     #elif defined(__MINGW32__) || defined(__CYGWIN32__)
 295         #if wxCHECK_GCC_VERSION(2, 95)
 296             /*  GCC 2.95 has C++ casts, what about earlier versions? */
 297             #define HAVE_CXX_CASTS
 298         #endif
 299     #endif
 300 #endif /*  !HAVE_CXX_CASTS */
 301
 302 #ifdef HAVE_CXX_CASTS
 303     #ifndef HAVE_CONST_CAST
 304         #define HAVE_CONST_CAST
 305     #endif
 306     #ifndef HAVE_REINTERPRET_CAST
 307         #define HAVE_REINTERPRET_CAST
 308     #endif
 309     #ifndef HAVE_STATIC_CAST
 310         #define HAVE_STATIC_CAST
 311     #endif
 312     #ifndef HAVE_DYNAMIC_CAST
 313         #define HAVE_DYNAMIC_CAST
 314     #endif
 315 #endif /*  HAVE_CXX_CASTS */
 316
 317 #ifdef HAVE_STATIC_CAST
 318     #define wx_static_cast(t, x) static_cast<t>(x)
 319 #else
 320     #define wx_static_cast(t, x) ((t)(x))
 321 #endif
 322
 323 #ifdef HAVE_CONST_CAST
 324     #define wx_const_cast(t, x) const_cast<t>(x)
 325 #else
 326     #define wx_const_cast(t, x) ((t)(x))
 327 #endif
 328
 329 #ifdef HAVE_REINTERPRET_CAST
 330     #define wx_reinterpret_cast(t, x) reinterpret_cast<t>(x)
 331 #else
 332     #define wx_reinterpret_cast(t, x) ((t)(x))
 333 #endif
 334
 335 /*
 336    This one is a wx invention: like static cast but used when we intentionally
 337    truncate from a larger to smaller type, static_cast<> can't be used for it
 338    as it results in warnings when using some compilers (SGI mipspro for example)
 339  */
 340 #if defined(__INTELC__) && defined(__cplusplus)
 341     template <typename T, typename X>
 342     inline T wx_truncate_cast_impl(X x)
 343     {
 344         #pragma warning(push)
 345         /* implicit conversion of a 64-bit integral type to a smaller integral type */
 346         #pragma warning(disable: 1682)
 347         /* conversion from "X" to "T" may lose significant bits */
 348         #pragma warning(disable: 810)
 349
 350         return x;
 351
 352         #pragma warning(pop)
 353     }
 354
 355     #define wx_truncate_cast(t, x) wx_truncate_cast_impl<t>(x)
 356
 357 #elif defined(__cplusplus) && defined(__VISUALC__) && __VISUALC__ >= 1310
 358     template <typename T, typename X>
 359     inline T wx_truncate_cast_impl(X x)
 360     {
 361         #pragma warning(push)
 362         /* conversion from 'X' to 'T', possible loss of data */
 363         #pragma warning(disable: 4267)
 364
 365         return x;
 366
 367         #pragma warning(pop)
 368     }
 369
 370     #define wx_truncate_cast(t, x) wx_truncate_cast_impl<t>(x)
 371 #else
 372     #define wx_truncate_cast(t, x) ((t)(x))
 373 #endif
 374
 375 /* for consistency with wxStatic/DynamicCast defined in wx/object.h */
 376 #define wxConstCast(obj, className) wx_const_cast(className *, obj)
 377
 378 #ifndef HAVE_STD_WSTRING
 379     #if defined(__VISUALC__) && (__VISUALC__ >= 1100)
 380         /*  VC++ 6.0 and 5.0 have std::wstring (what about earlier versions?) */
 381         #define HAVE_STD_WSTRING
 382     #elif ( defined(__MINGW32__) || defined(__CYGWIN32__) ) \
 383           && wxCHECK_GCC_VERSION(3, 3)
 384         /*  GCC 3.1 has std::wstring; 3.0 never was in MinGW, 2.95 hasn't it */
 385         #define HAVE_STD_WSTRING
 386     #endif
 387 #endif
 388
 389 #ifndef HAVE_STD_STRING_COMPARE
 390     #if defined(__VISUALC__) && (__VISUALC__ >= 1100)
 391         /*  VC++ 6.0 and 5.0 have std::string::compare */
 392         /*  (what about earlier versions?) */
 393         #define HAVE_STD_STRING_COMPARE
 394     #elif ( defined(__MINGW32__) || defined(__CYGWIN32__) ) \
 395           && wxCHECK_GCC_VERSION(3, 1)
 396         /*  GCC 3.1 has std::string::compare; */
 397         /*  3.0 never was in MinGW, 2.95 hasn't it */
 398         #define HAVE_STD_STRING_COMPARE
 399     #endif
 400 #endif
 401
 402 /* provide replacement for C99 va_copy() if the compiler doesn't have it */
 403
 404 /* could be already defined by configure or the user */
 405 #ifndef wxVaCopy
 406     /* if va_copy is a macro or configure detected that we have it, use it */
 407     #if defined(va_copy) || defined(HAVE_VA_COPY)
 408         #define wxVaCopy va_copy
 409     #else /* no va_copy, try to provide a replacement */
 410         /*
 411            configure tries to determine whether va_list is an array or struct
 412            type, but it may not be used under Windows, so deal with a few
 413            special cases.
 414          */
 415
 416         #ifdef __WATCOMC__
 417             /* Watcom uses array type for va_list except for PPC and Alpha */
 418             #if !defined(__PPC__) && !defined(__AXP__)
 419                 #define VA_LIST_IS_ARRAY
 420             #endif
 421         #endif /* __WATCOMC__ */
 422
 423         #if defined(__PPC__) && (defined(_CALL_SYSV) || defined (_WIN32))
 424             /*
 425                 PPC using SysV ABI and NT/PPC are special in that they use an
 426                 extra level of indirection.
 427              */
 428             #define VA_LIST_IS_POINTER
 429         #endif /* SysV or Win32 on __PPC__ */
 430
 431         /*
 432             note that we use memmove(), not memcpy(), in case anybody tries
 433             to do wxVaCopy(ap, ap)
 434          */
 435         #if defined(VA_LIST_IS_POINTER)
 436             #define wxVaCopy(d, s)  memmove(*(d), *(s), sizeof(va_list))
 437         #elif defined(VA_LIST_IS_ARRAY)
 438             #define wxVaCopy(d, s) memmove((d), (s), sizeof(va_list))
 439         #else /* we can only hope that va_lists are simple lvalues */
 440             #define wxVaCopy(d, s) ((d) = (s))
 441         #endif
 442     #endif /* va_copy/!va_copy */
 443 #endif /* wxVaCopy */
 444
 445 #ifndef HAVE_VARIADIC_MACROS
 446     #if wxCHECK_WATCOM_VERSION(1,2)
 447         #define HAVE_VARIADIC_MACROS
 448     #endif
 449 #endif /* HAVE_VARIADIC_MACROS */
 450
 451
 452 #ifndef HAVE_WOSTREAM
 453     // Mingw <=3.4 doesn't have std::wostream
 454     #if !defined(__MINGW32__) || wxCHECK_GCC_VERSION(4,0)
 455         #define HAVE_WOSTREAM
 456     #endif
 457 #endif /* HAVE_WOSTREAM */
 458
 459 /*  ---------------------------------------------------------------------------- */
 460 /*  portable calling conventions macros */
 461 /*  ---------------------------------------------------------------------------- */
 462
 463 /*  stdcall is used for all functions called by Windows under Windows */
 464 #if defined(__WINDOWS__)
 465     #if defined(__GNUWIN32__)
 466         #define wxSTDCALL __attribute__((stdcall))
 467     #else
 468         /*  both VC++ and Borland understand this */
 469         #define wxSTDCALL _stdcall
 470     #endif
 471
 472 #else /*  Win */
 473     /*  no such stupidness under Unix */
 474     #define wxSTDCALL
 475 #endif /*  platform */
 476
 477 /*  LINKAGEMODE mode is empty for everyting except OS/2 */
 478 #ifndef LINKAGEMODE
 479     #define LINKAGEMODE
 480 #endif /*  LINKAGEMODE */
 481
 482 /*  wxCALLBACK should be used for the functions which are called back by */
 483 /*  Windows (such as compare function for wxListCtrl) */
 484 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
 485     #define wxCALLBACK wxSTDCALL
 486 #else
 487     /*  no stdcall under Unix nor Win16 */
 488     #define wxCALLBACK
 489 #endif /*  platform */
 490
 491 /*  generic calling convention for the extern "C" functions */
 492
 493 #if defined(__VISUALC__)
 494   #define   wxC_CALLING_CONV    _cdecl
 495 #elif defined(__VISAGECPP__)
 496   #define   wxC_CALLING_CONV    _Optlink
 497 #else   /*  !Visual C++ */
 498   #define   wxC_CALLING_CONV
 499 #endif  /*  compiler */
 500
 501 /*  callling convention for the qsort(3) callback */
 502 #define wxCMPFUNC_CONV wxC_CALLING_CONV
 503
 504 /*  compatibility :-( */
 505 #define CMPFUNC_CONV wxCMPFUNC_CONV
 506
 507 /*  DLL import/export declarations */
 508 #include "wx/dlimpexp.h"
 509
 510 /*  ---------------------------------------------------------------------------- */
 511 /*  Very common macros */
 512 /*  ---------------------------------------------------------------------------- */
 513
 514 /*  Printf-like attribute definitions to obtain warnings with GNU C/C++ */
 515 #ifndef ATTRIBUTE_PRINTF
 516 #   if defined(__GNUC__) && !wxUSE_UNICODE
 517 #       define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n)))
 518 #   else
 519 #       define ATTRIBUTE_PRINTF(m, n)
 520 #   endif
 521
 522 #   define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2)
 523 #   define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3)
 524 #   define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4)
 525 #   define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5)
 526 #   define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6)
 527 #endif /* !defined(ATTRIBUTE_PRINTF) */
 528
 529
 530 /*  Macro to issue warning when using deprecated functions with gcc3 or MSVC7: */
 531 #if wxCHECK_GCC_VERSION(3, 1)
 532     #define wxDEPRECATED(x) __attribute__((deprecated)) x
 533 #elif defined(__VISUALC__) && (__VISUALC__ >= 1300)
 534     #define wxDEPRECATED(x) __declspec(deprecated) x
 535 #else
 536     #define wxDEPRECATED(x) x
 537 #endif
 538
 539 /*
 540    Macro which marks the function as being deprecated but also defines it
 541    inline.
 542
 543    Currently it's defined in the same trivial way in all cases but it could
 544    need a special definition with some other compilers in the future which
 545    explains why do we have it.
 546  */
 547 #define wxDEPRECATED_INLINE(func, body) wxDEPRECATED(func) { body }
 548
 549 /*
 550    Special variant of the macro above which should be used for the functions
 551    which are deprecated but called by wx itself: this often happens with
 552    deprecated virtual functions which are called by the library.
 553  */
 554 #ifdef WXBUILDING
 555 #   define wxDEPRECATED_BUT_USED_INTERNALLY(x) x
 556 #else
 557 #   define wxDEPRECATED_BUT_USED_INTERNALLY(x) wxDEPRECATED(x)
 558 #endif
 559
 560 /*  everybody gets the assert and other debug macros */
 561 #include "wx/debug.h"
 562
 563 /*  NULL declaration: it must be defined as 0 for C++ programs (in particular, */
 564 /*  it must not be defined as "(void *)0" which is standard for C but completely */
 565 /*  breaks C++ code) */
 566 #ifndef __HANDHELDPC__
 567 #include <stddef.h>
 568 #endif
 569
 570 /*  delete pointer if it is not NULL and NULL it afterwards */
 571 /*  (checking that it's !NULL before passing it to delete is just a */
 572 /*   a question of style, because delete will do it itself anyhow, but it might */
 573 /*   be considered as an error by some overzealous debugging implementations of */
 574 /*   the library, so we do it ourselves) */
 575 #define wxDELETE(p)      if ( (p) != NULL ) { delete p; p = NULL; }
 576
 577 /*  delete an array and NULL it (see comments above) */
 578 #define wxDELETEA(p)     if ( (p) ) { delete [] (p); p = NULL; }
 579
 580 /*  size of statically declared array */
 581 #define WXSIZEOF(array)   (sizeof(array)/sizeof(array[0]))
 582
 583 /*  symbolic constant used by all Find()-like functions returning positive */
 584 /*  integer on success as failure indicator */
 585 #define wxNOT_FOUND       (-1)
 586
 587 /*  ---------------------------------------------------------------------------- */
 588 /*  macros dealing with comparison operators */
 589 /*  ---------------------------------------------------------------------------- */
 590
 591 /*
 592     Expands into m(op, args...) for each op in the set { ==, !=, <, <=, >, >= }.
 593  */
 594 #define wxFOR_ALL_COMPARISONS(m) \
 595     m(==) m(!=) m(>=) m(<=) m(>) m(<)
 596
 597 #define wxFOR_ALL_COMPARISONS_1(m, x) \
 598     m(==,x) m(!=,x) m(>=,x) m(<=,x) m(>,x) m(<,x)
 599
 600 #define wxFOR_ALL_COMPARISONS_2(m, x, y) \
 601     m(==,x,y) m(!=,x,y) m(>=,x,y) m(<=,x,y) m(>,x,y) m(<,x,y)
 602
 603 #define wxFOR_ALL_COMPARISONS_3(m, x, y, z) \
 604     m(==,x,y,z) m(!=,x,y,z) m(>=,x,y,z) m(<=,x,y,z) m(>,x,y,z) m(<,x,y,z)
 605
 606 /*
 607     This is only used with wxDEFINE_COMPARISON_REV: it passes both the normal
 608     and the reversed comparison operators to the macro.
 609  */
 610 #define wxFOR_ALL_COMPARISONS_3_REV(m, x, y, z) \
 611     m(==,x,y,z,==) m(!=,x,y,z,!=) m(>=,x,y,z,<=) \
 612     m(<=,x,y,z,>=) m(>,x,y,z,<) m(<,x,y,z,>)
 613
 614
 615 #define wxDEFINE_COMPARISON(op, T1, T2, cmp) \
 616     inline bool operator op(T1 x, T2 y) { return cmp(x, y, op); }
 617
 618 #define wxDEFINE_COMPARISON_REV(op, T1, T2, cmp, oprev) \
 619     inline bool operator op(T2 y, T1 x) { return cmp(x, y, oprev); }
 620
 621 /*
 622     Define all 6 comparison operators (==, !=, <, <=, >, >=) for the given
 623     types in the specified order. The implementation is provided by the cmp
 624     macro. Normally wxDEFINE_ALL_COMPARISONS should be used as comparison
 625     operators are usually symmetric.
 626  */
 627 #define wxDEFINE_COMPARISONS(T1, T2, cmp) \
 628     wxFOR_ALL_COMPARISONS_3(wxDEFINE_COMPARISON, T1, T2, cmp)
 629
 630 /*
 631     This macro allows to define all 12 comparison operators (6 operators for
 632     both orders of arguments) for the given types using the provided "cmp"
 633     macro to implement the actual comparison: the macro is called with the 2
 634     arguments names, the first of type T1 and the second of type T2, and the
 635     comparison operator being implemented.
 636  */
 637 #define wxDEFINE_ALL_COMPARISONS(T1, T2, cmp) \
 638     wxFOR_ALL_COMPARISONS_3(wxDEFINE_COMPARISON, T1, T2, cmp) \
 639     wxFOR_ALL_COMPARISONS_3_REV(wxDEFINE_COMPARISON_REV, T1, T2, cmp)
 640
 641 /*  ---------------------------------------------------------------------------- */
 642 /*  macros to avoid compiler warnings */
 643 /*  ---------------------------------------------------------------------------- */
 644
 645 /*  Macro to cut down on compiler warnings. */
 646 #if 1 /*  there should be no more any compilers needing the "#else" version */
 647     #define WXUNUSED(identifier) /* identifier */
 648 #else  /*  stupid, broken compiler */
 649     #define WXUNUSED(identifier) identifier
 650 #endif
 651
 652 /*  some arguments are only used in debug mode, but unused in release one */
 653 #ifdef __WXDEBUG__
 654     #define WXUNUSED_UNLESS_DEBUG(param)  param
 655 #else
 656     #define WXUNUSED_UNLESS_DEBUG(param)  WXUNUSED(param)
 657 #endif
 658
 659 /*  some arguments are not used in unicode mode */
 660 #if wxUSE_UNICODE
 661     #define WXUNUSED_IN_UNICODE(param)  WXUNUSED(param)
 662 #else
 663     #define WXUNUSED_IN_UNICODE(param)  param
 664 #endif
 665
 666 /*  some arguments are not used in WinCE build */
 667 #ifdef __WXWINCE__
 668     #define WXUNUSED_IN_WINCE(param)  WXUNUSED(param)
 669 #else
 670     #define WXUNUSED_IN_WINCE(param)  param
 671 #endif
 672
 673 /*  unused parameters in non stream builds */
 674 #if wxUSE_STREAMS
 675     #define WXUNUSED_UNLESS_STREAMS(param)  param
 676 #else
 677     #define WXUNUSED_UNLESS_STREAMS(param)  WXUNUSED(param)
 678 #endif
 679
 680 /*  some compilers give warning about a possibly unused variable if it is */
 681 /*  initialized in both branches of if/else and shut up if it is initialized */
 682 /*  when declared, but other compilers then give warnings about unused variable */
 683 /*  value -- this should satisfy both of them */
 684 #if defined(__VISUALC__)
 685     #define wxDUMMY_INITIALIZE(val) = val
 686 #else
 687     #define wxDUMMY_INITIALIZE(val)
 688 #endif
 689
 690 /*  sometimes the value of a variable is *really* not used, to suppress  the */
 691 /*  resulting warning you may pass it to this function */
 692 #ifdef __cplusplus
 693 #   ifdef __BORLANDC__
 694 #       define wxUnusedVar(identifier) identifier
 695 #   else
 696         template <class T>
 697             inline void wxUnusedVar(const T& WXUNUSED(t)) { }
 698 #   endif
 699 #endif
 700
 701 /*  ---------------------------------------------------------------------------- */
 702 /*  compiler specific settings */
 703 /*  ---------------------------------------------------------------------------- */
 704
 705 /*  to allow compiling with warning level 4 under Microsoft Visual C++ some */
 706 /*  warnings just must be disabled */
 707 #ifdef  __VISUALC__
 708   #pragma warning(disable: 4514) /*  unreferenced inline func has been removed */
 709 /*
 710   you might be tempted to disable this one also: triggered by CHECK and FAIL
 711   macros in debug.h, but it's, overall, a rather useful one, so I leave it and
 712   will try to find some way to disable this warning just for CHECK/FAIL. Anyone?
 713 */
 714   #pragma warning(disable: 4127) /*  conditional expression is constant */
 715 #endif  /*  VC++ */
 716
 717 #if defined(__MWERKS__)
 718     #undef try
 719     #undef except
 720     #undef finally
 721     #define except(x) catch(...)
 722 #endif /*  Metrowerks */
 723
 724 #if wxONLY_WATCOM_EARLIER_THAN(1,4)
 725     typedef short mode_t;
 726 #endif
 727
 728 /*  where should i put this? we need to make sure of this as it breaks */
 729 /*  the <iostream> code. */
 730 #if !wxUSE_IOSTREAMH && defined(__WXDEBUG__)
 731 #  ifndef __MWERKS__
 732 /*  #undef __WXDEBUG__ */
 733 #    ifdef wxUSE_DEBUG_NEW_ALWAYS
 734 #    undef wxUSE_DEBUG_NEW_ALWAYS
 735 #    define wxUSE_DEBUG_NEW_ALWAYS 0
 736 #    endif
 737 #  endif
 738 #endif
 739
 740 /*  ---------------------------------------------------------------------------- */
 741 /*  standard wxWidgets types */
 742 /*  ---------------------------------------------------------------------------- */
 743
 744 /*  the type for screen and DC coordinates */
 745 typedef int wxCoord;
 746
 747 enum {  wxDefaultCoord = -1 };
 748
 749 /*  ---------------------------------------------------------------------------- */
 750 /*  define fixed length types */
 751 /*  ---------------------------------------------------------------------------- */
 752
 753 #if defined(__WXPALMOS__) || defined(__MINGW32__)
 754     #include <sys/types.h>
 755 #endif
 756
 757 /*  chars are always one byte (by definition), shorts are always two (in */
 758 /*  practice) */
 759
 760 /*  8bit */
 761 typedef signed char wxInt8;
 762 typedef unsigned char wxUint8;
 763 typedef wxUint8 wxByte;
 764
 765
 766 /*  16bit */
 767 #ifdef SIZEOF_SHORT
 768     #if SIZEOF_SHORT != 2
 769         #error "wxWidgets assumes sizeof(short) == 2, please fix the code"
 770     #endif
 771 #else
 772     #define SIZEOF_SHORT 2
 773 #endif
 774
 775 typedef signed short wxInt16;
 776 typedef unsigned short wxUint16;
 777
 778 typedef wxUint16 wxWord;
 779
 780 /*
 781   things are getting more interesting with ints, longs and pointers
 782
 783   there are several different standard data models described by this table:
 784
 785   +-----------+----------------------------+
 786   |type\model | LP64 ILP64 LLP64 ILP32 LP32|
 787   +-----------+----------------------------+
 788   |char       |  8     8     8     8     8 |
 789   |short      | 16    16    16    16    16 |
 790   |int        | 32    64    32    32    16 |
 791   |long       | 64    64    32    32    32 |
 792   |long long  | 64    64    64    --    -- |
 793   |void *     | 64    64    64    32    32 |
 794   +-----------+----------------------------+
 795
 796   Win16 used LP32 (but we don't support it any longer), Win32 obviously used
 797   ILP32 and Win64 uses LLP64 (a.k.a. P64)
 798
 799   Under Unix LP64 is the most widely used (the only I've ever seen, in fact)
 800  */
 801
 802 /*  32bit */
 803 #ifdef __PALMOS__
 804     typedef int wxInt32;
 805     typedef unsigned int wxUint32;
 806     #define SIZEOF_INT 4
 807     #define SIZEOF_LONG 4
 808     #define SIZEOF_WCHAR_T 2
 809     #define SIZEOF_SIZE_T 4
 810     #define wxSIZE_T_IS_UINT
 811     #define SIZEOF_VOID_P 4
 812     #define SIZEOF_SIZE_T 4
 813 #elif defined(__WINDOWS__)
 814     /*  Win64 uses LLP64 model and so ints and longs have the same size as in */
 815     /*  Win32 */
 816     #if defined(__WIN32__)
 817         typedef int wxInt32;
 818         typedef unsigned int wxUint32;
 819
 820         /* Assume that if SIZEOF_INT is defined that all the other ones except
 821            SIZEOF_SIZE_T, are too.  See next #if below.  */
 822         #ifndef SIZEOF_INT
 823             #define SIZEOF_INT 4
 824             #define SIZEOF_LONG 4
 825             #define SIZEOF_WCHAR_T 2
 826
 827             /*
 828                under Win64 sizeof(size_t) == 8 and so it is neither unsigned
 829                int nor unsigned long!
 830              */
 831             #ifdef __WIN64__
 832                 #define SIZEOF_SIZE_T 8
 833
 834                 #undef wxSIZE_T_IS_UINT
 835             #else /* Win32 */
 836                 #define SIZEOF_SIZE_T 4
 837
 838                 #define wxSIZE_T_IS_UINT
 839             #endif
 840             #undef wxSIZE_T_IS_ULONG
 841
 842             #ifdef __WIN64__
 843                 #define SIZEOF_VOID_P 8
 844             #else /*  Win32 */
 845                 #define SIZEOF_VOID_P 4
 846             #endif /*  Win64/32 */
 847         #endif /*  !defined(SIZEOF_INT) */
 848
 849         /*
 850           If Python.h was included first, it defines all of the SIZEOF's above
 851           except for SIZEOF_SIZE_T, so we need to do it here to avoid
 852           triggering the #error in the ssize_t typedefs below...
 853         */
 854         #ifndef SIZEOF_SIZE_T
 855             #ifdef __WIN64__
 856                 #define SIZEOF_SIZE_T 8
 857             #else /* Win32 */
 858                 #define SIZEOF_SIZE_T 4
 859             #endif
 860         #endif
 861     #else
 862         #error "Unsupported Windows version"
 863     #endif
 864 #else /*  !Windows */
 865     /*  SIZEOF_XXX are normally defined by configure */
 866     #ifdef SIZEOF_INT
 867         #if SIZEOF_INT == 8
 868             /*  must be ILP64 data model, there is normally a special 32 bit */
 869             /*  type in it but we don't know what it is... */
 870             #error "No 32bit int type on this platform"
 871         #elif SIZEOF_INT == 4
 872             typedef int wxInt32;
 873             typedef unsigned int wxUint32;
 874         #elif SIZEOF_INT == 2
 875             /*  must be LP32 */
 876             #if SIZEOF_LONG != 4
 877                 #error "No 32bit int type on this platform"
 878             #endif
 879
 880             typedef long wxInt32;
 881             typedef unsigned long wxUint32;
 882         #else
 883             /*  wxWidgets is not ready for 128bit systems yet... */
 884             #error "Unknown sizeof(int) value, what are you compiling for?"
 885         #endif
 886     #else /*  !defined(SIZEOF_INT) */
 887         /*  assume default 32bit machine -- what else can we do? */
 888         wxCOMPILE_TIME_ASSERT( sizeof(int) == 4, IntMustBeExactly4Bytes);
 889         wxCOMPILE_TIME_ASSERT( sizeof(size_t) == 4, SizeTMustBeExactly4Bytes);
 890         wxCOMPILE_TIME_ASSERT( sizeof(void *) == 4, PtrMustBeExactly4Bytes);
 891
 892         #define SIZEOF_INT 4
 893         #define SIZEOF_SIZE_T 4
 894         #define SIZEOF_VOID_P 4
 895
 896         typedef int wxInt32;
 897         typedef unsigned int wxUint32;
 898
 899         #if defined(__MACH__) && !defined(SIZEOF_WCHAR_T)
 900             #define SIZEOF_WCHAR_T 4
 901         #endif
 902         #if wxUSE_WCHAR_T && !defined(SIZEOF_WCHAR_T)
 903             /*  also assume that sizeof(wchar_t) == 2 (under Unix the most */
 904             /*  common case is 4 but there configure would have defined */
 905             /*  SIZEOF_WCHAR_T for us) */
 906             /*  the most common case */
 907             wxCOMPILE_TIME_ASSERT( sizeof(wchar_t) == 2,
 908                                     Wchar_tMustBeExactly2Bytes);
 909
 910             #define SIZEOF_WCHAR_T 2
 911         #endif /*  wxUSE_WCHAR_T */
 912     #endif
 913 #endif /*  Win/!Win */
 914
 915 /* also define C99-like sized MIN/MAX constants */
 916 #define wxINT8_MIN CHAR_MIN
 917 #define wxINT8_MAX CHAR_MAX
 918
 919 #define wxINT16_MIN SHRT_MIN
 920 #define wxINT16_MAX SHRT_MAX
 921
 922 #if SIZEOF_INT == 4
 923     #define wxINT32_MIN INT_MIN
 924     #define wxINT32_MAX INT_MAX
 925 #elif SIZEOF_LONG == 4
 926     #define wxINT32_MIN LONG_MIN
 927     #define wxINT32_MAX LONG_MAX
 928 #else
 929     #error "Unknown 32 bit type"
 930 #endif
 931
 932 typedef wxUint32 wxDword;
 933
 934 #ifdef LLONG_MAX
 935     #define wxINT64_MAX LLONG_MAX
 936     #define wxINT64_MIN LLONG_MIN
 937 #else
 938     #define wxINT64_MAX wxLL(9223372036854775807)
 939     #define wxINT64_MIN wxLL(-9223372036854775807-1)
 940 #endif
 941
 942 /*
 943    Define an integral type big enough to contain all of long, size_t and void *.
 944  */
 945 #if SIZEOF_LONG >= SIZEOF_VOID_P && SIZEOF_LONG >= SIZEOF_SIZE_T
 946     /* normal case */
 947     typedef unsigned long wxUIntPtr;
 948 #elif SIZEOF_SIZE_T >= SIZEOF_VOID_P
 949     /* Win64 case */
 950     typedef size_t wxUIntPtr;
 951 #else
 952     /*
 953        This should never happen for the current architectures but if you're
 954        using one where it does, please contact wx-dev@lists.wxwidgets.org.
 955      */
 956     #error "Pointers can't be stored inside integer types."
 957 #endif
 958
 959 #ifdef __cplusplus
 960 /* And also define a couple of simple functions to cast pointer to/from it. */
 961 inline wxUIntPtr wxPtrToUInt(const void *p)
 962 {
 963     /*
 964        VC++ 7.1 gives warnings about casts such as below even when they're
 965        explicit with /Wp64 option, suppress them as we really know what we're
 966        doing here. Same thing with icc with -Wall.
 967      */
 968 #ifdef __VISUALC__
 969     #if __VISUALC__ >= 1200
 970         #pragma warning(push)
 971     #endif
 972     /* pointer truncation from '' to '' */
 973     #pragma warning(disable: 4311)
 974 #elif defined(__INTELC__)
 975     #pragma warning(push)
 976     /* conversion from pointer to same-sized integral type */
 977     #pragma warning(disable: 1684)
 978 #endif
 979
 980     return wx_reinterpret_cast(wxUIntPtr, p);
 981
 982 #if (defined(__VISUALC__) && __VISUALC__ >= 1200) || defined(__INTELC__)
 983     #pragma warning(pop)
 984 #endif
 985 }
 986
 987 inline void *wxUIntToPtr(wxUIntPtr p)
 988 {
 989 #ifdef __VISUALC__
 990     #if __VISUALC__ >= 1200
 991         #pragma warning(push)
 992     #endif
 993     /* conversion to type of greater size */
 994     #pragma warning(disable: 4312)
 995 #elif defined(__INTELC__)
 996     #pragma warning(push)
 997     /* invalid type conversion: "wxUIntPtr={unsigned long}" to "void *" */
 998     #pragma warning(disable: 171)
 999 #endif
1000
1001     return wx_reinterpret_cast(void *, p);
1002
1003 #if (defined(__VISUALC__) && __VISUALC__ >= 1200) || defined(__INTELC__)
1004     #pragma warning(pop)
1005 #endif
1006 }
1007 #endif /*__cplusplus*/
1008
1009
1010 /*  64 bit */
1011
1012 /*  NB: we #define and not typedef wxLongLong_t because we use "#ifdef */
1013 /*      wxLongLong_t" in wx/longlong.h */
1014
1015 /*      wxULongLong_t is set later (usually to unsigned wxLongLong_t) */
1016
1017 /*  to avoid compilation problems on 64bit machines with ambiguous method calls */
1018 /*  we will need to define this */
1019 #undef wxLongLongIsLong
1020
1021 /*
1022    First check for specific compilers which have known 64 bit integer types,
1023    this avoids clashes with SIZEOF_LONG[_LONG] being defined incorrectly for
1024    e.g. MSVC builds (Python.h defines it as 8 even for MSVC).
1025
1026    Also notice that we check for "long long" before checking for 64 bit long as
1027    we still want to use "long long" and not "long" for wxLongLong_t on 64 bit
1028    architectures to be able to pass wxLongLong_t to the standard functions
1029    prototyped as taking "long long" such as strtoll().
1030  */
1031 #if (defined(__VISUALC__) && defined(__WIN32__))
1032     #define wxLongLong_t __int64
1033     #define wxLongLongSuffix i64
1034     #define wxLongLongFmtSpec _T("I64")
1035 #elif defined(__BORLANDC__) && defined(__WIN32__) && (__BORLANDC__ >= 0x520)
1036     #define wxLongLong_t __int64
1037     #define wxLongLongSuffix i64
1038     #define wxLongLongFmtSpec _T("L")
1039 #elif (defined(__WATCOMC__) && (defined(__WIN32__) || defined(__DOS__) || defined(__OS2__)))
1040       #define wxLongLong_t __int64
1041       #define wxLongLongSuffix i64
1042       #define wxLongLongFmtSpec _T("L")
1043 #elif defined(__DIGITALMARS__)
1044       #define wxLongLong_t __int64
1045       #define wxLongLongSuffix LL
1046       #define wxLongLongFmtSpec _T("ll")
1047 #elif defined(__MINGW32__)
1048     #define wxLongLong_t long long
1049     #define wxLongLongSuffix ll
1050     #define wxLongLongFmtSpec _T("I64")
1051 #elif defined(__MWERKS__)
1052     #if __option(longlong)
1053         #define wxLongLong_t long long
1054         #define wxLongLongSuffix ll
1055         #define wxLongLongFmtSpec _T("ll")
1056     #else
1057         #error "The 64 bit integer support in CodeWarrior has been disabled."
1058         #error "See the documentation on the 'longlong' pragma."
1059     #endif
1060 #elif defined(__WXPALMOS__)
1061     #define wxLongLong_t int64_t
1062     #define wxLongLongSuffix ll
1063     #define wxLongLongFmtSpec _T("ll")
1064 #elif defined(__VISAGECPP__) && __IBMCPP__ >= 400
1065     #define wxLongLong_t long long
1066 #elif (defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8)  || \
1067         defined(__GNUC__) || \
1068         defined(__CYGWIN__) || \
1069         defined(__WXMICROWIN__) || \
1070         (defined(__DJGPP__) && __DJGPP__ >= 2)
1071     #define wxLongLong_t long long
1072     #define wxLongLongSuffix ll
1073     #define wxLongLongFmtSpec _T("ll")
1074 #elif defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
1075     #define wxLongLong_t long
1076     #define wxLongLongSuffix l
1077     #define wxLongLongFmtSpec _T("l")
1078     #define wxLongLongIsLong
1079 #endif
1080
1081
1082 #ifdef wxLongLong_t
1083
1084     #ifdef __WXPALMOS__
1085         #define wxULongLong_t uint64_t
1086     #else
1087         #define wxULongLong_t unsigned wxLongLong_t
1088     #endif
1089
1090     /*  these macros allow to define 64 bit constants in a portable way */
1091     #define wxLL(x) wxCONCAT(x, wxLongLongSuffix)
1092     #define wxULL(x) wxCONCAT(x, wxCONCAT(u, wxLongLongSuffix))
1093
1094     typedef wxLongLong_t wxInt64;
1095     typedef wxULongLong_t wxUint64;
1096
1097     #define wxHAS_INT64 1
1098
1099 #elif wxUSE_LONGLONG
1100     /*  these macros allow to define 64 bit constants in a portable way */
1101     #define wxLL(x) wxLongLong(x)
1102     #define wxULL(x) wxULongLong(x)
1103
1104     #define wxInt64 wxLongLong
1105     #define wxUint64 wxULongLong
1106
1107     #define wxHAS_INT64 1
1108
1109 #else /* !wxUSE_LONGLONG */
1110
1111     #define wxHAS_INT64 0
1112
1113 #endif
1114
1115
1116 /* Make sure ssize_t is defined (a signed type the same size as size_t) */
1117 /* HAVE_SSIZE_T should be defined for compiliers that already have it */
1118 #ifdef __MINGW32__
1119     #if defined(_SSIZE_T_) && !defined(HAVE_SSIZE_T)
1120         #define HAVE_SSIZE_T
1121     #endif
1122 #endif
1123 #if defined(__PALMOS__) && !defined(HAVE_SSIZE_T)
1124     #define HAVE_SSIZE_T
1125 #endif
1126 #if wxCHECK_WATCOM_VERSION(1,4)
1127     #define HAVE_SSIZE_T
1128 #endif
1129 #ifndef HAVE_SSIZE_T
1130     #if SIZEOF_SIZE_T == 4
1131         typedef wxInt32 ssize_t;
1132     #elif SIZEOF_SIZE_T == 8
1133         typedef wxInt64 ssize_t;
1134     #else
1135         #error "error defining ssize_t, size_t is not 4 or 8 bytes"
1136     #endif
1137 #endif
1138
1139
1140 /*  base floating point types */
1141 /*  wxFloat32: 32 bit IEEE float ( 1 sign, 8 exponent bits, 23 fraction bits */
1142 /*  wxFloat64: 64 bit IEEE float ( 1 sign, 11 exponent bits, 52 fraction bits */
1143 /*  wxDouble: native fastest representation that has at least wxFloat64 */
1144 /*            precision, so use the IEEE types for storage, and this for */
1145 /*            calculations */
1146
1147 typedef float wxFloat32;
1148 #if (defined( __WXMAC__ ) || defined(__WXCOCOA__))  && defined (__MWERKS__)
1149     typedef short double wxFloat64;
1150 #else
1151     typedef double wxFloat64;
1152 #endif
1153
1154 typedef double wxDouble;
1155
1156 /*
1157     Some (non standard) compilers typedef wchar_t as an existing type instead
1158     of treating it as a real fundamental type, set wxWCHAR_T_IS_REAL_TYPE to 0
1159     for them and to 1 for all the others.
1160  */
1161 #ifndef wxWCHAR_T_IS_REAL_TYPE
1162     /*
1163         VC++ typedefs wchar_t as unsigned short by default until VC8, that is
1164         unless /Za or /Zc:wchar_t option is used in which case _WCHAR_T_DEFINED
1165         is defined.
1166      */
1167 #   if defined(__VISUALC__) && !defined(_NATIVE_WCHAR_T_DEFINED)
1168 #       define wxWCHAR_T_IS_REAL_TYPE 0
1169 #   else /* compiler having standard-conforming wchar_t */
1170 #       define wxWCHAR_T_IS_REAL_TYPE 1
1171 #   endif
1172 #endif /* !defined(wxWCHAR_T_IS_REAL_TYPE) */
1173
1174 /* Helper macro for doing something dependent on whether wchar_t is or isn't a
1175    typedef inside another macro. */
1176 #if wxWCHAR_T_IS_REAL_TYPE
1177     #define wxIF_WCHAR_T_TYPE(x) x
1178 #else /* !wxWCHAR_T_IS_REAL_TYPE */
1179     #define wxIF_WCHAR_T_TYPE(x)
1180 #endif /* wxWCHAR_T_IS_REAL_TYPE/!wxWCHAR_T_IS_REAL_TYPE */
1181
1182 /*
1183    This constant should be used instead of NULL in vararg functions taking
1184    wxChar* arguments: passing NULL (which is the same as 0, unless the compiler
1185    defines it specially, e.g. like gcc does with its __null built-in) doesn't
1186    work in this case as va_arg() wouldn't interpret the integer 0 correctly
1187    when trying to convert it to a pointer on architectures where sizeof(int) is
1188    strictly less than sizeof(void *).
1189
1190    Examples of places where this must be used include wxFileTypeInfo ctor.
1191  */
1192 #define wxNullPtr ((void *)NULL)
1193
1194 /*  ---------------------------------------------------------------------------- */
1195 /*  byte ordering related definition and macros */
1196 /*  ---------------------------------------------------------------------------- */
1197
1198 /*  byte sex */
1199
1200 #define  wxBIG_ENDIAN     4321
1201 #define  wxLITTLE_ENDIAN  1234
1202 #define  wxPDP_ENDIAN     3412
1203
1204 #ifdef WORDS_BIGENDIAN
1205 #define  wxBYTE_ORDER  wxBIG_ENDIAN
1206 #else
1207 #define  wxBYTE_ORDER  wxLITTLE_ENDIAN
1208 #endif
1209
1210 /*  byte swapping */
1211
1212 #if defined (__MWERKS__) && ( (__MWERKS__ < 0x0900) || macintosh )
1213 /*  assembler versions for these */
1214 #ifdef __POWERPC__
1215     inline wxUint16 wxUINT16_SWAP_ALWAYS( wxUint16 i )
1216         {return (__lhbrx( &i , 0 ) );}
1217     inline wxInt16 wxINT16_SWAP_ALWAYS( wxInt16 i )
1218         {return (__lhbrx( &i , 0 ) );}
1219     inline wxUint32 wxUINT32_SWAP_ALWAYS( wxUint32 i )
1220         {return (__lwbrx( &i , 0 ) );}
1221     inline wxInt32 wxINT32_SWAP_ALWAYS( wxInt32 i )
1222         {return (__lwbrx( &i , 0 ) );}
1223 #else
1224     #pragma parameter __D0 wxUINT16_SWAP_ALWAYS(__D0)
1225     pascal wxUint16 wxUINT16_SWAP_ALWAYS(wxUint16 value)
1226         = { 0xE158 };
1227
1228     #pragma parameter __D0 wxINT16_SWAP_ALWAYS(__D0)
1229     pascal wxInt16 wxINT16_SWAP_ALWAYS(wxInt16 value)
1230         = { 0xE158 };
1231
1232     #pragma parameter __D0 wxUINT32_SWAP_ALWAYS (__D0)
1233     pascal wxUint32 wxUINT32_SWAP_ALWAYS(wxUint32 value)
1234         = { 0xE158, 0x4840, 0xE158 };
1235
1236     #pragma parameter __D0 wxINT32_SWAP_ALWAYS (__D0)
1237     pascal wxInt32 wxINT32_SWAP_ALWAYS(wxInt32 value)
1238         = { 0xE158, 0x4840, 0xE158 };
1239
1240 #endif
1241 #else /*  !MWERKS */
1242 #define wxUINT16_SWAP_ALWAYS(val) \
1243    ((wxUint16) ( \
1244     (((wxUint16) (val) & (wxUint16) 0x00ffU) << 8) | \
1245     (((wxUint16) (val) & (wxUint16) 0xff00U) >> 8)))
1246
1247 #define wxINT16_SWAP_ALWAYS(val) \
1248    ((wxInt16) ( \
1249     (((wxUint16) (val) & (wxUint16) 0x00ffU) << 8) | \
1250     (((wxUint16) (val) & (wxUint16) 0xff00U) >> 8)))
1251
1252 #define wxUINT32_SWAP_ALWAYS(val) \
1253    ((wxUint32) ( \
1254     (((wxUint32) (val) & (wxUint32) 0x000000ffU) << 24) | \
1255     (((wxUint32) (val) & (wxUint32) 0x0000ff00U) <<  8) | \
1256     (((wxUint32) (val) & (wxUint32) 0x00ff0000U) >>  8) | \
1257     (((wxUint32) (val) & (wxUint32) 0xff000000U) >> 24)))
1258
1259 #define wxINT32_SWAP_ALWAYS(val) \
1260    ((wxInt32) ( \
1261     (((wxUint32) (val) & (wxUint32) 0x000000ffU) << 24) | \
1262     (((wxUint32) (val) & (wxUint32) 0x0000ff00U) <<  8) | \
1263     (((wxUint32) (val) & (wxUint32) 0x00ff0000U) >>  8) | \
1264     (((wxUint32) (val) & (wxUint32) 0xff000000U) >> 24)))
1265 #endif
1266 /*  machine specific byte swapping */
1267
1268 #ifdef wxLongLong_t
1269     #define wxUINT64_SWAP_ALWAYS(val) \
1270        ((wxUint64) ( \
1271         (((wxUint64) (val) & (wxUint64) wxULL(0x00000000000000ff)) << 56) | \
1272         (((wxUint64) (val) & (wxUint64) wxULL(0x000000000000ff00)) << 40) | \
1273         (((wxUint64) (val) & (wxUint64) wxULL(0x0000000000ff0000)) << 24) | \
1274         (((wxUint64) (val) & (wxUint64) wxULL(0x00000000ff000000)) <<  8) | \
1275         (((wxUint64) (val) & (wxUint64) wxULL(0x000000ff00000000)) >>  8) | \
1276         (((wxUint64) (val) & (wxUint64) wxULL(0x0000ff0000000000)) >> 24) | \
1277         (((wxUint64) (val) & (wxUint64) wxULL(0x00ff000000000000)) >> 40) | \
1278         (((wxUint64) (val) & (wxUint64) wxULL(0xff00000000000000)) >> 56)))
1279
1280     #define wxINT64_SWAP_ALWAYS(val) \
1281        ((wxInt64) ( \
1282         (((wxUint64) (val) & (wxUint64) wxULL(0x00000000000000ff)) << 56) | \
1283         (((wxUint64) (val) & (wxUint64) wxULL(0x000000000000ff00)) << 40) | \
1284         (((wxUint64) (val) & (wxUint64) wxULL(0x0000000000ff0000)) << 24) | \
1285         (((wxUint64) (val) & (wxUint64) wxULL(0x00000000ff000000)) <<  8) | \
1286         (((wxUint64) (val) & (wxUint64) wxULL(0x000000ff00000000)) >>  8) | \
1287         (((wxUint64) (val) & (wxUint64) wxULL(0x0000ff0000000000)) >> 24) | \
1288         (((wxUint64) (val) & (wxUint64) wxULL(0x00ff000000000000)) >> 40) | \
1289         (((wxUint64) (val) & (wxUint64) wxULL(0xff00000000000000)) >> 56)))
1290 #elif wxUSE_LONGLONG /*  !wxLongLong_t */
1291     #define wxUINT64_SWAP_ALWAYS(val) \
1292        ((wxUint64) ( \
1293         ((wxULongLong(val) & wxULongLong(0L, 0x000000ffU)) << 56) | \
1294         ((wxULongLong(val) & wxULongLong(0L, 0x0000ff00U)) << 40) | \
1295         ((wxULongLong(val) & wxULongLong(0L, 0x00ff0000U)) << 24) | \
1296         ((wxULongLong(val) & wxULongLong(0L, 0xff000000U)) <<  8) | \
1297         ((wxULongLong(val) & wxULongLong(0x000000ffL, 0U)) >>  8) | \
1298         ((wxULongLong(val) & wxULongLong(0x0000ff00L, 0U)) >> 24) | \
1299         ((wxULongLong(val) & wxULongLong(0x00ff0000L, 0U)) >> 40) | \
1300         ((wxULongLong(val) & wxULongLong(0xff000000L, 0U)) >> 56)))
1301
1302     #define wxINT64_SWAP_ALWAYS(val) \
1303        ((wxInt64) ( \
1304         ((wxLongLong(val) & wxLongLong(0L, 0x000000ffU)) << 56) | \
1305         ((wxLongLong(val) & wxLongLong(0L, 0x0000ff00U)) << 40) | \
1306         ((wxLongLong(val) & wxLongLong(0L, 0x00ff0000U)) << 24) | \
1307         ((wxLongLong(val) & wxLongLong(0L, 0xff000000U)) <<  8) | \
1308         ((wxLongLong(val) & wxLongLong(0x000000ffL, 0U)) >>  8) | \
1309         ((wxLongLong(val) & wxLongLong(0x0000ff00L, 0U)) >> 24) | \
1310         ((wxLongLong(val) & wxLongLong(0x00ff0000L, 0U)) >> 40) | \
1311         ((wxLongLong(val) & wxLongLong(0xff000000L, 0U)) >> 56)))
1312 #endif /*  wxLongLong_t/!wxLongLong_t */
1313
1314 #ifdef WORDS_BIGENDIAN
1315     #define wxUINT16_SWAP_ON_BE(val)  wxUINT16_SWAP_ALWAYS(val)
1316     #define wxINT16_SWAP_ON_BE(val)   wxINT16_SWAP_ALWAYS(val)
1317     #define wxUINT16_SWAP_ON_LE(val)  (val)
1318     #define wxINT16_SWAP_ON_LE(val)   (val)
1319     #define wxUINT32_SWAP_ON_BE(val)  wxUINT32_SWAP_ALWAYS(val)
1320     #define wxINT32_SWAP_ON_BE(val)   wxINT32_SWAP_ALWAYS(val)
1321     #define wxUINT32_SWAP_ON_LE(val)  (val)
1322     #define wxINT32_SWAP_ON_LE(val)   (val)
1323     #if wxHAS_INT64
1324         #define wxUINT64_SWAP_ON_BE(val)  wxUINT64_SWAP_ALWAYS(val)
1325         #define wxUINT64_SWAP_ON_LE(val)  (val)
1326     #endif
1327 #else
1328     #define wxUINT16_SWAP_ON_LE(val)  wxUINT16_SWAP_ALWAYS(val)
1329     #define wxINT16_SWAP_ON_LE(val)   wxINT16_SWAP_ALWAYS(val)
1330     #define wxUINT16_SWAP_ON_BE(val)  (val)
1331     #define wxINT16_SWAP_ON_BE(val)   (val)
1332     #define wxUINT32_SWAP_ON_LE(val)  wxUINT32_SWAP_ALWAYS(val)
1333     #define wxINT32_SWAP_ON_LE(val)   wxINT32_SWAP_ALWAYS(val)
1334     #define wxUINT32_SWAP_ON_BE(val)  (val)
1335     #define wxINT32_SWAP_ON_BE(val)   (val)
1336     #if wxHAS_INT64
1337         #define wxUINT64_SWAP_ON_LE(val)  wxUINT64_SWAP_ALWAYS(val)
1338         #define wxUINT64_SWAP_ON_BE(val)  (val)
1339     #endif
1340 #endif
1341
1342 /*  ---------------------------------------------------------------------------- */
1343 /*  Geometric flags */
1344 /*  ---------------------------------------------------------------------------- */
1345
1346 enum wxGeometryCentre
1347 {
1348     wxCENTRE                  = 0x0001,
1349     wxCENTER                  = wxCENTRE
1350 };
1351
1352 /*  centering into frame rather than screen (obsolete) */
1353 #define wxCENTER_FRAME          0x0000
1354 /*  centre on screen rather than parent */
1355 #define wxCENTRE_ON_SCREEN      0x0002
1356 #define wxCENTER_ON_SCREEN      wxCENTRE_ON_SCREEN
1357
1358 enum wxOrientation
1359 {
1360     /* don't change the values of these elements, they are used elsewhere */
1361     wxHORIZONTAL              = 0x0004,
1362     wxVERTICAL                = 0x0008,
1363
1364     wxBOTH                    = wxVERTICAL | wxHORIZONTAL
1365 };
1366
1367 enum wxDirection
1368 {
1369     wxLEFT                    = 0x0010,
1370     wxRIGHT                   = 0x0020,
1371     wxUP                      = 0x0040,
1372     wxDOWN                    = 0x0080,
1373
1374     wxTOP                     = wxUP,
1375     wxBOTTOM                  = wxDOWN,
1376
1377     wxNORTH                   = wxUP,
1378     wxSOUTH                   = wxDOWN,
1379     wxWEST                    = wxLEFT,
1380     wxEAST                    = wxRIGHT,
1381
1382     wxALL                     = (wxUP | wxDOWN | wxRIGHT | wxLEFT)
1383 };
1384
1385 enum wxAlignment
1386 {
1387     wxALIGN_NOT               = 0x0000,
1388     wxALIGN_CENTER_HORIZONTAL = 0x0100,
1389     wxALIGN_CENTRE_HORIZONTAL = wxALIGN_CENTER_HORIZONTAL,
1390     wxALIGN_LEFT              = wxALIGN_NOT,
1391     wxALIGN_TOP               = wxALIGN_NOT,
1392     wxALIGN_RIGHT             = 0x0200,
1393     wxALIGN_BOTTOM            = 0x0400,
1394     wxALIGN_CENTER_VERTICAL   = 0x0800,
1395     wxALIGN_CENTRE_VERTICAL   = wxALIGN_CENTER_VERTICAL,
1396
1397     wxALIGN_CENTER            = (wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL),
1398     wxALIGN_CENTRE            = wxALIGN_CENTER,
1399
1400     /*  a mask to extract alignment from the combination of flags */
1401     wxALIGN_MASK              = 0x0f00
1402 };
1403
1404 enum wxStretch
1405 {
1406     /* for compatibility only, default now, don't use explicitly any more */
1407 #if WXWIN_COMPATIBILITY_2_6
1408     wxADJUST_MINSIZE          = 0,
1409 #endif
1410
1411     wxSTRETCH_NOT             = 0x0000,
1412     wxSHRINK                  = 0x1000,
1413     wxGROW                    = 0x2000,
1414     wxEXPAND                  = wxGROW,
1415     wxSHAPED                  = 0x4000,
1416     wxFIXED_MINSIZE           = 0x8000,
1417     wxTILE                    = 0xc000
1418 };
1419
1420 /*  border flags: the values are chosen for backwards compatibility */
1421 enum wxBorder
1422 {
1423     /*  this is different from wxBORDER_NONE as by default the controls do have */
1424     /*  border */
1425     wxBORDER_DEFAULT = 0,
1426
1427     wxBORDER_NONE   = 0x00200000,
1428     wxBORDER_STATIC = 0x01000000,
1429     wxBORDER_SIMPLE = 0x02000000,
1430     wxBORDER_RAISED = 0x04000000,
1431     wxBORDER_SUNKEN = 0x08000000,
1432     wxBORDER_DOUBLE = 0x10000000, /* deprecated */
1433     wxBORDER_THEME  = wxBORDER_DOUBLE,
1434
1435     /*  a mask to extract border style from the combination of flags */
1436     wxBORDER_MASK   = 0x1f200000
1437 };
1438
1439 /* This makes it easier to specify a 'normal' border for a control */
1440 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
1441 #define wxDEFAULT_CONTROL_BORDER    wxBORDER_SIMPLE
1442 #else
1443 #define wxDEFAULT_CONTROL_BORDER    wxBORDER_SUNKEN
1444 #endif
1445
1446 /*  ---------------------------------------------------------------------------- */
1447 /*  Window style flags */
1448 /*  ---------------------------------------------------------------------------- */
1449
1450 /*
1451  * Values are chosen so they can be |'ed in a bit list.
1452  * Some styles are used across more than one group,
1453  * so the values mustn't clash with others in the group.
1454  * Otherwise, numbers can be reused across groups.
1455  *
1456  * From version 1.66:
1457  * Window (cross-group) styles now take up the first half
1458  * of the flag, and control-specific styles the
1459  * second half.
1460  *
1461  */
1462
1463 /*
1464  * Window (Frame/dialog/subwindow/panel item) style flags
1465  */
1466 #define wxVSCROLL               0x80000000
1467 #define wxHSCROLL               0x40000000
1468 #define wxCAPTION               0x20000000
1469
1470 /*  New styles (border styles are now in their own enum) */
1471 #define wxDOUBLE_BORDER         wxBORDER_DOUBLE
1472 #define wxSUNKEN_BORDER         wxBORDER_SUNKEN
1473 #define wxRAISED_BORDER         wxBORDER_RAISED
1474 #define wxBORDER                wxBORDER_SIMPLE
1475 #define wxSIMPLE_BORDER         wxBORDER_SIMPLE
1476 #define wxSTATIC_BORDER         wxBORDER_STATIC
1477 #define wxNO_BORDER             wxBORDER_NONE
1478
1479 /*  wxALWAYS_SHOW_SB: instead of hiding the scrollbar when it is not needed, */
1480 /*  disable it - but still show (see also wxLB_ALWAYS_SB style) */
1481 /*  */
1482 /*  NB: as this style is only supported by wxUniversal and wxMSW so far */
1483 #define wxALWAYS_SHOW_SB        0x00800000
1484
1485 /*  Clip children when painting, which reduces flicker in e.g. frames and */
1486 /*  splitter windows, but can't be used in a panel where a static box must be */
1487 /*  'transparent' (panel paints the background for it) */
1488 #define wxCLIP_CHILDREN         0x00400000
1489
1490 /*  Note we're reusing the wxCAPTION style because we won't need captions */
1491 /*  for subwindows/controls */
1492 #define wxCLIP_SIBLINGS         0x20000000
1493
1494 #define wxTRANSPARENT_WINDOW    0x00100000
1495
1496 /*  Add this style to a panel to get tab traversal working outside of dialogs */
1497 /*  (on by default for wxPanel, wxDialog, wxScrolledWindow) */
1498 #define wxTAB_TRAVERSAL         0x00080000
1499
1500 /*  Add this style if the control wants to get all keyboard messages (under */
1501 /*  Windows, it won't normally get the dialog navigation key events) */
1502 #define wxWANTS_CHARS           0x00040000
1503
1504 /*  Make window retained (Motif only, see src/generic/scrolwing.cpp)
1505  *  This is non-zero only under wxMotif, to avoid a clash with wxPOPUP_WINDOW
1506  *  on other platforms
1507  */
1508
1509 #ifdef __WXMOTIF__
1510 #define wxRETAINED              0x00020000
1511 #else
1512 #define wxRETAINED              0x00000000
1513 #endif
1514 #define wxBACKINGSTORE          wxRETAINED
1515
1516 /*  set this flag to create a special popup window: it will be always shown on */
1517 /*  top of other windows, will capture the mouse and will be dismissed when the */
1518 /*  mouse is clicked outside of it or if it loses focus in any other way */
1519 #define wxPOPUP_WINDOW          0x00020000
1520
1521 /*  force a full repaint when the window is resized (instead of repainting just */
1522 /*  the invalidated area) */
1523 #define wxFULL_REPAINT_ON_RESIZE 0x00010000
1524
1525 /*  obsolete: now this is the default behaviour */
1526 /*  */
1527 /*  don't invalidate the whole window (resulting in a PAINT event) when the */
1528 /*  window is resized (currently, makes sense for wxMSW only) */
1529 #define wxNO_FULL_REPAINT_ON_RESIZE 0
1530
1531 /* A mask which can be used to filter (out) all wxWindow-specific styles.
1532  */
1533 #define wxWINDOW_STYLE_MASK     \
1534     (wxVSCROLL|wxHSCROLL|wxBORDER_MASK|wxALWAYS_SHOW_SB|wxCLIP_CHILDREN| \
1535      wxCLIP_SIBLINGS|wxTRANSPARENT_WINDOW|wxTAB_TRAVERSAL|wxWANTS_CHARS| \
1536      wxRETAINED|wxPOPUP_WINDOW|wxFULL_REPAINT_ON_RESIZE)
1537
1538 /*
1539  * Extra window style flags (use wxWS_EX prefix to make it clear that they
1540  * should be passed to wxWindow::SetExtraStyle(), not SetWindowStyle())
1541  */
1542
1543 /*  by default, TransferDataTo/FromWindow() only work on direct children of the */
1544 /*  window (compatible behaviour), set this flag to make them recursively */
1545 /*  descend into all subwindows */
1546 #define wxWS_EX_VALIDATE_RECURSIVELY    0x00000001
1547
1548 /*  wxCommandEvents and the objects of the derived classes are forwarded to the */
1549 /*  parent window and so on recursively by default. Using this flag for the */
1550 /*  given window allows to block this propagation at this window, i.e. prevent */
1551 /*  the events from being propagated further upwards. The dialogs have this */
1552 /*  flag on by default. */
1553 #define wxWS_EX_BLOCK_EVENTS            0x00000002
1554
1555 /*  don't use this window as an implicit parent for the other windows: this must */
1556 /*  be used with transient windows as otherwise there is the risk of creating a */
1557 /*  dialog/frame with this window as a parent which would lead to a crash if the */
1558 /*  parent is destroyed before the child */
1559 #define wxWS_EX_TRANSIENT               0x00000004
1560
1561 /*  don't paint the window background, we'll assume it will */
1562 /*  be done by a theming engine. This is not yet used but could */
1563 /*  possibly be made to work in the future, at least on Windows */
1564 #define wxWS_EX_THEMED_BACKGROUND       0x00000008
1565
1566 /*  this window should always process idle events */
1567 #define wxWS_EX_PROCESS_IDLE            0x00000010
1568
1569 /*  this window should always process UI update events */
1570 #define wxWS_EX_PROCESS_UI_UPDATES      0x00000020
1571
1572 /*  Draw the window in a metal theme on Mac */
1573 #define wxFRAME_EX_METAL                0x00000040
1574 #define wxDIALOG_EX_METAL               0x00000040
1575
1576 /*  Use this style to add a context-sensitive help to the window (currently for */
1577 /*  Win32 only and it doesn't work if wxMINIMIZE_BOX or wxMAXIMIZE_BOX are used) */
1578 #define wxWS_EX_CONTEXTHELP             0x00000080
1579
1580 /* synonyms for wxWS_EX_CONTEXTHELP for compatibility */
1581 #define wxFRAME_EX_CONTEXTHELP          wxWS_EX_CONTEXTHELP
1582 #define wxDIALOG_EX_CONTEXTHELP         wxWS_EX_CONTEXTHELP
1583
1584 /*  Create a window which is attachable to another top level window */
1585 #define wxFRAME_DRAWER          0x0020
1586
1587 /*
1588  * MDI parent frame style flags
1589  * Can overlap with some of the above.
1590  */
1591
1592 #define wxFRAME_NO_WINDOW_MENU  0x0100
1593
1594 /*
1595  * wxMenuBar style flags
1596  */
1597 /*  use native docking */
1598 #define wxMB_DOCKABLE       0x0001
1599
1600 /*
1601  * wxMenu style flags
1602  */
1603 #define wxMENU_TEAROFF      0x0001
1604
1605 /*
1606  * Apply to all panel items
1607  */
1608 #define wxCOLOURED          0x0800
1609 #define wxFIXED_LENGTH      0x0400
1610
1611 /*
1612  * Styles for wxListBox
1613  */
1614 #define wxLB_SORT           0x0010
1615 #define wxLB_SINGLE         0x0020
1616 #define wxLB_MULTIPLE       0x0040
1617 #define wxLB_EXTENDED       0x0080
1618 /*  wxLB_OWNERDRAW is Windows-only */
1619 #define wxLB_OWNERDRAW      0x0100
1620 #define wxLB_NEEDED_SB      0x0200
1621 #define wxLB_ALWAYS_SB      0x0400
1622 #define wxLB_HSCROLL        wxHSCROLL
1623 /*  always show an entire number of rows */
1624 #define wxLB_INT_HEIGHT     0x0800
1625
1626 #if WXWIN_COMPATIBILITY_2_6
1627     /*  deprecated synonyms */
1628     #define wxPROCESS_ENTER   0x0400  /*  wxTE_PROCESS_ENTER */
1629     #define wxPASSWORD        0x0800  /*  wxTE_PASSWORD */
1630 #endif
1631
1632 /*
1633  * wxComboBox style flags
1634  */
1635 #define wxCB_SIMPLE         0x0004
1636 #define wxCB_SORT           0x0008
1637 #define wxCB_READONLY       0x0010
1638 #define wxCB_DROPDOWN       0x0020
1639
1640 /*
1641  * wxRadioBox style flags
1642  */
1643 /*  should we number the items from left to right or from top to bottom in a 2d */
1644 /*  radiobox? */
1645 #define wxRA_LEFTTORIGHT    0x0001
1646 #define wxRA_TOPTOBOTTOM    0x0002
1647
1648 /*  New, more intuitive names to specify majorDim argument */
1649 #define wxRA_SPECIFY_COLS   wxHORIZONTAL
1650 #define wxRA_SPECIFY_ROWS   wxVERTICAL
1651
1652 /*  Old names for compatibility */
1653 #define wxRA_HORIZONTAL     wxHORIZONTAL
1654 #define wxRA_VERTICAL       wxVERTICAL
1655 #define wxRA_USE_CHECKBOX   0x0010 /* alternative native subcontrols (wxPalmOS) */
1656
1657 /*
1658  * wxRadioButton style flag
1659  */
1660 #define wxRB_GROUP          0x0004
1661 #define wxRB_SINGLE         0x0008
1662 #define wxRB_USE_CHECKBOX   0x0010 /* alternative native control (wxPalmOS) */
1663
1664 /*
1665  * wxScrollBar flags
1666  */
1667 #define wxSB_HORIZONTAL      wxHORIZONTAL
1668 #define wxSB_VERTICAL        wxVERTICAL
1669
1670 /*
1671  * wxSpinButton flags.
1672  * Note that a wxSpinCtrl is sometimes defined as
1673  * a wxTextCtrl, and so the flags must be different
1674  * from wxTextCtrl's.
1675  */
1676 #define wxSP_HORIZONTAL       wxHORIZONTAL /*  4 */
1677 #define wxSP_VERTICAL         wxVERTICAL   /*  8 */
1678 #define wxSP_ARROW_KEYS       0x1000
1679 #define wxSP_WRAP             0x2000
1680
1681 /*
1682  * wxTabCtrl flags
1683  */
1684 #define wxTC_RIGHTJUSTIFY     0x0010
1685 #define wxTC_FIXEDWIDTH       0x0020
1686 #define wxTC_TOP              0x0000    /*  default */
1687 #define wxTC_LEFT             0x0020
1688 #define wxTC_RIGHT            0x0040
1689 #define wxTC_BOTTOM           0x0080
1690 #define wxTC_MULTILINE        0x0200    /* == wxNB_MULTILINE */
1691 #define wxTC_OWNERDRAW        0x0400
1692
1693 /*
1694  * wxStatusBar95 flags
1695  */
1696 #define wxST_SIZEGRIP         0x0010
1697
1698 /*
1699  * wxStaticBitmap flags
1700  */
1701 #define wxBI_EXPAND           wxEXPAND
1702
1703 /*
1704  * wxStaticLine flags
1705  */
1706 #define wxLI_HORIZONTAL         wxHORIZONTAL
1707 #define wxLI_VERTICAL           wxVERTICAL
1708
1709
1710 /*
1711  * extended dialog specifiers. these values are stored in a different
1712  * flag and thus do not overlap with other style flags. note that these
1713  * values do not correspond to the return values of the dialogs (for
1714  * those values, look at the wxID_XXX defines).
1715  */
1716
1717 /*  wxCENTRE already defined as  0x00000001 */
1718 #define wxYES                   0x00000002
1719 #define wxOK                    0x00000004
1720 #define wxNO                    0x00000008
1721 #define wxYES_NO                (wxYES | wxNO)
1722 #define wxCANCEL                0x00000010
1723 #define wxAPPLY                 0x00000020
1724 #define wxCLOSE                 0x00000040
1725
1726 #define wxYES_DEFAULT           0x00000000  /*  has no effect (default) */
1727 #define wxNO_DEFAULT            0x00000080
1728
1729 #define wxICON_EXCLAMATION      0x00000100
1730 #define wxICON_HAND             0x00000200
1731 #define wxICON_WARNING          wxICON_EXCLAMATION
1732 #define wxICON_ERROR            wxICON_HAND
1733 #define wxICON_QUESTION         0x00000400
1734 #define wxICON_INFORMATION      0x00000800
1735 #define wxICON_STOP             wxICON_HAND
1736 #define wxICON_ASTERISK         wxICON_INFORMATION
1737 #define wxICON_MASK             (0x00000100|0x00000200|0x00000400|0x00000800)
1738
1739 #define  wxFORWARD              0x00001000
1740 #define  wxBACKWARD             0x00002000
1741 #define  wxRESET                0x00004000
1742 #define  wxHELP                 0x00008000
1743 #define  wxMORE                 0x00010000
1744 #define  wxSETUP                0x00020000
1745
1746 /*
1747  * Background styles. See wxWindow::SetBackgroundStyle
1748  */
1749
1750 enum wxBackgroundStyle
1751 {
1752   wxBG_STYLE_SYSTEM,
1753   wxBG_STYLE_COLOUR,
1754   wxBG_STYLE_CUSTOM,
1755   wxBG_STYLE_TRANSPARENT
1756 };
1757
1758 /*
1759  * Key types used by (old style) lists and hashes.
1760  */
1761 enum wxKeyType
1762 {
1763     wxKEY_NONE,
1764     wxKEY_INTEGER,
1765     wxKEY_STRING
1766 };
1767
1768 /*  ---------------------------------------------------------------------------- */
1769 /*  standard IDs */
1770 /*  ---------------------------------------------------------------------------- */
1771
1772 /*  Standard menu IDs */
1773 enum
1774 {
1775     /*
1776        These ids delimit the range used by automatically-generated ids
1777        (i.e. those used when wxID_ANY is specified during construction).
1778      */
1779     wxID_AUTO_LOWEST = -32000,
1780     wxID_AUTO_HIGHEST = -2000,
1781
1782     /* no id matches this one when compared to it */
1783     wxID_NONE = -3,
1784
1785     /*  id for a separator line in the menu (invalid for normal item) */
1786     wxID_SEPARATOR = -2,
1787
1788     /* any id: means that we don't care about the id, whether when installing
1789      * an event handler or when creating a new window */
1790     wxID_ANY = -1,
1791
1792
1793     /* all predefined ids are between wxID_LOWEST and wxID_HIGHEST */
1794     wxID_LOWEST = 4999,
1795
1796     wxID_OPEN,
1797     wxID_CLOSE,
1798     wxID_NEW,
1799     wxID_SAVE,
1800     wxID_SAVEAS,
1801     wxID_REVERT,
1802     wxID_EXIT,
1803     wxID_UNDO,
1804     wxID_REDO,
1805     wxID_HELP,
1806     wxID_PRINT,
1807     wxID_PRINT_SETUP,
1808     wxID_PAGE_SETUP,
1809     wxID_PREVIEW,
1810     wxID_ABOUT,
1811     wxID_HELP_CONTENTS,
1812     wxID_HELP_INDEX,
1813     wxID_HELP_SEARCH,
1814     wxID_HELP_COMMANDS,
1815     wxID_HELP_PROCEDURES,
1816     wxID_HELP_CONTEXT,
1817     wxID_CLOSE_ALL,
1818     wxID_PREFERENCES,
1819
1820     wxID_EDIT = 5030,
1821     wxID_CUT,
1822     wxID_COPY,
1823     wxID_PASTE,
1824     wxID_CLEAR,
1825     wxID_FIND,
1826     wxID_DUPLICATE,
1827     wxID_SELECTALL,
1828     wxID_DELETE,
1829     wxID_REPLACE,
1830     wxID_REPLACE_ALL,
1831     wxID_PROPERTIES,
1832
1833     wxID_VIEW_DETAILS,
1834     wxID_VIEW_LARGEICONS,
1835     wxID_VIEW_SMALLICONS,
1836     wxID_VIEW_LIST,
1837     wxID_VIEW_SORTDATE,
1838     wxID_VIEW_SORTNAME,
1839     wxID_VIEW_SORTSIZE,
1840     wxID_VIEW_SORTTYPE,
1841
1842     wxID_FILE = 5050,
1843     wxID_FILE1,
1844     wxID_FILE2,
1845     wxID_FILE3,
1846     wxID_FILE4,
1847     wxID_FILE5,
1848     wxID_FILE6,
1849     wxID_FILE7,
1850     wxID_FILE8,
1851     wxID_FILE9,
1852
1853     /*  Standard button and menu IDs */
1854     wxID_OK = 5100,
1855     wxID_CANCEL,
1856     wxID_APPLY,
1857     wxID_YES,
1858     wxID_NO,
1859     wxID_STATIC,
1860     wxID_FORWARD,
1861     wxID_BACKWARD,
1862     wxID_DEFAULT,
1863     wxID_MORE,
1864     wxID_SETUP,
1865     wxID_RESET,
1866     wxID_CONTEXT_HELP,
1867     wxID_YESTOALL,
1868     wxID_NOTOALL,
1869     wxID_ABORT,
1870     wxID_RETRY,
1871     wxID_IGNORE,
1872     wxID_ADD,
1873     wxID_REMOVE,
1874
1875     wxID_UP,
1876     wxID_DOWN,
1877     wxID_HOME,
1878     wxID_REFRESH,
1879     wxID_STOP,
1880     wxID_INDEX,
1881
1882     wxID_BOLD,
1883     wxID_ITALIC,
1884     wxID_JUSTIFY_CENTER,
1885     wxID_JUSTIFY_FILL,
1886     wxID_JUSTIFY_RIGHT,
1887     wxID_JUSTIFY_LEFT,
1888     wxID_UNDERLINE,
1889     wxID_INDENT,
1890     wxID_UNINDENT,
1891     wxID_ZOOM_100,
1892     wxID_ZOOM_FIT,
1893     wxID_ZOOM_IN,
1894     wxID_ZOOM_OUT,
1895     wxID_UNDELETE,
1896     wxID_REVERT_TO_SAVED,
1897
1898     /*  System menu IDs (used by wxUniv): */
1899     wxID_SYSTEM_MENU = 5200,
1900     wxID_CLOSE_FRAME,
1901     wxID_MOVE_FRAME,
1902     wxID_RESIZE_FRAME,
1903     wxID_MAXIMIZE_FRAME,
1904     wxID_ICONIZE_FRAME,
1905     wxID_RESTORE_FRAME,
1906
1907     /*  IDs used by generic file dialog (13 consecutive starting from this value) */
1908     wxID_FILEDLGG = 5900,
1909
1910     /*  IDs used by generic file ctrl (4 consecutive starting from this value) */
1911     wxID_FILECTRL = 5950,
1912
1913     wxID_HIGHEST = 5999
1914 };
1915
1916 /*  ---------------------------------------------------------------------------- */
1917 /*  other constants */
1918 /*  ---------------------------------------------------------------------------- */
1919
1920 /*  menu and toolbar item kinds */
1921 enum wxItemKind
1922 {
1923     wxITEM_SEPARATOR = -1,
1924     wxITEM_NORMAL,
1925     wxITEM_CHECK,
1926     wxITEM_RADIO,
1927     wxITEM_DROPDOWN,
1928     wxITEM_MAX
1929 };
1930
1931 /*  hit test results */
1932 enum wxHitTest
1933 {
1934     wxHT_NOWHERE,
1935
1936     /*  scrollbar */
1937     wxHT_SCROLLBAR_FIRST = wxHT_NOWHERE,
1938     wxHT_SCROLLBAR_ARROW_LINE_1,    /*  left or upper arrow to scroll by line */
1939     wxHT_SCROLLBAR_ARROW_LINE_2,    /*  right or down */
1940     wxHT_SCROLLBAR_ARROW_PAGE_1,    /*  left or upper arrow to scroll by page */
1941     wxHT_SCROLLBAR_ARROW_PAGE_2,    /*  right or down */
1942     wxHT_SCROLLBAR_THUMB,           /*  on the thumb */
1943     wxHT_SCROLLBAR_BAR_1,           /*  bar to the left/above the thumb */
1944     wxHT_SCROLLBAR_BAR_2,           /*  bar to the right/below the thumb */
1945     wxHT_SCROLLBAR_LAST,
1946
1947     /*  window */
1948     wxHT_WINDOW_OUTSIDE,            /*  not in this window at all */
1949     wxHT_WINDOW_INSIDE,             /*  in the client area */
1950     wxHT_WINDOW_VERT_SCROLLBAR,     /*  on the vertical scrollbar */
1951     wxHT_WINDOW_HORZ_SCROLLBAR,     /*  on the horizontal scrollbar */
1952     wxHT_WINDOW_CORNER,             /*  on the corner between 2 scrollbars */
1953
1954     wxHT_MAX
1955 };
1956
1957 /*  ---------------------------------------------------------------------------- */
1958 /*  Possible SetSize flags */
1959 /*  ---------------------------------------------------------------------------- */
1960
1961 /*  Use internally-calculated width if -1 */
1962 #define wxSIZE_AUTO_WIDTH       0x0001
1963 /*  Use internally-calculated height if -1 */
1964 #define wxSIZE_AUTO_HEIGHT      0x0002
1965 /*  Use internally-calculated width and height if each is -1 */
1966 #define wxSIZE_AUTO             (wxSIZE_AUTO_WIDTH|wxSIZE_AUTO_HEIGHT)
1967 /*  Ignore missing (-1) dimensions (use existing). */
1968 /*  For readability only: test for wxSIZE_AUTO_WIDTH/HEIGHT in code. */
1969 #define wxSIZE_USE_EXISTING     0x0000
1970 /*  Allow -1 as a valid position */
1971 #define wxSIZE_ALLOW_MINUS_ONE  0x0004
1972 /*  Don't do parent client adjustments (for implementation only) */
1973 #define wxSIZE_NO_ADJUSTMENTS   0x0008
1974 /*  Change the window position even if it seems to be already correct */
1975 #define wxSIZE_FORCE            0x0010
1976
1977 /*  ---------------------------------------------------------------------------- */
1978 /*  GDI descriptions */
1979 /*  ---------------------------------------------------------------------------- */
1980
1981 enum
1982 {
1983     /*  Text font families */
1984     wxDEFAULT    = 70,
1985     wxDECORATIVE,
1986     wxROMAN,
1987     wxSCRIPT,
1988     wxSWISS,
1989     wxMODERN,
1990     wxTELETYPE,  /* @@@@ */
1991
1992     /*  Proportional or Fixed width fonts (not yet used) */
1993     wxVARIABLE   = 80,
1994     wxFIXED,
1995
1996     wxNORMAL     = 90,
1997     wxLIGHT,
1998     wxBOLD,
1999     /*  Also wxNORMAL for normal (non-italic text) */
2000     wxITALIC,
2001     wxSLANT,
2002
2003     /*  Pen styles */
2004     wxSOLID      =   100,
2005     wxDOT,
2006     wxLONG_DASH,
2007     wxSHORT_DASH,
2008     wxDOT_DASH,
2009     wxUSER_DASH,
2010
2011     wxTRANSPARENT,
2012
2013     /*  Brush & Pen Stippling. Note that a stippled pen cannot be dashed!! */
2014     /*  Note also that stippling a Pen IS meaningfull, because a Line is */
2015     wxSTIPPLE_MASK_OPAQUE, /* mask is used for blitting monochrome using text fore and back ground colors */
2016     wxSTIPPLE_MASK,        /* mask is used for masking areas in the stipple bitmap (TO DO) */
2017     /*  drawn with a Pen, and without any Brush -- and it can be stippled. */
2018     wxSTIPPLE =          110,
2019
2020     wxBDIAGONAL_HATCH,     /* In wxWidgets < 2.6 use WX_HATCH macro  */
2021     wxCROSSDIAG_HATCH,     /* to verify these wx*_HATCH are in style */
2022     wxFDIAGONAL_HATCH,     /* of wxBrush. In wxWidgets >= 2.6 use    */
2023     wxCROSS_HATCH,         /* wxBrush::IsHatch() instead.            */
2024     wxHORIZONTAL_HATCH,
2025     wxVERTICAL_HATCH,
2026     wxFIRST_HATCH = wxBDIAGONAL_HATCH,
2027     wxLAST_HATCH = wxVERTICAL_HATCH,
2028
2029     wxJOIN_BEVEL =     120,
2030     wxJOIN_MITER,
2031     wxJOIN_ROUND,
2032
2033     wxCAP_ROUND =      130,
2034     wxCAP_PROJECTING,
2035     wxCAP_BUTT
2036 };
2037
2038 /*  Logical ops */
2039 typedef enum
2040 {
2041     wxCLEAR,        wxROP_BLACK = wxCLEAR,             wxBLIT_BLACKNESS = wxCLEAR,        /*  0 */
2042     wxXOR,          wxROP_XORPEN = wxXOR,              wxBLIT_SRCINVERT = wxXOR,          /*  src XOR dst */
2043     wxINVERT,       wxROP_NOT = wxINVERT,              wxBLIT_DSTINVERT = wxINVERT,       /*  NOT dst */
2044     wxOR_REVERSE,   wxROP_MERGEPENNOT = wxOR_REVERSE,  wxBLIT_00DD0228 = wxOR_REVERSE,    /*  src OR (NOT dst) */
2045     wxAND_REVERSE,  wxROP_MASKPENNOT = wxAND_REVERSE,  wxBLIT_SRCERASE = wxAND_REVERSE,   /*  src AND (NOT dst) */
2046     wxCOPY,         wxROP_COPYPEN = wxCOPY,            wxBLIT_SRCCOPY = wxCOPY,           /*  src */
2047     wxAND,          wxROP_MASKPEN = wxAND,             wxBLIT_SRCAND = wxAND,             /*  src AND dst */
2048     wxAND_INVERT,   wxROP_MASKNOTPEN = wxAND_INVERT,   wxBLIT_00220326 = wxAND_INVERT,    /*  (NOT src) AND dst */
2049     wxNO_OP,        wxROP_NOP = wxNO_OP,               wxBLIT_00AA0029 = wxNO_OP,         /*  dst */
2050     wxNOR,          wxROP_NOTMERGEPEN = wxNOR,         wxBLIT_NOTSRCERASE = wxNOR,        /*  (NOT src) AND (NOT dst) */
2051     wxEQUIV,        wxROP_NOTXORPEN = wxEQUIV,         wxBLIT_00990066 = wxEQUIV,         /*  (NOT src) XOR dst */
2052     wxSRC_INVERT,   wxROP_NOTCOPYPEN = wxSRC_INVERT,   wxBLIT_NOTSCRCOPY = wxSRC_INVERT,  /*  (NOT src) */
2053     wxOR_INVERT,    wxROP_MERGENOTPEN = wxOR_INVERT,   wxBLIT_MERGEPAINT = wxOR_INVERT,   /*  (NOT src) OR dst */
2054     wxNAND,         wxROP_NOTMASKPEN = wxNAND,         wxBLIT_007700E6 = wxNAND,          /*  (NOT src) OR (NOT dst) */
2055     wxOR,           wxROP_MERGEPEN = wxOR,             wxBLIT_SRCPAINT = wxOR,            /*  src OR dst */
2056     wxSET,          wxROP_WHITE = wxSET,               wxBLIT_WHITENESS = wxSET           /*  1 */
2057 } form_ops_t;
2058
2059 /*  Flood styles */
2060 enum
2061 {
2062     wxFLOOD_SURFACE = 1,
2063     wxFLOOD_BORDER
2064 };
2065
2066 /*  Polygon filling mode */
2067 enum
2068 {
2069     wxODDEVEN_RULE = 1,
2070     wxWINDING_RULE
2071 };
2072
2073 /*  ToolPanel in wxFrame (VZ: unused?) */
2074 enum
2075 {
2076     wxTOOL_TOP = 1,
2077     wxTOOL_BOTTOM,
2078     wxTOOL_LEFT,
2079     wxTOOL_RIGHT
2080 };
2081
2082 /*  the values of the format constants should be the same as corresponding */
2083 /*  CF_XXX constants in Windows API */
2084 enum wxDataFormatId
2085 {
2086     wxDF_INVALID =          0,
2087     wxDF_TEXT =             1,  /* CF_TEXT */
2088     wxDF_BITMAP =           2,  /* CF_BITMAP */
2089     wxDF_METAFILE =         3,  /* CF_METAFILEPICT */
2090     wxDF_SYLK =             4,
2091     wxDF_DIF =              5,
2092     wxDF_TIFF =             6,
2093     wxDF_OEMTEXT =          7,  /* CF_OEMTEXT */
2094     wxDF_DIB =              8,  /* CF_DIB */
2095     wxDF_PALETTE =          9,
2096     wxDF_PENDATA =          10,
2097     wxDF_RIFF =             11,
2098     wxDF_WAVE =             12,
2099     wxDF_UNICODETEXT =      13,
2100     wxDF_ENHMETAFILE =      14,
2101     wxDF_FILENAME =         15, /* CF_HDROP */
2102     wxDF_LOCALE =           16,
2103     wxDF_PRIVATE =          20,
2104     wxDF_HTML =             30, /* Note: does not correspond to CF_ constant */
2105     wxDF_MAX
2106 };
2107
2108 /*  Virtual keycodes */
2109 enum wxKeyCode
2110 {
2111     WXK_BACK    =    8,
2112     WXK_TAB     =    9,
2113     WXK_RETURN  =    13,
2114     WXK_ESCAPE  =    27,
2115     WXK_SPACE   =    32,
2116     WXK_DELETE  =    127,
2117
2118     /* These are, by design, not compatible with unicode characters.
2119        If you want to get a unicode character from a key event, use
2120        wxKeyEvent::GetUnicodeKey instead.                           */
2121     WXK_START   = 300,
2122     WXK_LBUTTON,
2123     WXK_RBUTTON,
2124     WXK_CANCEL,
2125     WXK_MBUTTON,
2126     WXK_CLEAR,
2127     WXK_SHIFT,
2128     WXK_ALT,
2129     WXK_CONTROL,
2130     WXK_MENU,
2131     WXK_PAUSE,
2132     WXK_CAPITAL,
2133     WXK_END,
2134     WXK_HOME,
2135     WXK_LEFT,
2136     WXK_UP,
2137     WXK_RIGHT,
2138     WXK_DOWN,
2139     WXK_SELECT,
2140     WXK_PRINT,
2141     WXK_EXECUTE,
2142     WXK_SNAPSHOT,
2143     WXK_INSERT,
2144     WXK_HELP,
2145     WXK_NUMPAD0,
2146     WXK_NUMPAD1,
2147     WXK_NUMPAD2,
2148     WXK_NUMPAD3,
2149     WXK_NUMPAD4,
2150     WXK_NUMPAD5,
2151     WXK_NUMPAD6,
2152     WXK_NUMPAD7,
2153     WXK_NUMPAD8,
2154     WXK_NUMPAD9,
2155     WXK_MULTIPLY,
2156     WXK_ADD,
2157     WXK_SEPARATOR,
2158     WXK_SUBTRACT,
2159     WXK_DECIMAL,
2160     WXK_DIVIDE,
2161     WXK_F1,
2162     WXK_F2,
2163     WXK_F3,
2164     WXK_F4,
2165     WXK_F5,
2166     WXK_F6,
2167     WXK_F7,
2168     WXK_F8,
2169     WXK_F9,
2170     WXK_F10,
2171     WXK_F11,
2172     WXK_F12,
2173     WXK_F13,
2174     WXK_F14,
2175     WXK_F15,
2176     WXK_F16,
2177     WXK_F17,
2178     WXK_F18,
2179     WXK_F19,
2180     WXK_F20,
2181     WXK_F21,
2182     WXK_F22,
2183     WXK_F23,
2184     WXK_F24,
2185     WXK_NUMLOCK,
2186     WXK_SCROLL,
2187     WXK_PAGEUP,
2188     WXK_PAGEDOWN,
2189 #if WXWIN_COMPATIBILITY_2_6
2190     WXK_PRIOR = WXK_PAGEUP,
2191     WXK_NEXT  = WXK_PAGEDOWN,
2192 #endif
2193
2194     WXK_NUMPAD_SPACE,
2195     WXK_NUMPAD_TAB,
2196     WXK_NUMPAD_ENTER,
2197     WXK_NUMPAD_F1,
2198     WXK_NUMPAD_F2,
2199     WXK_NUMPAD_F3,
2200     WXK_NUMPAD_F4,
2201     WXK_NUMPAD_HOME,
2202     WXK_NUMPAD_LEFT,
2203     WXK_NUMPAD_UP,
2204     WXK_NUMPAD_RIGHT,
2205     WXK_NUMPAD_DOWN,
2206     WXK_NUMPAD_PAGEUP,
2207     WXK_NUMPAD_PAGEDOWN,
2208 #if WXWIN_COMPATIBILITY_2_6
2209     WXK_NUMPAD_PRIOR = WXK_NUMPAD_PAGEUP,
2210     WXK_NUMPAD_NEXT  = WXK_NUMPAD_PAGEDOWN,
2211 #endif
2212     WXK_NUMPAD_END,
2213     WXK_NUMPAD_BEGIN,
2214     WXK_NUMPAD_INSERT,
2215     WXK_NUMPAD_DELETE,
2216     WXK_NUMPAD_EQUAL,
2217     WXK_NUMPAD_MULTIPLY,
2218     WXK_NUMPAD_ADD,
2219     WXK_NUMPAD_SEPARATOR,
2220     WXK_NUMPAD_SUBTRACT,
2221     WXK_NUMPAD_DECIMAL,
2222     WXK_NUMPAD_DIVIDE,
2223
2224     WXK_WINDOWS_LEFT,
2225     WXK_WINDOWS_RIGHT,
2226     WXK_WINDOWS_MENU ,
2227     WXK_COMMAND,
2228
2229     /* Hardware-specific buttons */
2230     WXK_SPECIAL1 = 193,
2231     WXK_SPECIAL2,
2232     WXK_SPECIAL3,
2233     WXK_SPECIAL4,
2234     WXK_SPECIAL5,
2235     WXK_SPECIAL6,
2236     WXK_SPECIAL7,
2237     WXK_SPECIAL8,
2238     WXK_SPECIAL9,
2239     WXK_SPECIAL10,
2240     WXK_SPECIAL11,
2241     WXK_SPECIAL12,
2242     WXK_SPECIAL13,
2243     WXK_SPECIAL14,
2244     WXK_SPECIAL15,
2245     WXK_SPECIAL16,
2246     WXK_SPECIAL17,
2247     WXK_SPECIAL18,
2248     WXK_SPECIAL19,
2249     WXK_SPECIAL20
2250 };
2251
2252 /* This enum contains bit mask constants used in wxKeyEvent */
2253 enum wxKeyModifier
2254 {
2255     wxMOD_NONE      = 0x0000,
2256     wxMOD_ALT       = 0x0001,
2257     wxMOD_CONTROL   = 0x0002,
2258     wxMOD_ALTGR     = wxMOD_ALT | wxMOD_CONTROL,
2259     wxMOD_SHIFT     = 0x0004,
2260     wxMOD_META      = 0x0008,
2261     wxMOD_WIN       = wxMOD_META,
2262 #if defined(__WXMAC__) || defined(__WXCOCOA__)
2263     wxMOD_CMD       = wxMOD_META,
2264 #else
2265     wxMOD_CMD       = wxMOD_CONTROL,
2266 #endif
2267     wxMOD_ALL       = 0xffff
2268 };
2269
2270 /*  Mapping modes (same values as used by Windows, don't change) */
2271 enum
2272 {
2273     wxMM_TEXT = 1,
2274     wxMM_LOMETRIC,
2275     wxMM_HIMETRIC,
2276     wxMM_LOENGLISH,
2277     wxMM_HIENGLISH,
2278     wxMM_TWIPS,
2279     wxMM_ISOTROPIC,
2280     wxMM_ANISOTROPIC,
2281     wxMM_POINTS,
2282     wxMM_METRIC
2283 };
2284
2285 /* Shortcut for easier dialog-unit-to-pixel conversion */
2286 #define wxDLG_UNIT(parent, pt) parent->ConvertDialogToPixels(pt)
2287
2288 /* Paper types */
2289 typedef enum
2290 {
2291     wxPAPER_NONE,               /*  Use specific dimensions */
2292     wxPAPER_LETTER,             /*  Letter, 8 1/2 by 11 inches */
2293     wxPAPER_LEGAL,              /*  Legal, 8 1/2 by 14 inches */
2294     wxPAPER_A4,                 /*  A4 Sheet, 210 by 297 millimeters */
2295     wxPAPER_CSHEET,             /*  C Sheet, 17 by 22 inches */
2296     wxPAPER_DSHEET,             /*  D Sheet, 22 by 34 inches */
2297     wxPAPER_ESHEET,             /*  E Sheet, 34 by 44 inches */
2298     wxPAPER_LETTERSMALL,        /*  Letter Small, 8 1/2 by 11 inches */
2299     wxPAPER_TABLOID,            /*  Tabloid, 11 by 17 inches */
2300     wxPAPER_LEDGER,             /*  Ledger, 17 by 11 inches */
2301     wxPAPER_STATEMENT,          /*  Statement, 5 1/2 by 8 1/2 inches */
2302     wxPAPER_EXECUTIVE,          /*  Executive, 7 1/4 by 10 1/2 inches */
2303     wxPAPER_A3,                 /*  A3 sheet, 297 by 420 millimeters */
2304     wxPAPER_A4SMALL,            /*  A4 small sheet, 210 by 297 millimeters */
2305     wxPAPER_A5,                 /*  A5 sheet, 148 by 210 millimeters */
2306     wxPAPER_B4,                 /*  B4 sheet, 250 by 354 millimeters */
2307     wxPAPER_B5,                 /*  B5 sheet, 182-by-257-millimeter paper */
2308     wxPAPER_FOLIO,              /*  Folio, 8-1/2-by-13-inch paper */
2309     wxPAPER_QUARTO,             /*  Quarto, 215-by-275-millimeter paper */
2310     wxPAPER_10X14,              /*  10-by-14-inch sheet */
2311     wxPAPER_11X17,              /*  11-by-17-inch sheet */
2312     wxPAPER_NOTE,               /*  Note, 8 1/2 by 11 inches */
2313     wxPAPER_ENV_9,              /*  #9 Envelope, 3 7/8 by 8 7/8 inches */
2314     wxPAPER_ENV_10,             /*  #10 Envelope, 4 1/8 by 9 1/2 inches */
2315     wxPAPER_ENV_11,             /*  #11 Envelope, 4 1/2 by 10 3/8 inches */
2316     wxPAPER_ENV_12,             /*  #12 Envelope, 4 3/4 by 11 inches */
2317     wxPAPER_ENV_14,             /*  #14 Envelope, 5 by 11 1/2 inches */
2318     wxPAPER_ENV_DL,             /*  DL Envelope, 110 by 220 millimeters */
2319     wxPAPER_ENV_C5,             /*  C5 Envelope, 162 by 229 millimeters */
2320     wxPAPER_ENV_C3,             /*  C3 Envelope, 324 by 458 millimeters */
2321     wxPAPER_ENV_C4,             /*  C4 Envelope, 229 by 324 millimeters */
2322     wxPAPER_ENV_C6,             /*  C6 Envelope, 114 by 162 millimeters */
2323     wxPAPER_ENV_C65,            /*  C65 Envelope, 114 by 229 millimeters */
2324     wxPAPER_ENV_B4,             /*  B4 Envelope, 250 by 353 millimeters */
2325     wxPAPER_ENV_B5,             /*  B5 Envelope, 176 by 250 millimeters */
2326     wxPAPER_ENV_B6,             /*  B6 Envelope, 176 by 125 millimeters */
2327     wxPAPER_ENV_ITALY,          /*  Italy Envelope, 110 by 230 millimeters */
2328     wxPAPER_ENV_MONARCH,        /*  Monarch Envelope, 3 7/8 by 7 1/2 inches */
2329     wxPAPER_ENV_PERSONAL,       /*  6 3/4 Envelope, 3 5/8 by 6 1/2 inches */
2330     wxPAPER_FANFOLD_US,         /*  US Std Fanfold, 14 7/8 by 11 inches */
2331     wxPAPER_FANFOLD_STD_GERMAN, /*  German Std Fanfold, 8 1/2 by 12 inches */
2332     wxPAPER_FANFOLD_LGL_GERMAN, /*  German Legal Fanfold, 8 1/2 by 13 inches */
2333
2334     wxPAPER_ISO_B4,             /*  B4 (ISO) 250 x 353 mm */
2335     wxPAPER_JAPANESE_POSTCARD,  /*  Japanese Postcard 100 x 148 mm */
2336     wxPAPER_9X11,               /*  9 x 11 in */
2337     wxPAPER_10X11,              /*  10 x 11 in */
2338     wxPAPER_15X11,              /*  15 x 11 in */
2339     wxPAPER_ENV_INVITE,         /*  Envelope Invite 220 x 220 mm */
2340     wxPAPER_LETTER_EXTRA,       /*  Letter Extra 9 \275 x 12 in */
2341     wxPAPER_LEGAL_EXTRA,        /*  Legal Extra 9 \275 x 15 in */
2342     wxPAPER_TABLOID_EXTRA,      /*  Tabloid Extra 11.69 x 18 in */
2343     wxPAPER_A4_EXTRA,           /*  A4 Extra 9.27 x 12.69 in */
2344     wxPAPER_LETTER_TRANSVERSE,  /*  Letter Transverse 8 \275 x 11 in */
2345     wxPAPER_A4_TRANSVERSE,      /*  A4 Transverse 210 x 297 mm */
2346     wxPAPER_LETTER_EXTRA_TRANSVERSE, /*  Letter Extra Transverse 9\275 x 12 in */
2347     wxPAPER_A_PLUS,             /*  SuperA/SuperA/A4 227 x 356 mm */
2348     wxPAPER_B_PLUS,             /*  SuperB/SuperB/A3 305 x 487 mm */
2349     wxPAPER_LETTER_PLUS,        /*  Letter Plus 8.5 x 12.69 in */
2350     wxPAPER_A4_PLUS,            /*  A4 Plus 210 x 330 mm */
2351     wxPAPER_A5_TRANSVERSE,      /*  A5 Transverse 148 x 210 mm */
2352     wxPAPER_B5_TRANSVERSE,      /*  B5 (JIS) Transverse 182 x 257 mm */
2353     wxPAPER_A3_EXTRA,           /*  A3 Extra 322 x 445 mm */
2354     wxPAPER_A5_EXTRA,           /*  A5 Extra 174 x 235 mm */
2355     wxPAPER_B5_EXTRA,           /*  B5 (ISO) Extra 201 x 276 mm */
2356     wxPAPER_A2,                 /*  A2 420 x 594 mm */
2357     wxPAPER_A3_TRANSVERSE,      /*  A3 Transverse 297 x 420 mm */
2358     wxPAPER_A3_EXTRA_TRANSVERSE, /*  A3 Extra Transverse 322 x 445 mm */
2359
2360     wxPAPER_DBL_JAPANESE_POSTCARD,/* Japanese Double Postcard 200 x 148 mm */
2361     wxPAPER_A6,                 /* A6 105 x 148 mm */
2362     wxPAPER_JENV_KAKU2,         /* Japanese Envelope Kaku #2 */
2363     wxPAPER_JENV_KAKU3,         /* Japanese Envelope Kaku #3 */
2364     wxPAPER_JENV_CHOU3,         /* Japanese Envelope Chou #3 */
2365     wxPAPER_JENV_CHOU4,         /* Japanese Envelope Chou #4 */
2366     wxPAPER_LETTER_ROTATED,     /* Letter Rotated 11 x 8 1/2 in */
2367     wxPAPER_A3_ROTATED,         /* A3 Rotated 420 x 297 mm */
2368     wxPAPER_A4_ROTATED,         /* A4 Rotated 297 x 210 mm */
2369     wxPAPER_A5_ROTATED,         /* A5 Rotated 210 x 148 mm */
2370     wxPAPER_B4_JIS_ROTATED,     /* B4 (JIS) Rotated 364 x 257 mm */
2371     wxPAPER_B5_JIS_ROTATED,     /* B5 (JIS) Rotated 257 x 182 mm */
2372     wxPAPER_JAPANESE_POSTCARD_ROTATED,/* Japanese Postcard Rotated 148 x 100 mm */
2373     wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED,/* Double Japanese Postcard Rotated 148 x 200 mm */
2374     wxPAPER_A6_ROTATED,         /* A6 Rotated 148 x 105 mm */
2375     wxPAPER_JENV_KAKU2_ROTATED, /* Japanese Envelope Kaku #2 Rotated */
2376     wxPAPER_JENV_KAKU3_ROTATED, /* Japanese Envelope Kaku #3 Rotated */
2377     wxPAPER_JENV_CHOU3_ROTATED, /* Japanese Envelope Chou #3 Rotated */
2378     wxPAPER_JENV_CHOU4_ROTATED, /* Japanese Envelope Chou #4 Rotated */
2379     wxPAPER_B6_JIS,             /* B6 (JIS) 128 x 182 mm */
2380     wxPAPER_B6_JIS_ROTATED,     /* B6 (JIS) Rotated 182 x 128 mm */
2381     wxPAPER_12X11,              /* 12 x 11 in */
2382     wxPAPER_JENV_YOU4,          /* Japanese Envelope You #4 */
2383     wxPAPER_JENV_YOU4_ROTATED,  /* Japanese Envelope You #4 Rotated */
2384     wxPAPER_P16K,               /* PRC 16K 146 x 215 mm */
2385     wxPAPER_P32K,               /* PRC 32K 97 x 151 mm */
2386     wxPAPER_P32KBIG,            /* PRC 32K(Big) 97 x 151 mm */
2387     wxPAPER_PENV_1,             /* PRC Envelope #1 102 x 165 mm */
2388     wxPAPER_PENV_2,             /* PRC Envelope #2 102 x 176 mm */
2389     wxPAPER_PENV_3,             /* PRC Envelope #3 125 x 176 mm */
2390     wxPAPER_PENV_4,             /* PRC Envelope #4 110 x 208 mm */
2391     wxPAPER_PENV_5,             /* PRC Envelope #5 110 x 220 mm */
2392     wxPAPER_PENV_6,             /* PRC Envelope #6 120 x 230 mm */
2393     wxPAPER_PENV_7,             /* PRC Envelope #7 160 x 230 mm */
2394     wxPAPER_PENV_8,             /* PRC Envelope #8 120 x 309 mm */
2395     wxPAPER_PENV_9,             /* PRC Envelope #9 229 x 324 mm */
2396     wxPAPER_PENV_10,            /* PRC Envelope #10 324 x 458 mm */
2397     wxPAPER_P16K_ROTATED,       /* PRC 16K Rotated */
2398     wxPAPER_P32K_ROTATED,       /* PRC 32K Rotated */
2399     wxPAPER_P32KBIG_ROTATED,    /* PRC 32K(Big) Rotated */
2400     wxPAPER_PENV_1_ROTATED,     /* PRC Envelope #1 Rotated 165 x 102 mm */
2401     wxPAPER_PENV_2_ROTATED,     /* PRC Envelope #2 Rotated 176 x 102 mm */
2402     wxPAPER_PENV_3_ROTATED,     /* PRC Envelope #3 Rotated 176 x 125 mm */
2403     wxPAPER_PENV_4_ROTATED,     /* PRC Envelope #4 Rotated 208 x 110 mm */
2404     wxPAPER_PENV_5_ROTATED,     /* PRC Envelope #5 Rotated 220 x 110 mm */
2405     wxPAPER_PENV_6_ROTATED,     /* PRC Envelope #6 Rotated 230 x 120 mm */
2406     wxPAPER_PENV_7_ROTATED,     /* PRC Envelope #7 Rotated 230 x 160 mm */
2407     wxPAPER_PENV_8_ROTATED,     /* PRC Envelope #8 Rotated 309 x 120 mm */
2408     wxPAPER_PENV_9_ROTATED,     /* PRC Envelope #9 Rotated 324 x 229 mm */
2409     wxPAPER_PENV_10_ROTATED    /* PRC Envelope #10 Rotated 458 x 324 m */
2410 } wxPaperSize;
2411
2412 /* Printing orientation */
2413 #ifndef wxPORTRAIT
2414 #define wxPORTRAIT      1
2415 #define wxLANDSCAPE     2
2416 #endif
2417
2418 /* Duplex printing modes
2419  */
2420
2421 enum wxDuplexMode
2422 {
2423     wxDUPLEX_SIMPLEX, /*  Non-duplex */
2424     wxDUPLEX_HORIZONTAL,
2425     wxDUPLEX_VERTICAL
2426 };
2427
2428 /* Print quality.
2429  */
2430
2431 #define wxPRINT_QUALITY_HIGH    -1
2432 #define wxPRINT_QUALITY_MEDIUM  -2
2433 #define wxPRINT_QUALITY_LOW     -3
2434 #define wxPRINT_QUALITY_DRAFT   -4
2435
2436 typedef int wxPrintQuality;
2437
2438 /* Print mode (currently PostScript only)
2439  */
2440
2441 enum wxPrintMode
2442 {
2443     wxPRINT_MODE_NONE =    0,
2444     wxPRINT_MODE_PREVIEW = 1,   /*  Preview in external application */
2445     wxPRINT_MODE_FILE =    2,   /*  Print to file */
2446     wxPRINT_MODE_PRINTER = 3,   /*  Send to printer */
2447     wxPRINT_MODE_STREAM =  4    /*  Send postscript data into a stream */
2448 };
2449
2450 /*  ---------------------------------------------------------------------------- */
2451 /*  UpdateWindowUI flags */
2452 /*  ---------------------------------------------------------------------------- */
2453
2454 enum wxUpdateUI
2455 {
2456     wxUPDATE_UI_NONE          = 0x0000,
2457     wxUPDATE_UI_RECURSE       = 0x0001,
2458     wxUPDATE_UI_FROMIDLE      = 0x0002 /*  Invoked from On(Internal)Idle */
2459 };
2460
2461 /*  ---------------------------------------------------------------------------- */
2462 /*  miscellaneous */
2463 /*  ---------------------------------------------------------------------------- */
2464
2465 /*  define this macro if font handling is done using the X font names */
2466 #if (defined(__WXGTK__) && !defined(__WXGTK20__)) || defined(__X__)
2467     #define _WX_X_FONTLIKE
2468 #endif
2469
2470 /*  macro to specify "All Files" on different platforms */
2471 #if defined(__WXMSW__) || defined(__WXPM__)
2472 #   define wxALL_FILES_PATTERN   wxT("*.*")
2473 #   define wxALL_FILES           gettext_noop("All files (*.*)|*.*")
2474 #else
2475 #   define wxALL_FILES_PATTERN   wxT("*")
2476 #   define wxALL_FILES           gettext_noop("All files (*)|*")
2477 #endif
2478
2479 #if defined(__CYGWIN__) && defined(__WXMSW__)
2480 #   if wxUSE_STL || defined(wxUSE_STD_STRING)
2481          /*
2482             NASTY HACK because the gethostname in sys/unistd.h which the gnu
2483             stl includes and wx builds with by default clash with each other
2484             (windows version 2nd param is int, sys/unistd.h version is unsigned
2485             int).
2486           */
2487 #        define gethostname gethostnameHACK
2488 #        include <unistd.h>
2489 #        undef gethostname
2490 #   endif
2491 #endif
2492
2493 /*  --------------------------------------------------------------------------- */
2494 /*  macros that enable wxWidgets apps to be compiled in absence of the */
2495 /*  sytem headers, although some platform specific types are used in the */
2496 /*  platform specific (implementation) parts of the headers */
2497 /*  --------------------------------------------------------------------------- */
2498
2499 #ifdef __WXMAC__
2500
2501 #define WX_OPAQUE_TYPE( name ) struct wxOpaque##name
2502
2503 typedef void*       WXCOLORREF;
2504 typedef void*       WXCGIMAGEREF;
2505 typedef void*       WXHBITMAP;
2506 typedef void*       WXHCURSOR;
2507 typedef void*       WXHRGN;
2508 typedef void*       WXRECTPTR;
2509 typedef void*       WXPOINTPTR;
2510 typedef void*       WXHWND;
2511 typedef void*       WXEVENTREF;
2512 typedef void*       WXEVENTHANDLERREF;
2513 typedef void*       WXEVENTHANDLERCALLREF;
2514 typedef void*       WXAPPLEEVENTREF;
2515 typedef void*       WXHDC;
2516 typedef void*       WXHMENU;
2517 typedef unsigned int    WXUINT;
2518 typedef unsigned long   WXDWORD;
2519 typedef unsigned short  WXWORD;
2520
2521 typedef WX_OPAQUE_TYPE(CIconHandle ) * WXHICON ;
2522 typedef WX_OPAQUE_TYPE(PicHandle ) * WXHMETAFILE ;
2523 typedef WX_OPAQUE_TYPE(ControlRef ) * WXWidget ;
2524 typedef WX_OPAQUE_TYPE(WindowRef) * WXWindow ;
2525
2526 typedef void*       WXDisplay;
2527
2528 // a few native types
2529
2530 typedef const void * CFTypeRef;
2531
2532 typedef const struct __CFString * CFStringRef;
2533 typedef struct __CFString * CFMutableStringRef;
2534
2535 typedef struct __CFRunLoopSource * CFRunLoopSourceRef;
2536
2537 #define DECLARE_WXMAC_OPAQUE_CGREF( name ) typedef struct name* name##Ref;
2538
2539 DECLARE_WXMAC_OPAQUE_CGREF( CGColor );
2540 DECLARE_WXMAC_OPAQUE_CGREF( CGImage );
2541 DECLARE_WXMAC_OPAQUE_CGREF( CGContext );
2542
2543 #define DECLARE_WXMAC_OPAQUE_REF( name ) typedef struct Opaque##name* name;
2544
2545 DECLARE_WXMAC_OPAQUE_REF( PasteboardRef );
2546 DECLARE_WXMAC_OPAQUE_REF( IconRef );
2547
2548 #endif
2549
2550 #if defined( __WXCOCOA__ ) || defined(__WXMAC__)
2551
2552 /* Definitions of 32-bit/64-bit types
2553  * These are typedef'd exactly the same way in newer OS X headers so
2554  * redefinition when real headers are included should not be a problem.  If
2555  * it is, the types are being defined wrongly here.
2556  * The purpose of these types is so they can be used from public wx headers.
2557  * and also because the older (pre-Leopard) headers don't define them.
2558  */
2559
2560 /* NOTE: We don't pollute namespace with CGFLOAT_MIN/MAX/IS_DOUBLE macros
2561  * since they are unlikely to be needed in a public header.
2562  */
2563 #if defined(__LP64__) && __LP64__
2564     typedef double CGFloat;
2565 #else
2566     typedef float CGFloat;
2567 #endif
2568
2569 #if (defined(__LP64__) && __LP64__) || (defined(NS_BUILD_32_LIKE_64) && NS_BUILD_32_LIKE_64)
2570 typedef long NSInteger;
2571 typedef unsigned long NSUInteger;
2572 #else
2573 typedef int NSInteger;
2574 typedef unsigned int NSUInteger;
2575 #endif
2576
2577 /* Objective-C type declarations.
2578  * These are to be used in public headers in lieu of NSSomething* because
2579  * Objective-C class names are not available in C/C++ code.
2580  */
2581
2582 /*  NOTE: This ought to work with other compilers too, but I'm being cautious */
2583 #if (defined(__GNUC__) && defined(__APPLE__)) || defined(__MWERKS__)
2584 /* It's desirable to have type safety for Objective-C(++) code as it does
2585 at least catch typos of method names among other things.  However, it
2586 is not possible to declare an Objective-C class from plain old C or C++
2587 code.  Furthermore, because of C++ name mangling, the type name must
2588 be the same for both C++ and Objective-C++ code.  Therefore, we define
2589 what should be a pointer to an Objective-C class as a pointer to a plain
2590 old C struct with the same name.  Unfortunately, because the compiler
2591 does not see a struct as an Objective-C class we cannot declare it
2592 as a struct in Objective-C(++) mode.
2593 */
2594 #if defined(__OBJC__)
2595 #define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
2596 @class klass; \
2597 typedef klass *WX_##klass
2598 #else /*  not defined(__OBJC__) */
2599 #define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
2600 typedef struct klass *WX_##klass
2601 #endif /*  defined(__OBJC__) */
2602
2603 #else /*  not Apple's GNU or CodeWarrior */
2604 #warning "Objective-C types will not be checked by the compiler."
2605 /*  NOTE: typedef struct objc_object *id; */
2606 /*  IOW, we're declaring these using the id type without using that name, */
2607 /*  since "id" is used extensively not only within wxWidgets itself, but */
2608 /*  also in wxWidgets application code.  The following works fine when */
2609 /*  compiling C(++) code, and works without typesafety for Obj-C(++) code */
2610 #define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
2611 typedef struct objc_object *WX_##klass
2612
2613 #endif /*  (defined(__GNUC__) && defined(__APPLE__)) || defined(__MWERKS__) */
2614
2615 DECLARE_WXCOCOA_OBJC_CLASS(NSApplication);
2616 DECLARE_WXCOCOA_OBJC_CLASS(NSBitmapImageRep);
2617 DECLARE_WXCOCOA_OBJC_CLASS(NSBox);
2618 DECLARE_WXCOCOA_OBJC_CLASS(NSButton);
2619 DECLARE_WXCOCOA_OBJC_CLASS(NSColor);
2620 DECLARE_WXCOCOA_OBJC_CLASS(NSColorPanel);
2621 DECLARE_WXCOCOA_OBJC_CLASS(NSControl);
2622 DECLARE_WXCOCOA_OBJC_CLASS(NSCursor);
2623 DECLARE_WXCOCOA_OBJC_CLASS(NSEvent);
2624 DECLARE_WXCOCOA_OBJC_CLASS(NSFontPanel);
2625 DECLARE_WXCOCOA_OBJC_CLASS(NSImage);
2626 DECLARE_WXCOCOA_OBJC_CLASS(NSLayoutManager);
2627 DECLARE_WXCOCOA_OBJC_CLASS(NSMenu);
2628 DECLARE_WXCOCOA_OBJC_CLASS(NSMenuExtra);
2629 DECLARE_WXCOCOA_OBJC_CLASS(NSMenuItem);
2630 DECLARE_WXCOCOA_OBJC_CLASS(NSMutableArray);
2631 DECLARE_WXCOCOA_OBJC_CLASS(NSNotification);
2632 DECLARE_WXCOCOA_OBJC_CLASS(NSObject);
2633 DECLARE_WXCOCOA_OBJC_CLASS(NSPanel);
2634 DECLARE_WXCOCOA_OBJC_CLASS(NSScrollView);
2635 DECLARE_WXCOCOA_OBJC_CLASS(NSSound);
2636 DECLARE_WXCOCOA_OBJC_CLASS(NSStatusItem);
2637 DECLARE_WXCOCOA_OBJC_CLASS(NSTableColumn);
2638 DECLARE_WXCOCOA_OBJC_CLASS(NSTableView);
2639 DECLARE_WXCOCOA_OBJC_CLASS(NSTextContainer);
2640 DECLARE_WXCOCOA_OBJC_CLASS(NSTextField);
2641 DECLARE_WXCOCOA_OBJC_CLASS(NSTextStorage);
2642 DECLARE_WXCOCOA_OBJC_CLASS(NSThread);
2643 DECLARE_WXCOCOA_OBJC_CLASS(NSWindow);
2644 DECLARE_WXCOCOA_OBJC_CLASS(NSView);
2645 #ifdef __WXMAC__
2646 // things added for __WXMAC__
2647 DECLARE_WXCOCOA_OBJC_CLASS(NSString);
2648 #else
2649 // things only for __WXCOCOA__
2650 typedef WX_NSView WXWidget; /*  wxWidgets BASE definition */
2651 #endif
2652 #endif /*  __WXCOCOA__  || ( __WXMAC__ &__DARWIN__)*/
2653
2654 #if defined(__WXPALMOS__)
2655
2656 typedef void *          WXHWND;
2657 typedef void *          WXHANDLE;
2658 typedef void *          WXHICON;
2659 typedef void *          WXHFONT;
2660 typedef void *          WXHMENU;
2661 typedef void *          WXHPEN;
2662 typedef void *          WXHBRUSH;
2663 typedef void *          WXHPALETTE;
2664 typedef void *          WXHCURSOR;
2665 typedef void *          WXHRGN;
2666 typedef void *          WXHACCEL;
2667 typedef void *          WXHINSTANCE;
2668 typedef void *          WXHBITMAP;
2669 typedef void *          WXHIMAGELIST;
2670 typedef void *          WXHGLOBAL;
2671 typedef void *          WXHDC;
2672 typedef unsigned int    WXUINT;
2673 typedef unsigned long   WXDWORD;
2674 typedef unsigned short  WXWORD;
2675
2676 typedef unsigned long   WXCOLORREF;
2677 typedef struct tagMSG   WXMSG;
2678
2679 typedef WXHWND          WXWINHANDLE; /* WinHandle of PalmOS */
2680 typedef WXWINHANDLE     WXWidget;
2681
2682 typedef void *          WXFORMPTR;
2683 typedef void *          WXEVENTPTR;
2684 typedef void *          WXRECTANGLEPTR;
2685
2686 #endif /* __WXPALMOS__ */
2687
2688
2689 /* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */
2690 #if defined(__WIN32__)
2691
2692 /*  the keywords needed for WinMain() declaration */
2693 #ifndef WXFAR
2694 #    define WXFAR
2695 #endif
2696
2697 /*  Stand-ins for Windows types to avoid #including all of windows.h */
2698 typedef void *          WXHWND;
2699 typedef void *          WXHANDLE;
2700 typedef void *          WXHICON;
2701 typedef void *          WXHFONT;
2702 typedef void *          WXHMENU;
2703 typedef void *          WXHPEN;
2704 typedef void *          WXHBRUSH;
2705 typedef void *          WXHPALETTE;
2706 typedef void *          WXHCURSOR;
2707 typedef void *          WXHRGN;
2708 typedef void *          WXRECTPTR;
2709 typedef void *          WXHACCEL;
2710 typedef void WXFAR  *   WXHINSTANCE;
2711 typedef void *          WXHBITMAP;
2712 typedef void *          WXHIMAGELIST;
2713 typedef void *          WXHGLOBAL;
2714 typedef void *          WXHDC;
2715 typedef unsigned int    WXUINT;
2716 typedef unsigned long   WXDWORD;
2717 typedef unsigned short  WXWORD;
2718
2719 typedef unsigned long   WXCOLORREF;
2720 typedef void *          WXRGNDATA;
2721 typedef struct tagMSG   WXMSG;
2722 typedef void *          WXHCONV;
2723 typedef void *          WXHKEY;
2724 typedef void *          WXHTREEITEM;
2725
2726 typedef void *          WXDRAWITEMSTRUCT;
2727 typedef void *          WXMEASUREITEMSTRUCT;
2728 typedef void *          WXLPCREATESTRUCT;
2729
2730 typedef WXHWND          WXWidget;
2731
2732 #ifdef __WIN64__
2733 typedef unsigned __int64    WXWPARAM;
2734 typedef __int64            WXLPARAM;
2735 typedef __int64            WXLRESULT;
2736 #else
2737 typedef unsigned int    WXWPARAM;
2738 typedef long            WXLPARAM;
2739 typedef long            WXLRESULT;
2740 #endif
2741
2742 #if defined(__GNUWIN32__) || defined(__WXMICROWIN__)
2743 typedef int             (*WXFARPROC)();
2744 #else
2745 typedef int             (__stdcall *WXFARPROC)();
2746 #endif
2747 #endif /*  __WIN32__ */
2748
2749
2750 #if defined(__OS2__)
2751 typedef unsigned long   DWORD;
2752 typedef unsigned short  WORD;
2753 #endif
2754
2755 #if defined(__WXPM__) || defined(__EMX__)
2756 #ifdef __WXPM__
2757 /*  Stand-ins for OS/2 types, to avoid #including all of os2.h */
2758 typedef unsigned long   WXHWND;
2759 typedef unsigned long   WXHANDLE;
2760 typedef unsigned long   WXHICON;
2761 typedef unsigned long   WXHFONT;
2762 typedef unsigned long   WXHMENU;
2763 typedef unsigned long   WXHPEN;
2764 typedef unsigned long   WXHBRUSH;
2765 typedef unsigned long   WXHPALETTE;
2766 typedef unsigned long   WXHCURSOR;
2767 typedef unsigned long   WXHRGN;
2768 typedef unsigned long   WXHACCEL;
2769 typedef unsigned long   WXHBITMAP;
2770 typedef unsigned long   WXHDC;
2771 typedef unsigned int    WXUINT;
2772 typedef unsigned long   WXDWORD;
2773 typedef unsigned short  WXWORD;
2774
2775 typedef unsigned long   WXCOLORREF;
2776 typedef void *          WXMSG;
2777 typedef unsigned long   WXHTREEITEM;
2778
2779 typedef void *          WXDRAWITEMSTRUCT;
2780 typedef void *          WXMEASUREITEMSTRUCT;
2781 typedef void *          WXLPCREATESTRUCT;
2782
2783 typedef WXHWND          WXWidget;
2784 #endif
2785 #ifdef __EMX__
2786 /* Need a well-known type for WXFARPROC
2787    below. MPARAM is typedef'ed too late. */
2788 #define WXWPARAM        void *
2789 #define WXLPARAM        void *
2790 #else
2791 #define WXWPARAM        MPARAM
2792 #define WXLPARAM        MPARAM
2793 #endif
2794 #define RECT            RECTL
2795 #define LOGFONT         FATTRS
2796 #define LOWORD          SHORT1FROMMP
2797 #define HIWORD          SHORT2FROMMP
2798
2799 typedef unsigned long   WXMPARAM;
2800 typedef unsigned long   WXMSGID;
2801 typedef void*           WXRESULT;
2802 /* typedef int             (*WXFARPROC)(); */
2803 /*  some windows handles not defined by PM */
2804 typedef unsigned long   HANDLE;
2805 typedef unsigned long   HICON;
2806 typedef unsigned long   HFONT;
2807 typedef unsigned long   HMENU;
2808 typedef unsigned long   HPEN;
2809 typedef unsigned long   HBRUSH;
2810 typedef unsigned long   HPALETTE;
2811 typedef unsigned long   HCURSOR;
2812 typedef unsigned long   HINSTANCE;
2813 typedef unsigned long   HIMAGELIST;
2814 typedef unsigned long   HGLOBAL;
2815 #endif /*  WXPM || EMX */
2816
2817 #if defined (__WXPM__)
2818 /*  WIN32 graphics types for OS/2 GPI */
2819
2820 /*  RGB under OS2 is more like a PALETTEENTRY struct under Windows so we need a real RGB def */
2821 #define OS2RGB(r,g,b) ((DWORD)((unsigned char)(b) | ((unsigned char)(g) << 8)) | ((unsigned char)(r) << 16))
2822
2823 typedef unsigned long COLORREF;
2824 #define GetRValue(rgb) ((unsigned char)((rgb) >> 16))
2825 #define GetGValue(rgb) ((unsigned char)(((unsigned short)(rgb)) >> 8))
2826 #define GetBValue(rgb) ((unsigned char)(rgb))
2827 #define PALETTEINDEX(i) ((COLORREF)(0x01000000 | (DWORD)(WORD)(i)))
2828 #define PALETTERGB(r,g,b) (0x02000000 | OS2RGB(r,g,b))
2829 /*  OS2's RGB/RGB2 is backwards from this */
2830 typedef struct tagPALETTEENTRY
2831 {
2832     char bRed;
2833     char bGreen;
2834     char bBlue;
2835     char bFlags;
2836 } PALETTEENTRY;
2837 typedef struct tagLOGPALETTE
2838 {
2839     WORD palVersion;
2840     WORD palNumentries;
2841     WORD PALETTEENTRY[1];
2842 } LOGPALETTE;
2843
2844 #if (defined(__VISAGECPP__) && (__IBMCPP__ < 400)) || defined (__WATCOMC__)
2845     /*  VA 3.0 for some reason needs base data types when typedefing a proc proto??? */
2846 typedef void* (_System *WXFARPROC)(unsigned long, unsigned long, void*, void*);
2847 #else
2848 #if defined(__EMX__) && !defined(_System)
2849 #define _System
2850 #endif
2851 typedef WXRESULT (_System *WXFARPROC)(WXHWND, WXMSGID, WXWPARAM, WXLPARAM);
2852 #endif
2853
2854 #endif /* __WXPM__ */
2855
2856
2857 #if defined(__WXMOTIF__) || defined(__WXX11__)
2858 /* Stand-ins for X/Xt/Motif types */
2859 typedef void*           WXWindow;
2860 typedef void*           WXWidget;
2861 typedef void*           WXAppContext;
2862 typedef void*           WXColormap;
2863 typedef void*           WXColor;
2864 typedef void            WXDisplay;
2865 typedef void            WXEvent;
2866 typedef void*           WXCursor;
2867 typedef void*           WXPixmap;
2868 typedef void*           WXFontStructPtr;
2869 typedef void*           WXGC;
2870 typedef void*           WXRegion;
2871 typedef void*           WXFont;
2872 typedef void*           WXImage;
2873 typedef void*           WXFontList;
2874 typedef void*           WXFontSet;
2875 typedef void*           WXRendition;
2876 typedef void*           WXRenderTable;
2877 typedef void*           WXFontType; /* either a XmFontList or XmRenderTable */
2878 typedef void*           WXString;
2879
2880 typedef unsigned long   Atom;  /* this might fail on a few architectures */
2881 typedef long            WXPixel; /* safety catch in src/motif/colour.cpp */
2882
2883 #endif /*  Motif */
2884
2885 #ifdef __WXGTK__
2886
2887 /* Stand-ins for GLIB types */
2888 typedef char           gchar;
2889 typedef signed char    gint8;
2890 typedef int            gint;
2891 typedef unsigned       guint;
2892 typedef unsigned long  gulong;
2893 typedef void*          gpointer;
2894 typedef struct _GSList GSList;
2895
2896 /* Stand-ins for GDK types */
2897 typedef struct _GdkColor        GdkColor;
2898 typedef struct _GdkColormap     GdkColormap;
2899 typedef struct _GdkFont         GdkFont;
2900 typedef struct _GdkGC           GdkGC;
2901 typedef struct _GdkVisual       GdkVisual;
2902
2903 #ifdef __WXGTK20__
2904 typedef struct _GdkAtom        *GdkAtom;
2905 typedef struct _GdkDrawable     GdkWindow;
2906 typedef struct _GdkDrawable     GdkBitmap;
2907 typedef struct _GdkDrawable     GdkPixmap;
2908 #else /*  GTK+ 1.2 */
2909 typedef gulong                  GdkAtom;
2910 typedef struct _GdkWindow       GdkWindow;
2911 typedef struct _GdkWindow       GdkBitmap;
2912 typedef struct _GdkWindow       GdkPixmap;
2913 #endif /*  GTK+ 1.2/2.0 */
2914
2915 typedef struct _GdkCursor       GdkCursor;
2916 typedef struct _GdkRegion       GdkRegion;
2917 typedef struct _GdkDragContext  GdkDragContext;
2918
2919 #ifdef HAVE_XIM
2920 typedef struct _GdkIC           GdkIC;
2921 typedef struct _GdkICAttr       GdkICAttr;
2922 #endif
2923
2924 /* Stand-ins for GTK types */
2925 typedef struct _GtkWidget         GtkWidget;
2926 typedef struct _GtkRcStyle        GtkRcStyle;
2927 typedef struct _GtkAdjustment     GtkAdjustment;
2928 typedef struct _GtkList           GtkList;
2929 typedef struct _GtkToolbar        GtkToolbar;
2930 typedef struct _GtkTooltips       GtkTooltips;
2931 typedef struct _GtkNotebook       GtkNotebook;
2932 typedef struct _GtkNotebookPage   GtkNotebookPage;
2933 typedef struct _GtkAccelGroup     GtkAccelGroup;
2934 typedef struct _GtkItemFactory    GtkItemFactory;
2935 typedef struct _GtkSelectionData  GtkSelectionData;
2936 typedef struct _GtkTextBuffer     GtkTextBuffer;
2937 typedef struct _GtkRange          GtkRange;
2938 typedef struct _GtkCellRenderer   GtkCellRenderer;
2939
2940 typedef GtkWidget *WXWidget;
2941
2942 #ifndef __WXGTK20__
2943 #define GTK_OBJECT_GET_CLASS(object) (GTK_OBJECT(object)->klass)
2944 #define GTK_CLASS_TYPE(klass) ((klass)->type)
2945 #endif
2946
2947 #endif /*  __WXGTK__ */
2948
2949 #if defined(__WXGTK20__) || (defined(__WXX11__) && wxUSE_UNICODE)
2950 #define wxUSE_PANGO 1
2951 #else
2952 #define wxUSE_PANGO 0
2953 #endif
2954
2955 #if wxUSE_PANGO
2956 /* Stand-ins for Pango types */
2957 typedef struct _PangoContext         PangoContext;
2958 typedef struct _PangoLayout          PangoLayout;
2959 typedef struct _PangoFontDescription PangoFontDescription;
2960 #endif
2961
2962 #ifdef __WXMGL__
2963 typedef struct window_t *WXWidget;
2964 #endif /*  MGL */
2965
2966 #ifdef __WXDFB__
2967 /* DirectFB doesn't have the concept of non-TLW window, so use
2968    something arbitrary */
2969 typedef const void* WXWidget;
2970 #endif /*  DFB */
2971
2972 /*  This is required because of clashing macros in windows.h, which may be */
2973 /*  included before or after wxWidgets classes, and therefore must be */
2974 /*  disabled here before any significant wxWidgets headers are included. */
2975 #ifdef __WXMSW__
2976 #include "wx/msw/winundef.h"
2977 #endif /* __WXMSW__ */
2978
2979
2980 /*  include the feature test macros */
2981 #include "wx/features.h"
2982
2983 /*  --------------------------------------------------------------------------- */
2984 /*  macro to define a class without copy ctor nor assignment operator */
2985 /*  --------------------------------------------------------------------------- */
2986
2987 #define DECLARE_NO_COPY_CLASS(classname)        \
2988     private:                                    \
2989         classname(const classname&);            \
2990         classname& operator=(const classname&);
2991
2992 #define DECLARE_NO_ASSIGN_CLASS(classname)      \
2993     private:                                    \
2994         classname& operator=(const classname&);
2995
2996 /*  --------------------------------------------------------------------------- */
2997 /*  If a manifest is being automatically generated, add common controls 6 to it */
2998 /*  --------------------------------------------------------------------------- */
2999
3000 #if (!defined wxUSE_NO_MANIFEST || wxUSE_NO_MANIFEST == 0 ) && \
3001     ( defined _MSC_FULL_VER && _MSC_FULL_VER >= 140040130 )
3002
3003 #define WX_CC_MANIFEST(cpu)                     \
3004     "/manifestdependency:\"type='win32'         \
3005      name='Microsoft.Windows.Common-Controls'   \
3006      version='6.0.0.0'                          \
3007      processorArchitecture='"cpu"'              \
3008      publicKeyToken='6595b64144ccf1df'          \
3009      language='*'\""
3010
3011 #if defined _M_IX86
3012     #pragma comment(linker, WX_CC_MANIFEST("x86"))
3013 #elif defined _M_X64
3014     #pragma comment(linker, WX_CC_MANIFEST("amd64"))
3015 #elif defined _M_IA64
3016     #pragma comment(linker, WX_CC_MANIFEST("ia64"))
3017 #else
3018     #pragma comment(linker, WX_CC_MANIFEST("*"))
3019 #endif
3020
3021 #endif /* !wxUSE_NO_MANIFEST && _MSC_FULL_VER >= 140040130 */
3022
3023 #endif
3024     /*  _WX_DEFS_H_ */