X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/cb9d5bd07e7aa0b190c3ee60f5778a974ac9f87b..ca77701441e39245dcbfce903049e76f166979e5:/include/wx/defs.h?ds=inline diff --git a/include/wx/defs.h b/include/wx/defs.h index 6c9931e482..a96a6e91f4 100644 --- a/include/wx/defs.h +++ b/include/wx/defs.h @@ -1,39 +1,46 @@ -/** -* Name: defs.h -* Purpose: Declarations/definitions common to all wx source files -* Author: Julian Smart and others -* Modified by: Ryan Norton (Converted to C) -* Created: 01/02/97 -* RCS-ID: $Id$ -* Copyright: (c) -* Licence: wxWindows licence -*/ +/* + * Name: wx/defs.h + * Purpose: Declarations/definitions common to all wx source files + * Author: Julian Smart and others + * Modified by: Ryan Norton (Converted to C) + * Created: 01/02/97 + * RCS-ID: $Id$ + * Copyright: (c) Julian Smart + * Licence: wxWindows licence + */ /* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */ #ifndef _WX_DEFS_H_ #define _WX_DEFS_H_ +/* + NOTE: this symbol will be replaced with "WXWIN_COMPATIBILITY_3_0" as soon + as the development branch for 3.1 is created + */ +#define FUTURE_WXWIN_COMPATIBILITY_3_0 1 +#define wxDEPRECATED_FUTURE( x ) x + /* ---------------------------------------------------------------------------- */ /* compiler and OS identification */ /* ---------------------------------------------------------------------------- */ #include "wx/platform.h" -/* RN - only double-check the environment when building in C++ - Shouldn't configure pass the environment to all sub-libs too? */ #ifdef __cplusplus /* Make sure the environment is set correctly */ # if defined(__WXMSW__) && defined(__X__) -# error "Target can't be both X and Windows" +# error "Target can't be both X and MSW" # elif !defined(__WXMOTIF__) && \ !defined(__WXMSW__) && \ !defined(__WXGTK__) && \ !defined(__WXPM__) && \ - !defined(__WXMAC__) && \ + !defined(__WXOSX_CARBON__) && \ + !defined(__WXOSX_COCOA__) && \ + !defined(__WXOSX_IPHONE__) && \ !defined(__WXCOCOA__) && \ !defined(__X__) && \ - !defined(__WXMGL__) && \ + !defined(__WXDFB__) && \ !defined(__WXX11__) && \ wxUSE_GUI # ifdef __UNIX__ @@ -57,41 +64,129 @@ #define __WXBASE__ #endif -/* include the feature test macros */ -#include "wx/features.h" - /* suppress some Visual C++ warnings */ #ifdef __VISUALC__ /* the only "real" warning here is 4244 but there are just too many of them */ /* in our code... one day someone should go and fix them but until then... */ +# pragma warning(disable:4097) /* typedef used as class */ # pragma warning(disable:4201) /* nonstandard extension used: nameless struct/union */ # pragma warning(disable:4244) /* conversion from double to float */ -# pragma warning(disable:4710) /* function not inlined */ -# pragma warning(disable:4097) /* typedef used as class */ +# pragma warning(disable:4355) /* 'this' used in base member initializer list */ # pragma warning(disable:4511) /* copy ctor couldn't be generated */ # pragma warning(disable:4512) /* operator=() couldn't be generated */ -#ifndef WIN32 -# pragma warning(disable:4135) /* conversion between different integral types */ -# pragma warning(disable:4769) /* assignment of near pointer to long integer */ -/* This one is really annoying, since it occurs for each cast to (HANDLE)... */ -# pragma warning(disable:4305) /* truncation of long to near ptr */ -#endif -#endif /* __VISUALC__ */ +# pragma warning(disable:4514) /* unreferenced inline func has been removed */ +# pragma warning(disable:4710) /* function not inlined */ + + /* + TODO: this warning should really be enabled as it can be genuinely + useful, check where does it occur in wxWidgets + */ + #pragma warning(disable: 4127) /* conditional expression is constant */ + + /* There are too many false positivies for this one, particularly when + using templates like wxVector */ + /* class 'foo' needs to have dll-interface to be used by clients of + class 'bar'" */ +# pragma warning(disable:4251) -/* suppress some Salford C++ warnings */ -#ifdef __SALFORDC__ -# pragma suppress 353 /* Possible nested comments */ -# pragma suppress 593 /* Define not used */ -# pragma suppress 61 /* enum has no name (doesn't suppress!) */ -# pragma suppress 106 /* unnamed, unused parameter */ -# pragma suppress 571 /* Virtual function hiding */ -#endif /* __SALFORDC__ */ + /* + This is a similar warning which occurs when deriving from standard + containers. MSDN even mentions that it can be ignored in this case + (albeit only in debug build while the warning is the same in release + too and seems equally harmless). + */ +#if wxUSE_STD_CONTAINERS +# pragma warning(disable:4275) +#endif /* wxUSE_STD_CONTAINERS */ + +# ifdef __VISUALC5__ + /* For VC++ 5.0 for release mode, the warning 'C4702: unreachable code */ + /* is buggy, and occurs for code that does actually get executed */ +# ifndef __WXDEBUG__ +# pragma warning(disable:4702) /* unreachable code */ +# endif + + /* The VC++ 5.0 warning 'C4003: not enough actual parameters for macro' + * is incompatible with the wxWidgets headers since it is given when + * parameters are empty but not missing. */ +# pragma warning(disable:4003) /* not enough actual parameters for macro */ +# endif + + /* + VC6 insists on complaining about + + return type for 'wxVector::reverse_iterator::operator ->' is 'T **' + (ie; not a UDT or reference to a UDT. Will produce errors if applied + using infix notation) + + which is perfectly fine because template classes do routinely define + operators which don't make sense for all template parameter values + (besides this warning was removed in subsequent versions). + */ + #ifdef __VISUALC6__ + #pragma warning(disable: 4284) + #endif /* VC6 */ + + /* + When compiling with VC++ 7 /Wp64 option we get thousands of warnings for + conversion from size_t to int or long. Some precious few of them might + be worth looking into but unfortunately it seems infeasible to fix all + the other, harmless ones (e.g. inserting static_cast(s.length()) + everywhere this method is used though we are quite sure that using >4GB + strings is a bad idea anyhow) so just disable it globally for now. + */ + #if wxCHECK_VISUALC_VERSION(7) + /* conversion from 'size_t' to 'unsigned long', possible loss of data */ + #pragma warning(disable:4267) + #endif /* VC++ 7 or later */ + + /* + VC++ 8 gives a warning when using standard functions such as sprintf, + localtime, ... -- stop this madness, unless the user had already done it + */ + #if wxCHECK_VISUALC_VERSION(8) + #ifndef _CRT_SECURE_NO_DEPRECATE + #define _CRT_SECURE_NO_DEPRECATE 1 + #endif + #ifndef _CRT_NON_CONFORMING_SWPRINTFS + #define _CRT_NON_CONFORMING_SWPRINTFS 1 + #endif + #ifndef _SCL_SECURE_NO_WARNINGS + #define _SCL_SECURE_NO_WARNINGS 1 + #endif + #endif /* VC++ 8 */ +#endif /* __VISUALC__ */ /* suppress some Borland C++ warnings */ #ifdef __BORLANDC__ # pragma warn -inl /* Functions containing reserved words and certain constructs are not expanded inline */ #endif /* __BORLANDC__ */ +/* + g++ gives a warning when a class has private dtor if it has no friends but + this is a perfectly valid situation for a ref-counted class which destroys + itself when its ref count drops to 0, so provide a macro to suppress this + warning + */ +#ifdef __GNUG__ +# define wxSUPPRESS_GCC_PRIVATE_DTOR_WARNING(name) \ + friend class wxDummyFriendFor ## name; +#else /* !g++ */ +# define wxSUPPRESS_GCC_PRIVATE_DTOR_WARNING(name) +#endif + +/* + Clang Support + */ + +#ifndef WX_HAS_CLANG_FEATURE +# ifndef __has_feature +# define WX_HAS_CLANG_FEATURE(x) 0 +# else +# define WX_HAS_CLANG_FEATURE(x) __has_feature(x) +# endif +#endif + /* ---------------------------------------------------------------------------- */ /* wxWidgets version and compatibility defines */ /* ---------------------------------------------------------------------------- */ @@ -120,71 +215,16 @@ #define va_list __gnuc_va_list #endif /* HP-UX */ +/* Prevents conflicts between sys/types.h and winsock.h with Cygwin, */ +/* when using Windows sockets. */ +#if defined(__CYGWIN__) && defined(__WXMSW__) +#define __USE_W32_SOCKETS +#endif + /* ---------------------------------------------------------------------------- */ /* check for native bool type and TRUE/FALSE constants */ /* ---------------------------------------------------------------------------- */ -/* Add more tests here for Windows compilers that already define bool */ -/* (under Unix, configure tests for this) */ -#ifndef HAVE_BOOL - #if defined( __MWERKS__ ) - #if (__MWERKS__ >= 0x1000) && __option(bool) - #define HAVE_BOOL - #endif - #elif defined(__APPLE__) && defined(__APPLE_CC__) - /* Apple bundled gcc supports bool */ - #define HAVE_BOOL - #elif defined(__VISUALC__) && (__VISUALC__ == 1020) - /* in VC++ 4.2 the bool keyword is reserved (hence can't be typedefed) */ - /* but not implemented, so we must #define it */ - #define bool unsigned int - #elif defined(__VISUALC__) && (__VISUALC__ == 1010) - /* For VisualC++ 4.1, we need to define */ - /* bool as something between 4.0 & 5.0... */ - typedef unsigned int wxbool; - #define bool wxbool - #define HAVE_BOOL - #elif defined(__VISUALC__) && (__VISUALC__ > 1020) - /* VC++ supports bool since 4.2 */ - #define HAVE_BOOL - #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x500) - /* Borland 5.0+ supports bool */ - #define HAVE_BOOL - #elif defined(__WATCOMC__) && (__WATCOMC__ >= 1100) - /* Watcom 11+ supports bool */ - #define HAVE_BOOL - #elif defined(__DIGITALMARS__) - /* DigitalMars supports bool */ - #define HAVE_BOOL - #elif defined(__GNUWIN32__) || defined(__MINGW32__) || defined(__CYGWIN__) - /* Cygwin supports bool */ - #define HAVE_BOOL - #elif defined(__VISAGECPP__) - #if __IBMCPP__ < 400 - typedef unsigned long bool; - #define true ((bool)1) - #define false ((bool)0) - #endif - #define HAVE_BOOL - #endif /* compilers */ -#endif /* HAVE_BOOL */ - -#if !defined(HAVE_BOOL) && !defined(bool) && !defined(VMS) - /* NB: of course, this doesn't replace the standard type, because, for */ - /* example, overloading based on bool/int parameter doesn't work and */ - /* so should be avoided in portable programs */ - typedef unsigned int bool; -#endif /* bool */ - -/* deal with TRUE/true stuff: we assume that if the compiler supports bool, it */ -/* supports true/false as well and that, OTOH, if it does _not_ support bool, */ -/* it doesn't support these keywords (this is less sure, in particular VC++ */ -/* 4.x could be a problem here) */ -#ifndef HAVE_BOOL - #define true ((bool)1) - #define false ((bool)0) -#endif - /* for backwards compatibility, also define TRUE and FALSE */ /* */ /* note that these definitions should work both in C++ and C code, so don't */ @@ -199,12 +239,6 @@ typedef short int WXTYPE; -/* special care should be taken with this type under Windows where the real */ -/* window id is unsigned, so we must always do the cast before comparing them */ -/* (or else they would be always different!). Using wxGetWindowId() which does */ -/* the cast itself is recommended. Note that this type can't be unsigned */ -/* because wxID_ANY == -1 is a valid (and largely used) value for window id. */ -typedef int wxWindowID; /* ---------------------------------------------------------------------------- */ /* other feature tests */ @@ -230,11 +264,10 @@ typedef int wxWindowID; #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x0520) /* BC++ 4.52 doesn't support explicit, CBuilder 1 does */ #define HAVE_EXPLICIT - #elif defined(__MWERKS__) && (__MWERKS__ >= 0x2400) - /* Metrowerks CW6 or higher has explicit */ - #define HAVE_EXPLICIT #elif defined(__DIGITALMARS__) #define HAVE_EXPLICIT + #elif defined(__WATCOMC__) + #define HAVE_EXPLICIT #endif #endif /* !HAVE_EXPLICIT */ @@ -244,46 +277,51 @@ typedef int wxWindowID; #define wxEXPLICIT #endif /* HAVE_EXPLICIT/!HAVE_EXPLICIT */ -/* check for static/const_cast<>() (we don't use the other ones for now) */ -#ifndef HAVE_CXX_CASTS - #if defined(__VISUALC__) && (__VISUALC__ >= 1100) - /* VC++ 6.0 and 5.0 have C++ casts (what about earlier versions?) */ - #define HAVE_CXX_CASTS - #elif ( defined(__MINGW32__) || defined(__CYGWIN32__) ) \ - && wxCHECK_GCC_VERSION(2, 95) - /* GCC 2.95 has C++ casts, what about earlier versions? */ - #define HAVE_CXX_CASTS - #endif -#endif /* !HAVE_CXX_CASTS */ - -#ifdef HAVE_CXX_CASTS - #ifndef HAVE_CONST_CAST - #define HAVE_CONST_CAST - #endif - #ifndef HAVE_REINTERPRET_CAST - #define HAVE_REINTERPRET_CAST - #endif - #ifndef HAVE_STATIC_CAST - #define HAVE_STATIC_CAST - #endif -#endif /* HAVE_CXX_CASTS */ - -#ifdef HAVE_STATIC_CAST - #define wx_static_cast(t, x) static_cast(x) -#else - #define wx_static_cast(t, x) ((t)(x)) -#endif +/* these macros are obsolete, use the standard C++ casts directly now */ +#define wx_static_cast(t, x) static_cast(x) +#define wx_const_cast(t, x) const_cast(x) +#define wx_reinterpret_cast(t, x) reinterpret_cast(x) -#ifdef HAVE_CONST_CAST - #define wx_const_cast(t, x) const_cast(x) -#else - #define wx_const_cast(t, x) ((t)(x)) -#endif - -#ifdef HAVE_REINTERPRET_CAST - #define wx_reinterpret_cast(t, x) reinterpret_cast(x) +/* + This one is a wx invention: like static cast but used when we intentionally + truncate from a larger to smaller type, static_cast<> can't be used for it + as it results in warnings when using some compilers (SGI mipspro for example) + */ +#if defined(__INTELC__) && defined(__cplusplus) + template + inline T wx_truncate_cast_impl(X x) + { + #pragma warning(push) + /* implicit conversion of a 64-bit integral type to a smaller integral type */ + #pragma warning(disable: 1682) + /* conversion from "X" to "T" may lose significant bits */ + #pragma warning(disable: 810) + /* non-pointer conversion from "foo" to "bar" may lose significant bits */ + #pragma warning(disable: 2259) + + return x; + + #pragma warning(pop) + } + + #define wx_truncate_cast(t, x) wx_truncate_cast_impl(x) + +#elif defined(__cplusplus) && defined(__VISUALC__) && __VISUALC__ >= 1310 + template + inline T wx_truncate_cast_impl(X x) + { + #pragma warning(push) + /* conversion from 'X' to 'T', possible loss of data */ + #pragma warning(disable: 4267) + + return x; + + #pragma warning(pop) + } + + #define wx_truncate_cast(t, x) wx_truncate_cast_impl(x) #else - #define wx_reinterpret_cast(t, x) ((t)(x)) + #define wx_truncate_cast(t, x) ((t)(x)) #endif /* for consistency with wxStatic/DynamicCast defined in wx/object.h */ @@ -293,8 +331,7 @@ typedef int wxWindowID; #if defined(__VISUALC__) && (__VISUALC__ >= 1100) /* VC++ 6.0 and 5.0 have std::wstring (what about earlier versions?) */ #define HAVE_STD_WSTRING - #elif ( defined(__MINGW32__) || defined(__CYGWIN32__) ) \ - && wxCHECK_GCC_VERSION(3, 1) + #elif defined(__MINGW32__) && wxCHECK_GCC_VERSION(3, 3) /* GCC 3.1 has std::wstring; 3.0 never was in MinGW, 2.95 hasn't it */ #define HAVE_STD_WSTRING #endif @@ -313,6 +350,12 @@ typedef int wxWindowID; #endif #endif +#ifndef HAVE_TR1_TYPE_TRAITS + #if defined(__VISUALC__) && (_MSC_FULL_VER >= 150030729) + #define HAVE_TR1_TYPE_TRAITS + #endif +#endif + /* provide replacement for C99 va_copy() if the compiler doesn't have it */ /* could be already defined by configure or the user */ @@ -354,8 +397,64 @@ typedef int wxWindowID; #define wxVaCopy(d, s) ((d) = (s)) #endif #endif /* va_copy/!va_copy */ -#endif // wxVaCopy +#endif /* wxVaCopy */ + +#ifndef HAVE_VARIADIC_MACROS + #if wxCHECK_WATCOM_VERSION(1,2) + #define HAVE_VARIADIC_MACROS + #endif + + #if wxCHECK_VISUALC_VERSION(9) + #define HAVE_VARIADIC_MACROS + #endif +#endif /* HAVE_VARIADIC_MACROS */ + + +#ifndef HAVE_WOSTREAM + /* + Mingw <= 3.4 and all versions of Cygwin don't have std::wostream + */ + #if (defined(__MINGW32__) && !wxCHECK_GCC_VERSION(4, 0)) || \ + defined(__CYGWIN__) + #define wxNO_WOSTREAM + #endif + + /* VC++ doesn't have it in the old iostream library */ + #if defined(__VISUALC__) && wxUSE_IOSTREAMH + #define wxNO_WOSTREAM + #endif + + #ifndef wxNO_WOSTREAM + #define HAVE_WOSTREAM + #endif + + #undef wxNO_WOSTREAM +#endif /* HAVE_WOSTREAM */ +/* ---------------------------------------------------------------------------- */ +/* other C++ features */ +/* ---------------------------------------------------------------------------- */ + +#ifndef HAVE_PARTIAL_SPECIALIZATION + /* be optimistic by default */ + #define HAVE_PARTIAL_SPECIALIZATION +#endif + +#ifdef __VISUALC__ + #if __VISUALC__ < 1310 + #undef HAVE_PARTIAL_SPECIALIZATION + #endif +#endif /* __VISUALC__ */ + + +#ifndef HAVE_TEMPLATE_OVERLOAD_RESOLUTION + /* assume the compiler can use type or const expressions as template + arguments if it supports partial specialization -- except if it's a + Borland one which can't */ + #if defined(HAVE_PARTIAL_SPECIALIZATION) && !defined(__BORLANDC__) + #define HAVE_TEMPLATE_OVERLOAD_RESOLUTION + #endif /* (HAVE_PARTIAL_SPECIALIZATION) && !defined(__BORLANDC__) */ +#endif /* !defined(HAVE_TEMPLATE_OVERLOAD_RESOLUTION) */ /* ---------------------------------------------------------------------------- */ /* portable calling conventions macros */ @@ -375,7 +474,7 @@ typedef int wxWindowID; #define wxSTDCALL #endif /* platform */ -/* LINKAGEMODE mode is empty for everyting except OS/2 */ +/* LINKAGEMODE mode is empty for everything except OS/2 */ #ifndef LINKAGEMODE #define LINKAGEMODE #endif /* LINKAGEMODE */ @@ -413,84 +512,216 @@ typedef int wxWindowID; /* ---------------------------------------------------------------------------- */ /* Printf-like attribute definitions to obtain warnings with GNU C/C++ */ -#if defined(__GNUC__) && !wxUSE_UNICODE -# ifndef ATTRIBUTE_PRINTF -# define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n))) -# define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2) -# define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3) -# define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4) -# define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5) -# define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6) -# endif /* ATTRIBUTE_PRINTF */ -#else -# ifndef ATTRIBUTE_PRINTF -# define ATTRIBUTE_PRINTF -# define ATTRIBUTE_PRINTF_1 -# define ATTRIBUTE_PRINTF_2 -# define ATTRIBUTE_PRINTF_3 -# define ATTRIBUTE_PRINTF_4 -# define ATTRIBUTE_PRINTF_5 -# endif /* ATTRIBUTE_PRINTF */ +#ifndef WX_ATTRIBUTE_PRINTF +# if defined(__GNUC__) && !wxUSE_UNICODE +# define WX_ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n))) +# else +# define WX_ATTRIBUTE_PRINTF(m, n) +# endif + +# define WX_ATTRIBUTE_PRINTF_1 WX_ATTRIBUTE_PRINTF(1, 2) +# define WX_ATTRIBUTE_PRINTF_2 WX_ATTRIBUTE_PRINTF(2, 3) +# define WX_ATTRIBUTE_PRINTF_3 WX_ATTRIBUTE_PRINTF(3, 4) +# define WX_ATTRIBUTE_PRINTF_4 WX_ATTRIBUTE_PRINTF(4, 5) +# define WX_ATTRIBUTE_PRINTF_5 WX_ATTRIBUTE_PRINTF(5, 6) +#endif /* !defined(WX_ATTRIBUTE_PRINTF) */ + +#ifndef WX_ATTRIBUTE_NORETURN +# if WX_HAS_CLANG_FEATURE(attribute_analyzer_noreturn) +# define WX_ATTRIBUTE_NORETURN __attribute__((analyzer_noreturn)) +# elif defined( __GNUC__ ) +# define WX_ATTRIBUTE_NORETURN __attribute__ ((noreturn)) +# elif wxCHECK_VISUALC_VERSION(7) +# define WX_ATTRIBUTE_NORETURN __declspec(noreturn) +# else +# define WX_ATTRIBUTE_NORETURN +# endif #endif /* Macro to issue warning when using deprecated functions with gcc3 or MSVC7: */ #if wxCHECK_GCC_VERSION(3, 1) - #define wxDEPRECATED(x) x __attribute__ ((deprecated)) + #define wxDEPRECATED(x) __attribute__((deprecated)) x #elif defined(__VISUALC__) && (__VISUALC__ >= 1300) #define wxDEPRECATED(x) __declspec(deprecated) x #else #define wxDEPRECATED(x) x #endif -/* everybody gets the assert and other debug macros */ -#include "wx/debug.h" +#if defined(__GNUC__) && !wxCHECK_GCC_VERSION(3, 4) + /* + We need to add dummy "inline" to allow gcc < 3.4 to handle the + deprecation attribute on the constructors. + */ + #define wxDEPRECATED_CONSTRUCTOR(x) wxDEPRECATED( inline x) +#else + #define wxDEPRECATED_CONSTRUCTOR(x) wxDEPRECATED(x) +#endif + +/* + Macro which marks the function as being deprecated but also defines it + inline. + + Currently it's defined in the same trivial way in all cases but it could + need a special definition with some other compilers in the future which + explains why do we have it. + */ +#define wxDEPRECATED_INLINE(func, body) wxDEPRECATED(func) { body } + +/* + A macro to define a simple deprecated accessor. + */ +#define wxDEPRECATED_ACCESSOR(func, what) wxDEPRECATED_INLINE(func, return what;) + +/* + Special variant of the macro above which should be used for the functions + which are deprecated but called by wx itself: this often happens with + deprecated virtual functions which are called by the library. + */ +#ifdef WXBUILDING +# define wxDEPRECATED_BUT_USED_INTERNALLY(x) x +#else +# define wxDEPRECATED_BUT_USED_INTERNALLY(x) wxDEPRECATED(x) +#endif + +/* + Combination of the two variants above: should be used for deprecated + functions which are defined inline and are used by wxWidgets itself. + */ +#ifdef WXBUILDING +# define wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(func, body) func { body } +#else +# define wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(func, body) \ + wxDEPRECATED(func) { body } +#endif /* NULL declaration: it must be defined as 0 for C++ programs (in particular, */ /* it must not be defined as "(void *)0" which is standard for C but completely */ /* breaks C++ code) */ -#ifndef __HANDHELDPC__ +#if !defined(__HANDHELDPC__) #include #endif -/* delete pointer if it is not NULL and NULL it afterwards */ -/* (checking that it's !NULL before passing it to delete is just a */ -/* a question of style, because delete will do it itself anyhow, but it might */ -/* be considered as an error by some overzealous debugging implementations of */ -/* the library, so we do it ourselves) */ -#define wxDELETE(p) if ( (p) != NULL ) { delete p; p = NULL; } +#ifdef __cplusplus + +// everybody gets the assert and other debug macros +#include "wx/debug.h" -/* delete an array and NULL it (see comments above) */ -#define wxDELETEA(p) if ( (p) ) { delete [] (p); p = NULL; } + // delete pointer if it is not NULL and NULL it afterwards + template + inline void wxDELETE(T*& ptr) + { + typedef char TypeIsCompleteCheck[sizeof(T)]; + + if ( ptr != NULL ) + { + delete ptr; + ptr = NULL; + } + } + + // delete an array and NULL it (see comments above) + template + inline void wxDELETEA(T*& ptr) + { + typedef char TypeIsCompleteCheck[sizeof(T)]; + + if ( ptr != NULL ) + { + delete [] ptr; + ptr = NULL; + } + } + + // trivial implementation of std::swap() for primitive types + template + inline void wxSwap(T& first, T& second) + { + T tmp(first); + first = second; + second = tmp; + } +#endif /*__cplusplus*/ /* size of statically declared array */ #define WXSIZEOF(array) (sizeof(array)/sizeof(array[0])) -/* helper macros to concatenate two tokens together */ -#define wxCONCAT_HELPER(text, line) text ## line -#define wxCONCAT(text, line) wxCONCAT_HELPER(text, line) - -/* helper macros to be able to define unique/anonymous objects: this works by */ -/* appending the current line number to the given identifier to reduce the */ -/* probability of the conflict (it may still happen if this is used in the */ -/* headers, hence you should avoid doing it or provide unique prefixes then) */ -#if defined(__VISUALC__) && (__VISUALC__ >= 1300) - /* - __LINE__ handling is completely broken in VC++ when using "Edit and - Continue" (/ZI option) and results in preprocessor errors if we use it - inside the macros. Luckily VC7 has another standard macro which can be - used like this and is even better than __LINE__ because it is globally - unique. - */ -# define wxCONCAT_LINE(text) wxCONCAT(text, __COUNTER__) -#else /* normal compilers */ -# define wxCONCAT_LINE(text) wxCONCAT(text, __LINE__) -#endif -#define wxMAKE_UNIQUE_NAME(text) wxCONCAT_LINE(text) - /* symbolic constant used by all Find()-like functions returning positive */ /* integer on success as failure indicator */ #define wxNOT_FOUND (-1) +/* the default value for some length parameters meaning that the string is */ +/* NUL-terminated */ +#define wxNO_LEN ((size_t)-1) + +/* ---------------------------------------------------------------------------- */ +/* macros dealing with comparison operators */ +/* ---------------------------------------------------------------------------- */ + +/* + Expands into m(op, args...) for each op in the set { ==, !=, <, <=, >, >= }. + */ +#define wxFOR_ALL_COMPARISONS(m) \ + m(==) m(!=) m(>=) m(<=) m(>) m(<) + +#define wxFOR_ALL_COMPARISONS_1(m, x) \ + m(==,x) m(!=,x) m(>=,x) m(<=,x) m(>,x) m(<,x) + +#define wxFOR_ALL_COMPARISONS_2(m, x, y) \ + m(==,x,y) m(!=,x,y) m(>=,x,y) m(<=,x,y) m(>,x,y) m(<,x,y) + +#define wxFOR_ALL_COMPARISONS_3(m, x, y, z) \ + m(==,x,y,z) m(!=,x,y,z) m(>=,x,y,z) m(<=,x,y,z) m(>,x,y,z) m(<,x,y,z) + +/* + These are only used with wxDEFINE_COMPARISON_[BY_]REV: they pass both the + normal and the reversed comparison operators to the macro. + */ +#define wxFOR_ALL_COMPARISONS_2_REV(m, x, y) \ + m(==,x,y,==) m(!=,x,y,!=) m(>=,x,y,<=) \ + m(<=,x,y,>=) m(>,x,y,<) m(<,x,y,>) + +#define wxFOR_ALL_COMPARISONS_3_REV(m, x, y, z) \ + m(==,x,y,z,==) m(!=,x,y,z,!=) m(>=,x,y,z,<=) \ + m(<=,x,y,z,>=) m(>,x,y,z,<) m(<,x,y,z,>) + + +#define wxDEFINE_COMPARISON(op, T1, T2, cmp) \ + inline bool operator op(T1 x, T2 y) { return cmp(x, y, op); } + +#define wxDEFINE_COMPARISON_REV(op, T1, T2, cmp, oprev) \ + inline bool operator op(T2 y, T1 x) { return cmp(x, y, oprev); } + +#define wxDEFINE_COMPARISON_BY_REV(op, T1, T2, oprev) \ + inline bool operator op(T1 x, T2 y) { return y oprev x; } + +/* + Define all 6 comparison operators (==, !=, <, <=, >, >=) for the given + types in the specified order. The implementation is provided by the cmp + macro. Normally wxDEFINE_ALL_COMPARISONS should be used as comparison + operators are usually symmetric. + */ +#define wxDEFINE_COMPARISONS(T1, T2, cmp) \ + wxFOR_ALL_COMPARISONS_3(wxDEFINE_COMPARISON, T1, T2, cmp) + +/* + Define all 6 comparison operators (==, !=, <, <=, >, >=) for the given + types in the specified order, implemented in terms of existing operators + for the reverse order. + */ +#define wxDEFINE_COMPARISONS_BY_REV(T1, T2) \ + wxFOR_ALL_COMPARISONS_2_REV(wxDEFINE_COMPARISON_BY_REV, T1, T2) + +/* + This macro allows to define all 12 comparison operators (6 operators for + both orders of arguments) for the given types using the provided "cmp" + macro to implement the actual comparison: the macro is called with the 2 + arguments names, the first of type T1 and the second of type T2, and the + comparison operator being implemented. + */ +#define wxDEFINE_ALL_COMPARISONS(T1, T2, cmp) \ + wxFOR_ALL_COMPARISONS_3(wxDEFINE_COMPARISON, T1, T2, cmp) \ + wxFOR_ALL_COMPARISONS_3_REV(wxDEFINE_COMPARISON_REV, T1, T2, cmp) + /* ---------------------------------------------------------------------------- */ /* macros to avoid compiler warnings */ /* ---------------------------------------------------------------------------- */ @@ -502,11 +733,25 @@ typedef int wxWindowID; #define WXUNUSED(identifier) identifier #endif -/* some arguments are only used in debug mode, but unused in release one */ -#ifdef __WXDEBUG__ - #define WXUNUSED_UNLESS_DEBUG(param) param +/* some arguments are not used in unicode mode */ +#if wxUSE_UNICODE + #define WXUNUSED_IN_UNICODE(param) WXUNUSED(param) #else - #define WXUNUSED_UNLESS_DEBUG(param) WXUNUSED(param) + #define WXUNUSED_IN_UNICODE(param) param +#endif + +/* some arguments are not used in WinCE build */ +#ifdef __WXWINCE__ + #define WXUNUSED_IN_WINCE(param) WXUNUSED(param) +#else + #define WXUNUSED_IN_WINCE(param) param +#endif + +/* unused parameters in non stream builds */ +#if wxUSE_STREAMS + #define WXUNUSED_UNLESS_STREAMS(param) param +#else + #define WXUNUSED_UNLESS_STREAMS(param) WXUNUSED(param) #endif /* some compilers give warning about a possibly unused variable if it is */ @@ -534,94 +779,25 @@ typedef int wxWindowID; /* compiler specific settings */ /* ---------------------------------------------------------------------------- */ -/* to allow compiling with warning level 4 under Microsoft Visual C++ some */ -/* warnings just must be disabled */ -#ifdef __VISUALC__ - #pragma warning(disable: 4514) /* unreferenced inline func has been removed */ -/* - you might be tempted to disable this one also: triggered by CHECK and FAIL - macros in debug.h, but it's, overall, a rather useful one, so I leave it and - will try to find some way to disable this warning just for CHECK/FAIL. Anyone? -*/ - #pragma warning(disable: 4127) /* conditional expression is constant */ -#endif /* VC++ */ - -#if defined(__MWERKS__) - #undef try - #undef except - #undef finally - #define except(x) catch(...) -#endif /* Metrowerks */ - -#if defined(__WATCOMC__) +#if wxONLY_WATCOM_EARLIER_THAN(1,4) typedef short mode_t; #endif /* where should i put this? we need to make sure of this as it breaks */ /* the code. */ #if !wxUSE_IOSTREAMH && defined(__WXDEBUG__) -# ifndef __MWERKS__ -/* #undef __WXDEBUG__ */ # ifdef wxUSE_DEBUG_NEW_ALWAYS # undef wxUSE_DEBUG_NEW_ALWAYS # define wxUSE_DEBUG_NEW_ALWAYS 0 # endif -# endif #endif -/* ---------------------------------------------------------------------------- */ -/* OS mnemonics -- Identify the running OS (useful for Windows) */ -/* ---------------------------------------------------------------------------- */ - -/* Not all platforms are currently available or supported */ -enum -{ - wxUNKNOWN_PLATFORM, - wxCURSES, /* Text-only CURSES */ - wxXVIEW_X, /* Sun's XView OpenLOOK toolkit */ - wxMOTIF_X, /* OSF Motif 1.x.x */ - wxCOSE_X, /* OSF Common Desktop Environment */ - wxNEXTSTEP, /* NeXTStep */ - wxMAC, /* Apple Mac OS 8/9/X with Mac paths */ - wxMAC_DARWIN, /* Apple Mac OS X with Unix paths */ - wxBEOS, /* BeOS */ - wxGTK, /* GTK on X */ - wxGTK_WIN32, /* GTK on Win32 */ - wxGTK_OS2, /* GTK on OS/2 */ - wxGTK_BEOS, /* GTK on BeOS */ - wxGEOS, /* GEOS */ - wxOS2_PM, /* OS/2 Workplace */ - wxWINDOWS, /* Windows or WfW */ - wxMICROWINDOWS, /* MicroWindows */ - wxPENWINDOWS, /* Windows for Pen Computing */ - wxWINDOWS_NT, /* Windows NT */ - wxWIN32S, /* Windows 32S API */ - wxWIN95, /* Windows 95 */ - wxWIN386, /* Watcom 32-bit supervisor modus */ - wxWINDOWS_CE, /* Windows CE */ - wxMGL_UNIX, /* MGL with direct hardware access */ - wxMGL_X, /* MGL on X */ - wxMGL_WIN32, /* MGL on Win32 */ - wxMGL_OS2, /* MGL on OS/2 */ - wxMGL_DOS, /* MGL on MS-DOS */ - wxWINDOWS_OS2, /* Native OS/2 PM */ - wxUNIX, /* wxBase under Unix */ - wxX11 /* Plain X11 and Universal widgets */ -}; - /* ---------------------------------------------------------------------------- */ /* standard wxWidgets types */ /* ---------------------------------------------------------------------------- */ /* the type for screen and DC coordinates */ - -#if wxUSE_COMPATIBLE_COORD_TYPES - /* to ensure compatibility with 2.0, we must use long */ - #define wxCoord long -#else /* !wxUSE_COMPATIBLE_COORD_TYPES */ - /* other platforms we support have at least 32bit int - quite enough */ - typedef int wxCoord; -#endif /* wxUSE_COMPATIBLE_COORD_TYPES/!wxUSE_COMPATIBLE_COORD_TYPES */ +typedef int wxCoord; enum { wxDefaultCoord = -1 }; @@ -629,13 +805,14 @@ enum { wxDefaultCoord = -1 }; /* define fixed length types */ /* ---------------------------------------------------------------------------- */ +#if defined(__MINGW32__) + #include +#endif + /* chars are always one byte (by definition), shorts are always two (in */ /* practice) */ /* 8bit */ -#ifndef SIZEOF_CHAR - #define SIZEOF_CHAR 1 -#endif typedef signed char wxInt8; typedef unsigned char wxUint8; typedef wxUint8 wxByte; @@ -667,7 +844,7 @@ typedef wxUint16 wxWord; |short | 16 16 16 16 16 | |int | 32 64 32 32 16 | |long | 64 64 32 32 32 | - |long long | 64 | + |long long | 64 64 64 -- -- | |void * | 64 64 64 32 32 | +-----------+----------------------------+ @@ -678,22 +855,31 @@ typedef wxUint16 wxWord; */ /* 32bit */ -#ifdef __WINDOWS__ - /* Win64 uses LLP64 model and so ints and longs have the same size as in */ - /* Win32 */ +#if defined(__WINDOWS__) #if defined(__WIN32__) typedef int wxInt32; typedef unsigned int wxUint32; - /* Assume that if SIZEOF_INT is defined that all the other ones except - SIZEOF_SIZE_T, are too. See next #if below. */ + /* + Win64 uses LLP64 model and so ints and longs have the same size as + in Win32. + */ #ifndef SIZEOF_INT #define SIZEOF_INT 4 + #endif + + #ifndef SIZEOF_LONG #define SIZEOF_LONG 4 + #endif + + #ifndef SIZEOF_WCHAR_T + /* Windows uses UTF-16 */ #define SIZEOF_WCHAR_T 2 + #endif + #ifndef SIZEOF_SIZE_T /* - under Win64 sizeof(size_t) == 8 and so it is neither unsigned + Under Win64 sizeof(size_t) == 8 and so it is neither unsigned int nor unsigned long! */ #ifdef __WIN64__ @@ -706,25 +892,14 @@ typedef wxUint16 wxWord; #define wxSIZE_T_IS_UINT #endif #undef wxSIZE_T_IS_ULONG + #endif + #ifndef SIZEOF_VOID_P #ifdef __WIN64__ #define SIZEOF_VOID_P 8 #else /* Win32 */ #define SIZEOF_VOID_P 4 #endif /* Win64/32 */ - #endif /* !defined(SIZEOF_INT) */ - - /* - If Python.h was included first, it defines all of the SIZEOF's above - except for SIZEOF_SIZE_T, so we need to do it here to avoid - triggering the #error in the ssize_t typedefs below... - */ - #ifndef SIZEOF_SIZE_T - #ifdef __WIN64__ - #define SIZEOF_SIZE_T 8 - #else /* Win32 */ - #define SIZEOF_SIZE_T 4 - #endif #endif #else #error "Unsupported Windows version" @@ -747,7 +922,7 @@ typedef wxUint16 wxWord; typedef long wxInt32; typedef unsigned long wxUint32; - #elif + #else /* wxWidgets is not ready for 128bit systems yet... */ #error "Unknown sizeof(int) value, what are you compiling for?" #endif @@ -767,7 +942,7 @@ typedef wxUint16 wxWord; #if defined(__MACH__) && !defined(SIZEOF_WCHAR_T) #define SIZEOF_WCHAR_T 4 #endif - #if wxUSE_WCHAR_T && !defined(SIZEOF_WCHAR_T) + #if !defined(SIZEOF_WCHAR_T) /* also assume that sizeof(wchar_t) == 2 (under Unix the most */ /* common case is 4 but there configure would have defined */ /* SIZEOF_WCHAR_T for us) */ @@ -776,186 +951,340 @@ typedef wxUint16 wxWord; Wchar_tMustBeExactly2Bytes); #define SIZEOF_WCHAR_T 2 - #endif /* wxUSE_WCHAR_T */ + #endif /* !defined(SIZEOF_WCHAR_T) */ #endif #endif /* Win/!Win */ -typedef wxUint32 wxDword; - -/* - Define an integral type big enough to contain all of long, size_t and void *. - */ -#if SIZEOF_LONG >= SIZEOF_VOID_P && SIZEOF_LONG >= SIZEOF_SIZE_T - /* normal case */ - typedef unsigned long wxUIntPtr; -#elif SIZEOF_SIZE_T >= SIZEOF_VOID_P - /* Win64 case */ - typedef size_t wxUIntPtr; -#else - /* - This should never happen for the current architectures but if you're - using one where it does, please contact wx-dev@lists.wxwidgets.org. - */ - #error "Pointers can't be stored inside integer types." -#endif - -#ifdef __cplusplus -/* And also define a couple of simple functions to cast pointer to/from it. */ -inline wxUIntPtr wxPtrToUInt(const void *p) -{ - /* - VC++ 7.1 gives warnings about casts such as below even when they're - explicit with /Wp64 option, suppress them as we really know what we're - doing here - */ -#ifdef __VISUALC__ - #pragma warning(disable: 4311) /* pointer truncation from '' to '' */ +#ifndef SIZEOF_WCHAR_T + #error "SIZEOF_WCHAR_T must be defined, but isn't" #endif - return wx_reinterpret_cast(wxUIntPtr, p); +/* also define C99-like sized MIN/MAX constants */ +#define wxINT8_MIN CHAR_MIN +#define wxINT8_MAX CHAR_MAX +#define wxUINT8_MAX UCHAR_MAX -#ifdef __VISUALC__ - #pragma warning(default: 4311) -#endif -} +#define wxINT16_MIN SHRT_MIN +#define wxINT16_MAX SHRT_MAX +#define wxUINT16_MAX USHRT_MAX -inline void *wxUIntToPtr(wxUIntPtr p) -{ -#ifdef __VISUALC__ - #pragma warning(disable: 4312) /* conversion to type of greater size */ +#if SIZEOF_INT == 4 + #define wxINT32_MIN INT_MIN + #define wxINT32_MAX INT_MAX + #define wxUINT32_MAX UINT_MAX +#elif SIZEOF_LONG == 4 + #define wxINT32_MIN LONG_MIN + #define wxINT32_MAX LONG_MAX + #define wxUINT32_MAX ULONG_MAX +#else + #error "Unknown 32 bit type" #endif - return wx_reinterpret_cast(void *, p); +typedef wxUint32 wxDword; -#ifdef __VISUALC__ - #pragma warning(default: 4312) +#ifdef LLONG_MAX + #define wxINT64_MIN LLONG_MIN + #define wxINT64_MAX LLONG_MAX + #define wxUINT64_MAX ULLONG_MAX +#else + #define wxINT64_MIN (wxLL(-9223372036854775807)-1) + #define wxINT64_MAX wxLL(9223372036854775807) + #define wxUINT64_MAX wxULL(0xFFFFFFFFFFFFFFFF) #endif -} -#endif /*__cplusplus*/ - /* 64 bit */ -/* NB: we #define and not typedef wxLongLong_t because we want to be able to */ -/* use 'unsigned wxLongLong_t' as well and because we use "#ifdef */ +/* NB: we #define and not typedef wxLongLong_t because we use "#ifdef */ /* wxLongLong_t" in wx/longlong.h */ +/* wxULongLong_t is set later (usually to unsigned wxLongLong_t) */ + /* to avoid compilation problems on 64bit machines with ambiguous method calls */ /* we will need to define this */ #undef wxLongLongIsLong -/* first check for generic cases which are long on 64bit machine and "long */ -/* long", then check for specific compilers */ -#if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8) - #define wxLongLong_t long - #define wxLongLongSuffix l - #define wxLongLongFmtSpec _T("l") - #define wxLongLongIsLong -#elif (defined(__VISUALC__) && defined(__WIN32__)) +/* + First check for specific compilers which have known 64 bit integer types, + this avoids clashes with SIZEOF_LONG[_LONG] being defined incorrectly for + e.g. MSVC builds (Python.h defines it as 8 even for MSVC). + + Also notice that we check for "long long" before checking for 64 bit long as + we still want to use "long long" and not "long" for wxLongLong_t on 64 bit + architectures to be able to pass wxLongLong_t to the standard functions + prototyped as taking "long long" such as strtoll(). + */ +#if (defined(__VISUALC__) && defined(__WIN32__)) #define wxLongLong_t __int64 #define wxLongLongSuffix i64 - #define wxLongLongFmtSpec _T("I64") + #define wxLongLongFmtSpec "I64" #elif defined(__BORLANDC__) && defined(__WIN32__) && (__BORLANDC__ >= 0x520) #define wxLongLong_t __int64 #define wxLongLongSuffix i64 - #define wxLongLongFmtSpec _T("Ld") -#elif (defined(__WATCOMC__) && (defined(__WIN32__) || defined(__DOS__))) + #define wxLongLongFmtSpec "L" +#elif (defined(__WATCOMC__) && (defined(__WIN32__) || defined(__DOS__) || defined(__OS2__))) #define wxLongLong_t __int64 #define wxLongLongSuffix i64 - #define wxLongLongFmtSpec _T("Ld") + #define wxLongLongFmtSpec "L" #elif defined(__DIGITALMARS__) #define wxLongLong_t __int64 #define wxLongLongSuffix LL - #define wxLongLongFmtSpec _T("ll") + #define wxLongLongFmtSpec "ll" +#elif defined(__MINGW32__) + #define wxLongLong_t long long + #define wxLongLongSuffix ll + #define wxLongLongFmtSpec "I64" +#elif defined(__VISAGECPP__) && __IBMCPP__ >= 400 + #define wxLongLong_t long long #elif (defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8) || \ - defined(__MINGW32__) || \ defined(__GNUC__) || \ defined(__CYGWIN__) || \ defined(__WXMICROWIN__) || \ (defined(__DJGPP__) && __DJGPP__ >= 2) #define wxLongLong_t long long #define wxLongLongSuffix ll - #define wxLongLongFmtSpec _T("ll") -#elif defined(__MWERKS__) - #if __option(longlong) - #define wxLongLong_t long long - #define wxLongLongSuffix ll - #define wxLongLongFmtSpec _T("ll") - #else - #error "The 64 bit integer support in CodeWarrior has been disabled." - #error "See the documentation on the 'longlong' pragma." - #endif -#elif defined(__VISAGECPP__) && __IBMCPP__ >= 400 - #define wxLongLong_t long long + #define wxLongLongFmtSpec "ll" +#elif defined(SIZEOF_LONG) && (SIZEOF_LONG == 8) + #define wxLongLong_t long + #define wxLongLongSuffix l + #define wxLongLongFmtSpec "l" + #define wxLongLongIsLong #endif #ifdef wxLongLong_t - /* these macros allow to definea 64 bit constants in a portable way */ - #define wxLL(x) wxCONCAT(x, wxLongLongSuffix) - #define wxULL(x) wxCONCAT(x, wxCONCAT(u, wxLongLongSuffix)) + #define wxULongLong_t unsigned wxLongLong_t + + /* + wxLL() and wxULL() macros allow to define 64 bit constants in a + portable way. + */ + #ifndef wxCOMPILER_BROKEN_CONCAT_OPER + #define wxLL(x) wxCONCAT(x, wxLongLongSuffix) + #define wxULL(x) wxCONCAT(x, wxCONCAT(u, wxLongLongSuffix)) + #else + /* + Currently only Borland compiler has broken concatenation operator + and this compiler is known to use [u]i64 suffix. + */ + #define wxLL(x) wxAPPEND_i64(x) + #define wxULL(x) wxAPPEND_ui64(x) + #endif typedef wxLongLong_t wxInt64; - typedef unsigned wxLongLong_t wxUint64; + typedef wxULongLong_t wxUint64; + + #define wxHAS_INT64 1 + + #ifndef wxLongLongIsLong + #define wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG + #endif +#elif wxUSE_LONGLONG + /* these macros allow to define 64 bit constants in a portable way */ + #define wxLL(x) wxLongLong(x) + #define wxULL(x) wxULongLong(x) + + #define wxInt64 wxLongLong + #define wxUint64 wxULongLong + + #define wxHAS_INT64 1 + +#else /* !wxUSE_LONGLONG */ + + #define wxHAS_INT64 0 + #endif -/* Make sure ssize_t is defined (a signed type the same size as size_t) */ -/* HAVE_SSIZE_T should be defined for compiliers that already have it */ +/* Make sure ssize_t is defined (a signed type the same size as size_t). */ +/* (HAVE_SSIZE_T is not already defined by configure) */ +#ifndef HAVE_SSIZE_T #ifdef __MINGW32__ - #include - #if defined(_SSIZE_T_) && !defined(HAVE_SSIZE_T) + #if defined(_SSIZE_T_) || defined(_SSIZE_T_DEFINED) #define HAVE_SSIZE_T #endif +#elif wxCHECK_WATCOM_VERSION(1,4) + #define HAVE_SSIZE_T #endif -#ifndef HAVE_SSIZE_T +#endif /* !HAVE_SSIZE_T */ + +/* If we really don't have ssize_t, provide our own version. */ +#ifdef HAVE_SSIZE_T + #ifdef __UNIX__ + #include + #endif +#else /* !HAVE_SSIZE_T */ #if SIZEOF_SIZE_T == 4 typedef wxInt32 ssize_t; #elif SIZEOF_SIZE_T == 8 - typedef wxInt64 ssize_t + typedef wxInt64 ssize_t; #else #error "error defining ssize_t, size_t is not 4 or 8 bytes" #endif + + /* prevent ssize_t redefinitions in other libraries */ + #define HAVE_SSIZE_T #endif +/* + We can't rely on Windows _W64 being defined as windows.h may not be + included so define our own equivalent: this should be used with types + like WXLPARAM or WXWPARAM which are 64 bit under Win64 to avoid warnings + each time we cast it to a pointer or a handle (which results in hundreds + of warnings as Win32 API often passes pointers in them) + */ +#if wxCHECK_VISUALC_VERSION(7) + #define wxW64 __w64 +#else + #define wxW64 +#endif + +/* + Define signed and unsigned integral types big enough to contain all of long, + size_t and void *. + */ +#if SIZEOF_LONG >= SIZEOF_VOID_P + /* + Normal case when long is the largest integral type. + */ + typedef long wxIntPtr; + typedef unsigned long wxUIntPtr; +#elif SIZEOF_SIZE_T >= SIZEOF_VOID_P + /* + Win64 case: size_t is the only integral type big enough for "void *". + + Notice that we must use __w64 to avoid warnings about casting pointers + to wxIntPtr (which we do often as this is what it is defined for) in 32 + bit build with MSVC. + */ + typedef wxW64 ssize_t wxIntPtr; + typedef size_t wxUIntPtr; +#else + /* + This should never happen for the current architectures but if you're + using one where it does, please contact wx-dev@lists.wxwidgets.org. + */ + #error "Pointers can't be stored inside integer types." +#endif + +#ifdef __cplusplus +/* And also define a couple of simple functions to cast pointer to/from it. */ +inline wxUIntPtr wxPtrToUInt(const void *p) +{ + /* + VC++ 7.1 gives warnings about casts such as below even when they're + explicit with /Wp64 option, suppress them as we really know what we're + doing here. Same thing with icc with -Wall. + */ +#ifdef __VISUALC__ + #if __VISUALC__ >= 1200 + #pragma warning(push) + #endif + /* pointer truncation from '' to '' */ + #pragma warning(disable: 4311) +#elif defined(__INTELC__) + #pragma warning(push) + /* conversion from pointer to same-sized integral type */ + #pragma warning(disable: 1684) +#endif + + return wx_reinterpret_cast(wxUIntPtr, p); + +#if (defined(__VISUALC__) && __VISUALC__ >= 1200) || defined(__INTELC__) + #pragma warning(pop) +#endif +} + +inline void *wxUIntToPtr(wxUIntPtr p) +{ +#ifdef __VISUALC__ + #if __VISUALC__ >= 1200 + #pragma warning(push) + #endif + /* conversion to type of greater size */ + #pragma warning(disable: 4312) +#elif defined(__INTELC__) + #pragma warning(push) + /* invalid type conversion: "wxUIntPtr={unsigned long}" to "void *" */ + #pragma warning(disable: 171) +#endif + + return wx_reinterpret_cast(void *, p); + +#if (defined(__VISUALC__) && __VISUALC__ >= 1200) || defined(__INTELC__) + #pragma warning(pop) +#endif +} +#endif /*__cplusplus*/ + + /* base floating point types */ -/* wxFloat32: 32 bit IEEE float ( 1 sign, 8 exponent bits, 23 fraction bits */ -/* wxFloat64: 64 bit IEEE float ( 1 sign, 11 exponent bits, 52 fraction bits */ +/* wxFloat32: 32 bit IEEE float ( 1 sign, 8 exponent bits, 23 fraction bits ) */ +/* wxFloat64: 64 bit IEEE float ( 1 sign, 11 exponent bits, 52 fraction bits ) */ /* wxDouble: native fastest representation that has at least wxFloat64 */ /* precision, so use the IEEE types for storage, and this for */ /* calculations */ typedef float wxFloat32; -#if (defined( __WXMAC__ ) || defined(__WXCOCOA__)) && defined (__MWERKS__) - typedef short double wxFloat64; -#else - typedef double wxFloat64; -#endif +typedef double wxFloat64; -#if defined( __WXMAC__ ) && !defined( __POWERPC__ ) - typedef long double wxDouble; -#else - typedef double wxDouble; -#endif +typedef double wxDouble; /* Some (non standard) compilers typedef wchar_t as an existing type instead of treating it as a real fundamental type, set wxWCHAR_T_IS_REAL_TYPE to 0 for them and to 1 for all the others. */ -#if wxUSE_WCHAR_T +#ifndef wxWCHAR_T_IS_REAL_TYPE /* - VC++ typedefs wchar_t as unsigned short by default, that is unless - /Za or /Zc:wchar_t option is used in which case _WCHAR_T_DEFINED is - defined. + VC++ typedefs wchar_t as unsigned short by default until VC8, that is + unless /Za or /Zc:wchar_t option is used in which case _WCHAR_T_DEFINED + is defined. */ # if defined(__VISUALC__) && !defined(_NATIVE_WCHAR_T_DEFINED) # define wxWCHAR_T_IS_REAL_TYPE 0 # else /* compiler having standard-conforming wchar_t */ # define wxWCHAR_T_IS_REAL_TYPE 1 # endif -#endif /* wxUSE_WCHAR_T */ +#endif /* !defined(wxWCHAR_T_IS_REAL_TYPE) */ + +/* Helper macro for doing something dependent on whether wchar_t is or isn't a + typedef inside another macro. */ +#if wxWCHAR_T_IS_REAL_TYPE + #define wxIF_WCHAR_T_TYPE(x) x +#else /* !wxWCHAR_T_IS_REAL_TYPE */ + #define wxIF_WCHAR_T_TYPE(x) +#endif /* wxWCHAR_T_IS_REAL_TYPE/!wxWCHAR_T_IS_REAL_TYPE */ + +/* + This constant should be used instead of NULL in vararg functions taking + wxChar* arguments: passing NULL (which is the same as 0, unless the compiler + defines it specially, e.g. like gcc does with its __null built-in) doesn't + work in this case as va_arg() wouldn't interpret the integer 0 correctly + when trying to convert it to a pointer on architectures where sizeof(int) is + strictly less than sizeof(void *). + + Examples of places where this must be used include wxFileTypeInfo ctor. + */ +#define wxNullPtr ((void *)NULL) + + +/* Define wxChar16 and wxChar32 */ + +#if SIZEOF_WCHAR_T == 2 + #define wxWCHAR_T_IS_WXCHAR16 + typedef wchar_t wxChar16; +#else + typedef wxUint16 wxChar16; +#endif + +#if SIZEOF_WCHAR_T == 4 + #define wxWCHAR_T_IS_WXCHAR32 + typedef wchar_t wxChar32; +#else + typedef wxUint32 wxChar32; +#endif + /* ---------------------------------------------------------------------------- */ /* byte ordering related definition and macros */ @@ -975,36 +1304,6 @@ typedef float wxFloat32; /* byte swapping */ -#if defined (__MWERKS__) && ( (__MWERKS__ < 0x0900) || macintosh ) -/* assembler versions for these */ -#ifdef __POWERPC__ - inline wxUint16 wxUINT16_SWAP_ALWAYS( wxUint16 i ) - {return (__lhbrx( &i , 0 ) );} - inline wxInt16 wxINT16_SWAP_ALWAYS( wxInt16 i ) - {return (__lhbrx( &i , 0 ) );} - inline wxUint32 wxUINT32_SWAP_ALWAYS( wxUint32 i ) - {return (__lwbrx( &i , 0 ) );} - inline wxInt32 wxINT32_SWAP_ALWAYS( wxInt32 i ) - {return (__lwbrx( &i , 0 ) );} -#else - #pragma parameter __D0 wxUINT16_SWAP_ALWAYS(__D0) - pascal wxUint16 wxUINT16_SWAP_ALWAYS(wxUint16 value) - = { 0xE158 }; - - #pragma parameter __D0 wxINT16_SWAP_ALWAYS(__D0) - pascal wxInt16 wxINT16_SWAP_ALWAYS(wxInt16 value) - = { 0xE158 }; - - #pragma parameter __D0 wxUINT32_SWAP_ALWAYS (__D0) - pascal wxUint32 wxUINT32_SWAP_ALWAYS(wxUint32 value) - = { 0xE158, 0x4840, 0xE158 }; - - #pragma parameter __D0 wxINT32_SWAP_ALWAYS (__D0) - pascal wxInt32 wxINT32_SWAP_ALWAYS(wxInt32 value) - = { 0xE158, 0x4840, 0xE158 }; - -#endif -#else /* !MWERKS */ #define wxUINT16_SWAP_ALWAYS(val) \ ((wxUint16) ( \ (((wxUint16) (val) & (wxUint16) 0x00ffU) << 8) | \ @@ -1028,7 +1327,6 @@ typedef float wxFloat32; (((wxUint32) (val) & (wxUint32) 0x0000ff00U) << 8) | \ (((wxUint32) (val) & (wxUint32) 0x00ff0000U) >> 8) | \ (((wxUint32) (val) & (wxUint32) 0xff000000U) >> 24))) -#endif /* machine specific byte swapping */ #ifdef wxLongLong_t @@ -1053,7 +1351,7 @@ typedef float wxFloat32; (((wxUint64) (val) & (wxUint64) wxULL(0x0000ff0000000000)) >> 24) | \ (((wxUint64) (val) & (wxUint64) wxULL(0x00ff000000000000)) >> 40) | \ (((wxUint64) (val) & (wxUint64) wxULL(0xff00000000000000)) >> 56))) -#else /* !wxLongLong_t */ +#elif wxUSE_LONGLONG /* !wxLongLong_t */ #define wxUINT64_SWAP_ALWAYS(val) \ ((wxUint64) ( \ ((wxULongLong(val) & wxULongLong(0L, 0x000000ffU)) << 56) | \ @@ -1086,19 +1384,66 @@ typedef float wxFloat32; #define wxINT32_SWAP_ON_BE(val) wxINT32_SWAP_ALWAYS(val) #define wxUINT32_SWAP_ON_LE(val) (val) #define wxINT32_SWAP_ON_LE(val) (val) - #define wxUINT64_SWAP_ON_BE(val) wxUINT64_SWAP_ALWAYS(val) - #define wxUINT64_SWAP_ON_LE(val) (val) + #if wxHAS_INT64 + #define wxUINT64_SWAP_ON_BE(val) wxUINT64_SWAP_ALWAYS(val) + #define wxUINT64_SWAP_ON_LE(val) (val) + #define wxINT64_SWAP_ON_BE(val) wxINT64_SWAP_ALWAYS(val) + #define wxINT64_SWAP_ON_LE(val) (val) + #endif +#else + #define wxUINT16_SWAP_ON_LE(val) wxUINT16_SWAP_ALWAYS(val) + #define wxINT16_SWAP_ON_LE(val) wxINT16_SWAP_ALWAYS(val) + #define wxUINT16_SWAP_ON_BE(val) (val) + #define wxINT16_SWAP_ON_BE(val) (val) + #define wxUINT32_SWAP_ON_LE(val) wxUINT32_SWAP_ALWAYS(val) + #define wxINT32_SWAP_ON_LE(val) wxINT32_SWAP_ALWAYS(val) + #define wxUINT32_SWAP_ON_BE(val) (val) + #define wxINT32_SWAP_ON_BE(val) (val) + #if wxHAS_INT64 + #define wxUINT64_SWAP_ON_LE(val) wxUINT64_SWAP_ALWAYS(val) + #define wxUINT64_SWAP_ON_BE(val) (val) + #define wxINT64_SWAP_ON_LE(val) wxINT64_SWAP_ALWAYS(val) + #define wxINT64_SWAP_ON_BE(val) (val) + #endif +#endif + +/* ---------------------------------------------------------------------------- */ +/* template workarounds for buggy compilers */ +/* ---------------------------------------------------------------------------- */ + +#if defined(__GNUC__) && !wxCHECK_GCC_VERSION( 3, 4 ) + /* GCC <= 3.4 has buggy template support */ +# define wxUSE_MEMBER_TEMPLATES 0 +#endif + +#if defined(_MSC_VER) && _MSC_VER <= 1200 + /* MSVC <= 6.0 has buggy template support */ +# define wxUSE_MEMBER_TEMPLATES 0 +# define wxUSE_FUNC_TEMPLATE_POINTER 0 +#endif + +#ifndef wxUSE_MEMBER_TEMPLATES +# define wxUSE_MEMBER_TEMPLATES 1 +#endif + +#ifndef wxUSE_FUNC_TEMPLATE_POINTER +# define wxUSE_FUNC_TEMPLATE_POINTER 1 +#endif + +#if wxUSE_MEMBER_TEMPLATES +# define wxTEMPLATED_MEMBER_CALL( method, type ) method() +# define wxTEMPLATED_MEMBER_FIX( type ) +#else +# define wxTEMPLATED_MEMBER_CALL( method, type ) method((type*)NULL) +# define wxTEMPLATED_MEMBER_FIX( type ) type* =NULL +#endif + +#if defined(_MSC_VER) && _MSC_VER <= 1200 +# define wxTEMPLATED_FUNCTION_FIX( type ), wxTEMPLATED_MEMBER_FIX(type) +# define wxINFUNC_CLASS_TYPE_FIX( type ) typedef type type; #else - #define wxUINT16_SWAP_ON_LE(val) wxUINT16_SWAP_ALWAYS(val) - #define wxINT16_SWAP_ON_LE(val) wxINT16_SWAP_ALWAYS(val) - #define wxUINT16_SWAP_ON_BE(val) (val) - #define wxINT16_SWAP_ON_BE(val) (val) - #define wxUINT32_SWAP_ON_LE(val) wxUINT32_SWAP_ALWAYS(val) - #define wxINT32_SWAP_ON_LE(val) wxINT32_SWAP_ALWAYS(val) - #define wxUINT32_SWAP_ON_BE(val) (val) - #define wxINT32_SWAP_ON_BE(val) (val) - #define wxUINT64_SWAP_ON_LE(val) wxUINT64_SWAP_ALWAYS(val) - #define wxUINT64_SWAP_ON_BE(val) (val) +# define wxTEMPLATED_FUNCTION_FIX( type ) +# define wxINFUNC_CLASS_TYPE_FIX( type ) #endif /* ---------------------------------------------------------------------------- */ @@ -1119,10 +1464,14 @@ enum wxGeometryCentre enum wxOrientation { + /* don't change the values of these elements, they are used elsewhere */ wxHORIZONTAL = 0x0004, wxVERTICAL = 0x0008, - wxBOTH = (wxVERTICAL | wxHORIZONTAL) + wxBOTH = wxVERTICAL | wxHORIZONTAL, + + /* a mask to extract orientation from the combination of flags */ + wxORIENTATION_MASK = wxBOTH }; enum wxDirection @@ -1140,11 +1489,21 @@ enum wxDirection wxWEST = wxLEFT, wxEAST = wxRIGHT, - wxALL = (wxUP | wxDOWN | wxRIGHT | wxLEFT) + wxALL = (wxUP | wxDOWN | wxRIGHT | wxLEFT), + + /* a mask to extract direction from the combination of flags */ + wxDIRECTION_MASK = wxALL }; enum wxAlignment { + /* + 0 is a valid wxAlignment value (both wxALIGN_LEFT and wxALIGN_TOP + use it) so define a symbolic name for an invalid alignment value + which can be assumed to be different from anything else + */ + wxALIGN_INVALID = -1, + wxALIGN_NOT = 0x0000, wxALIGN_CENTER_HORIZONTAL = 0x0100, wxALIGN_CENTRE_HORIZONTAL = wxALIGN_CENTER_HORIZONTAL, @@ -1162,6 +1521,25 @@ enum wxAlignment wxALIGN_MASK = 0x0f00 }; +/* misc. flags for wxSizer items */ +enum wxSizerFlagBits +{ + /* + wxADJUST_MINSIZE doesn't do anything any more but we still define + it for compatibility. Notice that it may be also predefined (as 0, + hopefully) in the user code in order to use it even in + !WXWIN_COMPATIBILITY_2_8 builds so don't redefine it in such case. + */ +#if WXWIN_COMPATIBILITY_2_8 && !defined(wxADJUST_MINSIZE) + wxADJUST_MINSIZE = 0, +#endif + wxFIXED_MINSIZE = 0x8000, + wxRESERVE_SPACE_EVEN_IF_HIDDEN = 0x0002, + + /* a mask to extract wxSizerFlagBits from combination of flags */ + wxSIZER_FLAG_BITS_MASK = 0x8002 +}; + enum wxStretch { wxSTRETCH_NOT = 0x0000, @@ -1169,15 +1547,10 @@ enum wxStretch wxGROW = 0x2000, wxEXPAND = wxGROW, wxSHAPED = 0x4000, - wxFIXED_MINSIZE = 0x8000, - wxTILE = 0xc000, + wxTILE = wxSHAPED | wxFIXED_MINSIZE, - /* for compatibility only, default now, don't use explicitly any more */ -#if WXWIN_COMPATIBILITY_2_4 - wxADJUST_MINSIZE = 0x00100000 -#else - wxADJUST_MINSIZE = 0 -#endif + /* a mask to extract stretch from the combination of flags */ + wxSTRETCH_MASK = 0x7000 /* sans wxTILE */ }; /* border flags: the values are chosen for backwards compatibility */ @@ -1192,12 +1565,20 @@ enum wxBorder wxBORDER_SIMPLE = 0x02000000, wxBORDER_RAISED = 0x04000000, wxBORDER_SUNKEN = 0x08000000, - wxBORDER_DOUBLE = 0x10000000, + wxBORDER_DOUBLE = 0x10000000, /* deprecated */ + wxBORDER_THEME = wxBORDER_DOUBLE, /* a mask to extract border style from the combination of flags */ wxBORDER_MASK = 0x1f200000 }; +/* This makes it easier to specify a 'normal' border for a control */ +#if defined(__SMARTPHONE__) || defined(__POCKETPC__) +#define wxDEFAULT_CONTROL_BORDER wxBORDER_SIMPLE +#else +#define wxDEFAULT_CONTROL_BORDER wxBORDER_SUNKEN +#endif + /* ---------------------------------------------------------------------------- */ /* Window style flags */ /* ---------------------------------------------------------------------------- */ @@ -1207,12 +1588,40 @@ enum wxBorder * Some styles are used across more than one group, * so the values mustn't clash with others in the group. * Otherwise, numbers can be reused across groups. - * - * From version 1.66: - * Window (cross-group) styles now take up the first half - * of the flag, and control-specific styles the - * second half. - * + */ + +/* + Summary of the bits used by various styles. + + High word, containing styles which can be used with many windows: + + +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + |31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16| + +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + | | | | | | | | | | | | | | | | + | | | | | | | | | | | | | | | \_ wxFULL_REPAINT_ON_RESIZE + | | | | | | | | | | | | | | \____ wxPOPUP_WINDOW + | | | | | | | | | | | | | \_______ wxWANTS_CHARS + | | | | | | | | | | | | \__________ wxTAB_TRAVERSAL + | | | | | | | | | | | \_____________ wxTRANSPARENT_WINDOW + | | | | | | | | | | \________________ wxBORDER_NONE + | | | | | | | | | \___________________ wxCLIP_CHILDREN + | | | | | | | | \______________________ wxALWAYS_SHOW_SB + | | | | | | | \_________________________ wxBORDER_STATIC + | | | | | | \____________________________ wxBORDER_SIMPLE + | | | | | \_______________________________ wxBORDER_RAISED + | | | | \__________________________________ wxBORDER_SUNKEN + | | | \_____________________________________ wxBORDER_{DOUBLE,THEME} + | | \________________________________________ wxCAPTION/wxCLIP_SIBLINGS + | \___________________________________________ wxHSCROLL + \______________________________________________ wxVSCROLL + + + Low word style bits is class-specific meaning that the same bit can have + different meanings for different controls (e.g. 0x10 is wxCB_READONLY + meaning that the control can't be modified for wxComboBox but wxLB_SORT + meaning that the control should be kept sorted for wxListBox, while + wxLB_SORT has a different value -- and this is just fine). */ /* @@ -1283,6 +1692,13 @@ enum wxBorder /* window is resized (currently, makes sense for wxMSW only) */ #define wxNO_FULL_REPAINT_ON_RESIZE 0 +/* A mask which can be used to filter (out) all wxWindow-specific styles. + */ +#define wxWINDOW_STYLE_MASK \ + (wxVSCROLL|wxHSCROLL|wxBORDER_MASK|wxALWAYS_SHOW_SB|wxCLIP_CHILDREN| \ + wxCLIP_SIBLINGS|wxTRANSPARENT_WINDOW|wxTAB_TRAVERSAL|wxWANTS_CHARS| \ + wxRETAINED|wxPOPUP_WINDOW|wxFULL_REPAINT_ON_RESIZE) + /* * Extra window style flags (use wxWS_EX prefix to make it clear that they * should be passed to wxWindow::SetExtraStyle(), not SetWindowStyle()) @@ -1317,10 +1733,17 @@ enum wxBorder /* this window should always process UI update events */ #define wxWS_EX_PROCESS_UI_UPDATES 0x00000020 +/* Draw the window in a metal theme on Mac */ +#define wxFRAME_EX_METAL 0x00000040 +#define wxDIALOG_EX_METAL 0x00000040 + /* Use this style to add a context-sensitive help to the window (currently for */ /* Win32 only and it doesn't work if wxMINIMIZE_BOX or wxMAXIMIZE_BOX are used) */ -#define wxFRAME_EX_CONTEXTHELP 0x00000004 -#define wxDIALOG_EX_CONTEXTHELP 0x00000004 +#define wxWS_EX_CONTEXTHELP 0x00000080 + +/* synonyms for wxWS_EX_CONTEXTHELP for compatibility */ +#define wxFRAME_EX_CONTEXTHELP wxWS_EX_CONTEXTHELP +#define wxDIALOG_EX_CONTEXTHELP wxWS_EX_CONTEXTHELP /* Create a window which is attachable to another top level window */ #define wxFRAME_DRAWER 0x0020 @@ -1332,20 +1755,6 @@ enum wxBorder #define wxFRAME_NO_WINDOW_MENU 0x0100 -/* - * wxExtDialog style flags - */ -#define wxED_CLIENT_MARGIN 0x0004 -#define wxED_BUTTONS_BOTTOM 0x0000 /* has no effect */ -#define wxED_BUTTONS_RIGHT 0x0002 -#define wxED_STATIC_LINE 0x0001 - -#if defined(__WXMSW__) || defined(__WXMAC__) -# define wxEXT_DIALOG_STYLE (wxDEFAULT_DIALOG_STYLE|wxED_CLIENT_MARGIN) -#else -# define wxEXT_DIALOG_STYLE (wxDEFAULT_DIALOG_STYLE|wxED_CLIENT_MARGIN|wxED_STATIC_LINE) -#endif - /* * wxMenuBar style flags */ @@ -1371,16 +1780,19 @@ enum wxBorder #define wxLB_MULTIPLE 0x0040 #define wxLB_EXTENDED 0x0080 /* wxLB_OWNERDRAW is Windows-only */ +#define wxLB_NEEDED_SB 0x0000 #define wxLB_OWNERDRAW 0x0100 -#define wxLB_NEEDED_SB 0x0200 -#define wxLB_ALWAYS_SB 0x0400 +#define wxLB_ALWAYS_SB 0x0200 +#define wxLB_NO_SB 0x0400 #define wxLB_HSCROLL wxHSCROLL /* always show an entire number of rows */ #define wxLB_INT_HEIGHT 0x0800 -/* deprecated synonyms */ -#define wxPROCESS_ENTER 0x0400 /* wxTE_PROCESS_ENTER */ -#define wxPASSWORD 0x0800 /* wxTE_PASSWORD */ +#if WXWIN_COMPATIBILITY_2_6 + /* deprecated synonyms */ + #define wxPROCESS_ENTER 0x0400 /* wxTE_PROCESS_ENTER */ + #define wxPASSWORD 0x0800 /* wxTE_PASSWORD */ +#endif /* * wxComboBox style flags @@ -1412,23 +1824,6 @@ enum wxBorder #define wxRB_GROUP 0x0004 #define wxRB_SINGLE 0x0008 -/* - * wxSlider flags - */ -#define wxSL_HORIZONTAL wxHORIZONTAL /* 4 */ -#define wxSL_VERTICAL wxVERTICAL /* 8 */ -/* The next one is obsolete - use scroll events instead */ -#define wxSL_NOTIFY_DRAG 0x0000 -#define wxSL_TICKS 0x0010 -#define wxSL_AUTOTICKS wxSL_TICKS /* we don't support manual ticks */ -#define wxSL_LABELS 0x0020 -#define wxSL_LEFT 0x0040 -#define wxSL_TOP 0x0080 -#define wxSL_RIGHT 0x0100 -#define wxSL_BOTTOM 0x0200 -#define wxSL_BOTH 0x0400 -#define wxSL_SELRANGE 0x0800 - /* * wxScrollBar flags */ @@ -1437,45 +1832,15 @@ enum wxBorder /* * wxSpinButton flags. - * Note that a wxSpinCtrl is sometimes defined as - * a wxTextCtrl, and so the flags must be different - * from wxTextCtrl's. + * Note that a wxSpinCtrl is sometimes defined as a wxTextCtrl, and so the + * flags shouldn't overlap with wxTextCtrl flags that can be used for a single + * line controls (currently we reuse wxTE_CHARWRAP and wxTE_RICH2 neither of + * which makes sense for them). */ #define wxSP_HORIZONTAL wxHORIZONTAL /* 4 */ #define wxSP_VERTICAL wxVERTICAL /* 8 */ -#define wxSP_ARROW_KEYS 0x1000 -#define wxSP_WRAP 0x2000 - -/* - * wxNotebook flags - */ -#define wxNB_FIXEDWIDTH 0x0010 -#define wxNB_TOP 0x0000 /* default */ -#define wxNB_LEFT 0x0020 -#define wxNB_RIGHT 0x0040 -#define wxNB_BOTTOM 0x0080 -#define wxNB_MULTILINE 0x0100 -#define wxNB_DEFAULT wxNB_TOP - -/* - * wxListbook flags - */ -#define wxLB_DEFAULT 0x0 -#define wxLB_TOP 0x1 -#define wxLB_BOTTOM 0x2 -#define wxLB_LEFT 0x4 -#define wxLB_RIGHT 0x8 -#define wxLB_ALIGN_MASK 0xf - -/* - * wxChoicebook flags - */ -#define wxCHB_DEFAULT 0x0 -#define wxCHB_TOP 0x1 -#define wxCHB_BOTTOM 0x2 -#define wxCHB_LEFT 0x4 -#define wxCHB_RIGHT 0x8 -#define wxCHB_ALIGN_MASK 0xf +#define wxSP_ARROW_KEYS 0x4000 +#define wxSP_WRAP 0x8000 /* * wxTabCtrl flags @@ -1486,18 +1851,8 @@ enum wxBorder #define wxTC_LEFT 0x0020 #define wxTC_RIGHT 0x0040 #define wxTC_BOTTOM 0x0080 -#define wxTC_MULTILINE wxNB_MULTILINE -#define wxTC_OWNERDRAW 0x0200 - -/* - * wxStatusBar95 flags - */ -#define wxST_SIZEGRIP 0x0010 - -/* - * wxStaticText flags - */ -#define wxST_NO_AUTORESIZE 0x0001 +#define wxTC_MULTILINE 0x0200 /* == wxNB_MULTILINE */ +#define wxTC_OWNERDRAW 0x0400 /* * wxStaticBitmap flags @@ -1510,24 +1865,6 @@ enum wxBorder #define wxLI_HORIZONTAL wxHORIZONTAL #define wxLI_VERTICAL wxVERTICAL -/* - * wxProgressDialog flags - */ -#define wxPD_CAN_ABORT 0x0001 -#define wxPD_APP_MODAL 0x0002 -#define wxPD_AUTO_HIDE 0x0004 -#define wxPD_ELAPSED_TIME 0x0008 -#define wxPD_ESTIMATED_TIME 0x0010 -/* wxGA_SMOOTH = 0x0020 may also be used with wxProgressDialog */ -/* NO!!! This is wxDIALOG_MODAL and will cause the progress dialog to */ -/* be modal. No progress will then be made at all. */ -#define wxPD_REMAINING_TIME 0x0040 - -/* - * wxDirDialog styles - */ - -#define wxDD_NEW_DIR_BUTTON 0x0080 /* * extended dialog specifiers. these values are stored in a different @@ -1542,9 +1879,13 @@ enum wxBorder #define wxNO 0x00000008 #define wxYES_NO (wxYES | wxNO) #define wxCANCEL 0x00000010 +#define wxAPPLY 0x00000020 +#define wxCLOSE 0x00000040 -#define wxYES_DEFAULT 0x00000000 /* has no effect (default) */ -#define wxNO_DEFAULT 0x00000080 +#define wxOK_DEFAULT 0x00000000 /* has no effect (default) */ +#define wxYES_DEFAULT 0x00000000 /* has no effect (default) */ +#define wxNO_DEFAULT 0x00000080 /* only valid with wxYES_NO */ +#define wxCANCEL_DEFAULT 0x80000000 /* only valid with wxCANCEL */ #define wxICON_EXCLAMATION 0x00000100 #define wxICON_HAND 0x00000200 @@ -1554,46 +1895,104 @@ enum wxBorder #define wxICON_INFORMATION 0x00000800 #define wxICON_STOP wxICON_HAND #define wxICON_ASTERISK wxICON_INFORMATION -#define wxICON_MASK (0x00000100|0x00000200|0x00000400|0x00000800) -#define wxFORWARD 0x00001000 -#define wxBACKWARD 0x00002000 -#define wxRESET 0x00004000 -#define wxHELP 0x00008000 -#define wxMORE 0x00010000 -#define wxSETUP 0x00020000 +#define wxHELP 0x00001000 +#define wxFORWARD 0x00002000 +#define wxBACKWARD 0x00004000 +#define wxRESET 0x00008000 +#define wxMORE 0x00010000 +#define wxSETUP 0x00020000 +#define wxICON_NONE 0x00040000 + +#define wxICON_MASK \ + (wxICON_EXCLAMATION|wxICON_HAND|wxICON_QUESTION|wxICON_INFORMATION|wxICON_NONE) /* * Background styles. See wxWindow::SetBackgroundStyle */ - enum wxBackgroundStyle { - wxBG_STYLE_SYSTEM, - wxBG_STYLE_COLOUR, - wxBG_STYLE_CUSTOM -}; + /* + background is erased in the EVT_ERASE_BACKGROUND handler or using + the system default background if no such handler is defined (this + is the default style) + */ + wxBG_STYLE_ERASE, -/* ---------------------------------------------------------------------------- */ -/* standard IDs */ -/* ---------------------------------------------------------------------------- */ + /* + background is erased by the system, no EVT_ERASE_BACKGROUND event + is generated at all + */ + wxBG_STYLE_SYSTEM, -/* any id: means that we don't care about the id, whether when installing an */ -/* event handler or when creating a new window */ -enum -{ - wxID_ANY = -1 + /* + background is erased in EVT_PAINT handler and not erased at all + before it, this should be used if the paint handler paints over + the entire window to avoid flicker + */ + wxBG_STYLE_PAINT, + + + /* this is a Mac-only style, don't use in portable code */ + wxBG_STYLE_TRANSPARENT, + + /* this style is deprecated and doesn't do anything, don't use */ + wxBG_STYLE_COLOUR, + + /* + this style is deprecated and is synonymous with + wxBG_STYLE_PAINT, use the new name + */ + wxBG_STYLE_CUSTOM = wxBG_STYLE_PAINT }; -/* id for a separator line in the menu (invalid for normal item) */ -enum +/* + * Key types used by (old style) lists and hashes. + */ +enum wxKeyType { - wxID_SEPARATOR = -2 + wxKEY_NONE, + wxKEY_INTEGER, + wxKEY_STRING }; +/* ---------------------------------------------------------------------------- */ +/* standard IDs */ +/* ---------------------------------------------------------------------------- */ + /* Standard menu IDs */ -enum +enum wxStandardID { + /* + These ids delimit the range used by automatically-generated ids + (i.e. those used when wxID_ANY is specified during construction). + */ +#if defined(__WXMSW__) || wxUSE_AUTOID_MANAGEMENT + /* + On MSW the range is always restricted no matter if id management + is used or not because the native window ids are limited to short + range. On other platforms the range is only restricted if id + management is used so the reference count buffer won't be so big. + */ + wxID_AUTO_LOWEST = -32000, + wxID_AUTO_HIGHEST = -2000, +#else + wxID_AUTO_LOWEST = -1000000, + wxID_AUTO_HIGHEST = -2000, +#endif + + /* no id matches this one when compared to it */ + wxID_NONE = -3, + + /* id for a separator line in the menu (invalid for normal item) */ + wxID_SEPARATOR = -2, + + /* any id: means that we don't care about the id, whether when installing + * an event handler or when creating a new window */ + wxID_ANY = -1, + + + /* all predefined ids are between wxID_LOWEST and wxID_HIGHEST */ wxID_LOWEST = 4999, wxID_OPEN, @@ -1608,16 +2007,20 @@ enum wxID_HELP, wxID_PRINT, wxID_PRINT_SETUP, + wxID_PAGE_SETUP, wxID_PREVIEW, wxID_ABOUT, wxID_HELP_CONTENTS, + wxID_HELP_INDEX, + wxID_HELP_SEARCH, wxID_HELP_COMMANDS, wxID_HELP_PROCEDURES, wxID_HELP_CONTEXT, wxID_CLOSE_ALL, - wxID_PREFERENCES , + wxID_PREFERENCES, - wxID_CUT = 5030, + wxID_EDIT = 5030, + wxID_CUT, wxID_COPY, wxID_PASTE, wxID_CLEAR, @@ -1638,7 +2041,8 @@ enum wxID_VIEW_SORTSIZE, wxID_VIEW_SORTTYPE, - wxID_FILE1 = 5050, + wxID_FILE = 5050, + wxID_FILE1, wxID_FILE2, wxID_FILE3, wxID_FILE4, @@ -1692,6 +2096,24 @@ enum wxID_ZOOM_OUT, wxID_UNDELETE, wxID_REVERT_TO_SAVED, + wxID_CDROM, + wxID_CONVERT, + wxID_EXECUTE, + wxID_FLOPPY, + wxID_HARDDISK, + wxID_BOTTOM, + wxID_FIRST, + wxID_LAST, + wxID_TOP, + wxID_INFO, + wxID_JUMP_TO, + wxID_NETWORK, + wxID_SELECT_COLOR, + wxID_SELECT_FONT, + wxID_SORT_ASCENDING, + wxID_SORT_DESCENDING, + wxID_SPELL_CHECK, + wxID_STRIKETHROUGH, /* System menu IDs (used by wxUniv): */ wxID_SYSTEM_MENU = 5200, @@ -1702,12 +2124,45 @@ enum wxID_ICONIZE_FRAME, wxID_RESTORE_FRAME, + /* MDI window menu ids */ + wxID_MDI_WINDOW_FIRST = 5230, + wxID_MDI_WINDOW_CASCADE = wxID_MDI_WINDOW_FIRST, + wxID_MDI_WINDOW_TILE_HORZ, + wxID_MDI_WINDOW_TILE_VERT, + wxID_MDI_WINDOW_ARRANGE_ICONS, + wxID_MDI_WINDOW_PREV, + wxID_MDI_WINDOW_NEXT, + wxID_MDI_WINDOW_LAST = wxID_MDI_WINDOW_NEXT, + + /* OS X system menu ids */ + wxID_OSX_MENU_FIRST = 5250, + wxID_OSX_HIDE = wxID_OSX_MENU_FIRST, + wxID_OSX_HIDEOTHERS, + wxID_OSX_SHOWALL, + wxID_OSX_MENU_LAST = wxID_OSX_SHOWALL, + /* IDs used by generic file dialog (13 consecutive starting from this value) */ wxID_FILEDLGG = 5900, + /* IDs used by generic file ctrl (4 consecutive starting from this value) */ + wxID_FILECTRL = 5950, + wxID_HIGHEST = 5999 }; +/* ---------------------------------------------------------------------------- */ +/* wxWindowID type (after wxID_XYZ enum, platform detection, and dlimpexp.h) */ +/* ---------------------------------------------------------------------------- */ + +/* special care should be taken with this type under Windows where the real */ +/* window id is unsigned, so we must always do the cast before comparing them */ +/* (or else they would be always different!). Using wxGetWindowId() which does */ +/* the cast itself is recommended. Note that this type can't be unsigned */ +/* because wxID_ANY == -1 is a valid (and largely used) value for window id. */ +#if defined(__cplusplus) && wxUSE_GUI + #include "wx/windowid.h" +#endif + /* ---------------------------------------------------------------------------- */ /* other constants */ /* ---------------------------------------------------------------------------- */ @@ -1719,9 +2174,22 @@ enum wxItemKind wxITEM_NORMAL, wxITEM_CHECK, wxITEM_RADIO, + wxITEM_DROPDOWN, wxITEM_MAX }; +/* + * The possible states of a 3-state checkbox (Compatible + * with the 2-state checkbox). + */ +enum wxCheckBoxState +{ + wxCHK_UNCHECKED, + wxCHK_CHECKED, + wxCHK_UNDETERMINED /* 3-state checkbox only */ +}; + + /* hit test results */ enum wxHitTest { @@ -1765,12 +2233,47 @@ enum wxHitTest #define wxSIZE_ALLOW_MINUS_ONE 0x0004 /* Don't do parent client adjustments (for implementation only) */ #define wxSIZE_NO_ADJUSTMENTS 0x0008 +/* Change the window position even if it seems to be already correct */ +#define wxSIZE_FORCE 0x0010 +/* Emit size event even if size didn't change */ +#define wxSIZE_FORCE_EVENT 0x0020 /* ---------------------------------------------------------------------------- */ /* GDI descriptions */ /* ---------------------------------------------------------------------------- */ -enum +// Hatch styles used by both pen and brush styles. +// +// NB: Do not use these constants directly, they're for internal use only, use +// wxBRUSHSTYLE_XXX_HATCH and wxPENSTYLE_XXX_HATCH instead. +enum wxHatchStyle +{ + wxHATCHSTYLE_INVALID = -1, + + /* + The value of the first style is chosen to fit with + wxDeprecatedGUIConstants values below, don't change it. + */ + wxHATCHSTYLE_FIRST = 111, + wxHATCHSTYLE_BDIAGONAL = wxHATCHSTYLE_FIRST, + wxHATCHSTYLE_CROSSDIAG, + wxHATCHSTYLE_FDIAGONAL, + wxHATCHSTYLE_CROSS, + wxHATCHSTYLE_HORIZONTAL, + wxHATCHSTYLE_VERTICAL, + wxHATCHSTYLE_LAST = wxHATCHSTYLE_VERTICAL +}; + +/* + WARNING: the following styles are deprecated; use the + wxFontFamily, wxFontStyle, wxFontWeight, wxBrushStyle, + wxPenStyle, wxPenCap, wxPenJoin enum values instead! +*/ + +#if FUTURE_WXWIN_COMPATIBILITY_3_0 + +/* don't use any elements of this enum in the new code */ +enum wxDeprecatedGUIConstants { /* Text font families */ wxDEFAULT = 70, @@ -1803,71 +2306,23 @@ enum wxTRANSPARENT, /* Brush & Pen Stippling. Note that a stippled pen cannot be dashed!! */ - /* Note also that stippling a Pen IS meaningfull, because a Line is */ + /* Note also that stippling a Pen IS meaningful, because a Line is */ wxSTIPPLE_MASK_OPAQUE, /* mask is used for blitting monochrome using text fore and back ground colors */ wxSTIPPLE_MASK, /* mask is used for masking areas in the stipple bitmap (TO DO) */ /* drawn with a Pen, and without any Brush -- and it can be stippled. */ wxSTIPPLE = 110, - wxBDIAGONAL_HATCH, /* In wxWidgets < 2.6 use WX_HATCH macro */ - wxCROSSDIAG_HATCH, /* to verify these wx*_HATCH are in style */ - wxFDIAGONAL_HATCH, /* of wxBrush. In wxWidgets >= 2.6 use */ - wxCROSS_HATCH, /* wxBrush::IsHatch() instead. */ - wxHORIZONTAL_HATCH, - wxVERTICAL_HATCH, - wxFIRST_HATCH = wxBDIAGONAL_HATCH, - wxLAST_HATCH = wxVERTICAL_HATCH, - - wxJOIN_BEVEL = 120, - wxJOIN_MITER, - wxJOIN_ROUND, - - wxCAP_ROUND = 130, - wxCAP_PROJECTING, - wxCAP_BUTT + wxBDIAGONAL_HATCH = wxHATCHSTYLE_BDIAGONAL, + wxCROSSDIAG_HATCH = wxHATCHSTYLE_CROSSDIAG, + wxFDIAGONAL_HATCH = wxHATCHSTYLE_FDIAGONAL, + wxCROSS_HATCH = wxHATCHSTYLE_CROSS, + wxHORIZONTAL_HATCH = wxHATCHSTYLE_HORIZONTAL, + wxVERTICAL_HATCH = wxHATCHSTYLE_VERTICAL, + wxFIRST_HATCH = wxHATCHSTYLE_FIRST, + wxLAST_HATCH = wxHATCHSTYLE_LAST }; - -#if WXWIN_COMPATIBILITY_2_4 - #define IS_HATCH(s) ((s)>=wxFIRST_HATCH && (s)<=wxLAST_HATCH) -#else - /* use wxBrush::IsHatch() instead thought wxMotif still uses it in src/motif/dcclient.cpp */ #endif -/* Logical ops */ -typedef enum -{ - wxCLEAR, wxROP_BLACK = wxCLEAR, wxBLIT_BLACKNESS = wxCLEAR, /* 0 */ - wxXOR, wxROP_XORPEN = wxXOR, wxBLIT_SRCINVERT = wxXOR, /* src XOR dst */ - wxINVERT, wxROP_NOT = wxINVERT, wxBLIT_DSTINVERT = wxINVERT, /* NOT dst */ - wxOR_REVERSE, wxROP_MERGEPENNOT = wxOR_REVERSE, wxBLIT_00DD0228 = wxOR_REVERSE, /* src OR (NOT dst) */ - wxAND_REVERSE, wxROP_MASKPENNOT = wxAND_REVERSE, wxBLIT_SRCERASE = wxAND_REVERSE, /* src AND (NOT dst) */ - wxCOPY, wxROP_COPYPEN = wxCOPY, wxBLIT_SRCCOPY = wxCOPY, /* src */ - wxAND, wxROP_MASKPEN = wxAND, wxBLIT_SRCAND = wxAND, /* src AND dst */ - wxAND_INVERT, wxROP_MASKNOTPEN = wxAND_INVERT, wxBLIT_00220326 = wxAND_INVERT, /* (NOT src) AND dst */ - wxNO_OP, wxROP_NOP = wxNO_OP, wxBLIT_00AA0029 = wxNO_OP, /* dst */ - wxNOR, wxROP_NOTMERGEPEN = wxNOR, wxBLIT_NOTSRCERASE = wxNOR, /* (NOT src) AND (NOT dst) */ - wxEQUIV, wxROP_NOTXORPEN = wxEQUIV, wxBLIT_00990066 = wxEQUIV, /* (NOT src) XOR dst */ - wxSRC_INVERT, wxROP_NOTCOPYPEN = wxSRC_INVERT, wxBLIT_NOTSCRCOPY = wxSRC_INVERT, /* (NOT src) */ - wxOR_INVERT, wxROP_MERGENOTPEN = wxOR_INVERT, wxBLIT_MERGEPAINT = wxOR_INVERT, /* (NOT src) OR dst */ - wxNAND, wxROP_NOTMASKPEN = wxNAND, wxBLIT_007700E6 = wxNAND, /* (NOT src) OR (NOT dst) */ - wxOR, wxROP_MERGEPEN = wxOR, wxBLIT_SRCPAINT = wxOR, /* src OR dst */ - wxSET, wxROP_WHITE = wxSET, wxBLIT_WHITENESS = wxSET /* 1 */ -} form_ops_t; - -/* Flood styles */ -enum -{ - wxFLOOD_SURFACE = 1, - wxFLOOD_BORDER -}; - -/* Polygon filling mode */ -enum -{ - wxODDEVEN_RULE = 1, - wxWINDING_RULE -}; - /* ToolPanel in wxFrame (VZ: unused?) */ enum { @@ -1877,7 +2332,7 @@ enum wxTOOL_RIGHT }; -/* the values of the format constants should be the same as correspondign */ +/* the values of the format constants should be the same as corresponding */ /* CF_XXX constants in Windows API */ enum wxDataFormatId { @@ -1903,19 +2358,55 @@ enum wxDataFormatId wxDF_MAX }; -/* Virtual keycodes */ +/* Key codes */ enum wxKeyCode { - WXK_BACK = 8, + WXK_NONE = 0, + + WXK_CONTROL_A = 1, + WXK_CONTROL_B, + WXK_CONTROL_C, + WXK_CONTROL_D, + WXK_CONTROL_E, + WXK_CONTROL_F, + WXK_CONTROL_G, + WXK_CONTROL_H, + WXK_CONTROL_I, + WXK_CONTROL_J, + WXK_CONTROL_K, + WXK_CONTROL_L, + WXK_CONTROL_M, + WXK_CONTROL_N, + WXK_CONTROL_O, + WXK_CONTROL_P, + WXK_CONTROL_Q, + WXK_CONTROL_R, + WXK_CONTROL_S, + WXK_CONTROL_T, + WXK_CONTROL_U, + WXK_CONTROL_V, + WXK_CONTROL_W, + WXK_CONTROL_X, + WXK_CONTROL_Y, + WXK_CONTROL_Z, + + WXK_BACK = 8, /* backspace */ WXK_TAB = 9, WXK_RETURN = 13, WXK_ESCAPE = 27, + + /* values from 33 to 126 are reserved for the standard ASCII characters */ + WXK_SPACE = 32, WXK_DELETE = 127, - /* These are, by design, not compatable with unicode characters. + /* values from 128 to 255 are reserved for ASCII extended characters + (note that there isn't a single fixed standard for the meaning + of these values; avoid them in portable apps!) */ + + /* These are not compatible with unicode characters. If you want to get a unicode character from a key event, use - wxKeyEvent::GetUnicodeKey instead. */ + wxKeyEvent::GetUnicodeKey */ WXK_START = 300, WXK_LBUTTON, WXK_RBUTTON, @@ -1928,8 +2419,6 @@ enum wxKeyCode WXK_MENU, WXK_PAUSE, WXK_CAPITAL, - WXK_PRIOR, /* Page up */ - WXK_NEXT, /* Page down */ WXK_END, WXK_HOME, WXK_LEFT, @@ -1986,6 +2475,10 @@ enum wxKeyCode WXK_SCROLL, WXK_PAGEUP, WXK_PAGEDOWN, +#if WXWIN_COMPATIBILITY_2_6 + WXK_PRIOR = WXK_PAGEUP, + WXK_NEXT = WXK_PAGEDOWN, +#endif WXK_NUMPAD_SPACE, WXK_NUMPAD_TAB, @@ -1999,10 +2492,12 @@ enum wxKeyCode WXK_NUMPAD_UP, WXK_NUMPAD_RIGHT, WXK_NUMPAD_DOWN, - WXK_NUMPAD_PRIOR, WXK_NUMPAD_PAGEUP, - WXK_NUMPAD_NEXT, WXK_NUMPAD_PAGEDOWN, +#if WXWIN_COMPATIBILITY_2_6 + WXK_NUMPAD_PRIOR = WXK_NUMPAD_PAGEUP, + WXK_NUMPAD_NEXT = WXK_NUMPAD_PAGEDOWN, +#endif WXK_NUMPAD_END, WXK_NUMPAD_BEGIN, WXK_NUMPAD_INSERT, @@ -2018,33 +2513,53 @@ enum wxKeyCode WXK_WINDOWS_LEFT, WXK_WINDOWS_RIGHT, WXK_WINDOWS_MENU , - WXK_COMMAND +#ifdef __WXOSX__ + WXK_RAW_CONTROL, +#else + WXK_RAW_CONTROL = WXK_CONTROL, +#endif + WXK_COMMAND = WXK_CONTROL, + + /* Hardware-specific buttons */ + WXK_SPECIAL1 = 193, + WXK_SPECIAL2, + WXK_SPECIAL3, + WXK_SPECIAL4, + WXK_SPECIAL5, + WXK_SPECIAL6, + WXK_SPECIAL7, + WXK_SPECIAL8, + WXK_SPECIAL9, + WXK_SPECIAL10, + WXK_SPECIAL11, + WXK_SPECIAL12, + WXK_SPECIAL13, + WXK_SPECIAL14, + WXK_SPECIAL15, + WXK_SPECIAL16, + WXK_SPECIAL17, + WXK_SPECIAL18, + WXK_SPECIAL19, + WXK_SPECIAL20 }; -#if wxUSE_HOTKEY -enum wxHotkeyModifier +/* This enum contains bit mask constants used in wxKeyEvent */ +enum wxKeyModifier { - wxMOD_NONE = 0, - wxMOD_ALT = 1, - wxMOD_CONTROL = 2, - wxMOD_SHIFT = 4, - wxMOD_WIN = 8 -}; + wxMOD_NONE = 0x0000, + wxMOD_ALT = 0x0001, + wxMOD_CONTROL = 0x0002, + wxMOD_ALTGR = wxMOD_ALT | wxMOD_CONTROL, + wxMOD_SHIFT = 0x0004, + wxMOD_META = 0x0008, + wxMOD_WIN = wxMOD_META, +#if defined(__WXMAC__) || defined(__WXCOCOA__) + wxMOD_RAW_CONTROL = 0x0010, +#else + wxMOD_RAW_CONTROL = wxMOD_CONTROL, #endif - -/* Mapping modes (same values as used by Windows, don't change) */ -enum -{ - wxMM_TEXT = 1, - wxMM_LOMETRIC, - wxMM_HIMETRIC, - wxMM_LOENGLISH, - wxMM_HIENGLISH, - wxMM_TWIPS, - wxMM_ISOTROPIC, - wxMM_ANISOTROPIC, - wxMM_POINTS, - wxMM_METRIC + wxMOD_CMD = wxMOD_CONTROL, + wxMOD_ALL = 0xffff }; /* Shortcut for easier dialog-unit-to-pixel conversion */ @@ -2120,15 +2635,68 @@ typedef enum wxPAPER_B5_EXTRA, /* B5 (ISO) Extra 201 x 276 mm */ wxPAPER_A2, /* A2 420 x 594 mm */ wxPAPER_A3_TRANSVERSE, /* A3 Transverse 297 x 420 mm */ - wxPAPER_A3_EXTRA_TRANSVERSE /* A3 Extra Transverse 322 x 445 mm */ - + wxPAPER_A3_EXTRA_TRANSVERSE, /* A3 Extra Transverse 322 x 445 mm */ + + wxPAPER_DBL_JAPANESE_POSTCARD,/* Japanese Double Postcard 200 x 148 mm */ + wxPAPER_A6, /* A6 105 x 148 mm */ + wxPAPER_JENV_KAKU2, /* Japanese Envelope Kaku #2 */ + wxPAPER_JENV_KAKU3, /* Japanese Envelope Kaku #3 */ + wxPAPER_JENV_CHOU3, /* Japanese Envelope Chou #3 */ + wxPAPER_JENV_CHOU4, /* Japanese Envelope Chou #4 */ + wxPAPER_LETTER_ROTATED, /* Letter Rotated 11 x 8 1/2 in */ + wxPAPER_A3_ROTATED, /* A3 Rotated 420 x 297 mm */ + wxPAPER_A4_ROTATED, /* A4 Rotated 297 x 210 mm */ + wxPAPER_A5_ROTATED, /* A5 Rotated 210 x 148 mm */ + wxPAPER_B4_JIS_ROTATED, /* B4 (JIS) Rotated 364 x 257 mm */ + wxPAPER_B5_JIS_ROTATED, /* B5 (JIS) Rotated 257 x 182 mm */ + wxPAPER_JAPANESE_POSTCARD_ROTATED,/* Japanese Postcard Rotated 148 x 100 mm */ + wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED,/* Double Japanese Postcard Rotated 148 x 200 mm */ + wxPAPER_A6_ROTATED, /* A6 Rotated 148 x 105 mm */ + wxPAPER_JENV_KAKU2_ROTATED, /* Japanese Envelope Kaku #2 Rotated */ + wxPAPER_JENV_KAKU3_ROTATED, /* Japanese Envelope Kaku #3 Rotated */ + wxPAPER_JENV_CHOU3_ROTATED, /* Japanese Envelope Chou #3 Rotated */ + wxPAPER_JENV_CHOU4_ROTATED, /* Japanese Envelope Chou #4 Rotated */ + wxPAPER_B6_JIS, /* B6 (JIS) 128 x 182 mm */ + wxPAPER_B6_JIS_ROTATED, /* B6 (JIS) Rotated 182 x 128 mm */ + wxPAPER_12X11, /* 12 x 11 in */ + wxPAPER_JENV_YOU4, /* Japanese Envelope You #4 */ + wxPAPER_JENV_YOU4_ROTATED, /* Japanese Envelope You #4 Rotated */ + wxPAPER_P16K, /* PRC 16K 146 x 215 mm */ + wxPAPER_P32K, /* PRC 32K 97 x 151 mm */ + wxPAPER_P32KBIG, /* PRC 32K(Big) 97 x 151 mm */ + wxPAPER_PENV_1, /* PRC Envelope #1 102 x 165 mm */ + wxPAPER_PENV_2, /* PRC Envelope #2 102 x 176 mm */ + wxPAPER_PENV_3, /* PRC Envelope #3 125 x 176 mm */ + wxPAPER_PENV_4, /* PRC Envelope #4 110 x 208 mm */ + wxPAPER_PENV_5, /* PRC Envelope #5 110 x 220 mm */ + wxPAPER_PENV_6, /* PRC Envelope #6 120 x 230 mm */ + wxPAPER_PENV_7, /* PRC Envelope #7 160 x 230 mm */ + wxPAPER_PENV_8, /* PRC Envelope #8 120 x 309 mm */ + wxPAPER_PENV_9, /* PRC Envelope #9 229 x 324 mm */ + wxPAPER_PENV_10, /* PRC Envelope #10 324 x 458 mm */ + wxPAPER_P16K_ROTATED, /* PRC 16K Rotated */ + wxPAPER_P32K_ROTATED, /* PRC 32K Rotated */ + wxPAPER_P32KBIG_ROTATED, /* PRC 32K(Big) Rotated */ + wxPAPER_PENV_1_ROTATED, /* PRC Envelope #1 Rotated 165 x 102 mm */ + wxPAPER_PENV_2_ROTATED, /* PRC Envelope #2 Rotated 176 x 102 mm */ + wxPAPER_PENV_3_ROTATED, /* PRC Envelope #3 Rotated 176 x 125 mm */ + wxPAPER_PENV_4_ROTATED, /* PRC Envelope #4 Rotated 208 x 110 mm */ + wxPAPER_PENV_5_ROTATED, /* PRC Envelope #5 Rotated 220 x 110 mm */ + wxPAPER_PENV_6_ROTATED, /* PRC Envelope #6 Rotated 230 x 120 mm */ + wxPAPER_PENV_7_ROTATED, /* PRC Envelope #7 Rotated 230 x 160 mm */ + wxPAPER_PENV_8_ROTATED, /* PRC Envelope #8 Rotated 309 x 120 mm */ + wxPAPER_PENV_9_ROTATED, /* PRC Envelope #9 Rotated 324 x 229 mm */ + wxPAPER_PENV_10_ROTATED, /* PRC Envelope #10 Rotated 458 x 324 m */ + wxPAPER_A0, /* A0 Sheet 841 x 1189 mm */ + wxPAPER_A1 /* A1 Sheet 594 x 841 mm */ } wxPaperSize; /* Printing orientation */ -#ifndef wxPORTRAIT -#define wxPORTRAIT 1 -#define wxLANDSCAPE 2 -#endif +enum wxPrintOrientation +{ + wxPORTRAIT = 1, + wxLANDSCAPE +}; /* Duplex printing modes */ @@ -2173,6 +2741,21 @@ enum wxUpdateUI wxUPDATE_UI_FROMIDLE = 0x0002 /* Invoked from On(Internal)Idle */ }; + +/* ---------------------------------------------------------------------------- */ +/* wxList types */ +/* ---------------------------------------------------------------------------- */ + +/* type of compare function for list sort operation (as in 'qsort'): it should + return a negative value, 0 or positive value if the first element is less + than, equal or greater than the second */ + +typedef int (* LINKAGEMODE wxSortCompareFunction)(const void *elem1, const void *elem2); + +/* wxList iterator function */ +typedef int (* LINKAGEMODE wxListIterateFunction)(void *current); + + /* ---------------------------------------------------------------------------- */ /* miscellaneous */ /* ---------------------------------------------------------------------------- */ @@ -2191,22 +2774,37 @@ enum wxUpdateUI # define wxALL_FILES gettext_noop("All files (*)|*") #endif +#if defined(__CYGWIN__) && defined(__WXMSW__) +# if wxUSE_STD_CONTAINERS || defined(wxUSE_STD_STRING) + /* + NASTY HACK because the gethostname in sys/unistd.h which the gnu + stl includes and wx builds with by default clash with each other + (windows version 2nd param is int, sys/unistd.h version is unsigned + int). + */ +# define gethostname gethostnameHACK +# include +# undef gethostname +# endif +#endif + /* --------------------------------------------------------------------------- */ /* macros that enable wxWidgets apps to be compiled in absence of the */ -/* sytem headers, although some platform specific types are used in the */ +/* system headers, although some platform specific types are used in the */ /* platform specific (implementation) parts of the headers */ /* --------------------------------------------------------------------------- */ +#ifdef __DARWIN__ +#define DECLARE_WXOSX_OPAQUE_CFREF( name ) typedef struct __##name* name##Ref; +#define DECLARE_WXOSX_OPAQUE_CONST_CFREF( name ) typedef const struct __##name* name##Ref; +#endif + #ifdef __WXMAC__ #define WX_OPAQUE_TYPE( name ) struct wxOpaque##name -typedef unsigned char WXCOLORREF[6]; typedef void* WXHBITMAP; -typedef void* WXHMETAFILE; -typedef void* WXHICON; typedef void* WXHCURSOR; -typedef void* WXHRGN; typedef void* WXRECTPTR; typedef void* WXPOINTPTR; typedef void* WXHWND; @@ -2214,54 +2812,102 @@ typedef void* WXEVENTREF; typedef void* WXEVENTHANDLERREF; typedef void* WXEVENTHANDLERCALLREF; typedef void* WXAPPLEEVENTREF; -typedef void* WXHDC; -typedef void* WXHMENU; + typedef unsigned int WXUINT; typedef unsigned long WXDWORD; typedef unsigned short WXWORD; +typedef WX_OPAQUE_TYPE(PicHandle ) * WXHMETAFILE ; +#if wxOSX_USE_CARBON +typedef struct OpaqueControlRef* WXWidget ; +typedef struct OpaqueWindowPtr* WXWindow ; +typedef struct __AGLPixelFormatRec *WXGLPixelFormat; +typedef struct __AGLContextRec *WXGLContext; +#endif -/* typedef void* WXWidget; */ -/* typedef void* WXWindow; */ -typedef WX_OPAQUE_TYPE(ControlRef ) * WXWidget ; -typedef WX_OPAQUE_TYPE(WindowRef) * WXWindow ; typedef void* WXDisplay; -/* typedef WindowPtr WXHWND; */ -/* typedef Handle WXHANDLE; */ -/* typedef CIconHandle WXHICON; */ -/* typedef unsigned long WXHFONT; */ -/* typedef MenuHandle WXHMENU; */ -/* typedef unsigned long WXHPEN; */ -/* typedef unsigned long WXHBRUSH; */ -/* typedef unsigned long WXHPALETTE; */ -/* typedef CursHandle WXHCURSOR; */ -/* typedef RgnHandle WXHRGN; */ -/* typedef unsigned long WXHACCEL; */ -/* typedef unsigned long WXHINSTANCE; */ -/* typedef unsigned long WXHIMAGELIST; */ -/* typedef unsigned long WXHGLOBAL; */ -/* typedef GrafPtr WXHDC; */ -/* typedef unsigned int WXWPARAM; */ -/* typedef long WXLPARAM; */ -/* typedef void * WXRGNDATA; */ -/* typedef void * WXMSG; */ -/* typedef unsigned long WXHCONV; */ -/* typedef unsigned long WXHKEY; */ -/* typedef void * WXDRAWITEMSTRUCT; */ -/* typedef void * WXMEASUREITEMSTRUCT; */ -/* typedef void * WXLPCREATESTRUCT; */ -/* typedef int (*WXFARPROC)(); */ - -/* typedef WindowPtr WXWindow; */ -/* typedef ControlHandle WXWidget; */ - -#endif - -#ifdef __WXCOCOA__ +/* + * core frameworks + */ + +typedef const void * CFTypeRef; + +/* typedef const struct __CFString * CFStringRef; */ + +DECLARE_WXOSX_OPAQUE_CONST_CFREF( CFString ) +typedef struct __CFString * CFMutableStringRef; + +DECLARE_WXOSX_OPAQUE_CFREF( CFRunLoopSource ) +DECLARE_WXOSX_OPAQUE_CONST_CFREF( CTFont ) +DECLARE_WXOSX_OPAQUE_CONST_CFREF( CTFontDescriptor ) + +#define DECLARE_WXOSX_OPAQUE_CGREF( name ) typedef struct name* name##Ref; + +DECLARE_WXOSX_OPAQUE_CGREF( CGColor ) +DECLARE_WXOSX_OPAQUE_CGREF( CGImage ) +DECLARE_WXOSX_OPAQUE_CGREF( CGContext ) +DECLARE_WXOSX_OPAQUE_CGREF( CGFont ) + +typedef CGColorRef WXCOLORREF; +typedef CGImageRef WXCGIMAGEREF; +typedef CGContextRef WXHDC; + +/* + * carbon + */ + +typedef const struct __HIShape * HIShapeRef; +typedef struct __HIShape * HIMutableShapeRef; + +#define DECLARE_WXMAC_OPAQUE_REF( name ) typedef struct Opaque##name* name; + +DECLARE_WXMAC_OPAQUE_REF( PasteboardRef ) +DECLARE_WXMAC_OPAQUE_REF( IconRef ) +DECLARE_WXMAC_OPAQUE_REF( MenuRef ) + +typedef IconRef WXHICON ; +typedef HIShapeRef WXHRGN; +#if wxOSX_USE_CARBON +typedef MenuRef WXHMENU; +#endif + +#endif + +#if defined( __WXCOCOA__ ) || defined(__WXMAC__) + +/* Definitions of 32-bit/64-bit types + * These are typedef'd exactly the same way in newer OS X headers so + * redefinition when real headers are included should not be a problem. If + * it is, the types are being defined wrongly here. + * The purpose of these types is so they can be used from public wx headers. + * and also because the older (pre-Leopard) headers don't define them. + */ + +/* NOTE: We don't pollute namespace with CGFLOAT_MIN/MAX/IS_DOUBLE macros + * since they are unlikely to be needed in a public header. + */ +#if defined(__LP64__) && __LP64__ + typedef double CGFloat; +#else + typedef float CGFloat; +#endif + +#if (defined(__LP64__) && __LP64__) || (defined(NS_BUILD_32_LIKE_64) && NS_BUILD_32_LIKE_64) +typedef long NSInteger; +typedef unsigned long NSUInteger; +#else +typedef int NSInteger; +typedef unsigned int NSUInteger; +#endif + +/* Objective-C type declarations. + * These are to be used in public headers in lieu of NSSomething* because + * Objective-C class names are not available in C/C++ code. + */ /* NOTE: This ought to work with other compilers too, but I'm being cautious */ -#if (defined(__GNUC__) && defined(__APPLE__)) || defined(__MWERKS__) +#if (defined(__GNUC__) && defined(__APPLE__)) /* It's desirable to have type safety for Objective-C(++) code as it does at least catch typos of method names among other things. However, it is not possible to declare an Objective-C class from plain old C or C++ @@ -2281,7 +2927,7 @@ typedef klass *WX_##klass typedef struct klass *WX_##klass #endif /* defined(__OBJC__) */ -#else /* not Apple's GNU or CodeWarrior */ +#else /* not Apple's gcc */ #warning "Objective-C types will not be checked by the compiler." /* NOTE: typedef struct objc_object *id; */ /* IOW, we're declaring these using the id type without using that name, */ @@ -2291,7 +2937,7 @@ typedef struct klass *WX_##klass #define DECLARE_WXCOCOA_OBJC_CLASS(klass) \ typedef struct objc_object *WX_##klass -#endif /* (defined(__GNUC__) && defined(__APPLE__)) || defined(__MWERKS__) */ +#endif /* (defined(__GNUC__) && defined(__APPLE__)) */ DECLARE_WXCOCOA_OBJC_CLASS(NSApplication); DECLARE_WXCOCOA_OBJC_CLASS(NSBitmapImageRep); @@ -2302,6 +2948,8 @@ DECLARE_WXCOCOA_OBJC_CLASS(NSColorPanel); DECLARE_WXCOCOA_OBJC_CLASS(NSControl); DECLARE_WXCOCOA_OBJC_CLASS(NSCursor); DECLARE_WXCOCOA_OBJC_CLASS(NSEvent); +DECLARE_WXCOCOA_OBJC_CLASS(NSFont); +DECLARE_WXCOCOA_OBJC_CLASS(NSFontDescriptor); DECLARE_WXCOCOA_OBJC_CLASS(NSFontPanel); DECLARE_WXCOCOA_OBJC_CLASS(NSImage); DECLARE_WXCOCOA_OBJC_CLASS(NSLayoutManager); @@ -2323,33 +2971,77 @@ DECLARE_WXCOCOA_OBJC_CLASS(NSTextStorage); DECLARE_WXCOCOA_OBJC_CLASS(NSThread); DECLARE_WXCOCOA_OBJC_CLASS(NSWindow); DECLARE_WXCOCOA_OBJC_CLASS(NSView); +DECLARE_WXCOCOA_OBJC_CLASS(NSOpenGLContext); +DECLARE_WXCOCOA_OBJC_CLASS(NSOpenGLPixelFormat); +DECLARE_WXCOCOA_OBJC_CLASS( NSPrintInfo ); +#ifndef __WXMAC__ typedef WX_NSView WXWidget; /* wxWidgets BASE definition */ -#endif /* __WXCOCOA__ */ +#endif +#endif /* __WXCOCOA__ || ( __WXMAC__ &__DARWIN__)*/ -#ifdef __WXMSW__ +#ifdef __WXMAC__ + +DECLARE_WXCOCOA_OBJC_CLASS(NSString); + +#if wxOSX_USE_COCOA + +typedef WX_NSWindow WXWindow; +typedef WX_NSView WXWidget; +typedef WX_NSMenu WXHMENU; +typedef WX_NSOpenGLPixelFormat WXGLPixelFormat; +typedef WX_NSOpenGLContext WXGLContext; + +#elif wxOSX_USE_IPHONE + +DECLARE_WXCOCOA_OBJC_CLASS(UIWindow); +DECLARE_WXCOCOA_OBJC_CLASS(UIView); +DECLARE_WXCOCOA_OBJC_CLASS(UIFont); +DECLARE_WXCOCOA_OBJC_CLASS(UIImage); +DECLARE_WXCOCOA_OBJC_CLASS(UIEvent); +DECLARE_WXCOCOA_OBJC_CLASS(NSSet); +DECLARE_WXCOCOA_OBJC_CLASS(EAGLContext); + +typedef WX_UIWindow WXWindow; +typedef WX_UIView WXWidget; +typedef WX_EAGLContext WXGLContext; +typedef WX_NSString* WXGLPixelFormat; -/* the keywords needed for WinMain() declaration */ -#ifndef WXFAR -# define WXFAR #endif +#endif /* __WXMAC__ */ + +/* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */ +#if defined(__WIN32__) + /* Stand-ins for Windows types to avoid #including all of windows.h */ -typedef void * WXHWND; -typedef void * WXHANDLE; -typedef void * WXHICON; -typedef void * WXHFONT; -typedef void * WXHMENU; -typedef void * WXHPEN; -typedef void * WXHBRUSH; -typedef void * WXHPALETTE; -typedef void * WXHCURSOR; -typedef void * WXHRGN; -typedef void * WXHACCEL; -typedef void WXFAR * WXHINSTANCE; -typedef void * WXHBITMAP; -typedef void * WXHIMAGELIST; -typedef void * WXHGLOBAL; -typedef void * WXHDC; + +#ifndef NO_STRICT + #define WX_MSW_DECLARE_HANDLE(type) typedef struct type##__ * WX##type +#else + #define WX_MSW_DECLARE_HANDLE(type) typedef void * WX##type +#endif + +typedef void* WXHANDLE; +WX_MSW_DECLARE_HANDLE(HWND); +WX_MSW_DECLARE_HANDLE(HICON); +WX_MSW_DECLARE_HANDLE(HFONT); +WX_MSW_DECLARE_HANDLE(HMENU); +WX_MSW_DECLARE_HANDLE(HPEN); +WX_MSW_DECLARE_HANDLE(HBRUSH); +WX_MSW_DECLARE_HANDLE(HPALETTE); +WX_MSW_DECLARE_HANDLE(HCURSOR); +WX_MSW_DECLARE_HANDLE(HRGN); +WX_MSW_DECLARE_HANDLE(RECTPTR); +WX_MSW_DECLARE_HANDLE(HACCEL); +WX_MSW_DECLARE_HANDLE(HINSTANCE); +WX_MSW_DECLARE_HANDLE(HBITMAP); +WX_MSW_DECLARE_HANDLE(HIMAGELIST); +WX_MSW_DECLARE_HANDLE(HGLOBAL); +WX_MSW_DECLARE_HANDLE(HDC); +typedef WXHINSTANCE WXHMODULE; + +#undef WX_MSW_DECLARE_HANDLE + typedef unsigned int WXUINT; typedef unsigned long WXDWORD; typedef unsigned short WXWORD; @@ -2365,26 +3057,33 @@ typedef void * WXDRAWITEMSTRUCT; typedef void * WXMEASUREITEMSTRUCT; typedef void * WXLPCREATESTRUCT; +#ifdef __WXMSW__ typedef WXHWND WXWidget; +#endif #ifdef __WIN64__ -typedef unsigned __int64 WXWPARAM; +typedef unsigned __int64 WXWPARAM; typedef __int64 WXLPARAM; typedef __int64 WXLRESULT; #else -typedef unsigned int WXWPARAM; -typedef long WXLPARAM; -typedef long WXLRESULT; +typedef wxW64 unsigned int WXWPARAM; +typedef wxW64 long WXLPARAM; +typedef wxW64 long WXLRESULT; #endif -#if !defined(__WIN32__) || defined(__GNUWIN32__) || defined(__WXMICROWIN__) +#if defined(__GNUWIN32__) || defined(__WXMICROWIN__) typedef int (*WXFARPROC)(); #else typedef int (__stdcall *WXFARPROC)(); #endif -#endif /* __WXMSW__ */ +#endif /* __WIN32__ */ +#if defined(__OS2__) +typedef unsigned long DWORD; +typedef unsigned short WORD; +#endif + #if defined(__WXPM__) || defined(__EMX__) #ifdef __WXPM__ /* Stand-ins for OS/2 types, to avoid #including all of os2.h */ @@ -2399,6 +3098,8 @@ typedef unsigned long WXHPALETTE; typedef unsigned long WXHCURSOR; typedef unsigned long WXHRGN; typedef unsigned long WXHACCEL; +typedef unsigned long WXHINSTANCE; +typedef unsigned long WXHMODULE; typedef unsigned long WXHBITMAP; typedef unsigned long WXHDC; typedef unsigned int WXUINT; @@ -2445,23 +3146,18 @@ typedef unsigned long HCURSOR; typedef unsigned long HINSTANCE; typedef unsigned long HIMAGELIST; typedef unsigned long HGLOBAL; -typedef unsigned long DWORD; -typedef unsigned short WORD; #endif /* WXPM || EMX */ #if defined (__WXPM__) /* WIN32 graphics types for OS/2 GPI */ /* RGB under OS2 is more like a PALETTEENTRY struct under Windows so we need a real RGB def */ -/* WARNING: The OS/2 headers typedef BYTE simply as 'char'; if the default is signed, all */ -/* hell will break loose! */ -/* #define OS2RGB(r,g,b) ((DWORD ((BYTE) (b) | ((WORD) (g) << 8)) | (((DWORD)(BYTE)(r)) << 16))) */ #define OS2RGB(r,g,b) ((DWORD)((unsigned char)(b) | ((unsigned char)(g) << 8)) | ((unsigned char)(r) << 16)) typedef unsigned long COLORREF; -#define GetBValue(rgb) ((BYTE)((rgb) >> 16)) -#define GetGValue(rgb) ((BYTE)(((WORD)(rgb)) >> 8)) -#define GetRValue(rgb) ((BYTE)(rgb)) +#define GetRValue(rgb) ((unsigned char)((rgb) >> 16)) +#define GetGValue(rgb) ((unsigned char)(((unsigned short)(rgb)) >> 8)) +#define GetBValue(rgb) ((unsigned char)(rgb)) #define PALETTEINDEX(i) ((COLORREF)(0x01000000 | (DWORD)(WORD)(i))) #define PALETTERGB(r,g,b) (0x02000000 | OS2RGB(r,g,b)) /* OS2's RGB/RGB2 is backwards from this */ @@ -2509,67 +3205,63 @@ typedef void* WXRegion; typedef void* WXFont; typedef void* WXImage; typedef void* WXFontList; +typedef void* WXFontSet; typedef void* WXRendition; typedef void* WXRenderTable; typedef void* WXFontType; /* either a XmFontList or XmRenderTable */ typedef void* WXString; typedef unsigned long Atom; /* this might fail on a few architectures */ +typedef long WXPixel; /* safety catch in src/motif/colour.cpp */ #endif /* Motif */ #ifdef __WXGTK__ /* Stand-ins for GLIB types */ -typedef char gchar; -typedef signed char gint8; -typedef int gint; -typedef unsigned guint; -typedef unsigned long gulong; -typedef void* gpointer; typedef struct _GSList GSList; /* Stand-ins for GDK types */ typedef struct _GdkColor GdkColor; -typedef struct _GdkColormap GdkColormap; -typedef struct _GdkFont GdkFont; -typedef struct _GdkGC GdkGC; -typedef struct _GdkVisual GdkVisual; - -#ifdef __WXGTK20__ -typedef struct _GdkAtom *GdkAtom; -typedef struct _GdkDrawable GdkWindow; -typedef struct _GdkDrawable GdkBitmap; -typedef struct _GdkDrawable GdkPixmap; -#else /* GTK+ 1.2 */ -typedef gulong GdkAtom; -typedef struct _GdkWindow GdkWindow; -typedef struct _GdkWindow GdkBitmap; -typedef struct _GdkWindow GdkPixmap; -#endif /* GTK+ 1.2/2.0 */ - typedef struct _GdkCursor GdkCursor; -typedef struct _GdkRegion GdkRegion; typedef struct _GdkDragContext GdkDragContext; -#ifdef HAVE_XIM -typedef struct _GdkIC GdkIC; -typedef struct _GdkICAttr GdkICAttr; +#if defined(__WXGTK20__) + typedef struct _GdkAtom* GdkAtom; +#else + typedef unsigned long GdkAtom; +#endif + +#if !defined(__WXGTK3__) + typedef struct _GdkColormap GdkColormap; + typedef struct _GdkFont GdkFont; + typedef struct _GdkGC GdkGC; + typedef struct _GdkRegion GdkRegion; +#endif + +#if defined(__WXGTK3__) + typedef struct _GdkWindow GdkWindow; +#elif defined(__WXGTK20__) + typedef struct _GdkDrawable GdkWindow; + typedef struct _GdkDrawable GdkPixmap; +#else + typedef struct _GdkWindow GdkWindow; + typedef struct _GdkWindow GdkBitmap; + typedef struct _GdkWindow GdkPixmap; #endif /* Stand-ins for GTK types */ typedef struct _GtkWidget GtkWidget; typedef struct _GtkRcStyle GtkRcStyle; typedef struct _GtkAdjustment GtkAdjustment; -typedef struct _GtkList GtkList; typedef struct _GtkToolbar GtkToolbar; -typedef struct _GtkTooltips GtkTooltips; typedef struct _GtkNotebook GtkNotebook; typedef struct _GtkNotebookPage GtkNotebookPage; typedef struct _GtkAccelGroup GtkAccelGroup; -typedef struct _GtkItemFactory GtkItemFactory; typedef struct _GtkSelectionData GtkSelectionData; typedef struct _GtkTextBuffer GtkTextBuffer; +typedef struct _GtkRange GtkRange; +typedef struct _GtkCellRenderer GtkCellRenderer; typedef GtkWidget *WXWidget; @@ -2593,56 +3285,82 @@ typedef struct _PangoLayout PangoLayout; typedef struct _PangoFontDescription PangoFontDescription; #endif -#ifdef __WXMGL__ -typedef struct window_t *WXWidget; -#endif /* MGL */ +#ifdef __WXDFB__ +/* DirectFB doesn't have the concept of non-TLW window, so use + something arbitrary */ +typedef const void* WXWidget; +#endif /* DFB */ /* This is required because of clashing macros in windows.h, which may be */ /* included before or after wxWidgets classes, and therefore must be */ /* disabled here before any significant wxWidgets headers are included. */ -#ifdef __WXMSW__ -#ifdef GetClassInfo -#undef GetClassInfo -#endif +#ifdef __cplusplus +#ifdef __WINDOWS__ +#include "wx/msw/winundef.h" +#endif /* __WINDOWS__ */ +#endif /* __cplusplus */ -#ifdef GetClassName -#undef GetClassName -#endif -#ifdef DrawText -#undef DrawText -#endif +/* include the feature test macros */ +#include "wx/features.h" -#ifdef GetCharWidth -#undef GetCharWidth -#endif +/* --------------------------------------------------------------------------- */ +/* macros to define a class without copy ctor nor assignment operator */ +/* --------------------------------------------------------------------------- */ -#ifdef StartDoc -#undef StartDoc -#endif +#define wxDECLARE_NO_COPY_CLASS(classname) \ + private: \ + classname(const classname&); \ + classname& operator=(const classname&) -#ifdef FindWindow -#undef FindWindow -#endif +#define wxDECLARE_NO_COPY_TEMPLATE_CLASS(classname, arg) \ + private: \ + classname(const classname&); \ + classname& operator=(const classname&) -#ifdef FindResource -#undef FindResource -#endif -#endif - /* __WXMSW__ */ +#define wxDECLARE_NO_COPY_TEMPLATE_CLASS_2(classname, arg1, arg2) \ + private: \ + classname(const classname&); \ + classname& operator=(const classname&) + +#define wxDECLARE_NO_ASSIGN_CLASS(classname) \ + private: \ + classname& operator=(const classname&) + +/* deprecated variants _not_ requiring a semicolon after them */ +#define DECLARE_NO_COPY_CLASS(classname) \ + wxDECLARE_NO_COPY_CLASS(classname); +#define DECLARE_NO_COPY_TEMPLATE_CLASS(classname, arg) \ + wxDECLARE_NO_COPY_TEMPLATE_CLASS(classname, arg); +#define DECLARE_NO_ASSIGN_CLASS(classname) \ + wxDECLARE_NO_ASSIGN_CLASS(classname); /* --------------------------------------------------------------------------- */ -/* macro to define a class without copy ctor nor assignment operator */ +/* If a manifest is being automatically generated, add common controls 6 to it */ /* --------------------------------------------------------------------------- */ -#define DECLARE_NO_COPY_CLASS(classname) \ - private: \ - classname(const classname&); \ - classname& operator=(const classname&); +#if (!defined wxUSE_NO_MANIFEST || wxUSE_NO_MANIFEST == 0 ) && \ + ( defined _MSC_FULL_VER && _MSC_FULL_VER >= 140040130 ) + +#define WX_CC_MANIFEST(cpu) \ + "/manifestdependency:\"type='win32' \ + name='Microsoft.Windows.Common-Controls' \ + version='6.0.0.0' \ + processorArchitecture='" cpu "' \ + publicKeyToken='6595b64144ccf1df' \ + language='*'\"" + +#if defined _M_IX86 + #pragma comment(linker, WX_CC_MANIFEST("x86")) +#elif defined _M_X64 + #pragma comment(linker, WX_CC_MANIFEST("amd64")) +#elif defined _M_IA64 + #pragma comment(linker, WX_CC_MANIFEST("ia64")) +#else + #pragma comment(linker, WX_CC_MANIFEST("*")) +#endif -#define DECLARE_NO_ASSIGN_CLASS(classname) \ - private: \ - classname& operator=(const classname&); +#endif /* !wxUSE_NO_MANIFEST && _MSC_FULL_VER >= 140040130 */ #endif /* _WX_DEFS_H_ */