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