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