1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/ole/activex.cpp
3 // Purpose: wxActiveXContainer implementation
4 // Author: Ryan Norton <wxprojects@comcast.net>, Lindsay Mathieson <???>
8 // Copyright: (c) 2003 Lindsay Mathieson, (c) 2005 Ryan Norton
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 #include "wx/wxprec.h"
29 #include "wx/dcclient.h"
33 #include "wx/msw/dc.h"
35 #include "wx/msw/ole/activex.h"
36 #include "wx/msw/private.h" // for wxCopyRectToRECT
38 // autointerfaces that we only use here
39 typedef wxAutoOleInterface
<IOleInPlaceSite
> wxAutoIOleInPlaceSite
;
40 typedef wxAutoOleInterface
<IOleDocument
> wxAutoIOleDocument
;
41 typedef wxAutoOleInterface
<IPersistStreamInit
> wxAutoIPersistStreamInit
;
42 typedef wxAutoOleInterface
<IAdviseSink
> wxAutoIAdviseSink
;
43 typedef wxAutoOleInterface
<IProvideClassInfo
> wxAutoIProvideClassInfo
;
44 typedef wxAutoOleInterface
<ITypeInfo
> wxAutoITypeInfo
;
45 typedef wxAutoOleInterface
<IConnectionPoint
> wxAutoIConnectionPoint
;
46 typedef wxAutoOleInterface
<IConnectionPointContainer
> wxAutoIConnectionPointContainer
;
48 wxDEFINE_EVENT( wxEVT_ACTIVEX
, wxActiveXEvent
);
50 // Ole class helpers (sort of MFC-like) from wxActiveX
51 #define DECLARE_OLE_UNKNOWN(cls)\
57 TAutoInitInt() : l(1) {}\
59 TAutoInitInt refCount, lockCount;\
60 static void _GetInterface(cls *self, REFIID iid, void **_interface, const char *&desc);\
63 HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void ** ppvObject);\
64 ULONG STDMETHODCALLTYPE AddRef();\
65 ULONG STDMETHODCALLTYPE Release();\
66 ULONG STDMETHODCALLTYPE AddLock();\
67 ULONG STDMETHODCALLTYPE ReleaseLock()
69 #define DEFINE_OLE_TABLE(cls)\
70 LONG cls::GetRefCount() {return refCount.l;}\
71 HRESULT STDMETHODCALLTYPE cls::QueryInterface(REFIID iid, void ** ppvObject)\
77 const char *desc = NULL;\
78 cls::_GetInterface(this, iid, ppvObject, desc);\
81 return E_NOINTERFACE;\
83 ((IUnknown * )(*ppvObject))->AddRef();\
86 ULONG STDMETHODCALLTYPE cls::AddRef()\
88 InterlockedIncrement(&refCount.l);\
91 ULONG STDMETHODCALLTYPE cls::Release()\
95 InterlockedDecrement(&refCount.l);\
106 ULONG STDMETHODCALLTYPE cls::AddLock()\
108 InterlockedIncrement(&lockCount.l);\
111 ULONG STDMETHODCALLTYPE cls::ReleaseLock()\
113 if (lockCount.l > 0)\
115 InterlockedDecrement(&lockCount.l);\
123 #define DEFINE_OLE_BASE(cls)\
124 void cls::_GetInterface(cls *self, REFIID iid, void **_interface, const char *&desc)\
129 #define OLE_INTERFACE(_iid, _type)\
130 if (IsEqualIID(iid, _iid))\
132 *_interface = (IUnknown *) (_type *) self;\
137 #define OLE_IINTERFACE(_face) OLE_INTERFACE(IID_##_face, _face)
139 #define OLE_INTERFACE_CUSTOM(func)\
140 if (func(self, iid, _interface, desc))\
145 #define END_OLE_TABLE\
148 // ============================================================================
150 // ============================================================================
152 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
155 // Utility to convert from pixels to the himetric values in some COM methods
156 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
159 #define HIMETRIC_PER_INCH 2540
160 #define MAP_PIX_TO_LOGHIM(x,ppli) MulDiv(HIMETRIC_PER_INCH, (x), (ppli))
162 static void PixelsToHimetric(SIZEL
&sz
)
170 HDC dc
= GetDC(NULL
);
171 logX
= GetDeviceCaps(dc
, LOGPIXELSX
);
172 logY
= GetDeviceCaps(dc
, LOGPIXELSY
);
176 #define HIMETRIC_INCH 2540
177 #define CONVERT(x, logpixels) wxMulDivInt32(HIMETRIC_INCH, (x), (logpixels))
179 sz
.cx
= CONVERT(sz
.cx
, logX
);
180 sz
.cy
= CONVERT(sz
.cy
, logY
);
187 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
191 // Handles the actual wxActiveX container implementation
193 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
195 public IOleClientSite
,
196 public IOleInPlaceSiteEx
,
197 public IOleInPlaceFrame
,
198 public IOleItemContainer
,
200 public IOleCommandTarget
,
201 public IOleDocumentSite
,
203 public IOleControlSite
206 DECLARE_OLE_UNKNOWN(FrameSite
);
209 FrameSite(wxWindow
* win
, wxActiveXContainer
* win2
)
212 m_bSupportsWindowlessActivation
= true;
213 m_bInPlaceLocked
= false;
215 m_bInPlaceActive
= false;
216 m_bWindowless
= false;
218 m_nAmbientLocale
= 0;
219 m_clrAmbientForeColor
= ::GetSysColor(COLOR_WINDOWTEXT
);
220 m_clrAmbientBackColor
= ::GetSysColor(COLOR_WINDOW
);
221 m_bAmbientShowHatching
= true;
222 m_bAmbientShowGrabHandles
= true;
223 m_bAmbientAppearance
= true;
226 m_hWndParent
= (HWND
)win
->GetHWND();
228 virtual ~FrameSite(){}
229 //***************************IDispatch*****************************
230 HRESULT STDMETHODCALLTYPE
GetIDsOfNames(REFIID
, OLECHAR
** ,
231 unsigned int , LCID
,
233 { return E_NOTIMPL
; }
234 STDMETHOD(GetTypeInfo
)(unsigned int, LCID
, ITypeInfo
**)
235 { return E_NOTIMPL
; }
236 HRESULT STDMETHODCALLTYPE
GetTypeInfoCount(unsigned int *)
237 { return E_NOTIMPL
; }
238 HRESULT STDMETHODCALLTYPE
Invoke(DISPID dispIdMember
, REFIID
, LCID
,
239 WORD wFlags
, DISPPARAMS
*,
240 VARIANT
* pVarResult
, EXCEPINFO
*,
243 if (!(wFlags
& DISPATCH_PROPERTYGET
))
246 if (pVarResult
== NULL
)
249 //The most common case is boolean, use as an initial type
250 V_VT(pVarResult
) = VT_BOOL
;
252 switch (dispIdMember
)
254 case DISPID_AMBIENT_MESSAGEREFLECT
:
255 V_BOOL(pVarResult
)= FALSE
;
258 case DISPID_AMBIENT_DISPLAYASDEFAULT
:
259 V_BOOL(pVarResult
)= TRUE
;
262 case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED
:
263 V_BOOL(pVarResult
) = TRUE
;
266 case DISPID_AMBIENT_SILENT
:
267 V_BOOL(pVarResult
)= TRUE
;
270 case DISPID_AMBIENT_APPEARANCE
:
271 pVarResult
->vt
= VT_BOOL
;
272 pVarResult
->boolVal
= m_bAmbientAppearance
;
275 case DISPID_AMBIENT_FORECOLOR
:
276 pVarResult
->vt
= VT_I4
;
277 pVarResult
->lVal
= (long) m_clrAmbientForeColor
;
280 case DISPID_AMBIENT_BACKCOLOR
:
281 pVarResult
->vt
= VT_I4
;
282 pVarResult
->lVal
= (long) m_clrAmbientBackColor
;
285 case DISPID_AMBIENT_LOCALEID
:
286 pVarResult
->vt
= VT_I4
;
287 pVarResult
->lVal
= (long) m_nAmbientLocale
;
290 case DISPID_AMBIENT_USERMODE
:
291 pVarResult
->vt
= VT_BOOL
;
292 pVarResult
->boolVal
= m_window
->m_bAmbientUserMode
;
295 case DISPID_AMBIENT_SHOWGRABHANDLES
:
296 pVarResult
->vt
= VT_BOOL
;
297 pVarResult
->boolVal
= m_bAmbientShowGrabHandles
;
300 case DISPID_AMBIENT_SHOWHATCHING
:
301 pVarResult
->vt
= VT_BOOL
;
302 pVarResult
->boolVal
= m_bAmbientShowHatching
;
306 return DISP_E_MEMBERNOTFOUND
;
312 //**************************IOleWindow***************************
313 HRESULT STDMETHODCALLTYPE
GetWindow(HWND
* phwnd
)
317 (*phwnd
) = m_hWndParent
;
320 HRESULT STDMETHODCALLTYPE
ContextSensitiveHelp(BOOL
)
322 //**************************IOleInPlaceUIWindow*****************
323 HRESULT STDMETHODCALLTYPE
GetBorder(LPRECT lprectBorder
)
325 if (lprectBorder
== NULL
)
327 return INPLACE_E_NOTOOLSPACE
;
329 HRESULT STDMETHODCALLTYPE
RequestBorderSpace(LPCBORDERWIDTHS pborderwidths
)
331 if (pborderwidths
== NULL
)
333 return INPLACE_E_NOTOOLSPACE
;
335 HRESULT STDMETHODCALLTYPE
SetBorderSpace(LPCBORDERWIDTHS
)
337 HRESULT STDMETHODCALLTYPE
SetActiveObject(
338 IOleInPlaceActiveObject
*pActiveObject
, LPCOLESTR
)
341 pActiveObject
->AddRef();
343 m_window
->m_oleInPlaceActiveObject
= pActiveObject
;
347 //********************IOleInPlaceFrame************************
349 STDMETHOD(InsertMenus
)(HMENU
, LPOLEMENUGROUPWIDTHS
){return S_OK
;}
350 STDMETHOD(SetMenu
)(HMENU
, HOLEMENU
, HWND
){ return S_OK
;}
351 STDMETHOD(RemoveMenus
)(HMENU
){return S_OK
;}
352 STDMETHOD(SetStatusText
)(LPCOLESTR
){ return S_OK
;}
353 HRESULT STDMETHODCALLTYPE
EnableModeless(BOOL
){return S_OK
;}
354 HRESULT STDMETHODCALLTYPE
TranslateAccelerator(LPMSG lpmsg
, WORD
)
356 // TODO: send an event with this id
357 if (m_window
->m_oleInPlaceActiveObject
.IsOk())
358 m_window
->m_oleInPlaceActiveObject
->TranslateAccelerator(lpmsg
);
362 //*******************IOleInPlaceSite**************************
363 HRESULT STDMETHODCALLTYPE
CanInPlaceActivate(){return S_OK
;}
364 HRESULT STDMETHODCALLTYPE
OnInPlaceActivate()
365 { m_bInPlaceActive
= true; return S_OK
; }
366 HRESULT STDMETHODCALLTYPE
OnUIActivate()
367 { m_bUIActive
= true; return S_OK
; }
368 HRESULT STDMETHODCALLTYPE
GetWindowContext(IOleInPlaceFrame
**ppFrame
,
369 IOleInPlaceUIWindow
**ppDoc
,
372 LPOLEINPLACEFRAMEINFO lpFrameInfo
)
374 if (ppFrame
== NULL
|| ppDoc
== NULL
|| lprcPosRect
== NULL
||
375 lprcClipRect
== NULL
|| lpFrameInfo
== NULL
)
384 HRESULT hr
= QueryInterface(IID_IOleInPlaceFrame
, (void **) ppFrame
);
390 hr
= QueryInterface(IID_IOleInPlaceUIWindow
, (void **) ppDoc
);
393 (*ppFrame
)->Release();
399 ::GetClientRect(m_hWndParent
, &rect
);
402 lprcPosRect
->left
= lprcPosRect
->top
= 0;
403 lprcPosRect
->right
= rect
.right
;
404 lprcPosRect
->bottom
= rect
.bottom
;
408 lprcClipRect
->left
= lprcClipRect
->top
= 0;
409 lprcClipRect
->right
= rect
.right
;
410 lprcClipRect
->bottom
= rect
.bottom
;
413 memset(lpFrameInfo
, 0, sizeof(OLEINPLACEFRAMEINFO
));
414 lpFrameInfo
->cb
= sizeof(OLEINPLACEFRAMEINFO
);
415 lpFrameInfo
->hwndFrame
= m_hWndParent
;
419 HRESULT STDMETHODCALLTYPE
Scroll(SIZE
){return S_OK
;}
420 HRESULT STDMETHODCALLTYPE
OnUIDeactivate(BOOL
)
421 { m_bUIActive
= false; return S_OK
; }
422 HRESULT STDMETHODCALLTYPE
OnInPlaceDeactivate()
423 { m_bInPlaceActive
= false; return S_OK
; }
424 HRESULT STDMETHODCALLTYPE
DiscardUndoState(){return S_OK
;}
425 HRESULT STDMETHODCALLTYPE
DeactivateAndUndo(){return S_OK
; }
426 HRESULT STDMETHODCALLTYPE
OnPosRectChange(LPCRECT lprcPosRect
)
428 if (m_window
->m_oleInPlaceObject
.IsOk() && lprcPosRect
)
431 // Result of several hours and days of bug hunting -
432 // this is called by an object when it wants to resize
433 // itself to something different then our parent window -
436 // m_window->m_oleInPlaceObject->SetObjectRects(
437 // lprcPosRect, lprcPosRect);
439 ::GetClientRect(m_hWndParent
, &rcClient
);
440 m_window
->m_oleInPlaceObject
->SetObjectRects(
441 &rcClient
, &rcClient
);
445 //*************************IOleInPlaceSiteEx***********************
446 HRESULT STDMETHODCALLTYPE
OnInPlaceActivateEx(BOOL
* pfNoRedraw
, DWORD
)
449 IRunnableObject
* runnable
= NULL
;
450 HRESULT hr
= QueryInterface(
451 IID_IRunnableObject
, (void**)(& runnable
));
454 runnable
->LockRunning(TRUE
, FALSE
);
457 OleLockRunning(m_window
->m_ActiveX
, TRUE
, FALSE
);
460 (*pfNoRedraw
) = FALSE
;
464 HRESULT STDMETHODCALLTYPE
OnInPlaceDeactivateEx(BOOL
)
467 IRunnableObject
* runnable
= NULL
;
468 HRESULT hr
= QueryInterface(
469 IID_IRunnableObject
, (void**)(& runnable
));
472 runnable
->LockRunning(FALSE
, FALSE
);
475 OleLockRunning(m_window
->m_ActiveX
, FALSE
, FALSE
);
479 STDMETHOD(RequestUIActivate
)(){ return S_OK
;}
480 //*************************IOleClientSite**************************
481 HRESULT STDMETHODCALLTYPE
SaveObject(){return S_OK
;}
482 const char *OleGetMonikerToStr(DWORD dwAssign
)
486 case OLEGETMONIKER_ONLYIFTHERE
: return "OLEGETMONIKER_ONLYIFTHERE";
487 case OLEGETMONIKER_FORCEASSIGN
: return "OLEGETMONIKER_FORCEASSIGN";
488 case OLEGETMONIKER_UNASSIGN
: return "OLEGETMONIKER_UNASSIGN";
489 case OLEGETMONIKER_TEMPFORUSER
: return "OLEGETMONIKER_TEMPFORUSER";
490 default : return "Bad Enum";
494 const char *OleGetWhicMonikerStr(DWORD dwWhichMoniker
)
496 switch(dwWhichMoniker
)
498 case OLEWHICHMK_CONTAINER
: return "OLEWHICHMK_CONTAINER";
499 case OLEWHICHMK_OBJREL
: return "OLEWHICHMK_OBJREL";
500 case OLEWHICHMK_OBJFULL
: return "OLEWHICHMK_OBJFULL";
501 default : return "Bad Enum";
504 STDMETHOD(GetMoniker
)(DWORD
, DWORD
, IMoniker
**){return E_FAIL
;}
505 HRESULT STDMETHODCALLTYPE
GetContainer(LPOLECONTAINER
* ppContainer
)
507 if (ppContainer
== NULL
)
509 HRESULT hr
= QueryInterface(
510 IID_IOleContainer
, (void**)(ppContainer
));
511 wxASSERT(SUCCEEDED(hr
));
514 HRESULT STDMETHODCALLTYPE
ShowObject()
516 if (m_window
->m_oleObjectHWND
)
517 ::ShowWindow(m_window
->m_oleObjectHWND
, SW_SHOW
);
520 STDMETHOD(OnShowWindow
)(BOOL
){return S_OK
;}
521 STDMETHOD(RequestNewObjectLayout
)(){return E_NOTIMPL
;}
522 //********************IParseDisplayName***************************
523 HRESULT STDMETHODCALLTYPE
ParseDisplayName(
524 IBindCtx
*, LPOLESTR
, ULONG
*, IMoniker
**){return E_NOTIMPL
;}
525 //********************IOleContainer*******************************
526 STDMETHOD(EnumObjects
)(DWORD
, IEnumUnknown
**){return E_NOTIMPL
;}
527 HRESULT STDMETHODCALLTYPE
LockContainer(BOOL
){return S_OK
;}
528 //********************IOleItemContainer***************************
529 HRESULT STDMETHODCALLTYPE
530 #if 0 // defined(__WXWINCE__) && __VISUALC__ < 1400
532 #elif defined(_UNICODE)
537 (LPOLESTR pszItem
, DWORD
, IBindCtx
*, REFIID
, void ** ppvObject
)
539 if (pszItem
== NULL
|| ppvObject
== NULL
)
542 return MK_E_NOOBJECT
;
544 HRESULT STDMETHODCALLTYPE
GetObjectStorage(
545 LPOLESTR pszItem
, IBindCtx
* , REFIID
, void ** ppvStorage
)
547 if (pszItem
== NULL
|| ppvStorage
== NULL
)
550 return MK_E_NOOBJECT
;
552 HRESULT STDMETHODCALLTYPE
IsRunning(LPOLESTR pszItem
)
556 return MK_E_NOOBJECT
;
558 //***********************IOleControlSite*****************************
559 HRESULT STDMETHODCALLTYPE
OnControlInfoChanged()
561 HRESULT STDMETHODCALLTYPE
LockInPlaceActive(BOOL fLock
)
563 m_bInPlaceLocked
= (fLock
) ? true : false;
566 HRESULT STDMETHODCALLTYPE
GetExtendedControl(IDispatch
**)
568 HRESULT STDMETHODCALLTYPE
TransformCoords(
569 POINTL
* pPtlHimetric
, POINTF
* pPtfContainer
, DWORD
)
571 if (pPtlHimetric
== NULL
|| pPtfContainer
== NULL
)
575 HRESULT STDMETHODCALLTYPE
TranslateAccelerator(LPMSG
, DWORD
)
577 HRESULT STDMETHODCALLTYPE
OnFocus(BOOL
){return S_OK
;}
578 HRESULT STDMETHODCALLTYPE
ShowPropertyFrame(){return E_NOTIMPL
;}
579 //**************************IOleCommandTarget***********************
580 HRESULT STDMETHODCALLTYPE
QueryStatus(const GUID
*, ULONG cCmds
,
581 OLECMD prgCmds
[], OLECMDTEXT
*)
583 if (prgCmds
== NULL
) return E_INVALIDARG
;
584 for (ULONG nCmd
= 0; nCmd
< cCmds
; nCmd
++)
586 // unsupported by default
587 prgCmds
[nCmd
].cmdf
= 0;
589 return OLECMDERR_E_UNKNOWNGROUP
;
592 HRESULT STDMETHODCALLTYPE
Exec(const GUID
*, DWORD
,
593 DWORD
, VARIANTARG
*, VARIANTARG
*)
594 {return OLECMDERR_E_NOTSUPPORTED
;}
596 //**********************IAdviseSink************************************
597 void STDMETHODCALLTYPE
OnDataChange(FORMATETC
*, STGMEDIUM
*) {}
598 void STDMETHODCALLTYPE
OnViewChange(DWORD
, LONG
) {}
599 void STDMETHODCALLTYPE
OnRename(IMoniker
*){}
600 void STDMETHODCALLTYPE
OnSave(){}
601 void STDMETHODCALLTYPE
OnClose(){}
603 //**********************IOleDocumentSite***************************
604 HRESULT STDMETHODCALLTYPE
ActivateMe(
605 IOleDocumentView __RPC_FAR
*pViewToActivate
)
607 wxAutoIOleInPlaceSite
inPlaceSite(
608 IID_IOleInPlaceSite
, (IDispatch
*) this);
609 if (!inPlaceSite
.IsOk())
614 m_window
->m_docView
= pViewToActivate
;
615 m_window
->m_docView
->SetInPlaceSite(inPlaceSite
);
619 wxAutoIOleDocument
oleDoc(
620 IID_IOleDocument
, m_window
->m_oleObject
);
624 HRESULT hr
= oleDoc
->CreateView(inPlaceSite
, NULL
,
625 0, m_window
->m_docView
.GetRef());
629 m_window
->m_docView
->SetInPlaceSite(inPlaceSite
);
632 m_window
->m_docView
->UIActivate(TRUE
);
638 wxActiveXContainer
* m_window
;
643 bool m_bSupportsWindowlessActivation
;
644 bool m_bInPlaceLocked
;
645 bool m_bInPlaceActive
;
649 LCID m_nAmbientLocale
;
650 COLORREF m_clrAmbientForeColor
;
651 COLORREF m_clrAmbientBackColor
;
652 bool m_bAmbientShowHatching
;
653 bool m_bAmbientShowGrabHandles
;
654 bool m_bAmbientAppearance
;
657 DEFINE_OLE_TABLE(FrameSite
)
658 OLE_INTERFACE(IID_IUnknown
, IOleClientSite
)
659 OLE_IINTERFACE(IOleClientSite
)
660 OLE_INTERFACE(IID_IOleWindow
, IOleInPlaceSite
)
661 OLE_IINTERFACE(IOleInPlaceSite
)
662 OLE_IINTERFACE(IOleInPlaceSiteEx
)
663 OLE_IINTERFACE(IOleInPlaceUIWindow
)
664 OLE_IINTERFACE(IOleInPlaceFrame
)
665 OLE_IINTERFACE(IParseDisplayName
)
666 OLE_IINTERFACE(IOleContainer
)
667 OLE_IINTERFACE(IOleItemContainer
)
668 OLE_IINTERFACE(IDispatch
)
669 OLE_IINTERFACE(IOleCommandTarget
)
670 OLE_IINTERFACE(IOleDocumentSite
)
671 OLE_IINTERFACE(IAdviseSink
)
672 OLE_IINTERFACE(IOleControlSite
)
676 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
680 // Handles and sends activex events received from the ActiveX control
681 // to the appropriate wxEvtHandler
683 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
684 class wxActiveXEvents
: public IDispatch
687 DECLARE_OLE_UNKNOWN(wxActiveXEvents
);
690 wxActiveXContainer
*m_activeX
;
694 friend bool wxActiveXEventsInterface(wxActiveXEvents
*self
, REFIID iid
, void **_interface
, const char *&desc
);
698 // a pointer to this static variable is used as an 'invalid_entry_marker'
699 // wxVariants containing a void* to this variables are 'empty' in the sense
700 // that the actual ActiveX OLE parameter has not been converted and inserted
702 static wxVariant ms_invalidEntryMarker
;
704 wxActiveXEvents(wxActiveXContainer
*ax
) : m_activeX(ax
), m_haveCustomId(false) {}
705 wxActiveXEvents(wxActiveXContainer
*ax
, REFIID iid
) : m_activeX(ax
), m_customId(iid
), m_haveCustomId(true) {}
706 virtual ~wxActiveXEvents()
711 STDMETHODIMP
GetIDsOfNames(REFIID
, OLECHAR
**, unsigned int, LCID
, DISPID
*)
716 STDMETHODIMP
GetTypeInfo(unsigned int, LCID
, ITypeInfo
**)
721 STDMETHODIMP
GetTypeInfoCount(unsigned int*)
727 STDMETHODIMP
Invoke(DISPID dispIdMember
, REFIID riid
,
729 WORD wFlags
, DISPPARAMS
* pDispParams
,
730 VARIANT
* pVarResult
, EXCEPINFO
* pExcepInfo
,
731 unsigned int * puArgErr
)
733 if (wFlags
& (DISPATCH_PROPERTYGET
| DISPATCH_PROPERTYPUT
| DISPATCH_PROPERTYPUTREF
))
741 wxActiveXEvent event
;
742 event
.SetEventType(wxEVT_ACTIVEX
);
743 // Create an empty list of Variants
744 // Note that the event parameters use lazy evaluation
745 // They are not actually created until wxActiveXEvent::operator[] is called
746 event
.m_params
.NullList();
747 event
.m_dispid
= dispIdMember
;
749 // save the native (MSW) event parameters for event handlers that need to access them
750 // this can be done on the stack since wxActiveXEvent is also allocated on the stack
751 wxActiveXEventNativeMSW
eventParameters(dispIdMember
, riid
, lcid
, wFlags
, pDispParams
, pVarResult
, pExcepInfo
, puArgErr
);
752 event
.SetClientData(&eventParameters
);
754 // The event parameters are not copied to event.m_params until they are actually
755 // referenced in wxActiveXEvent::operator[]
756 // This increases performance and avoids error messages and/or crashes
757 // when the event has parameters that are not (yet or never) supported
758 // by wxConvertOleToVariant
760 // process the events from the activex method
761 m_activeX
->ProcessEvent(event
);
762 for (DWORD i
= 0; i
< pDispParams
->cArgs
; i
++)
764 size_t params_index
= pDispParams
->cArgs
- i
- 1;
765 if (params_index
< event
.m_params
.GetCount()) {
766 wxVariant
&vx
= event
.m_params
[params_index
];
767 // copy the result back to pDispParams only if the event has been accessed
768 // i.e. if vx != ms_invalidEntryMarker
769 if (!vx
.IsType(wxActiveXEvents::ms_invalidEntryMarker
.GetType()) || vx
!=ms_invalidEntryMarker
) {
770 VARIANTARG
& va
= pDispParams
->rgvarg
[i
];
771 wxConvertVariantToOle(vx
, va
);
776 if(event
.GetSkipped())
777 return DISP_E_MEMBERNOTFOUND
;
785 // just a unique global variable
786 const int invalid_entry_marker
= 0;
789 wxVariant
wxActiveXEvents::ms_invalidEntryMarker((void*)&invalid_entry_marker
);
791 size_t wxActiveXEvent::ParamCount() const
793 wxActiveXEventNativeMSW
*native
=GetNativeParameters();
794 // 'native' will always be != if the event has been created
795 // for an actual active X event.
796 // But it may be zero if the event has been created by wx program code.
798 return native
->pDispParams
? native
->pDispParams
->cArgs
: 0;
800 return m_params
.GetCount();
803 wxVariant
&wxActiveXEvent::operator [](size_t idx
)
805 wxASSERT(idx
< ParamCount());
806 wxActiveXEventNativeMSW
*native
=GetNativeParameters();
807 // 'native' will always be != if the event has been created
808 // for an actual active X event.
809 // But it may be zero if the event has been created by wx program code.
812 while ( m_params
.GetCount()<=idx
)
814 m_params
.Append(wxActiveXEvents::ms_invalidEntryMarker
);
817 wxVariant
& vx
= m_params
[idx
];
818 if ( vx
.IsType(wxActiveXEvents::ms_invalidEntryMarker
.GetType()) &&
819 vx
== wxActiveXEvents::ms_invalidEntryMarker
)
821 // copy the _real_ parameter into this one
822 // NOTE: m_params stores the parameters in *reverse* order.
823 // Whyever, but this was the case in the original implementation of
824 // wxActiveXEvents::Invoke
825 // Keep this convention.
826 VARIANTARG
& va
= native
->pDispParams
->rgvarg
[ native
->pDispParams
->cArgs
- idx
- 1 ];
827 wxConvertOleToVariant(va
, vx
);
831 return m_params
[idx
];
834 bool wxActiveXEventsInterface(wxActiveXEvents
*self
, REFIID iid
, void **_interface
, const char *&desc
)
836 if (self
->m_haveCustomId
&& IsEqualIID(iid
, self
->m_customId
))
838 *_interface
= (IUnknown
*) (IDispatch
*) self
;
839 desc
= "Custom Dispatch Interface";
846 DEFINE_OLE_TABLE(wxActiveXEvents
)
847 OLE_IINTERFACE(IUnknown
)
848 OLE_INTERFACE(IID_IDispatch
, IDispatch
)
849 OLE_INTERFACE_CUSTOM(wxActiveXEventsInterface
)
852 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
854 // wxActiveXContainer
856 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
858 //---------------------------------------------------------------------------
859 // wxActiveXContainer Constructor
861 // Initializes members and creates the native ActiveX container
862 //---------------------------------------------------------------------------
863 wxActiveXContainer::wxActiveXContainer(wxWindow
* parent
,
864 REFIID iid
, IUnknown
* pUnk
)
865 : m_realparent(parent
)
867 m_bAmbientUserMode
= true;
868 m_docAdviseCookie
= 0;
869 CreateActiveX(iid
, pUnk
);
872 //---------------------------------------------------------------------------
873 // wxActiveXContainer Destructor
875 // Destroys members (the FrameSite et al. are destroyed implicitly
876 // through COM ref counting)
877 //---------------------------------------------------------------------------
878 wxActiveXContainer::~wxActiveXContainer()
880 // disconnect connection points
881 if (m_oleInPlaceObject
.IsOk())
883 m_oleInPlaceObject
->InPlaceDeactivate();
884 m_oleInPlaceObject
->UIDeactivate();
887 if (m_oleObject
.IsOk())
889 if (m_docAdviseCookie
!= 0)
890 m_oleObject
->Unadvise(m_docAdviseCookie
);
893 OLEIVERB_HIDE
, NULL
, m_clientSite
, 0, (HWND
) GetHWND(), NULL
);
894 m_oleObject
->Close(OLECLOSE_NOSAVE
);
895 m_oleObject
->SetClientSite(NULL
);
898 // m_clientSite uses m_frameSite so destroy it first
902 // our window doesn't belong to us, don't destroy it
906 // VZ: we might want to really report an error instead of just asserting here
908 #define CHECK_HR(hr) \
909 wxASSERT_LEVEL_2_MSG( SUCCEEDED(hr), \
910 wxString::Format("HRESULT = %X", (unsigned)(hr)) )
912 #define CHECK_HR(hr) wxUnusedVar(hr)
915 //---------------------------------------------------------------------------
916 // wxActiveXContainer::CreateActiveX
918 // Actually creates the ActiveX container through the FrameSite
919 // and sets up ActiveX events
921 // TODO: Document this more
922 //---------------------------------------------------------------------------
923 void wxActiveXContainer::CreateActiveX(REFIID iid
, IUnknown
* pUnk
)
926 hret
= m_ActiveX
.QueryInterface(iid
, pUnk
);
930 m_frameSite
= new FrameSite(m_realparent
, this);
932 hret
= m_clientSite
.QueryInterface(
933 IID_IOleClientSite
, (IDispatch
*) m_frameSite
);
936 wxAutoIAdviseSink
adviseSink(IID_IAdviseSink
, (IDispatch
*) m_frameSite
);
937 wxASSERT(adviseSink
.IsOk());
939 // Get Dispatch interface
940 hret
= m_Dispatch
.QueryInterface(IID_IDispatch
, m_ActiveX
);
944 // SETUP TYPEINFO AND ACTIVEX EVENTS
947 // get type info via class info
948 wxAutoIProvideClassInfo
classInfo(IID_IProvideClassInfo
, m_ActiveX
);
949 wxASSERT(classInfo
.IsOk());
952 wxAutoITypeInfo typeInfo
;
953 hret
= classInfo
->GetClassInfo(typeInfo
.GetRef());
955 wxASSERT(typeInfo
.IsOk());
959 hret
= typeInfo
->GetTypeAttr(&ta
);
962 // this should be a TKIND_COCLASS
963 wxASSERT(ta
->typekind
== TKIND_COCLASS
);
965 // iterate contained interfaces
966 for (int i
= 0; i
< ta
->cImplTypes
; i
++)
970 // get dispatch type info handle
971 hret
= typeInfo
->GetRefTypeOfImplType(i
, &rt
);
972 if (! SUCCEEDED(hret
))
975 // get dispatch type info interface
977 hret
= typeInfo
->GetRefTypeInfo(rt
, ti
.GetRef());
983 // check if default event sink
984 bool defEventSink
= false;
985 int impTypeFlags
= 0;
986 typeInfo
->GetImplTypeFlags(i
, &impTypeFlags
);
988 if (impTypeFlags
& IMPLTYPEFLAG_FDEFAULT
)
990 if (impTypeFlags
& IMPLTYPEFLAG_FSOURCE
)
992 // WXOLE_TRACEOUT("Default Event Sink");
994 if (impTypeFlags
& IMPLTYPEFLAG_FDEFAULTVTABLE
)
996 // WXOLE_TRACEOUT("*ERROR* - Default Event Sink is via vTable");
997 defEventSink
= false;
998 wxFAIL_MSG(wxT("Default event sink is in vtable!"));
1004 // wxAutoOleInterface<> assumes a ref has already been added
1006 TYPEATTR
*ta
= NULL
;
1007 hret
= ti
->GetTypeAttr(&ta
);
1010 if (ta
->typekind
== TKIND_DISPATCH
)
1012 // WXOLE_TRACEOUT("GUID = " << GetIIDName(ta->guid).c_str());
1015 wxAutoIConnectionPoint cp
;
1016 DWORD adviseCookie
= 0;
1018 wxAutoIConnectionPointContainer
cpContainer(IID_IConnectionPointContainer
, m_ActiveX
);
1019 wxASSERT( cpContainer
.IsOk());
1022 cpContainer
->FindConnectionPoint(ta
->guid
, cp
.GetRef());
1024 // Notice that the return value of CONNECT_E_NOCONNECTION is
1025 // expected if the interface doesn't support connection points.
1026 if ( hret
!= CONNECT_E_NOCONNECTION
)
1033 wxActiveXEvents
* const
1034 events
= new wxActiveXEvents(this, ta
->guid
);
1035 hret
= cp
->Advise(events
, &adviseCookie
);
1037 // We don't need this object any more and cp will keep a
1038 // reference to it if it needs it, i.e. if Advise()
1047 ti
->ReleaseTypeAttr(ta
);
1051 typeInfo
->ReleaseTypeAttr(ta
);
1057 // Get IOleObject interface
1058 hret
= m_oleObject
.QueryInterface(IID_IOleObject
, m_ActiveX
);
1061 // get IViewObject Interface
1062 hret
= m_viewObject
.QueryInterface(IID_IViewObject
, m_ActiveX
);
1066 m_docAdviseCookie
= 0;
1067 hret
= m_oleObject
->Advise(adviseSink
, &m_docAdviseCookie
);
1071 // hret = m_viewObject->SetAdvise(DVASPECT_CONTENT, 0, adviseSink);
1072 m_oleObject
->SetHostNames(L
"wxActiveXContainer", NULL
);
1073 OleSetContainedObject(m_oleObject
, TRUE
);
1074 OleRun(m_oleObject
);
1077 // Get IOleInPlaceObject interface
1078 hret
= m_oleInPlaceObject
.QueryInterface(
1079 IID_IOleInPlaceObject
, m_ActiveX
);
1084 m_oleObject
->GetMiscStatus(DVASPECT_CONTENT
, &dwMiscStatus
);
1087 // set client site first ?
1088 if (dwMiscStatus
& OLEMISC_SETCLIENTSITEFIRST
)
1089 m_oleObject
->SetClientSite(m_clientSite
);
1093 wxAutoIPersistStreamInit
1094 pPersistStreamInit(IID_IPersistStreamInit
, m_oleObject
);
1096 if (pPersistStreamInit
.IsOk())
1098 hret
= pPersistStreamInit
->InitNew();
1102 if (! (dwMiscStatus
& OLEMISC_SETCLIENTSITEFIRST
))
1103 m_oleObject
->SetClientSite(m_clientSite
);
1106 m_oleObjectHWND
= 0;
1108 if (m_oleInPlaceObject
.IsOk())
1110 hret
= m_oleInPlaceObject
->GetWindow(&m_oleObjectHWND
);
1111 if (SUCCEEDED(hret
))
1112 ::SetActiveWindow(m_oleObjectHWND
);
1116 if (! (dwMiscStatus
& OLEMISC_INVISIBLEATRUNTIME
))
1119 wxCopyRectToRECT(m_realparent
->GetClientSize(), posRect
);
1121 if (posRect
.right
> 0 && posRect
.bottom
> 0 &&
1122 m_oleInPlaceObject
.IsOk())
1124 m_oleInPlaceObject
->SetObjectRects(&posRect
, &posRect
);
1127 hret
= m_oleObject
->DoVerb(OLEIVERB_INPLACEACTIVATE
, NULL
,
1128 m_clientSite
, 0, (HWND
)m_realparent
->GetHWND(), &posRect
);
1131 hret
= m_oleObject
->DoVerb(OLEIVERB_SHOW
, 0, m_clientSite
, 0,
1132 (HWND
)m_realparent
->GetHWND(), &posRect
);
1136 if (! m_oleObjectHWND
&& m_oleInPlaceObject
.IsOk())
1138 hret
= m_oleInPlaceObject
->GetWindow(&m_oleObjectHWND
);
1142 if (m_oleObjectHWND
)
1144 ::SetActiveWindow(m_oleObjectHWND
);
1145 ::ShowWindow(m_oleObjectHWND
, SW_SHOW
);
1147 this->AssociateHandle(m_oleObjectHWND
);
1148 this->Reparent(m_realparent
);
1150 wxWindow
* pWnd
= m_realparent
;
1151 int id
= m_realparent
->GetId();
1153 pWnd
->Connect(id
, wxEVT_SIZE
,
1154 wxSizeEventHandler(wxActiveXContainer::OnSize
), 0, this);
1155 // this->Connect(GetId(), wxEVT_PAINT,
1156 // wxPaintEventHandler(wxActiveXContainer::OnPaint), 0, this);
1157 pWnd
->Connect(id
, wxEVT_SET_FOCUS
,
1158 wxFocusEventHandler(wxActiveXContainer::OnSetFocus
), 0, this);
1159 pWnd
->Connect(id
, wxEVT_KILL_FOCUS
,
1160 wxFocusEventHandler(wxActiveXContainer::OnKillFocus
), 0, this);
1164 //---------------------------------------------------------------------------
1165 // wxActiveXContainer::OnSize
1167 // Called when the parent is resized - we need to do this to actually
1168 // move the ActiveX control to where the parent is
1169 //---------------------------------------------------------------------------
1170 void wxActiveXContainer::OnSize(wxSizeEvent
& event
)
1173 GetParent()->GetClientSize(&w
, &h
);
1181 if (w
<= 0 || h
<= 0)
1184 // extents are in HIMETRIC units
1185 if (m_oleObject
.IsOk())
1189 PixelsToHimetric(sz
);
1193 m_oleObject
->GetExtent(DVASPECT_CONTENT
, &sz2
);
1194 if (sz2
.cx
!= sz
.cx
|| sz
.cy
!= sz2
.cy
)
1195 m_oleObject
->SetExtent(DVASPECT_CONTENT
, &sz
);
1199 if (m_oleInPlaceObject
.IsOk())
1200 m_oleInPlaceObject
->SetObjectRects(&posRect
, &posRect
);
1205 //---------------------------------------------------------------------------
1206 // wxActiveXContainer::OnPaint
1208 // Called when the parent is resized - repaints the ActiveX control
1209 //---------------------------------------------------------------------------
1210 void wxActiveXContainer::OnPaint(wxPaintEvent
& WXUNUSED(event
))
1213 // Draw only when control is windowless or deactivated
1217 GetParent()->GetSize(&w
, &h
);
1224 #if !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1225 ::RedrawWindow(m_oleObjectHWND
, NULL
, NULL
, RDW_INTERNALPAINT
);
1227 ::InvalidateRect(m_oleObjectHWND
, NULL
, false);
1229 RECTL
*prcBounds
= (RECTL
*) &posRect
;
1230 wxMSWDCImpl
*msw
= wxDynamicCast( dc
.GetImpl() , wxMSWDCImpl
);
1231 m_viewObject
->Draw(DVASPECT_CONTENT
, -1, NULL
, NULL
, NULL
,
1232 (HDC
)msw
->GetHDC(), prcBounds
, NULL
, NULL
, 0);
1236 //---------------------------------------------------------------------------
1237 // wxActiveXContainer::OnSetFocus
1239 // Called when the focus is set on the parent - activates the activex control
1240 //---------------------------------------------------------------------------
1241 void wxActiveXContainer::OnSetFocus(wxFocusEvent
& event
)
1243 if (m_oleInPlaceActiveObject
.IsOk())
1244 m_oleInPlaceActiveObject
->OnFrameWindowActivate(TRUE
);
1249 //---------------------------------------------------------------------------
1250 // wxActiveXContainer::OnKillFocus
1252 // Called when the focus is killed on the parent -
1253 // deactivates the activex control
1254 //---------------------------------------------------------------------------
1255 void wxActiveXContainer::OnKillFocus(wxFocusEvent
& event
)
1257 if (m_oleInPlaceActiveObject
.IsOk())
1258 m_oleInPlaceActiveObject
->OnFrameWindowActivate(FALSE
);
1263 //---------------------------------------------------------------------------
1264 // wxActiveXContainer::MSWTranslateMessage
1266 // Called for every message that needs to be translated.
1267 // Some controls might need more keyboard keys to process (CTRL-C, CTRL-A ect),
1268 // In that case TranslateAccelerator should always be called first.
1269 //---------------------------------------------------------------------------
1270 bool wxActiveXContainer::MSWTranslateMessage(WXMSG
* pMsg
)
1272 if(m_oleInPlaceActiveObject
.IsOk() && m_oleInPlaceActiveObject
->TranslateAccelerator(pMsg
) == S_OK
)
1276 return wxWindow::MSWTranslateMessage(pMsg
);
1279 #endif // wxUSE_ACTIVEX