X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/47bc1060127d86222768789575295254a710f5a6..6c56b261b7a0159516b46c57be8a85a281eaefd8:/src/common/variant.cpp

diff --git a/src/common/variant.cpp b/src/common/variant.cpp
index 02fa477273..ad725d2e13 100644
--- a/src/common/variant.cpp
+++ b/src/common/variant.cpp
@@ -6,7 +6,7 @@
 // Created:     10/09/98
 // RCS-ID:      $Id$
 // Copyright:   (c)
-// Licence:   	wxWindows licence
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__
@@ -17,16 +17,13 @@
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-#pragma hdrstop
+    #pragma hdrstop
 #endif
 
 #if wxUSE_IOSTREAMH
 #   include <fstream.h>
 #else
 #   include <fstream>
-#   ifdef _MSC_VER
-        using namespace std;
-#   endif
 #endif
 
 #include "wx/stream.h"
@@ -35,7 +32,7 @@
 
 IMPLEMENT_ABSTRACT_CLASS(wxVariantData, wxObject)
 
-wxVariant wxNullVariant;
+wxVariant WXDLLEXPORT wxNullVariant;
 
 /*
  * wxVariantDataList
@@ -142,7 +139,7 @@ bool wxVariantDataList::Write(ostream& str) const
 {
     wxString s;
     Write(s);
-    str << s;
+    str << (const char*) s;
     return TRUE;
 }
 
@@ -243,7 +240,7 @@ bool wxVariantDataStringList::Write(ostream& str) const
 {
     wxString s;
     Write(s);
-    str << s;
+    str << (const char*) s;
     return TRUE;
 }
 
@@ -293,12 +290,17 @@ public:
 
     virtual void Copy(wxVariantData& data);
     virtual bool Eq(wxVariantData& data) const;
-    virtual bool Write(ostream& str) const;
+
+    virtual bool Read(wxString& str);
     virtual bool Write(wxString& str) const;
-    virtual bool Write(wxOutputStream &str) const;
     virtual bool Read(istream& str);
+    virtual bool Write(ostream& str) const;
+
+#if wxUSE_STREAMS
     virtual bool Read(wxInputStream& str);
-    virtual bool Read(wxString& str);
+    virtual bool Write(wxOutputStream &str) const;
+#endif // wxUSE_STREAMS
+
     virtual wxString GetType() const { return "long"; };
 
 protected:
@@ -329,13 +331,7 @@ bool wxVariantDataLong::Write(ostream& str) const
 {
     wxString s;
     Write(s);
-    str << s;
-    return TRUE;
-}
-
-bool wxVariantDataLong::Write(wxOutputStream& str) const
-{
-    str << m_value;
+    str << (const char*) s;
     return TRUE;
 }
 
@@ -351,11 +347,19 @@ bool wxVariantDataLong::Read(istream& str)
     return TRUE;
 }
 
+#if wxUSE_STREAMS
+bool wxVariantDataLong::Write(wxOutputStream& str) const
+{
+    str << m_value;
+    return TRUE;
+}
+
 bool wxVariantDataLong::Read(wxInputStream& str)
 {
    str >> m_value;
    return TRUE;
 }
+#endif // wxUSE_STREAMS
 
 bool wxVariantDataLong::Read(wxString& str)
 {
@@ -379,12 +383,14 @@ public:
 
     virtual void Copy(wxVariantData& data);
     virtual bool Eq(wxVariantData& data) const;
+    virtual bool Read(wxString& str);
     virtual bool Write(ostream& str) const;
     virtual bool Write(wxString& str) const;
-    virtual bool Write(wxOutputStream &str) const;
     virtual bool Read(istream& str);
+#if wxUSE_STREAMS
     virtual bool Read(wxInputStream& str);
-    virtual bool Read(wxString& str);
+    virtual bool Write(wxOutputStream &str) const;
+#endif // wxUSE_STREAMS
     virtual wxString GetType() const { return "double"; };
 
 protected:
@@ -415,13 +421,7 @@ bool wxVariantDataReal::Write(ostream& str) const
 {
     wxString s;
     Write(s);
-    str << s;
-    return TRUE;
-}
-
-bool wxVariantDataReal::Write(wxOutputStream& str) const
-{
-    str << m_value;
+    str << (const char*) s;
     return TRUE;
 }
 
@@ -437,11 +437,19 @@ bool wxVariantDataReal::Read(istream& str)
     return TRUE;
 }
 
+#if wxUSE_STREAMS
+bool wxVariantDataReal::Write(wxOutputStream& str) const
+{
+    str << m_value;
+    return TRUE;
+}
+
 bool wxVariantDataReal::Read(wxInputStream& str)
 {
     str >> (float&)m_value;
     return TRUE;
 }
+#endif // wxUSE_STREAMS
 
 bool wxVariantDataReal::Read(wxString& str)
 {
@@ -466,11 +474,13 @@ public:
     virtual void Copy(wxVariantData& data);
     virtual bool Eq(wxVariantData& data) const;
     virtual bool Write(ostream& str) const;
-    virtual bool Write(wxOutputStream& str) const;
     virtual bool Write(wxString& str) const;
+    virtual bool Read(wxString& str);
     virtual bool Read(istream& str);
+#if wxUSE_STREAMS
     virtual bool Read(wxInputStream& str);
-    virtual bool Read(wxString& str);
+    virtual bool Write(wxOutputStream& str) const;
+#endif // wxUSE_STREAMS
     virtual wxString GetType() const { return "bool"; };
 
 protected:
@@ -501,13 +511,7 @@ bool wxVariantDataBool::Write(ostream& str) const
 {
     wxString s;
     Write(s);
-    str << s;
-    return TRUE;
-}
-
-bool wxVariantDataBool::Write(wxOutputStream& str) const
-{
-    str << (char)m_value;
+    str << (const char*) s;
     return TRUE;
 }
 
@@ -524,11 +528,19 @@ bool wxVariantDataBool::Read(istream& WXUNUSED(str))
     return FALSE;
 }
 
+#if wxUSE_STREAMS
+bool wxVariantDataBool::Write(wxOutputStream& str) const
+{
+    str << (char)m_value;
+    return TRUE;
+}
+
 bool wxVariantDataBool::Read(wxInputStream& str)
 {
     str >> (char&)m_value;
     return TRUE;
 }
+#endif // wxUSE_STREAMS
 
 bool wxVariantDataBool::Read(wxString& str)
 {
@@ -552,12 +564,14 @@ public:
 
     virtual void Copy(wxVariantData& data);
     virtual bool Eq(wxVariantData& data) const;
+    virtual bool Read(istream& str);
     virtual bool Write(ostream& str) const;
-    virtual bool Write(wxOutputStream& str) const;
+    virtual bool Read(wxString& str);
     virtual bool Write(wxString& str) const;
-    virtual bool Read(istream& str);
+#if wxUSE_STREAMS
     virtual bool Read(wxInputStream& str);
-    virtual bool Read(wxString& str);
+    virtual bool Write(wxOutputStream& str) const;
+#endif // wxUSE_STREAMS
     virtual wxString GetType() const { return "char"; };
 
 protected:
@@ -588,13 +602,7 @@ bool wxVariantDataChar::Write(ostream& str) const
 {
     wxString s;
     Write(s);
-    str << s;
-    return TRUE;
-}
-
-bool wxVariantDataChar::Write(wxOutputStream& str) const
-{
-    str << m_value;
+    str << (const char*) s;
     return TRUE;
 }
 
@@ -611,11 +619,19 @@ bool wxVariantDataChar::Read(istream& WXUNUSED(str))
     return FALSE;
 }
 
+#if wxUSE_STREAMS
+bool wxVariantDataChar::Write(wxOutputStream& str) const
+{
+    str << m_value;
+    return TRUE;
+}
+
 bool wxVariantDataChar::Read(wxInputStream& str)
 {
     str >> m_value;
     return TRUE;
 }
+#endif // wxUSE_STREAMS
 
 bool wxVariantDataChar::Read(wxString& str)
 {
@@ -627,9 +643,18 @@ bool wxVariantDataChar::Read(wxString& str)
  * wxVariantDataString
  */
 
+#if defined(__BORLANDC__) && defined(__WIN16__)
+// Change name because of truncation
+#define wxVariantDataString wxVariantStringData
+#endif
+
 class WXDLLEXPORT wxVariantDataString: public wxVariantData
 {
+#if defined(__BORLANDC__) && defined(__WIN16__)
+DECLARE_DYNAMIC_CLASS(wxVariantStringData)
+#else
 DECLARE_DYNAMIC_CLASS(wxVariantDataString)
+#endif
 public:
     wxVariantDataString() { }
     wxVariantDataString(const wxString& value) { m_value = value; }
@@ -640,11 +665,13 @@ public:
     virtual void Copy(wxVariantData& data);
     virtual bool Eq(wxVariantData& data) const;
     virtual bool Write(ostream& str) const;
-    virtual bool Write(wxOutputStream& str) const;
+    virtual bool Read(wxString& str);
     virtual bool Write(wxString& str) const;
     virtual bool Read(istream& str);
+#if wxUSE_STREAMS
     virtual bool Read(wxInputStream& str);
-    virtual bool Read(wxString& str);
+    virtual bool Write(wxOutputStream& str) const;
+#endif // wxUSE_STREAMS
     virtual wxString GetType() const { return "string"; };
 
 protected:
@@ -670,12 +697,6 @@ bool wxVariantDataString::Eq(wxVariantData& data) const
 }
 
 bool wxVariantDataString::Write(ostream& str) const
-{
-    str << m_value;
-    return TRUE;
-}
-
-bool wxVariantDataString::Write(wxOutputStream& str) const
 {
     str << (const char*) m_value;
     return TRUE;
@@ -693,11 +714,19 @@ bool wxVariantDataString::Read(istream& str)
     return TRUE;
 }
 
+#if wxUSE_STREAMS
+bool wxVariantDataString::Write(wxOutputStream& str) const
+{
+    str << (const char*) m_value;
+    return TRUE;
+}
+
 bool wxVariantDataString::Read(wxInputStream& str)
 {
     str >> m_value;
     return TRUE;
 }
+#endif // wxUSE_STREAMS
 
 bool wxVariantDataString::Read(wxString& str)
 {
@@ -705,7 +734,238 @@ bool wxVariantDataString::Read(wxString& str)
     return TRUE;
 }
 
+#if defined(__BORLANDC__) && defined(__WIN16__)
+IMPLEMENT_DYNAMIC_CLASS(wxVariantStringData, wxVariantData)
+#else
 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataString, wxVariantData)
+#endif
+
+/*
+ * wxVariantDataTime
+ */
+
+#if wxUSE_TIMEDATE
+
+class wxVariantDataTime: public wxVariantData
+{
+ DECLARE_DYNAMIC_CLASS(wxVariantDataTime)
+public:
+    wxVariantDataTime() { }
+    wxVariantDataTime(const wxTime& value) { m_value = value; }
+
+    inline wxTime GetValue() const { return m_value; }
+    inline void SetValue(const wxTime& value) { m_value = value; }
+
+    virtual void Copy(wxVariantData& data);
+    virtual bool Eq(wxVariantData& data) const;
+    virtual bool Write(ostream& str) const;
+    virtual bool Write(wxString& str) const;
+    virtual bool Read(istream& str);
+    virtual bool Read(wxString& str);
+    virtual wxString GetType() const { return "time"; };
+	virtual wxVariantData* Clone() { return new wxVariantDataTime; }
+
+protected:
+    wxTime m_value;
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxVariantDataTime, wxVariantData)
+
+void wxVariantDataTime::Copy(wxVariantData& data)
+{
+    wxASSERT_MSG( (data.GetType() == "time"), "wxVariantDataTime::Copy: Can't copy to this type of data" );
+
+    wxVariantDataTime& otherData = (wxVariantDataTime&) data;
+
+    otherData.m_value = m_value;
+}
+
+bool wxVariantDataTime::Eq(wxVariantData& data) const
+{
+    wxASSERT_MSG( (data.GetType() == "time"), "wxVariantDataTime::Eq: argument mismatch" );
+
+    wxVariantDataTime& otherData = (wxVariantDataTime&) data;
+
+    return (otherData.m_value == m_value);
+}
+
+bool wxVariantDataTime::Write(ostream& str) const
+{
+    wxString s;
+    Write(s);
+    str << (const char*) s;
+    return TRUE;
+}
+
+bool wxVariantDataTime::Write(wxString& str) const
+{
+    char*s = m_value.FormatTime();
+    str = s;
+    return TRUE;
+}
+
+bool wxVariantDataTime::Read(istream& WXUNUSED(str))
+{
+    // Not implemented
+    return FALSE;
+}
+
+bool wxVariantDataTime::Read(wxString& WXUNUSED(str))
+{
+    // Not implemented
+    return FALSE;
+}
+
+/*
+ * wxVariantDataDate
+ */
+
+class wxVariantDataDate: public wxVariantData
+{
+ DECLARE_DYNAMIC_CLASS(wxVariantDataDate)
+public:
+    wxVariantDataDate() { }
+    wxVariantDataDate(const wxDate& value) { m_value = value; }
+
+    inline wxDate GetValue() const { return m_value; }
+    inline void SetValue(const wxDate& value) { m_value = value; }
+
+    virtual void Copy(wxVariantData& data);
+    virtual bool Eq(wxVariantData& data) const;
+    virtual bool Write(ostream& str) const;
+    virtual bool Write(wxString& str) const;
+    virtual bool Read(istream& str);
+    virtual bool Read(wxString& str);
+    virtual wxString GetType() const { return "date"; };
+	virtual wxVariantData* Clone() { return new wxVariantDataDate; }
+
+protected:
+    wxDate m_value;
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxVariantDataDate, wxVariantData)
+
+void wxVariantDataDate::Copy(wxVariantData& data)
+{
+    wxASSERT_MSG( (data.GetType() == "date"), "wxVariantDataDate::Copy: Can't copy to this type of data" );
+
+    wxVariantDataDate& otherData = (wxVariantDataDate&) data;
+
+    otherData.m_value = m_value;
+}
+
+bool wxVariantDataDate::Eq(wxVariantData& data) const
+{
+    wxASSERT_MSG( (data.GetType() == "date"), "wxVariantDataDate::Eq: argument mismatch" );
+
+    wxVariantDataDate& otherData = (wxVariantDataDate&) data;
+
+    return (otherData.m_value == m_value);
+}
+
+bool wxVariantDataDate::Write(ostream& str) const
+{
+    wxString s;
+    Write(s);
+    str << (const char*) s;
+    return TRUE;
+}
+
+bool wxVariantDataDate::Write(wxString& str) const
+{
+    str = m_value.FormatDate();
+    return TRUE;
+}
+
+bool wxVariantDataDate::Read(istream& WXUNUSED(str))
+{
+    // Not implemented
+    return FALSE;
+}
+
+bool wxVariantDataDate::Read(wxString& WXUNUSED(str))
+{
+    // Not implemented
+    return FALSE;
+}
+#endif
+  // wxUSE_TIMEDATE
+
+/*
+ * wxVariantDataVoidPtr
+ */
+
+class wxVariantDataVoidPtr: public wxVariantData
+{
+DECLARE_DYNAMIC_CLASS(wxVariantDataVoidPtr)
+public:
+    wxVariantDataVoidPtr() { }
+    wxVariantDataVoidPtr(void* value) { m_value = value; }
+
+    inline void* GetValue() const { return m_value; }
+    inline void SetValue(void* value) { m_value = value; }
+
+    virtual void Copy(wxVariantData& data);
+    virtual bool Eq(wxVariantData& data) const;
+    virtual bool Write(ostream& str) const;
+    virtual bool Write(wxString& str) const;
+    virtual bool Read(istream& str);
+    virtual bool Read(wxString& str);
+    virtual wxString GetType() const { return "void*"; };
+	virtual wxVariantData* Clone() { return new wxVariantDataVoidPtr; }
+
+protected:
+    void* m_value;
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxVariantDataVoidPtr, wxVariantData)
+
+void wxVariantDataVoidPtr::Copy(wxVariantData& data)
+{
+    wxASSERT_MSG( (data.GetType() == "void*"), "wxVariantDataVoidPtr::Copy: Can't copy to this type of data" );
+
+    wxVariantDataVoidPtr& otherData = (wxVariantDataVoidPtr&) data;
+
+    otherData.m_value = m_value;
+}
+
+bool wxVariantDataVoidPtr::Eq(wxVariantData& data) const
+{
+    wxASSERT_MSG( (data.GetType() == "void*"), "wxVariantDataVoidPtr::Eq: argument mismatch" );
+
+    wxVariantDataVoidPtr& otherData = (wxVariantDataVoidPtr&) data;
+
+    return (otherData.m_value == m_value);
+}
+
+bool wxVariantDataVoidPtr::Write(ostream& str) const
+{
+    wxString s;
+    Write(s);
+    str << (const char*) s;
+    return TRUE;
+}
+
+bool wxVariantDataVoidPtr::Write(wxString& str) const
+{
+    char buf[80];
+    sprintf(buf, "%ld", (long) m_value);
+    str = buf;
+    return TRUE;
+}
+
+bool wxVariantDataVoidPtr::Read(istream& WXUNUSED(str))
+{
+    // Not implemented
+    return FALSE;
+}
+
+bool wxVariantDataVoidPtr::Read(wxString& WXUNUSED(str))
+{
+    // Not implemented
+    return FALSE;
+}
+
 
 /*
  * wxVariant
@@ -719,46 +979,72 @@ wxVariant::wxVariant()
     m_data = (wxVariantData*) NULL;
 }
 
-wxVariant::wxVariant(double val)
+wxVariant::wxVariant(double val, const wxString& name)
 {
     m_data = new wxVariantDataReal(val);
+    m_name = name;
 }
 
-wxVariant::wxVariant(long val)
+wxVariant::wxVariant(long val, const wxString& name)
 {
     m_data = new wxVariantDataLong(val);
+    m_name = name;
 }
 
-wxVariant::wxVariant(bool val)
+wxVariant::wxVariant(bool val, const wxString& name)
 {
     m_data = new wxVariantDataBool(val);
+    m_name = name;
 }
 
-wxVariant::wxVariant(char val)
+wxVariant::wxVariant(char val, const wxString& name)
 {
     m_data = new wxVariantDataChar(val);
+    m_name = name;
 }
 
-wxVariant::wxVariant(const wxString& val)
+wxVariant::wxVariant(const wxString& val, const wxString& name)
 {
     m_data = new wxVariantDataString(val);
+    m_name = name;
 }
 
-wxVariant::wxVariant(const char* val)
+wxVariant::wxVariant(const char* val, const wxString& name)
 {
     m_data = new wxVariantDataString(wxString(val));
+    m_name = name;
 }
 
-/* Causes ambiguity
-wxVariant::wxVariant(const wxStringList& val)
+wxVariant::wxVariant(const wxStringList& val, const wxString& name)
 {
     m_data = new wxVariantDataStringList(val);
+    m_name = name;
 }
-*/
 
-wxVariant::wxVariant(const wxList& val) // List of variants
+wxVariant::wxVariant(const wxList& val, const wxString& name) // List of variants
 {
     m_data = new wxVariantDataList(val);
+    m_name = name;
+}
+
+#if wxUSE_TIMEDATE
+wxVariant::wxVariant(const wxTime& val, const wxString& name) // Time
+{
+    m_data = new wxVariantDataTime(val);
+    m_name = name;
+}
+
+wxVariant::wxVariant(const wxDate& val, const wxString& name) // Date
+{
+    m_data = new wxVariantDataDate(val);
+    m_name = name;
+}
+#endif
+
+wxVariant::wxVariant(void* val, const wxString& name) // Void ptr
+{
+    m_data = new wxVariantDataVoidPtr(val);
+    m_name = name;
 }
 
 wxVariant::wxVariant(const wxVariant& variant)
@@ -768,11 +1054,15 @@ wxVariant::wxVariant(const wxVariant& variant)
         m_data = (wxVariantData*) variant.GetData()->GetClassInfo()->CreateObject();
         variant.m_data->Copy(*m_data);
     }
+    else
+        m_data = (wxVariantData*) NULL;
+    m_name = variant.m_name;
 }
 
-wxVariant::wxVariant(wxVariantData* data) // User-defined data
+wxVariant::wxVariant(wxVariantData* data, const wxString& name) // User-defined data
 {
     m_data = data;
+    m_name = name;
 }
 
 wxVariant::~wxVariant()
@@ -804,7 +1094,8 @@ void wxVariant::operator= (const wxVariant& variant)
             delete m_data;
         m_data = (wxVariantData*) variant.GetData()->GetClassInfo()->CreateObject();
     }
-    GetData()->Copy(* variant.GetData());
+//    GetData()->Copy(* variant.GetData());
+    variant.GetData()->Copy(* GetData());
 }
 
 // Assignment using data, e.g.
@@ -1038,6 +1329,87 @@ void wxVariant::operator= (const wxList& value)
     }
 }
 
+#if wxUSE_TIMEDATE
+bool wxVariant::operator== (const wxTime& value) const
+{
+    wxTime thisValue;
+    if (!Convert(&thisValue))
+        return FALSE;
+    else
+        return (value == thisValue);
+}
+
+bool wxVariant::operator!= (const wxTime& value) const
+{
+    return (!((*this) == value));
+}
+
+void wxVariant::operator= (const wxTime& value)
+{
+    if (GetType() == "time")
+    {
+        ((wxVariantDataTime*)GetData())->SetValue(value);
+    }
+    else
+    {
+        if (m_data)
+            delete m_data;
+        m_data = new wxVariantDataTime(value);
+    }
+}
+
+bool wxVariant::operator== (const wxDate& value) const
+{
+    wxDate thisValue;
+    if (!Convert(&thisValue))
+        return FALSE;
+    else
+        return (value == thisValue);
+}
+
+bool wxVariant::operator!= (const wxDate& value) const
+{
+    return (!((*this) == value));
+}
+
+void wxVariant::operator= (const wxDate& value)
+{
+    if (GetType() == "date")
+    {
+        ((wxVariantDataTime*)GetData())->SetValue(value);
+    }
+    else
+    {
+        if (m_data)
+            delete m_data;
+        m_data = new wxVariantDataDate(value);
+    }
+}
+#endif
+
+bool wxVariant::operator== (void* value) const
+{
+    return (value == ((wxVariantDataVoidPtr*)GetData())->GetValue());
+}
+
+bool wxVariant::operator!= (void* value) const
+{
+    return (!((*this) == value));
+}
+
+void wxVariant::operator= (void* value)
+{
+    if (GetType() == "void*")
+    {
+        ((wxVariantDataVoidPtr*)GetData())->SetValue(value);
+    }
+    else
+    {
+        if (m_data)
+            delete m_data;
+        m_data = new wxVariantDataVoidPtr(value);
+    }
+}
 
 // Treat a list variant as an array
 wxVariant wxVariant::operator[] (size_t idx) const
@@ -1190,6 +1562,39 @@ wxString wxVariant::GetString() const
     }
 }
 
+#if wxUSE_TIMEDATE
+wxTime wxVariant::GetTime() const
+{
+    wxTime value;
+    if (Convert(& value))
+        return value;
+    else
+    {
+        wxFAIL_MSG("Could not convert to a time");
+        return wxTime();
+    }
+}
+
+wxDate wxVariant::GetDate() const
+{
+    wxDate value;
+    if (Convert(& value))
+        return value;
+    else
+    {
+        wxFAIL_MSG("Could not convert to a date");
+        return wxDate();
+    }
+}
+#endif
+
+void* wxVariant::GetVoidPtr() const
+{
+    wxASSERT( (GetType() == "void*") );
+
+    return (void*) ((wxVariantDataVoidPtr*) m_data)->GetValue();
+}
+
 wxList& wxVariant::GetList() const
 {
     wxASSERT( (GetType() == "list") );
@@ -1349,3 +1754,29 @@ bool wxVariant::Convert(wxString* value) const
     return TRUE;
 }
 
+#if wxUSE_TIMEDATE
+bool wxVariant::Convert(wxTime* value) const
+{
+    wxString type(GetType());
+    if (type == "time")
+        *value = ((wxVariantDataTime*)GetData())->GetValue();
+    else if (type == "date")
+        *value = wxTime(((wxVariantDataDate*)GetData())->GetValue());
+    else
+        return FALSE;
+
+    return TRUE;
+}
+
+bool wxVariant::Convert(wxDate* value) const
+{
+    wxString type(GetType());
+    if (type == "date")
+        *value = ((wxVariantDataDate*)GetData())->GetValue();
+    else
+        return FALSE;
+
+    return TRUE;
+}
+#endif
+ // wxUSE_TIMEDATE