X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/7c08b47173a8dfcdc8af7349bd708c9b84b1d636..1d9301a914cb19e8721fdfae7d6d824444768138:/include/wx/defs.h diff --git a/include/wx/defs.h b/include/wx/defs.h index 1a7e0ff56e..38bba222a7 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 */ /* ---------------------------------------------------------------------------- */ @@ -31,7 +36,9 @@ !defined(__WXPALMOS__)&& \ !defined(__WXGTK__) && \ !defined(__WXPM__) && \ - !defined(__WXMAC__) && \ + !defined(__WXOSX_CARBON__) && \ + !defined(__WXOSX_COCOA__) && \ + !defined(__WXOSX_IPHONE__) && \ !defined(__WXCOCOA__) && \ !defined(__X__) && \ !defined(__WXMGL__) && \ @@ -69,26 +76,47 @@ # 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 */ +# 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) +# 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 */ -# if !defined __WXDEBUG__ && __VISUALC__ <= 1100 +# 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. */ -# if __VISUALC__ <= 1100 # 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 @@ -166,72 +194,6 @@ /* 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 wxCHECK_WATCOM_VERSION(1,0) - /* 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 - #elif defined(__WXPALMOS__) - /* Palm OS supports bool */ - #define HAVE_BOOL - #endif /* compilers */ -#endif /* HAVE_BOOL */ - -#if !defined(__MWERKS__) || !defined(true) -#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 -#endif - /* for backwards compatibility, also define TRUE and FALSE */ /* */ /* note that these definitions should work both in C++ and C code, so don't */ @@ -287,51 +249,10 @@ typedef short int WXTYPE; #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__) - #if wxCHECK_GCC_VERSION(2, 95) - /* GCC 2.95 has C++ casts, what about earlier versions? */ - #define HAVE_CXX_CASTS - #endif - #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 - #ifndef HAVE_DYNAMIC_CAST - #define HAVE_DYNAMIC_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 - -#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) -#else - #define wx_reinterpret_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) /* This one is a wx invention: like static cast but used when we intentionally @@ -347,6 +268,8 @@ typedef short int WXTYPE; #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; @@ -451,8 +374,10 @@ typedef short int WXTYPE; #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 @@ -573,6 +498,17 @@ typedef short int WXTYPE; #define wxDEPRECATED(x) x #endif +/* + explicitly specifying inline allows gcc < 3.4 to + handle the deprecation attribute even in the constructor. + doesn't seem to work on Apple's gcc 4.0.1 unless using -O0 +*/ +#if defined( __DARWIN__ ) && !defined(__WXDEBUG__) + #define wxDEPRECATED_CONSTRUCTOR(x) x +#else + #define wxDEPRECATED_CONSTRUCTOR(x) wxDEPRECATED( inline x) +#endif + /* Macro which marks the function as being deprecated but also defines it inline. @@ -604,15 +540,42 @@ typedef short int WXTYPE; #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 + // delete pointer if it is not NULL and NULL it afterwards + template + inline void wxDELETE(T*& ptr) + { + typedef char TypeIsCompleteCheck[sizeof(T)]; -/* delete an array and NULL it (see comments above) */ -#define wxDELETEA(p) if ( (p) ) { delete [] (p); p = NULL; } + 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])) @@ -739,18 +702,6 @@ typedef short int WXTYPE; /* 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 @@ -980,84 +931,6 @@ typedef wxUint32 wxDword; #define wxINT64_MIN (wxLL(-9223372036854775807)-1) #endif -/* - Define an integral type 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 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 - 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*/ - - /* 64 bit */ /* NB: we #define and not typedef wxLongLong_t because we use "#ifdef */ @@ -1172,20 +1045,26 @@ inline void *wxUIntToPtr(wxUIntPtr p) #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__ - #if defined(_SSIZE_T_) && !defined(HAVE_SSIZE_T) + #if defined(_SSIZE_T_) || defined(_SSIZE_T_DEFINED) #define HAVE_SSIZE_T #endif -#endif -#if defined(__PALMOS__) && !defined(HAVE_SSIZE_T) +#elif defined(__PALMOS__) #define HAVE_SSIZE_T -#endif -#if wxCHECK_WATCOM_VERSION(1,4) +#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 @@ -1195,6 +1074,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 */ @@ -1250,6 +1219,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 */ /* ---------------------------------------------------------------------------- */ @@ -1382,6 +1369,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) @@ -1395,6 +1384,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 @@ -1470,7 +1461,7 @@ enum wxAlignment enum wxSizerFlagBits { /* for compatibility only, default now, don't use explicitly any more */ -#if WXWIN_COMPATIBILITY_2_6 +#if WXWIN_COMPATIBILITY_2_8 wxADJUST_MINSIZE = 0, #endif wxFIXED_MINSIZE = 0x8000, @@ -1799,8 +1790,10 @@ enum wxBorder #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 @@ -1981,6 +1974,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, @@ -2078,7 +2089,16 @@ enum wxHitTest /* GDI descriptions */ /* ---------------------------------------------------------------------------- */ -enum +/* + 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, @@ -2099,7 +2119,34 @@ enum /* Also wxNORMAL for normal (non-italic text) */ wxITALIC, wxSLANT, + + /* Pen styles */ + wxSOLID = 100, + wxDOT, + wxLONG_DASH, + wxSHORT_DASH, + wxDOT_DASH, + wxUSER_DASH, + + wxTRANSPARENT, + + /* Brush & Pen Stippling. Note that a stippled pen cannot be dashed!! */ + /* Note also that stippling a Pen IS meaningfull, 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 }; +#endif /* Logical ops */ typedef enum @@ -2524,6 +2571,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 */ /* ---------------------------------------------------------------------------- */ @@ -2575,15 +2637,18 @@ typedef void* WXEVENTREF; typedef void* WXEVENTHANDLERREF; typedef void* WXEVENTHANDLERCALLREF; typedef void* WXAPPLEEVENTREF; -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 WX_OPAQUE_TYPE(ControlRef ) * WXWidget ; typedef WX_OPAQUE_TYPE(WindowRef) * WXWindow ; +typedef struct __AGLPixelFormatRec *WXGLPixelFormat; +typedef struct __AGLContextRec *WXGLContext; +#endif typedef void* WXDisplay; @@ -2619,9 +2684,13 @@ typedef struct __HIShape * HIMutableShapeRef; 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 @@ -2720,15 +2789,38 @@ 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__ +DECLARE_WXCOCOA_OBJC_CLASS(NSOpenGLContext); +DECLARE_WXCOCOA_OBJC_CLASS(NSOpenGLPixelFormat); +#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; +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); + +typedef WX_UIWindow WXWindow; +typedef WX_UIView WXWidget; + +#endif + +#endif // __WXMAC__ + #if defined(__WXPALMOS__) typedef void * WXHWND; @@ -2772,17 +2864,6 @@ 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; @@ -3078,6 +3159,11 @@ typedef const void* WXWidget; classname(const classname&); \ classname& operator=(const classname&); +#define DECLARE_NO_COPY_TEMPLATE_CLASS(classname, arg) \ + private: \ + classname(const classname&); \ + classname& operator=(const classname&); + #define DECLARE_NO_ASSIGN_CLASS(classname) \ private: \ classname& operator=(const classname&);