X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/92ffc98a0816dc6d046edb70d7fb063912391eb7..81533a3af6ed598c32a35e1c1c2b60f4908f5541:/src/common/variant.cpp?ds=sidebyside

diff --git a/src/common/variant.cpp b/src/common/variant.cpp
index bed7a03f60..b1c8838981 100644
--- a/src/common/variant.cpp
+++ b/src/common/variant.cpp
@@ -62,13 +62,13 @@ WX_DEFINE_LIST(wxVariantList)
 IMPLEMENT_DYNAMIC_CLASS(wxVariant, wxObject)
 
 wxVariant::wxVariant()
+    : wxObject()
 {
-    m_data = NULL;
 }
 
 bool wxVariant::IsNull() const
 {
-     return (m_data == NULL);
+     return (m_refData == NULL);
 }
 
 void wxVariant::MakeNull()
@@ -84,8 +84,6 @@ void wxVariant::Clear()
 wxVariant::wxVariant(const wxVariant& variant)
     : wxObject()
 {
-    m_data = NULL;
-
     if (!variant.IsNull())
         Ref(variant);
 
@@ -93,14 +91,26 @@ wxVariant::wxVariant(const wxVariant& variant)
 }
 
 wxVariant::wxVariant(wxVariantData* data, const wxString& name) // User-defined data
+    : wxObject()
 {
-    m_data = data;
+    m_refData = data;
     m_name = name;
 }
 
 wxVariant::~wxVariant()
 {
-    UnRef();
+}
+
+wxObjectRefData *wxVariant::CreateRefData() const
+{
+    // We cannot create any particular wxVariantData.
+    wxFAIL_MSG("wxVariant::CreateRefData() cannot be implemented");
+    return NULL;
+}
+
+wxObjectRefData *wxVariant::CloneRefData(const wxObjectRefData *data) const
+{
+    return ((wxVariantData*) data)->Clone();
 }
 
 // Assignment
@@ -114,7 +124,7 @@ void wxVariant::operator= (const wxVariant& variant)
 void wxVariant::operator= (wxVariantData* variantData)
 {
     UnRef();
-    m_data = variantData;
+    m_refData = variantData;
 }
 
 bool wxVariant::operator== (const wxVariant& variant) const
@@ -147,60 +157,17 @@ wxString wxVariant::MakeString() const
 void wxVariant::SetData(wxVariantData* data)
 {
     UnRef();
-    m_data = data;
-}
-
-void wxVariant::Ref(const wxVariant& clone)
-{
-    // nothing to be done
-    if (m_data == clone.m_data)
-        return;
-
-    // delete reference to old data
-    UnRef();
-
-    // reference new data
-    if ( clone.m_data )
-    {
-        m_data = clone.m_data;
-        m_data->IncRef();
-    }
-}
-
-
-void wxVariant::UnRef()
-{
-    if ( m_data )
-    {
-        wxASSERT_MSG( m_data->GetRefCount() > 0, _T("invalid ref data count") );
-
-        m_data->DecRef();
-        m_data = NULL;
-    }
+    m_refData = data;
 }
 
 bool wxVariant::Unshare()
 {
-    if ( m_data && m_data->GetRefCount() > 1 )
-    {
-        // note that ref is not going to be destroyed in this case...
-        const wxVariantData* ref = m_data;
-        UnRef();
-
-        // ... so we can still access it
-        m_data = ref->Clone();
+    if ( !m_refData || m_refData->GetRefCount() == 1 )
+        return true;
 
-        wxASSERT_MSG( (m_data && m_data->GetRefCount() == 1),
-                  _T("wxVariant::AllocExclusive() failed.") );
+    wxObject::UnShare();
 
-        if (!m_data || m_data->GetRefCount() != 1)
-            return false;
-        else
-            return true;
-    }
-    //else: data is null or ref count is 1, so we are exclusive owners of m_refData anyhow
-    else
-        return true;
+    return (m_refData && m_refData->GetRefCount() == 1);
 }
 
 
@@ -321,19 +288,19 @@ bool wxVariantDataLong::Read(wxString& str)
 
 wxVariant::wxVariant(long val, const wxString& name)
 {
-    m_data = new wxVariantDataLong(val);
+    m_refData = new wxVariantDataLong(val);
     m_name = name;
 }
 
 wxVariant::wxVariant(int val, const wxString& name)
 {
-    m_data = new wxVariantDataLong((long)val);
+    m_refData = new wxVariantDataLong((long)val);
     m_name = name;
 }
 
 wxVariant::wxVariant(short val, const wxString& name)
 {
-    m_data = new wxVariantDataLong((long)val);
+    m_refData = new wxVariantDataLong((long)val);
     m_name = name;
 }
 
@@ -354,14 +321,14 @@ bool wxVariant::operator!= (long value) const
 void wxVariant::operator= (long value)
 {
     if (GetType() == wxT("long") &&
-        m_data->GetRefCount() == 1)
+        m_refData->GetRefCount() == 1)
     {
         ((wxVariantDataLong*)GetData())->SetValue(value);
     }
     else
     {
         UnRef();
-        m_data = new wxVariantDataLong(value);
+        m_refData = new wxVariantDataLong(value);
     }
 }
 
@@ -469,7 +436,7 @@ bool wxVariantDoubleData::Read(wxString& str)
 
 wxVariant::wxVariant(double val, const wxString& name)
 {
-    m_data = new wxVariantDoubleData(val);
+    m_refData = new wxVariantDoubleData(val);
     m_name = name;
 }
 
@@ -490,14 +457,14 @@ bool wxVariant::operator!= (double value) const
 void wxVariant::operator= (double value)
 {
     if (GetType() == wxT("double") &&
-        m_data->GetRefCount() == 1)
+        m_refData->GetRefCount() == 1)
     {
         ((wxVariantDoubleData*)GetData())->SetValue(value);
     }
     else
     {
         UnRef();
-        m_data = new wxVariantDoubleData(value);
+        m_refData = new wxVariantDoubleData(value);
     }
 }
 
@@ -608,7 +575,7 @@ bool wxVariantDataBool::Read(wxString& str)
 
 wxVariant::wxVariant(bool val, const wxString& name)
 {
-    m_data = new wxVariantDataBool(val);
+    m_refData = new wxVariantDataBool(val);
     m_name = name;
 }
 
@@ -629,14 +596,14 @@ bool wxVariant::operator!= (bool value) const
 void wxVariant::operator= (bool value)
 {
     if (GetType() == wxT("bool") &&
-        m_data->GetRefCount() == 1)
+        m_refData->GetRefCount() == 1)
     {
         ((wxVariantDataBool*)GetData())->SetValue(value);
     }
     else
     {
         UnRef();
-        m_data = new wxVariantDataBool(value);
+        m_refData = new wxVariantDataBool(value);
     }
 }
 
@@ -749,19 +716,19 @@ bool wxVariantDataChar::Read(wxString& str)
 
 wxVariant::wxVariant(const wxUniChar& val, const wxString& name)
 {
-    m_data = new wxVariantDataChar(val);
+    m_refData = new wxVariantDataChar(val);
     m_name = name;
 }
 
 wxVariant::wxVariant(char val, const wxString& name)
 {
-    m_data = new wxVariantDataChar(val);
+    m_refData = new wxVariantDataChar(val);
     m_name = name;
 }
 
 wxVariant::wxVariant(wchar_t val, const wxString& name)
 {
-    m_data = new wxVariantDataChar(val);
+    m_refData = new wxVariantDataChar(val);
     m_name = name;
 }
 
@@ -777,14 +744,14 @@ bool wxVariant::operator==(const wxUniChar& value) const
 wxVariant& wxVariant::operator=(const wxUniChar& value)
 {
     if (GetType() == wxT("char") &&
-        m_data->GetRefCount() == 1)
+        m_refData->GetRefCount() == 1)
     {
         ((wxVariantDataChar*)GetData())->SetValue(value);
     }
     else
     {
         UnRef();
-        m_data = new wxVariantDataChar(value);
+        m_refData = new wxVariantDataChar(value);
     }
 
     return *this;
@@ -886,37 +853,37 @@ bool wxVariantDataString::Read(wxString& str)
 
 wxVariant::wxVariant(const wxString& val, const wxString& name)
 {
-    m_data = new wxVariantDataString(val);
+    m_refData = new wxVariantDataString(val);
     m_name = name;
 }
 
 wxVariant::wxVariant(const char* val, const wxString& name)
 {
-    m_data = new wxVariantDataString(wxString(val));
+    m_refData = new wxVariantDataString(wxString(val));
     m_name = name;
 }
 
 wxVariant::wxVariant(const wchar_t* val, const wxString& name)
 {
-    m_data = new wxVariantDataString(wxString(val));
+    m_refData = new wxVariantDataString(wxString(val));
     m_name = name;
 }
 
 wxVariant::wxVariant(const wxCStrData& val, const wxString& name)
 {
-    m_data = new wxVariantDataString(val.AsString());
+    m_refData = new wxVariantDataString(val.AsString());
     m_name = name;
 }
 
 wxVariant::wxVariant(const wxScopedCharBuffer& val, const wxString& name)
 {
-    m_data = new wxVariantDataString(wxString(val));
+    m_refData = new wxVariantDataString(wxString(val));
     m_name = name;
 }
 
 wxVariant::wxVariant(const wxScopedWCharBuffer& val, const wxString& name)
 {
-    m_data = new wxVariantDataString(wxString(val));
+    m_refData = new wxVariantDataString(wxString(val));
     m_name = name;
 }
 
@@ -937,14 +904,14 @@ bool wxVariant::operator!= (const wxString& value) const
 wxVariant& wxVariant::operator= (const wxString& value)
 {
     if (GetType() == wxT("string") &&
-        m_data->GetRefCount() == 1)
+        m_refData->GetRefCount() == 1)
     {
         ((wxVariantDataString*)GetData())->SetValue(value);
     }
     else
     {
         UnRef();
-        m_data = new wxVariantDataString(value);
+        m_refData = new wxVariantDataString(value);
     }
     return *this;
 }
@@ -1056,7 +1023,7 @@ bool wxVariantDataWxObjectPtr::Read(wxString& WXUNUSED(str))
 
 wxVariant::wxVariant( wxObject* val, const wxString& name)
 {
-    m_data = new wxVariantDataWxObjectPtr(val);
+    m_refData = new wxVariantDataWxObjectPtr(val);
     m_name = name;
 }
 
@@ -1073,12 +1040,12 @@ bool wxVariant::operator!= (wxObject* value) const
 void wxVariant::operator= (wxObject* value)
 {
     UnRef();
-    m_data = new wxVariantDataWxObjectPtr(value);
+    m_refData = new wxVariantDataWxObjectPtr(value);
 }
 
 wxObject* wxVariant::GetWxObjectPtr() const
 {
-    return (wxObject*) ((wxVariantDataWxObjectPtr*) m_data)->GetValue();
+    return (wxObject*) ((wxVariantDataWxObjectPtr*) m_refData)->GetValue();
 }
 
 // ----------------------------------------------------------------------------
@@ -1153,7 +1120,7 @@ bool wxVariantDataVoidPtr::Read(wxString& WXUNUSED(str))
 
 wxVariant::wxVariant( void* val, const wxString& name)
 {
-    m_data = new wxVariantDataVoidPtr(val);
+    m_refData = new wxVariantDataVoidPtr(val);
     m_name = name;
 }
 
@@ -1169,14 +1136,14 @@ bool wxVariant::operator!= (void* value) const
 
 void wxVariant::operator= (void* value)
 {
-    if (GetType() == wxT("void*") && (m_data->GetRefCount() == 1))
+    if (GetType() == wxT("void*") && (m_refData->GetRefCount() == 1))
     {
         ((wxVariantDataVoidPtr*)GetData())->SetValue(value);
     }
     else
     {
         UnRef();
-        m_data = new wxVariantDataVoidPtr(value);
+        m_refData = new wxVariantDataVoidPtr(value);
     }
 }
 
@@ -1188,7 +1155,7 @@ void* wxVariant::GetVoidPtr() const
 
     wxASSERT( GetType() == wxT("void*") );
 
-    return (void*) ((wxVariantDataVoidPtr*) m_data)->GetValue();
+    return (void*) ((wxVariantDataVoidPtr*) m_refData)->GetValue();
 }
 
 // ----------------------------------------------------------------------------
@@ -1279,7 +1246,7 @@ bool wxVariantDataDateTime::Read(wxString& str)
 
 wxVariant::wxVariant(const wxDateTime& val, const wxString& name) // Date
 {
-    m_data = new wxVariantDataDateTime(val);
+    m_refData = new wxVariantDataDateTime(val);
     m_name = name;
 }
 
@@ -1300,14 +1267,14 @@ bool wxVariant::operator!= (const wxDateTime& value) const
 void wxVariant::operator= (const wxDateTime& value)
 {
     if (GetType() == wxT("datetime") &&
-        m_data->GetRefCount() == 1)
+        m_refData->GetRefCount() == 1)
     {
         ((wxVariantDataDateTime*)GetData())->SetValue(value);
     }
     else
     {
         UnRef();
-        m_data = new wxVariantDataDateTime(value);
+        m_refData = new wxVariantDataDateTime(value);
     }
 }
 
@@ -1376,7 +1343,7 @@ bool wxVariantDataArrayString::Write(wxString& str) const
     for ( size_t n = 0; n < count; n++ )
     {
         if ( n )
-            str += _T(';');
+            str += wxT(';');
 
         str += m_value[n];
     }
@@ -1396,7 +1363,7 @@ bool wxVariantDataArrayString::Read(wxSTD istream& WXUNUSED(str))
 
 bool wxVariantDataArrayString::Read(wxString& str)
 {
-    wxStringTokenizer tk(str, _T(";"));
+    wxStringTokenizer tk(str, wxT(";"));
     while ( tk.HasMoreTokens() )
     {
         m_value.Add(tk.GetNextToken());
@@ -1409,13 +1376,13 @@ bool wxVariantDataArrayString::Read(wxString& str)
 
 wxVariant::wxVariant(const wxArrayString& val, const wxString& name) // Strings
 {
-    m_data = new wxVariantDataArrayString(val);
+    m_refData = new wxVariantDataArrayString(val);
     m_name = name;
 }
 
 bool wxVariant::operator==(const wxArrayString& WXUNUSED(value)) const
 {
-    wxFAIL_MSG( _T("TODO") );
+    wxFAIL_MSG( wxT("TODO") );
 
     return false;
 }
@@ -1428,14 +1395,14 @@ bool wxVariant::operator!=(const wxArrayString& value) const
 void wxVariant::operator=(const wxArrayString& value)
 {
     if (GetType() == wxT("arrstring") &&
-        m_data->GetRefCount() == 1)
+        m_refData->GetRefCount() == 1)
     {
         ((wxVariantDataArrayString *)GetData())->SetValue(value);
     }
     else
     {
         UnRef();
-        m_data = new wxVariantDataArrayString(value);
+        m_refData = new wxVariantDataArrayString(value);
     }
 }
 
@@ -1447,6 +1414,328 @@ wxArrayString wxVariant::GetArrayString() const
     return wxArrayString();
 }
 
+// ----------------------------------------------------------------------------
+// wxVariantDataLongLong
+// ----------------------------------------------------------------------------
+
+#if wxUSE_LONGLONG
+
+class WXDLLIMPEXP_BASE wxVariantDataLongLong : public wxVariantData
+{
+public:
+    wxVariantDataLongLong() { m_value = 0; }
+    wxVariantDataLongLong(wxLongLong value) { m_value = value; }
+
+    wxLongLong GetValue() const { return m_value; }
+    void SetValue(wxLongLong value) { m_value = value; }
+
+    virtual bool Eq(wxVariantData& data) const;
+
+    virtual bool Read(wxString& str);
+    virtual bool Write(wxString& str) const;
+#if wxUSE_STD_IOSTREAM
+    virtual bool Read(wxSTD istream& str);
+    virtual bool Write(wxSTD ostream& str) const;
+#endif
+#if wxUSE_STREAMS
+    virtual bool Read(wxInputStream& str);
+    virtual bool Write(wxOutputStream &str) const;
+#endif // wxUSE_STREAMS
+
+    wxVariantData* Clone() const
+    {
+        return new wxVariantDataLongLong(m_value);
+    }
+
+    virtual wxString GetType() const { return wxS("longlong"); }
+
+protected:
+    wxLongLong m_value;
+};
+
+bool wxVariantDataLongLong::Eq(wxVariantData& data) const
+{
+    wxASSERT_MSG( (data.GetType() == wxS("longlong")),
+                  "wxVariantDataLongLong::Eq: argument mismatch" );
+
+    wxVariantDataLongLong& otherData = (wxVariantDataLongLong&) data;
+
+    return (otherData.m_value == m_value);
+}
+
+#if wxUSE_STD_IOSTREAM
+bool wxVariantDataLongLong::Write(wxSTD ostream& str) const
+{
+    wxString s;
+    Write(s);
+    str << (const char*) s.mb_str();
+    return true;
+}
+#endif
+
+bool wxVariantDataLongLong::Write(wxString& str) const
+{
+#ifdef wxLongLong_t
+    str.Printf(wxS("%lld"), m_value.GetValue());
+    return true;
+#else
+    return false;
+#endif
+}
+
+#if wxUSE_STD_IOSTREAM
+bool wxVariantDataLongLong::Read(wxSTD istream& WXUNUSED(str))
+{
+    wxFAIL_MSG(wxS("Unimplemented"));
+    return false;
+}
+#endif
+
+#if wxUSE_STREAMS
+bool wxVariantDataLongLong::Write(wxOutputStream& str) const
+{
+    wxTextOutputStream s(str);
+    s.Write32(m_value.GetLo());
+    s.Write32(m_value.GetHi());
+    return true;
+}
+
+bool wxVariantDataLongLong::Read(wxInputStream& str)
+{
+   wxTextInputStream s(str);
+   unsigned long lo = s.Read32();
+   long hi = s.Read32();
+   m_value = wxLongLong(hi, lo);
+   return true;
+}
+#endif // wxUSE_STREAMS
+
+bool wxVariantDataLongLong::Read(wxString& str)
+{
+#ifdef wxLongLong_t
+    wxLongLong_t value_t;
+    if ( !str.ToLongLong(&value_t) )
+        return false;
+    m_value = value_t;
+    return true;
+#else
+    return false;
+#endif
+}
+
+// wxVariant
+
+wxVariant::wxVariant(wxLongLong val, const wxString& name)
+{
+    m_refData = new wxVariantDataLongLong(val);
+    m_name = name;
+}
+
+bool wxVariant::operator==(wxLongLong value) const
+{
+    wxLongLong thisValue;
+    if ( !Convert(&thisValue) )
+        return false;
+    else
+        return (value == thisValue);
+}
+
+bool wxVariant::operator!=(wxLongLong value) const
+{
+    return (!((*this) == value));
+}
+
+void wxVariant::operator=(wxLongLong value)
+{
+    if ( GetType() == wxS("longlong") &&
+         m_refData->GetRefCount() == 1 )
+    {
+        ((wxVariantDataLongLong*)GetData())->SetValue(value);
+    }
+    else
+    {
+        UnRef();
+        m_refData = new wxVariantDataLongLong(value);
+    }
+}
+
+wxLongLong wxVariant::GetLongLong() const
+{
+    wxLongLong value;
+    if ( Convert(&value) )
+    {
+        return value;
+    }
+    else
+    {
+        wxFAIL_MSG(wxT("Could not convert to a long long"));
+        return 0;
+    }
+}
+
+#endif // wxUSE_LONGLONG
+
+// ----------------------------------------------------------------------------
+// wxVariantDataULongLong
+// ----------------------------------------------------------------------------
+
+#if wxUSE_LONGLONG
+
+class WXDLLIMPEXP_BASE wxVariantDataULongLong : public wxVariantData
+{
+public:
+    wxVariantDataULongLong() { m_value = 0; }
+    wxVariantDataULongLong(wxULongLong value) { m_value = value; }
+
+    wxULongLong GetValue() const { return m_value; }
+    void SetValue(wxULongLong value) { m_value = value; }
+
+    virtual bool Eq(wxVariantData& data) const;
+
+    virtual bool Read(wxString& str);
+    virtual bool Write(wxString& str) const;
+#if wxUSE_STD_IOSTREAM
+    virtual bool Read(wxSTD istream& str);
+    virtual bool Write(wxSTD ostream& str) const;
+#endif
+#if wxUSE_STREAMS
+    virtual bool Read(wxInputStream& str);
+    virtual bool Write(wxOutputStream &str) const;
+#endif // wxUSE_STREAMS
+
+    wxVariantData* Clone() const
+    {
+        return new wxVariantDataULongLong(m_value);
+    }
+
+    virtual wxString GetType() const { return wxS("ulonglong"); }
+
+protected:
+    wxULongLong m_value;
+};
+
+bool wxVariantDataULongLong::Eq(wxVariantData& data) const
+{
+    wxASSERT_MSG( (data.GetType() == wxS("ulonglong")),
+                  "wxVariantDataULongLong::Eq: argument mismatch" );
+
+    wxVariantDataULongLong& otherData = (wxVariantDataULongLong&) data;
+
+    return (otherData.m_value == m_value);
+}
+
+#if wxUSE_STD_IOSTREAM
+bool wxVariantDataULongLong::Write(wxSTD ostream& str) const
+{
+    wxString s;
+    Write(s);
+    str << (const char*) s.mb_str();
+    return true;
+}
+#endif
+
+bool wxVariantDataULongLong::Write(wxString& str) const
+{
+#ifdef wxLongLong_t
+    str.Printf(wxS("%llu"), m_value.GetValue());
+    return true;
+#else
+    return false;
+#endif
+}
+
+#if wxUSE_STD_IOSTREAM
+bool wxVariantDataULongLong::Read(wxSTD istream& WXUNUSED(str))
+{
+    wxFAIL_MSG(wxS("Unimplemented"));
+    return false;
+}
+#endif
+
+#if wxUSE_STREAMS
+bool wxVariantDataULongLong::Write(wxOutputStream& str) const
+{
+    wxTextOutputStream s(str);
+    s.Write32(m_value.GetLo());
+    s.Write32(m_value.GetHi());
+    return true;
+}
+
+bool wxVariantDataULongLong::Read(wxInputStream& str)
+{
+   wxTextInputStream s(str);
+   unsigned long lo = s.Read32();
+   long hi = s.Read32();
+   m_value = wxULongLong(hi, lo);
+   return true;
+}
+#endif // wxUSE_STREAMS
+
+bool wxVariantDataULongLong::Read(wxString& str)
+{
+#ifdef wxLongLong_t
+    wxULongLong_t value_t;
+    if ( !str.ToULongLong(&value_t) )
+        return false;
+    m_value = value_t;
+    return true;
+#else
+    return false;
+#endif
+}
+
+// wxVariant
+
+wxVariant::wxVariant(wxULongLong val, const wxString& name)
+{
+    m_refData = new wxVariantDataULongLong(val);
+    m_name = name;
+}
+
+bool wxVariant::operator==(wxULongLong value) const
+{
+    wxULongLong thisValue;
+    if ( !Convert(&thisValue) )
+        return false;
+    else
+        return (value == thisValue);
+}
+
+bool wxVariant::operator!=(wxULongLong value) const
+{
+    return (!((*this) == value));
+}
+
+void wxVariant::operator=(wxULongLong value)
+{
+    if ( GetType() == wxS("ulonglong") &&
+         m_refData->GetRefCount() == 1 )
+    {
+        ((wxVariantDataULongLong*)GetData())->SetValue(value);
+    }
+    else
+    {
+        UnRef();
+        m_refData = new wxVariantDataULongLong(value);
+    }
+}
+
+wxULongLong wxVariant::GetULongLong() const
+{
+    wxULongLong value;
+    if ( Convert(&value) )
+    {
+        return value;
+    }
+    else
+    {
+        wxFAIL_MSG(wxT("Could not convert to a long long"));
+        return 0;
+    }
+}
+
+#endif // wxUSE_LONGLONG
+
 // ----------------------------------------------------------------------------
 // wxVariantDataList
 // ----------------------------------------------------------------------------
@@ -1580,7 +1869,7 @@ bool wxVariantDataList::Read(wxString& WXUNUSED(str))
 
 wxVariant::wxVariant(const wxVariantList& val, const wxString& name) // List of variants
 {
-    m_data = new wxVariantDataList(val);
+    m_refData = new wxVariantDataList(val);
     m_name = name;
 }
 
@@ -1600,14 +1889,14 @@ bool wxVariant::operator!= (const wxVariantList& value) const
 void wxVariant::operator= (const wxVariantList& value)
 {
     if (GetType() == wxT("list") &&
-        m_data->GetRefCount() == 1)
+        m_refData->GetRefCount() == 1)
     {
         ((wxVariantDataList*)GetData())->SetValue(value);
     }
     else
     {
         UnRef();
-        m_data = new wxVariantDataList(value);
+        m_refData = new wxVariantDataList(value);
     }
 }
 
@@ -1615,7 +1904,7 @@ wxVariantList& wxVariant::GetList() const
 {
     wxASSERT( (GetType() == wxT("list")) );
 
-    return (wxVariantList&) ((wxVariantDataList*) m_data)->GetValue();
+    return (wxVariantList&) ((wxVariantDataList*) m_refData)->GetValue();
 }
 
 // Make empty list
@@ -1674,14 +1963,14 @@ void wxVariant::ClearList()
 {
     if (!IsNull() && (GetType() == wxT("list")))
     {
-        ((wxVariantDataList*) m_data)->Clear();
+        ((wxVariantDataList*) m_refData)->Clear();
     }
     else
     {
         if (!GetType().IsSameAs(wxT("list")))
             UnRef();
 
-        m_data = new wxVariantDataList;
+        m_refData = new wxVariantDataList;
     }
 }
 
@@ -1692,7 +1981,7 @@ wxVariant wxVariant::operator[] (size_t idx) const
 
     if (GetType() == wxT("list"))
     {
-        wxVariantDataList* data = (wxVariantDataList*) m_data;
+        wxVariantDataList* data = (wxVariantDataList*) m_refData;
         wxASSERT_MSG( (idx < data->GetValue().GetCount()), wxT("Invalid index for array") );
         return *(data->GetValue().Item(idx)->GetData());
     }
@@ -1706,7 +1995,7 @@ wxVariant& wxVariant::operator[] (size_t idx)
 
     wxASSERT_MSG( (GetType() == wxT("list")), wxT("Invalid type for array operator") );
 
-    wxVariantDataList* data = (wxVariantDataList*) m_data;
+    wxVariantDataList* data = (wxVariantDataList*) m_refData;
     wxASSERT_MSG( (idx < data->GetValue().GetCount()), wxT("Invalid index for array") );
 
     return * (data->GetValue().Item(idx)->GetData());
@@ -1719,7 +2008,7 @@ size_t wxVariant::GetCount() const
 
     if (GetType() == wxT("list"))
     {
-        wxVariantDataList* data = (wxVariantDataList*) m_data;
+        wxVariantDataList* data = (wxVariantDataList*) m_refData;
         return data->GetValue().GetCount();
     }
     return 0;
@@ -1732,14 +2021,32 @@ size_t wxVariant::GetCount() const
 bool wxVariant::Convert(long* value) const
 {
     wxString type(GetType());
-    if (type == wxT("double"))
+    if (type == wxS("double"))
         *value = (long) (((wxVariantDoubleData*)GetData())->GetValue());
-    else if (type == wxT("long"))
+    else if (type == wxS("long"))
         *value = ((wxVariantDataLong*)GetData())->GetValue();
-    else if (type == wxT("bool"))
+    else if (type == wxS("bool"))
         *value = (long) (((wxVariantDataBool*)GetData())->GetValue());
-    else if (type == wxT("string"))
+    else if (type == wxS("string"))
         *value = wxAtol(((wxVariantDataString*)GetData())->GetValue());
+#if wxUSE_LONGLONG
+    else if (type == wxS("longlong"))
+    {
+        wxLongLong v = ((wxVariantDataLongLong*)GetData())->GetValue();
+        // Don't convert if return value would be vague
+        if ( v < LONG_MIN || v > LONG_MAX )
+            return false;
+        *value = v.ToLong();
+    }
+    else if (type == wxS("ulonglong"))
+    {
+        wxULongLong v = ((wxVariantDataULongLong*)GetData())->GetValue();
+        // Don't convert if return value would be vague
+        if ( v.GetHi() )
+            return false;
+        *value = (long) v.ToULong();
+    }
+#endif
     else
         return false;
 
@@ -1783,6 +2090,16 @@ bool wxVariant::Convert(double* value) const
         *value = (double) (((wxVariantDataBool*)GetData())->GetValue());
     else if (type == wxT("string"))
         *value = (double) wxAtof(((wxVariantDataString*)GetData())->GetValue());
+#if wxUSE_LONGLONG
+    else if (type == wxS("longlong"))
+    {
+        *value = ((wxVariantDataLongLong*)GetData())->GetValue().ToDouble();
+    }
+    else if (type == wxS("ulonglong"))
+    {
+        *value = ((wxVariantDataULongLong*)GetData())->GetValue().ToDouble();
+    }
+#endif
     else
         return false;
 
@@ -1828,6 +2145,91 @@ bool wxVariant::Convert(wxString* value) const
     return true;
 }
 
+#if wxUSE_LONGLONG
+bool wxVariant::Convert(wxLongLong* value) const
+{
+    wxString type(GetType());
+    if (type == wxS("longlong"))
+        *value = ((wxVariantDataLongLong*)GetData())->GetValue();
+    else if (type == wxS("long"))
+        *value = ((wxVariantDataLong*)GetData())->GetValue();
+    else if (type == wxS("string"))
+    {
+        wxString s = ((wxVariantDataString*)GetData())->GetValue();
+#ifdef wxLongLong_t
+        wxLongLong_t value_t;
+        if ( !s.ToLongLong(&value_t) )
+            return false;
+        *value = value_t;
+#else
+        long l_value;
+        if ( !s.ToLong(&l_value) )
+            return false;
+        *value = l_value;
+#endif
+    }
+    else if (type == wxS("bool"))
+        *value = (long) (((wxVariantDataBool*)GetData())->GetValue());
+    else if (type == wxS("double"))
+    {
+        value->Assign(((wxVariantDoubleData*)GetData())->GetValue());
+    }
+    else if (type == wxS("ulonglong"))
+        *value = ((wxVariantDataULongLong*)GetData())->GetValue();
+    else
+        return false;
+
+    return true;
+}
+
+bool wxVariant::Convert(wxULongLong* value) const
+{
+    wxString type(GetType());
+    if (type == wxS("ulonglong"))
+        *value = ((wxVariantDataULongLong*)GetData())->GetValue();
+    else if (type == wxS("long"))
+        *value = ((wxVariantDataLong*)GetData())->GetValue();
+    else if (type == wxS("string"))
+    {
+        wxString s = ((wxVariantDataString*)GetData())->GetValue();
+#ifdef wxLongLong_t
+        wxULongLong_t value_t;
+        if ( !s.ToULongLong(&value_t) )
+            return false;
+        *value = value_t;
+#else
+        unsigned long l_value;
+        if ( !s.ToULong(&l_value) )
+            return false;
+        *value = l_value;
+#endif
+    }
+    else if (type == wxS("bool"))
+        *value = (long) (((wxVariantDataBool*)GetData())->GetValue());
+    else if (type == wxS("double"))
+    {
+        double value_d = ((wxVariantDoubleData*)GetData())->GetValue();
+
+        if ( value_d < 0.0 )
+            return false;
+
+#ifdef wxLongLong_t
+        *value = (wxULongLong_t) value_d;
+#else
+        wxLongLong temp;
+        temp.Assign(value_d);
+        *value = temp;
+#endif
+    }
+    else if (type == wxS("longlong"))
+        *value = ((wxVariantDataLongLong*)GetData())->GetValue();
+    else
+        return false;
+
+    return true;
+}
+#endif // wxUSE_LONGLONG
+
 #if wxUSE_DATETIME
 bool wxVariant::Convert(wxDateTime* value) const
 {