X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/f35fdf7e4a86ad98256debf60939f1f3a34c8a0f..93928d517b4f748fb8bdbd7e0ae5334e2e3a8562:/include/wx/defs.h diff --git a/include/wx/defs.h b/include/wx/defs.h index ad5e2a6ab5..3d34d267b2 100644 --- a/include/wx/defs.h +++ b/include/wx/defs.h @@ -14,6 +14,11 @@ #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 */ /* ---------------------------------------------------------------------------- */ @@ -89,11 +94,24 @@ # pragma warning(disable:4003) /* not enough actual parameters for macro */ # endif + /* + 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 __VISUALC__ >= 1400 + #if wxCHECK_VISUALC_VERSION(8) #ifndef _CRT_SECURE_NO_DEPRECATE #define _CRT_SECURE_NO_DEPRECATE 1 #endif @@ -103,15 +121,6 @@ #endif /* VC++ 8 */ #endif /* __VISUALC__ */ -/* 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__ */ - /* suppress some Borland C++ warnings */ #ifdef __BORLANDC__ # pragma warn -inl /* Functions containing reserved words and certain constructs are not expanded inline */ @@ -204,6 +213,9 @@ #define false ((bool)0) #endif #define HAVE_BOOL + #elif defined(__WXPALMOS__) + /* Palm OS supports bool */ + #define HAVE_BOOL #endif /* compilers */ #endif /* HAVE_BOOL */ @@ -239,12 +251,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 */ @@ -451,11 +457,47 @@ typedef int wxWindowID; #ifndef HAVE_WOSTREAM // Mingw <=3.4 doesn't have std::wostream - #if !defined(__MINGW32__) || wxCHECK_GCC_VERSION(4,0) + #if defined(__MINGW32__) && !wxCHECK_GCC_VERSION(4,0) + #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 // __BORLANDC__ +#endif // !defined(HAVE_TEMPLATE_OVERLOAD_RESOLUTION) + /* ---------------------------------------------------------------------------- */ /* portable calling conventions macros */ /* ---------------------------------------------------------------------------- */ @@ -563,7 +605,7 @@ typedef int wxWindowID; /* 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__) && !defined(__PALMOS__) #include #endif @@ -751,7 +793,9 @@ enum { wxDefaultCoord = -1 }; /* ---------------------------------------------------------------------------- */ #if defined(__WXPALMOS__) || defined(__MINGW32__) + #if !defined(__MWERKS__) #include + #endif #endif /* chars are always one byte (by definition), shorts are always two (in */ @@ -807,7 +851,9 @@ typedef wxUint16 wxWord; #define SIZEOF_LONG 4 #define SIZEOF_WCHAR_T 2 #define SIZEOF_SIZE_T 4 - #define wxSIZE_T_IS_UINT + #ifdef __WXPALMOS6__ + #define wxSIZE_T_IS_UINT + #endif #define SIZEOF_VOID_P 4 #define SIZEOF_SIZE_T 4 #elif defined(__WINDOWS__) @@ -936,18 +982,28 @@ typedef wxUint32 wxDword; #define wxINT64_MIN LLONG_MIN #else #define wxINT64_MAX wxLL(9223372036854775807) - #define wxINT64_MIN wxLL(-9223372036854775807-1) + #define wxINT64_MIN (wxLL(-9223372036854775807)-1) #endif /* 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 */ +#if SIZEOF_SIZE_T >= SIZEOF_VOID_P + /* + Win64 case: size_t is the only integral type big enough for "void *". + + Notice that wxUIntPtr should be also defined as size_t when building + under Win32 with MSVC with /Wp64 option as otherwise any conversion + between ints and pointers results in a warning 4311 or 4312, even if it + is safe under Win32. Using size_t (declared with __w64) allows to avoid + them. + */ typedef size_t wxUIntPtr; +#elif SIZEOF_LONG >= SIZEOF_VOID_P + /* + Normal case when long is the largest integral type. + */ + typedef unsigned long wxUIntPtr; #else /* This should never happen for the current architectures but if you're @@ -1058,7 +1114,11 @@ inline void *wxUIntToPtr(wxUIntPtr p) #error "See the documentation on the 'longlong' pragma." #endif #elif defined(__WXPALMOS__) - #define wxLongLong_t int64_t + #if defined(__WXPALMOS6__) + #define wxLongLong_t int64_t + #else + #define wxLongLong_t long long + #endif /* __WXPALMOS6__ */ #define wxLongLongSuffix ll #define wxLongLongFmtSpec _T("ll") #elif defined(__VISAGECPP__) && __IBMCPP__ >= 400 @@ -1082,7 +1142,11 @@ inline void *wxUIntToPtr(wxUIntPtr p) #ifdef wxLongLong_t #ifdef __WXPALMOS__ + #if defined(__WXPALMOS6__) #define wxULongLong_t uint64_t + #else + #define wxULongLong_t unsigned long long + #endif /* __WXPALMOS6__ */ #else #define wxULongLong_t unsigned wxLongLong_t #endif @@ -1361,7 +1425,10 @@ enum wxOrientation 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 @@ -1379,7 +1446,10 @@ 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 @@ -1401,20 +1471,31 @@ enum wxAlignment wxALIGN_MASK = 0x0f00 }; -enum wxStretch +/* misc. flags for wxSizer items */ +enum wxSizerFlagBits { /* for compatibility only, default now, don't use explicitly any more */ #if WXWIN_COMPATIBILITY_2_6 - wxADJUST_MINSIZE = 0, + 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, wxSHRINK = 0x1000, wxGROW = 0x2000, wxEXPAND = wxGROW, wxSHAPED = 0x4000, - wxFIXED_MINSIZE = 0x8000, - wxTILE = 0xc000 + wxTILE = wxSHAPED | wxFIXED_MINSIZE, + + /* a mask to extract stretch from the combination of flags */ + wxSTRETCH_MASK = 0x7000 /* sans wxTILE */ }; /* border flags: the values are chosen for backwards compatibility */ @@ -1776,8 +1857,19 @@ enum 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, @@ -1906,13 +1998,26 @@ enum /* 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 */ /* ---------------------------------------------------------------------------- */ @@ -1978,7 +2083,8 @@ enum wxHitTest /* GDI descriptions */ /* ---------------------------------------------------------------------------- */ -enum +/* don't use any elements of this enum in the new code */ +enum wxDeprecatedGUIConstants { /* Text font families */ wxDEFAULT = 70, @@ -2000,6 +2106,13 @@ enum wxITALIC, wxSLANT, + +#if FUTURE_WXWIN_COMPATIBILITY_3_0 + /* + WARNING: the following styles are deprecated; use the wxBrushStyle, + wxPenStyle, wxPenCap, wxPenJoin enum values instead! + */ + /* Pen styles */ wxSOLID = 100, wxDOT, @@ -2024,15 +2137,8 @@ enum 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 + wxLAST_HATCH = wxVERTICAL_HATCH +#endif }; /* Logical ops */ @@ -2500,11 +2606,8 @@ enum wxUpdateUI #define WX_OPAQUE_TYPE( name ) struct wxOpaque##name -typedef unsigned char WXCOLORREF[6]; -typedef void* WXCGIMAGEREF; typedef void* WXHBITMAP; typedef void* WXHCURSOR; -typedef void* WXHRGN; typedef void* WXRECTPTR; typedef void* WXPOINTPTR; typedef void* WXHWND; @@ -2512,20 +2615,21 @@ 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(CIconHandle ) * WXHICON ; typedef WX_OPAQUE_TYPE(PicHandle ) * WXHMETAFILE ; typedef WX_OPAQUE_TYPE(ControlRef ) * WXWidget ; typedef WX_OPAQUE_TYPE(WindowRef) * WXWindow ; typedef void* WXDisplay; -// a few native types +/* + * core frameworks + */ typedef const void * CFTypeRef; @@ -2534,13 +2638,34 @@ typedef struct __CFString * CFMutableStringRef; typedef struct __CFRunLoopSource * CFRunLoopSourceRef; +#define DECLARE_WXMAC_OPAQUE_CGREF( name ) typedef struct name* name##Ref; + +DECLARE_WXMAC_OPAQUE_CGREF( CGColor ) +DECLARE_WXMAC_OPAQUE_CGREF( CGImage ) +DECLARE_WXMAC_OPAQUE_CGREF( CGContext ) + +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( PasteboardRef ) +DECLARE_WXMAC_OPAQUE_REF( IconRef ) + +typedef IconRef WXHICON ; +typedef HIShapeRef WXHRGN; #endif -#if defined( __WXCOCOA__ ) || ( defined(__WXMAC__) && defined(__DARWIN__) ) +#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 @@ -2687,6 +2812,17 @@ typedef void * WXRECTANGLEPTR; # define WXFAR #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 + /* Stand-ins for Windows types to avoid #including all of windows.h */ typedef void * WXHWND; typedef void * WXHANDLE; @@ -2723,13 +2859,13 @@ typedef void * WXLPCREATESTRUCT; typedef WXHWND WXWidget; #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(__GNUWIN32__) || defined(__WXMICROWIN__)