X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/cf25a599cd5ec86b3e054efb799dfbafe26a0d50..d485bda109d5ef0fef36a3f737549e9b9f54baab:/src/common/variant.cpp diff --git a/src/common/variant.cpp b/src/common/variant.cpp index b018603350..6bafda604f 100644 --- a/src/common/variant.cpp +++ b/src/common/variant.cpp @@ -37,11 +37,6 @@ #endif #endif -#if defined(__MWERKS__) && __MSL__ >= 0x6000 -namespace std {} -using namespace std ; -#endif - #if wxUSE_STREAMS #include "wx/txtstrm.h" #endif @@ -193,6 +188,52 @@ bool wxVariant::IsValueKindOf(const wxClassInfo* type) const return info ? info->IsKindOf(type) : false ; } +// ----------------------------------------------------------------- +// wxVariant <-> wxAny conversion code +// ----------------------------------------------------------------- + +#if wxUSE_ANY + +wxAnyToVariantRegistration:: + wxAnyToVariantRegistration(wxVariantDataFactory factory) + : m_factory(factory) +{ + wxPreRegisterAnyToVariant(this); +} + +wxAnyToVariantRegistration::~wxAnyToVariantRegistration() +{ +} + +wxVariant::wxVariant(const wxAny& any) + : wxObject() +{ + wxVariant variant; + if ( !any.GetAs(&variant) ) + { + wxFAIL_MSG("wxAny of this type cannot be converted to wxVariant"); + return; + } + + *this = variant; +} + +wxAny wxVariant::GetAny() const +{ + if ( IsNull() ) + return wxAny(); + + wxAny any; + wxVariantData* data = GetData(); + + if ( data->GetAsAny(&any) ) + return any; + + // If everything else fails, wrap the whole wxVariantData + return wxAny(data); +} + +#endif // wxUSE_ANY // ----------------------------------------------------------------- // wxVariantDataLong @@ -224,10 +265,29 @@ public: virtual wxString GetType() const { return wxT("long"); } +#if wxUSE_ANY + // Since wxAny does not have separate type for integers shorter than + // longlong, we do not usually implement wxVariant->wxAny conversion + // here (but in wxVariantDataLongLong instead). + #ifndef wxLongLong_t + DECLARE_WXANY_CONVERSION() + #else + bool GetAsAny(wxAny* any) const + { + *any = m_value; + return true; + } + #endif +#endif // wxUSE_ANY + protected: long m_value; }; +#ifndef wxLongLong_t +IMPLEMENT_TRIVIAL_WXANY_CONVERSION(long, wxVariantDataLong) +#endif + bool wxVariantDataLong::Eq(wxVariantData& data) const { wxASSERT_MSG( (data.GetType() == wxT("long")), wxT("wxVariantDataLong::Eq: argument mismatch") ); @@ -373,10 +433,14 @@ public: virtual wxString GetType() const { return wxT("double"); } wxVariantData* Clone() const { return new wxVariantDoubleData(m_value); } + + DECLARE_WXANY_CONVERSION() protected: double m_value; }; +IMPLEMENT_TRIVIAL_WXANY_CONVERSION(double, wxVariantDoubleData) + bool wxVariantDoubleData::Eq(wxVariantData& data) const { wxASSERT_MSG( (data.GetType() == wxT("double")), wxT("wxVariantDoubleData::Eq: argument mismatch") ); @@ -509,10 +573,14 @@ public: virtual wxString GetType() const { return wxT("bool"); } wxVariantData* Clone() const { return new wxVariantDataBool(m_value); } + + DECLARE_WXANY_CONVERSION() protected: bool m_value; }; +IMPLEMENT_TRIVIAL_WXANY_CONVERSION(bool, wxVariantDataBool) + bool wxVariantDataBool::Eq(wxVariantData& data) const { wxASSERT_MSG( (data.GetType() == wxT("bool")), wxT("wxVariantDataBool::Eq: argument mismatch") ); @@ -646,10 +714,13 @@ public: virtual wxString GetType() const { return wxT("char"); } wxVariantData* Clone() const { return new wxVariantDataChar(m_value); } + DECLARE_WXANY_CONVERSION() protected: wxUniChar m_value; }; +IMPLEMENT_TRIVIAL_WXANY_CONVERSION(wxUniChar, wxVariantDataChar) + bool wxVariantDataChar::Eq(wxVariantData& data) const { wxASSERT_MSG( (data.GetType() == wxT("char")), wxT("wxVariantDataChar::Eq: argument mismatch") ); @@ -798,10 +869,33 @@ public: virtual wxString GetType() const { return wxT("string"); } wxVariantData* Clone() const { return new wxVariantDataString(m_value); } + DECLARE_WXANY_CONVERSION() protected: wxString m_value; }; +IMPLEMENT_TRIVIAL_WXANY_CONVERSION(wxString, wxVariantDataString) + +#if wxUSE_ANY +// This allows converting string literal wxAnys to string variants +wxVariantData* wxVariantDataFromConstCharPAny(const wxAny& any) +{ + return new wxVariantDataString(wxANY_AS(any, const char*)); +} + +wxVariantData* wxVariantDataFromConstWchar_tPAny(const wxAny& any) +{ + return new wxVariantDataString(wxANY_AS(any, const wchar_t*)); +} + +_REGISTER_WXANY_CONVERSION(const char*, + ConstCharP, + wxVariantDataFromConstCharPAny) +_REGISTER_WXANY_CONVERSION(const wchar_t*, + ConstWchar_tP, + wxVariantDataFromConstWchar_tPAny) +#endif + bool wxVariantDataString::Eq(wxVariantData& data) const { wxASSERT_MSG( (data.GetType() == wxT("string")), wxT("wxVariantDataString::Eq: argument mismatch") ); @@ -887,6 +981,20 @@ wxVariant::wxVariant(const wxScopedWCharBuffer& val, const wxString& name) m_name = name; } +#if wxUSE_STD_STRING +wxVariant::wxVariant(const std::string& val, const wxString& name) +{ + m_refData = new wxVariantDataString(wxString(val)); + m_name = name; +} + +wxVariant::wxVariant(const wxStdWideString& val, const wxString& name) +{ + m_refData = new wxVariantDataString(wxString(val)); + m_name = name; +} +#endif // wxUSE_STD_STRING + bool wxVariant::operator== (const wxString& value) const { wxString thisValue; @@ -954,10 +1062,13 @@ public: virtual wxClassInfo* GetValueClassInfo(); + DECLARE_WXANY_CONVERSION() protected: wxObject* m_value; }; +IMPLEMENT_TRIVIAL_WXANY_CONVERSION(wxObject*, wxVariantDataWxObjectPtr) + bool wxVariantDataWxObjectPtr::Eq(wxVariantData& data) const { wxASSERT_MSG( data.GetType() == GetType(), wxT("wxVariantDataWxObjectPtr::Eq: argument mismatch") ); @@ -1073,10 +1184,13 @@ public: virtual wxString GetType() const { return wxT("void*"); } virtual wxVariantData* Clone() const { return new wxVariantDataVoidPtr(m_value); } + DECLARE_WXANY_CONVERSION() protected: void* m_value; }; +IMPLEMENT_TRIVIAL_WXANY_CONVERSION(void*, wxVariantDataVoidPtr) + bool wxVariantDataVoidPtr::Eq(wxVariantData& data) const { wxASSERT_MSG( data.GetType() == wxT("void*"), wxT("wxVariantDataVoidPtr::Eq: argument mismatch") ); @@ -1185,10 +1299,12 @@ public: virtual wxString GetType() const { return wxT("datetime"); } virtual wxVariantData* Clone() const { return new wxVariantDataDateTime(m_value); } + DECLARE_WXANY_CONVERSION() protected: wxDateTime m_value; }; +IMPLEMENT_TRIVIAL_WXANY_CONVERSION(wxDateTime, wxVariantDataDateTime) bool wxVariantDataDateTime::Eq(wxVariantData& data) const { @@ -1316,10 +1432,13 @@ public: virtual wxString GetType() const { return wxT("arrstring"); } virtual wxVariantData* Clone() const { return new wxVariantDataArrayString(m_value); } + DECLARE_WXANY_CONVERSION() protected: wxArrayString m_value; }; +IMPLEMENT_TRIVIAL_WXANY_CONVERSION(wxArrayString, wxVariantDataArrayString) + bool wxVariantDataArrayString::Eq(wxVariantData& data) const { wxASSERT_MSG( data.GetType() == GetType(), wxT("wxVariantDataArrayString::Eq: argument mismatch") ); @@ -1343,7 +1462,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]; } @@ -1363,7 +1482,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()); @@ -1382,7 +1501,7 @@ wxVariant::wxVariant(const wxArrayString& val, const wxString& name) // Strings bool wxVariant::operator==(const wxArrayString& WXUNUSED(value)) const { - wxFAIL_MSG( _T("TODO") ); + wxFAIL_MSG( wxT("TODO") ); return false; } @@ -1414,6 +1533,405 @@ 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"); } + + DECLARE_WXANY_CONVERSION() +protected: + wxLongLong m_value; +}; + +// +// wxLongLong type requires customized wxAny conversion code +// +#if wxUSE_ANY +#ifdef wxLongLong_t + +bool wxVariantDataLongLong::GetAsAny(wxAny* any) const +{ + *any = m_value.GetValue(); + return true; +} + +wxVariantData* wxVariantDataLongLong::VariantDataFactory(const wxAny& any) +{ + return new wxVariantDataLongLong(wxANY_AS(any, wxLongLong_t)); +} + +REGISTER_WXANY_CONVERSION(wxLongLong_t, wxVariantDataLongLong) + +#else // if !defined(wxLongLong_t) + +bool wxVariantDataLongLong::GetAsAny(wxAny* any) const +{ + *any = m_value; + return true; +} + +wxVariantData* wxVariantDataLongLong::VariantDataFactory(const wxAny& any) +{ + return new wxVariantDataLongLong(wxANY_AS(any, wxLongLong)); +} + +REGISTER_WXANY_CONVERSION(wxLongLong, wxVariantDataLongLong) + +#endif // defined(wxLongLong_t)/!defined(wxLongLong_t) +#endif // wxUSE_ANY + +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"); } + + DECLARE_WXANY_CONVERSION() +protected: + wxULongLong m_value; +}; + +// +// wxULongLong type requires customized wxAny conversion code +// +#if wxUSE_ANY +#ifdef wxLongLong_t + +bool wxVariantDataULongLong::GetAsAny(wxAny* any) const +{ + *any = m_value.GetValue(); + return true; +} + +wxVariantData* wxVariantDataULongLong::VariantDataFactory(const wxAny& any) +{ + return new wxVariantDataULongLong(wxANY_AS(any, wxULongLong_t)); +} + +REGISTER_WXANY_CONVERSION(wxULongLong_t, wxVariantDataULongLong) + +#else // if !defined(wxLongLong_t) + +bool wxVariantDataULongLong::GetAsAny(wxAny* any) const +{ + *any = m_value; + return true; +} + +wxVariantData* wxVariantDataULongLong::VariantDataFactory(const wxAny& any) +{ + return new wxVariantDataULongLong(wxANY_AS(any, wxULongLong)); +} + +REGISTER_WXANY_CONVERSION(wxULongLong, wxVariantDataULongLong) + +#endif // defined(wxLongLong_t)/!defined(wxLongLong_t) +#endif // wxUSE_ANY + + +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 // ---------------------------------------------------------------------------- @@ -1442,10 +1960,52 @@ public: void Clear(); wxVariantData* Clone() const { return new wxVariantDataList(m_value); } + + DECLARE_WXANY_CONVERSION() protected: wxVariantList m_value; }; +#if wxUSE_ANY + +// +// Convert to/from list of wxAnys +// + +bool wxVariantDataList::GetAsAny(wxAny* any) const +{ + wxAnyList dst; + wxVariantList::compatibility_iterator node = m_value.GetFirst(); + while (node) + { + wxVariant* pVar = node->GetData(); + dst.push_back(new wxAny(((const wxVariant&)*pVar))); + node = node->GetNext(); + } + + *any = dst; + return true; +} + +wxVariantData* wxVariantDataList::VariantDataFactory(const wxAny& any) +{ + wxAnyList src = wxANY_AS(any, wxAnyList); + wxVariantList dst; + wxAnyList::compatibility_iterator node = src.GetFirst(); + while (node) + { + wxAny* pAny = node->GetData(); + dst.push_back(new wxVariant(*pAny)); + node = node->GetNext(); + } + + return new wxVariantDataList(dst); +} + +REGISTER_WXANY_CONVERSION(wxAnyList, wxVariantDataList) + +#endif // wxUSE_ANY + wxVariantDataList::wxVariantDataList(const wxVariantList& list) { SetValue(list); @@ -1699,14 +2259,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; @@ -1750,6 +2328,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; @@ -1765,6 +2353,15 @@ bool wxVariant::Convert(wxUniChar* value) const *value = (char) (((wxVariantDataLong*)GetData())->GetValue()); else if (type == wxT("bool")) *value = (char) (((wxVariantDataBool*)GetData())->GetValue()); + else if (type == wxS("string")) + { + // Also accept strings of length 1 + const wxString& str = (((wxVariantDataString*)GetData())->GetValue()); + if ( str.length() == 1 ) + *value = str[0]; + else + return false; + } else return false; @@ -1795,6 +2392,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 {