X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/cc18b1c7af38025eb0848e117ca72d3e496e81e6..fa61b1df36e12ffdb77ec07677f6e14881c96a3b:/include/wx/defs.h diff --git a/include/wx/defs.h b/include/wx/defs.h index 11c305c7a3..1555231826 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 */ @@ -450,12 +456,50 @@ typedef int wxWindowID; #ifndef HAVE_WOSTREAM - // Mingw <=3.4 doesn't have std::wostream - #if !defined(__MINGW32__) || wxCHECK_GCC_VERSION(4,0) + // 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 */ /* ---------------------------------------------------------------------------- */ @@ -563,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 @@ -751,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 */ @@ -807,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__) @@ -936,76 +984,8 @@ typedef wxUint32 wxDword; #define wxINT64_MIN LLONG_MIN #else #define wxINT64_MAX wxLL(9223372036854775807) - #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 */ - 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) + #define wxINT64_MIN (wxLL(-9223372036854775807)-1) #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*/ - /* 64 bit */ @@ -1058,7 +1038,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 +1066,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 @@ -1126,7 +1114,11 @@ inline void *wxUIntToPtr(wxUIntPtr p) #if wxCHECK_WATCOM_VERSION(1,4) #define HAVE_SSIZE_T #endif -#ifndef HAVE_SSIZE_T +#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 @@ -1136,6 +1128,96 @@ inline void *wxUIntToPtr(wxUIntPtr p) #endif #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_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; +#elif SIZEOF_LONG >= SIZEOF_VOID_P + /* + Normal case when long is the largest integral type. + */ + typedef long wxIntPtr; + typedef unsigned long 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 */ @@ -1191,6 +1273,24 @@ typedef double wxDouble; */ #define wxNullPtr ((void *)NULL) + +/* Define wxChar16 and wxChar32 */ + +#if wxUSE_WCHAR_T && (!defined(SIZEOF_WCHAR_T) || (SIZEOF_WCHAR_T == 2)) + #define wxWCHAR_T_IS_WXCHAR16 + typedef wchar_t wxChar16; +#else + typedef wxUint16 wxChar16; +#endif + +#if wxUSE_WCHAR_T && defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4) + #define wxWCHAR_T_IS_WXCHAR32 + typedef wchar_t wxChar32; +#else + typedef wxUint32 wxChar32; +#endif + + /* ---------------------------------------------------------------------------- */ /* byte ordering related definition and macros */ /* ---------------------------------------------------------------------------- */ @@ -1323,6 +1423,8 @@ typedef double wxDouble; #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) @@ -1336,6 +1438,8 @@ typedef double wxDouble; #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 @@ -1361,7 +1465,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 +1486,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 +1511,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 */ @@ -1772,6 +1893,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, @@ -1899,13 +2038,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 */ /* ---------------------------------------------------------------------------- */ @@ -1971,7 +2123,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, @@ -1993,6 +2146,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, @@ -2017,15 +2177,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 */ @@ -2493,11 +2646,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; @@ -2505,54 +2655,59 @@ 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; */ +#if wxOSX_USE_CARBON typedef WX_OPAQUE_TYPE(ControlRef ) * WXWidget ; typedef WX_OPAQUE_TYPE(WindowRef) * WXWindow ; +#endif + 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 - -#if defined( __WXCOCOA__ ) || ( defined(__WXMAC__) && defined(__DARWIN__) ) +/* + * 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 @@ -2647,15 +2802,33 @@ 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__ +#ifndef __WXMAC__ typedef WX_NSView WXWidget; /* wxWidgets BASE definition */ #endif #endif /* __WXCOCOA__ || ( __WXMAC__ &__DARWIN__)*/ +#ifdef __WXMAC__ + +DECLARE_WXCOCOA_OBJC_CLASS(NSString); + +#if wxOSX_USE_COCOA + +typedef WX_NSWindow WXWindow; +typedef WX_NSView WXWidget; + +#elif wxOSX_USE_IPHONE + +DECLARE_WXCOCOA_OBJC_CLASS(UIWindow); +DECLARE_WXCOCOA_OBJC_CLASS(UIView); +DECLARE_WXCOCOA_OBJC_CLASS(UIFont); + +typedef WX_UIWindow WXWindow; +typedef WX_UIView WXWidget; + +#endif + +#endif // __WXMAC__ + #if defined(__WXPALMOS__) typedef void * WXHWND; @@ -2735,13 +2908,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__)