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