X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/78cd9c69eb3f4c158fe10ce49325d57ec05d1306..13d843f1c15fe721f03d933c600cd5ca62944003:/include/wx/defs.h diff --git a/include/wx/defs.h b/include/wx/defs.h index 63fb8e9331..22afbab35e 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 */ /* ---------------------------------------------------------------------------- */ @@ -71,6 +76,12 @@ # pragma warning(disable:4512) /* operator=() couldn't be generated */ # pragma warning(disable:4710) /* function not inlined */ + /* 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) + /* For VC++ 5.0 for release mode, the warning 'C4702: unreachable code */ /* is buggy, and occurs for code that does actually get executed */ # if !defined __WXDEBUG__ && __VISUALC__ <= 1100 @@ -83,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 @@ -97,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 */ @@ -198,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 */ @@ -233,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 */ @@ -443,6 +455,51 @@ typedef int wxWindowID; #endif /* HAVE_VARIADIC_MACROS */ +#ifndef HAVE_WOSTREAM + // Mingw <= 3.4 and any version (so far) when targetting PalmOS don't have + // std::wostream + #if defined(__PALMOS__) || \ + (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 */ /* ---------------------------------------------------------------------------- */ @@ -516,13 +573,23 @@ typedef int wxWindowID; /* 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 +/* + 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 } + /* 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 @@ -540,7 +607,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 @@ -728,7 +795,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 */ @@ -784,7 +853,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__) @@ -913,18 +984,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 @@ -1035,7 +1116,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 @@ -1059,7 +1144,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 @@ -1338,7 +1427,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 @@ -1356,7 +1448,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 @@ -1378,20 +1473,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 */ @@ -1728,7 +1834,8 @@ enum wxBackgroundStyle { wxBG_STYLE_SYSTEM, wxBG_STYLE_COLOUR, - wxBG_STYLE_CUSTOM + wxBG_STYLE_CUSTOM, + wxBG_STYLE_TRANSPARENT }; /* @@ -1748,6 +1855,24 @@ enum wxKeyType /* Standard menu IDs */ 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, @@ -1875,13 +2000,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 */ /* ---------------------------------------------------------------------------- */ @@ -1947,7 +2085,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, @@ -1969,6 +2108,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, @@ -1993,15 +2139,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 */ @@ -2469,11 +2608,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; @@ -2481,54 +2617,57 @@ 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 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; +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( IconRef ) + +typedef IconRef WXHICON ; +typedef HIShapeRef WXHRGN; + +#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 @@ -2623,8 +2762,14 @@ DECLARE_WXCOCOA_OBJC_CLASS(NSTextStorage); DECLARE_WXCOCOA_OBJC_CLASS(NSThread); DECLARE_WXCOCOA_OBJC_CLASS(NSWindow); DECLARE_WXCOCOA_OBJC_CLASS(NSView); +#ifdef __WXMAC__ +// things added for __WXMAC__ +DECLARE_WXCOCOA_OBJC_CLASS(NSString); +#else +// things only for __WXCOCOA__ typedef WX_NSView WXWidget; /* wxWidgets BASE definition */ -#endif /* __WXCOCOA__ */ +#endif +#endif /* __WXCOCOA__ || ( __WXMAC__ &__DARWIN__)*/ #if defined(__WXPALMOS__) @@ -2669,6 +2814,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; @@ -2705,13 +2861,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__)