1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 // MARKER(update_precomp.py): autogen include statement, do not remove 29 #include "precompiled_extensions.hxx" 30 31 #ifdef __MINGW32__ 32 #define INITGUID 33 #include <initguid.h> 34 #else 35 #include "ole2uno.hxx" 36 #include "unoconversionutilities.hxx" 37 #endif 38 #include "servprov.hxx" 39 #include "unoobjw.hxx" 40 #include "oleobjw.hxx" 41 #include <rtl/unload.h> 42 43 #include <tools/presys.h> 44 #define _WIN32_WINNT 0x0400 45 46 #if defined(_MSC_VER) && (_MSC_VER >= 1300) 47 #undef _DEBUG 48 #endif 49 #include <atlbase.h> 50 extern CComModule _Module; 51 #include <atlcom.h> 52 #include <tools/postsys.h> 53 54 55 using namespace std; 56 using namespace cppu; 57 using namespace rtl; 58 using namespace osl; 59 using namespace com::sun::star::lang; 60 using namespace com::sun::star::uno; 61 using namespace com::sun::star::bridge; 62 using namespace com::sun::star::bridge::ModelDependent; 63 64 65 66 namespace ole_adapter 67 { 68 69 #include <initguid.h> 70 // prior 5.2 ( src569 ver m) 71 // {3ECF78F0-B149-11D2-8EBE-00105AD848AF} 72 //DEFINE_GUID(OID_ServiceManager, 0x3ECF78F0, 0xB149, 0x11d2, 0x8E, 0xBE, 0x00, 0x10, 0x5A, 0xD8, 0x48, 0xAF); 73 74 #ifndef OWNGUID 75 // GUID used since 5.2 ( src569 m) 76 // {82154420-0FBF-11d4-8313-005004526AB4} 77 DEFINE_GUID(OID_ServiceManager, 0x82154420, 0xfbf, 0x11d4, 0x83, 0x13, 0x0, 0x50, 0x4, 0x52, 0x6a, 0xb4); 78 #else 79 // Alternative GUID 80 // {D9BB9D1D-BFA9-4357-9F11-9A2E9061F06E} 81 DEFINE_GUID(OID_ServiceManager, 0xd9bb9d1d, 0xbfa9, 0x4357, 0x9f, 0x11, 0x9a, 0x2e, 0x90, 0x61, 0xf0, 0x6e); 82 #endif 83 84 extern rtl_StandardModuleCount globalModuleCount; 85 86 /***************************************************************************** 87 88 class implementation ProviderOleWrapper_Impl 89 90 *****************************************************************************/ 91 92 ProviderOleWrapper_Impl::ProviderOleWrapper_Impl(const Reference<XMultiServiceFactory>& smgr, 93 const Reference<XSingleServiceFactory>& xSFact, GUID* pGuid) 94 : m_xSingleServiceFactory(xSFact), 95 m_smgr( smgr) 96 { 97 m_guid = *pGuid; 98 99 Reference<XInterface> xInt = smgr->createInstance(reinterpret_cast<const sal_Unicode*>(L"com.sun.star.bridge.oleautomation.BridgeSupplier")); 100 101 if (xInt.is()) 102 { 103 Any a= xInt->queryInterface( ::getCppuType( reinterpret_cast< 104 Reference< XBridgeSupplier2>* >(0))); 105 a >>= m_bridgeSupplier; 106 107 } 108 } 109 110 ProviderOleWrapper_Impl::~ProviderOleWrapper_Impl() 111 { 112 } 113 114 sal_Bool ProviderOleWrapper_Impl::registerClass() 115 { 116 HRESULT hresult; 117 118 o2u_attachCurrentThread(); 119 120 hresult = CoRegisterClassObject( 121 m_guid, 122 this, 123 CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER, 124 REGCLS_MULTIPLEUSE, 125 &m_factoryHandle); 126 127 return (hresult == NOERROR); 128 } 129 130 sal_Bool ProviderOleWrapper_Impl::deregisterClass() 131 { 132 HRESULT hresult = CoRevokeClassObject(m_factoryHandle); 133 134 return (hresult == NOERROR); 135 } 136 137 STDMETHODIMP ProviderOleWrapper_Impl::QueryInterface(REFIID riid, void FAR* FAR* ppv) 138 { 139 if(IsEqualIID(riid, IID_IUnknown)) 140 { 141 AddRef(); 142 *ppv = (IUnknown*) (IClassFactory*) this; 143 return NOERROR; 144 } 145 else if (IsEqualIID(riid, IID_IClassFactory)) 146 { 147 AddRef(); 148 *ppv = (IClassFactory*) this; 149 return NOERROR; 150 } 151 152 *ppv = NULL; 153 return ResultFromScode(E_NOINTERFACE); 154 } 155 156 STDMETHODIMP_(ULONG) ProviderOleWrapper_Impl::AddRef() 157 { 158 return osl_incrementInterlockedCount( &m_refCount); 159 } 160 161 STDMETHODIMP_(ULONG) ProviderOleWrapper_Impl::Release() 162 { 163 MutexGuard aGuard( Mutex::getGlobalMutex()); 164 ULONG refCount = --m_refCount; 165 if (m_refCount == 0) 166 { 167 delete this; 168 } 169 170 return refCount; 171 } 172 173 STDMETHODIMP ProviderOleWrapper_Impl::CreateInstance(IUnknown FAR* punkOuter, 174 REFIID riid, 175 void FAR* FAR* ppv) 176 { 177 HRESULT ret = ResultFromScode(E_UNEXPECTED); 178 punkOuter = NULL; 179 180 Reference<XInterface> xInstance; 181 182 if (m_xSingleServiceFactory.is()) 183 { 184 xInstance = m_xSingleServiceFactory->createInstance(); 185 186 if (xInstance.is()) 187 { 188 Any usrAny(&xInstance, getCppuType( & xInstance)); 189 190 sal_uInt8 arId[16]; 191 rtl_getGlobalProcessId( arId ); 192 Any oleAny = m_bridgeSupplier->createBridge(usrAny, 193 Sequence<sal_Int8>((sal_Int8*)arId, 16), 194 UNO, 195 OLE); 196 197 198 if (oleAny.getValueTypeClass() == getCppuType( (sal_uInt32 *)0).getTypeClass()) 199 { 200 VARIANT* pVariant = *(VARIANT**)oleAny.getValue(); 201 202 if (pVariant->vt == VT_DISPATCH) 203 { 204 ret = pVariant->pdispVal->QueryInterface(riid, ppv); 205 } 206 207 VariantClear(pVariant); 208 CoTaskMemFree(pVariant); 209 } 210 } 211 } 212 213 return ret; 214 } 215 216 STDMETHODIMP ProviderOleWrapper_Impl::LockServer(int /*fLock*/) 217 { 218 return NOERROR; 219 } 220 221 /***************************************************************************** 222 223 class implementation OneInstanceOleWrapper_Impl 224 225 *****************************************************************************/ 226 227 OneInstanceOleWrapper_Impl::OneInstanceOleWrapper_Impl( const Reference<XMultiServiceFactory>& smgr, 228 const Reference<XInterface>& xInst, 229 GUID* pGuid, 230 sal_Bool bAsApplication ) 231 : m_xInst(xInst), m_refCount(0), 232 m_smgr( smgr), 233 m_factoryHandle( 0 ), 234 m_bAsApplication( bAsApplication ), 235 m_nApplRegHandle( 0 ) 236 { 237 m_guid = *pGuid; 238 239 Reference<XInterface> xInt = m_smgr->createInstance(reinterpret_cast<const sal_Unicode*>(L"com.sun.star.bridge.oleautomation.BridgeSupplier")); 240 241 if (xInt.is()) 242 { 243 Any a= xInt->queryInterface( getCppuType( 244 reinterpret_cast< Reference<XBridgeSupplier2>*>(0))); 245 a >>= m_bridgeSupplier; 246 } 247 } 248 249 OneInstanceOleWrapper_Impl::~OneInstanceOleWrapper_Impl() 250 { 251 } 252 253 sal_Bool OneInstanceOleWrapper_Impl::registerClass() 254 { 255 HRESULT hresult; 256 257 o2u_attachCurrentThread(); 258 259 hresult = CoRegisterClassObject( 260 m_guid, 261 this, 262 CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER, 263 REGCLS_MULTIPLEUSE, 264 &m_factoryHandle); 265 266 if ( hresult == NOERROR && m_bAsApplication ) 267 hresult = RegisterActiveObject( this, m_guid, ACTIVEOBJECT_WEAK, &m_nApplRegHandle ); 268 269 return (hresult == NOERROR); 270 } 271 272 sal_Bool OneInstanceOleWrapper_Impl::deregisterClass() 273 { 274 HRESULT hresult1 = NOERROR; 275 if ( m_bAsApplication ) 276 hresult1 = RevokeActiveObject( m_nApplRegHandle, NULL ); 277 278 HRESULT hresult2 = CoRevokeClassObject(m_factoryHandle); 279 280 return (hresult1 == NOERROR && hresult2 == NOERROR); 281 } 282 283 STDMETHODIMP OneInstanceOleWrapper_Impl::QueryInterface(REFIID riid, void FAR* FAR* ppv) 284 { 285 if(IsEqualIID(riid, IID_IUnknown)) 286 { 287 AddRef(); 288 *ppv = (IUnknown*) (IClassFactory*) this; 289 return NOERROR; 290 } 291 else if (IsEqualIID(riid, IID_IClassFactory)) 292 { 293 AddRef(); 294 *ppv = (IClassFactory*) this; 295 return NOERROR; 296 } 297 298 *ppv = NULL; 299 return ResultFromScode(E_NOINTERFACE); 300 } 301 302 STDMETHODIMP_(ULONG) OneInstanceOleWrapper_Impl::AddRef() 303 { 304 return osl_incrementInterlockedCount( &m_refCount); 305 } 306 307 STDMETHODIMP_(ULONG) OneInstanceOleWrapper_Impl::Release() 308 { 309 MutexGuard oGuard( Mutex::getGlobalMutex()); 310 ULONG refCount = --m_refCount; 311 if ( m_refCount == 0) 312 { 313 delete this; 314 } 315 316 return refCount; 317 } 318 319 STDMETHODIMP OneInstanceOleWrapper_Impl::CreateInstance(IUnknown FAR* punkOuter, 320 REFIID riid, 321 void FAR* FAR* ppv) 322 { 323 HRESULT ret = ResultFromScode(E_UNEXPECTED); 324 punkOuter = NULL; 325 326 if (m_xInst.is()) 327 { 328 Any usrAny(&m_xInst, getCppuType( &m_xInst)); 329 sal_uInt8 arId[16]; 330 rtl_getGlobalProcessId( arId); 331 Any oleAny = m_bridgeSupplier->createBridge(usrAny, 332 Sequence<sal_Int8>( (sal_Int8*)arId, 16), 333 UNO, 334 OLE); 335 336 337 if (oleAny.getValueTypeClass() == TypeClass_UNSIGNED_LONG) 338 { 339 VARIANT* pVariant = *(VARIANT**)oleAny.getValue(); 340 341 if ((pVariant->vt == VT_UNKNOWN) || (pVariant->vt == VT_DISPATCH)) 342 { 343 ret = pVariant->punkVal->QueryInterface(riid, ppv); 344 } 345 346 VariantClear(pVariant); 347 CoTaskMemFree(pVariant); 348 } 349 } 350 351 return ret; 352 } 353 354 STDMETHODIMP OneInstanceOleWrapper_Impl::LockServer(int /*fLock*/) 355 { 356 return NOERROR; 357 } 358 359 360 /***************************************************************************** 361 362 class implementation OleConverter_Impl2 363 364 *****************************************************************************/ 365 366 OleConverter_Impl2::OleConverter_Impl2( const Reference<XMultiServiceFactory> &smgr): 367 UnoConversionUtilities<OleConverter_Impl2>( smgr) 368 369 { 370 // library unloading support 371 globalModuleCount.modCnt.acquire( &globalModuleCount.modCnt); 372 } 373 374 // The XMultiServiceFactory is later set by XInitialization 375 OleConverter_Impl2::OleConverter_Impl2( const Reference<XMultiServiceFactory>& smgr, sal_uInt8 unoWrapperClass, sal_uInt8 comWrapperClass ): 376 UnoConversionUtilities<OleConverter_Impl2>( smgr, unoWrapperClass, comWrapperClass ) 377 378 { 379 //library unloading support 380 globalModuleCount.modCnt.acquire( &globalModuleCount.modCnt); 381 } 382 383 OleConverter_Impl2::~OleConverter_Impl2() 384 { 385 globalModuleCount.modCnt.release( &globalModuleCount.modCnt); 386 } 387 388 // XBridgeSupplier -------------------------------------------------------------- 389 Any SAL_CALL OleConverter_Impl2::createBridge(const Any& modelDepObject, 390 const Sequence< sal_Int8 >& ProcessId, 391 sal_Int16 sourceModelType, 392 sal_Int16 destModelType) 393 throw (IllegalArgumentException, 394 RuntimeException ) 395 { 396 Any ret; 397 sal_uInt8 arId[16]; 398 rtl_getGlobalProcessId( arId ); 399 400 Sequence< sal_Int8 > seqProcessId( (sal_Int8*)arId, 16); 401 402 if ( seqProcessId == ProcessId) 403 { 404 if (sourceModelType == UNO) 405 { 406 if (destModelType == UNO) 407 { 408 // same model -> copy value only 409 ret = modelDepObject; 410 } 411 else if (destModelType == OLE) 412 { 413 // convert UNO any into variant 414 VARIANT* pVariant = (VARIANT*) CoTaskMemAlloc(sizeof(VARIANT)); 415 VariantInit( pVariant); 416 try 417 { 418 anyToVariant( pVariant, modelDepObject); 419 } 420 catch(...) 421 { 422 CoTaskMemFree(pVariant); 423 throw IllegalArgumentException(); 424 } 425 ret.setValue((void*) &pVariant, getCppuType((sal_uInt32*)0)); 426 } 427 else 428 throw IllegalArgumentException(); 429 } 430 else if (sourceModelType == OLE) 431 { 432 if (modelDepObject.getValueType() != getCppuType((sal_uInt32*)0)) 433 { 434 throw IllegalArgumentException(); 435 } 436 else if (destModelType == OLE) 437 { 438 // same model -> copy value only 439 VARIANT* pVariant = (VARIANT*) CoTaskMemAlloc(sizeof(VARIANT)); 440 441 if (NOERROR != VariantCopy(pVariant, *(VARIANT**)modelDepObject.getValue())) 442 { 443 CoTaskMemFree(pVariant); 444 throw(IllegalArgumentException()); 445 } 446 else 447 { 448 ret.setValue((void*) &pVariant, getCppuType((sal_uInt32*)0)); 449 } 450 } 451 else if (destModelType == UNO) 452 { 453 // convert variant into UNO any 454 VARIANT* pVariant = *(VARIANT**)modelDepObject.getValue(); 455 try 456 { 457 variantToAny(pVariant, ret); 458 } 459 catch (CannotConvertException & e) 460 { 461 throw IllegalArgumentException( 462 e.Message, 0, -1); 463 } 464 } 465 else 466 throw IllegalArgumentException(); 467 468 } 469 else 470 throw IllegalArgumentException(); 471 } 472 473 return ret; 474 } 475 476 477 // XInitialize ------------------------------------------------------------------------------ 478 // the first argument is an XMultiServiceFactory if at all 479 void SAL_CALL OleConverter_Impl2::initialize( const Sequence< Any >& aArguments ) 480 throw(Exception, RuntimeException) 481 { 482 if( aArguments.getLength() == 1 && aArguments[0].getValueTypeClass() == TypeClass_INTERFACE) 483 { 484 Reference < XInterface > xInt; 485 aArguments[0] >>= xInt; 486 Reference <XMultiServiceFactory> xMulti( xInt, UNO_QUERY); 487 m_smgrRemote= xMulti; 488 } 489 } 490 491 // UnoConversionUtilities ------------------------------------------------------------------- 492 Reference< XInterface > OleConverter_Impl2::createUnoWrapperInstance() 493 { 494 if( m_nUnoWrapperClass == INTERFACE_OLE_WRAPPER_IMPL) 495 { 496 Reference<XWeak> xWeak= static_cast<XWeak*>( new InterfaceOleWrapper_Impl( 497 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass)); 498 return Reference<XInterface>( xWeak, UNO_QUERY); 499 } 500 else if( m_nUnoWrapperClass == UNO_OBJECT_WRAPPER_REMOTE_OPT) 501 { 502 Reference<XWeak> xWeak= static_cast<XWeak*>( new UnoObjectWrapperRemoteOpt( 503 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass)); 504 return Reference<XInterface>( xWeak, UNO_QUERY); 505 } 506 else 507 return Reference<XInterface>(); 508 } 509 510 Reference< XInterface > OleConverter_Impl2::createComWrapperInstance() 511 { 512 Reference<XWeak> xWeak= static_cast<XWeak*>( new IUnknownWrapper_Impl( 513 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass)); 514 return Reference<XInterface>( xWeak, UNO_QUERY); 515 } 516 517 518 519 /***************************************************************************** 520 521 class implementation OleClient_Impl 522 523 *****************************************************************************/ 524 525 OleClient_Impl::OleClient_Impl( const Reference<XMultiServiceFactory>& smgr): 526 UnoConversionUtilities<OleClient_Impl>( smgr) 527 { 528 // library unloading support 529 globalModuleCount.modCnt.acquire( &globalModuleCount.modCnt); 530 Reference<XInterface> xInt;// = m_smgr->createInstance(L"com.sun.star.bridge.OleBridgeSupplier2"); 531 532 if (xInt.is()) 533 { 534 Any a= xInt->queryInterface(getCppuType( 535 reinterpret_cast<Reference<XBridgeSupplier2>*>(0))); 536 a >>= m_bridgeSupplier; 537 } 538 } 539 540 OleClient_Impl::~OleClient_Impl() 541 { 542 // library unloading support 543 globalModuleCount.modCnt.release( &globalModuleCount.modCnt); 544 } 545 546 Sequence< OUString > SAL_CALL OleClient_Impl::getAvailableServiceNames() throw( RuntimeException ) 547 { 548 Sequence< OUString > ret; 549 550 return ret; 551 } 552 553 554 OUString OleClient_Impl::getImplementationName() 555 { 556 return OUString(reinterpret_cast<const sal_Unicode*>(L"com.sun.star.comp.ole.OleClient")); 557 } 558 559 Reference<XInterface> SAL_CALL OleClient_Impl::createInstance(const OUString& ServiceSpecifier) throw (Exception, RuntimeException ) 560 { 561 Reference<XInterface> ret; 562 HRESULT result; 563 IUnknown* pUnknown = NULL; 564 CLSID classId; 565 566 o2u_attachCurrentThread(); 567 568 result = CLSIDFromProgID( 569 reinterpret_cast<LPCWSTR>(ServiceSpecifier.getStr()), //Pointer to the ProgID 570 &classId); //Pointer to the CLSID 571 572 573 if (result == NOERROR) 574 { 575 result = CoCreateInstance( 576 classId, //Class identifier (CLSID) of the object 577 NULL, //Pointer to whether object is or isn't part of an aggregate 578 CLSCTX_SERVER, //Context for running executable code 579 IID_IUnknown, //Reference to the identifier of the interface 580 (void**)&pUnknown); //Address of output variable that receives 581 // the interface pointer requested in riid 582 } 583 584 if (pUnknown != NULL) 585 { 586 Any any; 587 CComVariant variant; 588 589 V_VT(&variant) = VT_UNKNOWN; 590 V_UNKNOWN(&variant) = pUnknown; 591 // AddRef for Variant 592 pUnknown->AddRef(); 593 594 // When the object is wrapped, then its refcount is increased 595 variantToAny(&variant, any); 596 if (any.getValueTypeClass() == TypeClass_INTERFACE) 597 { 598 any >>= ret; 599 } 600 pUnknown->Release(); // CoCreateInstance 601 } 602 603 return ret; 604 } 605 606 Reference<XInterface> SAL_CALL OleClient_Impl::createInstanceWithArguments(const OUString& ServiceSpecifier, const Sequence< Any >& /*Arguments*/) throw (Exception, RuntimeException) 607 { 608 return createInstance( ServiceSpecifier); 609 } 610 611 // UnoConversionUtilities ----------------------------------------------------------------------------- 612 Reference< XInterface > OleClient_Impl::createUnoWrapperInstance() 613 { 614 if( m_nUnoWrapperClass == INTERFACE_OLE_WRAPPER_IMPL) 615 { 616 Reference<XWeak> xWeak= static_cast<XWeak*>( new InterfaceOleWrapper_Impl( 617 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass)); 618 return Reference<XInterface>( xWeak, UNO_QUERY); 619 } 620 else if( m_nUnoWrapperClass == UNO_OBJECT_WRAPPER_REMOTE_OPT) 621 { 622 Reference<XWeak> xWeak= static_cast<XWeak*>( new UnoObjectWrapperRemoteOpt( 623 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass)); 624 return Reference<XInterface>( xWeak, UNO_QUERY); 625 } 626 else 627 return Reference< XInterface>(); 628 } 629 // UnoConversionUtilities ----------------------------------------------------------------------------- 630 Reference< XInterface > OleClient_Impl::createComWrapperInstance( ) 631 { 632 Reference<XWeak> xWeak= static_cast<XWeak*>( new IUnknownWrapper_Impl( 633 m_smgr, m_nUnoWrapperClass, m_nComWrapperClass)); 634 return Reference<XInterface>( xWeak, UNO_QUERY); 635 } 636 637 638 639 /***************************************************************************** 640 641 class implementation OleServer_Impl 642 643 *****************************************************************************/ 644 645 OleServer_Impl::OleServer_Impl( const Reference<XMultiServiceFactory>& smgr): 646 m_smgr( smgr) 647 { 648 //library unloading support 649 globalModuleCount.modCnt.acquire( &globalModuleCount.modCnt); 650 Reference<XInterface> xInt = m_smgr->createInstance(reinterpret_cast<const sal_Unicode*>(L"com.sun.star.bridge.oleautomation.BridgeSupplier")); 651 652 if (xInt.is()) 653 { 654 Any a= xInt->queryInterface( getCppuType( 655 reinterpret_cast< Reference<XBridgeSupplier2>*>(0))); 656 a >>= m_bridgeSupplier; 657 } 658 659 #ifndef OWNGUID 660 sal_Bool bOLERegister = sal_False; 661 #else 662 sal_Bool bOLERegister = sal_True; 663 #endif 664 sal_Bool ret = provideInstance( m_smgr, (GUID*)&OID_ServiceManager, bOLERegister ); 665 (void)ret; 666 } 667 668 OleServer_Impl::~OleServer_Impl() 669 { 670 while (!m_wrapperList.empty()) 671 { 672 (*m_wrapperList.begin())->deregisterClass(); 673 (*m_wrapperList.begin())->Release(); 674 m_wrapperList.pop_front(); 675 } 676 //library unloading support 677 globalModuleCount.modCnt.release( &globalModuleCount.modCnt); 678 } 679 // XInterface -------------------------------------------------- 680 Any SAL_CALL OleServer_Impl::queryInterface( const Type& aType ) throw(RuntimeException) 681 { 682 Any a= ::cppu::queryInterface( aType, static_cast<XTypeProvider*>(this)); 683 if( a == Any()) 684 return OWeakObject::queryInterface( aType); 685 else 686 return a; 687 } 688 void SAL_CALL OleServer_Impl::acquire( ) throw() 689 { 690 OWeakObject::acquire(); 691 } 692 void SAL_CALL OleServer_Impl::release( ) throw () 693 { 694 OWeakObject::release(); 695 } 696 697 698 // XTypeProvider -------------------------------------------------- 699 Sequence< Type > SAL_CALL OleServer_Impl::getTypes( ) throw(RuntimeException) 700 { 701 static OTypeCollection *pCollection = 0; 702 if( ! pCollection ) 703 { 704 MutexGuard guard( Mutex::getGlobalMutex() ); 705 if( ! pCollection ) 706 { 707 static OTypeCollection collection( 708 getCppuType(reinterpret_cast< Reference< XWeak>*>(0)), 709 getCppuType(reinterpret_cast< Reference< XTypeProvider>*>(0)) ); 710 pCollection = &collection; 711 } 712 } 713 return (*pCollection).getTypes(); 714 } 715 Sequence< sal_Int8 > SAL_CALL OleServer_Impl::getImplementationId() throw(RuntimeException) 716 { 717 static OImplementationId *pId = 0; 718 if( ! pId ) 719 { 720 MutexGuard guard( Mutex::getGlobalMutex() ); 721 if( ! pId ) 722 { 723 static OImplementationId id( sal_False ); 724 pId = &id; 725 } 726 } 727 return (*pId).getImplementationId(); 728 } 729 730 731 sal_Bool OleServer_Impl::provideService(const Reference<XSingleServiceFactory>& xSFact, GUID* guid) 732 { 733 IClassFactoryWrapper* pFac = new ProviderOleWrapper_Impl( m_smgr, xSFact, guid); 734 735 pFac->AddRef(); 736 737 m_wrapperList.push_back(pFac); 738 739 return pFac->registerClass(); 740 } 741 742 sal_Bool OleServer_Impl::provideInstance(const Reference<XInterface>& xInst, GUID* guid, sal_Bool bAsApplication ) 743 { 744 IClassFactoryWrapper* pFac = new OneInstanceOleWrapper_Impl( m_smgr, xInst, guid, bAsApplication ); 745 746 pFac->AddRef(); 747 m_wrapperList.push_back(pFac); 748 749 return pFac->registerClass(); 750 } 751 752 753 754 } // end namespace 755