xref: /aoo4110/main/extensions/test/ole/cpnt/cpnt.cxx (revision b1cdbd2c)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_extensions.hxx"
26 #include <windows.h>
27 #include <atlbase.h>
28 #include <stdio.h>
29 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
30 #include <com/sun/star/registry/XRegistryKey.hpp>
31 #include <osl/diagnose.h>
32 #include <uno/environment.h>
33 #include <cppuhelper/factory.hxx>
34 // OPTIONAL is a constant in com.sun.star.beans.PropertyAttributes but it must be
35 // undef'd in some header files
36 #define OPTIONAL OPTIONAL
37 #include <com/sun/star/beans/PropertyAttribute.hpp>
38 #include <com/sun/star/script/XInvocation.hpp>
39 #include <com/sun/star/reflection/XIdlReflection.hpp>
40 #include <com/sun/star/lang/XEventListener.hpp>
41 
42 #include <cppuhelper/implbase7.hxx>
43 #include <cppuhelper/implbase1.hxx>
44 #include <com/sun/star/uno/Reference.h>
45 #include <rtl/ustring.h>
46 #include <com/sun/star/uno/Reference.hxx>
47 #include <oletest/XTestSequence.hpp>
48 #include <oletest/XTestStruct.hpp>
49 #include <oletest/XTestOther.hpp>
50 #include <oletest/XTestInterfaces.hpp>
51 #include <oletest/XSimple.hpp>
52 #include <oletest/XSimple2.hpp>
53 #include <oletest/XSimple3.hpp>
54 #include <oletest/XTestInParameters.hpp>
55 //#include <oletest/XTestOutParameters.hpp>
56 #include <oletest/XIdentity.hpp>
57 #include <com/sun/star/beans/Property.hpp>
58 using namespace cppu;
59 using namespace osl;
60 using namespace oletest;
61 using namespace rtl;
62 using namespace com::sun::star::uno;
63 using namespace com::sun::star::lang;
64 using namespace com::sun::star::beans;
65 using namespace com::sun::star::registry;
66 using namespace com::sun::star::script;
67 using namespace com::sun::star::reflection;
68 
69 
70 #define IMPL_NAME L"oletest.OleTestImpl"  // oletest.OleTestImpl in applicat.rdb
71 #define SERVICE_NAME L"oletest.OleTest"
72 #define KEY1 L"/oletest.OleTestImpl/UNO/SERVICES"
73 #define KEY2 L"oletest.OleTest"
74 
75 class OComponent : public WeakImplHelper7<
76          XTestSequence, XTestStruct, XTestOther, XTestInterfaces,
77 				   XSimple, XTestInParameters, XIdentity >
78 {
79     Reference<XInterface> m_xIntIdentity;
80 	sal_Int32 m_arrayConstructor;
81 	Reference<XMultiServiceFactory> m_rFactory;
82 
83 	Sequence<sal_Int8> m_seqByte;
84 	Sequence<float> m_seqFloat;
85 	Sequence<double> m_seqDouble;
86 	Sequence<sal_Bool> m_seqBool;
87 	Sequence<sal_Int16> m_seqShort;
88 	Sequence<sal_uInt16> m_seqUShort;
89 	Sequence<sal_Int32> m_seqLong;
90 	Sequence<sal_uInt32> m_seqULong;
91 	Sequence<sal_Unicode> m_seqChar;
92 	Sequence<OUString> m_seqString;
93 	Sequence<Any> m_seqAny;
94     Sequence<Type> m_seqType;
95 	Sequence<Sequence< sal_Int32> > m_seq1;
96 	Sequence<Sequence< Sequence< sal_Int32> > > m_seq2;
97 	Any m_any;
98     Type m_type;
99 	Sequence<Reference< XInterface > > m_seqxInterface;
100 
101     sal_Int8 m_int8;
102     sal_uInt8 m_uint8;
103     sal_Int16 m_int16;
104     sal_uInt16 m_uint16;
105     sal_Int32 m_int32;
106     sal_uInt32 m_uint32;
107     sal_Int64 m_int64;
108     sal_uInt64 m_uint64;
109     float m_float;
110     double m_double;
111     OUString m_string;
112     sal_Unicode m_char;
113     sal_Bool m_bool;
114     Reference<XInterface> m_xinterface;
115 
116     sal_Int8 m_attr_int8;
117     sal_uInt8 m_attr_uint8;
118     sal_Int16 m_attr_int16;
119     sal_uInt16 m_attr_uint16;
120     sal_Int32 m_attr_int32;
121     sal_uInt32 m_attr_uint32;
122     sal_Int64 m_attr_int64;
123     sal_uInt64 m_attr_uint64;
124     float m_attr_float;
125     double m_attr_double;
126     OUString m_attr_string;
127     sal_Unicode m_attr_char;
128     sal_Bool m_attr_bool;
129     Any m_attr_any;
130     Type m_attr_type;
131     Reference<XInterface> m_attr_xinterface;
132     Reference<XInvocation> m_attr_xinvocation;
133 
134 public:
OComponent(const Reference<XMultiServiceFactory> & rFactory)135 	OComponent( const Reference<XMultiServiceFactory> & rFactory ) :
136 	  m_rFactory( rFactory ), m_arrayConstructor(0) {}
137 	~OComponent();
138 public: // XTestSequence
139 	virtual Sequence<sal_Int8> SAL_CALL methodByte(const Sequence< sal_Int8 >& aSeq) throw( RuntimeException );
140 	virtual Sequence<float> SAL_CALL methodFloat(const Sequence< float >& aSeq) throw( RuntimeException );
141 	virtual Sequence< double > SAL_CALL methodDouble(const Sequence< double >& aSeq) throw( RuntimeException);
142 	virtual Sequence< sal_Bool > SAL_CALL methodBool(const Sequence< sal_Bool >& aSeq) throw( RuntimeException );
143 	virtual Sequence< sal_Int16 > SAL_CALL methodShort(const Sequence< sal_Int16 >& aSeq) throw( RuntimeException );
144 	virtual Sequence< sal_uInt16 > SAL_CALL methodUShort(const Sequence< sal_uInt16 >& aSeq) throw( RuntimeException );
145 	virtual Sequence< sal_Int32 > SAL_CALL methodLong(const Sequence< sal_Int32 >& aSeq) throw( RuntimeException) ;
146 	virtual Sequence< sal_uInt32 > SAL_CALL methodULong(const Sequence< sal_uInt32 >& aSeq) throw( RuntimeException );
147 	virtual Sequence< OUString > SAL_CALL methodString(const Sequence< OUString >& aSeq) throw( RuntimeException );
148 	virtual Sequence< sal_Unicode > SAL_CALL methodChar(const Sequence< sal_Unicode >& aSeq) throw( RuntimeException );
149 	virtual Sequence< Any > SAL_CALL methodAny(const Sequence< Any >& aSeq) throw( RuntimeException );
150     virtual Sequence< Type > SAL_CALL methodType(const Sequence< Type >& aSeq) throw( RuntimeException );
151     virtual Sequence< Reference< XInterface > > SAL_CALL methodXInterface( const Sequence< Reference< XInterface > >& aSeq ) throw(RuntimeException) ;
152 	virtual Sequence< Sequence< sal_Int32 > > SAL_CALL methodSequence(const Sequence< Sequence< sal_Int32 > >& aSeq) throw( RuntimeException );
153 	virtual Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL methodSequence2(const Sequence< Sequence< Sequence< sal_Int32 > > >& aSeq) throw( RuntimeException );
154     virtual Sequence< Reference<XEventListener> > SAL_CALL methodXEventListeners( const Sequence<Reference<XEventListener> >& aSeq) throw( RuntimeException);
155     virtual Sequence< Sequence<Reference<XEventListener > > > SAL_CALL methodXEventListenersMul( const Sequence<Sequence<Reference<XEventListener > > >& aSeq ) throw (RuntimeException);
156 
157     virtual Sequence< sal_Int8 > SAL_CALL getAttrByte(void) throw( RuntimeException );
158     virtual void SAL_CALL setAttrByte(const Sequence< sal_Int8 >& AttrByte_) throw( RuntimeException );
159     virtual Sequence< float > SAL_CALL getAttrFloat(void)  throw( RuntimeException) ;
160     virtual void SAL_CALL setAttrFloat(const Sequence< float >& AttrFloat_) throw( RuntimeException );
161     virtual Sequence< double > SAL_CALL getAttrDouble(void)  throw( RuntimeException) ;
162     virtual void SAL_CALL setAttrDouble(const Sequence< double >& AttrDouble_) throw( RuntimeException );
163     virtual Sequence< sal_Bool > SAL_CALL getAttrBool(void)  throw( RuntimeException );
164     virtual void SAL_CALL setAttrBool(const Sequence< sal_Bool >& AttrBool_) throw( RuntimeException );
165 	virtual Sequence< sal_Int16 > SAL_CALL getAttrShort(void)  throw( RuntimeException );
166     virtual void SAL_CALL setAttrShort(const Sequence< sal_Int16 >& AttrShort_) throw( RuntimeException );
167     virtual Sequence< sal_uInt16 > SAL_CALL getAttrUShort(void)  throw( RuntimeException );
168     virtual void SAL_CALL setAttrUShort(const Sequence< sal_uInt16 >& AttrUShort_) throw( RuntimeException );
169     virtual Sequence< sal_Int32 > SAL_CALL getAttrLong(void)  throw( RuntimeException );
170     virtual void SAL_CALL setAttrLong(const Sequence< sal_Int32 >& AttrLong_) throw( RuntimeException );
171     virtual Sequence< sal_uInt32 > SAL_CALL getAttrULong(void)  throw( RuntimeException );
172     virtual void SAL_CALL setAttrULong(const Sequence< sal_uInt32 >& AttrULong_) throw( RuntimeException );
173     virtual Sequence< OUString > SAL_CALL getAttrString(void)  throw(RuntimeException );
174     virtual void SAL_CALL setAttrString(const Sequence< OUString >& AttrString_) throw( RuntimeException );
175     virtual Sequence< sal_Unicode > SAL_CALL getAttrChar(void)  throw( RuntimeException );
176     virtual void SAL_CALL setAttrChar(const Sequence< sal_Unicode >& AttrChar_) throw( RuntimeException );
177 	virtual Sequence< Any > SAL_CALL getAttrAny(void)  throw( RuntimeException );
178     virtual void SAL_CALL setAttrAny(const Sequence< Any >& AttrAny_) throw( RuntimeException );
179 	virtual Sequence< Type > SAL_CALL getAttrType(void)  throw( RuntimeException );
180     virtual void SAL_CALL setAttrType( const Sequence< Type >& _attrtype ) throw (RuntimeException);
181     virtual Sequence< Sequence< sal_Int32 > > SAL_CALL getAttrSequence(void) throw( RuntimeException );
182     virtual void SAL_CALL  setAttrSequence(const Sequence< Sequence< sal_Int32 > >& AttrSequence_) throw( RuntimeException );
183 	virtual Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL getAttrSequence2(void)  throw( RuntimeException );
184     virtual void SAL_CALL setAttrSequence2(const Sequence< Sequence< Sequence< sal_Int32 > > >& AttrSequence2_) throw ( RuntimeException );
185     virtual Sequence< Reference< XInterface > > SAL_CALL getAttrXInterface() throw(RuntimeException);
186 	virtual void SAL_CALL setAttrXInterface( const Sequence< Reference< XInterface > >& _attrxinterface ) throw(RuntimeException);
187 
188     virtual ::sal_Int8 SAL_CALL getAByte() throw (RuntimeException);
189     virtual void SAL_CALL setAByte( ::sal_Int8 _abyte ) throw (RuntimeException);
190     virtual float SAL_CALL getAFloat() throw (RuntimeException);
191     virtual void SAL_CALL setAFloat( float _afloat ) throw (RuntimeException);
192     virtual double SAL_CALL getADouble() throw (RuntimeException);
193     virtual void SAL_CALL setADouble( double _adouble ) throw (RuntimeException);
194     virtual ::sal_Bool SAL_CALL getABool() throw (RuntimeException);
195     virtual void SAL_CALL setABool( ::sal_Bool _abool ) throw (RuntimeException);
196     virtual ::sal_Int16 SAL_CALL getAShort() throw (RuntimeException);
197     virtual void SAL_CALL setAShort( ::sal_Int16 _ashort ) throw (RuntimeException);
198     virtual ::sal_uInt16 SAL_CALL getAUShort() throw (RuntimeException);
199     virtual void SAL_CALL setAUShort( ::sal_uInt16 _aushort ) throw (RuntimeException);
200     virtual ::sal_Int32 SAL_CALL getALong() throw (RuntimeException);
201     virtual void SAL_CALL setALong( ::sal_Int32 _along ) throw (RuntimeException);
202     virtual ::sal_uInt32 SAL_CALL getAULong() throw (RuntimeException);
203     virtual void SAL_CALL setAULong( ::sal_uInt32 _aulong ) throw (RuntimeException);
204     virtual ::rtl::OUString SAL_CALL getAString() throw (RuntimeException);
205     virtual void SAL_CALL setAString( const ::rtl::OUString& _astring ) throw (RuntimeException);
206     virtual ::sal_Unicode SAL_CALL getAChar() throw (RuntimeException);
207     virtual void SAL_CALL setAChar( ::sal_Unicode _achar ) throw (RuntimeException);
208     virtual Any SAL_CALL getAAny() throw (RuntimeException);
209     virtual void SAL_CALL setAAny( const Any& _aany ) throw (RuntimeException);
210     virtual Type SAL_CALL getAType() throw (RuntimeException);
211     virtual void SAL_CALL setAType( const Type& _atype ) throw (RuntimeException);
212     virtual Reference< XInterface > SAL_CALL getAXInterface() throw (RuntimeException);
213     virtual void SAL_CALL setAXInterface( const Reference<XInterface >& _axinterface ) throw (RuntimeException);
214     virtual Reference<XInvocation > SAL_CALL getAXInvocation() throw (RuntimeException);
215     virtual void SAL_CALL setAXInvocation( const Reference< XInvocation >& _axinvocation ) throw (RuntimeException);
216 
217     virtual void SAL_CALL testout_methodByte(sal_Int8& rOut) throw( RuntimeException );
218     virtual void SAL_CALL testout_methodFloat(float& rOut) throw( RuntimeException );
219     virtual void SAL_CALL testout_methodDouble(double& rOut) throw( RuntimeException );
220     virtual void SAL_CALL testout_methodBool(sal_Bool& rOut) throw( RuntimeException );
221     virtual void SAL_CALL testout_methodShort(sal_Int16& rOut) throw( RuntimeException );
222     virtual void SAL_CALL testout_methodUShort(sal_uInt16& rOut) throw( RuntimeException );
223     virtual void SAL_CALL testout_methodLong(sal_Int32& rOut) throw( RuntimeException );
224     virtual void SAL_CALL testout_methodULong(sal_uInt32& rOut) throw( RuntimeException );
225     virtual void SAL_CALL testout_methodHyper(sal_Int64& rOut) throw( RuntimeException );
226     virtual void SAL_CALL testout_methodUHyper(sal_uInt64& rOut) throw( RuntimeException );
227     virtual void SAL_CALL testout_methodString(OUString& rOut) throw( RuntimeException );
228     virtual void SAL_CALL testout_methodChar(sal_Unicode& rOut) throw( RuntimeException );
229     virtual void SAL_CALL testout_methodAny(Any& rOut) throw( RuntimeException );
230     virtual void SAL_CALL testout_methodType(Type& rOut) throw( RuntimeException );
231     virtual void SAL_CALL testout_methodSequence(Sequence< sal_Int32 >& rOut) throw( RuntimeException );
232     virtual void SAL_CALL testout_methodSequence2(Sequence< Sequence< sal_Int32 > >& rOut) throw( RuntimeException );
233     virtual void SAL_CALL testout_methodMulParams1(sal_Int32& rout1, sal_Int32& rout2) throw( RuntimeException );
234     virtual void SAL_CALL testout_methodMulParams2(sal_Int32& rout1, sal_Int32& rout2, OUString& rout3) throw( RuntimeException );
235     virtual void SAL_CALL testout_methodMulParams3(const OUString& sin, OUString& sout) throw( RuntimeException );
236     virtual void SAL_CALL testout_methodMulParams4( float in1, float& out1, sal_Int32 in2, sal_Int32& out2, sal_Int32 in3 ) throw(RuntimeException);
237     virtual void SAL_CALL testout_methodXInterface( Reference< XInterface >& rOut ) throw(RuntimeException);
238 
239 	virtual void SAL_CALL testinout_methodByte(sal_Int8& rOut) throw( RuntimeException );
240     virtual void SAL_CALL testinout_methodFloat(float& rOut) throw( RuntimeException );
241     virtual void SAL_CALL testinout_methodDouble(double& rOut) throw( RuntimeException );
242     virtual void SAL_CALL testinout_methodBool(sal_Bool& rOut) throw( RuntimeException );
243     virtual void SAL_CALL testinout_methodShort(sal_Int16& rOut) throw( RuntimeException );
244     virtual void SAL_CALL testinout_methodUShort(sal_uInt16& rOut) throw( RuntimeException );
245     virtual void SAL_CALL testinout_methodLong(sal_Int32& rOut) throw( RuntimeException );
246     virtual void SAL_CALL testinout_methodULong(sal_uInt32& rOut) throw( RuntimeException );
247     virtual void SAL_CALL testinout_methodHyper(sal_Int64& rOut) throw( RuntimeException );
248     virtual void SAL_CALL testinout_methodUHyper(sal_uInt64& rOut) throw( RuntimeException );
249     virtual void SAL_CALL testinout_methodString(OUString& rOut) throw( RuntimeException );
250     virtual void SAL_CALL testinout_methodChar(sal_Unicode& rOut) throw( RuntimeException );
251     virtual void SAL_CALL testinout_methodAny(Any& rOut) throw( RuntimeException );
252     virtual void SAL_CALL testinout_methodType(Type& rOut) throw( RuntimeException );
253     virtual void SAL_CALL testinout_methodSequence(Sequence< sal_Int32 >& rOut) throw( RuntimeException );
254     virtual void SAL_CALL testinout_methodSequence2(Sequence< Sequence< sal_Int32 > >& rOut) throw( RuntimeException );
255     virtual void SAL_CALL testinout_methodXInterface( Reference< XInvocation >& rOut ) throw(RuntimeException);
256 	virtual void SAL_CALL testinout_methodXInterface2( Reference< XInterface > & rOut) throw( RuntimeException);
257     virtual Any SAL_CALL methodAnyTest1(const Any& rIn) throw( RuntimeException ) ;
258     virtual Any SAL_CALL getAttrAny2(void) throw( RuntimeException ) ;
259     virtual void SAL_CALL setAttrAny2(const Any& AttrAny2_) throw( RuntimeException ) ;
260 
261 
262 	// XTestStruct
263 	virtual void SAL_CALL methodStruct(const Property& aProp) throw( RuntimeException );
264 
265     virtual Property SAL_CALL retMethodStruct(void) throw( RuntimeException );
266 
267     virtual Property SAL_CALL  getAttrStruct(void) throw( RuntimeException );
268     virtual void SAL_CALL setAttrStruct(const Property& AttrStruct_) throw( RuntimeException );
269     virtual Property SAL_CALL methodStruct2( const Property& aProp ) throw (RuntimeException);
270 
271 	// XTestOther
272     virtual void SAL_CALL other_methodAnyIn(const Any& rAny) throw( RuntimeException );
273     virtual void SAL_CALL other_methodAnyOut(Any& rAny) throw( RuntimeException );
274     virtual Any SAL_CALL other_methodAnyRet(void) throw( RuntimeException );
275 	virtual void SAL_CALL in_float( float val) throw ( RuntimeException);
276     virtual Any SAL_CALL other_methodAny( const Any& rAny, const OUString& typeInAny )
277         throw (RuntimeException);
278 
279 
280 	// XTestOutParameters ------------------------------------------------------------------------
281 //     virtual void SAL_CALL out_test(sal_Int8 rIn) throw( RuntimeException );
282 
283 // 	virtual void SAL_CALL out_methodByte(sal_Int8& rOut) throw( RuntimeException );
284 // 	virtual void SAL_CALL out_methodFloat(float& rOut) throw( RuntimeException );
285 // 	virtual void SAL_CALL out_methodDouble(double& rOut) throw( RuntimeException );
286 // 	virtual void SAL_CALL out_methodBool(sal_Bool& rOut) throw( RuntimeException );
287 // 	virtual void SAL_CALL out_methodShort(sal_Int16& rOut) throw( RuntimeException );
288 // 	virtual void SAL_CALL out_methodUShort(sal_uInt16& rOut) throw( RuntimeException );
289 // 	virtual void SAL_CALL out_methodLong(sal_Int32& rOut) throw( RuntimeException );
290 // 	virtual void SAL_CALL out_methodULong(sal_uInt32& rOut) throw( RuntimeException );
291 // 	virtual void SAL_CALL out_methodHyper(sal_Int64& rOut) throw( RuntimeException );
292 // 	virtual void SAL_CALL out_methodUHyper(sal_uInt64& rOut) throw( RuntimeException );
293 //     virtual void SAL_CALL out_methodString(OUString& rOut) throw( RuntimeException );
294 // 	virtual void SAL_CALL out_methodChar(sal_Unicode& rOut) throw( RuntimeException );
295 // 	virtual void SAL_CALL out_methodAny(Any& rOut) throw( RuntimeException );
296 // 	virtual void SAL_CALL out_methodSequence(Sequence< sal_Int32 >& rOut) throw( RuntimeException );
297 // 	virtual void SAL_CALL out_methodSequence2(Sequence< Sequence< sal_Int32 > >& rOut) throw( RuntimeException );
298 //     virtual void SAL_CALL out_methodMulParams1(sal_Int32& rout1, sal_Int32& rout2) throw( RuntimeException );
299 //     virtual void SAL_CALL out_methodMulParams2(sal_Int32& rout1, sal_Int32& rout2, OUString& rout3) throw( RuntimeException );
300 //     virtual void SAL_CALL out_methodMulParams3(const OUString& sin, OUString& sout) throw( RuntimeException );
301 
302 	// XTestInParameters
303     virtual sal_Int8 SAL_CALL in_methodByte( sal_Int8 rIn ) throw (RuntimeException);
304     virtual float SAL_CALL in_methodFloat( float rIn ) throw (RuntimeException);
305     virtual double SAL_CALL in_methodDouble( double rIn ) throw (RuntimeException);
306     virtual sal_Bool SAL_CALL in_methodBool( sal_Bool rIn ) throw (RuntimeException);
307     virtual sal_Int16 SAL_CALL in_methodShort( sal_Int16 rIn ) throw (RuntimeException);
308     virtual sal_uInt16 SAL_CALL in_methodUShort( sal_uInt16 rIn ) throw (RuntimeException);
309     virtual sal_Int32 SAL_CALL in_methodLong( sal_Int32 rIn ) throw (RuntimeException);
310     virtual sal_uInt32 SAL_CALL in_methodULong( sal_uInt32 rIn ) throw (RuntimeException);
311     virtual sal_Int64 SAL_CALL in_methodHyper( sal_Int64 rIn ) throw (RuntimeException);
312     virtual sal_uInt64 SAL_CALL in_methodUHyper( sal_uInt64 rIn ) throw (RuntimeException);
313     virtual OUString SAL_CALL in_methodString( const OUString& rIn ) throw (RuntimeException);
314     virtual sal_Unicode SAL_CALL in_methodChar( sal_Unicode rIn ) throw (RuntimeException);
315     virtual Any SAL_CALL in_methodAny( const Any& rIn ) throw (RuntimeException);
316     virtual Type SAL_CALL in_methodType( const Type& rIn ) throw (RuntimeException);
317     virtual Reference<XInterface> SAL_CALL in_methodXInterface( const Reference< XInterface >& rIn ) throw (RuntimeException);
318     virtual Reference<XInvocation > SAL_CALL in_methodInvocation( const Reference< XInvocation >& inv ) throw (RuntimeException);
319 	virtual SimpleStruct SAL_CALL in_methodStruct( const SimpleStruct& aStruct ) throw (RuntimeException);
320     virtual void SAL_CALL in_methodAll( sal_Int8 b, float f, double d, sal_Bool boo, sal_Int16 sh, sal_uInt16 us, sal_Int32 l, sal_uInt32 ul, const OUString& s, sal_Unicode c, const Any& a, const Type& t, const Reference<XInvocation>& inv ) throw (RuntimeException);
321 
322 	// XTestInterfaces --------------------------------------------------------------------------
323     virtual void SAL_CALL testInterface(  const Reference< XCallback >& xCallback, sal_Int32 mode ) throw(RuntimeException);
324     virtual void SAL_CALL testInterface2(  const Reference< XSimple >& xSimple, sal_Int32 mode ) throw(RuntimeException);
325 	// XSimple --------------------------------------------------------------------------
326 	void SAL_CALL func( const OUString &message) throw(::com::sun::star::uno::RuntimeException);
327 	OUString SAL_CALL getName() throw(::com::sun::star::uno::RuntimeException);
328 
329     // XIdentity
330     virtual void SAL_CALL setObject( const Reference< XInterface >& val ) throw (RuntimeException);
331     virtual sal_Bool SAL_CALL isSame( const Reference< XInterface >& val ) throw (RuntimeException);
332     virtual Reference< XInterface > SAL_CALL getThis(  ) throw (RuntimeException);
333 };
334 
335 class EventListener: public WeakImplHelper1<XEventListener>
336 {
337 public:
EventListener()338     EventListener::EventListener(): bCalled( sal_False)
339         {}
340     virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) throw (RuntimeException);
341 
342     sal_Bool bCalled;
343 };
344 
345 
~OComponent()346 OComponent::~OComponent()
347 {
348 }
349 
350 
351 // Funktions ==============================================================================
352 
OComponent_CreateInstance(const Reference<XMultiServiceFactory> & rSMgr)353 Reference<XInterface> SAL_CALL OComponent_CreateInstance( const Reference<XMultiServiceFactory> & rSMgr ) throw(RuntimeException)
354 {
355 //	Reference<XInterface> xService(static_cast<XWeak*>(new OComponent( rSMgr )), UNO_QUERY);
356     OComponent* o= new OComponent( rSMgr );
357     Reference<XInterface> xService(static_cast<XIdentity*>(o), UNO_QUERY);
358 	return xService;
359 }
360 
OComponent_getSupportedServiceNames(void)361 Sequence<OUString> OComponent_getSupportedServiceNames(void)
362 {
363 	Sequence<OUString> aRet(1);
364 	aRet.getArray()[0] = SERVICE_NAME;//ODataInputStream_getImplementationName();
365 
366 	return aRet;
367 }
368 
369 
component_writeInfo(void *,void * pRegistryKey)370 extern "C" sal_Bool SAL_CALL component_writeInfo(	void * /*pServiceManager*/, void * pRegistryKey )
371 {
372 	if(pRegistryKey)
373 	{
374 		try
375 		{
376 			Reference<XRegistryKey> xNewKey =
377 				reinterpret_cast<XRegistryKey*>( pRegistryKey)->createKey(KEY1);
378 			xNewKey->createKey( KEY2);
379 			return sal_True;
380 
381 		}
382 		catch(InvalidRegistryException &)
383 		{
384 			OSL_ENSURE( sal_False, "### InvalidRegistryException!\n");
385 		}
386 	}
387 	return sal_False;
388 }
389 
component_getFactory(const sal_Char * pImplName,void * pServiceManager,void *)390 extern "C" void * SAL_CALL component_getFactory(
391 	const sal_Char * pImplName, void * pServiceManager, void * /*pRegistryKey*/ )
392 {
393 	static void * pRet= NULL;
394 	if( ! pRet)
395 	{
396 		OUString aImplName( OUString::createFromAscii( pImplName ) );
397 		if (pServiceManager && aImplName.equals(  IMPL_NAME  ))
398 		{
399 			Reference<XMultiServiceFactory> xMulFac(
400 				reinterpret_cast< XMultiServiceFactory*>(pServiceManager));
401 
402 			Sequence<OUString> seqServiceNames;
403 			Reference<XSingleServiceFactory> xFactory = createOneInstanceFactory( xMulFac, SERVICE_NAME,
404 										OComponent_CreateInstance, seqServiceNames);
405 
406 			if (xFactory.is())
407 			{
408 				xFactory->acquire();
409 				pRet = xFactory.get();
410 			}
411 		}
412 	}
413 	return	pRet;
414 }
415 
component_getImplementationEnvironment(const sal_Char ** ppEnvTypeName,uno_Environment **)416 extern "C" void SAL_CALL component_getImplementationEnvironment(
417 	const sal_Char ** ppEnvTypeName, uno_Environment ** )
418 {
419 	*ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME;
420 }
421 
422 
423 // XTestSequence ============================================================================
methodByte(const Sequence<sal_Int8> & aSeq)424 Sequence<sal_Int8> SAL_CALL OComponent::methodByte(const Sequence< sal_Int8 >& aSeq) throw( RuntimeException )
425 {
426 	sal_Int8 _x;
427 	for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
428 		_x= aSeq.getConstArray()[i];
429 	}
430 	return aSeq;
431 }
methodFloat(const Sequence<float> & aSeq)432 Sequence<float> SAL_CALL OComponent::methodFloat(const Sequence< float>& aSeq) throw( RuntimeException )
433 {
434 	float _x;
435 	for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
436 		_x= aSeq.getConstArray()[i];
437 	}
438 	return aSeq;
439 }
methodDouble(const Sequence<double> & aSeq)440 Sequence<double> SAL_CALL OComponent::methodDouble(const Sequence< double >& aSeq) throw( RuntimeException)
441 {
442 	double _x;
443 	for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
444 		_x= aSeq.getConstArray()[i];
445 	}
446 	return aSeq;
447 }
methodBool(const Sequence<sal_Bool> & aSeq)448 Sequence< sal_Bool > SAL_CALL OComponent::methodBool(const Sequence< sal_Bool >& aSeq) throw( RuntimeException)
449 {
450 	sal_Bool _x;
451 	for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
452 		_x= aSeq.getConstArray()[i];
453 	}
454 	return aSeq;
455 }
methodShort(const Sequence<sal_Int16> & aSeq)456 Sequence< sal_Int16 > SAL_CALL OComponent::methodShort(const Sequence< sal_Int16 >& aSeq) throw( RuntimeException )
457 {
458 	sal_Int16 _x;
459 	for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
460 		_x= aSeq.getConstArray()[i];
461 	}
462 	return aSeq;
463 }
methodUShort(const Sequence<sal_uInt16> & aSeq)464 Sequence< sal_uInt16 > SAL_CALL OComponent::methodUShort(const Sequence< sal_uInt16 >& aSeq) throw( RuntimeException )
465 {
466 	sal_uInt16 _x;
467 	for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
468 		_x= aSeq.getConstArray()[i];
469 	}
470 	return aSeq;
471 }
methodLong(const Sequence<sal_Int32> & aSeq)472 Sequence< sal_Int32 > SAL_CALL OComponent::methodLong(const Sequence< sal_Int32 >& aSeq) throw( RuntimeException)
473 {
474 	sal_Int32 _x;
475 	for( sal_Int16 i= 0; i < aSeq.getLength(); i++)  {
476 		_x= aSeq.getConstArray()[i];
477 	}
478 	return aSeq;
479 }
methodULong(const Sequence<sal_uInt32> & aSeq)480 Sequence< sal_uInt32 > SAL_CALL OComponent::methodULong(const Sequence< sal_uInt32 >& aSeq) throw( RuntimeException)
481 {
482 	sal_uInt32 _x;
483 	for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
484 		_x= aSeq.getConstArray()[i];
485 	}
486 	return aSeq;
487 }
methodString(const Sequence<OUString> & aSeq)488 Sequence< OUString > SAL_CALL OComponent::methodString(const Sequence< OUString >& aSeq) throw( RuntimeException)
489 {
490 	OUString _x;
491 	for( sal_Int16 i= 0; i < aSeq.getLength(); i++) {
492 		_x= aSeq.getConstArray()[i];
493 	}
494 	return aSeq;
495 }
methodChar(const Sequence<sal_Unicode> & aSeq)496 Sequence< sal_Unicode > SAL_CALL OComponent::methodChar(const Sequence< sal_Unicode >& aSeq) throw( RuntimeException)
497 {
498 	sal_Unicode _x;
499 	for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
500 		_x= aSeq.getConstArray()[i];
501 	}
502 	return aSeq;
503 }
methodAny(const Sequence<Any> & aSeq)504 Sequence< Any > SAL_CALL OComponent::methodAny(const Sequence< Any >& aSeq) throw( RuntimeException)
505 {
506 	Any _x;
507 	for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
508 		_x= aSeq.getConstArray()[i];
509 		TypeClass _t= _x.getValueTypeClass();
510 		if( _t== TypeClass_STRING)
511 			OUString s(* (rtl_uString**)_x.getValue());
512 	}
513 	return aSeq;
514 
515 }
516 
methodType(const Sequence<Type> & aSeq)517 Sequence< Type > SAL_CALL OComponent::methodType(const Sequence< Type >& aSeq) throw( RuntimeException )
518 {
519 	Type _x;
520 	for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
521 		_x= aSeq.getConstArray()[i];
522 	}
523     return aSeq;
524 }
525 //Sequence< Reference< XInterface> > SAL_CALL methodXInterface ( const Sequence< Reference < XInterface> >& aSeq)
526 //	throw (RuntimeException)
methodXInterface(const Sequence<Reference<XInterface>> & aSeq)527 Sequence< Reference< XInterface > > SAL_CALL OComponent::methodXInterface( const Sequence< Reference< XInterface > >& aSeq ) throw(RuntimeException)
528 {
529     for( sal_Int32 i= 0; i < aSeq.getLength(); i++)
530     {
531         Reference<XInterface> xInt= aSeq[i];
532         Reference<XEventListener> xList( xInt, UNO_QUERY);
533         if( xList.is())
534             xList->disposing( EventObject());
535     }
536 	return aSeq;
537 }
538 
methodSequence(const Sequence<Sequence<sal_Int32>> & aSeq)539 Sequence< Sequence< sal_Int32 > > SAL_CALL OComponent::methodSequence(const Sequence< Sequence< sal_Int32 > >& aSeq) throw( RuntimeException)
540 {
541 	sal_Int32 value;
542 	for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
543 		const Sequence<sal_Int32>& rseq2= aSeq.getConstArray()[i];
544 		for (sal_Int16 j= 0; j < rseq2.getLength(); j++){
545 			value= rseq2.getConstArray()[j];
546 		}
547 	}
548 	return aSeq;
549 }
methodSequence2(const Sequence<Sequence<Sequence<sal_Int32>>> & aSeq)550 Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL OComponent::methodSequence2(const Sequence< Sequence< Sequence< sal_Int32 > > >& aSeq)
551 	throw( RuntimeException )
552 {
553 	sal_Int32 value;
554 	sal_Int32 len= aSeq.getLength();
555 	for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
556 		const Sequence< Sequence<sal_Int32> >& rseq2= aSeq.getConstArray()[i];
557 		len= rseq2.getLength();
558 
559 		for (sal_Int16 j= 0; j < rseq2.getLength(); j++){
560 			const Sequence<sal_Int32> & rseq3= rseq2.getConstArray()[j];
561 			len= rseq3.getLength();
562 
563 			for (sal_Int16 k= 0; k < rseq3.getLength(); k++)
564 				value= rseq3.getConstArray()[k];
565 		}
566 	}
567 	return aSeq;
568 }
569 
methodXEventListeners(const Sequence<Reference<XEventListener>> & aSeq)570 Sequence< Reference< XEventListener> > SAL_CALL OComponent::methodXEventListeners( const Sequence< Reference <XEventListener> >& aSeq) throw( RuntimeException)
571 {
572     Reference<XEventListener> listener;
573     for( int i= 0; i < aSeq.getLength(); i++)
574     {
575         listener= aSeq[i];
576 
577         listener->disposing( EventObject() );
578     }
579 
580     return aSeq;
581 }
582 
methodXEventListenersMul(const Sequence<Sequence<Reference<XEventListener>>> & aSeq)583 Sequence< Sequence<Reference<XEventListener > > > SAL_CALL OComponent::methodXEventListenersMul( const Sequence<Sequence<Reference<XEventListener > > >& aSeq ) throw (RuntimeException)
584 {
585     Reference<XEventListener> listener;
586     for( int i= 0; i < aSeq.getLength(); i++)
587     {
588         Sequence<Reference<XEventListener> > seqInner= aSeq[i];
589         for( int j= 0; j < seqInner.getLength(); j++)
590         {
591             listener= seqInner[j];
592             listener->disposing( EventObject() );
593         }
594     }
595     return aSeq;
596 }
597 
598 //---------------------------------------------------------------------------------------------
599 
getAttrByte(void)600 Sequence< sal_Int8 > SAL_CALL OComponent::getAttrByte(void) throw( RuntimeException)
601 {
602 	return m_seqByte;
603 }
setAttrByte(const Sequence<sal_Int8> & AttrByte_)604 void SAL_CALL OComponent::setAttrByte(const Sequence< sal_Int8 >& AttrByte_) throw( RuntimeException )
605 {
606 	m_seqByte= AttrByte_;
607 }
getAttrFloat(void)608 Sequence< float > SAL_CALL OComponent::getAttrFloat(void)  throw( RuntimeException )
609 {
610 	return m_seqFloat;
611 }
setAttrFloat(const Sequence<float> & AttrFloat_)612 void SAL_CALL OComponent::setAttrFloat(const Sequence< float >& AttrFloat_) throw( RuntimeException )
613 {
614 	m_seqFloat= AttrFloat_;
615 }
616 
getAttrDouble(void)617 Sequence< double > SAL_CALL OComponent::getAttrDouble(void)  throw( RuntimeException )
618 {
619 	return m_seqDouble;
620 }
setAttrDouble(const Sequence<double> & AttrDouble_)621 void SAL_CALL OComponent::setAttrDouble(const Sequence< double >& AttrDouble_) throw( RuntimeException )
622 {
623 	m_seqDouble= AttrDouble_;
624 }
625 
getAttrBool(void)626 Sequence< sal_Bool > SAL_CALL OComponent::getAttrBool(void)  throw( RuntimeException)
627 {
628 	return m_seqBool;
629 }
630 
setAttrBool(const Sequence<sal_Bool> & AttrBool_)631 void SAL_CALL OComponent::setAttrBool(const Sequence< sal_Bool >& AttrBool_) throw (RuntimeException )
632 {
633 	m_seqBool= AttrBool_;
634 }
635 
getAttrShort(void)636 Sequence< sal_Int16 > SAL_CALL OComponent::getAttrShort(void)  throw( RuntimeException)
637 {
638 	return m_seqShort;
639 }
setAttrShort(const Sequence<sal_Int16> & AttrShort_)640 void SAL_CALL OComponent::setAttrShort(const Sequence< sal_Int16 >& AttrShort_) throw( RuntimeException )
641 {
642 	m_seqShort= AttrShort_;
643 }
644 
getAttrUShort(void)645 Sequence< sal_uInt16 > SAL_CALL OComponent::getAttrUShort(void) throw( RuntimeException )
646 {
647 	return m_seqUShort;
648 }
setAttrUShort(const Sequence<sal_uInt16> & AttrUShort_)649 void SAL_CALL OComponent::setAttrUShort(const Sequence< sal_uInt16 >& AttrUShort_) throw( RuntimeException )
650 {
651 	m_seqUShort= AttrUShort_;
652 }
653 
getAttrLong(void)654 Sequence< sal_Int32 > SAL_CALL OComponent::getAttrLong(void)  throw( RuntimeException)
655 {
656 	return m_seqLong;
657 }
setAttrLong(const Sequence<sal_Int32> & AttrLong_)658 void SAL_CALL OComponent::setAttrLong(const Sequence< sal_Int32 >& AttrLong_) throw( RuntimeException )
659 {
660 	m_seqLong= AttrLong_;
661 }
662 
getAttrULong(void)663 Sequence< sal_uInt32 > SAL_CALL OComponent::getAttrULong(void)  throw( RuntimeException )
664 {
665 	return m_seqULong;
666 }
setAttrULong(const Sequence<sal_uInt32> & AttrULong_)667 void SAL_CALL OComponent::setAttrULong(const Sequence< sal_uInt32 >& AttrULong_) throw( RuntimeException )
668 {
669 	m_seqULong= AttrULong_;
670 }
671 
getAttrString(void)672 Sequence< OUString > SAL_CALL OComponent::getAttrString(void)  throw( RuntimeException )
673 {
674 	return m_seqString;
675 }
setAttrString(const Sequence<OUString> & AttrString_)676 void SAL_CALL OComponent::setAttrString(const Sequence< OUString >& AttrString_) throw( RuntimeException )
677 {
678 	m_seqString= AttrString_;
679 }
680 
getAttrChar(void)681 Sequence< sal_Unicode > SAL_CALL OComponent::getAttrChar(void)  throw( RuntimeException )
682 {
683 	return m_seqChar;
684 }
setAttrChar(const Sequence<sal_Unicode> & AttrChar_)685 void SAL_CALL OComponent::setAttrChar(const Sequence< sal_Unicode >& AttrChar_) throw( RuntimeException)
686 {
687 	m_seqChar= AttrChar_;
688 }
689 
getAttrAny(void)690 Sequence< Any > SAL_CALL OComponent::getAttrAny(void) throw( RuntimeException)
691 {
692 	return m_seqAny;
693 }
setAttrAny(const Sequence<Any> & AttrAny_)694 void SAL_CALL OComponent::setAttrAny(const Sequence< Any >& AttrAny_) throw( RuntimeException )
695 {
696 	m_seqAny= AttrAny_;
697 }
698 
getAttrType(void)699 Sequence< Type > SAL_CALL OComponent::getAttrType(void)  throw( RuntimeException )
700 {
701     return m_seqType;
702 }
703 
setAttrType(const Sequence<Type> & AttrType_)704 void SAL_CALL OComponent::setAttrType( const Sequence< Type >& AttrType_) throw( RuntimeException )
705 {
706     m_seqType = AttrType_;
707 }
708 
709 
getAttrSequence(void)710 Sequence< Sequence< sal_Int32 > > SAL_CALL OComponent::getAttrSequence(void)  throw( RuntimeException)
711 {
712 	return m_seq1;
713 }
setAttrSequence(const Sequence<Sequence<sal_Int32>> & AttrSequence)714 void SAL_CALL OComponent::setAttrSequence(const Sequence< Sequence< sal_Int32 > >& AttrSequence) throw(RuntimeException )
715 {
716 	sal_Int32 x= 0;
717 	for( sal_Int32 i=0; i < AttrSequence.getLength(); i++)
718 	{
719 		 Sequence< sal_Int32 > seq= AttrSequence[i];
720 
721 		for ( sal_Int32 j=0; j < seq.getLength(); j++)
722 		{
723 			x= seq[j];
724 		}
725 	}
726 
727 	m_seq1= AttrSequence;
728 }
729 
getAttrSequence2(void)730 Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL OComponent::getAttrSequence2(void)  throw( RuntimeException )
731 {
732 	return m_seq2;
733 }
setAttrSequence2(const Sequence<Sequence<Sequence<sal_Int32>>> & AttrSequence2_)734 void SAL_CALL OComponent::setAttrSequence2(const Sequence< Sequence< Sequence< sal_Int32 > > >& AttrSequence2_)
735 	throw( RuntimeException )
736 {
737 	m_seq2= AttrSequence2_;
738 }
739 
getAttrXInterface()740 Sequence< Reference< XInterface > > SAL_CALL OComponent::getAttrXInterface() throw(RuntimeException)
741 {
742 	return m_seqxInterface;
743 }
setAttrXInterface(const Sequence<Reference<XInterface>> & _attrxinterface)744 void SAL_CALL OComponent::setAttrXInterface( const Sequence< Reference< XInterface > >& _attrxinterface ) throw(RuntimeException)
745 {
746 	m_seqxInterface= _attrxinterface;
747 }
748 
749 // ----------------------------------------------------------------------------
750 
getAByte()751 ::sal_Int8 SAL_CALL OComponent::getAByte() throw (RuntimeException)
752 {
753     return m_attr_int8;
754 }
755 
setAByte(::sal_Int8 _abyte)756 void SAL_CALL OComponent::setAByte( ::sal_Int8 _abyte ) throw (RuntimeException)
757 {
758     m_attr_int8 = _abyte;
759 }
760 
getAFloat()761 float SAL_CALL OComponent::getAFloat() throw (RuntimeException)
762 {
763     return m_attr_float;
764 }
765 
setAFloat(float _afloat)766 void SAL_CALL OComponent::setAFloat( float _afloat ) throw (RuntimeException)
767 {
768     m_attr_float = _afloat;
769 }
770 
getADouble()771 double SAL_CALL OComponent::getADouble() throw (RuntimeException)
772 {
773     return m_attr_double;
774 }
775 
setADouble(double _adouble)776 void SAL_CALL OComponent::setADouble( double _adouble ) throw (RuntimeException)
777 {
778     m_attr_double = _adouble;
779 }
780 
getABool()781 ::sal_Bool SAL_CALL OComponent::getABool() throw (RuntimeException)
782 {
783     return m_attr_bool;
784 }
785 
setABool(::sal_Bool _abool)786 void SAL_CALL OComponent::setABool( ::sal_Bool _abool ) throw (RuntimeException)
787 {
788     m_attr_bool = _abool;
789 }
790 
getAShort()791 ::sal_Int16 SAL_CALL OComponent::getAShort() throw (RuntimeException)
792 {
793     return m_attr_int16;
794 }
795 
setAShort(::sal_Int16 _ashort)796 void SAL_CALL OComponent::setAShort( ::sal_Int16 _ashort ) throw (RuntimeException)
797 {
798     m_attr_int16 = _ashort;
799 }
800 
getAUShort()801 ::sal_uInt16 SAL_CALL OComponent::getAUShort() throw (RuntimeException)
802 {
803     return m_attr_uint16;
804 }
805 
setAUShort(::sal_uInt16 _aushort)806 void SAL_CALL OComponent::setAUShort( ::sal_uInt16 _aushort ) throw (RuntimeException)
807 {
808     m_attr_uint16 = _aushort;
809 }
810 
getALong()811 ::sal_Int32 SAL_CALL OComponent::getALong() throw (RuntimeException)
812 {
813     return m_attr_int32;
814 }
815 
setALong(::sal_Int32 _along)816 void SAL_CALL OComponent::setALong( ::sal_Int32 _along ) throw (RuntimeException)
817 {
818     m_attr_int32 = _along;
819 }
820 
getAULong()821 ::sal_uInt32 SAL_CALL OComponent::getAULong() throw (RuntimeException)
822 {
823     return m_attr_uint32;;
824 }
825 
setAULong(::sal_uInt32 _aulong)826 void SAL_CALL OComponent::setAULong( ::sal_uInt32 _aulong ) throw (RuntimeException)
827 {
828     m_attr_uint32 = _aulong;
829 }
830 
getAString()831 ::rtl::OUString SAL_CALL OComponent::getAString() throw (RuntimeException)
832 {
833     return m_attr_string;
834 }
835 
setAString(const::rtl::OUString & _astring)836 void SAL_CALL OComponent::setAString( const ::rtl::OUString& _astring ) throw (RuntimeException)
837 {
838     m_attr_string = _astring;
839 }
840 
getAChar()841 ::sal_Unicode SAL_CALL OComponent::getAChar() throw (RuntimeException)
842 {
843     return m_attr_char;
844 }
845 
setAChar(::sal_Unicode _achar)846 void SAL_CALL OComponent::setAChar( ::sal_Unicode _achar ) throw (RuntimeException)
847 {
848     m_attr_char = _achar;
849 }
850 
getAAny()851 Any SAL_CALL OComponent::getAAny() throw (RuntimeException)
852 {
853     return m_attr_any;
854 }
855 
setAAny(const Any & _aany)856 void SAL_CALL OComponent::setAAny( const Any& _aany ) throw (RuntimeException)
857 {
858     m_attr_any = _aany;
859 }
860 
getAType()861 Type SAL_CALL OComponent::getAType() throw (RuntimeException)
862 {
863     return m_attr_type;
864 }
865 
setAType(const Type & _atype)866 void SAL_CALL OComponent::setAType( const Type& _atype ) throw (RuntimeException)
867 {
868     m_attr_type = _atype;
869 }
870 
getAXInterface()871 Reference< XInterface > SAL_CALL OComponent::getAXInterface() throw (RuntimeException)
872 {
873     return m_attr_xinterface;
874 }
875 
setAXInterface(const Reference<XInterface> & _axinterface)876 void SAL_CALL OComponent::setAXInterface( const Reference<XInterface >& _axinterface ) throw (RuntimeException)
877 {
878     m_attr_xinterface = _axinterface;
879 }
880 
getAXInvocation()881 Reference<XInvocation > SAL_CALL OComponent::getAXInvocation() throw (RuntimeException)
882 {
883     return m_attr_xinvocation;
884 }
885 
setAXInvocation(const Reference<XInvocation> & _axinvocation)886 void SAL_CALL OComponent::setAXInvocation( const Reference< XInvocation >& _axinvocation ) throw (RuntimeException)
887 {
888     m_attr_xinvocation = _axinvocation;
889 }
890 //-----------------------------------------------------------------------------------
testout_methodByte(sal_Int8 & rOut)891 void SAL_CALL OComponent::testout_methodByte(sal_Int8& rOut) throw( RuntimeException )
892 {
893 	rOut= m_int8;
894 }
testout_methodFloat(float & rOut)895 void SAL_CALL OComponent::testout_methodFloat(float& rOut) throw( RuntimeException )
896 {
897 	rOut= m_float;
898 }
testout_methodDouble(double & rOut)899 void SAL_CALL OComponent::testout_methodDouble(double& rOut) throw( RuntimeException )
900 {
901 	rOut= m_double;
902 }
903 
testout_methodBool(sal_Bool & rOut)904 void SAL_CALL OComponent::testout_methodBool(sal_Bool& rOut) throw( RuntimeException )
905 {
906 	rOut= m_bool;
907 }
testout_methodShort(sal_Int16 & rOut)908 void SAL_CALL OComponent::testout_methodShort(sal_Int16& rOut) throw( RuntimeException )
909 {
910 	rOut= m_int16;
911 }
testout_methodUShort(sal_uInt16 & rOut)912 void SAL_CALL OComponent::testout_methodUShort(sal_uInt16& rOut) throw( RuntimeException )
913 {
914 	rOut= m_uint16;
915 }
testout_methodLong(sal_Int32 & rOut)916 void SAL_CALL OComponent::testout_methodLong(sal_Int32& rOut) throw( RuntimeException )
917 {
918 	rOut = m_int32;
919 }
testout_methodULong(sal_uInt32 & rOut)920 void SAL_CALL OComponent::testout_methodULong(sal_uInt32& rOut) throw( RuntimeException )
921 {
922 	rOut= m_uint32;
923 }
testout_methodHyper(sal_Int64 & rOut)924 void SAL_CALL OComponent::testout_methodHyper(sal_Int64& rOut) throw( RuntimeException )
925 {
926     rOut = m_int64;
927 }
928 
testout_methodUHyper(sal_uInt64 & rOut)929 void SAL_CALL OComponent::testout_methodUHyper(sal_uInt64& rOut) throw( RuntimeException )
930 {
931     rOut = m_uint64;
932 }
933 
testout_methodString(OUString & rOut)934 void SAL_CALL OComponent::testout_methodString(OUString& rOut) throw( RuntimeException )
935 {
936 	rOut= m_string;
937 }
testout_methodChar(sal_Unicode & rOut)938 void SAL_CALL OComponent::testout_methodChar(sal_Unicode& rOut) throw( RuntimeException )
939 {
940 	rOut= m_char;
941 }
testout_methodAny(Any & rOut)942 void SAL_CALL OComponent::testout_methodAny(Any& rOut) throw( RuntimeException)
943 {
944 	rOut = m_any;
945 }
946 
testout_methodType(Type & rOut)947 void SAL_CALL OComponent::testout_methodType(Type& rOut) throw( RuntimeException )
948 {
949     rOut = m_type;
950 }
951 
testout_methodSequence(Sequence<sal_Int32> & rOut)952 void SAL_CALL OComponent::testout_methodSequence(Sequence< sal_Int32 >& rOut) throw( RuntimeException)
953 {
954 	rOut.realloc(10);
955 	for( sal_Int16 i= 0; i < rOut.getLength(); i++) rOut.getArray()[i]= i;
956 }
testout_methodSequence2(Sequence<Sequence<sal_Int32>> & rOut)957 void SAL_CALL OComponent::testout_methodSequence2(Sequence< Sequence< sal_Int32 > >& rOut) throw( RuntimeException )
958 {
959 	rOut.realloc( 10);
960 	for( sal_Int16 i= 0; i < rOut.getLength(); i++){
961 		Sequence<sal_Int32>& rseq2= rOut.getArray()[i];
962 		rseq2.realloc( 10);
963 		for (sal_Int16 j= 0; j < rseq2.getLength(); j++){
964 			rseq2.getArray()[j]= j;
965 		}
966 	}
967 }
testout_methodMulParams1(sal_Int32 & rout1,sal_Int32 & rout2)968 void SAL_CALL OComponent::testout_methodMulParams1(sal_Int32& rout1, sal_Int32& rout2) throw( RuntimeException )
969 {
970 	rout1= 999;
971 	rout2= 1111;
972 }
testout_methodMulParams2(sal_Int32 & rout1,sal_Int32 & rout2,OUString & rout3)973 void SAL_CALL OComponent::testout_methodMulParams2(sal_Int32& rout1, sal_Int32& rout2, OUString& rout3) throw( RuntimeException )
974 {
975 	rout1= 1111;
976 	rout2= 1222;
977 	rout3= L" another string";
978 }
testout_methodMulParams3(const OUString &,OUString & sout)979 void SAL_CALL OComponent::testout_methodMulParams3(const OUString&, OUString& sout) throw( RuntimeException )
980 {
981 	sout= L"Out Hallo!";
982 }
testout_methodMulParams4(float in1,float & out1,sal_Int32 in2,sal_Int32 & out2,sal_Int32)983 void SAL_CALL OComponent::testout_methodMulParams4( float in1, float& out1, sal_Int32 in2, sal_Int32& out2, sal_Int32 ) throw(RuntimeException)
984 {
985 	out1= in1 + 1;
986 	out2= in2 + 1;
987 }
988 
testout_methodXInterface(Reference<XInterface> & rOut)989 void SAL_CALL OComponent::testout_methodXInterface( Reference< XInterface >& rOut ) throw(RuntimeException)
990 {
991     rOut = m_xinterface;
992 // 	OUString string( L"Property Any");
993 // 	m_any <<= string;
994 // 	rOut=  Reference<XInterface> (static_cast<XTestSequence*>(this), UNO_QUERY);
995 }
996 
997 // XTestInParameters ------------------------------------------------------------
in_methodByte(sal_Int8 rIn)998 sal_Int8 SAL_CALL OComponent::in_methodByte( sal_Int8 rIn ) throw (RuntimeException)
999 {
1000     m_int8 = rIn;
1001 	return rIn;
1002 }
in_methodFloat(float rIn)1003 float SAL_CALL OComponent::in_methodFloat( float rIn ) throw (RuntimeException)
1004 {
1005     m_float = rIn;
1006 	return rIn;
1007 }
in_methodDouble(double rIn)1008 double SAL_CALL OComponent::in_methodDouble( double rIn ) throw (RuntimeException)
1009 {
1010     m_double = rIn;
1011 	return rIn;
1012 }
in_methodBool(sal_Bool rIn)1013 sal_Bool SAL_CALL OComponent::in_methodBool( sal_Bool rIn ) throw (RuntimeException)
1014 {
1015     m_bool = rIn;
1016 	return rIn;
1017 }
in_methodShort(sal_Int16 rIn)1018 sal_Int16 SAL_CALL OComponent::in_methodShort( sal_Int16 rIn ) throw (RuntimeException)
1019 {
1020     m_int16 = rIn;
1021 	return rIn;
1022 }
in_methodUShort(sal_uInt16 rIn)1023 sal_uInt16 SAL_CALL OComponent::in_methodUShort( sal_uInt16 rIn ) throw (RuntimeException)
1024 {
1025     m_uint16 = rIn;
1026 	return rIn;
1027 }
in_methodLong(sal_Int32 rIn)1028 sal_Int32 SAL_CALL OComponent::in_methodLong( sal_Int32 rIn ) throw (RuntimeException)
1029 {
1030     m_int32 = rIn;
1031 	return rIn;
1032 }
in_methodULong(sal_uInt32 rIn)1033 sal_uInt32 SAL_CALL OComponent::in_methodULong( sal_uInt32 rIn ) throw (RuntimeException)
1034 {
1035     m_uint32 = rIn;
1036 	return rIn;
1037 }
in_methodHyper(sal_Int64 rIn)1038 sal_Int64 SAL_CALL OComponent::in_methodHyper( sal_Int64 rIn ) throw (RuntimeException)
1039 {
1040     m_int64 = rIn;
1041     return rIn;
1042 }
1043 
in_methodUHyper(sal_uInt64 rIn)1044 sal_uInt64 SAL_CALL OComponent::in_methodUHyper( sal_uInt64 rIn ) throw (RuntimeException)
1045 {
1046     m_uint64 = rIn;
1047     return rIn;
1048 }
1049 
in_methodString(const OUString & rIn)1050 OUString SAL_CALL OComponent::in_methodString( const OUString& rIn ) throw (RuntimeException)
1051 {
1052     m_string = rIn;
1053 	return rIn;
1054 }
in_methodChar(sal_Unicode rIn)1055 sal_Unicode SAL_CALL OComponent::in_methodChar( sal_Unicode rIn ) throw (RuntimeException)
1056 {
1057     m_char = rIn;
1058 	return rIn;
1059 }
in_methodAny(const Any & rIn)1060 Any SAL_CALL OComponent::in_methodAny( const Any& rIn ) throw (RuntimeException)
1061 {
1062     m_any = rIn;
1063 	return rIn;
1064 }
1065 
in_methodType(const Type & rIn)1066 Type SAL_CALL OComponent::in_methodType( const Type& rIn ) throw (RuntimeException)
1067 {
1068     m_type = rIn;
1069 	return rIn;
1070 }
1071 
in_methodInvocation(const Reference<XInvocation> & inv)1072 Reference<XInvocation > SAL_CALL OComponent::in_methodInvocation( const Reference< XInvocation >& inv )
1073 		throw (RuntimeException)
1074 {
1075 	//We expect the invocation results from a conversion of VBasicEventListener.VBEventListener
1076 //which implements XEventListener
1077 	// extensions/test/ole/EventListenerSample
1078 	EventObject event( Reference<XInterface>(static_cast<XTestInParameters*>(this),UNO_QUERY));
1079 	Any anyParam;
1080 	anyParam <<= event;
1081 	Sequence<Any> params( &anyParam, 1);
1082 	Sequence<sal_Int16> outIndex;
1083 	Sequence<Any> outParams;
1084 	try{
1085 	inv->invoke( OUString(RTL_CONSTASCII_USTRINGPARAM("disposing")),
1086 				params, outIndex, outParams);
1087 	}catch(IllegalArgumentException &) {
1088 	}
1089 	catch(CannotConvertException &){
1090 	}
1091 	catch(InvocationTargetException&) {
1092 	}
1093 	return inv;
1094 }
in_methodXInterface(const Reference<XInterface> & rIn)1095 Reference<XInterface> SAL_CALL OComponent::in_methodXInterface( const Reference<XInterface >& rIn ) throw (RuntimeException)
1096 {
1097     m_xinterface = rIn;
1098     return rIn;
1099 }
1100 
in_methodStruct(const SimpleStruct & aStruct)1101 SimpleStruct SAL_CALL OComponent::in_methodStruct( const SimpleStruct& aStruct )
1102 		throw (RuntimeException)
1103 {
1104 	SimpleStruct& s= const_cast<SimpleStruct&>(aStruct);
1105 	s.message= s.message + OUString(RTL_CONSTASCII_USTRINGPARAM(
1106 		"This string was set in OleTest"));
1107 	return aStruct;
1108 }
in_methodAll(sal_Int8,float,double,sal_Bool,sal_Int16,sal_uInt16,sal_Int32,sal_uInt32,const OUString &,sal_Unicode,const Any &,const Type &,const Reference<XInvocation> &)1109 void SAL_CALL OComponent::in_methodAll(
1110     sal_Int8, float, double, sal_Bool, sal_Int16, sal_uInt16,
1111     sal_Int32, sal_uInt32, const OUString&, sal_Unicode,
1112     const Any&, const Type&, const Reference<XInvocation>&) throw (RuntimeException)
1113 {
1114 }
1115 
1116 // INOUT -----------------------------------------------------------------------------------
testinout_methodByte(sal_Int8 & rOut)1117 void SAL_CALL OComponent::testinout_methodByte(sal_Int8& rOut) throw( RuntimeException )
1118 {
1119     sal_Int8 tmp = rOut;
1120 	rOut = m_int8;
1121     m_int8 = tmp;
1122 }
testinout_methodFloat(float & rOut)1123 void SAL_CALL OComponent::testinout_methodFloat(float& rOut) throw( RuntimeException )
1124 {
1125     float tmp = rOut;
1126     rOut = m_float;
1127     m_float = tmp;
1128 }
1129 
testinout_methodDouble(double & rOut)1130 void SAL_CALL OComponent::testinout_methodDouble(double& rOut) throw( RuntimeException )
1131 {
1132 	double tmp = rOut;
1133     rOut = m_double;
1134     m_double = tmp;
1135 }
testinout_methodBool(sal_Bool & rOut)1136 void SAL_CALL OComponent::testinout_methodBool(sal_Bool& rOut) throw( RuntimeException )
1137 {
1138     sal_Bool tmp = rOut;
1139     rOut = m_bool;
1140     m_bool = tmp;
1141 }
testinout_methodShort(sal_Int16 & rOut)1142 void SAL_CALL OComponent::testinout_methodShort(sal_Int16& rOut) throw( RuntimeException )
1143 {
1144 	sal_Int16 tmp= rOut;
1145     rOut = m_int16;
1146     m_int16 = tmp;
1147 }
testinout_methodUShort(sal_uInt16 & rOut)1148 void SAL_CALL OComponent::testinout_methodUShort(sal_uInt16& rOut) throw( RuntimeException )
1149 {
1150     sal_uInt16 tmp = rOut;
1151     rOut = m_uint16;
1152     m_uint16 = tmp;
1153 }
testinout_methodLong(sal_Int32 & rOut)1154 void SAL_CALL OComponent::testinout_methodLong(sal_Int32& rOut) throw( RuntimeException )
1155 {
1156     sal_Int32 tmp = rOut;
1157     rOut = m_int32;
1158     m_int32 = tmp;
1159 }
testinout_methodULong(sal_uInt32 & rOut)1160 void SAL_CALL OComponent::testinout_methodULong(sal_uInt32& rOut) throw( RuntimeException )
1161 {
1162     sal_uInt32 tmp = rOut;
1163     rOut = m_uint32;
1164     m_uint32 = tmp;
1165 }
testinout_methodHyper(sal_Int64 & rOut)1166 void SAL_CALL OComponent::testinout_methodHyper(sal_Int64& rOut) throw( RuntimeException )
1167 {
1168     sal_Int64 tmp = rOut;
1169     rOut = m_int64;
1170     m_int64 = tmp;
1171 }
1172 
testinout_methodUHyper(sal_uInt64 & rOut)1173 void SAL_CALL OComponent::testinout_methodUHyper(sal_uInt64& rOut) throw( RuntimeException )
1174 {
1175     sal_uInt64 tmp = rOut;
1176     rOut = m_uint64;
1177     m_uint64 = tmp;
1178 }
1179 
testinout_methodString(OUString & rOut)1180 void SAL_CALL OComponent::testinout_methodString(OUString& rOut) throw( RuntimeException )
1181 {
1182     OUString tmp = rOut;
1183     rOut = m_string;
1184     m_string = tmp;
1185 }
testinout_methodChar(sal_Unicode & rOut)1186 void SAL_CALL OComponent::testinout_methodChar(sal_Unicode& rOut) throw( RuntimeException)
1187 {
1188     sal_Unicode tmp = rOut;
1189     rOut = m_char;
1190     m_char = tmp;
1191 }
testinout_methodAny(Any & rOut)1192 void SAL_CALL OComponent::testinout_methodAny(Any& rOut) throw( RuntimeException)
1193 {
1194     Any tmp = rOut;
1195     rOut = m_any;
1196     m_any = tmp;
1197 }
testinout_methodType(Type & rOut)1198 void SAL_CALL OComponent::testinout_methodType(Type& rOut) throw( RuntimeException)
1199 {
1200     Type tmp = rOut;
1201     rOut = m_type;
1202     m_type = tmp;
1203 }
1204 
1205 
testinout_methodSequence(Sequence<sal_Int32> & rOut)1206 void SAL_CALL OComponent::testinout_methodSequence(Sequence< sal_Int32 >& rOut) throw( RuntimeException)
1207 {
1208 
1209 	sal_Int32* arr= rOut.getArray();
1210 	for ( sal_Int32 i=0; i < rOut.getLength(); i++)
1211 	{
1212 		rOut.getArray()[i] += 1;
1213 	}
1214 }
testinout_methodSequence2(Sequence<Sequence<sal_Int32>> & rOut)1215 void SAL_CALL OComponent::testinout_methodSequence2(Sequence< Sequence< sal_Int32 > >& rOut) throw( RuntimeException )
1216 {
1217 	for( sal_Int32 i=0; i < rOut.getLength(); i++)
1218 	{
1219 		Sequence< sal_Int32 >& seq= rOut.getArray()[i];
1220 
1221 		for ( sal_Int32 j=0; j < seq.getLength(); j++)
1222 		{
1223 			seq.getArray()[j] += seq.getArray()[j];
1224 		}
1225 	}
1226 }
1227 
1228 // The parameter should implement XInvocation and a Property "value"
testinout_methodXInterface(Reference<XInvocation> & rOut)1229 void SAL_CALL OComponent::testinout_methodXInterface( Reference< XInvocation >& rOut ) throw(RuntimeException)
1230 {
1231 		Any any;
1232 		any= rOut->getValue( OUString( L"value"));
1233 		OUString _s;
1234 		any >>= _s;
1235 		OUString string(L"out");
1236 		any <<= string;
1237 		rOut->setValue( OUString(L"value"), any);
1238 
1239 		any= rOut->getValue( OUString( L"value"));
1240 		any >>= _s;
1241 
1242 }
1243 
testinout_methodXInterface2(Reference<XInterface> & rOut)1244 void SAL_CALL OComponent::testinout_methodXInterface2( Reference< XInterface > & rOut) throw( RuntimeException)
1245 {
1246     Reference<XInterface> tmp = rOut;
1247     rOut = m_xinterface;
1248     m_xinterface = tmp;
1249 // 	Reference<XTestSequence> xTest( rOut, UNO_QUERY);
1250 // 	if( xTest.is())
1251 // 	{
1252 // 		Any any= xTest->getAttrAny2();
1253 // 		OUString _s;
1254 // 		any >>= _s;
1255 // 		OUString string= _s + OUString((L" this string was written in the UNO component to the inout pararmeter"));
1256 // 		any <<= string;
1257 // 		xTest->setAttrAny2( any);
1258 // 	}
1259 
1260 }
methodAnyTest1(const Any & rIn)1261 Any SAL_CALL OComponent::methodAnyTest1(const Any& rIn) throw( RuntimeException )
1262 {
1263 	return rIn;
1264 }
getAttrAny2(void)1265 Any SAL_CALL OComponent::getAttrAny2(void)  throw( RuntimeException )
1266 {
1267 	return m_any;
1268 }
setAttrAny2(const Any & AttrAny2_)1269 void SAL_CALL OComponent::setAttrAny2(const Any& AttrAny2_) throw( RuntimeException )
1270 {
1271 	m_any= AttrAny2_;
1272 }
1273 
1274 
1275 
1276 // XTestStruct =======================================================================================
1277 
methodStruct(const Property & aProp)1278 void SAL_CALL OComponent::methodStruct(const Property& aProp) throw( RuntimeException )
1279 {
1280 	char buff[1024];
1281 	buff[0]= 0;
1282 	sprintf( buff,"Property::Attribute : %d \n Property::Handle : %d \n Property::Name : %S",
1283 		aProp.Attributes, aProp.Handle, (const sal_Unicode*)aProp.Name);
1284 	MessageBox( NULL, A2T(buff), _T("OleTest: methodStruct"), MB_OK);
1285 }
1286 
retMethodStruct(void)1287 Property SAL_CALL OComponent::retMethodStruct(void) throw( RuntimeException )
1288 {
1289 	Property a(L"OleTest_Property", 255, getCppuType( (Reference<XInterface>*)0), PropertyAttribute::MAYBEVOID |
1290 		PropertyAttribute::BOUND | PropertyAttribute::CONSTRAINED |
1291 		PropertyAttribute::TRANSIENT | PropertyAttribute::READONLY |
1292 		PropertyAttribute::MAYBEAMBIGUOUS | PropertyAttribute::MAYBEDEFAULT );
1293 	return a;
1294 }
1295 
getAttrStruct(void)1296 Property SAL_CALL OComponent::getAttrStruct(void) throw( RuntimeException)
1297 {
1298 	Property a(L"OleTest_Property", 255, getCppuType( (Reference<XInterface>*)0), PropertyAttribute::MAYBEVOID |
1299 		PropertyAttribute::BOUND | PropertyAttribute::CONSTRAINED |
1300 		PropertyAttribute::TRANSIENT | PropertyAttribute::READONLY |
1301 		PropertyAttribute::MAYBEAMBIGUOUS | PropertyAttribute::MAYBEDEFAULT );
1302 	return a;
1303 
1304 }
1305 
setAttrStruct(const Property & AttrStruct_)1306 void SAL_CALL OComponent::setAttrStruct(const Property& AttrStruct_) throw( RuntimeException )
1307 {
1308 	char buff[1024];
1309 	buff[0]= 0;
1310 	sprintf( buff,"Property::Attribute : %d \n Property::Handle : %d \n Property::Name : %S",
1311 		AttrStruct_.Attributes, AttrStruct_.Handle, (const sal_Unicode*)AttrStruct_.Name);
1312 //	MessageBox( NULL, A2T(buff), _T("OleTest: setAttrStruct"), MB_OK);
1313 }
1314 
methodStruct2(const Property & aProp)1315 Property SAL_CALL OComponent::methodStruct2( const Property& aProp ) throw (RuntimeException)
1316 {
1317     return aProp;
1318 }
1319 
1320 // XTestOther ==================================================================================
other_methodAnyIn(const Any &)1321 void SAL_CALL OComponent::other_methodAnyIn(const Any& ) throw( RuntimeException )
1322 {
1323 }
other_methodAnyOut(Any & rAny)1324 void SAL_CALL OComponent::other_methodAnyOut(Any& rAny) throw( RuntimeException )
1325 {
1326 	rAny <<= OUString(L"Ein Any");
1327 }
1328 
other_methodAnyRet(void)1329 Any SAL_CALL OComponent::other_methodAnyRet(void) throw(RuntimeException )
1330 {
1331 	Any a;
1332 	a <<= OUString(L"Ein Any");
1333 	return a;
1334 }
in_float(float val)1335 void SAL_CALL OComponent::in_float( float val) throw ( RuntimeException)
1336 {
1337 	USES_CONVERSION;
1338 	char buff[256];
1339 	sprintf( buff, "parameter : %f", val);
1340 	MessageBox( NULL, A2T(buff), _T("OleTest"), MB_OK);
1341 }
other_methodAny(const Any & rAny,const OUString & typeInAny)1342 Any SAL_CALL OComponent::other_methodAny( const Any& rAny, const OUString& typeInAny )
1343         throw (RuntimeException)
1344 {
1345     Type expectedType;
1346 	typelib_TypeDescription	* pDesc= NULL;
1347 	typelib_typedescription_getByName( &pDesc, typeInAny.pData );
1348 	if( pDesc)
1349 	{
1350 		expectedType = Type( pDesc->pWeakRef );
1351 		typelib_typedescription_release( pDesc);
1352 	}
1353     if (rAny.getValueType() != expectedType)
1354         throw RuntimeException();
1355 
1356     return rAny;
1357 }
1358 
1359 // XTestOutParameters ============================================================================
1360 // void SAL_CALL OComponent::out_test(sal_Int8 rIn) throw( RuntimeException )
1361 // {
1362 // }
1363 
1364 // void SAL_CALL OComponent::out_methodByte(sal_Int8& rOut) throw( RuntimeException )
1365 // {
1366 // 	rOut= 100;
1367 // }
1368 
1369 // void SAL_CALL OComponent::out_methodDouble(double& rOut) throw( RuntimeException )
1370 // {
1371 // 	rOut= 3.14;
1372 // }
1373 // void SAL_CALL OComponent::out_methodFloat(float& rOut) throw( RuntimeException )
1374 // {
1375 // 	rOut= 3.14;
1376 // }
1377 // void SAL_CALL OComponent::out_methodBool(sal_Bool& rOut) throw( RuntimeException )
1378 // {
1379 // 	rOut= sal_True;
1380 // }
1381 // void SAL_CALL OComponent::out_methodShort(sal_Int16& rOut) throw( RuntimeException )
1382 // {
1383 // 	rOut= -100;
1384 // }
1385 // void SAL_CALL OComponent::out_methodUShort(sal_uInt16& rOut) throw( RuntimeException )
1386 // {
1387 // 	rOut= 100;
1388 // }
1389 // void SAL_CALL OComponent::out_methodLong(sal_Int32& rOut) throw( RuntimeException )
1390 // {
1391 // 	rOut= -100;
1392 // }
1393 
1394 // void SAL_CALL OComponent::out_methodULong(sal_uInt32& rOut) throw( RuntimeException )
1395 // {
1396 // 	rOut= 100;
1397 // }
1398 // void SAL_CALL OComponent::out_methodHyper(sal_Int64& rOut) throw( RuntimeException )
1399 // {
1400 
1401 // }
1402 
1403 // void SAL_CALL OComponent::out_methodUHyper(sal_uInt64& rOut) throw( RuntimeException )
1404 // {
1405 // }
1406 
1407 // void SAL_CALL OComponent::out_methodString(OUString& rOut) throw( RuntimeException )
1408 // {
1409 // 	rOut= L"I'm a string";
1410 // }
1411 // void SAL_CALL OComponent::out_methodChar(sal_Unicode& rOut) throw( RuntimeException )
1412 // {
1413 // 	rOut= 'A';
1414 // }
1415 // void SAL_CALL OComponent::out_methodAny(Any& rOut) throw( RuntimeException)
1416 // {
1417 // 	Any a;
1418 //     a <<= OUString( L"Hi");
1419 // 	rOut= a;
1420 // }
1421 // void SAL_CALL OComponent::out_methodSequence(Sequence< sal_Int32 >& rOut) throw( RuntimeException )
1422 // {
1423 // 	Sequence< sal_Int32 > aseq(10);
1424 // 	for( sal_Int16 i= 0; i < aseq.getLength(); i++) aseq.getArray()[i]= i;
1425 // 	rOut= aseq;
1426 // }
1427 // void SAL_CALL OComponent::out_methodSequence2(Sequence< Sequence< sal_Int32 > >& rOut) throw( RuntimeException )
1428 // {
1429 // 	rOut= Sequence< Sequence< sal_Int32 > >();
1430 // }
1431 // void SAL_CALL OComponent::out_methodMulParams1(sal_Int32& rout1, sal_Int32& rout2) throw( RuntimeException )
1432 // {
1433 // 	rout1= 111;
1434 // 	rout2= 222;
1435 // }
1436 // void SAL_CALL OComponent::out_methodMulParams2(sal_Int32& rout1, sal_Int32& rout2, OUString& rout3) throw( RuntimeException )
1437 // {
1438 // 	rout1= 111;
1439 // 	rout2= 222;
1440 // 	rout3= L"this is a neet little string";
1441 // }
1442 // void SAL_CALL OComponent::out_methodMulParams3(const OUString& sin, OUString& sout) throw( RuntimeException )
1443 // {
1444 // 	sout= L"this is a neet little string";
1445 // }
1446 
1447 // XTestInterfaces -------------------------------------------------------------------------------------
testInterface(const Reference<XCallback> & xCallback,sal_Int32 mode)1448 void SAL_CALL OComponent::testInterface(  const Reference< XCallback >& xCallback, sal_Int32 mode ) throw(RuntimeException)
1449 {
1450 	USES_CONVERSION;
1451 	sal_Int32 i=0;
1452 	OUString aString;
1453 	char buff[1024];
1454 
1455 	Reference<XSimple> xSimple;
1456 	SimpleStruct aSimpleStruct;
1457 	SimpleEnum aSimpleEnum;
1458 	Sequence<Any> seqAny;
1459 	Sequence< sal_Int8 > seqByte;
1460 	Any outAny;
1461 	sal_Bool aBool;
1462 	sal_Unicode aChar;
1463 	float aFloat;
1464 	double aDouble;
1465 	sal_Int8 aByte;
1466 	sal_Int16 aShort;
1467 	sal_Int32 aLong;
1468 // 	sal_uInt16 aUShort;
1469 // 	sal_uInt32 aULong;
1470 
1471 	switch( mode)
1472 	{
1473 	case 1:
1474 		 xCallback->func1(); break;
1475 	case 2:
1476 		xSimple=	xCallback->returnInterface();
1477 		xSimple->func(L"XCallback::returnInterface");
1478 		break;
1479 
1480 
1481 	case 3:
1482 		xCallback->outInterface( xSimple);
1483 		sprintf( buff, "XCallback::outInterface, value: %x", xSimple.get());
1484 		MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
1485 		xSimple->func(L"XCallback::outInterface works");
1486 		break;
1487 	case 4:
1488 		 xCallback->outStruct( aSimpleStruct);
1489 		 sprintf( buff,"XCallback::outStruct, SimpleStruct::message: %s", OLE2A( aSimpleStruct.message));
1490 		 MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
1491 		 break;
1492 	case 5:
1493 		xCallback->outEnum( aSimpleEnum);
1494 		sprintf( buff,"XCallback::outEnum, SimpleEnum: %d", aSimpleEnum);
1495 		MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
1496 		break;
1497 	case 6:
1498 		xCallback->outSeqAny( seqAny);
1499 		sprintf( buff,"XCallback::outSeqAny, length: %d )", seqAny.getLength());
1500 		MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
1501 		for( i=0; i < seqAny.getLength(); i++)
1502 		{
1503 			Any any= seqAny[i];
1504 			if( any.getValueTypeClass() == TypeClass_STRING)
1505 			{
1506 				any >>= aString;
1507 				OutputDebugStringW( aString);
1508 			}
1509 
1510 		}
1511 		break;
1512 	case 7:
1513 		xCallback->outAny( outAny);
1514 		if( outAny.getValueTypeClass() == TypeClass_STRING)
1515 			outAny >>= aString;
1516 		sprintf( buff,"XCallback::outAny, Any : %s", W2A( aString));
1517 		MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
1518 		break;
1519 	case 8:
1520 		xCallback->outBool( aBool);
1521 		sprintf( buff,"XCallback::outBool, value: %d", aBool);
1522 		MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
1523 		break;
1524 	case 9:
1525 		xCallback->outChar( aChar);
1526 		sprintf( buff,"XCallback::outChar, value: %C", aChar);
1527 		MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
1528 		break;
1529 	case 10:
1530 		xCallback->outString( aString);
1531 		sprintf( buff,"XCallback::outString, value: %s", W2A( aString));
1532 		MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
1533 		break;
1534 	case 11:
1535 		xCallback->outFloat( aFloat);
1536 		sprintf( buff,"XCallback::outFloat, value: %f", aFloat);
1537 		MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
1538 		break;
1539 	case 12:
1540 		xCallback->outDouble( aDouble);
1541 		sprintf( buff,"XCallback::outDouble, value: %f", aDouble);
1542 		MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
1543 		break;
1544 	case 13:
1545 		xCallback->outByte( aByte);
1546 		sprintf( buff,"XCallback::outByte, value: %d", aByte);
1547 		MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
1548 		break;
1549 	case 14:
1550 		xCallback->outShort( aShort);
1551 		sprintf( buff,"XCallback::outShort, value: %d", aShort);
1552 		MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
1553 		break;
1554 	case 15:
1555 		xCallback->outLong( aLong);
1556 		sprintf( buff,"XCallback::outLong, value: %d", aLong);
1557 		MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
1558 		break;
1559 	case 18:
1560 	case 19:
1561 	case 30:
1562 		{
1563 
1564 			long outLong= 0;
1565 			xCallback->outValuesMixed( 1111, outLong, OUString( L"in string") );
1566 
1567 			sprintf( buff, "oletest.testInterface: outValue: %d", outLong);
1568 			MessageBox( NULL, A2T(buff), _T("OleTest"), MB_OK);
1569 			break;
1570 		}
1571 
1572 	case 31:
1573 		{
1574 			Reference< XSimple > xSimple;
1575 			SimpleStruct aSimpleStruct;
1576 			SimpleEnum aSimpleEnum;
1577 			Sequence<Any> seqAny;
1578 			Any			aAny;
1579 			sal_Bool	aBool;
1580 			sal_Unicode aChar;
1581 			OUString	aString;
1582 			float		aFloat;
1583 			double		aDouble;
1584 			sal_Int8	aByte;
1585 			sal_Int16	aShort;
1586 			sal_Int32	aLong;
1587 //			sal_uInt16	aUShort;
1588 //			sal_uInt32	aULong;
1589 			xCallback->outValuesAll( xSimple, aSimpleStruct, aSimpleEnum, seqAny, aAny, aBool,
1590 				aChar, aString,
1591 			aFloat, aDouble,
1592 			aByte,
1593 			aShort, aLong);
1594 
1595 			MessageBox( NULL, _T("XCallback::outValuesAll returned"), _T("OleTest::testInterface"), MB_OK);
1596 			break;
1597 		}
1598 	case 32:
1599 		{
1600 
1601 			xCallback->outSeqByte( seqByte);
1602 			sprintf( buff,"XCallback::outSeqAny, length: %d )", seqAny.getLength());
1603 			MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
1604 			for( i=0; i < seqAny.getLength(); i++)
1605 			{
1606 				Any any= seqAny[i];
1607 				if( any.getValueTypeClass() == TypeClass_STRING)
1608 				{
1609 					any >>= aString;
1610 					OutputDebugStringW( aString);
1611 				}
1612 			}
1613 			break;
1614 		}
1615 		// ############################################################################
1616 		// IN OUT parameter
1617 		// ############################################################################
1618 	case 100:
1619 		{
1620 			Reference<XSimple> xSimple= static_cast<XSimple*>(this);
1621 			xCallback->inoutInterface( xSimple);
1622 			xSimple->func(L"XSimple called from OleTest");
1623 			break;
1624 		}
1625 	case 101:
1626 		{
1627 		Reference<XIdlReflection> xRefl( m_rFactory->createInstance(L"com.sun.star.reflection.CoreReflection"), UNO_QUERY);
1628 		if( xRefl.is())
1629 		{
1630 			Reference<XIdlClass> xClass= xRefl->forName(L"oletest.SimpleStruct");
1631 			Any any;
1632 			if( xClass.is())
1633 				xClass->createObject( any);
1634 
1635 			if( any.getValueTypeClass() == TypeClass_STRUCT)
1636 			{
1637 				SimpleStruct* pStruct= ( SimpleStruct*) any.getValue();
1638 				pStruct->message= OUString::createFromAscii("This struct was created in OleTest");
1639 
1640 				SimpleStruct aStruct;
1641 				any >>= aStruct;
1642 				xCallback->inoutStruct( aStruct);
1643 				// a Struct should now contain a different message
1644 				MessageBox( NULL, W2T(aStruct.message), _T("OleTest in out parameter"), MB_OK);
1645 			}
1646 
1647 		}
1648 		break;
1649 		}
1650 	case 102:
1651 		{
1652 		SimpleEnum aEnum= SimpleEnum_B;
1653 		xCallback->inoutEnum( aEnum);
1654 		char buff[1024];
1655 		sprintf( buff, "Enum: %d", aEnum);
1656 		MessageBox( NULL, A2T(buff), _T("OleTest in out parameter"), MB_OK);
1657 		break;
1658 		}
1659 	case 103:
1660 		{
1661 			Any arAny[3];
1662 			arAny[0] <<= OUString( L"string 0");
1663 			arAny[1] <<= OUString( L"string 1");
1664 			arAny[2] <<= OUString( L"string 2");
1665 
1666 			Sequence< Any >seqAny( arAny, 3);
1667 			xCallback->inoutSeqAny( seqAny);
1668 			char buff[1023];
1669 			sprintf( buff, "Sequence length: %d", seqAny.getLength());
1670 			MessageBox( NULL,A2T(buff) , _T("OleTest in out parameter"), MB_OK);
1671 
1672 			for( int i=0; i < seqAny.getLength(); i++)
1673 			{
1674 				Any any;
1675 				any <<= seqAny[i];
1676 				if(any.getValueTypeClass() == TypeClass_STRING)
1677 				{
1678 					OUString str;
1679 					any >>= str;
1680 
1681 				}
1682 			}
1683 
1684 		break;
1685 		}
1686 	case 104:
1687 		{
1688 			Any any;
1689 			OUString s(L" OleTest");
1690 			any <<= s;
1691 			xCallback->inoutAny(any);
1692 			if( any.getValueTypeClass() == TypeClass_STRING)
1693 			{
1694 				OUString s= *( rtl_uString**) any.getValue();
1695 				MessageBox( NULL, W2T( s), _T("OleTest: inout value any"), MB_OK);
1696 			}
1697 		break;
1698 		}
1699 	case 105:
1700 		{
1701 		sal_Bool b= sal_True;
1702 		xCallback->inoutBool( b);
1703 		char buff[1024];
1704 		sprintf( buff, "out value bool: %d", b);
1705 		MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
1706 			break;
1707 		}
1708 	case 106:
1709 		{
1710 			sal_Unicode uc= L'A';
1711 			xCallback->inoutChar( uc);
1712 			char buff[1024];
1713 			sprintf( buff, "out value sal_Unicode: %C", uc);
1714 			MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
1715 			break;
1716 		}
1717 	case 107:
1718 		{
1719 			OUString s(L"OleTest");
1720 			xCallback->inoutString( s);
1721 			char buff[1024];
1722 			sprintf( buff, "out value string: %S", s.getStr());
1723 			MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
1724 			break;
1725 		}
1726 	case 108:
1727 		{
1728 			float f= 3.14f;
1729 			xCallback->inoutFloat(f);
1730 			char buff[1024];
1731 			sprintf( buff, "out value float: %f", f);
1732 			MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
1733 			break;
1734 		}
1735 	case 109:
1736 		{
1737 			double f= 3.145;
1738 			xCallback->inoutDouble( f);
1739 			char buff[1024];
1740 			sprintf( buff, "out value double: %g", f);
1741 			MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
1742 			break;
1743 		}
1744 	case 110:
1745 		{
1746 			sal_Int8 aByte= 0xf;
1747 			xCallback->inoutByte( aByte);
1748 			char buff[1024];
1749 			sprintf( buff, "out value sal_Int8: %d", aByte);
1750 			MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
1751 			break;
1752 		}
1753 	case 111:
1754 		{
1755 			sal_Int16 aShort= 0xff;
1756 			xCallback->inoutShort( aShort);
1757 			char buff[1024];
1758 			sprintf( buff, "out value sal_Int16: %d", aShort);
1759 			MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
1760 			break;
1761 		}
1762 	case 112:
1763 		{
1764 			sal_Int32 aLong= 0xfffe;
1765 			xCallback->inoutLong( aLong);
1766 			char buff[1024];
1767 			sprintf( buff, "out value sal_Int32: %d", aLong);
1768 			MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
1769 			break;
1770 		}
1771 	case 120:
1772 		{
1773 		Reference<XSimple> aXSimple= static_cast<XSimple*>(this);
1774 
1775 		SimpleStruct aStruct;
1776 		Reference<XIdlReflection> xRefl( m_rFactory->createInstance(L"com.sun.star.reflection.CoreReflection"), UNO_QUERY);
1777 		if( xRefl.is())
1778 		{
1779 			Reference<XIdlClass> xClass= xRefl->forName(L"oletest.SimpleStruct");
1780 			Any any;
1781 			if( xClass.is())
1782 				xClass->createObject( any);
1783 
1784 			if( any.getValueTypeClass() == TypeClass_STRUCT)
1785 			{
1786 				SimpleStruct* pStruct= ( SimpleStruct*) any.getValue();
1787 				pStruct->message= OUString::createFromAscii("This struct was created in OleTest");
1788 				any >>= aStruct;
1789 			}
1790 		}
1791 
1792 		SimpleEnum aEnum= SimpleEnum_B;
1793 
1794 		Sequence< Any > aSeq;
1795 		Any arAny[3];
1796 		arAny[0] <<= OUString( L"string 0");
1797 		arAny[1] <<= OUString( L"string 1");
1798 		arAny[2] <<= OUString( L"string 2");
1799 		aSeq = Sequence< Any >( arAny, 3);
1800 
1801 		Any aAny;
1802 		OUString s(L" OleTest");
1803 		aAny <<= s;
1804 
1805 		sal_Bool aBool= sal_True;
1806 		sal_Unicode aChar= L'A';
1807 		OUString aString( L"OleTest");
1808 		float aFloat=3.14f;
1809 		double aDouble= 3.145;
1810 		sal_Int8 aByte= 0xf;
1811 		sal_Int16 aShort= 0xff;
1812 		sal_Int32 aLong= 0xffe;
1813 
1814 		xCallback->inoutValuesAll( aXSimple, aStruct, aEnum, aSeq,
1815 			aAny, aBool, aChar, aString,  aFloat, aDouble,
1816 			aByte, aShort,  aLong );
1817 
1818 		aXSimple->func(L"XSimple called from OleTest");
1819 		MessageBox( NULL, W2T(aStruct.message), _T("OleTest"), MB_OK);
1820 
1821 		for( int i=0; i < aSeq.getLength(); i++)
1822 		{
1823 			Any any;
1824 			any <<= aSeq[i];
1825 			if(any.getValueTypeClass() == TypeClass_STRING)
1826 			{
1827 				OUString str;
1828 				any >>= str;
1829 
1830 			}
1831 		}
1832 		break;
1833 		}
1834 
1835 	// ############################################################################
1836 	// IN parameter
1837 	// ############################################################################
1838 
1839 	case 200:
1840 
1841 		xCallback->inValues( L'a', 0xffffL, OUString(L" a string from OleTest"));
1842 		break;
1843 	case 201:
1844     {
1845         sal_Int8 arbyte[3]= { 1,2,3};
1846         Sequence< sal_Int8 > seq( arbyte, 3);
1847         xCallback->inSeqByte( seq);
1848         break;
1849     }
1850     case 202:
1851     {
1852         const int LISTENERS= 3;
1853         Reference<XEventListener> arListeners[LISTENERS];
1854         EventObject arEvents[LISTENERS];
1855 
1856         for( int i= 0; i < LISTENERS; i++)
1857         {
1858             Reference<XInterface> aList= static_cast<XWeak*>( new EventListener());
1859             arListeners[i]= Reference<XEventListener>( aList, UNO_QUERY);
1860         }
1861 
1862         xCallback->inSeqXEventListener(Sequence<Reference<XEventListener> > (arListeners, LISTENERS),
1863                                        Sequence<EventObject>(arEvents, LISTENERS));
1864         break;
1865     }
1866 
1867 	// ############################################################################
1868 	// Call a COM object that has not been passed as parameter to a UNO component and
1869 	// hence no type information are available in the COM wrapper
1870 	// ############################################################################
1871 	case 300:
1872 		{
1873 			Reference<XInterface> xIntFact = m_rFactory->createInstance(L"com.sun.star.bridge.oleautomation.Factory");
1874 
1875 			Reference<XMultiServiceFactory> oleFact(xIntFact, UNO_QUERY);
1876 
1877 			Reference<XInterface> xIntCallback= oleFact->createInstance(L"XCallback_Impl.Callback");
1878 			Reference<XInvocation> xInv( xIntCallback, UNO_QUERY);
1879 //Any SAL_CALL invoke( const OUString& aFunctionName, const Sequence<Any >& aParams,Sequence< sal_Int16 >& aOutParamIndex,
1880 //			Sequence<Any >& aOutParam );
1881 			Sequence<sal_Int16> seqIndizes;
1882 			Sequence<Any> seqOutParams;
1883 			xInv->invoke( OUString( L"outValuesAll"), Sequence<Any>(), seqIndizes, seqOutParams);
1884 
1885 //			void outValuesAll( [out] oletest::XSimple outInterface,
1886 //					   [out] SimpleStruct outStruct ,
1887 //					   [out] SimpleEnum outEnum,
1888 //					   [out] sequence<any> outSeqAny,
1889 //					   [out] any outAny,
1890 //					   [out] boolean outBool,
1891 //					   [out] char outChar,
1892 //					   [out] string outString,
1893 //					   [out] float outFloat,
1894 //					   [out] double outDouble,
1895 //					   [out] byte	outByte,
1896 //					   [out] short outShort,
1897 //					   [out] long outLong);
1898 			if( seqOutParams.getLength() == 12)
1899 			{
1900 				Reference<XSimple> xSimple= *(XSimple**)seqOutParams[0].getValue();
1901 				xSimple->func( L"Call from OleTest on XSimple");
1902 				SimpleStruct aStruct;
1903 				seqOutParams[1] >>= aStruct;
1904 				SimpleEnum aEnum= *(SimpleEnum*)seqOutParams[2].getValue();
1905 
1906 				Sequence<Any> seqAny;
1907 				seqOutParams[3] >>= seqAny;
1908 				for( int i=0; i<seqAny.getLength(); i++)
1909 				{
1910 					OUString _s;
1911 					seqAny[i] >>= _s;
1912 				}
1913 
1914 				Any _any= *(Any*)seqOutParams[4].getValue();
1915 				sal_Bool _bool= *(sal_Bool*)seqOutParams[5].getValue();
1916 				sal_Unicode _char= *( sal_Unicode*) seqOutParams[6].getValue();
1917 				OUString _str= *( rtl_uString**)seqOutParams[7].getValue();
1918 
1919 				float _f= *( float*)seqOutParams[8].getValue();
1920 				double _d= *( double*) seqOutParams[9].getValue();
1921 				sal_Int8 _byte= *( sal_Int8*) seqOutParams[10].getValue();
1922 				sal_Int16 _short= *( sal_Int16*) seqOutParams[11].getValue();
1923 
1924 				sal_Int32 _long= *( sal_Int32*) seqOutParams[12].getValue();
1925 
1926 			}
1927 			break;
1928 		}
1929 	case 301:
1930 		// in / out parameter
1931 		{
1932 			Reference<XInterface> xIntFact = m_rFactory->createInstance(L"com.sun.star.bridge.oleautomation.Factory");
1933 
1934 			Reference<XMultiServiceFactory> oleFact(xIntFact, UNO_QUERY);
1935 
1936 			Reference<XInterface> xIntCallback= oleFact->createInstance(L"XCallback_Impl.Callback");
1937 			Reference<XInvocation> xInv( xIntCallback, UNO_QUERY);
1938 			Sequence<sal_Int16> seqIndizes;
1939 			Sequence<Any> seqOutParams;
1940 
1941 
1942 			Any arAny[13];
1943 			Reference<XSimple> xSimple= static_cast<XSimple*>( this);
1944 
1945 			arAny[0] <<=  xSimple;
1946 			SimpleStruct aStruct;
1947 			Reference<XIdlReflection> xRefl( m_rFactory->createInstance(L"com.sun.star.reflection.CoreReflection"), UNO_QUERY);
1948 			if( xRefl.is())
1949 			{
1950 				Reference<XIdlClass> xClass= xRefl->forName(L"oletest.SimpleStruct");
1951 				Any any;
1952 				if( xClass.is())
1953 					xClass->createObject( any);
1954 
1955 				if( any.getValueTypeClass() == TypeClass_STRUCT)
1956 				{
1957 					SimpleStruct* pStruct= ( SimpleStruct*) any.getValue();
1958 					pStruct->message= OUString::createFromAscii("This struct was created in OleTest");
1959 					any >>= aStruct;
1960 				}
1961 			}
1962 			arAny[1] <<= aStruct;
1963 			arAny[2] <<= SimpleEnum_C;
1964 
1965 			Any arSeqAny[3];
1966 			arSeqAny[0] <<= OUString( L"string 0");
1967 			arSeqAny[1] <<= OUString( L"string 1");
1968 			arSeqAny[2] <<= OUString( L"string 2");
1969 
1970 			arAny[3] <<=  Sequence< Any >( arAny, 3);
1971 
1972 			OUString str(L" Ein Any param");
1973 			arAny[4] <<= str;
1974 			arAny[5] <<= sal_False;
1975 			arAny[6] <<= L'B';
1976 			OUString stringParam(L" a string parameter");
1977 			arAny[7] <<= stringParam;
1978 			float _float= 3.14f;
1979 			arAny[8] <<= _float;
1980 			double _double= 3.145;
1981 			arAny[9] <<= _double;
1982 			sal_Int8 _byte= -1;
1983 			arAny[10] <<= _byte;
1984 			sal_Int16 _short= -1;
1985 			arAny[11] <<= _short;
1986 			sal_Int32 _long= -1;
1987 			arAny[12] <<= _long;
1988 //
1989 			Sequence<Any> params( arAny, 13);
1990 
1991 			xInv->invoke( OUString( L"inoutValuesAll"), params, seqIndizes, seqOutParams);
1992 
1993 			if( seqOutParams.getLength() == 12)
1994 			{
1995 				Reference<XSimple> xSimple= *(XSimple**)seqOutParams[0].getValue();
1996 				xSimple->func( L"Call from OleTest on XSimple");
1997 				SimpleStruct aStruct;
1998 				seqOutParams[1] >>= aStruct;
1999 				SimpleEnum aEnum= *(SimpleEnum*)seqOutParams[2].getValue();
2000 
2001 				Sequence<Any> seqAny;
2002 				seqOutParams[3] >>= seqAny;
2003 				for( int i=0; i<seqAny.getLength(); i++)
2004 				{
2005 					OUString _s;
2006 					seqAny[i] >>= _s;
2007 				}
2008 
2009 				Any _any= *(Any*)seqOutParams[4].getValue();
2010 				sal_Bool _bool= *(sal_Bool*)seqOutParams[5].getValue();
2011 				sal_Unicode _char= *( sal_Unicode*) seqOutParams[6].getValue();
2012 				OUString _str= *( rtl_uString**)seqOutParams[7].getValue();
2013 
2014 				float _f= *( float*)seqOutParams[8].getValue();
2015 				double _d= *( double*) seqOutParams[9].getValue();
2016 				sal_Int8 _byte= *( sal_Int8*) seqOutParams[10].getValue();
2017 				sal_Int16 _short= *( sal_Int16*) seqOutParams[11].getValue();
2018 
2019 				sal_Int32 _long= *( sal_Int32*) seqOutParams[12].getValue();
2020 
2021 			}
2022 			break;
2023 		}
2024 	case 303:
2025 		// in parameter
2026 //	void inValues( [in] char aChar, [in] long aLong, [in] string aString);
2027 		{
2028 			Reference<XInterface> xIntFact = m_rFactory->createInstance(
2029 				L"com.sun.star.bridge.oleautomation.Factory");
2030 
2031 			Reference<XMultiServiceFactory> oleFact(xIntFact, UNO_QUERY);
2032 
2033 			Reference<XInterface> xIntCallback= oleFact->createInstance(L"XCallback_Impl.Callback");
2034 			Reference<XInvocation> xInv( xIntCallback, UNO_QUERY);
2035 			Sequence<sal_Int16> seqIndizes;
2036 			Sequence<Any> seqOutParams;
2037 
2038 			Any arAny[3];
2039 			sal_Unicode aChar=L'a';
2040 			arAny[0] <<= aChar;
2041 			sal_Int32 aLong= 0xffffffff;
2042 			arAny[1] <<= aLong;
2043 			OUString aString(L" a string parameter");
2044 			arAny[2] <<= aString;
2045 
2046 			xInv->invoke( OUString( L"inValues"), Sequence<Any>(arAny,3), seqIndizes, seqOutParams);
2047 
2048 			break;
2049 		}
2050 	// ############################################################################
2051 	// Attributes
2052 	// ############################################################################
2053 
2054 	case 400:
2055 		Reference<XSimple> simple=	xCallback->getsimple();
2056 		simple->func(L"OleTest calls on XSimple");
2057 		break;
2058 
2059 
2060 
2061 
2062 	}
2063 
2064 }
2065 
setObject(const Reference<XInterface> & val)2066 void SAL_CALL OComponent::setObject( const Reference< XInterface >& val ) throw (RuntimeException)
2067 {
2068     m_xIntIdentity= val;
2069 }
2070 
isSame(const Reference<XInterface> & val)2071 sal_Bool SAL_CALL OComponent::isSame( const Reference< XInterface >& val ) throw (RuntimeException)
2072 {
2073     if( m_xIntIdentity == val)
2074         return sal_True;
2075     else
2076         return sal_False;
2077 }
2078 
getThis()2079 Reference< XInterface > SAL_CALL OComponent::getThis(  ) throw (RuntimeException)
2080 {
2081 //    return Reference<XInterface>(static_cast<XIdentity*>(this), UNO_QUERY);
2082 	Reference<XInterface> ret(static_cast<XIdentity*>(this), UNO_QUERY);
2083 	return ret;
2084 }
2085 
disposing(const::com::sun::star::lang::EventObject &)2086 void SAL_CALL EventListener::disposing( const ::com::sun::star::lang::EventObject& ) throw (RuntimeException)
2087 {
2088     bCalled= sal_True;
2089 }
2090 
2091 // XSimple --------------------------------------------------------------------------
func(const OUString & message)2092 void SAL_CALL OComponent::func( const OUString &message)throw(::com::sun::star::uno::RuntimeException)
2093 {
2094 	USES_CONVERSION;
2095 
2096 	MessageBox( NULL, W2T( message.getStr()), _T("OleTest: XSimple::func"), MB_OK);
2097 }
2098 // XSimple --------------------------------------------------------------------------
getName()2099 OUString SAL_CALL OComponent::getName()throw(::com::sun::star::uno::RuntimeException)
2100 {
2101 	return L"XSimple";
2102 }
testInterface2(const Reference<XSimple> & xSimple,sal_Int32 mode)2103 void SAL_CALL OComponent::testInterface2(  const Reference< XSimple >& xSimple, sal_Int32 mode ) throw(RuntimeException)
2104 {
2105 	switch( mode)
2106 	{
2107 	case 0:
2108 		{
2109 		xSimple->func( L"OleTest is calling XSimple");
2110 		Reference<XSimple2> xSimple2( xSimple, UNO_QUERY);
2111 		if( xSimple2.is())
2112 			xSimple2->func2( L"OleTest is calling XSimple2");
2113 		Reference<XSimple3> xSimple3( xSimple, UNO_QUERY);
2114 		if( xSimple3.is())
2115 			xSimple3->func3( L"OleTest is calling XSimple3");
2116 
2117 		break;
2118 		}
2119 	}
2120 }
2121