Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 301 insertions, 0 deletions

diff --git a/extensions/test/ole/idl/oletest.idl b/extensions/test/ole/idl/oletest.idl
new file mode 100644
index 000000000..b23f20b21
--- /dev/null
+++ b/extensions/test/ole/idl/oletest.idl
@@ -0,0 +1,301 @@
+/* -*- 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 .
+ */
+
+#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
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */