Import r67258 of the wxWidgets trunk, which I expect will before

long become wxWidgets 2.9.2, which in turn is expected to be the
last 2.9 release before the 3.0 stable release.

Since the full wxWidgets distribution is rather large, I have
imported only the parts that we use, on a subdirectory basis:

art
include/wx/*.*
include/wx/aui
include/wx/cocoa
include/wx/generic
include/wx/gtk
include/wx/meta
include/wx/msw
include/wx/osx
include/wx/persist
include/wx/private
include/wx/protocol
include/wx/unix
src/aui
src/common
src/generic
src/gtk
src/msw
src/osx
src/unix


git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@7380 8ced0084-cf51-0410-be5f-012b33b47a6e

Externals/wxWidgets3/include/wx/meta/convertible.h

@@ -0,0 +1,39 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/meta/convertible.h
+// Purpose:     Test if types are convertible
+// Author:      Arne Steinarson
+// Created:     2008-01-10
+// RCS-ID:      $Id: convertible.h 61724 2009-08-21 10:41:26Z VZ $
+// Copyright:   (c) 2008 Arne Steinarson
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_META_CONVERTIBLE_H_
+#define _WX_META_CONVERTIBLE_H_
+
+//
+// Introduce an extra class to make this header compilable with g++3.2
+//
+template <class D, class B>
+struct wxConvertibleTo_SizeHelper
+{
+    static char Match(B* pb);
+    static int  Match(...);
+};
+
+// Helper to decide if an object of type D is convertible to type B (the test
+// succeeds in particular when D derives from B)
+template <class D, class B>
+struct wxConvertibleTo
+{
+    enum
+    {
+        value =
+            sizeof(wxConvertibleTo_SizeHelper<D,B>::Match(static_cast<D*>(NULL)))
+            ==
+            sizeof(char)
+    };
+};
+
+#endif // _WX_META_CONVERTIBLE_H_
+

Externals/wxWidgets3/include/wx/meta/if.h

@@ -0,0 +1,73 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/meta/if.h
+// Purpose:     declares wxIf<> metaprogramming construct
+// Author:      Vaclav Slavik
+// Created:     2008-01-22
+// RCS-ID:      $Id: if.h 61724 2009-08-21 10:41:26Z VZ $
+// Copyright:   (c) 2008 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_META_IF_H_
+#define _WX_META_IF_H_
+
+#include "wx/defs.h"
+
+// NB: This code is intentionally written without partial templates
+//     specialization, because some older compilers (notably VC6) don't
+//     support it.
+
+namespace wxPrivate
+{
+
+template <bool Cond>
+struct wxIfImpl
+
+// broken VC6 needs not just an incomplete template class declaration but a
+// "skeleton" declaration of the specialized versions below as it apparently
+// tries to look up the types in the generic template definition at some moment
+// even though it ends up by using the correct specialization in the end -- but
+// without this skeleton it doesn't recognize Result as a class at all below
+#if defined(__VISUALC__) && !wxCHECK_VISUALC_VERSION(7)
+{
+    template<typename TTrue, typename TFalse> struct Result {};
+}
+#endif // VC++ <= 6
+;
+
+// specialization for true:
+template <>
+struct wxIfImpl<true>
+{
+    template<typename TTrue, typename TFalse> struct Result
+    {
+        typedef TTrue value;
+    };
+};
+
+// specialization for false:
+template<>
+struct wxIfImpl<false>
+{
+    template<typename TTrue, typename TFalse> struct Result
+    {
+        typedef TFalse value;
+    };
+};
+
+} // namespace wxPrivate
+
+// wxIf<> template defines nested type "value" which is the same as
+// TTrue if the condition Cond (boolean compile-time constant) was met and
+// TFalse if it wasn't.
+//
+// See wxVector<T> in vector.h for usage example
+template<bool Cond, typename TTrue, typename TFalse>
+struct wxIf
+{
+    typedef typename wxPrivate::wxIfImpl<Cond>
+                     ::template Result<TTrue, TFalse>::value
+            value;
+};
+
+#endif // _WX_META_IF_H_

Externals/wxWidgets3/include/wx/meta/implicitconversion.h

@@ -0,0 +1,113 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/meta/implicitconversion.h
+// Purpose:     Determine resulting type from implicit conversion
+// Author:      Vaclav Slavik
+// Created:     2010-10-22
+// RCS-ID:      $Id: implicitconversion.h 66054 2010-11-07 13:16:20Z VZ $
+// Copyright:   (c) 2010 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_META_IMPLICITCONVERSION_H_
+#define _WX_META_IMPLICITCONVERSION_H_
+
+#include "wx/defs.h"
+#include "wx/meta/if.h"
+
+// C++ hierarchy of data types is:
+//
+//   Long double (highest)
+//   Double
+//   Float
+//   Unsigned long int
+//   Long int
+//   Unsigned int
+//   Int (lowest)
+//
+// Types lower in the hierarchy are converted into ones higher up if both are
+// involved e.g. in arithmetic expressions.
+
+namespace wxPrivate
+{
+
+// Helper macro to define a constant inside a template class: it's needed
+// because MSVC6 doesn't support initializing static integer members but the
+// usual workaround of using enums instead doesn't work for Borland (at least
+// in template classes).
+#ifdef __VISUALC6__
+    #define wxDEFINE_CLASS_INT_CONST(name, value) enum { name = value }
+#else
+    #define wxDEFINE_CLASS_INT_CONST(name, value) static const int name = value
+#endif
+
+template<typename T>
+struct TypeHierarchy
+{
+    // consider unknown types (e.g. objects, pointers) to be of highest
+    // level, always convert to them if they occur
+    wxDEFINE_CLASS_INT_CONST( level, 9999 );
+};
+
+#define WX_TYPE_HIERARCHY_LEVEL(level_num, type)        \
+    template<> struct TypeHierarchy<type>               \
+    {                                                   \
+        wxDEFINE_CLASS_INT_CONST( level, level_num );   \
+    }
+
+WX_TYPE_HIERARCHY_LEVEL( 1, char);
+WX_TYPE_HIERARCHY_LEVEL( 2, unsigned char);
+WX_TYPE_HIERARCHY_LEVEL( 3, short);
+WX_TYPE_HIERARCHY_LEVEL( 4, unsigned short);
+WX_TYPE_HIERARCHY_LEVEL( 5, int);
+WX_TYPE_HIERARCHY_LEVEL( 6, unsigned int);
+WX_TYPE_HIERARCHY_LEVEL( 7, long);
+WX_TYPE_HIERARCHY_LEVEL( 8, unsigned long);
+#ifdef wxLongLong_t
+WX_TYPE_HIERARCHY_LEVEL( 9, wxLongLong_t);
+WX_TYPE_HIERARCHY_LEVEL(10, wxULongLong_t);
+#endif
+WX_TYPE_HIERARCHY_LEVEL(11, float);
+WX_TYPE_HIERARCHY_LEVEL(12, double);
+WX_TYPE_HIERARCHY_LEVEL(13, long double);
+
+#if wxWCHAR_T_IS_REAL_TYPE
+    #if SIZEOF_WCHAR_T == SIZEOF_SHORT
+      template<> struct TypeHierarchy<wchar_t> : public TypeHierarchy<short> {};
+    #elif SIZEOF_WCHAR_T == SIZEOF_INT
+      template<> struct TypeHierarchy<wchar_t> : public TypeHierarchy<int> {};
+    #elif SIZEOF_WCHAR_T == SIZEOF_LONG
+      template<> struct TypeHierarchy<wchar_t> : public TypeHierarchy<long> {};
+    #else
+      #error "weird wchar_t size, please update this code"
+    #endif
+#endif
+
+#undef WX_TYPE_HIERARCHY_LEVEL
+
+} // namespace wxPrivate
+
+// Helper to determine resulting type of implicit conversion in
+// an expression with two arithmetic types.
+template<typename T1, typename T2>
+struct wxImplicitConversionType
+{
+    typedef typename wxIf
+            <
+                // if T2 is "higher" type, convert to it
+                (int)(wxPrivate::TypeHierarchy<T1>::level) < (int)(wxPrivate::TypeHierarchy<T2>::level),
+                T2,
+                // otherwise use T1
+                T1
+            >::value
+            value;
+};
+
+
+template<typename T1, typename T2, typename T3>
+struct wxImplicitConversionType3 : public wxImplicitConversionType<
+                        T1,
+                        typename wxImplicitConversionType<T2,T3>::value>
+{
+};
+
+#endif // _WX_META_IMPLICITCONVERSION_H_

Externals/wxWidgets3/include/wx/meta/int2type.h

@@ -0,0 +1,17 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/meta/int2type.h
+// Purpose:     Generate a unique type from a constant integer
+// Author:      Arne Steinarson
+// Created:     2008-01-10
+// RCS-ID:      $Id: int2type.h 61724 2009-08-21 10:41:26Z VZ $
+// Copyright:   (c) 2008 Arne Steinarson
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_META_INT2TYPE_H_
+#define _WX_META_INT2TYPE_H_
+
+template <int N>
+struct wxInt2Type { enum { value=N }; };
+
+#endif // _WX_META_INT2TYPE_H_

Externals/wxWidgets3/include/wx/meta/movable.h

@@ -0,0 +1,45 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/meta/movable.h
+// Purpose:     Test if a type is movable using memmove() etc.
+// Author:      Vaclav Slavik
+// Created:     2008-01-21
+// RCS-ID:      $Id: movable.h 64589 2010-06-14 15:12:37Z JMS $
+// Copyright:   (c) 2008 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_META_MOVABLE_H_
+#define _WX_META_MOVABLE_H_
+
+#include "wx/meta/pod.h"
+#include "wx/string.h" // for wxIsMovable<wxString> specialization
+
+// Helper to decide if an object of type T is "movable", i.e. if it can be
+// copied to another memory location using memmove() or realloc() C functions.
+// C++ only gurantees that POD types (including primitive types) are
+// movable.
+template<typename T>
+struct wxIsMovable
+{
+    wxDEFINE_TEMPLATE_BOOL_VALUE(wxIsPod<T>::value);
+};
+
+// Macro to add wxIsMovable<T> specialization for given type that marks it
+// as movable:
+#define WX_DECLARE_TYPE_MOVABLE(type)                       \
+    template<> struct wxIsMovable<type>                     \
+    {                                                       \
+        wxDEFINE_TEMPLATE_BOOL_VALUE(true);                 \
+    };
+
+// Our implementation of wxString is written in such way that it's safe to move
+// it around (unless position cache is used which unfortunately breaks this).
+// OTOH, we don't know anything about std::string.
+// (NB: we don't put this into string.h and choose to include wx/string.h from
+// here instead so that rarely-used wxIsMovable<T> code isn't included by
+// everything)
+#if !wxUSE_STL && !wxUSE_STRING_POS_CACHE
+WX_DECLARE_TYPE_MOVABLE(wxString)
+#endif
+
+#endif // _WX_META_MOVABLE_H_

Externals/wxWidgets3/include/wx/meta/pod.h

@@ -0,0 +1,88 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/meta/pod.h
+// Purpose:     Test if a type is POD
+// Author:      Vaclav Slavik, Jaakko Salli
+// Created:     2010-06-14
+// RCS-ID:      $Id: pod.h 64589 2010-06-14 15:12:37Z JMS $
+// Copyright:   (c) wxWidgets team
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_META_POD_H_
+#define _WX_META_POD_H_
+
+#include "wx/defs.h"
+
+//
+// TODO: Use TR1 is_pod<> implementation where available. VC9 SP1 has it
+//       in tr1 namespace, VC10 has it in std namespace. GCC 4.2 has it in
+//       <tr1/type_traits>, while GCC 4.3 and later have it in <type_traits>.
+//
+
+// This macro declares something called "value" inside a class declaration.
+//
+// It has to be used because VC6 doesn't handle initialization of the static
+// variables in the class declaration itself while BCC5.82 doesn't understand
+// enums (it compiles the template fine but can't use it later)
+#if defined(__VISUALC__) && !wxCHECK_VISUALC_VERSION(7)
+    #define wxDEFINE_TEMPLATE_BOOL_VALUE(val) enum { value = val }
+#else
+    #define wxDEFINE_TEMPLATE_BOOL_VALUE(val) static const bool value = val
+#endif
+
+// Helper to decide if an object of type T is POD (Plain Old Data)
+template<typename T>
+struct wxIsPod
+{
+    wxDEFINE_TEMPLATE_BOOL_VALUE(false);
+};
+
+// Macro to add wxIsPod<T> specialization for given type that marks it
+// as Plain Old Data:
+#define WX_DECLARE_TYPE_POD(type)                           \
+    template<> struct wxIsPod<type>                         \
+    {                                                       \
+        wxDEFINE_TEMPLATE_BOOL_VALUE(true);                 \
+    };
+
+WX_DECLARE_TYPE_POD(bool)
+WX_DECLARE_TYPE_POD(unsigned char)
+WX_DECLARE_TYPE_POD(signed char)
+WX_DECLARE_TYPE_POD(unsigned int)
+WX_DECLARE_TYPE_POD(signed int)
+WX_DECLARE_TYPE_POD(unsigned short int)
+WX_DECLARE_TYPE_POD(signed short int)
+WX_DECLARE_TYPE_POD(signed long int)
+WX_DECLARE_TYPE_POD(unsigned long int)
+WX_DECLARE_TYPE_POD(float)
+WX_DECLARE_TYPE_POD(double)
+WX_DECLARE_TYPE_POD(long double)
+#if wxWCHAR_T_IS_REAL_TYPE
+WX_DECLARE_TYPE_POD(wchar_t)
+#endif
+#ifdef wxLongLong_t
+WX_DECLARE_TYPE_POD(wxLongLong_t)
+WX_DECLARE_TYPE_POD(wxULongLong_t)
+#endif
+
+// Visual C++ 6.0 can't compile partial template specializations and as this is
+// only an optimization, we can live with pointers not being recognized as
+// POD types under VC6
+#if !defined(__VISUALC__) || wxCHECK_VISUALC_VERSION(7)
+
+// pointers are Plain Old Data:
+template<typename T>
+struct wxIsPod<T*>
+{
+    static const bool value = true;
+};
+
+template<typename T>
+struct wxIsPod<const T*>
+{
+    static const bool value = true;
+};
+
+#endif // !VC++ < 7
+
+#endif // _WX_META_POD_H_