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