summaryrefslogtreecommitdiff
path: root/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.idl
blob: de56aac457026ca0138b9c674b6cd26d91c6180c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
/* -*- 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 .
 */
// XCallback_Impl.idl : IDL source for XCallback_Impl.dll


// This file will be processed by the MIDL tool to
// produce the type library (XCallback_Impl.tlb) and marshalling code.

import "oaidl.idl";
import "ocidl.idl";
    [
        object,
        uuid(180FF55F-6F5C-11D4-8330-005004526AB4),
        dual,
        helpstring("ICallback Interface"),
        pointer_default(unique)
    ]
    interface ICallback : IDispatch
    {
        [id(1), helpstring("method func1")] HRESULT func1();
        [id(2), helpstring("method returnInterface")] HRESULT returnInterface([out, retval] IDispatch** ppdisp);
        [id(3), helpstring("method outInterface")] HRESULT outInterface([out] IDispatch** ppdisp);
        [id(4), helpstring("method outValuesMixed")] HRESULT outValuesMixed([in] long val, [out] long* pval, [in] BSTR string);
        [id(5), helpstring("method outValuesAll")] HRESULT outValuesAll([out] IDispatch** ppdisp, [out] IDispatch** ppSimpleStruct, [out] long* aSimpleEnum,
        [out] SAFEARRAY( VARIANT)* outSeq,
        [out] VARIANT* varAny,
        [out] VARIANT_BOOL * aBool,
           [out] short* aChar,
            [out] BSTR* aString ,
            [out] float* aFloat,
            [out] double* aDouble,
            [out] unsigned char*  aByte,
            [out] short* aShort,
            [out]long* aLong);
//      );
        [id(6), helpstring("method outStruct")] HRESULT outStruct([out] IDispatch** outStruct);
        [id(7), helpstring("method outEnum")] HRESULT outEnum([out] long* outEnum);
        [id(8), helpstring("method outSeqAny")] HRESULT outSeqAny([out] SAFEARRAY( VARIANT)* outSeq);
        [id(9), helpstring("method outAny")] HRESULT outAny([out] VARIANT* outAny);
        [id(10), helpstring("method outBool")] HRESULT outBool([out]VARIANT_BOOL* outBool);
        [id(11), helpstring("method outChar")] HRESULT outChar([out] short* outChar);
        [id(12), helpstring("method outString")] HRESULT outString([out] BSTR * outString);
        [id(13), helpstring("method outFloat")] HRESULT outFloat([out] float* outFloat);
        [id(14), helpstring("method outDouble")] HRESULT outDouble([out] double* outDouble);
        [id(16), helpstring("method outShort")] HRESULT outShort([out] short *outShort);
        [id(17), helpstring("method outLong")] HRESULT outLong([out] long* outLong);
        [id(20), helpstring("method outByte")] HRESULT outByte([out] unsigned char* outByte);
        [id(21), helpstring("method inoutInterface")] HRESULT inoutInterface([in,out] IDispatch** ppdisp);
        [id(22), helpstring("method inoutStruct")] HRESULT inoutStruct([in,out] IDispatch** inoutVal);
        [id(23), helpstring("method inoutEnum")] HRESULT inoutEnum([in,out] long * inoutVal);
        [id(24), helpstring("method inoutSeqAny")] HRESULT inoutSeqAny([in,out] SAFEARRAY(VARIANT)* pArray);
        [id(25), helpstring("method inoutAny")] HRESULT inoutAny([in,out] VARIANT* inoutVal);
        [id(26), helpstring("method inoutBool")] HRESULT inoutBool([in,out] VARIANT_BOOL * inoutVal);
        [id(27), helpstring("method inoutChar")] HRESULT inoutChar([in,out] short* inoutVal);
        [id(28), helpstring("method inoutString")] HRESULT inoutString([in,out] BSTR *inoutVal);
        [id(29), helpstring("method inoutFloat")] HRESULT inoutFloat([in,out] float* inoutVal);
        [id(30), helpstring("method inoutDouble")] HRESULT inoutDouble([in,out] double* inoutVal);
        [id(31), helpstring("method inoutByte")] HRESULT inoutByte([in,out] unsigned char* inoutVal);
        [id(32), helpstring("method inoutShort")] HRESULT inoutShort([in,out] short* inoutVal);
        [id(33), helpstring("method inoutLong")] HRESULT inoutLong([in,out] long* inoutVal);
        [id(34), helpstring("method inoutValueAll")] HRESULT inoutValuesAll(
                         [in,out] IDispatch** aXSimple,
                         [in,out] IDispatch** aStruct,
                         [in,out] long* aEnum,
                         [in,out]  SAFEARRAY( VARIANT)* aSeq,
                         [in,out] VARIANT* aAny,
                         [in,out] VARIANT_BOOL* aBool,
                         [in,out] short* aChar,
                         [in,out] BSTR* aString,
                         [in,out] float* aFloat,
                         [in,out] double* aDouble,
                         [in,out] unsigned char* aByte,
                         [in,out] short* aShort,
                         [in,out] long* aLong);
        [id(35), helpstring("method inValues")] HRESULT inValues([in]short aChar, [in] long aLong, [in] BSTR aString);
        [id(36), helpstring("method outSeqByte")] HRESULT outSeqByte([out] SAFEARRAY(unsigned char)* outVal);
        [id(37), helpstring("method inSeqByte")] HRESULT inSeqByte([in] SAFEARRAY(VARIANT) val);
        [id(38), helpstring("method inSeqXEventListener")] HRESULT inSeqXEventListener([in] SAFEARRAY(VARIANT) listener,
                                                                        [in] SAFEARRAY(VARIANT) event);

    };
    [
        object,
        uuid(180FF564-6F5C-11D4-8330-005004526AB4),
        dual,
        helpstring("ISimple Interface"),
        pointer_default(unique)
    ]
    interface ISimple : IDispatch
    {
        [id(1), helpstring("method func")] HRESULT func( [in] BSTR message);
        [id(2), helpstring("method func2")] HRESULT func2([in] BSTR message);
        [id(3), helpstring("method func3")] HRESULT func3([in] BSTR message);
        [propget, id(4), helpstring("property _implementedInterfaces")] HRESULT _implementedInterfaces([out, retval] SAFEARRAY(BSTR) *pVal);
    };



[
    uuid(180FF553-6F5C-11D4-8330-005004526AB4),
    version(1.0),
    helpstring("XCallback_Impl 1.0 Type Library")
]
library XCALLBACK_IMPLLib
{
    importlib("stdole32.tlb");
    importlib("stdole2.tlb");

    [
        uuid(180FF560-6F5C-11D4-8330-005004526AB4),
        helpstring("Callback Class")
    ]
    coclass Callback
    {
        [default] interface ICallback;
    };
    [
        uuid(180FF565-6F5C-11D4-8330-005004526AB4),
        helpstring("Simple Class")
    ]
    coclass Simple
    {
        [default] interface ISimple;
    };
};


/* vim:set shiftwidth=4 softtabstop=4 expandtab: */