src/msw/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 <zeitlin@dptmaths.ens-cachan.fr>
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// Declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#if defined(__BORLANDC__)
    #pragma hdrstop
#endif

#if wxUSE_OLE

#ifndef WX_PRECOMP
    #include "wx/log.h"
#endif

#ifndef __CYGWIN10__

#include "wx/msw/private.h"

#ifdef __WXWINCE__
    #include <winreg.h>
    #include <ole2.h>

    #define GUID_DEFINED
    #define UUID_DEFINED
#endif

// OLE
#ifndef __WXWINCE__
#include  "wx/msw/ole/uuid.h"
#endif

#include  "wx/msw/ole/oleutils.h"

#if defined(__VISUALC__) && (__VISUALC__ > 1000)
    #include  <docobj.h>
#endif

// ============================================================================
// Implementation
// ============================================================================

// return true if the iid is in the array
WXDLLEXPORT 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 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

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


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() ;
    }
    // Original VC6 came with SDK too old to contain VARIANT::llVal declaration
    // and there doesn't seem to be any way to test for it as Microsoft simply
    // added it to the later version of oaidl.h without changing anything else.
    // So assume it's not present for VC6, even though it might be if an
    // updated SDK is used. In this case the user would need to disable this
    // check himself.
#if wxUSE_LONGLONG && !defined(__VISUALC6__)
    else if (type == wxT("longlong"))
    {
        oleVariant.vt = VT_I8;
        oleVariant.llVal = variant.GetLongLong().GetValue();
    }
#endif
    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"))
    {
        wxSafeArrayHelper sah;

        if (!sah.Create(VT_VARIANT, variant.GetCount()))
            return false;

        for (size_t i = 0; i < variant.GetCount(); i++)
        {
            if (!sah.SetElement(i, variant[i]))
                return false;
        }

        oleVariant.vt = VT_VARIANT | VT_ARRAY;
        oleVariant.parray = sah.Detach();
    }
    else if (type == wxT("arrstring"))
    {
        wxArrayString strings(variant.GetArrayString());
        wxSafeArrayHelper sah;

        if (!sah.Create(VT_BSTR, strings.GetCount()))
            return false;

        for (size_t i = 0; i < strings.GetCount(); i++)
        {
            if (!sah.SetElement(i, strings[i]))
                return false;
        }

        oleVariant.vt = VT_BSTR | VT_ARRAY;
        oleVariant.parray = sah.Detach();
    }
    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;

                // See the comment before the __VISUALC6__ test above.
#if wxUSE_LONGLONG && !defined(__VISUALC6__)
            case VT_I8:
                variant = wxLongLong(oleVariant.llVal);
                break;
#endif // wxUSE_LONGLONG

            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_R4:
                variant = oleVariant.fltVal;
                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;
}

#endif // wxUSE_VARIANT


// ----------------------------------------------------------------------------
// Debug support
// ----------------------------------------------------------------------------

#if wxUSE_DATAOBJ

#if wxDEBUG_LEVEL && (( defined(__VISUALC__) && (__VISUALC__ > 1000) ))
static wxString GetIidName(REFIID riid)
{
  // an association between symbolic name and numeric value of an IID
  struct KNOWN_IID {
    const IID  *pIid;
    const wxChar *szName;
  };

  // construct the table containing all known interfaces
  #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) )
    ADD_KNOWN_IID(ContinueCallback),
    ADD_KNOWN_IID(EnumOleDocumentViews),
    ADD_KNOWN_IID(OleCommandTarget),
    ADD_KNOWN_IID(OleDocument),
    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),
    ADD_KNOWN_IID(DebugStream),
    ADD_KNOWN_IID(DfReserved1),
    ADD_KNOWN_IID(DfReserved2),
    ADD_KNOWN_IID(DfReserved3),
    ADD_KNOWN_IID(Dispatch),
    ADD_KNOWN_IID(DropSource),
    ADD_KNOWN_IID(DropTarget),
    ADD_KNOWN_IID(EnumCallback),
    ADD_KNOWN_IID(EnumFORMATETC),
    ADD_KNOWN_IID(EnumGeneric),
    ADD_KNOWN_IID(EnumHolder),
    ADD_KNOWN_IID(EnumMoniker),
    ADD_KNOWN_IID(EnumOLEVERB),
    ADD_KNOWN_IID(EnumSTATDATA),
    ADD_KNOWN_IID(EnumSTATSTG),
    ADD_KNOWN_IID(EnumString),
    ADD_KNOWN_IID(EnumUnknown),
    ADD_KNOWN_IID(EnumVARIANT),
    ADD_KNOWN_IID(ExternalConnection),
    ADD_KNOWN_IID(InternalMoniker),
    ADD_KNOWN_IID(LockBytes),
    ADD_KNOWN_IID(Malloc),
    ADD_KNOWN_IID(Marshal),
    ADD_KNOWN_IID(MessageFilter),
    ADD_KNOWN_IID(Moniker),
    ADD_KNOWN_IID(OleAdviseHolder),
    ADD_KNOWN_IID(OleCache),
    ADD_KNOWN_IID(OleCache2),
    ADD_KNOWN_IID(OleCacheControl),
    ADD_KNOWN_IID(OleClientSite),
    ADD_KNOWN_IID(OleContainer),
    ADD_KNOWN_IID(OleInPlaceActiveObject),
    ADD_KNOWN_IID(OleInPlaceFrame),
    ADD_KNOWN_IID(OleInPlaceObject),
    ADD_KNOWN_IID(OleInPlaceSite),
    ADD_KNOWN_IID(OleInPlaceUIWindow),
    ADD_KNOWN_IID(OleItemContainer),
    ADD_KNOWN_IID(OleLink),
    ADD_KNOWN_IID(OleManager),
    ADD_KNOWN_IID(OleObject),
    ADD_KNOWN_IID(OlePresObj),
    ADD_KNOWN_IID(OleWindow),
    ADD_KNOWN_IID(PSFactory),
    ADD_KNOWN_IID(ParseDisplayName),
    ADD_KNOWN_IID(Persist),
    ADD_KNOWN_IID(PersistFile),
    ADD_KNOWN_IID(PersistStorage),
    ADD_KNOWN_IID(PersistStream),
    ADD_KNOWN_IID(ProxyManager),
    ADD_KNOWN_IID(RootStorage),
    ADD_KNOWN_IID(RpcChannel),
    ADD_KNOWN_IID(RpcProxy),
    ADD_KNOWN_IID(RpcStub),
    ADD_KNOWN_IID(RunnableObject),
    ADD_KNOWN_IID(RunningObjectTable),
    ADD_KNOWN_IID(StdMarshalInfo),
    ADD_KNOWN_IID(Storage),
    ADD_KNOWN_IID(Stream),
    ADD_KNOWN_IID(StubManager),
    ADD_KNOWN_IID(Unknown),
    ADD_KNOWN_IID(ViewObject),
    ADD_KNOWN_IID(ViewObject2),
  };

  // don't clobber preprocessor name space
  #undef ADD_KNOWN_IID

  // try to find the interface in the table
  for ( size_t ui = 0; ui < WXSIZEOF(aKnownIids); ui++ ) {
    if ( riid == *aKnownIids[ui].pIid ) {
      return aKnownIids[ui].szName;
    }
  }

#ifndef __WXWINCE__
  // unknown IID, just transform to string
  Uuid uuid(riid);
  return wxString((const wxChar *)uuid);
#else
  return wxEmptyString;
#endif
}

WXDLLEXPORT void wxLogQueryInterface(const wxChar *szInterface, REFIID riid)
{
  wxLogTrace(wxTRACE_OleCalls, wxT("%s::QueryInterface (iid = %s)"),
             szInterface, GetIidName(riid).c_str());
}

WXDLLEXPORT void wxLogAddRef(const wxChar *szInterface, ULONG cRef)
{
  wxLogTrace(wxTRACE_OleCalls, wxT("After %s::AddRef: m_cRef = %d"), szInterface, cRef + 1);
}

WXDLLEXPORT void wxLogRelease(const wxChar *szInterface, ULONG cRef)
{
  wxLogTrace(wxTRACE_OleCalls, wxT("After %s::Release: m_cRef = %d"), szInterface, cRef - 1);
}

#endif  // wxDEBUG_LEVEL

#endif // wxUSE_DATAOBJ

#endif // __CYGWIN10__

#endif // wxUSE_OLE
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: src/msw/ole/oleutils.cpp
	3	// Purpose: implementation of OLE helper functions
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 19.02.98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	9	// Licence: wxWindows licence
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// Declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	// For compilers that support precompilation, includes "wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#if defined(__BORLANDC__)
	24	#pragma hdrstop
	25	#endif
	26
	27	#if wxUSE_OLE
	28
	29	#ifndef WX_PRECOMP
	30	#include "wx/log.h"
	31	#endif
	32
	33	#ifndef __CYGWIN10__
	34
	35	#include "wx/msw/private.h"
	36
	37	#ifdef __WXWINCE__
	38	#include <winreg.h>
	39	#include <ole2.h>
	40
	41	#define GUID_DEFINED
	42	#define UUID_DEFINED
	43	#endif
	44
	45	// OLE
	46	#ifndef __WXWINCE__
	47	#include "wx/msw/ole/uuid.h"
	48	#endif
	49
	50	#include "wx/msw/ole/oleutils.h"
	51
	52	#if defined(__VISUALC__) && (__VISUALC__ > 1000)
	53	#include <docobj.h>
	54	#endif
	55
	56	// ============================================================================
	57	// Implementation
	58	// ============================================================================
	59
	60	// return true if the iid is in the array
	61	WXDLLEXPORT bool IsIidFromList(REFIID riid, const IID *aIids[], size_t nCount)
	62	{
	63	for ( size_t i = 0; i < nCount; i++ ) {
	64	if ( riid == *aIids[i] )
	65	return true;
	66	}
	67
	68	return false;
	69	}
	70
	71	WXDLLEXPORT BSTR wxConvertStringToOle(const wxString& str)
	72	{
	73	return wxBasicString(str).Get();
	74	}
	75
	76	WXDLLEXPORT wxString wxConvertStringFromOle(BSTR bStr)
	77	{
	78	// NULL BSTR is equivalent to an empty string (this is the convention used
	79	// by VB and hence we must follow it)
	80	if ( !bStr )
	81	return wxString();
	82
	83	const int len = SysStringLen(bStr);
	84
	85	#if wxUSE_UNICODE
	86	wxString str(bStr, len);
	87	#else
	88	wxString str;
	89	if (len)
	90	{
	91	wxStringBufferLength buf(str, len); // asserts if len == 0
	92	buf.SetLength(WideCharToMultiByte(CP_ACP, 0 /* no flags */,
	93	bStr, len /* not necessarily NUL-terminated */,
	94	buf, len,
	95	NULL, NULL /* no default char */));
	96	}
	97	#endif
	98
	99	return str;
	100	}
	101
	102	// ----------------------------------------------------------------------------
	103	// wxBasicString
	104	// ----------------------------------------------------------------------------
	105
	106	wxBasicString::wxBasicString(const wxString& str)
	107	{
	108	m_bstrBuf = SysAllocString(str.wc_str(*wxConvCurrent));
	109	}
	110
	111	wxBasicString::wxBasicString(const wxBasicString& src)
	112	{
	113	m_bstrBuf = src.Get();
	114	}
	115
	116	wxBasicString& wxBasicString::operator=(const wxBasicString& src)
	117	{
	118	SysReAllocString(&m_bstrBuf, src);
	119	return *this;
	120	}
	121
	122	wxBasicString::~wxBasicString()
	123	{
	124	SysFreeString(m_bstrBuf);
	125	}
	126
	127
	128	// ----------------------------------------------------------------------------
	129	// Convert variants
	130	// ----------------------------------------------------------------------------
	131
	132	#if wxUSE_VARIANT
	133
	134	namespace
	135	{
	136
	137	// Helper class for creating and filling SAFEARRAY. To use it, call Create()
	138	// first, then SetElement() for each element and finally Detach() the SAFEARRAY
	139	// from it if you don't want it to be deleted when this class is.
	140	class wxSafeArrayHelper
	141	{
	142	public:
	143	wxSafeArrayHelper();
	144	~wxSafeArrayHelper();
	145
	146	bool Create(VARTYPE vt, long count); // creates and locks the array
	147
	148	bool SetElement(size_t index, const wxVariant& variant);
	149	bool SetElement(size_t index, const wxString& str);
	150
	151	SAFEARRAY* Detach(); // unlocks the array and gives up its ownership
	152
	153	private:
	154	void Unlock();
	155
	156	SAFEARRAY* m_array;
	157	};
	158
	159	wxSafeArrayHelper::wxSafeArrayHelper()
	160	{
	161	m_array = NULL;
	162	}
	163
	164	wxSafeArrayHelper::~wxSafeArrayHelper()
	165	{
	166	if ( m_array )
	167	{
	168	Unlock();
	169	SafeArrayDestroy(m_array);
	170	}
	171	}
	172
	173	bool wxSafeArrayHelper::Create(VARTYPE vt, long count)
	174	{
	175	SAFEARRAYBOUND saBound;
	176
	177	saBound.lLbound = 0;
	178	saBound.cElements = count;
	179	m_array = SafeArrayCreate(vt, 1, &saBound);
	180	if ( !m_array )
	181	return false;
	182	return SUCCEEDED( SafeArrayLock(m_array) );
	183	}
	184
	185	bool wxSafeArrayHelper::SetElement(size_t index, const wxVariant& variant)
	186	{
	187	VARIANT* data = (VARIANT*)m_array->pvData;
	188	return wxConvertVariantToOle(variant, data[index]);
	189	}
	190
	191	bool wxSafeArrayHelper::SetElement(size_t index, const wxString& str)
	192	{
	193	BSTR bstr = wxConvertStringToOle(str);
	194
	195	if ( !bstr && !str.empty() )
	196	{
	197	// BSTR can be NULL for empty strings but if the string was
	198	// not empty, it means we failed to allocate memory for it.
	199	return false;
	200	}
	201
	202	BSTR* data = (BSTR*)m_array->pvData;
	203	data[index] = bstr;
	204	return true;
	205	}
	206
	207	SAFEARRAY* wxSafeArrayHelper::Detach()
	208	{
	209	Unlock();
	210	SAFEARRAY* result = m_array;
	211	m_array = NULL;
	212	return result;
	213	}
	214
	215	void wxSafeArrayHelper::Unlock()
	216	{
	217	if ( m_array )
	218	SafeArrayUnlock(m_array);
	219	}
	220
	221	} // unnamed namespace
	222
	223
	224	WXDLLEXPORT bool wxConvertVariantToOle(const wxVariant& variant, VARIANTARG& oleVariant)
	225	{
	226	VariantInit(&oleVariant);
	227	if (variant.IsNull())
	228	{
	229	oleVariant.vt = VT_NULL;
	230	return true;
	231	}
	232
	233	wxString type(variant.GetType());
	234
	235
	236	if (type == wxT("long"))
	237	{
	238	oleVariant.vt = VT_I4;
	239	oleVariant.lVal = variant.GetLong() ;
	240	}
	241	// Original VC6 came with SDK too old to contain VARIANT::llVal declaration
	242	// and there doesn't seem to be any way to test for it as Microsoft simply
	243	// added it to the later version of oaidl.h without changing anything else.
	244	// So assume it's not present for VC6, even though it might be if an
	245	// updated SDK is used. In this case the user would need to disable this
	246	// check himself.
	247	#if wxUSE_LONGLONG && !defined(__VISUALC6__)
	248	else if (type == wxT("longlong"))
	249	{
	250	oleVariant.vt = VT_I8;
	251	oleVariant.llVal = variant.GetLongLong().GetValue();
	252	}
	253	#endif
	254	else if (type == wxT("char"))
	255	{
	256	oleVariant.vt=VT_I1; // Signed Char
	257	oleVariant.cVal=variant.GetChar();
	258	}
	259	else if (type == wxT("double"))
	260	{
	261	oleVariant.vt = VT_R8;
	262	oleVariant.dblVal = variant.GetDouble();
	263	}
	264	else if (type == wxT("bool"))
	265	{
	266	oleVariant.vt = VT_BOOL;
	267	oleVariant.boolVal = variant.GetBool() ? VARIANT_TRUE : VARIANT_FALSE;
	268	}
	269	else if (type == wxT("string"))
	270	{
	271	wxString str( variant.GetString() );
	272	oleVariant.vt = VT_BSTR;
	273	oleVariant.bstrVal = wxConvertStringToOle(str);
	274	}
	275	#if wxUSE_DATETIME
	276	else if (type == wxT("datetime"))
	277	{
	278	wxDateTime date( variant.GetDateTime() );
	279	oleVariant.vt = VT_DATE;
	280
	281	SYSTEMTIME st;
	282	date.GetAsMSWSysTime(&st);
	283
	284	SystemTimeToVariantTime(&st, &oleVariant.date);
	285	}
	286	#endif
	287	else if (type == wxT("void*"))
	288	{
	289	oleVariant.vt = VT_DISPATCH;
	290	oleVariant.pdispVal = (IDispatch*) variant.GetVoidPtr();
	291	}
	292	else if (type == wxT("list"))
	293	{
	294	wxSafeArrayHelper sah;
	295
	296	if (!sah.Create(VT_VARIANT, variant.GetCount()))
	297	return false;
	298
	299	for (size_t i = 0; i < variant.GetCount(); i++)
	300	{
	301	if (!sah.SetElement(i, variant[i]))
	302	return false;
	303	}
	304
	305	oleVariant.vt = VT_VARIANT \| VT_ARRAY;
	306	oleVariant.parray = sah.Detach();
	307	}
	308	else if (type == wxT("arrstring"))
	309	{
	310	wxArrayString strings(variant.GetArrayString());
	311	wxSafeArrayHelper sah;
	312
	313	if (!sah.Create(VT_BSTR, strings.GetCount()))
	314	return false;
	315
	316	for (size_t i = 0; i < strings.GetCount(); i++)
	317	{
	318	if (!sah.SetElement(i, strings[i]))
	319	return false;
	320	}
	321
	322	oleVariant.vt = VT_BSTR \| VT_ARRAY;
	323	oleVariant.parray = sah.Detach();
	324	}
	325	else
	326	{
	327	oleVariant.vt = VT_NULL;
	328	return false;
	329	}
	330	return true;
	331	}
	332
	333	#ifndef VT_TYPEMASK
	334	#define VT_TYPEMASK 0xfff
	335	#endif
	336
	337	WXDLLEXPORT bool
	338	wxConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant)
	339	{
	340	bool ok = true;
	341	if ( oleVariant.vt & VT_ARRAY )
	342	{
	343
	344	// Compute the total number of elements in all array dimensions
	345	int cElements = 1;
	346	for ( int cDims = 0; cDims < oleVariant.parray->cDims; cDims++ )
	347	cElements *= oleVariant.parray->rgsabound[cDims].cElements;
	348
	349	// Get a pointer to the data
	350	void* pvdata;
	351	HRESULT hr = SafeArrayAccessData(oleVariant.parray, &pvdata);
	352	if ( FAILED(hr) )
	353	return false;
	354
	355	switch (oleVariant.vt & VT_TYPEMASK)
	356	{
	357	case VT_VARIANT:
	358	{
	359	variant.ClearList();
	360	VARIANTARG variant_data=(VARIANTARG)pvdata;
	361	for ( int i = 0; i < cElements; i++ )
	362	{
	363	VARIANTARG& oleElement = variant_data[i];
	364	wxVariant vElement;
	365	if ( !wxConvertOleToVariant(oleElement, vElement) )
	366	{
	367	ok = false;
	368	variant.ClearList();
	369	break;
	370	}
	371
	372	variant.Append(vElement);
	373	}
	374	}
	375	break;
	376
	377	case VT_BSTR:
	378	{
	379	wxArrayString strings;
	380	BSTR string_val=(BSTR)pvdata;
	381	for ( int i = 0; i < cElements; ++i )
	382	{
	383	wxString str=wxConvertStringFromOle(*string_val);
	384	strings.Add(str);
	385	++string_val;
	386	}
	387	variant=strings;
	388	}
	389	break;
	390
	391	default:
	392	wxLogDebug(wxT("unhandled VT_ARRAY type %x in wxConvertOleToVariant"),
	393	oleVariant.vt & VT_TYPEMASK);
	394	variant = wxVariant();
	395	ok = false;
	396	break;
	397	}
	398
	399	SafeArrayUnaccessData(oleVariant.parray);
	400	}
	401	else if ( oleVariant.vt & VT_BYREF )
	402	{
	403	switch ( oleVariant.vt & VT_TYPEMASK )
	404	{
	405	case VT_VARIANT:
	406	{
	407	VARIANTARG& oleReference = *((LPVARIANT)oleVariant.byref);
	408	if (!wxConvertOleToVariant(oleReference,variant))
	409	return false;
	410	break;
	411	}
	412
	413	default:
	414	wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: [as yet] unhandled reference %X"),
	415	oleVariant.vt);
	416	return false;
	417	}
	418	}
	419	else // simply type (not array or reference)
	420	{
	421	switch ( oleVariant.vt & VT_TYPEMASK )
	422	{
	423	case VT_BSTR:
	424	{
	425	wxString str(wxConvertStringFromOle(oleVariant.bstrVal));
	426	variant = str;
	427	}
	428	break;
	429
	430	case VT_DATE:
	431	#if wxUSE_DATETIME
	432	{
	433	SYSTEMTIME st;
	434	VariantTimeToSystemTime(oleVariant.date, &st);
	435
	436	wxDateTime date;
	437	date.SetFromMSWSysTime(st);
	438	variant = date;
	439	}
	440	#endif // wxUSE_DATETIME
	441	break;
	442
	443	// See the comment before the __VISUALC6__ test above.
	444	#if wxUSE_LONGLONG && !defined(__VISUALC6__)
	445	case VT_I8:
	446	variant = wxLongLong(oleVariant.llVal);
	447	break;
	448	#endif // wxUSE_LONGLONG
	449
	450	case VT_I4:
	451	variant = (long) oleVariant.lVal;
	452	break;
	453
	454	case VT_I2:
	455	variant = (long) oleVariant.iVal;
	456	break;
	457
	458	case VT_BOOL:
	459	variant = oleVariant.boolVal != 0;
	460	break;
	461
	462	case VT_R4:
	463	variant = oleVariant.fltVal;
	464	break;
	465
	466	case VT_R8:
	467	variant = oleVariant.dblVal;
	468	break;
	469
	470	case VT_DISPATCH:
	471	variant = (void*) oleVariant.pdispVal;
	472	break;
	473
	474	case VT_NULL:
	475	variant.MakeNull();
	476	break;
	477
	478	case VT_EMPTY:
	479	break; // Ignore Empty Variant, used only during destruction of objects
	480
	481	default:
	482	wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: Unknown variant value type %X -> %X"),
	483	oleVariant.vt,oleVariant.vt&VT_TYPEMASK);
	484	return false;
	485	}
	486	}
	487
	488	return ok;
	489	}
	490
	491	#endif // wxUSE_VARIANT
	492
	493
	494	// ----------------------------------------------------------------------------
	495	// Debug support
	496	// ----------------------------------------------------------------------------
	497
	498	#if wxUSE_DATAOBJ
	499
	500	#if wxDEBUG_LEVEL && (( defined(__VISUALC__) && (__VISUALC__ > 1000) ))
	501	static wxString GetIidName(REFIID riid)
	502	{
	503	// an association between symbolic name and numeric value of an IID
	504	struct KNOWN_IID {
	505	const IID *pIid;
	506	const wxChar *szName;
	507	};
	508
	509	// construct the table containing all known interfaces
	510	#define ADD_KNOWN_IID(name) { &IID_I##name, wxT(#name) }
	511
	512	static const KNOWN_IID aKnownIids[] = {
	513	ADD_KNOWN_IID(AdviseSink),
	514	ADD_KNOWN_IID(AdviseSink2),
	515	ADD_KNOWN_IID(BindCtx),
	516	ADD_KNOWN_IID(ClassFactory),
	517	#if ( !defined( __VISUALC__) \|\| (__VISUALC__!=1010) )
	518	ADD_KNOWN_IID(ContinueCallback),
	519	ADD_KNOWN_IID(EnumOleDocumentViews),
	520	ADD_KNOWN_IID(OleCommandTarget),
	521	ADD_KNOWN_IID(OleDocument),
	522	ADD_KNOWN_IID(OleDocumentSite),
	523	ADD_KNOWN_IID(OleDocumentView),
	524	ADD_KNOWN_IID(Print),
	525	#endif
	526	ADD_KNOWN_IID(DataAdviseHolder),
	527	ADD_KNOWN_IID(DataObject),
	528	ADD_KNOWN_IID(Debug),
	529	ADD_KNOWN_IID(DebugStream),
	530	ADD_KNOWN_IID(DfReserved1),
	531	ADD_KNOWN_IID(DfReserved2),
	532	ADD_KNOWN_IID(DfReserved3),
	533	ADD_KNOWN_IID(Dispatch),
	534	ADD_KNOWN_IID(DropSource),
	535	ADD_KNOWN_IID(DropTarget),
	536	ADD_KNOWN_IID(EnumCallback),
	537	ADD_KNOWN_IID(EnumFORMATETC),
	538	ADD_KNOWN_IID(EnumGeneric),
	539	ADD_KNOWN_IID(EnumHolder),
	540	ADD_KNOWN_IID(EnumMoniker),
	541	ADD_KNOWN_IID(EnumOLEVERB),
	542	ADD_KNOWN_IID(EnumSTATDATA),
	543	ADD_KNOWN_IID(EnumSTATSTG),
	544	ADD_KNOWN_IID(EnumString),
	545	ADD_KNOWN_IID(EnumUnknown),
	546	ADD_KNOWN_IID(EnumVARIANT),
	547	ADD_KNOWN_IID(ExternalConnection),
	548	ADD_KNOWN_IID(InternalMoniker),
	549	ADD_KNOWN_IID(LockBytes),
	550	ADD_KNOWN_IID(Malloc),
	551	ADD_KNOWN_IID(Marshal),
	552	ADD_KNOWN_IID(MessageFilter),
	553	ADD_KNOWN_IID(Moniker),
	554	ADD_KNOWN_IID(OleAdviseHolder),
	555	ADD_KNOWN_IID(OleCache),
	556	ADD_KNOWN_IID(OleCache2),
	557	ADD_KNOWN_IID(OleCacheControl),
	558	ADD_KNOWN_IID(OleClientSite),
	559	ADD_KNOWN_IID(OleContainer),
	560	ADD_KNOWN_IID(OleInPlaceActiveObject),
	561	ADD_KNOWN_IID(OleInPlaceFrame),
	562	ADD_KNOWN_IID(OleInPlaceObject),
	563	ADD_KNOWN_IID(OleInPlaceSite),
	564	ADD_KNOWN_IID(OleInPlaceUIWindow),
	565	ADD_KNOWN_IID(OleItemContainer),
	566	ADD_KNOWN_IID(OleLink),
	567	ADD_KNOWN_IID(OleManager),
	568	ADD_KNOWN_IID(OleObject),
	569	ADD_KNOWN_IID(OlePresObj),
	570	ADD_KNOWN_IID(OleWindow),
	571	ADD_KNOWN_IID(PSFactory),
	572	ADD_KNOWN_IID(ParseDisplayName),
	573	ADD_KNOWN_IID(Persist),
	574	ADD_KNOWN_IID(PersistFile),
	575	ADD_KNOWN_IID(PersistStorage),
	576	ADD_KNOWN_IID(PersistStream),
	577	ADD_KNOWN_IID(ProxyManager),
	578	ADD_KNOWN_IID(RootStorage),
	579	ADD_KNOWN_IID(RpcChannel),
	580	ADD_KNOWN_IID(RpcProxy),
	581	ADD_KNOWN_IID(RpcStub),
	582	ADD_KNOWN_IID(RunnableObject),
	583	ADD_KNOWN_IID(RunningObjectTable),
	584	ADD_KNOWN_IID(StdMarshalInfo),
	585	ADD_KNOWN_IID(Storage),
	586	ADD_KNOWN_IID(Stream),
	587	ADD_KNOWN_IID(StubManager),
	588	ADD_KNOWN_IID(Unknown),
	589	ADD_KNOWN_IID(ViewObject),
	590	ADD_KNOWN_IID(ViewObject2),
	591	};
	592
	593	// don't clobber preprocessor name space
	594	#undef ADD_KNOWN_IID
	595
	596	// try to find the interface in the table
	597	for ( size_t ui = 0; ui < WXSIZEOF(aKnownIids); ui++ ) {
	598	if ( riid == *aKnownIids[ui].pIid ) {
	599	return aKnownIids[ui].szName;
	600	}
	601	}
	602
	603	#ifndef __WXWINCE__
	604	// unknown IID, just transform to string
	605	Uuid uuid(riid);
	606	return wxString((const wxChar *)uuid);
	607	#else
	608	return wxEmptyString;
	609	#endif
	610	}
	611
	612	WXDLLEXPORT void wxLogQueryInterface(const wxChar *szInterface, REFIID riid)
	613	{
	614	wxLogTrace(wxTRACE_OleCalls, wxT("%s::QueryInterface (iid = %s)"),
	615	szInterface, GetIidName(riid).c_str());
	616	}
	617
	618	WXDLLEXPORT void wxLogAddRef(const wxChar *szInterface, ULONG cRef)
	619	{
	620	wxLogTrace(wxTRACE_OleCalls, wxT("After %s::AddRef: m_cRef = %d"), szInterface, cRef + 1);
	621	}
	622
	623	WXDLLEXPORT void wxLogRelease(const wxChar *szInterface, ULONG cRef)
	624	{
	625	wxLogTrace(wxTRACE_OleCalls, wxT("After %s::Release: m_cRef = %d"), szInterface, cRef - 1);
	626	}
	627
	628	#endif // wxDEBUG_LEVEL
	629
	630	#endif // wxUSE_DATAOBJ
	631
	632	#endif // __CYGWIN10__
	633
	634	#endif // wxUSE_OLE