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