wxPython/contrib/iewin/wxactivex.cpp

   1 #include "wxActiveX.h"
   2 #include <wx/strconv.h>
   3 #include <wx/msw/ole/uuid.h>
   4 #include <oleidl.h>
   5 #include <winerror.h>
   6 #include <idispids.h>
   7 #include <exdispid.h>
   8 #include <olectl.h>
   9 #include <Mshtml.h>
  10 #include <sstream>
  11 using namespace std;
  12
  13 // Depending on compilation mode, the wx headers may have undef'd
  14 // this, but in this case we need it so the virtual method in
  15 // FrameSite will match what is in oleidl.h.
  16 #ifndef GetObject
  17     #ifdef _UNICODE
  18         #define GetObject GetObjectW
  19     #else
  20         #define GetObject GetObjectA
  21     #endif
  22 #endif
  23
  24 //////////////////////////////////////////////////////////////////////
  25 BEGIN_EVENT_TABLE(wxActiveX, wxWindow)
  26         EVT_SIZE(OnSize)
  27         EVT_SET_FOCUS(OnSetFocus)
  28         EVT_KILL_FOCUS(OnKillFocus)
  29 END_EVENT_TABLE()
  30
  31 class wxActiveX;
  32
  33 class FrameSite :
  34     public IOleClientSite,
  35     public IOleInPlaceSiteEx,
  36     public IOleInPlaceFrame,
  37     public IOleItemContainer,
  38     public IDispatch,
  39     public IOleCommandTarget,
  40     public IOleDocumentSite,
  41     public IAdviseSink,
  42     public IOleControlSite
  43 {
  44 private:
  45     DECLARE_OLE_UNKNOWN(FrameSite);
  46
  47 public:
  48         FrameSite(wxActiveX * win);
  49         ~FrameSite();
  50
  51         //IOleWindow
  52         STDMETHODIMP GetWindow(HWND*);
  53         STDMETHODIMP ContextSensitiveHelp(BOOL);
  54
  55     //IOleInPlaceUIWindow
  56         STDMETHODIMP GetBorder(LPRECT);
  57         STDMETHODIMP RequestBorderSpace(LPCBORDERWIDTHS);
  58         STDMETHODIMP SetBorderSpace(LPCBORDERWIDTHS);
  59         STDMETHODIMP SetActiveObject(IOleInPlaceActiveObject*, LPCOLESTR);
  60
  61     //IOleInPlaceFrame
  62         STDMETHODIMP InsertMenus(HMENU, LPOLEMENUGROUPWIDTHS);
  63         STDMETHODIMP SetMenu(HMENU, HOLEMENU, HWND);
  64         STDMETHODIMP RemoveMenus(HMENU);
  65         STDMETHODIMP SetStatusText(LPCOLESTR);
  66         STDMETHODIMP EnableModeless(BOOL);
  67         STDMETHODIMP TranslateAccelerator(LPMSG, WORD);
  68
  69         //IOleInPlaceSite
  70         STDMETHODIMP CanInPlaceActivate();
  71         STDMETHODIMP OnInPlaceActivate();
  72         STDMETHODIMP OnUIActivate();
  73         STDMETHODIMP GetWindowContext(IOleInPlaceFrame**, IOleInPlaceUIWindow**,
  74                 LPRECT, LPRECT, LPOLEINPLACEFRAMEINFO);
  75         STDMETHODIMP Scroll(SIZE);
  76         STDMETHODIMP OnUIDeactivate(BOOL);
  77         STDMETHODIMP OnInPlaceDeactivate();
  78         STDMETHODIMP DiscardUndoState();
  79         STDMETHODIMP DeactivateAndUndo();
  80         STDMETHODIMP OnPosRectChange(LPCRECT);
  81
  82     //IOleInPlaceSiteEx
  83         STDMETHODIMP OnInPlaceActivateEx(BOOL*, DWORD);
  84         STDMETHODIMP OnInPlaceDeactivateEx(BOOL);
  85         STDMETHODIMP RequestUIActivate();
  86
  87         //IOleClientSite
  88         STDMETHODIMP SaveObject();
  89         STDMETHODIMP GetMoniker(DWORD, DWORD, IMoniker**);
  90         STDMETHODIMP GetContainer(LPOLECONTAINER FAR*);
  91         STDMETHODIMP ShowObject();
  92         STDMETHODIMP OnShowWindow(BOOL);
  93         STDMETHODIMP RequestNewObjectLayout();
  94
  95         //IOleControlSite
  96         STDMETHODIMP OnControlInfoChanged();
  97         STDMETHODIMP LockInPlaceActive(BOOL);
  98         STDMETHODIMP GetExtendedControl(IDispatch**);
  99         STDMETHODIMP TransformCoords(POINTL*, POINTF*, DWORD);
 100         STDMETHODIMP TranslateAccelerator(LPMSG, DWORD);
 101         STDMETHODIMP OnFocus(BOOL);
 102         STDMETHODIMP ShowPropertyFrame();
 103
 104         //IOleCommandTarget
 105         STDMETHODIMP QueryStatus(const GUID*, ULONG, OLECMD[], OLECMDTEXT*);
 106         STDMETHODIMP Exec(const GUID*, DWORD, DWORD, VARIANTARG*, VARIANTARG*);
 107
 108         //IParseDisplayName
 109         STDMETHODIMP ParseDisplayName(IBindCtx*, LPOLESTR, ULONG*, IMoniker**);
 110
 111     //IOleContainer
 112         STDMETHODIMP EnumObjects(DWORD, IEnumUnknown**);
 113         STDMETHODIMP LockContainer(BOOL);
 114
 115         //IOleItemContainer
 116         STDMETHODIMP GetObject(LPOLESTR, DWORD, IBindCtx*, REFIID, void**);
 117         STDMETHODIMP GetObjectStorage(LPOLESTR, IBindCtx*, REFIID, void**);
 118         STDMETHODIMP IsRunning(LPOLESTR);
 119
 120         //IDispatch
 121         STDMETHODIMP GetIDsOfNames(REFIID, OLECHAR**, unsigned int, LCID, DISPID*);
 122         STDMETHODIMP GetTypeInfo(unsigned int, LCID, ITypeInfo**);
 123         STDMETHODIMP GetTypeInfoCount(unsigned int*);
 124         STDMETHODIMP Invoke(DISPID, REFIID, LCID, WORD, DISPPARAMS*, VARIANT*, EXCEPINFO*, UINT*);
 125
 126         //IAdviseSink
 127         void STDMETHODCALLTYPE OnDataChange(FORMATETC*, STGMEDIUM*);
 128         void STDMETHODCALLTYPE OnViewChange(DWORD, LONG);
 129         void STDMETHODCALLTYPE OnRename(IMoniker*);
 130         void STDMETHODCALLTYPE OnSave();
 131         void STDMETHODCALLTYPE OnClose();
 132
 133     // IOleDocumentSite
 134         HRESULT STDMETHODCALLTYPE ActivateMe(IOleDocumentView __RPC_FAR *pViewToActivate);
 135
 136 protected:
 137
 138         wxActiveX * m_window;
 139
 140         HDC m_hDCBuffer;
 141         HWND m_hWndParent;
 142
 143         bool m_bSupportsWindowlessActivation;
 144         bool m_bInPlaceLocked;
 145         bool m_bInPlaceActive;
 146         bool m_bUIActive;
 147         bool m_bWindowless;
 148
 149
 150
 151         LCID m_nAmbientLocale;
 152         COLORREF m_clrAmbientForeColor;
 153         COLORREF m_clrAmbientBackColor;
 154         bool m_bAmbientShowHatching;
 155         bool m_bAmbientShowGrabHandles;
 156         bool m_bAmbientAppearance;
 157 };
 158
 159 DEFINE_OLE_TABLE(FrameSite)
 160     OLE_INTERFACE(IID_IUnknown, IOleClientSite)
 161
 162     OLE_IINTERFACE(IOleClientSite)
 163
 164     OLE_INTERFACE(IID_IOleWindow, IOleInPlaceSite)
 165     OLE_IINTERFACE(IOleInPlaceSite)
 166     OLE_IINTERFACE(IOleInPlaceSiteEx)
 167
 168     //OLE_IINTERFACE(IOleWindow)
 169     OLE_IINTERFACE(IOleInPlaceUIWindow)
 170     OLE_IINTERFACE(IOleInPlaceFrame)
 171
 172     OLE_IINTERFACE(IParseDisplayName)
 173     OLE_IINTERFACE(IOleContainer)
 174     OLE_IINTERFACE(IOleItemContainer)
 175
 176     OLE_IINTERFACE(IDispatch)
 177
 178     OLE_IINTERFACE(IOleCommandTarget)
 179
 180     OLE_IINTERFACE(IOleDocumentSite)
 181
 182     OLE_IINTERFACE(IAdviseSink)
 183
 184     OLE_IINTERFACE(IOleControlSite)
 185 END_OLE_TABLE;
 186
 187
 188 wxActiveX::wxActiveX(wxWindow * parent, REFCLSID clsid, wxWindowID id,
 189               const wxPoint& pos,
 190               const wxSize& size,
 191               long style,
 192               const wxString& name) :
 193         wxWindow(parent, id, pos, size, style, name)
 194 {
 195         m_bAmbientUserMode = true;
 196     m_docAdviseCookie = 0;
 197         CreateActiveX(clsid);
 198 }
 199
 200 wxActiveX::wxActiveX(wxWindow * parent, wxString progId, wxWindowID id,
 201               const wxPoint& pos,
 202               const wxSize& size,
 203               long style,
 204               const wxString& name) :
 205         wxWindow(parent, id, pos, size, style, name)
 206 {
 207         m_bAmbientUserMode = true;
 208     m_docAdviseCookie = 0;
 209         CreateActiveX((LPOLESTR) wxConvUTF8.cMB2WC(progId).data());
 210 }
 211
 212 wxActiveX::~wxActiveX()
 213 {
 214         // disconnect connection points
 215         wxOleConnectionArray::iterator it = m_connections.begin();
 216         while (it != m_connections.end())
 217         {
 218                 wxOleConnectionPoint& cp = it->first;
 219                 cp->Unadvise(it->second);
 220
 221                 it++;
 222         };
 223         m_connections.clear();
 224
 225     if (m_oleInPlaceObject.Ok())
 226         {
 227                 m_oleInPlaceObject->InPlaceDeactivate();
 228                 m_oleInPlaceObject->UIDeactivate();
 229         }
 230
 231
 232         if (m_oleObject.Ok())
 233         {
 234             if (m_docAdviseCookie != 0)
 235                 m_oleObject->Unadvise(m_docAdviseCookie);
 236
 237             m_oleObject->DoVerb(OLEIVERB_HIDE, NULL, m_clientSite, 0, (HWND) GetHWND(), NULL);
 238         m_oleObject->Close(OLECLOSE_NOSAVE);
 239                 m_oleObject->SetClientSite(NULL);
 240         }
 241 }
 242
 243 void wxActiveX::CreateActiveX(REFCLSID clsid)
 244 {
 245         SetTransparent();
 246
 247         HRESULT hret;
 248
 249     ////////////////////////////////////////////////////////
 250         // FrameSite
 251     FrameSite *frame = new FrameSite(this);
 252     // oleClientSite
 253     hret = m_clientSite.QueryInterface(IID_IOleClientSite, (IDispatch *) frame);
 254     wxASSERT(SUCCEEDED(hret));
 255     // adviseSink
 256     wxAutoOleInterface<IAdviseSink> adviseSink(IID_IAdviseSink, (IDispatch *) frame);
 257     wxASSERT(adviseSink.Ok());
 258
 259
 260
 261
 262         // // Create Object, get IUnknown interface
 263     m_ActiveX.CreateInstance(clsid, IID_IUnknown);
 264         wxASSERT(m_ActiveX.Ok());
 265
 266         // Get IOleObject interface
 267         hret = m_oleObject.QueryInterface(IID_IOleObject, m_ActiveX);
 268         wxASSERT(SUCCEEDED(hret));
 269         // Get IOleInPlaceObject interface
 270         hret = m_oleInPlaceObject.QueryInterface(IID_IOleInPlaceObject, m_ActiveX);
 271         wxASSERT(SUCCEEDED(hret));
 272
 273     // status
 274         DWORD dwMiscStatus;
 275         m_oleObject->GetMiscStatus(DVASPECT_CONTENT, &dwMiscStatus);
 276     wxASSERT(SUCCEEDED(hret));
 277
 278     // set client site first ?
 279     if (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST)
 280                 m_oleObject->SetClientSite(m_clientSite);
 281
 282
 283     // stream init
 284     wxAutoOleInterface<IPersistStreamInit>
 285                 pPersistStreamInit(IID_IPersistStreamInit, m_oleObject);
 286
 287     if (pPersistStreamInit.Ok())
 288     {
 289         hret = pPersistStreamInit->InitNew();
 290         WXOLE_WARN(hret, "CreateActiveX::pPersistStreamInit->InitNew()");
 291     };
 292
 293     // document advise
 294     m_docAdviseCookie = 0;
 295     hret = m_oleObject->Advise(adviseSink, &m_docAdviseCookie);
 296     WXOLE_WARN(hret, "m_oleObject->Advise(adviseSink, &m_docAdviseCookie),\"Advise\")");
 297     m_oleObject->SetHostNames(L"wxActiveXContainer", NULL);
 298         OleSetContainedObject(m_oleObject, TRUE);
 299
 300     if (! (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST))
 301                 m_oleObject->SetClientSite(m_clientSite);
 302
 303
 304         int w, h;
 305         GetClientSize(&w, &h);
 306         RECT posRect;
 307         posRect.left = 0;
 308         posRect.top = 0;
 309         posRect.right = w;
 310         posRect.bottom = h;
 311
 312     m_oleObjectHWND = 0;
 313         hret = m_oleInPlaceObject->GetWindow(&m_oleObjectHWND);
 314         WXOLE_WARN(hret, "m_oleInPlaceObject->GetWindow(&m_oleObjectHWND)");
 315     if (SUCCEEDED(hret))
 316             ::SetActiveWindow(m_oleObjectHWND);
 317
 318
 319     if (! (dwMiscStatus & OLEMISC_INVISIBLEATRUNTIME))
 320     {
 321             m_oleInPlaceObject->SetObjectRects(&posRect, &posRect);
 322
 323                 hret = m_oleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, m_clientSite, 0, (HWND)GetHWND(), &posRect);
 324         hret = m_oleObject->DoVerb(OLEIVERB_SHOW, 0, m_clientSite, 0, (HWND)GetHWND(), &posRect);
 325     };
 326
 327 }
 328
 329 void wxActiveX::CreateActiveX(LPOLESTR progId)
 330 {
 331     CLSID clsid;
 332     if (CLSIDFromProgID(progId, &clsid) != S_OK)
 333         return;
 334
 335     CreateActiveX(clsid);
 336 };
 337
 338 HRESULT wxActiveX::ConnectAdvise(REFIID riid, IUnknown *events)
 339 {
 340         wxOleConnectionPoint    cp;
 341         DWORD                                   adviseCookie = 0;
 342
 343         wxAutoOleInterface<IConnectionPointContainer> cpContainer(IID_IConnectionPointContainer, m_ActiveX);
 344         if (! cpContainer.Ok())
 345                 return E_FAIL;
 346
 347         HRESULT hret = cpContainer->FindConnectionPoint(riid, cp.GetRef());
 348         if (! SUCCEEDED(hret))
 349                 return hret;
 350
 351         hret = cp->Advise(events, &adviseCookie);
 352
 353         if (SUCCEEDED(hret))
 354                 m_connections.push_back(wxOleConnection(cp, adviseCookie));
 355
 356         return hret;
 357 };
 358
 359 HRESULT wxActiveX::AmbientPropertyChanged(DISPID dispid)
 360 {
 361     wxAutoOleInterface<IOleControl> oleControl(IID_IOleControl, m_oleObject);
 362
 363     if (oleControl.Ok())
 364         return oleControl->OnAmbientPropertyChange(dispid);
 365     else
 366         return S_FALSE;
 367 };
 368
 369 #define HIMETRIC_PER_INCH   2540
 370 #define MAP_PIX_TO_LOGHIM(x,ppli)   MulDiv(HIMETRIC_PER_INCH, (x), (ppli))
 371
 372 static void PixelsToHimetric(SIZEL &sz)
 373 {
 374         static int logX = 0;
 375         static int logY = 0;
 376
 377         if (logY == 0)
 378         {
 379                 // initaliase
 380                 HDC dc = GetDC(NULL);
 381                 logX = GetDeviceCaps(dc, LOGPIXELSX);
 382                 logY = GetDeviceCaps(dc, LOGPIXELSY);
 383                 ReleaseDC(NULL, dc);
 384         };
 385
 386 #define HIMETRIC_INCH   2540
 387 #define CONVERT(x, logpixels)   MulDiv(HIMETRIC_INCH, (x), (logpixels))
 388
 389         sz.cx = CONVERT(sz.cx, logX);
 390         sz.cy = CONVERT(sz.cy, logY);
 391
 392 #undef CONVERT
 393 #undef HIMETRIC_INCH
 394 }
 395
 396
 397 void wxActiveX::OnSize(wxSizeEvent& event)
 398 {
 399         int w, h;
 400         GetClientSize(&w, &h);
 401
 402         RECT posRect;
 403         posRect.left = 0;
 404         posRect.top = 0;
 405         posRect.right = w;
 406         posRect.bottom = h;
 407
 408         if (m_oleInPlaceObject)
 409                 m_oleInPlaceObject->SetObjectRects(&posRect, &posRect);
 410
 411         // extents are in HIMETRIC units
 412     SIZEL sz = {w, h};
 413         PixelsToHimetric(sz);
 414
 415     SIZEL sz2;
 416     m_oleObject->GetExtent(DVASPECT_CONTENT, &sz2);
 417     if (sz2.cx !=  sz.cx || sz.cy != sz2.cy)
 418         m_oleObject->SetExtent(DVASPECT_CONTENT, &sz);
 419 }
 420
 421 void wxActiveX::OnSetFocus(wxFocusEvent& event)
 422 {
 423         if (m_oleInPlaceActiveObject.Ok())
 424         m_oleInPlaceActiveObject->OnFrameWindowActivate(TRUE);
 425 }
 426
 427 void wxActiveX::OnKillFocus(wxFocusEvent& event)
 428 {
 429         if (m_oleInPlaceActiveObject.Ok())
 430         m_oleInPlaceActiveObject->OnFrameWindowActivate(FALSE);
 431 }
 432
 433
 434 FrameSite::FrameSite(wxActiveX * win)
 435 {
 436         m_window = win;
 437         m_bSupportsWindowlessActivation = true;
 438         m_bInPlaceLocked = false;
 439         m_bUIActive = false;
 440         m_bInPlaceActive = false;
 441         m_bWindowless = false;
 442
 443         m_nAmbientLocale = 0;
 444         m_clrAmbientForeColor = ::GetSysColor(COLOR_WINDOWTEXT);
 445         m_clrAmbientBackColor = ::GetSysColor(COLOR_WINDOW);
 446         m_bAmbientShowHatching = true;
 447         m_bAmbientShowGrabHandles = true;
 448         m_bAmbientAppearance = true;
 449
 450         m_hDCBuffer = NULL;
 451         m_hWndParent = (HWND)m_window->GetHWND();
 452 }
 453
 454 FrameSite::~FrameSite()
 455 {
 456 }
 457
 458
 459 //IDispatch
 460
 461 HRESULT FrameSite::GetIDsOfNames(REFIID riid, OLECHAR ** rgszNames, unsigned int cNames,
 462                                                                  LCID lcid, DISPID * rgDispId)
 463 {
 464         WXOLE_TRACE("IDispatch::GetIDsOfNames");
 465         return E_NOTIMPL;
 466 }
 467
 468 HRESULT FrameSite::GetTypeInfo(unsigned int iTInfo, LCID lcid, ITypeInfo ** ppTInfo)
 469 {
 470         WXOLE_TRACE("IDispatch::GetTypeInfo");
 471         return E_NOTIMPL;
 472 }
 473
 474 HRESULT FrameSite::GetTypeInfoCount(unsigned int * pcTInfo)
 475 {
 476         WXOLE_TRACE("IDispatch::GetTypeInfoCount");
 477         return E_NOTIMPL;
 478 }
 479
 480 HRESULT FrameSite::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
 481                                                   WORD wFlags, DISPPARAMS * pDispParams,
 482                                                   VARIANT * pVarResult, EXCEPINFO * pExcepInfo,
 483                                                   unsigned int * puArgErr)
 484 {
 485         WXOLE_TRACE("IDispatch::Invoke");
 486
 487         if (!(wFlags & DISPATCH_PROPERTYGET))
 488         return S_OK;
 489
 490     HRESULT hr;
 491
 492         if (pVarResult == NULL)
 493                 return E_INVALIDARG;
 494
 495     //The most common case is boolean, use as an initial type
 496     V_VT(pVarResult) = VT_BOOL;
 497
 498         switch (dispIdMember)
 499         {
 500         case DISPID_AMBIENT_MESSAGEREFLECT:
 501             WXOLE_TRACE("Invoke::DISPID_AMBIENT_MESSAGEREFLECT");
 502             V_BOOL(pVarResult)= FALSE;
 503             return S_OK;
 504
 505         case DISPID_AMBIENT_DISPLAYASDEFAULT:
 506             WXOLE_TRACE("Invoke::DISPID_AMBIENT_DISPLAYASDEFAULT");
 507             V_BOOL(pVarResult)= TRUE;
 508             return S_OK;
 509
 510         case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED:
 511             WXOLE_TRACE("Invoke::DISPID_AMBIENT_OFFLINEIFNOTCONNECTED");
 512             V_BOOL(pVarResult) = TRUE;
 513             return S_OK;
 514
 515
 516         case DISPID_AMBIENT_SILENT:
 517             WXOLE_TRACE("Invoke::DISPID_AMBIENT_SILENT");
 518             V_BOOL(pVarResult)= TRUE;
 519             return S_OK;
 520
 521                 case DISPID_AMBIENT_APPEARANCE:
 522                         pVarResult->vt = VT_BOOL;
 523                         pVarResult->boolVal = m_bAmbientAppearance;
 524                         break;
 525
 526                 case DISPID_AMBIENT_FORECOLOR:
 527                         pVarResult->vt = VT_I4;
 528                         pVarResult->lVal = (long) m_clrAmbientForeColor;
 529                         break;
 530
 531                 case DISPID_AMBIENT_BACKCOLOR:
 532                         pVarResult->vt = VT_I4;
 533                         pVarResult->lVal = (long) m_clrAmbientBackColor;
 534                         break;
 535
 536                 case DISPID_AMBIENT_LOCALEID:
 537                         pVarResult->vt = VT_I4;
 538                         pVarResult->lVal = (long) m_nAmbientLocale;
 539                         break;
 540
 541                 case DISPID_AMBIENT_USERMODE:
 542                         pVarResult->vt = VT_BOOL;
 543                         pVarResult->boolVal = m_window->m_bAmbientUserMode;
 544                         break;
 545
 546                 case DISPID_AMBIENT_SHOWGRABHANDLES:
 547                         pVarResult->vt = VT_BOOL;
 548                         pVarResult->boolVal = m_bAmbientShowGrabHandles;
 549                         break;
 550
 551                 case DISPID_AMBIENT_SHOWHATCHING:
 552                         pVarResult->vt = VT_BOOL;
 553                         pVarResult->boolVal = m_bAmbientShowHatching;
 554                         break;
 555
 556                 default:
 557                         return DISP_E_MEMBERNOTFOUND;
 558         }
 559
 560     return S_OK;
 561 }
 562
 563 //IOleWindow
 564
 565 HRESULT FrameSite::GetWindow(HWND * phwnd)
 566 {
 567         WXOLE_TRACE("IOleWindow::GetWindow");
 568         if (phwnd == NULL)
 569         return E_INVALIDARG;
 570         (*phwnd) = m_hWndParent;
 571         return S_OK;
 572 }
 573
 574 HRESULT FrameSite::ContextSensitiveHelp(BOOL fEnterMode)
 575 {
 576         WXOLE_TRACE("IOleWindow::ContextSensitiveHelp");
 577         return S_OK;
 578 }
 579
 580 //IOleInPlaceUIWindow
 581
 582 HRESULT FrameSite::GetBorder(LPRECT lprectBorder)
 583 {
 584         WXOLE_TRACE("IOleInPlaceUIWindow::GetBorder");
 585         if (lprectBorder == NULL)
 586         return E_INVALIDARG;
 587         return INPLACE_E_NOTOOLSPACE;
 588 }
 589
 590 HRESULT FrameSite::RequestBorderSpace(LPCBORDERWIDTHS pborderwidths)
 591 {
 592         WXOLE_TRACE("IOleInPlaceUIWindow::RequestBorderSpace");
 593         if (pborderwidths == NULL)
 594         return E_INVALIDARG;
 595         return INPLACE_E_NOTOOLSPACE;
 596 }
 597
 598 HRESULT FrameSite::SetBorderSpace(LPCBORDERWIDTHS pborderwidths)
 599 {
 600         WXOLE_TRACE("IOleInPlaceUIWindow::SetBorderSpace");
 601         return S_OK;
 602 }
 603
 604 HRESULT FrameSite::SetActiveObject(IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
 605 {
 606         WXOLE_TRACE("IOleInPlaceUIWindow::SetActiveObject");
 607
 608     if (pActiveObject)
 609         pActiveObject->AddRef();
 610
 611     m_window->m_oleInPlaceActiveObject = pActiveObject;
 612         return S_OK;
 613 }
 614
 615 //IOleInPlaceFrame
 616
 617 HRESULT FrameSite::InsertMenus(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths)
 618 {
 619         WXOLE_TRACE("IOleInPlaceFrame::InsertMenus");
 620         return S_OK;
 621 }
 622
 623 HRESULT FrameSite::SetMenu(HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject)
 624 {
 625         WXOLE_TRACE("IOleInPlaceFrame::SetMenu");
 626         return S_OK;
 627 }
 628
 629 HRESULT FrameSite::RemoveMenus(HMENU hmenuShared)
 630 {
 631         WXOLE_TRACE("IOleInPlaceFrame::RemoveMenus");
 632         return S_OK;
 633 }
 634
 635 HRESULT FrameSite::SetStatusText(LPCOLESTR pszStatusText)
 636 {
 637         WXOLE_TRACE("IOleInPlaceFrame::SetStatusText");
 638         //((wxFrame*)wxGetApp().GetTopWindow())->GetStatusBar()->SetStatusText(pszStatusText);
 639         return S_OK;
 640 }
 641
 642 HRESULT FrameSite::EnableModeless(BOOL fEnable)
 643 {
 644         WXOLE_TRACE("IOleInPlaceFrame::EnableModeless");
 645         return S_OK;
 646 }
 647
 648 HRESULT FrameSite::TranslateAccelerator(LPMSG lpmsg, WORD wID)
 649 {
 650         WXOLE_TRACE("IOleInPlaceFrame::TranslateAccelerator");
 651         // TODO: send an event with this id
 652     if (m_window->m_oleInPlaceActiveObject.Ok())
 653         m_window->m_oleInPlaceActiveObject->TranslateAccelerator(lpmsg);
 654
 655         return S_FALSE;
 656 }
 657
 658 //IOleInPlaceSite
 659
 660 HRESULT FrameSite::CanInPlaceActivate()
 661 {
 662         WXOLE_TRACE("IOleInPlaceSite::CanInPlaceActivate");
 663         return S_OK;
 664 }
 665
 666 HRESULT FrameSite::OnInPlaceActivate()
 667 {
 668         WXOLE_TRACE("IOleInPlaceSite::OnInPlaceActivate");
 669         m_bInPlaceActive = true;
 670         return S_OK;
 671 }
 672
 673 HRESULT FrameSite::OnUIActivate()
 674 {
 675         WXOLE_TRACE("IOleInPlaceSite::OnUIActivate");
 676         m_bUIActive = true;
 677         return S_OK;
 678 }
 679
 680 HRESULT FrameSite::GetWindowContext(IOleInPlaceFrame **ppFrame,
 681                                                                         IOleInPlaceUIWindow **ppDoc,
 682                                                                         LPRECT lprcPosRect,
 683                                                                         LPRECT lprcClipRect,
 684                                                                         LPOLEINPLACEFRAMEINFO lpFrameInfo)
 685 {
 686         WXOLE_TRACE("IOleInPlaceSite::GetWindowContext");
 687         if (ppFrame == NULL || ppDoc == NULL || lprcPosRect == NULL ||
 688                 lprcClipRect == NULL || lpFrameInfo == NULL)
 689         {
 690                 if (ppFrame != NULL)
 691             (*ppFrame) = NULL;
 692                 if (ppDoc != NULL)
 693             (*ppDoc) = NULL;
 694                 return E_INVALIDARG;
 695         }
 696
 697     HRESULT hr = QueryInterface(IID_IOleInPlaceFrame, (void **) ppFrame);
 698     if (! SUCCEEDED(hr))
 699     {
 700         WXOLE_TRACE("IOleInPlaceSite::IOleInPlaceFrame Error !");
 701         return E_UNEXPECTED;
 702     };
 703
 704     hr = QueryInterface(IID_IOleInPlaceUIWindow, (void **) ppDoc);
 705     if (! SUCCEEDED(hr))
 706     {
 707         WXOLE_TRACE("IOleInPlaceSite::IOleInPlaceUIWindow Error !");
 708         (*ppFrame)->Release();
 709         *ppFrame = NULL;
 710         return E_UNEXPECTED;
 711     };
 712
 713         int w, h;
 714         m_window->GetClientSize(&w, &h);
 715     if (lprcPosRect)
 716     {
 717             lprcPosRect->left = lprcPosRect->top = 0;
 718             lprcPosRect->right = w;
 719             lprcPosRect->bottom = h;
 720     };
 721     if (lprcClipRect)
 722     {
 723             lprcClipRect->left = lprcClipRect->top = 0;
 724             lprcClipRect->right = w;
 725             lprcClipRect->bottom = h;
 726     };
 727
 728     memset(lpFrameInfo, 0, sizeof(OLEINPLACEFRAMEINFO));
 729     lpFrameInfo->cb = sizeof(OLEINPLACEFRAMEINFO);
 730         lpFrameInfo->hwndFrame = m_hWndParent;
 731
 732         return S_OK;
 733 }
 734
 735 HRESULT FrameSite::Scroll(SIZE scrollExtent)
 736 {
 737         WXOLE_TRACE("IOleInPlaceSite::Scroll");
 738         return S_OK;
 739 }
 740
 741 HRESULT FrameSite::OnUIDeactivate(BOOL fUndoable)
 742 {
 743         WXOLE_TRACE("IOleInPlaceSite::OnUIDeactivate");
 744         m_bUIActive = false;
 745         return S_OK;
 746 }
 747
 748 HRESULT FrameSite::OnInPlaceDeactivate()
 749 {
 750         WXOLE_TRACE("IOleInPlaceSite::OnInPlaceDeactivate");
 751         m_bInPlaceActive = false;
 752         return S_OK;
 753 }
 754
 755 HRESULT FrameSite::DiscardUndoState()
 756 {
 757         WXOLE_TRACE("IOleInPlaceSite::DiscardUndoState");
 758         return S_OK;
 759 }
 760
 761 HRESULT FrameSite::DeactivateAndUndo()
 762 {
 763         WXOLE_TRACE("IOleInPlaceSite::DeactivateAndUndo");
 764         return S_OK;
 765 }
 766
 767 HRESULT FrameSite::OnPosRectChange(LPCRECT lprcPosRect)
 768 {
 769         WXOLE_TRACE("IOleInPlaceSite::OnPosRectChange");
 770     if (m_window->m_oleInPlaceObject.Ok() && lprcPosRect)
 771         m_window->m_oleInPlaceObject->SetObjectRects(lprcPosRect, lprcPosRect);
 772
 773         return S_OK;
 774 }
 775
 776 //IOleInPlaceSiteEx
 777
 778 HRESULT FrameSite::OnInPlaceActivateEx(BOOL * pfNoRedraw, DWORD dwFlags)
 779 {
 780         WXOLE_TRACE("IOleInPlaceSiteEx::OnInPlaceActivateEx");
 781         OleLockRunning(m_window->m_ActiveX, TRUE, FALSE);
 782     if (pfNoRedraw)
 783         (*pfNoRedraw) = FALSE;
 784         return S_OK;
 785 }
 786
 787 HRESULT FrameSite::OnInPlaceDeactivateEx(BOOL fNoRedraw)
 788 {
 789         WXOLE_TRACE("IOleInPlaceSiteEx::OnInPlaceDeactivateEx");
 790     OleLockRunning(m_window->m_ActiveX, FALSE, FALSE);
 791         return S_OK;
 792 }
 793
 794 HRESULT FrameSite::RequestUIActivate()
 795 {
 796         WXOLE_TRACE("IOleInPlaceSiteEx::RequestUIActivate");
 797         return S_OK;
 798 }
 799
 800
 801 //IOleClientSite
 802
 803 HRESULT FrameSite::SaveObject()
 804 {
 805         WXOLE_TRACE("IOleClientSite::SaveObject");
 806         return S_OK;
 807 }
 808
 809 HRESULT FrameSite::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker,
 810                                                           IMoniker ** ppmk)
 811 {
 812         WXOLE_TRACE("IOleClientSite::GetMoniker");
 813         return E_NOTIMPL;
 814 }
 815
 816 HRESULT FrameSite::GetContainer(LPOLECONTAINER * ppContainer)
 817 {
 818         WXOLE_TRACE("IOleClientSite::GetContainer");
 819         if (ppContainer == NULL)
 820         return E_INVALIDARG;
 821
 822     HRESULT hr = QueryInterface(IID_IOleContainer, (void**)(ppContainer));
 823     wxASSERT(SUCCEEDED(hr));
 824
 825         return hr;
 826 }
 827
 828 HRESULT FrameSite::ShowObject()
 829 {
 830         WXOLE_TRACE("IOleClientSite::ShowObject");
 831         return S_OK;
 832 }
 833
 834 HRESULT FrameSite::OnShowWindow(BOOL fShow)
 835 {
 836         WXOLE_TRACE("IOleClientSite::OnShowWindow");
 837         return S_OK;
 838 }
 839
 840 HRESULT FrameSite::RequestNewObjectLayout()
 841 {
 842         WXOLE_TRACE("IOleClientSite::RequestNewObjectLayout");
 843         return E_NOTIMPL;
 844 }
 845
 846 // IParseDisplayName
 847
 848 HRESULT FrameSite::ParseDisplayName(IBindCtx *pbc, LPOLESTR pszDisplayName,
 849                                                                         ULONG *pchEaten, IMoniker **ppmkOut)
 850 {
 851         WXOLE_TRACE("IParseDisplayName::ParseDisplayName");
 852         return E_NOTIMPL;
 853 }
 854
 855 //IOleContainer
 856
 857 HRESULT FrameSite::EnumObjects(DWORD grfFlags, IEnumUnknown **ppenum)
 858 {
 859         WXOLE_TRACE("IOleContainer::EnumObjects");
 860         return E_NOTIMPL;
 861 }
 862
 863 HRESULT FrameSite::LockContainer(BOOL fLock)
 864 {
 865         WXOLE_TRACE("IOleContainer::LockContainer");
 866         // TODO
 867         return S_OK;
 868 }
 869
 870 //IOleItemContainer
 871
 872 HRESULT FrameSite::GetObject(LPOLESTR pszItem, DWORD dwSpeedNeeded,
 873                                                          IBindCtx * pbc, REFIID riid, void ** ppvObject)
 874 {
 875         WXOLE_TRACE("IOleItemContainer::GetObject");
 876         if (pszItem == NULL)
 877         return E_INVALIDARG;
 878         if (ppvObject == NULL)
 879         return E_INVALIDARG;
 880
 881         *ppvObject = NULL;
 882         return MK_E_NOOBJECT;
 883 }
 884
 885 HRESULT FrameSite::GetObjectStorage(LPOLESTR pszItem, IBindCtx * pbc,
 886                                                                         REFIID riid, void ** ppvStorage)
 887 {
 888         WXOLE_TRACE("IOleItemContainer::GetObjectStorage");
 889         if (pszItem == NULL)
 890         return E_INVALIDARG;
 891         if (ppvStorage == NULL)
 892         return E_INVALIDARG;
 893
 894         *ppvStorage = NULL;
 895         return MK_E_NOOBJECT;
 896 }
 897
 898 HRESULT FrameSite::IsRunning(LPOLESTR pszItem)
 899 {
 900         WXOLE_TRACE("IOleItemContainer::IsRunning");
 901         if (pszItem == NULL)
 902         return E_INVALIDARG;
 903
 904         return MK_E_NOOBJECT;
 905 }
 906
 907
 908
 909 //IOleControlSite
 910
 911 HRESULT FrameSite::OnControlInfoChanged()
 912 {
 913         WXOLE_TRACE("IOleControlSite::OnControlInfoChanged");
 914         return S_OK;
 915 }
 916
 917 HRESULT FrameSite::LockInPlaceActive(BOOL fLock)
 918 {
 919         WXOLE_TRACE("IOleControlSite::LockInPlaceActive");
 920         m_bInPlaceLocked = (fLock) ? true : false;
 921         return S_OK;
 922 }
 923
 924 HRESULT FrameSite::GetExtendedControl(IDispatch ** ppDisp)
 925 {
 926         WXOLE_TRACE("IOleControlSite::GetExtendedControl");
 927         return E_NOTIMPL;
 928 }
 929
 930 HRESULT FrameSite::TransformCoords(POINTL * pPtlHimetric, POINTF * pPtfContainer, DWORD dwFlags)
 931 {
 932         WXOLE_TRACE("IOleControlSite::TransformCoords");
 933         HRESULT hr = S_OK;
 934
 935         if (pPtlHimetric == NULL)
 936                 return E_INVALIDARG;
 937
 938         if (pPtfContainer == NULL)
 939                 return E_INVALIDARG;
 940
 941         return E_NOTIMPL;
 942
 943 }
 944
 945 HRESULT FrameSite::TranslateAccelerator(LPMSG pMsg, DWORD grfModifiers)
 946 {
 947         WXOLE_TRACE("IOleControlSite::TranslateAccelerator");
 948         // TODO: send an event with this id
 949         return E_NOTIMPL;
 950 }
 951
 952 HRESULT FrameSite::OnFocus(BOOL fGotFocus)
 953 {
 954         WXOLE_TRACE("IOleControlSite::OnFocus");
 955         return S_OK;
 956 }
 957
 958 HRESULT FrameSite::ShowPropertyFrame()
 959 {
 960         WXOLE_TRACE("IOleControlSite::ShowPropertyFrame");
 961         return E_NOTIMPL;
 962 }
 963
 964 //IOleCommandTarget
 965
 966 HRESULT FrameSite::QueryStatus(const GUID * pguidCmdGroup, ULONG cCmds,
 967                                                            OLECMD * prgCmds, OLECMDTEXT * pCmdTet)
 968 {
 969         WXOLE_TRACE("IOleCommandTarget::QueryStatus");
 970         if (prgCmds == NULL) return E_INVALIDARG;
 971         bool bCmdGroupFound = false;
 972
 973         for (ULONG nCmd = 0; nCmd < cCmds; nCmd++)
 974         {
 975                 // unsupported by default
 976                 prgCmds[nCmd].cmdf = 0;
 977
 978                 // TODO
 979         }
 980
 981         if (!bCmdGroupFound) { OLECMDERR_E_UNKNOWNGROUP; }
 982         return S_OK;
 983 }
 984
 985 HRESULT FrameSite::Exec(const GUID * pguidCmdGroup, DWORD nCmdID,
 986                                                 DWORD nCmdExecOpt, VARIANTARG * pVaIn,
 987                                                 VARIANTARG * pVaOut)
 988 {
 989         WXOLE_TRACE("IOleCommandTarget::Exec");
 990         bool bCmdGroupFound = false;
 991
 992         if (!bCmdGroupFound) { OLECMDERR_E_UNKNOWNGROUP; }
 993         return OLECMDERR_E_NOTSUPPORTED;
 994 }
 995
 996 //IAdviseSink
 997
 998 void STDMETHODCALLTYPE FrameSite::OnDataChange(FORMATETC * pFormatEtc, STGMEDIUM * pgStgMed)
 999 {
1000         WXOLE_TRACE("IAdviseSink::OnDataChange");
1001 }
1002
1003 void STDMETHODCALLTYPE FrameSite::OnViewChange(DWORD dwAspect, LONG lIndex)
1004 {
1005         WXOLE_TRACE("IAdviseSink::OnViewChange");
1006         // redraw the control
1007 }
1008
1009 void STDMETHODCALLTYPE FrameSite::OnRename(IMoniker * pmk)
1010 {
1011         WXOLE_TRACE("IAdviseSink::OnRename");
1012 }
1013
1014 void STDMETHODCALLTYPE FrameSite::OnSave()
1015 {
1016         WXOLE_TRACE("IAdviseSink::OnSave");
1017 }
1018
1019 void STDMETHODCALLTYPE FrameSite::OnClose()
1020 {
1021         WXOLE_TRACE("IAdviseSink::OnClose");
1022 }
1023
1024 /////////////////////////////////////////////
1025 // IOleDocumentSite
1026 HRESULT STDMETHODCALLTYPE FrameSite::ActivateMe(
1027         /* [in] */ IOleDocumentView __RPC_FAR *pViewToActivate)
1028 {
1029     wxAutoOleInterface<IOleInPlaceSite> inPlaceSite(IID_IOleInPlaceSite, (IDispatch *) this);
1030     if (!inPlaceSite.Ok())
1031         return E_FAIL;
1032
1033     if (pViewToActivate)
1034     {
1035         m_window->m_docView = pViewToActivate;
1036         m_window->m_docView->SetInPlaceSite(inPlaceSite);
1037     }
1038     else
1039     {
1040         wxAutoOleInterface<IOleDocument> oleDoc(IID_IOleDocument, m_window->m_oleObject);
1041         if (! oleDoc.Ok())
1042                 return E_FAIL;
1043
1044         HRESULT hr = oleDoc->CreateView(inPlaceSite, NULL, 0, m_window->m_docView.GetRef());
1045         if (hr != S_OK)
1046                 return E_FAIL;
1047
1048                 m_window->m_docView->SetInPlaceSite(inPlaceSite);
1049     };
1050
1051     m_window->m_docView->UIActivate(TRUE);
1052
1053     return S_OK;
1054 };
1055
1056
1057
1058 static IMalloc *iMalloc = NULL;
1059
1060 IMalloc *wxOleInit::GetIMalloc()
1061 {
1062         assert(iMalloc);
1063         return iMalloc;
1064 };
1065
1066 wxOleInit::wxOleInit()
1067 {
1068     if (OleInitialize(NULL) == S_OK && iMalloc == NULL)
1069             CoGetMalloc(1, &iMalloc);
1070     else if (iMalloc)
1071         iMalloc->AddRef();
1072 };
1073
1074 wxOleInit::~wxOleInit()
1075 {
1076         if (iMalloc)
1077     {
1078         if (iMalloc->Release() == 0)
1079                 iMalloc = NULL;
1080     };
1081
1082     OleUninitialize();
1083 }
1084
1085 wxString OLEHResultToString(HRESULT hr)
1086 {
1087     switch (hr)
1088     {
1089     case S_OK:
1090         return "";
1091
1092     case OLECMDERR_E_UNKNOWNGROUP:
1093                 return "The pguidCmdGroup parameter is not NULL but does not specify a recognized command group.";
1094
1095     case OLECMDERR_E_NOTSUPPORTED:
1096                 return "The nCmdID parameter is not a valid command in the group identified by pguidCmdGroup.";
1097
1098     case OLECMDERR_E_DISABLED:
1099                 return "The command identified by nCmdID is currently disabled and cannot be executed.";
1100
1101     case OLECMDERR_E_NOHELP:
1102                 return "The caller has asked for help on the command identified by nCmdID, but no help is available.";
1103
1104     case OLECMDERR_E_CANCELED:
1105                 return "The user canceled the execution of the command.";
1106
1107     case E_INVALIDARG:
1108         return "E_INVALIDARG";
1109
1110     case E_OUTOFMEMORY:
1111         return "E_OUTOFMEMORY";
1112
1113     case E_NOINTERFACE:
1114         return "E_NOINTERFACE";
1115
1116     case E_UNEXPECTED:
1117         return "E_UNEXPECTED";
1118
1119     case STG_E_INVALIDFLAG:
1120         return "STG_E_INVALIDFLAG";
1121
1122     case E_FAIL:
1123         return "E_FAIL";
1124
1125     case E_NOTIMPL:
1126         return "E_NOTIMPL";
1127
1128     default:
1129         {
1130             char buf[64];
1131             sprintf(buf, "Unknown - 0x%X", hr);
1132             return wxString(buf);
1133         }
1134     };
1135 };
1136
1137 // borrowed from src/msw/ole/oleutils.cpp
1138 wxString GetIIDName(REFIID riid)
1139 {
1140   // an association between symbolic name and numeric value of an IID
1141   struct KNOWN_IID
1142   {
1143     const IID  *pIid;
1144     const wxChar *szName;
1145   };
1146
1147   // construct the table containing all known interfaces
1148   #define ADD_KNOWN_IID(name) { &IID_I##name, _T(#name) }
1149
1150   static const KNOWN_IID aKnownIids[] =
1151   {
1152     ADD_KNOWN_IID(AdviseSink),
1153     ADD_KNOWN_IID(AdviseSink2),
1154     ADD_KNOWN_IID(BindCtx),
1155     ADD_KNOWN_IID(ClassFactory),
1156 #if ( !defined( __VISUALC__) || (__VISUALC__!=1010) ) && !defined(__MWERKS__)
1157     ADD_KNOWN_IID(ContinueCallback),
1158     ADD_KNOWN_IID(EnumOleDocumentViews),
1159     ADD_KNOWN_IID(OleCommandTarget),
1160     ADD_KNOWN_IID(OleDocument),
1161     ADD_KNOWN_IID(OleDocumentSite),
1162     ADD_KNOWN_IID(OleDocumentView),
1163     ADD_KNOWN_IID(Print),
1164 #endif
1165     ADD_KNOWN_IID(DataAdviseHolder),
1166     ADD_KNOWN_IID(DataObject),
1167     ADD_KNOWN_IID(Debug),
1168     ADD_KNOWN_IID(DebugStream),
1169     ADD_KNOWN_IID(DfReserved1),
1170     ADD_KNOWN_IID(DfReserved2),
1171     ADD_KNOWN_IID(DfReserved3),
1172     ADD_KNOWN_IID(Dispatch),
1173     ADD_KNOWN_IID(DropSource),
1174     ADD_KNOWN_IID(DropTarget),
1175     ADD_KNOWN_IID(EnumCallback),
1176     ADD_KNOWN_IID(EnumFORMATETC),
1177     ADD_KNOWN_IID(EnumGeneric),
1178     ADD_KNOWN_IID(EnumHolder),
1179     ADD_KNOWN_IID(EnumMoniker),
1180     ADD_KNOWN_IID(EnumOLEVERB),
1181     ADD_KNOWN_IID(EnumSTATDATA),
1182     ADD_KNOWN_IID(EnumSTATSTG),
1183     ADD_KNOWN_IID(EnumString),
1184     ADD_KNOWN_IID(EnumUnknown),
1185     ADD_KNOWN_IID(EnumVARIANT),
1186     ADD_KNOWN_IID(ExternalConnection),
1187     ADD_KNOWN_IID(InternalMoniker),
1188     ADD_KNOWN_IID(LockBytes),
1189     ADD_KNOWN_IID(Malloc),
1190     ADD_KNOWN_IID(Marshal),
1191     ADD_KNOWN_IID(MessageFilter),
1192     ADD_KNOWN_IID(Moniker),
1193     ADD_KNOWN_IID(OleAdviseHolder),
1194     ADD_KNOWN_IID(OleCache),
1195     ADD_KNOWN_IID(OleCache2),
1196     ADD_KNOWN_IID(OleCacheControl),
1197     ADD_KNOWN_IID(OleClientSite),
1198     ADD_KNOWN_IID(OleContainer),
1199     ADD_KNOWN_IID(OleInPlaceActiveObject),
1200     ADD_KNOWN_IID(OleInPlaceFrame),
1201     ADD_KNOWN_IID(OleInPlaceObject),
1202     ADD_KNOWN_IID(OleInPlaceSite),
1203     ADD_KNOWN_IID(OleInPlaceUIWindow),
1204     ADD_KNOWN_IID(OleItemContainer),
1205     ADD_KNOWN_IID(OleLink),
1206     ADD_KNOWN_IID(OleManager),
1207     ADD_KNOWN_IID(OleObject),
1208     ADD_KNOWN_IID(OlePresObj),
1209     ADD_KNOWN_IID(OleWindow),
1210     ADD_KNOWN_IID(PSFactory),
1211     ADD_KNOWN_IID(ParseDisplayName),
1212     ADD_KNOWN_IID(Persist),
1213     ADD_KNOWN_IID(PersistFile),
1214     ADD_KNOWN_IID(PersistStorage),
1215     ADD_KNOWN_IID(PersistStream),
1216     ADD_KNOWN_IID(ProxyManager),
1217     ADD_KNOWN_IID(RootStorage),
1218     ADD_KNOWN_IID(RpcChannel),
1219     ADD_KNOWN_IID(RpcProxy),
1220     ADD_KNOWN_IID(RpcStub),
1221     ADD_KNOWN_IID(RunnableObject),
1222     ADD_KNOWN_IID(RunningObjectTable),
1223     ADD_KNOWN_IID(StdMarshalInfo),
1224     ADD_KNOWN_IID(Storage),
1225     ADD_KNOWN_IID(Stream),
1226     ADD_KNOWN_IID(StubManager),
1227     ADD_KNOWN_IID(Unknown),
1228     ADD_KNOWN_IID(ViewObject),
1229     ADD_KNOWN_IID(ViewObject2),
1230   };
1231
1232   // don't clobber preprocessor name space
1233   #undef ADD_KNOWN_IID
1234
1235   // try to find the interface in the table
1236   for ( size_t ui = 0; ui < WXSIZEOF(aKnownIids); ui++ )
1237   {
1238     if ( riid == *aKnownIids[ui].pIid )
1239     {
1240       return aKnownIids[ui].szName;
1241     }
1242   }
1243
1244   // unknown IID, just transform to string
1245   LPOLESTR str = NULL;
1246   StringFromIID(riid, &str);
1247   if (str)
1248   {
1249       wxString s = str;
1250       CoTaskMemFree(str);
1251       return s;
1252   }
1253   else
1254       return "StringFromIID() error";
1255 }