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: 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: 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 346 OComponent::~OComponent() 347 { 348 } 349 350 351 // Funktions ============================================================================== 352 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 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 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 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 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 ============================================================================ 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 } 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 } 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 } 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 } 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 } 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 } 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 } 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 } 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 } 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 } 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 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) 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 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 } 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 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 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 600 Sequence< sal_Int8 > SAL_CALL OComponent::getAttrByte(void) throw( RuntimeException) 601 { 602 return m_seqByte; 603 } 604 void SAL_CALL OComponent::setAttrByte(const Sequence< sal_Int8 >& AttrByte_) throw( RuntimeException ) 605 { 606 m_seqByte= AttrByte_; 607 } 608 Sequence< float > SAL_CALL OComponent::getAttrFloat(void) throw( RuntimeException ) 609 { 610 return m_seqFloat; 611 } 612 void SAL_CALL OComponent::setAttrFloat(const Sequence< float >& AttrFloat_) throw( RuntimeException ) 613 { 614 m_seqFloat= AttrFloat_; 615 } 616 617 Sequence< double > SAL_CALL OComponent::getAttrDouble(void) throw( RuntimeException ) 618 { 619 return m_seqDouble; 620 } 621 void SAL_CALL OComponent::setAttrDouble(const Sequence< double >& AttrDouble_) throw( RuntimeException ) 622 { 623 m_seqDouble= AttrDouble_; 624 } 625 626 Sequence< sal_Bool > SAL_CALL OComponent::getAttrBool(void) throw( RuntimeException) 627 { 628 return m_seqBool; 629 } 630 631 void SAL_CALL OComponent::setAttrBool(const Sequence< sal_Bool >& AttrBool_) throw (RuntimeException ) 632 { 633 m_seqBool= AttrBool_; 634 } 635 636 Sequence< sal_Int16 > SAL_CALL OComponent::getAttrShort(void) throw( RuntimeException) 637 { 638 return m_seqShort; 639 } 640 void SAL_CALL OComponent::setAttrShort(const Sequence< sal_Int16 >& AttrShort_) throw( RuntimeException ) 641 { 642 m_seqShort= AttrShort_; 643 } 644 645 Sequence< sal_uInt16 > SAL_CALL OComponent::getAttrUShort(void) throw( RuntimeException ) 646 { 647 return m_seqUShort; 648 } 649 void SAL_CALL OComponent::setAttrUShort(const Sequence< sal_uInt16 >& AttrUShort_) throw( RuntimeException ) 650 { 651 m_seqUShort= AttrUShort_; 652 } 653 654 Sequence< sal_Int32 > SAL_CALL OComponent::getAttrLong(void) throw( RuntimeException) 655 { 656 return m_seqLong; 657 } 658 void SAL_CALL OComponent::setAttrLong(const Sequence< sal_Int32 >& AttrLong_) throw( RuntimeException ) 659 { 660 m_seqLong= AttrLong_; 661 } 662 663 Sequence< sal_uInt32 > SAL_CALL OComponent::getAttrULong(void) throw( RuntimeException ) 664 { 665 return m_seqULong; 666 } 667 void SAL_CALL OComponent::setAttrULong(const Sequence< sal_uInt32 >& AttrULong_) throw( RuntimeException ) 668 { 669 m_seqULong= AttrULong_; 670 } 671 672 Sequence< OUString > SAL_CALL OComponent::getAttrString(void) throw( RuntimeException ) 673 { 674 return m_seqString; 675 } 676 void SAL_CALL OComponent::setAttrString(const Sequence< OUString >& AttrString_) throw( RuntimeException ) 677 { 678 m_seqString= AttrString_; 679 } 680 681 Sequence< sal_Unicode > SAL_CALL OComponent::getAttrChar(void) throw( RuntimeException ) 682 { 683 return m_seqChar; 684 } 685 void SAL_CALL OComponent::setAttrChar(const Sequence< sal_Unicode >& AttrChar_) throw( RuntimeException) 686 { 687 m_seqChar= AttrChar_; 688 } 689 690 Sequence< Any > SAL_CALL OComponent::getAttrAny(void) throw( RuntimeException) 691 { 692 return m_seqAny; 693 } 694 void SAL_CALL OComponent::setAttrAny(const Sequence< Any >& AttrAny_) throw( RuntimeException ) 695 { 696 m_seqAny= AttrAny_; 697 } 698 699 Sequence< Type > SAL_CALL OComponent::getAttrType(void) throw( RuntimeException ) 700 { 701 return m_seqType; 702 } 703 704 void SAL_CALL OComponent::setAttrType( const Sequence< Type >& AttrType_) throw( RuntimeException ) 705 { 706 m_seqType = AttrType_; 707 } 708 709 710 Sequence< Sequence< sal_Int32 > > SAL_CALL OComponent::getAttrSequence(void) throw( RuntimeException) 711 { 712 return m_seq1; 713 } 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 730 Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL OComponent::getAttrSequence2(void) throw( RuntimeException ) 731 { 732 return m_seq2; 733 } 734 void SAL_CALL OComponent::setAttrSequence2(const Sequence< Sequence< Sequence< sal_Int32 > > >& AttrSequence2_) 735 throw( RuntimeException ) 736 { 737 m_seq2= AttrSequence2_; 738 } 739 740 Sequence< Reference< XInterface > > SAL_CALL OComponent::getAttrXInterface() throw(RuntimeException) 741 { 742 return m_seqxInterface; 743 } 744 void SAL_CALL OComponent::setAttrXInterface( const Sequence< Reference< XInterface > >& _attrxinterface ) throw(RuntimeException) 745 { 746 m_seqxInterface= _attrxinterface; 747 } 748 749 // ---------------------------------------------------------------------------- 750 751 ::sal_Int8 SAL_CALL OComponent::getAByte() throw (RuntimeException) 752 { 753 return m_attr_int8; 754 } 755 756 void SAL_CALL OComponent::setAByte( ::sal_Int8 _abyte ) throw (RuntimeException) 757 { 758 m_attr_int8 = _abyte; 759 } 760 761 float SAL_CALL OComponent::getAFloat() throw (RuntimeException) 762 { 763 return m_attr_float; 764 } 765 766 void SAL_CALL OComponent::setAFloat( float _afloat ) throw (RuntimeException) 767 { 768 m_attr_float = _afloat; 769 } 770 771 double SAL_CALL OComponent::getADouble() throw (RuntimeException) 772 { 773 return m_attr_double; 774 } 775 776 void SAL_CALL OComponent::setADouble( double _adouble ) throw (RuntimeException) 777 { 778 m_attr_double = _adouble; 779 } 780 781 ::sal_Bool SAL_CALL OComponent::getABool() throw (RuntimeException) 782 { 783 return m_attr_bool; 784 } 785 786 void SAL_CALL OComponent::setABool( ::sal_Bool _abool ) throw (RuntimeException) 787 { 788 m_attr_bool = _abool; 789 } 790 791 ::sal_Int16 SAL_CALL OComponent::getAShort() throw (RuntimeException) 792 { 793 return m_attr_int16; 794 } 795 796 void SAL_CALL OComponent::setAShort( ::sal_Int16 _ashort ) throw (RuntimeException) 797 { 798 m_attr_int16 = _ashort; 799 } 800 801 ::sal_uInt16 SAL_CALL OComponent::getAUShort() throw (RuntimeException) 802 { 803 return m_attr_uint16; 804 } 805 806 void SAL_CALL OComponent::setAUShort( ::sal_uInt16 _aushort ) throw (RuntimeException) 807 { 808 m_attr_uint16 = _aushort; 809 } 810 811 ::sal_Int32 SAL_CALL OComponent::getALong() throw (RuntimeException) 812 { 813 return m_attr_int32; 814 } 815 816 void SAL_CALL OComponent::setALong( ::sal_Int32 _along ) throw (RuntimeException) 817 { 818 m_attr_int32 = _along; 819 } 820 821 ::sal_uInt32 SAL_CALL OComponent::getAULong() throw (RuntimeException) 822 { 823 return m_attr_uint32;; 824 } 825 826 void SAL_CALL OComponent::setAULong( ::sal_uInt32 _aulong ) throw (RuntimeException) 827 { 828 m_attr_uint32 = _aulong; 829 } 830 831 ::rtl::OUString SAL_CALL OComponent::getAString() throw (RuntimeException) 832 { 833 return m_attr_string; 834 } 835 836 void SAL_CALL OComponent::setAString( const ::rtl::OUString& _astring ) throw (RuntimeException) 837 { 838 m_attr_string = _astring; 839 } 840 841 ::sal_Unicode SAL_CALL OComponent::getAChar() throw (RuntimeException) 842 { 843 return m_attr_char; 844 } 845 846 void SAL_CALL OComponent::setAChar( ::sal_Unicode _achar ) throw (RuntimeException) 847 { 848 m_attr_char = _achar; 849 } 850 851 Any SAL_CALL OComponent::getAAny() throw (RuntimeException) 852 { 853 return m_attr_any; 854 } 855 856 void SAL_CALL OComponent::setAAny( const Any& _aany ) throw (RuntimeException) 857 { 858 m_attr_any = _aany; 859 } 860 861 Type SAL_CALL OComponent::getAType() throw (RuntimeException) 862 { 863 return m_attr_type; 864 } 865 866 void SAL_CALL OComponent::setAType( const Type& _atype ) throw (RuntimeException) 867 { 868 m_attr_type = _atype; 869 } 870 871 Reference< XInterface > SAL_CALL OComponent::getAXInterface() throw (RuntimeException) 872 { 873 return m_attr_xinterface; 874 } 875 876 void SAL_CALL OComponent::setAXInterface( const Reference<XInterface >& _axinterface ) throw (RuntimeException) 877 { 878 m_attr_xinterface = _axinterface; 879 } 880 881 Reference<XInvocation > SAL_CALL OComponent::getAXInvocation() throw (RuntimeException) 882 { 883 return m_attr_xinvocation; 884 } 885 886 void SAL_CALL OComponent::setAXInvocation( const Reference< XInvocation >& _axinvocation ) throw (RuntimeException) 887 { 888 m_attr_xinvocation = _axinvocation; 889 } 890 //----------------------------------------------------------------------------------- 891 void SAL_CALL OComponent::testout_methodByte(sal_Int8& rOut) throw( RuntimeException ) 892 { 893 rOut= m_int8; 894 } 895 void SAL_CALL OComponent::testout_methodFloat(float& rOut) throw( RuntimeException ) 896 { 897 rOut= m_float; 898 } 899 void SAL_CALL OComponent::testout_methodDouble(double& rOut) throw( RuntimeException ) 900 { 901 rOut= m_double; 902 } 903 904 void SAL_CALL OComponent::testout_methodBool(sal_Bool& rOut) throw( RuntimeException ) 905 { 906 rOut= m_bool; 907 } 908 void SAL_CALL OComponent::testout_methodShort(sal_Int16& rOut) throw( RuntimeException ) 909 { 910 rOut= m_int16; 911 } 912 void SAL_CALL OComponent::testout_methodUShort(sal_uInt16& rOut) throw( RuntimeException ) 913 { 914 rOut= m_uint16; 915 } 916 void SAL_CALL OComponent::testout_methodLong(sal_Int32& rOut) throw( RuntimeException ) 917 { 918 rOut = m_int32; 919 } 920 void SAL_CALL OComponent::testout_methodULong(sal_uInt32& rOut) throw( RuntimeException ) 921 { 922 rOut= m_uint32; 923 } 924 void SAL_CALL OComponent::testout_methodHyper(sal_Int64& rOut) throw( RuntimeException ) 925 { 926 rOut = m_int64; 927 } 928 929 void SAL_CALL OComponent::testout_methodUHyper(sal_uInt64& rOut) throw( RuntimeException ) 930 { 931 rOut = m_uint64; 932 } 933 934 void SAL_CALL OComponent::testout_methodString(OUString& rOut) throw( RuntimeException ) 935 { 936 rOut= m_string; 937 } 938 void SAL_CALL OComponent::testout_methodChar(sal_Unicode& rOut) throw( RuntimeException ) 939 { 940 rOut= m_char; 941 } 942 void SAL_CALL OComponent::testout_methodAny(Any& rOut) throw( RuntimeException) 943 { 944 rOut = m_any; 945 } 946 947 void SAL_CALL OComponent::testout_methodType(Type& rOut) throw( RuntimeException ) 948 { 949 rOut = m_type; 950 } 951 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 } 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 } 968 void SAL_CALL OComponent::testout_methodMulParams1(sal_Int32& rout1, sal_Int32& rout2) throw( RuntimeException ) 969 { 970 rout1= 999; 971 rout2= 1111; 972 } 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 } 979 void SAL_CALL OComponent::testout_methodMulParams3(const OUString&, OUString& sout) throw( RuntimeException ) 980 { 981 sout= L"Out Hallo!"; 982 } 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 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 ------------------------------------------------------------ 998 sal_Int8 SAL_CALL OComponent::in_methodByte( sal_Int8 rIn ) throw (RuntimeException) 999 { 1000 m_int8 = rIn; 1001 return rIn; 1002 } 1003 float SAL_CALL OComponent::in_methodFloat( float rIn ) throw (RuntimeException) 1004 { 1005 m_float = rIn; 1006 return rIn; 1007 } 1008 double SAL_CALL OComponent::in_methodDouble( double rIn ) throw (RuntimeException) 1009 { 1010 m_double = rIn; 1011 return rIn; 1012 } 1013 sal_Bool SAL_CALL OComponent::in_methodBool( sal_Bool rIn ) throw (RuntimeException) 1014 { 1015 m_bool = rIn; 1016 return rIn; 1017 } 1018 sal_Int16 SAL_CALL OComponent::in_methodShort( sal_Int16 rIn ) throw (RuntimeException) 1019 { 1020 m_int16 = rIn; 1021 return rIn; 1022 } 1023 sal_uInt16 SAL_CALL OComponent::in_methodUShort( sal_uInt16 rIn ) throw (RuntimeException) 1024 { 1025 m_uint16 = rIn; 1026 return rIn; 1027 } 1028 sal_Int32 SAL_CALL OComponent::in_methodLong( sal_Int32 rIn ) throw (RuntimeException) 1029 { 1030 m_int32 = rIn; 1031 return rIn; 1032 } 1033 sal_uInt32 SAL_CALL OComponent::in_methodULong( sal_uInt32 rIn ) throw (RuntimeException) 1034 { 1035 m_uint32 = rIn; 1036 return rIn; 1037 } 1038 sal_Int64 SAL_CALL OComponent::in_methodHyper( sal_Int64 rIn ) throw (RuntimeException) 1039 { 1040 m_int64 = rIn; 1041 return rIn; 1042 } 1043 1044 sal_uInt64 SAL_CALL OComponent::in_methodUHyper( sal_uInt64 rIn ) throw (RuntimeException) 1045 { 1046 m_uint64 = rIn; 1047 return rIn; 1048 } 1049 1050 OUString SAL_CALL OComponent::in_methodString( const OUString& rIn ) throw (RuntimeException) 1051 { 1052 m_string = rIn; 1053 return rIn; 1054 } 1055 sal_Unicode SAL_CALL OComponent::in_methodChar( sal_Unicode rIn ) throw (RuntimeException) 1056 { 1057 m_char = rIn; 1058 return rIn; 1059 } 1060 Any SAL_CALL OComponent::in_methodAny( const Any& rIn ) throw (RuntimeException) 1061 { 1062 m_any = rIn; 1063 return rIn; 1064 } 1065 1066 Type SAL_CALL OComponent::in_methodType( const Type& rIn ) throw (RuntimeException) 1067 { 1068 m_type = rIn; 1069 return rIn; 1070 } 1071 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 } 1095 Reference<XInterface> SAL_CALL OComponent::in_methodXInterface( const Reference<XInterface >& rIn ) throw (RuntimeException) 1096 { 1097 m_xinterface = rIn; 1098 return rIn; 1099 } 1100 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 } 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 ----------------------------------------------------------------------------------- 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 } 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 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 } 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 } 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 } 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 } 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 } 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 } 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 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 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 } 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 } 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 } 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 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 } 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" 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 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 } 1261 Any SAL_CALL OComponent::methodAnyTest1(const Any& rIn) throw( RuntimeException ) 1262 { 1263 return rIn; 1264 } 1265 Any SAL_CALL OComponent::getAttrAny2(void) throw( RuntimeException ) 1266 { 1267 return m_any; 1268 } 1269 void SAL_CALL OComponent::setAttrAny2(const Any& AttrAny2_) throw( RuntimeException ) 1270 { 1271 m_any= AttrAny2_; 1272 } 1273 1274 1275 1276 // XTestStruct ======================================================================================= 1277 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 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 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 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 1315 Property SAL_CALL OComponent::methodStruct2( const Property& aProp ) throw (RuntimeException) 1316 { 1317 return aProp; 1318 } 1319 1320 // XTestOther ================================================================================== 1321 void SAL_CALL OComponent::other_methodAnyIn(const Any& ) throw( RuntimeException ) 1322 { 1323 } 1324 void SAL_CALL OComponent::other_methodAnyOut(Any& rAny) throw( RuntimeException ) 1325 { 1326 rAny <<= OUString(L"Ein Any"); 1327 } 1328 1329 Any SAL_CALL OComponent::other_methodAnyRet(void) throw(RuntimeException ) 1330 { 1331 Any a; 1332 a <<= OUString(L"Ein Any"); 1333 return a; 1334 } 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 } 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 ------------------------------------------------------------------------------------- 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 2066 void SAL_CALL OComponent::setObject( const Reference< XInterface >& val ) throw (RuntimeException) 2067 { 2068 m_xIntIdentity= val; 2069 } 2070 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 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 2086 void SAL_CALL EventListener::disposing( const ::com::sun::star::lang::EventObject& ) throw (RuntimeException) 2087 { 2088 bCalled= sal_True; 2089 } 2090 2091 // XSimple -------------------------------------------------------------------------- 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 -------------------------------------------------------------------------- 2099 OUString SAL_CALL OComponent::getName()throw(::com::sun::star::uno::RuntimeException) 2100 { 2101 return L"XSimple"; 2102 } 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