1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_extensions.hxx"
26 #include "ole2uno.hxx"
27 #include "rtl/ustrbuf.hxx"
28
29
30 #include "osl/diagnose.h"
31 #include "osl/doublecheckedlocking.h"
32 #include "osl/thread.h"
33
34 #include "boost/scoped_array.hpp"
35 #include <com/sun/star/script/FailReason.hpp>
36 #include <com/sun/star/beans/XMaterialHolder.hpp>
37 #include <com/sun/star/script/XTypeConverter.hpp>
38 #include <com/sun/star/script/FinishEngineEvent.hpp>
39 #include <com/sun/star/script/InterruptReason.hpp>
40 #include <com/sun/star/script/XEngineListener.hpp>
41 #include <com/sun/star/script/XDebugging.hpp>
42 #include <com/sun/star/script/XInvocation.hpp>
43 #include <com/sun/star/script/ContextInformation.hpp>
44 #include <com/sun/star/script/FinishReason.hpp>
45 #include <com/sun/star/script/XEngine.hpp>
46 #include <com/sun/star/script/InterruptEngineEvent.hpp>
47 #include <com/sun/star/script/XLibraryAccess.hpp>
48 #include <com/sun/star/bridge/ModelDependent.hpp>
49
50 #include "com/sun/star/bridge/oleautomation/NamedArgument.hpp"
51 #include "com/sun/star/bridge/oleautomation/PropertyPutArgument.hpp"
52
53 #include <typelib/typedescription.hxx>
54 #include <rtl/uuid.h>
55 #include <rtl/memory.h>
56 #include <rtl/ustring.hxx>
57
58 #include "jscriptclasses.hxx"
59
60 #include "oleobjw.hxx"
61 #include "unoobjw.hxx"
62 #include <stdio.h>
63 using namespace std;
64 using namespace boost;
65 using namespace osl;
66 using namespace rtl;
67 using namespace cppu;
68 using namespace com::sun::star::script;
69 using namespace com::sun::star::lang;
70 using namespace com::sun::star::bridge;
71 using namespace com::sun::star::bridge::oleautomation;
72 using namespace com::sun::star::bridge::ModelDependent;
73 using namespace ::com::sun::star;
74
75 #define JSCRIPT_ID_PROPERTY L"_environment"
76 #define JSCRIPT_ID L"jscript"
77 namespace ole_adapter
78 {
79
80
81 // key: XInterface pointer created by Invocation Adapter Factory
82 // value: XInterface pointer to the wrapper class.
83 // Entries to the map are made within
84 // Any createOleObjectWrapper(IUnknown* pUnknown, const Type& aType);
85 // Entries are being deleted if the wrapper class's destructor has been
86 // called.
87 // Before UNO object is wrapped to COM object this map is checked
88 // to see if the UNO object is already a wrapper.
89 hash_map<sal_uInt32, sal_uInt32> AdapterToWrapperMap;
90 // key: XInterface of the wrapper object.
91 // value: XInterface of the Interface created by the Invocation Adapter Factory.
92 // A COM wrapper is responsible for removing the corresponding entry
93 // in AdapterToWrappperMap if it is being destroyed. Because the wrapper does not
94 // know about its adapted interface it uses WrapperToAdapterMap to get the
95 // adapted interface which is then used to locate the entry in AdapterToWrapperMap.
96 hash_map<sal_uInt32,sal_uInt32> WrapperToAdapterMap;
97
98 hash_map<sal_uInt32, WeakReference<XInterface> > ComPtrToWrapperMap;
99 /*****************************************************************************
100
101 class implementation IUnknownWrapper_Impl
102
103 *****************************************************************************/
104
IUnknownWrapper_Impl(Reference<XMultiServiceFactory> & xFactory,sal_uInt8 unoWrapperClass,sal_uInt8 comWrapperClass)105 IUnknownWrapper_Impl::IUnknownWrapper_Impl( Reference<XMultiServiceFactory>& xFactory,
106 sal_uInt8 unoWrapperClass, sal_uInt8 comWrapperClass):
107 UnoConversionUtilities<IUnknownWrapper_Impl>( xFactory, unoWrapperClass, comWrapperClass),
108 m_pxIdlClass( NULL), m_eJScript( JScriptUndefined),
109 m_bComTlbIndexInit(false), m_bHasDfltMethod(false), m_bHasDfltProperty(false)
110 {
111 }
112
113
~IUnknownWrapper_Impl()114 IUnknownWrapper_Impl::~IUnknownWrapper_Impl()
115 {
116 o2u_attachCurrentThread();
117 MutexGuard guard(getBridgeMutex());
118 XInterface * xIntRoot = (OWeakObject *)this;
119 #if OSL_DEBUG_LEVEL > 0
120 acquire(); // make sure we don't delete us twice because of Reference
121 OSL_ASSERT( Reference<XInterface>( static_cast<XWeak*>(this), UNO_QUERY).get() == xIntRoot );
122 #endif
123
124 // remove entries in global maps
125 typedef hash_map<sal_uInt32, sal_uInt32>::iterator _IT;
126 _IT it= WrapperToAdapterMap.find( (sal_uInt32) xIntRoot);
127 if( it != WrapperToAdapterMap.end())
128 {
129 sal_uInt32 adapter= it->second;
130
131 AdapterToWrapperMap.erase( adapter);
132 WrapperToAdapterMap.erase( it);
133 }
134
135 IT_Com it_c= ComPtrToWrapperMap.find( (sal_uInt32) m_spUnknown.p);
136 if(it_c != ComPtrToWrapperMap.end())
137 ComPtrToWrapperMap.erase(it_c);
138
139 #if OSL_DEBUG_LEVEL > 0
140 fprintf(stderr,"[automation bridge] ComPtrToWrapperMap contains: %i \n",
141 ComPtrToWrapperMap.size());
142 #endif
143 }
144
queryInterface(const Type & t)145 Any IUnknownWrapper_Impl::queryInterface(const Type& t)
146 throw (RuntimeException)
147 {
148 if (t == getCppuType(static_cast<Reference<XDefaultMethod>*>( 0)) && !m_bHasDfltMethod )
149 return Any();
150 if (t == getCppuType(static_cast<Reference<XDefaultProperty>*>( 0)) && !m_bHasDfltProperty )
151 return Any();
152 if (t == getCppuType(static_cast<Reference<XInvocation>*>( 0)) && !m_spDispatch)
153 return Any();
154
155 return WeakImplHelper7<XInvocation, XBridgeSupplier2,
156 XInitialization, XAutomationObject, XDefaultProperty, XDefaultMethod, XDirectInvocation>::queryInterface(t);
157 }
158
getIntrospection(void)159 Reference<XIntrospectionAccess> SAL_CALL IUnknownWrapper_Impl::getIntrospection(void)
160 throw (RuntimeException )
161 {
162 Reference<XIntrospectionAccess> ret;
163
164 return ret;
165 }
166
167
168
invoke(const OUString & aFunctionName,const Sequence<Any> & aParams,Sequence<sal_Int16> & aOutParamIndex,Sequence<Any> & aOutParam)169 Any SAL_CALL IUnknownWrapper_Impl::invoke( const OUString& aFunctionName,
170 const Sequence< Any >& aParams, Sequence< sal_Int16 >& aOutParamIndex,
171 Sequence< Any >& aOutParam )
172 throw(IllegalArgumentException, CannotConvertException, InvocationTargetException,
173 RuntimeException)
174 {
175 if ( ! m_spDispatch )
176 {
177 throw RuntimeException(
178 OUSTR("[automation bridge] The object does not have an IDispatch interface"),
179 Reference<XInterface>());
180 }
181
182 Any ret;
183
184 try
185 {
186 o2u_attachCurrentThread();
187
188 TypeDescription methodDesc;
189 getMethodInfo(aFunctionName, methodDesc);
190 if( methodDesc.is())
191 {
192 ret = invokeWithDispIdUnoTlb(aFunctionName,
193 aParams,
194 aOutParamIndex,
195 aOutParam);
196 }
197 else
198 {
199 ret= invokeWithDispIdComTlb( aFunctionName,
200 aParams,
201 aOutParamIndex,
202 aOutParam);
203 }
204 }
205 catch (IllegalArgumentException &)
206 {
207 throw;
208 }
209 catch (CannotConvertException &)
210 {
211 throw;
212 }
213 catch (BridgeRuntimeError & e)
214 {
215 throw RuntimeException(e.message, Reference<XInterface>());
216 }
217 catch (Exception & e)
218 {
219 throw RuntimeException(OUSTR("[automation bridge] unexpected exception in "
220 "IUnknownWrapper_Impl::invoke ! Message : \n") +
221 e.Message, Reference<XInterface>());
222
223 }
224 catch(...)
225 {
226 throw RuntimeException(
227 OUSTR("[automation bridge] unexpected exception in "
228 "IUnknownWrapper_Impl::Invoke !"), Reference<XInterface>());
229 }
230 return ret;
231 }
232
setValue(const OUString & aPropertyName,const Any & aValue)233 void SAL_CALL IUnknownWrapper_Impl::setValue( const OUString& aPropertyName,
234 const Any& aValue )
235 throw(UnknownPropertyException, CannotConvertException, InvocationTargetException,
236 RuntimeException)
237 {
238 if ( ! m_spDispatch )
239 {
240 throw RuntimeException(
241 OUSTR("[automation bridge] The object does not have an IDispatch interface"),
242 Reference<XInterface>());
243 }
244 try
245 {
246 o2u_attachCurrentThread();
247
248 ITypeInfo * pInfo = getTypeInfo();
249 FuncDesc aDescGet(pInfo);
250 FuncDesc aDescPut(pInfo);
251 VarDesc aVarDesc(pInfo);
252 getPropDesc(aPropertyName, & aDescGet, & aDescPut, & aVarDesc);
253 //check if there is such a property at all or if it is read only
254 if ( ! aDescPut && ! aDescGet && ! aVarDesc)
255 {
256 OUString msg(OUSTR("[automation bridge]Property \"") + aPropertyName +
257 OUSTR("\" is not supported"));
258 throw UnknownPropertyException(msg, Reference<XInterface>());
259 }
260
261 if ( (! aDescPut && aDescGet) || aVarDesc
262 && aVarDesc->wVarFlags == VARFLAG_FREADONLY )
263 {
264 //read-only
265 OUString msg(OUSTR("[automation bridge] Property ") + aPropertyName +
266 OUSTR(" is read-only"));
267 OString sMsg = OUStringToOString(msg, osl_getThreadTextEncoding());
268 OSL_ENSURE(0, sMsg.getStr());
269 // ignore silently
270 return;
271 }
272
273 HRESULT hr= S_OK;
274 DISPPARAMS dispparams;
275 CComVariant varArg;
276 CComVariant varRefArg;
277 CComVariant varResult;
278 ExcepInfo excepinfo;
279 unsigned int uArgErr;
280
281 // converting UNO value to OLE variant
282 DISPID dispidPut= DISPID_PROPERTYPUT;
283 dispparams.rgdispidNamedArgs = &dispidPut;
284 dispparams.cArgs = 1;
285 dispparams.cNamedArgs = 1;
286 dispparams.rgvarg = & varArg;
287
288 OSL_ASSERT(aDescPut || aVarDesc);
289
290 VARTYPE vt = 0;
291 DISPID dispid = 0;
292 INVOKEKIND invkind = INVOKE_PROPERTYPUT;
293 //determine the expected type, dispid, invoke kind (DISPATCH_PROPERTYPUT,
294 //DISPATCH_PROPERTYPUTREF)
295 if (aDescPut)
296 {
297 vt = getElementTypeDesc(& aDescPut->lprgelemdescParam[0].tdesc);
298 dispid = aDescPut->memid;
299 invkind = aDescPut->invkind;
300 }
301 else
302 {
303 vt = getElementTypeDesc( & aVarDesc->elemdescVar.tdesc);
304 dispid = aVarDesc->memid;
305 if (vt == VT_UNKNOWN || vt == VT_DISPATCH ||
306 (vt & VT_ARRAY) || (vt & VT_BYREF))
307 {
308 invkind = INVOKE_PROPERTYPUTREF;
309 }
310 }
311
312 // convert the uno argument
313 if (vt & VT_BYREF)
314 {
315 anyToVariant( & varRefArg, aValue, ::sal::static_int_cast< VARTYPE, int >( vt ^ VT_BYREF ) );
316 varArg.vt = vt;
317 if( (vt & VT_TYPEMASK) == VT_VARIANT)
318 varArg.byref = & varRefArg;
319 else if ((vt & VT_TYPEMASK) == VT_DECIMAL)
320 varArg.byref = & varRefArg.decVal;
321 else
322 varArg.byref = & varRefArg.byref;
323 }
324 else
325 {
326 anyToVariant(& varArg, aValue, vt);
327 }
328 // call to IDispatch
329 hr = m_spDispatch->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, ::sal::static_int_cast< WORD, INVOKEKIND >( invkind ),
330 &dispparams, & varResult, & excepinfo, &uArgErr);
331
332 // lookup error code
333 switch (hr)
334 {
335 case S_OK:
336 break;
337 case DISP_E_BADPARAMCOUNT:
338 throw RuntimeException();
339 break;
340 case DISP_E_BADVARTYPE:
341 throw RuntimeException();
342 break;
343 case DISP_E_EXCEPTION:
344 throw InvocationTargetException();
345 break;
346 case DISP_E_MEMBERNOTFOUND:
347 throw UnknownPropertyException();
348 break;
349 case DISP_E_NONAMEDARGS:
350 throw RuntimeException();
351 break;
352 case DISP_E_OVERFLOW:
353 throw CannotConvertException(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("call to OLE object failed")), static_cast<XInterface*>(
354 static_cast<XWeak*>(this)), TypeClass_UNKNOWN, FailReason::OUT_OF_RANGE, uArgErr);
355 break;
356 case DISP_E_PARAMNOTFOUND:
357 throw IllegalArgumentException(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("call to OLE object failed")), static_cast<XInterface*>(
358 static_cast<XWeak*>(this)), ::sal::static_int_cast< sal_Int16, unsigned int >( uArgErr )) ;
359 break;
360 case DISP_E_TYPEMISMATCH:
361 throw CannotConvertException(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("call to OLE object failed")), static_cast<XInterface*>(
362 static_cast<XWeak*>(this)), TypeClass_UNKNOWN, FailReason::UNKNOWN, ::sal::static_int_cast< sal_Int16, unsigned int >( uArgErr ));
363 break;
364 case DISP_E_UNKNOWNINTERFACE:
365 throw RuntimeException();
366 break;
367 case DISP_E_UNKNOWNLCID:
368 throw RuntimeException();
369 break;
370 case DISP_E_PARAMNOTOPTIONAL:
371 throw CannotConvertException(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("call to OLE object failed")),static_cast<XInterface*>(
372 static_cast<XWeak*>(this)) , TypeClass_UNKNOWN, FailReason::NO_DEFAULT_AVAILABLE, uArgErr);
373 break;
374 default:
375 throw RuntimeException();
376 break;
377 }
378 }
379 catch (CannotConvertException &)
380 {
381 throw;
382 }
383 catch (UnknownPropertyException &)
384 {
385 throw;
386 }
387 catch (BridgeRuntimeError& e)
388 {
389 throw RuntimeException(
390 e.message, Reference<XInterface>());
391 }
392 catch (Exception & e)
393 {
394 throw RuntimeException(OUSTR("[automation bridge] unexpected exception in "
395 "IUnknownWrapper_Impl::setValue ! Message : \n") +
396 e.Message, Reference<XInterface>());
397
398 }
399 catch (...)
400 {
401 throw RuntimeException(
402 OUSTR("[automation bridge] unexpected exception in "
403 "IUnknownWrapper_Impl::setValue !"), Reference<XInterface>());
404 }
405 }
406
getValue(const OUString & aPropertyName)407 Any SAL_CALL IUnknownWrapper_Impl::getValue( const OUString& aPropertyName )
408 throw(UnknownPropertyException, RuntimeException)
409 {
410 if ( ! m_spDispatch )
411 {
412 throw RuntimeException(
413 OUSTR("[automation bridge] The object does not have an IDispatch interface"),
414 Reference<XInterface>());
415 }
416 Any ret;
417 try
418 {
419 o2u_attachCurrentThread();
420 ITypeInfo * pInfo = getTypeInfo();
421 // I was going to implement an XServiceInfo interface to allow the type
422 // of the automation object to be exposed.. but it seems
423 // from looking at comments in the code that it is possible for
424 // this object to actually wrap an UNO object ( I guess if automation is
425 // used from MSO to create Openoffice objects ) Therefore, those objects
426 // will more than likely already have their own XServiceInfo interface.
427 // Instead here I chose a name that should be illegal both in COM and
428 // UNO ( from an IDL point of view ) therefore I think this is a safe
429 // hack
430 if ( aPropertyName.equals( rtl::OUString::createFromAscii("$GetTypeName") ))
431 {
432 if ( pInfo && m_sTypeName.getLength() == 0 )
433 {
434 m_sTypeName = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("IDispatch") );
435 CComBSTR sName;
436
437 if ( SUCCEEDED( pInfo->GetDocumentation( -1, &sName, NULL, NULL, NULL ) ) )
438 {
439 rtl::OUString sTmp( reinterpret_cast<const sal_Unicode*>(LPCOLESTR(sName)));
440 if ( sTmp.indexOf('_') == 0 )
441 sTmp = sTmp.copy(1);
442 // do we own the memory for pTypeLib, msdn doco is vague
443 // I'll assume we do
444 CComPtr< ITypeLib > pTypeLib;
445 unsigned int index;
446 if ( SUCCEEDED( pInfo->GetContainingTypeLib( &pTypeLib.p, &index )) )
447 {
448 if ( SUCCEEDED( pTypeLib->GetDocumentation( -1, &sName, NULL, NULL, NULL ) ) )
449 {
450 rtl::OUString sLibName( reinterpret_cast<const sal_Unicode*>(LPCOLESTR(sName)));
451 m_sTypeName = sLibName.concat( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(".") ) ).concat( sTmp );
452
453 }
454 }
455 }
456
457 }
458 ret <<= m_sTypeName;
459 return ret;
460 }
461 FuncDesc aDescGet(pInfo);
462 FuncDesc aDescPut(pInfo);
463 VarDesc aVarDesc(pInfo);
464 getPropDesc(aPropertyName, & aDescGet, & aDescPut, & aVarDesc);
465 if ( ! aDescGet && ! aDescPut && ! aVarDesc)
466 {
467 //property not found
468 OUString msg(OUSTR("[automation bridge]Property \"") + aPropertyName +
469 OUSTR("\" is not supported"));
470 throw UnknownPropertyException(msg, Reference<XInterface>());
471 }
472 // write-only should not be possible
473 OSL_ASSERT( aDescGet || ! aDescPut);
474
475 HRESULT hr;
476 DISPPARAMS dispparams = {0, 0, 0, 0};
477 CComVariant varResult;
478 ExcepInfo excepinfo;
479 unsigned int uArgErr;
480 DISPID dispid;
481 if (aDescGet)
482 dispid = aDescGet->memid;
483 else if (aVarDesc)
484 dispid = aVarDesc->memid;
485 else
486 dispid = aDescPut->memid;
487
488 hr = m_spDispatch->Invoke(dispid,
489 IID_NULL,
490 LOCALE_USER_DEFAULT,
491 DISPATCH_PROPERTYGET,
492 &dispparams,
493 &varResult,
494 &excepinfo,
495 &uArgErr);
496
497 // converting return value and out parameter back to UNO
498 if (hr == S_OK)
499 {
500 // If the com object implements uno interfaces then we have
501 // to convert the attribute into the expected type.
502 TypeDescription attrInfo;
503 getAttributeInfo(aPropertyName, attrInfo);
504 if( attrInfo.is() )
505 variantToAny( &varResult, ret, Type( attrInfo.get()->pWeakRef));
506 else
507 variantToAny(&varResult, ret);
508 }
509
510 // lookup error code
511 switch (hr)
512 {
513 case S_OK:
514 break;
515 case DISP_E_BADPARAMCOUNT:
516 throw RuntimeException(OUString(reinterpret_cast<const sal_Unicode*>(excepinfo.bstrDescription)),
517 Reference<XInterface>());
518 break;
519 case DISP_E_BADVARTYPE:
520 throw RuntimeException(OUString(reinterpret_cast<const sal_Unicode*>(excepinfo.bstrDescription)),
521 Reference<XInterface>());
522 break;
523 case DISP_E_EXCEPTION:
524 throw RuntimeException(OUString(reinterpret_cast<const sal_Unicode*>(excepinfo.bstrDescription)),
525 Reference<XInterface>());
526 break;
527 case DISP_E_MEMBERNOTFOUND:
528 throw UnknownPropertyException(OUString(reinterpret_cast<const sal_Unicode*>(excepinfo.bstrDescription)),
529 Reference<XInterface>());
530 break;
531 case DISP_E_NONAMEDARGS:
532 throw RuntimeException(OUString(reinterpret_cast<const sal_Unicode*>(excepinfo.bstrDescription)),
533 Reference<XInterface>());
534 break;
535 case DISP_E_OVERFLOW:
536 throw RuntimeException(OUString(reinterpret_cast<const sal_Unicode*>(excepinfo.bstrDescription)),
537 Reference<XInterface>());
538 break;
539 case DISP_E_PARAMNOTFOUND:
540 throw RuntimeException(OUString(reinterpret_cast<const sal_Unicode*>(excepinfo.bstrDescription)),
541 Reference<XInterface>());
542 break;
543 case DISP_E_TYPEMISMATCH:
544 throw RuntimeException(OUString(reinterpret_cast<const sal_Unicode*>(excepinfo.bstrDescription)),
545 Reference<XInterface>());
546 break;
547 case DISP_E_UNKNOWNINTERFACE:
548 throw RuntimeException(OUString(reinterpret_cast<const sal_Unicode*>(excepinfo.bstrDescription)),
549 Reference<XInterface>());
550 break;
551 case DISP_E_UNKNOWNLCID:
552 throw RuntimeException(OUString(reinterpret_cast<const sal_Unicode*>(excepinfo.bstrDescription)),
553 Reference<XInterface>());
554 break;
555 case DISP_E_PARAMNOTOPTIONAL:
556 throw RuntimeException(OUString(reinterpret_cast<const sal_Unicode*>(excepinfo.bstrDescription)),
557 Reference<XInterface>());
558 break;
559 default:
560 throw RuntimeException(OUString(reinterpret_cast<const sal_Unicode*>(excepinfo.bstrDescription)),
561 Reference<XInterface>());
562 break;
563 }
564 }
565 catch (UnknownPropertyException& )
566 {
567 throw;
568 }
569 catch (BridgeRuntimeError& e)
570 {
571 throw RuntimeException(
572 e.message, Reference<XInterface>());
573 }
574 catch (Exception & e)
575 {
576 throw RuntimeException(OUSTR("[automation bridge] unexpected exception in "
577 "IUnknownWrapper_Impl::getValue ! Message : \n") +
578 e.Message, Reference<XInterface>());
579 }
580 catch (...)
581 {
582 throw RuntimeException(
583 OUSTR("[automation bridge] unexpected exception in "
584 "IUnknownWrapper_Impl::getValue !"), Reference<XInterface>());
585 }
586 return ret;
587 }
588
hasMethod(const OUString & aName)589 sal_Bool SAL_CALL IUnknownWrapper_Impl::hasMethod( const OUString& aName )
590 throw(RuntimeException)
591 {
592 if ( ! m_spDispatch )
593 {
594 throw RuntimeException(
595 OUSTR("[automation bridge] The object does not have an IDispatch interface"),
596 Reference<XInterface>());
597 }
598 sal_Bool ret = sal_False;
599
600 try
601 {
602 o2u_attachCurrentThread();
603 ITypeInfo* pInfo = getTypeInfo();
604 FuncDesc aDesc(pInfo);
605 getFuncDesc(aName, & aDesc);
606 // Automation properties can have arguments. Those are treated as methods and
607 //are called through XInvocation::invoke.
608 if ( ! aDesc)
609 {
610 FuncDesc aDescGet(pInfo);
611 FuncDesc aDescPut(pInfo);
612 VarDesc aVarDesc(pInfo);
613 getPropDesc( aName, & aDescGet, & aDescPut, & aVarDesc);
614 if (aDescGet && aDescGet->cParams > 0
615 || aDescPut && aDescPut->cParams > 0)
616 ret = sal_True;
617 }
618 else
619 ret = sal_True;
620 }
621 catch (BridgeRuntimeError& e)
622 {
623 throw RuntimeException(e.message, Reference<XInterface>());
624 }
625 catch (Exception & e)
626 {
627 throw RuntimeException(OUSTR("[automation bridge] unexpected exception in "
628 "IUnknownWrapper_Impl::hasMethod ! Message : \n") +
629 e.Message, Reference<XInterface>());
630 }
631 catch (...)
632 {
633 throw RuntimeException(OUSTR("[automation bridge] unexpected exception in "
634 "IUnknownWrapper_Impl::hasMethod !"), Reference<XInterface>());;
635 }
636 return ret;
637 }
638
hasProperty(const OUString & aName)639 sal_Bool SAL_CALL IUnknownWrapper_Impl::hasProperty( const OUString& aName )
640 throw(RuntimeException)
641 {
642 if ( ! m_spDispatch )
643 {
644 throw RuntimeException(OUSTR("[automation bridge] The object does not have an "
645 "IDispatch interface"), Reference<XInterface>());
646 return sal_False;
647 }
648 sal_Bool ret = sal_False;
649 try
650 {
651 o2u_attachCurrentThread();
652
653 ITypeInfo * pInfo = getTypeInfo();
654 FuncDesc aDescGet(pInfo);
655 FuncDesc aDescPut(pInfo);
656 VarDesc aVarDesc(pInfo);
657 getPropDesc(aName, & aDescGet, & aDescPut, & aVarDesc);
658 // Automation properties can have parameters. If so, we access them through
659 // XInvocation::invoke. Thas is, hasProperty must return false for such a
660 // property
661 if (aVarDesc
662 || aDescPut && aDescPut->cParams == 0
663 || aDescGet && aDescGet->cParams == 0)
664 {
665 ret = sal_True;
666 }
667 }
668 catch (BridgeRuntimeError& e)
669 {
670 throw RuntimeException(e.message, Reference<XInterface>());
671 }
672 catch (Exception & e)
673 {
674 throw RuntimeException(OUSTR("[automation bridge] unexpected exception in "
675 "IUnknownWrapper_Impl::hasProperty ! Message : \n") +
676 e.Message, Reference<XInterface>());
677
678 }
679 catch (...)
680 {
681 throw RuntimeException(OUSTR("[automation bridge] unexpected exception in "
682 "IUnknownWrapper_Impl::hasProperty !"), Reference<XInterface>());
683 }
684 return ret;
685 }
686
createBridge(const Any & modelDepObject,const Sequence<sal_Int8> &,sal_Int16 sourceModelType,sal_Int16 destModelType)687 Any SAL_CALL IUnknownWrapper_Impl::createBridge( const Any& modelDepObject,
688 const Sequence< sal_Int8 >& /*aProcessId*/, sal_Int16 sourceModelType,
689 sal_Int16 destModelType )
690 throw( IllegalArgumentException, RuntimeException)
691 {
692 Any ret;
693 o2u_attachCurrentThread();
694
695 if (
696 (sourceModelType == UNO) &&
697 (destModelType == OLE) &&
698 (modelDepObject.getValueTypeClass() == TypeClass_INTERFACE)
699 )
700 {
701 Reference<XInterface> xInt( *(XInterface**) modelDepObject.getValue());
702 Reference<XInterface> xSelf( (OWeakObject*)this);
703
704 if (xInt == xSelf)
705 {
706 VARIANT* pVariant = (VARIANT*) CoTaskMemAlloc(sizeof(VARIANT));
707
708 VariantInit(pVariant);
709 if (m_bOriginalDispatch == sal_True)
710 {
711 pVariant->vt = VT_DISPATCH;
712 pVariant->pdispVal = m_spDispatch;
713 pVariant->pdispVal->AddRef();
714 }
715 else
716 {
717 pVariant->vt = VT_UNKNOWN;
718 pVariant->punkVal = m_spUnknown;
719 pVariant->punkVal->AddRef();
720 }
721
722 ret.setValue((void*)&pVariant, getCppuType( (sal_uInt32*) 0));
723 }
724 }
725
726 return ret;
727 }
728 /** @internal
729 @exception IllegalArgumentException
730 @exception CannotConvertException
731 @exception InvocationTargetException
732 @RuntimeException
733 */
invokeWithDispIdUnoTlb(const OUString & sFunctionName,const Sequence<Any> & Params,Sequence<sal_Int16> & OutParamIndex,Sequence<Any> & OutParam)734 Any IUnknownWrapper_Impl::invokeWithDispIdUnoTlb(const OUString& sFunctionName,
735 const Sequence< Any >& Params,
736 Sequence< sal_Int16 >& OutParamIndex,
737 Sequence< Any >& OutParam)
738 {
739 Any ret;
740 HRESULT hr= S_OK;
741
742 sal_Int32 parameterCount= Params.getLength();
743 sal_Int32 outParameterCount= 0;
744 typelib_InterfaceMethodTypeDescription* pMethod= NULL;
745 TypeDescription methodDesc;
746 getMethodInfo(sFunctionName, methodDesc);
747
748 // We need to know whether the IDispatch is from a JScript object.
749 // Then out and in/out parameters have to be treated differently than
750 // with common COM objects.
751 sal_Bool bJScriptObject= isJScriptObject();
752 scoped_array<CComVariant> sarParams;
753 scoped_array<CComVariant> sarParamsRef;
754 CComVariant *pVarParams= NULL;
755 CComVariant *pVarParamsRef= NULL;
756 sal_Bool bConvRet= sal_True;
757
758 if( methodDesc.is())
759 {
760 pMethod = (typelib_InterfaceMethodTypeDescription* )methodDesc.get();
761 parameterCount = pMethod->nParams;
762 // Create the Array for the array being passed in DISPPARAMS
763 // the array also contains the outparameter (but not the values)
764 if( pMethod->nParams > 0)
765 {
766 sarParams.reset(new CComVariant[ parameterCount]);
767 pVarParams = sarParams.get();
768 }
769
770 // Create the Array for the out an in/out parameter. These values
771 // are referenced by the VT_BYREF VARIANTs in DISPPARAMS.
772 // We need to find out the number of out and in/out parameter.
773 for( sal_Int32 i=0; i < parameterCount; i++)
774 {
775 if( pMethod->pParams[i].bOut)
776 outParameterCount++;
777 }
778
779 if( !bJScriptObject)
780 {
781 sarParamsRef.reset(new CComVariant[outParameterCount]);
782 pVarParamsRef = sarParamsRef.get();
783 // build up the parameters for IDispatch::Invoke
784 sal_Int32 outParamIndex=0;
785 int i = 0;
786 try
787 {
788 for( i= 0; i < parameterCount; i++)
789 {
790 // In parameter
791 if( pMethod->pParams[i].bIn == sal_True && ! pMethod->pParams[i].bOut)
792 {
793 anyToVariant( &pVarParams[parameterCount - i -1], Params.getConstArray()[i]);
794 }
795 // Out parameter + in/out parameter
796 else if( pMethod->pParams[i].bOut == sal_True)
797 {
798 CComVariant var;
799 if(pMethod->pParams[i].bIn)
800 {
801 anyToVariant( & var,Params[i]);
802 pVarParamsRef[outParamIndex] = var;
803 }
804
805 switch( pMethod->pParams[i].pTypeRef->eTypeClass)
806 {
807 case TypeClass_INTERFACE:
808 case TypeClass_STRUCT:
809 if( ! pMethod->pParams[i].bIn)
810 {
811 pVarParamsRef[ outParamIndex].vt= VT_DISPATCH;
812 pVarParamsRef[ outParamIndex].pdispVal= 0;
813 }
814 pVarParams[parameterCount - i -1].vt = VT_DISPATCH | VT_BYREF;
815 pVarParams[parameterCount - i -1].ppdispVal= &pVarParamsRef[outParamIndex].pdispVal;
816 break;
817 case TypeClass_ENUM:
818 case TypeClass_LONG:
819 case TypeClass_UNSIGNED_LONG:
820 if( ! pMethod->pParams[i].bIn)
821 {
822 pVarParamsRef[ outParamIndex].vt = VT_I4;
823 pVarParamsRef[ outParamIndex].lVal = 0;
824 }
825 pVarParams[parameterCount - i -1].vt = VT_I4 | VT_BYREF;
826 pVarParams[parameterCount - i -1].plVal= &pVarParamsRef[outParamIndex].lVal;
827 break;
828 case TypeClass_SEQUENCE:
829 if( ! pMethod->pParams[i].bIn)
830 {
831 pVarParamsRef[ outParamIndex].vt = VT_ARRAY| VT_VARIANT;
832 pVarParamsRef[ outParamIndex].parray= NULL;
833 }
834 pVarParams[parameterCount - i -1].vt = VT_ARRAY| VT_BYREF | VT_VARIANT;
835 pVarParams[parameterCount - i -1].pparray= &pVarParamsRef[outParamIndex].parray;
836 break;
837 case TypeClass_ANY:
838 if( ! pMethod->pParams[i].bIn)
839 {
840 pVarParamsRef[ outParamIndex].vt = VT_EMPTY;
841 pVarParamsRef[ outParamIndex].lVal = 0;
842 }
843 pVarParams[parameterCount - i -1].vt = VT_VARIANT | VT_BYREF;
844 pVarParams[parameterCount - i -1].pvarVal = &pVarParamsRef[outParamIndex];
845 break;
846 case TypeClass_BOOLEAN:
847 if( ! pMethod->pParams[i].bIn)
848 {
849 pVarParamsRef[ outParamIndex].vt = VT_BOOL;
850 pVarParamsRef[ outParamIndex].boolVal = 0;
851 }
852 pVarParams[parameterCount - i -1].vt = VT_BOOL| VT_BYREF;
853 pVarParams[parameterCount - i -1].pboolVal =
854 & pVarParamsRef[outParamIndex].boolVal;
855 break;
856
857 case TypeClass_STRING:
858 if( ! pMethod->pParams[i].bIn)
859 {
860 pVarParamsRef[ outParamIndex].vt = VT_BSTR;
861 pVarParamsRef[ outParamIndex].bstrVal= 0;
862 }
863 pVarParams[parameterCount - i -1].vt = VT_BSTR| VT_BYREF;
864 pVarParams[parameterCount - i -1].pbstrVal=
865 & pVarParamsRef[outParamIndex].bstrVal;
866 break;
867
868 case TypeClass_FLOAT:
869 if( ! pMethod->pParams[i].bIn)
870 {
871 pVarParamsRef[ outParamIndex].vt = VT_R4;
872 pVarParamsRef[ outParamIndex].fltVal= 0;
873 }
874 pVarParams[parameterCount - i -1].vt = VT_R4| VT_BYREF;
875 pVarParams[parameterCount - i -1].pfltVal =
876 & pVarParamsRef[outParamIndex].fltVal;
877 break;
878 case TypeClass_DOUBLE:
879 if( ! pMethod->pParams[i].bIn)
880 {
881 pVarParamsRef[ outParamIndex].vt = VT_R8;
882 pVarParamsRef[ outParamIndex].dblVal= 0;
883 }
884 pVarParams[parameterCount - i -1].vt = VT_R8| VT_BYREF;
885 pVarParams[parameterCount - i -1].pdblVal=
886 & pVarParamsRef[outParamIndex].dblVal;
887 break;
888 case TypeClass_BYTE:
889 if( ! pMethod->pParams[i].bIn)
890 {
891 pVarParamsRef[ outParamIndex].vt = VT_UI1;
892 pVarParamsRef[ outParamIndex].bVal= 0;
893 }
894 pVarParams[parameterCount - i -1].vt = VT_UI1| VT_BYREF;
895 pVarParams[parameterCount - i -1].pbVal=
896 & pVarParamsRef[outParamIndex].bVal;
897 break;
898 case TypeClass_CHAR:
899 case TypeClass_SHORT:
900 case TypeClass_UNSIGNED_SHORT:
901 if( ! pMethod->pParams[i].bIn)
902 {
903 pVarParamsRef[ outParamIndex].vt = VT_I2;
904 pVarParamsRef[ outParamIndex].iVal = 0;
905 }
906 pVarParams[parameterCount - i -1].vt = VT_I2| VT_BYREF;
907 pVarParams[parameterCount - i -1].piVal=
908 & pVarParamsRef[outParamIndex].iVal;
909 break;
910
911 default:
912 if( ! pMethod->pParams[i].bIn)
913 {
914 pVarParamsRef[ outParamIndex].vt = VT_EMPTY;
915 pVarParamsRef[ outParamIndex].lVal = 0;
916 }
917 pVarParams[parameterCount - i -1].vt = VT_VARIANT | VT_BYREF;
918 pVarParams[parameterCount - i -1].pvarVal =
919 & pVarParamsRef[outParamIndex];
920 }
921 outParamIndex++;
922 } // end else if
923 } // end for
924 }
925 catch (IllegalArgumentException & e)
926 {
927 e.ArgumentPosition = ::sal::static_int_cast< sal_Int16, int >( i );
928 throw;
929 }
930 catch (CannotConvertException & e)
931 {
932 e.ArgumentIndex = i;
933 throw;
934 }
935 }
936 else // it is an JScriptObject
937 {
938 int i = 0;
939 try
940 {
941 for( ; i< parameterCount; i++)
942 {
943 // In parameter
944 if( pMethod->pParams[i].bIn == sal_True && ! pMethod->pParams[i].bOut)
945 {
946 anyToVariant( &pVarParams[parameterCount - i -1], Params.getConstArray()[i]);
947 }
948 // Out parameter + in/out parameter
949 else if( pMethod->pParams[i].bOut == sal_True)
950 {
951 CComObject<JScriptOutParam>* pParamObject;
952 if( SUCCEEDED( CComObject<JScriptOutParam>::CreateInstance( &pParamObject)))
953 {
954 CComPtr<IUnknown> pUnk(pParamObject->GetUnknown());
955 #ifdef __MINGW32__
956 CComQIPtr<IDispatch, &__uuidof(IDispatch)> pDisp( pUnk);
957 #else
958 CComQIPtr<IDispatch> pDisp( pUnk);
959 #endif
960
961 pVarParams[ parameterCount - i -1].vt= VT_DISPATCH;
962 pVarParams[ parameterCount - i -1].pdispVal= pDisp;
963 pVarParams[ parameterCount - i -1].pdispVal->AddRef();
964 // if the param is in/out then put the parameter on index 0
965 if( pMethod->pParams[i].bIn == sal_True ) // in / out
966 {
967 CComVariant varParam;
968 anyToVariant( &varParam, Params.getConstArray()[i]);
969 CComDispatchDriver dispDriver( pDisp);
970 if(FAILED( dispDriver.PutPropertyByName( L"0", &varParam)))
971 throw BridgeRuntimeError(
972 OUSTR("[automation bridge]IUnknownWrapper_Impl::"
973 "invokeWithDispIdUnoTlb\n"
974 "Could not set property \"0\" for the in/out "
975 "param!"));
976
977 }
978 }
979 else
980 {
981 throw BridgeRuntimeError(
982 OUSTR("[automation bridge]IUnknownWrapper_Impl::"
983 "invokeWithDispIdUnoTlb\n"
984 "Could not create out parameter at index: ") +
985 OUString::valueOf((sal_Int32) i));
986 }
987
988 }
989 }
990 }
991 catch (IllegalArgumentException & e)
992 {
993 e.ArgumentPosition = ::sal::static_int_cast< sal_Int16, int >( i );
994 throw;
995 }
996 catch (CannotConvertException & e)
997 {
998 e.ArgumentIndex = i;
999 throw;
1000 }
1001 }
1002 }
1003 // No type description Available, that is we have to deal with a COM component,
1004 // that does not implements UNO interfaces ( IDispatch based)
1005 else
1006 {
1007 //We should not run into this block, because invokeWithDispIdComTlb should
1008 //have been called instead.
1009 OSL_ASSERT(0);
1010 }
1011
1012
1013 CComVariant varResult;
1014 ExcepInfo excepinfo;
1015 unsigned int uArgErr;
1016 DISPPARAMS dispparams= { pVarParams, NULL, parameterCount, 0};
1017 // Get the DISPID
1018 FuncDesc aDesc(getTypeInfo());
1019 getFuncDesc(sFunctionName, & aDesc);
1020 // invoking OLE method
1021 hr = m_spDispatch->Invoke(aDesc->memid,
1022 IID_NULL,
1023 LOCALE_USER_DEFAULT,
1024 DISPATCH_METHOD,
1025 &dispparams,
1026 &varResult,
1027 &excepinfo,
1028 &uArgErr);
1029
1030 // converting return value and out parameter back to UNO
1031 if (hr == S_OK)
1032 {
1033 if( outParameterCount && pMethod)
1034 {
1035 OutParamIndex.realloc( outParameterCount);
1036 OutParam.realloc( outParameterCount);
1037 sal_Int32 outIndex=0;
1038 int i = 0;
1039 try
1040 {
1041 for( ; i < parameterCount; i++)
1042 {
1043 if( pMethod->pParams[i].bOut )
1044 {
1045 OutParamIndex[outIndex]= (sal_Int16) i;
1046 Any outAny;
1047 if( !bJScriptObject)
1048 {
1049 variantToAny( &pVarParamsRef[outIndex], outAny,
1050 Type(pMethod->pParams[i].pTypeRef), sal_False);
1051 OutParam[outIndex++]= outAny;
1052 }
1053 else //JScriptObject
1054 {
1055 if( pVarParams[i].vt == VT_DISPATCH)
1056 {
1057 CComDispatchDriver pDisp( pVarParams[i].pdispVal);
1058 if( pDisp)
1059 {
1060 CComVariant varOut;
1061 if( SUCCEEDED( pDisp.GetPropertyByName( L"0", &varOut)))
1062 {
1063 variantToAny( &varOut, outAny,
1064 Type(pMethod->pParams[parameterCount - 1 - i].pTypeRef), sal_False);
1065 OutParam[outParameterCount - 1 - outIndex++]= outAny;
1066 }
1067 else
1068 bConvRet= sal_False;
1069 }
1070 else
1071 bConvRet= sal_False;
1072 }
1073 else
1074 bConvRet= sal_False;
1075 }
1076 }
1077 if( !bConvRet) break;
1078 }
1079 }
1080 catch(IllegalArgumentException & e)
1081 {
1082 e.ArgumentPosition = ::sal::static_int_cast< sal_Int16, int >( i );
1083 throw;
1084 }
1085 catch(CannotConvertException & e)
1086 {
1087 e.ArgumentIndex = i;
1088 throw;
1089 }
1090 }
1091 // return value, no type information available
1092 if ( bConvRet)
1093 {
1094 try
1095 {
1096 if( pMethod )
1097 variantToAny(&varResult, ret, Type( pMethod->pReturnTypeRef), sal_False);
1098 else
1099 variantToAny(&varResult, ret, sal_False);
1100 }
1101 catch (IllegalArgumentException & e)
1102 {
1103 e.Message =
1104 OUSTR("[automation bridge]IUnknownWrapper_Impl::invokeWithDispIdUnoTlb\n"
1105 "Could not convert return value! \n Message: \n") + e.Message;
1106 throw;
1107 }
1108 catch (CannotConvertException & e)
1109 {
1110 e.Message =
1111 OUSTR("[automation bridge]IUnknownWrapper_Impl::invokeWithDispIdUnoTlb\n"
1112 "Could not convert return value! \n Message: \n") + e.Message;
1113 throw;
1114 }
1115 }
1116 }
1117
1118 if( !bConvRet) // conversion of return or out parameter failed
1119 throw CannotConvertException( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Call to COM object failed. Conversion of return or out value failed")),
1120 Reference<XInterface>( static_cast<XWeak*>(this), UNO_QUERY ), TypeClass_UNKNOWN,
1121 FailReason::UNKNOWN, 0);// lookup error code
1122 // conversion of return or out parameter failed
1123 switch (hr)
1124 {
1125 case S_OK:
1126 break;
1127 case DISP_E_BADPARAMCOUNT:
1128 throw IllegalArgumentException();
1129 break;
1130 case DISP_E_BADVARTYPE:
1131 throw RuntimeException();
1132 break;
1133 case DISP_E_EXCEPTION:
1134 throw InvocationTargetException();
1135 break;
1136 case DISP_E_MEMBERNOTFOUND:
1137 throw IllegalArgumentException();
1138 break;
1139 case DISP_E_NONAMEDARGS:
1140 throw IllegalArgumentException();
1141 break;
1142 case DISP_E_OVERFLOW:
1143 throw CannotConvertException(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("call to OLE object failed")), static_cast<XInterface*>(
1144 static_cast<XWeak*>(this)), TypeClass_UNKNOWN, FailReason::OUT_OF_RANGE, uArgErr);
1145 break;
1146 case DISP_E_PARAMNOTFOUND:
1147 throw IllegalArgumentException(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("call to OLE object failed")), static_cast<XInterface*>(
1148 static_cast<XWeak*>(this)), ::sal::static_int_cast< sal_Int16, unsigned int >( uArgErr ));
1149 break;
1150 case DISP_E_TYPEMISMATCH:
1151 throw CannotConvertException(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("call to OLE object failed")),static_cast<XInterface*>(
1152 static_cast<XWeak*>(this)) , TypeClass_UNKNOWN, FailReason::UNKNOWN, uArgErr);
1153 break;
1154 case DISP_E_UNKNOWNINTERFACE:
1155 throw RuntimeException() ;
1156 break;
1157 case DISP_E_UNKNOWNLCID:
1158 throw RuntimeException() ;
1159 break;
1160 case DISP_E_PARAMNOTOPTIONAL:
1161 throw CannotConvertException(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("call to OLE object failed")), static_cast<XInterface*>(
1162 static_cast<XWeak*>(this)), TypeClass_UNKNOWN, FailReason::NO_DEFAULT_AVAILABLE, uArgErr);
1163 break;
1164 default:
1165 throw RuntimeException();
1166 break;
1167 }
1168
1169 return ret;
1170 }
1171
1172
1173
1174 // --------------------------
1175 // XInitialization
initialize(const Sequence<Any> & aArguments)1176 void SAL_CALL IUnknownWrapper_Impl::initialize( const Sequence< Any >& aArguments ) throw(Exception, RuntimeException)
1177 {
1178 // 1.parameter is IUnknown
1179 // 2.parameter is a boolean which indicates if the the COM pointer was a IUnknown or IDispatch
1180 // 3.parameter is a Sequence<Type>
1181 o2u_attachCurrentThread();
1182 OSL_ASSERT(aArguments.getLength() == 3);
1183
1184 m_spUnknown= *(IUnknown**) aArguments[0].getValue();
1185 #ifdef __MINGW32__
1186 m_spUnknown->QueryInterface(IID_IDispatch, reinterpret_cast<LPVOID*>( & m_spDispatch.p));
1187 #else
1188 m_spUnknown.QueryInterface( & m_spDispatch.p);
1189 #endif
1190
1191 aArguments[1] >>= m_bOriginalDispatch;
1192 aArguments[2] >>= m_seqTypes;
1193
1194 ITypeInfo* pType = NULL;
1195 try
1196 {
1197 // a COM object implementation that has no TypeInfo is still a legal COM object;
1198 // such objects can at least be transported through UNO using the bridge
1199 // so we should allow to create wrappers for them as well
1200 pType = getTypeInfo();
1201 }
1202 catch( BridgeRuntimeError& )
1203 {}
1204 catch( Exception& )
1205 {}
1206
1207 if ( pType )
1208 {
1209 try
1210 {
1211 // Get Default member
1212 CComBSTR defaultMemberName;
1213 if ( SUCCEEDED( pType->GetDocumentation(0, &defaultMemberName, 0, 0, 0 ) ) )
1214 {
1215 OUString usName(reinterpret_cast<const sal_Unicode*>(LPCOLESTR(defaultMemberName)));
1216 FuncDesc aDescGet(pType);
1217 FuncDesc aDescPut(pType);
1218 VarDesc aVarDesc(pType);
1219 // see if this is a property first ( more likely to be a property then a method )
1220 getPropDesc( usName, & aDescGet, & aDescPut, & aVarDesc);
1221
1222 if ( !aDescGet && !aDescPut )
1223 {
1224 getFuncDesc( usName, &aDescGet );
1225 if ( !aDescGet )
1226 throw BridgeRuntimeError( OUSTR("[automation bridge]IUnknownWrapper_Impl::initialize() Failed to get Function or Property desc. for " ) + usName );
1227 }
1228 // now for some funny heuristics to make basic understand what to do
1229 // a single aDescGet ( that doesn't take any params ) would be
1230 // a read only ( defaultmember ) property e.g. this object
1231 // should implement XDefaultProperty
1232 // a single aDescGet ( that *does* ) take params is basically a
1233 // default method e.g. implement XDefaultMethod
1234
1235 // a DescPut ( I guess we only really support a default param with '1' param ) as a setValue ( but I guess we can leave it through, the object will fail if we don't get it right anyway )
1236 if ( aDescPut || ( aDescGet && aDescGet->cParams == 0 ) )
1237 m_bHasDfltProperty = true;
1238 if ( aDescGet->cParams > 0 )
1239 m_bHasDfltMethod = true;
1240 if ( m_bHasDfltProperty || m_bHasDfltMethod )
1241 m_sDefaultMember = usName;
1242 }
1243 }
1244 catch ( BridgeRuntimeError & e )
1245 {
1246 throw RuntimeException( e.message, Reference<XInterface>() );
1247 }
1248 catch( Exception& e )
1249 {
1250 throw RuntimeException(
1251 OUSTR("[automation bridge] unexpected exception in IUnknownWrapper_Impl::initialiase() error message: \n") + e.Message,
1252 Reference<XInterface>() );
1253 }
1254 }
1255 }
1256
1257 // --------------------------
1258 // XDirectInvocation
directInvoke(const::rtl::OUString & aName,const uno::Sequence<uno::Any> & aParams)1259 uno::Any SAL_CALL IUnknownWrapper_Impl::directInvoke( const ::rtl::OUString& aName, const uno::Sequence< uno::Any >& aParams )
1260 throw (lang::IllegalArgumentException, script::CannotConvertException, reflection::InvocationTargetException, uno::RuntimeException)
1261 {
1262 Any aResult;
1263
1264 if ( !m_spDispatch )
1265 {
1266 throw RuntimeException(
1267 OUSTR("[automation bridge] The object does not have an IDispatch interface"),
1268 Reference<XInterface>());
1269 }
1270
1271 o2u_attachCurrentThread();
1272 DISPID dispid;
1273 if ( !getDispid( aName, &dispid ) )
1274 throw IllegalArgumentException(
1275 OUSTR( "[automation bridge] The object does not have a function or property " )
1276 + aName, Reference<XInterface>(), 0);
1277
1278 CComVariant varResult;
1279 ExcepInfo excepinfo;
1280 unsigned int uArgErr = 0;
1281 INVOKEKIND pInvkinds[2];
1282 pInvkinds[0] = INVOKE_FUNC;
1283 pInvkinds[1] = aParams.getLength() ? INVOKE_PROPERTYPUT : INVOKE_PROPERTYGET;
1284 HRESULT hInvRes = E_FAIL;
1285
1286 // try Invoke first, if it does not work, try put/get property
1287 for ( sal_Int32 nStep = 0; FAILED( hInvRes ) && nStep < 2; nStep++ )
1288 {
1289 DISPPARAMS dispparams = {NULL, NULL, 0, 0};
1290
1291 DISPID idPropertyPut = DISPID_PROPERTYPUT;
1292 scoped_array<DISPID> arDispidNamedArgs;
1293 scoped_array<CComVariant> ptrArgs;
1294 scoped_array<CComVariant> ptrRefArgs; // referenced arguments
1295 CComVariant * arArgs = NULL;
1296 CComVariant * arRefArgs = NULL;
1297 bool bVarargParam = false;
1298
1299 dispparams.cArgs = aParams.getLength();
1300
1301 // Determine the number of named arguments
1302 for ( sal_Int32 nInd = 0; nInd < aParams.getLength(); nInd++ )
1303 if ( aParams[nInd].getValueType() == getCppuType((NamedArgument*) 0) )
1304 dispparams.cNamedArgs ++;
1305
1306 // fill the named arguments
1307 if ( dispparams.cNamedArgs > 0
1308 && !( dispparams.cNamedArgs == 1 && pInvkinds[nStep] == INVOKE_PROPERTYPUT ) )
1309 {
1310 int nSizeAr = dispparams.cNamedArgs + 1;
1311 if ( pInvkinds[nStep] == INVOKE_PROPERTYPUT )
1312 nSizeAr = dispparams.cNamedArgs;
1313
1314 scoped_array<OLECHAR*> saNames(new OLECHAR*[nSizeAr]);
1315 OLECHAR ** pNames = saNames.get();
1316 pNames[0] = const_cast<OLECHAR*>(reinterpret_cast<LPCOLESTR>(aName.getStr()));
1317
1318 int cNamedArg = 0;
1319 for ( size_t nInd = 0; nInd < dispparams.cArgs; nInd++ )
1320 {
1321 if ( aParams[nInd].getValueType() == getCppuType((NamedArgument*) 0))
1322 {
1323 const NamedArgument& arg = *(NamedArgument const*)aParams[nInd].getValue();
1324
1325 //We put the parameter names in reverse order into the array,
1326 //so we can use the DISPID array for DISPPARAMS::rgdispidNamedArgs
1327 //The first name in the array is the method name
1328 pNames[nSizeAr - 1 - cNamedArg++] = const_cast<OLECHAR*>(reinterpret_cast<LPCOLESTR>(arg.Name.getStr()));
1329 }
1330 }
1331
1332 arDispidNamedArgs.reset( new DISPID[nSizeAr] );
1333 HRESULT hr = getTypeInfo()->GetIDsOfNames( pNames, nSizeAr, arDispidNamedArgs.get() );
1334 if ( hr == E_NOTIMPL )
1335 hr = m_spDispatch->GetIDsOfNames(IID_NULL, pNames, nSizeAr, LOCALE_USER_DEFAULT, arDispidNamedArgs.get() );
1336
1337 if ( SUCCEEDED( hr ) )
1338 {
1339 if ( pInvkinds[nStep] == DISPATCH_PROPERTYPUT )
1340 {
1341 DISPID* arIDs = arDispidNamedArgs.get();
1342 arIDs[0] = DISPID_PROPERTYPUT;
1343 dispparams.rgdispidNamedArgs = arIDs;
1344 }
1345 else
1346 {
1347 DISPID* arIDs = arDispidNamedArgs.get();
1348 dispparams.rgdispidNamedArgs = & arIDs[1];
1349 }
1350 }
1351 else if (hr == DISP_E_UNKNOWNNAME)
1352 {
1353 throw IllegalArgumentException(
1354 OUSTR("[automation bridge]One of the named arguments is wrong!"),
1355 Reference<XInterface>(), 0);
1356 }
1357 else
1358 {
1359 throw InvocationTargetException(
1360 OUSTR("[automation bridge] ITypeInfo::GetIDsOfNames returned error ")
1361 + OUString::valueOf((sal_Int32) hr, 16), Reference<XInterface>(), Any());
1362 }
1363 }
1364
1365 //Convert arguments
1366 ptrArgs.reset(new CComVariant[dispparams.cArgs]);
1367 ptrRefArgs.reset(new CComVariant[dispparams.cArgs]);
1368 arArgs = ptrArgs.get();
1369 arRefArgs = ptrRefArgs.get();
1370
1371 sal_Int32 nInd = 0;
1372 try
1373 {
1374 sal_Int32 revIndex = 0;
1375 for ( nInd = 0; nInd < sal_Int32(dispparams.cArgs); nInd++)
1376 {
1377 revIndex = dispparams.cArgs - nInd - 1;
1378 arRefArgs[revIndex].byref = 0;
1379 Any anyArg;
1380 if ( nInd < aParams.getLength() )
1381 anyArg = aParams.getConstArray()[nInd];
1382
1383 // Property Put arguments
1384 if ( anyArg.getValueType() == getCppuType((PropertyPutArgument*)0) )
1385 {
1386 PropertyPutArgument arg;
1387 anyArg >>= arg;
1388 anyArg <<= arg.Value;
1389 }
1390 // named argument
1391 if (anyArg.getValueType() == getCppuType((NamedArgument*) 0))
1392 {
1393 NamedArgument aNamedArgument;
1394 anyArg >>= aNamedArgument;
1395 anyArg <<= aNamedArgument.Value;
1396 }
1397
1398 if ( nInd < aParams.getLength() && anyArg.getValueTypeClass() != TypeClass_VOID )
1399 {
1400 anyToVariant( &arArgs[revIndex], anyArg, VT_VARIANT );
1401 }
1402 else
1403 {
1404 arArgs[revIndex].vt = VT_ERROR;
1405 arArgs[revIndex].scode = DISP_E_PARAMNOTFOUND;
1406 }
1407 }
1408 }
1409 catch (IllegalArgumentException & e)
1410 {
1411 e.ArgumentPosition = ::sal::static_int_cast< sal_Int16, sal_Int32 >( nInd );
1412 throw;
1413 }
1414 catch (CannotConvertException & e)
1415 {
1416 e.ArgumentIndex = nInd;
1417 throw;
1418 }
1419
1420 dispparams.rgvarg = arArgs;
1421 // invoking OLE method
1422 DWORD localeId = LOCALE_USER_DEFAULT;
1423 hInvRes = m_spDispatch->Invoke( dispid,
1424 IID_NULL,
1425 localeId,
1426 ::sal::static_int_cast< WORD, INVOKEKIND >( pInvkinds[nStep] ),
1427 &dispparams,
1428 &varResult,
1429 &excepinfo,
1430 &uArgErr);
1431 }
1432
1433 // converting return value and out parameter back to UNO
1434 if ( SUCCEEDED( hInvRes ) )
1435 variantToAny( &varResult, aResult, sal_False );
1436 else
1437 {
1438 // map error codes to exceptions
1439 OUString message;
1440 switch ( hInvRes )
1441 {
1442 case S_OK:
1443 break;
1444 case DISP_E_BADPARAMCOUNT:
1445 throw IllegalArgumentException(OUSTR("[automation bridge] Wrong "
1446 "number of arguments. Object returned DISP_E_BADPARAMCOUNT."),
1447 0, 0);
1448 break;
1449 case DISP_E_BADVARTYPE:
1450 throw RuntimeException(OUSTR("[automation bridge] One or more "
1451 "arguments have the wrong type. Object returned "
1452 "DISP_E_BADVARTYPE."), 0);
1453 break;
1454 case DISP_E_EXCEPTION:
1455 message = OUSTR("[automation bridge]: ");
1456 message += OUString(reinterpret_cast<const sal_Unicode*>(excepinfo.bstrDescription),
1457 ::SysStringLen(excepinfo.bstrDescription));
1458 throw InvocationTargetException(message, Reference<XInterface>(), Any());
1459 break;
1460 case DISP_E_MEMBERNOTFOUND:
1461 message = OUSTR("[automation bridge]: A function with the name \"")
1462 + aName + OUSTR("\" is not supported. Object returned "
1463 "DISP_E_MEMBERNOTFOUND.");
1464 throw IllegalArgumentException(message, 0, 0);
1465 break;
1466 case DISP_E_NONAMEDARGS:
1467 throw IllegalArgumentException(OUSTR("[automation bridge] Object "
1468 "returned DISP_E_NONAMEDARGS"),0, ::sal::static_int_cast< sal_Int16, unsigned int >( uArgErr ));
1469 break;
1470 case DISP_E_OVERFLOW:
1471 throw CannotConvertException(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("[automation bridge] Call failed.")),
1472 static_cast<XInterface*>(
1473 static_cast<XWeak*>(this)), TypeClass_UNKNOWN, FailReason::OUT_OF_RANGE, uArgErr);
1474 break;
1475 case DISP_E_PARAMNOTFOUND:
1476 throw IllegalArgumentException(OUSTR("[automation bridge]Call failed."
1477 "Object returned DISP_E_PARAMNOTFOUND."),
1478 0, ::sal::static_int_cast< sal_Int16, unsigned int >( uArgErr ));
1479 break;
1480 case DISP_E_TYPEMISMATCH:
1481 throw CannotConvertException(OUSTR("[automation bridge] Call failed. "
1482 "Object returned DISP_E_TYPEMISMATCH"),
1483 static_cast<XInterface*>(
1484 static_cast<XWeak*>(this)) , TypeClass_UNKNOWN, FailReason::UNKNOWN, uArgErr);
1485 break;
1486 case DISP_E_UNKNOWNINTERFACE:
1487 throw RuntimeException(OUSTR("[automation bridge] Call failed. "
1488 "Object returned DISP_E_UNKNOWNINTERFACE."),0);
1489 break;
1490 case DISP_E_UNKNOWNLCID:
1491 throw RuntimeException(OUSTR("[automation bridge] Call failed. "
1492 "Object returned DISP_E_UNKNOWNLCID."),0);
1493 break;
1494 case DISP_E_PARAMNOTOPTIONAL:
1495 throw CannotConvertException(OUSTR("[automation bridge] Call failed."
1496 "Object returned DISP_E_PARAMNOTOPTIONAL"),
1497 static_cast<XInterface*>(static_cast<XWeak*>(this)),
1498 TypeClass_UNKNOWN, FailReason::NO_DEFAULT_AVAILABLE, uArgErr);
1499 break;
1500 default:
1501 throw RuntimeException();
1502 break;
1503 }
1504 }
1505
1506 return aResult;
1507 }
1508
hasMember(const::rtl::OUString & aName)1509 ::sal_Bool SAL_CALL IUnknownWrapper_Impl::hasMember( const ::rtl::OUString& aName )
1510 throw (uno::RuntimeException)
1511 {
1512 if ( ! m_spDispatch )
1513 {
1514 throw RuntimeException(
1515 OUSTR("[automation bridge] The object does not have an IDispatch interface"),
1516 Reference<XInterface>());
1517 }
1518
1519 o2u_attachCurrentThread();
1520 DISPID dispid;
1521 return getDispid( aName, &dispid );
1522 }
1523
1524
1525 // UnoConversionUtilities --------------------------------------------------------------------------------
createUnoWrapperInstance()1526 Reference< XInterface > IUnknownWrapper_Impl::createUnoWrapperInstance()
1527 {
1528 if( m_nUnoWrapperClass == INTERFACE_OLE_WRAPPER_IMPL)
1529 {
1530 Reference<XWeak> xWeak= static_cast<XWeak*>( new InterfaceOleWrapper_Impl(
1531 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass));
1532 return Reference<XInterface>( xWeak, UNO_QUERY);
1533 }
1534 else if( m_nUnoWrapperClass == UNO_OBJECT_WRAPPER_REMOTE_OPT)
1535 {
1536 Reference<XWeak> xWeak= static_cast<XWeak*>( new UnoObjectWrapperRemoteOpt(
1537 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass));
1538 return Reference<XInterface>( xWeak, UNO_QUERY);
1539 }
1540 else
1541 return Reference<XInterface>();
1542 }
createComWrapperInstance()1543 Reference<XInterface> IUnknownWrapper_Impl::createComWrapperInstance()
1544 {
1545 Reference<XWeak> xWeak= static_cast<XWeak*>( new IUnknownWrapper_Impl(
1546 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass));
1547 return Reference<XInterface>( xWeak, UNO_QUERY);
1548 }
1549
1550
1551
getMethodInfo(const OUString & sName,TypeDescription & methodInfo)1552 void IUnknownWrapper_Impl::getMethodInfo(const OUString& sName, TypeDescription& methodInfo)
1553 {
1554 TypeDescription desc= getInterfaceMemberDescOfCurrentCall(sName);
1555 if( desc.is())
1556 {
1557 typelib_TypeDescription* pMember= desc.get();
1558 if( pMember->eTypeClass == TypeClass_INTERFACE_METHOD )
1559 methodInfo= pMember;
1560 }
1561 }
1562
getAttributeInfo(const OUString & sName,TypeDescription & attributeInfo)1563 void IUnknownWrapper_Impl::getAttributeInfo(const OUString& sName, TypeDescription& attributeInfo)
1564 {
1565 TypeDescription desc= getInterfaceMemberDescOfCurrentCall(sName);
1566 if( desc.is())
1567 {
1568 typelib_TypeDescription* pMember= desc.get();
1569 if( pMember->eTypeClass == TypeClass_INTERFACE_ATTRIBUTE )
1570 {
1571 attributeInfo= ((typelib_InterfaceAttributeTypeDescription*)pMember)->pAttributeTypeRef;
1572 }
1573 }
1574 }
getInterfaceMemberDescOfCurrentCall(const OUString & sName)1575 TypeDescription IUnknownWrapper_Impl::getInterfaceMemberDescOfCurrentCall(const OUString& sName)
1576 {
1577 TypeDescription ret;
1578
1579 for( sal_Int32 i=0; i < m_seqTypes.getLength(); i++)
1580 {
1581 TypeDescription _curDesc( m_seqTypes[i]);
1582 _curDesc.makeComplete();
1583 typelib_InterfaceTypeDescription * pInterface= (typelib_InterfaceTypeDescription*) _curDesc.get();
1584 if( pInterface)
1585 {
1586 typelib_InterfaceMemberTypeDescription* pMember= NULL;
1587 //find the member description of the current call
1588 for( int i=0; i < pInterface->nAllMembers; i++)
1589 {
1590 typelib_TypeDescriptionReference* pTypeRefMember = pInterface->ppAllMembers[i];
1591 typelib_TypeDescription* pDescMember= NULL;
1592 TYPELIB_DANGER_GET( &pDescMember, pTypeRefMember);
1593
1594 typelib_InterfaceMemberTypeDescription* pInterfaceMember=
1595 (typelib_InterfaceMemberTypeDescription*) pDescMember;
1596 if( OUString( pInterfaceMember->pMemberName) == sName)
1597 {
1598 pMember= pInterfaceMember;
1599 break;
1600 }
1601 TYPELIB_DANGER_RELEASE( pDescMember);
1602 }
1603
1604 if( pMember)
1605 {
1606 ret= (typelib_TypeDescription*)pMember;
1607 TYPELIB_DANGER_RELEASE( (typelib_TypeDescription*)pMember);
1608 }
1609 }
1610 if( ret.is())
1611 break;
1612 }
1613 return ret;
1614 }
1615
isJScriptObject()1616 sal_Bool IUnknownWrapper_Impl::isJScriptObject()
1617 {
1618 if( m_eJScript == JScriptUndefined)
1619 {
1620 CComDispatchDriver disp( m_spDispatch);
1621 if( disp)
1622 {
1623 CComVariant result;
1624 if( SUCCEEDED( disp.GetPropertyByName( JSCRIPT_ID_PROPERTY, &result)))
1625 {
1626 if(result.vt == VT_BSTR)
1627 {
1628 CComBSTR name( result.bstrVal);
1629 name.ToLower();
1630 if( name == CComBSTR(JSCRIPT_ID))
1631 m_eJScript= IsJScript;
1632 }
1633 }
1634 }
1635 if( m_eJScript == JScriptUndefined)
1636 m_eJScript= NoJScript;
1637 }
1638
1639 return m_eJScript == NoJScript ? sal_False : sal_True;
1640 }
1641
1642
1643
1644 /** @internal
1645 The function ultimately calls IDispatch::Invoke on the wrapped COM object.
1646 The COM object does not implement UNO Interfaces ( via IDispatch). This
1647 is the case when the OleObjectFactory service has been used to create a
1648 component.
1649 @exception IllegalArgumentException
1650 @exception CannotConvertException
1651 @InvocationTargetException
1652 @RuntimeException
1653 @BridgeRuntimeError
1654 */
invokeWithDispIdComTlb(const OUString & sFuncName,const Sequence<Any> & Params,Sequence<sal_Int16> & OutParamIndex,Sequence<Any> & OutParam)1655 Any IUnknownWrapper_Impl::invokeWithDispIdComTlb(const OUString& sFuncName,
1656 const Sequence< Any >& Params,
1657 Sequence< sal_Int16 >& OutParamIndex,
1658 Sequence< Any >& OutParam)
1659 {
1660 Any ret;
1661 HRESULT result;
1662
1663 DISPPARAMS dispparams = {NULL, NULL, 0, 0};
1664 CComVariant varResult;
1665 ExcepInfo excepinfo;
1666 unsigned int uArgErr;
1667 sal_Int32 i = 0;
1668 sal_Int32 nUnoArgs = Params.getLength();
1669 DISPID idPropertyPut = DISPID_PROPERTYPUT;
1670 scoped_array<DISPID> arDispidNamedArgs;
1671 scoped_array<CComVariant> ptrArgs;
1672 scoped_array<CComVariant> ptrRefArgs; // referenced arguments
1673 CComVariant * arArgs = NULL;
1674 CComVariant * arRefArgs = NULL;
1675 sal_Int32 revIndex = 0;
1676 bool bVarargParam = false;
1677
1678 // Get type info for the call. It can be a method call or property put or
1679 // property get operation.
1680 FuncDesc aFuncDesc(getTypeInfo());
1681 getFuncDescForInvoke(sFuncName, Params, & aFuncDesc);
1682
1683 //Set the array of DISPIDs for named args if it is a property put operation.
1684 //If there are other named arguments another array is set later on.
1685 if (aFuncDesc->invkind == INVOKE_PROPERTYPUT
1686 || aFuncDesc->invkind == INVOKE_PROPERTYPUTREF)
1687 dispparams.rgdispidNamedArgs = & idPropertyPut;
1688
1689 //Determine the number of named arguments
1690 for (int iParam = 0; iParam < nUnoArgs; iParam ++)
1691 {
1692 const Any & curArg = Params[iParam];
1693 if (curArg.getValueType() == getCppuType((NamedArgument*) 0))
1694 dispparams.cNamedArgs ++;
1695 }
1696 //In a property put operation a property value is a named argument (DISPID_PROPERTYPUT).
1697 //Therefore the number of named arguments is increased by one.
1698 //Although named, the argument is not named in a actual language, such as Basic,
1699 //therefore it is never a com.sun.star.bridge.oleautomation.NamedArgument
1700 if (aFuncDesc->invkind == DISPATCH_PROPERTYPUT
1701 || aFuncDesc->invkind == DISPATCH_PROPERTYPUTREF)
1702 dispparams.cNamedArgs ++;
1703
1704 //Determine the number of all arguments and named arguments
1705 if (aFuncDesc->cParamsOpt == -1)
1706 {
1707 //Attribute vararg is set on this method. "Unlimited" number of args
1708 //supported. There can be no optional or defaultvalue on any of the arguments.
1709 dispparams.cArgs = nUnoArgs;
1710 }
1711 else
1712 {
1713 //If there are namesd arguments, then the dispparams.cArgs
1714 //is the number of supplied args, otherwise it is the expected number.
1715 if (dispparams.cNamedArgs)
1716 dispparams.cArgs = nUnoArgs;
1717 else
1718 dispparams.cArgs = aFuncDesc->cParams;
1719 }
1720
1721 //check if there are not to many arguments supplied
1722 if (::sal::static_int_cast< sal_uInt32, int >( nUnoArgs ) > dispparams.cArgs)
1723 {
1724 OUStringBuffer buf(256);
1725 buf.appendAscii("[automation bridge] There are too many arguments for this method");
1726 throw IllegalArgumentException( buf.makeStringAndClear(),
1727 Reference<XInterface>(), (sal_Int16) dispparams.cArgs);
1728 }
1729
1730 //Set up the array of DISPIDs (DISPPARAMS::rgdispidNamedArgs)
1731 //for the named arguments.
1732 //If there is only one named arg and if it is because of a property put
1733 //operation, then we need not set up the DISPID array.
1734 if (dispparams.cNamedArgs > 0 &&
1735 ! (dispparams.cNamedArgs == 1 &&
1736 (aFuncDesc->invkind == INVOKE_PROPERTYPUT ||
1737 aFuncDesc->invkind == INVOKE_PROPERTYPUT)))
1738 {
1739 //set up an array containing the member and parameter names
1740 //which is then used in ITypeInfo::GetIDsOfNames
1741 //First determine the size of the array of names which is passed to
1742 //ITypeInfo::GetIDsOfNames. It must hold the method names + the named
1743 //args.
1744 int nSizeAr = dispparams.cNamedArgs + 1;
1745 if (aFuncDesc->invkind == INVOKE_PROPERTYPUT
1746 || aFuncDesc->invkind == INVOKE_PROPERTYPUTREF)
1747 {
1748 nSizeAr = dispparams.cNamedArgs; //counts the DISID_PROPERTYPUT
1749 }
1750
1751 scoped_array<OLECHAR*> saNames(new OLECHAR*[nSizeAr]);
1752 OLECHAR ** arNames = saNames.get();
1753 arNames[0] = const_cast<OLECHAR*>(reinterpret_cast<LPCOLESTR>(sFuncName.getStr()));
1754
1755 int cNamedArg = 0;
1756 for (size_t iParams = 0; iParams < dispparams.cArgs; iParams ++)
1757 {
1758 const Any & curArg = Params[iParams];
1759 if (curArg.getValueType() == getCppuType((NamedArgument*) 0))
1760 {
1761 const NamedArgument& arg = *(NamedArgument const*) curArg.getValue();
1762 //We put the parameter names in reverse order into the array,
1763 //so we can use the DISPID array for DISPPARAMS::rgdispidNamedArgs
1764 //The first name in the array is the method name
1765 arNames[nSizeAr - 1 - cNamedArg++] = const_cast<OLECHAR*>(reinterpret_cast<LPCOLESTR>(arg.Name.getStr()));
1766 }
1767 }
1768
1769 //Prepare the array of DISPIDs for ITypeInfo::GetIDsOfNames
1770 //it must be big enough to contain the DISPIDs of the member + parameters
1771 arDispidNamedArgs.reset(new DISPID[nSizeAr]);
1772 HRESULT hr = getTypeInfo()->GetIDsOfNames(arNames, nSizeAr,
1773 arDispidNamedArgs.get());
1774 if ( hr == E_NOTIMPL )
1775 hr = m_spDispatch->GetIDsOfNames(IID_NULL, arNames, nSizeAr, LOCALE_USER_DEFAULT, arDispidNamedArgs.get() );
1776
1777 if (hr == S_OK)
1778 {
1779 // In a "property put" operation, the property value is a named param with the
1780 //special DISPID DISPID_PROPERTYPUT
1781 if (aFuncDesc->invkind == DISPATCH_PROPERTYPUT
1782 || aFuncDesc->invkind == DISPATCH_PROPERTYPUTREF)
1783 {
1784 //Element at index 0 in the DISPID array must be DISPID_PROPERTYPUT
1785 //The first item in the array arDispidNamedArgs is the DISPID for
1786 //the method. We replace it with DISPID_PROPERTYPUT.
1787 DISPID* arIDs = arDispidNamedArgs.get();
1788 arIDs[0] = DISPID_PROPERTYPUT;
1789 dispparams.rgdispidNamedArgs = arIDs;
1790 }
1791 else
1792 {
1793 //The first item in the array arDispidNamedArgs is the DISPID for
1794 //the method. It must be removed
1795 DISPID* arIDs = arDispidNamedArgs.get();
1796 dispparams.rgdispidNamedArgs = & arIDs[1];
1797 }
1798 }
1799 else if (hr == DISP_E_UNKNOWNNAME)
1800 {
1801 throw IllegalArgumentException(
1802 OUSTR("[automation bridge]One of the named arguments is wrong!"),
1803 Reference<XInterface>(), 0);
1804 }
1805 else
1806 {
1807 throw InvocationTargetException(
1808 OUSTR("[automation bridge] ITypeInfo::GetIDsOfNames returned error ")
1809 + OUString::valueOf((sal_Int32) hr, 16), Reference<XInterface>(), Any());
1810 }
1811 }
1812
1813 //Convert arguments
1814 ptrArgs.reset(new CComVariant[dispparams.cArgs]);
1815 ptrRefArgs.reset(new CComVariant[dispparams.cArgs]);
1816 arArgs = ptrArgs.get();
1817 arRefArgs = ptrRefArgs.get();
1818 try
1819 {
1820 for (i = 0; i < (sal_Int32) dispparams.cArgs; i++)
1821 {
1822 revIndex= dispparams.cArgs - i -1;
1823 arRefArgs[revIndex].byref=0;
1824 Any anyArg;
1825 if ( i < nUnoArgs)
1826 anyArg= Params.getConstArray()[i];
1827
1828 //Test if the current parameter is a "vararg" parameter.
1829 if (bVarargParam || (aFuncDesc->cParamsOpt == -1 &&
1830 aFuncDesc->cParams == (i + 1)))
1831 { //This parameter is from the variable argument list. There is no
1832 //type info available, except that it must be a VARIANT
1833 bVarargParam = true;
1834 }
1835
1836 unsigned short paramFlags = PARAMFLAG_FOPT | PARAMFLAG_FIN;
1837 VARTYPE varType = VT_VARIANT;
1838 if ( ! bVarargParam)
1839 {
1840 paramFlags =
1841 aFuncDesc->lprgelemdescParam[i].paramdesc.wParamFlags;
1842 varType = getElementTypeDesc(
1843 & aFuncDesc->lprgelemdescParam[i].tdesc);
1844 }
1845 //Make sure that there is a UNO parameter for every
1846 // expected parameter. If there is no UNO parameter where the
1847 // called function expects one, then it must be optional. Otherwise
1848 // its a UNO programming error.
1849 if (i >= nUnoArgs && !(paramFlags & PARAMFLAG_FOPT))
1850 {
1851 OUStringBuffer buf(256);
1852 buf.appendAscii("ole automation bridge: The called function expects an argument at"
1853 "position: "); //a different number of arguments")),
1854 buf.append(OUString::valueOf((sal_Int32) i));
1855 buf.appendAscii(" (index starting at 0).");
1856 throw IllegalArgumentException( buf.makeStringAndClear(),
1857 Reference<XInterface>(), (sal_Int16) i);
1858 }
1859
1860 // Property Put arguments
1861 if (anyArg.getValueType() == getCppuType((PropertyPutArgument*)0))
1862 {
1863 PropertyPutArgument arg;
1864 anyArg >>= arg;
1865 anyArg <<= arg.Value;
1866 }
1867 // named argument
1868 if (anyArg.getValueType() == getCppuType((NamedArgument*) 0))
1869 {
1870 NamedArgument aNamedArgument;
1871 anyArg >>= aNamedArgument;
1872 anyArg <<= aNamedArgument.Value;
1873 }
1874 // out param
1875 if (paramFlags & PARAMFLAG_FOUT &&
1876 ! (paramFlags & PARAMFLAG_FIN) )
1877 {
1878 VARTYPE type = ::sal::static_int_cast< VARTYPE, int >( varType ^ VT_BYREF );
1879 if (i < nUnoArgs)
1880 {
1881 arRefArgs[revIndex].vt= type;
1882 }
1883 else
1884 {
1885 //optional arg
1886 arRefArgs[revIndex].vt = VT_ERROR;
1887 arRefArgs[revIndex].scode = DISP_E_PARAMNOTFOUND;
1888 }
1889 if( type == VT_VARIANT )
1890 {
1891 arArgs[revIndex].vt= VT_VARIANT | VT_BYREF;
1892 arArgs[revIndex].byref= &arRefArgs[revIndex];
1893 }
1894 else
1895 {
1896 arArgs[revIndex].vt= varType;
1897 if (type == VT_DECIMAL)
1898 arArgs[revIndex].byref= & arRefArgs[revIndex].decVal;
1899 else
1900 arArgs[revIndex].byref= & arRefArgs[revIndex].byref;
1901 }
1902 }
1903 // in/out + in byref params
1904 else if (varType & VT_BYREF)
1905 {
1906 VARTYPE type = ::sal::static_int_cast< VARTYPE, int >( varType ^ VT_BYREF );
1907 CComVariant var;
1908
1909 if (i < nUnoArgs && anyArg.getValueTypeClass() != TypeClass_VOID)
1910 {
1911 anyToVariant( & arRefArgs[revIndex], anyArg, type);
1912 }
1913 else if (paramFlags & PARAMFLAG_FHASDEFAULT)
1914 {
1915 //optional arg with default
1916 VariantCopy( & arRefArgs[revIndex],
1917 & aFuncDesc->lprgelemdescParam[i].paramdesc.
1918 pparamdescex->varDefaultValue);
1919 }
1920 else
1921 {
1922 //optional arg
1923 //e.g: call func(x) in basic : func() ' no arg supplied
1924 OSL_ASSERT(paramFlags & PARAMFLAG_FOPT);
1925 arRefArgs[revIndex].vt = VT_ERROR;
1926 arRefArgs[revIndex].scode = DISP_E_PARAMNOTFOUND;
1927 }
1928
1929 // Set the converted arguments in the array which will be
1930 // DISPPARAMS::rgvarg
1931 // byref arg VT_XXX |VT_BYREF
1932 arArgs[revIndex].vt = varType;
1933 if (revIndex == 0 && aFuncDesc->invkind == INVOKE_PROPERTYPUT)
1934 {
1935 arArgs[revIndex] = arRefArgs[revIndex];
1936 }
1937 else if (type == VT_DECIMAL)
1938 {
1939 arArgs[revIndex].byref= & arRefArgs[revIndex].decVal;
1940 }
1941 else if (type == VT_VARIANT)
1942 {
1943 if ( ! (paramFlags & PARAMFLAG_FOUT))
1944 arArgs[revIndex] = arRefArgs[revIndex];
1945 else
1946 arArgs[revIndex].byref = & arRefArgs[revIndex];
1947 }
1948 else
1949 {
1950 arArgs[revIndex].byref = & arRefArgs[revIndex].byref;
1951 arArgs[revIndex].vt = ::sal::static_int_cast< VARTYPE, int >( arRefArgs[revIndex].vt | VT_BYREF );
1952 }
1953
1954 }
1955 // in parameter no VT_BYREF except for array, interfaces
1956 else
1957 { // void any stands for optional param
1958 if (i < nUnoArgs && anyArg.getValueTypeClass() != TypeClass_VOID)
1959 {
1960 anyToVariant( & arArgs[revIndex], anyArg, varType);
1961 }
1962 //optional arg but no void any supplied
1963 //Basic: obj.func() ' first parameter left out because it is optional
1964 else if (paramFlags & PARAMFLAG_FHASDEFAULT)
1965 {
1966 //optional arg with defaulteithter as direct arg : VT_XXX or
1967 VariantCopy( & arArgs[revIndex],
1968 & aFuncDesc->lprgelemdescParam[i].paramdesc.
1969 pparamdescex->varDefaultValue);
1970 }
1971 else if (paramFlags & PARAMFLAG_FOPT)
1972 {
1973 arArgs[revIndex].vt = VT_ERROR;
1974 arArgs[revIndex].scode = DISP_E_PARAMNOTFOUND;
1975 }
1976 else
1977 {
1978 arArgs[revIndex].vt = VT_EMPTY;
1979 arArgs[revIndex].lVal = 0;
1980 }
1981 }
1982 }
1983 }
1984 catch (IllegalArgumentException & e)
1985 {
1986 e.ArgumentPosition = ::sal::static_int_cast< sal_Int16, sal_Int32 >( i );
1987 throw;
1988 }
1989 catch (CannotConvertException & e)
1990 {
1991 e.ArgumentIndex = i;
1992 throw;
1993 }
1994 dispparams.rgvarg= arArgs;
1995 // invoking OLE method
1996 DWORD localeId = LOCALE_USER_DEFAULT;
1997 result = m_spDispatch->Invoke(aFuncDesc->memid,
1998 IID_NULL,
1999 localeId,
2000 ::sal::static_int_cast< WORD, INVOKEKIND >( aFuncDesc->invkind ),
2001 &dispparams,
2002 &varResult,
2003 &excepinfo,
2004 &uArgErr);
2005
2006 // converting return value and out parameter back to UNO
2007 if (result == S_OK)
2008 {
2009
2010 // allocate space for the out param Sequence and indices Sequence
2011 int outParamsCount= 0; // includes in/out parameter
2012 for (int i = 0; i < aFuncDesc->cParams; i++)
2013 {
2014 if (aFuncDesc->lprgelemdescParam[i].paramdesc.wParamFlags &
2015 PARAMFLAG_FOUT)
2016 outParamsCount++;
2017 }
2018
2019 OutParamIndex.realloc(outParamsCount);
2020 OutParam.realloc(outParamsCount);
2021 // Convert out params
2022 if (outParamsCount)
2023 {
2024 int outParamIndex=0;
2025 for (int paramIndex = 0; paramIndex < nUnoArgs; paramIndex ++)
2026 {
2027 //Determine the index within the method sinature
2028 int realParamIndex = paramIndex;
2029 int revParamIndex = dispparams.cArgs - paramIndex - 1;
2030 if (Params[paramIndex].getValueType()
2031 == getCppuType((NamedArgument*) 0))
2032 {
2033 //dispparams.rgdispidNamedArgs contains the mapping from index
2034 //of named args list to index of parameter list
2035 realParamIndex = dispparams.rgdispidNamedArgs[revParamIndex];
2036 }
2037
2038 // no named arg, always come before named args
2039 if (! (aFuncDesc->lprgelemdescParam[realParamIndex].paramdesc.wParamFlags
2040 & PARAMFLAG_FOUT))
2041 continue;
2042 Any outAny;
2043 // variantToAny is called with the "reduce range" parameter set to sal_False.
2044 // That causes VT_I4 values not to be converted down to a "lower" type. That
2045 // feature exist for JScript only because it only uses VT_I4 for integer types.
2046 try
2047 {
2048 variantToAny( & arRefArgs[revParamIndex], outAny, sal_False );
2049 }
2050 catch (IllegalArgumentException & e)
2051 {
2052 e.ArgumentPosition = (sal_Int16)paramIndex;
2053 throw;
2054 }
2055 catch (CannotConvertException & e)
2056 {
2057 e.ArgumentIndex = paramIndex;
2058 throw;
2059 }
2060 OutParam[outParamIndex] = outAny;
2061 OutParamIndex[outParamIndex] = ::sal::static_int_cast< sal_Int16, int >( paramIndex );
2062 outParamIndex++;
2063 }
2064 OutParam.realloc(outParamIndex);
2065 OutParamIndex.realloc(outParamIndex);
2066 }
2067 // Return value
2068 variantToAny(&varResult, ret, sal_False);
2069 }
2070
2071 // map error codes to exceptions
2072 OUString message;
2073 switch (result)
2074 {
2075 case S_OK:
2076 break;
2077 case DISP_E_BADPARAMCOUNT:
2078 throw IllegalArgumentException(OUSTR("[automation bridge] Wrong "
2079 "number of arguments. Object returned DISP_E_BADPARAMCOUNT."),
2080 0, 0);
2081 break;
2082 case DISP_E_BADVARTYPE:
2083 throw RuntimeException(OUSTR("[automation bridge] One or more "
2084 "arguments have the wrong type. Object returned "
2085 "DISP_E_BADVARTYPE."), 0);
2086 break;
2087 case DISP_E_EXCEPTION:
2088 message = OUSTR("[automation bridge]: ");
2089 message += OUString(reinterpret_cast<const sal_Unicode*>(excepinfo.bstrDescription),
2090 ::SysStringLen(excepinfo.bstrDescription));
2091 throw InvocationTargetException(message, Reference<XInterface>(), Any());
2092 break;
2093 case DISP_E_MEMBERNOTFOUND:
2094 message = OUSTR("[automation bridge]: A function with the name \"")
2095 + sFuncName + OUSTR("\" is not supported. Object returned "
2096 "DISP_E_MEMBERNOTFOUND.");
2097 throw IllegalArgumentException(message, 0, 0);
2098 break;
2099 case DISP_E_NONAMEDARGS:
2100 throw IllegalArgumentException(OUSTR("[automation bridge] Object "
2101 "returned DISP_E_NONAMEDARGS"),0, ::sal::static_int_cast< sal_Int16, unsigned int >( uArgErr ));
2102 break;
2103 case DISP_E_OVERFLOW:
2104 throw CannotConvertException(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("[automation bridge] Call failed.")),
2105 static_cast<XInterface*>(
2106 static_cast<XWeak*>(this)), TypeClass_UNKNOWN, FailReason::OUT_OF_RANGE, uArgErr);
2107 break;
2108 case DISP_E_PARAMNOTFOUND:
2109 throw IllegalArgumentException(OUSTR("[automation bridge]Call failed."
2110 "Object returned DISP_E_PARAMNOTFOUND."),
2111 0, ::sal::static_int_cast< sal_Int16, unsigned int >( uArgErr ));
2112 break;
2113 case DISP_E_TYPEMISMATCH:
2114 throw CannotConvertException(OUSTR("[automation bridge] Call failed. "
2115 "Object returned DISP_E_TYPEMISMATCH"),
2116 static_cast<XInterface*>(
2117 static_cast<XWeak*>(this)) , TypeClass_UNKNOWN, FailReason::UNKNOWN, uArgErr);
2118 break;
2119 case DISP_E_UNKNOWNINTERFACE:
2120 throw RuntimeException(OUSTR("[automation bridge] Call failed. "
2121 "Object returned DISP_E_UNKNOWNINTERFACE."),0);
2122 break;
2123 case DISP_E_UNKNOWNLCID:
2124 throw RuntimeException(OUSTR("[automation bridge] Call failed. "
2125 "Object returned DISP_E_UNKNOWNLCID."),0);
2126 break;
2127 case DISP_E_PARAMNOTOPTIONAL:
2128 throw CannotConvertException(OUSTR("[automation bridge] Call failed."
2129 "Object returned DISP_E_PARAMNOTOPTIONAL"),
2130 static_cast<XInterface*>(static_cast<XWeak*>(this)),
2131 TypeClass_UNKNOWN, FailReason::NO_DEFAULT_AVAILABLE, uArgErr);
2132 break;
2133 default:
2134 throw RuntimeException();
2135 break;
2136 }
2137
2138 return ret;
2139 }
2140
getFuncDescForInvoke(const OUString & sFuncName,const Sequence<Any> & seqArgs,FUNCDESC ** pFuncDesc)2141 void IUnknownWrapper_Impl::getFuncDescForInvoke(const OUString & sFuncName,
2142 const Sequence<Any> & seqArgs,
2143 FUNCDESC** pFuncDesc)
2144 {
2145 int nUnoArgs = seqArgs.getLength();
2146 const Any * arArgs = seqArgs.getConstArray();
2147 ITypeInfo* pInfo = getTypeInfo();
2148
2149 //If the last of the positional arguments is a PropertyPutArgument
2150 //then obtain the type info for the property put operation.
2151
2152 //The property value is always the last argument, in a positional argument list
2153 //or in a list of named arguments. A PropertyPutArgument is actually a named argument
2154 //hence it must not be put in an extra NamedArgument structure
2155 if (nUnoArgs > 0 &&
2156 arArgs[nUnoArgs - 1].getValueType() == getCppuType((PropertyPutArgument*) 0))
2157 {
2158 // DISPATCH_PROPERTYPUT
2159 FuncDesc aDescGet(pInfo);
2160 FuncDesc aDescPut(pInfo);
2161 VarDesc aVarDesc(pInfo);
2162 getPropDesc(sFuncName, & aDescGet, & aDescPut, & aVarDesc);
2163 if ( ! aDescPut)
2164 {
2165 throw IllegalArgumentException(
2166 OUSTR("[automation bridge] The object does not have a writeable property: ")
2167 + sFuncName, Reference<XInterface>(), 0);
2168 }
2169 *pFuncDesc = aDescPut.Detach();
2170 }
2171 else
2172 { // DISPATCH_METHOD
2173 FuncDesc aFuncDesc(pInfo);
2174 getFuncDesc(sFuncName, & aFuncDesc);
2175 if ( ! aFuncDesc)
2176 {
2177 // Fallback: DISPATCH_PROPERTYGET can mostly be called as
2178 // DISPATCH_METHOD
2179 ITypeInfo * pInfo = getTypeInfo();
2180 FuncDesc aDescPut(pInfo);
2181 VarDesc aVarDesc(pInfo);
2182 getPropDesc(sFuncName, & aFuncDesc, & aDescPut, & aVarDesc);
2183 if ( ! aFuncDesc )
2184 {
2185 throw IllegalArgumentException(
2186 OUSTR("[automation bridge] The object does not have a function"
2187 "or readable property \"")
2188 + sFuncName, Reference<XInterface>(), 0);
2189 }
2190 }
2191 *pFuncDesc = aFuncDesc.Detach();
2192 }
2193 }
getDispid(const OUString & sFuncName,DISPID * id)2194 bool IUnknownWrapper_Impl::getDispid(const OUString& sFuncName, DISPID * id)
2195 {
2196 OSL_ASSERT(m_spDispatch);
2197 LPOLESTR lpsz = const_cast<LPOLESTR> (reinterpret_cast<LPCOLESTR>(sFuncName.getStr()));
2198 HRESULT hr = m_spDispatch->GetIDsOfNames(IID_NULL, &lpsz, 1, LOCALE_USER_DEFAULT, id);
2199 return hr == S_OK ? true : false;
2200 }
getFuncDesc(const OUString & sFuncName,FUNCDESC ** pFuncDesc)2201 void IUnknownWrapper_Impl::getFuncDesc(const OUString & sFuncName, FUNCDESC ** pFuncDesc)
2202
2203 {
2204 OSL_ASSERT( * pFuncDesc == 0);
2205 buildComTlbIndex();
2206 typedef TLBFuncIndexMap::const_iterator cit;
2207 typedef TLBFuncIndexMap::iterator it;
2208 //We assume there is only one entry with the function name. A property
2209 //would have two entries.
2210 cit itIndex= m_mapComFunc.find(sFuncName);
2211 if (itIndex == m_mapComFunc.end())
2212 {
2213 //try case insensive with IDispatch::GetIDsOfNames
2214 DISPID id;
2215 if (getDispid(sFuncName, &id))
2216 {
2217 CComBSTR memberName;
2218 unsigned int pcNames=0;
2219 // get the case sensitive name
2220 if( SUCCEEDED(getTypeInfo()->GetNames( id, & memberName, 1, &pcNames)))
2221 {
2222 //get the associated index and add an entry to the map
2223 //with the name sFuncName which differs in the casing of the letters to
2224 //the actual name as obtained from ITypeInfo
2225 cit itOrg = m_mapComFunc.find(OUString(reinterpret_cast<const sal_Unicode*>(LPCOLESTR(memberName))));
2226 OSL_ASSERT(itOrg != m_mapComFunc.end());
2227 itIndex =
2228 m_mapComFunc.insert( TLBFuncIndexMap::value_type
2229 ( make_pair(sFuncName, itOrg->second ) ));
2230 }
2231 }
2232 }
2233
2234 #if OSL_DEBUG_LEVEL >= 1
2235 // There must only be one entry if sFuncName represents a function or two
2236 // if it is a property
2237 pair<cit, cit> p = m_mapComFunc.equal_range(sFuncName.toAsciiLowerCase());
2238 int numEntries = 0;
2239 for ( ;p.first != p.second; p.first ++, numEntries ++);
2240 OSL_ASSERT( ! (numEntries > 3) );
2241 #endif
2242 if( itIndex != m_mapComFunc.end())
2243 {
2244 ITypeInfo* pType= getTypeInfo();
2245 FUNCDESC * pDesc = NULL;
2246 if (SUCCEEDED(pType->GetFuncDesc(itIndex->second, & pDesc)))
2247 {
2248 if (pDesc->invkind == INVOKE_FUNC)
2249 {
2250 (*pFuncDesc) = pDesc;
2251 }
2252 else
2253 {
2254 pType->ReleaseFuncDesc(pDesc);
2255 }
2256 }
2257 else
2258 {
2259 throw BridgeRuntimeError(OUSTR("[automation bridge] Could not get "
2260 "FUNCDESC for ") + sFuncName);
2261 }
2262 }
2263 //else no entry found for sFuncName, pFuncDesc will not be filled in
2264 }
2265
getPropDesc(const OUString & sFuncName,FUNCDESC ** pFuncDescGet,FUNCDESC ** pFuncDescPut,VARDESC ** pVarDesc)2266 void IUnknownWrapper_Impl::getPropDesc(const OUString & sFuncName, FUNCDESC ** pFuncDescGet,
2267 FUNCDESC** pFuncDescPut, VARDESC** pVarDesc)
2268 {
2269 OSL_ASSERT( * pFuncDescGet == 0 && * pFuncDescPut == 0);
2270 buildComTlbIndex();
2271 typedef TLBFuncIndexMap::const_iterator cit;
2272 pair<cit, cit> p = m_mapComFunc.equal_range(sFuncName);
2273 if (p.first == m_mapComFunc.end())
2274 {
2275 //try case insensive with IDispatch::GetIDsOfNames
2276 DISPID id;
2277 if (getDispid(sFuncName, &id))
2278 {
2279 CComBSTR memberName;
2280 unsigned int pcNames=0;
2281 // get the case sensitive name
2282 if( SUCCEEDED(getTypeInfo()->GetNames( id, & memberName, 1, &pcNames)))
2283 {
2284 //As opposed to getFuncDesc, we do not add the value because we would
2285 // need to find the get and set description for the property. This would
2286 //mean to iterate over all FUNCDESCs again.
2287 p = m_mapComFunc.equal_range(OUString(reinterpret_cast<const sal_Unicode*>(LPCOLESTR(memberName))));
2288 }
2289 }
2290 }
2291
2292 for ( int i = 0 ;p.first != p.second; p.first ++, i ++)
2293 {
2294 // There are a maximum of two entries, property put and property get
2295 OSL_ASSERT( ! (i > 2) );
2296 ITypeInfo* pType= getTypeInfo();
2297 FUNCDESC * pFuncDesc = NULL;
2298 if (SUCCEEDED( pType->GetFuncDesc(p.first->second, & pFuncDesc)))
2299 {
2300 if (pFuncDesc->invkind == INVOKE_PROPERTYGET)
2301 {
2302 (*pFuncDescGet) = pFuncDesc;
2303 }
2304 else if (pFuncDesc->invkind == INVOKE_PROPERTYPUT ||
2305 pFuncDesc->invkind == INVOKE_PROPERTYPUTREF)
2306 {
2307 //a property can have 3 entries, put, put ref, get
2308 // If INVOKE_PROPERTYPUTREF or INVOKE_PROPERTYPUT is used
2309 //depends on what is found first.
2310 if ( * pFuncDescPut)
2311 {
2312 //we already have found one
2313 pType->ReleaseFuncDesc(pFuncDesc);
2314 }
2315 else
2316 {
2317 (*pFuncDescPut) = pFuncDesc;
2318 }
2319 }
2320 else
2321 {
2322 pType->ReleaseFuncDesc(pFuncDesc);
2323 }
2324 }
2325 //ITypeInfo::GetFuncDesc may even provide a funcdesc for a VARDESC
2326 // with invkind = INVOKE_FUNC. Since this function should only return
2327 //a value for a real property (XInvokation::hasMethod, ..::hasProperty
2328 //we need to make sure that sFuncName represents a real property.
2329 VARDESC * pVD = NULL;
2330 if (SUCCEEDED(pType->GetVarDesc(p.first->second, & pVD)))
2331 (*pVarDesc) = pVD;
2332 }
2333 //else no entry for sFuncName, pFuncDesc will not be filled in
2334 }
2335
lcl_getUserDefinedElementType(ITypeInfo * pTypeInfo,const DWORD nHrefType)2336 VARTYPE lcl_getUserDefinedElementType( ITypeInfo* pTypeInfo, const DWORD nHrefType )
2337 {
2338 VARTYPE _type( VT_NULL );
2339 if ( pTypeInfo )
2340 {
2341 CComPtr<ITypeInfo> spRefInfo;
2342 pTypeInfo->GetRefTypeInfo( nHrefType, &spRefInfo.p );
2343 if ( spRefInfo )
2344 {
2345 TypeAttr attr( spRefInfo );
2346 spRefInfo->GetTypeAttr( &attr );
2347 if ( attr->typekind == TKIND_ENUM )
2348 {
2349 // We use the type of the first enum value.
2350 if ( attr->cVars == 0 )
2351 {
2352 throw BridgeRuntimeError(OUSTR("[automation bridge] Could not obtain type description"));
2353 }
2354 VarDesc var( spRefInfo );
2355 spRefInfo->GetVarDesc( 0, &var );
2356 _type = var->lpvarValue->vt;
2357 }
2358 else if ( attr->typekind == TKIND_INTERFACE )
2359 {
2360 _type = VT_UNKNOWN;
2361 }
2362 else if ( attr->typekind == TKIND_DISPATCH )
2363 {
2364 _type = VT_DISPATCH;
2365 }
2366 else if ( attr->typekind == TKIND_ALIAS )
2367 {
2368 // TKIND_ALIAS is a type that is an alias for another type. So get that alias type.
2369 _type = lcl_getUserDefinedElementType( pTypeInfo, attr->tdescAlias.hreftype );
2370 }
2371 else
2372 {
2373 throw BridgeRuntimeError( OUSTR("[automation bridge] Unhandled user defined type.") );
2374 }
2375 }
2376 }
2377 return _type;
2378 }
2379
getElementTypeDesc(const TYPEDESC * desc)2380 VARTYPE IUnknownWrapper_Impl::getElementTypeDesc(const TYPEDESC *desc)
2381 {
2382 VARTYPE _type( VT_NULL );
2383
2384 if (desc->vt == VT_PTR)
2385 {
2386 _type = getElementTypeDesc(desc->lptdesc);
2387 _type |= VT_BYREF;
2388 }
2389 else if (desc->vt == VT_SAFEARRAY)
2390 {
2391 _type = getElementTypeDesc(desc->lptdesc);
2392 _type |= VT_ARRAY;
2393 }
2394 else if (desc->vt == VT_USERDEFINED)
2395 {
2396 ITypeInfo* thisInfo = getTypeInfo(); //kept by this instance
2397 _type = lcl_getUserDefinedElementType( thisInfo, desc->hreftype );
2398 }
2399 else
2400 {
2401 _type = desc->vt;
2402 }
2403 return _type;
2404 }
2405
buildComTlbIndex()2406 void IUnknownWrapper_Impl::buildComTlbIndex()
2407 {
2408 if ( ! m_bComTlbIndexInit)
2409 {
2410 MutexGuard guard(getBridgeMutex());
2411 {
2412 if ( ! m_bComTlbIndexInit)
2413 {
2414 OUString sError;
2415 ITypeInfo* pType= getTypeInfo();
2416 TypeAttr typeAttr(pType);
2417 if( SUCCEEDED( pType->GetTypeAttr( &typeAttr)))
2418 {
2419 for( long i= 0; i < typeAttr->cFuncs; i++)
2420 {
2421 FuncDesc funcDesc(pType);
2422 if( SUCCEEDED( pType->GetFuncDesc( i, &funcDesc)))
2423 {
2424 CComBSTR memberName;
2425 unsigned int pcNames=0;
2426 if( SUCCEEDED(pType->GetNames( funcDesc->memid, & memberName, 1, &pcNames)))
2427 {
2428 OUString usName(reinterpret_cast<const sal_Unicode*>(LPCOLESTR(memberName)));
2429 m_mapComFunc.insert( TLBFuncIndexMap::value_type( usName, i));
2430 }
2431 else
2432 {
2433 sError = OUSTR("[automation bridge] IUnknownWrapper_Impl::buildComTlbIndex, " \
2434 "ITypeInfo::GetNames failed.");
2435 }
2436 }
2437 else
2438 sError = OUSTR("[automation bridge] IUnknownWrapper_Impl::buildComTlbIndex, " \
2439 "ITypeInfo::GetFuncDesc failed.");
2440 }
2441
2442 //If we create an Object in JScript and a a property then it
2443 //has VARDESC instead of FUNCDESC
2444 for (long i = 0; i < typeAttr->cVars; i++)
2445 {
2446 VarDesc varDesc(pType);
2447 if (SUCCEEDED(pType->GetVarDesc(i, & varDesc)))
2448 {
2449 CComBSTR memberName;
2450 unsigned int pcNames = 0;
2451 if (SUCCEEDED(pType->GetNames(varDesc->memid, & memberName, 1, &pcNames)))
2452 {
2453 if (varDesc->varkind == VAR_DISPATCH)
2454 {
2455 OUString usName(reinterpret_cast<const sal_Unicode*>(LPCOLESTR(memberName)));
2456 m_mapComFunc.insert(TLBFuncIndexMap::value_type(
2457 usName, i));
2458 }
2459 }
2460 else
2461 {
2462 sError = OUSTR("[automation bridge] IUnknownWrapper_Impl::buildComTlbIndex, " \
2463 "ITypeInfo::GetNames failed.");
2464 }
2465 }
2466 else
2467 sError = OUSTR("[automation bridge] IUnknownWrapper_Impl::buildComTlbIndex, " \
2468 "ITypeInfo::GetVarDesc failed.");
2469
2470 }
2471 }
2472 else
2473 sError = OUSTR("[automation bridge] IUnknownWrapper_Impl::buildComTlbIndex, " \
2474 "ITypeInfo::GetTypeAttr failed.");
2475
2476 if (sError.getLength())
2477 {
2478 throw BridgeRuntimeError(sError);
2479 }
2480
2481 m_bComTlbIndexInit = true;
2482 }
2483 }
2484 }
2485 }
2486
getTypeInfo()2487 ITypeInfo* IUnknownWrapper_Impl::getTypeInfo()
2488 {
2489 if( !m_spDispatch)
2490 {
2491 throw BridgeRuntimeError(OUSTR("The object has no IDispatch interface!"));
2492 }
2493
2494 if( !m_spTypeInfo )
2495 {
2496 MutexGuard guard(getBridgeMutex());
2497 if( ! m_spTypeInfo)
2498 {
2499 CComPtr< ITypeInfo > spType;
2500 if( SUCCEEDED( m_spDispatch->GetTypeInfo( 0, LOCALE_USER_DEFAULT, &spType.p)))
2501
2502 {
2503 OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
2504
2505 //If this is a dual interface then TYPEATTR::typekind is usually TKIND_INTERFACE
2506 //We need to get the type description for TKIND_DISPATCH
2507 TypeAttr typeAttr(spType.p);
2508 if( SUCCEEDED(spType->GetTypeAttr( &typeAttr)))
2509 {
2510 if (typeAttr->typekind == TKIND_INTERFACE &&
2511 typeAttr->wTypeFlags & TYPEFLAG_FDUAL)
2512 {
2513 HREFTYPE refDispatch;
2514 if (SUCCEEDED(spType->GetRefTypeOfImplType(::sal::static_int_cast< UINT, int >( -1 ), &refDispatch)))
2515 {
2516 CComPtr<ITypeInfo> spTypeDisp;
2517 if (SUCCEEDED(spType->GetRefTypeInfo(refDispatch, & spTypeDisp)))
2518 m_spTypeInfo= spTypeDisp;
2519 }
2520 else
2521 {
2522 throw BridgeRuntimeError(
2523 OUSTR("[automation bridge] Could not obtain type information "
2524 "for dispatch interface." ));
2525 }
2526 }
2527 else if (typeAttr->typekind == TKIND_DISPATCH)
2528 {
2529 m_spTypeInfo= spType;
2530 }
2531 else
2532 {
2533 throw BridgeRuntimeError(
2534 OUSTR("[automation bridge] Automation object does not "
2535 "provide type information."));
2536 }
2537 }
2538 }
2539 else
2540 {
2541 throw BridgeRuntimeError(OUSTR("[automation bridge]The dispatch object does not "
2542 "support ITypeInfo!"));
2543 }
2544 }
2545 }
2546 return m_spTypeInfo;
2547 }
2548
2549 } // end namespace
2550
2551