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