wxPython/contrib/iewin/wxactivex.cpp

   1 #include "wxActiveX.h"
   2 #include <wx/strconv.h>
   3 #include <wx/event.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 //////////////////////////////////////////////////////////////////////
  26 BEGIN_EVENT_TABLE(wxActiveX, wxWindow)
  27         EVT_SIZE(OnSize)
  28         EVT_SET_FOCUS(OnSetFocus)
  29         EVT_KILL_FOCUS(OnKillFocus)
  30 END_EVENT_TABLE()
  31
  32 class wxActiveX;
  33
  34 class FrameSite :
  35     public IOleClientSite,
  36     public IOleInPlaceSiteEx,
  37     public IOleInPlaceFrame,
  38     public IOleItemContainer,
  39     public IDispatch,
  40     public IOleCommandTarget,
  41     public IOleDocumentSite,
  42     public IAdviseSink,
  43     public IOleControlSite
  44 {
  45 private:
  46     DECLARE_OLE_UNKNOWN(FrameSite);
  47
  48 public:
  49         FrameSite(wxActiveX * win);
  50         ~FrameSite();
  51
  52         //IOleWindow
  53         STDMETHODIMP GetWindow(HWND*);
  54         STDMETHODIMP ContextSensitiveHelp(BOOL);
  55
  56     //IOleInPlaceUIWindow
  57         STDMETHODIMP GetBorder(LPRECT);
  58         STDMETHODIMP RequestBorderSpace(LPCBORDERWIDTHS);
  59         STDMETHODIMP SetBorderSpace(LPCBORDERWIDTHS);
  60         STDMETHODIMP SetActiveObject(IOleInPlaceActiveObject*, LPCOLESTR);
  61
  62     //IOleInPlaceFrame
  63         STDMETHODIMP InsertMenus(HMENU, LPOLEMENUGROUPWIDTHS);
  64         STDMETHODIMP SetMenu(HMENU, HOLEMENU, HWND);
  65         STDMETHODIMP RemoveMenus(HMENU);
  66         STDMETHODIMP SetStatusText(LPCOLESTR);
  67         STDMETHODIMP EnableModeless(BOOL);
  68         STDMETHODIMP TranslateAccelerator(LPMSG, WORD);
  69
  70         //IOleInPlaceSite
  71         STDMETHODIMP CanInPlaceActivate();
  72         STDMETHODIMP OnInPlaceActivate();
  73         STDMETHODIMP OnUIActivate();
  74         STDMETHODIMP GetWindowContext(IOleInPlaceFrame**, IOleInPlaceUIWindow**,
  75                 LPRECT, LPRECT, LPOLEINPLACEFRAMEINFO);
  76         STDMETHODIMP Scroll(SIZE);
  77         STDMETHODIMP OnUIDeactivate(BOOL);
  78         STDMETHODIMP OnInPlaceDeactivate();
  79         STDMETHODIMP DiscardUndoState();
  80         STDMETHODIMP DeactivateAndUndo();
  81         STDMETHODIMP OnPosRectChange(LPCRECT);
  82
  83     //IOleInPlaceSiteEx
  84         STDMETHODIMP OnInPlaceActivateEx(BOOL*, DWORD);
  85         STDMETHODIMP OnInPlaceDeactivateEx(BOOL);
  86         STDMETHODIMP RequestUIActivate();
  87
  88         //IOleClientSite
  89         STDMETHODIMP SaveObject();
  90         STDMETHODIMP GetMoniker(DWORD, DWORD, IMoniker**);
  91         STDMETHODIMP GetContainer(LPOLECONTAINER FAR*);
  92         STDMETHODIMP ShowObject();
  93         STDMETHODIMP OnShowWindow(BOOL);
  94         STDMETHODIMP RequestNewObjectLayout();
  95
  96         //IOleControlSite
  97         STDMETHODIMP OnControlInfoChanged();
  98         STDMETHODIMP LockInPlaceActive(BOOL);
  99         STDMETHODIMP GetExtendedControl(IDispatch**);
 100         STDMETHODIMP TransformCoords(POINTL*, POINTF*, DWORD);
 101         STDMETHODIMP TranslateAccelerator(LPMSG, DWORD);
 102         STDMETHODIMP OnFocus(BOOL);
 103         STDMETHODIMP ShowPropertyFrame();
 104
 105         //IOleCommandTarget
 106         STDMETHODIMP QueryStatus(const GUID*, ULONG, OLECMD[], OLECMDTEXT*);
 107         STDMETHODIMP Exec(const GUID*, DWORD, DWORD, VARIANTARG*, VARIANTARG*);
 108
 109         //IParseDisplayName
 110         STDMETHODIMP ParseDisplayName(IBindCtx*, LPOLESTR, ULONG*, IMoniker**);
 111
 112     //IOleContainer
 113         STDMETHODIMP EnumObjects(DWORD, IEnumUnknown**);
 114         STDMETHODIMP LockContainer(BOOL);
 115
 116         //IOleItemContainer
 117         STDMETHODIMP GetObject(LPOLESTR, DWORD, IBindCtx*, REFIID, void**);
 118         STDMETHODIMP GetObjectStorage(LPOLESTR, IBindCtx*, REFIID, void**);
 119         STDMETHODIMP IsRunning(LPOLESTR);
 120
 121         //IDispatch
 122         STDMETHODIMP GetIDsOfNames(REFIID, OLECHAR**, unsigned int, LCID, DISPID*);
 123         STDMETHODIMP GetTypeInfo(unsigned int, LCID, ITypeInfo**);
 124         STDMETHODIMP GetTypeInfoCount(unsigned int*);
 125         STDMETHODIMP Invoke(DISPID, REFIID, LCID, WORD, DISPPARAMS*, VARIANT*, EXCEPINFO*, UINT*);
 126
 127         //IAdviseSink
 128         void STDMETHODCALLTYPE OnDataChange(FORMATETC*, STGMEDIUM*);
 129         void STDMETHODCALLTYPE OnViewChange(DWORD, LONG);
 130         void STDMETHODCALLTYPE OnRename(IMoniker*);
 131         void STDMETHODCALLTYPE OnSave();
 132         void STDMETHODCALLTYPE OnClose();
 133
 134     // IOleDocumentSite
 135         HRESULT STDMETHODCALLTYPE ActivateMe(IOleDocumentView __RPC_FAR *pViewToActivate);
 136
 137 protected:
 138
 139         wxActiveX * m_window;
 140
 141         HDC m_hDCBuffer;
 142         HWND m_hWndParent;
 143
 144         bool m_bSupportsWindowlessActivation;
 145         bool m_bInPlaceLocked;
 146         bool m_bInPlaceActive;
 147         bool m_bUIActive;
 148         bool m_bWindowless;
 149
 150
 151
 152         LCID m_nAmbientLocale;
 153         COLORREF m_clrAmbientForeColor;
 154         COLORREF m_clrAmbientBackColor;
 155         bool m_bAmbientShowHatching;
 156         bool m_bAmbientShowGrabHandles;
 157         bool m_bAmbientAppearance;
 158 };
 159
 160 DEFINE_OLE_TABLE(FrameSite)
 161     OLE_INTERFACE(IID_IUnknown, IOleClientSite)
 162
 163     OLE_IINTERFACE(IOleClientSite)
 164
 165     OLE_INTERFACE(IID_IOleWindow, IOleInPlaceSite)
 166     OLE_IINTERFACE(IOleInPlaceSite)
 167     OLE_IINTERFACE(IOleInPlaceSiteEx)
 168
 169     //OLE_IINTERFACE(IOleWindow)
 170     OLE_IINTERFACE(IOleInPlaceUIWindow)
 171     OLE_IINTERFACE(IOleInPlaceFrame)
 172
 173     OLE_IINTERFACE(IParseDisplayName)
 174     OLE_IINTERFACE(IOleContainer)
 175     OLE_IINTERFACE(IOleItemContainer)
 176
 177     OLE_IINTERFACE(IDispatch)
 178
 179     OLE_IINTERFACE(IOleCommandTarget)
 180
 181     OLE_IINTERFACE(IOleDocumentSite)
 182
 183     OLE_IINTERFACE(IAdviseSink)
 184
 185     OLE_IINTERFACE(IOleControlSite)
 186 END_OLE_TABLE;
 187
 188
 189 wxActiveX::wxActiveX(wxWindow * parent, REFCLSID clsid, wxWindowID id,
 190         const wxPoint& pos,
 191         const wxSize& size,
 192         long style,
 193         const wxString& name) :
 194 wxWindow(parent, id, pos, size, style, name)
 195 {
 196     m_bAmbientUserMode = true;
 197     m_docAdviseCookie = 0;
 198     CreateActiveX(clsid);
 199 }
 200
 201 wxActiveX::wxActiveX(wxWindow * parent, wxString progId, wxWindowID id,
 202         const wxPoint& pos,
 203         const wxSize& size,
 204         long style,
 205         const wxString& name) :
 206     wxWindow(parent, id, pos, size, style, name)
 207 {
 208     m_bAmbientUserMode = true;
 209     m_docAdviseCookie = 0;
 210     CreateActiveX((LPOLESTR) wxConvUTF8.cMB2WC(progId).data());
 211 }
 212
 213 wxActiveX::~wxActiveX()
 214 {
 215         // disconnect connection points
 216         wxOleConnectionArray::iterator it = m_connections.begin();
 217         while (it != m_connections.end())
 218         {
 219                 wxOleConnectionPoint& cp = it->first;
 220                 cp->Unadvise(it->second);
 221
 222                 it++;
 223         };
 224         m_connections.clear();
 225
 226     if (m_oleInPlaceObject.Ok())
 227         {
 228                 m_oleInPlaceObject->InPlaceDeactivate();
 229                 m_oleInPlaceObject->UIDeactivate();
 230         }
 231
 232
 233         if (m_oleObject.Ok())
 234         {
 235             if (m_docAdviseCookie != 0)
 236                 m_oleObject->Unadvise(m_docAdviseCookie);
 237
 238             m_oleObject->DoVerb(OLEIVERB_HIDE, NULL, m_clientSite, 0, (HWND) GetHWND(), NULL);
 239         m_oleObject->Close(OLECLOSE_NOSAVE);
 240                 m_oleObject->SetClientSite(NULL);
 241         }
 242 }
 243
 244 void wxActiveX::CreateActiveX(REFCLSID clsid)
 245 {
 246         SetTransparent();
 247
 248         HRESULT hret;
 249
 250     ////////////////////////////////////////////////////////
 251         // FrameSite
 252     FrameSite *frame = new FrameSite(this);
 253     // oleClientSite
 254     hret = m_clientSite.QueryInterface(IID_IOleClientSite, (IDispatch *) frame);
 255     wxASSERT(SUCCEEDED(hret));
 256     // adviseSink
 257     wxAutoOleInterface<IAdviseSink> adviseSink(IID_IAdviseSink, (IDispatch *) frame);
 258     wxASSERT(adviseSink.Ok());
 259
 260
 261         // // Create Object, get IUnknown interface
 262     m_ActiveX.CreateInstance(clsid, IID_IUnknown);
 263         wxASSERT(m_ActiveX.Ok());
 264
 265         // Type Info
 266         GetTypeInfo();
 267
 268         // Get IOleObject interface
 269         hret = m_oleObject.QueryInterface(IID_IOleObject, m_ActiveX);
 270         wxASSERT(SUCCEEDED(hret));
 271         // Get IOleInPlaceObject interface
 272         hret = m_oleInPlaceObject.QueryInterface(IID_IOleInPlaceObject, m_ActiveX);
 273         wxASSERT(SUCCEEDED(hret));
 274
 275     // status
 276         DWORD dwMiscStatus;
 277         m_oleObject->GetMiscStatus(DVASPECT_CONTENT, &dwMiscStatus);
 278     wxASSERT(SUCCEEDED(hret));
 279
 280     // set client site first ?
 281     if (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST)
 282                 m_oleObject->SetClientSite(m_clientSite);
 283
 284
 285     // stream init
 286     wxAutoOleInterface<IPersistStreamInit>
 287                 pPersistStreamInit(IID_IPersistStreamInit, m_oleObject);
 288
 289     if (pPersistStreamInit.Ok())
 290     {
 291         hret = pPersistStreamInit->InitNew();
 292         WXOLE_WARN(hret, "CreateActiveX::pPersistStreamInit->InitNew()");
 293     };
 294
 295     // document advise
 296     m_docAdviseCookie = 0;
 297     hret = m_oleObject->Advise(adviseSink, &m_docAdviseCookie);
 298     WXOLE_WARN(hret, "m_oleObject->Advise(adviseSink, &m_docAdviseCookie),\"Advise\")");
 299     m_oleObject->SetHostNames(L"wxActiveXContainer", NULL);
 300         OleSetContainedObject(m_oleObject, TRUE);
 301
 302     if (! (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST))
 303                 m_oleObject->SetClientSite(m_clientSite);
 304
 305
 306         int w, h;
 307         GetClientSize(&w, &h);
 308         RECT posRect;
 309         posRect.left = 0;
 310         posRect.top = 0;
 311         posRect.right = w;
 312         posRect.bottom = h;
 313
 314     m_oleObjectHWND = 0;
 315         hret = m_oleInPlaceObject->GetWindow(&m_oleObjectHWND);
 316         WXOLE_WARN(hret, "m_oleInPlaceObject->GetWindow(&m_oleObjectHWND)");
 317     if (SUCCEEDED(hret))
 318             ::SetActiveWindow(m_oleObjectHWND);
 319
 320
 321     if (! (dwMiscStatus & OLEMISC_INVISIBLEATRUNTIME))
 322     {
 323                 if (w > 0 && h > 0)
 324                         m_oleInPlaceObject->SetObjectRects(&posRect, &posRect);
 325
 326                 hret = m_oleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, m_clientSite, 0, (HWND)GetHWND(), &posRect);
 327         hret = m_oleObject->DoVerb(OLEIVERB_SHOW, 0, m_clientSite, 0, (HWND)GetHWND(), &posRect);
 328     };
 329
 330         if (! m_oleObjectHWND)
 331         {
 332                 hret = m_oleInPlaceObject->GetWindow(&m_oleObjectHWND);
 333                 WXOLE_WARN(hret, "m_oleInPlaceObject->GetWindow(&m_oleObjectHWND)");
 334         };
 335
 336         if (m_oleObjectHWND)
 337         {
 338                 ::SetActiveWindow(m_oleObjectHWND);
 339                 ::ShowWindow(m_oleObjectHWND, SW_SHOW);
 340         };
 341 }
 342
 343 void wxActiveX::CreateActiveX(LPOLESTR progId)
 344 {
 345     CLSID clsid;
 346     if (CLSIDFromProgID(progId, &clsid) != S_OK)
 347         return;
 348
 349     CreateActiveX(clsid);
 350 };
 351
 352 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
 353 // Case Insensitive Map of Event names to eventTypes
 354 // created dynamically at run time in:
 355 //      EVT_ACTIVEX(eventName, id, fn)
 356 // we map the pointer to them so that:
 357 //      const wxEventType& RegisterActiveXEvent(wxString eventName);
 358 // can return a const reference, which is neccessary for event tables
 359 // probably should use a wxWindows hash table here, but I'm lazy ...
 360 struct less_wxStringI
 361 {
 362     bool operator()(const wxString& x, const wxString& y) const
 363     {
 364         return x.CmpNoCase(y) < 0;
 365     };
 366 };
 367
 368 typedef map<wxString, wxEventType *, less_wxStringI> ActiveXEventMap;
 369 static ActiveXEventMap sg_eventMap;
 370
 371 // one off class for automatic freeing of activeX eventtypes
 372 class ActiveXEventMapFlusher
 373 {
 374 public:
 375     ~ActiveXEventMapFlusher()
 376     {
 377         ActiveXEventMap::iterator it = sg_eventMap.end();
 378         while (it != sg_eventMap.end())
 379         {
 380             delete it->second;
 381             it++;
 382         };
 383     };
 384 };
 385
 386 static ActiveXEventMapFlusher s_dummyActiveXEventMapFlusher;
 387
 388 const wxEventType& RegisterActiveXEvent(wxString eventName)
 389 {
 390     ActiveXEventMap::iterator it = sg_eventMap.find(eventName);
 391     if (it == sg_eventMap.end())
 392     {
 393         wxEventType  *et = new wxEventType(wxNewEventType());
 394         sg_eventMap[eventName] = et;
 395
 396         return *et;
 397     };
 398
 399     return *(it->second);
 400 };
 401
 402 //////////////////////////////////////////////////////
 403 bool MSWVariantToVariant(VARIANTARG& va, wxVariant& vx)
 404 {
 405     switch(va.vt)
 406     {
 407         case VT_VARIANT | VT_BYREF:
 408                 return MSWVariantToVariant(*va.pvarVal, vx);
 409
 410     case VT_I2:
 411     case VT_I4:
 412         vx = (long) va.iVal;
 413         return true;
 414
 415     case VT_I2 | VT_BYREF:
 416     case VT_I4 | VT_BYREF:
 417         vx = (long) *va.piVal;
 418         return true;
 419
 420     case VT_BSTR:
 421         vx = wxString(va.bstrVal);
 422         return true;
 423
 424     case VT_BSTR | VT_BYREF:
 425         vx = wxString(*va.pbstrVal);
 426         return true;
 427
 428         case VT_BOOL:
 429                 vx = (va.boolVal != FALSE);
 430                 return true;
 431
 432         case VT_BOOL | VT_BYREF:
 433                 vx = (*va.pboolVal != FALSE);
 434                 return true;
 435
 436     default:
 437         vx.MakeNull();
 438         return false;
 439     };
 440 };
 441
 442 bool VariantToMSWVariant(wxVariant& vx, VARIANTARG& va)
 443 {
 444     switch(va.vt)
 445     {
 446         case VT_VARIANT | VT_BYREF:
 447                 return VariantToMSWVariant(vx, va);
 448
 449     case VT_I2:
 450     case VT_I4:
 451         va.iVal = (long) vx;
 452         return true;
 453
 454     case VT_I2 | VT_BYREF:
 455     case VT_I4 | VT_BYREF:
 456          *va.piVal = (long) vx;
 457         return true;
 458
 459         case VT_BOOL:
 460                 va.boolVal = ((bool) vx) ? TRUE : FALSE;
 461                 return true;
 462
 463         case VT_BOOL | VT_BYREF:
 464                 *va.pboolVal = ((bool) vx) ? TRUE : FALSE;
 465                 return true;
 466
 467     default:
 468         return false;
 469     };
 470 };
 471
 472 class wxActiveXEvents : public IDispatch
 473 {
 474 private:
 475     DECLARE_OLE_UNKNOWN(wxActiveXEvents);
 476
 477
 478     wxActiveX *m_activeX;
 479
 480 public:
 481     wxActiveXEvents(wxActiveX *ax) : m_activeX(ax) {}
 482         ~wxActiveXEvents()
 483     {
 484     }
 485
 486         //IDispatch
 487         STDMETHODIMP GetIDsOfNames(REFIID r, OLECHAR** o, unsigned int i, LCID l, DISPID* d)
 488         {
 489         return E_NOTIMPL;
 490     };
 491
 492         STDMETHODIMP GetTypeInfo(unsigned int i, LCID l, ITypeInfo** t)
 493         {
 494         return E_NOTIMPL;
 495     };
 496
 497         STDMETHODIMP GetTypeInfoCount(unsigned int* i)
 498         {
 499         return E_NOTIMPL;
 500     };
 501
 502
 503
 504         STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
 505                                                   WORD wFlags, DISPPARAMS * pDispParams,
 506                                                   VARIANT * pVarResult, EXCEPINFO * pExcepInfo,
 507                                                   unsigned int * puArgErr)
 508         {
 509             if (wFlags & (DISPATCH_PROPERTYGET | DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF))
 510             return E_NOTIMPL;
 511
 512         // map dispid to name
 513         wxActiveX::MemberIdList::iterator mid = m_activeX->m_eventsIdx.find((MEMBERID) dispIdMember);
 514         if (mid == m_activeX->m_eventsIdx.end())
 515             return S_OK;
 516
 517         int idx = mid->second;
 518
 519
 520         wxActiveX::FuncX &func = m_activeX->m_events[idx];
 521
 522         ActiveXEventMap::iterator it = sg_eventMap.find(func.name);
 523         if (it == sg_eventMap.end())
 524             return S_OK;
 525
 526                 wxActiveXEvent  event;
 527         event.SetId(m_activeX->GetId());
 528             event.SetEventType(*(it->second));
 529         event.m_params.NullList();
 530
 531         // arguments
 532         if (pDispParams)
 533         {
 534                         // cdecl call
 535             for (int i = pDispParams->cArgs - 1; i >= 0; i--)
 536             {
 537                 VARIANTARG& va = pDispParams->rgvarg[i];
 538                                 wxActiveX::ParamX &px = func.params[pDispParams->cArgs - i - 1];
 539                 wxVariant vx;
 540
 541                 MSWVariantToVariant(va, vx);
 542                 vx.SetName(px.name);
 543                 event.m_params.Append(vx);
 544             };
 545         };
 546
 547                 if (func.hasOut)
 548                 {
 549                 m_activeX->GetParent()->ProcessEvent(event);
 550             for (unsigned int i = 0; i < pDispParams->cArgs; i++)
 551             {
 552                 VARIANTARG& va = pDispParams->rgvarg[i];
 553                                 wxActiveX::ParamX &px = func.params[pDispParams->cArgs - i - 1];
 554
 555                                 if (px.IsOut())
 556                                 {
 557                                         wxVariant& vx = event.m_params[pDispParams->cArgs - i - 1];
 558
 559                                         VariantToMSWVariant(vx, va);
 560                                 };
 561                         };
 562                 }
 563                 else
 564                 m_activeX->GetParent()->AddPendingEvent(event);
 565
 566         return S_OK;
 567     }
 568 };
 569
 570
 571 DEFINE_OLE_TABLE(wxActiveXEvents)
 572         OLE_IINTERFACE(IUnknown)
 573         OLE_INTERFACE(IID_IDispatch, IDispatch)
 574 END_OLE_TABLE;
 575
 576
 577 int wxActiveXEvent::ParamCount() const
 578 {
 579     return m_params.GetCount();
 580 };
 581
 582 static wxVariant nullVar;
 583
 584 wxVariant wxActiveXEvent::operator[] (int idx) const
 585 {
 586     return (wxVariant&) operator[] (idx);
 587 };
 588
 589 wxVariant& wxActiveXEvent::operator[] (int idx)
 590 {
 591     wxASSERT(idx >= 0 && idx < ParamCount());
 592
 593     return m_params[idx];
 594 };
 595
 596 wxVariant wxActiveXEvent::operator[] (wxString name) const
 597 {
 598     return (wxVariant&) operator[] (name);
 599 };
 600
 601 wxVariant& wxActiveXEvent::operator[] (wxString name)
 602 {
 603     for (int i = 0; i < m_params.GetCount(); i++)
 604     {
 605         if (name.CmpNoCase(m_params[i].GetName()) == 0)
 606             return m_params[i];
 607     };
 608
 609     wxString err = "wxActiveXEvent::operator[] invalid name <" + name + ">";
 610     err += "\r\nValid Names = :\r\n";
 611     for (i = 0; i < m_params.GetCount(); i++)
 612     {
 613         err += m_params[i].GetName();
 614         err += "\r\n";
 615     };
 616
 617     wxASSERT_MSG(false, err);
 618
 619     return nullVar;
 620 };
 621
 622 void wxActiveX::GetTypeInfo()
 623 {
 624         /*
 625         We are currently only interested in the IDispatch interface
 626         to the control. For dual interfaces (TypeKind = TKIND_INTERFACE)
 627         we should drill down through the inheritance
 628         (using TYPEATTR->cImplTypes) and GetRefTypeOfImplType(n)
 629         and retrieve all the func names etc that way, then generate a C++
 630         header  file for it.
 631
 632         But we don't do this and probably never will, so if we have a DUAL
 633         interface then we query for the IDispatch
 634         via GetRefTypeOfImplType(-1).
 635         */
 636
 637         HRESULT hret = 0;
 638
 639         // get type info via class info
 640         wxAutoOleInterface<IProvideClassInfo> classInfo(IID_IProvideClassInfo, m_ActiveX);
 641         if (! classInfo.Ok())
 642                 return;
 643
 644         // type info
 645         wxAutoOleInterface<ITypeInfo> typeInfo;
 646         hret = classInfo->GetClassInfo(typeInfo.GetRef());
 647         if (! typeInfo.Ok())
 648                 return;
 649
 650         // TYPEATTR
 651         TYPEATTR *ta = NULL;
 652         hret = typeInfo->GetTypeAttr(&ta);
 653         if (! ta)
 654                 return;
 655
 656     // this should be a TKIND_COCLASS
 657     wxASSERT(ta->typekind == TKIND_COCLASS);
 658
 659     // iterate contained interfaces
 660         for (int i = 0; i < ta->cImplTypes; i++)
 661         {
 662                 HREFTYPE rt = 0;
 663
 664                 // get dispatch type info handle
 665                 hret = typeInfo->GetRefTypeOfImplType(i, &rt);
 666                 if (! SUCCEEDED(hret))
 667                         continue;
 668
 669                 // get dispatch type info interface
 670                 wxAutoOleInterface<ITypeInfo>  ti;
 671                 hret = typeInfo->GetRefTypeInfo(rt, ti.GetRef());
 672                 if (! ti.Ok())
 673                         continue;
 674
 675         // check if default event sink
 676         bool defEventSink = false;
 677         int impTypeFlags = 0;
 678         typeInfo->GetImplTypeFlags(i, &impTypeFlags);
 679
 680         if (impTypeFlags & IMPLTYPEFLAG_FDEFAULT)
 681         {
 682             if (impTypeFlags & IMPLTYPEFLAG_FSOURCE)
 683             {
 684                 WXOLE_TRACEOUT("Default Event Sink");
 685                 defEventSink = true;
 686             }
 687             else
 688             {
 689                 WXOLE_TRACEOUT("Default Interface");
 690             }
 691         };
 692
 693
 694                 // process
 695                 GetTypeInfo(ti, defEventSink);
 696         };
 697
 698
 699     // free
 700     typeInfo->ReleaseTypeAttr(ta);
 701 };
 702
 703 void wxActiveX::GetTypeInfo(ITypeInfo *ti, bool defEventSink)
 704 {
 705         ti->AddRef();
 706         wxAutoOleInterface<ITypeInfo> typeInfo(ti);
 707
 708         // TYPEATTR
 709         TYPEATTR *ta = NULL;
 710         HRESULT hret = typeInfo->GetTypeAttr(&ta);
 711         if (! ta)
 712                 return;
 713
 714         if (ta->typekind == TKIND_DISPATCH)
 715         {
 716         WXOLE_TRACEOUT("GUID = " << GetIIDName(ta->guid).c_str());
 717
 718         if (defEventSink)
 719         {
 720             wxActiveXEvents *disp = new wxActiveXEvents(this);
 721             ConnectAdvise(ta->guid, disp);
 722         };
 723
 724
 725                 // Get Function Names
 726                 for (int i = 0; i < ta->cFuncs; i++)
 727                 {
 728                         FUNCDESC FAR *fd = NULL;
 729
 730                         hret = typeInfo->GetFuncDesc(i, &fd);
 731                         if (! fd)
 732                                 continue;
 733
 734                         BSTR anames[1] = {NULL};
 735                         unsigned int n = 0;
 736
 737                         hret = typeInfo->GetNames(fd->memid, anames, 1, &n);
 738
 739                         if (anames[0])
 740                         {
 741                                 wxString name = anames[0];
 742
 743                                 WXOLE_TRACEOUT("Name " << i << " = " << name.c_str());
 744                                 SysFreeString(anames[0]);
 745
 746                 if (defEventSink)
 747                 {
 748                     FuncX func;
 749                     func.name = name;
 750                     func.memid = fd->memid;
 751                                         func.hasOut = false;
 752
 753                     // get Param Names
 754                     unsigned int maxPNames = fd->cParams + 1;
 755                     unsigned int nPNames = 0;
 756                     BSTR *pnames = new BSTR[maxPNames];
 757
 758                     hret = typeInfo->GetNames(fd->memid, pnames, maxPNames, &nPNames);
 759
 760                     SysFreeString(pnames[0]);
 761                                         // params
 762                                         for (int p = 0; p < fd->cParams; p++)
 763                                         {
 764                                                 ParamX param;
 765                                                 param.flags = fd->lprgelemdescParam[p].idldesc.wIDLFlags;
 766                                                 param.vt = fd->lprgelemdescParam[p].tdesc.vt;
 767                         param.name = pnames[p + 1];
 768                         SysFreeString(pnames[p + 1]);
 769
 770                                                 func.hasOut |= param.IsOut();
 771                                                 func.params.push_back(param);
 772                                         };
 773                     delete [] pnames;
 774
 775                     m_events.push_back(func);
 776                     m_eventsIdx[fd->memid] = m_events.size() - 1;
 777                 };
 778                         };
 779
 780                         typeInfo->ReleaseFuncDesc(fd);
 781                 };
 782         }
 783
 784         typeInfo->ReleaseTypeAttr(ta);
 785 };
 786
 787 HRESULT wxActiveX::ConnectAdvise(REFIID riid, IUnknown *events)
 788 {
 789         wxOleConnectionPoint    cp;
 790         DWORD                                   adviseCookie = 0;
 791
 792         wxAutoOleInterface<IConnectionPointContainer> cpContainer(IID_IConnectionPointContainer, m_ActiveX);
 793         if (! cpContainer.Ok())
 794                 return E_FAIL;
 795
 796         HRESULT hret = cpContainer->FindConnectionPoint(riid, cp.GetRef());
 797         if (! SUCCEEDED(hret))
 798                 return hret;
 799
 800         hret = cp->Advise(events, &adviseCookie);
 801
 802         if (SUCCEEDED(hret))
 803                 m_connections.push_back(wxOleConnection(cp, adviseCookie));
 804
 805         return hret;
 806 };
 807
 808 HRESULT wxActiveX::AmbientPropertyChanged(DISPID dispid)
 809 {
 810     wxAutoOleInterface<IOleControl> oleControl(IID_IOleControl, m_oleObject);
 811
 812     if (oleControl.Ok())
 813         return oleControl->OnAmbientPropertyChange(dispid);
 814     else
 815         return S_FALSE;
 816 };
 817
 818 #define HIMETRIC_PER_INCH   2540
 819 #define MAP_PIX_TO_LOGHIM(x,ppli)   MulDiv(HIMETRIC_PER_INCH, (x), (ppli))
 820
 821 static void PixelsToHimetric(SIZEL &sz)
 822 {
 823         static int logX = 0;
 824         static int logY = 0;
 825
 826         if (logY == 0)
 827         {
 828                 // initaliase
 829                 HDC dc = GetDC(NULL);
 830                 logX = GetDeviceCaps(dc, LOGPIXELSX);
 831                 logY = GetDeviceCaps(dc, LOGPIXELSY);
 832                 ReleaseDC(NULL, dc);
 833         };
 834
 835 #define HIMETRIC_INCH   2540
 836 #define CONVERT(x, logpixels)   MulDiv(HIMETRIC_INCH, (x), (logpixels))
 837
 838         sz.cx = CONVERT(sz.cx, logX);
 839         sz.cy = CONVERT(sz.cy, logY);
 840
 841 #undef CONVERT
 842 #undef HIMETRIC_INCH
 843 }
 844
 845
 846 void wxActiveX::OnSize(wxSizeEvent& event)
 847 {
 848         int w, h;
 849         GetClientSize(&w, &h);
 850
 851         RECT posRect;
 852         posRect.left = 0;
 853         posRect.top = 0;
 854         posRect.right = w;
 855         posRect.bottom = h;
 856
 857         if (w <= 0 && h <= 0)
 858                 return;
 859
 860         if (m_oleInPlaceObject)
 861                 m_oleInPlaceObject->SetObjectRects(&posRect, &posRect);
 862
 863         // extents are in HIMETRIC units
 864     SIZEL sz = {w, h};
 865         PixelsToHimetric(sz);
 866
 867     SIZEL sz2;
 868     m_oleObject->GetExtent(DVASPECT_CONTENT, &sz2);
 869     if (sz2.cx !=  sz.cx || sz.cy != sz2.cy)
 870         m_oleObject->SetExtent(DVASPECT_CONTENT, &sz);
 871 }
 872
 873 void wxActiveX::OnSetFocus(wxFocusEvent& event)
 874 {
 875         if (m_oleInPlaceActiveObject.Ok())
 876         m_oleInPlaceActiveObject->OnFrameWindowActivate(TRUE);
 877 }
 878
 879 void wxActiveX::OnKillFocus(wxFocusEvent& event)
 880 {
 881         if (m_oleInPlaceActiveObject.Ok())
 882         m_oleInPlaceActiveObject->OnFrameWindowActivate(FALSE);
 883 }
 884
 885
 886 FrameSite::FrameSite(wxActiveX * win)
 887 {
 888         m_window = win;
 889         m_bSupportsWindowlessActivation = true;
 890         m_bInPlaceLocked = false;
 891         m_bUIActive = false;
 892         m_bInPlaceActive = false;
 893         m_bWindowless = false;
 894
 895         m_nAmbientLocale = 0;
 896         m_clrAmbientForeColor = ::GetSysColor(COLOR_WINDOWTEXT);
 897         m_clrAmbientBackColor = ::GetSysColor(COLOR_WINDOW);
 898         m_bAmbientShowHatching = true;
 899         m_bAmbientShowGrabHandles = true;
 900         m_bAmbientAppearance = true;
 901
 902         m_hDCBuffer = NULL;
 903         m_hWndParent = (HWND)m_window->GetHWND();
 904 }
 905
 906 FrameSite::~FrameSite()
 907 {
 908 }
 909
 910
 911 //IDispatch
 912
 913 HRESULT FrameSite::GetIDsOfNames(REFIID riid, OLECHAR ** rgszNames, unsigned int cNames,
 914                                                                  LCID lcid, DISPID * rgDispId)
 915 {
 916         WXOLE_TRACE("IDispatch::GetIDsOfNames");
 917         return E_NOTIMPL;
 918 }
 919
 920 HRESULT FrameSite::GetTypeInfo(unsigned int iTInfo, LCID lcid, ITypeInfo ** ppTInfo)
 921 {
 922         WXOLE_TRACE("IDispatch::GetTypeInfo");
 923         return E_NOTIMPL;
 924 }
 925
 926 HRESULT FrameSite::GetTypeInfoCount(unsigned int * pcTInfo)
 927 {
 928         WXOLE_TRACE("IDispatch::GetTypeInfoCount");
 929         return E_NOTIMPL;
 930 }
 931
 932 HRESULT FrameSite::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
 933                                                   WORD wFlags, DISPPARAMS * pDispParams,
 934                                                   VARIANT * pVarResult, EXCEPINFO * pExcepInfo,
 935                                                   unsigned int * puArgErr)
 936 {
 937         WXOLE_TRACE("IDispatch::Invoke");
 938
 939         if (!(wFlags & DISPATCH_PROPERTYGET))
 940         return S_OK;
 941
 942     HRESULT hr;
 943
 944         if (pVarResult == NULL)
 945                 return E_INVALIDARG;
 946
 947     //The most common case is boolean, use as an initial type
 948     V_VT(pVarResult) = VT_BOOL;
 949
 950         switch (dispIdMember)
 951         {
 952         case DISPID_AMBIENT_MESSAGEREFLECT:
 953             WXOLE_TRACE("Invoke::DISPID_AMBIENT_MESSAGEREFLECT");
 954             V_BOOL(pVarResult)= FALSE;
 955             return S_OK;
 956
 957         case DISPID_AMBIENT_DISPLAYASDEFAULT:
 958             WXOLE_TRACE("Invoke::DISPID_AMBIENT_DISPLAYASDEFAULT");
 959             V_BOOL(pVarResult)= TRUE;
 960             return S_OK;
 961
 962         case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED:
 963             WXOLE_TRACE("Invoke::DISPID_AMBIENT_OFFLINEIFNOTCONNECTED");
 964             V_BOOL(pVarResult) = TRUE;
 965             return S_OK;
 966
 967
 968         case DISPID_AMBIENT_SILENT:
 969             WXOLE_TRACE("Invoke::DISPID_AMBIENT_SILENT");
 970             V_BOOL(pVarResult)= TRUE;
 971             return S_OK;
 972
 973                 case DISPID_AMBIENT_APPEARANCE:
 974                         pVarResult->vt = VT_BOOL;
 975                         pVarResult->boolVal = m_bAmbientAppearance;
 976                         break;
 977
 978                 case DISPID_AMBIENT_FORECOLOR:
 979                         pVarResult->vt = VT_I4;
 980                         pVarResult->lVal = (long) m_clrAmbientForeColor;
 981                         break;
 982
 983                 case DISPID_AMBIENT_BACKCOLOR:
 984                         pVarResult->vt = VT_I4;
 985                         pVarResult->lVal = (long) m_clrAmbientBackColor;
 986                         break;
 987
 988                 case DISPID_AMBIENT_LOCALEID:
 989                         pVarResult->vt = VT_I4;
 990                         pVarResult->lVal = (long) m_nAmbientLocale;
 991                         break;
 992
 993                 case DISPID_AMBIENT_USERMODE:
 994                         pVarResult->vt = VT_BOOL;
 995                         pVarResult->boolVal = m_window->m_bAmbientUserMode;
 996                         break;
 997
 998                 case DISPID_AMBIENT_SHOWGRABHANDLES:
 999                         pVarResult->vt = VT_BOOL;
1000                         pVarResult->boolVal = m_bAmbientShowGrabHandles;
1001                         break;
1002
1003                 case DISPID_AMBIENT_SHOWHATCHING:
1004                         pVarResult->vt = VT_BOOL;
1005                         pVarResult->boolVal = m_bAmbientShowHatching;
1006                         break;
1007
1008                 default:
1009                         return DISP_E_MEMBERNOTFOUND;
1010         }
1011
1012     return S_OK;
1013 }
1014
1015 //IOleWindow
1016
1017 HRESULT FrameSite::GetWindow(HWND * phwnd)
1018 {
1019         WXOLE_TRACE("IOleWindow::GetWindow");
1020         if (phwnd == NULL)
1021         return E_INVALIDARG;
1022         (*phwnd) = m_hWndParent;
1023         return S_OK;
1024 }
1025
1026 HRESULT FrameSite::ContextSensitiveHelp(BOOL fEnterMode)
1027 {
1028         WXOLE_TRACE("IOleWindow::ContextSensitiveHelp");
1029         return S_OK;
1030 }
1031
1032 //IOleInPlaceUIWindow
1033
1034 HRESULT FrameSite::GetBorder(LPRECT lprectBorder)
1035 {
1036         WXOLE_TRACE("IOleInPlaceUIWindow::GetBorder");
1037         if (lprectBorder == NULL)
1038         return E_INVALIDARG;
1039         return INPLACE_E_NOTOOLSPACE;
1040 }
1041
1042 HRESULT FrameSite::RequestBorderSpace(LPCBORDERWIDTHS pborderwidths)
1043 {
1044         WXOLE_TRACE("IOleInPlaceUIWindow::RequestBorderSpace");
1045         if (pborderwidths == NULL)
1046         return E_INVALIDARG;
1047         return INPLACE_E_NOTOOLSPACE;
1048 }
1049
1050 HRESULT FrameSite::SetBorderSpace(LPCBORDERWIDTHS pborderwidths)
1051 {
1052         WXOLE_TRACE("IOleInPlaceUIWindow::SetBorderSpace");
1053         return S_OK;
1054 }
1055
1056 HRESULT FrameSite::SetActiveObject(IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1057 {
1058         WXOLE_TRACE("IOleInPlaceUIWindow::SetActiveObject");
1059
1060     if (pActiveObject)
1061         pActiveObject->AddRef();
1062
1063     m_window->m_oleInPlaceActiveObject = pActiveObject;
1064         return S_OK;
1065 }
1066
1067 //IOleInPlaceFrame
1068
1069 HRESULT FrameSite::InsertMenus(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths)
1070 {
1071         WXOLE_TRACE("IOleInPlaceFrame::InsertMenus");
1072         return S_OK;
1073 }
1074
1075 HRESULT FrameSite::SetMenu(HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject)
1076 {
1077         WXOLE_TRACE("IOleInPlaceFrame::SetMenu");
1078         return S_OK;
1079 }
1080
1081 HRESULT FrameSite::RemoveMenus(HMENU hmenuShared)
1082 {
1083         WXOLE_TRACE("IOleInPlaceFrame::RemoveMenus");
1084         return S_OK;
1085 }
1086
1087 HRESULT FrameSite::SetStatusText(LPCOLESTR pszStatusText)
1088 {
1089         WXOLE_TRACE("IOleInPlaceFrame::SetStatusText");
1090         //((wxFrame*)wxGetApp().GetTopWindow())->GetStatusBar()->SetStatusText(pszStatusText);
1091         return S_OK;
1092 }
1093
1094 HRESULT FrameSite::EnableModeless(BOOL fEnable)
1095 {
1096         WXOLE_TRACE("IOleInPlaceFrame::EnableModeless");
1097         return S_OK;
1098 }
1099
1100 HRESULT FrameSite::TranslateAccelerator(LPMSG lpmsg, WORD wID)
1101 {
1102         WXOLE_TRACE("IOleInPlaceFrame::TranslateAccelerator");
1103         // TODO: send an event with this id
1104     if (m_window->m_oleInPlaceActiveObject.Ok())
1105         m_window->m_oleInPlaceActiveObject->TranslateAccelerator(lpmsg);
1106
1107         return S_FALSE;
1108 }
1109
1110 //IOleInPlaceSite
1111
1112 HRESULT FrameSite::CanInPlaceActivate()
1113 {
1114         WXOLE_TRACE("IOleInPlaceSite::CanInPlaceActivate");
1115         return S_OK;
1116 }
1117
1118 HRESULT FrameSite::OnInPlaceActivate()
1119 {
1120         WXOLE_TRACE("IOleInPlaceSite::OnInPlaceActivate");
1121         m_bInPlaceActive = true;
1122         return S_OK;
1123 }
1124
1125 HRESULT FrameSite::OnUIActivate()
1126 {
1127         WXOLE_TRACE("IOleInPlaceSite::OnUIActivate");
1128         m_bUIActive = true;
1129         return S_OK;
1130 }
1131
1132 HRESULT FrameSite::GetWindowContext(IOleInPlaceFrame **ppFrame,
1133                                                                         IOleInPlaceUIWindow **ppDoc,
1134                                                                         LPRECT lprcPosRect,
1135                                                                         LPRECT lprcClipRect,
1136                                                                         LPOLEINPLACEFRAMEINFO lpFrameInfo)
1137 {
1138         WXOLE_TRACE("IOleInPlaceSite::GetWindowContext");
1139         if (ppFrame == NULL || ppDoc == NULL || lprcPosRect == NULL ||
1140                 lprcClipRect == NULL || lpFrameInfo == NULL)
1141         {
1142                 if (ppFrame != NULL)
1143             (*ppFrame) = NULL;
1144                 if (ppDoc != NULL)
1145             (*ppDoc) = NULL;
1146                 return E_INVALIDARG;
1147         }
1148
1149     HRESULT hr = QueryInterface(IID_IOleInPlaceFrame, (void **) ppFrame);
1150     if (! SUCCEEDED(hr))
1151     {
1152         WXOLE_TRACE("IOleInPlaceSite::IOleInPlaceFrame Error !");
1153         return E_UNEXPECTED;
1154     };
1155
1156     hr = QueryInterface(IID_IOleInPlaceUIWindow, (void **) ppDoc);
1157     if (! SUCCEEDED(hr))
1158     {
1159         WXOLE_TRACE("IOleInPlaceSite::IOleInPlaceUIWindow Error !");
1160         (*ppFrame)->Release();
1161         *ppFrame = NULL;
1162         return E_UNEXPECTED;
1163     };
1164
1165         int w, h;
1166         m_window->GetClientSize(&w, &h);
1167     if (lprcPosRect)
1168     {
1169             lprcPosRect->left = lprcPosRect->top = 0;
1170             lprcPosRect->right = w;
1171             lprcPosRect->bottom = h;
1172     };
1173     if (lprcClipRect)
1174     {
1175             lprcClipRect->left = lprcClipRect->top = 0;
1176             lprcClipRect->right = w;
1177             lprcClipRect->bottom = h;
1178     };
1179
1180     memset(lpFrameInfo, 0, sizeof(OLEINPLACEFRAMEINFO));
1181     lpFrameInfo->cb = sizeof(OLEINPLACEFRAMEINFO);
1182         lpFrameInfo->hwndFrame = m_hWndParent;
1183
1184         return S_OK;
1185 }
1186
1187 HRESULT FrameSite::Scroll(SIZE scrollExtent)
1188 {
1189         WXOLE_TRACE("IOleInPlaceSite::Scroll");
1190         return S_OK;
1191 }
1192
1193 HRESULT FrameSite::OnUIDeactivate(BOOL fUndoable)
1194 {
1195         WXOLE_TRACE("IOleInPlaceSite::OnUIDeactivate");
1196         m_bUIActive = false;
1197         return S_OK;
1198 }
1199
1200 HRESULT FrameSite::OnInPlaceDeactivate()
1201 {
1202         WXOLE_TRACE("IOleInPlaceSite::OnInPlaceDeactivate");
1203         m_bInPlaceActive = false;
1204         return S_OK;
1205 }
1206
1207 HRESULT FrameSite::DiscardUndoState()
1208 {
1209         WXOLE_TRACE("IOleInPlaceSite::DiscardUndoState");
1210         return S_OK;
1211 }
1212
1213 HRESULT FrameSite::DeactivateAndUndo()
1214 {
1215         WXOLE_TRACE("IOleInPlaceSite::DeactivateAndUndo");
1216         return S_OK;
1217 }
1218
1219 HRESULT FrameSite::OnPosRectChange(LPCRECT lprcPosRect)
1220 {
1221         WXOLE_TRACE("IOleInPlaceSite::OnPosRectChange");
1222     if (m_window->m_oleInPlaceObject.Ok() && lprcPosRect)
1223         m_window->m_oleInPlaceObject->SetObjectRects(lprcPosRect, lprcPosRect);
1224
1225         return S_OK;
1226 }
1227
1228 //IOleInPlaceSiteEx
1229
1230 HRESULT FrameSite::OnInPlaceActivateEx(BOOL * pfNoRedraw, DWORD dwFlags)
1231 {
1232         WXOLE_TRACE("IOleInPlaceSiteEx::OnInPlaceActivateEx");
1233         OleLockRunning(m_window->m_ActiveX, TRUE, FALSE);
1234     if (pfNoRedraw)
1235         (*pfNoRedraw) = FALSE;
1236         return S_OK;
1237 }
1238
1239 HRESULT FrameSite::OnInPlaceDeactivateEx(BOOL fNoRedraw)
1240 {
1241         WXOLE_TRACE("IOleInPlaceSiteEx::OnInPlaceDeactivateEx");
1242     OleLockRunning(m_window->m_ActiveX, FALSE, FALSE);
1243         return S_OK;
1244 }
1245
1246 HRESULT FrameSite::RequestUIActivate()
1247 {
1248         WXOLE_TRACE("IOleInPlaceSiteEx::RequestUIActivate");
1249         return S_OK;
1250 }
1251
1252
1253 //IOleClientSite
1254
1255 HRESULT FrameSite::SaveObject()
1256 {
1257         WXOLE_TRACE("IOleClientSite::SaveObject");
1258         return S_OK;
1259 }
1260
1261 HRESULT FrameSite::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker,
1262                                                           IMoniker ** ppmk)
1263 {
1264         WXOLE_TRACE("IOleClientSite::GetMoniker");
1265         return E_NOTIMPL;
1266 }
1267
1268 HRESULT FrameSite::GetContainer(LPOLECONTAINER * ppContainer)
1269 {
1270         WXOLE_TRACE("IOleClientSite::GetContainer");
1271         if (ppContainer == NULL)
1272         return E_INVALIDARG;
1273
1274     HRESULT hr = QueryInterface(IID_IOleContainer, (void**)(ppContainer));
1275     wxASSERT(SUCCEEDED(hr));
1276
1277         return hr;
1278 }
1279
1280 HRESULT FrameSite::ShowObject()
1281 {
1282         WXOLE_TRACE("IOleClientSite::ShowObject");
1283         if (m_window->m_oleObjectHWND)
1284                 ::ShowWindow(m_window->m_oleObjectHWND, SW_SHOW);
1285         return S_OK;
1286 }
1287
1288 HRESULT FrameSite::OnShowWindow(BOOL fShow)
1289 {
1290         WXOLE_TRACE("IOleClientSite::OnShowWindow");
1291         return S_OK;
1292 }
1293
1294 HRESULT FrameSite::RequestNewObjectLayout()
1295 {
1296         WXOLE_TRACE("IOleClientSite::RequestNewObjectLayout");
1297         return E_NOTIMPL;
1298 }
1299
1300 // IParseDisplayName
1301
1302 HRESULT FrameSite::ParseDisplayName(IBindCtx *pbc, LPOLESTR pszDisplayName,
1303                                                                         ULONG *pchEaten, IMoniker **ppmkOut)
1304 {
1305         WXOLE_TRACE("IParseDisplayName::ParseDisplayName");
1306         return E_NOTIMPL;
1307 }
1308
1309 //IOleContainer
1310
1311 HRESULT FrameSite::EnumObjects(DWORD grfFlags, IEnumUnknown **ppenum)
1312 {
1313         WXOLE_TRACE("IOleContainer::EnumObjects");
1314         return E_NOTIMPL;
1315 }
1316
1317 HRESULT FrameSite::LockContainer(BOOL fLock)
1318 {
1319         WXOLE_TRACE("IOleContainer::LockContainer");
1320         // TODO
1321         return S_OK;
1322 }
1323
1324 //IOleItemContainer
1325
1326 HRESULT FrameSite::GetObject(LPOLESTR pszItem, DWORD dwSpeedNeeded,
1327                                                          IBindCtx * pbc, REFIID riid, void ** ppvObject)
1328 {
1329         WXOLE_TRACE("IOleItemContainer::GetObject");
1330         if (pszItem == NULL)
1331         return E_INVALIDARG;
1332         if (ppvObject == NULL)
1333         return E_INVALIDARG;
1334
1335         *ppvObject = NULL;
1336         return MK_E_NOOBJECT;
1337 }
1338
1339 HRESULT FrameSite::GetObjectStorage(LPOLESTR pszItem, IBindCtx * pbc,
1340                                                                         REFIID riid, void ** ppvStorage)
1341 {
1342         WXOLE_TRACE("IOleItemContainer::GetObjectStorage");
1343         if (pszItem == NULL)
1344         return E_INVALIDARG;
1345         if (ppvStorage == NULL)
1346         return E_INVALIDARG;
1347
1348         *ppvStorage = NULL;
1349         return MK_E_NOOBJECT;
1350 }
1351
1352 HRESULT FrameSite::IsRunning(LPOLESTR pszItem)
1353 {
1354         WXOLE_TRACE("IOleItemContainer::IsRunning");
1355         if (pszItem == NULL)
1356         return E_INVALIDARG;
1357
1358         return MK_E_NOOBJECT;
1359 }
1360
1361
1362
1363 //IOleControlSite
1364
1365 HRESULT FrameSite::OnControlInfoChanged()
1366 {
1367         WXOLE_TRACE("IOleControlSite::OnControlInfoChanged");
1368         return S_OK;
1369 }
1370
1371 HRESULT FrameSite::LockInPlaceActive(BOOL fLock)
1372 {
1373         WXOLE_TRACE("IOleControlSite::LockInPlaceActive");
1374         m_bInPlaceLocked = (fLock) ? true : false;
1375         return S_OK;
1376 }
1377
1378 HRESULT FrameSite::GetExtendedControl(IDispatch ** ppDisp)
1379 {
1380         WXOLE_TRACE("IOleControlSite::GetExtendedControl");
1381         return E_NOTIMPL;
1382 }
1383
1384 HRESULT FrameSite::TransformCoords(POINTL * pPtlHimetric, POINTF * pPtfContainer, DWORD dwFlags)
1385 {
1386         WXOLE_TRACE("IOleControlSite::TransformCoords");
1387         HRESULT hr = S_OK;
1388
1389         if (pPtlHimetric == NULL)
1390                 return E_INVALIDARG;
1391
1392         if (pPtfContainer == NULL)
1393                 return E_INVALIDARG;
1394
1395         return E_NOTIMPL;
1396
1397 }
1398
1399 HRESULT FrameSite::TranslateAccelerator(LPMSG pMsg, DWORD grfModifiers)
1400 {
1401         WXOLE_TRACE("IOleControlSite::TranslateAccelerator");
1402         // TODO: send an event with this id
1403         return E_NOTIMPL;
1404 }
1405
1406 HRESULT FrameSite::OnFocus(BOOL fGotFocus)
1407 {
1408         WXOLE_TRACE("IOleControlSite::OnFocus");
1409         return S_OK;
1410 }
1411
1412 HRESULT FrameSite::ShowPropertyFrame()
1413 {
1414         WXOLE_TRACE("IOleControlSite::ShowPropertyFrame");
1415         return E_NOTIMPL;
1416 }
1417
1418 //IOleCommandTarget
1419
1420 HRESULT FrameSite::QueryStatus(const GUID * pguidCmdGroup, ULONG cCmds,
1421                                                            OLECMD * prgCmds, OLECMDTEXT * pCmdTet)
1422 {
1423         WXOLE_TRACE("IOleCommandTarget::QueryStatus");
1424         if (prgCmds == NULL) return E_INVALIDARG;
1425         bool bCmdGroupFound = false;
1426
1427         for (ULONG nCmd = 0; nCmd < cCmds; nCmd++)
1428         {
1429                 // unsupported by default
1430                 prgCmds[nCmd].cmdf = 0;
1431
1432                 // TODO
1433         }
1434
1435         if (!bCmdGroupFound) { OLECMDERR_E_UNKNOWNGROUP; }
1436         return S_OK;
1437 }
1438
1439 HRESULT FrameSite::Exec(const GUID * pguidCmdGroup, DWORD nCmdID,
1440                                                 DWORD nCmdExecOpt, VARIANTARG * pVaIn,
1441                                                 VARIANTARG * pVaOut)
1442 {
1443         WXOLE_TRACE("IOleCommandTarget::Exec");
1444         bool bCmdGroupFound = false;
1445
1446         if (!bCmdGroupFound) { OLECMDERR_E_UNKNOWNGROUP; }
1447         return OLECMDERR_E_NOTSUPPORTED;
1448 }
1449
1450 //IAdviseSink
1451
1452 void STDMETHODCALLTYPE FrameSite::OnDataChange(FORMATETC * pFormatEtc, STGMEDIUM * pgStgMed)
1453 {
1454         WXOLE_TRACE("IAdviseSink::OnDataChange");
1455 }
1456
1457 void STDMETHODCALLTYPE FrameSite::OnViewChange(DWORD dwAspect, LONG lIndex)
1458 {
1459         WXOLE_TRACE("IAdviseSink::OnViewChange");
1460         // redraw the control
1461 }
1462
1463 void STDMETHODCALLTYPE FrameSite::OnRename(IMoniker * pmk)
1464 {
1465         WXOLE_TRACE("IAdviseSink::OnRename");
1466 }
1467
1468 void STDMETHODCALLTYPE FrameSite::OnSave()
1469 {
1470         WXOLE_TRACE("IAdviseSink::OnSave");
1471 }
1472
1473 void STDMETHODCALLTYPE FrameSite::OnClose()
1474 {
1475         WXOLE_TRACE("IAdviseSink::OnClose");
1476 }
1477
1478 /////////////////////////////////////////////
1479 // IOleDocumentSite
1480 HRESULT STDMETHODCALLTYPE FrameSite::ActivateMe(
1481         /* [in] */ IOleDocumentView __RPC_FAR *pViewToActivate)
1482 {
1483     wxAutoOleInterface<IOleInPlaceSite> inPlaceSite(IID_IOleInPlaceSite, (IDispatch *) this);
1484     if (!inPlaceSite.Ok())
1485         return E_FAIL;
1486
1487     if (pViewToActivate)
1488     {
1489         m_window->m_docView = pViewToActivate;
1490         m_window->m_docView->SetInPlaceSite(inPlaceSite);
1491     }
1492     else
1493     {
1494         wxAutoOleInterface<IOleDocument> oleDoc(IID_IOleDocument, m_window->m_oleObject);
1495         if (! oleDoc.Ok())
1496                 return E_FAIL;
1497
1498         HRESULT hr = oleDoc->CreateView(inPlaceSite, NULL, 0, m_window->m_docView.GetRef());
1499         if (hr != S_OK)
1500                 return E_FAIL;
1501
1502                 m_window->m_docView->SetInPlaceSite(inPlaceSite);
1503     };
1504
1505     m_window->m_docView->UIActivate(TRUE);
1506
1507     return S_OK;
1508 };
1509
1510
1511
1512 static IMalloc *iMalloc = NULL;
1513
1514 IMalloc *wxOleInit::GetIMalloc()
1515 {
1516         assert(iMalloc);
1517         return iMalloc;
1518 };
1519
1520 wxOleInit::wxOleInit()
1521 {
1522     if (OleInitialize(NULL) == S_OK && iMalloc == NULL)
1523             CoGetMalloc(1, &iMalloc);
1524     else if (iMalloc)
1525         iMalloc->AddRef();
1526 };
1527
1528 wxOleInit::~wxOleInit()
1529 {
1530         if (iMalloc)
1531     {
1532         if (iMalloc->Release() == 0)
1533                 iMalloc = NULL;
1534     };
1535
1536     OleUninitialize();
1537 }
1538
1539 wxString OLEHResultToString(HRESULT hr)
1540 {
1541     switch (hr)
1542     {
1543     case S_OK:
1544         return "";
1545
1546     case OLECMDERR_E_UNKNOWNGROUP:
1547                 return "The pguidCmdGroup parameter is not NULL but does not specify a recognized command group.";
1548
1549     case OLECMDERR_E_NOTSUPPORTED:
1550                 return "The nCmdID parameter is not a valid command in the group identified by pguidCmdGroup.";
1551
1552     case OLECMDERR_E_DISABLED:
1553                 return "The command identified by nCmdID is currently disabled and cannot be executed.";
1554
1555     case OLECMDERR_E_NOHELP:
1556                 return "The caller has asked for help on the command identified by nCmdID, but no help is available.";
1557
1558     case OLECMDERR_E_CANCELED:
1559                 return "The user canceled the execution of the command.";
1560
1561     case E_INVALIDARG:
1562         return "E_INVALIDARG";
1563
1564     case E_OUTOFMEMORY:
1565         return "E_OUTOFMEMORY";
1566
1567     case E_NOINTERFACE:
1568         return "E_NOINTERFACE";
1569
1570     case E_UNEXPECTED:
1571         return "E_UNEXPECTED";
1572
1573     case STG_E_INVALIDFLAG:
1574         return "STG_E_INVALIDFLAG";
1575
1576     case E_FAIL:
1577         return "E_FAIL";
1578
1579     case E_NOTIMPL:
1580         return "E_NOTIMPL";
1581
1582     default:
1583         {
1584             char buf[64];
1585             sprintf(buf, "Unknown - 0x%X", hr);
1586             return wxString(buf);
1587         }
1588     };
1589 };
1590
1591 // borrowed from src/msw/ole/oleutils.cpp
1592 wxString GetIIDName(REFIID riid)
1593 {
1594   // an association between symbolic name and numeric value of an IID
1595   struct KNOWN_IID
1596   {
1597     const IID  *pIid;
1598     const wxChar *szName;
1599   };
1600
1601   // construct the table containing all known interfaces
1602   #define ADD_KNOWN_IID(name) { &IID_I##name, _T(#name) }
1603   #define ADD_KNOWN_GUID(name) { &name, _T(#name) }
1604
1605   static const KNOWN_IID aKnownIids[] =
1606   {
1607     ADD_KNOWN_IID(AdviseSink),
1608     ADD_KNOWN_IID(AdviseSink2),
1609     ADD_KNOWN_IID(BindCtx),
1610     ADD_KNOWN_IID(ClassFactory),
1611 #if ( !defined( __VISUALC__) || (__VISUALC__!=1010) ) && !defined(__MWERKS__)
1612     ADD_KNOWN_IID(ContinueCallback),
1613     ADD_KNOWN_IID(EnumOleDocumentViews),
1614     ADD_KNOWN_IID(OleCommandTarget),
1615     ADD_KNOWN_IID(OleDocument),
1616     ADD_KNOWN_IID(OleDocumentSite),
1617     ADD_KNOWN_IID(OleDocumentView),
1618     ADD_KNOWN_IID(Print),
1619 #endif
1620     ADD_KNOWN_IID(DataAdviseHolder),
1621     ADD_KNOWN_IID(DataObject),
1622     ADD_KNOWN_IID(Debug),
1623     ADD_KNOWN_IID(DebugStream),
1624     ADD_KNOWN_IID(DfReserved1),
1625     ADD_KNOWN_IID(DfReserved2),
1626     ADD_KNOWN_IID(DfReserved3),
1627     ADD_KNOWN_IID(Dispatch),
1628     ADD_KNOWN_IID(DropSource),
1629     ADD_KNOWN_IID(DropTarget),
1630     ADD_KNOWN_IID(EnumCallback),
1631     ADD_KNOWN_IID(EnumFORMATETC),
1632     ADD_KNOWN_IID(EnumGeneric),
1633     ADD_KNOWN_IID(EnumHolder),
1634     ADD_KNOWN_IID(EnumMoniker),
1635     ADD_KNOWN_IID(EnumOLEVERB),
1636     ADD_KNOWN_IID(EnumSTATDATA),
1637     ADD_KNOWN_IID(EnumSTATSTG),
1638     ADD_KNOWN_IID(EnumString),
1639     ADD_KNOWN_IID(EnumUnknown),
1640     ADD_KNOWN_IID(EnumVARIANT),
1641     ADD_KNOWN_IID(ExternalConnection),
1642     ADD_KNOWN_IID(InternalMoniker),
1643     ADD_KNOWN_IID(LockBytes),
1644     ADD_KNOWN_IID(Malloc),
1645     ADD_KNOWN_IID(Marshal),
1646     ADD_KNOWN_IID(MessageFilter),
1647     ADD_KNOWN_IID(Moniker),
1648     ADD_KNOWN_IID(OleAdviseHolder),
1649     ADD_KNOWN_IID(OleCache),
1650     ADD_KNOWN_IID(OleCache2),
1651     ADD_KNOWN_IID(OleCacheControl),
1652     ADD_KNOWN_IID(OleClientSite),
1653     ADD_KNOWN_IID(OleContainer),
1654     ADD_KNOWN_IID(OleInPlaceActiveObject),
1655     ADD_KNOWN_IID(OleInPlaceFrame),
1656     ADD_KNOWN_IID(OleInPlaceObject),
1657     ADD_KNOWN_IID(OleInPlaceSite),
1658     ADD_KNOWN_IID(OleInPlaceUIWindow),
1659     ADD_KNOWN_IID(OleItemContainer),
1660     ADD_KNOWN_IID(OleLink),
1661     ADD_KNOWN_IID(OleManager),
1662     ADD_KNOWN_IID(OleObject),
1663     ADD_KNOWN_IID(OlePresObj),
1664     ADD_KNOWN_IID(OleWindow),
1665     ADD_KNOWN_IID(PSFactory),
1666     ADD_KNOWN_IID(ParseDisplayName),
1667     ADD_KNOWN_IID(Persist),
1668     ADD_KNOWN_IID(PersistFile),
1669     ADD_KNOWN_IID(PersistStorage),
1670     ADD_KNOWN_IID(PersistStream),
1671     ADD_KNOWN_IID(ProxyManager),
1672     ADD_KNOWN_IID(RootStorage),
1673     ADD_KNOWN_IID(RpcChannel),
1674     ADD_KNOWN_IID(RpcProxy),
1675     ADD_KNOWN_IID(RpcStub),
1676     ADD_KNOWN_IID(RunnableObject),
1677     ADD_KNOWN_IID(RunningObjectTable),
1678     ADD_KNOWN_IID(StdMarshalInfo),
1679     ADD_KNOWN_IID(Storage),
1680     ADD_KNOWN_IID(Stream),
1681     ADD_KNOWN_IID(StubManager),
1682     ADD_KNOWN_IID(Unknown),
1683     ADD_KNOWN_IID(ViewObject),
1684     ADD_KNOWN_IID(ViewObject2),
1685     ADD_KNOWN_GUID(IID_IDispatch),
1686     ADD_KNOWN_GUID(IID_IWebBrowser),
1687     ADD_KNOWN_GUID(IID_IWebBrowserApp),
1688     ADD_KNOWN_GUID(IID_IWebBrowser2),
1689     ADD_KNOWN_GUID(IID_IWebBrowser),
1690     ADD_KNOWN_GUID(DIID_DWebBrowserEvents2),
1691     ADD_KNOWN_GUID(DIID_DWebBrowserEvents),
1692   };
1693
1694   // don't clobber preprocessor name space
1695   #undef ADD_KNOWN_IID
1696   #undef ADD_KNOWN_GUID
1697
1698   // try to find the interface in the table
1699   for ( size_t ui = 0; ui < WXSIZEOF(aKnownIids); ui++ )
1700   {
1701     if ( riid == *aKnownIids[ui].pIid )
1702     {
1703       return aKnownIids[ui].szName;
1704     }
1705   }
1706
1707   // unknown IID, just transform to string
1708   LPOLESTR str = NULL;
1709   StringFromIID(riid, &str);
1710   if (str)
1711   {
1712       wxString s = str;
1713       CoTaskMemFree(str);
1714       return s;
1715   }
1716   else
1717       return "StringFromIID() error";
1718 }