add an assert indicating that old code overriding OnExecute() must be updated with 2.9

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

diff --git a/include/wx/defs.h b/include/wx/defs.h
index 896a20de29319a91e81d00cc4d42c09d8b9a2648..3d34d267b23adccc922cbfeab0315f9e1a6e8661 100644 (file)
--- a/include/wx/defs.h
+++ b/include/wx/defs.h
@@ -1,19 +1,24 @@
-/**
-*  Name:        wx/defs.h
-*  Purpose:     Declarations/definitions common to all wx source files
-*  Author:      Julian Smart and others
-*  Modified by: Ryan Norton (Converted to C)
-*  Created:     01/02/97
-*  RCS-ID:      $Id$
-*  Copyright:   (c) Julian Smart
-*  Licence:     wxWindows licence
-*/
+/*
+ *  Name:        wx/defs.h
+ *  Purpose:     Declarations/definitions common to all wx source files
+ *  Author:      Julian Smart and others
+ *  Modified by: Ryan Norton (Converted to C)
+ *  Created:     01/02/97
+ *  RCS-ID:      $Id$
+ *  Copyright:   (c) Julian Smart
+ *  Licence:     wxWindows licence
+ */

 
 /* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
 
 #ifndef _WX_DEFS_H_
 #define _WX_DEFS_H_
 
 
 /* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
 
 #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 */
 /*  ---------------------------------------------------------------------------- */


@@ -35,6 +40,7 @@
          !defined(__WXCOCOA__) && \
          !defined(__X__)       && \
          !defined(__WXMGL__)   && \
          !defined(__WXCOCOA__) && \
          !defined(__X__)       && \
          !defined(__WXMGL__)   && \

+         !defined(__WXDFB__)   && \

          !defined(__WXX11__)   && \
           wxUSE_GUI
 #       ifdef __UNIX__
          !defined(__WXX11__)   && \
           wxUSE_GUI
 #       ifdef __UNIX__


@@ -58,9 +64,6 @@
     #define __WXBASE__
 #endif
 
     #define __WXBASE__
 #endif
 

-/*  include the feature test macros */
-#include "wx/features.h"
-

 /*  suppress some Visual C++ warnings */
 #ifdef __VISUALC__
     /*  the only "real" warning here is 4244 but there are just too many of them */
 /*  suppress some Visual C++ warnings */
 #ifdef __VISUALC__
     /*  the only "real" warning here is 4244 but there are just too many of them */


@@ -73,17 +76,42 @@
 #   pragma warning(disable:4512)    /*  operator=() couldn't be generated */
 #   pragma warning(disable:4710)    /*  function not inlined */
 
 #   pragma warning(disable:4512)    /*  operator=() couldn't be generated */
 #   pragma warning(disable:4710)    /*  function not inlined */
 

+    /* There are too many false positivies for this one, particularly when
+       using templates like wxVector<T> */
+    /* class 'foo' needs to have dll-interface to be used by clients of
+       class 'bar'" */
+#   pragma warning(disable:4251)
+

     /* For VC++ 5.0 for release mode, the warning 'C4702: unreachable code */
     /* is buggy, and occurs for code that does actually get executed */
 #   if !defined __WXDEBUG__ && __VISUALC__ <= 1100
 #       pragma warning(disable:4702)    /* unreachable code */
     /* For VC++ 5.0 for release mode, the warning 'C4702: unreachable code */
     /* is buggy, and occurs for code that does actually get executed */
 #   if !defined __WXDEBUG__ && __VISUALC__ <= 1100
 #       pragma warning(disable:4702)    /* unreachable code */

+#   endif
+    /* The VC++ 5.0 warning 'C4003: not enough actual parameters for macro'
+     * is incompatible with the wxWidgets headers since it is given when
+     * parameters are empty but not missing. */
+#   if __VISUALC__ <= 1100
+#       pragma warning(disable:4003)    /* not enough actual parameters for macro */

 #   endif
 
 #   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


@@ -93,15 +121,6 @@
     #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 */


@@ -194,6 +213,9 @@
             #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 */
 


@@ -229,12 +251,6 @@
 
 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 */


@@ -265,6 +281,8 @@ typedef int wxWindowID;
         #define HAVE_EXPLICIT
     #elif defined(__DIGITALMARS__)
         #define HAVE_EXPLICIT
         #define HAVE_EXPLICIT
     #elif defined(__DIGITALMARS__)
         #define HAVE_EXPLICIT

+    #elif defined(__WATCOMC__)
+        #define HAVE_EXPLICIT

     #endif
 #endif /*  !HAVE_EXPLICIT */
 
     #endif
 #endif /*  !HAVE_EXPLICIT */
 


@@ -368,7 +386,7 @@ typedef int wxWindowID;
         /*  VC++ 6.0 and 5.0 have std::wstring (what about earlier versions?) */
         #define HAVE_STD_WSTRING
     #elif ( defined(__MINGW32__) || defined(__CYGWIN32__) ) \
         /*  VC++ 6.0 and 5.0 have std::wstring (what about earlier versions?) */
         #define HAVE_STD_WSTRING
     #elif ( defined(__MINGW32__) || defined(__CYGWIN32__) ) \

-          && wxCHECK_GCC_VERSION(3, 1)
+          && wxCHECK_GCC_VERSION(3, 3)

         /*  GCC 3.1 has std::wstring; 3.0 never was in MinGW, 2.95 hasn't it */
         #define HAVE_STD_WSTRING
     #endif
         /*  GCC 3.1 has std::wstring; 3.0 never was in MinGW, 2.95 hasn't it */
         #define HAVE_STD_WSTRING
     #endif


@@ -430,6 +448,55 @@ typedef int wxWindowID;
     #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
+    // Mingw <=3.4 doesn't have std::wostream
+    #if defined(__MINGW32__) && !wxCHECK_GCC_VERSION(4,0)
+        #define wxNO_WOSTREAM
+    #endif
+
+    // VC++ doesn't have it in the old iostream library
+    #if defined(__VISUALC__) && wxUSE_IOSTREAMH
+        #define wxNO_WOSTREAM
+    #endif
+
+    #ifndef wxNO_WOSTREAM
+        #define HAVE_WOSTREAM
+    #endif
+
+    #undef wxNO_WOSTREAM
+#endif /* HAVE_WOSTREAM */
+
+// ----------------------------------------------------------------------------
+// other C++ features
+// ----------------------------------------------------------------------------
+
+#ifndef HAVE_PARTIAL_SPECIALIZATION
+    // be optimistic by default
+    #define HAVE_PARTIAL_SPECIALIZATION
+#endif
+
+#ifdef __VISUALC__
+    #if __VISUALC__ < 1310
+        #undef HAVE_PARTIAL_SPECIALIZATION
+    #endif
+#endif // __VISUALC__
+
+
+#ifndef HAVE_TEMPLATE_OVERLOAD_RESOLUTION
+    // assume the compiler can use type or const expressions as template
+    // arguments if it supports partial specialization -- except if it's a
+    // Borland one which can't
+    #if defined(HAVE_PARTIAL_SPECIALIZATION) && !defined(__BORLANDC__)
+        #define HAVE_TEMPLATE_OVERLOAD_RESOLUTION
+    #endif // __BORLANDC__
+#endif // !defined(HAVE_TEMPLATE_OVERLOAD_RESOLUTION)

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


@@ -487,42 +554,58 @@ typedef int wxWindowID;
 /*  ---------------------------------------------------------------------------- */
 
 /*  Printf-like attribute definitions to obtain warnings with GNU C/C++ */
 /*  ---------------------------------------------------------------------------- */
 
 /*  Printf-like attribute definitions to obtain warnings with GNU C/C++ */

-#if defined(__GNUC__) && !wxUSE_UNICODE
-#  ifndef ATTRIBUTE_PRINTF
-#    define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n)))
-#    define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2)
-#    define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3)
-#    define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4)
-#    define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5)
-#    define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6)
-#  endif /* ATTRIBUTE_PRINTF */
-#else
-#  ifndef ATTRIBUTE_PRINTF
-#    define ATTRIBUTE_PRINTF
-#    define ATTRIBUTE_PRINTF_1
-#    define ATTRIBUTE_PRINTF_2
-#    define ATTRIBUTE_PRINTF_3
-#    define ATTRIBUTE_PRINTF_4
-#    define ATTRIBUTE_PRINTF_5
-#  endif /* ATTRIBUTE_PRINTF */
-#endif
+#ifndef ATTRIBUTE_PRINTF
+#   if defined(__GNUC__) && !wxUSE_UNICODE
+#       define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n)))
+#   else
+#       define ATTRIBUTE_PRINTF(m, n)
+#   endif
+
+#   define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2)
+#   define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3)
+#   define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4)
+#   define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5)
+#   define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6)
+#endif /* !defined(ATTRIBUTE_PRINTF) */
+

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

-    #define wxDEPRECATED(x) x __attribute__ ((deprecated))
+    #define wxDEPRECATED(x) __attribute__((deprecated)) x

 #elif defined(__VISUALC__) && (__VISUALC__ >= 1300)
     #define wxDEPRECATED(x) __declspec(deprecated) x
 #else
     #define wxDEPRECATED(x) x
 #endif
 
 #elif defined(__VISUALC__) && (__VISUALC__ >= 1300)
     #define wxDEPRECATED(x) __declspec(deprecated) x
 #else
     #define wxDEPRECATED(x) x
 #endif
 

+/*
+   Macro which marks the function as being deprecated but also defines it
+   inline.
+
+   Currently it's defined in the same trivial way in all cases but it could
+   need a special definition with some other compilers in the future which
+   explains why do we have it.
+ */
+#define wxDEPRECATED_INLINE(func, body) wxDEPRECATED(func) { body }
+
+/*
+   Special variant of the macro above which should be used for the functions
+   which are deprecated but called by wx itself: this often happens with
+   deprecated virtual functions which are called by the library.
+ */
+#ifdef WXBUILDING
+#   define wxDEPRECATED_BUT_USED_INTERNALLY(x) x
+#else
+#   define wxDEPRECATED_BUT_USED_INTERNALLY(x) wxDEPRECATED(x)
+#endif
+

 /*  everybody gets the assert and other debug macros */
 #include "wx/debug.h"
 
 /*  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) */
 /*  everybody gets the assert and other debug macros */
 #include "wx/debug.h"
 
 /*  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
 


@@ -539,32 +622,64 @@ typedef int wxWindowID;
 /*  size of statically declared array */
 #define WXSIZEOF(array)   (sizeof(array)/sizeof(array[0]))
 
 /*  size of statically declared array */
 #define WXSIZEOF(array)   (sizeof(array)/sizeof(array[0]))
 

-/*  helper macros to concatenate two tokens together */
-#define wxCONCAT_HELPER(text, line) text ## line
-#define wxCONCAT(text, line)        wxCONCAT_HELPER(text, line)
-
-/*  helper macros to be able to define unique/anonymous objects: this works by */
-/*  appending the current line number to the given identifier to reduce the */
-/*  probability of the conflict (it may still happen if this is used in the */
-/*  headers, hence you should avoid doing it or provide unique prefixes then) */
-#if defined(__VISUALC__) && (__VISUALC__ >= 1300)
-    /*
-       __LINE__ handling is completely broken in VC++ when using "Edit and
-       Continue" (/ZI option) and results in preprocessor errors if we use it
-       inside the macros. Luckily VC7 has another standard macro which can be
-       used like this and is even better than __LINE__ because it is globally
-       unique.
-     */
-#   define wxCONCAT_LINE(text)         wxCONCAT(text, __COUNTER__)
-#else /* normal compilers */
-#   define wxCONCAT_LINE(text)         wxCONCAT(text, __LINE__)
-#endif
-#define wxMAKE_UNIQUE_NAME(text)    wxCONCAT_LINE(text)
-

 /*  symbolic constant used by all Find()-like functions returning positive */
 /*  integer on success as failure indicator */
 #define wxNOT_FOUND       (-1)
 
 /*  symbolic constant used by all Find()-like functions returning positive */
 /*  integer on success as failure indicator */
 #define wxNOT_FOUND       (-1)
 

+/*  ---------------------------------------------------------------------------- */
+/*  macros dealing with comparison operators */
+/*  ---------------------------------------------------------------------------- */
+
+/*
+    Expands into m(op, args...) for each op in the set { ==, !=, <, <=, >, >= }.
+ */
+#define wxFOR_ALL_COMPARISONS(m) \
+    m(==) m(!=) m(>=) m(<=) m(>) m(<)
+
+#define wxFOR_ALL_COMPARISONS_1(m, x) \
+    m(==,x) m(!=,x) m(>=,x) m(<=,x) m(>,x) m(<,x)
+
+#define wxFOR_ALL_COMPARISONS_2(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(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.
+ */
+#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 wxDEFINE_COMPARISON(op, T1, T2, cmp) \
+    inline bool operator op(T1 x, T2 y) { return cmp(x, y, op); }
+
+#define wxDEFINE_COMPARISON_REV(op, T1, T2, cmp, oprev) \
+    inline bool operator op(T2 y, T1 x) { return cmp(x, y, oprev); }
+
+/*
+    Define all 6 comparison operators (==, !=, <, <=, >, >=) for the given
+    types in the specified order. The implementation is provided by the cmp
+    macro. Normally wxDEFINE_ALL_COMPARISONS should be used as comparison
+    operators are usually symmetric.
+ */
+#define wxDEFINE_COMPARISONS(T1, T2, cmp) \
+    wxFOR_ALL_COMPARISONS_3(wxDEFINE_COMPARISON, T1, T2, 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"
+    macro to implement the actual comparison: the macro is called with the 2
+    arguments names, the first of type T1 and the second of type T2, and the
+    comparison operator being implemented.
+ */
+#define wxDEFINE_ALL_COMPARISONS(T1, T2, cmp) \
+    wxFOR_ALL_COMPARISONS_3(wxDEFINE_COMPARISON, T1, T2, cmp) \
+    wxFOR_ALL_COMPARISONS_3_REV(wxDEFINE_COMPARISON_REV, T1, T2, cmp)
+

 /*  ---------------------------------------------------------------------------- */
 /*  macros to avoid compiler warnings */
 /*  ---------------------------------------------------------------------------- */
 /*  ---------------------------------------------------------------------------- */
 /*  macros to avoid compiler warnings */
 /*  ---------------------------------------------------------------------------- */


@@ -664,68 +779,6 @@ typedef int wxWindowID;
 #  endif
 #endif
 
 #  endif
 #endif
 

-/*  ---------------------------------------------------------------------------- */
-/*  OS mnemonics -- Identify the running OS (useful for Windows) */
-/*  ---------------------------------------------------------------------------- */
-
-/*  Not all platforms are currently available or supported */
-enum
-{
-    wxUNKNOWN_PLATFORM,
-    wxCURSES,                 /*  Text-only CURSES */
-    wxXVIEW_X,                /*  Sun's XView OpenLOOK toolkit */
-    wxMOTIF_X,                /*  OSF Motif 1.x.x */
-    wxCOSE_X,                 /*  OSF Common Desktop Environment */
-    wxNEXTSTEP,               /*  NeXTStep */
-    wxMAC,                    /*  Apple Mac OS 8/9/X with Mac paths */
-    wxMAC_DARWIN,             /*  Apple Mac OS X with Unix paths */
-    wxBEOS,                   /*  BeOS */
-    wxGTK,                    /*  GTK on X */
-    wxGTK_WIN32,              /*  GTK on Win32 */
-    wxGTK_OS2,                /*  GTK on OS/2 */
-    wxGTK_BEOS,               /*  GTK on BeOS */
-    wxGEOS,                   /*  GEOS */
-    wxOS2_PM,                 /*  OS/2 Workplace */
-    wxWINDOWS,                /*  Windows or WfW */
-    wxMICROWINDOWS,           /*  MicroWindows */
-    wxPENWINDOWS,             /*  Windows for Pen Computing */
-    wxWINDOWS_NT,             /*  Windows NT */
-    wxWIN32S,                 /*  Windows 32S API */
-    wxWIN95,                  /*  Windows 95 */
-    wxWIN386,                 /*  Watcom 32-bit supervisor modus */
-    wxWINDOWS_CE,             /*  Windows CE (generic) */
-    wxWINDOWS_POCKETPC,       /*  Windows CE PocketPC */
-    wxWINDOWS_SMARTPHONE,     /*  Windows CE Smartphone */
-    wxMGL_UNIX,               /*  MGL with direct hardware access */
-    wxMGL_X,                  /*  MGL on X */
-    wxMGL_WIN32,              /*  MGL on Win32 */
-    wxMGL_OS2,                /*  MGL on OS/2 */
-    wxMGL_DOS,                /*  MGL on MS-DOS */
-    wxWINDOWS_OS2,            /*  Native OS/2 PM */
-    wxUNIX,                   /*  wxBase under Unix */
-    wxX11,                    /*  Plain X11 and Universal widgets */
-    wxPALMOS,                 /*  PalmOS */
-    wxDOS                     /*  wxBase under MS-DOS */
-};
-
-/* Friendlier platform names */
-enum
-{
-    wxMotif = wxMOTIF_X,
-    wxMac = wxMAC,
-    wxMSW = wxWINDOWS,
-    wxWinCE = wxWINDOWS_CE,
-    wxWinPocketPC = wxWINDOWS_POCKETPC,
-    wxWinSmartPhone = wxWINDOWS_SMARTPHONE,
-    wxWin95= wxWIN95,
-    wxUnix = wxUNIX,                   /*  wxBase under Unix */
-    wxPalmOS = wxPALMOS,               /*  PalmOS */
-    wxOS2 = wxOS2_PM,
-
-    wxMGL = 100,
-    wxCocoa
-};
-

 /*  ---------------------------------------------------------------------------- */
 /*  standard wxWidgets types */
 /*  ---------------------------------------------------------------------------- */
 /*  ---------------------------------------------------------------------------- */
 /*  standard wxWidgets types */
 /*  ---------------------------------------------------------------------------- */


@@ -740,16 +793,15 @@ 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 */
 /*  practice) */
 
 /*  8bit */
 #endif
 
 /*  chars are always one byte (by definition), shorts are always two (in */
 /*  practice) */
 
 /*  8bit */

-#ifndef SIZEOF_CHAR
-    #define SIZEOF_CHAR 1
-#endif

 typedef signed char wxInt8;
 typedef unsigned char wxUint8;
 typedef wxUint8 wxByte;
 typedef signed char wxInt8;
 typedef unsigned char wxUint8;
 typedef wxUint8 wxByte;


@@ -781,7 +833,7 @@ typedef wxUint16 wxWord;
   |short      | 16    16    16    16    16 |
   |int        | 32    64    32    32    16 |
   |long       | 64    64    32    32    32 |
   |short      | 16    16    16    16    16 |
   |int        | 32    64    32    32    16 |
   |long       | 64    64    32    32    32 |

-  |long long  |             64             |
+  |long long  | 64    64    64    --    -- |

   |void *     | 64    64    64    32    32 |
   +-----------+----------------------------+
 
   |void *     | 64    64    64    32    32 |
   +-----------+----------------------------+
 


@@ -799,7 +851,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__)


@@ -904,17 +958,52 @@ typedef wxUint16 wxWord;
     #endif
 #endif /*  Win/!Win */
 
     #endif
 #endif /*  Win/!Win */
 

+/* also define C99-like sized MIN/MAX constants */
+#define wxINT8_MIN CHAR_MIN
+#define wxINT8_MAX CHAR_MAX
+
+#define wxINT16_MIN SHRT_MIN
+#define wxINT16_MAX SHRT_MAX
+
+#if SIZEOF_INT == 4
+    #define wxINT32_MIN INT_MIN
+    #define wxINT32_MAX INT_MAX
+#elif SIZEOF_LONG == 4
+    #define wxINT32_MIN LONG_MIN
+    #define wxINT32_MAX LONG_MAX
+#else
+    #error "Unknown 32 bit type"
+#endif
+

 typedef wxUint32 wxDword;
 
 typedef wxUint32 wxDword;
 

+#ifdef LLONG_MAX
+    #define wxINT64_MAX LLONG_MAX
+    #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 *.
  */
 /*
    Define an integral type big enough to contain all of long, size_t and void *.
  */

-#if SIZEOF_LONG >= SIZEOF_VOID_P && SIZEOF_LONG >= SIZEOF_SIZE_T
-    /* normal case */
-    typedef unsigned long wxUIntPtr;
-#elif SIZEOF_SIZE_T >= SIZEOF_VOID_P
-    /* Win64 case */
+#if SIZEOF_SIZE_T >= SIZEOF_VOID_P
+    /*
+       Win64 case: size_t is the only integral type big enough for "void *".
+
+       Notice that wxUIntPtr should be also defined as size_t when building
+       under Win32 with MSVC with /Wp64 option as otherwise any conversion
+       between ints and pointers results in a warning 4311 or 4312, even if it
+       is safe under Win32. Using size_t (declared with __w64) allows to avoid
+       them.
+     */

     typedef size_t wxUIntPtr;
     typedef size_t wxUIntPtr;

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

 #else
     /*
        This should never happen for the current architectures but if you're
 #else
     /*
        This should never happen for the current architectures but if you're


@@ -985,18 +1074,17 @@ inline void *wxUIntToPtr(wxUIntPtr p)
 /*  we will need to define this */
 #undef wxLongLongIsLong
 
 /*  we will need to define this */
 #undef wxLongLongIsLong
 

-/*  first check for generic cases which are long on 64bit machine and "long */
-/*  long", then check for specific compilers */
-#if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
-    #define wxLongLong_t long
-    #define wxLongLongSuffix l
-    #define wxLongLongFmtSpec _T("l")
-    #define wxLongLongIsLong
-#elif defined(__WXPALMOS__)
-    #define wxLongLong_t int64_t
-    #define wxLongLongSuffix ll
-    #define wxLongLongFmtSpec _T("ll")
-#elif (defined(__VISUALC__) && defined(__WIN32__))
+/*
+   First check for specific compilers which have known 64 bit integer types,
+   this avoids clashes with SIZEOF_LONG[_LONG] being defined incorrectly for
+   e.g. MSVC builds (Python.h defines it as 8 even for MSVC).
+
+   Also notice that we check for "long long" before checking for 64 bit long as
+   we still want to use "long long" and not "long" for wxLongLong_t on 64 bit
+   architectures to be able to pass wxLongLong_t to the standard functions
+   prototyped as taking "long long" such as strtoll().
+ */
+#if (defined(__VISUALC__) && defined(__WIN32__))

     #define wxLongLong_t __int64
     #define wxLongLongSuffix i64
     #define wxLongLongFmtSpec _T("I64")
     #define wxLongLong_t __int64
     #define wxLongLongSuffix i64
     #define wxLongLongFmtSpec _T("I64")


@@ -1016,14 +1104,6 @@ inline void *wxUIntToPtr(wxUIntPtr p)
     #define wxLongLong_t long long
     #define wxLongLongSuffix ll
     #define wxLongLongFmtSpec _T("I64")
     #define wxLongLong_t long long
     #define wxLongLongSuffix ll
     #define wxLongLongFmtSpec _T("I64")

-#elif (defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8)  || \
-        defined(__GNUC__) || \
-        defined(__CYGWIN__) || \
-        defined(__WXMICROWIN__) || \
-        (defined(__DJGPP__) && __DJGPP__ >= 2)
-    #define wxLongLong_t long long
-    #define wxLongLongSuffix ll
-    #define wxLongLongFmtSpec _T("ll")

 #elif defined(__MWERKS__)
     #if __option(longlong)
         #define wxLongLong_t long long
 #elif defined(__MWERKS__)
     #if __option(longlong)
         #define wxLongLong_t long long


@@ -1033,20 +1113,45 @@ inline void *wxUIntToPtr(wxUIntPtr p)
         #error "The 64 bit integer support in CodeWarrior has been disabled."
         #error "See the documentation on the 'longlong' pragma."
     #endif
         #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 _T("ll")

 #elif defined(__VISAGECPP__) && __IBMCPP__ >= 400
     #define wxLongLong_t long long
 #elif defined(__VISAGECPP__) && __IBMCPP__ >= 400
     #define wxLongLong_t long long

+#elif (defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8)  || \
+        defined(__GNUC__) || \
+        defined(__CYGWIN__) || \
+        defined(__WXMICROWIN__) || \
+        (defined(__DJGPP__) && __DJGPP__ >= 2)
+    #define wxLongLong_t long long
+    #define wxLongLongSuffix ll
+    #define wxLongLongFmtSpec _T("ll")
+#elif defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
+    #define wxLongLong_t long
+    #define wxLongLongSuffix l
+    #define wxLongLongFmtSpec _T("l")
+    #define wxLongLongIsLong

 #endif
 
 
 #ifdef wxLongLong_t
 
     #ifdef __WXPALMOS__
 #endif
 
 
 #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
 

-    /*  these macros allow to definea 64 bit constants in a portable way */
+    /*  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))
 
     #define wxLL(x) wxCONCAT(x, wxLongLongSuffix)
     #define wxULL(x) wxCONCAT(x, wxCONCAT(u, wxLongLongSuffix))
 


@@ -1056,7 +1161,7 @@ inline void *wxUIntToPtr(wxUIntPtr p)
     #define wxHAS_INT64 1
 
 #elif wxUSE_LONGLONG
     #define wxHAS_INT64 1
 
 #elif wxUSE_LONGLONG

-    /*  these macros allow to definea 64 bit constants in a portable way */
+    /*  these macros allow to define 64 bit constants in a portable way */

     #define wxLL(x) wxLongLong(x)
     #define wxULL(x) wxULongLong(x)
 
     #define wxLL(x) wxLongLong(x)
     #define wxULL(x) wxULongLong(x)
 


@@ -1110,29 +1215,45 @@ typedef float wxFloat32;
     typedef double wxFloat64;
 #endif
 
     typedef double wxFloat64;
 #endif
 

-#if defined( __WXMAC__ )  && !defined( __POWERPC__ )
-    typedef long double wxDouble;
-#else
-    typedef double wxDouble;
-#endif
+typedef double wxDouble;

 
 /*
     Some (non standard) compilers typedef wchar_t as an existing type instead
     of treating it as a real fundamental type, set wxWCHAR_T_IS_REAL_TYPE to 0
     for them and to 1 for all the others.
  */
 
 /*
     Some (non standard) compilers typedef wchar_t as an existing type instead
     of treating it as a real fundamental type, set wxWCHAR_T_IS_REAL_TYPE to 0
     for them and to 1 for all the others.
  */

-#if wxUSE_WCHAR_T
+#ifndef wxWCHAR_T_IS_REAL_TYPE

     /*
     /*

-        VC++ typedefs wchar_t as unsigned short by default, that is unless
-        /Za or /Zc:wchar_t option is used in which case _WCHAR_T_DEFINED is
-        defined.
+        VC++ typedefs wchar_t as unsigned short by default until VC8, that is
+        unless /Za or /Zc:wchar_t option is used in which case _WCHAR_T_DEFINED
+        is defined.

      */
 #   if defined(__VISUALC__) && !defined(_NATIVE_WCHAR_T_DEFINED)
 #       define wxWCHAR_T_IS_REAL_TYPE 0
 #   else /* compiler having standard-conforming wchar_t */
 #       define wxWCHAR_T_IS_REAL_TYPE 1
 #   endif
      */
 #   if defined(__VISUALC__) && !defined(_NATIVE_WCHAR_T_DEFINED)
 #       define wxWCHAR_T_IS_REAL_TYPE 0
 #   else /* compiler having standard-conforming wchar_t */
 #       define wxWCHAR_T_IS_REAL_TYPE 1
 #   endif

-#endif /* wxUSE_WCHAR_T */
+#endif /* !defined(wxWCHAR_T_IS_REAL_TYPE) */
+
+/* Helper macro for doing something dependent on whether wchar_t is or isn't a
+   typedef inside another macro. */
+#if wxWCHAR_T_IS_REAL_TYPE
+    #define wxIF_WCHAR_T_TYPE(x) x
+#else /* !wxWCHAR_T_IS_REAL_TYPE */
+    #define wxIF_WCHAR_T_TYPE(x)
+#endif /* wxWCHAR_T_IS_REAL_TYPE/!wxWCHAR_T_IS_REAL_TYPE */
+
+/*
+   This constant should be used instead of NULL in vararg functions taking
+   wxChar* arguments: passing NULL (which is the same as 0, unless the compiler
+   defines it specially, e.g. like gcc does with its __null built-in) doesn't
+   work in this case as va_arg() wouldn't interpret the integer 0 correctly
+   when trying to convert it to a pointer on architectures where sizeof(int) is
+   strictly less than sizeof(void *).
+
+   Examples of places where this must be used include wxFileTypeInfo ctor.
+ */
+#define wxNullPtr ((void *)NULL)

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


@@ -1304,7 +1425,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


@@ -1322,7 +1446,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


@@ -1344,6 +1471,20 @@ enum wxAlignment
     wxALIGN_MASK              = 0x0f00
 };
 
     wxALIGN_MASK              = 0x0f00
 };
 

+/* misc. flags for wxSizer items */
+enum wxSizerFlagBits
+{
+    /* for compatibility only, default now, don't use explicitly any more */
+#if WXWIN_COMPATIBILITY_2_6
+    wxADJUST_MINSIZE               = 0,
+#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,
 enum wxStretch
 {
     wxSTRETCH_NOT             = 0x0000,


@@ -1351,15 +1492,10 @@ enum wxStretch
     wxGROW                    = 0x2000,
     wxEXPAND                  = wxGROW,
     wxSHAPED                  = 0x4000,
     wxGROW                    = 0x2000,
     wxEXPAND                  = wxGROW,
     wxSHAPED                  = 0x4000,

-    wxFIXED_MINSIZE           = 0x8000,
-    wxTILE                    = 0xc000,
+    wxTILE                    = wxSHAPED | wxFIXED_MINSIZE,

 
 

-    /* for compatibility only, default now, don't use explicitly any more */
-#if WXWIN_COMPATIBILITY_2_4
-    wxADJUST_MINSIZE          = 0x00100000
-#else
-    wxADJUST_MINSIZE          = 0
-#endif
+    /*  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 */


@@ -1374,7 +1510,8 @@ enum wxBorder
     wxBORDER_SIMPLE = 0x02000000,
     wxBORDER_RAISED = 0x04000000,
     wxBORDER_SUNKEN = 0x08000000,
     wxBORDER_SIMPLE = 0x02000000,
     wxBORDER_RAISED = 0x04000000,
     wxBORDER_SUNKEN = 0x08000000,

-    wxBORDER_DOUBLE = 0x10000000,
+    wxBORDER_DOUBLE = 0x10000000, /* deprecated */
+    wxBORDER_THEME  = wxBORDER_DOUBLE,

 
     /*  a mask to extract border style from the combination of flags */
     wxBORDER_MASK   = 0x1f200000
 
     /*  a mask to extract border style from the combination of flags */
     wxBORDER_MASK   = 0x1f200000


@@ -1622,60 +1759,6 @@ enum wxBorder
 #define wxSP_ARROW_KEYS       0x1000
 #define wxSP_WRAP             0x2000
 
 #define wxSP_ARROW_KEYS       0x1000
 #define wxSP_WRAP             0x2000
 

-/*
- * wxBookCtrl flags (common for wxNotebook, wxListbook, wxChoicebook, wxTreebook)
- */
-
-#define wxBK_DEFAULT          0x0000
-#define wxBK_TOP              0x0010
-#define wxBK_BOTTOM           0x0020
-#define wxBK_LEFT             0x0040
-#define wxBK_RIGHT            0x0080
-#define wxBK_ALIGN_MASK       ( wxBK_TOP | wxBK_BOTTOM | wxBK_LEFT | wxBK_RIGHT )
-
-/*
- * wxNotebook flags
- */
-#if WXWIN_COMPATIBILITY_2_6
-/* Use common book wxBK_* flags for describing alignment */
-#define wxNB_DEFAULT          wxBK_DEFAULT
-#define wxNB_TOP              wxBK_TOP
-#define wxNB_BOTTOM           wxBK_BOTTOM
-#define wxNB_LEFT             wxBK_LEFT
-#define wxNB_RIGHT            wxBK_RIGHT
-#endif
-
-#define wxNB_FIXEDWIDTH       0x0100
-#define wxNB_MULTILINE        0x0200
-#define wxNB_NOPAGETHEME      0x0400
-#define wxNB_FLAT             0x0800
-
-/*
- * wxListbook flags
- */
-#if WXWIN_COMPATIBILITY_2_6
-/* Use common book wxBK_* flags for describing alignment */
-#define wxLB_DEFAULT          wxBK_DEFAULT
-#define wxLB_TOP              wxBK_TOP
-#define wxLB_BOTTOM           wxBK_BOTTOM
-#define wxLB_LEFT             wxBK_LEFT
-#define wxLB_RIGHT            wxBK_RIGHT
-#define wxLB_ALIGN_MASK       wxBK_ALIGN_MASK
-#endif
-
-/*
- * wxChoicebook flags
- */
-#if WXWIN_COMPATIBILITY_2_6
-/* Use common book wxBK_* flags for describing alignment */
-#define wxCHB_DEFAULT          wxBK_DEFAULT
-#define wxCHB_TOP              wxBK_TOP
-#define wxCHB_BOTTOM           wxBK_BOTTOM
-#define wxCHB_LEFT             wxBK_LEFT
-#define wxCHB_RIGHT            wxBK_RIGHT
-#define wxCHB_ALIGN_MASK       wxBK_ALIGN_MASK
-#endif
-

 /*
  * wxTabCtrl flags
  */
 /*
  * wxTabCtrl flags
  */


@@ -1685,21 +1768,14 @@ enum wxBorder
 #define wxTC_LEFT             0x0020
 #define wxTC_RIGHT            0x0040
 #define wxTC_BOTTOM           0x0080
 #define wxTC_LEFT             0x0020
 #define wxTC_RIGHT            0x0040
 #define wxTC_BOTTOM           0x0080

-#define wxTC_MULTILINE        wxNB_MULTILINE
-#define wxTC_OWNERDRAW        0x0200
+#define wxTC_MULTILINE        0x0200    /* == wxNB_MULTILINE */
+#define wxTC_OWNERDRAW        0x0400

 
 /*
  * wxStatusBar95 flags
  */
 #define wxST_SIZEGRIP         0x0010
 
 
 /*
  * wxStatusBar95 flags
  */
 #define wxST_SIZEGRIP         0x0010
 

-/*
- * wxStaticText flags
- */
-#define wxST_NO_AUTORESIZE    0x0001
-#define wxST_DOTS_MIDDLE      0x0002
-#define wxST_DOTS_END         0x0004
-

 /*
  * wxStaticBitmap flags
  */
 /*
  * wxStaticBitmap flags
  */


@@ -1711,18 +1787,6 @@ enum wxBorder
 #define wxLI_HORIZONTAL         wxHORIZONTAL
 #define wxLI_VERTICAL           wxVERTICAL
 
 #define wxLI_HORIZONTAL         wxHORIZONTAL
 #define wxLI_VERTICAL           wxVERTICAL
 

-/*
- * wxProgressDialog flags
- */
-#define wxPD_CAN_ABORT          0x0001
-#define wxPD_APP_MODAL          0x0002
-#define wxPD_AUTO_HIDE          0x0004
-#define wxPD_ELAPSED_TIME       0x0008
-#define wxPD_ESTIMATED_TIME     0x0010
-#define wxPD_SMOOTH             0x0020
-#define wxPD_REMAINING_TIME     0x0040
-#define wxPD_CAN_SKIP           0x0080
-

 
 /*
  * extended dialog specifiers. these values are stored in a different
 
 /*
  * extended dialog specifiers. these values are stored in a different


@@ -1737,6 +1801,8 @@ enum wxBorder
 #define wxNO                    0x00000008
 #define wxYES_NO                (wxYES | wxNO)
 #define wxCANCEL                0x00000010
 #define wxNO                    0x00000008
 #define wxYES_NO                (wxYES | wxNO)
 #define wxCANCEL                0x00000010

+#define wxAPPLY                 0x00000020
+#define wxCLOSE                 0x00000040

 
 #define wxYES_DEFAULT           0x00000000  /*  has no effect (default) */
 #define wxNO_DEFAULT            0x00000080
 
 #define wxYES_DEFAULT           0x00000000  /*  has no effect (default) */
 #define wxNO_DEFAULT            0x00000080


@@ -1766,7 +1832,18 @@ enum wxBackgroundStyle
 {
   wxBG_STYLE_SYSTEM,
   wxBG_STYLE_COLOUR,
 {
   wxBG_STYLE_SYSTEM,
   wxBG_STYLE_COLOUR,

-  wxBG_STYLE_CUSTOM
+  wxBG_STYLE_CUSTOM,
+  wxBG_STYLE_TRANSPARENT
+};
+
+/*
+ * Key types used by (old style) lists and hashes.
+ */
+enum wxKeyType
+{
+    wxKEY_NONE,
+    wxKEY_INTEGER,
+    wxKEY_STRING

 };
 
 /*  ---------------------------------------------------------------------------- */
 };
 
 /*  ---------------------------------------------------------------------------- */


@@ -1776,6 +1853,24 @@ enum wxBackgroundStyle
 /*  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,
 


@@ -1802,6 +1897,7 @@ enum
     wxID_HELP,
     wxID_PRINT,
     wxID_PRINT_SETUP,
     wxID_HELP,
     wxID_PRINT,
     wxID_PRINT_SETUP,

+    wxID_PAGE_SETUP,

     wxID_PREVIEW,
     wxID_ABOUT,
     wxID_HELP_CONTENTS,
     wxID_PREVIEW,
     wxID_ABOUT,
     wxID_HELP_CONTENTS,


@@ -1813,7 +1909,8 @@ enum
     wxID_CLOSE_ALL,
     wxID_PREFERENCES,
 
     wxID_CLOSE_ALL,
     wxID_PREFERENCES,
 

-    wxID_CUT = 5030,
+    wxID_EDIT = 5030,
+    wxID_CUT,

     wxID_COPY,
     wxID_PASTE,
     wxID_CLEAR,
     wxID_COPY,
     wxID_PASTE,
     wxID_CLEAR,


@@ -1834,7 +1931,8 @@ enum
     wxID_VIEW_SORTSIZE,
     wxID_VIEW_SORTTYPE,
 
     wxID_VIEW_SORTSIZE,
     wxID_VIEW_SORTTYPE,
 

-    wxID_FILE1 = 5050,
+    wxID_FILE = 5050,
+    wxID_FILE1,

     wxID_FILE2,
     wxID_FILE3,
     wxID_FILE4,
     wxID_FILE2,
     wxID_FILE3,
     wxID_FILE4,


@@ -1901,9 +1999,25 @@ 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
 };
 
     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 */
 /*  ---------------------------------------------------------------------------- */


@@ -1915,6 +2029,7 @@ enum wxItemKind
     wxITEM_NORMAL,
     wxITEM_CHECK,
     wxITEM_RADIO,
     wxITEM_NORMAL,
     wxITEM_CHECK,
     wxITEM_RADIO,

+    wxITEM_DROPDOWN,

     wxITEM_MAX
 };
 
     wxITEM_MAX
 };
 


@@ -1968,7 +2083,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,


@@ -1990,6 +2106,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,


@@ -2014,22 +2137,9 @@ 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
-};
-
-#if WXWIN_COMPATIBILITY_2_4
-    #define IS_HATCH(s)    ((s)>=wxFIRST_HATCH && (s)<=wxLAST_HATCH)
-#else
-    /* use wxBrush::IsHatch() instead thought wxMotif still uses it in src/motif/dcclient.cpp */
+    wxLAST_HATCH = wxVERTICAL_HATCH

 #endif
 #endif

+};

 
 /*  Logical ops */
 typedef enum
 
 /*  Logical ops */
 typedef enum


@@ -2496,11 +2606,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;


@@ -2508,54 +2615,87 @@ 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; */

 typedef WX_OPAQUE_TYPE(ControlRef ) * WXWidget ;
 typedef WX_OPAQUE_TYPE(WindowRef) * WXWindow ;
 typedef WX_OPAQUE_TYPE(ControlRef ) * WXWidget ;
 typedef WX_OPAQUE_TYPE(WindowRef) * WXWindow ;

+

 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
-
-#ifdef __WXCOCOA__
+/*
+ * core frameworks
+ */
+
+typedef const void * CFTypeRef;
+
+typedef const struct __CFString * CFStringRef;
+typedef struct __CFString * CFMutableStringRef;
+
+typedef struct __CFRunLoopSource * CFRunLoopSourceRef;
+
+#define DECLARE_WXMAC_OPAQUE_CGREF( name ) typedef struct name* name##Ref;
+
+DECLARE_WXMAC_OPAQUE_CGREF( CGColor )
+DECLARE_WXMAC_OPAQUE_CGREF( CGImage )
+DECLARE_WXMAC_OPAQUE_CGREF( CGContext )
+
+typedef CGColorRef    WXCOLORREF;
+typedef CGImageRef    WXCGIMAGEREF;
+typedef CGContextRef  WXHDC;
+
+/*
+ * carbon
+ */
+
+typedef const struct __HIShape * HIShapeRef;
+typedef struct __HIShape * HIMutableShapeRef;
+
+#define DECLARE_WXMAC_OPAQUE_REF( name ) typedef struct Opaque##name* name;
+
+DECLARE_WXMAC_OPAQUE_REF( PasteboardRef )
+DECLARE_WXMAC_OPAQUE_REF( IconRef )
+
+typedef IconRef WXHICON ;
+typedef HIShapeRef WXHRGN;
+
+#endif
+
+#if defined( __WXCOCOA__ ) || defined(__WXMAC__)
+
+/* Definitions of 32-bit/64-bit types
+ * These are typedef'd exactly the same way in newer OS X headers so
+ * redefinition when real headers are included should not be a problem.  If
+ * it is, the types are being defined wrongly here.
+ * The purpose of these types is so they can be used from public wx headers.
+ * and also because the older (pre-Leopard) headers don't define them.
+ */
+
+/* NOTE: We don't pollute namespace with CGFLOAT_MIN/MAX/IS_DOUBLE macros
+ * since they are unlikely to be needed in a public header.
+ */
+#if defined(__LP64__) && __LP64__
+    typedef double CGFloat;
+#else
+    typedef float CGFloat;
+#endif
+
+#if (defined(__LP64__) && __LP64__) || (defined(NS_BUILD_32_LIKE_64) && NS_BUILD_32_LIKE_64)
+typedef long NSInteger;
+typedef unsigned long NSUInteger;
+#else
+typedef int NSInteger;
+typedef unsigned int NSUInteger;
+#endif
+
+/* Objective-C type declarations.
+ * These are to be used in public headers in lieu of NSSomething* because
+ * Objective-C class names are not available in C/C++ code.
+ */

 
 /*  NOTE: This ought to work with other compilers too, but I'm being cautious */
 #if (defined(__GNUC__) && defined(__APPLE__)) || defined(__MWERKS__)
 
 /*  NOTE: This ought to work with other compilers too, but I'm being cautious */
 #if (defined(__GNUC__) && defined(__APPLE__)) || defined(__MWERKS__)


@@ -2620,8 +2760,14 @@ 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__

 typedef WX_NSView WXWidget; /*  wxWidgets BASE definition */
 typedef WX_NSView WXWidget; /*  wxWidgets BASE definition */

-#endif /*  __WXCOCOA__ */
+#endif
+#endif /*  __WXCOCOA__  || ( __WXMAC__ &__DARWIN__)*/

 
 #if defined(__WXPALMOS__)
 
 
 #if defined(__WXPALMOS__)
 


@@ -2666,6 +2812,17 @@ typedef void *          WXRECTANGLEPTR;
 #    define WXFAR
 #endif
 
 #    define WXFAR
 #endif
 

+// we can't rely on Windows _W64 being defined as windows.h may not be included
+// so define our own equivalent: this should be used with types like WXLPARAM
+// or WXWPARAM which are 64 bit under Win64 to avoid warnings each time we cast
+// it to a pointer or a handle (which results in hundreds of warnings as Win32
+// API often passes pointers in them)
+#if wxCHECK_VISUALC_VERSION(7)
+    #define wxW64 __w64
+#else
+    #define wxW64
+#endif
+

 /*  Stand-ins for Windows types to avoid #including all of windows.h */
 typedef void *          WXHWND;
 typedef void *          WXHANDLE;
 /*  Stand-ins for Windows types to avoid #including all of windows.h */
 typedef void *          WXHWND;
 typedef void *          WXHANDLE;


@@ -2702,13 +2859,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__)


@@ -2790,15 +2947,12 @@ typedef unsigned long   HGLOBAL;
 /*  WIN32 graphics types for OS/2 GPI */
 
 /*  RGB under OS2 is more like a PALETTEENTRY struct under Windows so we need a real RGB def */
 /*  WIN32 graphics types for OS/2 GPI */
 
 /*  RGB under OS2 is more like a PALETTEENTRY struct under Windows so we need a real RGB def */

-/*  WARNING: The OS/2 headers typedef BYTE simply as 'char'; if the default is signed, all */
-/*  hell will break loose! */
-/* #define OS2RGB(r,g,b) ((DWORD ((BYTE) (b) | ((WORD) (g) << 8)) | (((DWORD)(BYTE)(r)) << 16))) */

 #define OS2RGB(r,g,b) ((DWORD)((unsigned char)(b) | ((unsigned char)(g) << 8)) | ((unsigned char)(r) << 16))
 
 typedef unsigned long COLORREF;
 #define OS2RGB(r,g,b) ((DWORD)((unsigned char)(b) | ((unsigned char)(g) << 8)) | ((unsigned char)(r) << 16))
 
 typedef unsigned long COLORREF;

-#define GetBValue(rgb) ((BYTE)((rgb) >> 16))
-#define GetGValue(rgb) ((BYTE)(((WORD)(rgb)) >> 8))
-#define GetRValue(rgb) ((BYTE)(rgb))
+#define GetRValue(rgb) ((unsigned char)((rgb) >> 16))
+#define GetGValue(rgb) ((unsigned char)(((unsigned short)(rgb)) >> 8))
+#define GetBValue(rgb) ((unsigned char)(rgb))

 #define PALETTEINDEX(i) ((COLORREF)(0x01000000 | (DWORD)(WORD)(i)))
 #define PALETTERGB(r,g,b) (0x02000000 | OS2RGB(r,g,b))
 /*  OS2's RGB/RGB2 is backwards from this */
 #define PALETTEINDEX(i) ((COLORREF)(0x01000000 | (DWORD)(WORD)(i)))
 #define PALETTERGB(r,g,b) (0x02000000 | OS2RGB(r,g,b))
 /*  OS2's RGB/RGB2 is backwards from this */


@@ -2853,6 +3007,7 @@ typedef void*           WXFontType; /* either a XmFontList or XmRenderTable */
 typedef void*           WXString;
 
 typedef unsigned long   Atom;  /* this might fail on a few architectures */
 typedef void*           WXString;
 
 typedef unsigned long   Atom;  /* this might fail on a few architectures */

+typedef long            WXPixel; /* safety catch in src/motif/colour.cpp */

 
 #endif /*  Motif */
 
 
 #endif /*  Motif */
 


@@ -2909,6 +3064,7 @@ 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;

+typedef struct _GtkCellRenderer   GtkCellRenderer;

 
 typedef GtkWidget *WXWidget;
 
 
 typedef GtkWidget *WXWidget;
 


@@ -2917,16 +3073,6 @@ typedef GtkWidget *WXWidget;
 #define GTK_CLASS_TYPE(klass) ((klass)->type)
 #endif
 
 #define GTK_CLASS_TYPE(klass) ((klass)->type)
 #endif
 

-#ifdef __WXGTK20__
-#define G_DISABLE_DEPRECATED
-#define PANGO_DISABLE_DEPRECATED
-#define GDK_PIXBUF_DISABLE_DEPRECATED
-#ifndef __VMS
-/* GtkCombo is not defined on VMS if this is defined */
-# define GTK_DISABLE_DEPRECATED
-#endif
-#endif
-

 #endif /*  __WXGTK__ */
 
 #if defined(__WXGTK20__) || (defined(__WXX11__) && wxUSE_UNICODE)
 #endif /*  __WXGTK__ */
 
 #if defined(__WXGTK20__) || (defined(__WXX11__) && wxUSE_UNICODE)


@@ -2946,39 +3092,22 @@ typedef struct _PangoFontDescription PangoFontDescription;
 typedef struct window_t *WXWidget;
 #endif /*  MGL */
 
 typedef struct window_t *WXWidget;
 #endif /*  MGL */
 

+#ifdef __WXDFB__
+/* DirectFB doesn't have the concept of non-TLW window, so use
+   something arbitrary */
+typedef const void* WXWidget;
+#endif /*  DFB */
+

 /*  This is required because of clashing macros in windows.h, which may be */
 /*  included before or after wxWidgets classes, and therefore must be */
 /*  disabled here before any significant wxWidgets headers are included. */
 #ifdef __WXMSW__
 /*  This is required because of clashing macros in windows.h, which may be */
 /*  included before or after wxWidgets classes, and therefore must be */
 /*  disabled here before any significant wxWidgets headers are included. */
 #ifdef __WXMSW__

-#ifdef GetClassInfo
-#undef GetClassInfo
-#endif
+#include "wx/msw/winundef.h"
+#endif /* __WXMSW__ */

 
 

-#ifdef GetClassName
-#undef GetClassName
-#endif
-
-#ifdef DrawText
-#undef DrawText
-#endif
-
-#ifdef GetCharWidth
-#undef GetCharWidth
-#endif

 
 

-#ifdef StartDoc
-#undef StartDoc
-#endif
-
-#ifdef FindWindow
-#undef FindWindow
-#endif
-
-#ifdef FindResource
-#undef FindResource
-#endif
-#endif
-  /*  __WXMSW__ */
+/*  include the feature test macros */
+#include "wx/features.h"

 
 /*  --------------------------------------------------------------------------- */
 /*  macro to define a class without copy ctor nor assignment operator */
 
 /*  --------------------------------------------------------------------------- */
 /*  macro to define a class without copy ctor nor assignment operator */