?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 6.4.0.0.beta1, tag libreoffice-6.4.0.0.beta1
[LibreOffice.git] / extensions / source / ole / unoobjw.cxx
blob436feb3097e9cc562e4c6bec55583408d72dcff8
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 // Documentation pointers for recent work:
21 //
22 // https://www.codeproject.com/Articles/9014/Understanding-COM-Event-Handling
23 // https://blogs.msdn.microsoft.com/ericlippert/2005/02/15/why-does-wscript-connectobject-not-always-work/
24
25 #include "ole2uno.hxx"
26
27 #include <stdio.h>
28 #include <list>
29 #include <sstream>
30 #include <unordered_map>
31 #include <vector>
32
33 #if defined _MSC_VER && defined __clang__
34 #pragma clang diagnostic push
35 #pragma clang diagnostic ignored "-Wall"
36 #pragma clang diagnostic ignored "-Wattributes"
37 #pragma clang diagnostic ignored "-Wdelete-incomplete"
38 #pragma clang diagnostic ignored "-Wdynamic-class-memaccess"
39 #pragma clang diagnostic ignored "-Wextra"
40 #pragma clang diagnostic ignored "-Wint-to-pointer-cast"
41 #pragma clang diagnostic ignored "-Winvalid-noreturn"
42 #pragma clang diagnostic ignored "-Wmicrosoft"
43 #pragma clang diagnostic ignored "-Wnon-pod-varargs"
44 #pragma clang diagnostic ignored "-Wnon-virtual-dtor"
45 #pragma clang diagnostic ignored "-Wnonportable-include-path"
46 #pragma clang diagnostic ignored "-Wsequence-point"
47 #pragma clang diagnostic ignored "-Wtypename-missing"
48 #endif
49 #include <atlbase.h>
50 #include <atlcom.h>
51 #if defined _MSC_VER && defined __clang__
52 #pragma clang diagnostic pop
53 #endif
54 #include <comdef.h>
55
56 #include <osl/diagnose.h>
57 #include <salhelper/simplereferenceobject.hxx>
58 #include <rtl/ref.hxx>
59 #include <rtl/ustring.hxx>
60 #include <tools/diagnose_ex.h>
61 #include <sal/log.hxx>
62 #include <com/sun/star/beans/MethodConcept.hpp>
63 #include <com/sun/star/beans/PropertyConcept.hpp>
64 #include <com/sun/star/frame/Desktop.hpp>
65 #include <com/sun/star/frame/TerminationVetoException.hpp>
66 #include <com/sun/star/frame/XTerminateListener.hpp>
67 #include <com/sun/star/lang/NoSuchMethodException.hpp>
68 #include <com/sun/star/script/CannotConvertException.hpp>
69 #include <com/sun/star/script/FailReason.hpp>
70 #include <com/sun/star/reflection/theCoreReflection.hpp>
71 #include <com/sun/star/reflection/ParamInfo.hpp>
72 #include <com/sun/star/beans/XExactName.hpp>
73 #include <com/sun/star/container/NoSuchElementException.hpp>
74 #include <com/sun/star/container/XEnumeration.hpp>
75 #include <com/sun/star/container/XEnumerationAccess.hpp>
76
77 #include <com/sun/star/beans/XMaterialHolder.hpp>
78 #include <com/sun/star/script/XInvocation2.hpp>
79 #include <com/sun/star/script/MemberType.hpp>
80 #include <com/sun/star/reflection/XIdlReflection.hpp>
81 #include <ooo/vba/XCollection.hpp>
82 #include <ooo/vba/XConnectable.hpp>
83 #include <ooo/vba/XConnectionPoint.hpp>
84 #include <ooo/vba/XSink.hpp>
85 #include <ooo/vba/msforms/XCheckBox.hpp>
86 #include <osl/interlck.h>
87 #include <com/sun/star/uno/genfunc.h>
88 #include <comphelper/automationinvokedzone.hxx>
89 #include <comphelper/asyncquithandler.hxx>
90 #include <comphelper/processfactory.hxx>
91 #include <comphelper/profilezone.hxx>
92 #include <comphelper/windowsdebugoutput.hxx>
93 #include <comphelper/windowserrorstring.hxx>
94 #include <o3tl/char16_t2wchar_t.hxx>
95
96 #include "comifaces.hxx"
97 #include "jscriptclasses.hxx"
98 #include "unotypewrapper.hxx"
99 #include "oleobjw.hxx"
100 #include "unoobjw.hxx"
101 #include "servprov.hxx"
102
103 using namespace std;
104 using namespace osl;
105 using namespace cppu;
106 using namespace com::sun::star::uno;
107 using namespace com::sun::star::beans;
108 using namespace com::sun::star::container;
109 using namespace com::sun::star::script;
110 using namespace com::sun::star::lang;
111 using namespace com::sun::star::bridge::ModelDependent;
112 using namespace com::sun::star::reflection;
113
114 std::unordered_map<sal_uIntPtr, WeakReference<XInterface> > UnoObjToWrapperMap;
115 static bool writeBackOutParameter(VARIANTARG* pDest, VARIANT* pSource);
116 static bool writeBackOutParameter2( VARIANTARG* pDest, VARIANT* pSource);
117 static HRESULT mapCannotConvertException(const CannotConvertException &e, unsigned int * puArgErr);
118
119 class TerminationVetoer : public WeakImplHelper<css::frame::XTerminateListener>
120 {
121 public:
122 int mnCount;
123
124 private:
125 TerminationVetoer()
126 : mnCount(0)
127 {
128 try
129 {
130 Reference< css::frame::XDesktop > xDesktop =
131 css::frame::Desktop::create( comphelper::getProcessComponentContext() );
132 xDesktop->addTerminateListener( this );
133 }
134 catch ( const Exception& )
135 {
136 DBG_UNHANDLED_EXCEPTION("extensions.olebridge");
137 }
138 }
139
140 public:
141 static rtl::Reference< TerminationVetoer > get()
142 {
143 static TerminationVetoer* pInstance = new TerminationVetoer;
144 static rtl::Reference< TerminationVetoer > aInstance( pInstance );
145
146 return aInstance;
147 }
148
149 // XTerminateListener
150 void SAL_CALL queryTermination( const EventObject& ) override
151 {
152 SAL_INFO("extensions.olebridge", "TerminationVetoer::queryTermination: count=" << mnCount);
153 // Always veto termination while an OLE object is active, except if it is an OLE object that
154 // has asked us to quit.
155 if (!AsyncQuitHandler::instance().IsForceQuit() && mnCount > 0)
156 {
157 SAL_INFO("extensions.olebridge", "TerminationVetoer::queryTermination: Throwing!");
158 throw css::frame::TerminationVetoException();
159 }
160 }
161
162 void SAL_CALL notifyTermination( const EventObject& ) override
163 {
164 // ???
165 }
166
167 // XEventListener
168 void SAL_CALL disposing( const css::lang::EventObject& ) override
169 {
170 // ???
171 }
172 };
173
174 /* Does not throw any exceptions.
175 Param pInfo can be NULL.
176 */
177 static void writeExcepinfo(EXCEPINFO * pInfo, const OUString& message)
178 {
179 if (pInfo != nullptr)
180 {
181 pInfo->wCode = UNO_2_OLE_EXCEPTIONCODE;
182 pInfo->bstrSource = SysAllocString(L"[automation bridge] ");
183 pInfo->bstrDescription = SysAllocString(o3tl::toW(message.getStr()));
184 }
185 }
186
187 InterfaceOleWrapper::InterfaceOleWrapper( Reference<XMultiServiceFactory> const & xFactory,
188 sal_uInt8 unoWrapperClass, sal_uInt8 comWrapperClass):
189 UnoConversionUtilities<InterfaceOleWrapper>( xFactory, unoWrapperClass, comWrapperClass),
190 m_defaultValueType( 0)
191 {
192 TerminationVetoer::get()->mnCount++;
193 SAL_INFO("extensions.olebridge", "InterfaceOleWrapper CTOR, count=" << TerminationVetoer::get()->mnCount);
194 }
195
196 InterfaceOleWrapper::~InterfaceOleWrapper()
197 {
198 MutexGuard guard(getBridgeMutex());
199 // remove entries in global map
200 auto it = UnoObjToWrapperMap.find( reinterpret_cast<sal_uIntPtr>(m_xOrigin.get()));
201 if(it != UnoObjToWrapperMap.end())
202 UnoObjToWrapperMap.erase(it);
203
204 TerminationVetoer::get()->mnCount--;
205 SAL_INFO("extensions.olebridge", "InterfaceOleWrapper DTOR, count=" << TerminationVetoer::get()->mnCount);
206 }
207
208 COM_DECLSPEC_NOTHROW STDMETHODIMP InterfaceOleWrapper::QueryInterface(REFIID riid, void ** ppv)
209 {
210 comphelper::Automation::AutomationInvokedZone aAutomationActive;
211
212 SAL_INFO("extensions.olebridge", this << "@InterfaceOleWrapper::QueryInterface(" << riid << ")");
213
214 HRESULT ret= S_OK;
215
216 if( !ppv)
217 return E_POINTER;
218
219 if(IsEqualIID(riid, IID_IUnknown))
220 {
221 AddRef();
222 *ppv = static_cast<IUnknown*>(static_cast<IDispatch*>(this));
223 SAL_INFO("extensions.olebridge", " " << *ppv);
224 }
225 else if (IsEqualIID(riid, IID_IDispatch))
226 {
227 AddRef();
228 *ppv = static_cast<IDispatch*>(this);
229 SAL_INFO("extensions.olebridge", " " << *ppv);
230 }
231 else if (IsEqualIID(riid, IID_IProvideClassInfo))
232 {
233 Reference<ooo::vba::XConnectable> xConnectable(m_xOrigin, UNO_QUERY);
234 if (!xConnectable.is())
235 return E_NOINTERFACE;
236 AddRef();
237 *ppv = static_cast<IProvideClassInfo*>(this);
238 SAL_INFO("extensions.olebridge", " " << *ppv);
239 }
240 else if (IsEqualIID(riid, IID_IConnectionPointContainer))
241 {
242 Reference<ooo::vba::XConnectable> xConnectable(m_xOrigin, UNO_QUERY);
243 if (!xConnectable.is())
244 return E_NOINTERFACE;
245 AddRef();
246 *ppv = static_cast<IConnectionPointContainer*>(this);
247 SAL_INFO("extensions.olebridge", " " << *ppv);
248 }
249 else if( IsEqualIID( riid, __uuidof( IUnoObjectWrapper)))
250 {
251 AddRef();
252 *ppv= static_cast<IUnoObjectWrapper*>(this);
253 SAL_INFO("extensions.olebridge", " " << *ppv);
254 }
255 else
256 ret= E_NOINTERFACE;
257 return ret;
258 }
259
260 COM_DECLSPEC_NOTHROW STDMETHODIMP_(ULONG) InterfaceOleWrapper::AddRef()
261 {
262 acquire();
263 // does not need to guard because one should not rely on the return value of
264 // AddRef anyway
265 return m_refCount;
266 }
267
268 COM_DECLSPEC_NOTHROW STDMETHODIMP_(ULONG) InterfaceOleWrapper::Release()
269 {
270 ULONG n= m_refCount;
271 release();
272 return n - 1;
273 }
274
275 // IUnoObjectWrapper --------------------------------------------------------
276 COM_DECLSPEC_NOTHROW STDMETHODIMP InterfaceOleWrapper::getWrapperXInterface( Reference<XInterface>* pXInt)
277 {
278 pXInt->set( static_cast<XWeak*>( this), UNO_QUERY);
279 return pXInt->is() ? S_OK : E_FAIL;
280 }
281 COM_DECLSPEC_NOTHROW STDMETHODIMP InterfaceOleWrapper::getOriginalUnoObject( Reference<XInterface>* pXInt)
282 {
283 *pXInt= m_xOrigin;
284 return m_xOrigin.is() ? S_OK : E_FAIL;
285 }
286 COM_DECLSPEC_NOTHROW STDMETHODIMP InterfaceOleWrapper::getOriginalUnoStruct( Any * pStruct)
287 {
288 comphelper::Automation::AutomationInvokedZone aAutomationActive;
289
290 HRESULT ret= E_FAIL;
291 if( !m_xOrigin.is())
292 {
293 Reference<XMaterialHolder> xMatHolder( m_xInvocation, UNO_QUERY);
294 if( xMatHolder.is())
295 {
296 Any any = xMatHolder->getMaterial();
297 if( any.getValueTypeClass() == TypeClass_STRUCT)
298 {
299 *pStruct= any;
300 ret= S_OK;
301 }
302 }
303 }
304 return ret;
305 }
306
307 COM_DECLSPEC_NOTHROW STDMETHODIMP InterfaceOleWrapper::GetTypeInfoCount( UINT *pctinfo )
308 {
309 SAL_INFO("extensions.olebridge", this << "@InterfaceOleWrapper::GetTypeInfoCount");
310
311 if (!pctinfo)
312 return E_POINTER;
313
314 *pctinfo = 1;
315
316 return S_OK;
317 }
318
319 class CXTypeInfo : public ITypeInfo,
320 public CComObjectRoot
321 {
322 public:
323 enum class Kind { COCLASS, MAIN, OUTGOING };
324
325 #if defined __clang__
326 #pragma clang diagnostic push
327 #pragma clang diagnostic ignored "-Wunused-function"
328 #endif
329 BEGIN_COM_MAP(CXTypeInfo)
330 #if defined __clang__
331 #pragma clang diagnostic pop
332 #endif
333 COM_INTERFACE_ENTRY(ITypeInfo)
334 #if defined __clang__
335 #pragma clang diagnostic push
336 #pragma clang diagnostic ignored "-Winconsistent-missing-override"
337 #pragma clang diagnostic ignored "-Wunused-function"
338 #endif
339 END_COM_MAP()
340 #if defined __clang__
341 #pragma clang diagnostic pop
342 #endif
343
344 DECLARE_NOT_AGGREGATABLE(CXTypeInfo)
345
346 virtual ~CXTypeInfo() {}
347
348 void InitForCoclass(Reference<XInterface> xOrigin,
349 const OUString& sImplementationName,
350 const IID& rIID,
351 Reference<XMultiServiceFactory> xMSF);
352 void InitForClassItself(Reference<XInterface> xOrigin,
353 const OUString& sImplementationName,
354 const IID& rIID,
355 Reference<XMultiServiceFactory> xMSF);
356 void InitForOutgoing(Reference<XInterface> xOrigin,
357 const OUString& sInterfaceName,
358 const IID& rIID,
359 Reference<XMultiServiceFactory> xMSF,
360 Type aType);
361 virtual HRESULT STDMETHODCALLTYPE GetTypeAttr(TYPEATTR **ppTypeAttr) override;
362 virtual HRESULT STDMETHODCALLTYPE GetTypeComp(ITypeComp **ppTComp) override;
363 virtual HRESULT STDMETHODCALLTYPE GetFuncDesc(UINT index,
364 FUNCDESC **ppFuncDesc) override;
365 virtual HRESULT STDMETHODCALLTYPE GetVarDesc(UINT index,
366 VARDESC **ppVarDesc) override;
367 virtual HRESULT STDMETHODCALLTYPE GetNames(MEMBERID memid,
368 BSTR *rgBstrNames,
369 UINT cMaxNames,
370 UINT *pcNames) override;
371 virtual HRESULT STDMETHODCALLTYPE GetRefTypeOfImplType(UINT index,
372 HREFTYPE *pRefType) override;
373 virtual HRESULT STDMETHODCALLTYPE GetImplTypeFlags(UINT index,
374 INT *pImplTypeFlags) override;
375 virtual HRESULT STDMETHODCALLTYPE GetIDsOfNames(LPOLESTR *rgszNames,
376 UINT cNames,
377 MEMBERID *pMemId) override;
378 virtual HRESULT STDMETHODCALLTYPE Invoke(PVOID pvInstance,
379 MEMBERID memid,
380 WORD wFlags,
381 DISPPARAMS *pDispParams,
382 VARIANT *pVarResult,
383 EXCEPINFO *pExcepInfo,
384 UINT *puArgErr) override;
385 virtual HRESULT STDMETHODCALLTYPE GetDocumentation(MEMBERID memid,
386 BSTR *pBstrName,
387 BSTR *pBstrDocString,
388 DWORD *pdwHelpContext,
389 BSTR *pBstrHelpFile) override;
390 virtual HRESULT STDMETHODCALLTYPE GetDllEntry(MEMBERID memid,
391 INVOKEKIND invKind,
392 BSTR *pBstrDllName,
393 BSTR *pBstrName,
394 WORD *pwOrdinal) override;
395 virtual HRESULT STDMETHODCALLTYPE GetRefTypeInfo(HREFTYPE hRefType,
396 ITypeInfo **ppTInfo) override;
397 virtual HRESULT STDMETHODCALLTYPE AddressOfMember(MEMBERID memid,
398 INVOKEKIND invKind,
399 PVOID *ppv) override;
400 virtual HRESULT STDMETHODCALLTYPE CreateInstance(IUnknown *pUnkOuter,
401 REFIID riid,
402 PVOID *ppvObj) override;
403 virtual HRESULT STDMETHODCALLTYPE GetMops(MEMBERID memid,
404 BSTR *pBstrMops) override;
405 virtual HRESULT STDMETHODCALLTYPE GetContainingTypeLib(ITypeLib **ppTLib,
406 UINT *pIndex) override;
407 virtual void STDMETHODCALLTYPE ReleaseTypeAttr(TYPEATTR *pTypeAttr) override;
408 virtual void STDMETHODCALLTYPE ReleaseFuncDesc(FUNCDESC *pFuncDesc) override;
409 virtual void STDMETHODCALLTYPE ReleaseVarDesc(VARDESC *pVarDesc) override;
410
411 private:
412 Kind meKind;
413 Reference<XInterface> mxOrigin;
414 OUString msImplementationName;
415 OUString msInterfaceName;
416 IID maIID;
417 Reference<XMultiServiceFactory> mxMSF;
418 Type maType;
419 };
420
421 class CXTypeLib : public ITypeLib,
422 public CComObjectRoot
423 {
424 public:
425 #if defined __clang__
426 #pragma clang diagnostic push
427 #pragma clang diagnostic ignored "-Wunused-function"
428 #endif
429 BEGIN_COM_MAP(CXTypeLib)
430 #if defined __clang__
431 #pragma clang diagnostic pop
432 #endif
433 COM_INTERFACE_ENTRY(ITypeLib)
434 #if defined __clang__
435 #pragma clang diagnostic push
436 #pragma clang diagnostic ignored "-Winconsistent-missing-override"
437 #pragma clang diagnostic ignored "-Wunused-function"
438 #endif
439 END_COM_MAP()
440 #if defined __clang__
441 #pragma clang diagnostic pop
442 #endif
443
444 DECLARE_NOT_AGGREGATABLE(CXTypeLib)
445
446 virtual ~CXTypeLib() {}
447
448 void Init(Reference<XInterface> xOrigin,
449 const OUString& sImplementationName,
450 Reference<XMultiServiceFactory> xMSF)
451 {
452 SAL_INFO("extensions.olebridge", this << "@CXTypeLib::Init for " << sImplementationName);
453 mxOrigin = xOrigin;
454 msImplementationName = sImplementationName;
455 mxMSF = xMSF;
456 }
457
458 virtual UINT STDMETHODCALLTYPE GetTypeInfoCount() override
459 {
460 SAL_WARN("extensions.olebridge", this << "@CXTypeLib::GetTypeInfoCount");
461 return 1;
462 }
463
464 virtual HRESULT STDMETHODCALLTYPE GetTypeInfo(UINT,
465 ITypeInfo **) override
466 {
467 SAL_WARN("extensions.olebridge", this << "@CXTypeLib::GetTypeInfo: E_NOTIMPL");
468 return E_NOTIMPL;
469 }
470
471 virtual HRESULT STDMETHODCALLTYPE GetTypeInfoType(UINT,
472 TYPEKIND *) override
473 {
474 SAL_WARN("extensions.olebridge", this << "@CXTypeLib::GetTypeInfoType: E_NOTIMPL");
475 return E_NOTIMPL;
476 }
477
478 virtual HRESULT STDMETHODCALLTYPE GetTypeInfoOfGuid(REFGUID guid,
479 ITypeInfo **ppTInfo) override
480 {
481 comphelper::Automation::AutomationInvokedZone aAutomationActive;
482
483 SAL_INFO("extensions.olebridge", this << "@CXTypeLib::GetTypeInfoOfGuid(" << guid << ")");
484 if (!ppTInfo)
485 return E_POINTER;
486
487 Reference<ooo::vba::XConnectable> xConnectable(mxOrigin, UNO_QUERY);
488 if (!xConnectable.is())
489 return TYPE_E_ELEMENTNOTFOUND;
490
491 IID aIID;
492 if (SUCCEEDED(IIDFromString(reinterpret_cast<LPOLESTR>(xConnectable->getIID().pData->buffer), &aIID)))
493 {
494 if (IsEqualIID(guid, aIID))
495 {
496 HRESULT ret;
497
498 CComObject<CXTypeInfo>* pTypeInfo;
499
500 ret = CComObject<CXTypeInfo>::CreateInstance(&pTypeInfo);
501 if (FAILED(ret))
502 return ret;
503
504 pTypeInfo->AddRef();
505
506 pTypeInfo->InitForCoclass(mxOrigin, msImplementationName, aIID, mxMSF);
507
508 *ppTInfo = pTypeInfo;
509
510 return S_OK;
511 }
512 }
513
514 #if 0
515 ooo::vba::TypeAndIID aTypeAndIID = xConnectable->GetConnectionPoint();
516
517 IID aIID;
518 if (SUCCEEDED(IIDFromString((LPOLESTR)aTypeAndIID.IID.pData->buffer, &aIID)))
519 {
520 HRESULT ret;
521
522 CComObject<CXTypeInfo>* pTypeInfo;
523
524 ret = CComObject<CXTypeInfo>::CreateInstance(&pTypeInfo);
525 if (FAILED(ret))
526 return ret;
527
528 pTypeInfo->AddRef();
529
530 pTypeInfo->InitForOutgoing(mxOrigin, msImplementationName, aIID, mxMSF);
531
532 *ppTInfo = pTypeInfo;
533
534 return S_OK;
535 }
536 #else
537 SAL_WARN("extensions.olebridge", "Not implemented: GetTypeInfoOfGuid(" << guid << ")");
538 #endif
539
540 return TYPE_E_ELEMENTNOTFOUND;
541
542 }
543
544 virtual HRESULT STDMETHODCALLTYPE GetLibAttr(TLIBATTR **) override
545 {
546 SAL_WARN("extensions.olebridge", this << "@CXTypeLib::GetLibAttr: E_NOTIMPL");
547 return E_NOTIMPL;
548 }
549
550 virtual HRESULT STDMETHODCALLTYPE GetTypeComp(ITypeComp **) override
551 {
552 SAL_WARN("extensions.olebridge", this << "@CXTypeLib::GetTypeComp: E_NOTIMPL");
553 return E_NOTIMPL;
554 }
555
556 virtual HRESULT STDMETHODCALLTYPE GetDocumentation(INT,
557 BSTR *,
558 BSTR *,
559 DWORD *,
560 BSTR *) override
561 {
562 SAL_WARN("extensions.olebridge", this << "@CXTypeLib::GetDocumentation: E_NOTIMPL");
563 return E_NOTIMPL;
564 }
565
566 virtual HRESULT STDMETHODCALLTYPE IsName(LPOLESTR,
567 ULONG,
568 BOOL *) override
569 {
570 SAL_WARN("extensions.olebridge", this << "@CXTypeLib:IsName: E_NOTIMPL");
571 return E_NOTIMPL;
572 }
573
574 virtual HRESULT STDMETHODCALLTYPE FindName(LPOLESTR,
575 ULONG,
576 ITypeInfo **,
577 MEMBERID *,
578 USHORT *) override
579 {
580 SAL_WARN("extensions.olebridge", this << "@CXTypeLib::FindName: E_NOTIMPL");
581 return E_NOTIMPL;
582 }
583
584 virtual void STDMETHODCALLTYPE ReleaseTLibAttr(TLIBATTR *) override
585 {
586 SAL_WARN("extensions.olebridge", this << "@CXTypeLib::ReleaseTLibAttr: E_NOTIMPL");
587 }
588
589 private:
590 Reference<XInterface> mxOrigin;
591 OUString msImplementationName;
592 Reference<XMultiServiceFactory> mxMSF;
593 };
594
595 void CXTypeInfo::InitForCoclass(Reference<XInterface> xOrigin,
596 const OUString& sImplementationName,
597 const IID& rIID,
598 Reference<XMultiServiceFactory> xMSF)
599 {
600 SAL_INFO("extensions.olebridge", this << "@CXTypeInfo::InitForCoclass(" << sImplementationName << "," << rIID << ")");
601 meKind = Kind::COCLASS;
602 mxOrigin = xOrigin;
603 msImplementationName = sImplementationName;
604 maIID = rIID;
605 mxMSF = xMSF;
606 }
607
608 void CXTypeInfo::InitForClassItself(Reference<XInterface> xOrigin,
609 const OUString& sImplementationName,
610 const IID& rIID,
611 Reference<XMultiServiceFactory> xMSF)
612 {
613 SAL_INFO("extensions.olebridge", this << "@CXTypeInfo::InitForClassItself(" << sImplementationName << "," << rIID << ")");
614 meKind = Kind::MAIN;
615 mxOrigin = xOrigin;
616 msImplementationName = sImplementationName;
617 maIID = rIID;
618 mxMSF = xMSF;
619 }
620
621 void CXTypeInfo::InitForOutgoing(Reference<XInterface> xOrigin,
622 const OUString& sInterfaceName,
623 const IID& rIID,
624 Reference<XMultiServiceFactory> xMSF,
625 Type aType)
626 {
627 SAL_INFO("extensions.olebridge", this << "@CXTypeInfo::InitForOutgoing(" << sInterfaceName << "," << rIID << ")");
628 meKind = Kind::OUTGOING;
629 mxOrigin = xOrigin;
630 msInterfaceName = sInterfaceName;
631 maIID = rIID;
632 mxMSF = xMSF;
633 maType = aType;
634 }
635
636 HRESULT STDMETHODCALLTYPE CXTypeInfo::GetTypeAttr(TYPEATTR **ppTypeAttr)
637 {
638 comphelper::Automation::AutomationInvokedZone aAutomationActive;
639
640 SAL_INFO("extensions.olebridge", this << "@CXTypeInfo::GetTypeAttr");
641
642 if (!ppTypeAttr)
643 return E_POINTER;
644
645 assert(!IsEqualIID(maIID, IID_NULL));
646
647 TYPEATTR *pTypeAttr = new TYPEATTR;
648 memset(pTypeAttr, 0, sizeof(*pTypeAttr));
649
650 pTypeAttr->guid = maIID;
651
652 if (meKind == Kind::COCLASS)
653 {
654 pTypeAttr->typekind = TKIND_COCLASS;
655 pTypeAttr->cFuncs = 0;
656 pTypeAttr->cVars = 0;
657 pTypeAttr->cImplTypes = 3;
658 pTypeAttr->cbSizeVft = 0;
659 pTypeAttr->cbAlignment = 8;
660 pTypeAttr->wTypeFlags = TYPEFLAG_FCANCREATE;
661 }
662 else if (meKind == Kind::MAIN)
663 {
664 pTypeAttr->typekind = TKIND_DISPATCH;
665 pTypeAttr->cFuncs = 10; // FIXME, dummy
666 pTypeAttr->cVars = 0;
667 pTypeAttr->cImplTypes = 1;
668 // FIXME: I think this is always supposed to be as if just for the seven methods in
669 // IDIspatch?
670 pTypeAttr->cbSizeVft = 7 * sizeof(void*);
671 pTypeAttr->cbAlignment = 8;
672 pTypeAttr->wTypeFlags = TYPEFLAG_FHIDDEN|TYPEFLAG_FDISPATCHABLE;
673 }
674 else if (meKind == Kind::OUTGOING)
675 {
676 pTypeAttr->typekind = TKIND_DISPATCH;
677
678 Reference<XIdlReflection> xRefl = theCoreReflection::get(comphelper::getComponentContext(mxMSF));
679 assert(xRefl.is());
680
681 Reference<XIdlClass> xClass = xRefl->forName(maType.getTypeName());
682 assert(xClass.is());
683
684 auto aMethods = xClass->getMethods();
685 assert(xClass->getTypeClass() == TypeClass_INTERFACE &&
686 aMethods.getLength() > 0);
687
688 // Drop the three XInterface methods, add the three corresponding IUnknown ones plus the
689 // four IDispatch ones on top of that.
690 pTypeAttr->cFuncs = aMethods.getLength() - 3 + 3 + 4;
691 pTypeAttr->cVars = 0;
692 pTypeAttr->cImplTypes = 1;
693 // FIXME: I think this, too, is always supposed to be as if just for the seven methods in
694 // IDIspatch?
695 pTypeAttr->cbSizeVft = 7 * sizeof(void*);
696 pTypeAttr->cbAlignment = 8;
697 pTypeAttr->wTypeFlags = TYPEFLAG_FHIDDEN|TYPEFLAG_FNONEXTENSIBLE|TYPEFLAG_FDISPATCHABLE;
698 }
699 else
700 assert(false);
701
702 pTypeAttr->lcid = LOCALE_USER_DEFAULT;
703 pTypeAttr->memidConstructor = MEMBERID_NIL;
704 pTypeAttr->memidDestructor = MEMBERID_NIL;
705 // FIXME: Is this correct, just the vtable pointer, right?
706 pTypeAttr->cbSizeInstance = sizeof(void*);
707 pTypeAttr->wMajorVerNum = 0;
708 pTypeAttr->wMinorVerNum = 0;
709 pTypeAttr->idldescType.wIDLFlags = IDLFLAG_NONE;
710
711 SAL_INFO("extensions.olebridge", this << "@CXTypeInfo::GetTypeAttr: " << pTypeAttr);
712
713 *ppTypeAttr = pTypeAttr;
714
715 return S_OK;
716 }
717
718 HRESULT STDMETHODCALLTYPE CXTypeInfo::GetTypeComp(ITypeComp **)
719 {
720 SAL_WARN("extensions.olebridge", this << "@CXTypeInfo::GetTypeComp: E_NOTIMPL");
721 return E_NOTIMPL;
722 }
723
724 HRESULT STDMETHODCALLTYPE CXTypeInfo::GetFuncDesc(UINT index,
725 FUNCDESC **ppFuncDesc)
726 {
727 comphelper::Automation::AutomationInvokedZone aAutomationActive;
728
729 if (!ppFuncDesc)
730 return E_POINTER;
731
732 if (meKind != Kind::OUTGOING)
733 return E_NOTIMPL;
734
735 if (index <= 6)
736 {
737 *ppFuncDesc = new FUNCDESC;
738 (*ppFuncDesc)->memid = 0x60000000 + index;
739 (*ppFuncDesc)->lprgscode = nullptr;
740 (*ppFuncDesc)->lprgelemdescParam = nullptr;
741 (*ppFuncDesc)->funckind = FUNC_DISPATCH;
742 (*ppFuncDesc)->invkind = INVOKE_FUNC;
743 (*ppFuncDesc)->callconv = CC_STDCALL;
744 switch (index)
745 {
746 case 0: // QueryInterface
747 (*ppFuncDesc)->cParams = 2;
748 (*ppFuncDesc)->elemdescFunc.tdesc.lptdesc = nullptr;
749 (*ppFuncDesc)->elemdescFunc.tdesc.vt = VT_VOID;
750 break;
751 case 1: // AddRef
752 (*ppFuncDesc)->cParams = 0;
753 (*ppFuncDesc)->elemdescFunc.tdesc.lptdesc = nullptr;
754 (*ppFuncDesc)->elemdescFunc.tdesc.vt = VT_UI4;
755 break;
756 case 2: // Release
757 (*ppFuncDesc)->cParams = 1;
758 (*ppFuncDesc)->elemdescFunc.tdesc.lptdesc = nullptr;
759 (*ppFuncDesc)->elemdescFunc.tdesc.vt = VT_UI4;
760 break;
761 case 3: // GetTypeInfoCount
762 (*ppFuncDesc)->cParams = 1;
763 (*ppFuncDesc)->elemdescFunc.tdesc.lptdesc = nullptr;
764 (*ppFuncDesc)->elemdescFunc.tdesc.vt = VT_VOID;
765 break;
766 case 4: // GetTypeInfo
767 (*ppFuncDesc)->cParams = 3;
768 (*ppFuncDesc)->elemdescFunc.tdesc.lptdesc = nullptr;
769 (*ppFuncDesc)->elemdescFunc.tdesc.vt = VT_VOID;
770 break;
771 case 5: // GetIDsOfNames
772 (*ppFuncDesc)->cParams = 5;
773 (*ppFuncDesc)->elemdescFunc.tdesc.lptdesc = nullptr;
774 (*ppFuncDesc)->elemdescFunc.tdesc.vt = VT_VOID;
775 break;
776 case 6: // Invoke
777 (*ppFuncDesc)->cParams = 8;
778 (*ppFuncDesc)->elemdescFunc.tdesc.lptdesc = nullptr;
779 (*ppFuncDesc)->elemdescFunc.tdesc.vt = VT_VOID;
780 break;
781 }
782 (*ppFuncDesc)->cParamsOpt = 0;
783 (*ppFuncDesc)->oVft = index * sizeof(void*);
784 (*ppFuncDesc)->cScodes = 0;
785 (*ppFuncDesc)->wFuncFlags = FUNCFLAG_FRESTRICTED;
786
787 SAL_INFO("extensions.olebridge", this << "@CXTypeInfo::GetFuncDesc(" << index << "): S_OK: " << *ppFuncDesc);
788
789 return S_OK;
790 }
791
792 Reference<XIdlReflection> xRefl = theCoreReflection::get(comphelper::getComponentContext(mxMSF));
793 assert(xRefl.is());
794
795 Reference<XIdlClass> xClass = xRefl->forName(maType.getTypeName());
796 assert(xClass.is());
797
798 auto aMethods = xClass->getMethods();
799 assert(xClass->getTypeClass() == TypeClass_INTERFACE &&
800 aMethods.getLength() > 0);
801
802 if (index > static_cast<UINT>(aMethods.getLength() - 3 + 3 + 4))
803 return E_INVALIDARG;
804
805 *ppFuncDesc = new FUNCDESC;
806
807 (*ppFuncDesc)->memid = index - 6;
808 (*ppFuncDesc)->lprgscode = nullptr;
809 (*ppFuncDesc)->lprgelemdescParam = nullptr;
810 (*ppFuncDesc)->funckind = FUNC_DISPATCH;
811 (*ppFuncDesc)->invkind = INVOKE_FUNC;
812 (*ppFuncDesc)->callconv = CC_STDCALL;
813 (*ppFuncDesc)->cParams = aMethods[index - 4]->getParameterInfos().getLength();
814 (*ppFuncDesc)->cParamsOpt = 0;
815 (*ppFuncDesc)->oVft = index * sizeof(void*);
816 (*ppFuncDesc)->cScodes = 0;
817 (*ppFuncDesc)->elemdescFunc.tdesc.lptdesc = nullptr; // ???
818 (*ppFuncDesc)->elemdescFunc.tdesc.vt = VT_VOID; // ???
819 (*ppFuncDesc)->wFuncFlags = 0;
820
821 SAL_INFO("extensions.olebridge", this << "@CXTypeInfo::GetFuncDesc(" << index << "): S_OK: " << *ppFuncDesc);
822
823 return S_OK;
824 }
825
826 HRESULT STDMETHODCALLTYPE CXTypeInfo::GetVarDesc(UINT,
827 VARDESC **)
828 {
829 SAL_WARN("extensions.olebridge", this << "@CXTypeInfo::GetVarDesc: E_NOTIMPL");
830 return E_NOTIMPL;
831 }
832
833 HRESULT STDMETHODCALLTYPE CXTypeInfo::GetNames(MEMBERID memid,
834 BSTR *rgBstrNames,
835 UINT cMaxNames,
836 UINT *pcNames)
837 {
838 comphelper::Automation::AutomationInvokedZone aAutomationActive;
839
840 SAL_INFO("extensions.olebridge", this << "@CXTypeInfo::GetNames(" << memid << ")");
841 assert(meKind != Kind::COCLASS);
842
843 if (!rgBstrNames)
844 return E_POINTER;
845
846 if (!pcNames)
847 return E_POINTER;
848
849 if (memid < 1)
850 return E_INVALIDARG;
851
852 if (cMaxNames < 1)
853 return E_INVALIDARG;
854
855 if (meKind == Kind::MAIN)
856 {
857 SAL_WARN("extensions.olebridge", "GetNames() for MAIN not implemented");
858 return E_NOTIMPL;
859 }
860
861 Reference<XIdlReflection> xRefl = theCoreReflection::get(comphelper::getComponentContext(mxMSF));
862 assert(xRefl.is());
863
864 Reference<XIdlClass> xClass = xRefl->forName(maType.getTypeName());
865 assert(xClass.is());
866
867 auto aMethods = xClass->getMethods();
868 assert(xClass->getTypeClass() == TypeClass_INTERFACE &&
869 aMethods.getLength() > 0);
870
871 // Subtract the three XInterface methods. Memid for the first following method is 1.
872 if (memid > aMethods.getLength() - 3)
873 return E_INVALIDARG;
874
875 SAL_INFO("extensions.olebridge", "..." << this << "@CXTypeInfo::GetNames(" << memid << "): " << aMethods[memid + 2]->getName());
876 rgBstrNames[0] = SysAllocString(reinterpret_cast<LPOLESTR>(aMethods[memid + 2]->getName().pData->buffer));
877 *pcNames = 1;
878
879 return S_OK;
880 }
881
882 HRESULT STDMETHODCALLTYPE CXTypeInfo::GetRefTypeOfImplType(UINT index,
883 HREFTYPE *pRefType)
884 {
885 SAL_INFO("extensions.olebridge", this << "@CXTypeInfo::GetRefTypeOfImplType(" << index << ")");
886
887 if (!pRefType)
888 return E_POINTER;
889
890 assert(index == 0 || index == 1);
891
892 *pRefType = 1000+index;
893
894 return S_OK;
895 }
896
897 HRESULT STDMETHODCALLTYPE CXTypeInfo::GetImplTypeFlags(UINT index,
898 INT *pImplTypeFlags)
899 {
900 comphelper::Automation::AutomationInvokedZone aAutomationActive;
901
902 SAL_INFO("extensions.olebridge", this << "@CXTypeInfo::GetImplTypeFlags(" << index << ")");
903
904 if (!pImplTypeFlags)
905 return E_POINTER;
906
907 assert(meKind == Kind::COCLASS);
908 assert(index == 0 || index == 1);
909
910 if (index == 0)
911 *pImplTypeFlags = IMPLTYPEFLAG_FDEFAULT;
912 else if (index == 1)
913 *pImplTypeFlags = IMPLTYPEFLAG_FDEFAULT|IMPLTYPEFLAG_FSOURCE;
914
915 return S_OK;
916 }
917
918 HRESULT STDMETHODCALLTYPE CXTypeInfo::GetIDsOfNames(LPOLESTR *,
919 UINT,
920 MEMBERID *)
921 {
922 SAL_WARN("extensions.olebridge", this << "@CXTypeInfo::GetIDsOfNames: E_NOTIMPL");
923 return E_NOTIMPL;
924 }
925
926 HRESULT STDMETHODCALLTYPE CXTypeInfo::Invoke(PVOID,
927 MEMBERID,
928 WORD,
929 DISPPARAMS *,
930 VARIANT *,
931 EXCEPINFO *,
932 UINT *)
933 {
934 SAL_WARN("extensions.olebridge", this << "@CXTypeInfo::Invoke: E_NOTIMPL");
935 return E_NOTIMPL;
936 }
937
938 HRESULT STDMETHODCALLTYPE CXTypeInfo::GetDocumentation(MEMBERID memid,
939 BSTR *pBstrName,
940 BSTR *pBstrDocString,
941 DWORD *pdwHelpContext,
942 BSTR *pBstrHelpFile)
943 {
944 comphelper::Automation::AutomationInvokedZone aAutomationActive;
945
946 SAL_INFO("extensions.olebridge", this << "@CXTypeInfo::GetDocumentation(" << memid << ")");
947
948 if (pBstrName)
949 {
950 if (memid == MEMBERID_NIL)
951 {
952 *pBstrName = SysAllocString(o3tl::toW(msImplementationName.getStr()));
953 }
954 else if (memid == DISPID_VALUE)
955 {
956 // MEMBERIDs are the same as DISPIDs, apparently?
957 *pBstrName = SysAllocString(L"Value");
958 }
959 else
960 {
961 // FIXME: Shouldn't we be able to know the names of the members of UNO interfaces?
962 *pBstrName = SysAllocString(o3tl::toW(OUString("UnknownNameOfMember#" + OUString::number(memid)).getStr()));
963 }
964 }
965 if (pBstrDocString)
966 *pBstrDocString = SysAllocString(L"");
967 if (pdwHelpContext)
968 *pdwHelpContext = 0;
969 if (pBstrHelpFile)
970 *pBstrHelpFile = nullptr;
971
972 return S_OK;
973 }
974
975 HRESULT STDMETHODCALLTYPE CXTypeInfo::GetDllEntry(MEMBERID,
976 INVOKEKIND,
977 BSTR *,
978 BSTR *,
979 WORD *)
980 {
981 SAL_WARN("extensions.olebridge", this << "@CXTypeInfo::GetDllEntry: E_NOTIMPL");
982 return E_NOTIMPL;
983 }
984
985 HRESULT STDMETHODCALLTYPE CXTypeInfo::GetRefTypeInfo(HREFTYPE hRefType,
986 ITypeInfo **ppTInfo)
987 {
988 comphelper::Automation::AutomationInvokedZone aAutomationActive;
989
990 SAL_INFO("extensions.olebridge", this << "@CXTypeInfo::GetRefTypeInfo(" << hRefType << ")");
991
992 if (!ppTInfo)
993 return E_POINTER;
994
995 // FIXME: Is it correct to assume that the only interfaces on which GetRefTypeInfo() would be
996 // called are those that implement ooo::vba::XConnectable?
997
998 Reference<ooo::vba::XConnectable> xConnectable(mxOrigin, UNO_QUERY);
999 if (!xConnectable.is())
1000 return E_NOTIMPL;
1001
1002 ooo::vba::TypeAndIID aTypeAndIID = xConnectable->GetConnectionPoint();
1003
1004 IID aIID;
1005 if (!SUCCEEDED(IIDFromString(reinterpret_cast<LPOLESTR>(aTypeAndIID.IID.pData->buffer), &aIID)))
1006 return E_NOTIMPL;
1007
1008 HRESULT ret;
1009
1010 CComObject<CXTypeInfo>* pTypeInfo;
1011
1012 ret = CComObject<CXTypeInfo>::CreateInstance(&pTypeInfo);
1013 if (FAILED(ret))
1014 return ret;
1015
1016 pTypeInfo->AddRef();
1017
1018 pTypeInfo->InitForOutgoing(mxOrigin, aTypeAndIID.Type.getTypeName(), aIID, mxMSF, aTypeAndIID.Type);
1019
1020 *ppTInfo = pTypeInfo;
1021
1022 return S_OK;
1023 }
1024
1025 HRESULT STDMETHODCALLTYPE CXTypeInfo::AddressOfMember(MEMBERID,
1026 INVOKEKIND,
1027 PVOID *)
1028 {
1029 SAL_WARN("extensions.olebridge", this << "@CXTypeInfo::AddressOfMember: E_NOTIMPL");
1030 return E_NOTIMPL;
1031 }
1032
1033 HRESULT STDMETHODCALLTYPE CXTypeInfo::CreateInstance(IUnknown *,
1034 REFIID,
1035 PVOID *)
1036 {
1037 SAL_WARN("extensions.olebridge", this << "@CXTypeInfo::CreateInstance: E_NOTIMPL");
1038 return E_NOTIMPL;
1039 }
1040
1041 HRESULT STDMETHODCALLTYPE CXTypeInfo::GetMops(MEMBERID,
1042 BSTR *)
1043 {
1044 SAL_WARN("extensions.olebridge", this << "@CXTypeInfo::GetMops: E_NOTIMPL");
1045 return E_NOTIMPL;
1046 }
1047
1048 // This is not actually called any more by my vbscript test after I added the IProvideClassInfo
1049 // thing... so all the CXTypeLib stuff is dead code at the moment.
1050
1051 HRESULT STDMETHODCALLTYPE CXTypeInfo::GetContainingTypeLib(ITypeLib **ppTLib,
1052 UINT *pIndex)
1053 {
1054 comphelper::Automation::AutomationInvokedZone aAutomationActive;
1055
1056 SAL_INFO("extensions.olebridge", this << "@CXTypeInfo::GetContainingTypeLib");
1057
1058 if (!ppTLib || !pIndex)
1059 return E_POINTER;
1060
1061 HRESULT ret;
1062
1063 CComObject<CXTypeLib>* pTypeLib;
1064
1065 ret = CComObject<CXTypeLib>::CreateInstance(&pTypeLib);
1066 if (FAILED(ret))
1067 return ret;
1068
1069 pTypeLib->AddRef();
1070
1071 pTypeLib->Init(mxOrigin, msImplementationName, mxMSF);
1072
1073 *ppTLib = pTypeLib;
1074
1075 return S_OK;
1076 }
1077
1078 void STDMETHODCALLTYPE CXTypeInfo::ReleaseTypeAttr(TYPEATTR *pTypeAttr)
1079 {
1080 SAL_INFO("extensions.olebridge", this << "@CXTypeInfo::ReleaseTypeAttr(" << pTypeAttr << ")");
1081
1082 delete pTypeAttr;
1083 }
1084
1085 void STDMETHODCALLTYPE CXTypeInfo::ReleaseFuncDesc(FUNCDESC *pFuncDesc)
1086 {
1087 SAL_WARN("extensions.olebridge", this << "@CXTypeInfo::ReleaseFuncDesc(" << pFuncDesc << ")");
1088
1089 delete pFuncDesc;
1090 }
1091
1092 void STDMETHODCALLTYPE CXTypeInfo::ReleaseVarDesc(VARDESC *)
1093 {
1094 SAL_WARN("extensions.olebridge", this << "@CXTypeInfo::ReleaseVarDesc: E_NOTIMPL");
1095 }
1096
1097 COM_DECLSPEC_NOTHROW STDMETHODIMP InterfaceOleWrapper::GetTypeInfo(UINT iTInfo, LCID, ITypeInfo ** ppTInfo)
1098 {
1099 comphelper::Automation::AutomationInvokedZone aAutomationActive;
1100
1101 SAL_INFO("extensions.olebridge", this << "@InterfaceOleWrapper::GetTypeInfo(" << iTInfo << ")");
1102
1103 if (!ppTInfo)
1104 return E_POINTER;
1105
1106 if (iTInfo != 0)
1107 return E_NOTIMPL;
1108
1109 // FIXME: This is surely incorrect. Why is being able to handle GetTypeInfo() here coupled to
1110 // being a source for outgoing events, i.e. implementing XConnectable? What would break if we
1111 // would use XInterfaceWithIID and its getIID instead?
1112
1113 Reference<ooo::vba::XConnectable> xConnectable(m_xOrigin, UNO_QUERY);
1114 if (!xConnectable.is())
1115 return E_NOTIMPL;
1116
1117 OUString sIID = xConnectable->GetIIDForClassItselfNotCoclass();
1118 IID aIID;
1119 if (!SUCCEEDED(IIDFromString(reinterpret_cast<LPOLESTR>(sIID.pData->buffer), &aIID)))
1120 return E_NOTIMPL;
1121
1122 HRESULT ret;
1123
1124 CComObject<CXTypeInfo>* pTypeInfo;
1125
1126 ret = CComObject<CXTypeInfo>::CreateInstance(&pTypeInfo);
1127 if (FAILED(ret))
1128 return ret;
1129
1130 pTypeInfo->AddRef();
1131
1132 pTypeInfo->InitForClassItself(m_xOrigin, m_sImplementationName, aIID, m_smgr);
1133
1134 *ppTInfo = pTypeInfo;
1135
1136 return S_OK;
1137 }
1138
1139 COM_DECLSPEC_NOTHROW STDMETHODIMP InterfaceOleWrapper::GetIDsOfNames(REFIID /*riid*/,
1140 LPOLESTR * rgszNames,
1141 UINT cNames,
1142 LCID /*lcid*/,
1143 DISPID * rgdispid )
1144 {
1145 comphelper::Automation::AutomationInvokedZone aAutomationActive;
1146
1147 if( ! rgdispid)
1148 return E_POINTER;
1149
1150 SAL_INFO("extensions.olebridge", this << "@InterfaceOleWrapper::GetIDsOfNames:");
1151 for (unsigned int i = 0; i < cNames; ++i)
1152 {
1153 // Initialise returned rgdispid values.
1154 rgdispid[i] = DISPID_UNKNOWN;
1155
1156 SAL_INFO("extensions.olebridge", " " << o3tl::toU(rgszNames[i]));
1157 }
1158
1159 HRESULT ret = DISP_E_UNKNOWNNAME;
1160 try
1161 {
1162 MutexGuard guard( getBridgeMutex());
1163
1164 // FIXME: Handle the cNames > 1 case? Note that the rest of the names mean the names of *arguments*.
1165
1166 if( ! _wcsicmp( *rgszNames, JSCRIPT_VALUE_FUNC) ||
1167 ! _wcsicmp( *rgszNames, BRIDGE_VALUE_FUNC))
1168 {
1169 *rgdispid= DISPID_JSCRIPT_VALUE_FUNC;
1170 return S_OK;
1171 }
1172 else if( ! _wcsicmp( *rgszNames, GET_STRUCT_FUNC) ||
1173 ! _wcsicmp( *rgszNames, BRIDGE_GET_STRUCT_FUNC))
1174 {
1175 *rgdispid= DISPID_GET_STRUCT_FUNC;
1176 return S_OK;
1177 }
1178 else if( ! _wcsicmp( *rgszNames, BRIDGE_CREATE_TYPE_FUNC))
1179 {
1180 *rgdispid= DISPID_CREATE_TYPE_FUNC;
1181 return S_OK;
1182 }
1183
1184 if (m_xInvocation.is() && (cNames > 0))
1185 {
1186 OUString name(o3tl::toU(rgszNames[0]));
1187 NameToIdMap::iterator iter = m_nameToDispIdMap.find(name);
1188
1189 bool bIsMethod = false;
1190
1191 OUString exactName = name;
1192
1193 if (iter == m_nameToDispIdMap.end())
1194 {
1195 if (m_xExactName.is())
1196 {
1197 exactName = m_xExactName->getExactName(name);
1198 if (exactName.isEmpty())
1199 exactName = name;
1200 }
1201
1202 MemberInfo d(0, exactName);
1203
1204 if (m_xInvocation->hasProperty(exactName))
1205 {
1206 d.flags |= DISPATCH_PROPERTYGET;
1207 d.flags |= DISPATCH_PROPERTYPUT;
1208 d.flags |= DISPATCH_PROPERTYPUTREF;
1209 }
1210
1211 if (m_xInvocation->hasMethod(exactName))
1212 {
1213 d.flags |= DISPATCH_METHOD;
1214 bIsMethod = true;
1215 }
1216
1217 if (d.flags != 0)
1218 {
1219 m_MemberInfos.push_back(d);
1220 iter = m_nameToDispIdMap.emplace(exactName, static_cast<DISPID>(m_MemberInfos.size())).first;
1221
1222 if (exactName != name)
1223 {
1224 iter = m_nameToDispIdMap.emplace(name, static_cast<DISPID>(m_MemberInfos.size())).first;
1225 }
1226 }
1227 }
1228
1229 if (iter == m_nameToDispIdMap.end())
1230 {
1231 ret = DISP_E_UNKNOWNNAME;
1232 SAL_INFO("extensions.olebridge", " " << name << ": UNKNOWN");
1233 }
1234 else
1235 {
1236 rgdispid[0] = (*iter).second;
1237 SAL_INFO("extensions.olebridge", " " << name << ": " << rgdispid[0]);
1238
1239 if (bIsMethod && cNames > 1)
1240 {
1241 Reference<XIdlMethod> xIdlMethod;
1242 Reference<XIntrospectionAccess> xIntrospectionAccess = m_xInvocation->getIntrospection();
1243 try
1244 {
1245 if (xIntrospectionAccess.is())
1246 xIdlMethod = xIntrospectionAccess->getMethod(exactName, MethodConcept::ALL);
1247 }
1248 catch (const NoSuchMethodException&)
1249 {
1250 }
1251 if (xIdlMethod.is())
1252 {
1253 auto aParamInfos = xIdlMethod->getParameterInfos();
1254 for (unsigned int i = 1; i < cNames; ++i)
1255 {
1256 bool bFound = false;
1257 for (int j = 0; j < aParamInfos.getLength(); ++j)
1258 {
1259 if (aParamInfos[j].aName.equalsIgnoreAsciiCase(OUString(o3tl::toU(rgszNames[i]))))
1260 {
1261 rgdispid[i] = j;
1262 bFound = true;
1263 SAL_INFO("extensions.olebridge", " " << OUString(o3tl::toU(rgszNames[i])) << ": " << rgdispid[i]);
1264 break;
1265 }
1266 }
1267 if (!bFound)
1268 SAL_INFO("extensions.olebridge", " " << OUString(o3tl::toU(rgszNames[i])) << ": NOT FOUND");
1269 }
1270 }
1271 }
1272
1273 // Return value should be S_OK only if *all* the names were found.
1274 unsigned int i;
1275 for (i = 0; i < cNames; ++i)
1276 if (rgdispid[i] == DISPID_UNKNOWN)
1277 break;
1278 if (i == cNames)
1279 ret = S_OK;
1280 }
1281 }
1282 }
1283 catch(const BridgeRuntimeError&)
1284 {
1285 OSL_ASSERT(false);
1286 }
1287 catch(const Exception&)
1288 {
1289 OSL_ASSERT(false);
1290 }
1291 catch(...)
1292 {
1293 OSL_ASSERT(false);
1294 }
1295
1296 return ret;
1297 }
1298
1299 // Note: What the comments here say about JScript possibly holds for Automation clients in general,
1300 // like VBScript ones, too. Or not. Hard to say. What is the relevance of JScript nowadays anyway,
1301 // and can LO really be used from JScript code on web pages any longer?
1302
1303 // "convertDispparamsArgs" converts VARIANTS to their respecting Any counterparts
1304 // The parameters "id", "wFlags" and "pdispparams" equal those as used in
1305 // IDispatch::Invoke. The function handles special JavaScript
1306 // cases where a VARIANT of type VT_DISPATCH is ambiguous and could represent
1307 // an object, array ( JavaScript Array object), out parameter and in/out ( JavaScript Array object)
1308 // parameter (JavaScript Array object)
1309 // Because all those VT_DISPATCH objects need a different conversion
1310 // we have to find out what the object is supposed to be. The function does this
1311 // by either using type information or by help of a specialized ValueObject object.
1312
1313 // A. Type Information
1314
1315 // With the help of type information the kind of parameter can be exactly determined
1316 // and an appropriate conversion can be chosen. A problem arises if a method expects
1317 // an Any. Then the type info does not tell what the type of the value, that is kept
1318 // by the any, should be. In this situation the decision whether the param is a
1319 // sequence or an object is made upon the fact if the object has a property "0"
1320 // ( see function "isJScriptArray"). Since this is unsafe it is recommended to use
1321 // the JScript value objects within a JScript script on such an occasion.
1322
1323 // B. JavaScript Value Object ( class JScriptValue )
1324
1325 // A JScriptValue (ValueObject) object is a COM object in that it implements IDispatch and the
1326 // IJScriptValue object interface. Such objects are provided by all UNO wrapper
1327 // objects used within a JScript script. To obtain an instance one has to call
1328 // "_GetValueObject() or Bridge_GetValueObject()" on a UNO wrapper object (class InterfaceOleWrapper).
1329 // A value object is appropriately initialized within the script and passed as
1330 // parameter to a UNO object method or property. The convertDispparamsArgs function
1331 // can easily find out that a param is such an object by querying for the
1332 // IJScriptValue interface. By this interface one the type and kind ( out, in/out)
1333 // can be determined and the right conversion can be applied.
1334 // Using ValueObjects we spare us the effort of acquiring and examining type information
1335 // in order to figure out what the an IDispatch parameter is meant for.
1336
1337 // Normal JScript object parameter can be mixed with JScriptValue object. If an
1338 // VARIANT contains a VT_DISPATCH that is no JScriptValue than the type information
1339 // is used to find out about the required type.
1340 void InterfaceOleWrapper::convertDispparamsArgs(DISPID id,
1341 unsigned short /*wFlags*/, DISPPARAMS* pdispparams, Sequence<Any>& rSeq)
1342 {
1343 // Parameters come in in reverse order in pdispparams. There might be less parameters than
1344 // expected. In that case, assume they are "optional" (but can't be marked as such in UNO IDL),
1345 // and fill in the rest with empty Anys. There might also be more than expected. In that case,
1346 // assume the oovbaapi UNO IDL hasn't kept up with added optional parameters in MSO, and just
1347 // ignore the extra ones, as long as they are empty.
1348
1349 // An example: incoming parameters: <12, 13, "foo/bar.tem">
1350 //
1351 // Expected parameters: (string filename, int something, int somethingElse, Any whatever, Any
1352 // whateverElse)
1353 //
1354 // Here the existing incoming parameters are placed in reverse order in the first three outgoing
1355 // parameters, and the rest of the outgoing parameters are kept as empty Anys.
1356 //
1357 // Another example: incoming parameters: <EMPTY, TRUE>
1358 //
1359 // Expected parameters: (bool flag)
1360 //
1361 // Here the TRUE is passed as the sole outgoing parameter, and the incoming EMPTY is ignored.
1362 //
1363 // Still an example: incoming parameters: <"foo.doc", TRUE>
1364 //
1365 // Expected parameters: (bool flag)
1366 //
1367 // This throws an error as the incoming string parameter presumably should do something important,
1368 // but there is no corresponding outgoing parameter.
1369
1370 HRESULT hr = S_OK;
1371 const int countIncomingArgs = pdispparams->cArgs;
1372
1373 //Get type information for the current call
1374 InvocationInfo info;
1375 if( ! getInvocationInfoForCall( id, info))
1376 throw BridgeRuntimeError(
1377 "[automation bridge]InterfaceOleWrapper::convertDispparamsArgs \n"
1378 "Could not obtain type information for current call.");
1379
1380 // Size rSeq according to the number of expected parameters.
1381 const int expectedArgs = info.aParamTypes.getLength() + (info.eMemberType == MemberType_PROPERTY ? 1 : 0);
1382 rSeq.realloc( expectedArgs );
1383 Any* pParams = rSeq.getArray();
1384
1385 Any anyParam;
1386
1387 int outgoingArgIndex = 0;
1388
1389 // Go through incoming parameters in reverse order, i.e. in the order as declared in IDL
1390 for (int i = std::max(countIncomingArgs, expectedArgs) - 1; i >= 0; i--)
1391 {
1392 // Ignore too many parameters if they are VT_EMPTY anyway
1393 if ( outgoingArgIndex >= expectedArgs && pdispparams->rgvarg[i].vt == VT_EMPTY )
1394 continue;
1395
1396 // But otherwise too many parameters is an error
1397 if ( outgoingArgIndex >= expectedArgs )
1398 throw BridgeRuntimeError( "[automation bridge] Too many parameters" );
1399
1400 if (info.eMemberType == MemberType_METHOD &&
1401 info.aParamModes[ outgoingArgIndex ] == ParamMode_OUT)
1402 {
1403 outgoingArgIndex++;
1404 continue;
1405 }
1406
1407 if (i < countIncomingArgs)
1408 {
1409 // A missing (and hopefully optional) arg (in the middle of the argument list) is passed
1410 // as an empty Any.
1411 if (pdispparams->rgvarg[i].vt == VT_ERROR && pdispparams->rgvarg[i].scode == DISP_E_PARAMNOTFOUND)
1412 {
1413 Any aEmpty;
1414 pParams[ outgoingArgIndex ] = aEmpty;
1415 outgoingArgIndex++;
1416 continue;
1417 }
1418
1419 if(convertValueObject( & pdispparams->rgvarg[i], anyParam))
1420 { //a param is a ValueObject and could be converted
1421 pParams[ outgoingArgIndex ] = anyParam;
1422 outgoingArgIndex++;
1423 continue;
1424 }
1425 }
1426 else
1427 {
1428 // A missing arg. Let's hope it is de facto optional (there is no way in UNO IDL to mark
1429 // a parameter as optional). The corresponding slot in pParams is already a void Any.
1430 // Here we don't increase outgoingArgIndex!
1431 continue;
1432 }
1433
1434 // If the param is an out, in/out parameter in
1435 // JScript (Array object, with value at index 0) then we
1436 // extract Array[0] and put the value into varParam. At the end of the loop varParam
1437 // is converted if it contains a value otherwise the VARIANT from
1438 // DISPPARAMS is converted.
1439 CComVariant varParam;
1440
1441 // Check for JScript out and in/out paramsobjects (VT_DISPATCH).
1442 // To find them out we use typeinformation of the function being called.
1443
1444 // No idea how this stuff, originally written for JScript, works for other Automation
1445 // clients.
1446
1447 if( pdispparams->rgvarg[i].vt == VT_DISPATCH )
1448 {
1449 if( info.eMemberType == MemberType_METHOD && info.aParamModes[ outgoingArgIndex ] == ParamMode_INOUT)
1450 {
1451 // INOUT-param
1452 // Index ( property) "0" contains the actual IN-param. The object is a JScript
1453 // Array object.
1454 // Get the IN-param at index "0"
1455 IDispatch* pdisp= pdispparams->rgvarg[i].pdispVal;
1456
1457 OLECHAR const * sindex= L"0";
1458 DISPID id2;
1459 DISPPARAMS noParams= {nullptr,nullptr,0,0};
1460 if(SUCCEEDED( hr= pdisp->GetIDsOfNames( IID_NULL, const_cast<OLECHAR **>(&sindex), 1, LOCALE_USER_DEFAULT, &id2)))
1461 hr= pdisp->Invoke( id2, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET,
1462 & noParams, & varParam, nullptr, nullptr);
1463 if( FAILED( hr))
1464 {
1465 throw BridgeRuntimeError(
1466 "[automation bridge] Could not determine "
1467 "if the object has a member \"0\". Error: " +
1468 OUString::number(hr));
1469 }
1470 }
1471 }
1472
1473 if( varParam.vt == VT_EMPTY) // then it was no in/out parameter
1474 varParam= pdispparams->rgvarg[i];
1475
1476 if(info.eMemberType == MemberType_METHOD)
1477 variantToAny( & varParam, anyParam,
1478 info.aParamTypes[ outgoingArgIndex ]);
1479 else if(info.eMemberType == MemberType_PROPERTY)
1480 variantToAny( & varParam, anyParam, info.aType);
1481 else
1482 OSL_ASSERT(false);
1483
1484 if (outgoingArgIndex < expectedArgs)
1485 pParams[ outgoingArgIndex ]= anyParam;
1486 outgoingArgIndex++;
1487 }// end for / iterating over all parameters
1488 }
1489
1490 bool InterfaceOleWrapper::getInvocationInfoForCall( DISPID id, InvocationInfo& info)
1491 {
1492 bool bTypesAvailable= false;
1493
1494 if( !m_xInvocation.is() )return false;
1495 Reference<XInvocation2> inv2( m_xInvocation, UNO_QUERY);
1496 if( inv2.is())
1497 {
1498 // We need the name of the property or method to get its type information.
1499 // The name can be identified through the param "id"
1500 // that is kept as value in the map m_nameToDispIdMap.
1501 // Problem: the Windows JScript engine sometimes changes small letters to capital
1502 // letters as happens in xidlclass_obj.createObject( var) // in JScript.
1503 // IDispatch::GetIdsOfNames is then called with "CreateObject" !!!
1504 // m_nameToDispIdMap can contain several names for one DISPID but only one is
1505 // the exact one. If there's no m_xExactName and therefore no exact name then
1506 // there's only one entry in the map.
1507 OUString sMemberName;
1508
1509 auto ci1 = std::find_if(m_nameToDispIdMap.cbegin(), m_nameToDispIdMap.cend(),
1510 [&id](const NameToIdMap::value_type& nameToDispId) { return nameToDispId.second == id; }); // item is a pair<OUString, DISPID>
1511 if (ci1 != m_nameToDispIdMap.cend())
1512 sMemberName= (*ci1).first;
1513 // Get information for the current call ( property or method).
1514 // There could be similar names which only differ in the cases
1515 // of letters. First we assume that the name which was passed into
1516 // GetIDsOfNames is correct. If we won't get information with that
1517 // name then we have the invocation service use the XExactName interface.
1518 bool validInfo= true;
1519 InvocationInfo invInfo;
1520 try{
1521 invInfo= inv2->getInfoForName( sMemberName, false);
1522 }
1523 catch(const IllegalArgumentException&)
1524 {
1525 validInfo= false;
1526 }
1527
1528 if( ! validInfo)
1529 {
1530 invInfo= inv2->getInfoForName( sMemberName, true);
1531 }
1532 if( invInfo.aName.pData)
1533 {
1534 bTypesAvailable= true;
1535 info= invInfo;
1536 }
1537 }
1538 return bTypesAvailable;
1539 }
1540
1541 // XBridgeSupplier2 ---------------------------------------------------
1542 // only bridges itself ( this instance of InterfaceOleWrapper)from UNO to IDispatch
1543 // If sourceModelType is UNO than any UNO interface implemented by InterfaceOleWrapper
1544 // can bridged to IDispatch ( if destModelType == OLE). The IDispatch is
1545 // implemented by this class.
1546 Any SAL_CALL InterfaceOleWrapper::createBridge(const Any& modelDepObject,
1547 const Sequence<sal_Int8>& /*ProcessId*/,
1548 sal_Int16 sourceModelType,
1549 sal_Int16 destModelType)
1550 {
1551
1552 Any retAny;
1553 if( sourceModelType == UNO && destModelType == OLE &&
1554 modelDepObject.getValueTypeClass() == TypeClass_INTERFACE )
1555 {
1556 Reference<XInterface> xInt;
1557 if( modelDepObject >>= xInt )
1558 {
1559 if( xInt == Reference<XInterface>( static_cast<XWeak*>( this), UNO_QUERY))
1560 {
1561 VARIANT *pVar= static_cast<VARIANT*>(CoTaskMemAlloc( sizeof( VARIANT)));
1562 if( pVar)
1563 {
1564 pVar->vt= VT_DISPATCH;
1565 pVar->pdispVal= static_cast<IDispatch*>( this);
1566 AddRef();
1567
1568 retAny<<= reinterpret_cast< sal_uIntPtr >( pVar);
1569 }
1570 }
1571 }
1572 }
1573
1574 return retAny;
1575 }
1576
1577 // XInitialization --------------------------------------------------
1578 void SAL_CALL InterfaceOleWrapper::initialize( const Sequence< Any >& aArguments )
1579 {
1580 switch( aArguments.getLength() )
1581 {
1582 case 2: // the object wraps a UNO struct
1583 aArguments[0] >>= m_xInvocation;
1584 aArguments[1] >>= m_defaultValueType;
1585 break;
1586 case 3: // the object wraps a UNO interface
1587 aArguments[0] >>= m_xInvocation;
1588 aArguments[1] >>= m_xOrigin;
1589 aArguments[2] >>= m_defaultValueType;
1590
1591 Reference<XServiceInfo> xServiceInfo(m_xOrigin, UNO_QUERY);
1592 if (xServiceInfo.is())
1593 m_sImplementationName = xServiceInfo->getImplementationName();
1594
1595 SAL_INFO("extensions.olebridge", this << "@InterfaceOleWrapper::initialize for "
1596 << (m_sImplementationName.isEmpty()?"an unknown implementation":m_sImplementationName));
1597 break;
1598 }
1599
1600 m_xExactName.set( m_xInvocation, UNO_QUERY);
1601 }
1602
1603 Reference< XInterface > InterfaceOleWrapper::createUnoWrapperInstance()
1604 {
1605 Reference<XWeak> xWeak= static_cast<XWeak*>( new InterfaceOleWrapper(
1606 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass));
1607 return Reference<XInterface>( xWeak, UNO_QUERY);
1608 }
1609
1610 Reference<XInterface> InterfaceOleWrapper::createComWrapperInstance()
1611 {
1612 Reference<XWeak> xWeak= static_cast<XWeak*>( new IUnknownWrapper(
1613 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass));
1614 return Reference<XInterface>( xWeak, UNO_QUERY);
1615 }
1616
1617 // "getType" is used in convertValueObject to map the string denoting the type
1618 // to an actual Type object.
1619 bool getType( const BSTR name, Type & type)
1620 {
1621 bool ret = false;
1622 typelib_TypeDescription * pDesc= nullptr;
1623 OUString str(o3tl::toU(name));
1624 typelib_typedescription_getByName( &pDesc, str.pData );
1625 if( pDesc)
1626 {
1627 type = Type( pDesc->pWeakRef );
1628 typelib_typedescription_release( pDesc);
1629 ret = true;
1630 }
1631 return ret;
1632 }
1633
1634 static bool writeBackOutParameter2( VARIANTARG* pDest, VARIANT* pSource)
1635 {
1636 bool ret = false;
1637 HRESULT hr;
1638
1639 // Handle JScriptValue objects and JScript out params ( Array object )
1640 CComVariant varDest( *pDest);
1641
1642 if( SUCCEEDED( varDest.ChangeType(VT_DISPATCH)))
1643 {
1644 CComPtr<IDispatch> spDispDest(varDest.pdispVal);
1645
1646 // special Handling for a JScriptValue object
1647 CComQIPtr<IJScriptValueObject> spValueDest(spDispDest);
1648 if (spValueDest)
1649 {
1650 VARIANT_BOOL varBool= VARIANT_FALSE;
1651 if ((SUCCEEDED(hr = spValueDest->IsOutParam(&varBool))
1652 && varBool == VARIANT_TRUE)
1653 || (SUCCEEDED(hr = spValueDest->IsInOutParam(&varBool))
1654 && varBool == VARIANT_TRUE))
1655 {
1656 if( SUCCEEDED( spValueDest->Set( CComVariant(), *pSource)))
1657 ret= true;
1658 }
1659 }
1660 else if (pDest->vt == VT_DISPATCH)// VT_DISPATCH -> JScript out param
1661 {
1662 // We use IDispatchEx because its GetDispID function causes the creation
1663 // of a property if it does not exist already. This is convenient for
1664 // out parameters in JScript. Then the user must not specify property "0"
1665 // explicitly
1666 CComQIPtr<IDispatchEx> spDispEx( spDispDest);
1667 if( spDispEx)
1668 {
1669 CComBSTR nullProp(L"0");
1670 DISPID dwDispID;
1671 if( SUCCEEDED( spDispEx->GetDispID( nullProp, fdexNameEnsure, &dwDispID)))
1672 {
1673 DISPPARAMS dispparams = {nullptr, nullptr, 1, 1};
1674 dispparams.rgvarg = pSource;
1675 DISPID dispidPut = DISPID_PROPERTYPUT;
1676 dispparams.rgdispidNamedArgs = &dispidPut;
1677
1678 if (pSource->vt == VT_UNKNOWN || pSource->vt == VT_DISPATCH ||
1679 (pSource->vt & VT_ARRAY) || (pSource->vt & VT_BYREF))
1680 hr = spDispEx->InvokeEx(dwDispID, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUTREF,
1681 &dispparams, nullptr, nullptr, nullptr);
1682 else
1683 hr= spDispEx->InvokeEx(dwDispID, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUT,
1684 &dispparams, nullptr, nullptr, nullptr);
1685 if( SUCCEEDED(hr))
1686 ret= true;
1687 }
1688 }
1689 }
1690 else
1691 ret= writeBackOutParameter( pDest, pSource);
1692 }
1693 else // The param can't be a JScript out-parameter ( an Array object), it could be a VBScript
1694 { // param. The function checks itself for correct VBScript params
1695 ret= writeBackOutParameter( pDest, pSource);
1696 }
1697 return ret;
1698 }
1699
1700 // VisualBasic Script passes arguments as VT_VARIANT | VT_BYREF be it in or out parameter.
1701 // Thus we are in charge of freeing an eventual value contained by the inner VARIANT
1702 // Please note: VariantCopy doesn't free a VT_BYREF value
1703 // The out parameters are expected to have always a valid type
1704 static bool writeBackOutParameter(VARIANTARG* pDest, VARIANT* pSource)
1705 {
1706 HRESULT hr;
1707 bool ret = false;
1708 // Out parameter must be VT_BYREF
1709 if ((V_VT(pDest) & VT_BYREF) != 0 )
1710 {
1711 VARTYPE oleTypeFlags = V_VT(pSource);
1712
1713 // if caller accept VARIANT as out parameter, any value must be converted
1714 if (V_VT(pDest) == (VT_VARIANT | VT_BYREF))
1715 {
1716 // When the user provides a VARIANT rather than a concrete type
1717 // we just copy the source to the out, in/out parameter
1718 // VT_DISPATCH, VT_UNKNOWN, VT_ARRAY, VT_BSTR in the VARIANT that
1719 // is contained in pDest are released by VariantCopy
1720 VariantCopy(V_VARIANTREF(pDest), pSource);
1721 ret = true;
1722 }
1723 else
1724 {
1725 // variantarg and variant must have same type
1726 if ((V_VT(pDest) & oleTypeFlags) == oleTypeFlags)
1727 {
1728 if ((oleTypeFlags & VT_ARRAY) != 0)
1729 {
1730 // In / Out Param
1731 if( *V_ARRAYREF(pDest) != nullptr)
1732 hr= SafeArrayCopyData( V_ARRAY(pSource), *V_ARRAYREF(pDest));
1733 else
1734 // Out Param
1735 hr= SafeArrayCopy(V_ARRAY(pSource), V_ARRAYREF(pDest));
1736 if( SUCCEEDED( hr))
1737 ret = true;
1738 }
1739 else
1740 {
1741 // copy base type
1742 switch (V_VT(pSource))
1743 {
1744 case VT_I2:
1745 {
1746 *V_I2REF(pDest) = V_I2(pSource);
1747 ret = true;
1748 break;
1749 }
1750 case VT_I4:
1751 *V_I4REF(pDest) = V_I4(pSource);
1752 ret = true;
1753 break;
1754 case VT_R4:
1755 *V_R4REF(pDest) = V_R4(pSource);
1756 ret = true;
1757 break;
1758 case VT_R8:
1759 *V_R8REF(pDest) = V_R8(pSource);
1760 ret = true;
1761 break;
1762 case VT_CY:
1763 *V_CYREF(pDest) = V_CY(pSource);
1764 ret = true;
1765 break;
1766 case VT_DATE:
1767 *V_DATEREF(pDest) = V_DATE(pSource);
1768 ret = true;
1769 break;
1770 case VT_BSTR:
1771 SysFreeString( *pDest->pbstrVal);
1772
1773 *V_BSTRREF(pDest) = SysAllocString(V_BSTR(pSource));
1774 ret = true;
1775 break;
1776 case VT_DISPATCH:
1777 if (*V_DISPATCHREF(pDest) != nullptr)
1778 (*V_DISPATCHREF(pDest))->Release();
1779
1780 *V_DISPATCHREF(pDest) = V_DISPATCH(pSource);
1781
1782 if (*V_DISPATCHREF(pDest) != nullptr)
1783 (*V_DISPATCHREF(pDest))->AddRef();
1784
1785 ret = true;
1786 break;
1787 case VT_ERROR:
1788 *V_ERRORREF(pDest) = V_ERROR(pSource);
1789 ret = true;
1790 break;
1791 case VT_BOOL:
1792 *V_BOOLREF(pDest) = V_BOOL(pSource);
1793 ret = true;
1794 break;
1795 case VT_UNKNOWN:
1796 if (*V_UNKNOWNREF(pDest) != nullptr)
1797 (*V_UNKNOWNREF(pDest))->Release();
1798
1799 *V_UNKNOWNREF(pDest) = V_UNKNOWN(pSource);
1800
1801 if (*V_UNKNOWNREF(pDest) != nullptr)
1802 (*V_UNKNOWNREF(pDest))->AddRef();
1803
1804 ret = true;
1805 break;
1806 case VT_I1:
1807 *V_I1REF(pDest) = V_I1(pSource);
1808 ret = true;
1809 break;
1810 case VT_UI1:
1811 *V_UI1REF(pDest) = V_UI1(pSource);
1812 ret = true;
1813 break;
1814 case VT_UI2:
1815 *V_UI2REF(pDest) = V_UI2(pSource);
1816 ret = true;
1817 break;
1818 case VT_UI4:
1819 *V_UI4REF(pDest) = V_UI4(pSource);
1820 ret = true;
1821 break;
1822 case VT_INT:
1823 *V_INTREF(pDest) = V_INT(pSource);
1824 ret = true;
1825 break;
1826 case VT_UINT:
1827 *V_UINTREF(pDest) = V_UINT(pSource);
1828 ret = true;
1829 break;
1830 case VT_DECIMAL:
1831 memcpy(pDest->pdecVal, pSource, sizeof(DECIMAL));
1832 ret = true;
1833 break;
1834 default:
1835 break;
1836 }
1837 }
1838 }
1839 else
1840 {
1841 // Handling of special cases
1842 // Destination and source types are different
1843 if( pDest->vt == (VT_BSTR | VT_BYREF)
1844 && pSource->vt == VT_I2)
1845 {
1846 // When the user provides a String as out our in/out parameter
1847 // and the type is char (TypeClass_CHAR) then we convert to a BSTR
1848 // instead of VT_I2 as is done otherwise
1849 OLECHAR buff[]= {0,0};
1850 buff[0]= pSource->iVal;
1851
1852 SysFreeString( *pDest->pbstrVal);
1853 *pDest->pbstrVal= SysAllocString( buff);
1854 ret = true;
1855 }
1856 }
1857 }
1858 }
1859 return ret;
1860 }
1861
1862 COM_DECLSPEC_NOTHROW STDMETHODIMP InterfaceOleWrapper::Invoke(DISPID dispidMember,
1863 REFIID /*riid*/,
1864 LCID /*lcid*/,
1865 WORD wFlags,
1866 DISPPARAMS * pdispparams,
1867 VARIANT * pvarResult,
1868 EXCEPINFO * pexcepinfo,
1869 UINT * puArgErr )
1870 {
1871 comphelper::Automation::AutomationInvokedZone aAutomationActive;
1872
1873 OUString sParams;
1874 #if defined SAL_LOG_INFO
1875 sParams += "[";
1876 for (unsigned int i = 0; i < pdispparams->cArgs; ++i)
1877 {
1878 if (i > 0)
1879 sParams += ",";
1880 std::stringstream aStringStream;
1881 aStringStream << pdispparams->rgvarg[i];
1882 sParams += OUString::createFromAscii(aStringStream.str().c_str());
1883 }
1884 sParams += "]";
1885 #endif
1886 SAL_INFO("extensions.olebridge", this << "@InterfaceOleWrapper::Invoke(" << dispidMember << "," << sParams << ")");
1887
1888 comphelper::ProfileZone aZone("COM Bridge");
1889 HRESULT ret = S_OK;
1890
1891 try
1892 {
1893 bool bHandled= false;
1894 ret= InvokeGeneral( dispidMember, wFlags, pdispparams, pvarResult, pexcepinfo,
1895 puArgErr, bHandled);
1896 if( bHandled)
1897 return ret;
1898
1899 if ((dispidMember > 0) && (static_cast<size_t>(dispidMember) <= m_MemberInfos.size()) && m_xInvocation.is())
1900 {
1901 MemberInfo d = m_MemberInfos[dispidMember - 1];
1902 DWORD flags = wFlags & d.flags;
1903
1904 if (flags != 0)
1905 {
1906 if ((flags & DISPATCH_METHOD) != 0)
1907 {
1908 std::unique_ptr<DISPPARAMS> pNewDispParams;
1909 std::vector<VARIANTARG> vNewArgs;
1910
1911 if (pdispparams->cNamedArgs > 0)
1912 {
1913 // Convert named arguments to positional ones.
1914
1915 // An example:
1916 //
1917 // Function declaration (in pseudo-code):
1918 // int foo(int A, int B, optional int C, optional int D, optional int E, optional int F, optional int G)
1919 //
1920 // Corresponding parameter numbers (DISPIDs):
1921 // 0 1 2 3 4 5 6
1922 //
1923 // Actual call:
1924 // foo(10, 20, E:=50, D:=40, F:=60)
1925 //
1926 // That is, A and B are passed positionally, D, E, and F as named arguments,
1927 // and the optional C and G parameters are left out.
1928 //
1929 // Incoming DISPPARAMS:
1930 // cArgs=5, cNamedArgs=3
1931 // rgvarg: [60, 40, 50, 20, 10]
1932 // rgdispidNamedArgs: [5, 3, 4]
1933 //
1934 // We calculate nLowestNamedArgDispid = 3 and nHighestNamedArgDispid = 5.
1935 //
1936 // Result of conversion, no named args:
1937 // cArgs=6, cNamedArgs=0
1938 // rgvarg: [60, 50, 40, DISP_E_PARAMNOTFOUND, 20, 10]
1939
1940 // First find the lowest and highest DISPID of the named arguments.
1941 DISPID nLowestNamedArgDispid = 1000000;
1942 DISPID nHighestNamedArgDispid = -1;
1943 for (unsigned int i = 0; i < pdispparams->cNamedArgs; ++i)
1944 {
1945 if (pdispparams->rgdispidNamedArgs[i] < nLowestNamedArgDispid)
1946 nLowestNamedArgDispid = pdispparams->rgdispidNamedArgs[i];
1947 if (pdispparams->rgdispidNamedArgs[i] > nHighestNamedArgDispid)
1948 nHighestNamedArgDispid = pdispparams->rgdispidNamedArgs[i];
1949 }
1950
1951 // Make sure named arguments don't overlap with positional ones. The lowest
1952 // DISPID of the named arguments should be >= the number of positional
1953 // arguments.
1954 if (nLowestNamedArgDispid < static_cast<DISPID>(pdispparams->cArgs - pdispparams->cNamedArgs))
1955 return DISP_E_NONAMEDARGS;
1956
1957 // Do the actual conversion.
1958 pNewDispParams.reset(new DISPPARAMS);
1959 vNewArgs.resize(nHighestNamedArgDispid + 1);
1960 pNewDispParams->rgvarg = vNewArgs.data();
1961 pNewDispParams->rgdispidNamedArgs = nullptr;
1962 pNewDispParams->cArgs = nHighestNamedArgDispid + 1;
1963 pNewDispParams->cNamedArgs = 0;
1964
1965 // Initialise all parameter slots as missing
1966 for (int i = 0; i < nHighestNamedArgDispid; ++i)
1967 {
1968 pNewDispParams->rgvarg[i].vt = VT_ERROR;
1969 pNewDispParams->rgvarg[i].scode = DISP_E_PARAMNOTFOUND;
1970 }
1971
1972 // Then set the value of those actually present.
1973 for (unsigned int i = 0; i < pdispparams->cNamedArgs; ++i)
1974 pNewDispParams->rgvarg[nHighestNamedArgDispid - pdispparams->rgdispidNamedArgs[i]] = pdispparams->rgvarg[i];
1975
1976 const int nFirstUnnamedArg = pdispparams->cNamedArgs + (nLowestNamedArgDispid-(pdispparams->cArgs - pdispparams->cNamedArgs));
1977
1978 for (unsigned int i = pdispparams->cNamedArgs; i < pdispparams->cArgs; ++i)
1979 pNewDispParams->rgvarg[nFirstUnnamedArg + (i-pdispparams->cNamedArgs)] = pdispparams->rgvarg[i];
1980
1981 pdispparams = pNewDispParams.get();
1982 }
1983
1984 Sequence<Any> params;
1985
1986 convertDispparamsArgs(dispidMember, wFlags, pdispparams , params );
1987
1988 ret= doInvoke(pdispparams, pvarResult,
1989 pexcepinfo, puArgErr, d.name, params);
1990 }
1991 else if ((flags & DISPATCH_PROPERTYGET) != 0)
1992 {
1993 ret= doGetProperty( pdispparams, pvarResult,
1994 pexcepinfo, d.name);
1995 }
1996 else if ((flags & DISPATCH_PROPERTYPUT) != 0 || (flags & DISPATCH_PROPERTYPUTREF) != 0)
1997 {
1998 if (pdispparams->cArgs != 1)
1999 ret = DISP_E_BADPARAMCOUNT;
2000 else
2001 {
2002 Sequence<Any> params;
2003 convertDispparamsArgs(dispidMember, wFlags, pdispparams, params );
2004 if(params.getLength() > 0)
2005 ret= doSetProperty( pdispparams, pvarResult, pexcepinfo, puArgErr, d.name, params);
2006 else
2007 ret = DISP_E_BADVARTYPE;
2008 }
2009 }
2010 }
2011 else
2012 ret= DISP_E_MEMBERNOTFOUND;
2013 }
2014 else
2015 ret = DISP_E_MEMBERNOTFOUND;
2016 }
2017 catch(const BridgeRuntimeError& e)
2018 {
2019 writeExcepinfo(pexcepinfo, e.message);
2020 ret = DISP_E_EXCEPTION;
2021 }
2022 catch(const Exception& e)
2023 {
2024 OUString message= "InterfaceOleWrapper::Invoke : \n" +
2025 e.Message;
2026 writeExcepinfo(pexcepinfo, message);
2027 ret = DISP_E_EXCEPTION;
2028 }
2029 catch(...)
2030 {
2031 OUString message= "InterfaceOleWrapper::Invoke : \n"
2032 "Unexpected exception";
2033 writeExcepinfo(pexcepinfo, message);
2034 ret = DISP_E_EXCEPTION;
2035 }
2036
2037 return ret;
2038 }
2039
2040 HRESULT InterfaceOleWrapper::doInvoke( DISPPARAMS * pdispparams, VARIANT * pvarResult,
2041 EXCEPINFO * pexcepinfo, unsigned int * puArgErr, OUString& name, Sequence<Any>& params)
2042 {
2043
2044
2045 HRESULT ret= S_OK;
2046 try
2047 {
2048 Sequence<sal_Int16> outIndex;
2049 Sequence<Any> outParams;
2050 Any returnValue;
2051
2052 if (pdispparams->cNamedArgs > 0)
2053 return DISP_E_NONAMEDARGS;
2054
2055 // invoke method and take care of exceptions
2056 returnValue = m_xInvocation->invoke(name,
2057 params,
2058 outIndex,
2059 outParams);
2060
2061 // try to write back out parameter
2062 if (outIndex.getLength() > 0)
2063 {
2064 const sal_Int16* pOutIndex = outIndex.getConstArray();
2065 const Any* pOutParams = outParams.getConstArray();
2066
2067 for (sal_Int32 i = 0; i < outIndex.getLength(); i++)
2068 {
2069 CComVariant variant;
2070 // Currently a Sequence is converted to an SafeArray of VARIANTs.
2071 anyToVariant( &variant, pOutParams[i]);
2072
2073 // out parameter need special handling if they are VT_DISPATCH
2074 // and used in JScript
2075 int outindex= pOutIndex[i];
2076 writeBackOutParameter2(&(pdispparams->rgvarg[pdispparams->cArgs - 1 - outindex]),
2077 &variant );
2078 }
2079 }
2080
2081 // write back return value
2082 if (pvarResult != nullptr)
2083 anyToVariant(pvarResult, returnValue);
2084 }
2085 catch(const IllegalArgumentException & e) //XInvocation::invoke
2086 {
2087 writeExcepinfo(pexcepinfo, e.Message);
2088 ret = DISP_E_TYPEMISMATCH;
2089 }
2090 catch(const CannotConvertException & e) //XInvocation::invoke
2091 {
2092 writeExcepinfo(pexcepinfo, e.Message);
2093 ret = mapCannotConvertException( e, puArgErr);
2094 }
2095 catch(const InvocationTargetException & e) //XInvocation::invoke
2096 {
2097 const Any& org = e.TargetException;
2098 Exception excTarget;
2099 org >>= excTarget;
2100 OUString message=
2101 org.getValueType().getTypeName() + ": " + excTarget.Message;
2102 writeExcepinfo(pexcepinfo, message);
2103 ret = DISP_E_EXCEPTION;
2104 }
2105 catch(const NoSuchMethodException & e) //XInvocation::invoke
2106 {
2107 writeExcepinfo(pexcepinfo, e.Message);
2108 ret = DISP_E_MEMBERNOTFOUND;
2109 }
2110 catch(const BridgeRuntimeError & e)
2111 {
2112 writeExcepinfo(pexcepinfo, e.message);
2113 ret = DISP_E_EXCEPTION;
2114 }
2115 catch(const Exception & e)
2116 {
2117 OUString message= "InterfaceOleWrapper::doInvoke : \n" +
2118 e.Message;
2119 writeExcepinfo(pexcepinfo, message);
2120 ret = DISP_E_EXCEPTION;
2121 }
2122 catch( ... )
2123 {
2124 OUString message= "InterfaceOleWrapper::doInvoke : \n"
2125 "Unexpected exception";
2126 writeExcepinfo(pexcepinfo, message);
2127 ret = DISP_E_EXCEPTION;
2128 }
2129 return ret;
2130 }
2131
2132 HRESULT InterfaceOleWrapper::doGetProperty( DISPPARAMS * /*pdispparams*/, VARIANT * pvarResult,
2133 EXCEPINFO * pexcepinfo, OUString& name)
2134 {
2135 HRESULT ret= S_OK;
2136
2137 try
2138 {
2139 Any returnValue = m_xInvocation->getValue( name);
2140 // write back return value
2141 if (pvarResult)
2142 anyToVariant(pvarResult, returnValue);
2143 }
2144 catch(const UnknownPropertyException& e) //XInvocation::getValue
2145 {
2146 writeExcepinfo(pexcepinfo, e.Message);
2147 ret = DISP_E_MEMBERNOTFOUND;
2148 }
2149 catch(const BridgeRuntimeError& e)
2150 {
2151 writeExcepinfo(pexcepinfo, e.message);
2152 ret = DISP_E_EXCEPTION;
2153 }
2154 catch(const Exception& e)
2155 {
2156 OUString message= "InterfaceOleWrapper::doGetProperty : \n" +
2157 e.Message;
2158 writeExcepinfo(pexcepinfo, message);
2159 }
2160 catch( ... )
2161 {
2162 OUString message= "InterfaceOleWrapper::doInvoke : \n"
2163 "Unexpected exception";
2164 writeExcepinfo(pexcepinfo, message);
2165 ret = DISP_E_EXCEPTION;
2166 }
2167 return ret;
2168 }
2169
2170 HRESULT InterfaceOleWrapper::doSetProperty( DISPPARAMS * /*pdispparams*/, VARIANT * /*pvarResult*/,
2171 EXCEPINFO * pexcepinfo, unsigned int * puArgErr, OUString& name, Sequence<Any> const & params)
2172 {
2173 HRESULT ret= S_OK;
2174
2175 try
2176 {
2177 m_xInvocation->setValue( name, params.getConstArray()[0]);
2178 }
2179 catch(const UnknownPropertyException &)
2180 {
2181 ret = DISP_E_MEMBERNOTFOUND;
2182 }
2183 catch(const CannotConvertException &e)
2184 {
2185 ret= mapCannotConvertException( e, puArgErr);
2186 }
2187 catch(const InvocationTargetException &e)
2188 {
2189 if (pexcepinfo != nullptr)
2190 {
2191 Any org = e.TargetException;
2192
2193 pexcepinfo->wCode = UNO_2_OLE_EXCEPTIONCODE;
2194 pexcepinfo->bstrSource = SysAllocString(L"any ONE component");
2195 pexcepinfo->bstrDescription = SysAllocString(
2196 o3tl::toW(org.getValueType().getTypeName().getStr()));
2197 }
2198 ret = DISP_E_EXCEPTION;
2199 }
2200 catch( ... )
2201 {
2202 ret= DISP_E_EXCEPTION;
2203 }
2204 return ret;
2205 }
2206
2207 class CXEnumVariant : public IEnumVARIANT,
2208 public CComObjectRoot
2209 {
2210 public:
2211 CXEnumVariant()
2212 : mnIndex(1) // ooo::vba::XCollection index starts at one
2213 {
2214 }
2215
2216 virtual ~CXEnumVariant()
2217 {
2218 }
2219
2220 #if defined __clang__
2221 #pragma clang diagnostic push
2222 #pragma clang diagnostic ignored "-Wunused-function"
2223 #endif
2224 BEGIN_COM_MAP(CXEnumVariant)
2225 #if defined __clang__
2226 #pragma clang diagnostic pop
2227 #endif
2228 COM_INTERFACE_ENTRY(IEnumVARIANT)
2229 #if defined __clang__
2230 #pragma clang diagnostic push
2231 #pragma clang diagnostic ignored "-Winconsistent-missing-override"
2232 #pragma clang diagnostic ignored "-Wunused-function"
2233 #endif
2234 END_COM_MAP()
2235 #if defined __clang__
2236 #pragma clang diagnostic pop
2237 #endif
2238
2239 DECLARE_NOT_AGGREGATABLE(CXEnumVariant)
2240
2241 // Creates and initializes the enumerator
2242 void Init(InterfaceOleWrapper* pInterfaceOleWrapper,
2243 const Reference<ooo::vba::XCollection > xCollection)
2244 {
2245 mpInterfaceOleWrapper = pInterfaceOleWrapper;
2246 mxCollection = xCollection;
2247 }
2248
2249 // IEnumVARIANT
2250 virtual HRESULT STDMETHODCALLTYPE Clone(IEnumVARIANT **) override
2251 {
2252 SAL_INFO("extensions.olebridge", this << "@CXEnumVariant::Clone: E_NOTIMPL");
2253 return E_NOTIMPL;
2254 }
2255
2256 virtual HRESULT STDMETHODCALLTYPE Next(ULONG const celt,
2257 VARIANT *rgVar,
2258 ULONG *pCeltFetched) override
2259 {
2260 comphelper::Automation::AutomationInvokedZone aAutomationActive;
2261
2262 if (pCeltFetched)
2263 *pCeltFetched = 0;
2264
2265 if (celt == 0)
2266 {
2267 SAL_INFO("extensions.olebridge", this << "@CXEnumVariant::Next(" << celt << "): E_INVALIDARG");
2268 return E_INVALIDARG;
2269 }
2270
2271 if (rgVar == nullptr || (celt != 1 && pCeltFetched == nullptr))
2272 {
2273 SAL_INFO("extensions.olebridge", this << "@CXEnumVariant::Next(" << celt << "): E_FAIL");
2274 return E_FAIL;
2275 }
2276
2277 for (ULONG i = 0; i < celt; i++)
2278 VariantInit(&rgVar[i]);
2279
2280 ULONG nLeft = celt;
2281 ULONG nReturned = 0;
2282 while (nLeft > 0)
2283 {
2284 if (mnIndex > mxCollection->getCount())
2285 {
2286 SAL_INFO("extensions.olebridge", this << "@CXEnumVariant::Next(" << celt << "): got " << nReturned << ": S_FALSE");
2287 return S_FALSE;
2288 }
2289 Any aIndex;
2290 aIndex <<= mnIndex;
2291 Any aElement = mxCollection->Item(aIndex, Any());
2292 mpInterfaceOleWrapper->anyToVariant(rgVar, aElement);
2293 // rgVar->pdispVal->AddRef(); ??
2294 if (pCeltFetched)
2295 (*pCeltFetched)++;
2296 rgVar++;
2297 nReturned++;
2298 mnIndex++;
2299 nLeft--;
2300 }
2301 SAL_INFO("extensions.olebridge", this << "@CXEnumVariant::Next(" << celt << "): S_OK");
2302 return S_OK;
2303 }
2304
2305 virtual HRESULT STDMETHODCALLTYPE Reset() override
2306 {
2307 SAL_INFO("extensions.olebridge", this << "@CXEnumVariant::Reset: S_OK");
2308 mnIndex = 1;
2309 return S_OK;
2310 }
2311
2312 virtual HRESULT STDMETHODCALLTYPE STDMETHODCALLTYPE Skip(ULONG const celt) override
2313 {
2314 comphelper::Automation::AutomationInvokedZone aAutomationActive;
2315
2316 ULONG nLeft = celt;
2317 ULONG nSkipped = 0;
2318 while (nLeft > 0)
2319 {
2320 if (mnIndex > mxCollection->getCount())
2321 {
2322 SAL_INFO("extensions.olebridge", this << "@CXEnumVariant::Skip(" << celt << "): skipped " << nSkipped << ": S_FALSE");
2323 return S_FALSE;
2324 }
2325 mnIndex++;
2326 nLeft--;
2327 }
2328 SAL_INFO("extensions.olebridge", this << "@CXEnumVariant::Skip(" << celt << "): S_OK");
2329 return S_OK;
2330 }
2331
2332 private:
2333 InterfaceOleWrapper* mpInterfaceOleWrapper;
2334 Reference<ooo::vba::XCollection> mxCollection;
2335 sal_Int32 mnIndex;
2336 };
2337
2338 class Sink : public cppu::WeakImplHelper<ooo::vba::XSink>
2339 {
2340 public:
2341 Sink(IUnknown* pUnkSink,
2342 Reference<XMultiServiceFactory> xMSF,
2343 ooo::vba::TypeAndIID aTypeAndIID,
2344 InterfaceOleWrapper* pInterfaceOleWrapper);
2345
2346 // XSink
2347 void SAL_CALL Call( const OUString& Method, Sequence< Any >& Arguments ) override;
2348
2349 private:
2350 IUnknown* mpUnkSink;
2351 Reference<XMultiServiceFactory> mxMSF;
2352 ooo::vba::TypeAndIID maTypeAndIID;
2353 InterfaceOleWrapper* mpInterfaceOleWrapper;
2354 };
2355
2356 Sink::Sink(IUnknown* pUnkSink,
2357 Reference<XMultiServiceFactory> xMSF,
2358 ooo::vba::TypeAndIID aTypeAndIID,
2359 InterfaceOleWrapper* pInterfaceOleWrapper) :
2360 mpUnkSink(pUnkSink),
2361 mxMSF(xMSF),
2362 maTypeAndIID(aTypeAndIID),
2363 mpInterfaceOleWrapper(pInterfaceOleWrapper)
2364 {
2365 mpUnkSink->AddRef();
2366 }
2367
2368 void SAL_CALL
2369 Sink::Call( const OUString& Method, Sequence< Any >& Arguments )
2370 {
2371 SAL_INFO("extensions.olebridge", "Sink::Call(" << Method << ", " << Arguments.getLength() << " arguments)");
2372
2373 IDispatch* pDispatch;
2374 HRESULT nResult = mpUnkSink->QueryInterface(IID_IDispatch, reinterpret_cast<void **>(&pDispatch));
2375 if (!SUCCEEDED(nResult))
2376 {
2377 SAL_WARN("extensions.olebridge", "Sink::Call: Not IDispatch: " << WindowsErrorStringFromHRESULT(nResult));
2378 return;
2379 }
2380
2381 Reference<XIdlReflection> xRefl = theCoreReflection::get(comphelper::getComponentContext(mxMSF));
2382 assert(xRefl.is());
2383
2384 Reference<XIdlClass> xClass = xRefl->forName(maTypeAndIID.Type.getTypeName());
2385 assert(xClass.is());
2386
2387 auto aMethods = xClass->getMethods();
2388 assert(xClass->getTypeClass() == TypeClass_INTERFACE &&
2389 aMethods.getLength() > 0);
2390
2391 int nMemId = 1;
2392 // Skip the three XInterface methods
2393 for (int i = 3; i < aMethods.getLength(); i++)
2394 {
2395 if (aMethods[i]->getName() == Method)
2396 {
2397 // FIXME: Handle mismatch in type of actual argument and parameter of the method.
2398
2399 // FIXME: Handle mismatch in number of arguments passed and actual number of parameters
2400 // of the method.
2401
2402 auto aParamInfos = aMethods[i]->getParameterInfos();
2403
2404 assert(Arguments.getLength() == aParamInfos.getLength());
2405
2406 DISPPARAMS aDispParams;
2407 aDispParams.rgdispidNamedArgs = nullptr;
2408 aDispParams.cArgs = Arguments.getLength();
2409 aDispParams.cNamedArgs = 0;
2410 aDispParams.rgvarg = new VARIANT[aDispParams.cArgs];
2411 for (unsigned j = 0; j < aDispParams.cArgs; j++)
2412 {
2413 VariantInit(aDispParams.rgvarg+j);
2414 // Note: Reverse order of arguments in Arguments and aDispParams.rgvarg!
2415 const unsigned nIncomingArgIndex = aDispParams.cArgs - j - 1;
2416 mpInterfaceOleWrapper->anyToVariant(aDispParams.rgvarg+j, Arguments[nIncomingArgIndex]);
2417
2418 // Handle OUT and INOUT arguments. For instance, the second ('Cancel') parameter to
2419 // DocumentBeforeClose() should be a VT_BYREF|VT_BOOL parameter. Need to handle that
2420 // here.
2421
2422 if (aParamInfos[nIncomingArgIndex].aMode == ParamMode_OUT ||
2423 aParamInfos[nIncomingArgIndex].aMode == ParamMode_INOUT)
2424 {
2425 switch (aDispParams.rgvarg[j].vt)
2426 {
2427 case VT_I2:
2428 aDispParams.rgvarg[j].byref = new SHORT(aDispParams.rgvarg[j].iVal);
2429 aDispParams.rgvarg[j].vt |= VT_BYREF;
2430 break;
2431 case VT_I4:
2432 aDispParams.rgvarg[j].byref = new LONG(aDispParams.rgvarg[j].lVal);
2433 aDispParams.rgvarg[j].vt |= VT_BYREF;
2434 break;
2435 case VT_BSTR:
2436 aDispParams.rgvarg[j].byref = new BSTR(aDispParams.rgvarg[j].bstrVal);
2437 aDispParams.rgvarg[j].vt |= VT_BYREF;
2438 break;
2439 case VT_BOOL:
2440 // SAL_ DEBUG("===> VT_BOOL is initially " << (int)aDispParams.rgvarg[j].boolVal);
2441 aDispParams.rgvarg[j].byref = new VARIANT_BOOL(aDispParams.rgvarg[j].boolVal);
2442 // SAL_ DEBUG(" byref=" << aDispParams.rgvarg[j].byref);
2443 aDispParams.rgvarg[j].vt |= VT_BYREF;
2444 break;
2445 default:
2446 assert(false && "Not handled yet");
2447 break;
2448 }
2449 }
2450 }
2451
2452 VARIANT aVarResult;
2453 VariantInit(&aVarResult);
2454 UINT uArgErr;
2455
2456 // In the case of a VBScript client, which uses "late binding", calling Invoke on the
2457 // sink it provides will cause a callback to our CXTypeInfo::GetNames for the given
2458 // member id, and in that we will tell it the name of the corresponding method, and the
2459 // client will know what event handler to invoke based on that name.
2460 //
2461 // As the outgoing interfaces used (ooo::vba::word::XApplicationOutgoing and others) are
2462 // totally not stable and not published in any way, there can be no client that would
2463 // have done "compile-time binding" and where the sink would actually be an object with
2464 // a vtbl corresponding to the outgoing interface. Late binding clients that work like
2465 // VBScript is all we support.
2466 SAL_INFO("extensions.olebridge", "Sink::Call(" << Method << "): Calling Invoke(" << nMemId << ")");
2467
2468 nResult = pDispatch->Invoke(nMemId, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &aDispParams, &aVarResult, nullptr, &uArgErr);
2469 SAL_INFO("extensions.olebridge", "Sink::Call(" << Method << "): Invoke() returned");
2470
2471 SAL_WARN_IF(!SUCCEEDED(nResult), "extensions.olebridge", "Call to " << Method << " failed: " << WindowsErrorStringFromHRESULT(nResult));
2472
2473 // Undo VT_BYREF magic done above. Copy out parameters back to the Anys in Arguments
2474 for (unsigned j = 0; j < aDispParams.cArgs; j++)
2475 {
2476 const unsigned nIncomingArgIndex = aDispParams.cArgs - j - 1;
2477 if (aParamInfos[nIncomingArgIndex].aMode == ParamMode_OUT ||
2478 aParamInfos[nIncomingArgIndex].aMode == ParamMode_INOUT)
2479 {
2480 switch (aDispParams.rgvarg[j].vt)
2481 {
2482 case VT_BYREF|VT_I2:
2483 {
2484 SHORT *pI = static_cast<SHORT*>(aDispParams.rgvarg[j].byref);
2485 Arguments[nIncomingArgIndex] <<= static_cast<sal_Int16>(*pI);
2486 delete pI;
2487 }
2488 break;
2489 case VT_BYREF|VT_I4:
2490 {
2491 LONG *pL = static_cast<LONG*>(aDispParams.rgvarg[j].byref);
2492 Arguments[nIncomingArgIndex] <<= static_cast<sal_Int32>(*pL);
2493 delete pL;
2494 }
2495 break;
2496 case VT_BYREF|VT_BSTR:
2497 {
2498 BSTR *pBstr = static_cast<BSTR*>(aDispParams.rgvarg[j].byref);
2499 Arguments[nIncomingArgIndex] <<= OUString(o3tl::toU(*pBstr));
2500 // Undo SysAllocString() done in anyToVariant()
2501 SysFreeString(*pBstr);
2502 delete pBstr;
2503 }
2504 break;
2505 case VT_BYREF|VT_BOOL:
2506 {
2507 VARIANT_BOOL *pBool = static_cast<VARIANT_BOOL*>(aDispParams.rgvarg[j].byref);
2508 // SAL_ DEBUG("===> VT_BOOL: byref is now " << aDispParams.rgvarg[j].byref << ", " << (int)*pBool);
2509 Arguments[nIncomingArgIndex] <<= (*pBool != VARIANT_FALSE);
2510 delete pBool;
2511 }
2512 break;
2513 default:
2514 assert(false && "Not handled yet");
2515 break;
2516 }
2517 }
2518 else
2519 {
2520 switch (aDispParams.rgvarg[j].vt)
2521 {
2522 case VT_BSTR:
2523 // Undo SysAllocString() done in anyToVariant()
2524 SysFreeString(aDispParams.rgvarg[j].bstrVal);
2525 break;
2526 }
2527 }
2528 }
2529
2530 delete[] aDispParams.rgvarg;
2531 return;
2532 }
2533 nMemId++;
2534 }
2535 SAL_WARN("extensions.olebridge", "Sink::Call: Unknown method '" << Method << "'");
2536 }
2537
2538 class CXEnumConnections : public IEnumConnections,
2539 public CComObjectRoot
2540 {
2541 public:
2542 CXEnumConnections()
2543 {
2544 }
2545
2546 virtual ~CXEnumConnections()
2547 {
2548 }
2549
2550 #if defined __clang__
2551 #pragma clang diagnostic push
2552 #pragma clang diagnostic ignored "-Wunused-function"
2553 #endif
2554 BEGIN_COM_MAP(CXEnumConnections)
2555 #if defined __clang__
2556 #pragma clang diagnostic pop
2557 #endif
2558 COM_INTERFACE_ENTRY(IEnumConnections)
2559 #if defined __clang__
2560 #pragma clang diagnostic push
2561 #pragma clang diagnostic ignored "-Winconsistent-missing-override"
2562 #pragma clang diagnostic ignored "-Wunused-function"
2563 #endif
2564 END_COM_MAP()
2565 #if defined __clang__
2566 #pragma clang diagnostic pop
2567 #endif
2568
2569 DECLARE_NOT_AGGREGATABLE(CXEnumConnections)
2570
2571 void Init(std::vector<IUnknown*>& rUnknowns, std::vector<DWORD>& rCookies)
2572 {
2573 SAL_INFO("extensions.olebridge", this << "@CXEnumConnections::Init");
2574 SAL_WARN_IF(rUnknowns.size() != rCookies.size(), "extensions.olebridge", "Vectors of different size");
2575 mvUnknowns = rUnknowns;
2576 mvCookies = rCookies;
2577 mnIndex = 0;
2578 }
2579
2580 virtual HRESULT STDMETHODCALLTYPE Next(ULONG cConnections,
2581 LPCONNECTDATA rgcd,
2582 ULONG *pcFetched) override
2583 {
2584 comphelper::Automation::AutomationInvokedZone aAutomationActive;
2585
2586 if (!rgcd)
2587 {
2588 SAL_INFO("extensions.olebridge", this << "@CXEnumConnections::Next(" << cConnections << "): E_POINTER");
2589 return E_POINTER;
2590 }
2591
2592 if (pcFetched && cConnections != 1)
2593 {
2594 SAL_INFO("extensions.olebridge", this << "@CXEnumConnections::Next(" << cConnections << "): E_INVALIDARG");
2595 return E_INVALIDARG;
2596 }
2597
2598 ULONG nFetched = 0;
2599 while (nFetched < cConnections && mnIndex < mvUnknowns.size())
2600 {
2601 rgcd[nFetched].pUnk = mvUnknowns[mnIndex];
2602 rgcd[nFetched].pUnk->AddRef();
2603 rgcd[nFetched].dwCookie = mvCookies[mnIndex];
2604 ++nFetched;
2605 ++mnIndex;
2606 }
2607 if (nFetched != cConnections)
2608 {
2609 SAL_INFO("extensions.olebridge", this << "@CXEnumConnections::Next(" << cConnections << "): S_FALSE");
2610 if (pcFetched)
2611 *pcFetched = nFetched;
2612 return S_FALSE;
2613 }
2614 SAL_INFO("extensions.olebridge", this << "@CXEnumConnections::Next(" << cConnections << "): S_OK");
2615 if (pcFetched)
2616 *pcFetched = nFetched;
2617
2618 return S_OK;
2619 }
2620
2621 virtual HRESULT STDMETHODCALLTYPE Skip(ULONG cConnections) override
2622 {
2623 SAL_INFO("extensions.olebridge", this << "@CXEnumConnections::Skip(" << cConnections << "): E_NOTIMPL");
2624
2625 return E_NOTIMPL;
2626 }
2627
2628 virtual HRESULT STDMETHODCALLTYPE Reset() override
2629 {
2630 SAL_INFO("extensions.olebridge", this << "@CXEnumConnections::Reset: E_NOTIMPL");
2631
2632 return E_NOTIMPL;
2633 }
2634
2635 virtual HRESULT STDMETHODCALLTYPE Clone(IEnumConnections** /* ppEnum */) override
2636 {
2637 SAL_INFO("extensions.olebridge", this << "@CXEnumConnections::Clone: E_NOTIMPL");
2638
2639 return E_NOTIMPL;
2640 }
2641
2642 private:
2643 std::vector<IUnknown*> mvUnknowns;
2644 std::vector<DWORD> mvCookies;
2645 ULONG mnIndex;
2646 };
2647
2648 class CXConnectionPoint : public IConnectionPoint,
2649 public CComObjectRoot
2650 {
2651 public:
2652 #if defined __clang__
2653 #pragma clang diagnostic push
2654 #pragma clang diagnostic ignored "-Wunused-function"
2655 #endif
2656 BEGIN_COM_MAP(CXConnectionPoint)
2657 #if defined __clang__
2658 #pragma clang diagnostic pop
2659 #endif
2660 COM_INTERFACE_ENTRY(IConnectionPoint)
2661 #if defined __clang__
2662 #pragma clang diagnostic push
2663 #pragma clang diagnostic ignored "-Winconsistent-missing-override"
2664 #pragma clang diagnostic ignored "-Wunused-function"
2665 #endif
2666 END_COM_MAP()
2667 #if defined __clang__
2668 #pragma clang diagnostic pop
2669 #endif
2670
2671 DECLARE_NOT_AGGREGATABLE(CXConnectionPoint)
2672
2673 virtual ~CXConnectionPoint() {}
2674
2675 void Init(InterfaceOleWrapper* pInterfaceOleWrapper,
2676 Reference<ooo::vba::XConnectionPoint>& xCP,
2677 Reference<XMultiServiceFactory>& xMSF,
2678 ooo::vba::TypeAndIID aTypeAndIID)
2679 {
2680 SAL_INFO("extensions.olebridge", this << "@CXConnectionPoint::Init for " << pInterfaceOleWrapper->getImplementationName());
2681
2682 IUnknown *pUnknown;
2683 if (SUCCEEDED(QueryInterface(IID_IUnknown, reinterpret_cast<void **>(&pUnknown))))
2684 {
2685 // In case QI for IUnknown returns a different pointer, but nah, it doesn't
2686 SAL_INFO("extensions.olebridge", " (IUnknown@" << pUnknown << ")");
2687 }
2688
2689 mpInterfaceOleWrapper = pInterfaceOleWrapper;
2690 mxCP = xCP;
2691 mxMSF = xMSF;
2692 maTypeAndIID = aTypeAndIID;
2693 }
2694
2695 virtual HRESULT STDMETHODCALLTYPE GetConnectionInterface(IID *pIID) override
2696 {
2697 SAL_WARN("extensions.olebridge", this << "@CXConnectionPoint::GetConnectionInterface(" << *pIID << "): E_NOTIMPL");
2698
2699 // FIXME: Needed?
2700
2701 return E_NOTIMPL;
2702 }
2703
2704 virtual HRESULT STDMETHODCALLTYPE GetConnectionPointContainer(IConnectionPointContainer **) override
2705 {
2706 SAL_WARN("extensions.olebridge", this << "@CXConnectionPoint::GetConnectionInterface: E_NOTIMPL");
2707
2708 // FIXME: Needed?
2709
2710 return E_NOTIMPL;
2711 }
2712
2713 virtual HRESULT STDMETHODCALLTYPE Advise(IUnknown *pUnkSink,
2714 DWORD *pdwCookie) override
2715 {
2716 comphelper::Automation::AutomationInvokedZone aAutomationActive;
2717
2718 SAL_INFO("extensions.olebridge", this << "@CXConnectionPoint::Advise(" << pUnkSink << ")");
2719
2720 if (!pdwCookie)
2721 return E_POINTER;
2722
2723 Reference<ooo::vba::XSink> xSink(new Sink(pUnkSink, mxMSF, maTypeAndIID, mpInterfaceOleWrapper));
2724
2725 mvISinks.push_back(pUnkSink);
2726 *pdwCookie = mvISinks.size();
2727
2728 mvCookies.push_back(mxCP->Advise(xSink));
2729
2730 mvXSinks.push_back(xSink);
2731
2732 SAL_INFO("extensions.olebridge", " *pdwCookie: " << *pdwCookie);
2733
2734 return S_OK;
2735 }
2736
2737 virtual HRESULT STDMETHODCALLTYPE Unadvise(DWORD dwCookie) override
2738 {
2739 comphelper::Automation::AutomationInvokedZone aAutomationActive;
2740
2741 SAL_INFO("extensions.olebridge", this << "@CXConnectionPoint::Unadvise(" << dwCookie << ")");
2742
2743 if (dwCookie == 0 || dwCookie > mvISinks.size())
2744 return E_POINTER;
2745
2746 mvISinks[dwCookie-1] = nullptr;
2747
2748 mxCP->Unadvise(mvCookies[dwCookie-1]);
2749
2750 mvXSinks[dwCookie-1] = Reference<ooo::vba::XSink>();
2751
2752 return S_OK;
2753 }
2754
2755 virtual HRESULT STDMETHODCALLTYPE EnumConnections(IEnumConnections **ppEnum) override
2756 {
2757 comphelper::Automation::AutomationInvokedZone aAutomationActive;
2758
2759 HRESULT nResult;
2760
2761 SAL_INFO("extensions.olebridge", this << "@CXConnectionPoint::EnumConnections...");
2762
2763 if (!ppEnum)
2764 {
2765 SAL_INFO("extensions.olebridge", "..." << this << "@CXConnectionPoint::EnumConnections: E_POINTER");
2766 return E_POINTER;
2767 }
2768
2769 CComObject<CXEnumConnections>* pEnumConnections;
2770
2771 nResult = CComObject<CXEnumConnections>::CreateInstance(&pEnumConnections);
2772 if (FAILED(nResult))
2773 {
2774 SAL_INFO("extensions.olebridge", "..." << this << "@CXConnectionPoint::EnumConnections: " << WindowsErrorStringFromHRESULT(nResult));
2775 return nResult;
2776 }
2777
2778 pEnumConnections->AddRef();
2779
2780 pEnumConnections->Init(mvISinks, mvCookies);
2781 *ppEnum = pEnumConnections;
2782
2783 SAL_INFO("extensions.olebridge", "..." << this << "@CXConnectionPoint::EnumConnections: S_OK");
2784
2785 return S_OK;
2786 }
2787
2788 InterfaceOleWrapper* mpInterfaceOleWrapper;
2789 std::vector<IUnknown*> mvISinks;
2790 std::vector<Reference<ooo::vba::XSink>> mvXSinks;
2791 std::vector<DWORD> mvCookies;
2792 Reference<XMultiServiceFactory> mxMSF;
2793 Reference<ooo::vba::XConnectionPoint> mxCP;
2794 ooo::vba::TypeAndIID maTypeAndIID;
2795 };
2796
2797 HRESULT InterfaceOleWrapper::InvokeGeneral( DISPID dispidMember, unsigned short wFlags,
2798 DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo,
2799 unsigned int * /*puArgErr*/, bool& bHandled)
2800 {
2801 HRESULT ret= S_OK;
2802 try
2803 {
2804 // DISPID_VALUE | The DEFAULT Value is required in JScript when the situation
2805 // is that we put an object into an Array object ( out parameter). We have to return
2806 // IDispatch otherwise the object cannot be accessed from the Script.
2807 if( dispidMember == DISPID_VALUE && (wFlags & DISPATCH_PROPERTYGET) != 0
2808 && m_defaultValueType != VT_EMPTY && pvarResult != nullptr)
2809 {
2810 // Special case hack: If it is a ScVbaCheckBox, return the boolean value
2811 Reference<ooo::vba::msforms::XCheckBox> xCheckBox(m_xOrigin, UNO_QUERY);
2812 if (xCheckBox.is())
2813 {
2814 bHandled = true;
2815 Any aValue = xCheckBox->getValue();
2816 anyToVariant(pvarResult, aValue);
2817 return S_OK;
2818 }
2819
2820 bHandled= true;
2821 if( m_defaultValueType == VT_DISPATCH)
2822 {
2823 pvarResult->vt= VT_DISPATCH;
2824 pvarResult->pdispVal= static_cast<IDispatch*>( this);
2825 AddRef();
2826 ret= S_OK;
2827 }
2828 }
2829
2830 // function: _GetValueObject
2831 else if( dispidMember == DISPID_JSCRIPT_VALUE_FUNC)
2832 {
2833 bHandled= true;
2834 if( !pvarResult)
2835 return E_POINTER;
2836 CComObject< JScriptValue>* pValue;
2837 if( SUCCEEDED( CComObject<JScriptValue>::CreateInstance( &pValue)))
2838 {
2839 pValue->AddRef();
2840 pvarResult->vt= VT_DISPATCH;
2841 pvarResult->pdispVal= CComQIPtr<IDispatch>(pValue->GetUnknown());
2842 ret= S_OK;
2843 }
2844 else
2845 ret= DISP_E_EXCEPTION;
2846 }
2847 else if( dispidMember == DISPID_GET_STRUCT_FUNC)
2848 {
2849 bHandled= true;
2850 bool bStruct= false;
2851
2852
2853 Reference<XIdlReflection> xRefl = theCoreReflection::get(comphelper::getComponentContext(m_smgr));
2854 // the first parameter is in DISPPARAMS rgvargs contains the name of the struct.
2855 CComVariant arg;
2856 if( pdispparams->cArgs == 1 && SUCCEEDED( arg.ChangeType( VT_BSTR, &pdispparams->rgvarg[0])) )
2857 {
2858 Reference<XIdlClass> classStruct= xRefl->forName(o3tl::toU(arg.bstrVal));
2859 if( classStruct.is())
2860 {
2861 Any anyStruct;
2862 classStruct->createObject( anyStruct);
2863 CComVariant var;
2864 anyToVariant( &var, anyStruct );
2865
2866 if( var.vt == VT_DISPATCH)
2867 {
2868 VariantCopy( pvarResult, & var);
2869 bStruct= true;
2870 }
2871 }
2872 }
2873 ret= bStruct ? S_OK : DISP_E_EXCEPTION;
2874 }
2875 else if (dispidMember == DISPID_CREATE_TYPE_FUNC)
2876 {
2877 bHandled= true;
2878 if( !pvarResult)
2879 return E_POINTER;
2880 // the first parameter is in DISPPARAMS rgvargs contains the name of the struct.
2881 CComVariant arg;
2882 if( pdispparams->cArgs != 1)
2883 return DISP_E_BADPARAMCOUNT;
2884 if (FAILED( arg.ChangeType( VT_BSTR, &pdispparams->rgvarg[0])))
2885 return DISP_E_BADVARTYPE;
2886
2887 //check if the provided name represents a valid type
2888 Type type;
2889 if (!getType(arg.bstrVal, type))
2890 {
2891 writeExcepinfo(pexcepinfo, OUStringLiteral("[automation bridge] A UNO type with the name ") +
2892 o3tl::toU(arg.bstrVal) + " does not exist!");
2893 return DISP_E_EXCEPTION;
2894 }
2895
2896 if (!createUnoTypeWrapper(arg.bstrVal, pvarResult))
2897 {
2898 writeExcepinfo(pexcepinfo, "[automation bridge] InterfaceOleWrapper::InvokeGeneral\n"
2899 "Could not initialize UnoTypeWrapper object!");
2900 return DISP_E_EXCEPTION;
2901 }
2902 }
2903 else if (dispidMember == DISPID_NEWENUM)
2904 {
2905 bHandled = true;
2906 if( !pvarResult)
2907 return E_POINTER;
2908
2909 Reference< ooo::vba::XCollection> xCollection(m_xOrigin, UNO_QUERY);
2910 if (!xCollection.is())
2911 return DISP_E_MEMBERNOTFOUND;
2912
2913 CComObject<CXEnumVariant>* pEnumVar;
2914
2915 ret = CComObject<CXEnumVariant>::CreateInstance(&pEnumVar);
2916 if (FAILED(ret))
2917 return ret;
2918
2919 pEnumVar->AddRef();
2920
2921 pEnumVar->Init(this, xCollection);
2922
2923 pvarResult->vt = VT_UNKNOWN;
2924 pvarResult->punkVal = nullptr;
2925
2926 ret = pEnumVar->QueryInterface(IID_IUnknown, reinterpret_cast<void**>(&pvarResult->punkVal));
2927 if (FAILED(ret))
2928 {
2929 pEnumVar->Release();
2930 return ret;
2931 }
2932 }
2933 }
2934 catch(const BridgeRuntimeError & e)
2935 {
2936 writeExcepinfo(pexcepinfo, e.message);
2937 ret = DISP_E_EXCEPTION;
2938 }
2939 catch(const Exception & e)
2940 {
2941 OUString message= "InterfaceOleWrapper::InvokeGeneral : \n" +
2942 e.Message;
2943 writeExcepinfo(pexcepinfo, message);
2944 ret = DISP_E_EXCEPTION;
2945 }
2946 catch( ... )
2947 {
2948 OUString message= "InterfaceOleWrapper::InvokeGeneral : \n"
2949 "Unexpected exception";
2950 writeExcepinfo(pexcepinfo, message);
2951 ret = DISP_E_EXCEPTION;
2952 }
2953 return ret;
2954 }
2955
2956 STDMETHODIMP InterfaceOleWrapper::GetDispID(BSTR /*bstrName*/, DWORD /*grfdex*/, DISPID __RPC_FAR* /*pid*/)
2957 {
2958 return ResultFromScode(E_NOTIMPL);
2959 }
2960
2961 STDMETHODIMP InterfaceOleWrapper::InvokeEx(
2962 /* [in] */ DISPID /*id*/,
2963 /* [in] */ LCID /*lcid*/,
2964 /* [in] */ WORD /*wFlags*/,
2965 /* [in] */ DISPPARAMS __RPC_FAR* /*pdp*/,
2966 /* [out] */ VARIANT __RPC_FAR* /*pvarRes*/,
2967 /* [out] */ EXCEPINFO __RPC_FAR* /*pei*/,
2968 /* [unique][in] */ IServiceProvider __RPC_FAR* /*pspCaller*/)
2969 {
2970 return ResultFromScode(E_NOTIMPL);
2971 }
2972
2973 STDMETHODIMP InterfaceOleWrapper::DeleteMemberByName(
2974 /* [in] */ BSTR /*bstr*/,
2975 /* [in] */ DWORD /*grfdex*/)
2976 {
2977 return ResultFromScode(E_NOTIMPL);
2978 }
2979
2980 STDMETHODIMP InterfaceOleWrapper::DeleteMemberByDispID(DISPID /*id*/)
2981 {
2982 return ResultFromScode(E_NOTIMPL);
2983 }
2984
2985 STDMETHODIMP InterfaceOleWrapper::GetMemberProperties(
2986 /* [in] */ DISPID /*id*/,
2987 /* [in] */ DWORD /*grfdexFetch*/,
2988 /* [out] */ DWORD __RPC_FAR* /*pgrfdex*/)
2989 {
2990 return ResultFromScode(E_NOTIMPL);
2991 }
2992
2993 STDMETHODIMP InterfaceOleWrapper::GetMemberName(
2994 /* [in] */ DISPID /*id*/,
2995 /* [out] */ BSTR __RPC_FAR* /*pbstrName*/)
2996 {
2997 return ResultFromScode(E_NOTIMPL);
2998 }
2999
3000 STDMETHODIMP InterfaceOleWrapper::GetNextDispID(
3001 /* [in] */ DWORD /*grfdex*/,
3002 /* [in] */ DISPID /*id*/,
3003 /* [out] */ DISPID __RPC_FAR* /*pid*/)
3004 {
3005 return ResultFromScode(E_NOTIMPL);
3006 }
3007
3008 STDMETHODIMP InterfaceOleWrapper::GetNameSpaceParent(
3009 /* [out] */ IUnknown __RPC_FAR *__RPC_FAR* /*ppunk*/)
3010 {
3011 return ResultFromScode(E_NOTIMPL);
3012 }
3013
3014 // IProvideClassInfo
3015 HRESULT STDMETHODCALLTYPE InterfaceOleWrapper::GetClassInfo (
3016 /* [out] */ ITypeInfo **ppTI)
3017 {
3018 comphelper::Automation::AutomationInvokedZone aAutomationActive;
3019
3020 SAL_INFO("extensions.olebridge", this << "@InterfaceOleWrapper::GetClassInfo");
3021
3022 if (!ppTI)
3023 return E_POINTER;
3024
3025 Reference<ooo::vba::XInterfaceWithIID> xIID(m_xOrigin, UNO_QUERY);
3026 if (!xIID.is())
3027 return E_NOTIMPL;
3028
3029 OUString sIID = xIID->getIID();
3030 IID aIID;
3031 if (!SUCCEEDED(IIDFromString(reinterpret_cast<LPOLESTR>(sIID.pData->buffer), &aIID)))
3032 return E_NOTIMPL;
3033
3034 HRESULT ret;
3035
3036 CComObject<CXTypeInfo>* pTypeInfo;
3037
3038 ret = CComObject<CXTypeInfo>::CreateInstance(&pTypeInfo);
3039 if (FAILED(ret))
3040 return ret;
3041
3042 pTypeInfo->AddRef();
3043
3044 pTypeInfo->InitForCoclass(m_xOrigin, m_sImplementationName, aIID, m_smgr);
3045
3046 *ppTI = pTypeInfo;
3047
3048 return S_OK;
3049 }
3050
3051 // IConnectionPointContainer
3052 HRESULT STDMETHODCALLTYPE InterfaceOleWrapper::EnumConnectionPoints(
3053 /* [out] */ IEnumConnectionPoints **)
3054 {
3055 SAL_INFO("extensions.olebridge", this << "@InterfaceOleWrapper::EnumConnectionPoints");
3056 return ResultFromScode(E_NOTIMPL);
3057 }
3058
3059 HRESULT STDMETHODCALLTYPE InterfaceOleWrapper::FindConnectionPoint(
3060 /* [in] */ REFIID riid,
3061 /* [out] */ IConnectionPoint **ppCP)
3062 {
3063 comphelper::Automation::AutomationInvokedZone aAutomationActive;
3064
3065 SAL_INFO("extensions.olebridge", this << "@InterfaceOleWrapper::FindConnectionPoint(" << riid << ")");
3066
3067 if (!ppCP)
3068 return E_POINTER;
3069
3070 Reference<ooo::vba::XConnectable> xConnectable(m_xOrigin, UNO_QUERY);
3071
3072 // We checked already
3073 assert(xConnectable.is());
3074 if (!xConnectable.is())
3075 return E_NOTIMPL;
3076
3077 ooo::vba::TypeAndIID aTypeAndIID = xConnectable->GetConnectionPoint();
3078
3079 IID aIID;
3080 if (!SUCCEEDED(IIDFromString(reinterpret_cast<LPOLESTR>(aTypeAndIID.IID.pData->buffer), &aIID)))
3081 return E_INVALIDARG;
3082
3083 if (!IsEqualIID(riid, aIID))
3084 return E_INVALIDARG;
3085
3086 Reference<ooo::vba::XConnectionPoint> xCP = xConnectable->FindConnectionPoint();
3087 if (!xCP.is())
3088 return E_INVALIDARG;
3089
3090 HRESULT ret;
3091
3092 CComObject<CXConnectionPoint>* pConnectionPoint;
3093
3094 ret = CComObject<CXConnectionPoint>::CreateInstance(&pConnectionPoint);
3095 if (FAILED(ret))
3096 return ret;
3097
3098 pConnectionPoint->AddRef();
3099
3100 pConnectionPoint->Init(this, xCP, m_smgr, aTypeAndIID);
3101
3102 *ppCP = pConnectionPoint;
3103
3104 return S_OK;
3105 }
3106
3107 // UnoObjectWrapperRemoteOpt ---------------------------------------------------
3108
3109 UnoObjectWrapperRemoteOpt::UnoObjectWrapperRemoteOpt( Reference<XMultiServiceFactory> const & aFactory,
3110 sal_uInt8 unoWrapperClass, sal_uInt8 comWrapperClass):
3111 InterfaceOleWrapper( aFactory, unoWrapperClass, comWrapperClass),
3112 m_currentId(1)
3113
3114 {
3115 }
3116 UnoObjectWrapperRemoteOpt::~UnoObjectWrapperRemoteOpt()
3117 {
3118 }
3119
3120 // UnoConversionUtilities
3121 Reference< XInterface > UnoObjectWrapperRemoteOpt::createUnoWrapperInstance()
3122 {
3123 Reference<XWeak> xWeak= static_cast<XWeak*>( new UnoObjectWrapperRemoteOpt(
3124 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass));
3125 return Reference<XInterface>( xWeak, UNO_QUERY);
3126 }
3127
3128 COM_DECLSPEC_NOTHROW STDMETHODIMP UnoObjectWrapperRemoteOpt::GetIDsOfNames ( REFIID /*riid*/, LPOLESTR * rgszNames, UINT cNames,
3129 LCID /*lcid*/, DISPID * rgdispid )
3130 {
3131 MutexGuard guard( getBridgeMutex());
3132
3133 if( ! rgdispid)
3134 return E_POINTER;
3135 HRESULT ret = E_UNEXPECTED;
3136
3137 // _GetValueObject
3138 if( ! wcscmp( *rgszNames, JSCRIPT_VALUE_FUNC))
3139 {
3140 *rgdispid= DISPID_JSCRIPT_VALUE_FUNC;
3141 return S_OK;
3142 }
3143 else if( ! wcscmp( *rgszNames, GET_STRUCT_FUNC))
3144 {
3145 *rgdispid= DISPID_GET_STRUCT_FUNC;
3146 return S_OK;
3147 }
3148
3149 if (m_xInvocation.is() && (cNames > 0))
3150 {
3151 OUString name(o3tl::toU(rgszNames[0]));
3152 // has this name been determined as "bad"
3153 BadNameMap::iterator badIter= m_badNameMap.find( name);
3154 if( badIter == m_badNameMap.end() )
3155 {
3156 // name has not been bad before( member exists
3157 typedef NameToIdMap::iterator ITnames;
3158 pair< ITnames, bool > pair_id= m_nameToDispIdMap.emplace(name, m_currentId++);
3159 // new ID inserted ?
3160 if( pair_id.second )
3161 {// yes, now create MemberInfo and ad to IdToMemberInfoMap
3162 MemberInfo d(0, name);
3163 m_idToMemberInfoMap.emplace(m_currentId - 1, d);
3164 }
3165
3166 *rgdispid = pair_id.first->second;
3167 ret = S_OK;
3168 }
3169 else
3170 ret= DISP_E_UNKNOWNNAME;
3171 }
3172 return ret;
3173 }
3174
3175 COM_DECLSPEC_NOTHROW STDMETHODIMP UnoObjectWrapperRemoteOpt::Invoke ( DISPID dispidMember, REFIID /*riid*/, LCID /*lcid*/, WORD wFlags,
3176 DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo,
3177 UINT * puArgErr )
3178 {
3179 comphelper::Automation::AutomationInvokedZone aAutomationActive;
3180
3181 HRESULT ret = S_OK;
3182 try
3183 {
3184 bool bHandled= false;
3185 ret= InvokeGeneral( dispidMember, wFlags, pdispparams, pvarResult, pexcepinfo,
3186 puArgErr, bHandled);
3187 if( bHandled)
3188 return ret;
3189
3190 if ( dispidMember > 0 && m_xInvocation.is())
3191 {
3192
3193 IdToMemberInfoMap::iterator it_MemberInfo= m_idToMemberInfoMap.find( dispidMember);
3194 if( it_MemberInfo != m_idToMemberInfoMap.end() )
3195 {
3196 MemberInfo& info= it_MemberInfo->second;
3197
3198 Sequence<Any> params; // holds converted any s
3199 if( ! info.flags )
3200 { // DISPID called for the first time
3201 if( wFlags == DISPATCH_METHOD )
3202 {
3203 convertDispparamsArgs(dispidMember, wFlags, pdispparams, params );
3204
3205 if( FAILED( ret= doInvoke( pdispparams, pvarResult,
3206 pexcepinfo, puArgErr, info.name, params))
3207 && ret == DISP_E_MEMBERNOTFOUND)
3208 {
3209 // try to get the exact name
3210 OUString exactName;
3211 if (m_xExactName.is())
3212 {
3213 exactName = m_xExactName->getExactName( info.name);
3214 // invoke again
3215 if( !exactName.isEmpty() )
3216 {
3217 if( SUCCEEDED( ret= doInvoke( pdispparams, pvarResult,
3218 pexcepinfo, puArgErr, exactName, params)))
3219 info.name= exactName;
3220 }
3221 }
3222 }
3223 if( SUCCEEDED( ret ) )
3224 info.flags= DISPATCH_METHOD;
3225 }
3226 else if( wFlags == DISPATCH_PROPERTYPUT || wFlags == DISPATCH_PROPERTYPUTREF)
3227 {
3228 convertDispparamsArgs(dispidMember, wFlags, pdispparams, params );
3229 if( FAILED( ret= doSetProperty( pdispparams, pvarResult,
3230 pexcepinfo, puArgErr, info.name, params))
3231 && ret == DISP_E_MEMBERNOTFOUND)
3232 {
3233 // try to get the exact name
3234 OUString exactName;
3235 if (m_xExactName.is())
3236 {
3237 exactName = m_xExactName->getExactName( info.name);
3238 // invoke again
3239 if( !exactName.isEmpty() )
3240 {
3241 if( SUCCEEDED( ret= doSetProperty( pdispparams, pvarResult,
3242 pexcepinfo, puArgErr, exactName, params)))
3243 info.name= exactName;
3244 }
3245 }
3246 }
3247 if( SUCCEEDED( ret ) )
3248 info.flags= DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYGET;
3249 }
3250 else if( wFlags == DISPATCH_PROPERTYGET)
3251 {
3252 if( FAILED( ret= doGetProperty( pdispparams, pvarResult,
3253 pexcepinfo, info.name))
3254 && ret == DISP_E_MEMBERNOTFOUND)
3255 {
3256 // try to get the exact name
3257 OUString exactName;
3258 if (m_xExactName.is())
3259 {
3260 exactName = m_xExactName->getExactName( info.name);
3261 // invoke again
3262 if( !exactName.isEmpty() )
3263 {
3264 if( SUCCEEDED( ret= doGetProperty( pdispparams, pvarResult,
3265 pexcepinfo, exactName)))
3266 info.name= exactName;
3267 }
3268 }
3269 }
3270 if( SUCCEEDED( ret ) )
3271 info.flags= DISPATCH_PROPERTYGET | DISPATCH_PROPERTYPUT;
3272 }
3273 else if( wFlags & DISPATCH_METHOD &&
3274 (wFlags & DISPATCH_PROPERTYPUT || wFlags & DISPATCH_PROPERTYPUTREF))
3275 {
3276
3277 OUString exactName;
3278 // convert params for DISPATCH_METHOD or DISPATCH_PROPERTYPUT
3279 convertDispparamsArgs(dispidMember, wFlags, pdispparams, params );
3280 // try first as method
3281 if( FAILED( ret= doInvoke( pdispparams, pvarResult,
3282 pexcepinfo, puArgErr, info.name, params))
3283 && ret == DISP_E_MEMBERNOTFOUND)
3284 {
3285 // try to get the exact name
3286 if (m_xExactName.is())
3287 {
3288 exactName = m_xExactName->getExactName( info.name);
3289 // invoke again
3290 if( !exactName.isEmpty() )
3291 {
3292 if( SUCCEEDED( ret= doInvoke( pdispparams, pvarResult,
3293 pexcepinfo, puArgErr, exactName, params)))
3294 info.name= exactName;
3295 }
3296 }
3297 }
3298 if( SUCCEEDED( ret ) )
3299 info.flags= DISPATCH_METHOD;
3300
3301 // try as property
3302 if( FAILED( ret) && pdispparams->cArgs == 1)
3303 {
3304 if( FAILED( ret= doSetProperty( pdispparams, pvarResult,
3305 pexcepinfo, puArgErr, info.name, params))
3306 && ret == DISP_E_MEMBERNOTFOUND)
3307 {
3308 // try to get the exact name
3309 if( !exactName.isEmpty() )
3310 {
3311 if( SUCCEEDED( ret= doSetProperty( pdispparams, pvarResult,
3312 pexcepinfo, puArgErr, exactName, params)))
3313 info.name= exactName;
3314 }
3315 }
3316 if( SUCCEEDED( ret ) )
3317 info.flags= DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYGET;
3318 }
3319 }
3320 else if( wFlags & DISPATCH_METHOD && wFlags & DISPATCH_PROPERTYGET)
3321 {
3322 OUString exactName;
3323 convertDispparamsArgs(dispidMember, wFlags, pdispparams, params );
3324
3325 if( FAILED( ret= doInvoke( pdispparams, pvarResult,
3326 pexcepinfo, puArgErr, info.name, params))
3327 && ret == DISP_E_MEMBERNOTFOUND)
3328 {
3329 // try to get the exact name
3330 if (m_xExactName.is())
3331 {
3332 exactName = m_xExactName->getExactName( info.name);
3333 // invoke again
3334 if( !exactName.isEmpty() )
3335 {
3336 if( SUCCEEDED( ret= doInvoke( pdispparams, pvarResult,
3337 pexcepinfo, puArgErr, exactName, params)))
3338 info.name= exactName;
3339 }
3340 }
3341 }
3342 if( SUCCEEDED( ret ) )
3343 info.flags= DISPATCH_METHOD;
3344
3345 // try as property
3346 if( FAILED( ret) && pdispparams->cArgs == 1)
3347 {
3348 if( FAILED( ret= doGetProperty( pdispparams, pvarResult,
3349 pexcepinfo, info.name))
3350 && ret == DISP_E_MEMBERNOTFOUND)
3351 {
3352 if( !exactName.isEmpty() )
3353 {
3354 if( SUCCEEDED( ret= doSetProperty( pdispparams, pvarResult,
3355 pexcepinfo, puArgErr, exactName, params)))
3356 info.name= exactName;
3357 }
3358 }
3359 if( SUCCEEDED( ret ) )
3360 info.flags= DISPATCH_PROPERTYGET;
3361 }
3362 }
3363
3364 // update information about this member
3365 if( ret == DISP_E_MEMBERNOTFOUND)
3366 {
3367 // Remember the name as not existing
3368 // and remove the MemberInfo
3369 m_badNameMap[info.name]= false;
3370 m_idToMemberInfoMap.erase( it_MemberInfo);
3371 }
3372 } // if( ! info.flags )
3373 else // IdToMemberInfoMap contains a MemberInfo
3374 {
3375 if( wFlags & DISPATCH_METHOD && info.flags == DISPATCH_METHOD)
3376 {
3377 convertDispparamsArgs(dispidMember, wFlags, pdispparams, params );
3378 ret= doInvoke( pdispparams, pvarResult,
3379 pexcepinfo, puArgErr, info.name, params);
3380 }
3381 else if( (wFlags & DISPATCH_PROPERTYPUT || wFlags & DISPATCH_PROPERTYPUTREF ) &&
3382 info.flags & DISPATCH_PROPERTYPUT)
3383 {
3384 convertDispparamsArgs(dispidMember, wFlags, pdispparams, params );
3385 ret= doSetProperty( pdispparams, pvarResult,
3386 pexcepinfo, puArgErr, info.name, params);
3387 }
3388 else if( (wFlags & DISPATCH_PROPERTYGET) && ( info.flags & DISPATCH_PROPERTYGET))
3389 {
3390 ret= doGetProperty( pdispparams, pvarResult,
3391 pexcepinfo, info.name);
3392 }
3393 else
3394 {
3395 ret= DISP_E_MEMBERNOTFOUND;
3396 }
3397 }
3398 }// if( it_MemberInfo != m_idToMemberInfoMap.end() )
3399 else
3400 ret= DISP_E_MEMBERNOTFOUND;
3401 }
3402 }
3403 catch(const BridgeRuntimeError& e)
3404 {
3405 writeExcepinfo(pexcepinfo, e.message);
3406 ret = DISP_E_EXCEPTION;
3407 }
3408 catch(const Exception& e)
3409 {
3410 OUString message= "UnoObjectWrapperRemoteOpt::Invoke : \n" +
3411 e.Message;
3412 writeExcepinfo(pexcepinfo, message);
3413 ret = DISP_E_EXCEPTION;
3414 }
3415 catch(...)
3416 {
3417 OUString message= "UnoObjectWrapperRemoteOpt::Invoke : \n"
3418 "Unexpected exception";
3419 writeExcepinfo(pexcepinfo, message);
3420 ret = DISP_E_EXCEPTION;
3421 }
3422
3423 return ret;
3424 }
3425
3426 HRESULT UnoObjectWrapperRemoteOpt::methodInvoke( DISPID /*dispidMember*/, DISPPARAMS * /*pdispparams*/, VARIANT * /*pvarResult*/,
3427 EXCEPINFO * /*pexcepinfo*/, unsigned int * /*puArgErr*/, Sequence<Any> const &)
3428 {
3429 return S_OK;
3430 }
3431
3432 // The returned HRESULT is only appropriate for IDispatch::Invoke
3433 static HRESULT mapCannotConvertException(const CannotConvertException &e, unsigned int * puArgErr)
3434 {
3435 HRESULT ret;
3436 bool bWriteIndex= true;
3437
3438 switch ( e.Reason)
3439 {
3440 case FailReason::OUT_OF_RANGE:
3441 ret = DISP_E_OVERFLOW;
3442 break;
3443 case FailReason::IS_NOT_NUMBER:
3444 ret = DISP_E_TYPEMISMATCH;
3445 break;
3446 case FailReason::IS_NOT_ENUM:
3447 ret = DISP_E_TYPEMISMATCH;
3448 break;
3449 case FailReason::IS_NOT_BOOL:
3450 ret = DISP_E_TYPEMISMATCH;
3451 break;
3452 case FailReason::NO_SUCH_INTERFACE:
3453 ret = DISP_E_TYPEMISMATCH;
3454 break;
3455 case FailReason::SOURCE_IS_NO_DERIVED_TYPE:
3456 ret = DISP_E_TYPEMISMATCH;
3457 break;
3458 case FailReason::TYPE_NOT_SUPPORTED:
3459 ret = DISP_E_TYPEMISMATCH;
3460 break;
3461 case FailReason::INVALID:
3462 ret = DISP_E_TYPEMISMATCH;
3463 break;
3464 case FailReason::NO_DEFAULT_AVAILABLE:
3465 ret = DISP_E_BADPARAMCOUNT;
3466 break;
3467 case FailReason::UNKNOWN:
3468 ret = E_UNEXPECTED;
3469 break;
3470 default:
3471 ret = E_UNEXPECTED;
3472 bWriteIndex= false;
3473 break;
3474 }
3475
3476 if( bWriteIndex && puArgErr != nullptr)
3477 *puArgErr = e.ArgumentIndex;
3478 return ret;
3479 }
3480
3481 // The function maps the TypeClass of the any to VARTYPE: If
3482 // the Any contains STRUCT or INTERFACE then the return value
3483 // is VT_DISPATCH. The function is used from o2u_createUnoObjectWrapper
3484 // and the result is put into the constructor of the uno - wrapper
3485 // object. If a client asks the object for DISPID_VALUE and this
3486 // function returned VT_DISPATCH then the IDispatch of the same
3487 // object is being returned.
3488 // See InterfaceOleWrapper::Invoke, InterfaceOleWrapper::m_defaultValueType
3489 VARTYPE getVarType( const Any& value)
3490 {
3491 VARTYPE ret= VT_EMPTY;
3492
3493 switch ( value.getValueTypeClass())
3494 {
3495 case TypeClass_STRUCT: ret= VT_DISPATCH; break;
3496 case TypeClass_INTERFACE: ret= VT_DISPATCH; break;
3497 default: break;
3498 }
3499 return ret;
3500 }
3501
3502 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE