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