summaryrefslogtreecommitdiffstats
path: root/extensions/test/ole/cpnt/cpnt.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'extensions/test/ole/cpnt/cpnt.cxx')
-rw-r--r--extensions/test/ole/cpnt/cpnt.cxx1955
1 files changed, 1955 insertions, 0 deletions
diff --git a/extensions/test/ole/cpnt/cpnt.cxx b/extensions/test/ole/cpnt/cpnt.cxx
new file mode 100644
index 000000000..3369e03d6
--- /dev/null
+++ b/extensions/test/ole/cpnt/cpnt.cxx
@@ -0,0 +1,1955 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#if !defined WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <atlbase.h>
+#include <stdio.h>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/registry/XRegistryKey.hpp>
+#include <tools/diagnose_ex.h>
+#include <uno/environment.h>
+#include <comphelper/processfactory.hxx>
+#include <cppuhelper/factory.hxx>
+// OPTIONAL is a constant in com.sun.star.beans.PropertyAttributes but it must be
+// undef'd in some header files
+#define OPTIONAL OPTIONAL
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/script/XInvocation.hpp>
+#include <com/sun/star/reflection/theCoreReflection.hpp>
+#include <com/sun/star/reflection/XIdlReflection.hpp>
+#include <com/sun/star/lang/XEventListener.hpp>
+
+#include <cppuhelper/implbase.hxx>
+#include <com/sun/star/uno/Reference.h>
+#include <rtl/ustring.h>
+#include <com/sun/star/uno/Reference.hxx>
+#include <oletest/XTestSequence.hpp>
+#include <oletest/XTestStruct.hpp>
+#include <oletest/XTestOther.hpp>
+#include <oletest/XTestInterfaces.hpp>
+#include <oletest/XSimple.hpp>
+#include <oletest/XSimple2.hpp>
+#include <oletest/XSimple3.hpp>
+#include <oletest/XTestInParameters.hpp>
+#include <oletest/XIdentity.hpp>
+#include <com/sun/star/beans/Property.hpp>
+using namespace cppu;
+using namespace osl;
+using namespace oletest;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::beans;
+using namespace com::sun::star::registry;
+using namespace com::sun::star::script;
+using namespace com::sun::star::reflection;
+
+
+#define IMPL_NAME L"oletest.OleTestImpl" // oletest.OleTestImpl in applicat.rdb
+#define SERVICE_NAME L"oletest.OleTest"
+#define KEY1 L"/oletest.OleTestImpl/UNO/SERVICES"
+#define KEY2 L"oletest.OleTest"
+
+class OComponent : public WeakImplHelper<
+ XTestSequence, XTestStruct, XTestOther, XTestInterfaces,
+ XSimple, XTestInParameters, XIdentity >
+{
+ Reference<XInterface> m_xIntIdentity;
+ sal_Int32 m_arrayConstructor;
+ Reference<XMultiServiceFactory> m_rFactory;
+
+ Sequence<sal_Int8> m_seqByte;
+ Sequence<float> m_seqFloat;
+ Sequence<double> m_seqDouble;
+ Sequence<sal_Bool> m_seqBool;
+ Sequence<sal_Int16> m_seqShort;
+ Sequence<sal_uInt16> m_seqUShort;
+ Sequence<sal_Int32> m_seqLong;
+ Sequence<sal_uInt32> m_seqULong;
+ Sequence<sal_Unicode> m_seqChar;
+ Sequence<OUString> m_seqString;
+ Sequence<Any> m_seqAny;
+ Sequence<Type> m_seqType;
+ Sequence<Sequence< sal_Int32> > m_seq1;
+ Sequence<Sequence< Sequence< sal_Int32> > > m_seq2;
+ Any m_any;
+ Type m_type;
+ Sequence<Reference< XInterface > > m_seqxInterface;
+
+ sal_Int8 m_int8;
+ sal_uInt8 m_uint8;
+ sal_Int16 m_int16;
+ sal_uInt16 m_uint16;
+ sal_Int32 m_int32;
+ sal_uInt32 m_uint32;
+ sal_Int64 m_int64;
+ sal_uInt64 m_uint64;
+ float m_float;
+ double m_double;
+ OUString m_string;
+ sal_Unicode m_char;
+ sal_Bool m_bool;
+ Reference<XInterface> m_xinterface;
+
+ sal_Int8 m_attr_int8;
+ sal_uInt8 m_attr_uint8;
+ sal_Int16 m_attr_int16;
+ sal_uInt16 m_attr_uint16;
+ sal_Int32 m_attr_int32;
+ sal_uInt32 m_attr_uint32;
+ sal_Int64 m_attr_int64;
+ sal_uInt64 m_attr_uint64;
+ float m_attr_float;
+ double m_attr_double;
+ OUString m_attr_string;
+ sal_Unicode m_attr_char;
+ sal_Bool m_attr_bool;
+ Any m_attr_any;
+ Type m_attr_type;
+ Reference<XInterface> m_attr_xinterface;
+ Reference<XInvocation> m_attr_xinvocation;
+
+public:
+ OComponent( const Reference<XMultiServiceFactory> & rFactory ) :
+ m_rFactory( rFactory ), m_arrayConstructor(0) {}
+ ~OComponent();
+public: // XTestSequence
+ virtual Sequence<sal_Int8> SAL_CALL methodByte(const Sequence< sal_Int8 >& aSeq) throw( RuntimeException );
+ virtual Sequence<float> SAL_CALL methodFloat(const Sequence< float >& aSeq) throw( RuntimeException );
+ virtual Sequence< double > SAL_CALL methodDouble(const Sequence< double >& aSeq) throw( RuntimeException);
+ virtual Sequence< sal_Bool > SAL_CALL methodBool(const Sequence< sal_Bool >& aSeq) throw( RuntimeException );
+ virtual Sequence< sal_Int16 > SAL_CALL methodShort(const Sequence< sal_Int16 >& aSeq) throw( RuntimeException );
+ virtual Sequence< sal_uInt16 > SAL_CALL methodUShort(const Sequence< sal_uInt16 >& aSeq) throw( RuntimeException );
+ virtual Sequence< sal_Int32 > SAL_CALL methodLong(const Sequence< sal_Int32 >& aSeq) throw( RuntimeException) ;
+ virtual Sequence< sal_uInt32 > SAL_CALL methodULong(const Sequence< sal_uInt32 >& aSeq) throw( RuntimeException );
+ virtual Sequence< OUString > SAL_CALL methodString(const Sequence< OUString >& aSeq) throw( RuntimeException );
+ virtual Sequence< sal_Unicode > SAL_CALL methodChar(const Sequence< sal_Unicode >& aSeq) throw( RuntimeException );
+ virtual Sequence< Any > SAL_CALL methodAny(const Sequence< Any >& aSeq) throw( RuntimeException );
+ virtual Sequence< Type > SAL_CALL methodType(const Sequence< Type >& aSeq) throw( RuntimeException );
+ virtual Sequence< Reference< XInterface > > SAL_CALL methodXInterface( const Sequence< Reference< XInterface > >& aSeq ) throw(RuntimeException) ;
+ virtual Sequence< Sequence< sal_Int32 > > SAL_CALL methodSequence(const Sequence< Sequence< sal_Int32 > >& aSeq) throw( RuntimeException );
+ virtual Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL methodSequence2(const Sequence< Sequence< Sequence< sal_Int32 > > >& aSeq) throw( RuntimeException );
+ virtual Sequence< Reference<XEventListener> > SAL_CALL methodXEventListeners( const Sequence<Reference<XEventListener> >& aSeq) throw( RuntimeException);
+ virtual Sequence< Sequence<Reference<XEventListener > > > SAL_CALL methodXEventListenersMul( const Sequence<Sequence<Reference<XEventListener > > >& aSeq ) throw (RuntimeException);
+
+ virtual Sequence< sal_Int8 > SAL_CALL getAttrByte() throw( RuntimeException );
+ virtual void SAL_CALL setAttrByte(const Sequence< sal_Int8 >& AttrByte_) throw( RuntimeException );
+ virtual Sequence< float > SAL_CALL getAttrFloat() throw( RuntimeException) ;
+ virtual void SAL_CALL setAttrFloat(const Sequence< float >& AttrFloat_) throw( RuntimeException );
+ virtual Sequence< double > SAL_CALL getAttrDouble() throw( RuntimeException) ;
+ virtual void SAL_CALL setAttrDouble(const Sequence< double >& AttrDouble_) throw( RuntimeException );
+ virtual Sequence< sal_Bool > SAL_CALL getAttrBool() throw( RuntimeException );
+ virtual void SAL_CALL setAttrBool(const Sequence< sal_Bool >& AttrBool_) throw( RuntimeException );
+ virtual Sequence< sal_Int16 > SAL_CALL getAttrShort() throw( RuntimeException );
+ virtual void SAL_CALL setAttrShort(const Sequence< sal_Int16 >& AttrShort_) throw( RuntimeException );
+ virtual Sequence< sal_uInt16 > SAL_CALL getAttrUShort() throw( RuntimeException );
+ virtual void SAL_CALL setAttrUShort(const Sequence< sal_uInt16 >& AttrUShort_) throw( RuntimeException );
+ virtual Sequence< sal_Int32 > SAL_CALL getAttrLong() throw( RuntimeException );
+ virtual void SAL_CALL setAttrLong(const Sequence< sal_Int32 >& AttrLong_) throw( RuntimeException );
+ virtual Sequence< sal_uInt32 > SAL_CALL getAttrULong() throw( RuntimeException );
+ virtual void SAL_CALL setAttrULong(const Sequence< sal_uInt32 >& AttrULong_) throw( RuntimeException );
+ virtual Sequence< OUString > SAL_CALL getAttrString() throw(RuntimeException );
+ virtual void SAL_CALL setAttrString(const Sequence< OUString >& AttrString_) throw( RuntimeException );
+ virtual Sequence< sal_Unicode > SAL_CALL getAttrChar() throw( RuntimeException );
+ virtual void SAL_CALL setAttrChar(const Sequence< sal_Unicode >& AttrChar_) throw( RuntimeException );
+ virtual Sequence< Any > SAL_CALL getAttrAny() throw( RuntimeException );
+ virtual void SAL_CALL setAttrAny(const Sequence< Any >& AttrAny_) throw( RuntimeException );
+ virtual Sequence< Type > SAL_CALL getAttrType() throw( RuntimeException );
+ virtual void SAL_CALL setAttrType( const Sequence< Type >& _attrtype ) throw (RuntimeException);
+ virtual Sequence< Sequence< sal_Int32 > > SAL_CALL getAttrSequence() throw( RuntimeException );
+ virtual void SAL_CALL setAttrSequence(const Sequence< Sequence< sal_Int32 > >& AttrSequence_) throw( RuntimeException );
+ virtual Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL getAttrSequence2() throw( RuntimeException );
+ virtual void SAL_CALL setAttrSequence2(const Sequence< Sequence< Sequence< sal_Int32 > > >& AttrSequence2_) throw ( RuntimeException );
+ virtual Sequence< Reference< XInterface > > SAL_CALL getAttrXInterface() throw(RuntimeException);
+ virtual void SAL_CALL setAttrXInterface( const Sequence< Reference< XInterface > >& _attrxinterface ) throw(RuntimeException);
+
+ virtual ::sal_Int8 SAL_CALL getAByte() throw (RuntimeException);
+ virtual void SAL_CALL setAByte( ::sal_Int8 _abyte ) throw (RuntimeException);
+ virtual float SAL_CALL getAFloat() throw (RuntimeException);
+ virtual void SAL_CALL setAFloat( float _afloat ) throw (RuntimeException);
+ virtual double SAL_CALL getADouble() throw (RuntimeException);
+ virtual void SAL_CALL setADouble( double _adouble ) throw (RuntimeException);
+ virtual sal_Bool SAL_CALL getABool() throw (RuntimeException);
+ virtual void SAL_CALL setABool( sal_Bool _abool ) throw (RuntimeException);
+ virtual ::sal_Int16 SAL_CALL getAShort() throw (RuntimeException);
+ virtual void SAL_CALL setAShort( ::sal_Int16 _ashort ) throw (RuntimeException);
+ virtual ::sal_uInt16 SAL_CALL getAUShort() throw (RuntimeException);
+ virtual void SAL_CALL setAUShort( ::sal_uInt16 _aushort ) throw (RuntimeException);
+ virtual ::sal_Int32 SAL_CALL getALong() throw (RuntimeException);
+ virtual void SAL_CALL setALong( ::sal_Int32 _along ) throw (RuntimeException);
+ virtual ::sal_uInt32 SAL_CALL getAULong() throw (RuntimeException);
+ virtual void SAL_CALL setAULong( ::sal_uInt32 _aulong ) throw (RuntimeException);
+ virtual OUString SAL_CALL getAString() throw (RuntimeException);
+ virtual void SAL_CALL setAString( const OUString& _astring ) throw (RuntimeException);
+ virtual ::sal_Unicode SAL_CALL getAChar() throw (RuntimeException);
+ virtual void SAL_CALL setAChar( ::sal_Unicode _achar ) throw (RuntimeException);
+ virtual Any SAL_CALL getAAny() throw (RuntimeException);
+ virtual void SAL_CALL setAAny( const Any& _aany ) throw (RuntimeException);
+ virtual Type SAL_CALL getAType() throw (RuntimeException);
+ virtual void SAL_CALL setAType( const Type& _atype ) throw (RuntimeException);
+ virtual Reference< XInterface > SAL_CALL getAXInterface() throw (RuntimeException);
+ virtual void SAL_CALL setAXInterface( const Reference<XInterface >& _axinterface ) throw (RuntimeException);
+ virtual Reference<XInvocation > SAL_CALL getAXInvocation() throw (RuntimeException);
+ virtual void SAL_CALL setAXInvocation( const Reference< XInvocation >& _axinvocation ) throw (RuntimeException);
+
+ virtual void SAL_CALL testout_methodByte(sal_Int8& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodFloat(float& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodDouble(double& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodBool(sal_Bool& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodShort(sal_Int16& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodUShort(sal_uInt16& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodLong(sal_Int32& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodULong(sal_uInt32& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodHyper(sal_Int64& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodUHyper(sal_uInt64& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodString(OUString& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodChar(sal_Unicode& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodAny(Any& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodType(Type& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodSequence(Sequence< sal_Int32 >& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodSequence2(Sequence< Sequence< sal_Int32 > >& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodMulParams1(sal_Int32& rout1, sal_Int32& rout2) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodMulParams2(sal_Int32& rout1, sal_Int32& rout2, OUString& rout3) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodMulParams3(const OUString& sin, OUString& sout) throw( RuntimeException );
+ virtual void SAL_CALL testout_methodMulParams4( float in1, float& out1, sal_Int32 in2, sal_Int32& out2, sal_Int32 in3 ) throw(RuntimeException);
+ virtual void SAL_CALL testout_methodXInterface( Reference< XInterface >& rOut ) throw(RuntimeException);
+
+ virtual void SAL_CALL testinout_methodByte(sal_Int8& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodFloat(float& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodDouble(double& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodBool(sal_Bool& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodShort(sal_Int16& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodUShort(sal_uInt16& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodLong(sal_Int32& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodULong(sal_uInt32& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodHyper(sal_Int64& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodUHyper(sal_uInt64& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodString(OUString& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodChar(sal_Unicode& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodAny(Any& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodType(Type& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodSequence(Sequence< sal_Int32 >& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodSequence2(Sequence< Sequence< sal_Int32 > >& rOut) throw( RuntimeException );
+ virtual void SAL_CALL testinout_methodXInterface( Reference< XInvocation >& rOut ) throw(RuntimeException);
+ virtual void SAL_CALL testinout_methodXInterface2( Reference< XInterface > & rOut) throw( RuntimeException);
+ virtual Any SAL_CALL methodAnyTest1(const Any& rIn) throw( RuntimeException ) ;
+ virtual Any SAL_CALL getAttrAny2() throw( RuntimeException ) ;
+ virtual void SAL_CALL setAttrAny2(const Any& AttrAny2_) throw( RuntimeException ) ;
+
+
+ // XTestStruct
+ virtual void SAL_CALL methodStruct(const Property& aProp) throw( RuntimeException );
+
+ virtual Property SAL_CALL retMethodStruct() throw( RuntimeException );
+
+ virtual Property SAL_CALL getAttrStruct() throw( RuntimeException );
+ virtual void SAL_CALL setAttrStruct(const Property& AttrStruct_) throw( RuntimeException );
+ virtual Property SAL_CALL methodStruct2( const Property& aProp ) throw (RuntimeException);
+
+ // XTestOther
+ virtual void SAL_CALL other_methodAnyIn(const Any& rAny) throw( RuntimeException );
+ virtual void SAL_CALL other_methodAnyOut(Any& rAny) throw( RuntimeException );
+ virtual Any SAL_CALL other_methodAnyRet() throw( RuntimeException );
+ virtual void SAL_CALL in_float( float val) throw ( RuntimeException);
+ virtual Any SAL_CALL other_methodAny( const Any& rAny, const OUString& typeInAny )
+ throw (RuntimeException);
+
+ // XTestInParameters
+ virtual sal_Int8 SAL_CALL in_methodByte( sal_Int8 rIn ) throw (RuntimeException);
+ virtual float SAL_CALL in_methodFloat( float rIn ) throw (RuntimeException);
+ virtual double SAL_CALL in_methodDouble( double rIn ) throw (RuntimeException);
+ virtual sal_Bool SAL_CALL in_methodBool( sal_Bool rIn ) throw (RuntimeException);
+ virtual sal_Int16 SAL_CALL in_methodShort( sal_Int16 rIn ) throw (RuntimeException);
+ virtual sal_uInt16 SAL_CALL in_methodUShort( sal_uInt16 rIn ) throw (RuntimeException);
+ virtual sal_Int32 SAL_CALL in_methodLong( sal_Int32 rIn ) throw (RuntimeException);
+ virtual sal_uInt32 SAL_CALL in_methodULong( sal_uInt32 rIn ) throw (RuntimeException);
+ virtual sal_Int64 SAL_CALL in_methodHyper( sal_Int64 rIn ) throw (RuntimeException);
+ virtual sal_uInt64 SAL_CALL in_methodUHyper( sal_uInt64 rIn ) throw (RuntimeException);
+ virtual OUString SAL_CALL in_methodString( const OUString& rIn ) throw (RuntimeException);
+ virtual sal_Unicode SAL_CALL in_methodChar( sal_Unicode rIn ) throw (RuntimeException);
+ virtual Any SAL_CALL in_methodAny( const Any& rIn ) throw (RuntimeException);
+ virtual Type SAL_CALL in_methodType( const Type& rIn ) throw (RuntimeException);
+ virtual Reference<XInterface> SAL_CALL in_methodXInterface( const Reference< XInterface >& rIn ) throw (RuntimeException);
+ virtual Reference<XInvocation > SAL_CALL in_methodInvocation( const Reference< XInvocation >& inv ) throw (RuntimeException);
+ virtual SimpleStruct SAL_CALL in_methodStruct( const SimpleStruct& aStruct ) throw (RuntimeException);
+ 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);
+
+ // XTestInterfaces --------------------------------------------------------------------------
+ virtual void SAL_CALL testInterface( const Reference< XCallback >& xCallback, sal_Int32 mode ) throw(RuntimeException);
+ virtual void SAL_CALL testInterface2( const Reference< XSimple >& xSimple, sal_Int32 mode ) throw(RuntimeException);
+ // XSimple --------------------------------------------------------------------------
+ void SAL_CALL func( const OUString &message) throw(css::uno::RuntimeException);
+ OUString SAL_CALL getName() throw(css::uno::RuntimeException);
+
+ // XIdentity
+ virtual void SAL_CALL setObject( const Reference< XInterface >& val ) throw (RuntimeException);
+ virtual sal_Bool SAL_CALL isSame( const Reference< XInterface >& val ) throw (RuntimeException);
+ virtual Reference< XInterface > SAL_CALL getThis( ) throw (RuntimeException);
+};
+
+class EventListener: public WeakImplHelper<XEventListener>
+{
+public:
+ EventListener(): bCalled( sal_False)
+ {}
+ virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) throw (RuntimeException);
+
+ sal_Bool bCalled;
+};
+
+
+OComponent::~OComponent()
+{
+}
+
+
+// functions ==============================================================================
+
+Reference<XInterface> SAL_CALL OComponent_CreateInstance( const Reference<XMultiServiceFactory> & rSMgr ) throw(RuntimeException)
+{
+// Reference<XInterface> xService(static_cast<XWeak*>(new OComponent( rSMgr )), UNO_QUERY);
+ OComponent* o= new OComponent( rSMgr );
+ Reference<XInterface> xService(static_cast<XIdentity*>(o), UNO_QUERY);
+ return xService;
+}
+
+Sequence<OUString> OComponent_getSupportedServiceNames()
+{
+ Sequence<OUString> aRet { SERVICE_NAME;//ODataInputStream_getImplementationName() };
+
+ return aRet;
+}
+
+
+extern "C" sal_Bool SAL_CALL component_writeInfo( void * /*pServiceManager*/, void * pRegistryKey )
+{
+ if(pRegistryKey)
+ {
+ try
+ {
+ Reference<XRegistryKey> xNewKey =
+ reinterpret_cast<XRegistryKey*>( pRegistryKey)->createKey(KEY1);
+ xNewKey->createKey( KEY2);
+ return sal_True;
+
+ }
+ catch(InvalidRegistryException &)
+ {
+ TOOLS_WARN_EXCEPTION("extensions.olebridge", "");
+ }
+ }
+ return sal_False;
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT void * SAL_CALL component_getFactory(
+ const char * pImplName, void * pServiceManager, void * /*pRegistryKey*/ )
+{
+ static void * pRet= NULL;
+ if( ! pRet)
+ {
+ OUString aImplName( OUString::createFromAscii( pImplName ) );
+ if (pServiceManager && aImplName.equals( IMPL_NAME ))
+ {
+ Reference<XMultiServiceFactory> xMulFac(
+ reinterpret_cast< XMultiServiceFactory*>(pServiceManager));
+
+ Sequence<OUString> seqServiceNames;
+ Reference<XSingleServiceFactory> xFactory = createOneInstanceFactory( xMulFac, SERVICE_NAME,
+ OComponent_CreateInstance, seqServiceNames);
+
+ if (xFactory.is())
+ {
+ xFactory->acquire();
+ pRet = xFactory.get();
+ }
+ }
+ }
+ return pRet;
+}
+
+
+// XTestSequence ============================================================================
+Sequence<sal_Int8> SAL_CALL OComponent::methodByte(const Sequence< sal_Int8 >& aSeq) throw( RuntimeException )
+{
+ sal_Int8 _x;
+ for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
+ _x= aSeq.getConstArray()[i];
+ }
+ return aSeq;
+}
+Sequence<float> SAL_CALL OComponent::methodFloat(const Sequence< float>& aSeq) throw( RuntimeException )
+{
+ float _x;
+ for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
+ _x= aSeq.getConstArray()[i];
+ }
+ return aSeq;
+}
+Sequence<double> SAL_CALL OComponent::methodDouble(const Sequence< double >& aSeq) throw( RuntimeException)
+{
+ double _x;
+ for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
+ _x= aSeq.getConstArray()[i];
+ }
+ return aSeq;
+}
+Sequence< sal_Bool > SAL_CALL OComponent::methodBool(const Sequence< sal_Bool >& aSeq) throw( RuntimeException)
+{
+ sal_Bool _x;
+ for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
+ _x= aSeq.getConstArray()[i];
+ }
+ return aSeq;
+}
+Sequence< sal_Int16 > SAL_CALL OComponent::methodShort(const Sequence< sal_Int16 >& aSeq) throw( RuntimeException )
+{
+ sal_Int16 _x;
+ for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
+ _x= aSeq.getConstArray()[i];
+ }
+ return aSeq;
+}
+Sequence< sal_uInt16 > SAL_CALL OComponent::methodUShort(const Sequence< sal_uInt16 >& aSeq) throw( RuntimeException )
+{
+ sal_uInt16 _x;
+ for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
+ _x= aSeq.getConstArray()[i];
+ }
+ return aSeq;
+}
+Sequence< sal_Int32 > SAL_CALL OComponent::methodLong(const Sequence< sal_Int32 >& aSeq) throw( RuntimeException)
+{
+ sal_Int32 _x;
+ for( sal_Int16 i= 0; i < aSeq.getLength(); i++) {
+ _x= aSeq.getConstArray()[i];
+ }
+ return aSeq;
+}
+Sequence< sal_uInt32 > SAL_CALL OComponent::methodULong(const Sequence< sal_uInt32 >& aSeq) throw( RuntimeException)
+{
+ sal_uInt32 _x;
+ for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
+ _x= aSeq.getConstArray()[i];
+ }
+ return aSeq;
+}
+Sequence< OUString > SAL_CALL OComponent::methodString(const Sequence< OUString >& aSeq) throw( RuntimeException)
+{
+ OUString _x;
+ for( sal_Int16 i= 0; i < aSeq.getLength(); i++) {
+ _x= aSeq.getConstArray()[i];
+ }
+ return aSeq;
+}
+Sequence< sal_Unicode > SAL_CALL OComponent::methodChar(const Sequence< sal_Unicode >& aSeq) throw( RuntimeException)
+{
+ sal_Unicode _x;
+ for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
+ _x= aSeq.getConstArray()[i];
+ }
+ return aSeq;
+}
+Sequence< Any > SAL_CALL OComponent::methodAny(const Sequence< Any >& aSeq) throw( RuntimeException)
+{
+ Any _x;
+ for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
+ _x= aSeq.getConstArray()[i];
+ TypeClass _t= _x.getValueTypeClass();
+ if( _t== TypeClass_STRING)
+ OUString s(* (rtl_uString**)_x.getValue());
+ }
+ return aSeq;
+
+}
+
+Sequence< Type > SAL_CALL OComponent::methodType(const Sequence< Type >& aSeq) throw( RuntimeException )
+{
+ Type _x;
+ for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
+ _x= aSeq.getConstArray()[i];
+ }
+ return aSeq;
+}
+
+Sequence< Reference< XInterface > > SAL_CALL OComponent::methodXInterface( const Sequence< Reference< XInterface > >& aSeq ) throw(RuntimeException)
+{
+ for( sal_Int32 i= 0; i < aSeq.getLength(); i++)
+ {
+ Reference<XInterface> xInt= aSeq[i];
+ Reference<XEventListener> xList( xInt, UNO_QUERY);
+ if( xList.is())
+ xList->disposing( EventObject());
+ }
+ return aSeq;
+}
+
+Sequence< Sequence< sal_Int32 > > SAL_CALL OComponent::methodSequence(const Sequence< Sequence< sal_Int32 > >& aSeq) throw( RuntimeException)
+{
+ sal_Int32 value;
+ for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
+ const Sequence<sal_Int32>& rseq2= aSeq.getConstArray()[i];
+ for (sal_Int16 j= 0; j < rseq2.getLength(); j++){
+ value= rseq2.getConstArray()[j];
+ }
+ }
+ return aSeq;
+}
+Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL OComponent::methodSequence2(const Sequence< Sequence< Sequence< sal_Int32 > > >& aSeq)
+ throw( RuntimeException )
+{
+ sal_Int32 value;
+ sal_Int32 len= aSeq.getLength();
+ for( sal_Int16 i= 0; i < aSeq.getLength(); i++){
+ const Sequence< Sequence<sal_Int32> >& rseq2= aSeq.getConstArray()[i];
+ len= rseq2.getLength();
+
+ for (sal_Int16 j= 0; j < rseq2.getLength(); j++){
+ const Sequence<sal_Int32> & rseq3= rseq2.getConstArray()[j];
+ len= rseq3.getLength();
+
+ for (sal_Int16 k= 0; k < rseq3.getLength(); k++)
+ value= rseq3.getConstArray()[k];
+ }
+ }
+ return aSeq;
+}
+
+Sequence< Reference< XEventListener> > SAL_CALL OComponent::methodXEventListeners( const Sequence< Reference <XEventListener> >& aSeq) throw( RuntimeException)
+{
+ Reference<XEventListener> listener;
+ for( int i= 0; i < aSeq.getLength(); i++)
+ {
+ listener= aSeq[i];
+
+ listener->disposing( EventObject() );
+ }
+
+ return aSeq;
+}
+
+Sequence< Sequence<Reference<XEventListener > > > SAL_CALL OComponent::methodXEventListenersMul( const Sequence<Sequence<Reference<XEventListener > > >& aSeq ) throw (RuntimeException)
+{
+ Reference<XEventListener> listener;
+ for( int i= 0; i < aSeq.getLength(); i++)
+ {
+ Sequence<Reference<XEventListener> > seqInner= aSeq[i];
+ for( int j= 0; j < seqInner.getLength(); j++)
+ {
+ listener= seqInner[j];
+ listener->disposing( EventObject() );
+ }
+ }
+ return aSeq;
+}
+
+
+Sequence< sal_Int8 > SAL_CALL OComponent::getAttrByte() throw( RuntimeException)
+{
+ return m_seqByte;
+}
+void SAL_CALL OComponent::setAttrByte(const Sequence< sal_Int8 >& AttrByte_) throw( RuntimeException )
+{
+ m_seqByte= AttrByte_;
+}
+Sequence< float > SAL_CALL OComponent::getAttrFloat() throw( RuntimeException )
+{
+ return m_seqFloat;
+}
+void SAL_CALL OComponent::setAttrFloat(const Sequence< float >& AttrFloat_) throw( RuntimeException )
+{
+ m_seqFloat= AttrFloat_;
+}
+
+Sequence< double > SAL_CALL OComponent::getAttrDouble() throw( RuntimeException )
+{
+ return m_seqDouble;
+}
+void SAL_CALL OComponent::setAttrDouble(const Sequence< double >& AttrDouble_) throw( RuntimeException )
+{
+ m_seqDouble= AttrDouble_;
+}
+
+Sequence< sal_Bool > SAL_CALL OComponent::getAttrBool() throw( RuntimeException)
+{
+ return m_seqBool;
+}
+
+void SAL_CALL OComponent::setAttrBool(const Sequence< sal_Bool >& AttrBool_) throw (RuntimeException )
+{
+ m_seqBool= AttrBool_;
+}
+
+Sequence< sal_Int16 > SAL_CALL OComponent::getAttrShort() throw( RuntimeException)
+{
+ return m_seqShort;
+}
+void SAL_CALL OComponent::setAttrShort(const Sequence< sal_Int16 >& AttrShort_) throw( RuntimeException )
+{
+ m_seqShort= AttrShort_;
+}
+
+Sequence< sal_uInt16 > SAL_CALL OComponent::getAttrUShort() throw( RuntimeException )
+{
+ return m_seqUShort;
+}
+void SAL_CALL OComponent::setAttrUShort(const Sequence< sal_uInt16 >& AttrUShort_) throw( RuntimeException )
+{
+ m_seqUShort= AttrUShort_;
+}
+
+Sequence< sal_Int32 > SAL_CALL OComponent::getAttrLong() throw( RuntimeException)
+{
+ return m_seqLong;
+}
+void SAL_CALL OComponent::setAttrLong(const Sequence< sal_Int32 >& AttrLong_) throw( RuntimeException )
+{
+ m_seqLong= AttrLong_;
+}
+
+Sequence< sal_uInt32 > SAL_CALL OComponent::getAttrULong() throw( RuntimeException )
+{
+ return m_seqULong;
+}
+void SAL_CALL OComponent::setAttrULong(const Sequence< sal_uInt32 >& AttrULong_) throw( RuntimeException )
+{
+ m_seqULong= AttrULong_;
+}
+
+Sequence< OUString > SAL_CALL OComponent::getAttrString() throw( RuntimeException )
+{
+ return m_seqString;
+}
+void SAL_CALL OComponent::setAttrString(const Sequence< OUString >& AttrString_) throw( RuntimeException )
+{
+ m_seqString= AttrString_;
+}
+
+Sequence< sal_Unicode > SAL_CALL OComponent::getAttrChar() throw( RuntimeException )
+{
+ return m_seqChar;
+}
+void SAL_CALL OComponent::setAttrChar(const Sequence< sal_Unicode >& AttrChar_) throw( RuntimeException)
+{
+ m_seqChar= AttrChar_;
+}
+
+Sequence< Any > SAL_CALL OComponent::getAttrAny() throw( RuntimeException)
+{
+ return m_seqAny;
+}
+void SAL_CALL OComponent::setAttrAny(const Sequence< Any >& AttrAny_) throw( RuntimeException )
+{
+ m_seqAny= AttrAny_;
+}
+
+Sequence< Type > SAL_CALL OComponent::getAttrType() throw( RuntimeException )
+{
+ return m_seqType;
+}
+
+void SAL_CALL OComponent::setAttrType( const Sequence< Type >& AttrType_) throw( RuntimeException )
+{
+ m_seqType = AttrType_;
+}
+
+
+Sequence< Sequence< sal_Int32 > > SAL_CALL OComponent::getAttrSequence() throw( RuntimeException)
+{
+ return m_seq1;
+}
+void SAL_CALL OComponent::setAttrSequence(const Sequence< Sequence< sal_Int32 > >& AttrSequence) throw(RuntimeException )
+{
+ sal_Int32 x= 0;
+ for( sal_Int32 i=0; i < AttrSequence.getLength(); i++)
+ {
+ Sequence< sal_Int32 > seq= AttrSequence[i];
+
+ for ( sal_Int32 j=0; j < seq.getLength(); j++)
+ {
+ x= seq[j];
+ }
+ }
+
+ m_seq1= AttrSequence;
+}
+
+Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL OComponent::getAttrSequence2() throw( RuntimeException )
+{
+ return m_seq2;
+}
+void SAL_CALL OComponent::setAttrSequence2(const Sequence< Sequence< Sequence< sal_Int32 > > >& AttrSequence2_)
+ throw( RuntimeException )
+{
+ m_seq2= AttrSequence2_;
+}
+
+Sequence< Reference< XInterface > > SAL_CALL OComponent::getAttrXInterface() throw(RuntimeException)
+{
+ return m_seqxInterface;
+}
+void SAL_CALL OComponent::setAttrXInterface( const Sequence< Reference< XInterface > >& _attrxinterface ) throw(RuntimeException)
+{
+ m_seqxInterface= _attrxinterface;
+}
+
+
+::sal_Int8 SAL_CALL OComponent::getAByte() throw (RuntimeException)
+{
+ return m_attr_int8;
+}
+
+void SAL_CALL OComponent::setAByte( ::sal_Int8 _abyte ) throw (RuntimeException)
+{
+ m_attr_int8 = _abyte;
+}
+
+float SAL_CALL OComponent::getAFloat() throw (RuntimeException)
+{
+ return m_attr_float;
+}
+
+void SAL_CALL OComponent::setAFloat( float _afloat ) throw (RuntimeException)
+{
+ m_attr_float = _afloat;
+}
+
+double SAL_CALL OComponent::getADouble() throw (RuntimeException)
+{
+ return m_attr_double;
+}
+
+void SAL_CALL OComponent::setADouble( double _adouble ) throw (RuntimeException)
+{
+ m_attr_double = _adouble;
+}
+
+sal_Bool SAL_CALL OComponent::getABool() throw (RuntimeException)
+{
+ return m_attr_bool;
+}
+
+void SAL_CALL OComponent::setABool( sal_Bool _abool ) throw (RuntimeException)
+{
+ m_attr_bool = _abool;
+}
+
+::sal_Int16 SAL_CALL OComponent::getAShort() throw (RuntimeException)
+{
+ return m_attr_int16;
+}
+
+void SAL_CALL OComponent::setAShort( ::sal_Int16 _ashort ) throw (RuntimeException)
+{
+ m_attr_int16 = _ashort;
+}
+
+::sal_uInt16 SAL_CALL OComponent::getAUShort() throw (RuntimeException)
+{
+ return m_attr_uint16;
+}
+
+void SAL_CALL OComponent::setAUShort( ::sal_uInt16 _aushort ) throw (RuntimeException)
+{
+ m_attr_uint16 = _aushort;
+}
+
+::sal_Int32 SAL_CALL OComponent::getALong() throw (RuntimeException)
+{
+ return m_attr_int32;
+}
+
+void SAL_CALL OComponent::setALong( ::sal_Int32 _along ) throw (RuntimeException)
+{
+ m_attr_int32 = _along;
+}
+
+::sal_uInt32 SAL_CALL OComponent::getAULong() throw (RuntimeException)
+{
+ return m_attr_uint32;
+}
+
+void SAL_CALL OComponent::setAULong( ::sal_uInt32 _aulong ) throw (RuntimeException)
+{
+ m_attr_uint32 = _aulong;
+}
+
+OUString SAL_CALL OComponent::getAString() throw (RuntimeException)
+{
+ return m_attr_string;
+}
+
+void SAL_CALL OComponent::setAString( const OUString& _astring ) throw (RuntimeException)
+{
+ m_attr_string = _astring;
+}
+
+::sal_Unicode SAL_CALL OComponent::getAChar() throw (RuntimeException)
+{
+ return m_attr_char;
+}
+
+void SAL_CALL OComponent::setAChar( ::sal_Unicode _achar ) throw (RuntimeException)
+{
+ m_attr_char = _achar;
+}
+
+Any SAL_CALL OComponent::getAAny() throw (RuntimeException)
+{
+ return m_attr_any;
+}
+
+void SAL_CALL OComponent::setAAny( const Any& _aany ) throw (RuntimeException)
+{
+ m_attr_any = _aany;
+}
+
+Type SAL_CALL OComponent::getAType() throw (RuntimeException)
+{
+ return m_attr_type;
+}
+
+void SAL_CALL OComponent::setAType( const Type& _atype ) throw (RuntimeException)
+{
+ m_attr_type = _atype;
+}
+
+Reference< XInterface > SAL_CALL OComponent::getAXInterface() throw (RuntimeException)
+{
+ return m_attr_xinterface;
+}
+
+void SAL_CALL OComponent::setAXInterface( const Reference<XInterface >& _axinterface ) throw (RuntimeException)
+{
+ m_attr_xinterface = _axinterface;
+}
+
+Reference<XInvocation > SAL_CALL OComponent::getAXInvocation() throw (RuntimeException)
+{
+ return m_attr_xinvocation;
+}
+
+void SAL_CALL OComponent::setAXInvocation( const Reference< XInvocation >& _axinvocation ) throw (RuntimeException)
+{
+ m_attr_xinvocation = _axinvocation;
+}
+
+void SAL_CALL OComponent::testout_methodByte(sal_Int8& rOut) throw( RuntimeException )
+{
+ rOut= m_int8;
+}
+void SAL_CALL OComponent::testout_methodFloat(float& rOut) throw( RuntimeException )
+{
+ rOut= m_float;
+}
+void SAL_CALL OComponent::testout_methodDouble(double& rOut) throw( RuntimeException )
+{
+ rOut= m_double;
+}
+
+void SAL_CALL OComponent::testout_methodBool(sal_Bool& rOut) throw( RuntimeException )
+{
+ rOut= m_bool;
+}
+void SAL_CALL OComponent::testout_methodShort(sal_Int16& rOut) throw( RuntimeException )
+{
+ rOut= m_int16;
+}
+void SAL_CALL OComponent::testout_methodUShort(sal_uInt16& rOut) throw( RuntimeException )
+{
+ rOut= m_uint16;
+}
+void SAL_CALL OComponent::testout_methodLong(sal_Int32& rOut) throw( RuntimeException )
+{
+ rOut = m_int32;
+}
+void SAL_CALL OComponent::testout_methodULong(sal_uInt32& rOut) throw( RuntimeException )
+{
+ rOut= m_uint32;
+}
+void SAL_CALL OComponent::testout_methodHyper(sal_Int64& rOut) throw( RuntimeException )
+{
+ rOut = m_int64;
+}
+
+void SAL_CALL OComponent::testout_methodUHyper(sal_uInt64& rOut) throw( RuntimeException )
+{
+ rOut = m_uint64;
+}
+
+void SAL_CALL OComponent::testout_methodString(OUString& rOut) throw( RuntimeException )
+{
+ rOut= m_string;
+}
+void SAL_CALL OComponent::testout_methodChar(sal_Unicode& rOut) throw( RuntimeException )
+{
+ rOut= m_char;
+}
+void SAL_CALL OComponent::testout_methodAny(Any& rOut) throw( RuntimeException)
+{
+ rOut = m_any;
+}
+
+void SAL_CALL OComponent::testout_methodType(Type& rOut) throw( RuntimeException )
+{
+ rOut = m_type;
+}
+
+void SAL_CALL OComponent::testout_methodSequence(Sequence< sal_Int32 >& rOut) throw( RuntimeException)
+{
+ rOut.realloc(10);
+ for( sal_Int16 i= 0; i < rOut.getLength(); i++) rOut.getArray()[i]= i;
+}
+void SAL_CALL OComponent::testout_methodSequence2(Sequence< Sequence< sal_Int32 > >& rOut) throw( RuntimeException )
+{
+ rOut.realloc( 10);
+ for( sal_Int16 i= 0; i < rOut.getLength(); i++){
+ Sequence<sal_Int32>& rseq2= rOut.getArray()[i];
+ rseq2.realloc( 10);
+ for (sal_Int16 j= 0; j < rseq2.getLength(); j++){
+ rseq2.getArray()[j]= j;
+ }
+ }
+}
+void SAL_CALL OComponent::testout_methodMulParams1(sal_Int32& rout1, sal_Int32& rout2) throw( RuntimeException )
+{
+ rout1= 999;
+ rout2= 1111;
+}
+void SAL_CALL OComponent::testout_methodMulParams2(sal_Int32& rout1, sal_Int32& rout2, OUString& rout3) throw( RuntimeException )
+{
+ rout1= 1111;
+ rout2= 1222;
+ rout3= L" another string";
+}
+void SAL_CALL OComponent::testout_methodMulParams3(const OUString&, OUString& sout) throw( RuntimeException )
+{
+ sout= L"Out Hallo!";
+}
+void SAL_CALL OComponent::testout_methodMulParams4( float in1, float& out1, sal_Int32 in2, sal_Int32& out2, sal_Int32 ) throw(RuntimeException)
+{
+ out1= in1 + 1;
+ out2= in2 + 1;
+}
+
+void SAL_CALL OComponent::testout_methodXInterface( Reference< XInterface >& rOut ) throw(RuntimeException)
+{
+ rOut = m_xinterface;
+}
+
+// XTestInParameters ------------------------------------------------------------
+sal_Int8 SAL_CALL OComponent::in_methodByte( sal_Int8 rIn ) throw (RuntimeException)
+{
+ m_int8 = rIn;
+ return rIn;
+}
+float SAL_CALL OComponent::in_methodFloat( float rIn ) throw (RuntimeException)
+{
+ m_float = rIn;
+ return rIn;
+}
+double SAL_CALL OComponent::in_methodDouble( double rIn ) throw (RuntimeException)
+{
+ m_double = rIn;
+ return rIn;
+}
+sal_Bool SAL_CALL OComponent::in_methodBool( sal_Bool rIn ) throw (RuntimeException)
+{
+ m_bool = rIn;
+ return rIn;
+}
+sal_Int16 SAL_CALL OComponent::in_methodShort( sal_Int16 rIn ) throw (RuntimeException)
+{
+ m_int16 = rIn;
+ return rIn;
+}
+sal_uInt16 SAL_CALL OComponent::in_methodUShort( sal_uInt16 rIn ) throw (RuntimeException)
+{
+ m_uint16 = rIn;
+ return rIn;
+}
+sal_Int32 SAL_CALL OComponent::in_methodLong( sal_Int32 rIn ) throw (RuntimeException)
+{
+ m_int32 = rIn;
+ return rIn;
+}
+sal_uInt32 SAL_CALL OComponent::in_methodULong( sal_uInt32 rIn ) throw (RuntimeException)
+{
+ m_uint32 = rIn;
+ return rIn;
+}
+sal_Int64 SAL_CALL OComponent::in_methodHyper( sal_Int64 rIn ) throw (RuntimeException)
+{
+ m_int64 = rIn;
+ return rIn;
+}
+
+sal_uInt64 SAL_CALL OComponent::in_methodUHyper( sal_uInt64 rIn ) throw (RuntimeException)
+{
+ m_uint64 = rIn;
+ return rIn;
+}
+
+OUString SAL_CALL OComponent::in_methodString( const OUString& rIn ) throw (RuntimeException)
+{
+ m_string = rIn;
+ return rIn;
+}
+sal_Unicode SAL_CALL OComponent::in_methodChar( sal_Unicode rIn ) throw (RuntimeException)
+{
+ m_char = rIn;
+ return rIn;
+}
+Any SAL_CALL OComponent::in_methodAny( const Any& rIn ) throw (RuntimeException)
+{
+ m_any = rIn;
+ return rIn;
+}
+
+Type SAL_CALL OComponent::in_methodType( const Type& rIn ) throw (RuntimeException)
+{
+ m_type = rIn;
+ return rIn;
+}
+
+Reference<XInvocation > SAL_CALL OComponent::in_methodInvocation( const Reference< XInvocation >& inv )
+ throw (RuntimeException)
+{
+ //We expect the invocation results from a conversion of VBasicEventListener.VBEventListener
+//which implements XEventListener
+ // extensions/test/ole/EventListenerSample
+ EventObject event( Reference<XInterface>(static_cast<XTestInParameters*>(this),UNO_QUERY));
+ Any anyParam;
+ anyParam <<= event;
+ Sequence<Any> params( &anyParam, 1);
+ Sequence<sal_Int16> outIndex;
+ Sequence<Any> outParams;
+ try{
+ inv->invoke( OUString("disposing"),
+ params, outIndex, outParams);
+ }catch(IllegalArgumentException &) {
+ }
+ catch(CannotConvertException &){
+ }
+ catch(InvocationTargetException&) {
+ }
+ return inv;
+}
+Reference<XInterface> SAL_CALL OComponent::in_methodXInterface( const Reference<XInterface >& rIn ) throw (RuntimeException)
+{
+ m_xinterface = rIn;
+ return rIn;
+}
+
+SimpleStruct SAL_CALL OComponent::in_methodStruct( const SimpleStruct& aStruct )
+ throw (RuntimeException)
+{
+ SimpleStruct& s= const_cast<SimpleStruct&>(aStruct);
+ s.message= s.message + OUString(
+ "This string was set in OleTest");
+ return aStruct;
+}
+void SAL_CALL OComponent::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>&) throw (RuntimeException)
+{
+}
+
+// INOUT -----------------------------------------------------------------------------------
+void SAL_CALL OComponent::testinout_methodByte(sal_Int8& rOut) throw( RuntimeException )
+{
+ sal_Int8 tmp = rOut;
+ rOut = m_int8;
+ m_int8 = tmp;
+}
+void SAL_CALL OComponent::testinout_methodFloat(float& rOut) throw( RuntimeException )
+{
+ float tmp = rOut;
+ rOut = m_float;
+ m_float = tmp;
+}
+
+void SAL_CALL OComponent::testinout_methodDouble(double& rOut) throw( RuntimeException )
+{
+ double tmp = rOut;
+ rOut = m_double;
+ m_double = tmp;
+}
+void SAL_CALL OComponent::testinout_methodBool(sal_Bool& rOut) throw( RuntimeException )
+{
+ sal_Bool tmp = rOut;
+ rOut = m_bool;
+ m_bool = tmp;
+}
+void SAL_CALL OComponent::testinout_methodShort(sal_Int16& rOut) throw( RuntimeException )
+{
+ sal_Int16 tmp= rOut;
+ rOut = m_int16;
+ m_int16 = tmp;
+}
+void SAL_CALL OComponent::testinout_methodUShort(sal_uInt16& rOut) throw( RuntimeException )
+{
+ sal_uInt16 tmp = rOut;
+ rOut = m_uint16;
+ m_uint16 = tmp;
+}
+void SAL_CALL OComponent::testinout_methodLong(sal_Int32& rOut) throw( RuntimeException )
+{
+ sal_Int32 tmp = rOut;
+ rOut = m_int32;
+ m_int32 = tmp;
+}
+void SAL_CALL OComponent::testinout_methodULong(sal_uInt32& rOut) throw( RuntimeException )
+{
+ sal_uInt32 tmp = rOut;
+ rOut = m_uint32;
+ m_uint32 = tmp;
+}
+void SAL_CALL OComponent::testinout_methodHyper(sal_Int64& rOut) throw( RuntimeException )
+{
+ sal_Int64 tmp = rOut;
+ rOut = m_int64;
+ m_int64 = tmp;
+}
+
+void SAL_CALL OComponent::testinout_methodUHyper(sal_uInt64& rOut) throw( RuntimeException )
+{
+ sal_uInt64 tmp = rOut;
+ rOut = m_uint64;
+ m_uint64 = tmp;
+}
+
+void SAL_CALL OComponent::testinout_methodString(OUString& rOut) throw( RuntimeException )
+{
+ OUString tmp = rOut;
+ rOut = m_string;
+ m_string = tmp;
+}
+void SAL_CALL OComponent::testinout_methodChar(sal_Unicode& rOut) throw( RuntimeException)
+{
+ sal_Unicode tmp = rOut;
+ rOut = m_char;
+ m_char = tmp;
+}
+void SAL_CALL OComponent::testinout_methodAny(Any& rOut) throw( RuntimeException)
+{
+ Any tmp = rOut;
+ rOut = m_any;
+ m_any = tmp;
+}
+void SAL_CALL OComponent::testinout_methodType(Type& rOut) throw( RuntimeException)
+{
+ Type tmp = rOut;
+ rOut = m_type;
+ m_type = tmp;
+}
+
+
+void SAL_CALL OComponent::testinout_methodSequence(Sequence< sal_Int32 >& rOut) throw( RuntimeException)
+{
+
+ sal_Int32* arr= rOut.getArray();
+ for ( sal_Int32 i=0; i < rOut.getLength(); i++)
+ {
+ rOut.getArray()[i] += 1;
+ }
+}
+void SAL_CALL OComponent::testinout_methodSequence2(Sequence< Sequence< sal_Int32 > >& rOut) throw( RuntimeException )
+{
+ for( sal_Int32 i=0; i < rOut.getLength(); i++)
+ {
+ Sequence< sal_Int32 >& seq= rOut.getArray()[i];
+
+ for ( sal_Int32 j=0; j < seq.getLength(); j++)
+ {
+ seq.getArray()[j] += seq.getArray()[j];
+ }
+ }
+}
+
+// The parameter should implement XInvocation and a Property "value"
+void SAL_CALL OComponent::testinout_methodXInterface( Reference< XInvocation >& rOut ) throw(RuntimeException)
+{
+ Any any;
+ any= rOut->getValue( OUString( L"value"));
+ OUString _s;
+ any >>= _s;
+ OUString string(L"out");
+ any <<= string;
+ rOut->setValue( OUString(L"value"), any);
+
+ any= rOut->getValue( OUString( L"value"));
+ any >>= _s;
+
+}
+
+void SAL_CALL OComponent::testinout_methodXInterface2( Reference< XInterface > & rOut) throw( RuntimeException)
+{
+ Reference<XInterface> tmp = rOut;
+ rOut = m_xinterface;
+ m_xinterface = tmp;
+}
+Any SAL_CALL OComponent::methodAnyTest1(const Any& rIn) throw( RuntimeException )
+{
+ return rIn;
+}
+Any SAL_CALL OComponent::getAttrAny2() throw( RuntimeException )
+{
+ return m_any;
+}
+void SAL_CALL OComponent::setAttrAny2(const Any& AttrAny2_) throw( RuntimeException )
+{
+ m_any= AttrAny2_;
+}
+
+
+// XTestStruct =======================================================================================
+
+void SAL_CALL OComponent::methodStruct(const Property& aProp) throw( RuntimeException )
+{
+ char buff[1024];
+ buff[0]= 0;
+ sprintf( buff,"Property::Attribute : %d \n Property::Handle : %d \n Property::Name : %S",
+ aProp.Attributes, aProp.Handle, (const sal_Unicode*)aProp.Name);
+ MessageBox( NULL, A2T(buff), _T("OleTest: methodStruct"), MB_OK);
+}
+
+Property SAL_CALL OComponent::retMethodStruct() throw( RuntimeException )
+{
+ Property a(L"OleTest_Property", 255, cppu::UnoType<XInterface>::get(), PropertyAttribute::MAYBEVOID |
+ PropertyAttribute::BOUND | PropertyAttribute::CONSTRAINED |
+ PropertyAttribute::TRANSIENT | PropertyAttribute::READONLY |
+ PropertyAttribute::MAYBEAMBIGUOUS | PropertyAttribute::MAYBEDEFAULT );
+ return a;
+}
+
+Property SAL_CALL OComponent::getAttrStruct() throw( RuntimeException)
+{
+ Property a(L"OleTest_Property", 255, cppu::UnoType<XInterface>::get(), PropertyAttribute::MAYBEVOID |
+ PropertyAttribute::BOUND | PropertyAttribute::CONSTRAINED |
+ PropertyAttribute::TRANSIENT | PropertyAttribute::READONLY |
+ PropertyAttribute::MAYBEAMBIGUOUS | PropertyAttribute::MAYBEDEFAULT );
+ return a;
+
+}
+
+void SAL_CALL OComponent::setAttrStruct(const Property& AttrStruct_) throw( RuntimeException )
+{
+ char buff[1024];
+ buff[0]= 0;
+ sprintf( buff,"Property::Attribute : %d \n Property::Handle : %d \n Property::Name : %S",
+ AttrStruct_.Attributes, AttrStruct_.Handle, (const sal_Unicode*)AttrStruct_.Name);
+// MessageBox( NULL, A2T(buff), _T("OleTest: setAttrStruct"), MB_OK);
+}
+
+Property SAL_CALL OComponent::methodStruct2( const Property& aProp ) throw (RuntimeException)
+{
+ return aProp;
+}
+
+// XTestOther ==================================================================================
+void SAL_CALL OComponent::other_methodAnyIn(const Any& ) throw( RuntimeException )
+{
+}
+void SAL_CALL OComponent::other_methodAnyOut(Any& rAny) throw( RuntimeException )
+{
+ rAny <<= OUString(L"Ein Any");
+}
+
+Any SAL_CALL OComponent::other_methodAnyRet() throw(RuntimeException )
+{
+ Any a;
+ a <<= OUString(L"Ein Any");
+ return a;
+}
+void SAL_CALL OComponent::in_float( float val) throw ( RuntimeException)
+{
+ USES_CONVERSION;
+ char buff[256];
+ sprintf( buff, "parameter : %f", val);
+ MessageBox( NULL, A2T(buff), _T("OleTest"), MB_OK);
+}
+Any SAL_CALL OComponent::other_methodAny( const Any& rAny, const OUString& typeInAny )
+ throw (RuntimeException)
+{
+ Type expectedType;
+ typelib_TypeDescription * pDesc= NULL;
+ typelib_typedescription_getByName( &pDesc, typeInAny.pData );
+ if( pDesc)
+ {
+ expectedType = Type( pDesc->pWeakRef );
+ typelib_typedescription_release( pDesc);
+ }
+ if (rAny.getValueType() != expectedType)
+ throw RuntimeException();
+
+ return rAny;
+}
+
+// XTestInterfaces -------------------------------------------------------------------------------------
+void SAL_CALL OComponent::testInterface( const Reference< XCallback >& xCallback, sal_Int32 mode ) throw(RuntimeException)
+{
+ USES_CONVERSION;
+ sal_Int32 i=0;
+ OUString aString;
+ char buff[1024];
+
+ Reference<XSimple> xSimple;
+ SimpleStruct aSimpleStruct;
+ SimpleEnum aSimpleEnum;
+ Sequence<Any> seqAny;
+ Sequence< sal_Int8 > seqByte;
+ Any outAny;
+ sal_Bool aBool;
+ sal_Unicode aChar;
+ float aFloat;
+ double aDouble;
+ sal_Int8 aByte;
+ sal_Int16 aShort;
+ sal_Int32 aLong;
+
+ switch( mode)
+ {
+ case 1:
+ xCallback->func1(); break;
+ case 2:
+ xSimple= xCallback->returnInterface();
+ xSimple->func(L"XCallback::returnInterface");
+ break;
+
+
+ case 3:
+ xCallback->outInterface( xSimple);
+ sprintf( buff, "XCallback::outInterface, value: %x", xSimple.get());
+ MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
+ xSimple->func(L"XCallback::outInterface works");
+ break;
+ case 4:
+ xCallback->outStruct( aSimpleStruct);
+ sprintf( buff,"XCallback::outStruct, SimpleStruct::message: %s", OLE2A( aSimpleStruct.message));
+ MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
+ break;
+ case 5:
+ xCallback->outEnum( aSimpleEnum);
+ sprintf( buff,"XCallback::outEnum, SimpleEnum: %d", aSimpleEnum);
+ MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
+ break;
+ case 6:
+ xCallback->outSeqAny( seqAny);
+ sprintf( buff,"XCallback::outSeqAny, length: %d )", seqAny.getLength());
+ MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
+ for( i=0; i < seqAny.getLength(); i++)
+ {
+ Any any= seqAny[i];
+ if( any.getValueTypeClass() == TypeClass_STRING)
+ {
+ any >>= aString;
+ OutputDebugStringW( aString);
+ }
+
+ }
+ break;
+ case 7:
+ xCallback->outAny( outAny);
+ if( outAny.getValueTypeClass() == TypeClass_STRING)
+ outAny >>= aString;
+ sprintf( buff,"XCallback::outAny, Any : %s", W2A( aString));
+ MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
+ break;
+ case 8:
+ xCallback->outBool( aBool);
+ sprintf( buff,"XCallback::outBool, value: %d", aBool);
+ MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
+ break;
+ case 9:
+ xCallback->outChar( aChar);
+ sprintf( buff,"XCallback::outChar, value: %C", aChar);
+ MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
+ break;
+ case 10:
+ xCallback->outString( aString);
+ sprintf( buff,"XCallback::outString, value: %s", W2A( aString));
+ MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
+ break;
+ case 11:
+ xCallback->outFloat( aFloat);
+ sprintf( buff,"XCallback::outFloat, value: %f", aFloat);
+ MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
+ break;
+ case 12:
+ xCallback->outDouble( aDouble);
+ sprintf( buff,"XCallback::outDouble, value: %f", aDouble);
+ MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
+ break;
+ case 13:
+ xCallback->outByte( aByte);
+ sprintf( buff,"XCallback::outByte, value: %d", aByte);
+ MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
+ break;
+ case 14:
+ xCallback->outShort( aShort);
+ sprintf( buff,"XCallback::outShort, value: %d", aShort);
+ MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
+ break;
+ case 15:
+ xCallback->outLong( aLong);
+ sprintf( buff,"XCallback::outLong, value: %d", aLong);
+ MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
+ break;
+ case 18:
+ case 19:
+ case 30:
+ {
+
+ long outLong= 0;
+ xCallback->outValuesMixed( 1111, outLong, OUString( L"in string") );
+
+ sprintf( buff, "oletest.testInterface: outValue: %d", outLong);
+ MessageBox( NULL, A2T(buff), _T("OleTest"), MB_OK);
+ break;
+ }
+
+ case 31:
+ {
+ Reference< XSimple > xSimple;
+ SimpleStruct aSimpleStruct;
+ SimpleEnum aSimpleEnum;
+ Sequence<Any> seqAny;
+ Any aAny;
+ sal_Bool aBool;
+ sal_Unicode aChar;
+ OUString aString;
+ float aFloat;
+ double aDouble;
+ sal_Int8 aByte;
+ sal_Int16 aShort;
+ sal_Int32 aLong;
+ xCallback->outValuesAll( xSimple, aSimpleStruct, aSimpleEnum, seqAny, aAny, aBool,
+ aChar, aString,
+ aFloat, aDouble,
+ aByte,
+ aShort, aLong);
+
+ MessageBox( NULL, _T("XCallback::outValuesAll returned"), _T("OleTest::testInterface"), MB_OK);
+ break;
+ }
+ case 32:
+ {
+
+ xCallback->outSeqByte( seqByte);
+ sprintf( buff,"XCallback::outSeqAny, length: %d )", seqAny.getLength());
+ MessageBox( NULL, A2T(buff), _T("OleTest out parameter"), MB_OK);
+ for( i=0; i < seqAny.getLength(); i++)
+ {
+ Any any= seqAny[i];
+ if( any.getValueTypeClass() == TypeClass_STRING)
+ {
+ any >>= aString;
+ OutputDebugStringW( aString);
+ }
+ }
+ break;
+ }
+ // ############################################################################
+ // IN OUT parameter
+ // ############################################################################
+ case 100:
+ {
+ Reference<XSimple> xSimple= static_cast<XSimple*>(this);
+ xCallback->inoutInterface( xSimple);
+ xSimple->func(L"XSimple called from OleTest");
+ break;
+ }
+ case 101:
+ {
+ Reference<XIdlReflection> xRefl( theCoreReflection::get(comphelper::getComponentContext(m_rFactory)) );
+ Reference<XIdlClass> xClass= xRefl->forName(L"oletest.SimpleStruct");
+ Any any;
+ if( xClass.is())
+ xClass->createObject( any);
+
+ if( any.getValueTypeClass() == TypeClass_STRUCT)
+ {
+ SimpleStruct* pStruct= ( SimpleStruct*) any.getValue();
+ pStruct->message= "This struct was created in OleTest";
+
+ SimpleStruct aStruct;
+ any >>= aStruct;
+ xCallback->inoutStruct( aStruct);
+ // a Struct should now contain a different message
+ MessageBox( NULL, W2T(aStruct.message), _T("OleTest in out parameter"), MB_OK);
+ }
+
+ break;
+ }
+ case 102:
+ {
+ SimpleEnum aEnum= SimpleEnum_B;
+ xCallback->inoutEnum( aEnum);
+ char buff[1024];
+ sprintf( buff, "Enum: %d", aEnum);
+ MessageBox( NULL, A2T(buff), _T("OleTest in out parameter"), MB_OK);
+ break;
+ }
+ case 103:
+ {
+ Any arAny[3];
+ arAny[0] <<= OUString( L"string 0");
+ arAny[1] <<= OUString( L"string 1");
+ arAny[2] <<= OUString( L"string 2");
+
+ Sequence< Any >seqAny( arAny, 3);
+ xCallback->inoutSeqAny( seqAny);
+ char buff[1023];
+ sprintf( buff, "Sequence length: %d", seqAny.getLength());
+ MessageBox( NULL,A2T(buff) , _T("OleTest in out parameter"), MB_OK);
+
+ for( int i=0; i < seqAny.getLength(); i++)
+ {
+ Any any;
+ any <<= seqAny[i];
+ if(any.getValueTypeClass() == TypeClass_STRING)
+ {
+ OUString str;
+ any >>= str;
+
+ }
+ }
+
+ break;
+ }
+ case 104:
+ {
+ Any any;
+ OUString s(L" OleTest");
+ any <<= s;
+ xCallback->inoutAny(any);
+ if( any.getValueTypeClass() == TypeClass_STRING)
+ {
+ OUString s= *( rtl_uString**) any.getValue();
+ MessageBox( NULL, W2T( s), _T("OleTest: inout value any"), MB_OK);
+ }
+ break;
+ }
+ case 105:
+ {
+ sal_Bool b= sal_True;
+ xCallback->inoutBool( b);
+ char buff[1024];
+ sprintf( buff, "out value bool: %d", b);
+ MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
+ break;
+ }
+ case 106:
+ {
+ sal_Unicode uc= L'A';
+ xCallback->inoutChar( uc);
+ char buff[1024];
+ sprintf( buff, "out value sal_Unicode: %C", uc);
+ MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
+ break;
+ }
+ case 107:
+ {
+ OUString s(L"OleTest");
+ xCallback->inoutString( s);
+ char buff[1024];
+ sprintf( buff, "out value string: %S", s.getStr());
+ MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
+ break;
+ }
+ case 108:
+ {
+ float f= 3.14f;
+ xCallback->inoutFloat(f);
+ char buff[1024];
+ sprintf( buff, "out value float: %f", f);
+ MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
+ break;
+ }
+ case 109:
+ {
+ double f= 3.145;
+ xCallback->inoutDouble( f);
+ char buff[1024];
+ sprintf( buff, "out value double: %g", f);
+ MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
+ break;
+ }
+ case 110:
+ {
+ sal_Int8 aByte= 0xf;
+ xCallback->inoutByte( aByte);
+ char buff[1024];
+ sprintf( buff, "out value sal_Int8: %d", aByte);
+ MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
+ break;
+ }
+ case 111:
+ {
+ sal_Int16 aShort= 0xff;
+ xCallback->inoutShort( aShort);
+ char buff[1024];
+ sprintf( buff, "out value sal_Int16: %d", aShort);
+ MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
+ break;
+ }
+ case 112:
+ {
+ sal_Int32 aLong= 0xfffe;
+ xCallback->inoutLong( aLong);
+ char buff[1024];
+ sprintf( buff, "out value sal_Int32: %d", aLong);
+ MessageBox( NULL, A2T( buff), _T("OleTest in out parameter"), MB_OK);
+ break;
+ }
+ case 120:
+ {
+ Reference<XSimple> aXSimple= static_cast<XSimple*>(this);
+
+ SimpleStruct aStruct;
+ Reference<XIdlReflection> xRefl( m_rFactory->createInstance(L"com.sun.star.reflection.CoreReflection"), UNO_QUERY);
+ if( xRefl.is())
+ {
+ Reference<XIdlClass> xClass= xRefl->forName(L"oletest.SimpleStruct");
+ Any any;
+ if( xClass.is())
+ xClass->createObject( any);
+
+ if( any.getValueTypeClass() == TypeClass_STRUCT)
+ {
+ SimpleStruct* pStruct= ( SimpleStruct*) any.getValue();
+ pStruct->message= "This struct was created in OleTest";
+ any >>= aStruct;
+ }
+ }
+
+ SimpleEnum aEnum= SimpleEnum_B;
+
+ Sequence< Any > aSeq;
+ Any arAny[3];
+ arAny[0] <<= OUString( L"string 0");
+ arAny[1] <<= OUString( L"string 1");
+ arAny[2] <<= OUString( L"string 2");
+ aSeq = Sequence< Any >( arAny, 3);
+
+ Any aAny;
+ OUString s(L" OleTest");
+ aAny <<= s;
+
+ sal_Bool aBool= sal_True;
+ sal_Unicode aChar= L'A';
+ OUString aString( L"OleTest");
+ float aFloat=3.14f;
+ double aDouble= 3.145;
+ sal_Int8 aByte= 0xf;
+ sal_Int16 aShort= 0xff;
+ sal_Int32 aLong= 0xffe;
+
+ xCallback->inoutValuesAll( aXSimple, aStruct, aEnum, aSeq,
+ aAny, aBool, aChar, aString, aFloat, aDouble,
+ aByte, aShort, aLong );
+
+ aXSimple->func(L"XSimple called from OleTest");
+ MessageBox( NULL, W2T(aStruct.message), _T("OleTest"), MB_OK);
+
+ for( int i=0; i < aSeq.getLength(); i++)
+ {
+ Any any;
+ any <<= aSeq[i];
+ if(any.getValueTypeClass() == TypeClass_STRING)
+ {
+ OUString str;
+ any >>= str;
+
+ }
+ }
+ break;
+ }
+
+ // ############################################################################
+ // IN parameter
+ // ############################################################################
+
+ case 200:
+
+ xCallback->inValues( L'a', 0xffffL, OUString(L" a string from OleTest"));
+ break;
+ case 201:
+ {
+ sal_Int8 arbyte[3]= { 1,2,3};
+ Sequence< sal_Int8 > seq( arbyte, 3);
+ xCallback->inSeqByte( seq);
+ break;
+ }
+ case 202:
+ {
+ const int LISTENERS= 3;
+ Reference<XEventListener> arListeners[LISTENERS];
+ EventObject arEvents[LISTENERS];
+
+ for( int i= 0; i < LISTENERS; i++)
+ {
+ Reference<XInterface> aList= static_cast<XWeak*>( new EventListener());
+ arListeners[i].set( aList, UNO_QUERY);
+ }
+
+ xCallback->inSeqXEventListener(Sequence<Reference<XEventListener> > (arListeners, LISTENERS),
+ Sequence<EventObject>(arEvents, LISTENERS));
+ break;
+ }
+
+ // ############################################################################
+ // Call a COM object that has not been passed as parameter to a UNO component and
+ // hence no type information is available in the COM wrapper
+ // ############################################################################
+ case 300:
+ {
+ Reference<XInterface> xIntFact = m_rFactory->createInstance(L"com.sun.star.bridge.oleautomation.Factory");
+
+ Reference<XMultiServiceFactory> oleFact(xIntFact, UNO_QUERY);
+
+ Reference<XInterface> xIntCallback= oleFact->createInstance(L"XCallback_Impl.Callback");
+ Reference<XInvocation> xInv( xIntCallback, UNO_QUERY);
+ Sequence<sal_Int16> seqIndices;
+ Sequence<Any> seqOutParams;
+ xInv->invoke( OUString( L"outValuesAll"), Sequence<Any>(), seqIndices, seqOutParams);
+
+ if( seqOutParams.getLength() == 12)
+ {
+ Reference<XSimple> xSimple= *(XSimple**)seqOutParams[0].getValue();
+ xSimple->func( L"Call from OleTest on XSimple");
+ SimpleStruct aStruct;
+ seqOutParams[1] >>= aStruct;
+ SimpleEnum aEnum= *(SimpleEnum*)seqOutParams[2].getValue();
+
+ Sequence<Any> seqAny;
+ seqOutParams[3] >>= seqAny;
+ for( int i=0; i<seqAny.getLength(); i++)
+ {
+ OUString _s;
+ seqAny[i] >>= _s;
+ }
+
+ Any _any= *(Any*)seqOutParams[4].getValue();
+ sal_Bool _bool= *(sal_Bool*)seqOutParams[5].getValue();
+ sal_Unicode _char= *( sal_Unicode*) seqOutParams[6].getValue();
+ OUString _str= *( rtl_uString**)seqOutParams[7].getValue();
+
+ float _f= *( float*)seqOutParams[8].getValue();
+ double _d= *( double*) seqOutParams[9].getValue();
+ sal_Int8 _byte= *( sal_Int8*) seqOutParams[10].getValue();
+ sal_Int16 _short= *( sal_Int16*) seqOutParams[11].getValue();
+
+ sal_Int32 _long= *( sal_Int32*) seqOutParams[12].getValue();
+
+ }
+ break;
+ }
+ case 301:
+ // in / out parameter
+ {
+ Reference<XInterface> xIntFact = m_rFactory->createInstance(L"com.sun.star.bridge.oleautomation.Factory");
+
+ Reference<XMultiServiceFactory> oleFact(xIntFact, UNO_QUERY);
+
+ Reference<XInterface> xIntCallback= oleFact->createInstance(L"XCallback_Impl.Callback");
+ Reference<XInvocation> xInv( xIntCallback, UNO_QUERY);
+ Sequence<sal_Int16> seqIndices;
+ Sequence<Any> seqOutParams;
+
+
+ Any arAny[13];
+ Reference<XSimple> xSimple= static_cast<XSimple*>( this);
+
+ arAny[0] <<= xSimple;
+ SimpleStruct aStruct;
+ Reference<XIdlReflection> xRefl( m_rFactory->createInstance(L"com.sun.star.reflection.CoreReflection"), UNO_QUERY);
+ if( xRefl.is())
+ {
+ Reference<XIdlClass> xClass= xRefl->forName(L"oletest.SimpleStruct");
+ Any any;
+ if( xClass.is())
+ xClass->createObject( any);
+
+ if( any.getValueTypeClass() == TypeClass_STRUCT)
+ {
+ SimpleStruct* pStruct= ( SimpleStruct*) any.getValue();
+ pStruct->message = "This struct was created in OleTest";
+ any >>= aStruct;
+ }
+ }
+ arAny[1] <<= aStruct;
+ arAny[2] <<= SimpleEnum_C;
+
+ Any arSeqAny[3];
+ arSeqAny[0] <<= OUString( L"string 0");
+ arSeqAny[1] <<= OUString( L"string 1");
+ arSeqAny[2] <<= OUString( L"string 2");
+
+ arAny[3] <<= Sequence< Any >( arAny, 3);
+
+ OUString str(L" Ein Any param");
+ arAny[4] <<= str;
+ arAny[5] <<= sal_False;
+ arAny[6] <<= L'B';
+ OUString stringParam(L" a string parameter");
+ arAny[7] <<= stringParam;
+ float _float= 3.14f;
+ arAny[8] <<= _float;
+ double _double= 3.145;
+ arAny[9] <<= _double;
+ sal_Int8 _byte= -1;
+ arAny[10] <<= _byte;
+ sal_Int16 _short= -1;
+ arAny[11] <<= _short;
+ sal_Int32 _long= -1;
+ arAny[12] <<= _long;
+
+ Sequence<Any> params( arAny, 13);
+
+ xInv->invoke( OUString( L"inoutValuesAll"), params, seqIndices, seqOutParams);
+
+ if( seqOutParams.getLength() == 12)
+ {
+ Reference<XSimple> xSimple= *(XSimple**)seqOutParams[0].getValue();
+ xSimple->func( L"Call from OleTest on XSimple");
+ SimpleStruct aStruct;
+ seqOutParams[1] >>= aStruct;
+ SimpleEnum aEnum= *(SimpleEnum*)seqOutParams[2].getValue();
+
+ Sequence<Any> seqAny;
+ seqOutParams[3] >>= seqAny;
+ for( int i=0; i<seqAny.getLength(); i++)
+ {
+ OUString _s;
+ seqAny[i] >>= _s;
+ }
+
+ Any _any= *(Any*)seqOutParams[4].getValue();
+ sal_Bool _bool= *(sal_Bool*)seqOutParams[5].getValue();
+ sal_Unicode _char= *( sal_Unicode*) seqOutParams[6].getValue();
+ OUString _str= *( rtl_uString**)seqOutParams[7].getValue();
+
+ float _f= *( float*)seqOutParams[8].getValue();
+ double _d= *( double*) seqOutParams[9].getValue();
+ sal_Int8 _byte= *( sal_Int8*) seqOutParams[10].getValue();
+ sal_Int16 _short= *( sal_Int16*) seqOutParams[11].getValue();
+
+ sal_Int32 _long= *( sal_Int32*) seqOutParams[12].getValue();
+
+ }
+ break;
+ }
+ case 303:
+ {
+ Reference<XInterface> xIntFact = m_rFactory->createInstance(
+ L"com.sun.star.bridge.oleautomation.Factory");
+
+ Reference<XMultiServiceFactory> oleFact(xIntFact, UNO_QUERY);
+
+ Reference<XInterface> xIntCallback= oleFact->createInstance(L"XCallback_Impl.Callback");
+ Reference<XInvocation> xInv( xIntCallback, UNO_QUERY);
+ Sequence<sal_Int16> seqIndices;
+ Sequence<Any> seqOutParams;
+
+ Any arAny[3];
+ sal_Unicode aChar=L'a';
+ arAny[0] <<= aChar;
+ sal_Int32 aLong= 0xffffffff;
+ arAny[1] <<= aLong;
+ OUString aString(L" a string parameter");
+ arAny[2] <<= aString;
+
+ xInv->invoke( OUString( L"inValues"), Sequence<Any>(arAny,3), seqIndices, seqOutParams);
+
+ break;
+ }
+ // ############################################################################
+ // Attributes
+ // ############################################################################
+
+ case 400:
+ Reference<XSimple> simple= xCallback->getsimple();
+ simple->func(L"OleTest calls on XSimple");
+ break;
+
+
+ }
+
+}
+
+void SAL_CALL OComponent::setObject( const Reference< XInterface >& val ) throw (RuntimeException)
+{
+ m_xIntIdentity= val;
+}
+
+sal_Bool SAL_CALL OComponent::isSame( const Reference< XInterface >& val ) throw (RuntimeException)
+{
+ if( m_xIntIdentity == val)
+ return sal_True;
+ else
+ return sal_False;
+}
+
+Reference< XInterface > SAL_CALL OComponent::getThis( ) throw (RuntimeException)
+{
+ Reference<XInterface> ret(static_cast<XIdentity*>(this), UNO_QUERY);
+ return ret;
+}
+
+void SAL_CALL EventListener::disposing( const css::lang::EventObject& ) throw (RuntimeException)
+{
+ bCalled= sal_True;
+}
+
+// XSimple --------------------------------------------------------------------------
+void SAL_CALL OComponent::func( const OUString &message)throw(css::uno::RuntimeException)
+{
+ USES_CONVERSION;
+
+ MessageBox( NULL, W2T( message.getStr()), _T("OleTest: XSimple::func"), MB_OK);
+}
+// XSimple --------------------------------------------------------------------------
+OUString SAL_CALL OComponent::getName()throw(css::uno::RuntimeException)
+{
+ return L"XSimple";
+}
+void SAL_CALL OComponent::testInterface2( const Reference< XSimple >& xSimple, sal_Int32 mode ) throw(RuntimeException)
+{
+ switch( mode)
+ {
+ case 0:
+ {
+ xSimple->func( L"OleTest is calling XSimple");
+ Reference<XSimple2> xSimple2( xSimple, UNO_QUERY);
+ if( xSimple2.is())
+ xSimple2->func2( L"OleTest is calling XSimple2");
+ Reference<XSimple3> xSimple3( xSimple, UNO_QUERY);
+ if( xSimple3.is())
+ xSimple3->func3( L"OleTest is calling XSimple3");
+
+ break;
+ }
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */