src/msw/ole/oleutils.cpp

   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 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 WXDLLEXPORT bool wxConvertVariantToOle(const wxVariant& variant, VARIANTARG& oleVariant)
 135 {
 136     VariantInit(&oleVariant);
 137     if (variant.IsNull())
 138     {
 139         oleVariant.vt = VT_NULL;
 140         return true;
 141     }
 142
 143     wxString type(variant.GetType());
 144
 145
 146     if (type == wxT("long"))
 147     {
 148         oleVariant.vt = VT_I4;
 149         oleVariant.lVal = variant.GetLong() ;
 150     }
 151     else if (type == wxT("char"))
 152     {
 153         oleVariant.vt=VT_I1;            // Signed Char
 154         oleVariant.cVal=variant.GetChar();
 155     }
 156     else if (type == wxT("double"))
 157     {
 158         oleVariant.vt = VT_R8;
 159         oleVariant.dblVal = variant.GetDouble();
 160     }
 161     else if (type == wxT("bool"))
 162     {
 163         oleVariant.vt = VT_BOOL;
 164         oleVariant.boolVal = variant.GetBool();
 165     }
 166     else if (type == wxT("string"))
 167     {
 168         wxString str( variant.GetString() );
 169         oleVariant.vt = VT_BSTR;
 170         oleVariant.bstrVal = wxConvertStringToOle(str);
 171     }
 172 #if wxUSE_DATETIME
 173     else if (type == wxT("datetime"))
 174     {
 175         wxDateTime date( variant.GetDateTime() );
 176         oleVariant.vt = VT_DATE;
 177
 178         SYSTEMTIME st;
 179         date.GetAsMSWSysTime(&st);
 180
 181         SystemTimeToVariantTime(&st, &oleVariant.date);
 182     }
 183 #endif
 184     else if (type == wxT("void*"))
 185     {
 186         oleVariant.vt = VT_DISPATCH;
 187         oleVariant.pdispVal = (IDispatch*) variant.GetVoidPtr();
 188     }
 189     else if (type == wxT("list") || type == wxT("stringlist"))
 190     {
 191         oleVariant.vt = VT_VARIANT | VT_ARRAY;
 192
 193         SAFEARRAY *psa;
 194         SAFEARRAYBOUND saBound;
 195         VARIANTARG *pvargBase;
 196         VARIANTARG *pvarg;
 197         int i, j;
 198
 199         int iCount = variant.GetCount();
 200
 201         saBound.lLbound = 0;
 202         saBound.cElements = iCount;
 203
 204         psa = SafeArrayCreate(VT_VARIANT, 1, &saBound);
 205         if (psa == NULL)
 206             return false;
 207
 208         SafeArrayAccessData(psa, (void**)&pvargBase);
 209
 210         pvarg = pvargBase;
 211         for (i = 0; i < iCount; i++)
 212         {
 213             // copy each string in the list of strings
 214             wxVariant eachVariant(variant[i]);
 215             if (!wxConvertVariantToOle(eachVariant, * pvarg))
 216             {
 217                 // memory failure:  back out and free strings alloc'ed up to
 218                 // now, and then the array itself.
 219                 pvarg = pvargBase;
 220                 for (j = 0; j < i; j++)
 221                 {
 222                     SysFreeString(pvarg->bstrVal);
 223                     pvarg++;
 224                 }
 225                 SafeArrayDestroy(psa);
 226                 return false;
 227             }
 228             pvarg++;
 229         }
 230
 231         SafeArrayUnaccessData(psa);
 232
 233         oleVariant.parray = psa;
 234     }
 235     else
 236     {
 237         oleVariant.vt = VT_NULL;
 238         return false;
 239     }
 240     return true;
 241 }
 242
 243 #ifndef VT_TYPEMASK
 244 #define VT_TYPEMASK 0xfff
 245 #endif
 246
 247 WXDLLEXPORT bool
 248 wxConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant)
 249 {
 250     bool ok = true;
 251     if ( oleVariant.vt & VT_ARRAY )
 252     {
 253
 254         // Compute the total number of elements in all array dimensions
 255         int cElements = 1;
 256         for ( int cDims = 0; cDims < oleVariant.parray->cDims; cDims++ )
 257             cElements *= oleVariant.parray->rgsabound[cDims].cElements;
 258
 259         // Get a pointer to the data
 260         void* pvdata;
 261         HRESULT hr = SafeArrayAccessData(oleVariant.parray, &pvdata);
 262         if ( FAILED(hr) )
 263             return false;
 264
 265         switch (oleVariant.vt & VT_TYPEMASK)
 266         {
 267             case VT_VARIANT:
 268                 {
 269                     variant.ClearList();
 270                     VARIANTARG *variant_data=(VARIANTARG*)pvdata;
 271                     for ( int i = 0; i < cElements; i++ )
 272                     {
 273                         VARIANTARG& oleElement = variant_data[i];
 274                         wxVariant vElement;
 275                         if ( !wxConvertOleToVariant(oleElement, vElement) )
 276                         {
 277                             ok = false;
 278                             variant.ClearList();
 279                             break;
 280                         }
 281
 282                         variant.Append(vElement);
 283                     }
 284                 }
 285                 break;
 286
 287             case VT_BSTR:
 288                 {
 289                     wxArrayString strings;
 290                     BSTR *string_val=(BSTR*)pvdata;
 291                     for ( int i = 0; i < cElements; ++i )
 292                     {
 293                         wxString str=wxConvertStringFromOle(*string_val);
 294                         strings.Add(str);
 295                         ++string_val;
 296                     }
 297                     variant=strings;
 298                 }
 299                 break;
 300
 301             default:
 302                 wxLogDebug(wxT("unhandled VT_ARRAY type %x in wxConvertOleToVariant"),
 303                            oleVariant.vt & VT_TYPEMASK);
 304                 variant = wxVariant();
 305                 ok = false;
 306                 break;
 307         }
 308
 309         SafeArrayUnaccessData(oleVariant.parray);
 310     }
 311     else if ( oleVariant.vt & VT_BYREF )
 312     {
 313         switch ( oleVariant.vt & VT_TYPEMASK )
 314         {
 315             case VT_VARIANT:
 316                 {
 317                     VARIANTARG& oleReference = *((LPVARIANT)oleVariant.byref);
 318                     if (!wxConvertOleToVariant(oleReference,variant))
 319                         return false;
 320                     break;
 321                 }
 322
 323             default:
 324                 wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: [as yet] unhandled reference %X"),
 325                             oleVariant.vt);
 326                 return false;
 327         }
 328     }
 329     else // simply type (not array or reference)
 330     {
 331         switch ( oleVariant.vt & VT_TYPEMASK )
 332         {
 333             case VT_BSTR:
 334                 {
 335                     wxString str(wxConvertStringFromOle(oleVariant.bstrVal));
 336                     variant = str;
 337                 }
 338                 break;
 339
 340             case VT_DATE:
 341 #if wxUSE_DATETIME
 342                 {
 343                     SYSTEMTIME st;
 344                     VariantTimeToSystemTime(oleVariant.date, &st);
 345
 346                     wxDateTime date;
 347                     date.SetFromMSWSysTime(st);
 348                     variant = date;
 349                 }
 350 #endif // wxUSE_DATETIME
 351                 break;
 352
 353             case VT_I4:
 354                 variant = (long) oleVariant.lVal;
 355                 break;
 356
 357             case VT_I2:
 358                 variant = (long) oleVariant.iVal;
 359                 break;
 360
 361             case VT_BOOL:
 362                 variant = oleVariant.boolVal != 0;
 363                 break;
 364
 365             case VT_R8:
 366                 variant = oleVariant.dblVal;
 367                 break;
 368
 369             case VT_DISPATCH:
 370                 variant = (void*) oleVariant.pdispVal;
 371                 break;
 372
 373             case VT_NULL:
 374                 variant.MakeNull();
 375                 break;
 376
 377             case VT_EMPTY:
 378                 break;    // Ignore Empty Variant, used only during destruction of objects
 379
 380             default:
 381                 wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: Unknown variant value type %X -> %X"),
 382                            oleVariant.vt,oleVariant.vt&VT_TYPEMASK);
 383                 return false;
 384         }
 385     }
 386
 387     return ok;
 388 }
 389
 390 #endif // wxUSE_VARIANT
 391
 392
 393 // ----------------------------------------------------------------------------
 394 // Debug support
 395 // ----------------------------------------------------------------------------
 396
 397 #if wxUSE_DATAOBJ
 398
 399 #if wxDEBUG_LEVEL && ( ( defined(__VISUALC__) && (__VISUALC__ > 1000) ) || defined(__MWERKS__) )
 400 static wxString GetIidName(REFIID riid)
 401 {
 402   // an association between symbolic name and numeric value of an IID
 403   struct KNOWN_IID {
 404     const IID  *pIid;
 405     const wxChar *szName;
 406   };
 407
 408   // construct the table containing all known interfaces
 409   #define ADD_KNOWN_IID(name) { &IID_I##name, wxT(#name) }
 410
 411   static const KNOWN_IID aKnownIids[] = {
 412     ADD_KNOWN_IID(AdviseSink),
 413     ADD_KNOWN_IID(AdviseSink2),
 414     ADD_KNOWN_IID(BindCtx),
 415     ADD_KNOWN_IID(ClassFactory),
 416 #if ( !defined( __VISUALC__) || (__VISUALC__!=1010) ) && !defined(__MWERKS__)
 417     ADD_KNOWN_IID(ContinueCallback),
 418     ADD_KNOWN_IID(EnumOleDocumentViews),
 419     ADD_KNOWN_IID(OleCommandTarget),
 420     ADD_KNOWN_IID(OleDocument),
 421     ADD_KNOWN_IID(OleDocumentSite),
 422     ADD_KNOWN_IID(OleDocumentView),
 423     ADD_KNOWN_IID(Print),
 424 #endif
 425     ADD_KNOWN_IID(DataAdviseHolder),
 426     ADD_KNOWN_IID(DataObject),
 427     ADD_KNOWN_IID(Debug),
 428     ADD_KNOWN_IID(DebugStream),
 429     ADD_KNOWN_IID(DfReserved1),
 430     ADD_KNOWN_IID(DfReserved2),
 431     ADD_KNOWN_IID(DfReserved3),
 432     ADD_KNOWN_IID(Dispatch),
 433     ADD_KNOWN_IID(DropSource),
 434     ADD_KNOWN_IID(DropTarget),
 435     ADD_KNOWN_IID(EnumCallback),
 436     ADD_KNOWN_IID(EnumFORMATETC),
 437     ADD_KNOWN_IID(EnumGeneric),
 438     ADD_KNOWN_IID(EnumHolder),
 439     ADD_KNOWN_IID(EnumMoniker),
 440     ADD_KNOWN_IID(EnumOLEVERB),
 441     ADD_KNOWN_IID(EnumSTATDATA),
 442     ADD_KNOWN_IID(EnumSTATSTG),
 443     ADD_KNOWN_IID(EnumString),
 444     ADD_KNOWN_IID(EnumUnknown),
 445     ADD_KNOWN_IID(EnumVARIANT),
 446     ADD_KNOWN_IID(ExternalConnection),
 447     ADD_KNOWN_IID(InternalMoniker),
 448     ADD_KNOWN_IID(LockBytes),
 449     ADD_KNOWN_IID(Malloc),
 450     ADD_KNOWN_IID(Marshal),
 451     ADD_KNOWN_IID(MessageFilter),
 452     ADD_KNOWN_IID(Moniker),
 453     ADD_KNOWN_IID(OleAdviseHolder),
 454     ADD_KNOWN_IID(OleCache),
 455     ADD_KNOWN_IID(OleCache2),
 456     ADD_KNOWN_IID(OleCacheControl),
 457     ADD_KNOWN_IID(OleClientSite),
 458     ADD_KNOWN_IID(OleContainer),
 459     ADD_KNOWN_IID(OleInPlaceActiveObject),
 460     ADD_KNOWN_IID(OleInPlaceFrame),
 461     ADD_KNOWN_IID(OleInPlaceObject),
 462     ADD_KNOWN_IID(OleInPlaceSite),
 463     ADD_KNOWN_IID(OleInPlaceUIWindow),
 464     ADD_KNOWN_IID(OleItemContainer),
 465     ADD_KNOWN_IID(OleLink),
 466     ADD_KNOWN_IID(OleManager),
 467     ADD_KNOWN_IID(OleObject),
 468     ADD_KNOWN_IID(OlePresObj),
 469     ADD_KNOWN_IID(OleWindow),
 470     ADD_KNOWN_IID(PSFactory),
 471     ADD_KNOWN_IID(ParseDisplayName),
 472     ADD_KNOWN_IID(Persist),
 473     ADD_KNOWN_IID(PersistFile),
 474     ADD_KNOWN_IID(PersistStorage),
 475     ADD_KNOWN_IID(PersistStream),
 476     ADD_KNOWN_IID(ProxyManager),
 477     ADD_KNOWN_IID(RootStorage),
 478     ADD_KNOWN_IID(RpcChannel),
 479     ADD_KNOWN_IID(RpcProxy),
 480     ADD_KNOWN_IID(RpcStub),
 481     ADD_KNOWN_IID(RunnableObject),
 482     ADD_KNOWN_IID(RunningObjectTable),
 483     ADD_KNOWN_IID(StdMarshalInfo),
 484     ADD_KNOWN_IID(Storage),
 485     ADD_KNOWN_IID(Stream),
 486     ADD_KNOWN_IID(StubManager),
 487     ADD_KNOWN_IID(Unknown),
 488     ADD_KNOWN_IID(ViewObject),
 489     ADD_KNOWN_IID(ViewObject2),
 490   };
 491
 492   // don't clobber preprocessor name space
 493   #undef ADD_KNOWN_IID
 494
 495   // try to find the interface in the table
 496   for ( size_t ui = 0; ui < WXSIZEOF(aKnownIids); ui++ ) {
 497     if ( riid == *aKnownIids[ui].pIid ) {
 498       return aKnownIids[ui].szName;
 499     }
 500   }
 501
 502 #ifndef __WXWINCE__
 503   // unknown IID, just transform to string
 504   Uuid uuid(riid);
 505   return wxString((const wxChar *)uuid);
 506 #else
 507   return wxEmptyString;
 508 #endif
 509 }
 510
 511 void wxLogQueryInterface(const wxChar *szInterface, REFIID riid)
 512 {
 513   wxLogTrace(wxTRACE_OleCalls, wxT("%s::QueryInterface (iid = %s)"),
 514              szInterface, GetIidName(riid).c_str());
 515 }
 516
 517 void wxLogAddRef(const wxChar *szInterface, ULONG cRef)
 518 {
 519   wxLogTrace(wxTRACE_OleCalls, wxT("After %s::AddRef: m_cRef = %d"), szInterface, cRef + 1);
 520 }
 521
 522 void wxLogRelease(const wxChar *szInterface, ULONG cRef)
 523 {
 524   wxLogTrace(wxTRACE_OleCalls, wxT("After %s::Release: m_cRef = %d"), szInterface, cRef - 1);
 525 }
 526
 527 #endif  // wxDEBUG_LEVEL
 528
 529 #endif // wxUSE_DATAOBJ
 530
 531 #endif // __CYGWIN10__
 532
 533 #endif // wxUSE_OLE