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