include/wx/defs.h

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