]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/defs.h
OSX reshuffling
[wxWidgets.git] / include / wx / defs.h
index 11c305c7a33827d8c2bd7cbf42778aef7b77d57c..15552318263070de7a1c888cbf9447e61c05f092 100644 (file)
 #ifndef _WX_DEFS_H_
 #define _WX_DEFS_H_
 
 #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 */
 /*  ---------------------------------------------------------------------------- */
 /*  ---------------------------------------------------------------------------- */
 /*  compiler and OS identification */
 /*  ---------------------------------------------------------------------------- */
 #       pragma warning(disable:4003)    /* not enough actual parameters for macro */
 #   endif
 
 #       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<int>(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
      */
     /*
        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
         #ifndef _CRT_SECURE_NO_DEPRECATE
             #define _CRT_SECURE_NO_DEPRECATE 1
         #endif
     #endif /* VC++ 8 */
 #endif /*  __VISUALC__ */
 
     #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 */
 /*  suppress some Borland C++ warnings */
 #ifdef __BORLANDC__
 #   pragma warn -inl                /*  Functions containing reserved words and certain constructs are not expanded inline */
             #define false ((bool)0)
         #endif
         #define HAVE_BOOL
             #define false ((bool)0)
         #endif
         #define HAVE_BOOL
+    #elif defined(__WXPALMOS__)
+        /*  Palm OS supports bool */
+        #define HAVE_BOOL
     #endif /*  compilers */
 #endif /*  HAVE_BOOL */
 
     #endif /*  compilers */
 #endif /*  HAVE_BOOL */
 
 
 typedef short int WXTYPE;
 
 
 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 */
 
 /*  ---------------------------------------------------------------------------- */
 /*  other feature tests */
@@ -450,12 +456,50 @@ typedef int wxWindowID;
 
 
 #ifndef HAVE_WOSTREAM
 
 
 #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
         #define HAVE_WOSTREAM
     #endif
+
+    #undef wxNO_WOSTREAM
 #endif /* HAVE_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 */
 /*  ---------------------------------------------------------------------------- */
 /*  ---------------------------------------------------------------------------- */
 /*  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) */
 /*  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 <stddef.h>
 #endif
 
 #include <stddef.h>
 #endif
 
@@ -751,7 +795,9 @@ enum {  wxDefaultCoord = -1 };
 /*  ---------------------------------------------------------------------------- */
 
 #if defined(__WXPALMOS__) || defined(__MINGW32__)
 /*  ---------------------------------------------------------------------------- */
 
 #if defined(__WXPALMOS__) || defined(__MINGW32__)
+  #if !defined(__MWERKS__)
     #include <sys/types.h>
     #include <sys/types.h>
+  #endif
 #endif
 
 /*  chars are always one byte (by definition), shorts are always two (in */
 #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 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__)
     #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 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
 #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 */
 
 
 /*  64 bit */
 
@@ -1058,7 +1038,11 @@ inline void *wxUIntToPtr(wxUIntPtr p)
         #error "See the documentation on the 'longlong' pragma."
     #endif
 #elif defined(__WXPALMOS__)
         #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
     #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__
 #ifdef wxLongLong_t
 
     #ifdef __WXPALMOS__
+    #if defined(__WXPALMOS6__)
         #define wxULongLong_t uint64_t
         #define wxULongLong_t uint64_t
+    #else
+        #define wxULongLong_t unsigned long long
+    #endif /* __WXPALMOS6__ */
     #else
         #define wxULongLong_t unsigned wxLongLong_t
     #endif
     #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
 #if wxCHECK_WATCOM_VERSION(1,4)
     #define HAVE_SSIZE_T
 #endif
-#ifndef HAVE_SSIZE_T
+#ifdef HAVE_SSIZE_T
+    #ifdef __UNIX__
+        #include <sys/types.h>
+    #endif
+#else // !HAVE_SSIZE_T
     #if SIZEOF_SIZE_T == 4
         typedef wxInt32 ssize_t;
     #elif SIZEOF_SIZE_T == 8
     #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
 
     #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 */
 
 /*  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 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 */
 /*  ---------------------------------------------------------------------------- */
 /*  ---------------------------------------------------------------------------- */
 /*  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)
     #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)
     #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)
     #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
 
     #endif
 #endif
 
@@ -1361,7 +1465,10 @@ enum wxOrientation
     wxHORIZONTAL              = 0x0004,
     wxVERTICAL                = 0x0008,
 
     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
 };
 
 enum wxDirection
@@ -1379,7 +1486,10 @@ enum wxDirection
     wxWEST                    = wxLEFT,
     wxEAST                    = wxRIGHT,
 
     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
 };
 
 enum wxAlignment
@@ -1401,20 +1511,31 @@ enum wxAlignment
     wxALIGN_MASK              = 0x0f00
 };
 
     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
 {
     /* for compatibility only, default now, don't use explicitly any more */
 #if WXWIN_COMPATIBILITY_2_6
-    wxADJUST_MINSIZE          = 0,
+    wxADJUST_MINSIZE               = 0,
 #endif
 #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,
     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 */
 };
 
 /*  border flags: the values are chosen for backwards compatibility */
@@ -1772,6 +1893,24 @@ enum wxKeyType
 /*  Standard menu IDs */
 enum
 {
 /*  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,
 
     /* 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 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
 };
 
     /*  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 */
 /*  ---------------------------------------------------------------------------- */
 /*  ---------------------------------------------------------------------------- */
 /*  other constants */
 /*  ---------------------------------------------------------------------------- */
@@ -1971,7 +2123,8 @@ enum wxHitTest
 /*  GDI descriptions */
 /*  ---------------------------------------------------------------------------- */
 
 /*  GDI descriptions */
 /*  ---------------------------------------------------------------------------- */
 
-enum
+/* don't use any elements of this enum in the new code */
+enum wxDeprecatedGUIConstants
 {
     /*  Text font families */
     wxDEFAULT    = 70,
 {
     /*  Text font families */
     wxDEFAULT    = 70,
@@ -1993,6 +2146,13 @@ enum
     wxITALIC,
     wxSLANT,
 
     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,
     /*  Pen styles */
     wxSOLID      =   100,
     wxDOT,
@@ -2017,15 +2177,8 @@ enum
     wxHORIZONTAL_HATCH,
     wxVERTICAL_HATCH,
     wxFIRST_HATCH = wxBDIAGONAL_HATCH,
     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 */
 };
 
 /*  Logical ops */
@@ -2493,11 +2646,8 @@ enum wxUpdateUI
 
 #define WX_OPAQUE_TYPE( name ) struct wxOpaque##name
 
 
 #define WX_OPAQUE_TYPE( name ) struct wxOpaque##name
 
-typedef unsigned char WXCOLORREF[6];
-typedef void*       WXCGIMAGEREF;
 typedef void*       WXHBITMAP;
 typedef void*       WXHCURSOR;
 typedef void*       WXHBITMAP;
 typedef void*       WXHCURSOR;
-typedef void*       WXHRGN;
 typedef void*       WXRECTPTR;
 typedef void*       WXPOINTPTR;
 typedef void*       WXHWND;
 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*       WXEVENTHANDLERREF;
 typedef void*       WXEVENTHANDLERCALLREF;
 typedef void*       WXAPPLEEVENTREF;
-typedef void*       WXHDC;
 typedef void*       WXHMENU;
 typedef void*       WXHMENU;
+
 typedef unsigned int    WXUINT;
 typedef unsigned long   WXDWORD;
 typedef unsigned short  WXWORD;
 
 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(PicHandle ) * WXHMETAFILE ;
-
-
-/* typedef void*       WXWidget; */
-/* typedef void*       WXWindow; */
+#if wxOSX_USE_CARBON
 typedef WX_OPAQUE_TYPE(ControlRef ) * WXWidget ;
 typedef WX_OPAQUE_TYPE(WindowRef) * WXWindow ;
 typedef WX_OPAQUE_TYPE(ControlRef ) * WXWidget ;
 typedef WX_OPAQUE_TYPE(WindowRef) * WXWindow ;
+#endif
+
 typedef void*       WXDisplay;
 
 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
 
 /* 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);
 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__)*/
 
 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;
 #if defined(__WXPALMOS__)
 
 typedef void *          WXHWND;
@@ -2735,13 +2908,13 @@ typedef void *          WXLPCREATESTRUCT;
 typedef WXHWND          WXWidget;
 
 #ifdef __WIN64__
 typedef WXHWND          WXWidget;
 
 #ifdef __WIN64__
-typedef unsigned __int64    WXWPARAM;
+typedef unsigned __int64   WXWPARAM;
 typedef __int64            WXLPARAM;
 typedef __int64            WXLRESULT;
 #else
 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__)
 #endif
 
 #if defined(__GNUWIN32__) || defined(__WXMICROWIN__)