Add lambda-friendly wxDialog::ShowWindowModalThenDo().

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

diff --git a/include/wx/variant.h b/include/wx/variant.h
index b1b18da47f73821e05adb493db3c3ca898eecf28..39adc729b905beea97990744913d1235ed697f47 100644 (file)
--- a/include/wx/variant.h
+++ b/include/wx/variant.h
@@ -4,7 +4,6 @@
 // Author:      Julian Smart
 // Modified by:
 // Created:     10/09/98
-// RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
@@ -29,6 +28,8 @@
 
 #include "wx/iosfwrap.h"
 
+class wxAny;
+
 /*
  * wxVariantData stores the actual data in a wxVariant object,
  * to allow it to store any type of data.
@@ -78,6 +79,11 @@ public:
     // a copy of the data.
     virtual wxVariantData* Clone() const { return NULL; }
 
+#if wxUSE_ANY
+    // Converts value to wxAny, if possible. Return true if successful.
+    virtual bool GetAsAny(wxAny* WXUNUSED(any)) const { return false; }
+#endif
+
 protected:
     // Protected dtor should make some incompatible code
     // break more louder. That is, they should do data->DecRef()
@@ -101,6 +107,9 @@ public:
 
     wxVariant(const wxVariant& variant);
     wxVariant(wxVariantData* data, const wxString& name = wxEmptyString);
+#if wxUSE_ANY
+    wxVariant(const wxAny& any);
+#endif
     virtual ~wxVariant();
 
     // generic assignment
@@ -150,6 +159,10 @@ public:
     // write contents to a string (e.g. for debugging)
     wxString MakeString() const;
 
+#if wxUSE_ANY
+    wxAny GetAny() const;
+#endif
+
     // double
     wxVariant(double val, const wxString& name = wxEmptyString);
     bool operator== (double value) const;
@@ -216,6 +229,26 @@ public:
     inline operator wxString () const {  return MakeString(); }
     wxString GetString() const;
 
+#if wxUSE_STD_STRING
+    wxVariant(const std::string& val, const wxString& name = wxEmptyString);
+    bool operator==(const std::string& value) const
+        { return operator==(wxString(value)); }
+    bool operator!=(const std::string& value) const
+        { return operator!=(wxString(value)); }
+    wxVariant& operator=(const std::string& value)
+        { return operator=(wxString(value)); }
+    operator std::string() const { return (operator wxString()).ToStdString(); }
+
+    wxVariant(const wxStdWideString& val, const wxString& name = wxEmptyString);
+    bool operator==(const wxStdWideString& value) const
+        { return operator==(wxString(value)); }
+    bool operator!=(const wxStdWideString& value) const
+        { return operator!=(wxString(value)); }
+    wxVariant& operator=(const wxStdWideString& value)
+        { return operator=(wxString(value)); }
+    operator wxStdWideString() const { return (operator wxString()).ToStdWstring(); }
+#endif // wxUSE_STD_STRING
+
     // wxUniChar
     wxVariant(const wxUniChar& val, const wxString& name = wxEmptyString);
     wxVariant(const wxUniCharRef& val, const wxString& name = wxEmptyString);
@@ -328,6 +361,24 @@ public:
 #if wxUSE_LONGLONG
     bool Convert(wxLongLong* value) const;
     bool Convert(wxULongLong* value) const;
+  #ifdef wxLongLong_t
+    bool Convert(wxLongLong_t* value) const
+    {
+        wxLongLong temp;
+        if ( !Convert(&temp) )
+            return false;
+        *value = temp.GetValue();
+        return true;
+    }
+    bool Convert(wxULongLong_t* value) const
+    {
+        wxULongLong temp;
+        if ( !Convert(&temp) )
+            return false;
+        *value = temp.GetValue();
+        return true;
+    }
+  #endif // wxLongLong_t
 #endif // wxUSE_LONGLONG
 
 // Attributes
@@ -341,6 +392,84 @@ private:
     DECLARE_DYNAMIC_CLASS(wxVariant)
 };
 
+
+//
+// wxVariant <-> wxAny conversion code
+//
+#if wxUSE_ANY
+
+#include "wx/any.h"
+
+// In order to convert wxAny to wxVariant, we need to be able to associate
+// wxAnyValueType with a wxVariantData factory function.
+typedef wxVariantData* (*wxVariantDataFactory)(const wxAny& any);
+
+// Actual Any-to-Variant registration must be postponed to a time when all
+// global variables have been initialized. Hence this arrangement.
+// wxAnyToVariantRegistration instances are kept in global scope and
+// wxAnyValueTypeGlobals in any.cpp will use their data when the time is
+// right.
+class WXDLLIMPEXP_BASE wxAnyToVariantRegistration
+{
+public:
+    wxAnyToVariantRegistration(wxVariantDataFactory factory);
+    virtual ~wxAnyToVariantRegistration();
+
+    virtual wxAnyValueType* GetAssociatedType() = 0;
+    wxVariantDataFactory GetFactory() const { return m_factory; }
+private:
+    wxVariantDataFactory    m_factory;
+};
+
+template<typename T>
+class wxAnyToVariantRegistrationImpl : public wxAnyToVariantRegistration
+{
+public:
+    wxAnyToVariantRegistrationImpl(wxVariantDataFactory factory)
+        : wxAnyToVariantRegistration(factory)
+    {
+    }
+
+    virtual wxAnyValueType* GetAssociatedType()
+    {
+        return wxAnyValueTypeImpl<T>::GetInstance();
+    }
+private:
+};
+
+#define DECLARE_WXANY_CONVERSION() \
+virtual bool GetAsAny(wxAny* any) const; \
+static wxVariantData* VariantDataFactory(const wxAny& any);
+
+#define _REGISTER_WXANY_CONVERSION(T, CLASSNAME, FUNC) \
+static wxAnyToVariantRegistrationImpl<T> \
+    gs_##CLASSNAME##AnyToVariantRegistration = \
+    wxAnyToVariantRegistrationImpl<T>(&FUNC);
+
+#define REGISTER_WXANY_CONVERSION(T, CLASSNAME) \
+_REGISTER_WXANY_CONVERSION(T, CLASSNAME, CLASSNAME::VariantDataFactory)
+
+#define IMPLEMENT_TRIVIAL_WXANY_CONVERSION(T, CLASSNAME) \
+bool CLASSNAME::GetAsAny(wxAny* any) const \
+{ \
+    *any = m_value; \
+    return true; \
+} \
+wxVariantData* CLASSNAME::VariantDataFactory(const wxAny& any) \
+{ \
+    return new CLASSNAME(wxANY_AS(any, T)); \
+} \
+REGISTER_WXANY_CONVERSION(T, CLASSNAME)
+
+#else // if !wxUSE_ANY
+
+#define DECLARE_WXANY_CONVERSION()
+#define REGISTER_WXANY_CONVERSION(T, CLASSNAME)
+#define IMPLEMENT_TRIVIAL_WXANY_CONVERSION(T, CLASSNAME)
+
+#endif // wxUSE_ANY/!wxUSE_ANY
+
+
 #define DECLARE_VARIANT_OBJECT(classname) \
     DECLARE_VARIANT_OBJECT_EXPORTED(classname, wxEMPTY_PARAMETER_VALUE)
 
@@ -367,6 +496,7 @@ public:\
 \
     virtual wxVariantData* Clone() const { return new classname##VariantData(m_value); } \
 \
+    DECLARE_WXANY_CONVERSION() \
 protected:\
     classname m_value; \
 };\
@@ -395,7 +525,8 @@ expdecl wxVariant& operator << ( wxVariant &variant, const classname &value )\
     classname##VariantData *data = new classname##VariantData( value );\
     variant.SetData( data );\
     return variant;\
-}
+} \
+IMPLEMENT_TRIVIAL_WXANY_CONVERSION(classname, classname##VariantData)
 
 // implements a wxVariantData-derived class using for the Eq() method the
 // operator== which must have been provided by "classname"
@@ -438,7 +569,11 @@ bool classname##VariantData::Eq(wxVariantData& data) const \
                   var.GetWxObjectPtr() : NULL));
 
 // Replacement for using wxDynamicCast on a wxVariantData object
-#define wxDynamicCastVariantData(data, classname) dynamic_cast<classname*>(data)
+#ifndef wxNO_RTTI
+    #define wxDynamicCastVariantData(data, classname) dynamic_cast<classname*>(data)
+#endif
+
+#define wxStaticCastVariantData(data, classname) static_cast<classname*>(data)
 
 extern wxVariant WXDLLIMPEXP_BASE wxNullVariant;