Support using GetTextExtent() with empty string to get descent in wxOSX.

[wxWidgets.git] / include / wx / defs.h

diff --git a/include/wx/defs.h b/include/wx/defs.h
index 88e0bd99794392727952679d926c863c311cf00a..26bbf9721c93fd8755424b7ebbd7baff620799f5 100644 (file)
--- a/include/wx/defs.h
+++ b/include/wx/defs.h
@@ -14,8 +14,10 @@
 #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
+/*
+    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
 
 #define FUTURE_WXWIN_COMPATIBILITY_3_0      1
 #define wxDEPRECATED_FUTURE( x )            x
 


@@ -28,12 +30,9 @@
 #ifdef __cplusplus
 /*  Make sure the environment is set correctly */
 #   if defined(__WXMSW__) && defined(__X__)
 #ifdef __cplusplus
 /*  Make sure the environment is set correctly */
 #   if defined(__WXMSW__) && defined(__X__)

-#       error "Target can't be both X and Windows"
-#   elif defined(__WXMSW__) && defined(__PALMOS__)
-#       error "Target can't be both PalmOS and Windows"
+#       error "Target can't be both X and MSW"

 #   elif !defined(__WXMOTIF__) && \
          !defined(__WXMSW__)   && \
 #   elif !defined(__WXMOTIF__) && \
          !defined(__WXMSW__)   && \

-         !defined(__WXPALMOS__)&& \

          !defined(__WXGTK__)   && \
          !defined(__WXPM__)    && \
          !defined(__WXOSX_CARBON__)   && \
          !defined(__WXGTK__)   && \
          !defined(__WXPM__)    && \
          !defined(__WXOSX_CARBON__)   && \


@@ -41,7 +40,6 @@
          !defined(__WXOSX_IPHONE__)   && \
          !defined(__WXCOCOA__) && \
          !defined(__X__)       && \
          !defined(__WXOSX_IPHONE__)   && \
          !defined(__WXCOCOA__) && \
          !defined(__X__)       && \

-         !defined(__WXMGL__)   && \

          !defined(__WXDFB__)   && \
          !defined(__WXX11__)   && \
           wxUSE_GUI
          !defined(__WXDFB__)   && \
          !defined(__WXX11__)   && \
           wxUSE_GUI


@@ -79,8 +77,10 @@
 #   pragma warning(disable:4514)   /*  unreferenced inline func has been removed */
 #   pragma warning(disable:4710)    /*  function not inlined */
 
 #   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
+    /*
+        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
     #pragma warning(disable: 4127) /*  conditional expression is constant */
 
     /* There are too many false positivies for this one, particularly when


@@ -89,6 +89,16 @@
        class 'bar'" */
 #   pragma warning(disable:4251)
 
        class 'bar'" */
 #   pragma warning(disable:4251)
 

+    /*
+        This is a similar warning which occurs when deriving from standard
+        containers. MSDN even mentions that it can be ignored in this case
+        (albeit only in debug build while the warning is the same in release
+        too and seems equally harmless).
+     */
+#if wxUSE_STD_CONTAINERS
+#   pragma warning(disable:4275)
+#endif /* wxUSE_STD_CONTAINERS */
+

 #   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 */
 #   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 */


@@ -115,7 +125,7 @@
      */
     #ifdef __VISUALC6__
         #pragma warning(disable: 4284)
      */
     #ifdef __VISUALC6__
         #pragma warning(disable: 4284)

-    #endif // VC6
+    #endif /* VC6 */

 
     /*
        When compiling with VC++ 7 /Wp64 option we get thousands of warnings for
 
     /*
        When compiling with VC++ 7 /Wp64 option we get thousands of warnings for


@@ -165,6 +175,18 @@
 #   define wxSUPPRESS_GCC_PRIVATE_DTOR_WARNING(name)
 #endif
 
 #   define wxSUPPRESS_GCC_PRIVATE_DTOR_WARNING(name)
 #endif
 

+/*
+   Clang Support
+ */
+ 
+#ifndef WX_HAS_CLANG_FEATURE
+#   ifndef __has_feature      
+#       define WX_HAS_CLANG_FEATURE(x) 0 
+#   else
+#       define WX_HAS_CLANG_FEATURE(x) __has_feature(x)
+#   endif
+#endif
+

 /*  ---------------------------------------------------------------------------- */
 /*  wxWidgets version and compatibility defines */
 /*  ---------------------------------------------------------------------------- */
 /*  ---------------------------------------------------------------------------- */
 /*  wxWidgets version and compatibility defines */
 /*  ---------------------------------------------------------------------------- */


@@ -193,6 +215,12 @@
 #define va_list __gnuc_va_list
 #endif /*  HP-UX */
 
 #define va_list __gnuc_va_list
 #endif /*  HP-UX */
 

+/* Prevents conflicts between sys/types.h and winsock.h with Cygwin, */
+/* when using Windows sockets. */
+#if defined(__CYGWIN__) && defined(__WXMSW__)
+#define __USE_W32_SOCKETS
+#endif
+

 /*  ---------------------------------------------------------------------------- */
 /*  check for native bool type and TRUE/FALSE constants */
 /*  ---------------------------------------------------------------------------- */
 /*  ---------------------------------------------------------------------------- */
 /*  check for native bool type and TRUE/FALSE constants */
 /*  ---------------------------------------------------------------------------- */


@@ -236,9 +264,6 @@ typedef short int WXTYPE;
     #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x0520)
         /*  BC++ 4.52 doesn't support explicit, CBuilder 1 does */
         #define HAVE_EXPLICIT
     #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x0520)
         /*  BC++ 4.52 doesn't support explicit, CBuilder 1 does */
         #define HAVE_EXPLICIT

-    #elif defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
-        /*  Metrowerks CW6 or higher has explicit */
-        #define HAVE_EXPLICIT

     #elif defined(__DIGITALMARS__)
         #define HAVE_EXPLICIT
     #elif defined(__WATCOMC__)
     #elif defined(__DIGITALMARS__)
         #define HAVE_EXPLICIT
     #elif defined(__WATCOMC__)


@@ -325,6 +350,38 @@ typedef short int WXTYPE;
     #endif
 #endif
 
     #endif
 #endif
 

+#ifndef HAVE_TR1_TYPE_TRAITS
+    #if defined(__VISUALC__) && (_MSC_FULL_VER >= 150030729)
+        #define HAVE_TR1_TYPE_TRAITS
+    #endif
+#endif
+
+#if defined(__has_include)
+    #if !defined(HAVE_TYPE_TRAITS) && __has_include(<type_traits>)
+        #define HAVE_TYPE_TRAITS
+    #endif
+
+    #if !defined(HAVE_TR1_TYPE_TRAITS) && __has_include(<tr1/type_traits>)
+        #define HAVE_TR1_TYPE_TRAITS
+    #endif
+
+    #if !defined(HAVE_STD_UNORDERED_MAP) && __has_include(<unordered_map>)
+        #define HAVE_STD_UNORDERED_MAP
+    #endif
+
+    #if !defined(HAVE_TR1_UNORDERED_MAP) && __has_include(<tr1/unordered_map>)
+        #define HAVE_TR1_UNORDERED_MAP
+    #endif
+
+    #if !defined(HAVE_STD_UNORDERED_SET) && __has_include(<unordered_set>)
+        #define HAVE_STD_UNORDERED_SET
+    #endif
+
+    #if !defined(HAVE_TR1_UNORDERED_SET) && __has_include(<tr1/unordered_set>)
+        #define HAVE_TR1_UNORDERED_SET
+    #endif
+#endif // defined(__has_include)
+

 /* provide replacement for C99 va_copy() if the compiler doesn't have it */
 
 /* could be already defined by configure or the user */
 /* provide replacement for C99 va_copy() if the compiler doesn't have it */
 
 /* could be already defined by configure or the user */


@@ -368,23 +425,16 @@ typedef short int WXTYPE;
     #endif /* va_copy/!va_copy */
 #endif /* wxVaCopy */
 
     #endif /* va_copy/!va_copy */
 #endif /* wxVaCopy */
 

-#ifndef HAVE_VARIADIC_MACROS
-    #if wxCHECK_WATCOM_VERSION(1,2)
-        #define HAVE_VARIADIC_MACROS
-    #endif
-#endif /* HAVE_VARIADIC_MACROS */
-
-

 #ifndef HAVE_WOSTREAM
 #ifndef HAVE_WOSTREAM

-    // Mingw <= 3.4 and all versions of Cygwin as well as any gcc version (so
-    // far) targeting PalmOS don't have std::wostream
-    #if defined(__PALMOS__) || \
-        (defined(__MINGW32__) && !wxCHECK_GCC_VERSION(4, 0)) || \
+    /*
+        Mingw <= 3.4 and all versions of Cygwin don't have std::wostream
+     */
+    #if (defined(__MINGW32__) && !wxCHECK_GCC_VERSION(4, 0)) || \

         defined(__CYGWIN__)
         #define wxNO_WOSTREAM
     #endif
 
         defined(__CYGWIN__)
         #define wxNO_WOSTREAM
     #endif
 

-    // VC++ doesn't have it in the old iostream library
+    /* VC++ doesn't have it in the old iostream library */

     #if defined(__VISUALC__) && wxUSE_IOSTREAMH
         #define wxNO_WOSTREAM
     #endif
     #if defined(__VISUALC__) && wxUSE_IOSTREAMH
         #define wxNO_WOSTREAM
     #endif


@@ -396,12 +446,12 @@ typedef short int WXTYPE;
     #undef wxNO_WOSTREAM
 #endif /* HAVE_WOSTREAM */
 
     #undef wxNO_WOSTREAM
 #endif /* HAVE_WOSTREAM */
 

-// ----------------------------------------------------------------------------
-// other C++ features
-// ----------------------------------------------------------------------------
+/*  ---------------------------------------------------------------------------- */
+/*  other C++ features */
+/*  ---------------------------------------------------------------------------- */

 
 #ifndef HAVE_PARTIAL_SPECIALIZATION
 
 #ifndef HAVE_PARTIAL_SPECIALIZATION

-    // be optimistic by default
+    /* be optimistic by default */

     #define HAVE_PARTIAL_SPECIALIZATION
 #endif
 
     #define HAVE_PARTIAL_SPECIALIZATION
 #endif
 


@@ -409,17 +459,17 @@ typedef short int WXTYPE;
     #if __VISUALC__ < 1310
         #undef HAVE_PARTIAL_SPECIALIZATION
     #endif
     #if __VISUALC__ < 1310
         #undef HAVE_PARTIAL_SPECIALIZATION
     #endif

-#endif // __VISUALC__
+#endif /* __VISUALC__ */

 
 
 #ifndef HAVE_TEMPLATE_OVERLOAD_RESOLUTION
 
 
 #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
+    /* 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
     #if defined(HAVE_PARTIAL_SPECIALIZATION) && !defined(__BORLANDC__)
         #define HAVE_TEMPLATE_OVERLOAD_RESOLUTION

-    #endif // __BORLANDC__
-#endif // !defined(HAVE_TEMPLATE_OVERLOAD_RESOLUTION)
+    #endif /* (HAVE_PARTIAL_SPECIALIZATION) && !defined(__BORLANDC__) */
+#endif /* !defined(HAVE_TEMPLATE_OVERLOAD_RESOLUTION) */

 
 /*  ---------------------------------------------------------------------------- */
 /*  portable calling conventions macros */
 
 /*  ---------------------------------------------------------------------------- */
 /*  portable calling conventions macros */


@@ -439,7 +489,7 @@ typedef short int WXTYPE;
     #define wxSTDCALL
 #endif /*  platform */
 
     #define wxSTDCALL
 #endif /*  platform */
 

-/*  LINKAGEMODE mode is empty for everyting except OS/2 */
+/*  LINKAGEMODE mode is empty for everything except OS/2 */

 #ifndef LINKAGEMODE
     #define LINKAGEMODE
 #endif /*  LINKAGEMODE */
 #ifndef LINKAGEMODE
     #define LINKAGEMODE
 #endif /*  LINKAGEMODE */


@@ -491,6 +541,23 @@ typedef short int WXTYPE;
 #   define WX_ATTRIBUTE_PRINTF_5 WX_ATTRIBUTE_PRINTF(5, 6)
 #endif /* !defined(WX_ATTRIBUTE_PRINTF) */
 
 #   define WX_ATTRIBUTE_PRINTF_5 WX_ATTRIBUTE_PRINTF(5, 6)
 #endif /* !defined(WX_ATTRIBUTE_PRINTF) */
 

+#ifndef WX_ATTRIBUTE_NORETURN
+#   if WX_HAS_CLANG_FEATURE(attribute_analyzer_noreturn)
+#       define WX_ATTRIBUTE_NORETURN __attribute__((analyzer_noreturn))
+#   elif defined( __GNUC__ )
+#       define WX_ATTRIBUTE_NORETURN __attribute__ ((noreturn))
+#   elif wxCHECK_VISUALC_VERSION(7)
+#       define WX_ATTRIBUTE_NORETURN __declspec(noreturn)
+#   else
+#       define WX_ATTRIBUTE_NORETURN
+#   endif
+#endif
+
+#if defined(__GNUC__)
+    #define WX_ATTRIBUTE_UNUSED __attribute__ ((unused))
+#else
+    #define WX_ATTRIBUTE_UNUSED
+#endif

 
 /*  Macro to issue warning when using deprecated functions with gcc3 or MSVC7: */
 #if wxCHECK_GCC_VERSION(3, 1)
 
 /*  Macro to issue warning when using deprecated functions with gcc3 or MSVC7: */
 #if wxCHECK_GCC_VERSION(3, 1)


@@ -501,15 +568,14 @@ typedef short int WXTYPE;
     #define wxDEPRECATED(x) x
 #endif
 
     #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 wxCHECK_GCC_VERSION(3, 4) || defined( __DARWIN__ )
-    #define  wxDEPRECATED_CONSTRUCTOR(x) x
-#else
+#if defined(__GNUC__) && !wxCHECK_GCC_VERSION(3, 4)
+    /*
+        We need to add dummy "inline" to allow gcc < 3.4 to handle the
+        deprecation attribute on the constructors.
+    */

     #define  wxDEPRECATED_CONSTRUCTOR(x) wxDEPRECATED( inline x)
     #define  wxDEPRECATED_CONSTRUCTOR(x) wxDEPRECATED( inline x)

+#else
+    #define  wxDEPRECATED_CONSTRUCTOR(x) wxDEPRECATED(x)

 #endif
 
 /*
 #endif
 
 /*


@@ -538,6 +604,27 @@ typedef short int WXTYPE;
 #   define wxDEPRECATED_BUT_USED_INTERNALLY(x) wxDEPRECATED(x)
 #endif
 
 #   define wxDEPRECATED_BUT_USED_INTERNALLY(x) wxDEPRECATED(x)
 #endif
 

+/*
+   Macros to suppress and restore gcc warnings, requires g++ >= 4.6 and don't
+   do anything otherwise.
+
+   Example of use:
+
+        wxGCC_WARNING_SUPPRESS(float-equal)
+        inline bool wxIsSameDouble(double x, double y) { return x == y; }
+        wxGCC_WARNING_RESTORE(float-equal)
+ */
+#if wxCHECK_GCC_VERSION(4, 6)
+#   define wxGCC_WARNING_SUPPRESS(x) \
+        _Pragma (wxSTRINGIZE(GCC diagnostic push)) \
+        _Pragma (wxSTRINGIZE(GCC diagnostic ignored wxSTRINGIZE(wxCONCAT(-W,x))))
+#   define wxGCC_WARNING_RESTORE(x) \
+       _Pragma (wxSTRINGIZE(GCC diagnostic pop))
+#else /* gcc < 4.6 or not gcc at all */
+#   define wxGCC_WARNING_SUPPRESS(x)
+#   define wxGCC_WARNING_RESTORE(x)
+#endif
+

 /*
     Combination of the two variants above: should be used for deprecated
     functions which are defined inline and are used by wxWidgets itself.
 /*
     Combination of the two variants above: should be used for deprecated
     functions which are defined inline and are used by wxWidgets itself.


@@ -552,7 +639,7 @@ typedef short int WXTYPE;
 /*  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) */

-#if !defined(__HANDHELDPC__) && !defined(__PALMOS__)
+#if !defined(__HANDHELDPC__)

 #include <stddef.h>
 #endif
 
 #include <stddef.h>
 #endif
 


@@ -565,7 +652,7 @@ typedef short int WXTYPE;
     template <typename T>
     inline void wxDELETE(T*& ptr)
     {
     template <typename T>
     inline void wxDELETE(T*& ptr)
     {

-        typedef char TypeIsCompleteCheck[sizeof(T)];
+        typedef char TypeIsCompleteCheck[sizeof(T)] WX_ATTRIBUTE_UNUSED;

 
         if ( ptr != NULL )
         {
 
         if ( ptr != NULL )
         {


@@ -578,7 +665,7 @@ typedef short int WXTYPE;
     template <typename T>
     inline void wxDELETEA(T*& ptr)
     {
     template <typename T>
     inline void wxDELETEA(T*& ptr)
     {

-        typedef char TypeIsCompleteCheck[sizeof(T)];
+        typedef char TypeIsCompleteCheck[sizeof(T)] WX_ATTRIBUTE_UNUSED;

 
         if ( ptr != NULL )
         {
 
         if ( ptr != NULL )
         {


@@ -628,9 +715,13 @@ typedef short int WXTYPE;
     m(==,x,y,z) m(!=,x,y,z) m(>=,x,y,z) m(<=,x,y,z) m(>,x,y,z) m(<,x,y,z)
 
 /*
     m(==,x,y,z) m(!=,x,y,z) m(>=,x,y,z) m(<=,x,y,z) m(>,x,y,z) m(<,x,y,z)
 
 /*

-    This is only used with wxDEFINE_COMPARISON_REV: it passes both the normal
-    and the reversed comparison operators to the macro.
+    These are only used with wxDEFINE_COMPARISON_[BY_]REV: they pass both the
+    normal and the reversed comparison operators to the macro.

  */
  */

+#define wxFOR_ALL_COMPARISONS_2_REV(m, x, y) \
+    m(==,x,y,==) m(!=,x,y,!=) m(>=,x,y,<=) \
+    m(<=,x,y,>=) m(>,x,y,<) m(<,x,y,>)
+

 #define wxFOR_ALL_COMPARISONS_3_REV(m, x, y, z) \
     m(==,x,y,z,==) m(!=,x,y,z,!=) m(>=,x,y,z,<=) \
     m(<=,x,y,z,>=) m(>,x,y,z,<) m(<,x,y,z,>)
 #define wxFOR_ALL_COMPARISONS_3_REV(m, x, y, z) \
     m(==,x,y,z,==) m(!=,x,y,z,!=) m(>=,x,y,z,<=) \
     m(<=,x,y,z,>=) m(>,x,y,z,<) m(<,x,y,z,>)


@@ -642,6 +733,9 @@ typedef short int WXTYPE;
 #define wxDEFINE_COMPARISON_REV(op, T1, T2, cmp, oprev) \
     inline bool operator op(T2 y, T1 x) { return cmp(x, y, oprev); }
 
 #define wxDEFINE_COMPARISON_REV(op, T1, T2, cmp, oprev) \
     inline bool operator op(T2 y, T1 x) { return cmp(x, y, oprev); }
 

+#define wxDEFINE_COMPARISON_BY_REV(op, T1, T2, oprev) \
+    inline bool operator op(T1 x, T2 y) { return y oprev x; }
+

 /*
     Define all 6 comparison operators (==, !=, <, <=, >, >=) for the given
     types in the specified order. The implementation is provided by the cmp
 /*
     Define all 6 comparison operators (==, !=, <, <=, >, >=) for the given
     types in the specified order. The implementation is provided by the cmp


@@ -651,6 +745,14 @@ typedef short int WXTYPE;
 #define wxDEFINE_COMPARISONS(T1, T2, cmp) \
     wxFOR_ALL_COMPARISONS_3(wxDEFINE_COMPARISON, T1, T2, cmp)
 
 #define wxDEFINE_COMPARISONS(T1, T2, cmp) \
     wxFOR_ALL_COMPARISONS_3(wxDEFINE_COMPARISON, T1, T2, cmp)
 

+/*
+    Define all 6 comparison operators (==, !=, <, <=, >, >=) for the given
+    types in the specified order, implemented in terms of existing operators
+    for the reverse order.
+ */
+#define wxDEFINE_COMPARISONS_BY_REV(T1, T2) \
+    wxFOR_ALL_COMPARISONS_2_REV(wxDEFINE_COMPARISON_BY_REV, T1, T2)
+

 /*
     This macro allows to define all 12 comparison operators (6 operators for
     both orders of arguments) for the given types using the provided "cmp"
 /*
     This macro allows to define all 12 comparison operators (6 operators for
     both orders of arguments) for the given types using the provided "cmp"


@@ -719,13 +821,6 @@ typedef short int WXTYPE;
 /*  compiler specific settings */
 /*  ---------------------------------------------------------------------------- */
 
 /*  compiler specific settings */
 /*  ---------------------------------------------------------------------------- */
 

-#if defined(__MWERKS__)
-    #undef try
-    #undef except
-    #undef finally
-    #define except(x) catch(...)
-#endif /*  Metrowerks */
-

 #if wxONLY_WATCOM_EARLIER_THAN(1,4)
     typedef short mode_t;
 #endif
 #if wxONLY_WATCOM_EARLIER_THAN(1,4)
     typedef short mode_t;
 #endif


@@ -733,13 +828,10 @@ typedef short int WXTYPE;
 /*  where should i put this? we need to make sure of this as it breaks */
 /*  the <iostream> code. */
 #if !wxUSE_IOSTREAMH && defined(__WXDEBUG__)
 /*  where should i put this? we need to make sure of this as it breaks */
 /*  the <iostream> code. */
 #if !wxUSE_IOSTREAMH && defined(__WXDEBUG__)

-#  ifndef __MWERKS__
-/*  #undef __WXDEBUG__ */

 #    ifdef wxUSE_DEBUG_NEW_ALWAYS
 #    undef wxUSE_DEBUG_NEW_ALWAYS
 #    define wxUSE_DEBUG_NEW_ALWAYS 0
 #    endif
 #    ifdef wxUSE_DEBUG_NEW_ALWAYS
 #    undef wxUSE_DEBUG_NEW_ALWAYS
 #    define wxUSE_DEBUG_NEW_ALWAYS 0
 #    endif

-#  endif

 #endif
 
 /*  ---------------------------------------------------------------------------- */
 #endif
 
 /*  ---------------------------------------------------------------------------- */


@@ -755,10 +847,8 @@ enum {  wxDefaultCoord = -1 };
 /*  define fixed length types */
 /*  ---------------------------------------------------------------------------- */
 
 /*  define fixed length types */
 /*  ---------------------------------------------------------------------------- */
 

-#if defined(__WXPALMOS__) || defined(__MINGW32__)
-  #if !defined(__MWERKS__)
+#if defined(__MINGW32__)

     #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,34 +897,31 @@ typedef wxUint16 wxWord;
  */
 
 /*  32bit */
  */
 
 /*  32bit */

-#ifdef __PALMOS__
-    typedef int wxInt32;
-    typedef unsigned int wxUint32;
-    #define SIZEOF_INT 4
-    #define SIZEOF_LONG 4
-    #define SIZEOF_WCHAR_T 2
-    #define SIZEOF_SIZE_T 4
-    #ifdef __WXPALMOS6__
-        #define wxSIZE_T_IS_UINT
-    #endif
-    #define SIZEOF_VOID_P 4
-    #define SIZEOF_SIZE_T 4
-#elif defined(__WINDOWS__)
-    /*  Win64 uses LLP64 model and so ints and longs have the same size as in */
-    /*  Win32 */
+#if defined(__WINDOWS__)

     #if defined(__WIN32__)
         typedef int wxInt32;
         typedef unsigned int wxUint32;
 
     #if defined(__WIN32__)
         typedef int wxInt32;
         typedef unsigned int wxUint32;
 

-        /* Assume that if SIZEOF_INT is defined that all the other ones except
-           SIZEOF_SIZE_T, are too.  See next #if below.  */
+        /*
+            Win64 uses LLP64 model and so ints and longs have the same size as
+            in Win32.
+         */

         #ifndef SIZEOF_INT
             #define SIZEOF_INT 4
         #ifndef SIZEOF_INT
             #define SIZEOF_INT 4

+        #endif
+
+        #ifndef SIZEOF_LONG

             #define SIZEOF_LONG 4
             #define SIZEOF_LONG 4

+        #endif
+
+        #ifndef SIZEOF_WCHAR_T
+            /* Windows uses UTF-16 */

             #define SIZEOF_WCHAR_T 2
             #define SIZEOF_WCHAR_T 2

+        #endif

 
 

+        #ifndef SIZEOF_SIZE_T

             /*
             /*

-               under Win64 sizeof(size_t) == 8 and so it is neither unsigned
+               Under Win64 sizeof(size_t) == 8 and so it is neither unsigned

                int nor unsigned long!
              */
             #ifdef __WIN64__
                int nor unsigned long!
              */
             #ifdef __WIN64__


@@ -847,25 +934,14 @@ typedef wxUint16 wxWord;
                 #define wxSIZE_T_IS_UINT
             #endif
             #undef wxSIZE_T_IS_ULONG
                 #define wxSIZE_T_IS_UINT
             #endif
             #undef wxSIZE_T_IS_ULONG

+        #endif

 
 

+        #ifndef SIZEOF_VOID_P

             #ifdef __WIN64__
                 #define SIZEOF_VOID_P 8
             #else /*  Win32 */
                 #define SIZEOF_VOID_P 4
             #endif /*  Win64/32 */
             #ifdef __WIN64__
                 #define SIZEOF_VOID_P 8
             #else /*  Win32 */
                 #define SIZEOF_VOID_P 4
             #endif /*  Win64/32 */

-        #endif /*  !defined(SIZEOF_INT) */
-
-        /*
-          If Python.h was included first, it defines all of the SIZEOF's above
-          except for SIZEOF_SIZE_T, so we need to do it here to avoid
-          triggering the #error in the ssize_t typedefs below...
-        */
-        #ifndef SIZEOF_SIZE_T
-            #ifdef __WIN64__
-                #define SIZEOF_SIZE_T 8
-            #else /* Win32 */
-                #define SIZEOF_SIZE_T 4
-            #endif

         #endif
     #else
         #error "Unsupported Windows version"
         #endif
     #else
         #error "Unsupported Windows version"


@@ -999,23 +1075,6 @@ typedef wxUint32 wxDword;
     #define wxLongLong_t long long
     #define wxLongLongSuffix ll
     #define wxLongLongFmtSpec "I64"
     #define wxLongLong_t long long
     #define wxLongLongSuffix ll
     #define wxLongLongFmtSpec "I64"

-#elif defined(__MWERKS__)
-    #if __option(longlong)
-        #define wxLongLong_t long long
-        #define wxLongLongSuffix ll
-        #define wxLongLongFmtSpec "ll"
-    #else
-        #error "The 64 bit integer support in CodeWarrior has been disabled."
-        #error "See the documentation on the 'longlong' pragma."
-    #endif
-#elif defined(__WXPALMOS__)
-    #if defined(__WXPALMOS6__)
-        #define wxLongLong_t int64_t
-    #else
-        #define wxLongLong_t long long
-    #endif /* __WXPALMOS6__ */
-    #define wxLongLongSuffix ll
-    #define wxLongLongFmtSpec "ll"

 #elif defined(__VISAGECPP__) && __IBMCPP__ >= 400
     #define wxLongLong_t long long
 #elif (defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8)  || \
 #elif defined(__VISAGECPP__) && __IBMCPP__ >= 400
     #define wxLongLong_t long long
 #elif (defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8)  || \


@@ -1035,26 +1094,32 @@ typedef wxUint32 wxDword;
 
 
 #ifdef wxLongLong_t
 
 
 #ifdef wxLongLong_t

+    #define wxULongLong_t unsigned wxLongLong_t

 
 

-    #ifdef __WXPALMOS__
-    #if defined(__WXPALMOS6__)
-        #define wxULongLong_t uint64_t
-    #else
-        #define wxULongLong_t unsigned long long
-    #endif /* __WXPALMOS6__ */
+    /*
+        wxLL() and wxULL() macros allow to define 64 bit constants in a
+        portable way.
+     */
+    #ifndef wxCOMPILER_BROKEN_CONCAT_OPER
+        #define wxLL(x) wxCONCAT(x, wxLongLongSuffix)
+        #define wxULL(x) wxCONCAT(x, wxCONCAT(u, wxLongLongSuffix))

     #else
     #else

-        #define wxULongLong_t unsigned wxLongLong_t
+        /*
+            Currently only Borland compiler has broken concatenation operator
+            and this compiler is known to use [u]i64 suffix.
+         */
+        #define wxLL(x) wxAPPEND_i64(x)
+        #define wxULL(x) wxAPPEND_ui64(x)

     #endif
 
     #endif
 

-    /*  these macros allow to define 64 bit constants in a portable way */
-    #define wxLL(x) wxCONCAT(x, wxLongLongSuffix)
-    #define wxULL(x) wxCONCAT(x, wxCONCAT(u, wxLongLongSuffix))
-

     typedef wxLongLong_t wxInt64;
     typedef wxULongLong_t wxUint64;
 
     #define wxHAS_INT64 1
 
     typedef wxLongLong_t wxInt64;
     typedef wxULongLong_t wxUint64;
 
     #define wxHAS_INT64 1
 

+    #ifndef wxLongLongIsLong
+        #define wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
+    #endif

 #elif wxUSE_LONGLONG
     /*  these macros allow to define 64 bit constants in a portable way */
     #define wxLL(x) wxLongLong(x)
 #elif wxUSE_LONGLONG
     /*  these macros allow to define 64 bit constants in a portable way */
     #define wxLL(x) wxLongLong(x)


@@ -1071,6 +1136,17 @@ typedef wxUint32 wxDword;
 
 #endif
 
 
 #endif
 

+/*
+    Helper macro for conditionally compiling some code only if wxLongLong_t is
+    available and is a type different from the other integer types (i.e. not
+    long).
+ */
+#ifdef wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
+    #define wxIF_LONG_LONG_TYPE(x) x
+#else
+    #define wxIF_LONG_LONG_TYPE(x)
+#endif
+

 
 /* Make sure ssize_t is defined (a signed type the same size as size_t). */
 /* (HAVE_SSIZE_T is not already defined by configure) */
 
 /* Make sure ssize_t is defined (a signed type the same size as size_t). */
 /* (HAVE_SSIZE_T is not already defined by configure) */


@@ -1079,8 +1155,6 @@ typedef wxUint32 wxDword;
     #if defined(_SSIZE_T_) || defined(_SSIZE_T_DEFINED)
         #define HAVE_SSIZE_T
     #endif
     #if defined(_SSIZE_T_) || defined(_SSIZE_T_DEFINED)
         #define HAVE_SSIZE_T
     #endif

-#elif defined(__PALMOS__)
-    #define HAVE_SSIZE_T

 #elif wxCHECK_WATCOM_VERSION(1,4)
     #define HAVE_SSIZE_T
 #endif
 #elif wxCHECK_WATCOM_VERSION(1,4)
     #define HAVE_SSIZE_T
 #endif


@@ -1091,7 +1165,7 @@ typedef wxUint32 wxDword;
     #ifdef __UNIX__
         #include <sys/types.h>
     #endif
     #ifdef __UNIX__
         #include <sys/types.h>
     #endif

-#else // !HAVE_SSIZE_T
+#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


@@ -1104,11 +1178,13 @@ typedef wxUint32 wxDword;
     #define HAVE_SSIZE_T
 #endif
 
     #define HAVE_SSIZE_T
 #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)
+/*
+    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
 #if wxCHECK_VISUALC_VERSION(7)
     #define wxW64 __w64
 #else


@@ -1119,7 +1195,13 @@ typedef wxUint32 wxDword;
    Define signed and unsigned integral types big enough to contain all of long,
    size_t and void *.
  */
    Define signed and unsigned integral types big enough to contain all of long,
    size_t and void *.
  */

-#if SIZEOF_SIZE_T >= SIZEOF_VOID_P
+#if SIZEOF_LONG >= SIZEOF_VOID_P
+    /*
+       Normal case when long is the largest integral type.
+     */
+    typedef long wxIntPtr;
+    typedef unsigned long wxUIntPtr;
+#elif SIZEOF_SIZE_T >= SIZEOF_VOID_P

     /*
        Win64 case: size_t is the only integral type big enough for "void *".
 
     /*
        Win64 case: size_t is the only integral type big enough for "void *".
 


@@ -1129,12 +1211,6 @@ typedef wxUint32 wxDword;
      */
     typedef wxW64 ssize_t wxIntPtr;
     typedef size_t wxUIntPtr;
      */
     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
 #else
     /*
        This should never happen for the current architectures but if you're


@@ -1203,11 +1279,7 @@ inline void *wxUIntToPtr(wxUIntPtr p)
 /*            calculations */
 
 typedef float wxFloat32;
 /*            calculations */
 
 typedef float wxFloat32;

-#if (defined( __WXMAC__ ) || defined(__WXCOCOA__))  && defined (__MWERKS__)
-    typedef short double wxFloat64;
-#else
-    typedef double wxFloat64;
-#endif
+typedef double wxFloat64;

 
 typedef double wxDouble;
 
 
 typedef double wxDouble;
 


@@ -1267,6 +1339,63 @@ typedef double wxDouble;
 #endif
 
 
 #endif
 
 

+/*
+    Helper macro expanding into the given "m" macro invoked with each of the
+    integer types as parameter (notice that this does not include char/unsigned
+    char and bool but does include wchar_t).
+ */
+#define wxDO_FOR_INT_TYPES(m) \
+    m(short) \
+    m(unsigned short) \
+    m(int) \
+    m(unsigned int) \
+    m(long) \
+    m(unsigned long) \
+    wxIF_LONG_LONG_TYPE( m(wxLongLong_t) ) \
+    wxIF_LONG_LONG_TYPE( m(wxULongLong_t) ) \
+    wxIF_WCHAR_T_TYPE( m(wchar_t) )
+
+/*
+    Same as wxDO_FOR_INT_TYPES() but does include char and unsigned char.
+
+    Notice that we use "char" and "unsigned char" here but not "signed char"
+    which would be more correct as "char" could be unsigned by default. But
+    wxWidgets code currently supposes that char is signed and we'd need to
+    clean up assumptions about it, notably in wx/unichar.h, to be able to use
+    "signed char" here.
+ */
+#define wxDO_FOR_CHAR_INT_TYPES(m) \
+    m(char) \
+    m(unsigned char) \
+    wxDO_FOR_INT_TYPES(m)
+
+/*
+    Same as wxDO_FOR_INT_TYPES() above except that m macro takes the
+    type as the first argument and some extra argument, passed from this macro
+    itself, as the second one.
+ */
+#define wxDO_FOR_INT_TYPES_1(m, arg) \
+    m(short, arg) \
+    m(unsigned short, arg) \
+    m(int, arg) \
+    m(unsigned int, arg) \
+    m(long, arg) \
+    m(unsigned long, arg) \
+    wxIF_LONG_LONG_TYPE( m(wxLongLong_t, arg) ) \
+    wxIF_LONG_LONG_TYPE( m(wxULongLong_t, arg) ) \
+    wxIF_WCHAR_T_TYPE( m(wchar_t, arg) )
+
+/*
+    Combination of wxDO_FOR_CHAR_INT_TYPES() and wxDO_FOR_INT_TYPES_1():
+    invokes the given macro with the specified argument as its second parameter
+    for all char and int types.
+ */
+#define wxDO_FOR_CHAR_INT_TYPES_1(m, arg) \
+    m(char, arg) \
+    m(unsigned char, arg) \
+    wxDO_FOR_INT_TYPES_1(m, arg)
+
+

 /*  ---------------------------------------------------------------------------- */
 /*  byte ordering related definition and macros */
 /*  ---------------------------------------------------------------------------- */
 /*  ---------------------------------------------------------------------------- */
 /*  byte ordering related definition and macros */
 /*  ---------------------------------------------------------------------------- */


@@ -1285,36 +1414,6 @@ typedef double wxDouble;
 
 /*  byte swapping */
 
 
 /*  byte swapping */
 

-#if defined (__MWERKS__) && ( (__MWERKS__ < 0x0900) || macintosh )
-/*  assembler versions for these */
-#ifdef __POWERPC__
-    inline wxUint16 wxUINT16_SWAP_ALWAYS( wxUint16 i )
-        {return (__lhbrx( &i , 0 ) );}
-    inline wxInt16 wxINT16_SWAP_ALWAYS( wxInt16 i )
-        {return (__lhbrx( &i , 0 ) );}
-    inline wxUint32 wxUINT32_SWAP_ALWAYS( wxUint32 i )
-        {return (__lwbrx( &i , 0 ) );}
-    inline wxInt32 wxINT32_SWAP_ALWAYS( wxInt32 i )
-        {return (__lwbrx( &i , 0 ) );}
-#else
-    #pragma parameter __D0 wxUINT16_SWAP_ALWAYS(__D0)
-    pascal wxUint16 wxUINT16_SWAP_ALWAYS(wxUint16 value)
-        = { 0xE158 };
-
-    #pragma parameter __D0 wxINT16_SWAP_ALWAYS(__D0)
-    pascal wxInt16 wxINT16_SWAP_ALWAYS(wxInt16 value)
-        = { 0xE158 };
-
-    #pragma parameter __D0 wxUINT32_SWAP_ALWAYS (__D0)
-    pascal wxUint32 wxUINT32_SWAP_ALWAYS(wxUint32 value)
-        = { 0xE158, 0x4840, 0xE158 };
-
-    #pragma parameter __D0 wxINT32_SWAP_ALWAYS (__D0)
-    pascal wxInt32 wxINT32_SWAP_ALWAYS(wxInt32 value)
-        = { 0xE158, 0x4840, 0xE158 };
-
-#endif
-#else /*  !MWERKS */

 #define wxUINT16_SWAP_ALWAYS(val) \
    ((wxUint16) ( \
     (((wxUint16) (val) & (wxUint16) 0x00ffU) << 8) | \
 #define wxUINT16_SWAP_ALWAYS(val) \
    ((wxUint16) ( \
     (((wxUint16) (val) & (wxUint16) 0x00ffU) << 8) | \


@@ -1338,7 +1437,6 @@ typedef double wxDouble;
     (((wxUint32) (val) & (wxUint32) 0x0000ff00U) <<  8) | \
     (((wxUint32) (val) & (wxUint32) 0x00ff0000U) >>  8) | \
     (((wxUint32) (val) & (wxUint32) 0xff000000U) >> 24)))
     (((wxUint32) (val) & (wxUint32) 0x0000ff00U) <<  8) | \
     (((wxUint32) (val) & (wxUint32) 0x00ff0000U) >>  8) | \
     (((wxUint32) (val) & (wxUint32) 0xff000000U) >> 24)))

-#endif

 /*  machine specific byte swapping */
 
 #ifdef wxLongLong_t
 /*  machine specific byte swapping */
 
 #ifdef wxLongLong_t


@@ -1419,6 +1517,45 @@ typedef double wxDouble;
     #endif
 #endif
 
     #endif
 #endif
 

+/*  ---------------------------------------------------------------------------- */
+/*  template workarounds for buggy compilers */
+/*  ---------------------------------------------------------------------------- */
+
+#if defined(__GNUC__) && !wxCHECK_GCC_VERSION( 3, 4 )
+    /* GCC <= 3.4 has buggy template support */
+#  define wxUSE_MEMBER_TEMPLATES 0
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER <= 1200
+    /* MSVC <= 6.0 has buggy template support */
+#  define wxUSE_MEMBER_TEMPLATES 0
+#  define wxUSE_FUNC_TEMPLATE_POINTER 0
+#endif
+
+#ifndef wxUSE_MEMBER_TEMPLATES
+#  define wxUSE_MEMBER_TEMPLATES 1
+#endif
+
+#ifndef wxUSE_FUNC_TEMPLATE_POINTER
+#  define wxUSE_FUNC_TEMPLATE_POINTER 1
+#endif
+
+#if wxUSE_MEMBER_TEMPLATES
+#  define wxTEMPLATED_MEMBER_CALL( method, type ) method<type>()
+#  define wxTEMPLATED_MEMBER_FIX( type )
+#else
+#  define wxTEMPLATED_MEMBER_CALL( method, type ) method((type*)NULL)
+#  define wxTEMPLATED_MEMBER_FIX( type ) type* =NULL
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER <= 1200
+#  define wxTEMPLATED_FUNCTION_FIX( type ), wxTEMPLATED_MEMBER_FIX(type)
+#  define wxINFUNC_CLASS_TYPE_FIX( type ) typedef type type;
+#else
+#  define wxTEMPLATED_FUNCTION_FIX( type )
+#  define wxINFUNC_CLASS_TYPE_FIX( type )
+#endif
+

 /*  ---------------------------------------------------------------------------- */
 /*  Geometric flags */
 /*  ---------------------------------------------------------------------------- */
 /*  ---------------------------------------------------------------------------- */
 /*  Geometric flags */
 /*  ---------------------------------------------------------------------------- */


@@ -1470,9 +1607,11 @@ enum wxDirection
 
 enum wxAlignment
 {
 
 enum wxAlignment
 {

-    // 0 is a valid wxAlignment value (both wxALIGN_LEFT and wxALIGN_TOP use
-    // it) so define a symbolic name for an invalid alignment value which can
-    // be assumed to be different from anything else
+    /*
+        0 is a valid wxAlignment value (both wxALIGN_LEFT and wxALIGN_TOP
+        use it) so define a symbolic name for an invalid alignment value
+        which can be assumed to be different from anything else
+     */

     wxALIGN_INVALID           = -1,
 
     wxALIGN_NOT               = 0x0000,
     wxALIGN_INVALID           = -1,
 
     wxALIGN_NOT               = 0x0000,


@@ -1495,10 +1634,12 @@ enum wxAlignment
 /* misc. flags for wxSizer items */
 enum wxSizerFlagBits
 {
 /* misc. flags for wxSizer items */
 enum wxSizerFlagBits
 {

-    // wxADJUST_MINSIZE doesn't do anything any more but we still define it for
-    // compatibility. Notice that it may be also predefined (as 0, hopefully)
-    // in the user code in order to use it even in !WXWIN_COMPATIBILITY_2_8
-    // builds so don't redefine it in such case.
+    /*
+        wxADJUST_MINSIZE doesn't do anything any more but we still define
+        it for compatibility. Notice that it may be also predefined (as 0,
+        hopefully) in the user code in order to use it even in
+        !WXWIN_COMPATIBILITY_2_8 builds so don't redefine it in such case.
+     */

 #if WXWIN_COMPATIBILITY_2_8 && !defined(wxADJUST_MINSIZE)
     wxADJUST_MINSIZE               = 0,
 #endif
 #if WXWIN_COMPATIBILITY_2_8 && !defined(wxADJUST_MINSIZE)
     wxADJUST_MINSIZE               = 0,
 #endif


@@ -1786,14 +1927,12 @@ enum wxBorder
 /*  Old names for compatibility */
 #define wxRA_HORIZONTAL     wxHORIZONTAL
 #define wxRA_VERTICAL       wxVERTICAL
 /*  Old names for compatibility */
 #define wxRA_HORIZONTAL     wxHORIZONTAL
 #define wxRA_VERTICAL       wxVERTICAL

-#define wxRA_USE_CHECKBOX   0x0010 /* alternative native subcontrols (wxPalmOS) */

 
 /*
  * wxRadioButton style flag
  */
 #define wxRB_GROUP          0x0004
 #define wxRB_SINGLE         0x0008
 
 /*
  * wxRadioButton style flag
  */
 #define wxRB_GROUP          0x0004
 #define wxRB_SINGLE         0x0008

-#define wxRB_USE_CHECKBOX   0x0010 /* alternative native control (wxPalmOS) */

 
 /*
  * wxScrollBar flags
 
 /*
  * wxScrollBar flags


@@ -1803,14 +1942,15 @@ enum wxBorder
 
 /*
  * wxSpinButton flags.
 
 /*
  * wxSpinButton flags.

- * Note that a wxSpinCtrl is sometimes defined as
- * a wxTextCtrl, and so the flags must be different
- * from wxTextCtrl's.
+ * Note that a wxSpinCtrl is sometimes defined as a wxTextCtrl, and so the
+ * flags shouldn't overlap with wxTextCtrl flags that can be used for a single
+ * line controls (currently we reuse wxTE_CHARWRAP and wxTE_RICH2 neither of
+ * which makes sense for them).

  */
 #define wxSP_HORIZONTAL       wxHORIZONTAL /*  4 */
 #define wxSP_VERTICAL         wxVERTICAL   /*  8 */
  */
 #define wxSP_HORIZONTAL       wxHORIZONTAL /*  4 */
 #define wxSP_VERTICAL         wxVERTICAL   /*  8 */

-#define wxSP_ARROW_KEYS       0x1000
-#define wxSP_WRAP             0x2000
+#define wxSP_ARROW_KEYS       0x4000
+#define wxSP_WRAP             0x8000

 
 /*
  * wxTabCtrl flags
 
 /*
  * wxTabCtrl flags


@@ -1866,45 +2006,54 @@ enum wxBorder
 #define wxICON_STOP             wxICON_HAND
 #define wxICON_ASTERISK         wxICON_INFORMATION
 
 #define wxICON_STOP             wxICON_HAND
 #define wxICON_ASTERISK         wxICON_INFORMATION
 

-#define  wxFORWARD              0x00001000
-#define  wxBACKWARD             0x00002000
-#define  wxRESET                0x00004000
-#define  wxHELP                 0x00008000
-#define  wxMORE                 0x00010000
-#define  wxSETUP                0x00020000
+#define wxHELP                  0x00001000
+#define wxFORWARD               0x00002000
+#define wxBACKWARD              0x00004000
+#define wxRESET                 0x00008000
+#define wxMORE                  0x00010000
+#define wxSETUP                 0x00020000

 #define wxICON_NONE             0x00040000
 #define wxICON_NONE             0x00040000

+#define wxICON_AUTH_NEEDED      0x00080000

 
 #define wxICON_MASK \
 
 #define wxICON_MASK \

-    (wxICON_EXCLAMATION|wxICON_HAND|wxICON_QUESTION|wxICON_INFORMATION|wxICON_NONE)
+    (wxICON_EXCLAMATION|wxICON_HAND|wxICON_QUESTION|wxICON_INFORMATION|wxICON_NONE|wxICON_AUTH_NEEDED)

 
 /*
  * Background styles. See wxWindow::SetBackgroundStyle
  */
 enum wxBackgroundStyle
 {
 
 /*
  * Background styles. See wxWindow::SetBackgroundStyle
  */
 enum wxBackgroundStyle
 {

-    // background is erased in the EVT_ERASE_BACKGROUND handler or using the
-    // system default background if no such handler is defined (this is the
-    // default style)
+    /*
+        background is erased in the EVT_ERASE_BACKGROUND handler or using
+        the system default background if no such handler is defined (this
+        is the default style)
+     */

     wxBG_STYLE_ERASE,
 
     wxBG_STYLE_ERASE,
 

-    // background is erased by the system, no EVT_ERASE_BACKGROUND event is
-    // generated at all
+    /*
+        background is erased by the system, no EVT_ERASE_BACKGROUND event
+        is generated at all
+     */

     wxBG_STYLE_SYSTEM,
 
     wxBG_STYLE_SYSTEM,
 

-    // background is erased in EVT_PAINT handler and not erased at all before
-    // it, this should be used if the paint handler paints over the entire
-    // window to avoid flicker
+    /*
+        background is erased in EVT_PAINT handler and not erased at all
+        before it, this should be used if the paint handler paints over
+        the entire window to avoid flicker
+     */

     wxBG_STYLE_PAINT,
 
 
     wxBG_STYLE_PAINT,
 
 

-    // this is a Mac-only style, don't use in portable code
+    /* this is a Mac-only style, don't use in portable code */

     wxBG_STYLE_TRANSPARENT,
 
     wxBG_STYLE_TRANSPARENT,
 

-    // this style is deprecated and doesn't do anything, don't use
+    /* this style is deprecated and doesn't do anything, don't use */

     wxBG_STYLE_COLOUR,
 
     wxBG_STYLE_COLOUR,
 

-    // this style is deprecated and is synonymous with wxBG_STYLE_PAINT, use
-    // the new name
+    /*
+        this style is deprecated and is synonymous with
+        wxBG_STYLE_PAINT, use the new name
+     */

     wxBG_STYLE_CUSTOM = wxBG_STYLE_PAINT
 };
 
     wxBG_STYLE_CUSTOM = wxBG_STYLE_PAINT
 };
 


@@ -2096,6 +2245,13 @@ enum wxStandardID
     wxID_MDI_WINDOW_NEXT,
     wxID_MDI_WINDOW_LAST = wxID_MDI_WINDOW_NEXT,
 
     wxID_MDI_WINDOW_NEXT,
     wxID_MDI_WINDOW_LAST = wxID_MDI_WINDOW_NEXT,
 

+    /* OS X system menu ids */
+    wxID_OSX_MENU_FIRST = 5250,
+    wxID_OSX_HIDE = wxID_OSX_MENU_FIRST,
+    wxID_OSX_HIDEOTHERS,
+    wxID_OSX_SHOWALL,
+    wxID_OSX_MENU_LAST = wxID_OSX_SHOWALL,
+    

     /*  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,
 


@@ -2133,6 +2289,18 @@ enum wxItemKind
     wxITEM_MAX
 };
 
     wxITEM_MAX
 };
 

+/*
+ * The possible states of a 3-state checkbox (Compatible
+ * with the 2-state checkbox).
+ */
+enum wxCheckBoxState
+{
+    wxCHK_UNCHECKED,
+    wxCHK_CHECKED,
+    wxCHK_UNDETERMINED /* 3-state checkbox only */
+};
+
+

 /*  hit test results */
 enum wxHitTest
 {
 /*  hit test results */
 enum wxHitTest
 {


@@ -2185,6 +2353,28 @@ enum wxHitTest
 /*  GDI descriptions */
 /*  ---------------------------------------------------------------------------- */
 
 /*  GDI descriptions */
 /*  ---------------------------------------------------------------------------- */
 

+// Hatch styles used by both pen and brush styles.
+//
+// NB: Do not use these constants directly, they're for internal use only, use
+//     wxBRUSHSTYLE_XXX_HATCH and wxPENSTYLE_XXX_HATCH instead.
+enum wxHatchStyle
+{
+    wxHATCHSTYLE_INVALID = -1,
+
+    /*
+        The value of the first style is chosen to fit with
+        wxDeprecatedGUIConstants values below, don't change it.
+     */
+    wxHATCHSTYLE_FIRST = 111,
+    wxHATCHSTYLE_BDIAGONAL = wxHATCHSTYLE_FIRST,
+    wxHATCHSTYLE_CROSSDIAG,
+    wxHATCHSTYLE_FDIAGONAL,
+    wxHATCHSTYLE_CROSS,
+    wxHATCHSTYLE_HORIZONTAL,
+    wxHATCHSTYLE_VERTICAL,
+    wxHATCHSTYLE_LAST = wxHATCHSTYLE_VERTICAL
+};
+

 /*
     WARNING: the following styles are deprecated; use the
              wxFontFamily, wxFontStyle, wxFontWeight, wxBrushStyle,
 /*
     WARNING: the following styles are deprecated; use the
              wxFontFamily, wxFontStyle, wxFontWeight, wxBrushStyle,


@@ -2227,20 +2417,20 @@ enum wxDeprecatedGUIConstants
     wxTRANSPARENT,
 
     /*  Brush & Pen Stippling. Note that a stippled pen cannot be dashed!! */
     wxTRANSPARENT,
 
     /*  Brush & Pen Stippling. Note that a stippled pen cannot be dashed!! */

-    /*  Note also that stippling a Pen IS meaningfull, because a Line is */
+    /*  Note also that stippling a Pen IS meaningful, 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,
 
     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
+    wxBDIAGONAL_HATCH = wxHATCHSTYLE_BDIAGONAL,
+    wxCROSSDIAG_HATCH = wxHATCHSTYLE_CROSSDIAG,
+    wxFDIAGONAL_HATCH = wxHATCHSTYLE_FDIAGONAL,
+    wxCROSS_HATCH = wxHATCHSTYLE_CROSS,
+    wxHORIZONTAL_HATCH = wxHATCHSTYLE_HORIZONTAL,
+    wxVERTICAL_HATCH = wxHATCHSTYLE_VERTICAL,
+    wxFIRST_HATCH = wxHATCHSTYLE_FIRST,
+    wxLAST_HATCH = wxHATCHSTYLE_LAST

 };
 #endif
 
 };
 #endif
 


@@ -2279,10 +2469,39 @@ enum wxDataFormatId
     wxDF_MAX
 };
 
     wxDF_MAX
 };
 

-/*  Virtual keycodes */
+/* Key codes */

 enum wxKeyCode
 {
 enum wxKeyCode
 {

-    WXK_BACK    =    8, // backspace
+    WXK_NONE    =    0,
+
+    WXK_CONTROL_A = 1,
+    WXK_CONTROL_B,
+    WXK_CONTROL_C,
+    WXK_CONTROL_D,
+    WXK_CONTROL_E,
+    WXK_CONTROL_F,
+    WXK_CONTROL_G,
+    WXK_CONTROL_H,
+    WXK_CONTROL_I,
+    WXK_CONTROL_J,
+    WXK_CONTROL_K,
+    WXK_CONTROL_L,
+    WXK_CONTROL_M,
+    WXK_CONTROL_N,
+    WXK_CONTROL_O,
+    WXK_CONTROL_P,
+    WXK_CONTROL_Q,
+    WXK_CONTROL_R,
+    WXK_CONTROL_S,
+    WXK_CONTROL_T,
+    WXK_CONTROL_U,
+    WXK_CONTROL_V,
+    WXK_CONTROL_W,
+    WXK_CONTROL_X,
+    WXK_CONTROL_Y,
+    WXK_CONTROL_Z,
+
+    WXK_BACK    =    8, /* backspace */

     WXK_TAB     =    9,
     WXK_RETURN  =    13,
     WXK_ESCAPE  =    27,
     WXK_TAB     =    9,
     WXK_RETURN  =    13,
     WXK_ESCAPE  =    27,


@@ -2405,7 +2624,12 @@ enum wxKeyCode
     WXK_WINDOWS_LEFT,
     WXK_WINDOWS_RIGHT,
     WXK_WINDOWS_MENU ,
     WXK_WINDOWS_LEFT,
     WXK_WINDOWS_RIGHT,
     WXK_WINDOWS_MENU ,

-    WXK_COMMAND,
+#ifdef __WXOSX__
+    WXK_RAW_CONTROL,
+#else
+    WXK_RAW_CONTROL = WXK_CONTROL,
+#endif
+    WXK_COMMAND = WXK_CONTROL,

 
     /* Hardware-specific buttons */
     WXK_SPECIAL1 = 193,
 
     /* Hardware-specific buttons */
     WXK_SPECIAL1 = 193,


@@ -2441,10 +2665,11 @@ enum wxKeyModifier
     wxMOD_META      = 0x0008,
     wxMOD_WIN       = wxMOD_META,
 #if defined(__WXMAC__) || defined(__WXCOCOA__)
     wxMOD_META      = 0x0008,
     wxMOD_WIN       = wxMOD_META,
 #if defined(__WXMAC__) || defined(__WXCOCOA__)

-    wxMOD_CMD       = wxMOD_META,
+    wxMOD_RAW_CONTROL = 0x0010,

 #else
 #else

-    wxMOD_CMD       = wxMOD_CONTROL,
+    wxMOD_RAW_CONTROL = wxMOD_CONTROL,

 #endif
 #endif

+    wxMOD_CMD       = wxMOD_CONTROL,

     wxMOD_ALL       = 0xffff
 };
 
     wxMOD_ALL       = 0xffff
 };
 


@@ -2661,7 +2886,7 @@ typedef int (* LINKAGEMODE wxListIterateFunction)(void *current);
 #endif
 
 #if defined(__CYGWIN__) && defined(__WXMSW__)
 #endif
 
 #if defined(__CYGWIN__) && defined(__WXMSW__)

-#   if wxUSE_STL || defined(wxUSE_STD_STRING)
+#   if wxUSE_STD_CONTAINERS || defined(wxUSE_STD_STRING)

          /*
             NASTY HACK because the gethostname in sys/unistd.h which the gnu
             stl includes and wx builds with by default clash with each other
          /*
             NASTY HACK because the gethostname in sys/unistd.h which the gnu
             stl includes and wx builds with by default clash with each other


@@ -2676,10 +2901,15 @@ typedef int (* LINKAGEMODE wxListIterateFunction)(void *current);
 
 /*  --------------------------------------------------------------------------- */
 /*  macros that enable wxWidgets apps to be compiled in absence of the */
 
 /*  --------------------------------------------------------------------------- */
 /*  macros that enable wxWidgets apps to be compiled in absence of the */

-/*  sytem headers, although some platform specific types are used in the */
+/*  system headers, although some platform specific types are used in the */

 /*  platform specific (implementation) parts of the headers */
 /*  --------------------------------------------------------------------------- */
 
 /*  platform specific (implementation) parts of the headers */
 /*  --------------------------------------------------------------------------- */
 

+#ifdef __DARWIN__
+#define DECLARE_WXOSX_OPAQUE_CFREF( name ) typedef struct __##name* name##Ref;
+#define DECLARE_WXOSX_OPAQUE_CONST_CFREF( name ) typedef const struct __##name* name##Ref;
+#endif
+

 #ifdef __WXMAC__
 
 #define WX_OPAQUE_TYPE( name ) struct wxOpaque##name
 #ifdef __WXMAC__
 
 #define WX_OPAQUE_TYPE( name ) struct wxOpaque##name


@@ -2714,10 +2944,7 @@ typedef void*       WXDisplay;
 
 typedef const void * CFTypeRef;
 
 
 typedef const void * CFTypeRef;
 

-// typedef const struct __CFString * CFStringRef;
-
-#define DECLARE_WXOSX_OPAQUE_CFREF( name ) typedef struct __##name* name##Ref;
-#define DECLARE_WXOSX_OPAQUE_CONST_CFREF( name ) typedef const struct __##name* name##Ref;
+/* typedef const struct __CFString * CFStringRef; */

 
 DECLARE_WXOSX_OPAQUE_CONST_CFREF( CFString )
 typedef struct __CFString * CFMutableStringRef;
 
 DECLARE_WXOSX_OPAQUE_CONST_CFREF( CFString )
 typedef struct __CFString * CFMutableStringRef;


@@ -2791,7 +3018,7 @@ typedef unsigned int NSUInteger;
  */
 
 /*  NOTE: This ought to work with other compilers too, but I'm being cautious */
  */
 
 /*  NOTE: This ought to work with other compilers too, but I'm being cautious */

-#if (defined(__GNUC__) && defined(__APPLE__)) || defined(__MWERKS__)
+#if (defined(__GNUC__) && defined(__APPLE__))

 /* It's desirable to have type safety for Objective-C(++) code as it does
 at least catch typos of method names among other things.  However, it
 is not possible to declare an Objective-C class from plain old C or C++
 /* It's desirable to have type safety for Objective-C(++) code as it does
 at least catch typos of method names among other things.  However, it
 is not possible to declare an Objective-C class from plain old C or C++


@@ -2811,7 +3038,7 @@ typedef klass *WX_##klass
 typedef struct klass *WX_##klass
 #endif /*  defined(__OBJC__) */
 
 typedef struct klass *WX_##klass
 #endif /*  defined(__OBJC__) */
 

-#else /*  not Apple's GNU or CodeWarrior */
+#else /*  not Apple's gcc */

 #warning "Objective-C types will not be checked by the compiler."
 /*  NOTE: typedef struct objc_object *id; */
 /*  IOW, we're declaring these using the id type without using that name, */
 #warning "Objective-C types will not be checked by the compiler."
 /*  NOTE: typedef struct objc_object *id; */
 /*  IOW, we're declaring these using the id type without using that name, */


@@ -2821,7 +3048,7 @@ typedef struct klass *WX_##klass
 #define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
 typedef struct objc_object *WX_##klass
 
 #define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
 typedef struct objc_object *WX_##klass
 

-#endif /*  (defined(__GNUC__) && defined(__APPLE__)) || defined(__MWERKS__) */
+#endif /*  (defined(__GNUC__) && defined(__APPLE__)) */

 
 DECLARE_WXCOCOA_OBJC_CLASS(NSApplication);
 DECLARE_WXCOCOA_OBJC_CLASS(NSBitmapImageRep);
 
 DECLARE_WXCOCOA_OBJC_CLASS(NSApplication);
 DECLARE_WXCOCOA_OBJC_CLASS(NSBitmapImageRep);


@@ -2844,6 +3071,7 @@ DECLARE_WXCOCOA_OBJC_CLASS(NSMutableArray);
 DECLARE_WXCOCOA_OBJC_CLASS(NSNotification);
 DECLARE_WXCOCOA_OBJC_CLASS(NSObject);
 DECLARE_WXCOCOA_OBJC_CLASS(NSPanel);
 DECLARE_WXCOCOA_OBJC_CLASS(NSNotification);
 DECLARE_WXCOCOA_OBJC_CLASS(NSObject);
 DECLARE_WXCOCOA_OBJC_CLASS(NSPanel);

+DECLARE_WXCOCOA_OBJC_CLASS(NSResponder);

 DECLARE_WXCOCOA_OBJC_CLASS(NSScrollView);
 DECLARE_WXCOCOA_OBJC_CLASS(NSSound);
 DECLARE_WXCOCOA_OBJC_CLASS(NSStatusItem);
 DECLARE_WXCOCOA_OBJC_CLASS(NSScrollView);
 DECLARE_WXCOCOA_OBJC_CLASS(NSSound);
 DECLARE_WXCOCOA_OBJC_CLASS(NSStatusItem);


@@ -2892,42 +3120,7 @@ typedef WX_NSString* WXGLPixelFormat;
 
 #endif
 
 
 #endif
 

-#endif // __WXMAC__
-
-#if defined(__WXPALMOS__)
-
-typedef void *          WXHWND;
-typedef void *          WXHANDLE;
-typedef void *          WXHICON;
-typedef void *          WXHFONT;
-typedef void *          WXHMENU;
-typedef void *          WXHPEN;
-typedef void *          WXHBRUSH;
-typedef void *          WXHPALETTE;
-typedef void *          WXHCURSOR;
-typedef void *          WXHRGN;
-typedef void *          WXHACCEL;
-typedef void *          WXHINSTANCE;
-typedef void *          WXHBITMAP;
-typedef void *          WXHIMAGELIST;
-typedef void *          WXHGLOBAL;
-typedef void *          WXHDC;
-typedef unsigned int    WXUINT;
-typedef unsigned long   WXDWORD;
-typedef unsigned short  WXWORD;
-
-typedef unsigned long   WXCOLORREF;
-typedef struct tagMSG   WXMSG;
-
-typedef WXHWND          WXWINHANDLE; /* WinHandle of PalmOS */
-typedef WXWINHANDLE     WXWidget;
-
-typedef void *          WXFORMPTR;
-typedef void *          WXEVENTPTR;
-typedef void *          WXRECTANGLEPTR;
-
-#endif /* __WXPALMOS__ */
-
+#endif /* __WXMAC__ */

 
 /* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */
 #if defined(__WIN32__)
 
 /* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */
 #if defined(__WIN32__)


@@ -2976,7 +3169,9 @@ typedef void *          WXDRAWITEMSTRUCT;
 typedef void *          WXMEASUREITEMSTRUCT;
 typedef void *          WXLPCREATESTRUCT;
 
 typedef void *          WXMEASUREITEMSTRUCT;
 typedef void *          WXLPCREATESTRUCT;
 

+#ifdef __WXMSW__

 typedef WXHWND          WXWidget;
 typedef WXHWND          WXWidget;

+#endif

 
 #ifdef __WIN64__
 typedef unsigned __int64   WXWPARAM;
 
 #ifdef __WIN64__
 typedef unsigned __int64   WXWPARAM;


@@ -3136,53 +3331,45 @@ typedef long            WXPixel; /* safety catch in src/motif/colour.cpp */
 #ifdef __WXGTK__
 
 /* Stand-ins for GLIB types */
 #ifdef __WXGTK__
 
 /* Stand-ins for GLIB types */

-typedef char           gchar;
-typedef signed char    gint8;
-typedef int            gint;
-typedef unsigned       guint;
-typedef unsigned long  gulong;
-typedef void*          gpointer;

 typedef struct _GSList GSList;
 
 /* Stand-ins for GDK types */
 typedef struct _GdkColor        GdkColor;
 typedef struct _GSList GSList;
 
 /* Stand-ins for GDK types */
 typedef struct _GdkColor        GdkColor;

-typedef struct _GdkColormap     GdkColormap;
-typedef struct _GdkFont         GdkFont;
-typedef struct _GdkGC           GdkGC;
-typedef struct _GdkVisual       GdkVisual;
-
-#ifdef __WXGTK20__
-typedef struct _GdkAtom        *GdkAtom;
-typedef struct _GdkDrawable     GdkWindow;
-typedef struct _GdkDrawable     GdkBitmap;
-typedef struct _GdkDrawable     GdkPixmap;
-#else /*  GTK+ 1.2 */
-typedef gulong                  GdkAtom;
-typedef struct _GdkWindow       GdkWindow;
-typedef struct _GdkWindow       GdkBitmap;
-typedef struct _GdkWindow       GdkPixmap;
-#endif /*  GTK+ 1.2/2.0 */
-

 typedef struct _GdkCursor       GdkCursor;
 typedef struct _GdkCursor       GdkCursor;

-typedef struct _GdkRegion       GdkRegion;

 typedef struct _GdkDragContext  GdkDragContext;
 
 typedef struct _GdkDragContext  GdkDragContext;
 

-#ifdef HAVE_XIM
-typedef struct _GdkIC           GdkIC;
-typedef struct _GdkICAttr       GdkICAttr;
+#if defined(__WXGTK20__)
+    typedef struct _GdkAtom* GdkAtom;
+#else
+    typedef unsigned long GdkAtom;
+#endif
+
+#if !defined(__WXGTK3__)
+    typedef struct _GdkColormap GdkColormap;
+    typedef struct _GdkFont GdkFont;
+    typedef struct _GdkGC GdkGC;
+    typedef struct _GdkRegion GdkRegion;
+#endif
+
+#if defined(__WXGTK3__)
+    typedef struct _GdkWindow GdkWindow;
+#elif defined(__WXGTK20__)
+    typedef struct _GdkDrawable GdkWindow;
+    typedef struct _GdkDrawable GdkPixmap;
+#else
+    typedef struct _GdkWindow GdkWindow;
+    typedef struct _GdkWindow GdkBitmap;
+    typedef struct _GdkWindow GdkPixmap;

 #endif
 
 /* Stand-ins for GTK types */
 typedef struct _GtkWidget         GtkWidget;
 typedef struct _GtkRcStyle        GtkRcStyle;
 typedef struct _GtkAdjustment     GtkAdjustment;
 #endif
 
 /* Stand-ins for GTK types */
 typedef struct _GtkWidget         GtkWidget;
 typedef struct _GtkRcStyle        GtkRcStyle;
 typedef struct _GtkAdjustment     GtkAdjustment;

-typedef struct _GtkList           GtkList;

 typedef struct _GtkToolbar        GtkToolbar;
 typedef struct _GtkToolbar        GtkToolbar;

-typedef struct _GtkTooltips       GtkTooltips;

 typedef struct _GtkNotebook       GtkNotebook;
 typedef struct _GtkNotebookPage   GtkNotebookPage;
 typedef struct _GtkAccelGroup     GtkAccelGroup;
 typedef struct _GtkNotebook       GtkNotebook;
 typedef struct _GtkNotebookPage   GtkNotebookPage;
 typedef struct _GtkAccelGroup     GtkAccelGroup;

-typedef struct _GtkItemFactory    GtkItemFactory;

 typedef struct _GtkSelectionData  GtkSelectionData;
 typedef struct _GtkTextBuffer     GtkTextBuffer;
 typedef struct _GtkRange          GtkRange;
 typedef struct _GtkSelectionData  GtkSelectionData;
 typedef struct _GtkTextBuffer     GtkTextBuffer;
 typedef struct _GtkRange          GtkRange;


@@ -3210,10 +3397,6 @@ typedef struct _PangoLayout          PangoLayout;
 typedef struct _PangoFontDescription PangoFontDescription;
 #endif
 
 typedef struct _PangoFontDescription PangoFontDescription;
 #endif
 

-#ifdef __WXMGL__
-typedef struct window_t *WXWidget;
-#endif /*  MGL */
-

 #ifdef __WXDFB__
 /* DirectFB doesn't have the concept of non-TLW window, so use
    something arbitrary */
 #ifdef __WXDFB__
 /* DirectFB doesn't have the concept of non-TLW window, so use
    something arbitrary */


@@ -3224,9 +3407,9 @@ typedef const void* WXWidget;
 /*  included before or after wxWidgets classes, and therefore must be */
 /*  disabled here before any significant wxWidgets headers are included. */
 #ifdef __cplusplus
 /*  included before or after wxWidgets classes, and therefore must be */
 /*  disabled here before any significant wxWidgets headers are included. */
 #ifdef __cplusplus

-#ifdef __WXMSW__
+#ifdef __WINDOWS__

 #include "wx/msw/winundef.h"
 #include "wx/msw/winundef.h"

-#endif /* __WXMSW__ */
+#endif /* __WINDOWS__ */

 #endif /* __cplusplus */
 
 
 #endif /* __cplusplus */
 
 


@@ -3256,7 +3439,7 @@ typedef const void* WXWidget;
     private:                                    \
         classname& operator=(const classname&)
 
     private:                                    \
         classname& operator=(const classname&)
 

-// deprecated variants _not_ requiring a semicolon after them
+/* deprecated variants _not_ requiring a semicolon after them */

 #define DECLARE_NO_COPY_CLASS(classname) \
     wxDECLARE_NO_COPY_CLASS(classname);
 #define DECLARE_NO_COPY_TEMPLATE_CLASS(classname, arg) \
 #define DECLARE_NO_COPY_CLASS(classname) \
     wxDECLARE_NO_COPY_CLASS(classname);
 #define DECLARE_NO_COPY_TEMPLATE_CLASS(classname, arg) \


@@ -3268,14 +3451,15 @@ typedef const void* WXWidget;
 /*  If a manifest is being automatically generated, add common controls 6 to it */
 /*  --------------------------------------------------------------------------- */
 
 /*  If a manifest is being automatically generated, add common controls 6 to it */
 /*  --------------------------------------------------------------------------- */
 

-#if (!defined wxUSE_NO_MANIFEST || wxUSE_NO_MANIFEST == 0 ) && \
+#if wxUSE_GUI && \
+    (!defined wxUSE_NO_MANIFEST || wxUSE_NO_MANIFEST == 0 ) && \

     ( defined _MSC_FULL_VER && _MSC_FULL_VER >= 140040130 )
 
 #define WX_CC_MANIFEST(cpu)                     \
     "/manifestdependency:\"type='win32'         \
      name='Microsoft.Windows.Common-Controls'   \
      version='6.0.0.0'                          \
     ( defined _MSC_FULL_VER && _MSC_FULL_VER >= 140040130 )
 
 #define WX_CC_MANIFEST(cpu)                     \
     "/manifestdependency:\"type='win32'         \
      name='Microsoft.Windows.Common-Controls'   \
      version='6.0.0.0'                          \

-     processorArchitecture='"cpu"'              \
+     processorArchitecture='" cpu "'            \

      publicKeyToken='6595b64144ccf1df'          \
      language='*'\""
 
      publicKeyToken='6595b64144ccf1df'          \
      language='*'\""
 


@@ -3291,5 +3475,13 @@ typedef const void* WXWidget;
 
 #endif /* !wxUSE_NO_MANIFEST && _MSC_FULL_VER >= 140040130 */
 
 
 #endif /* !wxUSE_NO_MANIFEST && _MSC_FULL_VER >= 140040130 */
 

+/* wxThread and wxProcess priorities */
+enum
+{
+    wxPRIORITY_MIN     = 0u,   /* lowest possible priority */
+    wxPRIORITY_DEFAULT = 50u,  /* normal priority */
+    wxPRIORITY_MAX     = 100u  /* highest possible priority */
+};
+

 #endif
     /*  _WX_DEFS_H_ */
 #endif
     /*  _WX_DEFS_H_ */