X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/aeab10d07c1f4ef78c0c9152de115fa216922e6c..977c53206a4be411999140b514507e161e1f0a04:/src/msw/ole/oleutils.cpp diff --git a/src/msw/ole/oleutils.cpp b/src/msw/ole/oleutils.cpp index 58b3cd8a16..9c50a53fdc 100644 --- a/src/msw/ole/oleutils.cpp +++ b/src/msw/ole/oleutils.cpp @@ -1,12 +1,12 @@ /////////////////////////////////////////////////////////////////////////////// -// Name: ole/oleutils.cpp +// Name: src/msw/ole/oleutils.cpp // Purpose: implementation of OLE helper functions // Author: Vadim Zeitlin // Modified by: // Created: 19.02.98 // RCS-ID: $Id$ // Copyright: (c) 1998 Vadim Zeitlin -// Licence: wxWindows license +// Licence: wxWindows licence /////////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -17,25 +17,37 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ -#pragma implementation "oleutils.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" #if defined(__BORLANDC__) -#pragma hdrstop + #pragma hdrstop #endif -#include -#include +#if wxUSE_OLE + +#ifndef WX_PRECOMP + #include "wx/log.h" +#endif + +#ifndef __CYGWIN10__ + +#include "wx/msw/private.h" + +#ifdef __WXWINCE__ + #include + #include -#include + #define GUID_DEFINED + #define UUID_DEFINED +#endif // OLE -#include -#include +#ifndef __WXWINCE__ +#include "wx/msw/ole/uuid.h" +#endif + +#include "wx/msw/ole/oleutils.h" #if defined(__VISUALC__) && (__VISUALC__ > 1000) #include @@ -45,40 +57,363 @@ // Implementation // ============================================================================ -// return TRUE if the iid is in the array +// return true if the iid is in the array bool IsIidFromList(REFIID riid, const IID *aIids[], size_t nCount) { for ( size_t i = 0; i < nCount; i++ ) { if ( riid == *aIids[i] ) - return TRUE; + return true; } - return FALSE; + return false; +} + +WXDLLEXPORT BSTR wxConvertStringToOle(const wxString& str) +{ + return wxBasicString(str).Get(); +} + +WXDLLEXPORT wxString wxConvertStringFromOle(BSTR bStr) +{ + // NULL BSTR is equivalent to an empty string (this is the convention used + // by VB and hence we must follow it) + if ( !bStr ) + return wxString(); + + const int len = SysStringLen(bStr); + +#if wxUSE_UNICODE + wxString str(bStr, len); +#else + wxString str; + if (len) + { + wxStringBufferLength buf(str, len); // asserts if len == 0 + buf.SetLength(WideCharToMultiByte(CP_ACP, 0 /* no flags */, + bStr, len /* not necessarily NUL-terminated */, + buf, len, + NULL, NULL /* no default char */)); + } +#endif + + return str; +} + +// ---------------------------------------------------------------------------- +// wxBasicString +// ---------------------------------------------------------------------------- + +wxBasicString::wxBasicString(const wxString& str) +{ + m_bstrBuf = SysAllocString(str.wc_str(*wxConvCurrent)); +} + +wxBasicString::wxBasicString(const wxBasicString& src) +{ + m_bstrBuf = src.Get(); +} + +wxBasicString& wxBasicString::operator=(const wxBasicString& src) +{ + SysReAllocString(&m_bstrBuf, src); + return *this; +} + +wxBasicString::~wxBasicString() +{ + SysFreeString(m_bstrBuf); +} + + +// ---------------------------------------------------------------------------- +// Convert variants +// ---------------------------------------------------------------------------- + +#if wxUSE_VARIANT + +WXDLLEXPORT bool wxConvertVariantToOle(const wxVariant& variant, VARIANTARG& oleVariant) +{ + VariantInit(&oleVariant); + if (variant.IsNull()) + { + oleVariant.vt = VT_NULL; + return true; + } + + wxString type(variant.GetType()); + + + if (type == wxT("long")) + { + oleVariant.vt = VT_I4; + oleVariant.lVal = variant.GetLong() ; + } + else if (type == wxT("char")) + { + oleVariant.vt=VT_I1; // Signed Char + oleVariant.cVal=variant.GetChar(); + } + else if (type == wxT("double")) + { + oleVariant.vt = VT_R8; + oleVariant.dblVal = variant.GetDouble(); + } + else if (type == wxT("bool")) + { + oleVariant.vt = VT_BOOL; + oleVariant.boolVal = variant.GetBool() ? VARIANT_TRUE : VARIANT_FALSE; + } + else if (type == wxT("string")) + { + wxString str( variant.GetString() ); + oleVariant.vt = VT_BSTR; + oleVariant.bstrVal = wxConvertStringToOle(str); + } +#if wxUSE_DATETIME + else if (type == wxT("datetime")) + { + wxDateTime date( variant.GetDateTime() ); + oleVariant.vt = VT_DATE; + + SYSTEMTIME st; + date.GetAsMSWSysTime(&st); + + SystemTimeToVariantTime(&st, &oleVariant.date); + } +#endif + else if (type == wxT("void*")) + { + oleVariant.vt = VT_DISPATCH; + oleVariant.pdispVal = (IDispatch*) variant.GetVoidPtr(); + } + else if (type == wxT("list") || type == wxT("stringlist")) + { + oleVariant.vt = VT_VARIANT | VT_ARRAY; + + SAFEARRAY *psa; + SAFEARRAYBOUND saBound; + VARIANTARG *pvargBase; + VARIANTARG *pvarg; + int i, j; + + int iCount = variant.GetCount(); + + saBound.lLbound = 0; + saBound.cElements = iCount; + + psa = SafeArrayCreate(VT_VARIANT, 1, &saBound); + if (psa == NULL) + return false; + + SafeArrayAccessData(psa, (void**)&pvargBase); + + pvarg = pvargBase; + for (i = 0; i < iCount; i++) + { + // copy each string in the list of strings + wxVariant eachVariant(variant[i]); + if (!wxConvertVariantToOle(eachVariant, * pvarg)) + { + // memory failure: back out and free strings alloc'ed up to + // now, and then the array itself. + pvarg = pvargBase; + for (j = 0; j < i; j++) + { + SysFreeString(pvarg->bstrVal); + pvarg++; + } + SafeArrayDestroy(psa); + return false; + } + pvarg++; + } + + SafeArrayUnaccessData(psa); + + oleVariant.parray = psa; + } + else + { + oleVariant.vt = VT_NULL; + return false; + } + return true; +} + +#ifndef VT_TYPEMASK +#define VT_TYPEMASK 0xfff +#endif + +WXDLLEXPORT bool +wxConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant) +{ + bool ok = true; + if ( oleVariant.vt & VT_ARRAY ) + { + + // Compute the total number of elements in all array dimensions + int cElements = 1; + for ( int cDims = 0; cDims < oleVariant.parray->cDims; cDims++ ) + cElements *= oleVariant.parray->rgsabound[cDims].cElements; + + // Get a pointer to the data + void* pvdata; + HRESULT hr = SafeArrayAccessData(oleVariant.parray, &pvdata); + if ( FAILED(hr) ) + return false; + + switch (oleVariant.vt & VT_TYPEMASK) + { + case VT_VARIANT: + { + variant.ClearList(); + VARIANTARG *variant_data=(VARIANTARG*)pvdata; + for ( int i = 0; i < cElements; i++ ) + { + VARIANTARG& oleElement = variant_data[i]; + wxVariant vElement; + if ( !wxConvertOleToVariant(oleElement, vElement) ) + { + ok = false; + variant.ClearList(); + break; + } + + variant.Append(vElement); + } + } + break; + + case VT_BSTR: + { + wxArrayString strings; + BSTR *string_val=(BSTR*)pvdata; + for ( int i = 0; i < cElements; ++i ) + { + wxString str=wxConvertStringFromOle(*string_val); + strings.Add(str); + ++string_val; + } + variant=strings; + } + break; + + default: + wxLogDebug(wxT("unhandled VT_ARRAY type %x in wxConvertOleToVariant"), + oleVariant.vt & VT_TYPEMASK); + variant = wxVariant(); + ok = false; + break; + } + + SafeArrayUnaccessData(oleVariant.parray); + } + else if ( oleVariant.vt & VT_BYREF ) + { + switch ( oleVariant.vt & VT_TYPEMASK ) + { + case VT_VARIANT: + { + VARIANTARG& oleReference = *((LPVARIANT)oleVariant.byref); + if (!wxConvertOleToVariant(oleReference,variant)) + return false; + break; + } + + default: + wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: [as yet] unhandled reference %X"), + oleVariant.vt); + return false; + } + } + else // simply type (not array or reference) + { + switch ( oleVariant.vt & VT_TYPEMASK ) + { + case VT_BSTR: + { + wxString str(wxConvertStringFromOle(oleVariant.bstrVal)); + variant = str; + } + break; + + case VT_DATE: +#if wxUSE_DATETIME + { + SYSTEMTIME st; + VariantTimeToSystemTime(oleVariant.date, &st); + + wxDateTime date; + date.SetFromMSWSysTime(st); + variant = date; + } +#endif // wxUSE_DATETIME + break; + + case VT_I4: + variant = (long) oleVariant.lVal; + break; + + case VT_I2: + variant = (long) oleVariant.iVal; + break; + + case VT_BOOL: + variant = oleVariant.boolVal != 0; + break; + + case VT_R8: + variant = oleVariant.dblVal; + break; + + case VT_DISPATCH: + variant = (void*) oleVariant.pdispVal; + break; + + case VT_NULL: + variant.MakeNull(); + break; + + case VT_EMPTY: + break; // Ignore Empty Variant, used only during destruction of objects + + default: + wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: Unknown variant value type %X -> %X"), + oleVariant.vt,oleVariant.vt&VT_TYPEMASK); + return false; + } + } + + return ok; } -#if wxUSE_DRAG_AND_DROP +#endif // wxUSE_VARIANT + // ---------------------------------------------------------------------------- // Debug support // ---------------------------------------------------------------------------- -#if defined(__WXDEBUG__) && defined(__VISUALC__) && (__VISUALC__ > 1000) -const char *GetIidName(REFIID riid) +#if wxUSE_DATAOBJ + +#if wxDEBUG_LEVEL && ( ( defined(__VISUALC__) && (__VISUALC__ > 1000) ) || defined(__MWERKS__) ) +static wxString GetIidName(REFIID riid) { // an association between symbolic name and numeric value of an IID struct KNOWN_IID { const IID *pIid; - const char *szName; + const wxChar *szName; }; // construct the table containing all known interfaces - #define ADD_KNOWN_IID(name) { &IID_I##name, #name } + #define ADD_KNOWN_IID(name) { &IID_I##name, wxT(#name) } static const KNOWN_IID aKnownIids[] = { ADD_KNOWN_IID(AdviseSink), ADD_KNOWN_IID(AdviseSink2), ADD_KNOWN_IID(BindCtx), ADD_KNOWN_IID(ClassFactory), +#if ( !defined( __VISUALC__) || (__VISUALC__!=1010) ) && !defined(__MWERKS__) ADD_KNOWN_IID(ContinueCallback), ADD_KNOWN_IID(EnumOleDocumentViews), ADD_KNOWN_IID(OleCommandTarget), @@ -86,6 +421,7 @@ const char *GetIidName(REFIID riid) ADD_KNOWN_IID(OleDocumentSite), ADD_KNOWN_IID(OleDocumentView), ADD_KNOWN_IID(Print), +#endif ADD_KNOWN_IID(DataAdviseHolder), ADD_KNOWN_IID(DataObject), ADD_KNOWN_IID(Debug), @@ -163,46 +499,35 @@ const char *GetIidName(REFIID riid) } } +#ifndef __WXWINCE__ // unknown IID, just transform to string - static Uuid s_uuid; - s_uuid.Set(riid); - return s_uuid; + Uuid uuid(riid); + return wxString((const wxChar *)uuid); +#else + return wxEmptyString; +#endif } -void wxLogQueryInterface(const char *szInterface, REFIID riid) +void wxLogQueryInterface(const wxChar *szInterface, REFIID riid) { - wxLogTrace("%s::QueryInterface (iid = %s)", szInterface, GetIidName(riid)); + wxLogTrace(wxTRACE_OleCalls, wxT("%s::QueryInterface (iid = %s)"), + szInterface, GetIidName(riid).c_str()); } -void wxLogAddRef(const char *szInterface, ULONG cRef) +void wxLogAddRef(const wxChar *szInterface, ULONG cRef) { - wxLogTrace("After %s::AddRef: m_cRef = %d", szInterface, cRef + 1); + wxLogTrace(wxTRACE_OleCalls, wxT("After %s::AddRef: m_cRef = %d"), szInterface, cRef + 1); } -void wxLogRelease(const char *szInterface, ULONG cRef) +void wxLogRelease(const wxChar *szInterface, ULONG cRef) { - wxLogTrace("After %s::Release: m_cRef = %d", szInterface, cRef - 1); + wxLogTrace(wxTRACE_OleCalls, wxT("After %s::Release: m_cRef = %d"), szInterface, cRef - 1); } -#elif defined(__WXDEBUG__) && defined(__VISUALC__) && (__VISUALC__ <= 1000) +#endif // wxDEBUG_LEVEL -// For VC++ 4 -void wxLogQueryInterface(const char *szInterface, REFIID riid) -{ - wxLogTrace("%s::QueryInterface", szInterface); -} +#endif // wxUSE_DATAOBJ -void wxLogAddRef(const char *szInterface, ULONG cRef) -{ - wxLogTrace("After %s::AddRef: m_cRef = %d", szInterface, cRef + 1); -} - -void wxLogRelease(const char *szInterface, ULONG cRef) -{ - wxLogTrace("After %s::Release: m_cRef = %d", szInterface, cRef - 1); -} - -#endif //WXDEBUG +#endif // __CYGWIN10__ -#endif - // wxUSE_DRAG_AND_DROP +#endif // wxUSE_OLE