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
27 #include "ole2uno.hxx"
28 #include <stdio.h>
29 #include <tools/presys.h>
30 #include <olectl.h>
31 #include <vector>
32 #include <list>
33 #include <hash_map>
34 #include "comifaces.hxx"
35 #include <tools/postsys.h>
36
37
38 #include <vos/diagnose.hxx>
39 #include <vos/refernce.hxx>
40 #include <tools/debug.hxx>
41 #include <rtl/ustring.hxx>
42 #include <com/sun/star/beans/MethodConcept.hpp>
43 #include <com/sun/star/beans/PropertyConcept.hpp>
44 #include <com/sun/star/script/FailReason.hpp>
45 #include <com/sun/star/reflection/ParamInfo.hpp>
46 #include <com/sun/star/beans/XExactName.hpp>
47 #include <com/sun/star/container/NoSuchElementException.hpp>
48
49 #include <com/sun/star/beans/XMaterialHolder.hpp>
50 #include <com/sun/star/script/XInvocation2.hpp>
51 #include <com/sun/star/script/MemberType.hpp>
52 #include <com/sun/star/reflection/XIdlReflection.hpp>
53 #include <osl/interlck.h>
54 #include <com/sun/star/uno/genfunc.h>
55 #include <cppuhelper/implbase1.hxx>
56
57 #include "comifaces.hxx"
58 #include "jscriptclasses.hxx"
59 #include "unotypewrapper.hxx"
60 #include "oleobjw.hxx"
61 #include "unoobjw.hxx"
62 #include "servprov.hxx"
63
64 using namespace vos;
65 using namespace std;
66 using namespace rtl;
67 using namespace osl;
68 using namespace cppu;
69 using namespace com::sun::star::uno;
70 using namespace com::sun::star::beans;
71 using namespace com::sun::star::container;
72 using namespace com::sun::star::script;
73 using namespace com::sun::star::lang;
74 using namespace com::sun::star::bridge::ModelDependent;
75 using namespace com::sun::star::reflection;
76
77
78
79 #if _MSC_VER < 1200
80 extern "C" const GUID IID_IDispatchEx;
81 #endif
82
83 namespace ole_adapter
84 {
85 hash_map<sal_uInt32, WeakReference<XInterface> > UnoObjToWrapperMap;
86 static sal_Bool writeBackOutParameter(VARIANTARG* pDest, VARIANT* pSource);
87 static sal_Bool writeBackOutParameter2( VARIANTARG* pDest, VARIANT* pSource);
88 static HRESULT mapCannotConvertException( CannotConvertException e, unsigned int * puArgErr);
89
90
91 /* Does not throw any exceptions.
92 Param pInfo can be NULL.
93 */
writeExcepinfo(EXCEPINFO * pInfo,const OUString & message)94 static void writeExcepinfo(EXCEPINFO * pInfo, const OUString& message)
95 {
96 if (pInfo != NULL)
97 {
98 pInfo->wCode = UNO_2_OLE_EXCEPTIONCODE;
99 pInfo->bstrSource = SysAllocString(L"[automation bridge] ");
100 pInfo->bstrDescription = SysAllocString(reinterpret_cast<LPCOLESTR>(message.getStr()));
101 }
102 }
103
104 /*****************************************************************************
105
106 class implementation: InterfaceOleWrapper_Impl
107
108 *****************************************************************************/
InterfaceOleWrapper_Impl(Reference<XMultiServiceFactory> & xFactory,sal_uInt8 unoWrapperClass,sal_uInt8 comWrapperClass)109 InterfaceOleWrapper_Impl::InterfaceOleWrapper_Impl( Reference<XMultiServiceFactory>& xFactory,
110 sal_uInt8 unoWrapperClass, sal_uInt8 comWrapperClass):
111 m_defaultValueType( 0),
112 UnoConversionUtilities<InterfaceOleWrapper_Impl>( xFactory, unoWrapperClass, comWrapperClass)
113 {
114 }
115
~InterfaceOleWrapper_Impl()116 InterfaceOleWrapper_Impl::~InterfaceOleWrapper_Impl()
117 {
118 MutexGuard guard(getBridgeMutex());
119 // remove entries in global map
120 IT_Uno it= UnoObjToWrapperMap.find( (sal_uInt32) m_xOrigin.get());
121 if(it != UnoObjToWrapperMap.end())
122 UnoObjToWrapperMap.erase(it);
123 #if OSL_DEBUG_LEVEL > 0
124 fprintf(stderr,"[automation bridge] UnoObjToWrapperMap contains: %i \n",
125 UnoObjToWrapperMap.size());
126 #endif
127
128 }
129
QueryInterface(REFIID riid,LPVOID FAR * ppv)130 STDMETHODIMP InterfaceOleWrapper_Impl::QueryInterface(REFIID riid, LPVOID FAR * ppv)
131 {
132 HRESULT ret= S_OK;
133
134 if( !ppv)
135 return E_POINTER;
136
137 if(IsEqualIID(riid, IID_IUnknown))
138 {
139 AddRef();
140 *ppv = (IUnknown*) (IDispatch*) this;
141 }
142 else if (IsEqualIID(riid, IID_IDispatch))
143 {
144 AddRef();
145 *ppv = (IDispatch*) this;
146 }
147 else if( IsEqualIID( riid, __uuidof( IUnoObjectWrapper)))
148 {
149 AddRef();
150 *ppv= (IUnoObjectWrapper*) this;
151 }
152 else
153 ret= E_NOINTERFACE;
154 return ret;
155 }
156
STDMETHODIMP_(ULONG)157 STDMETHODIMP_(ULONG) InterfaceOleWrapper_Impl::AddRef()
158 {
159 acquire();
160 // does not need to guard because one should not rely on the return value of
161 // AddRef anyway
162 return m_refCount;
163 }
164
STDMETHODIMP_(ULONG)165 STDMETHODIMP_(ULONG) InterfaceOleWrapper_Impl::Release()
166 {
167 ULONG n= m_refCount;
168 release();
169 return n - 1;
170 }
171
172 // IUnoObjectWrapper --------------------------------------------------------
getWrapperXInterface(Reference<XInterface> * pXInt)173 STDMETHODIMP InterfaceOleWrapper_Impl::getWrapperXInterface( Reference<XInterface>* pXInt)
174 {
175 *pXInt= Reference<XInterface>( static_cast<XWeak*>( this), UNO_QUERY);
176 return pXInt->is() ? S_OK : E_FAIL;
177 }
getOriginalUnoObject(Reference<XInterface> * pXInt)178 STDMETHODIMP InterfaceOleWrapper_Impl::getOriginalUnoObject( Reference<XInterface>* pXInt)
179 {
180 *pXInt= m_xOrigin;
181 return m_xOrigin.is() ? S_OK : E_FAIL;
182 }
getOriginalUnoStruct(Any * pStruct)183 STDMETHODIMP InterfaceOleWrapper_Impl::getOriginalUnoStruct( Any * pStruct)
184 {
185 HRESULT ret= E_FAIL;
186 if( !m_xOrigin.is())
187 {
188 Reference<XMaterialHolder> xMatHolder( m_xInvocation, UNO_QUERY);
189 if( xMatHolder.is())
190 {
191 Any any = xMatHolder->getMaterial();
192 if( any.getValueTypeClass() == TypeClass_STRUCT)
193 {
194 *pStruct= any;
195 ret= S_OK;
196 }
197 }
198 }
199 return ret;
200 }
201
GetTypeInfoCount(unsigned int *)202 STDMETHODIMP InterfaceOleWrapper_Impl::GetTypeInfoCount( unsigned int * /*pctinfo*/ )
203 {
204 return E_NOTIMPL ;
205 }
206
GetTypeInfo(unsigned int,LCID,ITypeInfo **)207 STDMETHODIMP InterfaceOleWrapper_Impl::GetTypeInfo(unsigned int /*itinfo*/, LCID /*lcid*/, ITypeInfo ** /*pptinfo*/)
208 {
209 return E_NOTIMPL;
210 }
211
GetIDsOfNames(REFIID,OLECHAR ** rgszNames,unsigned int cNames,LCID,DISPID * rgdispid)212 STDMETHODIMP InterfaceOleWrapper_Impl::GetIDsOfNames(REFIID /*riid*/,
213 OLECHAR ** rgszNames,
214 unsigned int cNames,
215 LCID /*lcid*/,
216 DISPID * rgdispid )
217 {
218 HRESULT ret = DISP_E_UNKNOWNNAME;
219 try
220 {
221 MutexGuard guard( getBridgeMutex());
222 if( ! rgdispid)
223 return E_POINTER;
224
225 // ----------------------------------------
226 if( ! _wcsicmp( *rgszNames, JSCRIPT_VALUE_FUNC) ||
227 ! _wcsicmp( *rgszNames, BRIDGE_VALUE_FUNC))
228 {
229 *rgdispid= DISPID_JSCRIPT_VALUE_FUNC;
230 return S_OK;
231 }
232 else if( ! _wcsicmp( *rgszNames, GET_STRUCT_FUNC) ||
233 ! _wcsicmp( *rgszNames, BRIDGE_GET_STRUCT_FUNC))
234 {
235 *rgdispid= DISPID_GET_STRUCT_FUNC;
236 return S_OK;
237 }
238 else if( ! _wcsicmp( *rgszNames, BRIDGE_CREATE_TYPE_FUNC))
239 {
240 *rgdispid= DISPID_CREATE_TYPE_FUNC;
241 return S_OK;
242 }
243
244 // ----------------------------------------
245 if (m_xInvocation.is() && (cNames > 0))
246 {
247 OUString name(reinterpret_cast<const sal_Unicode*>(rgszNames[0]));
248 NameToIdMap::iterator iter = m_nameToDispIdMap.find(name);
249
250 if (iter == m_nameToDispIdMap.end())
251 {
252 OUString exactName;
253
254 if (m_xExactName.is())
255 {
256 exactName = m_xExactName->getExactName(name);
257 }
258 else
259 {
260 exactName = name;
261 }
262
263 MemberInfo d(0, exactName);
264
265 if (m_xInvocation->hasProperty(exactName))
266 {
267 d.flags |= DISPATCH_PROPERTYGET;
268 d.flags |= DISPATCH_PROPERTYPUT;
269 d.flags |= DISPATCH_PROPERTYPUTREF;
270 }
271
272 if (m_xInvocation->hasMethod(exactName))
273 {
274 d.flags |= DISPATCH_METHOD;
275 }
276
277 if (d.flags != 0)
278 {
279 m_MemberInfos.push_back(d);
280 iter = m_nameToDispIdMap.insert(NameToIdMap::value_type(exactName, (DISPID)m_MemberInfos.size())).first;
281
282 if (exactName != name)
283 {
284 iter = m_nameToDispIdMap.insert(NameToIdMap::value_type(name, (DISPID)m_MemberInfos.size())).first;
285 }
286 }
287 }
288
289 if (iter == m_nameToDispIdMap.end())
290 {
291 ret = DISP_E_UNKNOWNNAME;
292 }
293 else
294 {
295 *rgdispid = (*iter).second;
296 ret = S_OK;
297 }
298 }
299 }
300 catch(BridgeRuntimeError& )
301 {
302 OSL_ASSERT(0);
303 }
304 catch(Exception& )
305 {
306 OSL_ASSERT(0);
307 }
308 catch(...)
309 {
310 OSL_ASSERT(0);
311 }
312
313 return ret;
314 }
315
316 // "convertDispparamsArgs" converts VARIANTS to their respecting Any counterparts
317 // The parameters "id", "wFlags" and "pdispparams" equal those as used in
318 // IDispatch::Invoke. The function handles special JavaScript
319 // cases where a VARIANT of type VT_DISPATCH is ambiguous and could represent
320 // an object, array ( JavaScript Array object), out parameter and in/out ( JavaScript Array object)
321 // parameter (JavaScript Array object)
322 // Because all those VT_DISPATCH objects need a different conversion
323 // we have to find out what the object is supposed to be. The function does this
324 // by either using type information or by help of a specialized ValueObject object.
325
326 // A. Type Information
327 // -----------------------------------------------------------------------------
328 // With the help of type information the kind of parameter can be exactly determined
329 // and an appropriate conversion can be chosen. A problem arises if a method expects
330 // an Any. Then the type info does not tell what the type of the value, that is kept
331 // by the any, should be. In this situation the decision wheter the param is a
332 // sequence or an object is made upon the fact if the object has a property "0"
333 // ( see function "isJScriptArray"). Since this is unsafe it is recommended to use
334 // the JScript value objects within a JScript script on such an occasion.
335
336 // B. JavaScript Value Object ( class JScriptValue )
337 // -----------------------------------------------------------------------------
338 // A JScriptValue (ValueObject) object is a COM object in that it implements IDispatch and the
339 // IJScriptValue object interface. Such objects are provided by all UNO wrapper
340 // objects used within a JScript script. To obtain an instance one has to call
341 // "_GetValueObject() or Bridge_GetValueObject()" on an UNO wrapper object (class InterfaceOleWrapper_Impl).
342 // A value object is appropriately initialized within the script and passed as
343 // parameter to an UNO object method or property. The convertDispparamsArgs function
344 // can easily find out that a param is such an object by queriing for the
345 // IJScriptValue interface. By this interface one the type and kind ( out, in/out)
346 // can be determined and the right conversion can be applied.
347 // Using ValueObjects we spare us the effort of acquiring and examining type information
348 // in order to figure out what the an IDispatch parameter is meant for.
349
350 // Normal JScript object parameter can be mixed with JScriptValue object. If an
351 // VARIANT contains an VT_DISPATCH that is no JScriptValue than the type information
352 // is used to find out about the reqired type.
convertDispparamsArgs(DISPID id,unsigned short,DISPPARAMS * pdispparams,Sequence<Any> & rSeq)353 void InterfaceOleWrapper_Impl::convertDispparamsArgs(DISPID id,
354 unsigned short /*wFlags*/, DISPPARAMS* pdispparams, Sequence<Any>& rSeq)
355 {
356 HRESULT hr= S_OK;
357 sal_Int32 countArgs= pdispparams->cArgs;
358 if( countArgs == 0)
359 return;
360
361 rSeq.realloc( countArgs);
362 Any* pParams = rSeq.getArray();
363
364 Any anyParam;
365
366 //Get type information for the current call
367 InvocationInfo info;
368 if( ! getInvocationInfoForCall( id, info))
369 throw BridgeRuntimeError(
370 OUSTR("[automation bridge]InterfaceOleWrapper_Impl::convertDispparamsArgs \n"
371 "Could not obtain type information for current call."));
372
373 for (int i = 0; i < countArgs; i++)
374 {
375 if (info.eMemberType == MemberType_METHOD &&
376 info.aParamModes[ countArgs - i -1 ] == ParamMode_OUT)
377 continue;
378
379 if(convertValueObject( & pdispparams->rgvarg[i], anyParam))
380 { //a param is a ValueObject and could be converted
381 pParams[countArgs - (i + 1)] = anyParam;
382 continue;
383 }
384
385 // If the param is an out, in/out parameter in
386 // JScript (Array object, with value at index 0) then we
387 // extract Array[0] and put the value into varParam. At the end of the loop varParam
388 // is converted if it contains a value otherwise the VARIANT from
389 // DISPPARAMS is converted.
390 CComVariant varParam;
391
392 // Check for JScript out and in/out paramsobjects (VT_DISPATCH).
393 // To find them out we use typeinformation of the function being called.
394 if( pdispparams->rgvarg[i].vt == VT_DISPATCH )
395 {
396 if( info.eMemberType == MemberType_METHOD && info.aParamModes[ countArgs - i -1 ] == ParamMode_INOUT)
397 {
398 // INOUT-param
399 // Index ( property) "0" contains the actual IN-param. The object is a JScript
400 // Array object.
401 // Get the IN-param at index "0"
402 IDispatch* pdisp= pdispparams->rgvarg[i].pdispVal;
403
404 OLECHAR* sindex= L"0";
405 DISPID id;
406 DISPPARAMS noParams= {0,0,0,0};
407 if(SUCCEEDED( hr= pdisp->GetIDsOfNames( IID_NULL, &sindex, 1, LOCALE_USER_DEFAULT, &id)))
408 hr= pdisp->Invoke( id, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET,
409 & noParams, & varParam, NULL, NULL);
410 if( FAILED( hr))
411 {
412 throw BridgeRuntimeError(
413 OUSTR("[automation bridge] Could not determine "
414 "if the object has a member \"0\". Error: ") +
415 OUString::valueOf(hr));
416 }
417 }
418 }
419
420 if( varParam.vt == VT_EMPTY) // then it was no in/out parameter
421 varParam= pdispparams->rgvarg[i];
422
423 if(info.eMemberType == MemberType_METHOD)
424 variantToAny( & varParam, anyParam,
425 info.aParamTypes[ countArgs - i - 1]);
426 else if(info.eMemberType == MemberType_PROPERTY)
427 variantToAny( & varParam, anyParam, info.aType);
428 else
429 OSL_ASSERT(0);
430
431 pParams[countArgs - (i + 1)]= anyParam;
432 }// end for / iterating over all parameters
433 }
434
getInvocationInfoForCall(DISPID id,InvocationInfo & info)435 sal_Bool InterfaceOleWrapper_Impl::getInvocationInfoForCall( DISPID id, InvocationInfo& info)
436 {
437 sal_Bool bTypesAvailable= sal_False;
438
439 if( !m_xInvocation.is() )return false;
440 Reference<XInvocation2> inv2( m_xInvocation, UNO_QUERY);
441 if( inv2.is())
442 {
443 // We need the name of the property or method to get its type information.
444 // The name can be identified through the param "id"
445 // that is kept as value in the map m_nameToDispIdMap.
446 // Proplem: the Windows JScript engine sometimes changes small letters to capital
447 // letters as happens in xidlclass_obj.createObject( var) // in JScript.
448 // IDispatch::GetIdsOfNames is then called with "CreateObject" !!!
449 // m_nameToDispIdMap can contain several names for one DISPID but only one is
450 // the exact one. If there's no m_xExactName and therefore no exact name then
451 // there's only one entry in the map.
452 typedef NameToIdMap::const_iterator cit;
453 OUString sMemberName;
454
455 for(cit ci1= m_nameToDispIdMap.begin(); ci1 != m_nameToDispIdMap.end(); ci1++)
456 {
457 if( (*ci1).second == id) // iterator is a pair< OUString, DISPID>
458 {
459 sMemberName= (*ci1).first;
460 break;
461 }
462 }
463 // Get information for the current call ( property or method).
464 // There could be similar names which only differ in the cases
465 // of letters. First we assume that the name which was passed into
466 // GetIDsOfNames is correct. If we won't get information with that
467 // name then we have the invocation service use the XExactName interface.
468 sal_Bool validInfo= sal_True;
469 InvocationInfo invInfo;
470 try{
471 invInfo= inv2->getInfoForName( sMemberName, sal_False);
472 }
473 catch( IllegalArgumentException )
474 {
475 validInfo= sal_False;
476 }
477
478 if( ! validInfo)
479 {
480 invInfo= inv2->getInfoForName( sMemberName, sal_True);
481 }
482 if( invInfo.aName.pData)
483 {
484 bTypesAvailable= sal_True;
485 info= invInfo;
486 }
487 }
488 return bTypesAvailable;
489 }
490 // XBridgeSupplier2 ---------------------------------------------------
491 // only bridges itself ( this instance of InterfaceOleWrapper_Impl)from UNO to IDispatch
492 // If sourceModelType is UNO than any UNO interface implemented by InterfaceOleWrapper_Impl
493 // can bridged to IDispatch ( if destModelType == OLE). The IDispatch is
494 // implemented by this class.
createBridge(const Any & modelDepObject,const Sequence<sal_Int8> &,sal_Int16 sourceModelType,sal_Int16 destModelType)495 Any SAL_CALL InterfaceOleWrapper_Impl::createBridge(const Any& modelDepObject,
496 const Sequence<sal_Int8>& /*ProcessId*/,
497 sal_Int16 sourceModelType,
498 sal_Int16 destModelType)
499 throw (IllegalArgumentException, RuntimeException)
500 {
501
502 Any retAny;
503 if( sourceModelType == UNO && destModelType == OLE &&
504 modelDepObject.getValueTypeClass() == TypeClass_INTERFACE )
505 {
506 Reference<XInterface> xInt;
507 if( modelDepObject >>= xInt )
508 {
509 if( xInt == Reference<XInterface>( static_cast<XWeak*>( this), UNO_QUERY))
510 {
511 VARIANT *pVar= (VARIANT*)CoTaskMemAlloc( sizeof( VARIANT));
512 if( pVar)
513 {
514 pVar->vt= VT_DISPATCH;
515 pVar->pdispVal= static_cast<IDispatch*>( this);
516 AddRef();
517
518 retAny<<= reinterpret_cast< sal_uInt32 >( pVar);
519 }
520 }
521 }
522 }
523
524 return retAny;
525 }
526
527
528 // XInitialization --------------------------------------------------
initialize(const Sequence<Any> & aArguments)529 void SAL_CALL InterfaceOleWrapper_Impl::initialize( const Sequence< Any >& aArguments )
530 throw(Exception, RuntimeException)
531 {
532 switch( aArguments.getLength() )
533 {
534 case 2: // the object wraps an UNO struct
535 aArguments[0] >>= m_xInvocation;
536 aArguments[1] >>= m_defaultValueType;
537 break;
538 case 3: // the object wraps an UNO interface
539 aArguments[0] >>= m_xInvocation;
540 aArguments[1] >>= m_xOrigin;
541 aArguments[2] >>= m_defaultValueType;
542 break;
543 }
544
545 m_xExactName= Reference<XExactName>( m_xInvocation, UNO_QUERY);
546 }
547
createUnoWrapperInstance()548 Reference< XInterface > InterfaceOleWrapper_Impl::createUnoWrapperInstance()
549 {
550 Reference<XWeak> xWeak= static_cast<XWeak*>( new InterfaceOleWrapper_Impl(
551 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass));
552 return Reference<XInterface>( xWeak, UNO_QUERY);
553 }
554
createComWrapperInstance()555 Reference<XInterface> InterfaceOleWrapper_Impl::createComWrapperInstance()
556 {
557 Reference<XWeak> xWeak= static_cast<XWeak*>( new IUnknownWrapper_Impl(
558 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass));
559 return Reference<XInterface>( xWeak, UNO_QUERY);
560 }
561
562
563
564 // "getType" is used in convertValueObject to map the string denoting the type
565 // to an actual Type object.
getType(const BSTR name,Type & type)566 bool getType( const BSTR name, Type & type)
567 {
568 Type retType;
569 bool ret = false;
570 typelib_TypeDescription * pDesc= NULL;
571 OUString str( reinterpret_cast<const sal_Unicode*>(name));
572 typelib_typedescription_getByName( &pDesc, str.pData );
573 if( pDesc)
574 {
575 type = Type( pDesc->pWeakRef );
576 typelib_typedescription_release( pDesc);
577 ret = true;
578 }
579 return ret;
580 }
581
writeBackOutParameter2(VARIANTARG * pDest,VARIANT * pSource)582 static sal_Bool writeBackOutParameter2( VARIANTARG* pDest, VARIANT* pSource)
583 {
584 sal_Bool ret = sal_False;
585 HRESULT hr;
586
587 // Handle JScriptValue objects and JScript out params ( Array object )
588 CComVariant varDest( *pDest);
589
590 if( SUCCEEDED( varDest.ChangeType(VT_DISPATCH)))
591 {
592 CComPtr<IDispatch> spDispDest(varDest.pdispVal);
593
594 // special Handling for a JScriptValue object
595 #ifdef __MINGW32__
596 CComQIPtr<IJScriptValueObject, &__uuidof(IJScriptValueObject)> spValueDest(spDispDest);
597 #else
598 CComQIPtr<IJScriptValueObject> spValueDest(spDispDest);
599 #endif
600 if (spValueDest)
601 {
602 VARIANT_BOOL varBool= VARIANT_FALSE;
603 if( SUCCEEDED( hr= spValueDest->IsOutParam( &varBool) )
604 && varBool == VARIANT_TRUE ||
605 SUCCEEDED(hr= spValueDest->IsInOutParam( &varBool) )
606 && varBool == VARIANT_TRUE )
607 {
608 if( SUCCEEDED( spValueDest->Set( CComVariant(), *pSource)))
609 ret= sal_True;
610 }
611 }
612 else if (pDest->vt == VT_DISPATCH)// VT_DISPATCH -> JScript out param
613 {
614 // We use IDispatchEx because its GetDispID function causes the creation
615 // of a property if it does not exist already. This is convenient for
616 // out parameters in JScript. Then the user must not specify propery "0"
617 // explicitly
618 #ifdef __MINGW32__
619 CComQIPtr<IDispatchEx, &__uuidof(IDispatchEx)> spDispEx( spDispDest);
620 #else
621 CComQIPtr<IDispatchEx> spDispEx( spDispDest);
622 #endif
623 if( spDispEx)
624 {
625 CComBSTR nullProp(L"0");
626 DISPID dwDispID;
627 if( SUCCEEDED( spDispEx->GetDispID( nullProp, fdexNameEnsure, &dwDispID)))
628 {
629 DISPPARAMS dispparams = {NULL, NULL, 1, 1};
630 dispparams.rgvarg = pSource;
631 DISPID dispidPut = DISPID_PROPERTYPUT;
632 dispparams.rgdispidNamedArgs = &dispidPut;
633
634 if (pSource->vt == VT_UNKNOWN || pSource->vt == VT_DISPATCH ||
635 (pSource->vt & VT_ARRAY) || (pSource->vt & VT_BYREF))
636 hr = spDispEx->InvokeEx(dwDispID, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUTREF,
637 &dispparams, NULL, NULL, NULL);
638 else
639 hr= spDispEx->InvokeEx(dwDispID, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUT,
640 &dispparams, NULL, NULL, NULL);
641 if( SUCCEEDED(hr))
642 ret= sal_True;
643 }
644 }
645 }
646 else
647 ret= writeBackOutParameter( pDest, pSource);
648 }
649 else // The param can't be a JScript out-parameter ( an Array object), it could be a VBScript
650 { // param. The function checks itself for correct VBScript params
651 ret= writeBackOutParameter( pDest, pSource);
652 }
653 return ret;
654 }
655 // VisualBasic Script passes arguments as VT_VARIANT | VT_BYREF be it in or out parameter.
656 // Thus we are in charge of freeing an eventual value contained by the inner VARIANT
657 // Please note: VariantCopy doesn't free a VT_BYREF value
658 // The out parameters are expected to have always a valid type
writeBackOutParameter(VARIANTARG * pDest,VARIANT * pSource)659 static sal_Bool writeBackOutParameter(VARIANTARG* pDest, VARIANT* pSource)
660 {
661 HRESULT hr;
662 sal_Bool ret = FALSE;
663 // Out parameter must be VT_BYREF
664 if ((V_VT(pDest) & VT_BYREF) != 0 )
665 {
666 VARTYPE oleTypeFlags = V_VT(pSource);
667
668 // if caller accept VARIANT as out parameter, any value must be converted
669 if (V_VT(pDest) == (VT_VARIANT | VT_BYREF))
670 {
671 // When the user provides a VARIANT rather then a concrete type
672 // we just copy the source to the out, in/out parameter
673 // VT_DISPATCH, VT_UNKNOWN, VT_ARRAY, VT_BSTR in the VARIANT that
674 // is contained in pDest are released by VariantCopy
675 VariantCopy(V_VARIANTREF(pDest), pSource);
676 ret = sal_True;
677 }
678 else
679 {
680 // variantarg and variant must have same type
681 if ((V_VT(pDest) & oleTypeFlags) == oleTypeFlags)
682 {
683 if ((oleTypeFlags & VT_ARRAY) != 0)
684 {
685 // In / Out Param
686 if( *V_ARRAYREF(pDest) != NULL)
687 hr= SafeArrayCopyData( V_ARRAY(pSource), *V_ARRAYREF(pDest));
688 else
689 // Out Param
690 hr= SafeArrayCopy(V_ARRAY(pSource), V_ARRAYREF(pDest)) == NOERROR;
691 if( SUCCEEDED( hr))
692 ret = sal_True;
693 }
694 else
695 {
696 // copy base type
697 switch (V_VT(pSource))
698 {
699 case VT_I2:
700 {
701 *V_I2REF(pDest) = V_I2(pSource);
702 ret = sal_True;
703 break;
704 }
705 case VT_I4:
706 *V_I4REF(pDest) = V_I4(pSource);
707 ret = sal_True;
708 break;
709 case VT_R4:
710 *V_R4REF(pDest) = V_R4(pSource);
711 ret = sal_True;
712 break;
713 case VT_R8:
714 *V_R8REF(pDest) = V_R8(pSource);
715 ret = sal_True;
716 break;
717 case VT_CY:
718 *V_CYREF(pDest) = V_CY(pSource);
719 ret = sal_True;
720 break;
721 case VT_DATE:
722 *V_DATEREF(pDest) = V_DATE(pSource);
723 ret = sal_True;
724 break;
725 case VT_BSTR:
726 SysFreeString( *pDest->pbstrVal);
727
728 *V_BSTRREF(pDest) = SysAllocString(V_BSTR(pSource));
729 ret = sal_True;
730 break;
731 case VT_DISPATCH:
732 if (*V_DISPATCHREF(pDest) != NULL)
733 (*V_DISPATCHREF(pDest))->Release();
734
735 *V_DISPATCHREF(pDest) = V_DISPATCH(pSource);
736
737 if (*V_DISPATCHREF(pDest) != NULL)
738 (*V_DISPATCHREF(pDest))->AddRef();
739
740 ret = sal_True;
741 break;
742 case VT_ERROR:
743 *V_ERRORREF(pDest) = V_ERROR(pSource);
744 ret = sal_True;
745 break;
746 case VT_BOOL:
747 *V_BOOLREF(pDest) = V_BOOL(pSource);
748 ret = sal_True;
749 break;
750 case VT_UNKNOWN:
751 if (*V_UNKNOWNREF(pDest) != NULL)
752 (*V_UNKNOWNREF(pDest))->Release();
753
754 *V_UNKNOWNREF(pDest) = V_UNKNOWN(pSource);
755
756 if (*V_UNKNOWNREF(pDest) != NULL)
757 (*V_UNKNOWNREF(pDest))->AddRef();
758
759 ret = sal_True;
760 break;
761 case VT_I1:
762 *V_I1REF(pDest) = V_I1(pSource);
763 ret = sal_True;
764 break;
765 case VT_UI1:
766 *V_UI1REF(pDest) = V_UI1(pSource);
767 ret = sal_True;
768 break;
769 case VT_UI2:
770 *V_UI2REF(pDest) = V_UI2(pSource);
771 ret = sal_True;
772 break;
773 case VT_UI4:
774 *V_UI4REF(pDest) = V_UI4(pSource);
775 ret = sal_True;
776 break;
777 case VT_INT:
778 *V_INTREF(pDest) = V_INT(pSource);
779 ret = sal_True;
780 break;
781 case VT_UINT:
782 *V_UINTREF(pDest) = V_UINT(pSource);
783 ret = sal_True;
784 break;
785 case VT_DECIMAL:
786 memcpy(pDest->pdecVal, pSource, sizeof(DECIMAL));
787 ret = sal_True;
788 break;
789 default:
790 break;
791 }
792 }
793 }
794 else
795 {
796 // Handling of special cases
797 // Destination and source types are different
798 if( pDest->vt == (VT_BSTR | VT_BYREF)
799 && pSource->vt == VT_I2)
800 {
801 // When the user provides a String as out our in/out parameter
802 // and the type is char (TypeClass_CHAR) then we convert to a BSTR
803 // instead of VT_I2 as is done otherwise
804 OLECHAR buff[]= {0,0};
805 buff[0]= pSource->iVal;
806
807 SysFreeString( *pDest->pbstrVal);
808 *pDest->pbstrVal= SysAllocString( buff);
809 ret = sal_True;
810 }
811 }
812 }
813 }
814 return ret;
815 }
816
Invoke(DISPID dispidMember,REFIID,LCID,unsigned short wFlags,DISPPARAMS * pdispparams,VARIANT * pvarResult,EXCEPINFO * pexcepinfo,unsigned int * puArgErr)817 STDMETHODIMP InterfaceOleWrapper_Impl::Invoke(DISPID dispidMember,
818 REFIID /*riid*/,
819 LCID /*lcid*/,
820 unsigned short wFlags,
821 DISPPARAMS * pdispparams,
822 VARIANT * pvarResult,
823 EXCEPINFO * pexcepinfo,
824 unsigned int * puArgErr )
825 {
826 HRESULT ret = S_OK;
827
828 try
829 {
830 sal_Bool bHandled= sal_False;
831 ret= InvokeGeneral( dispidMember, wFlags, pdispparams, pvarResult, pexcepinfo,
832 puArgErr, bHandled);
833 if( bHandled)
834 return ret;
835
836 if ((dispidMember > 0) && ((size_t)dispidMember <= m_MemberInfos.size()) && m_xInvocation.is())
837 {
838 MemberInfo d = m_MemberInfos[dispidMember - 1];
839 DWORD flags = wFlags & d.flags;
840
841 if (flags != 0)
842 {
843 if ((flags & DISPATCH_METHOD) != 0)
844 {
845 if (pdispparams->cNamedArgs > 0)
846 ret = DISP_E_NONAMEDARGS;
847 else
848 {
849 Sequence<Any> params;
850
851 convertDispparamsArgs(dispidMember, wFlags, pdispparams , params );
852
853 ret= doInvoke(pdispparams, pvarResult,
854 pexcepinfo, puArgErr, d.name, params);
855 }
856 }
857 else if ((flags & DISPATCH_PROPERTYGET) != 0)
858 {
859 ret= doGetProperty( pdispparams, pvarResult,
860 pexcepinfo, d.name);
861 }
862 else if ((flags & DISPATCH_PROPERTYPUT || flags & DISPATCH_PROPERTYPUTREF) != 0)
863 {
864 if (pdispparams->cArgs != 1)
865 ret = DISP_E_BADPARAMCOUNT;
866 else
867 {
868 Sequence<Any> params;
869 convertDispparamsArgs(dispidMember, wFlags, pdispparams, params );
870 if(params.getLength() > 0)
871 ret= doSetProperty( pdispparams, pvarResult, pexcepinfo, puArgErr, d.name, params);
872 else
873 ret = DISP_E_BADVARTYPE;
874 }
875 }
876 }
877 else
878 ret= DISP_E_MEMBERNOTFOUND;
879 }
880 else
881 ret = DISP_E_MEMBERNOTFOUND;
882 }
883 catch(BridgeRuntimeError& e)
884 {
885 writeExcepinfo(pexcepinfo, e.message);
886 ret = DISP_E_EXCEPTION;
887 }
888 catch(Exception& e)
889 {
890 OUString message= OUSTR("InterfaceOleWrapper_Impl::Invoke : \n") +
891 e.Message;
892 writeExcepinfo(pexcepinfo, message);
893 ret = DISP_E_EXCEPTION;
894 }
895 catch(...)
896 {
897 OUString message= OUSTR("InterfaceOleWrapper_Impl::Invoke : \n"
898 "Unexpected exception");
899 writeExcepinfo(pexcepinfo, message);
900 ret = DISP_E_EXCEPTION;
901 }
902
903 return ret;
904 }
905
doInvoke(DISPPARAMS * pdispparams,VARIANT * pvarResult,EXCEPINFO * pexcepinfo,unsigned int * puArgErr,OUString & name,Sequence<Any> & params)906 HRESULT InterfaceOleWrapper_Impl::doInvoke( DISPPARAMS * pdispparams, VARIANT * pvarResult,
907 EXCEPINFO * pexcepinfo, unsigned int * puArgErr, OUString& name, Sequence<Any>& params)
908 {
909
910
911 HRESULT ret= S_OK;
912 try
913 {
914 Sequence<sal_Int16> outIndex;
915 Sequence<Any> outParams;
916 Any returnValue;
917
918 if (pdispparams->cNamedArgs > 0)
919 return DISP_E_NONAMEDARGS;
920
921 // invoke method and take care of exceptions
922 returnValue = m_xInvocation->invoke(name,
923 params,
924 outIndex,
925 outParams);
926
927 // try to write back out parameter
928 if (outIndex.getLength() > 0)
929 {
930 const sal_Int16* pOutIndex = outIndex.getConstArray();
931 const Any* pOutParams = outParams.getConstArray();
932
933 for (sal_Int32 i = 0; i < outIndex.getLength(); i++)
934 {
935 CComVariant variant;
936 // Currently a Sequence is converted to an SafeArray of VARIANTs.
937 anyToVariant( &variant, pOutParams[i]);
938
939 // out parameter need special handling if they are VT_DISPATCH
940 // and used in JScript
941 int outindex= pOutIndex[i];
942 writeBackOutParameter2(&(pdispparams->rgvarg[pdispparams->cArgs - 1 - outindex]),
943 &variant );
944 }
945 }
946
947 // write back return value
948 if (pvarResult != NULL)
949 anyToVariant(pvarResult, returnValue);
950 }
951 catch(IllegalArgumentException & e) //XInvocation::invoke
952 {
953 writeExcepinfo(pexcepinfo, e.Message);
954 ret = DISP_E_TYPEMISMATCH;
955 }
956 catch(CannotConvertException & e) //XInvocation::invoke
957 {
958 writeExcepinfo(pexcepinfo, e.Message);
959 ret = mapCannotConvertException( e, puArgErr);
960 }
961 catch(InvocationTargetException & e) //XInvocation::invoke
962 {
963 const Any& org = e.TargetException;
964 Exception excTarget;
965 org >>= excTarget;
966 OUString message=
967 org.getValueType().getTypeName() + OUSTR(": ") + excTarget.Message;
968 writeExcepinfo(pexcepinfo, message);
969 ret = DISP_E_EXCEPTION;
970 }
971 catch(NoSuchMethodException & e) //XInvocation::invoke
972 {
973 writeExcepinfo(pexcepinfo, e.Message);
974 ret = DISP_E_MEMBERNOTFOUND;
975 }
976 catch(BridgeRuntimeError & e)
977 {
978 writeExcepinfo(pexcepinfo, e.message);
979 ret = DISP_E_EXCEPTION;
980 }
981 catch(Exception & e)
982 {
983 OUString message= OUSTR("InterfaceOleWrapper_Impl::doInvoke : \n") +
984 e.Message;
985 writeExcepinfo(pexcepinfo, message);
986 ret = DISP_E_EXCEPTION;
987 }
988 catch( ... )
989 {
990 OUString message= OUSTR("InterfaceOleWrapper_Impl::doInvoke : \n"
991 "Unexpected exception");
992 writeExcepinfo(pexcepinfo, message);
993 ret = DISP_E_EXCEPTION;
994 }
995 return ret;
996 }
997
doGetProperty(DISPPARAMS *,VARIANT * pvarResult,EXCEPINFO * pexcepinfo,OUString & name)998 HRESULT InterfaceOleWrapper_Impl::doGetProperty( DISPPARAMS * /*pdispparams*/, VARIANT * pvarResult,
999 EXCEPINFO * pexcepinfo, OUString& name)
1000 {
1001 HRESULT ret= S_OK;
1002
1003 Any value;
1004 try
1005 {
1006 Any returnValue = m_xInvocation->getValue( name);
1007 // write back return value
1008 if (pvarResult)
1009 anyToVariant(pvarResult, returnValue);
1010 }
1011 catch(UnknownPropertyException e) //XInvocation::getValue
1012 {
1013 writeExcepinfo(pexcepinfo, e.Message);
1014 ret = DISP_E_MEMBERNOTFOUND;
1015 }
1016 catch(BridgeRuntimeError& e)
1017 {
1018 writeExcepinfo(pexcepinfo, e.message);
1019 ret = DISP_E_EXCEPTION;
1020 }
1021 catch(Exception& e)
1022 {
1023 OUString message= OUSTR("InterfaceOleWrapper_Impl::doGetProperty : \n") +
1024 e.Message;
1025 writeExcepinfo(pexcepinfo, message);
1026 }
1027 catch( ... )
1028 {
1029 OUString message= OUSTR("InterfaceOleWrapper_Impl::doInvoke : \n"
1030 "Unexpected exception");
1031 writeExcepinfo(pexcepinfo, message);
1032 ret = DISP_E_EXCEPTION;
1033 }
1034 return ret;
1035 }
1036
doSetProperty(DISPPARAMS *,VARIANT *,EXCEPINFO * pexcepinfo,unsigned int * puArgErr,OUString & name,Sequence<Any> params)1037 HRESULT InterfaceOleWrapper_Impl::doSetProperty( DISPPARAMS * /*pdispparams*/, VARIANT * /*pvarResult*/,
1038 EXCEPINFO * pexcepinfo, unsigned int * puArgErr, OUString& name, Sequence<Any> params)
1039 {
1040 HRESULT ret= S_OK;
1041
1042 try
1043 {
1044 m_xInvocation->setValue( name, params.getConstArray()[0]);
1045 }
1046 catch(UnknownPropertyException )
1047 {
1048 ret = DISP_E_MEMBERNOTFOUND;
1049 }
1050 catch(CannotConvertException e)
1051 {
1052 ret= mapCannotConvertException( e, puArgErr);
1053 }
1054 catch(InvocationTargetException e)
1055 {
1056 if (pexcepinfo != NULL)
1057 {
1058 Any org = e.TargetException;
1059
1060 pexcepinfo->wCode = UNO_2_OLE_EXCEPTIONCODE;
1061 pexcepinfo->bstrSource = SysAllocString(L"any ONE component");
1062 pexcepinfo->bstrDescription = SysAllocString(
1063 reinterpret_cast<LPCOLESTR>(org.getValueType().getTypeName().getStr()));
1064 }
1065 ret = DISP_E_EXCEPTION;
1066 }
1067 catch( ... )
1068 {
1069 ret= DISP_E_EXCEPTION;
1070 }
1071 return ret;
1072 }
1073
InvokeGeneral(DISPID dispidMember,unsigned short wFlags,DISPPARAMS * pdispparams,VARIANT * pvarResult,EXCEPINFO * pexcepinfo,unsigned int *,sal_Bool & bHandled)1074 HRESULT InterfaceOleWrapper_Impl::InvokeGeneral( DISPID dispidMember, unsigned short wFlags,
1075 DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo,
1076 unsigned int * /*puArgErr*/, sal_Bool& bHandled)
1077 {
1078 HRESULT ret= S_OK;
1079 try
1080 {
1081 // DISPID_VALUE | The DEFAULT Value is required in JScript when the situation
1082 // is that we put an object into an Array object ( out parameter). We have to return
1083 // IDispatch otherwise the object cannot be accessed from the Script.
1084 if( dispidMember == DISPID_VALUE && wFlags == DISPATCH_PROPERTYGET
1085 && m_defaultValueType != VT_EMPTY && pvarResult != NULL)
1086 {
1087 bHandled= sal_True;
1088 if( m_defaultValueType == VT_DISPATCH)
1089 {
1090 pvarResult->vt= VT_DISPATCH;
1091 pvarResult->pdispVal= static_cast<IDispatch*>( this);
1092 AddRef();
1093 ret= S_OK;
1094 }
1095 }
1096 // ---------
1097 // function: _GetValueObject
1098 else if( dispidMember == DISPID_JSCRIPT_VALUE_FUNC)
1099 {
1100 bHandled= sal_True;
1101 if( !pvarResult)
1102 ret= E_POINTER;
1103 CComObject< JScriptValue>* pValue;
1104 if( SUCCEEDED( CComObject<JScriptValue>::CreateInstance( &pValue)))
1105 {
1106 pValue->AddRef();
1107 pvarResult->vt= VT_DISPATCH;
1108 #ifdef __MINGW32__
1109 pvarResult->pdispVal= CComQIPtr<IDispatch, &__uuidof(IDispatch)>(pValue->GetUnknown());
1110 #else
1111 pvarResult->pdispVal= CComQIPtr<IDispatch>(pValue->GetUnknown());
1112 #endif
1113 ret= S_OK;
1114 }
1115 else
1116 ret= DISP_E_EXCEPTION;
1117 }
1118 else if( dispidMember == DISPID_GET_STRUCT_FUNC)
1119 {
1120 bHandled= sal_True;
1121 sal_Bool bStruct= sal_False;
1122
1123
1124 Reference<XInterface> xIntCore= m_smgr->createInstance( OUString::createFromAscii("com.sun.star.reflection.CoreReflection"));
1125 Reference<XIdlReflection> xRefl( xIntCore, UNO_QUERY);
1126 if( xRefl.is() )
1127 {
1128 // the first parameter is in DISPPARAMS rgvargs contains the name of the struct.
1129 CComVariant arg;
1130 if( pdispparams->cArgs == 1 && SUCCEEDED( arg.ChangeType( VT_BSTR, &pdispparams->rgvarg[0])) )
1131 {
1132 Reference<XIdlClass> classStruct= xRefl->forName( reinterpret_cast<const sal_Unicode*>(arg.bstrVal));
1133 if( classStruct.is())
1134 {
1135 Any anyStruct;
1136 classStruct->createObject( anyStruct);
1137 CComVariant var;
1138 anyToVariant( &var, anyStruct );
1139
1140 if( var.vt == VT_DISPATCH)
1141 {
1142 VariantCopy( pvarResult, & var);
1143 bStruct= sal_True;
1144 }
1145 }
1146 }
1147 }
1148 ret= bStruct == sal_True ? S_OK : DISP_E_EXCEPTION;
1149 }
1150 else if (dispidMember == DISPID_CREATE_TYPE_FUNC)
1151 {
1152 bHandled= sal_True;
1153 if( !pvarResult)
1154 ret= E_POINTER;
1155 // the first parameter is in DISPPARAMS rgvargs contains the name of the struct.
1156 CComVariant arg;
1157 if( pdispparams->cArgs != 1)
1158 return DISP_E_BADPARAMCOUNT;
1159 if (FAILED( arg.ChangeType( VT_BSTR, &pdispparams->rgvarg[0])))
1160 return DISP_E_BADVARTYPE;
1161
1162 //check if the provided name represents a valid type
1163 Type type;
1164 if (getType(arg.bstrVal, type) == false)
1165 {
1166 writeExcepinfo(pexcepinfo,OUString(
1167 OUSTR("[automation bridge] A UNO type with the name ") +
1168 OUString(reinterpret_cast<const sal_Unicode*>(arg.bstrVal)) + OUSTR(" does not exist!")));
1169 return DISP_E_EXCEPTION;
1170 }
1171
1172 if (createUnoTypeWrapper(arg.bstrVal, pvarResult) == false)
1173 {
1174 writeExcepinfo(pexcepinfo,OUSTR("[automation bridge] InterfaceOleWrapper_Impl::InvokeGeneral\n"
1175 "Could not initialize UnoTypeWrapper object!"));
1176 return DISP_E_EXCEPTION;
1177 }
1178 }
1179 }
1180 catch(BridgeRuntimeError & e)
1181 {
1182 writeExcepinfo(pexcepinfo, e.message);
1183 ret = DISP_E_EXCEPTION;
1184 }
1185 catch(Exception & e)
1186 {
1187 OUString message= OUSTR("InterfaceOleWrapper_Impl::InvokeGeneral : \n") +
1188 e.Message;
1189 writeExcepinfo(pexcepinfo, message);
1190 ret = DISP_E_EXCEPTION;
1191 }
1192 catch( ... )
1193 {
1194 OUString message= OUSTR("InterfaceOleWrapper_Impl::InvokeGeneral : \n"
1195 "Unexpected exception");
1196 writeExcepinfo(pexcepinfo, message);
1197 ret = DISP_E_EXCEPTION;
1198 }
1199 return ret;
1200 }
1201
1202
1203
1204
GetDispID(BSTR,DWORD,DISPID __RPC_FAR *)1205 STDMETHODIMP InterfaceOleWrapper_Impl::GetDispID(BSTR /*bstrName*/, DWORD /*grfdex*/, DISPID __RPC_FAR* /*pid*/)
1206 {
1207 HRESULT ret = ResultFromScode(E_NOTIMPL);
1208
1209 return ret;
1210 }
1211
InvokeEx(DISPID,LCID,WORD,DISPPARAMS __RPC_FAR *,VARIANT __RPC_FAR *,EXCEPINFO __RPC_FAR *,IServiceProvider __RPC_FAR *)1212 STDMETHODIMP InterfaceOleWrapper_Impl::InvokeEx(
1213 /* [in] */ DISPID /*id*/,
1214 /* [in] */ LCID /*lcid*/,
1215 /* [in] */ WORD /*wFlags*/,
1216 /* [in] */ DISPPARAMS __RPC_FAR* /*pdp*/,
1217 /* [out] */ VARIANT __RPC_FAR* /*pvarRes*/,
1218 /* [out] */ EXCEPINFO __RPC_FAR* /*pei*/,
1219 /* [unique][in] */ IServiceProvider __RPC_FAR* /*pspCaller*/)
1220 {
1221 HRESULT ret = ResultFromScode(E_NOTIMPL);
1222
1223 return ret;
1224 }
1225
1226
DeleteMemberByName(BSTR,DWORD)1227 STDMETHODIMP InterfaceOleWrapper_Impl::DeleteMemberByName(
1228 /* [in] */ BSTR /*bstr*/,
1229 /* [in] */ DWORD /*grfdex*/)
1230 {
1231 HRESULT ret = ResultFromScode(E_NOTIMPL);
1232
1233 return ret;
1234 }
1235
DeleteMemberByDispID(DISPID)1236 STDMETHODIMP InterfaceOleWrapper_Impl::DeleteMemberByDispID(DISPID /*id*/)
1237 {
1238 HRESULT ret = ResultFromScode(E_NOTIMPL);
1239
1240 return ret;
1241 }
1242
GetMemberProperties(DISPID,DWORD,DWORD __RPC_FAR *)1243 STDMETHODIMP InterfaceOleWrapper_Impl::GetMemberProperties(
1244 /* [in] */ DISPID /*id*/,
1245 /* [in] */ DWORD /*grfdexFetch*/,
1246 /* [out] */ DWORD __RPC_FAR* /*pgrfdex*/)
1247 {
1248 HRESULT ret = ResultFromScode(E_NOTIMPL);
1249
1250 return ret;
1251 }
1252
GetMemberName(DISPID,BSTR __RPC_FAR *)1253 STDMETHODIMP InterfaceOleWrapper_Impl::GetMemberName(
1254 /* [in] */ DISPID /*id*/,
1255 /* [out] */ BSTR __RPC_FAR* /*pbstrName*/)
1256 {
1257 HRESULT ret = ResultFromScode(E_NOTIMPL);
1258
1259 return ret;
1260 }
1261
GetNextDispID(DWORD,DISPID,DISPID __RPC_FAR *)1262 STDMETHODIMP InterfaceOleWrapper_Impl::GetNextDispID(
1263 /* [in] */ DWORD /*grfdex*/,
1264 /* [in] */ DISPID /*id*/,
1265 /* [out] */ DISPID __RPC_FAR* /*pid*/)
1266 {
1267 HRESULT ret = ResultFromScode(E_NOTIMPL);
1268
1269 return ret;
1270 }
1271
GetNameSpaceParent(IUnknown __RPC_FAR * __RPC_FAR *)1272 STDMETHODIMP InterfaceOleWrapper_Impl::GetNameSpaceParent(
1273 /* [out] */ IUnknown __RPC_FAR *__RPC_FAR* /*ppunk*/)
1274 {
1275 HRESULT ret = ResultFromScode(E_NOTIMPL);
1276
1277 return ret;
1278 }
1279
1280
1281 /*************************************************************************
1282
1283 UnoObjectWrapperRemoteOpt
1284
1285 *************************************************************************/
UnoObjectWrapperRemoteOpt(Reference<XMultiServiceFactory> & aFactory,sal_uInt8 unoWrapperClass,sal_uInt8 comWrapperClass)1286 UnoObjectWrapperRemoteOpt::UnoObjectWrapperRemoteOpt( Reference<XMultiServiceFactory>& aFactory,
1287 sal_uInt8 unoWrapperClass, sal_uInt8 comWrapperClass):
1288 InterfaceOleWrapper_Impl( aFactory, unoWrapperClass, comWrapperClass),
1289 m_currentId(1)
1290
1291 {
1292 }
~UnoObjectWrapperRemoteOpt()1293 UnoObjectWrapperRemoteOpt::~UnoObjectWrapperRemoteOpt()
1294 {
1295 }
1296
1297 // UnoConversionUtilities
createUnoWrapperInstance()1298 Reference< XInterface > UnoObjectWrapperRemoteOpt::createUnoWrapperInstance()
1299 {
1300 Reference<XWeak> xWeak= static_cast<XWeak*>( new UnoObjectWrapperRemoteOpt(
1301 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass));
1302 return Reference<XInterface>( xWeak, UNO_QUERY);
1303 }
1304
GetIDsOfNames(REFIID,OLECHAR ** rgszNames,unsigned int cNames,LCID,DISPID * rgdispid)1305 STDMETHODIMP UnoObjectWrapperRemoteOpt::GetIDsOfNames ( REFIID /*riid*/, OLECHAR ** rgszNames, unsigned int cNames,
1306 LCID /*lcid*/, DISPID * rgdispid )
1307 {
1308 MutexGuard guard( getBridgeMutex());
1309
1310 if( ! rgdispid)
1311 return E_POINTER;
1312 HRESULT ret = E_UNEXPECTED;
1313 // ----------------------------------------
1314 // _GetValueObject
1315 if( ! wcscmp( *rgszNames, JSCRIPT_VALUE_FUNC))
1316 {
1317 *rgdispid= DISPID_JSCRIPT_VALUE_FUNC;
1318 return S_OK;
1319 }
1320 else if( ! wcscmp( *rgszNames, GET_STRUCT_FUNC))
1321 {
1322 *rgdispid= DISPID_GET_STRUCT_FUNC;
1323 return S_OK;
1324 }
1325
1326 // ----------------------------------------
1327 if (m_xInvocation.is() && (cNames > 0))
1328 {
1329 OUString name(reinterpret_cast<const sal_Unicode*>(rgszNames[0]));
1330 // has this name been determined as "bad"
1331 BadNameMap::iterator badIter= m_badNameMap.find( name);
1332 if( badIter == m_badNameMap.end() )
1333 {
1334 // name has not been bad before( member exists
1335 typedef NameToIdMap::iterator ITnames;
1336 pair< ITnames, bool > pair_id= m_nameToDispIdMap.insert( NameToIdMap::value_type(name, m_currentId++));
1337 // new ID inserted ?
1338 if( pair_id.second )
1339 {// yes, now create MemberInfo and ad to IdToMemberInfoMap
1340 MemberInfo d(0, name);
1341 m_idToMemberInfoMap.insert( IdToMemberInfoMap::value_type( m_currentId - 1, d));
1342 }
1343
1344 *rgdispid = pair_id.first->second;
1345 ret = S_OK;
1346 }
1347 else
1348 ret= DISP_E_UNKNOWNNAME;
1349 }
1350 return ret;
1351 }
1352
Invoke(DISPID dispidMember,REFIID,LCID,unsigned short wFlags,DISPPARAMS * pdispparams,VARIANT * pvarResult,EXCEPINFO * pexcepinfo,unsigned int * puArgErr)1353 STDMETHODIMP UnoObjectWrapperRemoteOpt::Invoke ( DISPID dispidMember, REFIID /*riid*/, LCID /*lcid*/, unsigned short wFlags,
1354 DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo,
1355 unsigned int * puArgErr )
1356 {
1357 HRESULT ret = S_OK;
1358 try
1359 {
1360 sal_Bool bHandled= sal_False;
1361 ret= InvokeGeneral( dispidMember, wFlags, pdispparams, pvarResult, pexcepinfo,
1362 puArgErr, bHandled);
1363 if( bHandled)
1364 return ret;
1365
1366 if ( dispidMember > 0 && m_xInvocation.is())
1367 {
1368
1369 IdToMemberInfoMap::iterator it_MemberInfo= m_idToMemberInfoMap.find( dispidMember);
1370 if( it_MemberInfo != m_idToMemberInfoMap.end() )
1371 {
1372 MemberInfo& info= it_MemberInfo->second;
1373
1374 Sequence<Any> params; // holds converted any s
1375 if( ! info.flags )
1376 { // DISPID called for the first time
1377 if( wFlags == DISPATCH_METHOD )
1378 {
1379 convertDispparamsArgs(dispidMember, wFlags, pdispparams, params );
1380
1381 if( FAILED( ret= doInvoke( pdispparams, pvarResult,
1382 pexcepinfo, puArgErr, info.name, params))
1383 && ret == DISP_E_MEMBERNOTFOUND)
1384 {
1385 // try to get the exact name
1386 OUString exactName;
1387 if (m_xExactName.is())
1388 {
1389 exactName = m_xExactName->getExactName( info.name);
1390 // invoke again
1391 if( exactName.getLength() != 0)
1392 {
1393 if( SUCCEEDED( ret= doInvoke( pdispparams, pvarResult,
1394 pexcepinfo, puArgErr, exactName, params)))
1395 info.name= exactName;
1396 }
1397 }
1398 }
1399 if( SUCCEEDED( ret ) )
1400 info.flags= DISPATCH_METHOD;
1401 } //if( wFlags == DISPATCH_METHOD )
1402
1403 else if( wFlags == DISPATCH_PROPERTYPUT || wFlags == DISPATCH_PROPERTYPUTREF)
1404 {
1405 convertDispparamsArgs(dispidMember, wFlags, pdispparams, params );
1406 if( FAILED( ret= doSetProperty( pdispparams, pvarResult,
1407 pexcepinfo, puArgErr, info.name, params))
1408 && ret == DISP_E_MEMBERNOTFOUND)
1409 {
1410 // try to get the exact name
1411 OUString exactName;
1412 if (m_xExactName.is())
1413 {
1414 exactName = m_xExactName->getExactName( info.name);
1415 // invoke again
1416 if( exactName.getLength() != 0)
1417 {
1418 if( SUCCEEDED( ret= doSetProperty( pdispparams, pvarResult,
1419 pexcepinfo, puArgErr, exactName, params)))
1420 info.name= exactName;
1421 }
1422 }
1423 }
1424 if( SUCCEEDED( ret ) )
1425 info.flags= DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYGET;
1426 }
1427
1428 else if( wFlags == DISPATCH_PROPERTYGET)
1429 {
1430 if( FAILED( ret= doGetProperty( pdispparams, pvarResult,
1431 pexcepinfo, info.name))
1432 && ret == DISP_E_MEMBERNOTFOUND)
1433 {
1434 // try to get the exact name
1435 OUString exactName;
1436 if (m_xExactName.is())
1437 {
1438 exactName = m_xExactName->getExactName( info.name);
1439 // invoke again
1440 if( exactName.getLength() != 0)
1441 {
1442 if( SUCCEEDED( ret= doGetProperty( pdispparams, pvarResult,
1443 pexcepinfo, exactName)))
1444 info.name= exactName;
1445 }
1446 }
1447 }
1448 if( SUCCEEDED( ret ) )
1449 info.flags= DISPATCH_PROPERTYGET | DISPATCH_PROPERTYPUT;
1450 }
1451 else if( wFlags & DISPATCH_METHOD &&
1452 (wFlags & DISPATCH_PROPERTYPUT || wFlags & DISPATCH_PROPERTYPUTREF))
1453 {
1454
1455 OUString exactName;
1456 // convert params for DISPATCH_METHOD or DISPATCH_PROPERTYPUT
1457 convertDispparamsArgs(dispidMember, wFlags, pdispparams, params );
1458 // try first as method
1459 if( FAILED( ret= doInvoke( pdispparams, pvarResult,
1460 pexcepinfo, puArgErr, info.name, params))
1461 && ret == DISP_E_MEMBERNOTFOUND)
1462 {
1463 // try to get the exact name
1464 if (m_xExactName.is())
1465 {
1466 exactName = m_xExactName->getExactName( info.name);
1467 // invoke again
1468 if( exactName.getLength() != 0)
1469 {
1470 if( SUCCEEDED( ret= doInvoke( pdispparams, pvarResult,
1471 pexcepinfo, puArgErr, exactName, params)))
1472 info.name= exactName;
1473 }
1474 }
1475 }
1476 if( SUCCEEDED( ret ) )
1477 info.flags= DISPATCH_METHOD;
1478
1479 // try as property
1480 if( FAILED( ret) && pdispparams->cArgs == 1)
1481 {
1482 if( FAILED( ret= doSetProperty( pdispparams, pvarResult,
1483 pexcepinfo, puArgErr, info.name, params))
1484 && ret == DISP_E_MEMBERNOTFOUND)
1485 {
1486 // try to get the exact name
1487 if( exactName.getLength() != 0)
1488 {
1489 if( SUCCEEDED( ret= doSetProperty( pdispparams, pvarResult,
1490 pexcepinfo, puArgErr, exactName, params)))
1491 info.name= exactName;
1492 }
1493 }
1494 if( SUCCEEDED( ret ) )
1495 info.flags= DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYGET;
1496 }
1497 }
1498 else if( wFlags & DISPATCH_METHOD && wFlags & DISPATCH_PROPERTYGET)
1499 {
1500 OUString exactName;
1501 convertDispparamsArgs(dispidMember, wFlags, pdispparams, params );
1502
1503 if( FAILED( ret= doInvoke( pdispparams, pvarResult,
1504 pexcepinfo, puArgErr, info.name, params))
1505 && ret == DISP_E_MEMBERNOTFOUND)
1506 {
1507 // try to get the exact name
1508 if (m_xExactName.is())
1509 {
1510 exactName = m_xExactName->getExactName( info.name);
1511 // invoke again
1512 if( exactName.getLength() != 0)
1513 {
1514 if( SUCCEEDED( ret= doInvoke( pdispparams, pvarResult,
1515 pexcepinfo, puArgErr, exactName, params)))
1516 info.name= exactName;
1517 }
1518 }
1519 }
1520 if( SUCCEEDED( ret ) )
1521 info.flags= DISPATCH_METHOD;
1522
1523 // try as property
1524 if( FAILED( ret) && pdispparams->cArgs == 1)
1525 {
1526 if( FAILED( ret= doGetProperty( pdispparams, pvarResult,
1527 pexcepinfo, info.name))
1528 && ret == DISP_E_MEMBERNOTFOUND)
1529 {
1530 if( exactName.getLength() != 0)
1531 {
1532 if( SUCCEEDED( ret= doSetProperty( pdispparams, pvarResult,
1533 pexcepinfo, puArgErr, exactName, params)))
1534 info.name= exactName;
1535 }
1536 }
1537 if( SUCCEEDED( ret ) )
1538 info.flags= DISPATCH_PROPERTYGET;
1539 }
1540 }
1541
1542 // update �nformation about this member
1543 if( ret == DISP_E_MEMBERNOTFOUND)
1544 {
1545 // Remember the name as not existing
1546 // and remove the MemberInfo
1547 m_badNameMap[info.name]= sal_False;
1548 m_idToMemberInfoMap.erase( it_MemberInfo);
1549 }
1550 } // if( ! info.flags )
1551 else // IdToMemberInfoMap contains a MemberInfo
1552 {
1553 if( wFlags & DISPATCH_METHOD && info.flags == DISPATCH_METHOD)
1554 {
1555 convertDispparamsArgs(dispidMember, wFlags, pdispparams, params );
1556 ret= doInvoke( pdispparams, pvarResult,
1557 pexcepinfo, puArgErr, info.name, params);
1558 }
1559 else if( (wFlags & DISPATCH_PROPERTYPUT || wFlags & DISPATCH_PROPERTYPUTREF ) &&
1560 info.flags & DISPATCH_PROPERTYPUT)
1561 {
1562 convertDispparamsArgs(dispidMember, wFlags, pdispparams, params );
1563 ret= doSetProperty( pdispparams, pvarResult,
1564 pexcepinfo, puArgErr, info.name, params);
1565 }
1566 else if( (wFlags & DISPATCH_PROPERTYGET) && ( info.flags & DISPATCH_PROPERTYGET))
1567 {
1568 ret= doGetProperty( pdispparams, pvarResult,
1569 pexcepinfo, info.name);
1570 }
1571 else
1572 {
1573 ret= DISP_E_MEMBERNOTFOUND;
1574 }
1575 }
1576 }// if( it_MemberInfo != m_idToMemberInfoMap.end() )
1577 else
1578 ret= DISP_E_MEMBERNOTFOUND;
1579 }
1580 }
1581 catch(BridgeRuntimeError& e)
1582 {
1583 writeExcepinfo(pexcepinfo, e.message);
1584 ret = DISP_E_EXCEPTION;
1585 }
1586 catch(Exception& e)
1587 {
1588 OUString message= OUSTR("UnoObjectWrapperRemoteOpt::Invoke : \n") +
1589 e.Message;
1590 writeExcepinfo(pexcepinfo, message);
1591 ret = DISP_E_EXCEPTION;
1592 }
1593 catch(...)
1594 {
1595 OUString message= OUSTR("UnoObjectWrapperRemoteOpt::Invoke : \n"
1596 "Unexpected exception");
1597 writeExcepinfo(pexcepinfo, message);
1598 ret = DISP_E_EXCEPTION;
1599 }
1600
1601 return ret;
1602 }
1603
methodInvoke(DISPID,DISPPARAMS *,VARIANT *,EXCEPINFO *,unsigned int *,Sequence<Any> params)1604 HRESULT UnoObjectWrapperRemoteOpt::methodInvoke( DISPID /*dispidMember*/, DISPPARAMS * /*pdispparams*/, VARIANT * /*pvarResult*/,
1605 EXCEPINFO * /*pexcepinfo*/, unsigned int * /*puArgErr*/, Sequence<Any> params)
1606 {
1607 return S_OK;
1608 }
1609
1610
1611 // The returned HRESULT is only appropriate for IDispatch::Invoke
mapCannotConvertException(CannotConvertException e,unsigned int * puArgErr)1612 static HRESULT mapCannotConvertException( CannotConvertException e, unsigned int * puArgErr)
1613 {
1614 HRESULT ret;
1615 sal_Bool bWriteIndex= sal_True;
1616
1617 switch ( e.Reason)
1618 {
1619 case FailReason::OUT_OF_RANGE:
1620 ret = DISP_E_OVERFLOW;
1621 break;
1622 case FailReason::IS_NOT_NUMBER:
1623 ret = DISP_E_TYPEMISMATCH;
1624 break;
1625 case FailReason::IS_NOT_ENUM:
1626 ret = DISP_E_TYPEMISMATCH;
1627 break;
1628 case FailReason::IS_NOT_BOOL:
1629 ret = DISP_E_TYPEMISMATCH;
1630 break;
1631 case FailReason::NO_SUCH_INTERFACE:
1632 ret = DISP_E_TYPEMISMATCH;
1633 break;
1634 case FailReason::SOURCE_IS_NO_DERIVED_TYPE:
1635 ret = DISP_E_TYPEMISMATCH;
1636 break;
1637 case FailReason::TYPE_NOT_SUPPORTED:
1638 ret = DISP_E_TYPEMISMATCH;
1639 break;
1640 case FailReason::INVALID:
1641 ret = DISP_E_TYPEMISMATCH;
1642 break;
1643 case FailReason::NO_DEFAULT_AVAILABLE:
1644 ret = DISP_E_BADPARAMCOUNT;
1645 break;
1646 case FailReason::UNKNOWN:
1647 ret = E_UNEXPECTED;
1648 break;
1649 default:
1650 ret = E_UNEXPECTED;
1651 bWriteIndex= sal_False;
1652 break;
1653 }
1654
1655 if( bWriteIndex && puArgErr != NULL)
1656 *puArgErr = e.ArgumentIndex;
1657 return ret;
1658 }
1659
1660 // The function maps the TypeClass of the any to VARTYPE: If
1661 // the Any contains STRUCT or INTERFACE then the return value
1662 // is VT_DISPATCH. The function is used from o2u_createUnoObjectWrapper
1663 // and the result is put into the constructor of the uno - wrapper
1664 // object. If a client asks the object for DISPID_VALUE and this
1665 // function returned VT_DISPATCH then the IDispatch of the same
1666 // object is being returned.
1667 // See InterfaceOleWrapper_Impl::Invoke, InterfaceOleWrapper_Impl::m_defaultValueType
getVarType(const Any & value)1668 const VARTYPE getVarType( const Any& value)
1669 {
1670 VARTYPE ret= VT_EMPTY;
1671
1672 switch ( value.getValueTypeClass())
1673 {
1674 case TypeClass_STRUCT: ret= VT_DISPATCH; break;
1675 case TypeClass_INTERFACE: ret= VT_DISPATCH; break;
1676 default: break;
1677 }
1678 return ret;
1679 }
1680
1681
1682
1683
1684 } // end namespace
1685