include/wx/defs.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        defs.h
   3 // Purpose:     Declarations/definitions common to all wx source files
   4 // Author:      Julian Smart and others
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c)
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_DEFS_H_
  13 #define _WX_DEFS_H_
  14
  15 #if defined(__GNUG__) && !defined(__APPLE__)
  16 #pragma interface "defs.h"
  17 #endif
  18
  19 // ----------------------------------------------------------------------------
  20 // compiler and OS identification
  21 // ----------------------------------------------------------------------------
  22
  23 #include "wx/platform.h"
  24
  25 // Make sure the environment is set correctly
  26 #if defined(__WXMSW__) && defined(__X__)
  27 #error "Target can't be both X and Windows"
  28 #elif !defined(__WXMOTIF__) && !defined(__WXMSW__) && !defined(__WXGTK__) && \
  29       !defined(__WXPM__) && !defined(__WXMAC__) && !defined(__WXCOCOA__) && \
  30       !defined(__X__) && !defined(__WXMGL__) && !defined(__WXX11__) && \
  31       wxUSE_GUI
  32 #ifdef __UNIX__
  33 #error "No Target! You should use wx-config program for compilation flags!"
  34 #else // !Unix
  35 #error "No Target! You should use supplied makefiles for compilation!"
  36 #endif // Unix/!Unix
  37 #endif
  38
  39 // include the feature test macros
  40 #include "wx/features.h"
  41
  42 // suppress some Visual C++ warnings
  43 #ifdef __VISUALC__
  44 #   pragma warning(disable:4201)    // nonstandard extension used: nameless struct/union
  45 #   pragma warning(disable:4244)    // conversion from double to float
  46 #   pragma warning(disable:4100)    // unreferenced formal parameter
  47 #   pragma warning(disable:4511)    // copy ctor couldn't be generated
  48 #   pragma warning(disable:4512)    // operator=() couldn't be generated
  49 #   pragma warning(disable:4699)    // using precompiled header
  50 #   pragma warning(disable:4134)    // conversion between pointers to members of same class
  51 #   pragma warning(disable:4710)    // function not inlined
  52 #ifndef WIN32
  53 #   pragma warning(disable:4135)    // conversion between different integral types
  54 #   pragma warning(disable:4769)    // assignment of near pointer to long integer
  55 // This one is really annoying, since it occurs for each cast to (HANDLE)...
  56 #   pragma warning(disable:4305)    // truncation of long to near ptr
  57 #endif
  58 #endif // __VISUALC__
  59
  60 // suppress some Watcom C++ warnings
  61 #ifdef __WATCOMC__
  62 #   pragma warning 849 9            // Disable 'virtual function hidden'
  63 #   pragma warning 549 9            // Disable 'operand contains compiler generated information'
  64 #endif // __VISUALC__
  65
  66 // suppress some Salford C++ warnings
  67 #ifdef __SALFORDC__
  68 #   pragma suppress 353             // Possible nested comments
  69 #   pragma suppress 593             // Define not used
  70 #   pragma suppress 61              // enum has no name (doesn't suppress!)
  71 #   pragma suppress 106             // unnamed, unused parameter
  72 #   pragma suppress 571             // Virtual function hiding
  73 #endif // __SALFORDC__
  74
  75 // ----------------------------------------------------------------------------
  76 // wxWindows version and compatibility defines
  77 // ----------------------------------------------------------------------------
  78
  79 #include "wx/version.h"
  80
  81 // possibility to build non GUI apps is new, so don't burden ourselves with
  82 // compatibility code
  83 #if !wxUSE_GUI
  84 #undef WXWIN_COMPATIBILITY_2
  85 #undef WXWIN_COMPATIBILITY_2_2
  86
  87 #define WXWIN_COMPATIBILITY_2 0
  88 #define WXWIN_COMPATIBILITY_2_2 0
  89 #endif // !GUI
  90
  91 // ============================================================================
  92 // non portable C++ features
  93 // ============================================================================
  94
  95 // ----------------------------------------------------------------------------
  96 // compiler defects workarounds
  97 // ----------------------------------------------------------------------------
  98
  99 #if defined(__VISUALC__) && !defined(WIN32) && !defined(__WXWINCE__)
 100     // VC1.5 does not have LPTSTR type
 101 #define LPTSTR  LPSTR
 102 #define LPCTSTR LPCSTR
 103 #elif defined(__BORLANDC__) && !defined(__WIN32__)
 104 #ifndef LPTSTR
 105 #define LPTSTR  LPSTR
 106 #endif
 107 #ifndef LPCTSTR
 108 #define LPCTSTR LPSTR
 109 #endif
 110 #endif
 111
 112
 113 /*
 114    Digital Unix C++ compiler only defines this symbol for .cxx and .hxx files,
 115    so define it ourselves (newer versions do it for all files, though, and
 116    don't allow it to be redefined)
 117  */
 118 #if defined(__DECCXX) && !defined(__VMS) && !defined(__cplusplus)
 119 #define __cplusplus
 120 #endif /* __DECCXX */
 121
 122 // Resolves linking problems under HP-UX when compiling with gcc/g++
 123 #if defined(__HPUX__) && defined(__GNUG__)
 124 #define va_list __gnuc_va_list
 125 #endif // HP-UX
 126
 127 // ----------------------------------------------------------------------------
 128 // check for native bool type and TRUE/FALSE constants
 129 // ----------------------------------------------------------------------------
 130
 131 // Add more tests here for Windows compilers that already define bool
 132 // (under Unix, configure tests for this)
 133 #ifndef HAVE_BOOL
 134     #if defined( __MWERKS__ )
 135         #if (__MWERKS__ >= 0x1000) && __option(bool)
 136             #define HAVE_BOOL
 137         #endif
 138     #elif defined(__APPLE__) && defined(__APPLE_CC__)
 139         // Apple bundled gcc supports bool
 140         #define HAVE_BOOL
 141     #elif defined(__VISUALC__) && (__VISUALC__ == 1020)
 142         // in VC++ 4.2 the bool keyword is reserved (hence can't be typedefed)
 143         // but not implemented, so we must #define it
 144         #define bool unsigned int
 145     #elif defined(__VISUALC__) && (__VISUALC__ == 1010)
 146         // For VisualC++ 4.1, we need to define
 147         // bool as something between 4.0 & 5.0...
 148         typedef unsigned int wxbool;
 149         #define bool wxbool
 150         #define HAVE_BOOL
 151     #elif defined(__VISUALC__) && (__VISUALC__ > 1020)
 152         // VC++ supports bool since 4.2
 153         #define HAVE_BOOL
 154     #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x500)
 155         // Borland 5.0+ supports bool
 156         #define HAVE_BOOL
 157     #elif defined(__WATCOMC__) && (__WATCOMC__ >= 1100)
 158         // Watcom 11+ supports bool
 159         #define HAVE_BOOL
 160     #elif defined(__DIGITALMARS__)
 161         // DigitalMars supports bool
 162         #define HAVE_BOOL
 163     #elif defined(__GNUWIN32__) || defined(__MINGW32__) || defined(__CYGWIN__)
 164         // Cygwin supports bool
 165         #define HAVE_BOOL
 166     #elif defined(__VISAGECPP__)
 167         #if __IBMCPP__ < 400
 168             typedef unsigned long bool;
 169             #define true ((bool)1)
 170             #define false ((bool)0)
 171         #endif
 172         #define HAVE_BOOL
 173     #endif // compilers
 174 #endif // HAVE_BOOL
 175
 176 #if !defined(HAVE_BOOL) && !defined(bool) && !defined(VMS)
 177     // NB: of course, this doesn't replace the standard type, because, for
 178     //     example, overloading based on bool/int parameter doesn't work and
 179     //     so should be avoided in portable programs
 180     typedef unsigned int bool;
 181 #endif // bool
 182
 183 // deal with TRUE/true stuff: we assume that if the compiler supports bool, it
 184 // supports true/false as well and that, OTOH, if it does _not_ support bool,
 185 // it doesn't support these keywords (this is less sure, in particular VC++
 186 // 4.x could be a problem here)
 187 #ifndef HAVE_BOOL
 188     #define true ((bool)1)
 189     #define false ((bool)0)
 190 #endif
 191
 192 // for backwards compatibility, also define TRUE and FALSE
 193 //
 194 // note that these definitions should work both in C++ and C code, so don't
 195 // use true/false below
 196 #ifndef TRUE
 197     #define TRUE 1
 198 #endif
 199
 200 #ifndef FALSE
 201     #define FALSE 0
 202 #endif
 203
 204 typedef short int WXTYPE;
 205
 206 // special care should be taken with this type under Windows where the real
 207 // window id is unsigned, so we must always do the cast before comparing them
 208 // (or else they would be always different!). Usign wxGetWindowId() which does
 209 // the cast itself is recommended. Note that this type can't be unsigned
 210 // because wxID_ANY == -1 is a valid (and largely used) value for window id.
 211 typedef int wxWindowID;
 212
 213 // ----------------------------------------------------------------------------
 214 // other feature tests
 215 // ----------------------------------------------------------------------------
 216
 217 // Every ride down a slippery slope begins with a single step..
 218 //
 219 // Yes, using nested classes is indeed against our coding standards in
 220 // general, but there are places where you can use them to advantage
 221 // without totally breaking ports that cannot use them.  If you do, then
 222 // wrap it in this guard, but such cases should still be relatively rare.
 223 #ifndef __WIN16__
 224     #define wxUSE_NESTED_CLASSES    1
 225 #else
 226     #define wxUSE_NESTED_CLASSES    0
 227 #endif
 228
 229 // check for explicit keyword support
 230 #ifndef HAVE_EXPLICIT
 231     #if defined(__VISUALC__) && (__VISUALC__ >= 1100)
 232         // VC++ 6.0 and 5.0 have explicit (what about the earlier versions?)
 233         #define HAVE_EXPLICIT
 234     #elif ( defined(__MINGW32__) || defined(__CYGWIN32__) ) \
 235           && wxCHECK_GCC_VERSION(2, 95)
 236         // GCC 2.95 has explicit, what about earlier versions?
 237         #define HAVE_EXPLICIT
 238     #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x0520)
 239         // BC++ 4.52 doesn't support explicit, CBuilder 1 does
 240         #define HAVE_EXPLICIT
 241     #elif defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
 242         // Metrowerks CW6 or higher has explicit
 243         #define HAVE_EXPLICIT
 244     #endif
 245 #endif // !HAVE_EXPLICIT
 246
 247 #ifdef HAVE_EXPLICIT
 248     #define wxEXPLICIT explicit
 249 #else // !HAVE_EXPLICIT
 250     #define wxEXPLICIT
 251 #endif // HAVE_EXPLICIT/!HAVE_EXPLICIT
 252
 253 // check for static/const/reinterpret_cast<>()
 254 #ifndef HAVE_STATIC_CAST
 255     #if defined(__VISUALC__) && (__VISUALC__ >= 1100)
 256         // VC++ 6.0 and 5.0 have C++ casts (what about the earlier versions?)
 257         #define HAVE_CXX_CASTS
 258     #elif ( defined(__MINGW32__) || defined(__CYGWIN32__) ) \
 259           && wxCHECK_GCC_VERSION(2, 95)
 260         // GCC 2.95 has C++ casts, what about earlier versions?
 261         #define HAVE_CXX_CASTS
 262     #endif
 263 #endif // HAVE_STATIC_CAST
 264
 265 #ifdef HAVE_CXX_CASTS
 266     #ifndef HAVE_CONST_CAST
 267         #define HAVE_CONST_CAST
 268     #endif
 269 #endif // HAVE_CXX_CASTS
 270
 271 // ----------------------------------------------------------------------------
 272 // portable calling conventions macros
 273 // ----------------------------------------------------------------------------
 274
 275 // stdcall is used for all functions called by Windows under Windows
 276 #if defined(__WINDOWS__)
 277     #if defined(__GNUWIN32__)
 278         #define wxSTDCALL __attribute__((stdcall))
 279     #else
 280         // both VC++ and Borland understand this
 281         #define wxSTDCALL _stdcall
 282     #endif
 283
 284 #else // Win
 285     // no such stupidness under Unix
 286     #define wxSTDCALL
 287 #endif // platform
 288
 289 // LINKAGEMODE mode is empty for everyting except OS/2
 290 #ifndef LINKAGEMODE
 291     #define LINKAGEMODE
 292 #endif // LINKAGEMODE
 293
 294 // wxCALLBACK should be used for the functions which are called back by
 295 // Windows (such as compare function for wxListCtrl)
 296 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
 297     #define wxCALLBACK wxSTDCALL
 298 #else
 299     // no stdcall under Unix nor Win16
 300     #define wxCALLBACK
 301 #endif // platform
 302
 303 // generic calling convention for the extern "C" functions
 304
 305 #if defined(__VISUALC__)
 306   #define   wxC_CALLING_CONV    _cdecl
 307 #elif defined(__VISAGECPP__)
 308   #define   wxC_CALLING_CONV    _Optlink
 309 #else   // !Visual C++
 310   #define   wxC_CALLING_CONV
 311 #endif  // compiler
 312
 313 // callling convention for the qsort(3) callback
 314 #define wxCMPFUNC_CONV wxC_CALLING_CONV
 315
 316 // compatibility :-(
 317 #define CMPFUNC_CONV wxCMPFUNC_CONV
 318
 319 // ----------------------------------------------------------------------------
 320 // Making or using wxWindows as a Windows DLL
 321 // ----------------------------------------------------------------------------
 322
 323 #if defined(__WXMSW__)
 324     // __declspec works in BC++ 5 and later, Watcom C++ 11.0 and later as well
 325     // as VC++ and gcc
 326     #if defined(__VISUALC__) || defined(__BORLANDC__) || defined(__GNUC__) || defined(__WATCOMC__)
 327         #define WXEXPORT __declspec(dllexport)
 328         #define WXIMPORT __declspec(dllimport)
 329     #else // compiler doesn't support __declspec()
 330         #define WXEXPORT
 331         #define WXIMPORT
 332     #endif
 333 #elif defined(__WXPM__)
 334     #if defined (__WATCOMC__)
 335         #define WXEXPORT __declspec(dllexport)
 336         // __declspec(dllimport) prepends __imp to imported symbols. We do NOT
 337         // want that!
 338         #define WXIMPORT
 339     #elif (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )))
 340         #define WXEXPORT _Export
 341         #define WXIMPORT _Export
 342     #endif
 343 #elif defined(__WXMAC__) || defined(__WXCOCOA__)
 344     #ifdef __MWERKS__
 345         #define WXEXPORT __declspec(export)
 346         #define WXIMPORT __declspec(import)
 347     #endif
 348 #endif
 349
 350 // for other platforms/compilers we don't anything
 351 #ifndef WXEXPORT
 352     #define WXEXPORT
 353     #define WXIMPORT
 354 #endif
 355
 356 // WXDLLEXPORT maps to export declaration when building the DLL, to import
 357 // declaration if using it or to nothing at all if we don't use wxWin DLL
 358 #ifdef WXMAKINGDLL
 359     #define WXDLLEXPORT WXEXPORT
 360     #define WXDLLEXPORT_DATA(type) WXEXPORT type
 361     #define WXDLLEXPORT_CTORFN
 362 #elif defined(WXUSINGDLL)
 363     #define WXDLLEXPORT WXIMPORT
 364     #define WXDLLEXPORT_DATA(type) WXIMPORT type
 365     #define WXDLLEXPORT_CTORFN
 366 #else // not making nor using DLL
 367     #define WXDLLEXPORT
 368     #define WXDLLEXPORT_DATA(type) type
 369     #define WXDLLEXPORT_CTORFN
 370 #endif
 371
 372 // For ostream, istream ofstream
 373 #if defined(__BORLANDC__) && defined( _RTLDLL )
 374 #  define WXDLLIMPORT __import
 375 #else
 376 #  define WXDLLIMPORT
 377 #endif
 378
 379 #ifdef __cplusplus
 380 class WXDLLEXPORT wxObject;
 381 class WXDLLEXPORT wxEvent;
 382 #endif
 383
 384 // symbolic constant used by all Find()-like functions returning positive
 385 // integer on success as failure indicator
 386 #define wxNOT_FOUND       (-1)
 387
 388 // ----------------------------------------------------------------------------
 389 // Very common macros
 390 // ----------------------------------------------------------------------------
 391
 392 // Printf-like attribute definitions to obtain warnings with GNU C/C++
 393 #if defined(__GNUC__) && !wxUSE_UNICODE
 394 #  ifndef ATTRIBUTE_PRINTF
 395 #    define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n)))
 396 #    define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2)
 397 #    define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3)
 398 #    define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4)
 399 #    define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5)
 400 #    define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6)
 401 #  endif /* ATTRIBUTE_PRINTF */
 402 #else
 403 #  ifndef ATTRIBUTE_PRINTF
 404 #    define ATTRIBUTE_PRINTF
 405 #    define ATTRIBUTE_PRINTF_1
 406 #    define ATTRIBUTE_PRINTF_2
 407 #    define ATTRIBUTE_PRINTF_3
 408 #    define ATTRIBUTE_PRINTF_4
 409 #    define ATTRIBUTE_PRINTF_5
 410 #  endif /* ATTRIBUTE_PRINTF */
 411 #endif
 412
 413 // Macro to issue warning when using deprecated functions with gcc3 or MSVC7:
 414 #if wxCHECK_GCC_VERSION(3, 1)
 415     #define wxDEPRECATED(x) x __attribute__ ((deprecated))
 416 #elif defined(__VISUALC__) && (__VISUALC__ >= 1300)
 417     #define wxDEPRECATED(x) __declspec(deprecated) x
 418 #else
 419     #define wxDEPRECATED(x) x
 420 #endif
 421
 422 // everybody gets the assert and other debug macros
 423 #ifdef __cplusplus
 424 #include "wx/debug.h"
 425 #endif
 426
 427 // NULL declaration: it must be defined as 0 for C++ programs (in particular,
 428 // it must not be defined as "(void *)0" which is standard for C but completely
 429 // breaks C++ code)
 430 #include <stddef.h>
 431
 432 // Macro to cut down on compiler warnings.
 433 #if REMOVE_UNUSED_ARG
 434     #define WXUNUSED(identifier) /* identifier */
 435 #else  // stupid, broken compiler
 436     #define WXUNUSED(identifier) identifier
 437 #endif
 438
 439 // some arguments are only used in debug mode, but unused in release one
 440 #ifdef __WXDEBUG__
 441     #define WXUNUSED_UNLESS_DEBUG(param)  param
 442 #else
 443     #define WXUNUSED_UNLESS_DEBUG(param)  WXUNUSED(param)
 444 #endif
 445
 446 // delete pointer if it is not NULL and NULL it afterwards
 447 // (checking that it's !NULL before passing it to delete is just a
 448 //  a question of style, because delete will do it itself anyhow, but it might
 449 //  be considered as an error by some overzealous debugging implementations of
 450 //  the library, so we do it ourselves)
 451 #define wxDELETE(p)      if ( (p) != NULL ) { delete p; p = NULL; }
 452
 453 // delete an array and NULL it (see comments above)
 454 #define wxDELETEA(p)     if ( (p) ) { delete [] (p); p = NULL; }
 455
 456 // size of statically declared array
 457 #define WXSIZEOF(array)   (sizeof(array)/sizeof(array[0]))
 458
 459 // ----------------------------------------------------------------------------
 460 // compiler specific settings
 461 // ----------------------------------------------------------------------------
 462
 463 // to allow compiling with warning level 4 under Microsoft Visual C++ some
 464 // warnings just must be disabled
 465 #ifdef  __VISUALC__
 466   #pragma warning(disable: 4514) // unreferenced inline func has been removed
 467 /*
 468   you might be tempted to disable this one also: triggered by CHECK and FAIL
 469   macros in debug.h, but it's, overall, a rather useful one, so I leave it and
 470   will try to find some way to disable this warning just for CHECK/FAIL. Anyone?
 471 */
 472   #pragma warning(disable: 4127) // conditional expression is constant
 473 #endif  // VC++
 474
 475 #if defined(__MWERKS__)
 476     #undef try
 477     #undef except
 478     #undef finally
 479     #define except(x) catch(...)
 480 #endif // Metrowerks
 481
 482 // where should i put this? we need to make sure of this as it breaks
 483 // the <iostream> code.
 484 #if !wxUSE_IOSTREAMH && defined(__WXDEBUG__)
 485 #  ifndef __MWERKS__
 486 // #undef __WXDEBUG__
 487 #    ifdef wxUSE_DEBUG_NEW_ALWAYS
 488 #    undef wxUSE_DEBUG_NEW_ALWAYS
 489 #    define wxUSE_DEBUG_NEW_ALWAYS 0
 490 #    endif
 491 #  endif
 492 #endif
 493
 494 // Callback function type definition
 495 #ifdef __cplusplus
 496 typedef void (*wxFunction) (wxObject&, wxEvent&);
 497 #endif
 498
 499 // ----------------------------------------------------------------------------
 500 // OS mnemonics -- Identify the running OS (useful for Windows)
 501 // ----------------------------------------------------------------------------
 502
 503 // Not all platforms are currently available or supported
 504 enum
 505 {
 506     wxUNKNOWN_PLATFORM,
 507     wxCURSES,                 // Text-only CURSES
 508     wxXVIEW_X,                // Sun's XView OpenLOOK toolkit
 509     wxMOTIF_X,                // OSF Motif 1.x.x
 510     wxCOSE_X,                 // OSF Common Desktop Environment
 511     wxNEXTSTEP,               // NeXTStep
 512     wxMAC,                    // Apple Mac OS 8/9/X with Mac paths
 513     wxMAC_DARWIN,             // Apple Mac OS X with Unix paths
 514     wxBEOS,                   // BeOS
 515     wxGTK,                    // GTK on X
 516     wxGTK_WIN32,              // GTK on Win32
 517     wxGTK_OS2,                // GTK on OS/2
 518     wxGTK_BEOS,               // GTK on BeOS
 519     wxGEOS,                   // GEOS
 520     wxOS2_PM,                 // OS/2 Workplace
 521     wxWINDOWS,                // Windows or WfW
 522     wxMICROWINDOWS,           // MicroWindows
 523     wxPENWINDOWS,             // Windows for Pen Computing
 524     wxWINDOWS_NT,             // Windows NT
 525     wxWIN32S,                 // Windows 32S API
 526     wxWIN95,                  // Windows 95
 527     wxWIN386,                 // Watcom 32-bit supervisor modus
 528     wxMGL_UNIX,               // MGL with direct hardware access
 529     wxMGL_X,                  // MGL on X
 530     wxMGL_WIN32,              // MGL on Win32
 531     wxMGL_OS2,                // MGL on OS/2
 532     wxMGL_DOS,                // MGL on MS-DOS
 533     wxWINDOWS_OS2,            // Native OS/2 PM
 534     wxUNIX,                   // wxBase under Unix
 535     wxX11                     // Plain X11 and Universal widgets
 536 };
 537
 538 // ----------------------------------------------------------------------------
 539 // standard wxWindows types
 540 // ----------------------------------------------------------------------------
 541
 542 // the type for screen and DC coordinates
 543
 544 #if wxUSE_COMPATIBLE_COORD_TYPES
 545     // to ensure compatibility with 2.0, we must use long
 546     #define wxCoord long
 547 #else  // !wxUSE_COMPATIBLE_COORD_TYPES
 548     #ifdef __WIN16__
 549         // under Win16, int is too small, so use long to allow for bigger
 550         // virtual canvases
 551         typedef long wxCoord;
 552     #else // !Win16
 553         // other platforms we support have at least 32bit int - quite enough
 554         typedef int wxCoord;
 555     #endif // Win16/!Win16
 556 #endif // wxUSE_COMPATIBLE_COORD_TYPES/!wxUSE_COMPATIBLE_COORD_TYPES
 557
 558 // fixed length types
 559
 560 #define wxInt8    char    signed
 561 #define wxUint8   char  unsigned
 562
 563 #ifdef __WINDOWS__
 564     #if defined(__WIN16__)
 565         #define wxInt16    int    signed
 566         #define wxUint16   int  unsigned
 567         #define wxInt32   long    signed
 568         #define wxUint32  long  unsigned
 569     #elif defined(__WIN32__)
 570         #define wxInt16  short    signed
 571         #define wxUint16 short  unsigned
 572         #define wxInt32    int    signed
 573         #define wxUint32   int  unsigned
 574     #else
 575         // Win64 will have different type sizes
 576         #error "Please define a 32 bit type"
 577     #endif
 578 #else // !Windows
 579     // SIZEOF_XXX are defined by configure
 580     #if defined(SIZEOF_INT) && (SIZEOF_INT == 4)
 581         #define wxInt16  short    signed
 582         #define wxUint16 short  unsigned
 583         #define wxInt32    int    signed
 584         #define wxUint32   int  unsigned
 585     #elif defined(SIZEOF_INT) && (SIZEOF_INT == 2)
 586         #define wxInt16    int    signed
 587         #define wxUint16   int  unsigned
 588         #define wxInt32   long    signed
 589         #define wxUint32  long  unsigned
 590     #else
 591         // assume sizeof(int) == 4 - what else can we do
 592         wxCOMPILE_TIME_ASSERT( sizeof(int) == 4, IntMustBeExactly4Bytes);
 593
 594         #define wxInt16  short    signed
 595         #define wxUint16 short  unsigned
 596         #define wxInt32    int    signed
 597         #define wxUint32   int  unsigned
 598     #endif
 599 #endif // Win/!Win
 600
 601 #if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
 602 #define wxInt64   long    signed
 603 #define wxUint64  long  unsigned
 604 #elif defined(SIZEOF_LONG_LONG) && (SIZEOF_LONG_LONG == 8)
 605 #define wxInt64   long long    signed
 606 #define wxUint64  long long  unsigned
 607 #else   // FIXME: what else can we do here aside from implementing wxULongLong
 608 #define wxInt64   wxLongLong
 609 #define wxUint64  wxULongLong
 610 #endif
 611
 612 #define  wxByte   wxUint8
 613 #define  wxWord   wxUint16
 614
 615 // base floating point types
 616 // wxFloat32 : 32 bit IEEE float ( 1 sign , 8 exponent bits , 23 fraction bits
 617 // wxFloat64 : 64 bit IEEE float ( 1 sign , 11 exponent bits , 52 fraction bits
 618 // wxDouble : native fastest representation that has at least wxFloat64
 619 //            precision, so use the IEEE types for storage , and this for calculations
 620
 621 typedef float wxFloat32 ;
 622 #if (defined( __WXMAC__ ) || defined(__WXCOCOA__))  && defined (__MWERKS__)
 623     typedef short double wxFloat64;
 624 #else
 625     typedef double wxFloat64;
 626 #endif
 627
 628 #if defined( __WXMAC__ )  && !defined( __POWERPC__ )
 629     typedef long double wxDouble;
 630 #else
 631     typedef double wxDouble ;
 632 #endif
 633
 634 // ----------------------------------------------------------------------------
 635 // byte ordering related definition and macros
 636 // ----------------------------------------------------------------------------
 637
 638 // byte sex
 639
 640 #define  wxBIG_ENDIAN     4321
 641 #define  wxLITTLE_ENDIAN  1234
 642 #define  wxPDP_ENDIAN     3412
 643
 644 #ifdef WORDS_BIGENDIAN
 645 #define  wxBYTE_ORDER  wxBIG_ENDIAN
 646 #else
 647 #define  wxBYTE_ORDER  wxLITTLE_ENDIAN
 648 #endif
 649
 650 // byte swapping
 651
 652 #if defined (__MWERKS__) && ( (__MWERKS__ < 0x0900) || macintosh )
 653 // assembler versions for these
 654 #ifdef __POWERPC__
 655     inline wxUint16 wxUINT16_SWAP_ALWAYS( wxUint16 i )
 656         {return (__lhbrx( &i , 0 ) ) ;}
 657     inline wxInt16 wxINT16_SWAP_ALWAYS( wxInt16 i )
 658         {return (__lhbrx( &i , 0 ) ) ;}
 659     inline wxUint32 wxUINT32_SWAP_ALWAYS( wxUint32 i )
 660         {return (__lwbrx( &i , 0 ) ) ;}
 661     inline wxInt32 wxINT32_SWAP_ALWAYS( wxInt32 i )
 662         {return (__lwbrx( &i , 0 ) ) ;}
 663 #else
 664     #pragma parameter __D0 wxUINT16_SWAP_ALWAYS(__D0)
 665     pascal wxUint16 wxUINT16_SWAP_ALWAYS(wxUint16 value)
 666         = { 0xE158 };
 667
 668     #pragma parameter __D0 wxINT16_SWAP_ALWAYS(__D0)
 669     pascal wxInt16 wxINT16_SWAP_ALWAYS(wxInt16 value)
 670         = { 0xE158 };
 671
 672     #pragma parameter __D0 wxUINT32_SWAP_ALWAYS (__D0)
 673     pascal wxUint32 wxUINT32_SWAP_ALWAYS(wxUint32 value)
 674         = { 0xE158, 0x4840, 0xE158 };
 675
 676     #pragma parameter __D0 wxINT32_SWAP_ALWAYS (__D0)
 677     pascal wxInt32 wxINT32_SWAP_ALWAYS(wxInt32 value)
 678         = { 0xE158, 0x4840, 0xE158 };
 679
 680 #endif
 681 #else // !MWERKS
 682 #define wxUINT16_SWAP_ALWAYS(val) \
 683    ((wxUint16) ( \
 684     (((wxUint16) (val) & (wxUint16) 0x00ffU) << 8) | \
 685     (((wxUint16) (val) & (wxUint16) 0xff00U) >> 8)))
 686
 687 #define wxINT16_SWAP_ALWAYS(val) \
 688    ((wxInt16) ( \
 689     (((wxUint16) (val) & (wxUint16) 0x00ffU) << 8) | \
 690     (((wxUint16) (val) & (wxUint16) 0xff00U) >> 8)))
 691
 692 #define wxUINT32_SWAP_ALWAYS(val) \
 693    ((wxUint32) ( \
 694     (((wxUint32) (val) & (wxUint32) 0x000000ffU) << 24) | \
 695     (((wxUint32) (val) & (wxUint32) 0x0000ff00U) <<  8) | \
 696     (((wxUint32) (val) & (wxUint32) 0x00ff0000U) >>  8) | \
 697     (((wxUint32) (val) & (wxUint32) 0xff000000U) >> 24)))
 698
 699 #define wxINT32_SWAP_ALWAYS(val) \
 700    ((wxInt32) ( \
 701     (((wxUint32) (val) & (wxUint32) 0x000000ffU) << 24) | \
 702     (((wxUint32) (val) & (wxUint32) 0x0000ff00U) <<  8) | \
 703     (((wxUint32) (val) & (wxUint32) 0x00ff0000U) >>  8) | \
 704     (((wxUint32) (val) & (wxUint32) 0xff000000U) >> 24)))
 705 #endif
 706 // machine specific byte swapping
 707
 708 #if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
 709 #define wxUINT64_SWAP_ALWAYS(val) \
 710    ((wxUint64) ( \
 711     (((wxUint64) (val) & (wxUint64) 0x00000000000000ffUL) << 56) | \
 712     (((wxUint64) (val) & (wxUint64) 0x000000000000ff00UL) << 40) | \
 713     (((wxUint64) (val) & (wxUint64) 0x0000000000ff0000UL) << 24) | \
 714     (((wxUint64) (val) & (wxUint64) 0x00000000ff000000UL) <<  8) | \
 715     (((wxUint64) (val) & (wxUint64) 0x000000ff00000000UL) >>  8) | \
 716     (((wxUint64) (val) & (wxUint64) 0x0000ff0000000000UL) >> 24) | \
 717     (((wxUint64) (val) & (wxUint64) 0x00ff000000000000UL) >> 40) | \
 718     (((wxUint64) (val) & (wxUint64) 0xff00000000000000UL) >> 56)))
 719
 720 #define wxINT64_SWAP_ALWAYS(val) \
 721    ((wxInt64) ( \
 722     (((wxUint64) (val) & (wxUint64) 0x00000000000000ffUL) << 56) | \
 723     (((wxUint64) (val) & (wxUint64) 0x000000000000ff00UL) << 40) | \
 724     (((wxUint64) (val) & (wxUint64) 0x0000000000ff0000UL) << 24) | \
 725     (((wxUint64) (val) & (wxUint64) 0x00000000ff000000UL) <<  8) | \
 726     (((wxUint64) (val) & (wxUint64) 0x000000ff00000000UL) >>  8) | \
 727     (((wxUint64) (val) & (wxUint64) 0x0000ff0000000000UL) >> 24) | \
 728     (((wxUint64) (val) & (wxUint64) 0x00ff000000000000UL) >> 40) | \
 729     (((wxUint64) (val) & (wxUint64) 0xff00000000000000UL) >> 56)))
 730
 731 #elif defined(SIZEOF_LONG_LONG) && (SIZEOF_LONG_LONG == 8)
 732 #define wxUINT64_SWAP_ALWAYS(val) \
 733    ((wxUint64) ( \
 734     (((wxUint64) (val) & (wxUint64) 0x00000000000000ffULL) << 56) | \
 735     (((wxUint64) (val) & (wxUint64) 0x000000000000ff00ULL) << 40) | \
 736     (((wxUint64) (val) & (wxUint64) 0x0000000000ff0000ULL) << 24) | \
 737     (((wxUint64) (val) & (wxUint64) 0x00000000ff000000ULL) <<  8) | \
 738     (((wxUint64) (val) & (wxUint64) 0x000000ff00000000ULL) >>  8) | \
 739     (((wxUint64) (val) & (wxUint64) 0x0000ff0000000000ULL) >> 24) | \
 740     (((wxUint64) (val) & (wxUint64) 0x00ff000000000000ULL) >> 40) | \
 741     (((wxUint64) (val) & (wxUint64) 0xff00000000000000ULL) >> 56)))
 742
 743 #define wxINT64_SWAP_ALWAYS(val) \
 744    ((wxInt64) ( \
 745     (((wxUint64) (val) & (wxUint64) 0x00000000000000ffULL) << 56) | \
 746     (((wxUint64) (val) & (wxUint64) 0x000000000000ff00ULL) << 40) | \
 747     (((wxUint64) (val) & (wxUint64) 0x0000000000ff0000ULL) << 24) | \
 748     (((wxUint64) (val) & (wxUint64) 0x00000000ff000000ULL) <<  8) | \
 749     (((wxUint64) (val) & (wxUint64) 0x000000ff00000000ULL) >>  8) | \
 750     (((wxUint64) (val) & (wxUint64) 0x0000ff0000000000ULL) >> 24) | \
 751     (((wxUint64) (val) & (wxUint64) 0x00ff000000000000ULL) >> 40) | \
 752     (((wxUint64) (val) & (wxUint64) 0xff00000000000000ULL) >> 56)))
 753
 754 #else
 755 #define wxUINT64_SWAP_ALWAYS(val) \
 756    ((wxUint64) ( \
 757     ((wxULongLong(val) & wxULongLong(0L, 0x000000ffU)) << 56) | \
 758     ((wxULongLong(val) & wxULongLong(0L, 0x0000ff00U)) << 40) | \
 759     ((wxULongLong(val) & wxULongLong(0L, 0x00ff0000U)) << 24) | \
 760     ((wxULongLong(val) & wxULongLong(0L, 0xff000000U)) <<  8) | \
 761     ((wxULongLong(val) & wxULongLong(0x000000ffL, 0U)) >>  8) | \
 762     ((wxULongLong(val) & wxULongLong(0x0000ff00L, 0U)) >> 24) | \
 763     ((wxULongLong(val) & wxULongLong(0x00ff0000L, 0U)) >> 40) | \
 764     ((wxULongLong(val) & wxULongLong(0xff000000L, 0U)) >> 56)))
 765
 766 #define wxINT64_SWAP_ALWAYS(val) \
 767    ((wxInt64) ( \
 768     ((wxLongLong(val) & wxLongLong(0L, 0x000000ffU)) << 56) | \
 769     ((wxLongLong(val) & wxLongLong(0L, 0x0000ff00U)) << 40) | \
 770     ((wxLongLong(val) & wxLongLong(0L, 0x00ff0000U)) << 24) | \
 771     ((wxLongLong(val) & wxLongLong(0L, 0xff000000U)) <<  8) | \
 772     ((wxLongLong(val) & wxLongLong(0x000000ffL, 0U)) >>  8) | \
 773     ((wxLongLong(val) & wxLongLong(0x0000ff00L, 0U)) >> 24) | \
 774     ((wxLongLong(val) & wxLongLong(0x00ff0000L, 0U)) >> 40) | \
 775     ((wxLongLong(val) & wxLongLong(0xff000000L, 0U)) >> 56)))
 776 #endif
 777
 778 #ifdef WORDS_BIGENDIAN
 779   #define wxUINT16_SWAP_ON_BE(val)  wxUINT16_SWAP_ALWAYS(val)
 780   #define wxINT16_SWAP_ON_BE(val)   wxINT16_SWAP_ALWAYS(val)
 781   #define wxUINT16_SWAP_ON_LE(val)  (val)
 782   #define wxINT16_SWAP_ON_LE(val)   (val)
 783   #define wxUINT32_SWAP_ON_BE(val)  wxUINT32_SWAP_ALWAYS(val)
 784   #define wxINT32_SWAP_ON_BE(val)   wxINT32_SWAP_ALWAYS(val)
 785   #define wxUINT32_SWAP_ON_LE(val)  (val)
 786   #define wxINT32_SWAP_ON_LE(val)   (val)
 787   #define wxUINT64_SWAP_ON_BE(val)  wxUINT64_SWAP_ALWAYS(val)
 788   #define wxUINT64_SWAP_ON_LE(val)  (val)
 789 #else
 790   #define wxUINT16_SWAP_ON_LE(val)  wxUINT16_SWAP_ALWAYS(val)
 791   #define wxINT16_SWAP_ON_LE(val)   wxINT16_SWAP_ALWAYS(val)
 792   #define wxUINT16_SWAP_ON_BE(val)  (val)
 793   #define wxINT16_SWAP_ON_BE(val)   (val)
 794   #define wxUINT32_SWAP_ON_LE(val)  wxUINT32_SWAP_ALWAYS(val)
 795   #define wxINT32_SWAP_ON_LE(val)   wxINT32_SWAP_ALWAYS(val)
 796   #define wxUINT32_SWAP_ON_BE(val)  (val)
 797   #define wxINT32_SWAP_ON_BE(val)   (val)
 798   #define wxUINT64_SWAP_ON_LE(val)  wxUINT64_SWAP_ALWAYS(val)
 799   #define wxUINT64_SWAP_ON_BE(val)  (val)
 800 #endif
 801
 802 // Macros to convert from unsigned long to void pointer.
 803 // High order truncation occurs if the respective type is not large enough.
 804 #define WXPTRULONGSLICE (((wxBYTE_ORDER==wxBIG_ENDIAN)&&(sizeof(void*)==8)&&(sizeof(unsigned long)<8))?1:0)
 805 #define wxPtrToULong(p) (((unsigned long*)(&(p)))[WXPTRULONGSLICE])
 806 #define wxULongToPtr(p,n) (p=NULL,wxPtrToULong(p)=(unsigned long)(n),p)
 807
 808 // ----------------------------------------------------------------------------
 809 // Geometric flags
 810 // ----------------------------------------------------------------------------
 811
 812 enum wxGeometryCentre
 813 {
 814     wxCENTRE                  = 0x0001,
 815     wxCENTER                  = wxCENTRE
 816 };
 817
 818 // centering into frame rather than screen (obsolete)
 819 #define wxCENTER_FRAME          0x0000
 820 // centre on screen rather than parent
 821 #define wxCENTRE_ON_SCREEN      0x0002
 822 #define wxCENTER_ON_SCREEN      wxCENTRE_ON_SCREEN
 823
 824 enum wxOrientation
 825 {
 826     wxHORIZONTAL              = 0x0004,
 827     wxVERTICAL                = 0x0008,
 828
 829     wxBOTH                    = (wxVERTICAL | wxHORIZONTAL)
 830 };
 831
 832 enum wxDirection
 833 {
 834     wxLEFT                    = 0x0010,
 835     wxRIGHT                   = 0x0020,
 836     wxUP                      = 0x0040,
 837     wxDOWN                    = 0x0080,
 838
 839     wxTOP                     = wxUP,
 840     wxBOTTOM                  = wxDOWN,
 841
 842     wxNORTH                   = wxUP,
 843     wxSOUTH                   = wxDOWN,
 844     wxWEST                    = wxLEFT,
 845     wxEAST                    = wxRIGHT,
 846
 847     wxALL                     = (wxUP | wxDOWN | wxRIGHT | wxLEFT)
 848 };
 849
 850 enum wxAlignment
 851 {
 852     wxALIGN_NOT               = 0x0000,
 853     wxALIGN_CENTER_HORIZONTAL = 0x0100,
 854     wxALIGN_CENTRE_HORIZONTAL = wxALIGN_CENTER_HORIZONTAL,
 855     wxALIGN_LEFT              = wxALIGN_NOT,
 856     wxALIGN_TOP               = wxALIGN_NOT,
 857     wxALIGN_RIGHT             = 0x0200,
 858     wxALIGN_BOTTOM            = 0x0400,
 859     wxALIGN_CENTER_VERTICAL   = 0x0800,
 860     wxALIGN_CENTRE_VERTICAL   = wxALIGN_CENTER_VERTICAL,
 861
 862     wxALIGN_CENTER            = (wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL),
 863     wxALIGN_CENTRE            = wxALIGN_CENTER,
 864
 865     // a mask to extract alignment from the combination of flags
 866     wxALIGN_MASK              = 0x0f00
 867 };
 868
 869 enum wxStretch
 870 {
 871     wxSTRETCH_NOT             = 0x0000,
 872     wxSHRINK                  = 0x1000,
 873     wxGROW                    = 0x2000,
 874     wxEXPAND                  = wxGROW,
 875     wxSHAPED                  = 0x4000,
 876     wxADJUST_MINSIZE          = 0x8000,
 877     wxTILE                    = 0xc000
 878 };
 879
 880 // border flags: the values are chosen for backwards compatibility
 881 enum wxBorder
 882 {
 883     // this is different from wxBORDER_NONE as by default the controls do have
 884     // border
 885     wxBORDER_DEFAULT = 0,
 886
 887     wxBORDER_NONE   = 0x00200000,
 888     wxBORDER_STATIC = 0x01000000,
 889     wxBORDER_SIMPLE = 0x02000000,
 890     wxBORDER_RAISED = 0x04000000,
 891     wxBORDER_SUNKEN = 0x08000000,
 892     wxBORDER_DOUBLE = 0x10000000,
 893
 894     // a mask to extract border style from the combination of flags
 895     wxBORDER_MASK   = 0x1f200000
 896 };
 897
 898 // ----------------------------------------------------------------------------
 899 // Window style flags
 900 // ----------------------------------------------------------------------------
 901
 902 /*
 903  * Values are chosen so they can be |'ed in a bit list.
 904  * Some styles are used across more than one group,
 905  * so the values mustn't clash with others in the group.
 906  * Otherwise, numbers can be reused across groups.
 907  *
 908  * From version 1.66:
 909  * Window (cross-group) styles now take up the first half
 910  * of the flag, and control-specific styles the
 911  * second half.
 912  *
 913  */
 914
 915 /*
 916  * Window (Frame/dialog/subwindow/panel item) style flags
 917  */
 918 #define wxVSCROLL               0x80000000
 919 #define wxHSCROLL               0x40000000
 920 #define wxCAPTION               0x20000000
 921
 922 // New styles (border styles are now in their own enum)
 923 #define wxDOUBLE_BORDER         wxBORDER_DOUBLE
 924 #define wxSUNKEN_BORDER         wxBORDER_SUNKEN
 925 #define wxRAISED_BORDER         wxBORDER_RAISED
 926 #define wxBORDER                wxBORDER_SIMPLE
 927 #define wxSIMPLE_BORDER         wxBORDER_SIMPLE
 928 #define wxSTATIC_BORDER         wxBORDER_STATIC
 929 #define wxNO_BORDER             wxBORDER_NONE
 930
 931 // Override CTL3D etc. control colour processing to allow own background
 932 // colour.
 933 // Override CTL3D or native 3D styles for children
 934 #define wxNO_3D                 0x00800000
 935
 936 // OBSOLETE - use wxNO_3D instead
 937 #define wxUSER_COLOURS          wxNO_3D
 938
 939 // wxALWAYS_SHOW_SB: instead of hiding the scrollbar when it is not needed,
 940 // disable it - but still show (see also wxLB_ALWAYS_SB style)
 941 //
 942 // NB: as this style is only supported by wxUniversal so far as it doesn't use
 943 //     wxUSER_COLOURS/wxNO_3D, we reuse the same style value
 944 #define wxALWAYS_SHOW_SB        0x00800000
 945
 946 // Clip children when painting, which reduces flicker in e.g. frames and
 947 // splitter windows, but can't be used in a panel where a static box must be
 948 // 'transparent' (panel paints the background for it)
 949 #define wxCLIP_CHILDREN         0x00400000
 950
 951 // Note we're reusing the wxCAPTION style because we won't need captions
 952 // for subwindows/controls
 953 #define wxCLIP_SIBLINGS         0x20000000
 954
 955 #define wxTRANSPARENT_WINDOW    0x00100000
 956
 957 // Add this style to a panel to get tab traversal working outside of dialogs
 958 // (on by default for wxPanel, wxDialog, wxScrolledWindow)
 959 #define wxTAB_TRAVERSAL         0x00080000
 960
 961 // Add this style if the control wants to get all keyboard messages (under
 962 // Windows, it won't normally get the dialog navigation key events)
 963 #define wxWANTS_CHARS           0x00040000
 964
 965 // Make window retained (mostly Motif, I think) -- obsolete (VZ)?
 966 #define wxRETAINED              0x00020000
 967 #define wxBACKINGSTORE          wxRETAINED
 968
 969 // set this flag to create a special popup window: it will be always shown on
 970 // top of other windows, will capture the mouse and will be dismissed when the
 971 // mouse is clicked outside of it or if it loses focus in any other way
 972 #define wxPOPUP_WINDOW          0x00020000
 973
 974 // don't invalidate the whole window (resulting in a PAINT event) when the
 975 // window is resized (currently, makes sense for wxMSW only)
 976 #define wxNO_FULL_REPAINT_ON_RESIZE 0x00010000
 977
 978 /*
 979  * Extra window style flags (use wxWS_EX prefix to make it clear that they
 980  * should be passed to wxWindow::SetExtraStyle(), not SetWindowStyle())
 981  */
 982
 983 // by default, TransferDataTo/FromWindow() only work on direct children of the
 984 // window (compatible behaviour), set this flag to make them recursively
 985 // descend into all subwindows
 986 #define wxWS_EX_VALIDATE_RECURSIVELY    0x00000001
 987
 988 // wxCommandEvents and the objects of the derived classes are forwarded to the
 989 // parent window and so on recursively by default. Using this flag for the
 990 // given window allows to block this propagation at this window, i.e. prevent
 991 // the events from being propagated further upwards. The dialogs have this
 992 // flag on by default.
 993 #define wxWS_EX_BLOCK_EVENTS            0x00000002
 994
 995 // don't use this window as an implicit parent for the other windows: this must
 996 // be used with transient windows as otherwise there is the risk of creating a
 997 // dialog/frame with this window as a parent which would lead to a crash if the
 998 // parent is destroyed before the child
 999 #define wxWS_EX_TRANSIENT               0x00000004
1000
1001 // Use this style to add a context-sensitive help to the window (currently for
1002 // Win32 only and it doesn't work if wxMINIMIZE_BOX or wxMAXIMIZE_BOX are used)
1003 #define wxFRAME_EX_CONTEXTHELP  0x00000004
1004 #define wxDIALOG_EX_CONTEXTHELP 0x00000004
1005
1006 /*
1007  * wxFrame/wxDialog style flags
1008  */
1009 #define wxSTAY_ON_TOP           0x8000
1010 #define wxICONIZE               0x4000
1011 #define wxMINIMIZE              wxICONIZE
1012 #define wxMAXIMIZE              0x2000
1013 #define wxCLOSE_BOX                 0x1000
1014
1015 #define wxSYSTEM_MENU           0x0800
1016 #define wxMINIMIZE_BOX          0x0400
1017 #define wxMAXIMIZE_BOX          0x0200
1018 #define wxTINY_CAPTION_HORIZ    0x0100
1019 #define wxTINY_CAPTION_VERT     0x0080
1020 #define wxRESIZE_BORDER         0x0040
1021
1022 #define wxDIALOG_NO_PARENT      0x0001  // Don't make owned by apps top window
1023 #define wxFRAME_NO_TASKBAR      0x0002  // No taskbar button (MSW only)
1024 #define wxFRAME_TOOL_WINDOW     0x0004  // No taskbar button, no system menu
1025 #define wxFRAME_FLOAT_ON_PARENT 0x0008  // Always above its parent
1026 #define wxFRAME_SHAPED          0x0010  // Create a window that is able to be shaped
1027
1028 // deprecated versions defined for compatibility reasons
1029 #define wxRESIZE_BOX            wxMAXIMIZE_BOX
1030 #define wxTHICK_FRAME           wxRESIZE_BORDER
1031
1032 // obsolete styles, unused any more
1033 #define wxDIALOG_MODAL          0x0020  // free flag value 0x0020
1034 #define wxDIALOG_MODELESS       0x0000
1035
1036 /*
1037  * MDI parent frame style flags
1038  * Can overlap with some of the above.
1039  */
1040
1041 #define wxFRAME_NO_WINDOW_MENU  0x0100
1042
1043 #if WXWIN_COMPATIBILITY
1044 #define wxDEFAULT_FRAME wxDEFAULT_FRAME_STYLE
1045 #endif
1046
1047 #define wxDEFAULT_FRAME_STYLE \
1048   (wxSYSTEM_MENU | wxRESIZE_BORDER | \
1049    wxMINIMIZE_BOX | wxMAXIMIZE_BOX | wxCLOSE_BOX | \
1050    wxCAPTION | wxCLIP_CHILDREN)
1051
1052 #define wxDEFAULT_DIALOG_STYLE  (wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX)
1053
1054 /*
1055  * wxExtDialog style flags
1056  */
1057 #define wxED_CLIENT_MARGIN      0x0004
1058 #define wxED_BUTTONS_BOTTOM     0x0000  // has no effect
1059 #define wxED_BUTTONS_RIGHT      0x0002
1060 #define wxED_STATIC_LINE        0x0001
1061
1062 #if defined(__WXMSW__) || defined(__WXMAC__)
1063 #   define wxEXT_DIALOG_STYLE  (wxDEFAULT_DIALOG_STYLE|wxED_CLIENT_MARGIN)
1064 #else
1065 #   define wxEXT_DIALOG_STYLE  (wxDEFAULT_DIALOG_STYLE|wxED_CLIENT_MARGIN|wxED_STATIC_LINE)
1066 #endif
1067
1068 /*
1069  * wxMenuBar style flags
1070  */
1071 // use native docking
1072 #define wxMB_DOCKABLE       0x0001
1073
1074 /*
1075  * wxMenu style flags
1076  */
1077 #define wxMENU_TEAROFF      0x0001
1078
1079 /*
1080  * Apply to all panel items
1081  */
1082 #define wxCOLOURED          0x0800
1083 #define wxFIXED_LENGTH      0x0400
1084
1085 /*
1086  * Styles for wxListBox
1087  */
1088 #define wxLB_SORT           0x0010
1089 #define wxLB_SINGLE         0x0020
1090 #define wxLB_MULTIPLE       0x0040
1091 #define wxLB_EXTENDED       0x0080
1092 // wxLB_OWNERDRAW is Windows-only
1093 #define wxLB_OWNERDRAW      0x0100
1094 #define wxLB_NEEDED_SB      0x0200
1095 #define wxLB_ALWAYS_SB      0x0400
1096 #define wxLB_HSCROLL        wxHSCROLL
1097 // always show an entire number of rows
1098 #define wxLB_INT_HEIGHT     0x0800
1099
1100 // deprecated synonyms
1101 #define wxPROCESS_ENTER     0x0400  // wxTE_PROCESS_ENTER
1102 #define wxPASSWORD          0x0800  // wxTE_PASSWORD
1103
1104 /*
1105  * wxComboBox style flags
1106  */
1107 #define wxCB_SIMPLE         0x0004
1108 #define wxCB_SORT           0x0008
1109 #define wxCB_READONLY       0x0010
1110 #define wxCB_DROPDOWN       0x0020
1111
1112 /*
1113  * wxRadioBox style flags
1114  */
1115 // should we number the items from left to right or from top to bottom in a 2d
1116 // radiobox?
1117 #define wxRA_LEFTTORIGHT    0x0001
1118 #define wxRA_TOPTOBOTTOM    0x0002
1119
1120 // New, more intuitive names to specify majorDim argument
1121 #define wxRA_SPECIFY_COLS   wxHORIZONTAL
1122 #define wxRA_SPECIFY_ROWS   wxVERTICAL
1123
1124 // Old names for compatibility
1125 #define wxRA_HORIZONTAL     wxHORIZONTAL
1126 #define wxRA_VERTICAL       wxVERTICAL
1127
1128 /*
1129  * wxRadioButton style flag
1130  */
1131 #define wxRB_GROUP          0x0004
1132 #define wxRB_SINGLE         0x0008
1133
1134 /*
1135  * wxGauge flags
1136  */
1137 #define wxGA_HORIZONTAL      wxHORIZONTAL
1138 #define wxGA_VERTICAL        wxVERTICAL
1139 #define wxGA_PROGRESSBAR     0x0010
1140 // Windows only
1141 #define wxGA_SMOOTH          0x0020
1142
1143 /*
1144  * wxSlider flags
1145  */
1146 #define wxSL_HORIZONTAL      wxHORIZONTAL // 4
1147 #define wxSL_VERTICAL        wxVERTICAL   // 8
1148 // The next one is obsolete - use scroll events instead
1149 #define wxSL_NOTIFY_DRAG     0x0000
1150 #define wxSL_TICKS           0x0010
1151 #define wxSL_AUTOTICKS       wxSL_TICKS // we don't support manual ticks
1152 #define wxSL_LABELS          0x0020
1153 #define wxSL_LEFT            0x0040
1154 #define wxSL_TOP             0x0080
1155 #define wxSL_RIGHT           0x0100
1156 #define wxSL_BOTTOM          0x0200
1157 #define wxSL_BOTH            0x0400
1158 #define wxSL_SELRANGE        0x0800
1159
1160 /*
1161  * wxScrollBar flags
1162  */
1163 #define wxSB_HORIZONTAL      wxHORIZONTAL
1164 #define wxSB_VERTICAL        wxVERTICAL
1165
1166 /*
1167  * wxSpinButton flags.
1168  * Note that a wxSpinCtrl is sometimes defined as
1169  * a wxTextCtrl, and so the flags must be different
1170  * from wxTextCtrl's.
1171  */
1172 #define wxSP_HORIZONTAL       wxHORIZONTAL // 4
1173 #define wxSP_VERTICAL         wxVERTICAL   // 8
1174 #define wxSP_ARROW_KEYS       0x1000
1175 #define wxSP_WRAP             0x2000
1176
1177 /*
1178  * wxSplitterWindow flags
1179  */
1180 #define wxSP_NOBORDER         0x0000
1181 #define wxSP_NOSASH           0x0010
1182 #define wxSP_BORDER           0x0020
1183 #define wxSP_PERMIT_UNSPLIT   0x0040
1184 #define wxSP_LIVE_UPDATE      0x0080
1185 #define wxSP_3DSASH           0x0100
1186 #define wxSP_3DBORDER         0x0200
1187 #define wxSP_FULLSASH         0x0400
1188 #define wxSP_3D               (wxSP_3DBORDER | wxSP_3DSASH)
1189 #define wxSP_SASH_AQUA        0x0800
1190
1191 /*
1192  * wxNotebook flags
1193  */
1194 #define wxNB_FIXEDWIDTH       0x0010
1195 #define wxNB_TOP              0x0000    // default
1196 #define wxNB_LEFT             0x0020
1197 #define wxNB_RIGHT            0x0040
1198 #define wxNB_BOTTOM           0x0080
1199 #define wxNB_MULTILINE        0x0100
1200
1201 /*
1202  * wxTabCtrl flags
1203  */
1204 #define wxTC_RIGHTJUSTIFY     0x0010
1205 #define wxTC_FIXEDWIDTH       0x0020
1206 #define wxTC_TOP              0x0000    // default
1207 #define wxTC_LEFT             0x0020
1208 #define wxTC_RIGHT            0x0040
1209 #define wxTC_BOTTOM           0x0080
1210 #define wxTC_MULTILINE        wxNB_MULTILINE
1211 #define wxTC_OWNERDRAW        0x0200
1212
1213 // wxToolBar style flags
1214 #define wxTB_HORIZONTAL     wxHORIZONTAL    // == 0x0004
1215 #define wxTB_VERTICAL       wxVERTICAL      // == 0x0008
1216 #define wxTB_3DBUTTONS      0x0010
1217 #define wxTB_FLAT           0x0020          // supported only under Win98+/GTK
1218 #define wxTB_DOCKABLE       0x0040          // use native docking under GTK
1219 #define wxTB_NOICONS        0x0080          // don't show the icons
1220 #define wxTB_TEXT           0x0100          // show the text
1221 #define wxTB_NODIVIDER      0x0200          // don't show the divider (Windows)
1222 #define wxTB_NOALIGN        0x0400          // no automatic alignment (Windows)
1223
1224 /*
1225  * wxStatusBar95 flags
1226  */
1227 #define wxST_SIZEGRIP         0x0010
1228
1229 /*
1230  * wxStaticText flags
1231  */
1232 #define wxST_NO_AUTORESIZE    0x0001
1233
1234 /*
1235  * wxStaticBitmap flags
1236  */
1237 #define wxBI_EXPAND           wxEXPAND
1238
1239 /*
1240  * wxStaticLine flags
1241  */
1242 #define wxLI_HORIZONTAL         wxHORIZONTAL
1243 #define wxLI_VERTICAL           wxVERTICAL
1244
1245 /*
1246  * wxProgressDialog flags
1247  */
1248 #define wxPD_CAN_ABORT          0x0001
1249 #define wxPD_APP_MODAL          0x0002
1250 #define wxPD_AUTO_HIDE          0x0004
1251 #define wxPD_ELAPSED_TIME       0x0008
1252 #define wxPD_ESTIMATED_TIME     0x0010
1253 // wxGA_SMOOTH = 0x0020 may also be used with wxProgressDialog
1254 // NO!!! This is wxDIALOG_MODAL and will cause the progress dialog to
1255 // be modal. No progress will then be made at all.
1256 #define wxPD_REMAINING_TIME     0x0040
1257
1258 /*
1259  * wxDirDialog styles
1260  */
1261
1262 #define wxDD_NEW_DIR_BUTTON     0x0080
1263
1264 /*
1265  * extended dialog specifiers. these values are stored in a different
1266  * flag and thus do not overlap with other style flags. note that these
1267  * values do not correspond to the return values of the dialogs (for
1268  * those values, look at the wxID_XXX defines).
1269  */
1270
1271 // wxCENTRE already defined as  0x00000001
1272 #define wxYES                   0x00000002
1273 #define wxOK                    0x00000004
1274 #define wxNO                    0x00000008
1275 #define wxYES_NO                (wxYES | wxNO)
1276 #define wxCANCEL                0x00000010
1277
1278 #define wxYES_DEFAULT           0x00000000  // has no effect (default)
1279 #define wxNO_DEFAULT            0x00000080
1280
1281 #define wxICON_EXCLAMATION      0x00000100
1282 #define wxICON_HAND             0x00000200
1283 #define wxICON_WARNING          wxICON_EXCLAMATION
1284 #define wxICON_ERROR            wxICON_HAND
1285 #define wxICON_QUESTION         0x00000400
1286 #define wxICON_INFORMATION      0x00000800
1287 #define wxICON_STOP             wxICON_HAND
1288 #define wxICON_ASTERISK         wxICON_INFORMATION
1289 #define wxICON_MASK             (0x00000100|0x00000200|0x00000400|0x00000800)
1290
1291 #define  wxFORWARD              0x00001000
1292 #define  wxBACKWARD             0x00002000
1293 #define  wxRESET                0x00004000
1294 #define  wxHELP                 0x00008000
1295 #define  wxMORE                 0x00010000
1296 #define  wxSETUP                0x00020000
1297
1298 // ----------------------------------------------------------------------------
1299 // standard IDs
1300 // ----------------------------------------------------------------------------
1301
1302 // any id: means that we don't care about the id, whether when installing an
1303 // event handler or when creating a new window
1304 enum
1305 {
1306     wxID_ANY = -1
1307 };
1308
1309 // id for a separator line in the menu (invalid for normal item)
1310 enum
1311 {
1312     wxID_SEPARATOR = -1
1313 };
1314
1315 // Standard menu IDs
1316 enum
1317 {
1318     wxID_LOWEST = 4999,
1319
1320     wxID_OPEN,
1321     wxID_CLOSE,
1322     wxID_NEW,
1323     wxID_SAVE,
1324     wxID_SAVEAS,
1325     wxID_REVERT,
1326     wxID_EXIT,
1327     wxID_UNDO,
1328     wxID_REDO,
1329     wxID_HELP,
1330     wxID_PRINT,
1331     wxID_PRINT_SETUP,
1332     wxID_PREVIEW,
1333     wxID_ABOUT,
1334     wxID_HELP_CONTENTS,
1335     wxID_HELP_COMMANDS,
1336     wxID_HELP_PROCEDURES,
1337     wxID_HELP_CONTEXT,
1338     wxID_CLOSE_ALL,
1339
1340     wxID_CUT = 5030,
1341     wxID_COPY,
1342     wxID_PASTE,
1343     wxID_CLEAR,
1344     wxID_FIND,
1345     wxID_DUPLICATE,
1346     wxID_SELECTALL,
1347
1348     wxID_FILE1 = 5050,
1349     wxID_FILE2,
1350     wxID_FILE3,
1351     wxID_FILE4,
1352     wxID_FILE5,
1353     wxID_FILE6,
1354     wxID_FILE7,
1355     wxID_FILE8,
1356     wxID_FILE9,
1357
1358     // Standard button IDs
1359     wxID_OK = 5100,
1360     wxID_CANCEL,
1361     wxID_APPLY,
1362     wxID_YES,
1363     wxID_NO,
1364     wxID_STATIC,
1365     wxID_FORWARD,
1366     wxID_BACKWARD,
1367     wxID_DEFAULT,
1368     wxID_MORE,
1369     wxID_SETUP,
1370     wxID_RESET,
1371     wxID_CONTEXT_HELP,
1372     wxID_YESTOALL,
1373     wxID_NOTOALL,
1374     wxID_ABORT,
1375     wxID_RETRY,
1376     wxID_IGNORE,
1377
1378     // System menu IDs (used by wxUniv):
1379     wxID_SYSTEM_MENU = 5200,
1380     wxID_CLOSE_FRAME,
1381     wxID_MOVE_FRAME,
1382     wxID_RESIZE_FRAME,
1383     wxID_MAXIMIZE_FRAME,
1384     wxID_ICONIZE_FRAME,
1385     wxID_RESTORE_FRAME,
1386
1387     // IDs used by generic file dialog (13 consecutive starting from this value)
1388     wxID_FILEDLGG = 5900,
1389
1390     wxID_HIGHEST = 5999
1391 };
1392
1393 // ----------------------------------------------------------------------------
1394 // other constants
1395 // ----------------------------------------------------------------------------
1396
1397 // menu and toolbar item kinds
1398 enum wxItemKind
1399 {
1400     wxITEM_SEPARATOR = -1,
1401     wxITEM_NORMAL,
1402     wxITEM_CHECK,
1403     wxITEM_RADIO,
1404     wxITEM_MAX
1405 };
1406
1407 // hit test results
1408 enum wxHitTest
1409 {
1410     wxHT_NOWHERE,
1411
1412     // scrollbar
1413     wxHT_SCROLLBAR_FIRST = wxHT_NOWHERE,
1414     wxHT_SCROLLBAR_ARROW_LINE_1,    // left or upper arrow to scroll by line
1415     wxHT_SCROLLBAR_ARROW_LINE_2,    // right or down
1416     wxHT_SCROLLBAR_ARROW_PAGE_1,    // left or upper arrow to scroll by page
1417     wxHT_SCROLLBAR_ARROW_PAGE_2,    // right or down
1418     wxHT_SCROLLBAR_THUMB,           // on the thumb
1419     wxHT_SCROLLBAR_BAR_1,           // bar to the left/above the thumb
1420     wxHT_SCROLLBAR_BAR_2,           // bar to the right/below the thumb
1421     wxHT_SCROLLBAR_LAST,
1422
1423     // window
1424     wxHT_WINDOW_OUTSIDE,            // not in this window at all
1425     wxHT_WINDOW_INSIDE,             // in the client area
1426     wxHT_WINDOW_VERT_SCROLLBAR,     // on the vertical scrollbar
1427     wxHT_WINDOW_HORZ_SCROLLBAR,     // on the horizontal scrollbar
1428     wxHT_WINDOW_CORNER,             // on the corner between 2 scrollbars
1429
1430     wxHT_MAX
1431 };
1432
1433 // ----------------------------------------------------------------------------
1434 // Possible SetSize flags
1435 // ----------------------------------------------------------------------------
1436
1437 // Use internally-calculated width if -1
1438 #define wxSIZE_AUTO_WIDTH       0x0001
1439 // Use internally-calculated height if -1
1440 #define wxSIZE_AUTO_HEIGHT      0x0002
1441 // Use internally-calculated width and height if each is -1
1442 #define wxSIZE_AUTO             (wxSIZE_AUTO_WIDTH|wxSIZE_AUTO_HEIGHT)
1443 // Ignore missing (-1) dimensions (use existing).
1444 // For readability only: test for wxSIZE_AUTO_WIDTH/HEIGHT in code.
1445 #define wxSIZE_USE_EXISTING     0x0000
1446 // Allow -1 as a valid position
1447 #define wxSIZE_ALLOW_MINUS_ONE  0x0004
1448 // Don't do parent client adjustments (for implementation only)
1449 #define wxSIZE_NO_ADJUSTMENTS   0x0008
1450
1451 // ----------------------------------------------------------------------------
1452 // GDI descriptions
1453 // ----------------------------------------------------------------------------
1454
1455 enum
1456 {
1457     // Text font families
1458     wxDEFAULT    = 70,
1459     wxDECORATIVE,
1460     wxROMAN,
1461     wxSCRIPT,
1462     wxSWISS,
1463     wxMODERN,
1464     wxTELETYPE,  /* @@@@ */
1465
1466     // Proportional or Fixed width fonts (not yet used)
1467     wxVARIABLE   = 80,
1468     wxFIXED,
1469
1470     wxNORMAL     = 90,
1471     wxLIGHT,
1472     wxBOLD,
1473     // Also wxNORMAL for normal (non-italic text)
1474     wxITALIC,
1475     wxSLANT,
1476
1477     // Pen styles
1478     wxSOLID      =   100,
1479     wxDOT,
1480     wxLONG_DASH,
1481     wxSHORT_DASH,
1482     wxDOT_DASH,
1483     wxUSER_DASH,
1484
1485     wxTRANSPARENT,
1486
1487     // Brush & Pen Stippling. Note that a stippled pen cannot be dashed!!
1488     // Note also that stippling a Pen IS meaningfull, because a Line is
1489     wxSTIPPLE_MASK_OPAQUE, //mask is used for blitting monochrome using text fore and back ground colors
1490     wxSTIPPLE_MASK,        //mask is used for masking areas in the stipple bitmap (TO DO)
1491     // drawn with a Pen, and without any Brush -- and it can be stippled.
1492     wxSTIPPLE =          110,
1493     wxBDIAGONAL_HATCH,
1494     wxCROSSDIAG_HATCH,
1495     wxFDIAGONAL_HATCH,
1496     wxCROSS_HATCH,
1497     wxHORIZONTAL_HATCH,
1498     wxVERTICAL_HATCH,
1499
1500     wxJOIN_BEVEL =     120,
1501     wxJOIN_MITER,
1502     wxJOIN_ROUND,
1503
1504     wxCAP_ROUND =      130,
1505     wxCAP_PROJECTING,
1506     wxCAP_BUTT
1507 };
1508
1509 // VZ: why doesn't it start with "wx"? FIXME
1510 #define IS_HATCH(s)    ((s)>=wxBDIAGONAL_HATCH && (s)<=wxVERTICAL_HATCH)
1511
1512 // Logical ops
1513 typedef enum
1514 {
1515   wxCLEAR,        wxROP_BLACK = wxCLEAR,             wxBLIT_BLACKNESS = wxCLEAR,        // 0
1516   wxXOR,          wxROP_XORPEN = wxXOR,              wxBLIT_SRCINVERT = wxXOR,          // src XOR dst
1517   wxINVERT,       wxROP_NOT = wxINVERT,              wxBLIT_DSTINVERT = wxINVERT,       // NOT dst
1518   wxOR_REVERSE,   wxROP_MERGEPENNOT = wxOR_REVERSE,  wxBLIT_00DD0228 = wxOR_REVERSE,    // src OR (NOT dst)
1519   wxAND_REVERSE,  wxROP_MASKPENNOT = wxAND_REVERSE,  wxBLIT_SRCERASE = wxAND_REVERSE,   // src AND (NOT dst)
1520   wxCOPY,         wxROP_COPYPEN = wxCOPY,            wxBLIT_SRCCOPY = wxCOPY,           // src
1521   wxAND,          wxROP_MASKPEN = wxAND,             wxBLIT_SRCAND = wxAND,             // src AND dst
1522   wxAND_INVERT,   wxROP_MASKNOTPEN = wxAND_INVERT,   wxBLIT_00220326 = wxAND_INVERT,    // (NOT src) AND dst
1523   wxNO_OP,        wxROP_NOP = wxNO_OP,               wxBLIT_00AA0029 = wxNO_OP,         // dst
1524   wxNOR,          wxROP_NOTMERGEPEN = wxNOR,         wxBLIT_NOTSRCERASE = wxNOR,        // (NOT src) AND (NOT dst)
1525   wxEQUIV,        wxROP_NOTXORPEN = wxEQUIV,         wxBLIT_00990066 = wxEQUIV,         // (NOT src) XOR dst
1526   wxSRC_INVERT,   wxROP_NOTCOPYPEN = wxSRC_INVERT,   wxBLIT_NOTSCRCOPY = wxSRC_INVERT,  // (NOT src)
1527   wxOR_INVERT,    wxROP_MERGENOTPEN = wxOR_INVERT,   wxBLIT_MERGEPAINT = wxOR_INVERT,   // (NOT src) OR dst
1528   wxNAND,         wxROP_NOTMASKPEN = wxNAND,         wxBLIT_007700E6 = wxNAND,          // (NOT src) OR (NOT dst)
1529   wxOR,           wxROP_MERGEPEN = wxOR,             wxBLIT_SRCPAINT = wxOR,            // src OR dst
1530   wxSET,          wxROP_WHITE = wxSET,               wxBLIT_WHITENESS = wxSET           // 1
1531 } form_ops_t;
1532
1533 // Flood styles
1534 enum
1535 {
1536     wxFLOOD_SURFACE = 1,
1537     wxFLOOD_BORDER
1538 };
1539
1540 // Polygon filling mode
1541 enum
1542 {
1543     wxODDEVEN_RULE = 1,
1544     wxWINDING_RULE
1545 };
1546
1547 // ToolPanel in wxFrame (VZ: unused?)
1548 enum
1549 {
1550     wxTOOL_TOP = 1,
1551     wxTOOL_BOTTOM,
1552     wxTOOL_LEFT,
1553     wxTOOL_RIGHT
1554 };
1555
1556 // the values of the format constants should be the same as correspondign
1557 // CF_XXX constants in Windows API
1558 enum wxDataFormatId
1559 {
1560     wxDF_INVALID =          0,
1561     wxDF_TEXT =             1,  /* CF_TEXT */
1562     wxDF_BITMAP =           2,  /* CF_BITMAP */
1563     wxDF_METAFILE =         3,  /* CF_METAFILEPICT */
1564     wxDF_SYLK =             4,
1565     wxDF_DIF =              5,
1566     wxDF_TIFF =             6,
1567     wxDF_OEMTEXT =          7,  /* CF_OEMTEXT */
1568     wxDF_DIB =              8,  /* CF_DIB */
1569     wxDF_PALETTE =          9,
1570     wxDF_PENDATA =          10,
1571     wxDF_RIFF =             11,
1572     wxDF_WAVE =             12,
1573     wxDF_UNICODETEXT =      13,
1574     wxDF_ENHMETAFILE =      14,
1575     wxDF_FILENAME =         15, /* CF_HDROP */
1576     wxDF_LOCALE =           16,
1577     wxDF_PRIVATE =          20,
1578     wxDF_HTML =             30, /* Note: does not correspond to CF_ constant */
1579     wxDF_MAX
1580 };
1581
1582 // Virtual keycodes
1583 enum wxKeyCode
1584 {
1585     WXK_BACK    =    8,
1586     WXK_TAB     =    9,
1587     WXK_RETURN  =    13,
1588     WXK_ESCAPE  =    27,
1589     WXK_SPACE   =    32,
1590     WXK_DELETE  =    127,
1591
1592     WXK_START   = 300,
1593     WXK_LBUTTON,
1594     WXK_RBUTTON,
1595     WXK_CANCEL,
1596     WXK_MBUTTON,
1597     WXK_CLEAR,
1598     WXK_SHIFT,
1599     WXK_ALT,
1600     WXK_CONTROL,
1601     WXK_MENU,
1602     WXK_PAUSE,
1603     WXK_CAPITAL,
1604     WXK_PRIOR,  // Page up
1605     WXK_NEXT,   // Page down
1606     WXK_END,
1607     WXK_HOME,
1608     WXK_LEFT,
1609     WXK_UP,
1610     WXK_RIGHT,
1611     WXK_DOWN,
1612     WXK_SELECT,
1613     WXK_PRINT,
1614     WXK_EXECUTE,
1615     WXK_SNAPSHOT,
1616     WXK_INSERT,
1617     WXK_HELP,
1618     WXK_NUMPAD0,
1619     WXK_NUMPAD1,
1620     WXK_NUMPAD2,
1621     WXK_NUMPAD3,
1622     WXK_NUMPAD4,
1623     WXK_NUMPAD5,
1624     WXK_NUMPAD6,
1625     WXK_NUMPAD7,
1626     WXK_NUMPAD8,
1627     WXK_NUMPAD9,
1628     WXK_MULTIPLY,
1629     WXK_ADD,
1630     WXK_SEPARATOR,
1631     WXK_SUBTRACT,
1632     WXK_DECIMAL,
1633     WXK_DIVIDE,
1634     WXK_F1,
1635     WXK_F2,
1636     WXK_F3,
1637     WXK_F4,
1638     WXK_F5,
1639     WXK_F6,
1640     WXK_F7,
1641     WXK_F8,
1642     WXK_F9,
1643     WXK_F10,
1644     WXK_F11,
1645     WXK_F12,
1646     WXK_F13,
1647     WXK_F14,
1648     WXK_F15,
1649     WXK_F16,
1650     WXK_F17,
1651     WXK_F18,
1652     WXK_F19,
1653     WXK_F20,
1654     WXK_F21,
1655     WXK_F22,
1656     WXK_F23,
1657     WXK_F24,
1658     WXK_NUMLOCK,
1659     WXK_SCROLL,
1660     WXK_PAGEUP,
1661     WXK_PAGEDOWN,
1662
1663     WXK_NUMPAD_SPACE,
1664     WXK_NUMPAD_TAB,
1665     WXK_NUMPAD_ENTER,
1666     WXK_NUMPAD_F1,
1667     WXK_NUMPAD_F2,
1668     WXK_NUMPAD_F3,
1669     WXK_NUMPAD_F4,
1670     WXK_NUMPAD_HOME,
1671     WXK_NUMPAD_LEFT,
1672     WXK_NUMPAD_UP,
1673     WXK_NUMPAD_RIGHT,
1674     WXK_NUMPAD_DOWN,
1675     WXK_NUMPAD_PRIOR,
1676     WXK_NUMPAD_PAGEUP,
1677     WXK_NUMPAD_NEXT,
1678     WXK_NUMPAD_PAGEDOWN,
1679     WXK_NUMPAD_END,
1680     WXK_NUMPAD_BEGIN,
1681     WXK_NUMPAD_INSERT,
1682     WXK_NUMPAD_DELETE,
1683     WXK_NUMPAD_EQUAL,
1684     WXK_NUMPAD_MULTIPLY,
1685     WXK_NUMPAD_ADD,
1686     WXK_NUMPAD_SEPARATOR,
1687     WXK_NUMPAD_SUBTRACT,
1688     WXK_NUMPAD_DECIMAL,
1689     WXK_NUMPAD_DIVIDE,
1690
1691     WXK_WINDOWS_LEFT,
1692     WXK_WINDOWS_RIGHT,
1693     WXK_WINDOWS_MENU
1694 };
1695
1696 // Mapping modes (same values as used by Windows, don't change)
1697 enum
1698 {
1699     wxMM_TEXT = 1,
1700     wxMM_LOMETRIC,
1701     wxMM_HIMETRIC,
1702     wxMM_LOENGLISH,
1703     wxMM_HIENGLISH,
1704     wxMM_TWIPS,
1705     wxMM_ISOTROPIC,
1706     wxMM_ANISOTROPIC,
1707     wxMM_POINTS,
1708     wxMM_METRIC
1709 };
1710
1711 /* Shortcut for easier dialog-unit-to-pixel conversion */
1712 #define wxDLG_UNIT(parent, pt) parent->ConvertDialogToPixels(pt)
1713
1714 /* Paper types */
1715 typedef enum
1716 {
1717     wxPAPER_NONE,               // Use specific dimensions
1718     wxPAPER_LETTER,             // Letter, 8 1/2 by 11 inches
1719     wxPAPER_LEGAL,              // Legal, 8 1/2 by 14 inches
1720     wxPAPER_A4,                 // A4 Sheet, 210 by 297 millimeters
1721     wxPAPER_CSHEET,             // C Sheet, 17 by 22 inches
1722     wxPAPER_DSHEET,             // D Sheet, 22 by 34 inches
1723     wxPAPER_ESHEET,             // E Sheet, 34 by 44 inches
1724     wxPAPER_LETTERSMALL,        // Letter Small, 8 1/2 by 11 inches
1725     wxPAPER_TABLOID,            // Tabloid, 11 by 17 inches
1726     wxPAPER_LEDGER,             // Ledger, 17 by 11 inches
1727     wxPAPER_STATEMENT,          // Statement, 5 1/2 by 8 1/2 inches
1728     wxPAPER_EXECUTIVE,          // Executive, 7 1/4 by 10 1/2 inches
1729     wxPAPER_A3,                 // A3 sheet, 297 by 420 millimeters
1730     wxPAPER_A4SMALL,            // A4 small sheet, 210 by 297 millimeters
1731     wxPAPER_A5,                 // A5 sheet, 148 by 210 millimeters
1732     wxPAPER_B4,                 // B4 sheet, 250 by 354 millimeters
1733     wxPAPER_B5,                 // B5 sheet, 182-by-257-millimeter paper
1734     wxPAPER_FOLIO,              // Folio, 8-1/2-by-13-inch paper
1735     wxPAPER_QUARTO,             // Quarto, 215-by-275-millimeter paper
1736     wxPAPER_10X14,              // 10-by-14-inch sheet
1737     wxPAPER_11X17,              // 11-by-17-inch sheet
1738     wxPAPER_NOTE,               // Note, 8 1/2 by 11 inches
1739     wxPAPER_ENV_9,              // #9 Envelope, 3 7/8 by 8 7/8 inches
1740     wxPAPER_ENV_10,             // #10 Envelope, 4 1/8 by 9 1/2 inches
1741     wxPAPER_ENV_11,             // #11 Envelope, 4 1/2 by 10 3/8 inches
1742     wxPAPER_ENV_12,             // #12 Envelope, 4 3/4 by 11 inches
1743     wxPAPER_ENV_14,             // #14 Envelope, 5 by 11 1/2 inches
1744     wxPAPER_ENV_DL,             // DL Envelope, 110 by 220 millimeters
1745     wxPAPER_ENV_C5,             // C5 Envelope, 162 by 229 millimeters
1746     wxPAPER_ENV_C3,             // C3 Envelope, 324 by 458 millimeters
1747     wxPAPER_ENV_C4,             // C4 Envelope, 229 by 324 millimeters
1748     wxPAPER_ENV_C6,             // C6 Envelope, 114 by 162 millimeters
1749     wxPAPER_ENV_C65,            // C65 Envelope, 114 by 229 millimeters
1750     wxPAPER_ENV_B4,             // B4 Envelope, 250 by 353 millimeters
1751     wxPAPER_ENV_B5,             // B5 Envelope, 176 by 250 millimeters
1752     wxPAPER_ENV_B6,             // B6 Envelope, 176 by 125 millimeters
1753     wxPAPER_ENV_ITALY,          // Italy Envelope, 110 by 230 millimeters
1754     wxPAPER_ENV_MONARCH,        // Monarch Envelope, 3 7/8 by 7 1/2 inches
1755     wxPAPER_ENV_PERSONAL,       // 6 3/4 Envelope, 3 5/8 by 6 1/2 inches
1756     wxPAPER_FANFOLD_US,         // US Std Fanfold, 14 7/8 by 11 inches
1757     wxPAPER_FANFOLD_STD_GERMAN, // German Std Fanfold, 8 1/2 by 12 inches
1758     wxPAPER_FANFOLD_LGL_GERMAN, // German Legal Fanfold, 8 1/2 by 13 inches
1759
1760     wxPAPER_ISO_B4,             // B4 (ISO) 250 x 353 mm
1761     wxPAPER_JAPANESE_POSTCARD,  // Japanese Postcard 100 x 148 mm
1762     wxPAPER_9X11,               // 9 x 11 in
1763     wxPAPER_10X11,              // 10 x 11 in
1764     wxPAPER_15X11,              // 15 x 11 in
1765     wxPAPER_ENV_INVITE,         // Envelope Invite 220 x 220 mm
1766     wxPAPER_LETTER_EXTRA,       // Letter Extra 9 \275 x 12 in
1767     wxPAPER_LEGAL_EXTRA,        // Legal Extra 9 \275 x 15 in
1768     wxPAPER_TABLOID_EXTRA,      // Tabloid Extra 11.69 x 18 in
1769     wxPAPER_A4_EXTRA,           // A4 Extra 9.27 x 12.69 in
1770     wxPAPER_LETTER_TRANSVERSE,  // Letter Transverse 8 \275 x 11 in
1771     wxPAPER_A4_TRANSVERSE,      // A4 Transverse 210 x 297 mm
1772     wxPAPER_LETTER_EXTRA_TRANSVERSE, // Letter Extra Transverse 9\275 x 12 in
1773     wxPAPER_A_PLUS,             // SuperA/SuperA/A4 227 x 356 mm
1774     wxPAPER_B_PLUS,             // SuperB/SuperB/A3 305 x 487 mm
1775     wxPAPER_LETTER_PLUS,        // Letter Plus 8.5 x 12.69 in
1776     wxPAPER_A4_PLUS,            // A4 Plus 210 x 330 mm
1777     wxPAPER_A5_TRANSVERSE,      // A5 Transverse 148 x 210 mm
1778     wxPAPER_B5_TRANSVERSE,      // B5 (JIS) Transverse 182 x 257 mm
1779     wxPAPER_A3_EXTRA,           // A3 Extra 322 x 445 mm
1780     wxPAPER_A5_EXTRA,           // A5 Extra 174 x 235 mm
1781     wxPAPER_B5_EXTRA,           // B5 (ISO) Extra 201 x 276 mm
1782     wxPAPER_A2,                 // A2 420 x 594 mm
1783     wxPAPER_A3_TRANSVERSE,      // A3 Transverse 297 x 420 mm
1784     wxPAPER_A3_EXTRA_TRANSVERSE // A3 Extra Transverse 322 x 445 mm
1785
1786 } wxPaperSize;
1787
1788 /* Printing orientation */
1789 #ifndef wxPORTRAIT
1790 #define wxPORTRAIT      1
1791 #define wxLANDSCAPE     2
1792 #endif
1793
1794 /* Duplex printing modes
1795  */
1796
1797 enum wxDuplexMode
1798 {
1799     wxDUPLEX_SIMPLEX, // Non-duplex
1800     wxDUPLEX_HORIZONTAL,
1801     wxDUPLEX_VERTICAL
1802 };
1803
1804 /* Print quality.
1805  */
1806
1807 #define wxPRINT_QUALITY_HIGH    -1
1808 #define wxPRINT_QUALITY_MEDIUM  -2
1809 #define wxPRINT_QUALITY_LOW     -3
1810 #define wxPRINT_QUALITY_DRAFT   -4
1811
1812 typedef int wxPrintQuality;
1813
1814 /* Print mode (currently PostScript only)
1815  */
1816
1817 enum wxPrintMode
1818 {
1819     wxPRINT_MODE_NONE =    0,
1820     wxPRINT_MODE_PREVIEW = 1,   // Preview in external application
1821     wxPRINT_MODE_FILE =    2,   // Print to file
1822     wxPRINT_MODE_PRINTER = 3    // Send to printer
1823 };
1824
1825 // ----------------------------------------------------------------------------
1826 // miscellaneous
1827 // ----------------------------------------------------------------------------
1828
1829 // define this macro if font handling is done using the X font names
1830 #if (defined(__WXGTK__) && !defined(__WXGTK20__)) || defined(__X__)
1831     #define _WX_X_FONTLIKE
1832 #endif
1833
1834 // macro to specify "All Files" on different platforms
1835 #if defined(__WXMSW__) || defined(__WXPM__)
1836 #   define wxALL_FILES_PATTERN   wxT("*.*")
1837 #   define wxALL_FILES           gettext_noop("All files (*.*)|*.*")
1838 #else
1839 #   define wxALL_FILES_PATTERN   wxT("*")
1840 #   define wxALL_FILES           gettext_noop("All files (*)|*")
1841 #endif
1842
1843 // ---------------------------------------------------------------------------
1844 // macros that enable wxWindows apps to be compiled in absence of the
1845 // sytem headers, although some platform specific types are used in the
1846 // platform specific (implementation) parts of the headers
1847 // ---------------------------------------------------------------------------
1848
1849 #ifdef __WXMAC__
1850
1851 typedef unsigned char WXCOLORREF[6];
1852 typedef void*       WXHBITMAP;
1853 typedef void*       WXHMETAFILE ;
1854 typedef void*       WXHICON ;
1855 typedef void*       WXHCURSOR ;
1856 typedef void*       WXHRGN ;
1857 typedef void*       WXRECTPTR ;
1858 typedef void*       WXPOINTPTR ;
1859 typedef void*       WXHWND ;
1860 typedef void*       WXEVENTREF ;
1861 typedef void*           WXEVENTHANDLERREF ;
1862 typedef void*       WXEVENTHANDLERCALLREF ;
1863 typedef void*       WXAPPLEEVENTREF ;
1864 typedef void*       WXHDC ;
1865 typedef void*       WXHMENU ;
1866 typedef unsigned int    WXUINT;
1867 typedef unsigned long   WXDWORD;
1868 typedef unsigned short  WXWORD;
1869
1870 typedef void*       WXWidget ;
1871 typedef void*       WXWindow ;
1872 typedef void*       WXDisplay ;
1873 /*
1874 typedef WindowPtr       WXHWND;
1875 typedef Handle          WXHANDLE;
1876 typedef CIconHandle     WXHICON;
1877 //typedef unsigned long   WXHFONT;
1878 typedef MenuHandle      WXHMENU;
1879 //typedef unsigned long   WXHPEN;
1880 //typedef unsigned long   WXHBRUSH;
1881 //typedef unsigned long   WXHPALETTE;
1882 typedef CursHandle      WXHCURSOR;
1883 typedef RgnHandle       WXHRGN;
1884 //typedef unsigned long   WXHACCEL;
1885 //typedef unsigned long   WXHINSTANCE;
1886 //typedef unsigned long   WXHIMAGELIST;
1887 //typedef unsigned long   WXHGLOBAL;
1888 typedef GrafPtr         WXHDC;
1889 //typedef unsigned int    WXWPARAM;
1890 //typedef long            WXLPARAM;
1891 //typedef void *          WXRGNDATA;
1892 //typedef void *          WXMSG;
1893 //typedef unsigned long   WXHCONV;
1894 //typedef unsigned long   WXHKEY;
1895 //typedef void *          WXDRAWITEMSTRUCT;
1896 //typedef void *          WXMEASUREITEMSTRUCT;
1897 //typedef void *          WXLPCREATESTRUCT;
1898 typedef int (*WXFARPROC)();
1899
1900 typedef WindowPtr       WXWindow;
1901 typedef ControlHandle   WXWidget;
1902 */
1903 #endif
1904
1905 #ifdef __WXCOCOA__
1906
1907 // NOTE: typedef struct objc_object *id;
1908 // IOW, we're declaring these using the id type without using that name,
1909 // since "id" is used extensively not only within wxWindows itself, but
1910 // also in wxWindows application code.  The following works fine when
1911 // compiling C++ code, and works without typesafety for Obj-C++ code
1912 #define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
1913 typedef struct objc_object *WX_##klass
1914
1915 DECLARE_WXCOCOA_OBJC_CLASS(NSApplication);
1916 DECLARE_WXCOCOA_OBJC_CLASS(NSBox);
1917 DECLARE_WXCOCOA_OBJC_CLASS(NSButton);
1918 DECLARE_WXCOCOA_OBJC_CLASS(NSControl);
1919 DECLARE_WXCOCOA_OBJC_CLASS(NSEvent);
1920 DECLARE_WXCOCOA_OBJC_CLASS(NSLayoutManager);
1921 DECLARE_WXCOCOA_OBJC_CLASS(NSMenu);
1922 DECLARE_WXCOCOA_OBJC_CLASS(NSMenuItem);
1923 DECLARE_WXCOCOA_OBJC_CLASS(NSPanel);
1924 DECLARE_WXCOCOA_OBJC_CLASS(NSTableView);
1925 DECLARE_WXCOCOA_OBJC_CLASS(NSTextContainer);
1926 DECLARE_WXCOCOA_OBJC_CLASS(NSTextField);
1927 DECLARE_WXCOCOA_OBJC_CLASS(NSTextStorage);
1928 DECLARE_WXCOCOA_OBJC_CLASS(NSWindow);
1929 DECLARE_WXCOCOA_OBJC_CLASS(NSView);
1930 typedef WX_NSView WXWidget; // wxWindows BASE definition
1931 #endif // __WXCOCOA__
1932
1933 #if defined(__WXMSW__) || defined(__WXPM__)
1934
1935 // the keywords needed for WinMain() declaration
1936 #ifdef __WIN16__
1937 #  ifdef __VISUALC__
1938 #    define WXFAR __far
1939 #  else
1940 #    define WXFAR _far
1941 #  endif
1942 #else  // Win32
1943 #  ifndef WXFAR
1944 #    define WXFAR
1945 #  endif
1946 #endif // Win16/32
1947
1948 // Stand-ins for Windows types or OS/2, to avoid #including all of windows.h or os2.h
1949 typedef unsigned long   WXHWND;
1950 typedef unsigned long   WXHANDLE;
1951 typedef unsigned long   WXHICON;
1952 typedef unsigned long   WXHFONT;
1953 typedef unsigned long   WXHMENU;
1954 typedef unsigned long   WXHPEN;
1955 typedef unsigned long   WXHBRUSH;
1956 typedef unsigned long   WXHPALETTE;
1957 typedef unsigned long   WXHCURSOR;
1958 typedef unsigned long   WXHRGN;
1959 typedef unsigned long   WXHACCEL;
1960 typedef void WXFAR  *   WXHINSTANCE;
1961 typedef unsigned long   WXHBITMAP;
1962 typedef unsigned long   WXHIMAGELIST;
1963 typedef unsigned long   WXHGLOBAL;
1964 typedef unsigned long   WXHDC;
1965 typedef unsigned int    WXUINT;
1966 typedef unsigned long   WXDWORD;
1967 typedef unsigned short  WXWORD;
1968
1969 typedef unsigned long   WXCOLORREF;
1970 typedef void *          WXRGNDATA;
1971 typedef void *          WXMSG;
1972 typedef unsigned long   WXHCONV;
1973 typedef unsigned long   WXHKEY;
1974 typedef unsigned long   WXHTREEITEM;
1975
1976 typedef void *          WXDRAWITEMSTRUCT;
1977 typedef void *          WXMEASUREITEMSTRUCT;
1978 typedef void *          WXLPCREATESTRUCT;
1979
1980 typedef WXHWND          WXWidget;
1981
1982 #endif // MSW or OS2
1983
1984
1985 #ifdef __WXMSW__
1986 typedef unsigned int    WXWPARAM;
1987 typedef long            WXLPARAM;
1988
1989 #if !defined(__WIN32__) || defined(__GNUWIN32__) || defined(__WXMICROWIN__)
1990 typedef int             (*WXFARPROC)();
1991 #else
1992 typedef int             (__stdcall *WXFARPROC)();
1993 #endif
1994 #endif // __WXMSW__
1995
1996
1997 #if defined(__WXPM__)
1998 #ifdef __EMX__
1999 /* Need a well-known type for WXFARPROC
2000    below. MPARAM is typedef'ed too late. */
2001 #define WXWPARAM        void *
2002 #define WXLPARAM        void *
2003 #else
2004 #define WXWPARAM        MPARAM
2005 #define WXLPARAM        MPARAM
2006 #endif
2007 #define RECT            RECTL
2008 #define LOGFONT         FATTRS
2009 #define LOWORD          SHORT1FROMMP
2010 #define HIWORD          SHORT2FROMMP
2011
2012 typedef unsigned long   WXMPARAM;
2013 typedef unsigned long   WXMSGID;
2014 typedef void*           WXRESULT;
2015 //typedef int             (*WXFARPROC)();
2016 // some windows handles not defined by PM
2017 typedef unsigned long   HANDLE;
2018 typedef unsigned long   HICON;
2019 typedef unsigned long   HFONT;
2020 typedef unsigned long   HMENU;
2021 typedef unsigned long   HPEN;
2022 typedef unsigned long   HBRUSH;
2023 typedef unsigned long   HPALETTE;
2024 typedef unsigned long   HCURSOR;
2025 typedef unsigned long   HINSTANCE;
2026 typedef unsigned long   HIMAGELIST;
2027 typedef unsigned long   HGLOBAL;
2028 typedef unsigned long   DWORD;
2029 typedef unsigned short  WORD;
2030
2031 // WIN32 graphics types for OS/2 GPI
2032
2033 // RGB under OS2 is more like a PALETTEENTRY struct under Windows so we need a real RGB def
2034 // WARNING: The OS/2 headers typedef BYTE simply as 'char'; if the default is signed, all
2035 // hell will break loose!
2036 //#define OS2RGB(r,g,b) ((DWORD ((BYTE) (b) | ((WORD) (g) << 8)) | (((DWORD)(BYTE)(r)) << 16)))
2037 #define OS2RGB(r,g,b) ((DWORD)((unsigned char)(b) | ((unsigned char)(g) << 8)) | ((unsigned char)(r) << 16))
2038
2039 typedef unsigned long COLORREF;
2040 #define GetBValue(rgb) ((BYTE)((rgb) >> 16))
2041 #define GetGValue(rgb) ((BYTE)(((WORD)(rgb)) >> 8))
2042 #define GetRValue(rgb) ((BYTE)(rgb))
2043 #define PALETTEINDEX(i) ((COLORREF)(0x01000000 | (DWORD)(WORD)(i)))
2044 #define PALETTERGB(r,g,b) (0x02000000 | OS2RGB(r,g,b))
2045 // OS2's RGB/RGB2 is backwards from this
2046 typedef struct tagPALETTEENTRY
2047 {
2048     char bRed;
2049     char bGreen;
2050     char bBlue;
2051     char bFlags;
2052 } PALETTEENTRY;
2053 typedef struct tagLOGPALETTE
2054 {
2055     WORD palVersion;
2056     WORD palNumentries;
2057     WORD PALETTEENTRY[1];
2058 } LOGPALETTE;
2059
2060 #if (defined(__VISAGECPP__) && (__IBMCPP__ < 400)) || defined (__WATCOMC__)
2061     // VA 3.0 for some reason needs base data types when typedefing a proc proto???
2062 typedef void* (_System *WXFARPROC)(unsigned long, unsigned long, void*, void*);
2063 #else
2064 #ifdef __EMX__
2065 #define _System
2066 #endif
2067 typedef WXRESULT (_System *WXFARPROC)(WXHWND, WXMSGID, WXWPARAM, WXLPARAM);
2068 #endif
2069
2070 #endif //__WXPM__
2071
2072
2073 #if defined(__WXMOTIF__) || defined(__WXX11__)
2074 /* Stand-ins for X/Xt/Motif types */
2075 typedef void*           WXWindow;
2076 typedef void*           WXWidget;
2077 typedef void*           WXAppContext;
2078 typedef void*           WXColormap;
2079 typedef void*           WXColor;
2080 typedef void            WXDisplay;
2081 typedef void            WXEvent;
2082 typedef void*           WXCursor;
2083 typedef void*           WXPixmap;
2084 typedef void*           WXFontStructPtr;
2085 typedef void*           WXGC;
2086 typedef void*           WXRegion;
2087 typedef void*           WXFont;
2088 typedef void*           WXImage;
2089 typedef void*           WXFontList;
2090 typedef void*           WXRendition;
2091 typedef void*           WXRenderTable;
2092 typedef void*           WXFontType; /* either a XmFontList or XmRenderTable */
2093 typedef void*           WXString;
2094
2095 typedef unsigned long   Atom;  /* this might fail on a few architectures */
2096
2097 #endif // Motif
2098
2099 #ifdef __WXGTK__
2100
2101 /* Stand-ins for GLIB types */
2102 typedef char           gchar;
2103 typedef signed char    gint8;
2104 typedef int            gint;
2105 typedef unsigned       guint;
2106 typedef unsigned long  gulong;
2107 typedef void*          gpointer;
2108 typedef struct _GSList GSList;
2109
2110 /* Stand-ins for GDK types */
2111 typedef struct _GdkColor        GdkColor;
2112 typedef struct _GdkColormap     GdkColormap;
2113 typedef struct _GdkFont         GdkFont;
2114 typedef struct _GdkGC           GdkGC;
2115 typedef struct _GdkVisual       GdkVisual;
2116
2117 #ifdef __WXGTK20__
2118 typedef struct _GdkAtom        *GdkAtom;
2119 typedef struct _GdkDrawable     GdkWindow;
2120 typedef struct _GdkDrawable     GdkBitmap;
2121 typedef struct _GdkDrawable     GdkPixmap;
2122 #else // GTK+ 1.2
2123 typedef gulong                  GdkAtom;
2124 typedef struct _GdkWindow       GdkWindow;
2125 typedef struct _GdkWindow       GdkBitmap;
2126 typedef struct _GdkWindow       GdkPixmap;
2127 #endif // GTK+ 1.2/2.0
2128
2129 typedef struct _GdkCursor       GdkCursor;
2130 typedef struct _GdkRegion       GdkRegion;
2131 typedef struct _GdkDragContext  GdkDragContext;
2132
2133 #ifdef HAVE_XIM
2134 typedef struct _GdkIC           GdkIC;
2135 typedef struct _GdkICAttr       GdkICAttr;
2136 #endif
2137
2138 /* Stand-ins for GTK types */
2139 typedef struct _GtkWidget         GtkWidget;
2140 typedef struct _GtkStyle          GtkStyle;
2141 typedef struct _GtkAdjustment     GtkAdjustment;
2142 typedef struct _GtkList           GtkList;
2143 typedef struct _GtkToolbar        GtkToolbar;
2144 typedef struct _GtkTooltips       GtkTooltips;
2145 typedef struct _GtkNotebook       GtkNotebook;
2146 typedef struct _GtkNotebookPage   GtkNotebookPage;
2147 typedef struct _GtkAccelGroup     GtkAccelGroup;
2148 typedef struct _GtkItemFactory    GtkItemFactory;
2149 typedef struct _GtkSelectionData  GtkSelectionData;
2150
2151 typedef GtkWidget *WXWidget;
2152
2153 #ifndef __WXGTK20__
2154 #define GTK_OBJECT_GET_CLASS(object) (GTK_OBJECT(object)->klass)
2155 #define GTK_CLASS_TYPE(klass) ((klass)->type)
2156 #endif
2157
2158 #ifdef __WXGTK20__
2159 /* Input method thing */
2160 typedef struct _GtkIMMulticontext    GtkIMMulticontext;
2161 #endif // __WXGTK20__
2162
2163 #endif // __WXGTK__
2164
2165 #if defined(__WXGTK20__) || (defined(__WXX11__) && wxUSE_UNICODE)
2166 #define wxUSE_PANGO 1
2167 #else
2168 #define wxUSE_PANGO 0
2169 #endif
2170
2171 #if wxUSE_PANGO
2172 /* Stand-ins for Pango types */
2173 typedef struct _PangoContext         PangoContext;
2174 typedef struct _PangoLayout          PangoLayout;
2175 typedef struct _PangoFontDescription PangoFontDescription;
2176 #endif
2177
2178 #ifdef __WXMGL__
2179 typedef struct window_t *WXWidget;
2180 #endif // MGL
2181
2182 // This is required because of clashing macros in windows.h, which may be
2183 // included before or after wxWindows classes, and therefore must be
2184 // disabled here before any significant wxWindows headers are included.
2185 #ifdef __WXMSW__
2186 #ifdef GetClassInfo
2187 #undef GetClassInfo
2188 #endif
2189
2190 #ifdef GetClassName
2191 #undef GetClassName
2192 #endif
2193
2194 #ifdef DrawText
2195 #undef DrawText
2196 #endif
2197
2198 #ifdef GetCharWidth
2199 #undef GetCharWidth
2200 #endif
2201
2202 #ifdef StartDoc
2203 #undef StartDoc
2204 #endif
2205
2206 #ifdef FindWindow
2207 #undef FindWindow
2208 #endif
2209
2210 #ifdef FindResource
2211 #undef FindResource
2212 #endif
2213 #endif
2214   // __WXMSW__
2215
2216 // ---------------------------------------------------------------------------
2217 // macro to define a class without copy ctor nor assignment operator
2218 // ---------------------------------------------------------------------------
2219
2220 #define DECLARE_NO_COPY_CLASS(classname)        \
2221     private:                                    \
2222         classname(const classname&);            \
2223         classname& operator=(const classname&);
2224
2225 #endif
2226     // _WX_DEFS_H_