AOO410/main/extensions/test/ole/idl/oletest.idl

/**************************************************************
 * 
 * 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
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



#include <com/sun/star/uno/XInterface.idl>
#include <com/sun/star/script/XInvocation.idl>
#include <com/sun/star/beans/XPropertySet.idl>
#include <com/sun/star/lang/XEventListener.idl>


module oletest
{

interface XTestSequence: com::sun::star::uno::XInterface
{
	sequence<byte> methodByte( [in] sequence<byte> aSeq );
	sequence<float> methodFloat( [in] sequence<float> aSeq);
	sequence<double> methodDouble( [in] sequence<double> aSeq);
	sequence<boolean> methodBool( [in] sequence<boolean> aSeq);
	sequence<short> methodShort( [in] sequence<short> aSeq);
	sequence<unsigned short> methodUShort( [in] sequence<unsigned short> aSeq);
	sequence<long> methodLong( [in] sequence<long> aSeq);
	sequence<unsigned long> methodULong( [in] sequence<unsigned long> aSeq);
	sequence<string> methodString( [in] sequence<string> aSeq);
	sequence<char> methodChar( [in] sequence<char> aSeq);
	sequence<any> methodAny	( [in] sequence<any> aSeq);
    sequence<type> methodType	( [in] sequence<type> aSeq);
	sequence<com::sun::star::uno::XInterface> methodXInterface ( [in] sequence<com::sun::star::uno::XInterface> aSeq);
	sequence< sequence <long> > methodSequence( [in] sequence< sequence< long > > aSeq);
	sequence< sequence <sequence <long> > > methodSequence2( [in] sequence< sequence< sequence<long> > > aSeq);
    sequence< com::sun::star::lang::XEventListener > methodXEventListeners( [in] sequence<com::sun::star::lang::XEventListener> aSeq);
    sequence< sequence< com::sun::star::lang::XEventListener > > methodXEventListenersMul( [in] sequence< sequence< com::sun::star::lang::XEventListener> > aSeq);

	[attribute] sequence<byte> AttrByte;
	[attribute] sequence<float> AttrFloat;
	[attribute] sequence<double> AttrDouble;
	[attribute] sequence<boolean> AttrBool;
	[attribute] sequence<short> AttrShort;
	[attribute] sequence<unsigned short> AttrUShort;
	[attribute] sequence<long> AttrLong;
	[attribute] sequence<unsigned long> AttrULong;
	[attribute] sequence<string> AttrString;
	[attribute] sequence<char> AttrChar;
	[attribute] sequence<any> AttrAny;
    [attribute] sequence<type> AttrType;
	[attribute] sequence< sequence<long> > AttrSequence;
	[attribute] sequence< sequence< sequence <long> > > AttrSequence2;
	[attribute] sequence< com::sun::star::uno::XInterface > AttrXInterface;

	[attribute] byte AByte;
	[attribute] float AFloat;
	[attribute] double ADouble;
	[attribute] boolean ABool;
	[attribute] short AShort;
	[attribute] unsigned short AUShort;
	[attribute] long ALong;
	[attribute] unsigned long AULong;
	[attribute] string AString;
	[attribute] char AChar;
	[attribute] any AAny;
    [attribute] type AType;
	[attribute] com::sun::star::uno::XInterface  AXInterface;
    [attribute] com::sun::star::script::XInvocation  AXInvocation;    

	void testout_methodByte( [out] byte rOut );
	void testout_methodFloat( [out] float rOut);
	void testout_methodDouble( [out] double rOut);
	void testout_methodBool( [out] boolean rOut);
	void testout_methodShort( [out] short rOut);
	void testout_methodUShort( [out] unsigned short rOut);
	void testout_methodLong( [out]  long rOut);
	void testout_methodULong( [out] unsigned long rOut);
 	void testout_methodHyper( [out]  hyper rOut);
 	void testout_methodUHyper( [out] unsigned hyper rOut);
    void testout_methodString( [out] string rOut);
	void testout_methodChar( [out] char rOut);
	void testout_methodAny	( [out] any rOut);
    void testout_methodType	( [out] type rOut);
	void testout_methodSequence( [out] sequence< long > rOut);
	void testout_methodSequence2( [out] sequence < sequence< long > > rOut);
	void testout_methodXInterface( [out] com::sun::star::uno::XInterface rOut);

	void testout_methodMulParams1( [out] long rout1, [out] long rout2);
	void testout_methodMulParams2( [out] long rout1, [out] long rout2, [out] string rout3);
	void testout_methodMulParams3( [in] string sin, [out] string sout);
	void testout_methodMulParams4( [in] float in1, [out] float out1, [in] long in2, [out] long out2, [in] long in3);

	void testinout_methodByte( [inout] byte rOut );
	void testinout_methodFloat( [inout] float rOut);
	void testinout_methodDouble( [inout] double rOut);
	void testinout_methodBool( [inout] boolean rOut);
	void testinout_methodShort( [inout] short rOut);
	void testinout_methodUShort( [inout] unsigned short rOut);
	void testinout_methodLong( [inout]  long rOut);
	void testinout_methodULong( [inout] unsigned long rOut);
	void testinout_methodHyper( [inout]  hyper rOut);
	void testinout_methodUHyper( [inout] unsigned hyper rOut);
    void testinout_methodString( [inout] string rOut);
	void testinout_methodChar( [inout] char rOut);
	void testinout_methodAny	( [inout] any rOut);
    void testinout_methodType	( [inout] type rOut);
	void testinout_methodSequence( [inout] sequence< long > rOut);
	void testinout_methodSequence2( [inout] sequence < sequence< long > > rOut);
	void testinout_methodXInterface( [inout] com::sun::star::script::XInvocation rOut);
	void testinout_methodXInterface2( [inout] com::sun::star::uno::XInterface rOut);

	any methodAnyTest1( [in] any rIn);
	[attribute]  any AttrAny2;

};
interface XTestStruct: com::sun::star::uno::XInterface
{
// Method taking structs as arguments
	void methodStruct( [in] com::sun::star::beans::Property aProp);
//	Methods returning structs
	com::sun::star::beans::Property retMethodStruct();
// Attributes as structs
	[attribute] com::sun::star::beans::Property AttrStruct;

    com::sun::star::beans::Property methodStruct2( [in] com::sun::star::beans::Property aProp);
};


struct SimpleStruct
{
	string message;
};

interface XTestInParameters: com::sun::star::uno::XInterface
{
	byte in_methodByte( [in] byte rIn );
	float in_methodFloat( [in] float rIn);
	double in_methodDouble( [in] double rIn);
	boolean in_methodBool( [in] boolean rIn);
	short in_methodShort( [in] short rIn);
	unsigned short in_methodUShort( [in] unsigned short rIn);
	long in_methodLong( [in]  long rIn);
	unsigned long in_methodULong( [in] unsigned long rIn);
    hyper in_methodHyper( [in]  hyper rIn);
	unsigned hyper in_methodUHyper( [in] unsigned hyper rIn);
	string in_methodString( [in] string rIn);
	char in_methodChar( [in] char rIn);
	any in_methodAny	( [in] any rIn);
    type in_methodType	( [in] type rIn);
    com::sun::star::uno::XInterface in_methodXInterface([in] com::sun::star::uno::XInterface rIn);
	com::sun::star::script::XInvocation in_methodInvocation( [in] com::sun::star::script::XInvocation inv);
	SimpleStruct in_methodStruct( [in] SimpleStruct aStruct);
	void in_methodAll( [in] byte b, [in] float f, [in] double d, [in] boolean abool, [in]short sh,
					   [in] unsigned short us, [in] long l, [in] unsigned long ul,
					   [in] string s, [in] char c, [in] any a, [in] type t, [in] com::sun::star::script::XInvocation inv);
};


enum SimpleEnum
{
	A,
	B,
	C
};

interface XTestOther: com::sun::star::uno::XInterface
{
	// Any test
	void other_methodAnyIn( [in] any rAny);
	void other_methodAnyOut( [out] any rAny);
	any other_methodAnyRet();
	void in_float( [in] float val);
    //typeInAny determines what type must be in rAny. If rAny contains
    //a different type then an exception is being thrown
    any other_methodAny([in] any rAny, [in] string typeInAny);
};


interface XSimple: com::sun::star::uno::XInterface
{
	void func( [in] string message);
	string getName();
};

interface XSimple2: com::sun::star::uno::XInterface
{
	void func2( [in] string message);
	string getName2();
};

interface XSimple3: com::sun::star::uno::XInterface
{
	void func3( [in] string message);
	string getName3();
};


interface XCallback: com::sun::star::uno::XInterface
{
	void func1();
	oletest::XSimple returnInterface();
	void outInterface( [out] oletest::XSimple outInterface);
	void outStruct( [out] oletest::SimpleStruct outStruct);
	void outEnum( [out] oletest::SimpleEnum outEnum);
	void outSeqAny( [out] sequence<any> outSeqAny);
	void outSeqByte( [out] sequence<byte> outVal);
	void outAny( [out] any outAny);
	void outBool( [out] boolean outBool);
	void outChar( [out] char outChar);
	void outString( [out] string outString);
	void outFloat( [out] float outFloat);
	void outDouble( [out] double outDouble);
	void outByte( [out] byte outByte);
	void outShort( [out] short outShort);
	void outLong( [out] long outLong);
	void outValuesMixed( [in] long lval, [out] long outval, [in] string sval);
	void outValuesAll( [out] oletest::XSimple outInterface,
					   [out] SimpleStruct outStruct ,
					   [out] SimpleEnum outEnum,
					   [out] sequence<any> outSeqAny,
					   [out] any outAny,
					   [out] boolean outBool,
					   [out] char outChar,
					   [out] string outString,
					   [out] float outFloat,
					   [out] double outDouble,
					   [out] byte	outByte,
					   [out] short outShort,
					   [out] long outLong);
// IN OUT parameters
	void inoutInterface( [inout] oletest::XSimple inoutVal);
	void inoutStruct( [inout] oletest::SimpleStruct inoutVal);
	void inoutEnum( [inout] oletest::SimpleEnum inoutVal);
	void inoutSeqAny( [inout] sequence<any> inoutVal);
	void inoutAny( [inout] any inoutVal);
	void inoutBool( [inout] boolean inoutVal);
	void inoutChar( [inout] char inoutVal);
	void inoutString( [inout] string inoutVal);
	void inoutFloat( [inout] float inoutVal);
	void inoutDouble( [inout] double inoutVal);
	void inoutByte( [inout] byte inoutVal);
	void inoutShort( [inout] short inoutVal);
	void inoutLong( [inout] long inoutVal);

	void inoutValuesAll( [inout] oletest::XSimple aXSimple,
						 [inout] oletest::SimpleStruct aStruct,
						 [inout] oletest::SimpleEnum aEnum,
						 [inout] sequence<any> aSeq,
						 [inout] any aAny,
						 [inout] boolean aBool,
						 [inout] char aChar,
						 [inout] string aString,
						 [inout] float aFloat,
						 [inout] double aDouble,
						 [inout] byte aByte,
						 [inout] short aShort,
						 [inout] long aLong);

	// IN parameter

	void inValues( [in] char aChar, [in] long aLong, [in] string aString);
	void inSeqByte( [in] sequence<byte> val);
    void inSeqXEventListener( [in] sequence<com::sun::star::lang::XEventListener> listener, [in]
                              sequence<com::sun::star::lang::EventObject> events);
	
	// Attributes
	[attribute] oletest::XSimple simple;




};

interface XTestInterfaces: com::sun::star::uno::XInterface
{
	// Any test
	void testInterface( [in] oletest::XCallback xCallback, [in] long mode);
	void testInterface2( [in] oletest::XSimple xSimple, [in] long mode);
};

interface XIdentity: com::sun::star::uno::XInterface
{
    void setObject([in] com::sun::star::uno::XInterface val);
    boolean isSame( [in] com::sun::star::uno::XInterface val);

    com::sun::star::uno::XInterface getThis();
};

}; // oletest