]> git.saurik.com Git - wxWidgets.git/blob - wxPython/contrib/activex/wxie/wxactivex.cpp
projects / wxWidgets.git / blob
? search:


1fb0755413c60535bfb9c9968535236ac7dac0f9
[wxWidgets.git] / wxPython / contrib / activex / wxie / wxactivex.cpp
1 /*
2 wxActiveX Library Licence, Version 3
3 ====================================
4
5 Copyright (C) 2003 Lindsay Mathieson [, ...]
6
7 Everyone is permitted to copy and distribute verbatim copies
8 of this licence document, but changing it is not allowed.
9
10 wxActiveX LIBRARY LICENCE
11 TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
12
13 This library is free software; you can redistribute it and/or modify it
14 under the terms of the GNU Library General Public Licence as published by
15 the Free Software Foundation; either version 2 of the Licence, or (at
16 your option) any later version.
17
18 This library is distributed in the hope that it will be useful, but
19 WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library
21 General Public Licence for more details.
22
23 You should have received a copy of the GNU Library General Public Licence
24 along with this software, usually in a file named COPYING.LIB. If not,
25 write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
26 Boston, MA 02111-1307 USA.
27
28 EXCEPTION NOTICE
29
30 1. As a special exception, the copyright holders of this library give
31 permission for additional uses of the text contained in this release of
32 the library as licenced under the wxActiveX Library Licence, applying
33 either version 3 of the Licence, or (at your option) any later version of
34 the Licence as published by the copyright holders of version 3 of the
35 Licence document.
36
37 2. The exception is that you may use, copy, link, modify and distribute
38 under the user's own terms, binary object code versions of works based
39 on the Library.
40
41 3. If you copy code from files distributed under the terms of the GNU
42 General Public Licence or the GNU Library General Public Licence into a
43 copy of this library, as this licence permits, the exception does not
44 apply to the code that you add in this way. To avoid misleading anyone as
45 to the status of such modified files, you must delete this exception
46 notice from such code and/or adjust the licensing conditions notice
47 accordingly.
48
49 4. If you write modifications of your own for this library, it is your
50 choice whether to permit this exception to apply to your modifications.
51 If you do not wish that, you must delete the exception notice from such
52 code and/or adjust the licensing conditions notice accordingly.
53 */
54
55 #include "wxActiveX.h"
56 #include <wx/strconv.h>
57 #include <wx/event.h>
58 #include <wx/string.h>
59 #include <wx/datetime.h>
60 #include <wx/log.h>
61 #include <oleidl.h>
62 #include <winerror.h>
63 #include <idispids.h>
64 #include <olectl.h>
65 using namespace std;
66
67 // Depending on compilation mode, the wx headers may have undef'd
68 // this, but in this case we need it so the virtual method in
69 // FrameSite will match what is in oleidl.h.
70 #ifndef GetObject
71 #ifdef _UNICODE
72 #define GetObject GetObjectW
73 #else
74 #define GetObject GetObjectA
75 #endif
76 #endif
77
78
79 //////////////////////////////////////////////////////////////////////
80 BEGIN_EVENT_TABLE(wxActiveX, wxWindow)
81 EVT_SIZE(wxActiveX::OnSize)
82 EVT_PAINT(wxActiveX::OnPaint)
83 EVT_MOUSE_EVENTS(wxActiveX::OnMouse)
84 EVT_SET_FOCUS(wxActiveX::OnSetFocus)
85 EVT_KILL_FOCUS(wxActiveX::OnKillFocus)
86 END_EVENT_TABLE()
87
88 IMPLEMENT_CLASS(wxActiveX, wxWindow)
89
90 class wxActiveX;
91
92 class FrameSite :
93 public IOleClientSite,
94 public IOleInPlaceSiteEx,
95 public IOleInPlaceFrame,
96 public IOleItemContainer,
97 public IDispatch,
98 public IOleCommandTarget,
99 public IOleDocumentSite,
100 public IAdviseSink,
101 public IOleControlSite
102 {
103 private:
104 DECLARE_OLE_UNKNOWN(FrameSite);
105
106 public:
107 FrameSite(wxActiveX * win);
108 virtual ~FrameSite();
109
110 //IOleWindow
111 STDMETHODIMP GetWindow(HWND*);
112 STDMETHODIMP ContextSensitiveHelp(BOOL);
113
114 //IOleInPlaceUIWindow
115 STDMETHODIMP GetBorder(LPRECT);
116 STDMETHODIMP RequestBorderSpace(LPCBORDERWIDTHS);
117 STDMETHODIMP SetBorderSpace(LPCBORDERWIDTHS);
118 STDMETHODIMP SetActiveObject(IOleInPlaceActiveObject*, LPCOLESTR);
119
120 //IOleInPlaceFrame
121 STDMETHODIMP InsertMenus(HMENU, LPOLEMENUGROUPWIDTHS);
122 STDMETHODIMP SetMenu(HMENU, HOLEMENU, HWND);
123 STDMETHODIMP RemoveMenus(HMENU);
124 STDMETHODIMP SetStatusText(LPCOLESTR);
125 STDMETHODIMP EnableModeless(BOOL);
126 STDMETHODIMP TranslateAccelerator(LPMSG, WORD);
127
128 //IOleInPlaceSite
129 STDMETHODIMP CanInPlaceActivate();
130 STDMETHODIMP OnInPlaceActivate();
131 STDMETHODIMP OnUIActivate();
132 STDMETHODIMP GetWindowContext(IOleInPlaceFrame**, IOleInPlaceUIWindow**,
133 LPRECT, LPRECT, LPOLEINPLACEFRAMEINFO);
134 STDMETHODIMP Scroll(SIZE);
135 STDMETHODIMP OnUIDeactivate(BOOL);
136 STDMETHODIMP OnInPlaceDeactivate();
137 STDMETHODIMP DiscardUndoState();
138 STDMETHODIMP DeactivateAndUndo();
139 STDMETHODIMP OnPosRectChange(LPCRECT);
140
141 //IOleInPlaceSiteEx
142 STDMETHODIMP OnInPlaceActivateEx(BOOL*, DWORD);
143 STDMETHODIMP OnInPlaceDeactivateEx(BOOL);
144 STDMETHODIMP RequestUIActivate();
145
146 //IOleClientSite
147 STDMETHODIMP SaveObject();
148 STDMETHODIMP GetMoniker(DWORD, DWORD, IMoniker**);
149 STDMETHODIMP GetContainer(LPOLECONTAINER FAR*);
150 STDMETHODIMP ShowObject();
151 STDMETHODIMP OnShowWindow(BOOL);
152 STDMETHODIMP RequestNewObjectLayout();
153
154 //IOleControlSite
155 STDMETHODIMP OnControlInfoChanged();
156 STDMETHODIMP LockInPlaceActive(BOOL);
157 STDMETHODIMP GetExtendedControl(IDispatch**);
158 STDMETHODIMP TransformCoords(POINTL*, POINTF*, DWORD);
159 STDMETHODIMP TranslateAccelerator(LPMSG, DWORD);
160 STDMETHODIMP OnFocus(BOOL);
161 STDMETHODIMP ShowPropertyFrame();
162
163 //IOleCommandTarget
164 STDMETHODIMP QueryStatus(const GUID*, ULONG, OLECMD[], OLECMDTEXT*);
165 STDMETHODIMP Exec(const GUID*, DWORD, DWORD, VARIANTARG*, VARIANTARG*);
166
167 //IParseDisplayName
168 STDMETHODIMP ParseDisplayName(IBindCtx*, LPOLESTR, ULONG*, IMoniker**);
169
170 //IOleContainer
171 STDMETHODIMP EnumObjects(DWORD, IEnumUnknown**);
172 STDMETHODIMP LockContainer(BOOL);
173
174 //IOleItemContainer
175 STDMETHODIMP GetObject(LPOLESTR, DWORD, IBindCtx*, REFIID, void**);
176 STDMETHODIMP GetObjectStorage(LPOLESTR, IBindCtx*, REFIID, void**);
177 STDMETHODIMP IsRunning(LPOLESTR);
178
179 //IDispatch
180 STDMETHODIMP GetIDsOfNames(REFIID, OLECHAR**, unsigned int, LCID, DISPID*);
181 STDMETHODIMP GetTypeInfo(unsigned int, LCID, ITypeInfo**);
182 STDMETHODIMP GetTypeInfoCount(unsigned int*);
183 STDMETHODIMP Invoke(DISPID, REFIID, LCID, WORD, DISPPARAMS*, VARIANT*, EXCEPINFO*, UINT*);
184
185 //IAdviseSink
186 void STDMETHODCALLTYPE OnDataChange(FORMATETC*, STGMEDIUM*);
187 void STDMETHODCALLTYPE OnViewChange(DWORD, LONG);
188 void STDMETHODCALLTYPE OnRename(IMoniker*);
189 void STDMETHODCALLTYPE OnSave();
190 void STDMETHODCALLTYPE OnClose();
191
192 // IOleDocumentSite
193 HRESULT STDMETHODCALLTYPE ActivateMe(IOleDocumentView __RPC_FAR *pViewToActivate);
194
195 protected:
196
197 wxActiveX * m_window;
198
199 HDC m_hDCBuffer;
200 HWND m_hWndParent;
201
202 bool m_bSupportsWindowlessActivation;
203 bool m_bInPlaceLocked;
204 bool m_bInPlaceActive;
205 bool m_bUIActive;
206 bool m_bWindowless;
207
208
209
210 LCID m_nAmbientLocale;
211 COLORREF m_clrAmbientForeColor;
212 COLORREF m_clrAmbientBackColor;
213 bool m_bAmbientShowHatching;
214 bool m_bAmbientShowGrabHandles;
215 bool m_bAmbientAppearance;
216 };
217
218 DEFINE_OLE_TABLE(FrameSite)
219 OLE_INTERFACE(IID_IUnknown, IOleClientSite)
220
221 OLE_IINTERFACE(IOleClientSite)
222
223 OLE_INTERFACE(IID_IOleWindow, IOleInPlaceSite)
224 OLE_IINTERFACE(IOleInPlaceSite)
225 OLE_IINTERFACE(IOleInPlaceSiteEx)
226
227 //OLE_IINTERFACE(IOleWindow)
228 OLE_IINTERFACE(IOleInPlaceUIWindow)
229 OLE_IINTERFACE(IOleInPlaceFrame)
230
231 OLE_IINTERFACE(IParseDisplayName)
232 OLE_IINTERFACE(IOleContainer)
233 OLE_IINTERFACE(IOleItemContainer)
234
235 OLE_IINTERFACE(IDispatch)
236
237 OLE_IINTERFACE(IOleCommandTarget)
238
239 OLE_IINTERFACE(IOleDocumentSite)
240
241 OLE_IINTERFACE(IAdviseSink)
242
243 OLE_IINTERFACE(IOleControlSite)
244
245 END_OLE_TABLE;
246
247
248 wxActiveX::wxActiveX(wxWindow * parent, REFCLSID clsid, wxWindowID id,
249 const wxPoint& pos,
250 const wxSize& size,
251 long style,
252 const wxString& name) :
253 wxWindow(parent, id, pos, size, style, name)
254 {
255 m_bAmbientUserMode = true;
256 m_docAdviseCookie = 0;
257 CreateActiveX(clsid);
258 }
259
260 wxActiveX::wxActiveX(wxWindow * parent, const wxString& progId, wxWindowID id,
261 const wxPoint& pos,
262 const wxSize& size,
263 long style,
264 const wxString& name) :
265 wxWindow(parent, id, pos, size, style, name)
266 {
267 m_bAmbientUserMode = true;
268 m_docAdviseCookie = 0;
269 CreateActiveX((LPOLESTR) (const wchar_t *) progId.wc_str(wxConvUTF8));
270 }
271
272 wxActiveX::~wxActiveX()
273 {
274 // disconnect connection points
275 wxOleConnectionArray::iterator it = m_connections.begin();
276 while (it != m_connections.end())
277 {
278 wxOleConnectionPoint& cp = it->first;
279 cp->Unadvise(it->second);
280
281 it++;
282 };
283 m_connections.clear();
284
285 if (m_oleInPlaceObject.Ok())
286 {
287 m_oleInPlaceObject->InPlaceDeactivate();
288 m_oleInPlaceObject->UIDeactivate();
289 }
290
291
292 if (m_oleObject.Ok())
293 {
294 if (m_docAdviseCookie != 0)
295 m_oleObject->Unadvise(m_docAdviseCookie);
296
297 m_oleObject->DoVerb(OLEIVERB_HIDE, NULL, m_clientSite, 0, (HWND) GetHWND(), NULL);
298 m_oleObject->Close(OLECLOSE_NOSAVE);
299 m_oleObject->SetClientSite(NULL);
300 }
301 }
302
303 void wxActiveX::CreateActiveX(REFCLSID clsid)
304 {
305 SetTransparent();
306
307 HRESULT hret;
308
309 ////////////////////////////////////////////////////////
310 // FrameSite
311 FrameSite *frame = new FrameSite(this);
312 // oleClientSite
313 hret = m_clientSite.QueryInterface(IID_IOleClientSite, (IDispatch *) frame);
314 wxCHECK_RET(SUCCEEDED(hret), _T("m_clientSite.QueryInterface failed"));
315 // adviseSink
316 wxAutoOleInterface<IAdviseSink> adviseSink(IID_IAdviseSink, (IDispatch *) frame);
317 wxCHECK_RET(adviseSink.Ok(), _T("adviseSink not Ok"));
318
319
320 // Create Object, get IUnknown interface
321 m_ActiveX.CreateInstance(clsid, IID_IUnknown);
322 wxCHECK_RET(m_ActiveX.Ok(), _T("m_ActiveX.CreateInstance failed"));
323
324 // Register object as active
325 unsigned long pdwRegister;
326 hret = RegisterActiveObject(m_ActiveX, clsid, ACTIVEOBJECT_WEAK, &pdwRegister);
327 WXOLE_WARN(hret, "Unable to register object as active");
328
329 // Get Dispatch interface
330 hret = m_Dispatch.QueryInterface(IID_IDispatch, m_ActiveX);
331 WXOLE_WARN(hret, "Unable to get dispatch interface");
332
333 // Type Info
334 GetTypeInfo();
335
336 // Get IOleObject interface
337 hret = m_oleObject.QueryInterface(IID_IOleObject, m_ActiveX);
338 wxCHECK_RET(SUCCEEDED(hret), _("Unable to get IOleObject interface"));
339
340 // get IViewObject Interface
341 hret = m_viewObject.QueryInterface(IID_IViewObject, m_ActiveX);
342 wxCHECK_RET(SUCCEEDED(hret), _T("Unable to get IViewObject Interface"));
343
344 // document advise
345 m_docAdviseCookie = 0;
346 hret = m_oleObject->Advise(adviseSink, &m_docAdviseCookie);
347 WXOLE_WARN(hret, "m_oleObject->Advise(adviseSink, &m_docAdviseCookie),\"Advise\")");
348 m_oleObject->SetHostNames(L"wxActiveXContainer", NULL);
349 OleSetContainedObject(m_oleObject, TRUE);
350 OleRun(m_oleObject);
351
352
353 // Get IOleInPlaceObject interface
354 hret = m_oleInPlaceObject.QueryInterface(IID_IOleInPlaceObject, m_ActiveX);
355 wxCHECK_RET(SUCCEEDED(hret), _T("Unable to get IOleInPlaceObject interface"));
356
357 // status
358 DWORD dwMiscStatus;
359 m_oleObject->GetMiscStatus(DVASPECT_CONTENT, &dwMiscStatus);
360 wxCHECK_RET(SUCCEEDED(hret), _T("Unable to get oleObject status"));
361
362 // set client site first ?
363 if (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST)
364 m_oleObject->SetClientSite(m_clientSite);
365
366
367 // stream init
368 wxAutoOleInterface<IPersistStreamInit>
369 pPersistStreamInit(IID_IPersistStreamInit, m_oleObject);
370
371 if (pPersistStreamInit.Ok())
372 {
373 hret = pPersistStreamInit->InitNew();
374 WXOLE_WARN(hret, "CreateActiveX::pPersistStreamInit->InitNew()");
375 };
376
377 if (! (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST))
378 m_oleObject->SetClientSite(m_clientSite);
379
380
381 int w, h;
382 GetClientSize(&w, &h);
383 RECT posRect;
384 posRect.left = 0;
385 posRect.top = 0;
386 posRect.right = w;
387 posRect.bottom = h;
388
389 m_oleObjectHWND = 0;
390
391 if (m_oleInPlaceObject.Ok())
392 {
393 hret = m_oleInPlaceObject->GetWindow(&m_oleObjectHWND);
394 WXOLE_WARN(hret, "m_oleInPlaceObject->GetWindow(&m_oleObjectHWND)");
395 if (SUCCEEDED(hret))
396 ::SetActiveWindow(m_oleObjectHWND);
397 };
398
399
400 if (! (dwMiscStatus & OLEMISC_INVISIBLEATRUNTIME))
401 {
402 if (w > 0 && h > 0 && m_oleInPlaceObject.Ok())
403 m_oleInPlaceObject->SetObjectRects(&posRect, &posRect);
404
405 hret = m_oleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, m_clientSite, 0, (HWND)GetHWND(), &posRect);
406 hret = m_oleObject->DoVerb(OLEIVERB_SHOW, 0, m_clientSite, 0, (HWND)GetHWND(), &posRect);
407 };
408
409 if (! m_oleObjectHWND && m_oleInPlaceObject.Ok())
410 {
411 hret = m_oleInPlaceObject->GetWindow(&m_oleObjectHWND);
412 WXOLE_WARN(hret, "m_oleInPlaceObject->GetWindow(&m_oleObjectHWND)");
413 };
414
415 if (m_oleObjectHWND)
416 {
417 ::SetActiveWindow(m_oleObjectHWND);
418 ::ShowWindow(m_oleObjectHWND, SW_SHOW);
419
420 // Update by GBR to resize older controls
421 wxSizeEvent szEvent;
422 szEvent.m_size = wxSize(w, h) ;
423 GetEventHandler()->AddPendingEvent(szEvent);
424 };
425 }
426
427 void wxActiveX::CreateActiveX(LPOLESTR progId)
428 {
429 CLSID clsid;
430 if (CLSIDFromProgID(progId, &clsid) != S_OK)
431 return;
432
433 CreateActiveX(clsid);
434 };
435
436 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
437 // Case Insensitive Map of Event names to eventTypes
438 // created dynamically at run time in:
439 // EVT_ACTIVEX(eventName, id, fn)
440 // we map the pointer to them so that:
441 // const wxEventType& RegisterActiveXEvent(wxString eventName);
442 // can return a const reference, which is neccessary for event tables
443 // probably should use a wxWindows hash table here, but I'm lazy ...
444 typedef map<wxString, wxEventType *, NS_wxActiveX::less_wxStringI> ActiveXNamedEventMap;
445 static ActiveXNamedEventMap sg_NamedEventMap;
446
447 const wxEventType& RegisterActiveXEvent(const wxChar *eventName)
448 {
449 wxString ev = eventName;
450 ActiveXNamedEventMap::iterator it = sg_NamedEventMap.find(ev);
451 if (it == sg_NamedEventMap.end())
452 {
453 wxEventType *et = new wxEventType(wxNewEventType());
454 sg_NamedEventMap[ev] = et;
455
456 return *et;
457 };
458
459 return *(it->second);
460 };
461
462
463 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
464 // Map of Event DISPID's to eventTypes
465 // created dynamically at run time in:
466 // EVT_ACTIVEX(eventName, id, fn)
467 // we map the pointer to them so that:
468 // const wxEventType& RegisterActiveXEvent(wxString eventName);
469 // can return a const reference, which is neccessary for event tables
470
471 typedef map<DISPID, wxEventType *> ActiveXDISPIDEventMap;
472 static ActiveXDISPIDEventMap sg_dispIdEventMap;
473
474 const wxEventType& RegisterActiveXEvent(DISPID event)
475 {
476 ActiveXDISPIDEventMap::iterator it = sg_dispIdEventMap.find(event);
477 if (it == sg_dispIdEventMap.end())
478 {
479 wxEventType *et = new wxEventType(wxNewEventType());
480 sg_dispIdEventMap[event] = et;
481
482 return *et;
483 };
484
485 return *(it->second);
486 };
487
488 // one off class for automatic freeing of activeX eventtypes
489 class ActiveXEventMapFlusher
490 {
491 public:
492 ~ActiveXEventMapFlusher()
493 {
494 // Named events
495 ActiveXNamedEventMap::iterator it = sg_NamedEventMap.end();
496 while (it != sg_NamedEventMap.end())
497 {
498 delete it->second;
499 it++;
500 };
501 sg_NamedEventMap.clear();
502
503 // DISPID events
504 ActiveXDISPIDEventMap::iterator dit = sg_dispIdEventMap.end();
505 while (dit != sg_dispIdEventMap.end())
506 {
507 delete dit->second;
508 dit++;
509 };
510 sg_dispIdEventMap.clear();
511 };
512 };
513
514 static ActiveXEventMapFlusher s_dummyActiveXEventMapFlusher;
515
516
517 //////////////////////////////////////////////////////
518 VARTYPE wxTypeToVType(const wxVariant& v)
519 {
520 wxString type = v.GetType();
521 if (type == wxT("bool"))
522 return VT_BOOL;
523 else if (type == wxT("char"))
524 return VT_I1;
525 else if (type == wxT("datetime"))
526 return VT_DATE;
527 else if (type == wxT("double"))
528 return VT_R8;
529 else if (type == wxT("list"))
530 return VT_ARRAY;
531 else if (type == wxT("long"))
532 return VT_I4;
533 else if (type == wxT("string"))
534 return VT_BSTR;
535 else if (type == wxT("stringlist"))
536 return VT_ARRAY;
537 else if (type == wxT("date"))
538 return VT_DATE;
539 else if (type == wxT("time"))
540 return VT_DATE;
541 else if (type == wxT("void*"))
542 return VT_VOID | VT_BYREF;
543 else
544 return VT_NULL;
545 };
546
547 bool wxDateTimeToDATE(wxDateTime dt, DATE& d)
548 {
549 SYSTEMTIME st;
550 memset(&st, 0, sizeof(st));
551
552 st.wYear = dt.GetYear();
553 st.wMonth = dt.GetMonth() + 1;
554 st.wDay = dt.GetDay();
555 st.wHour = dt.GetHour();
556 st.wMinute = dt.GetMinute();
557 st.wSecond = dt.GetSecond();
558 st.wMilliseconds = dt.GetMillisecond();
559 return SystemTimeToVariantTime(&st, &d) != FALSE;
560 };
561
562 bool wxDateTimeToVariant(wxDateTime dt, VARIANTARG& va)
563 {
564 return wxDateTimeToDATE(dt, va.date);
565 };
566
567 bool DATEToWxDateTime(DATE date, wxDateTime& dt)
568 {
569 SYSTEMTIME st;
570 if (! VariantTimeToSystemTime(date, &st))
571 return false;
572
573 dt = wxDateTime(
574 st.wDay,
575 wxDateTime::Month(int(wxDateTime::Jan) + st.wMonth - 1),
576 st.wYear,
577 st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
578
579 return true;
580 };
581
582 bool VariantToWxDateTime(VARIANTARG va, wxDateTime& dt)
583 {
584 HRESULT hr = VariantChangeType(&va, &va, 0, VT_DATE);
585 if (! SUCCEEDED(hr))
586 return false;
587
588 return DATEToWxDateTime(va.date, dt);
589 };
590
591 bool MSWVariantToVariant(VARIANTARG& va, wxVariant& vx)
592 {
593 bool byRef = false;
594 VARTYPE vt = va.vt;
595
596 if (vt & VT_ARRAY)
597 return false; // don't support arrays yet
598
599 if (vt & VT_BYREF)
600 {
601 byRef = true;
602 vt &= ~(VT_BYREF);
603 };
604
605
606 switch(vt)
607 {
608 case VT_VARIANT:
609 if (byRef)
610 return MSWVariantToVariant(*va.pvarVal, vx);
611 else
612 {
613 VARIANT tmp = va;
614 VariantChangeType(&tmp, &tmp, 0, wxTypeToVType(vx));
615 bool rc = MSWVariantToVariant(tmp, vx);
616 VariantClear(&tmp);
617 return rc;
618 };
619
620 // 1 byte chars
621 case VT_I1:
622 case VT_UI1:
623 if (byRef)
624 vx = (char) *va.pbVal;
625 else
626 vx = (char) va.bVal;
627 return true;
628
629 // 2 byte shorts
630 case VT_I2:
631 case VT_UI2:
632 if (byRef)
633 vx = (long) *va.puiVal;
634 else
635 vx = (long) va.uiVal;
636 return true;
637
638 // 4 bytes longs
639 case VT_I4:
640 case VT_UI4:
641 case VT_INT:
642 case VT_UINT:
643 case VT_ERROR:
644 if (byRef)
645 vx = (long) *va.pulVal;
646 else
647 vx = (long) va.ulVal;
648 return true;
649
650
651 // 4 byte floats
652 case VT_R4:
653 if (byRef)
654 vx = *va.pfltVal;
655 else
656 vx = va.fltVal;
657 return true;
658
659 // 8 byte doubles
660 case VT_R8:
661 if (byRef)
662 vx = *va.pdblVal;
663 else
664 vx = va.dblVal;
665 return true;
666
667 case VT_BOOL:
668 if (byRef)
669 vx = (*va.pboolVal ? true : false);
670 else
671 vx = (va.boolVal ? true : false);
672 return true;
673
674 case VT_CY:
675 vx.MakeNull();
676 return false; // what the hell is a CY ?
677
678 case VT_DECIMAL:
679 {
680 double d = 0;
681 HRESULT hr;
682 if (byRef)
683 hr = VarR8FromDec(va.pdecVal, &d);
684 else
685 hr = VarR8FromDec(&va.decVal, &d);
686
687 vx = d;
688 return SUCCEEDED(hr);
689 };
690
691 case VT_DATE:
692 {
693 wxDateTime dt;
694 bool rc = false;
695 if (byRef)
696 rc = DATEToWxDateTime(*va.pdate, dt);
697 else
698 rc = VariantToWxDateTime(va, dt);
699 vx = dt;
700 return rc;
701 };
702
703 case VT_BSTR:
704 if (byRef)
705 vx = wxString(*va.pbstrVal);
706 else
707 vx = wxString(va.bstrVal);
708 return true;
709
710 case VT_UNKNOWN: // should do a custom wxVariantData for this
711 if (byRef)
712 vx = (void *) *va.ppunkVal;
713 else
714 vx = (void *) va.punkVal;
715 return false;
716
717 case VT_DISPATCH: // should do a custom wxVariantData for this
718 if (byRef)
719 vx = (void *) *va.ppdispVal;
720 else
721 vx = (void *) va.pdispVal;
722 return false;
723
724 default:
725 vx.MakeNull();
726 return false;
727 };
728 };
729
730 bool VariantToMSWVariant(const wxVariant& vx, VARIANTARG& va)
731 {
732 bool byRef = false;
733 VARTYPE vt = va.vt;
734
735 if (vt & VT_ARRAY)
736 return false; // don't support arrays yet
737
738 if (vt & VT_BYREF)
739 {
740 byRef = true;
741 vt &= ~(VT_BYREF);
742 };
743
744 switch(vt)
745 {
746 case VT_VARIANT:
747 if (byRef)
748 return VariantToMSWVariant(vx, *va.pvarVal);
749 else
750 {
751 va.vt = wxTypeToVType(vx);
752 return VariantToMSWVariant(vx, va);
753 };
754
755 // 1 byte chars
756 case VT_I1:
757 case VT_UI1:
758 if (byRef)
759 *va.pbVal = (char) vx;
760 else
761 va.bVal = (char) vx;
762 return true;
763
764 // 2 byte shorts
765 case VT_I2:
766 case VT_UI2:
767 if (byRef)
768 *va.puiVal = (long) vx;
769 else
770 va.uiVal = (long) vx;
771 return true;
772
773 // 4 bytes longs
774 case VT_I4:
775 case VT_UI4:
776 case VT_INT:
777 case VT_UINT:
778 case VT_ERROR:
779 if (byRef)
780 *va.pulVal = (long) vx;
781 else
782 va.ulVal = (long) vx;
783 return true;
784
785
786 // 4 byte floats
787 case VT_R4:
788 if (byRef)
789 *va.pfltVal = (double) vx;
790 else
791 va.fltVal = (double) vx;
792 return true;
793
794 // 8 byte doubles
795 case VT_R8:
796 if (byRef)
797 *va.pdblVal = (double) vx;
798 else
799 va.dblVal = (double) vx;
800 return true;
801
802 case VT_BOOL:
803 if (byRef)
804 *va.pboolVal = ((bool) vx) ? TRUE : FALSE;
805 else
806 va.boolVal = ((bool) vx) ? TRUE : FALSE;
807 return true;
808
809 case VT_CY:
810 return false; // what the hell is a CY ?
811
812 case VT_DECIMAL:
813 if (byRef)
814 return SUCCEEDED(VarDecFromR8(vx, va.pdecVal));
815 else
816 return SUCCEEDED(VarDecFromR8(vx, &va.decVal));
817
818 case VT_DATE:
819 if (byRef)
820 return wxDateTimeToDATE(vx, *va.pdate);
821 else
822 return wxDateTimeToVariant(vx,va);
823
824 case VT_BSTR:
825 if (byRef)
826 *va.pbstrVal = SysAllocString(vx.GetString().wc_str(wxConvUTF8));
827 else
828 va.bstrVal = SysAllocString(vx.GetString().wc_str(wxConvUTF8));
829 return true;
830
831 case VT_UNKNOWN: // should do a custom wxVariantData for this
832 if (byRef)
833 *va.ppunkVal = (IUnknown *) (void *) vx;
834 else
835 va.punkVal = (IUnknown *) (void *) vx;
836 return false;
837
838 case VT_DISPATCH: // should do a custom wxVariantData for this
839 if (byRef)
840 *va.ppdispVal = (IDispatch *) (void *) vx;
841 else
842 va.pdispVal = (IDispatch *) (void *) vx;
843 return false;
844
845 default:
846 return false;
847 };
848 };
849
850 IMPLEMENT_CLASS(wxActiveXEvent, wxCommandEvent)
851
852 class wxActiveXEvents : public IDispatch
853 {
854 private:
855 DECLARE_OLE_UNKNOWN(wxActiveXEvents);
856
857
858 wxActiveX *m_activeX;
859 IID m_customId;
860 bool m_haveCustomId;
861
862 friend bool wxActiveXEventsInterface(wxActiveXEvents *self, REFIID iid, void **_interface, const char *&desc);
863
864 public:
865 wxActiveXEvents(wxActiveX *ax) : m_activeX(ax), m_haveCustomId(false) {}
866 wxActiveXEvents(wxActiveX *ax, REFIID iid) : m_activeX(ax), m_haveCustomId(true), m_customId(iid) {}
867 virtual ~wxActiveXEvents()
868 {
869 }
870
871 //IDispatch
872 STDMETHODIMP GetIDsOfNames(REFIID r, OLECHAR** o, unsigned int i, LCID l, DISPID* d)
873 {
874 return E_NOTIMPL;
875 };
876
877 STDMETHODIMP GetTypeInfo(unsigned int i, LCID l, ITypeInfo** t)
878 {
879 return E_NOTIMPL;
880 };
881
882 STDMETHODIMP GetTypeInfoCount(unsigned int* i)
883 {
884 return E_NOTIMPL;
885 };
886
887
888 void DispatchEvent(wxActiveX::FuncX &func, const wxEventType& eventType, DISPPARAMS * pDispParams)
889 {
890 wxActiveXEvent event;
891 event.SetId(m_activeX->GetId());
892 event.SetEventType(eventType);
893 event.m_params.NullList();
894 event.m_params.SetName(func.name);
895
896 // arguments
897 if (pDispParams)
898 {
899 // cdecl call
900 // sometimes the pDispParams does not match the param info for a activex control
901 int nArg = wxMin(func.params.size(), pDispParams->cArgs);
902 for (int i = nArg - 1; i >= 0; i--)
903 {
904 VARIANTARG& va = pDispParams->rgvarg[i];
905 wxActiveX::ParamX &px = func.params[nArg - i - 1];
906 wxVariant vx;
907
908 vx.SetName(px.name);
909 MSWVariantToVariant(va, vx);
910 event.m_params.Append(vx);
911 };
912 };
913
914 if (func.hasOut)
915 {
916 int nArg = wxMin(func.params.size(), pDispParams->cArgs);
917 m_activeX->GetEventHandler()->ProcessEvent(event);
918 for (int i = 0; i < nArg; i++)
919 {
920 VARIANTARG& va = pDispParams->rgvarg[i];
921 wxActiveX::ParamX &px = func.params[nArg - i - 1];
922
923 if (px.IsOut())
924 {
925 wxVariant& vx = event.m_params[nArg - i - 1];
926
927 VariantToMSWVariant(vx, va);
928 };
929 };
930 }
931 else
932 m_activeX->GetEventHandler()->AddPendingEvent(event);
933
934 };
935
936 STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
937 WORD wFlags, DISPPARAMS * pDispParams,
938 VARIANT * pVarResult, EXCEPINFO * pExcepInfo,
939 unsigned int * puArgErr)
940 {
941 if (wFlags & (DISPATCH_PROPERTYGET | DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF))
942 return E_NOTIMPL;
943
944 wxASSERT(m_activeX);
945
946 // find event for dispid
947 wxActiveX::MemberIdMap::iterator mit = m_activeX->m_eventMemberIds.find((MEMBERID) dispIdMember);
948 if (mit == m_activeX->m_eventMemberIds.end())
949 return S_OK;
950
951 // sanity check
952 int midx = mit->second;
953 if (midx < 0 || midx >= m_activeX->GetEventCount())
954 return S_OK;
955
956 wxActiveX::FuncX &func = m_activeX->m_events[midx];
957
958
959 // try to find dispid event
960 ActiveXDISPIDEventMap::iterator dit = sg_dispIdEventMap.find(dispIdMember);
961 if (dit != sg_dispIdEventMap.end())
962 {
963 // Dispatch Event
964 DispatchEvent(func, *(dit->second), pDispParams);
965 return S_OK;
966 };
967
968 // try named event
969 ActiveXNamedEventMap::iterator nit = sg_NamedEventMap.find(func.name);
970 if (nit == sg_NamedEventMap.end())
971 return S_OK;
972
973 // Dispatch Event
974 DispatchEvent(func, *(nit->second), pDispParams);
975 return S_OK;
976 }
977 };
978
979 bool wxActiveXEventsInterface(wxActiveXEvents *self, REFIID iid, void **_interface, const char *&desc)
980 {
981 if (self->m_haveCustomId && IsEqualIID(iid, self->m_customId))
982 {
983 WXOLE_TRACE("Found Custom Dispatch Interface");
984 *_interface = (IUnknown *) (IDispatch *) self;
985 desc = "Custom Dispatch Interface";
986 return true;
987 };
988
989 return false;
990 };
991
992 DEFINE_OLE_TABLE(wxActiveXEvents)
993 OLE_IINTERFACE(IUnknown)
994 OLE_INTERFACE(IID_IDispatch, IDispatch)
995 OLE_INTERFACE_CUSTOM(wxActiveXEventsInterface)
996 END_OLE_TABLE;
997
998 wxString wxActiveXEvent::EventName()
999 {
1000 return m_params.GetName();
1001 };
1002
1003 int wxActiveXEvent::ParamCount() const
1004 {
1005 return m_params.GetCount();
1006 };
1007
1008 wxString wxActiveXEvent::ParamType(int idx)
1009 {
1010 wxASSERT(idx >= 0 && idx < m_params.GetCount());
1011
1012 return m_params[idx].GetType();
1013 };
1014
1015 wxString wxActiveXEvent::ParamName(int idx)
1016 {
1017 wxASSERT(idx >= 0 && idx < m_params.GetCount());
1018
1019 return m_params[idx].GetName();
1020 };
1021
1022 static wxVariant nullVar;
1023
1024 wxVariant& wxActiveXEvent::operator[] (int idx)
1025 {
1026 wxASSERT(idx >= 0 && idx < ParamCount());
1027
1028 return m_params[idx];
1029 };
1030
1031 wxVariant& wxActiveXEvent::operator[] (wxString name)
1032 {
1033 for (int i = 0; i < m_params.GetCount(); i++)
1034 {
1035 if (name.CmpNoCase(m_params[i].GetName()) == 0)
1036 return m_params[i];
1037 };
1038
1039 wxString err = _T("wxActiveXEvent::operator[] invalid name <") + name + _T(">");
1040 err += _T("\r\nValid Names = :\r\n");
1041 for (i = 0; i < m_params.GetCount(); i++)
1042 {
1043 err += m_params[i].GetName();
1044 err += _T("\r\n");
1045 };
1046
1047 wxASSERT_MSG(false, err);
1048
1049 return nullVar;
1050 };
1051
1052 void wxActiveX::GetTypeInfo()
1053 {
1054 /*
1055 We are currently only interested in the IDispatch interface
1056 to the control. For dual interfaces (TypeKind = TKIND_INTERFACE)
1057 we should drill down through the inheritance
1058 (using TYPEATTR->cImplTypes) and GetRefTypeOfImplType(n)
1059 and retrieve all the func names etc that way, then generate a C++
1060 header file for it.
1061
1062 But we don't do this and probably never will, so if we have a DUAL
1063 interface then we query for the IDispatch
1064 via GetRefTypeOfImplType(-1).
1065 */
1066
1067 HRESULT hret = 0;
1068
1069 // get type info via class info
1070 wxAutoOleInterface<IProvideClassInfo> classInfo(IID_IProvideClassInfo, m_ActiveX);
1071 if (! classInfo.Ok())
1072 return;
1073
1074 // type info
1075 wxAutoOleInterface<ITypeInfo> typeInfo;
1076 hret = classInfo->GetClassInfo(typeInfo.GetRef());
1077 if (! typeInfo.Ok())
1078 return;
1079
1080 // TYPEATTR
1081 TYPEATTR *ta = NULL;
1082 hret = typeInfo->GetTypeAttr(&ta);
1083 if (! ta)
1084 return;
1085
1086 // this should be a TKIND_COCLASS
1087 wxASSERT(ta->typekind == TKIND_COCLASS);
1088
1089 // iterate contained interfaces
1090 for (int i = 0; i < ta->cImplTypes; i++)
1091 {
1092 HREFTYPE rt = 0;
1093
1094 // get dispatch type info handle
1095 hret = typeInfo->GetRefTypeOfImplType(i, &rt);
1096 if (! SUCCEEDED(hret))
1097 continue;
1098
1099 // get dispatch type info interface
1100 wxAutoOleInterface<ITypeInfo> ti;
1101 hret = typeInfo->GetRefTypeInfo(rt, ti.GetRef());
1102 if (! ti.Ok())
1103 continue;
1104
1105 // check if default event sink
1106 bool defInterface = false;
1107 bool defEventSink = false;
1108 int impTypeFlags = 0;
1109 typeInfo->GetImplTypeFlags(i, &impTypeFlags);
1110
1111 if (impTypeFlags & IMPLTYPEFLAG_FDEFAULT)
1112 {
1113 if (impTypeFlags & IMPLTYPEFLAG_FSOURCE)
1114 {
1115 WXOLE_TRACEOUT("Default Event Sink");
1116 defEventSink = true;
1117 if (impTypeFlags & IMPLTYPEFLAG_FDEFAULTVTABLE)
1118 {
1119 WXOLE_TRACEOUT("*ERROR* - Default Event Sink is via vTable");
1120 defEventSink = false;
1121 };
1122 }
1123 else
1124 {
1125 WXOLE_TRACEOUT("Default Interface");
1126 defInterface = true;
1127 }
1128 };
1129
1130
1131 // process
1132 GetTypeInfo(ti, defInterface, defEventSink);
1133 };
1134
1135
1136 // free
1137 typeInfo->ReleaseTypeAttr(ta);
1138 };
1139
1140 void ElemDescToParam(const ELEMDESC& ed, wxActiveX::ParamX& param)
1141 {
1142 param.flags = ed.idldesc.wIDLFlags;
1143 param.vt = ed.tdesc.vt;
1144 param.isPtr = (param.vt == VT_PTR);
1145 param.isSafeArray = (param.vt == VT_SAFEARRAY);
1146 if (param.isPtr || param.isSafeArray)
1147 param.vt = ed.tdesc.lptdesc->vt;
1148 };
1149
1150 void wxActiveX::GetTypeInfo(ITypeInfo *ti, bool defInterface, bool defEventSink)
1151 {
1152 // wxAutoOleInterface<> assumes a ref has already been added
1153 ti->AddRef();
1154 wxAutoOleInterface<ITypeInfo> typeInfo(ti);
1155
1156 // TYPEATTR
1157 TYPEATTR *ta = NULL;
1158 HRESULT hret = typeInfo->GetTypeAttr(&ta);
1159 if (! ta)
1160 return;
1161
1162 if (ta->typekind == TKIND_DISPATCH)
1163 {
1164 WXOLE_TRACEOUT("GUID = " << GetIIDName(ta->guid).c_str());
1165
1166 if (defEventSink)
1167 {
1168 wxActiveXEvents *disp = new wxActiveXEvents(this, ta->guid);
1169 ConnectAdvise(ta->guid, disp);
1170 };
1171
1172
1173 // Get Function Names
1174 for (int i = 0; i < ta->cFuncs; i++)
1175 {
1176 FUNCDESC FAR *fd = NULL;
1177
1178 hret = typeInfo->GetFuncDesc(i, &fd);
1179 if (! fd)
1180 continue;
1181
1182 BSTR anames[1] = {NULL};
1183 unsigned int n = 0;
1184
1185 hret = typeInfo->GetNames(fd->memid, anames, 1, &n);
1186
1187 if (anames[0])
1188 {
1189 wxString name = anames[0];
1190
1191 WXOLE_TRACEOUT("Name " << i << " = " << name.c_str());
1192 SysFreeString(anames[0]);
1193
1194 if (defInterface || defEventSink)
1195 {
1196 FuncX func;
1197 func.name = name;
1198 func.memid = fd->memid;
1199 func.hasOut = false;
1200
1201 // get Param Names
1202 unsigned int maxPNames = fd->cParams + 1;
1203 unsigned int nPNames = 0;
1204 BSTR *pnames = new BSTR[maxPNames];
1205
1206 hret = typeInfo->GetNames(fd->memid, pnames, maxPNames, &nPNames);
1207
1208 int pbase = 0;
1209 if (fd->cParams < int(nPNames))
1210 {
1211 pbase++;
1212 SysFreeString(pnames[0]);
1213 };
1214
1215 // params
1216 ElemDescToParam(fd->elemdescFunc, func.retType);
1217 for (int p = 0; p < fd->cParams; p++)
1218 {
1219 ParamX param;
1220
1221 ElemDescToParam(fd->lprgelemdescParam[p], param);
1222
1223 param.name = pnames[pbase + p];
1224 SysFreeString(pnames[pbase + p]);
1225
1226 param.isOptional = (p > fd->cParams - fd->cParamsOpt);
1227
1228 func.hasOut |= (param.IsOut() || param.isPtr);
1229 func.params.push_back(param);
1230 };
1231 delete [] pnames;
1232
1233 if (defEventSink)
1234 {
1235 m_events.push_back(func);
1236 m_eventMemberIds[fd->memid] = m_events.size() - 1;
1237 }
1238 else
1239 {
1240 if (fd->invkind == INVOKE_FUNC)
1241 {
1242 m_methods.push_back(func);
1243 m_methodNames[func.name] = m_methods.size() - 1;
1244 }
1245 else
1246 {
1247 NameMap::iterator it = m_propNames.find(func.name);
1248 int idx = -1;
1249 if (it == m_propNames.end())
1250 {
1251 m_props.push_back(PropX());
1252 idx = m_props.size() - 1;
1253 m_propNames[func.name] = idx;
1254 m_props[idx].name = func.name;
1255 m_props[idx].memid = func.memid;
1256
1257 }
1258 else
1259 idx = it->second;
1260
1261 if (fd->invkind == INVOKE_PROPERTYGET)
1262 m_props[idx].type = func.retType;
1263 else if (func.params.size() > 0)
1264 {
1265 m_props[idx].arg = func.params[0];
1266 m_props[idx].putByRef = (fd->invkind == INVOKE_PROPERTYPUTREF);
1267 };
1268 };
1269 };
1270 };
1271 };
1272
1273 typeInfo->ReleaseFuncDesc(fd);
1274 };
1275 }
1276
1277 typeInfo->ReleaseTypeAttr(ta);
1278 };
1279
1280 ///////////////////////////////////////////////
1281 // Type Info exposure
1282 const wxActiveX::FuncX& wxActiveX::GetEventDesc(int idx) const
1283 {
1284 wxASSERT(idx >= 0 && idx < GetEventCount());
1285
1286 return m_events[idx];
1287 };
1288
1289 const wxActiveX::PropX& wxActiveX::GetPropDesc(int idx) const
1290 {
1291 if (idx < 0 || idx >= GetPropCount())
1292 throw exception("Property index out of bounds");
1293
1294 return m_props[idx];
1295 };
1296
1297 const wxActiveX::PropX& wxActiveX::GetPropDesc(const wxString& name) const
1298 {
1299 NameMap::const_iterator it = m_propNames.find(name);
1300 if (it == m_propNames.end())
1301 {
1302 wxString s;
1303 s << _T("property <") << name << _T("> not found");
1304 throw exception(s.mb_str());
1305 };
1306
1307 return GetPropDesc(it->second);
1308 };
1309
1310 const wxActiveX::FuncX& wxActiveX::GetMethodDesc(int idx) const
1311 {
1312 if (idx < 0 || idx >= GetMethodCount())
1313 throw exception("Method index out of bounds");
1314
1315
1316 return m_methods[idx];
1317 };
1318
1319
1320 const wxActiveX::FuncX& wxActiveX::GetMethodDesc(const wxString& name) const
1321 {
1322 NameMap::const_iterator it = m_methodNames.find(name);
1323 if (it == m_methodNames.end())
1324 {
1325 wxString s;
1326 s << _T("method <") << name << _T("> not found");
1327 throw exception(s.mb_str());
1328 };
1329
1330 return GetMethodDesc(it->second);
1331 };
1332
1333
1334 void wxActiveX::SetProp(MEMBERID name, VARIANTARG& value)
1335 {
1336 DISPID pids[1] = {DISPID_PROPERTYPUT};
1337 DISPPARAMS params = {&value, pids, 1, 1};
1338
1339 EXCEPINFO x;
1340 memset(&x, 0, sizeof(x));
1341 unsigned int argErr = 0;
1342
1343 HRESULT hr = m_Dispatch->Invoke(
1344 name,
1345 IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUT,
1346 &params, NULL, &x, &argErr);
1347
1348 WXOLE_WARN(hr, "Invoke Prop(...)");
1349 };
1350
1351 void wxActiveX::SetProp(const wxString &name, const wxVariant &value)
1352 {
1353 const PropX& prop = GetPropDesc(name);
1354 if (! prop.CanSet())
1355 {
1356 wxString s;
1357 s << _T("property <") << name << _T("> is readonly");
1358 throw exception(s.mb_str());
1359 };
1360
1361 VARIANT v = {prop.arg.vt};
1362 VariantToMSWVariant(value, v);
1363 SetProp(prop.memid, v);
1364 VariantClear(&v); // this releases any BSTR's etc
1365 };
1366
1367 VARIANT wxActiveX::GetPropAsVariant(MEMBERID name)
1368 {
1369 VARIANT v;
1370 VariantInit(&v);
1371
1372 DISPPARAMS params = {NULL, NULL, 0, 0};
1373
1374 EXCEPINFO x;
1375 memset(&x, 0, sizeof(x));
1376 unsigned int argErr = 0;
1377
1378 HRESULT hr = m_Dispatch->Invoke(
1379 name,
1380 IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET,
1381 &params, &v, &x, &argErr);
1382
1383 WXOLE_WARN(hr, "Invoke Prop(...)");
1384
1385 return v;
1386 };
1387
1388 VARIANT wxActiveX::GetPropAsVariant(const wxString& name)
1389 {
1390 const PropX& prop = GetPropDesc(name);
1391 if (! prop.CanGet())
1392 {
1393 wxString s;
1394 s << _T("property <") << name << _T("> is writeonly");
1395 throw exception(s.mb_str());
1396 };
1397
1398 return GetPropAsVariant(prop.memid);
1399 };
1400
1401 wxVariant wxActiveX::GetPropAsWxVariant(const wxString& name)
1402 {
1403 VARIANT v = GetPropAsVariant(name);
1404 HRESULT hr = VariantChangeType(&v, &v, 0, VT_BSTR);
1405 if (! SUCCEEDED(hr))
1406 throw exception("Unable to convert variant");
1407
1408 wxVariant wv;
1409 MSWVariantToVariant(v, wv);
1410
1411 VariantClear(&v);
1412
1413 return wv;
1414 };
1415
1416 wxString wxActiveX::GetPropAsString(const wxString& name)
1417 {
1418 VARIANT v = GetPropAsVariant(name);
1419 HRESULT hr = VariantChangeType(&v, &v, 0, VT_BSTR);
1420 if (! SUCCEEDED(hr))
1421 throw exception("Unable to convert variant");
1422
1423 wxString s = v.bstrVal;
1424 VariantClear(&v);
1425
1426 return s;
1427 };
1428
1429 char wxActiveX::GetPropAsChar(const wxString& name)
1430 {
1431 VARIANT v = GetPropAsVariant(name);
1432 HRESULT hr = VariantChangeType(&v, &v, 0, VT_I1);
1433 if (! SUCCEEDED(hr))
1434 throw exception("Unable to convert variant");
1435
1436 return v.cVal;
1437 };
1438
1439 long wxActiveX::GetPropAsLong(const wxString& name)
1440 {
1441 VARIANT v = GetPropAsVariant(name);
1442 HRESULT hr = VariantChangeType(&v, &v, 0, VT_I4);
1443 if (! SUCCEEDED(hr))
1444 throw exception("Unable to convert variant");
1445
1446 return v.iVal;
1447 };
1448
1449 bool wxActiveX::GetPropAsBool(const wxString& name)
1450 {
1451 VARIANT v = GetPropAsVariant(name);
1452 HRESULT hr = VariantChangeType(&v, &v, 0, VT_BOOL);
1453 if (! SUCCEEDED(hr))
1454 throw exception("Unable to convert variant");
1455
1456 return v.boolVal != 0;
1457 };
1458
1459 double wxActiveX::GetPropAsDouble(const wxString& name)
1460 {
1461 VARIANT v = GetPropAsVariant(name);
1462 HRESULT hr = VariantChangeType(&v, &v, 0, VT_R8);
1463 if (! SUCCEEDED(hr))
1464 throw exception("Unable to convert variant");
1465
1466 return v.dblVal;
1467 };
1468
1469 wxDateTime wxActiveX::GetPropAsDateTime(const wxString& name)
1470 {
1471 wxDateTime dt;
1472 VARIANT v = GetPropAsVariant(name);
1473
1474 if (! VariantToWxDateTime(v, dt))
1475 throw exception("Unable to convert variant to wxDateTime");
1476
1477 return dt;
1478 };
1479
1480 void *wxActiveX::GetPropAsPointer(const wxString& name)
1481 {
1482 VARIANT v = GetPropAsVariant(name);
1483 HRESULT hr = VariantChangeType(&v, &v, 0, VT_BYREF);
1484 if (! SUCCEEDED(hr))
1485 throw exception("Unable to convert variant");
1486
1487 return v.byref;
1488 };
1489
1490
1491
1492 // call methods
1493 VARIANT wxActiveX::CallMethod(MEMBERID name, VARIANTARG args[], int argc)
1494 {
1495 DISPPARAMS pargs = {args, NULL, argc, 0};
1496 VARIANT retVal;
1497 VariantInit(&retVal);
1498
1499 EXCEPINFO x;
1500 memset(&x, 0, sizeof(x));
1501 unsigned int argErr = 0;
1502
1503 HRESULT hr = m_Dispatch->Invoke(
1504 name,
1505 IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD,
1506 &pargs, &retVal, &x, &argErr);
1507
1508 WXOLE_WARN(hr, "Invoke Method(...)");
1509 return retVal;
1510 };
1511
1512 VARIANT wxActiveX::CallMethod(const wxString& name, VARIANTARG args[], int argc)
1513 {
1514 const FuncX& func = GetMethodDesc(name);
1515 if (argc < 0)
1516 argc = func.params.size();
1517
1518 return CallMethod(func.memid, args, argc);
1519 };
1520
1521
1522 wxVariant wxActiveX::CallMethod(const wxString& name, wxVariant args[], int nargs)
1523 {
1524 const FuncX& func = GetMethodDesc(name);
1525
1526 if (args == NULL)
1527 nargs = 0;
1528
1529 VARIANTARG *vargs = NULL;
1530 if (nargs < 0)
1531 nargs = func.params.size();
1532
1533 if (nargs > 0)
1534 vargs = new VARIANTARG[nargs];
1535
1536 if (vargs)
1537 {
1538 // init type of vargs
1539 for (int i = 0; i < nargs; i++)
1540 vargs[nargs - i - 1].vt = func.params[i].vt;
1541
1542 // put data
1543 for (i = 0; i < nargs; i++)
1544 VariantToMSWVariant(args[i], vargs[nargs - i - 1]);
1545 };
1546
1547 VARIANT rv = CallMethod(func.memid, vargs, nargs);
1548
1549 // process any by ref params
1550 if (func.hasOut)
1551 {
1552 for (int i = 0; i < nargs; i++)
1553 {
1554 VARIANTARG& va = vargs[nargs - i - 1];
1555 const wxActiveX::ParamX &px = func.params[i];
1556
1557 if (px.IsOut())
1558 {
1559 wxVariant& vx = args[i];
1560
1561 MSWVariantToVariant(va, vx);
1562 };
1563 };
1564 }
1565
1566 if (vargs)
1567 {
1568 for (int i = 0; i < nargs; i++)
1569 VariantClear(&vargs[i]);
1570 delete [] vargs;
1571 };
1572
1573 wxVariant ret;
1574
1575 MSWVariantToVariant(rv, ret);
1576 VariantClear(&rv);
1577
1578 return ret;
1579 };
1580
1581
1582 ///////////////////////////////////////////////
1583
1584 HRESULT wxActiveX::ConnectAdvise(REFIID riid, IUnknown *events)
1585 {
1586 wxOleConnectionPoint cp;
1587 DWORD adviseCookie = 0;
1588
1589 wxAutoOleInterface<IConnectionPointContainer> cpContainer(IID_IConnectionPointContainer, m_ActiveX);
1590 if (! cpContainer.Ok())
1591 return E_FAIL;
1592
1593 HRESULT hret = cpContainer->FindConnectionPoint(riid, cp.GetRef());
1594 if (! SUCCEEDED(hret))
1595 return hret;
1596
1597 hret = cp->Advise(events, &adviseCookie);
1598
1599 if (SUCCEEDED(hret))
1600 m_connections.push_back(wxOleConnection(cp, adviseCookie));
1601 else
1602 {
1603 WXOLE_WARN(hret, "ConnectAdvise");
1604 };
1605
1606 return hret;
1607 };
1608
1609 HRESULT wxActiveX::AmbientPropertyChanged(DISPID dispid)
1610 {
1611 wxAutoOleInterface<IOleControl> oleControl(IID_IOleControl, m_oleObject);
1612
1613 if (oleControl.Ok())
1614 return oleControl->OnAmbientPropertyChange(dispid);
1615 else
1616 return S_FALSE;
1617 };
1618
1619 #define HIMETRIC_PER_INCH 2540
1620 #define MAP_PIX_TO_LOGHIM(x,ppli) MulDiv(HIMETRIC_PER_INCH, (x), (ppli))
1621
1622 static void PixelsToHimetric(SIZEL &sz)
1623 {
1624 static int logX = 0;
1625 static int logY = 0;
1626
1627 if (logY == 0)
1628 {
1629 // initaliase
1630 HDC dc = GetDC(NULL);
1631 logX = GetDeviceCaps(dc, LOGPIXELSX);
1632 logY = GetDeviceCaps(dc, LOGPIXELSY);
1633 ReleaseDC(NULL, dc);
1634 };
1635
1636 #define HIMETRIC_INCH 2540
1637 #define CONVERT(x, logpixels) MulDiv(HIMETRIC_INCH, (x), (logpixels))
1638
1639 sz.cx = CONVERT(sz.cx, logX);
1640 sz.cy = CONVERT(sz.cy, logY);
1641
1642 #undef CONVERT
1643 #undef HIMETRIC_INCH
1644 }
1645
1646
1647 void wxActiveX::OnSize(wxSizeEvent& event)
1648 {
1649 int w, h;
1650 GetClientSize(&w, &h);
1651
1652 RECT posRect;
1653 posRect.left = 0;
1654 posRect.top = 0;
1655 posRect.right = w;
1656 posRect.bottom = h;
1657
1658 if (w <= 0 && h <= 0)
1659 return;
1660
1661 // extents are in HIMETRIC units
1662 if (m_oleObject.Ok())
1663 {
1664 SIZEL sz = {w, h};
1665 PixelsToHimetric(sz);
1666
1667 SIZEL sz2;
1668
1669 m_oleObject->GetExtent(DVASPECT_CONTENT, &sz2);
1670 if (sz2.cx != sz.cx || sz.cy != sz2.cy)
1671 m_oleObject->SetExtent(DVASPECT_CONTENT, &sz);
1672 };
1673
1674 if (m_oleInPlaceObject.Ok())
1675 m_oleInPlaceObject->SetObjectRects(&posRect, &posRect);
1676 }
1677
1678 void wxActiveX::OnPaint(wxPaintEvent& event)
1679 {
1680 wxLogTrace(wxT(""),wxT("repainting activex win"));
1681 wxPaintDC dc(this);
1682 dc.BeginDrawing();
1683 int w, h;
1684 GetSize(&w, &h);
1685 RECT posRect;
1686 posRect.left = 0;
1687 posRect.top = 0;
1688 posRect.right = w;
1689 posRect.bottom = h;
1690
1691 // Draw only when control is windowless or deactivated
1692 if (m_viewObject)
1693 {
1694 ::RedrawWindow(m_oleObjectHWND, NULL, NULL, RDW_INTERNALPAINT);
1695 {
1696 RECTL *prcBounds = (RECTL *) &posRect;
1697 m_viewObject->Draw(DVASPECT_CONTENT, -1, NULL, NULL, NULL,
1698 (HDC)dc.GetHDC(), prcBounds, NULL, NULL, 0);
1699 }
1700 }
1701 else
1702 {
1703 dc.SetBrush(*wxRED_BRUSH);
1704 dc.DrawRectangle(0, 0, w, h);
1705 dc.SetBrush(wxNullBrush);
1706 }
1707 dc.EndDrawing();
1708 }
1709
1710
1711 void wxActiveX::OnMouse(wxMouseEvent& event)
1712 {
1713 if (m_oleObjectHWND == NULL)
1714 {
1715 wxLogTrace(wxT(""),wxT("no oleInPlaceObject"));
1716 event.Skip();
1717 return;
1718 }
1719
1720 wxLogTrace(wxT(""),wxT("mouse event"));
1721 UINT msg = 0;
1722 WPARAM wParam = 0;
1723 LPARAM lParam = 0;
1724 LRESULT lResult = 0;
1725
1726 if (event.m_metaDown)
1727 wParam |= MK_CONTROL;
1728 if (event.m_shiftDown)
1729 wParam |= MK_SHIFT;
1730 if (event.m_leftDown)
1731 wParam |= MK_LBUTTON;
1732 if (event.m_middleDown)
1733 wParam |= MK_MBUTTON;
1734 if (event.m_rightDown)
1735 wParam |= MK_RBUTTON;
1736 lParam = event.m_x << 16;
1737 lParam |= event.m_y;
1738
1739 if (event.LeftDown())
1740 msg = WM_LBUTTONDOWN;
1741 else if (event.LeftDClick())
1742 msg = WM_LBUTTONDBLCLK;
1743 else if (event.LeftUp())
1744 msg = WM_LBUTTONUP;
1745 else if (event.MiddleDown())
1746 msg = WM_MBUTTONDOWN;
1747 else if (event.MiddleDClick())
1748 msg = WM_MBUTTONDBLCLK;
1749 else if (event.MiddleUp())
1750 msg = WM_MBUTTONUP;
1751 else if (event.RightDown())
1752 msg = WM_RBUTTONDOWN;
1753 else if (event.RightDClick())
1754 msg = WM_RBUTTONDBLCLK;
1755 else if (event.RightUp())
1756 msg = WM_RBUTTONUP;
1757 else if (event.Moving() || event.Dragging())
1758 msg = WM_MOUSEMOVE;
1759
1760 wxString log;
1761 if (msg == 0)
1762 {
1763 wxLogTrace(wxT(""),wxT("no message"));
1764 event.Skip(); return;
1765 };
1766
1767 if (!::SendMessage(m_oleObjectHWND, msg, wParam, lParam))
1768 {
1769 wxLogTrace(wxT(""),wxT("msg not delivered"));
1770 event.Skip();
1771 return;
1772 };
1773
1774 wxLogTrace(wxT(""),wxT("msg sent"));
1775 }
1776
1777 long wxActiveX::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
1778 {
1779 if (m_oleObjectHWND == NULL)
1780 return wxWindow::MSWWindowProc(nMsg, wParam, lParam);
1781
1782 switch(nMsg)
1783 {
1784 case WM_CHAR:
1785 case WM_DEADCHAR:
1786 case WM_KEYDOWN:
1787 case WM_KEYUP:
1788 case WM_SYSCHAR:
1789 case WM_SYSDEADCHAR:
1790 case WM_SYSKEYDOWN:
1791 case WM_SYSKEYUP:
1792 PostMessage(m_oleObjectHWND, nMsg, wParam, lParam);
1793
1794 default:
1795 return wxWindow::MSWWindowProc(nMsg, wParam, lParam);
1796 };
1797 };
1798
1799 void wxActiveX::OnSetFocus(wxFocusEvent& event)
1800 {
1801 if (m_oleInPlaceActiveObject.Ok())
1802 m_oleInPlaceActiveObject->OnFrameWindowActivate(TRUE);
1803 }
1804
1805 void wxActiveX::OnKillFocus(wxFocusEvent& event)
1806 {
1807 if (m_oleInPlaceActiveObject.Ok())
1808 m_oleInPlaceActiveObject->OnFrameWindowActivate(FALSE);
1809 }
1810
1811
1812 FrameSite::FrameSite(wxActiveX * win)
1813 {
1814 m_window = win;
1815 m_bSupportsWindowlessActivation = true;
1816 m_bInPlaceLocked = false;
1817 m_bUIActive = false;
1818 m_bInPlaceActive = false;
1819 m_bWindowless = false;
1820
1821 m_nAmbientLocale = 0;
1822 m_clrAmbientForeColor = ::GetSysColor(COLOR_WINDOWTEXT);
1823 m_clrAmbientBackColor = ::GetSysColor(COLOR_WINDOW);
1824 m_bAmbientShowHatching = true;
1825 m_bAmbientShowGrabHandles = true;
1826 m_bAmbientAppearance = true;
1827
1828 m_hDCBuffer = NULL;
1829 m_hWndParent = (HWND)m_window->GetHWND();
1830 }
1831
1832 FrameSite::~FrameSite()
1833 {
1834 }
1835
1836
1837 //IDispatch
1838
1839 HRESULT FrameSite::GetIDsOfNames(REFIID riid, OLECHAR ** rgszNames, unsigned int cNames,
1840 LCID lcid, DISPID * rgDispId)
1841 {
1842 WXOLE_TRACE("IDispatch::GetIDsOfNames");
1843 return E_NOTIMPL;
1844 }
1845
1846 HRESULT FrameSite::GetTypeInfo(unsigned int iTInfo, LCID lcid, ITypeInfo ** ppTInfo)
1847 {
1848 WXOLE_TRACE("IDispatch::GetTypeInfo");
1849 return E_NOTIMPL;
1850 }
1851
1852 HRESULT FrameSite::GetTypeInfoCount(unsigned int * pcTInfo)
1853 {
1854 WXOLE_TRACE("IDispatch::GetTypeInfoCount");
1855 return E_NOTIMPL;
1856 }
1857
1858 HRESULT FrameSite::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
1859 WORD wFlags, DISPPARAMS * pDispParams,
1860 VARIANT * pVarResult, EXCEPINFO * pExcepInfo,
1861 unsigned int * puArgErr)
1862 {
1863 WXOLE_TRACE("IDispatch::Invoke");
1864
1865 if (!(wFlags & DISPATCH_PROPERTYGET))
1866 return S_OK;
1867
1868 HRESULT hr;
1869
1870 if (pVarResult == NULL)
1871 return E_INVALIDARG;
1872
1873 //The most common case is boolean, use as an initial type
1874 V_VT(pVarResult) = VT_BOOL;
1875
1876 switch (dispIdMember)
1877 {
1878 case DISPID_AMBIENT_MESSAGEREFLECT:
1879 WXOLE_TRACE("Invoke::DISPID_AMBIENT_MESSAGEREFLECT");
1880 V_BOOL(pVarResult)= FALSE;
1881 return S_OK;
1882
1883 case DISPID_AMBIENT_DISPLAYASDEFAULT:
1884 WXOLE_TRACE("Invoke::DISPID_AMBIENT_DISPLAYASDEFAULT");
1885 V_BOOL(pVarResult)= TRUE;
1886 return S_OK;
1887
1888 case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED:
1889 WXOLE_TRACE("Invoke::DISPID_AMBIENT_OFFLINEIFNOTCONNECTED");
1890 V_BOOL(pVarResult) = TRUE;
1891 return S_OK;
1892
1893
1894 case DISPID_AMBIENT_SILENT:
1895 WXOLE_TRACE("Invoke::DISPID_AMBIENT_SILENT");
1896 V_BOOL(pVarResult)= TRUE;
1897 return S_OK;
1898
1899 case DISPID_AMBIENT_APPEARANCE:
1900 pVarResult->vt = VT_BOOL;
1901 pVarResult->boolVal = m_bAmbientAppearance;
1902 break;
1903
1904 case DISPID_AMBIENT_FORECOLOR:
1905 pVarResult->vt = VT_I4;
1906 pVarResult->lVal = (long) m_clrAmbientForeColor;
1907 break;
1908
1909 case DISPID_AMBIENT_BACKCOLOR:
1910 pVarResult->vt = VT_I4;
1911 pVarResult->lVal = (long) m_clrAmbientBackColor;
1912 break;
1913
1914 case DISPID_AMBIENT_LOCALEID:
1915 pVarResult->vt = VT_I4;
1916 pVarResult->lVal = (long) m_nAmbientLocale;
1917 break;
1918
1919 case DISPID_AMBIENT_USERMODE:
1920 pVarResult->vt = VT_BOOL;
1921 pVarResult->boolVal = m_window->m_bAmbientUserMode;
1922 break;
1923
1924 case DISPID_AMBIENT_SHOWGRABHANDLES:
1925 pVarResult->vt = VT_BOOL;
1926 pVarResult->boolVal = m_bAmbientShowGrabHandles;
1927 break;
1928
1929 case DISPID_AMBIENT_SHOWHATCHING:
1930 pVarResult->vt = VT_BOOL;
1931 pVarResult->boolVal = m_bAmbientShowHatching;
1932 break;
1933
1934 default:
1935 return DISP_E_MEMBERNOTFOUND;
1936 }
1937
1938 return S_OK;
1939 }
1940
1941 //IOleWindow
1942
1943 HRESULT FrameSite::GetWindow(HWND * phwnd)
1944 {
1945 WXOLE_TRACE("IOleWindow::GetWindow");
1946 if (phwnd == NULL)
1947 return E_INVALIDARG;
1948 (*phwnd) = m_hWndParent;
1949 return S_OK;
1950 }
1951
1952 HRESULT FrameSite::ContextSensitiveHelp(BOOL fEnterMode)
1953 {
1954 WXOLE_TRACE("IOleWindow::ContextSensitiveHelp");
1955 return S_OK;
1956 }
1957
1958 //IOleInPlaceUIWindow
1959
1960 HRESULT FrameSite::GetBorder(LPRECT lprectBorder)
1961 {
1962 WXOLE_TRACE("IOleInPlaceUIWindow::GetBorder");
1963 if (lprectBorder == NULL)
1964 return E_INVALIDARG;
1965 return INPLACE_E_NOTOOLSPACE;
1966 }
1967
1968 HRESULT FrameSite::RequestBorderSpace(LPCBORDERWIDTHS pborderwidths)
1969 {
1970 WXOLE_TRACE("IOleInPlaceUIWindow::RequestBorderSpace");
1971 if (pborderwidths == NULL)
1972 return E_INVALIDARG;
1973 return INPLACE_E_NOTOOLSPACE;
1974 }
1975
1976 HRESULT FrameSite::SetBorderSpace(LPCBORDERWIDTHS pborderwidths)
1977 {
1978 WXOLE_TRACE("IOleInPlaceUIWindow::SetBorderSpace");
1979 return S_OK;
1980 }
1981
1982 HRESULT FrameSite::SetActiveObject(IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1983 {
1984 WXOLE_TRACE("IOleInPlaceUIWindow::SetActiveObject");
1985
1986 if (pActiveObject)
1987 pActiveObject->AddRef();
1988
1989 m_window->m_oleInPlaceActiveObject = pActiveObject;
1990 return S_OK;
1991 }
1992
1993 //IOleInPlaceFrame
1994
1995 HRESULT FrameSite::InsertMenus(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths)
1996 {
1997 WXOLE_TRACE("IOleInPlaceFrame::InsertMenus");
1998 return S_OK;
1999 }
2000
2001 HRESULT FrameSite::SetMenu(HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject)
2002 {
2003 WXOLE_TRACE("IOleInPlaceFrame::SetMenu");
2004 return S_OK;
2005 }
2006
2007 HRESULT FrameSite::RemoveMenus(HMENU hmenuShared)
2008 {
2009 WXOLE_TRACE("IOleInPlaceFrame::RemoveMenus");
2010 return S_OK;
2011 }
2012
2013 HRESULT FrameSite::SetStatusText(LPCOLESTR pszStatusText)
2014 {
2015 WXOLE_TRACE("IOleInPlaceFrame::SetStatusText");
2016 //((wxFrame*)wxGetApp().GetTopWindow())->GetStatusBar()->SetStatusText(pszStatusText);
2017 return S_OK;
2018 }
2019
2020 HRESULT FrameSite::EnableModeless(BOOL fEnable)
2021 {
2022 WXOLE_TRACE("IOleInPlaceFrame::EnableModeless");
2023 return S_OK;
2024 }
2025
2026 HRESULT FrameSite::TranslateAccelerator(LPMSG lpmsg, WORD wID)
2027 {
2028 WXOLE_TRACE("IOleInPlaceFrame::TranslateAccelerator");
2029 // TODO: send an event with this id
2030 if (m_window->m_oleInPlaceActiveObject.Ok())
2031 m_window->m_oleInPlaceActiveObject->TranslateAccelerator(lpmsg);
2032
2033 return S_FALSE;
2034 }
2035
2036 //IOleInPlaceSite
2037
2038 HRESULT FrameSite::CanInPlaceActivate()
2039 {
2040 WXOLE_TRACE("IOleInPlaceSite::CanInPlaceActivate");
2041 return S_OK;
2042 }
2043
2044 HRESULT FrameSite::OnInPlaceActivate()
2045 {
2046 WXOLE_TRACE("IOleInPlaceSite::OnInPlaceActivate");
2047 m_bInPlaceActive = true;
2048 return S_OK;
2049 }
2050
2051 HRESULT FrameSite::OnUIActivate()
2052 {
2053 WXOLE_TRACE("IOleInPlaceSite::OnUIActivate");
2054 m_bUIActive = true;
2055 return S_OK;
2056 }
2057
2058 HRESULT FrameSite::GetWindowContext(IOleInPlaceFrame **ppFrame,
2059 IOleInPlaceUIWindow **ppDoc,
2060 LPRECT lprcPosRect,
2061 LPRECT lprcClipRect,
2062 LPOLEINPLACEFRAMEINFO lpFrameInfo)
2063 {
2064 WXOLE_TRACE("IOleInPlaceSite::GetWindowContext");
2065 if (ppFrame == NULL || ppDoc == NULL || lprcPosRect == NULL ||
2066 lprcClipRect == NULL || lpFrameInfo == NULL)
2067 {
2068 if (ppFrame != NULL)
2069 (*ppFrame) = NULL;
2070 if (ppDoc != NULL)
2071 (*ppDoc) = NULL;
2072 return E_INVALIDARG;
2073 }
2074
2075 HRESULT hr = QueryInterface(IID_IOleInPlaceFrame, (void **) ppFrame);
2076 if (! SUCCEEDED(hr))
2077 {
2078 WXOLE_TRACE("IOleInPlaceSite::IOleInPlaceFrame Error !");
2079 return E_UNEXPECTED;
2080 };
2081
2082 hr = QueryInterface(IID_IOleInPlaceUIWindow, (void **) ppDoc);
2083 if (! SUCCEEDED(hr))
2084 {
2085 WXOLE_TRACE("IOleInPlaceSite::IOleInPlaceUIWindow Error !");
2086 (*ppFrame)->Release();
2087 *ppFrame = NULL;
2088 return E_UNEXPECTED;
2089 };
2090
2091 int w, h;
2092 m_window->GetClientSize(&w, &h);
2093 if (lprcPosRect)
2094 {
2095 lprcPosRect->left = lprcPosRect->top = 0;
2096 lprcPosRect->right = w;
2097 lprcPosRect->bottom = h;
2098 };
2099 if (lprcClipRect)
2100 {
2101 lprcClipRect->left = lprcClipRect->top = 0;
2102 lprcClipRect->right = w;
2103 lprcClipRect->bottom = h;
2104 };
2105
2106 memset(lpFrameInfo, 0, sizeof(OLEINPLACEFRAMEINFO));
2107 lpFrameInfo->cb = sizeof(OLEINPLACEFRAMEINFO);
2108 lpFrameInfo->hwndFrame = m_hWndParent;
2109
2110 return S_OK;
2111 }
2112
2113 HRESULT FrameSite::Scroll(SIZE scrollExtent)
2114 {
2115 WXOLE_TRACE("IOleInPlaceSite::Scroll");
2116 return S_OK;
2117 }
2118
2119 HRESULT FrameSite::OnUIDeactivate(BOOL fUndoable)
2120 {
2121 WXOLE_TRACE("IOleInPlaceSite::OnUIDeactivate");
2122 m_bUIActive = false;
2123 return S_OK;
2124 }
2125
2126 HRESULT FrameSite::OnInPlaceDeactivate()
2127 {
2128 WXOLE_TRACE("IOleInPlaceSite::OnInPlaceDeactivate");
2129 m_bInPlaceActive = false;
2130 return S_OK;
2131 }
2132
2133 HRESULT FrameSite::DiscardUndoState()
2134 {
2135 WXOLE_TRACE("IOleInPlaceSite::DiscardUndoState");
2136 return S_OK;
2137 }
2138
2139 HRESULT FrameSite::DeactivateAndUndo()
2140 {
2141 WXOLE_TRACE("IOleInPlaceSite::DeactivateAndUndo");
2142 return S_OK;
2143 }
2144
2145 HRESULT FrameSite::OnPosRectChange(LPCRECT lprcPosRect)
2146 {
2147 WXOLE_TRACE("IOleInPlaceSite::OnPosRectChange");
2148 if (m_window->m_oleInPlaceObject.Ok() && lprcPosRect)
2149 m_window->m_oleInPlaceObject->SetObjectRects(lprcPosRect, lprcPosRect);
2150
2151 return S_OK;
2152 }
2153
2154 //IOleInPlaceSiteEx
2155
2156 HRESULT FrameSite::OnInPlaceActivateEx(BOOL * pfNoRedraw, DWORD dwFlags)
2157 {
2158 WXOLE_TRACE("IOleInPlaceSiteEx::OnInPlaceActivateEx");
2159 OleLockRunning(m_window->m_ActiveX, TRUE, FALSE);
2160 if (pfNoRedraw)
2161 (*pfNoRedraw) = FALSE;
2162 return S_OK;
2163 }
2164
2165 HRESULT FrameSite::OnInPlaceDeactivateEx(BOOL fNoRedraw)
2166 {
2167 WXOLE_TRACE("IOleInPlaceSiteEx::OnInPlaceDeactivateEx");
2168 OleLockRunning(m_window->m_ActiveX, FALSE, FALSE);
2169 return S_OK;
2170 }
2171
2172 HRESULT FrameSite::RequestUIActivate()
2173 {
2174 WXOLE_TRACE("IOleInPlaceSiteEx::RequestUIActivate");
2175 return S_OK;
2176 }
2177
2178
2179 //IOleClientSite
2180
2181 HRESULT FrameSite::SaveObject()
2182 {
2183 WXOLE_TRACE("IOleClientSite::SaveObject");
2184 return S_OK;
2185 }
2186
2187 const char *OleGetMonikerToStr(DWORD dwAssign)
2188 {
2189 switch (dwAssign)
2190 {
2191 case OLEGETMONIKER_ONLYIFTHERE : return "OLEGETMONIKER_ONLYIFTHERE";
2192 case OLEGETMONIKER_FORCEASSIGN : return "OLEGETMONIKER_FORCEASSIGN";
2193 case OLEGETMONIKER_UNASSIGN : return "OLEGETMONIKER_UNASSIGN";
2194 case OLEGETMONIKER_TEMPFORUSER : return "OLEGETMONIKER_TEMPFORUSER";
2195 default : return "Bad Enum";
2196 };
2197 };
2198
2199 const char *OleGetWhicMonikerStr(DWORD dwWhichMoniker)
2200 {
2201 switch(dwWhichMoniker)
2202 {
2203 case OLEWHICHMK_CONTAINER : return "OLEWHICHMK_CONTAINER";
2204 case OLEWHICHMK_OBJREL : return "OLEWHICHMK_OBJREL";
2205 case OLEWHICHMK_OBJFULL : return "OLEWHICHMK_OBJFULL";
2206 default : return "Bad Enum";
2207 };
2208 };
2209
2210 HRESULT FrameSite::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker,
2211 IMoniker ** ppmk)
2212 {
2213 WXOLE_TRACEOUT("IOleClientSite::GetMoniker(" << OleGetMonikerToStr(dwAssign) << ", " << OleGetWhicMonikerStr(dwWhichMoniker) << ")");
2214
2215
2216 if (! ppmk)
2217 return E_FAIL;
2218
2219 /*
2220 HRESULT hr = CreateFileMoniker(L"e:\\dev\\wxie\\bug-zap.swf", ppmk);
2221 if (SUCCEEDED(hr))
2222 return S_OK;
2223 */
2224 *ppmk = NULL;
2225
2226 return E_FAIL ;
2227 }
2228
2229 HRESULT FrameSite::GetContainer(LPOLECONTAINER * ppContainer)
2230 {
2231 WXOLE_TRACE("IOleClientSite::GetContainer");
2232 if (ppContainer == NULL)
2233 return E_INVALIDARG;
2234
2235 HRESULT hr = QueryInterface(IID_IOleContainer, (void**)(ppContainer));
2236 wxASSERT(SUCCEEDED(hr));
2237
2238 return hr;
2239 }
2240
2241 HRESULT FrameSite::ShowObject()
2242 {
2243 WXOLE_TRACE("IOleClientSite::ShowObject");
2244 if (m_window->m_oleObjectHWND)
2245 ::ShowWindow(m_window->m_oleObjectHWND, SW_SHOW);
2246 return S_OK;
2247 }
2248
2249 HRESULT FrameSite::OnShowWindow(BOOL fShow)
2250 {
2251 WXOLE_TRACE("IOleClientSite::OnShowWindow");
2252 return S_OK;
2253 }
2254
2255 HRESULT FrameSite::RequestNewObjectLayout()
2256 {
2257 WXOLE_TRACE("IOleClientSite::RequestNewObjectLayout");
2258 return E_NOTIMPL;
2259 }
2260
2261 // IParseDisplayName
2262
2263 HRESULT FrameSite::ParseDisplayName(IBindCtx *pbc, LPOLESTR pszDisplayName,
2264 ULONG *pchEaten, IMoniker **ppmkOut)
2265 {
2266 WXOLE_TRACE("IParseDisplayName::ParseDisplayName");
2267 return E_NOTIMPL;
2268 }
2269
2270 //IOleContainer
2271
2272 HRESULT FrameSite::EnumObjects(DWORD grfFlags, IEnumUnknown **ppenum)
2273 {
2274 WXOLE_TRACE("IOleContainer::EnumObjects");
2275 return E_NOTIMPL;
2276 }
2277
2278 HRESULT FrameSite::LockContainer(BOOL fLock)
2279 {
2280 WXOLE_TRACE("IOleContainer::LockContainer");
2281 // TODO
2282 return S_OK;
2283 }
2284
2285 //IOleItemContainer
2286
2287 HRESULT FrameSite::GetObject(LPOLESTR pszItem, DWORD dwSpeedNeeded,
2288 IBindCtx * pbc, REFIID riid, void ** ppvObject)
2289 {
2290 WXOLE_TRACE("IOleItemContainer::GetObject");
2291 if (pszItem == NULL)
2292 return E_INVALIDARG;
2293 if (ppvObject == NULL)
2294 return E_INVALIDARG;
2295
2296 *ppvObject = NULL;
2297 return MK_E_NOOBJECT;
2298 }
2299
2300 HRESULT FrameSite::GetObjectStorage(LPOLESTR pszItem, IBindCtx * pbc,
2301 REFIID riid, void ** ppvStorage)
2302 {
2303 WXOLE_TRACE("IOleItemContainer::GetObjectStorage");
2304 if (pszItem == NULL)
2305 return E_INVALIDARG;
2306 if (ppvStorage == NULL)
2307 return E_INVALIDARG;
2308
2309 *ppvStorage = NULL;
2310 return MK_E_NOOBJECT;
2311 }
2312
2313 HRESULT FrameSite::IsRunning(LPOLESTR pszItem)
2314 {
2315 WXOLE_TRACE("IOleItemContainer::IsRunning");
2316 if (pszItem == NULL)
2317 return E_INVALIDARG;
2318
2319 return MK_E_NOOBJECT;
2320 }
2321
2322
2323
2324 //IOleControlSite
2325
2326 HRESULT FrameSite::OnControlInfoChanged()
2327 {
2328 WXOLE_TRACE("IOleControlSite::OnControlInfoChanged");
2329 return S_OK;
2330 }
2331
2332 HRESULT FrameSite::LockInPlaceActive(BOOL fLock)
2333 {
2334 WXOLE_TRACE("IOleControlSite::LockInPlaceActive");
2335 m_bInPlaceLocked = (fLock) ? true : false;
2336 return S_OK;
2337 }
2338
2339 HRESULT FrameSite::GetExtendedControl(IDispatch ** ppDisp)
2340 {
2341 WXOLE_TRACE("IOleControlSite::GetExtendedControl");
2342 return E_NOTIMPL;
2343 }
2344
2345 HRESULT FrameSite::TransformCoords(POINTL * pPtlHimetric, POINTF * pPtfContainer, DWORD dwFlags)
2346 {
2347 WXOLE_TRACE("IOleControlSite::TransformCoords");
2348 HRESULT hr = S_OK;
2349
2350 if (pPtlHimetric == NULL)
2351 return E_INVALIDARG;
2352
2353 if (pPtfContainer == NULL)
2354 return E_INVALIDARG;
2355
2356 return E_NOTIMPL;
2357
2358 }
2359
2360 HRESULT FrameSite::TranslateAccelerator(LPMSG pMsg, DWORD grfModifiers)
2361 {
2362 WXOLE_TRACE("IOleControlSite::TranslateAccelerator");
2363 // TODO: send an event with this id
2364 return E_NOTIMPL;
2365 }
2366
2367 HRESULT FrameSite::OnFocus(BOOL fGotFocus)
2368 {
2369 WXOLE_TRACE("IOleControlSite::OnFocus");
2370 return S_OK;
2371 }
2372
2373 HRESULT FrameSite::ShowPropertyFrame()
2374 {
2375 WXOLE_TRACE("IOleControlSite::ShowPropertyFrame");
2376 return E_NOTIMPL;
2377 }
2378
2379 //IOleCommandTarget
2380
2381 HRESULT FrameSite::QueryStatus(const GUID * pguidCmdGroup, ULONG cCmds,
2382 OLECMD * prgCmds, OLECMDTEXT * pCmdTet)
2383 {
2384 WXOLE_TRACE("IOleCommandTarget::QueryStatus");
2385 if (prgCmds == NULL) return E_INVALIDARG;
2386 bool bCmdGroupFound = false;
2387
2388 for (ULONG nCmd = 0; nCmd < cCmds; nCmd++)
2389 {
2390 // unsupported by default
2391 prgCmds[nCmd].cmdf = 0;
2392
2393 // TODO
2394 }
2395
2396 if (!bCmdGroupFound) { OLECMDERR_E_UNKNOWNGROUP; }
2397 return S_OK;
2398 }
2399
2400 HRESULT FrameSite::Exec(const GUID * pguidCmdGroup, DWORD nCmdID,
2401 DWORD nCmdExecOpt, VARIANTARG * pVaIn,
2402 VARIANTARG * pVaOut)
2403 {
2404 WXOLE_TRACE("IOleCommandTarget::Exec");
2405 bool bCmdGroupFound = false;
2406
2407 if (!bCmdGroupFound) { OLECMDERR_E_UNKNOWNGROUP; }
2408 return OLECMDERR_E_NOTSUPPORTED;
2409 }
2410
2411 //IAdviseSink
2412
2413 void STDMETHODCALLTYPE FrameSite::OnDataChange(FORMATETC * pFormatEtc, STGMEDIUM * pgStgMed)
2414 {
2415 WXOLE_TRACE("IAdviseSink::OnDataChange");
2416 }
2417
2418 void STDMETHODCALLTYPE FrameSite::OnViewChange(DWORD dwAspect, LONG lIndex)
2419 {
2420 WXOLE_TRACE("IAdviseSink::OnViewChange");
2421 // redraw the control
2422 }
2423
2424 void STDMETHODCALLTYPE FrameSite::OnRename(IMoniker * pmk)
2425 {
2426 WXOLE_TRACE("IAdviseSink::OnRename");
2427 }
2428
2429 void STDMETHODCALLTYPE FrameSite::OnSave()
2430 {
2431 WXOLE_TRACE("IAdviseSink::OnSave");
2432 }
2433
2434 void STDMETHODCALLTYPE FrameSite::OnClose()
2435 {
2436 WXOLE_TRACE("IAdviseSink::OnClose");
2437 }
2438
2439 /////////////////////////////////////////////
2440 // IOleDocumentSite
2441 HRESULT STDMETHODCALLTYPE FrameSite::ActivateMe(
2442 /* [in] */ IOleDocumentView __RPC_FAR *pViewToActivate)
2443 {
2444 wxAutoOleInterface<IOleInPlaceSite> inPlaceSite(IID_IOleInPlaceSite, (IDispatch *) this);
2445 if (!inPlaceSite.Ok())
2446 return E_FAIL;
2447
2448 if (pViewToActivate)
2449 {
2450 m_window->m_docView = pViewToActivate;
2451 m_window->m_docView->SetInPlaceSite(inPlaceSite);
2452 }
2453 else
2454 {
2455 wxAutoOleInterface<IOleDocument> oleDoc(IID_IOleDocument, m_window->m_oleObject);
2456 if (! oleDoc.Ok())
2457 return E_FAIL;
2458
2459 HRESULT hr = oleDoc->CreateView(inPlaceSite, NULL, 0, m_window->m_docView.GetRef());
2460 if (hr != S_OK)
2461 return E_FAIL;
2462
2463 m_window->m_docView->SetInPlaceSite(inPlaceSite);
2464 };
2465
2466 m_window->m_docView->UIActivate(TRUE);
2467
2468 return S_OK;
2469 };
2470
2471
2472 static IMalloc *iMalloc = NULL;
2473
2474 IMalloc *wxOleInit::GetIMalloc()
2475 {
2476 assert(iMalloc);
2477 return iMalloc;
2478 };
2479
2480 wxOleInit::wxOleInit()
2481 {
2482 if (OleInitialize(NULL) == S_OK && iMalloc == NULL)
2483 CoGetMalloc(1, &iMalloc);
2484 else if (iMalloc)
2485 iMalloc->AddRef();
2486 };
2487
2488 wxOleInit::~wxOleInit()
2489 {
2490 if (iMalloc)
2491 {
2492 if (iMalloc->Release() == 0)
2493 iMalloc = NULL;
2494 };
2495
2496 OleUninitialize();
2497 }
2498
2499 bool GetSysErrMessage(int err, wxString& s)
2500 {
2501 wxChar buf[256];
2502 if (FormatMessage(
2503 FORMAT_MESSAGE_FROM_SYSTEM, NULL,
2504 err,0, buf, sizeof(buf), NULL) == 0)
2505 return false;
2506
2507 buf[sizeof(buf) - 1] = 0;
2508 s = buf;
2509 return true;
2510 };
2511
2512 wxString OLEHResultToString(HRESULT hr)
2513 {
2514 // try formatmessage
2515 wxString err;
2516 if (GetSysErrMessage(hr, err))
2517 return err;
2518
2519 switch (hr)
2520 {
2521 case S_OK:
2522 return wxEmptyString;
2523
2524 case CONNECT_E_CANNOTCONNECT:
2525 return _T("Cannot connect to event interface (maybe not there ?) - see MSDN");
2526
2527 case DISP_E_MEMBERNOTFOUND:
2528 return _T("The requested member does not exist, or the call to Invoke tried to set the value of a read-only property.");
2529
2530 case DISP_E_BADVARTYPE:
2531 return _T("One of the parameters in rgvarg is not a valid variant type.");
2532
2533 case DISP_E_BADPARAMCOUNT:
2534 return _T("The number of elements provided to DISPPARAMS is different from the number of parameters accepted by the method or property");
2535
2536 case DISP_E_EXCEPTION:
2537 return _T("The application needs to raise an exception. In this case, the structure passed in pExcepInfo should be filled in.");
2538
2539 case DISP_E_TYPEMISMATCH:
2540 return _T("One or more of the parameters could not be coerced. The index within rgvarg of the first parameter with the incorrect type is returned in the puArgErr parameter.");
2541
2542 case DISP_E_PARAMNOTOPTIONAL:
2543 return _T("A required parameter was omitted.");
2544
2545 case DISP_E_PARAMNOTFOUND:
2546 return _T("One of the parameter DISPIDs does not correspond to a parameter on the method. In this case, puArgErr should be set to the first parameter that contains the error.");
2547
2548 case OLECMDERR_E_UNKNOWNGROUP:
2549 return _T("The pguidCmdGroup parameter is not NULL but does not specify a recognized command group.");
2550
2551 case OLECMDERR_E_NOTSUPPORTED:
2552 return _T("The nCmdID parameter is not a valid command in the group identified by pguidCmdGroup.");
2553
2554 case OLECMDERR_E_DISABLED:
2555 return _T("The command identified by nCmdID is currently disabled and cannot be executed.");
2556
2557 case OLECMDERR_E_NOHELP:
2558 return _T("The caller has asked for help on the command identified by nCmdID, but no help is available.");
2559
2560 case OLECMDERR_E_CANCELED:
2561 return _T("The user canceled the execution of the command.");
2562
2563 case E_INVALIDARG:
2564 return _T("E_INVALIDARG");
2565
2566 case E_OUTOFMEMORY:
2567 return _T("E_OUTOFMEMORY");
2568
2569 case E_NOINTERFACE:
2570 return _T("E_NOINTERFACE");
2571
2572 case E_UNEXPECTED:
2573 return _T("E_UNEXPECTED");
2574
2575 case STG_E_INVALIDFLAG:
2576 return _T("STG_E_INVALIDFLAG");
2577
2578 case E_FAIL:
2579 return _T("E_FAIL");
2580
2581 case E_NOTIMPL:
2582 return _T("E_NOTIMPL");
2583
2584 default:
2585 {
2586 wxString buf;
2587 buf.Printf(_T("Unknown - 0x%X"), hr);
2588 return buf;
2589 }
2590 };
2591 };
2592
2593 // borrowed from src/msw/ole/oleutils.cpp
2594 wxString GetIIDName(REFIID riid)
2595 {
2596 // an association between symbolic name and numeric value of an IID
2597 struct KNOWN_IID
2598 {
2599 const IID *pIid;
2600 const wxChar *szName;
2601 };
2602
2603 // construct the table containing all known interfaces
2604 #define ADD_KNOWN_IID(name) { &IID_I##name, _T(#name) }
2605 #define ADD_KNOWN_GUID(name) { &name, _T(#name) }
2606
2607 static const KNOWN_IID aKnownIids[] =
2608 {
2609 ADD_KNOWN_IID(ServiceProvider),
2610 ADD_KNOWN_IID(AdviseSink),
2611 ADD_KNOWN_IID(AdviseSink2),
2612 ADD_KNOWN_IID(BindCtx),
2613 ADD_KNOWN_IID(ClassFactory),
2614 #if ( !defined( __VISUALC__) || (__VISUALC__!=1010) ) && !defined(__MWERKS__)
2615 ADD_KNOWN_IID(ContinueCallback),
2616 ADD_KNOWN_IID(EnumOleDocumentViews),
2617 ADD_KNOWN_IID(OleCommandTarget),
2618 ADD_KNOWN_IID(OleDocument),
2619 ADD_KNOWN_IID(OleDocumentSite),
2620 ADD_KNOWN_IID(OleDocumentView),
2621 ADD_KNOWN_IID(Print),
2622 #endif
2623 ADD_KNOWN_IID(DataAdviseHolder),
2624 ADD_KNOWN_IID(DataObject),
2625 ADD_KNOWN_IID(Debug),
2626 ADD_KNOWN_IID(DebugStream),
2627 ADD_KNOWN_IID(DfReserved1),
2628 ADD_KNOWN_IID(DfReserved2),
2629 ADD_KNOWN_IID(DfReserved3),
2630 ADD_KNOWN_IID(Dispatch),
2631 ADD_KNOWN_IID(DropSource),
2632 ADD_KNOWN_IID(DropTarget),
2633 ADD_KNOWN_IID(EnumCallback),
2634 ADD_KNOWN_IID(EnumFORMATETC),
2635 ADD_KNOWN_IID(EnumGeneric),
2636 ADD_KNOWN_IID(EnumHolder),
2637 ADD_KNOWN_IID(EnumMoniker),
2638 ADD_KNOWN_IID(EnumOLEVERB),
2639 ADD_KNOWN_IID(EnumSTATDATA),
2640 ADD_KNOWN_IID(EnumSTATSTG),
2641 ADD_KNOWN_IID(EnumString),
2642 ADD_KNOWN_IID(EnumUnknown),
2643 ADD_KNOWN_IID(EnumVARIANT),
2644 ADD_KNOWN_IID(ExternalConnection),
2645 ADD_KNOWN_IID(InternalMoniker),
2646 ADD_KNOWN_IID(LockBytes),
2647 ADD_KNOWN_IID(Malloc),
2648 ADD_KNOWN_IID(Marshal),
2649 ADD_KNOWN_IID(MessageFilter),
2650 ADD_KNOWN_IID(Moniker),
2651 ADD_KNOWN_IID(OleAdviseHolder),
2652 ADD_KNOWN_IID(OleCache),
2653 ADD_KNOWN_IID(OleCache2),
2654 ADD_KNOWN_IID(OleCacheControl),
2655 ADD_KNOWN_IID(OleClientSite),
2656 ADD_KNOWN_IID(OleContainer),
2657 ADD_KNOWN_IID(OleInPlaceActiveObject),
2658 ADD_KNOWN_IID(OleInPlaceFrame),
2659 ADD_KNOWN_IID(OleInPlaceObject),
2660 ADD_KNOWN_IID(OleInPlaceSite),
2661 ADD_KNOWN_IID(OleInPlaceUIWindow),
2662 ADD_KNOWN_IID(OleItemContainer),
2663 ADD_KNOWN_IID(OleLink),
2664 ADD_KNOWN_IID(OleManager),
2665 ADD_KNOWN_IID(OleObject),
2666 ADD_KNOWN_IID(OlePresObj),
2667 ADD_KNOWN_IID(OleWindow),
2668 ADD_KNOWN_IID(PSFactory),
2669 ADD_KNOWN_IID(ParseDisplayName),
2670 ADD_KNOWN_IID(Persist),
2671 ADD_KNOWN_IID(PersistFile),
2672 ADD_KNOWN_IID(PersistStorage),
2673 ADD_KNOWN_IID(PersistStream),
2674 ADD_KNOWN_IID(ProxyManager),
2675 ADD_KNOWN_IID(RootStorage),
2676 ADD_KNOWN_IID(RpcChannel),
2677 ADD_KNOWN_IID(RpcProxy),
2678 ADD_KNOWN_IID(RpcStub),
2679 ADD_KNOWN_IID(RunnableObject),
2680 ADD_KNOWN_IID(RunningObjectTable),
2681 ADD_KNOWN_IID(StdMarshalInfo),
2682 ADD_KNOWN_IID(Storage),
2683 ADD_KNOWN_IID(Stream),
2684 ADD_KNOWN_IID(StubManager),
2685 ADD_KNOWN_IID(Unknown),
2686 ADD_KNOWN_IID(ViewObject),
2687 ADD_KNOWN_IID(ViewObject2),
2688 ADD_KNOWN_GUID(IID_IDispatch),
2689 ADD_KNOWN_GUID(IID_IWebBrowser),
2690 ADD_KNOWN_GUID(IID_IWebBrowserApp),
2691 ADD_KNOWN_GUID(IID_IWebBrowser2),
2692 ADD_KNOWN_GUID(IID_IWebBrowser),
2693 ADD_KNOWN_GUID(DIID_DWebBrowserEvents2),
2694 ADD_KNOWN_GUID(DIID_DWebBrowserEvents),
2695 };
2696
2697 // don't clobber preprocessor name space
2698 #undef ADD_KNOWN_IID
2699 #undef ADD_KNOWN_GUID
2700
2701 // try to find the interface in the table
2702 for ( size_t ui = 0; ui < WXSIZEOF(aKnownIids); ui++ )
2703 {
2704 if ( riid == *aKnownIids[ui].pIid )
2705 {
2706 return aKnownIids[ui].szName;
2707 }
2708 }
2709
2710 // unknown IID, just transform to string
2711 LPOLESTR str = NULL;
2712 StringFromIID(riid, &str);
2713 if (str)
2714 {
2715 wxString s = str;
2716 CoTaskMemFree(str);
2717 return s;
2718 }
2719 else
2720 return _T("StringFromIID() error");
2721 }
wxWidgets (Impactor)