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
1027 // deprecated versions defined for compatibility reasons
1028 #define wxRESIZE_BOX            wxMAXIMIZE_BOX
1029 #define wxTHICK_FRAME           wxRESIZE_BORDER
1030
1031 // obsolete styles, unused any more
1032 #define wxDIALOG_MODAL          0x0020  // free flag value 0x0020
1033 #define wxDIALOG_MODELESS       0x0000
1034
1035 /*
1036  * MDI parent frame style flags
1037  * Can overlap with some of the above.
1038  */
1039
1040 #define wxFRAME_NO_WINDOW_MENU  0x0100
1041
1042 #if WXWIN_COMPATIBILITY
1043 #define wxDEFAULT_FRAME wxDEFAULT_FRAME_STYLE
1044 #endif
1045
1046 #define wxDEFAULT_FRAME_STYLE \
1047   (wxSYSTEM_MENU | wxRESIZE_BORDER | \
1048    wxMINIMIZE_BOX | wxMAXIMIZE_BOX | wxCLOSE_BOX | \
1049    wxCAPTION | wxCLIP_CHILDREN)
1050
1051 #define wxDEFAULT_DIALOG_STYLE  (wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX)
1052
1053 /*
1054  * wxExtDialog style flags
1055  */
1056 #define wxED_CLIENT_MARGIN      0x0004
1057 #define wxED_BUTTONS_BOTTOM     0x0000  // has no effect
1058 #define wxED_BUTTONS_RIGHT      0x0002
1059 #define wxED_STATIC_LINE        0x0001
1060
1061 #if defined(__WXMSW__) || defined(__WXMAC__)
1062 #   define wxEXT_DIALOG_STYLE  (wxDEFAULT_DIALOG_STYLE|wxED_CLIENT_MARGIN)
1063 #else
1064 #   define wxEXT_DIALOG_STYLE  (wxDEFAULT_DIALOG_STYLE|wxED_CLIENT_MARGIN|wxED_STATIC_LINE)
1065 #endif
1066
1067 /*
1068  * wxMenuBar style flags
1069  */
1070 // use native docking
1071 #define wxMB_DOCKABLE       0x0001
1072
1073 /*
1074  * wxMenu style flags
1075  */
1076 #define wxMENU_TEAROFF      0x0001
1077
1078 /*
1079  * Apply to all panel items
1080  */
1081 #define wxCOLOURED          0x0800
1082 #define wxFIXED_LENGTH      0x0400
1083
1084 /*
1085  * Styles for wxListBox
1086  */
1087 #define wxLB_SORT           0x0010
1088 #define wxLB_SINGLE         0x0020
1089 #define wxLB_MULTIPLE       0x0040
1090 #define wxLB_EXTENDED       0x0080
1091 // wxLB_OWNERDRAW is Windows-only
1092 #define wxLB_OWNERDRAW      0x0100
1093 #define wxLB_NEEDED_SB      0x0200
1094 #define wxLB_ALWAYS_SB      0x0400
1095 #define wxLB_HSCROLL        wxHSCROLL
1096 // always show an entire number of rows
1097 #define wxLB_INT_HEIGHT     0x0800
1098
1099 // deprecated synonyms
1100 #define wxPROCESS_ENTER     0x0400  // wxTE_PROCESS_ENTER
1101 #define wxPASSWORD          0x0800  // wxTE_PASSWORD
1102
1103 /*
1104  * wxComboBox style flags
1105  */
1106 #define wxCB_SIMPLE         0x0004
1107 #define wxCB_SORT           0x0008
1108 #define wxCB_READONLY       0x0010
1109 #define wxCB_DROPDOWN       0x0020
1110
1111 /*
1112  * wxRadioBox style flags
1113  */
1114 // should we number the items from left to right or from top to bottom in a 2d
1115 // radiobox?
1116 #define wxRA_LEFTTORIGHT    0x0001
1117 #define wxRA_TOPTOBOTTOM    0x0002
1118
1119 // New, more intuitive names to specify majorDim argument
1120 #define wxRA_SPECIFY_COLS   wxHORIZONTAL
1121 #define wxRA_SPECIFY_ROWS   wxVERTICAL
1122
1123 // Old names for compatibility
1124 #define wxRA_HORIZONTAL     wxHORIZONTAL
1125 #define wxRA_VERTICAL       wxVERTICAL
1126
1127 /*
1128  * wxRadioButton style flag
1129  */
1130 #define wxRB_GROUP          0x0004
1131 #define wxRB_SINGLE         0x0008
1132
1133 /*
1134  * wxGauge flags
1135  */
1136 #define wxGA_HORIZONTAL      wxHORIZONTAL
1137 #define wxGA_VERTICAL        wxVERTICAL
1138 #define wxGA_PROGRESSBAR     0x0010
1139 // Windows only
1140 #define wxGA_SMOOTH          0x0020
1141
1142 /*
1143  * wxSlider flags
1144  */
1145 #define wxSL_HORIZONTAL      wxHORIZONTAL // 4
1146 #define wxSL_VERTICAL        wxVERTICAL   // 8
1147 // The next one is obsolete - use scroll events instead
1148 #define wxSL_NOTIFY_DRAG     0x0000
1149 #define wxSL_TICKS           0x0010
1150 #define wxSL_AUTOTICKS       wxSL_TICKS // we don't support manual ticks
1151 #define wxSL_LABELS          0x0020
1152 #define wxSL_LEFT            0x0040
1153 #define wxSL_TOP             0x0080
1154 #define wxSL_RIGHT           0x0100
1155 #define wxSL_BOTTOM          0x0200
1156 #define wxSL_BOTH            0x0400
1157 #define wxSL_SELRANGE        0x0800
1158
1159 /*
1160  * wxScrollBar flags
1161  */
1162 #define wxSB_HORIZONTAL      wxHORIZONTAL
1163 #define wxSB_VERTICAL        wxVERTICAL
1164
1165 /*
1166  * wxSpinButton flags.
1167  * Note that a wxSpinCtrl is sometimes defined as
1168  * a wxTextCtrl, and so the flags must be different
1169  * from wxTextCtrl's.
1170  */
1171 #define wxSP_HORIZONTAL       wxHORIZONTAL // 4
1172 #define wxSP_VERTICAL         wxVERTICAL   // 8
1173 #define wxSP_ARROW_KEYS       0x1000
1174 #define wxSP_WRAP             0x2000
1175
1176 /*
1177  * wxSplitterWindow flags
1178  */
1179 #define wxSP_NOBORDER         0x0000
1180 #define wxSP_NOSASH           0x0010
1181 #define wxSP_BORDER           0x0020
1182 #define wxSP_PERMIT_UNSPLIT   0x0040
1183 #define wxSP_LIVE_UPDATE      0x0080
1184 #define wxSP_3DSASH           0x0100
1185 #define wxSP_3DBORDER         0x0200
1186 #define wxSP_FULLSASH         0x0400
1187 #define wxSP_3D               (wxSP_3DBORDER | wxSP_3DSASH)
1188 #define wxSP_SASH_AQUA        0x0800
1189
1190 /*
1191  * wxNotebook flags
1192  */
1193 #define wxNB_FIXEDWIDTH       0x0010
1194 #define wxNB_TOP              0x0000    // default
1195 #define wxNB_LEFT             0x0020
1196 #define wxNB_RIGHT            0x0040
1197 #define wxNB_BOTTOM           0x0080
1198 #define wxNB_MULTILINE        0x0100
1199
1200 /*
1201  * wxTabCtrl flags
1202  */
1203 #define wxTC_RIGHTJUSTIFY     0x0010
1204 #define wxTC_FIXEDWIDTH       0x0020
1205 #define wxTC_TOP              0x0000    // default
1206 #define wxTC_LEFT             0x0020
1207 #define wxTC_RIGHT            0x0040
1208 #define wxTC_BOTTOM           0x0080
1209 #define wxTC_MULTILINE        wxNB_MULTILINE
1210 #define wxTC_OWNERDRAW        0x0200
1211
1212 // wxToolBar style flags
1213 #define wxTB_HORIZONTAL     wxHORIZONTAL    // == 0x0004
1214 #define wxTB_VERTICAL       wxVERTICAL      // == 0x0008
1215 #define wxTB_3DBUTTONS      0x0010
1216 #define wxTB_FLAT           0x0020          // supported only under Win98+/GTK
1217 #define wxTB_DOCKABLE       0x0040          // use native docking under GTK
1218 #define wxTB_NOICONS        0x0080          // don't show the icons
1219 #define wxTB_TEXT           0x0100          // show the text
1220 #define wxTB_NODIVIDER      0x0200          // don't show the divider (Windows)
1221 #define wxTB_NOALIGN        0x0400          // no automatic alignment (Windows)
1222
1223 /*
1224  * wxStatusBar95 flags
1225  */
1226 #define wxST_SIZEGRIP         0x0010
1227
1228 /*
1229  * wxStaticText flags
1230  */
1231 #define wxST_NO_AUTORESIZE    0x0001
1232
1233 /*
1234  * wxStaticBitmap flags
1235  */
1236 #define wxBI_EXPAND           wxEXPAND
1237
1238 /*
1239  * wxStaticLine flags
1240  */
1241 #define wxLI_HORIZONTAL         wxHORIZONTAL
1242 #define wxLI_VERTICAL           wxVERTICAL
1243
1244 /*
1245  * wxProgressDialog flags
1246  */
1247 #define wxPD_CAN_ABORT          0x0001
1248 #define wxPD_APP_MODAL          0x0002
1249 #define wxPD_AUTO_HIDE          0x0004
1250 #define wxPD_ELAPSED_TIME       0x0008
1251 #define wxPD_ESTIMATED_TIME     0x0010
1252 // wxGA_SMOOTH = 0x0020 may also be used with wxProgressDialog
1253 // NO!!! This is wxDIALOG_MODAL and will cause the progress dialog to
1254 // be modal. No progress will then be made at all.
1255 #define wxPD_REMAINING_TIME     0x0040
1256
1257 /*
1258  * wxDirDialog styles
1259  */
1260
1261 #define wxDD_NEW_DIR_BUTTON     0x0080
1262
1263 /*
1264  * extended dialog specifiers. these values are stored in a different
1265  * flag and thus do not overlap with other style flags. note that these
1266  * values do not correspond to the return values of the dialogs (for
1267  * those values, look at the wxID_XXX defines).
1268  */
1269
1270 // wxCENTRE already defined as  0x00000001
1271 #define wxYES                   0x00000002
1272 #define wxOK                    0x00000004
1273 #define wxNO                    0x00000008
1274 #define wxYES_NO                (wxYES | wxNO)
1275 #define wxCANCEL                0x00000010
1276
1277 #define wxYES_DEFAULT           0x00000000  // has no effect (default)
1278 #define wxNO_DEFAULT            0x00000080
1279
1280 #define wxICON_EXCLAMATION      0x00000100
1281 #define wxICON_HAND             0x00000200
1282 #define wxICON_WARNING          wxICON_EXCLAMATION
1283 #define wxICON_ERROR            wxICON_HAND
1284 #define wxICON_QUESTION         0x00000400
1285 #define wxICON_INFORMATION      0x00000800
1286 #define wxICON_STOP             wxICON_HAND
1287 #define wxICON_ASTERISK         wxICON_INFORMATION
1288 #define wxICON_MASK             (0x00000100|0x00000200|0x00000400|0x00000800)
1289
1290 #define  wxFORWARD              0x00001000
1291 #define  wxBACKWARD             0x00002000
1292 #define  wxRESET                0x00004000
1293 #define  wxHELP                 0x00008000
1294 #define  wxMORE                 0x00010000
1295 #define  wxSETUP                0x00020000
1296
1297 // ----------------------------------------------------------------------------
1298 // standard IDs
1299 // ----------------------------------------------------------------------------
1300
1301 // any id: means that we don't care about the id, whether when installing an
1302 // event handler or when creating a new window
1303 enum
1304 {
1305     wxID_ANY = -1
1306 };
1307
1308 // id for a separator line in the menu (invalid for normal item)
1309 enum
1310 {
1311     wxID_SEPARATOR = -1
1312 };
1313
1314 // Standard menu IDs
1315 enum
1316 {
1317     wxID_LOWEST = 4999,
1318
1319     wxID_OPEN,
1320     wxID_CLOSE,
1321     wxID_NEW,
1322     wxID_SAVE,
1323     wxID_SAVEAS,
1324     wxID_REVERT,
1325     wxID_EXIT,
1326     wxID_UNDO,
1327     wxID_REDO,
1328     wxID_HELP,
1329     wxID_PRINT,
1330     wxID_PRINT_SETUP,
1331     wxID_PREVIEW,
1332     wxID_ABOUT,
1333     wxID_HELP_CONTENTS,
1334     wxID_HELP_COMMANDS,
1335     wxID_HELP_PROCEDURES,
1336     wxID_HELP_CONTEXT,
1337     wxID_CLOSE_ALL,
1338
1339     wxID_CUT = 5030,
1340     wxID_COPY,
1341     wxID_PASTE,
1342     wxID_CLEAR,
1343     wxID_FIND,
1344     wxID_DUPLICATE,
1345     wxID_SELECTALL,
1346
1347     wxID_FILE1 = 5050,
1348     wxID_FILE2,
1349     wxID_FILE3,
1350     wxID_FILE4,
1351     wxID_FILE5,
1352     wxID_FILE6,
1353     wxID_FILE7,
1354     wxID_FILE8,
1355     wxID_FILE9,
1356
1357     // Standard button IDs
1358     wxID_OK = 5100,
1359     wxID_CANCEL,
1360     wxID_APPLY,
1361     wxID_YES,
1362     wxID_NO,
1363     wxID_STATIC,
1364     wxID_FORWARD,
1365     wxID_BACKWARD,
1366     wxID_DEFAULT,
1367     wxID_MORE,
1368     wxID_SETUP,
1369     wxID_RESET,
1370     wxID_CONTEXT_HELP,
1371     wxID_YESTOALL,
1372     wxID_NOTOALL,
1373     wxID_ABORT,
1374     wxID_RETRY,
1375     wxID_IGNORE,
1376
1377     // System menu IDs (used by wxUniv):
1378     wxID_SYSTEM_MENU = 5200,
1379     wxID_CLOSE_FRAME,
1380     wxID_MOVE_FRAME,
1381     wxID_RESIZE_FRAME,
1382     wxID_MAXIMIZE_FRAME,
1383     wxID_ICONIZE_FRAME,
1384     wxID_RESTORE_FRAME,
1385
1386     // IDs used by generic file dialog (13 consecutive starting from this value)
1387     wxID_FILEDLGG = 5900,
1388
1389     wxID_HIGHEST = 5999
1390 };
1391
1392 // ----------------------------------------------------------------------------
1393 // other constants
1394 // ----------------------------------------------------------------------------
1395
1396 // menu and toolbar item kinds
1397 enum wxItemKind
1398 {
1399     wxITEM_SEPARATOR = -1,
1400     wxITEM_NORMAL,
1401     wxITEM_CHECK,
1402     wxITEM_RADIO,
1403     wxITEM_MAX
1404 };
1405
1406 // hit test results
1407 enum wxHitTest
1408 {
1409     wxHT_NOWHERE,
1410
1411     // scrollbar
1412     wxHT_SCROLLBAR_FIRST = wxHT_NOWHERE,
1413     wxHT_SCROLLBAR_ARROW_LINE_1,    // left or upper arrow to scroll by line
1414     wxHT_SCROLLBAR_ARROW_LINE_2,    // right or down
1415     wxHT_SCROLLBAR_ARROW_PAGE_1,    // left or upper arrow to scroll by page
1416     wxHT_SCROLLBAR_ARROW_PAGE_2,    // right or down
1417     wxHT_SCROLLBAR_THUMB,           // on the thumb
1418     wxHT_SCROLLBAR_BAR_1,           // bar to the left/above the thumb
1419     wxHT_SCROLLBAR_BAR_2,           // bar to the right/below the thumb
1420     wxHT_SCROLLBAR_LAST,
1421
1422     // window
1423     wxHT_WINDOW_OUTSIDE,            // not in this window at all
1424     wxHT_WINDOW_INSIDE,             // in the client area
1425     wxHT_WINDOW_VERT_SCROLLBAR,     // on the vertical scrollbar
1426     wxHT_WINDOW_HORZ_SCROLLBAR,     // on the horizontal scrollbar
1427     wxHT_WINDOW_CORNER,             // on the corner between 2 scrollbars
1428
1429     wxHT_MAX
1430 };
1431
1432 // ----------------------------------------------------------------------------
1433 // Possible SetSize flags
1434 // ----------------------------------------------------------------------------
1435
1436 // Use internally-calculated width if -1
1437 #define wxSIZE_AUTO_WIDTH       0x0001
1438 // Use internally-calculated height if -1
1439 #define wxSIZE_AUTO_HEIGHT      0x0002
1440 // Use internally-calculated width and height if each is -1
1441 #define wxSIZE_AUTO             (wxSIZE_AUTO_WIDTH|wxSIZE_AUTO_HEIGHT)
1442 // Ignore missing (-1) dimensions (use existing).
1443 // For readability only: test for wxSIZE_AUTO_WIDTH/HEIGHT in code.
1444 #define wxSIZE_USE_EXISTING     0x0000
1445 // Allow -1 as a valid position
1446 #define wxSIZE_ALLOW_MINUS_ONE  0x0004
1447 // Don't do parent client adjustments (for implementation only)
1448 #define wxSIZE_NO_ADJUSTMENTS   0x0008
1449
1450 // ----------------------------------------------------------------------------
1451 // GDI descriptions
1452 // ----------------------------------------------------------------------------
1453
1454 enum
1455 {
1456     // Text font families
1457     wxDEFAULT    = 70,
1458     wxDECORATIVE,
1459     wxROMAN,
1460     wxSCRIPT,
1461     wxSWISS,
1462     wxMODERN,
1463     wxTELETYPE,  /* @@@@ */
1464
1465     // Proportional or Fixed width fonts (not yet used)
1466     wxVARIABLE   = 80,
1467     wxFIXED,
1468
1469     wxNORMAL     = 90,
1470     wxLIGHT,
1471     wxBOLD,
1472     // Also wxNORMAL for normal (non-italic text)
1473     wxITALIC,
1474     wxSLANT,
1475
1476     // Pen styles
1477     wxSOLID      =   100,
1478     wxDOT,
1479     wxLONG_DASH,
1480     wxSHORT_DASH,
1481     wxDOT_DASH,
1482     wxUSER_DASH,
1483
1484     wxTRANSPARENT,
1485
1486     // Brush & Pen Stippling. Note that a stippled pen cannot be dashed!!
1487     // Note also that stippling a Pen IS meaningfull, because a Line is
1488     wxSTIPPLE_MASK_OPAQUE, //mask is used for blitting monochrome using text fore and back ground colors
1489     wxSTIPPLE_MASK,        //mask is used for masking areas in the stipple bitmap (TO DO)
1490     // drawn with a Pen, and without any Brush -- and it can be stippled.
1491     wxSTIPPLE =          110,
1492     wxBDIAGONAL_HATCH,
1493     wxCROSSDIAG_HATCH,
1494     wxFDIAGONAL_HATCH,
1495     wxCROSS_HATCH,
1496     wxHORIZONTAL_HATCH,
1497     wxVERTICAL_HATCH,
1498
1499     wxJOIN_BEVEL =     120,
1500     wxJOIN_MITER,
1501     wxJOIN_ROUND,
1502
1503     wxCAP_ROUND =      130,
1504     wxCAP_PROJECTING,
1505     wxCAP_BUTT
1506 };
1507
1508 // VZ: why doesn't it start with "wx"? FIXME
1509 #define IS_HATCH(s)    ((s)>=wxBDIAGONAL_HATCH && (s)<=wxVERTICAL_HATCH)
1510
1511 // Logical ops
1512 typedef enum
1513 {
1514   wxCLEAR,        wxROP_BLACK = wxCLEAR,             wxBLIT_BLACKNESS = wxCLEAR,        // 0
1515   wxXOR,          wxROP_XORPEN = wxXOR,              wxBLIT_SRCINVERT = wxXOR,          // src XOR dst
1516   wxINVERT,       wxROP_NOT = wxINVERT,              wxBLIT_DSTINVERT = wxINVERT,       // NOT dst
1517   wxOR_REVERSE,   wxROP_MERGEPENNOT = wxOR_REVERSE,  wxBLIT_00DD0228 = wxOR_REVERSE,    // src OR (NOT dst)
1518   wxAND_REVERSE,  wxROP_MASKPENNOT = wxAND_REVERSE,  wxBLIT_SRCERASE = wxAND_REVERSE,   // src AND (NOT dst)
1519   wxCOPY,         wxROP_COPYPEN = wxCOPY,            wxBLIT_SRCCOPY = wxCOPY,           // src
1520   wxAND,          wxROP_MASKPEN = wxAND,             wxBLIT_SRCAND = wxAND,             // src AND dst
1521   wxAND_INVERT,   wxROP_MASKNOTPEN = wxAND_INVERT,   wxBLIT_00220326 = wxAND_INVERT,    // (NOT src) AND dst
1522   wxNO_OP,        wxROP_NOP = wxNO_OP,               wxBLIT_00AA0029 = wxNO_OP,         // dst
1523   wxNOR,          wxROP_NOTMERGEPEN = wxNOR,         wxBLIT_NOTSRCERASE = wxNOR,        // (NOT src) AND (NOT dst)
1524   wxEQUIV,        wxROP_NOTXORPEN = wxEQUIV,         wxBLIT_00990066 = wxEQUIV,         // (NOT src) XOR dst
1525   wxSRC_INVERT,   wxROP_NOTCOPYPEN = wxSRC_INVERT,   wxBLIT_NOTSCRCOPY = wxSRC_INVERT,  // (NOT src)
1526   wxOR_INVERT,    wxROP_MERGENOTPEN = wxOR_INVERT,   wxBLIT_MERGEPAINT = wxOR_INVERT,   // (NOT src) OR dst
1527   wxNAND,         wxROP_NOTMASKPEN = wxNAND,         wxBLIT_007700E6 = wxNAND,          // (NOT src) OR (NOT dst)
1528   wxOR,           wxROP_MERGEPEN = wxOR,             wxBLIT_SRCPAINT = wxOR,            // src OR dst
1529   wxSET,          wxROP_WHITE = wxSET,               wxBLIT_WHITENESS = wxSET           // 1
1530 } form_ops_t;
1531
1532 // Flood styles
1533 enum
1534 {
1535     wxFLOOD_SURFACE = 1,
1536     wxFLOOD_BORDER
1537 };
1538
1539 // Polygon filling mode
1540 enum
1541 {
1542     wxODDEVEN_RULE = 1,
1543     wxWINDING_RULE
1544 };
1545
1546 // ToolPanel in wxFrame (VZ: unused?)
1547 enum
1548 {
1549     wxTOOL_TOP = 1,
1550     wxTOOL_BOTTOM,
1551     wxTOOL_LEFT,
1552     wxTOOL_RIGHT
1553 };
1554
1555 // the values of the format constants should be the same as correspondign
1556 // CF_XXX constants in Windows API
1557 enum wxDataFormatId
1558 {
1559     wxDF_INVALID =          0,
1560     wxDF_TEXT =             1,  /* CF_TEXT */
1561     wxDF_BITMAP =           2,  /* CF_BITMAP */
1562     wxDF_METAFILE =         3,  /* CF_METAFILEPICT */
1563     wxDF_SYLK =             4,
1564     wxDF_DIF =              5,
1565     wxDF_TIFF =             6,
1566     wxDF_OEMTEXT =          7,  /* CF_OEMTEXT */
1567     wxDF_DIB =              8,  /* CF_DIB */
1568     wxDF_PALETTE =          9,
1569     wxDF_PENDATA =          10,
1570     wxDF_RIFF =             11,
1571     wxDF_WAVE =             12,
1572     wxDF_UNICODETEXT =      13,
1573     wxDF_ENHMETAFILE =      14,
1574     wxDF_FILENAME =         15, /* CF_HDROP */
1575     wxDF_LOCALE =           16,
1576     wxDF_PRIVATE =          20,
1577     wxDF_HTML =             30, /* Note: does not correspond to CF_ constant */
1578     wxDF_MAX
1579 };
1580
1581 // Virtual keycodes
1582 enum wxKeyCode
1583 {
1584     WXK_BACK    =    8,
1585     WXK_TAB     =    9,
1586     WXK_RETURN  =    13,
1587     WXK_ESCAPE  =    27,
1588     WXK_SPACE   =    32,
1589     WXK_DELETE  =    127,
1590
1591     WXK_START   = 300,
1592     WXK_LBUTTON,
1593     WXK_RBUTTON,
1594     WXK_CANCEL,
1595     WXK_MBUTTON,
1596     WXK_CLEAR,
1597     WXK_SHIFT,
1598     WXK_ALT,
1599     WXK_CONTROL,
1600     WXK_MENU,
1601     WXK_PAUSE,
1602     WXK_CAPITAL,
1603     WXK_PRIOR,  // Page up
1604     WXK_NEXT,   // Page down
1605     WXK_END,
1606     WXK_HOME,
1607     WXK_LEFT,
1608     WXK_UP,
1609     WXK_RIGHT,
1610     WXK_DOWN,
1611     WXK_SELECT,
1612     WXK_PRINT,
1613     WXK_EXECUTE,
1614     WXK_SNAPSHOT,
1615     WXK_INSERT,
1616     WXK_HELP,
1617     WXK_NUMPAD0,
1618     WXK_NUMPAD1,
1619     WXK_NUMPAD2,
1620     WXK_NUMPAD3,
1621     WXK_NUMPAD4,
1622     WXK_NUMPAD5,
1623     WXK_NUMPAD6,
1624     WXK_NUMPAD7,
1625     WXK_NUMPAD8,
1626     WXK_NUMPAD9,
1627     WXK_MULTIPLY,
1628     WXK_ADD,
1629     WXK_SEPARATOR,
1630     WXK_SUBTRACT,
1631     WXK_DECIMAL,
1632     WXK_DIVIDE,
1633     WXK_F1,
1634     WXK_F2,
1635     WXK_F3,
1636     WXK_F4,
1637     WXK_F5,
1638     WXK_F6,
1639     WXK_F7,
1640     WXK_F8,
1641     WXK_F9,
1642     WXK_F10,
1643     WXK_F11,
1644     WXK_F12,
1645     WXK_F13,
1646     WXK_F14,
1647     WXK_F15,
1648     WXK_F16,
1649     WXK_F17,
1650     WXK_F18,
1651     WXK_F19,
1652     WXK_F20,
1653     WXK_F21,
1654     WXK_F22,
1655     WXK_F23,
1656     WXK_F24,
1657     WXK_NUMLOCK,
1658     WXK_SCROLL,
1659     WXK_PAGEUP,
1660     WXK_PAGEDOWN,
1661
1662     WXK_NUMPAD_SPACE,
1663     WXK_NUMPAD_TAB,
1664     WXK_NUMPAD_ENTER,
1665     WXK_NUMPAD_F1,
1666     WXK_NUMPAD_F2,
1667     WXK_NUMPAD_F3,
1668     WXK_NUMPAD_F4,
1669     WXK_NUMPAD_HOME,
1670     WXK_NUMPAD_LEFT,
1671     WXK_NUMPAD_UP,
1672     WXK_NUMPAD_RIGHT,
1673     WXK_NUMPAD_DOWN,
1674     WXK_NUMPAD_PRIOR,
1675     WXK_NUMPAD_PAGEUP,
1676     WXK_NUMPAD_NEXT,
1677     WXK_NUMPAD_PAGEDOWN,
1678     WXK_NUMPAD_END,
1679     WXK_NUMPAD_BEGIN,
1680     WXK_NUMPAD_INSERT,
1681     WXK_NUMPAD_DELETE,
1682     WXK_NUMPAD_EQUAL,
1683     WXK_NUMPAD_MULTIPLY,
1684     WXK_NUMPAD_ADD,
1685     WXK_NUMPAD_SEPARATOR,
1686     WXK_NUMPAD_SUBTRACT,
1687     WXK_NUMPAD_DECIMAL,
1688     WXK_NUMPAD_DIVIDE,
1689
1690     WXK_WINDOWS_LEFT,
1691     WXK_WINDOWS_RIGHT,
1692     WXK_WINDOWS_MENU
1693 };
1694
1695 // Mapping modes (same values as used by Windows, don't change)
1696 enum
1697 {
1698     wxMM_TEXT = 1,
1699     wxMM_LOMETRIC,
1700     wxMM_HIMETRIC,
1701     wxMM_LOENGLISH,
1702     wxMM_HIENGLISH,
1703     wxMM_TWIPS,
1704     wxMM_ISOTROPIC,
1705     wxMM_ANISOTROPIC,
1706     wxMM_POINTS,
1707     wxMM_METRIC
1708 };
1709
1710 /* Shortcut for easier dialog-unit-to-pixel conversion */
1711 #define wxDLG_UNIT(parent, pt) parent->ConvertDialogToPixels(pt)
1712
1713 /* Paper types */
1714 typedef enum
1715 {
1716     wxPAPER_NONE,               // Use specific dimensions
1717     wxPAPER_LETTER,             // Letter, 8 1/2 by 11 inches
1718     wxPAPER_LEGAL,              // Legal, 8 1/2 by 14 inches
1719     wxPAPER_A4,                 // A4 Sheet, 210 by 297 millimeters
1720     wxPAPER_CSHEET,             // C Sheet, 17 by 22 inches
1721     wxPAPER_DSHEET,             // D Sheet, 22 by 34 inches
1722     wxPAPER_ESHEET,             // E Sheet, 34 by 44 inches
1723     wxPAPER_LETTERSMALL,        // Letter Small, 8 1/2 by 11 inches
1724     wxPAPER_TABLOID,            // Tabloid, 11 by 17 inches
1725     wxPAPER_LEDGER,             // Ledger, 17 by 11 inches
1726     wxPAPER_STATEMENT,          // Statement, 5 1/2 by 8 1/2 inches
1727     wxPAPER_EXECUTIVE,          // Executive, 7 1/4 by 10 1/2 inches
1728     wxPAPER_A3,                 // A3 sheet, 297 by 420 millimeters
1729     wxPAPER_A4SMALL,            // A4 small sheet, 210 by 297 millimeters
1730     wxPAPER_A5,                 // A5 sheet, 148 by 210 millimeters
1731     wxPAPER_B4,                 // B4 sheet, 250 by 354 millimeters
1732     wxPAPER_B5,                 // B5 sheet, 182-by-257-millimeter paper
1733     wxPAPER_FOLIO,              // Folio, 8-1/2-by-13-inch paper
1734     wxPAPER_QUARTO,             // Quarto, 215-by-275-millimeter paper
1735     wxPAPER_10X14,              // 10-by-14-inch sheet
1736     wxPAPER_11X17,              // 11-by-17-inch sheet
1737     wxPAPER_NOTE,               // Note, 8 1/2 by 11 inches
1738     wxPAPER_ENV_9,              // #9 Envelope, 3 7/8 by 8 7/8 inches
1739     wxPAPER_ENV_10,             // #10 Envelope, 4 1/8 by 9 1/2 inches
1740     wxPAPER_ENV_11,             // #11 Envelope, 4 1/2 by 10 3/8 inches
1741     wxPAPER_ENV_12,             // #12 Envelope, 4 3/4 by 11 inches
1742     wxPAPER_ENV_14,             // #14 Envelope, 5 by 11 1/2 inches
1743     wxPAPER_ENV_DL,             // DL Envelope, 110 by 220 millimeters
1744     wxPAPER_ENV_C5,             // C5 Envelope, 162 by 229 millimeters
1745     wxPAPER_ENV_C3,             // C3 Envelope, 324 by 458 millimeters
1746     wxPAPER_ENV_C4,             // C4 Envelope, 229 by 324 millimeters
1747     wxPAPER_ENV_C6,             // C6 Envelope, 114 by 162 millimeters
1748     wxPAPER_ENV_C65,            // C65 Envelope, 114 by 229 millimeters
1749     wxPAPER_ENV_B4,             // B4 Envelope, 250 by 353 millimeters
1750     wxPAPER_ENV_B5,             // B5 Envelope, 176 by 250 millimeters
1751     wxPAPER_ENV_B6,             // B6 Envelope, 176 by 125 millimeters
1752     wxPAPER_ENV_ITALY,          // Italy Envelope, 110 by 230 millimeters
1753     wxPAPER_ENV_MONARCH,        // Monarch Envelope, 3 7/8 by 7 1/2 inches
1754     wxPAPER_ENV_PERSONAL,       // 6 3/4 Envelope, 3 5/8 by 6 1/2 inches
1755     wxPAPER_FANFOLD_US,         // US Std Fanfold, 14 7/8 by 11 inches
1756     wxPAPER_FANFOLD_STD_GERMAN, // German Std Fanfold, 8 1/2 by 12 inches
1757     wxPAPER_FANFOLD_LGL_GERMAN, // German Legal Fanfold, 8 1/2 by 13 inches
1758
1759     wxPAPER_ISO_B4,             // B4 (ISO) 250 x 353 mm
1760     wxPAPER_JAPANESE_POSTCARD,  // Japanese Postcard 100 x 148 mm
1761     wxPAPER_9X11,               // 9 x 11 in
1762     wxPAPER_10X11,              // 10 x 11 in
1763     wxPAPER_15X11,              // 15 x 11 in
1764     wxPAPER_ENV_INVITE,         // Envelope Invite 220 x 220 mm
1765     wxPAPER_LETTER_EXTRA,       // Letter Extra 9 \275 x 12 in
1766     wxPAPER_LEGAL_EXTRA,        // Legal Extra 9 \275 x 15 in
1767     wxPAPER_TABLOID_EXTRA,      // Tabloid Extra 11.69 x 18 in
1768     wxPAPER_A4_EXTRA,           // A4 Extra 9.27 x 12.69 in
1769     wxPAPER_LETTER_TRANSVERSE,  // Letter Transverse 8 \275 x 11 in
1770     wxPAPER_A4_TRANSVERSE,      // A4 Transverse 210 x 297 mm
1771     wxPAPER_LETTER_EXTRA_TRANSVERSE, // Letter Extra Transverse 9\275 x 12 in
1772     wxPAPER_A_PLUS,             // SuperA/SuperA/A4 227 x 356 mm
1773     wxPAPER_B_PLUS,             // SuperB/SuperB/A3 305 x 487 mm
1774     wxPAPER_LETTER_PLUS,        // Letter Plus 8.5 x 12.69 in
1775     wxPAPER_A4_PLUS,            // A4 Plus 210 x 330 mm
1776     wxPAPER_A5_TRANSVERSE,      // A5 Transverse 148 x 210 mm
1777     wxPAPER_B5_TRANSVERSE,      // B5 (JIS) Transverse 182 x 257 mm
1778     wxPAPER_A3_EXTRA,           // A3 Extra 322 x 445 mm
1779     wxPAPER_A5_EXTRA,           // A5 Extra 174 x 235 mm
1780     wxPAPER_B5_EXTRA,           // B5 (ISO) Extra 201 x 276 mm
1781     wxPAPER_A2,                 // A2 420 x 594 mm
1782     wxPAPER_A3_TRANSVERSE,      // A3 Transverse 297 x 420 mm
1783     wxPAPER_A3_EXTRA_TRANSVERSE // A3 Extra Transverse 322 x 445 mm
1784
1785 } wxPaperSize;
1786
1787 /* Printing orientation */
1788 #ifndef wxPORTRAIT
1789 #define wxPORTRAIT      1
1790 #define wxLANDSCAPE     2
1791 #endif
1792
1793 /* Duplex printing modes
1794  */
1795
1796 enum wxDuplexMode
1797 {
1798     wxDUPLEX_SIMPLEX, // Non-duplex
1799     wxDUPLEX_HORIZONTAL,
1800     wxDUPLEX_VERTICAL
1801 };
1802
1803 /* Print quality.
1804  */
1805
1806 #define wxPRINT_QUALITY_HIGH    -1
1807 #define wxPRINT_QUALITY_MEDIUM  -2
1808 #define wxPRINT_QUALITY_LOW     -3
1809 #define wxPRINT_QUALITY_DRAFT   -4
1810
1811 typedef int wxPrintQuality;
1812
1813 /* Print mode (currently PostScript only)
1814  */
1815
1816 enum wxPrintMode
1817 {
1818     wxPRINT_MODE_NONE =    0,
1819     wxPRINT_MODE_PREVIEW = 1,   // Preview in external application
1820     wxPRINT_MODE_FILE =    2,   // Print to file
1821     wxPRINT_MODE_PRINTER = 3    // Send to printer
1822 };
1823
1824 // ----------------------------------------------------------------------------
1825 // miscellaneous
1826 // ----------------------------------------------------------------------------
1827
1828 // define this macro if font handling is done using the X font names
1829 #if (defined(__WXGTK__) && !defined(__WXGTK20__)) || defined(__X__)
1830     #define _WX_X_FONTLIKE
1831 #endif
1832
1833 // macro to specify "All Files" on different platforms
1834 #if defined(__WXMSW__) || defined(__WXPM__)
1835 #   define wxALL_FILES_PATTERN   wxT("*.*")
1836 #   define wxALL_FILES           gettext_noop("All files (*.*)|*.*")
1837 #else
1838 #   define wxALL_FILES_PATTERN   wxT("*")
1839 #   define wxALL_FILES           gettext_noop("All files (*)|*")
1840 #endif
1841
1842 // ---------------------------------------------------------------------------
1843 // macros that enable wxWindows apps to be compiled in absence of the
1844 // sytem headers, although some platform specific types are used in the
1845 // platform specific (implementation) parts of the headers
1846 // ---------------------------------------------------------------------------
1847
1848 #ifdef __WXMAC__
1849
1850 typedef unsigned char WXCOLORREF[6];
1851 typedef void*       WXHBITMAP;
1852 typedef void*       WXHMETAFILE ;
1853 typedef void*       WXHICON ;
1854 typedef void*       WXHCURSOR ;
1855 typedef void*       WXHRGN ;
1856 typedef void*       WXRECTPTR ;
1857 typedef void*       WXPOINTPTR ;
1858 typedef void*       WXHWND ;
1859 typedef void*       WXEVENTREF ;
1860 typedef void*           WXEVENTHANDLERREF ;
1861 typedef void*       WXEVENTHANDLERCALLREF ;
1862 typedef void*       WXAPPLEEVENTREF ;
1863 typedef void*       WXHDC ;
1864 typedef void*       WXHMENU ;
1865 typedef unsigned int    WXUINT;
1866 typedef unsigned long   WXDWORD;
1867 typedef unsigned short  WXWORD;
1868
1869 typedef void*       WXWidget ;
1870 typedef void*       WXWindow ;
1871 typedef void*       WXDisplay ;
1872 /*
1873 typedef WindowPtr       WXHWND;
1874 typedef Handle          WXHANDLE;
1875 typedef CIconHandle     WXHICON;
1876 //typedef unsigned long   WXHFONT;
1877 typedef MenuHandle      WXHMENU;
1878 //typedef unsigned long   WXHPEN;
1879 //typedef unsigned long   WXHBRUSH;
1880 //typedef unsigned long   WXHPALETTE;
1881 typedef CursHandle      WXHCURSOR;
1882 typedef RgnHandle       WXHRGN;
1883 //typedef unsigned long   WXHACCEL;
1884 //typedef unsigned long   WXHINSTANCE;
1885 //typedef unsigned long   WXHIMAGELIST;
1886 //typedef unsigned long   WXHGLOBAL;
1887 typedef GrafPtr         WXHDC;
1888 //typedef unsigned int    WXWPARAM;
1889 //typedef long            WXLPARAM;
1890 //typedef void *          WXRGNDATA;
1891 //typedef void *          WXMSG;
1892 //typedef unsigned long   WXHCONV;
1893 //typedef unsigned long   WXHKEY;
1894 //typedef void *          WXDRAWITEMSTRUCT;
1895 //typedef void *          WXMEASUREITEMSTRUCT;
1896 //typedef void *          WXLPCREATESTRUCT;
1897 typedef int (*WXFARPROC)();
1898
1899 typedef WindowPtr       WXWindow;
1900 typedef ControlHandle   WXWidget;
1901 */
1902 #endif
1903
1904 #ifdef __WXCOCOA__
1905
1906 // NOTE: typedef struct objc_object *id;
1907 // IOW, we're declaring these using the id type without using that name,
1908 // since "id" is used extensively not only within wxWindows itself, but
1909 // also in wxWindows application code.  The following works fine when
1910 // compiling C++ code, and works without typesafety for Obj-C++ code
1911 #define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
1912 typedef struct objc_object *WX_##klass
1913
1914 DECLARE_WXCOCOA_OBJC_CLASS(NSApplication);
1915 DECLARE_WXCOCOA_OBJC_CLASS(NSBox);
1916 DECLARE_WXCOCOA_OBJC_CLASS(NSButton);
1917 DECLARE_WXCOCOA_OBJC_CLASS(NSControl);
1918 DECLARE_WXCOCOA_OBJC_CLASS(NSEvent);
1919 DECLARE_WXCOCOA_OBJC_CLASS(NSLayoutManager);
1920 DECLARE_WXCOCOA_OBJC_CLASS(NSMenu);
1921 DECLARE_WXCOCOA_OBJC_CLASS(NSMenuItem);
1922 DECLARE_WXCOCOA_OBJC_CLASS(NSPanel);
1923 DECLARE_WXCOCOA_OBJC_CLASS(NSTableView);
1924 DECLARE_WXCOCOA_OBJC_CLASS(NSTextContainer);
1925 DECLARE_WXCOCOA_OBJC_CLASS(NSTextField);
1926 DECLARE_WXCOCOA_OBJC_CLASS(NSTextStorage);
1927 DECLARE_WXCOCOA_OBJC_CLASS(NSWindow);
1928 DECLARE_WXCOCOA_OBJC_CLASS(NSView);
1929 typedef WX_NSView WXWidget; // wxWindows BASE definition
1930 #endif // __WXCOCOA__
1931
1932 #if defined(__WXMSW__) || defined(__WXPM__)
1933
1934 // the keywords needed for WinMain() declaration
1935 #ifdef __WIN16__
1936 #  ifdef __VISUALC__
1937 #    define WXFAR __far
1938 #  else
1939 #    define WXFAR _far
1940 #  endif
1941 #else  // Win32
1942 #  ifndef WXFAR
1943 #    define WXFAR
1944 #  endif
1945 #endif // Win16/32
1946
1947 // Stand-ins for Windows types or OS/2, to avoid #including all of windows.h or os2.h
1948 typedef unsigned long   WXHWND;
1949 typedef unsigned long   WXHANDLE;
1950 typedef unsigned long   WXHICON;
1951 typedef unsigned long   WXHFONT;
1952 typedef unsigned long   WXHMENU;
1953 typedef unsigned long   WXHPEN;
1954 typedef unsigned long   WXHBRUSH;
1955 typedef unsigned long   WXHPALETTE;
1956 typedef unsigned long   WXHCURSOR;
1957 typedef unsigned long   WXHRGN;
1958 typedef unsigned long   WXHACCEL;
1959 typedef void WXFAR  *   WXHINSTANCE;
1960 typedef unsigned long   WXHBITMAP;
1961 typedef unsigned long   WXHIMAGELIST;
1962 typedef unsigned long   WXHGLOBAL;
1963 typedef unsigned long   WXHDC;
1964 typedef unsigned int    WXUINT;
1965 typedef unsigned long   WXDWORD;
1966 typedef unsigned short  WXWORD;
1967
1968 typedef unsigned long   WXCOLORREF;
1969 typedef void *          WXRGNDATA;
1970 typedef void *          WXMSG;
1971 typedef unsigned long   WXHCONV;
1972 typedef unsigned long   WXHKEY;
1973 typedef unsigned long   WXHTREEITEM;
1974
1975 typedef void *          WXDRAWITEMSTRUCT;
1976 typedef void *          WXMEASUREITEMSTRUCT;
1977 typedef void *          WXLPCREATESTRUCT;
1978
1979 typedef WXHWND          WXWidget;
1980
1981 #endif // MSW or OS2
1982
1983
1984 #ifdef __WXMSW__
1985 typedef unsigned int    WXWPARAM;
1986 typedef long            WXLPARAM;
1987
1988 #if !defined(__WIN32__) || defined(__GNUWIN32__) || defined(__WXMICROWIN__)
1989 typedef int             (*WXFARPROC)();
1990 #else
1991 typedef int             (__stdcall *WXFARPROC)();
1992 #endif
1993 #endif // __WXMSW__
1994
1995
1996 #if defined(__WXPM__)
1997 #ifdef __EMX__
1998 /* Need a well-known type for WXFARPROC
1999    below. MPARAM is typedef'ed too late. */
2000 #define WXWPARAM        void *
2001 #define WXLPARAM        void *
2002 #else
2003 #define WXWPARAM        MPARAM
2004 #define WXLPARAM        MPARAM
2005 #endif
2006 #define RECT            RECTL
2007 #define LOGFONT         FATTRS
2008 #define LOWORD          SHORT1FROMMP
2009 #define HIWORD          SHORT2FROMMP
2010
2011 typedef unsigned long   WXMPARAM;
2012 typedef unsigned long   WXMSGID;
2013 typedef void*           WXRESULT;
2014 //typedef int             (*WXFARPROC)();
2015 // some windows handles not defined by PM
2016 typedef unsigned long   HANDLE;
2017 typedef unsigned long   HICON;
2018 typedef unsigned long   HFONT;
2019 typedef unsigned long   HMENU;
2020 typedef unsigned long   HPEN;
2021 typedef unsigned long   HBRUSH;
2022 typedef unsigned long   HPALETTE;
2023 typedef unsigned long   HCURSOR;
2024 typedef unsigned long   HINSTANCE;
2025 typedef unsigned long   HIMAGELIST;
2026 typedef unsigned long   HGLOBAL;
2027 typedef unsigned long   DWORD;
2028 typedef unsigned short  WORD;
2029
2030 // WIN32 graphics types for OS/2 GPI
2031
2032 // RGB under OS2 is more like a PALETTEENTRY struct under Windows so we need a real RGB def
2033 // WARNING: The OS/2 headers typedef BYTE simply as 'char'; if the default is signed, all
2034 // hell will break loose!
2035 //#define OS2RGB(r,g,b) ((DWORD ((BYTE) (b) | ((WORD) (g) << 8)) | (((DWORD)(BYTE)(r)) << 16)))
2036 #define OS2RGB(r,g,b) ((DWORD)((unsigned char)(b) | ((unsigned char)(g) << 8)) | ((unsigned char)(r) << 16))
2037
2038 typedef unsigned long COLORREF;
2039 #define GetBValue(rgb) ((BYTE)((rgb) >> 16))
2040 #define GetGValue(rgb) ((BYTE)(((WORD)(rgb)) >> 8))
2041 #define GetRValue(rgb) ((BYTE)(rgb))
2042 #define PALETTEINDEX(i) ((COLORREF)(0x01000000 | (DWORD)(WORD)(i)))
2043 #define PALETTERGB(r,g,b) (0x02000000 | OS2RGB(r,g,b))
2044 // OS2's RGB/RGB2 is backwards from this
2045 typedef struct tagPALETTEENTRY
2046 {
2047     char bRed;
2048     char bGreen;
2049     char bBlue;
2050     char bFlags;
2051 } PALETTEENTRY;
2052 typedef struct tagLOGPALETTE
2053 {
2054     WORD palVersion;
2055     WORD palNumentries;
2056     WORD PALETTEENTRY[1];
2057 } LOGPALETTE;
2058
2059 #if (defined(__VISAGECPP__) && (__IBMCPP__ < 400)) || defined (__WATCOMC__)
2060     // VA 3.0 for some reason needs base data types when typedefing a proc proto???
2061 typedef void* (_System *WXFARPROC)(unsigned long, unsigned long, void*, void*);
2062 #else
2063 #ifdef __EMX__
2064 #define _System
2065 #endif
2066 typedef WXRESULT (_System *WXFARPROC)(WXHWND, WXMSGID, WXWPARAM, WXLPARAM);
2067 #endif
2068
2069 #endif //__WXPM__
2070
2071
2072 #if defined(__WXMOTIF__) || defined(__WXX11__)
2073 /* Stand-ins for X/Xt/Motif types */
2074 typedef void*           WXWindow;
2075 typedef void*           WXWidget;
2076 typedef void*           WXAppContext;
2077 typedef void*           WXColormap;
2078 typedef void*           WXColor;
2079 typedef void            WXDisplay;
2080 typedef void            WXEvent;
2081 typedef void*           WXCursor;
2082 typedef void*           WXPixmap;
2083 typedef void*           WXFontStructPtr;
2084 typedef void*           WXGC;
2085 typedef void*           WXRegion;
2086 typedef void*           WXFont;
2087 typedef void*           WXImage;
2088 typedef void*           WXFontList;
2089 typedef void*           WXRendition;
2090 typedef void*           WXRenderTable;
2091 typedef void*           WXFontType; /* either a XmFontList or XmRenderTable */
2092 typedef void*           WXString;
2093
2094 typedef unsigned long   Atom;  /* this might fail on a few architectures */
2095
2096 #endif // Motif
2097
2098 #ifdef __WXGTK__
2099
2100 /* Stand-ins for GLIB types */
2101 typedef char           gchar;
2102 typedef signed char    gint8;
2103 typedef int            gint;
2104 typedef unsigned       guint;
2105 typedef unsigned long  gulong;
2106 typedef void*          gpointer;
2107 typedef struct _GSList GSList;
2108
2109 /* Stand-ins for GDK types */
2110 typedef struct _GdkColor        GdkColor;
2111 typedef struct _GdkColormap     GdkColormap;
2112 typedef struct _GdkFont         GdkFont;
2113 typedef struct _GdkGC           GdkGC;
2114 typedef struct _GdkVisual       GdkVisual;
2115
2116 #ifdef __WXGTK20__
2117 typedef struct _GdkAtom        *GdkAtom;
2118 typedef struct _GdkDrawable     GdkWindow;
2119 typedef struct _GdkDrawable     GdkBitmap;
2120 typedef struct _GdkDrawable     GdkPixmap;
2121 #else // GTK+ 1.2
2122 typedef gulong                  GdkAtom;
2123 typedef struct _GdkWindow       GdkWindow;
2124 typedef struct _GdkWindow       GdkBitmap;
2125 typedef struct _GdkWindow       GdkPixmap;
2126 #endif // GTK+ 1.2/2.0
2127
2128 typedef struct _GdkCursor       GdkCursor;
2129 typedef struct _GdkRegion       GdkRegion;
2130 typedef struct _GdkDragContext  GdkDragContext;
2131
2132 #ifdef HAVE_XIM
2133 typedef struct _GdkIC           GdkIC;
2134 typedef struct _GdkICAttr       GdkICAttr;
2135 #endif
2136
2137 /* Stand-ins for GTK types */
2138 typedef struct _GtkWidget         GtkWidget;
2139 typedef struct _GtkStyle          GtkStyle;
2140 typedef struct _GtkAdjustment     GtkAdjustment;
2141 typedef struct _GtkList           GtkList;
2142 typedef struct _GtkToolbar        GtkToolbar;
2143 typedef struct _GtkTooltips       GtkTooltips;
2144 typedef struct _GtkNotebook       GtkNotebook;
2145 typedef struct _GtkNotebookPage   GtkNotebookPage;
2146 typedef struct _GtkAccelGroup     GtkAccelGroup;
2147 typedef struct _GtkItemFactory    GtkItemFactory;
2148 typedef struct _GtkSelectionData  GtkSelectionData;
2149
2150 typedef GtkWidget *WXWidget;
2151
2152 #ifndef __WXGTK20__
2153 #define GTK_OBJECT_GET_CLASS(object) (GTK_OBJECT(object)->klass)
2154 #define GTK_CLASS_TYPE(klass) ((klass)->type)
2155 #endif
2156
2157 #ifdef __WXGTK20__
2158 /* Input method thing */
2159 typedef struct _GtkIMMulticontext    GtkIMMulticontext;
2160 #endif // __WXGTK20__
2161
2162 #endif // __WXGTK__
2163
2164 #if defined(__WXGTK20__) || (defined(__WXX11__) && wxUSE_UNICODE)
2165 #define wxUSE_PANGO 1
2166 #else
2167 #define wxUSE_PANGO 0
2168 #endif
2169
2170 #if wxUSE_PANGO
2171 /* Stand-ins for Pango types */
2172 typedef struct _PangoContext         PangoContext;
2173 typedef struct _PangoLayout          PangoLayout;
2174 typedef struct _PangoFontDescription PangoFontDescription;
2175 #endif
2176
2177 #ifdef __WXMGL__
2178 typedef struct window_t *WXWidget;
2179 #endif // MGL
2180
2181 // This is required because of clashing macros in windows.h, which may be
2182 // included before or after wxWindows classes, and therefore must be
2183 // disabled here before any significant wxWindows headers are included.
2184 #ifdef __WXMSW__
2185 #ifdef GetClassInfo
2186 #undef GetClassInfo
2187 #endif
2188
2189 #ifdef GetClassName
2190 #undef GetClassName
2191 #endif
2192
2193 #ifdef DrawText
2194 #undef DrawText
2195 #endif
2196
2197 #ifdef GetCharWidth
2198 #undef GetCharWidth
2199 #endif
2200
2201 #ifdef StartDoc
2202 #undef StartDoc
2203 #endif
2204
2205 #ifdef FindWindow
2206 #undef FindWindow
2207 #endif
2208
2209 #ifdef FindResource
2210 #undef FindResource
2211 #endif
2212 #endif
2213   // __WXMSW__
2214
2215 // ---------------------------------------------------------------------------
2216 // macro to define a class without copy ctor nor assignment operator
2217 // ---------------------------------------------------------------------------
2218
2219 #define DECLARE_NO_COPY_CLASS(classname)        \
2220     private:                                    \
2221         classname(const classname&);            \
2222         classname& operator=(const classname&);
2223
2224 #endif
2225     // _WX_DEFS_H_