X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/403dd8db634c6313f3c603fa049acd9e543070d7..1cd44b9c5f49407329c3da220ca8212e65e97d6c:/src/msw/ole/activex.cpp diff --git a/src/msw/ole/activex.cpp b/src/msw/ole/activex.cpp index c5ea0cb8e9..92a5a1186b 100644 --- a/src/msw/ole/activex.cpp +++ b/src/msw/ole/activex.cpp @@ -36,16 +36,16 @@ #include "wx/msw/private.h" // for wxCopyRectToRECT // autointerfaces that we only use here -WX_DECLARE_AUTOOLE(wxAutoIOleInPlaceSite, IOleInPlaceSite) -WX_DECLARE_AUTOOLE(wxAutoIOleDocument, IOleDocument) -WX_DECLARE_AUTOOLE(wxAutoIPersistStreamInit, IPersistStreamInit) -WX_DECLARE_AUTOOLE(wxAutoIAdviseSink, IAdviseSink) -WX_DECLARE_AUTOOLE(wxAutoIProvideClassInfo, IProvideClassInfo) -WX_DECLARE_AUTOOLE(wxAutoITypeInfo, ITypeInfo) -WX_DECLARE_AUTOOLE(wxAutoIConnectionPoint, IConnectionPoint) -WX_DECLARE_AUTOOLE(wxAutoIConnectionPointContainer, IConnectionPointContainer) +typedef wxAutoOleInterface wxAutoIOleInPlaceSite; +typedef wxAutoOleInterface wxAutoIOleDocument; +typedef wxAutoOleInterface wxAutoIPersistStreamInit; +typedef wxAutoOleInterface wxAutoIAdviseSink; +typedef wxAutoOleInterface wxAutoIProvideClassInfo; +typedef wxAutoOleInterface wxAutoITypeInfo; +typedef wxAutoOleInterface wxAutoIConnectionPoint; +typedef wxAutoOleInterface wxAutoIConnectionPointContainer; -wxDEFINE_EVENT( wxEVT_ACTIVEX, wxActiveXEvent ) +wxDEFINE_EVENT( wxEVT_ACTIVEX, wxActiveXEvent ); // Ole class helpers (sort of MFC-like) from wxActiveX #define DECLARE_OLE_UNKNOWN(cls)\ @@ -694,6 +694,13 @@ private: friend bool wxActiveXEventsInterface(wxActiveXEvents *self, REFIID iid, void **_interface, const char *&desc); public: + + // a pointer to this static variable is used as an 'invalid_entry_marker' + // wxVariants containing a void* to this variables are 'empty' in the sense + // that the actual ActiveX OLE parameter has not been converted and inserted + // into m_params. + static wxVariant ms_invalidEntryMarker; + wxActiveXEvents(wxActiveXContainer *ax) : m_activeX(ax), m_haveCustomId(false) {} wxActiveXEvents(wxActiveXContainer *ax, REFIID iid) : m_activeX(ax), m_customId(iid), m_haveCustomId(true) {} virtual ~wxActiveXEvents() @@ -717,11 +724,11 @@ public: } - STDMETHODIMP Invoke(DISPID dispIdMember, REFIID WXUNUSED(riid), - LCID WXUNUSED(lcid), + STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, + LCID lcid, WORD wFlags, DISPPARAMS * pDispParams, - VARIANT * WXUNUSED(pVarResult), EXCEPINFO * WXUNUSED(pExcepInfo), - unsigned int * WXUNUSED(puArgErr)) + VARIANT * pVarResult, EXCEPINFO * pExcepInfo, + unsigned int * puArgErr) { if (wFlags & (DISPATCH_PROPERTYGET | DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF)) return E_NOTIMPL; @@ -733,31 +740,37 @@ public: // Dispatch Event wxActiveXEvent event; event.SetEventType(wxEVT_ACTIVEX); + // Create an empty list of Variants + // Note that the event parameters use lazy evaluation + // They are not actually created until wxActiveXEvent::operator[] is called event.m_params.NullList(); event.m_dispid = dispIdMember; - // arguments - if (pDispParams) - { - for (DWORD i = pDispParams->cArgs; i > 0; i--) - { - VARIANTARG& va = pDispParams->rgvarg[i-1]; - wxVariant vx; + // save the native (MSW) event parameters for event handlers that need to access them + // this can be done on the stack since wxActiveXEvent is also allocated on the stack + wxActiveXEventNativeMSW eventParameters(dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + event.SetClientData(&eventParameters); -// vx.SetName(px.name); - wxConvertOleToVariant(va, vx); - event.m_params.Append(vx); - } - } + // The event parameters are not copied to event.m_params until they are actually + // referenced in wxActiveXEvent::operator[] + // This increases performance and avoids error messages and/or crashes + // when the event has parameters that are not (yet or never) supported + // by wxConvertOleToVariant // process the events from the activex method - m_activeX->ProcessEvent(event); + m_activeX->ProcessEvent(event); for (DWORD i = 0; i < pDispParams->cArgs; i++) { - VARIANTARG& va = pDispParams->rgvarg[i]; - wxVariant& vx = - event.m_params[pDispParams->cArgs - i - 1]; - wxConvertVariantToOle(vx, va); + size_t params_index = pDispParams->cArgs - i - 1; + if (params_index < event.m_params.GetCount()) { + wxVariant &vx = event.m_params[params_index]; + // copy the result back to pDispParams only if the event has been accessed + // i.e. if vx != ms_invalidEntryMarker + if (!vx.IsType(wxActiveXEvents::ms_invalidEntryMarker.GetType()) || vx!=ms_invalidEntryMarker) { + VARIANTARG& va = pDispParams->rgvarg[i]; + wxConvertVariantToOle(vx, va); + } + } } if(event.GetSkipped()) @@ -767,11 +780,61 @@ public: } }; +namespace +{ +// just a unique global variable +const int invalid_entry_marker = 0; +} + +wxVariant wxActiveXEvents::ms_invalidEntryMarker((void*)&invalid_entry_marker); + +size_t wxActiveXEvent::ParamCount() const +{ + wxActiveXEventNativeMSW *native=GetNativeParameters(); + // 'native' will always be != if the event has been created + // for an actual active X event. + // But it may be zero if the event has been created by wx program code. + if (native) + return native->pDispParams ? native->pDispParams->cArgs : 0; + + return m_params.GetCount(); +} + +wxVariant &wxActiveXEvent::operator [](size_t idx) +{ + wxASSERT(idx < ParamCount()); + wxActiveXEventNativeMSW *native=GetNativeParameters(); + // 'native' will always be != if the event has been created + // for an actual active X event. + // But it may be zero if the event has been created by wx program code. + if (native) + { + while ( m_params.GetCount()<=idx ) + { + m_params.Append(wxActiveXEvents::ms_invalidEntryMarker); + } + + wxVariant& vx = m_params[idx]; + if ( vx.IsType(wxActiveXEvents::ms_invalidEntryMarker.GetType()) && + vx == wxActiveXEvents::ms_invalidEntryMarker) + { + // copy the _real_ parameter into this one + // NOTE: m_params stores the parameters in *reverse* order. + // Whyever, but this was the case in the original implementation of + // wxActiveXEvents::Invoke + // Keep this convention. + VARIANTARG& va = native->pDispParams->rgvarg[ native->pDispParams->cArgs - idx - 1 ]; + wxConvertOleToVariant(va, vx); + } + return vx; + } + return m_params[idx]; +} + bool wxActiveXEventsInterface(wxActiveXEvents *self, REFIID iid, void **_interface, const char *&desc) { if (self->m_haveCustomId && IsEqualIID(iid, self->m_customId)) { -// WXOLE_TRACE("Found Custom Dispatch Interface"); *_interface = (IUnknown *) (IDispatch *) self; desc = "Custom Dispatch Interface"; return true; @@ -841,10 +904,10 @@ wxActiveXContainer::~wxActiveXContainer() } // VZ: we might want to really report an error instead of just asserting here -#ifdef __WXDEBUG__ +#if wxDEBUG_LEVEL #define CHECK_HR(hr) \ - wxASSERT_MSG( SUCCEEDED(hr), \ - wxString::Format("HRESULT = %X", (unsigned)(hr)) ) + wxASSERT_LEVEL_2_MSG( SUCCEEDED(hr), \ + wxString::Format("HRESULT = %X", (unsigned)(hr)) ) #else #define CHECK_HR(hr) wxUnusedVar(hr) #endif @@ -959,11 +1022,14 @@ void wxActiveXContainer::CreateActiveX(REFIID iid, IUnknown* pUnk) cpContainer->FindConnectionPoint(ta->guid, cp.GetRef()); CHECK_HR(hret); - IDispatch* disp; - m_frameSite->QueryInterface(IID_IDispatch, (void**)&disp); - hret = cp->Advise(new wxActiveXEvents(this, ta->guid), - &adviseCookie); - CHECK_HR(hret); + if ( cp ) + { + IDispatch* disp; + m_frameSite->QueryInterface(IID_IDispatch, (void**)&disp); + hret = cp->Advise(new wxActiveXEvents(this, ta->guid), + &adviseCookie); + CHECK_HR(hret); + } } }