#if wxUSE_VARIANT
+namespace
+{
+
+// Helper class for creating and filling SAFEARRAY. To use it, call Create()
+// first, then SetElement() for each element and finally Detach() the SAFEARRAY
+// from it if you don't want it to be deleted when this class is.
+class wxSafeArrayHelper
+{
+public:
+ wxSafeArrayHelper();
+ ~wxSafeArrayHelper();
+
+ bool Create(VARTYPE vt, long count); // creates and locks the array
+
+ bool SetElement(size_t index, const wxVariant& variant);
+ bool SetElement(size_t index, const wxString& str);
+
+ SAFEARRAY* Detach(); // unlocks the array and gives up its ownership
+
+private:
+ void Unlock();
+
+ SAFEARRAY* m_array;
+};
+
+wxSafeArrayHelper::wxSafeArrayHelper()
+{
+ m_array = NULL;
+}
+
+wxSafeArrayHelper::~wxSafeArrayHelper()
+{
+ if ( m_array )
+ {
+ Unlock();
+ SafeArrayDestroy(m_array);
+ }
+}
+
+bool wxSafeArrayHelper::Create(VARTYPE vt, long count)
+{
+ SAFEARRAYBOUND saBound;
+
+ saBound.lLbound = 0;
+ saBound.cElements = count;
+ m_array = SafeArrayCreate(vt, 1, &saBound);
+ if ( !m_array )
+ return false;
+ return SUCCEEDED( SafeArrayLock(m_array) );
+}
+
+bool wxSafeArrayHelper::SetElement(size_t index, const wxVariant& variant)
+{
+ VARIANT* data = (VARIANT*)m_array->pvData;
+ return wxConvertVariantToOle(variant, data[index]);
+}
+
+bool wxSafeArrayHelper::SetElement(size_t index, const wxString& str)
+{
+ BSTR bstr = wxConvertStringToOle(str);
+
+ if ( !bstr && !str.empty() )
+ {
+ // BSTR can be NULL for empty strings but if the string was
+ // not empty, it means we failed to allocate memory for it.
+ return false;
+ }
+
+ BSTR* data = (BSTR*)m_array->pvData;
+ data[index] = bstr;
+ return true;
+}
+
+SAFEARRAY* wxSafeArrayHelper::Detach()
+{
+ Unlock();
+ SAFEARRAY* result = m_array;
+ m_array = NULL;
+ return result;
+}
+
+void wxSafeArrayHelper::Unlock()
+{
+ if ( m_array )
+ SafeArrayUnlock(m_array);
+}
+
+} // unnamed namespace
+
+
+// ----------------------------------------------------------------------------
+// wxVariantDataCurrency
+// ----------------------------------------------------------------------------
+
+
+#if wxUSE_ANY
+
+bool wxVariantDataCurrency::GetAsAny(wxAny* any) const
+{
+ *any = m_value;
+ return true;
+}
+
+wxVariantData* wxVariantDataCurrency::VariantDataFactory(const wxAny& any)
+{
+ return new wxVariantDataCurrency(wxANY_AS(any, CURRENCY));
+}
+
+REGISTER_WXANY_CONVERSION(CURRENCY, wxVariantDataCurrency)
+
+#endif // wxUSE_ANY
+
+bool wxVariantDataCurrency::Eq(wxVariantData& data) const
+{
+ wxASSERT_MSG( (data.GetType() == wxS("currency")),
+ "wxVariantDataCurrency::Eq: argument mismatch" );
+
+ wxVariantDataCurrency& otherData = (wxVariantDataCurrency&) data;
+
+ return otherData.m_value.int64 == m_value.int64;
+}
+
+#if wxUSE_STD_IOSTREAM
+bool wxVariantDataCurrency::Write(wxSTD ostream& str) const
+{
+ wxString s;
+ Write(s);
+ str << s;
+ return true;
+}
+#endif
+
+bool wxVariantDataCurrency::Write(wxString& str) const
+{
+ BSTR bStr = NULL;
+ if ( SUCCEEDED(VarBstrFromCy(m_value, LOCALE_USER_DEFAULT, 0, &bStr)) )
+ {
+ str = wxConvertStringFromOle(bStr);
+ SysFreeString(bStr);
+ return true;
+ }
+ return false;
+}
+
+// ----------------------------------------------------------------------------
+// wxVariantDataErrorCode
+// ----------------------------------------------------------------------------
+
+#if wxUSE_ANY
+
+bool wxVariantDataErrorCode::GetAsAny(wxAny* any) const
+{
+ *any = m_value;
+ return true;
+}
+
+wxVariantData* wxVariantDataErrorCode::VariantDataFactory(const wxAny& any)
+{
+ return new wxVariantDataErrorCode(wxANY_AS(any, SCODE));
+}
+
+REGISTER_WXANY_CONVERSION(SCODE, wxVariantDataErrorCode)
+
+#endif // wxUSE_ANY
+
+bool wxVariantDataErrorCode::Eq(wxVariantData& data) const
+{
+ wxASSERT_MSG( (data.GetType() == wxS("errorcode")),
+ "wxVariantDataErrorCode::Eq: argument mismatch" );
+
+ wxVariantDataErrorCode& otherData = (wxVariantDataErrorCode&) data;
+
+ return otherData.m_value == m_value;
+}
+
+#if wxUSE_STD_IOSTREAM
+bool wxVariantDataErrorCode::Write(wxSTD ostream& str) const
+{
+ wxString s;
+ Write(s);
+ str << s;
+ return true;
+}
+#endif
+
+bool wxVariantDataErrorCode::Write(wxString& str) const
+{
+ str << m_value;
+ return true;
+}
+
+
+
WXDLLEXPORT bool wxConvertVariantToOle(const wxVariant& variant, VARIANTARG& oleVariant)
{
VariantInit(&oleVariant);
wxString type(variant.GetType());
-
- if (type == wxT("long"))
+ if (type == wxT("errorcode"))
+ {
+ wxVariantDataErrorCode* const
+ ec = wxDynamicCastVariantData(variant.GetData(),
+ wxVariantDataErrorCode);
+ oleVariant.vt = VT_ERROR;
+ oleVariant.scode = ec->GetValue();
+ }
+ else if (type == wxT("currency"))
+ {
+ wxVariantDataCurrency* const
+ c = wxDynamicCastVariantData(variant.GetData(),
+ wxVariantDataCurrency);
+ oleVariant.vt = VT_CY;
+ oleVariant.cyVal = c->GetValue();
+ }
+ else if (type == wxT("long"))
{
oleVariant.vt = VT_I4;
oleVariant.lVal = variant.GetLong() ;
oleVariant.vt = VT_DISPATCH;
oleVariant.pdispVal = (IDispatch*) variant.GetVoidPtr();
}
- else if (type == wxT("list") || type == wxT("arrstring"))
+ else if (type == wxT("list"))
{
- SAFEARRAY *psa;
- SAFEARRAYBOUND saBound;
- bool isArrString = type == wxT("arrstring");
- wxArrayString strings;
-
- if (isArrString)
- strings = variant.GetArrayString();
- oleVariant.vt = (isArrString ? VT_BSTR : VT_VARIANT) | VT_ARRAY;
-
- long lCount = isArrString ? strings.GetCount() : variant.GetCount();
- saBound.lLbound = 0;
- saBound.cElements = lCount;
- psa = SafeArrayCreate(isArrString ? VT_BSTR : VT_VARIANT, 1, &saBound);
- if (psa == NULL)
+ wxSafeArrayHelper sah;
+
+ if (!sah.Create(VT_VARIANT, variant.GetCount()))
return false;
- long i;
- for (i = 0; i < lCount; i++)
+ for (size_t i = 0; i < variant.GetCount(); i++)
{
- if (isArrString)
- {
- wxBasicString bstr(strings[i]);
- if ( !bstr && !strings[i].empty() )
- {
- // BSTR can be NULL for empty strings but if the string was
- // not empty, it means we failed to allocate memory for it.
- break;
- }
-
- if ( FAILED(SafeArrayPutElement(psa, &i, (BSTR)bstr)) )
- break;
- }
- else // list of wxVariants
- {
- VARIANT v;
- if ( !wxConvertVariantToOle(variant[i], v) )
- break;
-
- HRESULT hr = SafeArrayPutElement(psa, &i, &v);
+ if (!sah.SetElement(i, variant[i]))
+ return false;
+ }
- // SafeArrayPutElement makes a copy of an added element, so
- // free this one.
- VariantClear(&v);
+ oleVariant.vt = VT_VARIANT | VT_ARRAY;
+ oleVariant.parray = sah.Detach();
+ }
+ else if (type == wxT("arrstring"))
+ {
+ wxArrayString strings(variant.GetArrayString());
+ wxSafeArrayHelper sah;
- if (FAILED(hr))
- break;
- }
- }
+ if (!sah.Create(VT_BSTR, strings.GetCount()))
+ return false;
- if (i < lCount) // the iteration was exited prematurely because of an error
+ for (size_t i = 0; i < strings.GetCount(); i++)
{
- SafeArrayDestroy(psa);
- return false;
+ if (!sah.SetElement(i, strings[i]))
+ return false;
}
- oleVariant.parray = psa;
+ oleVariant.vt = VT_BSTR | VT_ARRAY;
+ oleVariant.parray = sah.Detach();
}
else
{
{
switch ( oleVariant.vt & VT_TYPEMASK )
{
+ case VT_ERROR:
+ variant.SetData(new wxVariantDataErrorCode(oleVariant.scode));
+ break;
+
+ case VT_CY:
+ variant.SetData(new wxVariantDataCurrency(oleVariant.cyVal));
+ break;
+
case VT_BSTR:
{
wxString str(wxConvertStringFromOle(oleVariant.bstrVal));
projects / wxWidgets.git / blobdiff