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 #ifndef _UNO_CONVERSION_UTILITIES 24 #define _UNO_CONVERSION_UTILITIES 25 26 #include "boost/scoped_array.hpp" 27 #include "com/sun/star/script/XInvocationAdapterFactory.hpp" 28 #include "com/sun/star/script/XInvocationAdapterFactory2.hpp" 29 #include "com/sun/star/script/XTypeConverter.hpp" 30 #include "com/sun/star/script/FailReason.hpp" 31 #include "com/sun/star/bridge/oleautomation/Date.hpp" 32 #include "com/sun/star/bridge/oleautomation/Currency.hpp" 33 #include "com/sun/star/bridge/oleautomation/SCode.hpp" 34 #include "com/sun/star/bridge/oleautomation/Decimal.hpp" 35 #include "typelib/typedescription.hxx" 36 #include "ole2uno.hxx" 37 38 #include "unotypewrapper.hxx" 39 #include <hash_map> 40 41 // for some reason DECIMAL_NEG (wtypes.h) which contains BYTE is not resolved. 42 typedef unsigned char BYTE; 43 // classes for wrapping uno objects 44 #define INTERFACE_OLE_WRAPPER_IMPL 1 45 #define UNO_OBJECT_WRAPPER_REMOTE_OPT 2 46 47 #define INVOCATION_SERVICE reinterpret_cast<const sal_Unicode*>(L"com.sun.star.script.Invocation") 48 49 50 // classes for wrapping ole objects 51 #define IUNKNOWN_WRAPPER_IMPL 1 52 53 #define INTERFACE_ADAPTER_FACTORY reinterpret_cast<const sal_Unicode*>(L"com.sun.star.script.InvocationAdapterFactory") 54 // COM or JScript objects implementing UNO interfaces have to implement this property 55 #define SUPPORTED_INTERFACES_PROP L"_implementedInterfaces" 56 // Second property without leading underscore for use in VB 57 #define SUPPORTED_INTERFACES_PROP2 L"Bridge_ImplementedInterfaces" 58 59 using namespace com::sun::star::script; 60 using namespace com::sun::star::beans; 61 using namespace com::sun::star::uno; 62 #ifdef __MINGW32__ 63 using namespace com::sun::star::bridge; 64 using namespace com::sun::star::bridge::ModelDependent; 65 #endif 66 using namespace com::sun::star::bridge::oleautomation; 67 using namespace boost; 68 namespace ole_adapter 69 { 70 extern hash_map<sal_uInt32, sal_uInt32> AdapterToWrapperMap; 71 extern hash_map<sal_uInt32, sal_uInt32> WrapperToAdapterMap; 72 typedef hash_map<sal_uInt32, sal_uInt32>::iterator IT_Wrap; 73 typedef hash_map<sal_uInt32, sal_uInt32>::iterator CIT_Wrap; 74 //Maps IUnknown pointers to a weak reference of the respective wrapper class (e.g. 75 // IUnknownWrapperImpl. It is the responsibility of the wrapper to remove the entry when 76 // it is being destroyed. 77 // Used to ensure that an Automation object is always mapped to the same UNO objects. 78 extern hash_map<sal_uInt32, WeakReference<XInterface> > ComPtrToWrapperMap; 79 typedef hash_map<sal_uInt32, WeakReference<XInterface> >::iterator IT_Com; 80 typedef hash_map<sal_uInt32, WeakReference<XInterface> >::const_iterator CIT_Com; 81 82 // Maps XInterface pointers to a weak reference of its wrapper class (i.e. 83 // InterfaceOleWrapper_Impl). It is the responsibility of the wrapper to remove the entry when 84 // it is being destroyed. It is used to ensure the identity of objects. That is, an UNO interface 85 // is mapped to IDispatch which is kept alive in the COM environment. If the same 86 // UNO interface is mapped again to COM then the IDispach of the first mapped instance 87 // must be returned. 88 extern hash_map<sal_uInt32, WeakReference<XInterface> > UnoObjToWrapperMap; 89 typedef hash_map<sal_uInt32, WeakReference<XInterface> >::iterator IT_Uno; 90 typedef hash_map<sal_uInt32, WeakReference<XInterface> >::const_iterator CIT_Uno; 91 #ifdef __MINGW32__ 92 inline void reduceRange( Any& any); 93 #endif 94 95 96 97 98 // createUnoObjectWrapper gets a wrapper instance by calling createUnoWrapperInstance 99 // and initializes it via XInitialization. The wrapper object is required to implement 100 // XBridgeSupplier so that it can convert itself to IDispatch. 101 // class T: Deriving class ( must implement XInterface ) 102 /** All methods are allowed to throw at least a BridgeRuntimeError. 103 */ 104 template< class > 105 class UnoConversionUtilities 106 { 107 public: 108 UnoConversionUtilities( const Reference<XMultiServiceFactory> & smgr): 109 m_nUnoWrapperClass( INTERFACE_OLE_WRAPPER_IMPL), 110 m_nComWrapperClass( IUNKNOWN_WRAPPER_IMPL), 111 m_smgr( smgr) 112 {} 113 114 UnoConversionUtilities( const Reference<XMultiServiceFactory> & xFactory, sal_uInt8 unoWrapperClass, sal_uInt8 comWrapperClass ) 115 : m_smgr( xFactory), m_nComWrapperClass( comWrapperClass), m_nUnoWrapperClass( unoWrapperClass) 116 {} 117 118 virtual ~UnoConversionUtilities() {} 119 /** converts only into oleautomation types, that is there is no VT_I1, VT_UI2, VT_UI4 120 a sal_Unicode character is converted into a BSTR. 121 @exception com.sun.star.lang.IllegalArgumentException 122 If the any was inappropriate for conversion. 123 @exception com.sun.star.script.CannotConvertException 124 The any contains a type class for which no conversion is provided. 125 */ 126 void anyToVariant(VARIANT* pVariant, const Any& rAny); 127 void anyToVariant(VARIANT* pVariant, const Any& rAny, VARTYPE type); 128 129 /** @exception com.sun.star.lang.IllegalArgumentException 130 If rSeq does not contain a sequence then the exception is thrown. 131 */ 132 SAFEARRAY* createUnoSequenceWrapper(const Any& rSeq); 133 /** @exception com.sun.star.lang.IllegalArgumentException 134 If rSeq does not contain a sequence or elemtype has no proper value 135 then the exception is thrown. 136 */ 137 SAFEARRAY* createUnoSequenceWrapper(const Any& rSeq, VARTYPE elemtype); 138 /** 139 @exception com.sun.star.lang.IllegalArgumentException 140 If rObj does not contain a struct or interface 141 */ 142 void createUnoObjectWrapper(const Any & rObj, VARIANT * pVar); 143 /** @exception CannotConvertException 144 Thrown if the VARIANT contains a type that cannot be coerced in the expected Any. 145 ArgumentIndex is 0. 146 @IllegalArgumentException 147 Thrown if the VARIANT is inappropriate for conversion. ArgumentPosition is -1, 148 */ 149 void variantToAny(const VARIANT* pVariant, Any& rAny, sal_Bool bReduceValueRange = sal_True); 150 /** This method converts variants arguments in calls from COM -> UNO. Only then 151 the expected UNO type is known. 152 @exception CannotConvertException 153 Thrown if the VARIANT contains a type that cannot be coerced in the expected Any. 154 ArgumentIndex is 0. 155 @IllegalArgumentException 156 Thrown if the VARIANT is inappropriate for conversion. ArgumentPosition is -1, 157 */ 158 void variantToAny( const VARIANTARG* pArg, Any& rAny, const Type& ptype, sal_Bool bReduceValueRange = sal_True); 159 160 /** 161 @exception IllegalArgumentException 162 -if pVar does not contain VT_UNKNOWN or VT_DISPATCH or 163 pVar is used for a particular UNO type which is not supported by pVar 164 */ 165 Any createOleObjectWrapper(VARIANT* pVar, const Type& aType= Type()); 166 167 /* 168 Return true means var contained a ValueObject, and it was successfully converted. 169 The result is in any. It an error occurred a BridgeRuntimeError will be thrown. 170 */ 171 bool convertValueObject( const VARIANTARG *var, Any& any); 172 void dispatchExObject2Sequence( const VARIANTARG* pvar, Any& anySeq, const Type& type); 173 174 Sequence<Any> createOleArrayWrapperOfDim(SAFEARRAY* pArray, unsigned int dimCount, unsigned int actDim, long* index, 175 VARTYPE type, const Type& unotype); 176 Sequence<Any> createOleArrayWrapper(SAFEARRAY* pArray, VARTYPE type, const Type& unotype= Type()); 177 178 179 VARTYPE mapTypeClassToVartype( TypeClass type); 180 Reference< XSingleServiceFactory > getInvocationFactory(const Any& anyObject); 181 182 183 virtual Reference< XInterface > createUnoWrapperInstance()=0; 184 virtual Reference< XInterface > createComWrapperInstance()=0; 185 186 static sal_Bool isJScriptArray(const VARIANT* pvar); 187 188 Sequence<Type> getImplementedInterfaces(IUnknown* pUnk); 189 190 protected: 191 Reference<XInterface> createAdapter(const Sequence<Type>& types, const Reference<XInterface>& receiver); 192 193 // helper function for Sequence conversion 194 void getElementCountAndTypeOfSequence( const Any& rSeq, sal_Int32 dim, Sequence< sal_Int32 >& seqElementCounts, TypeDescription& typeDesc); 195 // helper function for Sequence conversion 196 sal_Bool incrementMultidimensionalIndex(sal_Int32 dimensions, const sal_Int32 * parDimensionLength, 197 sal_Int32 * parMultidimensionalIndex); 198 // helper function for Sequence conversion 199 size_t getOleElementSize( VARTYPE type); 200 201 Type getElementTypeOfSequence( const Type& seqType); 202 203 //Provides a typeconverter 204 Reference<XTypeConverter> getTypeConverter(); 205 206 // This member determines what class is used to convert a UNO object 207 // or struct to a COM object. It is passed along to the o2u_anyToVariant 208 // function in the createBridge function implementation 209 sal_uInt8 m_nUnoWrapperClass; 210 sal_uInt8 m_nComWrapperClass; 211 212 // The servicemanager is either a local smgr or remote when the service 213 // com.sun.star.bridge.OleBridgeSupplierVar1 is used. This service can be 214 // created by createInstanceWithArguments where one can supply a service 215 // manager that is to be used. 216 // Local service manager as supplied by the loader when the creator function 217 // of the service is being called. 218 Reference<XMultiServiceFactory> m_smgr; 219 // An explicitly supplied service manager when the service 220 // com.sun.star.bridge.OleBridgeSupplierVar1 is used. That can be a remote 221 // manager. 222 Reference<XMultiServiceFactory> m_smgrRemote; 223 Reference<XSingleServiceFactory> m_xInvocationFactoryLocal; 224 Reference<XSingleServiceFactory> m_xInvocationFactoryRemote; 225 226 private: 227 // Holds the type converter which is used for sequence conversion etc. 228 // Use the getTypeConverter function to obtain the interface. 229 Reference<XTypeConverter> m_typeConverter; 230 231 232 }; 233 234 // ask the object for XBridgeSupplier2 and on success bridges 235 // the uno object to IUnknown or IDispatch. 236 // return true the UNO object supports 237 template < class T > 238 bool convertSelfToCom( T& unoInterface, VARIANT * pVar) 239 { 240 bool ret = false; 241 Reference< XInterface > xInt( unoInterface, UNO_QUERY); 242 if( xInt.is()) 243 { 244 Reference< XBridgeSupplier2 > xSupplier( xInt, UNO_QUERY); 245 if( xSupplier.is()) 246 { 247 sal_Int8 arId[16]; 248 rtl_getGlobalProcessId( (sal_uInt8*)arId); 249 Sequence<sal_Int8> seqId( arId, 16); 250 Any anySource; 251 anySource <<= xInt; 252 Any anyDisp= xSupplier->createBridge( anySource, seqId, UNO, OLE); 253 if( anyDisp.getValueTypeClass() == TypeClass_UNSIGNED_LONG) 254 { 255 VARIANT* pvariant= *(VARIANT**)anyDisp.getValue(); 256 HRESULT hr; 257 if (FAILED(hr = VariantCopy(pVar, pvariant))) 258 throw BridgeRuntimeError( 259 OUSTR("[automation bridge] convertSelfToCom\n" 260 "VariantCopy failed! Error: ") + 261 OUString::valueOf(hr)); 262 VariantClear( pvariant); 263 CoTaskMemFree( pvariant); 264 ret = true; 265 } 266 } 267 } 268 return ret; 269 } 270 271 272 273 // Gets the invocation factory depending on the Type in the Any. 274 // The factory can be created by a local or remote multi service factory. 275 // In case there is a remote multi service factory available there are 276 // some services or types for which the local factory is used. The exceptions 277 // are: all structs. 278 // Param anyObject - contains the object ( interface, struct) for what we need an invocation object. 279 // 280 template<class T> 281 Reference< XSingleServiceFactory > UnoConversionUtilities<T>::getInvocationFactory(const Any& anyObject) 282 { 283 Reference< XSingleServiceFactory > retVal; 284 MutexGuard guard( getBridgeMutex()); 285 if( anyObject.getValueTypeClass() != TypeClass_STRUCT && 286 m_smgrRemote.is() ) 287 { 288 if( ! m_xInvocationFactoryRemote.is() ) 289 m_xInvocationFactoryRemote= Reference<XSingleServiceFactory>( 290 m_smgrRemote->createInstance( INVOCATION_SERVICE), UNO_QUERY); 291 retVal= m_xInvocationFactoryRemote; 292 } 293 else 294 { 295 if( ! m_xInvocationFactoryLocal.is() ) 296 m_xInvocationFactoryLocal= Reference<XSingleServiceFactory>( 297 m_smgr->createInstance(INVOCATION_SERVICE ), UNO_QUERY); 298 retVal= m_xInvocationFactoryLocal; 299 } 300 return retVal; 301 } 302 303 template<class T> 304 void UnoConversionUtilities<T>::variantToAny( const VARIANTARG* pArg, Any& rAny, const Type& ptype, sal_Bool bReduceValueRange /* = sal_True */) 305 { 306 try 307 { 308 HRESULT hr; 309 bool bFail = false; 310 bool bCannotConvert = false; 311 CComVariant var; 312 313 // There is no need to support indirect values, since they're not supported by UNO 314 if( FAILED(hr= VariantCopyInd( &var, const_cast<VARIANTARG*>(pArg)))) // remove VT_BYREF 315 throw BridgeRuntimeError( 316 OUSTR("[automation bridge] UnoConversionUtilities<T>::variantToAny \n" 317 "VariantCopyInd failed for reason : ") + OUString::valueOf(hr)); 318 bool bHandled = convertValueObject( & var, rAny); 319 if( bHandled) 320 OSL_ENSURE( rAny.getValueType() == ptype, "type in Value Object must match the type parameter"); 321 322 if( ! bHandled) 323 { 324 // convert into a variant type that is the equivalent to the type 325 // the sequence expects. Thus variantToAny produces the correct type 326 // E.g. An Array object contains VT_I4 and the sequence expects shorts 327 // than the vartype must be changed. The reason is, you can't specify the 328 // type in JavaScript and the script engine determines the type beeing used. 329 switch( ptype.getTypeClass()) 330 { 331 case TypeClass_CHAR: // could be: new Array( 12, 'w', "w") 332 if( var.vt == VT_BSTR) 333 { 334 if(SUCCEEDED( hr= VariantChangeType( &var, &var, 0, VT_BSTR))) 335 rAny.setValue( (void*)V_BSTR( &var), ptype); 336 else if (hr == DISP_E_TYPEMISMATCH) 337 bCannotConvert = true; 338 else 339 bFail = true; 340 } 341 else 342 { 343 if(SUCCEEDED(hr = VariantChangeType( & var, &var, 0, VT_I2))) 344 rAny.setValue((void*) & var.iVal, ptype); 345 else if (hr == DISP_E_TYPEMISMATCH) 346 bCannotConvert = true; 347 else 348 bFail = true; 349 } 350 break; 351 case TypeClass_INTERFACE: // could also be an IUnknown 352 case TypeClass_STRUCT: 353 { 354 rAny = createOleObjectWrapper( & var, ptype); 355 break; 356 } 357 case TypeClass_ENUM: 358 if(SUCCEEDED(hr = VariantChangeType( & var, &var, 0, VT_I4))) 359 rAny.setValue((void*) & var.lVal, ptype); 360 else if (hr == DISP_E_TYPEMISMATCH) 361 bCannotConvert = true; 362 else 363 bFail = true; 364 break; 365 case TypeClass_SEQUENCE: 366 // There are different ways of receiving a sequence: 367 // 1: JScript, VARTYPE: VT_DISPATCH 368 // 2. VBScript simple arraysVT_VARIANT|VT_BYREF the referenced VARIANT contains 369 // a VT_ARRAY| <type> 370 // 3. VBSrcript multi dimensional arrays: VT_ARRAY|VT_BYREF 371 if( pArg->vt == VT_DISPATCH) 372 { 373 dispatchExObject2Sequence( pArg, rAny, ptype); 374 } 375 else 376 { 377 if ((var.vt & VT_ARRAY) != 0) 378 { 379 VARTYPE oleType = ::sal::static_int_cast< VARTYPE, int >( var.vt ^ VT_ARRAY ); 380 Sequence<Any> unoSeq = createOleArrayWrapper( var.parray, oleType, ptype); 381 Reference<XTypeConverter> conv = getTypeConverter(); 382 if (conv.is()) 383 { 384 try 385 { 386 Any anySeq = makeAny(unoSeq); 387 Any convAny = conv->convertTo(anySeq, ptype); 388 rAny = convAny; 389 } 390 catch (IllegalArgumentException& e) 391 { 392 throw BridgeRuntimeError( 393 OUSTR("[automation bridge]com.sun.star.lang.IllegalArgumentException " 394 "in UnoConversionUtilities<T>::variantToAny! Message: ") + 395 e.Message); 396 } 397 catch (CannotConvertException& e) 398 { 399 throw BridgeRuntimeError( 400 OUSTR("[automation bridge]com.sun.star.script.CannotConvertException " 401 "in UnoConversionUtilities<T>::variantToAny! Message: ") + 402 e.Message); 403 } 404 } 405 } 406 } 407 break; 408 case TypeClass_VOID: 409 rAny.setValue(NULL,Type()); 410 break; 411 case TypeClass_ANY: // Any 412 // There could be a JScript Array that needs special handling 413 // If an Any is expected and this Any must contain a Sequence 414 // then we cannot figure out what element type is required. 415 // Therefore we convert to Sequence< Any > 416 if( pArg->vt == VT_DISPATCH && isJScriptArray( pArg)) 417 { 418 dispatchExObject2Sequence( pArg, rAny, 419 getCppuType((Sequence<Any>*) 0)); 420 } 421 else if (pArg->vt == VT_DECIMAL) 422 { 423 //Decimal maps to hyper in calls from COM -> UNO 424 // It does not matter if we create a sal_uInt64 or sal_Int64, 425 // because the UNO object is called through invocation which 426 //will do a type conversion if necessary 427 if (var.decVal.sign == 0) 428 { 429 // positive value 430 variantToAny( & var, rAny, getCppuType( (sal_uInt64*) 0), 431 bReduceValueRange); 432 } 433 else 434 { 435 //negative value 436 variantToAny( & var, rAny, getCppuType( (sal_Int64*) 0), 437 bReduceValueRange); 438 } 439 } 440 else 441 { 442 variantToAny( & var, rAny); 443 } 444 break; 445 case TypeClass_BOOLEAN: // VARIANT could be VARIANT_BOOL or other 446 if(SUCCEEDED(hr = VariantChangeType( & var, &var, 0, VT_BOOL))) 447 variantToAny( & var, rAny); 448 else if (hr == DISP_E_TYPEMISMATCH) 449 bCannotConvert = true; 450 else 451 bFail = true; 452 break; 453 case TypeClass_STRING: // UString 454 if(SUCCEEDED(hr = VariantChangeType( & var, &var, 0, VT_BSTR))) 455 variantToAny( & var, rAny); 456 else if (hr == DISP_E_TYPEMISMATCH) 457 bCannotConvert = true; 458 else 459 bFail = true; 460 break; 461 case TypeClass_FLOAT: // float 462 if(SUCCEEDED(hr = VariantChangeType( & var, &var, 0, VT_R4))) 463 variantToAny( & var, rAny); 464 else if (hr == DISP_E_TYPEMISMATCH) 465 bCannotConvert = true; 466 else 467 bFail = true; 468 break; 469 case TypeClass_DOUBLE: // double 470 if(SUCCEEDED(hr = VariantChangeType( & var, &var, 0, VT_R8))) 471 variantToAny(& var, rAny); 472 else if (hr == DISP_E_TYPEMISMATCH) 473 bCannotConvert = true; 474 else 475 bFail = true; 476 break; 477 case TypeClass_BYTE: // BYTE 478 if(SUCCEEDED(hr = VariantChangeType( & var, &var, 0, VT_I1))) 479 variantToAny( & var, rAny); 480 else if (hr == DISP_E_TYPEMISMATCH) 481 bCannotConvert = true; 482 else 483 bFail = true; 484 break; 485 case TypeClass_SHORT: // INT16 486 if(SUCCEEDED(hr = VariantChangeType( & var, &var, 0, VT_I2))) 487 variantToAny( & var, rAny); 488 else if (hr == DISP_E_TYPEMISMATCH) 489 bCannotConvert = true; 490 else 491 bFail = true; 492 break; 493 case TypeClass_LONG: 494 if(SUCCEEDED(hr = VariantChangeType(& var, &var, 0, VT_I4))) 495 variantToAny( & var, rAny, bReduceValueRange); 496 else if (hr == DISP_E_TYPEMISMATCH) 497 bCannotConvert = true; 498 else 499 bFail = true; 500 break; 501 case TypeClass_HYPER: 502 if(SUCCEEDED(hr = VariantChangeType(& var, &var, 0, VT_DECIMAL))) 503 { 504 if (var.decVal.Lo64 > SAL_CONST_UINT64(0x8000000000000000) 505 || var.decVal.Hi32 > 0 506 || var.decVal.scale > 0) 507 { 508 bFail = true; 509 break; 510 } 511 sal_Int64 value = var.decVal.Lo64; 512 if (var.decVal.sign == DECIMAL_NEG) 513 value |= SAL_CONST_UINT64(0x8000000000000000); 514 rAny <<= value; 515 } 516 else if (hr == DISP_E_TYPEMISMATCH) 517 bCannotConvert = true; 518 else 519 bFail = true; 520 break; 521 case TypeClass_UNSIGNED_SHORT: // UINT16 522 if(SUCCEEDED(hr = VariantChangeType( & var, &var, 0, VT_UI2))) 523 variantToAny( & var, rAny); 524 else if (hr == DISP_E_TYPEMISMATCH) 525 bCannotConvert = true; 526 else 527 bFail = true; 528 break; 529 case TypeClass_UNSIGNED_LONG: 530 if(SUCCEEDED(hr = VariantChangeType( & var, &var, 0, VT_UI4))) 531 variantToAny( & var, rAny, bReduceValueRange); 532 else if (hr == DISP_E_TYPEMISMATCH) 533 bCannotConvert = true; 534 else 535 bFail = true; 536 break; 537 case TypeClass_UNSIGNED_HYPER: 538 if(SUCCEEDED(hr = VariantChangeType(& var, &var, 0, VT_DECIMAL))) 539 { 540 if (var.decVal.Hi32 > 0 || var.decVal.scale > 0) 541 { 542 bFail = true; 543 break; 544 } 545 rAny <<= var.decVal.Lo64; 546 } 547 else if (hr == DISP_E_TYPEMISMATCH) 548 bCannotConvert = true; 549 else 550 bFail = true; 551 break; 552 case TypeClass_TYPE: 553 if(SUCCEEDED(hr = VariantChangeType(& var, &var, 0, VT_UNKNOWN))) 554 variantToAny( & var, rAny); 555 else if (hr == DISP_E_TYPEMISMATCH) 556 bCannotConvert = true; 557 else 558 bFail = true; 559 break; 560 default: 561 // case TypeClass_SERVICE: break; // meta construct 562 // case TypeClass_TYPEDEF: break; 563 // case TypeClass_UNION: break; 564 // case TypeClass_MODULE: break; // module 565 // case TypeClass_EXCEPTION: break; 566 // case TypeClass_ARRAY: break; // there's no Array at the moment 567 // case TypeClass_UNKNOWN: break; 568 bCannotConvert = true; 569 break; 570 } 571 } 572 if (bCannotConvert) 573 throw CannotConvertException( 574 OUSTR("[automation bridge]UnoConversionUtilities<T>::variantToAny \n" 575 "Cannot convert the value of vartype :\"") + 576 OUString::valueOf((sal_Int32) var.vt) + 577 OUSTR("\" to the expected UNO type of type class: ") + 578 OUString::valueOf((sal_Int32) ptype.getTypeClass()), 579 0, TypeClass_UNKNOWN, FailReason::TYPE_NOT_SUPPORTED,0); 580 581 if (bFail) 582 throw IllegalArgumentException( 583 OUSTR("[automation bridge]UnoConversionUtilities<T>:variantToAny\n" 584 "The provided VARIANT of type\" ") + OUString::valueOf((sal_Int32) var.vt) + 585 OUSTR("\" is unappropriate for conversion!"), Reference<XInterface>(), -1); 586 } 587 catch (CannotConvertException &) 588 { 589 throw; 590 } 591 catch (IllegalArgumentException &) 592 { 593 throw; 594 } 595 catch (BridgeRuntimeError &) 596 { 597 throw; 598 } 599 catch (Exception & e) 600 { 601 throw BridgeRuntimeError(OUSTR("[automation bridge] unexpected exception in " 602 "UnoConversionUtilities<T>::variantToAny ! Message : \n") + 603 e.Message); 604 } 605 catch(...) 606 { 607 throw BridgeRuntimeError( 608 OUSTR("[automation bridge] unexpected exception in " 609 "UnoConversionUtilities<T>::variantToAny !")); 610 } 611 } 612 613 // The function only converts Sequences to SAFEARRAYS with elements of the type 614 // specified by the parameter type. Everything else is forwarded to 615 // anyToVariant(VARIANT* pVariant, const Any& rAny) 616 // Param type must not be VT_BYREF 617 template<class T> 618 void UnoConversionUtilities<T>::anyToVariant(VARIANT* pVariant, const Any& rAny, VARTYPE type) 619 { 620 try 621 { 622 HRESULT hr= S_OK; 623 624 OSL_ASSERT( (type & VT_BYREF) == 0); 625 if (type & VT_ARRAY) 626 { 627 type ^= VT_ARRAY; 628 SAFEARRAY* ar= createUnoSequenceWrapper( rAny, type); 629 if( ar) 630 { 631 VariantClear( pVariant); 632 pVariant->vt= ::sal::static_int_cast< VARTYPE, int >( VT_ARRAY | type ); 633 pVariant->byref= ar; 634 } 635 } 636 else if(type == VT_VARIANT) 637 { 638 anyToVariant(pVariant, rAny); 639 } 640 else 641 { 642 CComVariant var; 643 anyToVariant( &var, rAny); 644 if(FAILED(hr = VariantChangeType(&var, &var, 0, type))) 645 { 646 if (hr == DISP_E_TYPEMISMATCH) 647 throw CannotConvertException( 648 OUSTR("[automation bridge]UnoConversionUtilities<T>::anyToVariant \n" 649 "Cannot convert the value of type :\"") + 650 rAny.getValueTypeName() + 651 OUSTR("\" to the expected Automation type of VARTYPE: ") + 652 OUString::valueOf((sal_Int32)type), 653 0, TypeClass_UNKNOWN, FailReason::TYPE_NOT_SUPPORTED,0); 654 655 throw BridgeRuntimeError( 656 OUSTR("[automation bridge]UnoConversionUtilities<T>::anyToVariant \n" 657 "Conversion of any with ") + 658 rAny.getValueType().getTypeName() + 659 OUSTR(" to VARIANT with type: ") + OUString::valueOf((sal_Int32) type) + 660 OUSTR(" failed! Error code: ") + OUString::valueOf(hr)); 661 662 } 663 if(FAILED(hr = VariantCopy(pVariant, &var))) 664 { 665 throw BridgeRuntimeError( 666 OUSTR("[automation bridge]UnoConversionUtilities<T>::anyToVariant \n" 667 "VariantCopy failed for reason: ") + OUString::valueOf(hr)); 668 } 669 } 670 } 671 catch (IllegalArgumentException &) 672 { 673 throw; 674 } 675 catch (CannotConvertException & ) 676 { 677 throw; 678 } 679 catch (BridgeRuntimeError&) 680 { 681 throw; 682 } 683 catch(Exception & e) 684 { 685 throw BridgeRuntimeError( 686 OUSTR("[automation bridge]UnoConversionUtilities<T>::anyToVariant \n" 687 "Unexpected exception occurred. Message: ") + e.Message); 688 } 689 catch(...) 690 { 691 throw BridgeRuntimeError( 692 OUSTR("[automation bridge]UnoConversionUtilities<T>::anyToVariant \n" 693 "Unexpected exception occurred.")); 694 } 695 } 696 697 template<class T> 698 void UnoConversionUtilities<T>::anyToVariant(VARIANT* pVariant, const Any& rAny) 699 { 700 bool bIllegal = false; 701 try 702 { 703 switch (rAny.getValueTypeClass()) 704 { 705 case TypeClass_INTERFACE: 706 { 707 Reference<XInterface> xInt; 708 if (rAny >>= xInt) 709 { 710 createUnoObjectWrapper(rAny, pVariant); 711 } 712 else 713 { 714 bIllegal = true; 715 } 716 break; 717 } 718 case TypeClass_STRUCT: 719 { 720 if (rAny.getValueType() == getCppuType((Date*)0)) 721 { 722 Date d; 723 if (rAny >>= d) 724 { 725 pVariant->vt = VT_DATE; 726 pVariant->date = d.Value; 727 } 728 else 729 { 730 bIllegal = true; 731 } 732 } 733 else if(rAny.getValueType() == getCppuType((Decimal*)0)) 734 { 735 Decimal d; 736 if (rAny >>= d) 737 { 738 pVariant->vt = VT_DECIMAL; 739 pVariant->decVal.scale = d.Scale; 740 pVariant->decVal.sign = d.Sign; 741 pVariant->decVal.Lo32 = d.LowValue; 742 pVariant->decVal.Mid32 = d.MiddleValue; 743 pVariant->decVal.Hi32 = d.HighValue; 744 } 745 else 746 { 747 bIllegal = true; 748 } 749 } 750 else if (rAny.getValueType() == getCppuType((Currency*)0)) 751 { 752 Currency c; 753 if (rAny >>= c) 754 { 755 pVariant->vt = VT_CY; 756 pVariant->cyVal.int64 = c.Value; 757 } 758 else 759 { 760 bIllegal = true; 761 } 762 } 763 else if(rAny.getValueType() == getCppuType((SCode*)0)) 764 { 765 SCode s; 766 if (rAny >>= s) 767 { 768 pVariant->vt = VT_ERROR; 769 pVariant->scode = s.Value; 770 } 771 else 772 { 773 bIllegal = true; 774 } 775 } 776 else 777 { 778 createUnoObjectWrapper(rAny, pVariant); 779 } 780 break; 781 } 782 case TypeClass_SEQUENCE: // sequence ??? SafeArray descriptor 783 { 784 SAFEARRAY* pArray = createUnoSequenceWrapper(rAny); 785 if (pArray) 786 { 787 V_VT(pVariant) = VT_ARRAY | VT_VARIANT; 788 V_ARRAY(pVariant) = pArray; 789 } 790 else 791 { 792 bIllegal = true; 793 } 794 break; 795 } 796 case TypeClass_VOID: 797 { 798 HRESULT hr = S_OK; 799 if (FAILED(hr = VariantClear(pVariant))) 800 { 801 throw BridgeRuntimeError( 802 OUSTR("[automation bridge]UnoConversionUtilities<T>::anyToVariant\n" 803 "VariantClear failed with error:") + OUString::valueOf(hr)); 804 } 805 break; 806 } 807 case TypeClass_BOOLEAN: 808 { 809 sal_Bool value; 810 if (rAny >>= value) 811 { 812 pVariant->vt = VT_BOOL; 813 pVariant->boolVal = value == sal_True? VARIANT_TRUE: VARIANT_FALSE; 814 } 815 else 816 { 817 bIllegal = true; 818 } 819 break; 820 } 821 case TypeClass_CHAR: 822 { 823 // Because VT_UI2 does not conform to oleautomation we convert into VT_I2 instead 824 sal_uInt16 value = *(sal_Unicode*) rAny.getValue(); 825 pVariant->vt = VT_I2; 826 pVariant->iVal = value; 827 break; 828 } 829 case TypeClass_STRING: 830 { 831 OUString value; 832 if (rAny >>= value) 833 { 834 pVariant->vt = VT_BSTR; 835 pVariant->bstrVal = SysAllocString(reinterpret_cast<LPCOLESTR>(value.getStr())); 836 } 837 else 838 { 839 bIllegal = true; 840 } 841 break; 842 } 843 case TypeClass_FLOAT: 844 { 845 float value; 846 if (rAny >>= value) 847 { 848 pVariant->vt = VT_R4; 849 pVariant->fltVal = value; 850 } 851 else 852 { 853 bIllegal = true; 854 } 855 break; 856 } 857 case TypeClass_DOUBLE: 858 { 859 double value; 860 if (rAny >>= value) 861 { 862 pVariant->vt = VT_R8; 863 pVariant->dblVal = value; 864 } 865 else 866 { 867 bIllegal = true; 868 } 869 break; 870 } 871 case TypeClass_BYTE: 872 { 873 // ole automation does not know a signed char but only unsigned char 874 sal_Int8 value; 875 if (rAny >>= value) 876 { 877 pVariant->vt = VT_UI1; 878 pVariant->bVal = value; 879 } 880 else 881 { 882 bIllegal = true; 883 } 884 break; 885 } 886 case TypeClass_SHORT: // INT16 887 case TypeClass_UNSIGNED_SHORT: // UINT16 888 { 889 sal_Int16 value; 890 if (rAny >>= value) 891 { 892 pVariant->vt = VT_I2; 893 pVariant->iVal = value; 894 } 895 else 896 { 897 bIllegal = true; 898 } 899 break; 900 } 901 case TypeClass_ENUM: 902 { 903 sal_Int32 value = *(sal_Int32*) rAny.getValue(); 904 pVariant->vt = VT_I4; 905 pVariant->lVal= value; 906 break; 907 } 908 case TypeClass_LONG: 909 case TypeClass_UNSIGNED_LONG: 910 { 911 sal_Int32 value; 912 if (rAny >>= value) 913 { 914 pVariant->vt = VT_I4; 915 pVariant->lVal= value; 916 } 917 else 918 { 919 bIllegal = true; 920 } 921 break; 922 } 923 case TypeClass_HYPER: 924 { 925 926 pVariant->vt = VT_DECIMAL; 927 pVariant->decVal.scale = 0; 928 pVariant->decVal.sign = 0; 929 pVariant->decVal.Hi32 = 0; 930 931 sal_Int64 value; 932 rAny >>= value; 933 934 if (value & SAL_CONST_UINT64(0x8000000000000000)) 935 pVariant->decVal.sign = DECIMAL_NEG; 936 937 pVariant->decVal.Lo64 = value; 938 break; 939 } 940 case TypeClass_UNSIGNED_HYPER: 941 { 942 pVariant->vt = VT_DECIMAL; 943 pVariant->decVal.scale = 0; 944 pVariant->decVal.sign = 0; 945 pVariant->decVal.Hi32 = 0; 946 947 sal_uInt64 value; 948 rAny >>= value; 949 pVariant->decVal.Lo64 = value; 950 break; 951 } 952 case TypeClass_TYPE: 953 { 954 Type type; 955 rAny >>= type; 956 CComVariant var; 957 if (createUnoTypeWrapper(type.getTypeName(), & var) == false) 958 throw BridgeRuntimeError( 959 OUSTR("[automation bridge] UnoConversionUtilities<T>::anyToVariant \n" 960 "Error during conversion of UNO type to Automation object!")); 961 962 if (FAILED(VariantCopy(pVariant, &var))) 963 throw BridgeRuntimeError( 964 OUSTR("[automation bridge] UnoConversionUtilities<T>::anyToVariant \n" 965 "Unexpected error!")); 966 break; 967 } 968 default: 969 //TypeClass_SERVICE: 970 //TypeClass_EXCEPTION: 971 //When a InvocationTargetException is thrown when calling XInvocation::invoke 972 //on a UNO object, then the target exception is directly used to create a 973 //EXEPINFO structure 974 //TypeClass_TYPEDEF 975 //TypeClass_ANY: 976 //TypeClass_UNKNOWN: 977 //TypeClass_UNSIGNED_OCTET: 978 // TypeClass_UNION: 979 // TypeClass_ARRAY: 980 // TypeClass_UNSIGNED_INT: 981 // TypeClass_UNSIGNED_BYTE: 982 // TypeClass_MODULE: 983 throw CannotConvertException( 984 OUSTR("[automation bridge]UnoConversionUtilities<T>::anyToVariant\n" 985 "There is no conversion for this UNO type to a Automation type." 986 "The destination type class is the type class of the UNO " 987 "argument which was to be converted."), 988 Reference<XInterface>(), rAny.getValueTypeClass(), 989 FailReason::TYPE_NOT_SUPPORTED, 0); 990 991 break; 992 } 993 if (bIllegal) 994 { 995 throw IllegalArgumentException( 996 OUSTR("[automation bridge]UnoConversionUtilities<T>::anyToVariant\n" 997 "The provided any of type\" ") + rAny.getValueType().getTypeName() + 998 OUSTR("\" is unappropriate for conversion!"), Reference<XInterface>(), -1); 999 1000 } 1001 } 1002 catch (CannotConvertException & ) 1003 { 1004 throw; 1005 } 1006 catch (IllegalArgumentException & ) 1007 { 1008 throw; 1009 } 1010 catch(BridgeRuntimeError&) 1011 { 1012 throw; 1013 } 1014 catch(Exception & e) 1015 { 1016 throw BridgeRuntimeError( 1017 OUSTR("[automation bridge]UnoConversionUtilities<T>::anyToVariant \n" 1018 "Unexpected exception occurred. Message: ") + e.Message); 1019 } 1020 catch(...) 1021 { 1022 throw BridgeRuntimeError( 1023 OUSTR("[automation bridge]UnoConversionUtilities<T>::anyToVariant \n" 1024 "Unexpected exception occurred. ") ); 1025 } 1026 } 1027 1028 // Creates an SAFEARRAY of the specified element and if necessary 1029 // creates a SAFEARRAY with multiple dimensions. 1030 // Used by sal_Bool anyToVariant(VARIANT* pVariant, const Any& rAny, VARTYPE type); 1031 template<class T> 1032 SAFEARRAY* UnoConversionUtilities<T>::createUnoSequenceWrapper(const Any& rSeq, VARTYPE elemtype) 1033 { 1034 if (rSeq.getValueTypeClass() != TypeClass_SEQUENCE) 1035 throw IllegalArgumentException( 1036 OUSTR("[automation bridge]UnoConversionUtilities<T>::createUnoSequenceWrapper \n" 1037 "The any does not contain a sequence!"), 0, 0); 1038 if (elemtype == VT_NULL || elemtype == VT_EMPTY) 1039 throw IllegalArgumentException( 1040 OUSTR("[automation bridge]UnoConversionUtilities<T>::createUnoSequenceWrapper \n" 1041 "No element type supplied!"),0, -1); 1042 SAFEARRAY* pArray= NULL; 1043 // Get the dimensions. This is done by examining the type name string 1044 // The count of brackets determines the dimensions. 1045 OUString sTypeName= rSeq.getValueType().getTypeName(); 1046 sal_Int32 dims=0; 1047 for(sal_Int32 lastIndex=0;(lastIndex= sTypeName.indexOf( L'[', lastIndex)) != -1; lastIndex++,dims++); 1048 1049 //get the maximum number of elements per dimensions and the typedescription of the elements 1050 Sequence<sal_Int32> seqElementCounts( dims); 1051 TypeDescription elementTypeDesc; 1052 getElementCountAndTypeOfSequence( rSeq, 1, seqElementCounts, elementTypeDesc ); 1053 1054 if( elementTypeDesc.is() ) 1055 { 1056 // set up the SAFEARRAY 1057 scoped_array<SAFEARRAYBOUND> sarSafeArrayBound(new SAFEARRAYBOUND[dims]); 1058 SAFEARRAYBOUND* prgsabound= sarSafeArrayBound.get(); 1059 for( sal_Int32 i=0; i < dims; i++) 1060 { 1061 //prgsabound[0] is the right most dimension 1062 prgsabound[dims - i - 1].lLbound = 0; 1063 prgsabound[dims - i - 1].cElements = seqElementCounts[i]; 1064 } 1065 1066 typelib_TypeDescription* rawTypeDesc= elementTypeDesc.get(); 1067 sal_Int32 elementSize= rawTypeDesc->nSize; 1068 size_t oleElementSize= getOleElementSize( elemtype); 1069 // SafeArrayCreate clears the memory for the data itself. 1070 pArray = SafeArrayCreate(elemtype, dims, prgsabound); 1071 1072 // convert the Sequence's elements and populate the SAFEARRAY 1073 if( pArray) 1074 { 1075 // Iterate over every Sequence that contains the actual elements 1076 void* pSAData; 1077 if( SUCCEEDED( SafeArrayAccessData( pArray, &pSAData))) 1078 { 1079 const sal_Int32* parElementCount= seqElementCounts.getConstArray(); 1080 uno_Sequence * pMultiSeq= *(uno_Sequence* const*) rSeq.getValue(); 1081 sal_Int32 dimsSeq= dims - 1; 1082 1083 // arDimSeqIndizes contains the current index of a block of data. 1084 // E.g. Sequence<Sequence<sal_Int32>> , the index would refer to Sequence<sal_Int32> 1085 // In this case arDimSeqIndices would have the size 1. That is the elements are not counted 1086 // but the Sequences that contain those elements. 1087 // The indices ar 0 based 1088 scoped_array<sal_Int32> sarDimsSeqIndices; 1089 sal_Int32* arDimsSeqIndices= NULL; 1090 if( dimsSeq > 0) 1091 { 1092 sarDimsSeqIndices.reset(new sal_Int32[dimsSeq]); 1093 arDimsSeqIndices = sarDimsSeqIndices.get(); 1094 memset( arDimsSeqIndices, 0, sizeof( sal_Int32 ) * dimsSeq); 1095 } 1096 1097 char* psaCurrentData= (char*)pSAData; 1098 1099 do 1100 { 1101 // Get the Sequence at the current index , see arDimsSeqIndices 1102 uno_Sequence * pCurrentSeq= pMultiSeq; 1103 sal_Int32 curDim=1; // 1 based 1104 sal_Bool skipSeq= sal_False; 1105 while( curDim <= dimsSeq ) 1106 { 1107 // get the Sequence at the index if valid 1108 if( pCurrentSeq->nElements > arDimsSeqIndices[ curDim - 1] ) // don't point to Nirvana 1109 { 1110 // size of Sequence is 4 1111 sal_Int32 offset= arDimsSeqIndices[ curDim - 1] * 4; 1112 pCurrentSeq= *(uno_Sequence**) &pCurrentSeq->elements[ offset]; 1113 curDim++; 1114 } 1115 else 1116 { 1117 // There is no Sequence at this index, so skip this index 1118 skipSeq= sal_True; 1119 break; 1120 } 1121 } 1122 1123 if( skipSeq) 1124 continue; 1125 1126 // Calculate the current position within the datablock of the SAFEARRAY 1127 // for the next Sequence. 1128 sal_Int32 memOffset= 0; 1129 sal_Int32 dimWeight= parElementCount[ dims - 1]; // size of the rightmost dimension 1130 for(sal_Int16 idims=0; idims < dimsSeq; idims++ ) 1131 { 1132 memOffset+= arDimsSeqIndices[dimsSeq - 1 - idims] * dimWeight; 1133 // now determine the weight of the dimension to the left of the current. 1134 if( dims - 2 - idims >=0) 1135 dimWeight*= parElementCount[dims - 2 - idims]; 1136 } 1137 psaCurrentData= (char*)pSAData + memOffset * oleElementSize; 1138 // convert the Sequence and put the elements into the Safearray 1139 for( sal_Int32 i= 0; i < pCurrentSeq->nElements; i++) 1140 { 1141 Any unoElement( pCurrentSeq->elements + i * elementSize, rawTypeDesc ); 1142 // The any is being converted into an VARIANT which value is then copied 1143 // to the SAFEARRAY's data block. When copying one has to follow the rules for 1144 // copying certain types, as are VT_DISPATCH, VT_UNKNOWN, VT_VARIANT, VT_BSTR. 1145 // To increase performance, we just do a memcpy of VARIANT::byref. This is possible 1146 // because anyToVariant has already followed the copying rules. To make this 1147 // work there must not be a VariantClear. 1148 // One Exception is VARIANT because I don't know how VariantCopy works. 1149 1150 VARIANT var; 1151 VariantInit( &var); 1152 anyToVariant( &var, unoElement); 1153 if( elemtype == VT_VARIANT ) 1154 { 1155 VariantCopy( ( VARIANT*)psaCurrentData, &var); 1156 VariantClear( &var); 1157 } 1158 else 1159 memcpy( psaCurrentData, &var.byref, oleElementSize); 1160 1161 psaCurrentData+= oleElementSize; 1162 } 1163 } 1164 while( incrementMultidimensionalIndex( dimsSeq, parElementCount, arDimsSeqIndices)); 1165 1166 SafeArrayUnaccessData( pArray); 1167 } 1168 } 1169 } 1170 return pArray; 1171 } 1172 1173 // Increments a multi dimensional index. 1174 // Returns true as long as the index has been successfully incremented, false otherwise. 1175 // False is also returned if an overflow of the most significant dimension occurs. E.g. 1176 // assume an array with the dimensions (2,2), then the lowest index is (0,0) and the highest 1177 // index is (1,1). If the function is being called with the index (1,1) then the overflow would 1178 // occur, with the result (0,0) and a sal_False as return value. 1179 // Param dimensions - number of dimensions 1180 // Param parDimensionsLength - The array contains the size of each dimension, that is the 1181 // size of the array equals the parameter dimensions. 1182 // The rightmost dimensions is the least significant one 1183 // ( parDimensionsLengths[ dimensions -1 ] ). 1184 // Param parMultiDimensionalIndex - The array contains the index. Each dimension index is 1185 // 0 based. 1186 template<class T> 1187 sal_Bool UnoConversionUtilities<T>::incrementMultidimensionalIndex(sal_Int32 dimensions, 1188 const sal_Int32 * parDimensionLengths, 1189 sal_Int32 * parMultidimensionalIndex) 1190 { 1191 if( dimensions < 1) 1192 return sal_False; 1193 1194 sal_Bool ret= sal_True; 1195 sal_Bool carry= sal_True; // to get into the while loop 1196 1197 sal_Int32 currentDimension= dimensions; //most significant is 1 1198 while( carry) 1199 { 1200 parMultidimensionalIndex[ currentDimension - 1]++; 1201 // if carryover, set index to 0 and handle carry on a level above 1202 if( parMultidimensionalIndex[ currentDimension - 1] > (parDimensionLengths[ currentDimension - 1] - 1)) 1203 parMultidimensionalIndex[ currentDimension - 1]= 0; 1204 else 1205 carry= sal_False; 1206 1207 currentDimension --; 1208 // if dimensions drops below 1 and carry is set than then all indices are 0 again 1209 // this is signalled by returning sal_False 1210 if( currentDimension < 1 && carry) 1211 { 1212 carry= sal_False; 1213 ret= sal_False; 1214 } 1215 } 1216 return ret; 1217 } 1218 1219 // Determines the size of a certain OLE type. The function takes 1220 // only those types into account which are oleautomation types and 1221 // can have a value ( unless VT_NULL, VT_EMPTY, VT_ARRAY, VT_BYREF). 1222 // Currently used in createUnoSequenceWrapper to calculate addresses 1223 // for data within a SAFEARRAY. 1224 template<class T> 1225 size_t UnoConversionUtilities<T>::getOleElementSize( VARTYPE type) 1226 { 1227 size_t size; 1228 switch( type) 1229 { 1230 case VT_BOOL: size= sizeof( VARIANT_BOOL);break; 1231 case VT_UI1: size= sizeof( unsigned char);break; 1232 case VT_R8: size= sizeof( double);break; 1233 case VT_R4: size= sizeof( float);break; 1234 case VT_I2: size= sizeof( short);break; 1235 case VT_I4: size= sizeof( long);break; 1236 case VT_BSTR: size= sizeof( BSTR); break; 1237 case VT_ERROR: size= sizeof( SCODE); break; 1238 case VT_DISPATCH: 1239 case VT_UNKNOWN: size= sizeof( IUnknown*); break; 1240 case VT_VARIANT: size= sizeof( VARIANT);break; 1241 default: size= 0; 1242 } 1243 return size; 1244 } 1245 1246 //If a Sequence is being converted into a SAFEARRAY then we possibly have 1247 // to create a SAFEARRAY with multiple dimensions. This is the case when a 1248 // Sequence contains Sequences ( Sequence< Sequence < XXX > > ). The leftmost 1249 // Sequence in the declaration is assumed to represent dimension 1. Because 1250 // all Sequence elements of a Sequence can have different length, we have to 1251 // determine the maximum length which is then the length of the respective 1252 // dimension. 1253 // getElementCountAndTypeOfSequence determines the length of each dimension and calls itself recursively 1254 // in the process. 1255 // param rSeq - an Any that has to contain a Sequence 1256 // param dim - the dimension for which the number of elements is being determined, 1257 // must be one. 1258 // param seqElementCounts - contains the maximum number of elements for each 1259 // dimension. Index 0 contains the number of dimension one. 1260 // After return the Sequence contains the maximum number of 1261 // elements for each dimension. 1262 // The length of the Sequence must equal the number of dimensions. 1263 // param typeClass - TypeClass of the element type that is no Sequence, e.g. 1264 // Sequence< Sequence <Sequence <sal_Int32> > > - type is sal_Int32) 1265 template<class T> 1266 void UnoConversionUtilities<T>::getElementCountAndTypeOfSequence( const Any& rSeq, sal_Int32 dim, 1267 Sequence< sal_Int32 >& seqElementCounts, TypeDescription& typeDesc) 1268 { 1269 sal_Int32 dimCount= (*(uno_Sequence* const *) rSeq.getValue())->nElements; 1270 if( dimCount > seqElementCounts[ dim-1]) 1271 seqElementCounts[ dim-1]= dimCount; 1272 1273 // we need the element type to construct the any that is 1274 // passed into getElementCountAndTypeOfSequence again 1275 typelib_TypeDescription* pSeqDesc= NULL; 1276 rSeq.getValueTypeDescription( &pSeqDesc); 1277 typelib_TypeDescriptionReference* pElementDescRef= ((typelib_IndirectTypeDescription*)pSeqDesc)->pType; 1278 1279 // if the elements are Sequences than do recursion 1280 if( dim < seqElementCounts.getLength() ) 1281 { 1282 uno_Sequence* pSeq = *(uno_Sequence* const*) rSeq.getValue(); 1283 uno_Sequence** arSequences= (uno_Sequence**)pSeq->elements; 1284 for( sal_Int32 i=0; i < dimCount; i++) 1285 { 1286 uno_Sequence* arElement= arSequences[ i]; 1287 getElementCountAndTypeOfSequence( Any( &arElement, pElementDescRef), dim + 1 , seqElementCounts, typeDesc); 1288 } 1289 } 1290 else 1291 { 1292 // determine the element type ( e.g. Sequence< Sequence <Sequence <sal_Int32> > > - type is sal_Int32) 1293 typeDesc= pElementDescRef; 1294 } 1295 typelib_typedescription_release( pSeqDesc); 1296 } 1297 1298 1299 template<class T> 1300 SAFEARRAY* UnoConversionUtilities<T>::createUnoSequenceWrapper(const Any& rSeq) 1301 { 1302 SAFEARRAY* pArray = NULL; 1303 sal_uInt32 n = 0; 1304 1305 if( rSeq.getValueTypeClass() != TypeClass_SEQUENCE ) 1306 throw IllegalArgumentException( 1307 OUSTR("[automation bridge]UnoConversionUtilities<T>::createUnoSequenceWrapper\n" 1308 "The UNO argument is not a sequence"), 0, -1); 1309 1310 uno_Sequence * punoSeq= *(uno_Sequence**) rSeq.getValue(); 1311 1312 typelib_TypeDescriptionReference* pSeqTypeRef= rSeq.getValueTypeRef(); 1313 typelib_TypeDescription* pSeqType= NULL; 1314 TYPELIB_DANGER_GET( &pSeqType, pSeqTypeRef); 1315 typelib_IndirectTypeDescription * pSeqIndDec= (typelib_IndirectTypeDescription*) pSeqType; 1316 1317 1318 typelib_TypeDescriptionReference * pSeqElementTypeRef= pSeqIndDec->pType; 1319 TYPELIB_DANGER_RELEASE( pSeqType); 1320 1321 typelib_TypeDescription* pSeqElementDesc= NULL; 1322 TYPELIB_DANGER_GET( &pSeqElementDesc, pSeqElementTypeRef); 1323 sal_Int32 nElementSize= pSeqElementDesc->nSize; 1324 n= punoSeq->nElements; 1325 1326 SAFEARRAYBOUND rgsabound[1]; 1327 rgsabound[0].lLbound = 0; 1328 rgsabound[0].cElements = n; 1329 VARIANT oleElement; 1330 long safeI[1]; 1331 1332 pArray = SafeArrayCreate(VT_VARIANT, 1, rgsabound); 1333 1334 Any unoElement; 1335 sal_uInt8 * pSeqData= (sal_uInt8*) punoSeq->elements; 1336 1337 for (sal_uInt32 i = 0; i < n; i++) 1338 { 1339 unoElement.setValue( pSeqData + i * nElementSize, pSeqElementDesc); 1340 VariantInit(&oleElement); 1341 1342 anyToVariant(&oleElement, unoElement); 1343 1344 safeI[0] = i; 1345 SafeArrayPutElement(pArray, safeI, &oleElement); 1346 1347 VariantClear(&oleElement); 1348 } 1349 TYPELIB_DANGER_RELEASE( pSeqElementDesc); 1350 1351 return pArray; 1352 } 1353 1354 /* The argument rObj can contain 1355 - UNO struct 1356 - UNO interface 1357 - UNO interface created by this bridge (adapter factory) 1358 - UNO interface created by this bridge ( COM Wrapper) 1359 1360 pVar must be initialized. 1361 */ 1362 template<class T> 1363 void UnoConversionUtilities<T>::createUnoObjectWrapper(const Any & rObj, VARIANT * pVar) 1364 { 1365 MutexGuard guard(getBridgeMutex()); 1366 1367 Reference<XInterface> xInt; 1368 1369 TypeClass tc = rObj.getValueTypeClass(); 1370 if (tc != TypeClass_INTERFACE && tc != TypeClass_STRUCT) 1371 throw IllegalArgumentException( 1372 OUSTR("[automation bridge]UnoConversionUtilities<T>::createUnoObjectWrapper \n" 1373 "Cannot create an Automation interface for a UNO type which is not " 1374 "a struct or interface!"), 0, -1); 1375 1376 if (rObj.getValueTypeClass() == TypeClass_INTERFACE) 1377 { 1378 if (! (rObj >>= xInt)) 1379 throw IllegalArgumentException( 1380 OUSTR("[automation bridge] UnoConversionUtilities<T>::createUnoObjectWrapper\n " 1381 "Could not create wrapper object for UNO object!"), 0, -1); 1382 //If XInterface is NULL, which is a valid value, then simply return NULL. 1383 if ( ! xInt.is()) 1384 { 1385 pVar->vt = VT_UNKNOWN; 1386 pVar->punkVal = NULL; 1387 return; 1388 } 1389 //make sure we have the main XInterface which is used with a map 1390 xInt = Reference<XInterface>(xInt, UNO_QUERY); 1391 //If there is already a wrapper for the UNO object then use it 1392 1393 Reference<XInterface> xIntWrapper; 1394 // Does a UNO wrapper exist already ? 1395 IT_Uno it_uno = UnoObjToWrapperMap.find( (sal_uInt32) xInt.get()); 1396 if(it_uno != UnoObjToWrapperMap.end()) 1397 { 1398 xIntWrapper = it_uno->second; 1399 if (xIntWrapper.is()) 1400 { 1401 convertSelfToCom(xIntWrapper, pVar); 1402 return; 1403 } 1404 } 1405 // Is the object a COM wrapper ( either XInvocation, or Adapter object) 1406 // or does it supply an IDispatch by its own ? 1407 else 1408 { 1409 Reference<XInterface> xIntComWrapper = xInt; 1410 typedef hash_map<sal_uInt32,sal_uInt32>::iterator _IT; 1411 // Adapter? then get the COM wrapper to which the adapter delegates its calls 1412 _IT it= AdapterToWrapperMap.find( (sal_uInt32) xInt.get()); 1413 if( it != AdapterToWrapperMap.end() ) 1414 xIntComWrapper= reinterpret_cast<XInterface*>(it->second); 1415 1416 if (convertSelfToCom(xIntComWrapper, pVar)) 1417 return; 1418 } 1419 } 1420 // If we have no UNO wrapper nor the IDispatch yet then we have to create 1421 // a wrapper. For that we need an XInvocation from the UNO object. 1422 1423 // get an XInvocation or create one using the invocation service 1424 Reference<XInvocation> xInv(xInt, UNO_QUERY); 1425 if ( ! xInv.is()) 1426 { 1427 Reference<XSingleServiceFactory> xInvFactory= getInvocationFactory(rObj); 1428 if (xInvFactory.is()) 1429 { 1430 Sequence<Any> params(1); 1431 params.getArray()[0] = rObj; 1432 Reference<XInterface> xInt = xInvFactory->createInstanceWithArguments(params); 1433 xInv= Reference<XInvocation>(xInt, UNO_QUERY); 1434 } 1435 } 1436 1437 if (xInv.is()) 1438 { 1439 Reference<XInterface> xNewWrapper = createUnoWrapperInstance(); 1440 Reference<XInitialization> xInitWrapper(xNewWrapper, UNO_QUERY); 1441 if (xInitWrapper.is()) 1442 { 1443 VARTYPE vartype= getVarType( rObj); 1444 1445 if (xInt.is()) 1446 { 1447 Any params[3]; 1448 params[0] <<= xInv; 1449 params[1] <<= xInt; 1450 params[2] <<= vartype; 1451 xInitWrapper->initialize( Sequence<Any>(params, 3)); 1452 } 1453 else 1454 { 1455 Any params[2]; 1456 params[0] <<= xInv; 1457 params[1] <<= vartype; 1458 xInitWrapper->initialize( Sequence<Any>(params, 2)); 1459 } 1460 1461 // put the newly created object into a map. If the same object will 1462 // be mapped again and there is already a wrapper then the old wrapper 1463 // will be used. 1464 if(xInt.is()) // only interfaces 1465 UnoObjToWrapperMap[(sal_uInt32) xInt.get()]= xNewWrapper; 1466 convertSelfToCom(xNewWrapper, pVar); 1467 return; 1468 } 1469 } 1470 } 1471 1472 template<class T> 1473 void UnoConversionUtilities<T>::variantToAny( const VARIANT* pVariant, Any& rAny, 1474 sal_Bool bReduceValueRange /* = sal_True */) 1475 { 1476 HRESULT hr = S_OK; 1477 try 1478 { 1479 CComVariant var; 1480 1481 // There is no need to support indirect values, since they're not supported by UNO 1482 if( FAILED(hr= VariantCopyInd( &var, const_cast<VARIANTARG*>(pVariant)))) // remove VT_BYREF 1483 throw BridgeRuntimeError( 1484 OUSTR("[automation bridge] UnoConversionUtilities<T>::variantToAny \n" 1485 "VariantCopyInd failed for reason : ") + OUString::valueOf(hr)); 1486 1487 if ( ! convertValueObject( & var, rAny)) 1488 { 1489 if ((var.vt & VT_ARRAY) > 0) 1490 { 1491 VARTYPE oleTypeFlags = ::sal::static_int_cast< VARTYPE, int >( var.vt ^ VT_ARRAY ); 1492 1493 Sequence<Any> unoSeq = createOleArrayWrapper(var.parray, oleTypeFlags); 1494 rAny.setValue( &unoSeq, getCppuType( &unoSeq)); 1495 } 1496 else 1497 { 1498 switch (var.vt) 1499 { 1500 case VT_EMPTY: 1501 rAny.setValue(NULL, Type()); 1502 break; 1503 case VT_NULL: 1504 rAny.setValue(NULL, Type()); 1505 break; 1506 case VT_I2: 1507 rAny.setValue( & var.iVal, getCppuType( (sal_Int16*)0)); 1508 break; 1509 case VT_I4: 1510 rAny.setValue( & var.lVal, getCppuType( (sal_Int32*)0)); 1511 // necessary for use in JavaScript ( see "reduceRange") 1512 if( bReduceValueRange) 1513 reduceRange(rAny); 1514 break; 1515 case VT_R4: 1516 rAny.setValue( & var.fltVal, getCppuType( (float*)0)); 1517 break; 1518 case VT_R8: 1519 rAny.setValue(& var.dblVal, getCppuType( (double*)0)); 1520 break; 1521 case VT_CY: 1522 { 1523 Currency cy(var.cyVal.int64); 1524 rAny <<= cy; 1525 break; 1526 } 1527 case VT_DATE: 1528 { 1529 Date d(var.date); 1530 rAny <<= d; 1531 break; 1532 } 1533 case VT_BSTR: 1534 { 1535 OUString b(reinterpret_cast<const sal_Unicode*>(var.bstrVal)); 1536 rAny.setValue( &b, getCppuType( &b)); 1537 break; 1538 } 1539 case VT_UNKNOWN: 1540 case VT_DISPATCH: 1541 { 1542 //check if it is a UNO type 1543 #ifdef __MINGW32__ 1544 CComQIPtr<IUnoTypeWrapper, &__uuidof(IUnoTypeWrapper)> spType((IUnknown*) var.byref); 1545 #else 1546 CComQIPtr<IUnoTypeWrapper> spType((IUnknown*) var.byref); 1547 #endif 1548 if (spType) 1549 { 1550 CComBSTR sName; 1551 if (FAILED(spType->get_Name(&sName))) 1552 throw BridgeRuntimeError( 1553 OUSTR("[automation bridge]UnoConversionUtilities<T>::variantToAny \n" 1554 "Failed to get the type name from a UnoTypeWrapper!")); 1555 Type type; 1556 if (getType(sName, type) == false) 1557 { 1558 throw CannotConvertException( 1559 OUSTR("[automation bridge]UnoConversionUtilities<T>::variantToAny \n" 1560 "A UNO type with the name: ") + OUString(reinterpret_cast<const sal_Unicode*>(LPCOLESTR(sName))) + 1561 OUSTR("does not exist!"), 1562 0, TypeClass_UNKNOWN, FailReason::TYPE_NOT_SUPPORTED,0); 1563 } 1564 rAny <<= type; 1565 } 1566 else 1567 { 1568 rAny = createOleObjectWrapper( & var); 1569 } 1570 break; 1571 } 1572 case VT_ERROR: 1573 { 1574 SCode scode(var.scode); 1575 rAny <<= scode; 1576 break; 1577 } 1578 case VT_BOOL: 1579 { 1580 sal_Bool b= var.boolVal == VARIANT_TRUE; 1581 rAny.setValue( &b, getCppuType( &b)); 1582 break; 1583 } 1584 case VT_I1: 1585 rAny.setValue( & var.cVal, getCppuType((sal_Int8*)0)); 1586 break; 1587 case VT_UI1: // there is no unsigned char in UNO 1588 rAny.setValue( & var.bVal, getCppuType( (sal_Int8*)0)); 1589 break; 1590 case VT_UI2: 1591 rAny.setValue( & var.uiVal, getCppuType( (sal_uInt16*)0)); 1592 break; 1593 case VT_UI4: 1594 rAny.setValue( & var.ulVal, getCppuType( (sal_uInt32*)0)); 1595 break; 1596 case VT_INT: 1597 rAny.setValue( & var.intVal, getCppuType( (sal_Int32*)0)); 1598 break; 1599 case VT_UINT: 1600 rAny.setValue( & var.uintVal, getCppuType( (sal_uInt32*)0)); 1601 break; 1602 case VT_VOID: 1603 rAny.setValue( NULL, Type()); 1604 break; 1605 case VT_DECIMAL: 1606 { 1607 Decimal dec; 1608 dec.Scale = var.decVal.scale; 1609 dec.Sign = var.decVal.sign; 1610 dec.LowValue = var.decVal.Lo32; 1611 dec.MiddleValue = var.decVal.Mid32; 1612 dec.HighValue = var.decVal.Hi32; 1613 rAny <<= dec; 1614 break; 1615 } 1616 1617 default: 1618 break; 1619 } 1620 } 1621 } 1622 } 1623 catch (IllegalArgumentException & ) 1624 { 1625 throw; 1626 } 1627 catch (CannotConvertException &) 1628 { 1629 throw; 1630 } 1631 catch (BridgeRuntimeError & ) 1632 { 1633 throw; 1634 } 1635 catch (Exception & e) 1636 { 1637 throw BridgeRuntimeError(OUSTR("[automation bridge] unexpected exception in " 1638 "UnoConversionUtilities<T>::variantToAny ! Message : \n") + 1639 e.Message); 1640 } 1641 catch(...) 1642 { 1643 throw BridgeRuntimeError( 1644 OUSTR("[automation bridge] unexpected exception in " 1645 "UnoConversionUtilities<T>::variantToAny !")); 1646 } 1647 1648 } 1649 // The function converts an IUnknown* into an UNO interface or struct. The 1650 // IUnknown pointer can constitute different kind of objects: 1651 // 1. a wrapper of an UNO struct (the wrapper was created by this bridge) 1652 // 2. a wrapper of an UNO interface (created by this bridge) 1653 // 3. a dispatch object that implements UNO interfaces 1654 // 4. a dispatch object. 1655 1656 // If the parameter "aType" has a value then the COM object ( pUnknown) is supposed to 1657 // implement the interface described by "aType". Moreover it ( pUnknown) can implement 1658 // several other 1659 // UNO interfaces in which case it has to support the SUPPORTED_INTERFACES_PROP (see 1660 // #define) property. That property contains all names of interfaces. 1661 // "pUnknown" is wrapped by a COM wrapper object that implements XInvocation, e.g. 1662 // IUnknownWrapper_Impl. Additionally an object of type "aType" is created by help 1663 // of the INTERFACE_ADAPTER_FACTORY (see #define) service. The implementation of 1664 // "aType" calls on the COM wrapper's XInvocation::invoke. If the COM object supports 1665 // more then one UNO interfaces, as can be determined by the property 1666 // SUPPORTED_INTERFACES_PROP, then the INTERFACE_ADAPTER_FACTORY creates an object that 1667 // implements all these interfaces. 1668 // This is only done if "pUnknown" is not already a UNO wrapper, 1669 // that is it is actually NOT an UNO object that was converted to a COM object. If it is an 1670 // UNO wrapper than the original UNO object is being extracted, queried for "aType" (if 1671 // it is no struct) and returned. 1672 template<class T> 1673 #ifdef __MINGW32__ 1674 Any UnoConversionUtilities<T>::createOleObjectWrapper(VARIANT* pVar, const Type& aType) 1675 #else 1676 Any UnoConversionUtilities<T>::createOleObjectWrapper(VARIANT* pVar, const Type& aType= Type()) 1677 #endif 1678 { 1679 //To allow passing "Nothing" in VS 2008 we need to accept VT_EMPTY 1680 if (pVar->vt != VT_UNKNOWN && pVar->vt != VT_DISPATCH && pVar->vt != VT_EMPTY) 1681 throw IllegalArgumentException( 1682 OUSTR("[automation bridge]UnoConversionUtilities<T>::createOleObjectWrapper \n" 1683 "The VARIANT does not contain an object type! "), 0, -1); 1684 1685 MutexGuard guard( getBridgeMutex()); 1686 1687 CComPtr<IUnknown> spUnknown; 1688 CComPtr<IDispatch> spDispatch; 1689 1690 if (pVar->vt == VT_UNKNOWN) 1691 { 1692 spUnknown = pVar->punkVal; 1693 if (spUnknown) 1694 #ifdef __MINGW32__ 1695 spUnknown->QueryInterface( IID_IDispatch, reinterpret_cast<LPVOID*>( & spDispatch.p)); 1696 #else 1697 spUnknown.QueryInterface( & spDispatch.p); 1698 #endif 1699 } 1700 else if (pVar->vt == VT_DISPATCH && pVar->pdispVal != NULL) 1701 { 1702 CComPtr<IDispatch> spDispatch(pVar->pdispVal); 1703 if (spDispatch) 1704 #ifdef __MINGW32__ 1705 spDispatch->QueryInterface( IID_IUnknown, reinterpret_cast<LPVOID*>( & spUnknown.p)); 1706 #else 1707 spDispatch.QueryInterface( & spUnknown.p); 1708 #endif 1709 } 1710 1711 static Type VOID_TYPE= Type(); 1712 Any ret; 1713 //If no Type is provided and pVar contains IUnknown then we return a XInterface. 1714 //If pVar contains an IDispatch then we return a XInvocation. 1715 Type desiredType = aType; 1716 1717 if (aType == VOID_TYPE) 1718 { 1719 switch (pVar->vt) 1720 { 1721 case VT_EMPTY: 1722 case VT_UNKNOWN: 1723 desiredType = getCppuType((Reference<XInterface>*) 0); 1724 break; 1725 case VT_DISPATCH: 1726 desiredType = getCppuType((Reference<XInvocation>*) 0); 1727 break; 1728 default: 1729 desiredType = aType; 1730 } 1731 } 1732 1733 // COM pointer are NULL, no wrapper required 1734 if (spUnknown == NULL) 1735 { 1736 Reference<XInterface> xInt; 1737 if( aType.getTypeClass() == TypeClass_INTERFACE) 1738 ret.setValue( &xInt, aType); 1739 else if( aType.getTypeClass() == TypeClass_STRUCT) 1740 ret.setValue( NULL, aType); 1741 else 1742 ret <<= xInt; 1743 return ret; 1744 } 1745 1746 1747 // Check if "spUnknown" is a UNO wrapper, that is an UNO object that has been 1748 // passed to COM. Then it supports IUnoObjectWrapper 1749 // and we extract the original UNO object. 1750 #ifdef __MINGW32__ 1751 CComQIPtr<IUnoObjectWrapper, &__uuidof(IUnoObjectWrapper)> spUno( spUnknown); 1752 #else 1753 CComQIPtr<IUnoObjectWrapper> spUno( spUnknown); 1754 #endif 1755 if( spUno) 1756 { // it is a wrapper 1757 Reference<XInterface> xInt; 1758 if( SUCCEEDED( spUno->getOriginalUnoObject( &xInt))) 1759 { 1760 ret <<= xInt; 1761 } 1762 else 1763 { 1764 Any any; 1765 if( SUCCEEDED( spUno->getOriginalUnoStruct(&any))) 1766 ret= any; 1767 } 1768 return ret; 1769 } 1770 1771 // "spUnknown" is a real COM object. 1772 // Before we create a new wrapper object we check if there is an existing wrapper 1773 // There can be two kinds of wrappers, those who wrap dispatch - UNO objects, and those who 1774 // wrap ordinary dispatch objects. The dispatch-UNO objects usually are adapted to represent 1775 // particular UNO interfaces. 1776 Reference<XInterface> xIntWrapper; 1777 CIT_Com cit_currWrapper= ComPtrToWrapperMap.find( reinterpret_cast<sal_uInt32>(spUnknown.p)); 1778 if(cit_currWrapper != ComPtrToWrapperMap.end()) 1779 xIntWrapper = cit_currWrapper->second; 1780 if (xIntWrapper.is()) 1781 { 1782 //Try to find an adapter for the wrapper 1783 //find the proper Adapter. The pointer in the WrapperToAdapterMap are valid as long as 1784 //we get a pointer to the wrapper from ComPtrToWrapperMap, because the Adapter hold references 1785 //to the wrapper. 1786 CIT_Wrap it = WrapperToAdapterMap.find((sal_uInt32) xIntWrapper.get()); 1787 if (it == WrapperToAdapterMap.end()) 1788 { 1789 // No adapter available. 1790 //The COM component could be a UNO object. Then we need to provide 1791 // a proxy that implements all interfaces 1792 Sequence<Type> seqTypes= getImplementedInterfaces(spUnknown); 1793 Reference<XInterface> xIntAdapter; 1794 if (seqTypes.getLength() > 0) 1795 { 1796 //It is a COM UNO object 1797 xIntAdapter = createAdapter(seqTypes, xIntWrapper); 1798 } 1799 else 1800 { 1801 // Some ordinary COM object 1802 xIntAdapter = xIntWrapper; 1803 } 1804 // return the wrapper directly, return XInterface or XInvocation 1805 ret = xIntWrapper->queryInterface(desiredType); 1806 if ( ! ret.hasValue()) 1807 throw IllegalArgumentException( 1808 OUSTR("[automation bridge]UnoConversionUtilities<T>::createOleObjectWrapper \n" 1809 "The COM object is not suitable for the UNO type: ") + 1810 desiredType.getTypeName(), 0, -1); 1811 } 1812 else 1813 { 1814 //There is an adapter available 1815 Reference<XInterface> xIntAdapter((XInterface*) it->second); 1816 ret = xIntAdapter->queryInterface( desiredType); 1817 if ( ! ret.hasValue()) 1818 throw IllegalArgumentException( 1819 OUSTR("[automation bridge]UnoConversionUtilities<T>::createOleObjectWrapper \n" 1820 "The COM object is not suitable for the UNO type: ") + 1821 desiredType.getTypeName(), 0, -1); 1822 } 1823 1824 return ret; 1825 } 1826 // No existing wrapper. Therefore create a new proxy. 1827 // If the object implements UNO interfaces then get the types. 1828 Sequence<Type> seqTypes = getImplementedInterfaces(spUnknown); 1829 if (seqTypes.getLength() == 0 && 1830 aType != VOID_TYPE && aType != getCppuType((Reference<XInvocation>*)0)) 1831 { 1832 seqTypes = Sequence<Type>( & aType, 1); 1833 } 1834 1835 //There is no existing wrapper, therefore we create one for the real COM object 1836 Reference<XInterface> xIntNewProxy= createComWrapperInstance(); 1837 if ( ! xIntNewProxy.is()) 1838 throw BridgeRuntimeError( 1839 OUSTR("[automation bridge]UnoConversionUtilities<T>::createOleObjectWrapper \n" 1840 "Could not create proxy object for COM object!")); 1841 1842 // initialize the COM wrapper 1843 Reference<XInitialization> xInit( xIntNewProxy, UNO_QUERY); 1844 OSL_ASSERT( xInit.is()); 1845 1846 Any params[3]; 1847 #ifdef __MINGW32__ 1848 params[0] <<= reinterpret_cast<sal_uInt32>( spUnknown.p ); 1849 #else 1850 params[0] <<= (sal_uInt32) spUnknown.p; 1851 #endif 1852 sal_Bool bDisp = pVar->vt == VT_DISPATCH ? sal_True : sal_False; 1853 params[1].setValue( & bDisp, getBooleanCppuType()); 1854 params[2] <<= seqTypes; 1855 1856 xInit->initialize( Sequence<Any>( params, 3)); 1857 #ifdef __MINGW32__ 1858 ComPtrToWrapperMap[reinterpret_cast<sal_uInt32>( spUnknown.p )]= xIntNewProxy; 1859 #else 1860 ComPtrToWrapperMap[reinterpret_cast<sal_uInt32>(spUnknown.p)]= xIntNewProxy; 1861 #endif 1862 1863 // we have a wrapper object 1864 //The wrapper implements already XInvocation and XInterface. If 1865 //param aType is void then the object is supposed to have XInvocation. 1866 if (aType == getCppuType((Reference<XInvocation>*)0) || 1867 (aType == VOID_TYPE && seqTypes.getLength() == 0 )) 1868 { 1869 ret = xIntNewProxy->queryInterface(desiredType); 1870 } 1871 else 1872 { 1873 Reference<XInterface> xIntAdapter = 1874 createAdapter(seqTypes, xIntNewProxy); 1875 ret = xIntAdapter->queryInterface(desiredType); 1876 } 1877 return ret; 1878 } 1879 template<class T> 1880 Reference<XInterface> UnoConversionUtilities<T>::createAdapter(const Sequence<Type>& seqTypes, 1881 const Reference<XInterface>& receiver) 1882 { 1883 Reference< XInterface> xIntAdapterFac; 1884 xIntAdapterFac= m_smgr->createInstance(INTERFACE_ADAPTER_FACTORY); 1885 // We create an adapter object that does not only implement the required type but also 1886 // all types that the COM object pretends to implement. An COM object must therefore 1887 // support the property "_implementedInterfaces". 1888 Reference<XInterface> xIntAdapted; 1889 Reference<XInvocation> xInv(receiver, UNO_QUERY); 1890 Reference<XInvocationAdapterFactory2> xAdapterFac( xIntAdapterFac, UNO_QUERY); 1891 if( xAdapterFac.is()) 1892 xIntAdapted= xAdapterFac->createAdapter( xInv, seqTypes); 1893 1894 if( xIntAdapted.is()) 1895 { 1896 // Put the pointer to the wrapper object and the interface pointer of the adapted interface 1897 // in a global map. Thus we can determine in a call to createUnoObjectWrapper whether the UNO 1898 // object is a wrapped COM object. In that case we extract the original COM object rather than 1899 // creating a wrapper around the UNO object. 1900 typedef hash_map<sal_uInt32,sal_uInt32>::value_type VALUE; 1901 AdapterToWrapperMap.insert( VALUE( (sal_uInt32) xIntAdapted.get(), (sal_uInt32) receiver.get())); 1902 WrapperToAdapterMap.insert( VALUE( (sal_uInt32) receiver.get(), (sal_uInt32) xIntAdapted.get())); 1903 } 1904 else 1905 { 1906 throw BridgeRuntimeError( 1907 OUSTR("[automation bridge]UnoConversionUtilities<T>::createOleObjectWrapper \n" 1908 "Could not create a proxy for COM object! Creation of adapter failed.")); 1909 } 1910 return xIntAdapted; 1911 } 1912 // "convertValueObject" converts a JScriptValue object contained in "var" into 1913 // an any. The type contained in the any is stipulated by a "type value" thas 1914 // was set within the JScript script on the value object ( see JScriptValue). 1915 template<class T> 1916 bool UnoConversionUtilities<T>::convertValueObject( const VARIANTARG *var, Any& any) 1917 { 1918 bool ret = false; 1919 try 1920 { 1921 bool bFail = false; 1922 HRESULT hr= S_OK; 1923 CComVariant varDisp; 1924 1925 if(SUCCEEDED(hr = varDisp.ChangeType( VT_DISPATCH, var))) 1926 { 1927 CComPtr <IJScriptValueObject> spValue; 1928 VARIANT_BOOL varBool; 1929 CComBSTR bstrType; 1930 CComVariant varValue; 1931 CComPtr<IDispatch> spDisp( varDisp.pdispVal); 1932 if(spDisp) 1933 { 1934 if(SUCCEEDED( spDisp->QueryInterface( __uuidof( IJScriptValueObject), 1935 reinterpret_cast<void**> (&spValue)))) 1936 { 1937 ret = true; // is is a ValueObject 1938 //If it is an out - param then it does not need to be converted. In/out and 1939 // in params does so. 1940 if (SUCCEEDED(hr= spValue->IsOutParam( &varBool))) 1941 { 1942 // if varBool == true then no conversion needed because out param 1943 if (varBool == VARIANT_FALSE) 1944 { 1945 if(SUCCEEDED(hr = spValue->GetValue( & bstrType, & varValue))) 1946 { 1947 Type type; 1948 if (getType(bstrType, type)) 1949 variantToAny( & varValue, any, type); 1950 else 1951 bFail = true; 1952 } 1953 else 1954 bFail = true; 1955 } 1956 } 1957 else 1958 bFail = true;; 1959 } 1960 } 1961 } 1962 else if( hr != DISP_E_TYPEMISMATCH && hr != E_NOINTERFACE) 1963 bFail = true; 1964 1965 if (bFail) 1966 throw BridgeRuntimeError( 1967 OUSTR("[automation bridge] Conversion of ValueObject failed ")); 1968 } 1969 catch (BridgeRuntimeError &) 1970 { 1971 throw; 1972 } 1973 catch (Exception & e) 1974 { 1975 throw BridgeRuntimeError(OUSTR("[automation bridge] unexpected exception in " 1976 "UnoConversionUtilities<T>::convertValueObject ! Message : \n") + 1977 e.Message); 1978 } 1979 catch(...) 1980 { 1981 throw BridgeRuntimeError( 1982 OUSTR("[automation bridge] unexpected exception in " 1983 "UnoConversionUtilities<T>::convertValueObject !")); 1984 } 1985 return ret; 1986 } 1987 1988 template<class T> 1989 void UnoConversionUtilities<T>::dispatchExObject2Sequence( const VARIANTARG* pvar, Any& anySeq, const Type& type) 1990 { 1991 try 1992 { 1993 bool bFail = false; 1994 if( pvar->vt != VT_DISPATCH) 1995 throw BridgeRuntimeError(OUSTR("[automation bridge] UnoConversionUtilities<T>::dispatchExObject2Sequence \n" 1996 "Conversion of dispatch object to Sequence failed!")); 1997 IDispatchEx* pdispEx; 1998 HRESULT hr; 1999 if( FAILED( hr= pvar->pdispVal->QueryInterface( IID_IDispatchEx, 2000 reinterpret_cast<void**>( &pdispEx)))) 2001 throw BridgeRuntimeError(OUSTR("[automation bridge] UnoConversionUtilities<T>::dispatchExObject2Sequence \n" 2002 "Conversion of dispatch object to Sequence failed!")); 2003 2004 DISPID dispid; 2005 OUString sindex; 2006 DISPPARAMS param= {0,0,0,0}; 2007 CComVariant result; 2008 2009 OLECHAR* sLength= L"length"; 2010 2011 // Get the length of the array. Can also be obtained throu GetNextDispID. The 2012 // method only returns DISPIDs of the array data. Their names are like "0", "1" etc. 2013 if( FAILED( hr= pdispEx->GetIDsOfNames(IID_NULL, &sLength , 1, LOCALE_USER_DEFAULT, &dispid))) 2014 throw BridgeRuntimeError(OUSTR("[automation bridge] UnoConversionUtilities<T>::dispatchExObject2Sequence \n" 2015 "Conversion of dispatch object to Sequence failed!")); 2016 if( FAILED( hr= pdispEx->InvokeEx(dispid, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, 2017 ¶m, &result, NULL, NULL))) 2018 throw BridgeRuntimeError(OUSTR("[automation bridge] UnoConversionUtilities<T>::dispatchExObject2Sequence \n" 2019 "Conversion of dispatch object to Sequence failed!")); 2020 if( FAILED( VariantChangeType( &result, &result, 0, VT_I4))) 2021 throw BridgeRuntimeError(OUSTR("[automation bridge] UnoConversionUtilities<T>::dispatchExObject2Sequence \n" 2022 "Conversion of dispatch object to Sequence failed!")); 2023 long length= result.lVal; 2024 2025 result.Clear(); 2026 2027 // get a few basic facts about the sequence, and reallocate: 2028 // create the Sequences 2029 // get the size of the elements 2030 typelib_TypeDescription *pDesc= NULL; 2031 type.getDescription( &pDesc); 2032 2033 typelib_IndirectTypeDescription *pSeqDesc= reinterpret_cast<typelib_IndirectTypeDescription*>(pDesc); 2034 typelib_TypeDescriptionReference *pSeqElemDescRef= pSeqDesc->pType; // type of the Sequence' elements 2035 Type elemType( pSeqElemDescRef); 2036 _typelib_TypeDescription* pSeqElemDesc=NULL; 2037 TYPELIB_DANGER_GET( &pSeqElemDesc, pSeqElemDescRef); 2038 sal_uInt32 nelementSize= pSeqElemDesc->nSize; 2039 TYPELIB_DANGER_RELEASE( pSeqElemDesc); 2040 2041 uno_Sequence *p_uno_Seq; 2042 uno_sequence_construct( &p_uno_Seq, pDesc, NULL, length, cpp_acquire); 2043 2044 typelib_TypeClass typeElement= pSeqDesc->pType->eTypeClass; 2045 char *pArray= p_uno_Seq->elements; 2046 2047 // Get All properties in the object, convert their values to the expected type and 2048 // put them into the passed in sequence 2049 for( sal_Int32 i= 0; i< length; i++) 2050 { 2051 OUString ousIndex=OUString::valueOf( i); 2052 OLECHAR* sindex = (OLECHAR*)ousIndex.getStr(); 2053 2054 if( FAILED( hr= pdispEx->GetIDsOfNames(IID_NULL, &sindex , 1, LOCALE_USER_DEFAULT, &dispid))) 2055 { 2056 throw BridgeRuntimeError(OUSTR("[automation bridge] UnoConversionUtilities<T>::dispatchExObject2Sequence \n" 2057 "Conversion of dispatch object to Sequence failed!")); 2058 } 2059 if( FAILED( hr= pdispEx->InvokeEx(dispid, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, 2060 ¶m, &result, NULL, NULL))) 2061 { 2062 throw BridgeRuntimeError(OUSTR("[automation bridge] UnoConversionUtilities<T>::dispatchExObject2Sequence \n" 2063 "Conversion of dispatch object to Sequence failed!")); 2064 } 2065 2066 // If the result is VT_DISPATCH than the Sequence's element type could be Sequence 2067 // Look that up in the CoreReflection to make clear. 2068 // That requires a recursiv conversion 2069 Any any; 2070 // Destination address within the out-Sequence "anySeq" where to copy the next converted element 2071 void* pDest= (void*)(pArray + (i * nelementSize)); 2072 2073 if( result.vt & VT_DISPATCH && typeElement == typelib_TypeClass_SEQUENCE) 2074 { 2075 variantToAny( &result, any, elemType, sal_False); 2076 // copy the converted VARIANT, that is a Sequence to the Sequence 2077 uno_Sequence * p_unoSeq= *(uno_Sequence**)any.getValue(); 2078 // just copy the pointer of the uno_Sequence 2079 // nelementSize should be 4 !!!! 2080 memcpy( pDest, &p_unoSeq, nelementSize); 2081 osl_incrementInterlockedCount( &p_unoSeq->nRefCount); 2082 } 2083 else // Element type is no Sequence -> do one conversion 2084 { 2085 variantToAny( &result, any, elemType, sal_False); 2086 if( typeElement == typelib_TypeClass_ANY) 2087 { 2088 // copy the converted VARIANT to the Sequence 2089 uno_type_assignData( pDest, pSeqElemDescRef , &any, pSeqElemDescRef,cpp_queryInterface, 2090 cpp_acquire, cpp_release); 2091 } 2092 else 2093 { 2094 // type after conversion must be the element type of the sequence 2095 OSL_ENSURE( (any.getValueTypeClass() == typeElement), "wrong conversion"); 2096 uno_type_assignData( pDest, pSeqElemDescRef,const_cast<void*>( any.getValue()), any.getValueTypeRef(), 2097 cpp_queryInterface, cpp_acquire, cpp_release); 2098 } 2099 } 2100 } // else 2101 result.Clear(); 2102 anySeq.setValue( &p_uno_Seq, pDesc); 2103 uno_destructData( &p_uno_Seq, pDesc, cpp_release); 2104 typelib_typedescription_release( pDesc); 2105 2106 if (bFail) 2107 throw BridgeRuntimeError( 2108 OUSTR("[automation bridge] Conversion of ValueObject failed ")); 2109 } 2110 catch (BridgeRuntimeError & ) 2111 { 2112 throw; 2113 } 2114 catch (Exception & e) 2115 { 2116 throw BridgeRuntimeError(OUSTR("[automation bridge] unexpected exception in " 2117 "UnoConversionUtilities<T>::convertValueObject ! Message : \n") + 2118 e.Message); 2119 } 2120 catch(...) 2121 { 2122 throw BridgeRuntimeError( 2123 OUSTR("[automation bridge] unexpected exception in " 2124 "UnoConversionUtilities<T>::convertValueObject !")); 2125 } 2126 } 2127 2128 /* The argument unotype is the type that is expected by the currently called UNO function. 2129 For example: []long, [][]long. If the function calls itself recursively then the element type 2130 is passed on. For example a two dimensional SAFEARRAY of type VT_I4 is to be converted. Then 2131 unotype has to be either void or [][]long. When the function calls itself recursivly then 2132 it passes the element type which is []long. 2133 */ 2134 template<class T> 2135 Sequence<Any> UnoConversionUtilities<T>::createOleArrayWrapperOfDim(SAFEARRAY* pArray, 2136 unsigned int dimCount, unsigned int actDim, long* index, VARTYPE type, const Type& unotype) 2137 { 2138 HRESULT hr= S_OK; 2139 long lBound; 2140 long uBound; 2141 long nCountElements; 2142 2143 SafeArrayGetLBound(pArray, actDim, &lBound); 2144 SafeArrayGetUBound(pArray, actDim, &uBound); 2145 nCountElements= uBound - lBound +1; 2146 2147 Sequence<Any> anySeq(nCountElements); 2148 Any* pUnoArray = anySeq.getArray(); 2149 2150 for (index[actDim - 1] = lBound; index[actDim - 1] <= uBound; index[actDim - 1]++) 2151 { 2152 if (actDim > 1 ) 2153 { 2154 Sequence<Any> element = createOleArrayWrapperOfDim(pArray, dimCount, 2155 actDim - 1, index, type, getElementTypeOfSequence(unotype)); 2156 2157 pUnoArray[index[actDim - 1] - lBound].setValue(&element, getCppuType(&element)); 2158 } 2159 else 2160 { 2161 VARIANT variant; 2162 2163 VariantInit(&variant); 2164 2165 V_VT(&variant) = type; 2166 2167 switch (type) 2168 { 2169 case VT_I2: 2170 SafeArrayGetElement(pArray, index, &V_I2(&variant)); 2171 break; 2172 case VT_I4: 2173 SafeArrayGetElement(pArray, index, &V_I4(&variant)); 2174 break; 2175 case VT_R4: 2176 SafeArrayGetElement(pArray, index, &V_R4(&variant)); 2177 break; 2178 case VT_R8: 2179 SafeArrayGetElement(pArray, index, &V_R8(&variant)); 2180 break; 2181 case VT_CY: 2182 SafeArrayGetElement(pArray, index, &V_CY(&variant)); 2183 break; 2184 case VT_DATE: 2185 SafeArrayGetElement(pArray, index, &V_DATE(&variant)); 2186 break; 2187 case VT_BSTR: 2188 hr= SafeArrayGetElement(pArray, index, &V_BSTR(&variant)); 2189 break; 2190 case VT_DISPATCH: 2191 SafeArrayGetElement(pArray, index, &V_DISPATCH(&variant)); 2192 break; 2193 case VT_ERROR: 2194 SafeArrayGetElement(pArray, index, &V_ERROR(&variant)); 2195 break; 2196 case VT_BOOL: 2197 SafeArrayGetElement(pArray, index, &V_BOOL(&variant)); 2198 break; 2199 case VT_VARIANT: 2200 SafeArrayGetElement(pArray, index, &variant); 2201 break; 2202 case VT_UNKNOWN: 2203 SafeArrayGetElement(pArray, index, &V_UNKNOWN(&variant)); 2204 break; 2205 case VT_I1: 2206 SafeArrayGetElement(pArray, index, &V_I1(&variant)); 2207 break; 2208 case VT_UI1: 2209 SafeArrayGetElement(pArray, index, &V_UI1(&variant)); 2210 break; 2211 case VT_UI2: 2212 SafeArrayGetElement(pArray, index, &V_UI2(&variant)); 2213 break; 2214 case VT_UI4: 2215 SafeArrayGetElement(pArray, index, &V_UI4(&variant)); 2216 break; 2217 default: 2218 break; 2219 } 2220 2221 if( unotype.getTypeClass() == TypeClass_VOID) 2222 // the function was called without specifying the destination type 2223 variantToAny(&variant, pUnoArray[index[actDim - 1] - lBound], sal_False); 2224 else 2225 variantToAny(&variant, pUnoArray[index[actDim - 1] - lBound], 2226 getElementTypeOfSequence(unotype), sal_False); 2227 2228 VariantClear(&variant); 2229 } 2230 } 2231 return anySeq; 2232 } 2233 2234 template<class T> 2235 Type UnoConversionUtilities<T>::getElementTypeOfSequence( const Type& seqType) 2236 { 2237 Type retValue; 2238 if( seqType.getTypeClass() != TypeClass_VOID) 2239 { 2240 OSL_ASSERT( seqType.getTypeClass() == TypeClass_SEQUENCE); 2241 typelib_IndirectTypeDescription* pDescSeq= NULL; 2242 seqType.getDescription((typelib_TypeDescription** ) & pDescSeq); 2243 retValue = Type(pDescSeq->pType); 2244 typelib_typedescription_release( (typelib_TypeDescription*) pDescSeq); 2245 } 2246 return retValue; 2247 } 2248 template<class T> 2249 Sequence<Any> UnoConversionUtilities<T>::createOleArrayWrapper(SAFEARRAY* pArray, VARTYPE type, const Type& unoType) 2250 { 2251 sal_uInt32 dim = SafeArrayGetDim(pArray); 2252 2253 Sequence<Any> ret; 2254 2255 if (dim > 0) 2256 { 2257 scoped_array<long> sarIndex(new long[dim]); 2258 long * index = sarIndex.get(); 2259 2260 for (unsigned int i = 0; i < dim; i++) 2261 { 2262 index[i] = 0; 2263 } 2264 2265 ret = createOleArrayWrapperOfDim(pArray, dim, dim, index, type, unoType); 2266 } 2267 2268 return ret; 2269 } 2270 2271 // If an VARIANT has the type VT_DISPATCH it can either be an JScript Array 2272 // or some other object. This function finds out if it is such an array or 2273 // not. Currently there's no way to make sure it's an array 2274 // so we assume that when the object has a property "0" then it is an Array. 2275 // An JScript has property like "0", "1", "2" etc. which represent the 2276 // value at the corresponding index of the array 2277 template<class T> 2278 sal_Bool UnoConversionUtilities<T>::isJScriptArray(const VARIANT* rvar) 2279 { 2280 OSL_ENSURE( rvar->vt == VT_DISPATCH, "param is not a VT_DISPATCH"); 2281 HRESULT hr; 2282 OLECHAR* sindex= L"0"; 2283 DISPID id; 2284 if ( rvar->vt == VT_DISPATCH && rvar->pdispVal ) 2285 { 2286 hr= rvar->pdispVal->GetIDsOfNames( IID_NULL, &sindex, 1, 2287 LOCALE_USER_DEFAULT, &id); 2288 2289 if( SUCCEEDED ( hr) ) 2290 return sal_True; 2291 } 2292 2293 return sal_False; 2294 } 2295 2296 template<class T> 2297 VARTYPE UnoConversionUtilities<T>::mapTypeClassToVartype( TypeClass type) 2298 { 2299 VARTYPE ret; 2300 switch( type) 2301 { 2302 case TypeClass_INTERFACE: ret= VT_DISPATCH; 2303 break; 2304 case TypeClass_STRUCT: ret= VT_DISPATCH; 2305 break; 2306 case TypeClass_ENUM: ret= VT_I4; 2307 break; 2308 case TypeClass_SEQUENCE: ret= VT_ARRAY; 2309 break; 2310 case TypeClass_ANY: ret= VT_VARIANT; 2311 break; 2312 case TypeClass_BOOLEAN: ret= VT_BOOL; 2313 break; 2314 case TypeClass_CHAR: ret= VT_I2; 2315 break; 2316 case TypeClass_STRING: ret= VT_BSTR; 2317 break; 2318 case TypeClass_FLOAT: ret= VT_R4; 2319 break; 2320 case TypeClass_DOUBLE: ret= VT_R8; 2321 break; 2322 case TypeClass_BYTE: ret= VT_UI1; 2323 break; 2324 case TypeClass_SHORT: ret= VT_I2; 2325 break; 2326 case TypeClass_LONG: ret= VT_I4; 2327 break; 2328 case TypeClass_UNSIGNED_SHORT: ret= VT_UI2; 2329 break; 2330 case TypeClass_UNSIGNED_LONG: ret= VT_UI4; 2331 break; 2332 default: 2333 ret= VT_EMPTY; 2334 } 2335 return ret; 2336 } 2337 2338 template<class T> 2339 Sequence<Type> UnoConversionUtilities<T>::getImplementedInterfaces(IUnknown* pUnk) 2340 { 2341 Sequence<Type> seqTypes; 2342 CComDispatchDriver disp( pUnk); 2343 if( disp) 2344 { 2345 CComVariant var; 2346 HRESULT hr= S_OK; 2347 // There are two different property names possible. 2348 if( FAILED( hr= disp.GetPropertyByName( SUPPORTED_INTERFACES_PROP, &var))) 2349 { 2350 hr= disp.GetPropertyByName( SUPPORTED_INTERFACES_PROP2, &var); 2351 } 2352 if (SUCCEEDED( hr)) 2353 { 2354 // we exspect an array( SafeArray or IDispatch) of Strings. 2355 Any anyNames; 2356 variantToAny( &var, anyNames, getCppuType( (Sequence<Any>*) 0)); 2357 Sequence<Any> seqAny; 2358 if( anyNames >>= seqAny) 2359 { 2360 seqTypes.realloc( seqAny.getLength()); 2361 for( sal_Int32 i=0; i < seqAny.getLength(); i++) 2362 { 2363 OUString typeName; 2364 seqAny[i] >>= typeName; 2365 seqTypes[i]= Type( TypeClass_INTERFACE, typeName); 2366 } 2367 } 2368 } 2369 } 2370 return seqTypes; 2371 } 2372 template<class T> 2373 Reference<XTypeConverter> UnoConversionUtilities<T>::getTypeConverter() 2374 { 2375 if ( ! m_typeConverter.is()) 2376 { 2377 MutexGuard guard(getBridgeMutex()); 2378 if ( ! m_typeConverter.is()) 2379 { 2380 Reference<XInterface> xIntConverter = 2381 m_smgr->createInstance(OUSTR("com.sun.star.script.Converter")); 2382 if (xIntConverter.is()) 2383 m_typeConverter = Reference<XTypeConverter>(xIntConverter, UNO_QUERY); 2384 } 2385 } 2386 return m_typeConverter; 2387 } 2388 2389 // This function tries to the change the type of a value (contained in the Any) 2390 // to the smallest possible that can hold the value. This is actually done only 2391 // for types of VT_I4 (see o2u_variantToAny). The reason is the following: 2392 // JavaScript passes integer values always as VT_I4. If there is a parameter or 2393 // property of type any then the bridge converts the any's content according 2394 // to "o2u_variantToAny". Because the VARTYPE is VT_I4 the value would be converted 2395 // to TypeClass_LONG. Say the method XPropertySet::setPropertyValue( string name, any value) 2396 // would be called on an object and the property actually is of TypeClass_SHORT. 2397 // After conversion of the VARIANT parameter the Any would contain type 2398 // TypeClass_LONG. Because the corereflection does not cast from long to short 2399 // the "setPropertValue" would fail as the value has not the right type. 2400 2401 // The corereflection does convert small integer types to bigger types. 2402 // Therefore we can reduce the type if possible and avoid the above mentioned 2403 // problem. 2404 2405 // The function is not used when elements are to be converted for Sequences. 2406 2407 #ifndef _REDUCE_RANGE 2408 #define _REDUCE_RANGE 2409 inline void reduceRange( Any& any) 2410 { 2411 OSL_ASSERT( any.getValueTypeClass() == TypeClass_LONG); 2412 2413 sal_Int32 value= *(sal_Int32*)any.getValue(); 2414 if( value <= 0x7f && value >= -0x80) 2415 {// -128 bis 127 2416 sal_Int8 charVal= static_cast<sal_Int8>( value); 2417 any.setValue( &charVal, getCppuType( (sal_Int8*)0)); 2418 } 2419 else if( value <= 0x7fff && value >= -0x8000) 2420 {// -32768 bis 32767 2421 sal_Int16 shortVal= static_cast<sal_Int16>( value); 2422 any.setValue( &shortVal, getCppuType( (sal_Int16*)0)); 2423 } 2424 } 2425 #endif 2426 2427 2428 2429 } // end namespace 2430 #endif 2431 2432