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