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
2025-07-29 00:59:44 -06:00 · 2011-03-20 18:05:19 +00:00
parent 205637ccc3
commit d14efe561b
1945 changed files with 694474 additions and 0 deletions
--- a/Externals/wxWidgets3/include/wx/variantbase.h
+++ b/Externals/wxWidgets3/include/wx/variantbase.h
@ -0,0 +1,279 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/variantbase.h
+// Purpose:     wxVariantBase class, a minimal version of wxVariant used by XTI
+// Author:      Julian Smart
+// Modified by: Francesco Montorsi
+// Created:     10/09/98
+// RCS-ID:      $Id: variantbase.h 66584 2011-01-05 06:56:36Z PC $
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_VARIANTBASE_H_
+#define _WX_VARIANTBASE_H_
+
+#include "wx/defs.h"
+
+#if wxUSE_VARIANT
+
+#include "wx/string.h"
+#include "wx/arrstr.h"
+#include "wx/cpp.h"
+#include <typeinfo>
+
+#if wxUSE_DATETIME
+    #include "wx/datetime.h"
+#endif // wxUSE_DATETIME
+
+#include "wx/iosfwrap.h"
+
+class wxTypeInfo;
+class wxObject;
+class wxClassInfo;
+
+/*
+ * wxVariantData stores the actual data in a wxVariant object,
+ * to allow it to store any type of data.
+ * Derive from this to provide custom data handling.
+ *
+ * NB: To prevent addition of extra vtbl pointer to wxVariantData,
+ *     we don't multiple-inherit from wxObjectRefData. Instead,
+ *     we simply replicate the wxObject ref-counting scheme.
+ *
+ * NB: When you construct a wxVariantData, it will have refcount
+ *     of one. Refcount will not be further increased when
+ *     it is passed to wxVariant. This simulates old common
+ *     scenario where wxVariant took ownership of wxVariantData
+ *     passed to it.
+ *     If you create wxVariantData for other reasons than passing
+ *     it to wxVariant, technically you are not required to call
+ *     DecRef() before deleting it.
+ *
+ * TODO: in order to replace wxPropertyValue, we would need
+ * to consider adding constructors that take pointers to C++ variables,
+ * or removing that functionality from the wxProperty library.
+ * Essentially wxPropertyValue takes on some of the wxValidator functionality
+ * by storing pointers and not just actual values, allowing update of C++ data
+ * to be handled automatically. Perhaps there's another way of doing this without
+ * overloading wxVariant with unnecessary functionality.
+ */
+
+class WXDLLIMPEXP_BASE wxVariantData
+{
+    friend class wxVariantBase;
+
+public:
+    wxVariantData()
+        : m_count(1)
+    { }
+
+#if wxUSE_STD_IOSTREAM
+    virtual bool Write(wxSTD ostream& WXUNUSED(str)) const { return false; }
+    virtual bool Read(wxSTD istream& WXUNUSED(str)) { return false; }
+#endif
+    virtual bool Write(wxString& WXUNUSED(str)) const { return false; }
+    virtual bool Read(wxString& WXUNUSED(str)) { return false; }
+
+    // Override these to provide common functionality
+    virtual bool Eq(wxVariantData& data) const = 0;
+
+    // What type is it? Return a string name.
+    virtual wxString GetType() const = 0;
+
+    // returns the type info of the content
+    virtual const wxTypeInfo* GetTypeInfo() const = 0;
+
+    // If it based on wxObject return the ClassInfo.
+    virtual wxClassInfo* GetValueClassInfo() { return NULL; }
+
+    int GetRefCount() const 
+        { return m_count; }
+    void IncRef() 
+        { m_count++; }
+    void DecRef()
+    {
+        if ( --m_count == 0 )
+            delete this;
+    }
+
+protected:
+    // Protected dtor should make some incompatible code
+    // break more louder. That is, they should do data->DecRef()
+    // instead of delete data.
+    virtual ~wxVariantData() {}
+
+private:
+    int m_count;
+};
+
+template<typename T> class wxVariantDataT : public wxVariantData
+{
+public:
+    wxVariantDataT(const T& d) : m_data(d) {}
+    virtual ~wxVariantDataT() {}
+
+    // get a ref to the stored data
+    T & Get() { return m_data; }
+
+    // get a const ref to the stored data
+    const T & Get() const { return m_data; }
+
+    // set the data
+    void Set(const T& d) { m_data =  d; }
+
+    // Override these to provide common functionality
+    virtual bool Eq(wxVariantData& WXUNUSED(data)) const
+        { return false; /* FIXME!! */    }
+
+    // What type is it? Return a string name.
+    virtual wxString GetType() const
+        { return GetTypeInfo()->GetTypeName(); }
+
+    // return a heap allocated duplicate
+    //virtual wxVariantData* Clone() const { return new wxVariantDataT<T>( Get() ); }
+
+    // returns the type info of the contentc
+    virtual const wxTypeInfo* GetTypeInfo() const { return wxGetTypeInfo( (T*) NULL ); }
+
+private:
+    T m_data;
+};
+
+
+/*
+ * wxVariantBase can store any kind of data, but has some basic types
+ * built in.
+ */
+
+class WXDLLIMPEXP_BASE wxVariantBase
+{
+public:
+    wxVariantBase();
+    wxVariantBase(const wxVariantBase& variant);
+    wxVariantBase(wxVariantData* data, const wxString& name = wxEmptyString);
+
+    template<typename T> 
+        wxVariantBase(const T& data, const wxString& name = wxEmptyString) :
+            m_data(new wxVariantDataT<T>(data)), m_name(name) {}
+
+    virtual ~wxVariantBase();
+
+    // generic assignment
+    void operator= (const wxVariantBase& variant);
+
+    // Assignment using data, e.g.
+    // myVariant = new wxStringVariantData("hello");
+    void operator= (wxVariantData* variantData);
+
+    bool operator== (const wxVariantBase& variant) const;
+    bool operator!= (const wxVariantBase& variant) const;
+
+    // Sets/gets name
+    inline void SetName(const wxString& name) { m_name = name; }
+    inline const wxString& GetName() const { return m_name; }
+
+    // Tests whether there is data
+    bool IsNull() const;
+
+    // FIXME: used by wxVariantBase code but is nice wording...
+    bool IsEmpty() const { return IsNull(); }
+
+    // For compatibility with wxWidgets <= 2.6, this doesn't increase
+    // reference count.
+    wxVariantData* GetData() const { return m_data; }
+    void SetData(wxVariantData* data) ;
+
+    // make a 'clone' of the object
+    void Ref(const wxVariantBase& clone);
+
+    // destroy a reference
+    void UnRef();
+
+    // Make NULL (i.e. delete the data)
+    void MakeNull();
+
+    // write contents to a string (e.g. for debugging)
+    wxString MakeString() const;
+
+    // Delete data and name
+    void Clear();
+
+    // Returns a string representing the type of the variant,
+    // e.g. "string", "bool", "stringlist", "list", "double", "long"
+    wxString GetType() const;
+
+    bool IsType(const wxString& type) const;
+    bool IsValueKindOf(const wxClassInfo* type) const;
+
+    // FIXME wxXTI methods:
+
+    // get the typeinfo of the stored object
+    const wxTypeInfo* GetTypeInfo() const 
+    { 
+        if (!m_data)
+            return NULL;
+        return m_data->GetTypeInfo(); 
+    }
+
+    // get a ref to the stored data
+    template<typename T> T& Get(wxTEMPLATED_MEMBER_FIX(T))
+    {
+        wxVariantDataT<T> *dataptr = 
+            wx_dynamic_cast(wxVariantDataT<T>*, m_data);
+        wxASSERT_MSG( dataptr, 
+            wxString::Format(wxT("Cast to %s not possible"), typeid(T).name()) );
+        return dataptr->Get();
+    }
+
+    // get a const ref to the stored data
+    template<typename T> const T& Get(wxTEMPLATED_MEMBER_FIX(T)) const
+    {
+        const wxVariantDataT<T> *dataptr = 
+            wx_dynamic_cast(const wxVariantDataT<T>*, m_data);
+        wxASSERT_MSG( dataptr, 
+            wxString::Format(wxT("Cast to %s not possible"), typeid(T).name()) );
+        return dataptr->Get();
+    }
+
+    template<typename T> bool HasData(wxTEMPLATED_MEMBER_FIX(T)) const
+    {
+        const wxVariantDataT<T> *dataptr = 
+            wx_dynamic_cast(const wxVariantDataT<T>*, m_data);
+        return dataptr != NULL;
+    }
+
+    // returns this value as string
+    wxString GetAsString() const;
+
+    // gets the stored data casted to a wxObject*, 
+    // returning NULL if cast is not possible
+    wxObject* GetAsObject();
+
+protected:
+    wxVariantData*  m_data;
+    wxString        m_name;
+};
+
+#include "wx/dynarray.h"
+WX_DECLARE_OBJARRAY_WITH_DECL(wxVariantBase, wxVariantBaseArray, class WXDLLIMPEXP_BASE);
+
+
+// templated streaming, every type must have their specialization for these methods
+
+template<typename T>
+void wxStringReadValue( const wxString &s, T &data );
+
+template<typename T>
+void wxStringWriteValue( wxString &s, const T &data);
+
+template<typename T>
+void wxToStringConverter( const wxVariantBase &v, wxString &s wxTEMPLATED_FUNCTION_FIX(T)) \
+    { wxStringWriteValue( s, v.wxTEMPLATED_MEMBER_CALL(Get, T) ); }
+
+template<typename T>
+void wxFromStringConverter( const wxString &s, wxVariantBase &v wxTEMPLATED_FUNCTION_FIX(T)) \
+    { T d; wxStringReadValue( s, d ); v = wxVariantBase(d); }
+
+
+#endif // wxUSE_VARIANT
+#endif // _WX_VARIANTBASE_H_