1 // Licensed under the Apache License, Version 2.0
2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
4 // All files in the project carrying such notice may not be copied, modified, or distributed
5 // except according to those terms.
6 //! this ALWAYS GENERATED file contains the definitions for the interfaces
7 use ctypes::c_void;
8 use shared::basetsd::UINT64;
9 use shared::guiddef::{CLSID, IID, REFCLSID, REFIID};
10 use shared::minwindef::{BOOL, BYTE, DWORD, FILETIME, HGLOBAL, ULONG, WORD};
11 use shared::ntdef::LONG;
12 use shared::windef::{HBITMAP, HENHMETAFILE};
13 use shared::wtypes::{CLIPFORMAT, HMETAFILEPICT};
14 use shared::wtypesbase::{LPCOLESTR, LPOLESTR, OLECHAR};
15 use um::objidlbase::{IEnumString, IStream, STATSTG};
16 use um::unknwnbase::{IUnknown, IUnknownVtbl};
17 use um::winnt::{HRESULT, ULARGE_INTEGER};
18 //8402
19 STRUCT!{struct BIND_OPTS {
20     cbStruct: DWORD,
21     grfFlags: DWORD,
22     grfMode: DWORD,
23     dwTickCountDeadline: DWORD,
24 }}
25 pub type LPBIND_OPTS = *mut BIND_OPTS;
26 //8479
27 RIDL!{#[uuid(0x0000000e, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
28 interface IBindCtx(IBindCtxVtbl): IUnknown(IUnknownVtbl) {
29     fn RegisterObjectBound(
30         punk: *mut IUnknown,
31     ) -> HRESULT,
32     fn RevokeObjectBound(
33         punk: *mut IUnknown,
34     ) -> HRESULT,
35     fn ReleaseBoundObjects() -> HRESULT,
36     fn SetBindOptions(
37         pbindopts: *mut BIND_OPTS,
38     ) -> HRESULT,
39     fn GetBindOptions(
40         pbindopts: *mut BIND_OPTS,
41     ) -> HRESULT,
42     fn GetRunningObjectTable(
43         pprot: *mut *mut IRunningObjectTable,
44     ) -> HRESULT,
45     fn RegisterObjectParam(
46         pszKey: LPOLESTR,
47         punk: *mut IUnknown,
48     ) -> HRESULT,
49     fn GetObjectParam(
50         pszKey: LPOLESTR,
51         ppunk: *mut *mut IUnknown,
52     ) -> HRESULT,
53     fn EnumObjectParam(
54         ppenum: *mut *mut IEnumString,
55     ) -> HRESULT,
56     fn RevokeObjectParam(
57         pszKey: LPOLESTR,
58     ) -> HRESULT,
59 }}
60 //8681
61 RIDL!{#[uuid(0x00000102, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
62 interface IEnumMoniker(IEnumMonikerVtbl): IUnknown(IUnknownVtbl) {
63     fn Next(
64         celt: ULONG,
65         rgelt: *mut *mut IMoniker,
66         pceltFetched: *mut ULONG,
67     ) -> HRESULT,
68     fn Skip(
69         celt: ULONG,
70     ) -> HRESULT,
71     fn Reset() -> HRESULT,
72     fn Clone(
73         ppenum: *mut *mut IEnumMoniker,
74     ) -> HRESULT,
75 }}
76 //8958
77 RIDL!{#[uuid(0x00000010, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
78 interface IRunningObjectTable(IRunningObjectTableVtbl): IUnknown(IUnknownVtbl) {
79     fn Register(
80         grfFlags: DWORD,
81         punkObject: *mut IUnknown,
82         pmkObjectName: *mut IMoniker,
83         pdwRegister: *mut DWORD,
84     ) -> HRESULT,
85     fn Revoke(
86         dwRegister: DWORD,
87     ) -> HRESULT,
88     fn IsRunning(
89         pmkObjectName: *mut IMoniker,
90     ) -> HRESULT,
91     fn GetObject(
92         pmkObjectName: *mut IMoniker,
93         ppunkObject: *mut *mut IUnknown,
94     ) -> HRESULT,
95     fn NoteChangeTime(
96         dwRegister: DWORD,
97         pfiletime: *mut FILETIME,
98     ) -> HRESULT,
99     fn GetTimeOfLastChange(
100         pmkObjectName: *mut IMoniker,
101         pfiletime: *mut FILETIME,
102     ) -> HRESULT,
103     fn EnumRunning(
104         ppenumMoniker: *mut *mut IEnumMoniker,
105     ) -> HRESULT,
106 }}
107 //9125
108 RIDL!{#[uuid(0x0000010c, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
109 interface IPersist(IPersistVtbl): IUnknown(IUnknownVtbl) {
110     fn GetClassID(
111         pClassID: *mut CLSID,
112     ) -> HRESULT,
113 }}
114 //9207
115 RIDL!{#[uuid(0x00000109, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
116 interface IPersistStream(IPersistStreamVtbl): IPersist(IPersistVtbl) {
117     fn IsDirty() -> HRESULT,
118     fn Load(
119         pStm: *mut IStream,
120     ) -> HRESULT,
121     fn Save(
122         pStm: *mut IStream,
123         fClearDirty: BOOL,
124     ) -> HRESULT,
125     fn GetSizeMax(
126         pcbSize: *mut ULARGE_INTEGER,
127     ) -> HRESULT,
128 }}
129 //9350
130 RIDL!{#[uuid(0x0000000f, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
131 interface IMoniker(IMonikerVtbl): IPersistStream(IPersistStreamVtbl) {
132     fn BindToObject(
133         pbc: *mut IBindCtx,
134         pmkToLeft: *mut IMoniker,
135         riidResult: REFIID,
136         ppvResult: *mut *mut c_void,
137     ) -> HRESULT,
138     fn BindToStorage(
139         pbc: *mut IBindCtx,
140         pmkToLeft: *mut IMoniker,
141         riid: REFIID,
142         ppvObj: *mut *mut c_void,
143     ) -> HRESULT,
144     fn Reduce(
145         pbc: *mut IBindCtx,
146         dwReduceHowFar: DWORD,
147         ppmkToLeft: *mut *mut IMoniker,
148         ppmkReduced: *mut *mut IMoniker,
149     ) -> HRESULT,
150     fn ComposeWith(
151         pmkRight: *mut IMoniker,
152         fOnlyIfNotGeneric: BOOL,
153         ppmkComposite: *mut *mut IMoniker,
154     ) -> HRESULT,
155     fn Enum(
156         fForward: BOOL,
157         ppenumMoniker: *mut *mut IEnumMoniker,
158     ) -> HRESULT,
159     fn IsEqual(
160         pmkOtherMoniker: *mut IMoniker,
161     ) -> HRESULT,
162     fn Hash(
163         pdwHash: *mut DWORD,
164     ) -> HRESULT,
165     fn IsRunning(
166         pbc: *mut IBindCtx,
167         pmkToLeft: *mut IMoniker,
168         pmkNewlyRunning: *mut IMoniker,
169     ) -> HRESULT,
170     fn GetTimeOfLastChange(
171         pbc: *mut IBindCtx,
172         pmkToLeft: *mut IMoniker,
173         pFileTime: *mut FILETIME,
174     ) -> HRESULT,
175     fn Inverse(
176         ppmk: *mut *mut IMoniker,
177     ) -> HRESULT,
178     fn CommonPrefixWith(
179         pmkOther: *mut IMoniker,
180         ppmkPrefix: *mut *mut IMoniker,
181     ) -> HRESULT,
182     fn RelativePathTo(
183         pmkOther: *mut IMoniker,
184         ppmkRelPath: *mut *mut IMoniker,
185     ) -> HRESULT,
186     fn GetDisplayName(
187         pbc: *mut IBindCtx,
188         pmkToLeft: *mut IMoniker,
189         ppszDisplayName: *mut LPOLESTR,
190     ) -> HRESULT,
191     fn ParseDisplayName(
192         pbc: *mut IBindCtx,
193         pmkToLeft: *mut IMoniker,
194         pszDisplayName: LPOLESTR,
195         pchEaten: *mut ULONG,
196         ppmkOut: *mut *mut IMoniker,
197     ) -> HRESULT,
198     fn IsSystemMoniker(
199         pdwMksys: *mut DWORD,
200     ) -> HRESULT,
201 }}
202 ENUM!{enum EOLE_AUTHENTICATION_CAPABILITIES {
203     EOAC_NONE = 0,
204     EOAC_MUTUAL_AUTH = 0x1,
205     EOAC_STATIC_CLOAKING = 0x20,
206     EOAC_DYNAMIC_CLOAKING = 0x40,
207     EOAC_ANY_AUTHORITY = 0x80,
208     EOAC_MAKE_FULLSIC = 0x100,
209     EOAC_DEFAULT = 0x800,
210     EOAC_SECURE_REFS = 0x2,
211     EOAC_ACCESS_CONTROL = 0x4,
212     EOAC_APPID = 0x8,
213     EOAC_DYNAMIC = 0x10,
214     EOAC_REQUIRE_FULLSIC = 0x200,
215     EOAC_AUTO_IMPERSONATE = 0x400,
216     EOAC_NO_CUSTOM_MARSHAL = 0x2000,
217     EOAC_DISABLE_AAA = 0x1000,
218 }}
219 STRUCT!{struct SOLE_AUTHENTICATION_SERVICE {
220     dwAuthnSvc: DWORD,
221     dwAuthzSvc: DWORD,
222     pPrincipalName: *mut OLECHAR,
223     hr: HRESULT,
224 }}
225 RIDL!{#[uuid(0x0000000d, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
226 interface IEnumSTATSTG(IEnumSTATSTGVtbl): IUnknown(IUnknownVtbl) {
227     fn Next(
228         celt: ULONG,
229         rgelt: *mut STATSTG,
230         pceltFetched: *mut ULONG,
231     ) -> HRESULT,
232     fn Skip(
233         celt: ULONG,
234     ) -> HRESULT,
235     fn Reset() -> HRESULT,
236     fn Clone(
237         ppenum: *mut *mut IEnumSTATSTG,
238     ) -> HRESULT,
239 }}
240 pub type SNB = *const *const OLECHAR;
241 RIDL!{#[uuid(0x0000000b, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
242 interface IStorage(IStorageVtbl): IUnknown(IUnknownVtbl) {
243     fn CreateStream(
244         pwcsName: *const OLECHAR,
245         grfMode: DWORD,
246         reserved1: DWORD,
247         reserved2: DWORD,
248         ppstm: *mut *mut IStream,
249     ) -> HRESULT,
250     fn OpenStream(
251         pwcsName: *const OLECHAR,
252         reserved1: *const c_void,
253         grfMode: DWORD,
254         reserved2: DWORD,
255         ppstm: *mut *mut IStream,
256     ) -> HRESULT,
257     fn CreateStorage(
258         pwcsName: *const OLECHAR,
259         grfMode: DWORD,
260         reserved1: DWORD,
261         reserved2: DWORD,
262         ppstg: *mut *mut IStorage,
263     ) -> HRESULT,
264     fn OpenStorage(
265         pwcsName: *const OLECHAR,
266         pstgPriority: IStorage,
267         grfMode: DWORD,
268         snbExclude: SNB,
269         reserved: DWORD,
270         ppstg: *mut *mut IStorage,
271     ) -> HRESULT,
272     fn CopyTo(
273         ciidExclude: DWORD,
274         rgiidExclude: *const IID,
275         snbExclude: SNB,
276         pstgDest: *const IStorage,
277     ) -> HRESULT,
278     fn MoveElementTo(
279         pwcsName: *const OLECHAR,
280         pstgDest: *const IStorage,
281         pwcsNewName: *const OLECHAR,
282         grfFlags: DWORD,
283     ) -> HRESULT,
284     fn Commit(
285         grfCommitFlags: DWORD,
286     ) -> HRESULT,
287     fn Revert() -> HRESULT,
288     fn EnumElements(
289         reserved1: DWORD,
290         reserved2: *const c_void,
291         reserved3: DWORD,
292         ppenum: *mut *mut IEnumSTATSTG,
293     ) -> HRESULT,
294     fn DestroyElement(
295         pwcsName: *const OLECHAR,
296     ) -> HRESULT,
297     fn RenameElement(
298         pwcsOldName: *const OLECHAR,
299         pwcsNewName: *const OLECHAR,
300     ) -> HRESULT,
301     fn SetElementTimes(
302         pwcsName: *const OLECHAR,
303         pctime: *const FILETIME,
304         patime: *const FILETIME,
305         pmtime: *const FILETIME,
306     ) -> HRESULT,
307     fn SetClass(
308         clsid: REFCLSID,
309     ) -> HRESULT,
310     fn SetStateBits(
311         grfStateBits: DWORD,
312         grfMask: DWORD,
313     ) -> HRESULT,
314     fn Stat(
315         pstatstg: *mut STATSTG,
316         grfStatFlag: DWORD,
317     ) -> HRESULT,
318 }}
319 RIDL!{#[uuid(0x0000010b, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
320 interface IPersistFile(IPersistFileVtbl): IPersist(IPersistVtbl) {
321     fn IsDirty() -> HRESULT,
322     fn Load(
323         pszFileName: LPCOLESTR,
324         dwMode: DWORD,
325     ) -> HRESULT,
326     fn Save(
327         pszFileName: LPCOLESTR,
328         fRemember: BOOL,
329     ) -> HRESULT,
330     fn SaveCompleted(
331         pszFileName: LPCOLESTR,
332     ) -> HRESULT,
333     fn GetCurFile(
334         ppszFileName: *mut LPOLESTR,
335     ) -> HRESULT,
336 }}
337 STRUCT!{struct DVTARGETDEVICE {
338     tdSize: DWORD,
339     tdDriverNameOffset: WORD,
340     tdDeviceNameOffset: WORD,
341     tdPortNameOffset: WORD,
342     tdExtDevmodeOFfset: WORD,
343     tdData: [BYTE; 1],
344 }}
345 STRUCT!{struct FORMATETC {
346     cfFormat: CLIPFORMAT,
347     ptd: *const DVTARGETDEVICE,
348     dwAspect: DWORD,
349     lindex: LONG,
350     tymed: DWORD,
351 }}
352 RIDL!{#[uuid(0x00000103, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
353 interface IEnumFORMATETC(IEnumFORMATETCVtbl): IUnknown(IUnknownVtbl) {
354     fn Next(
355         celt: ULONG,
356         rgelt: *mut FORMATETC,
357         pceltFetched: *mut ULONG,
358     ) -> HRESULT,
359     fn Skip(
360         celt: ULONG,
361     ) -> HRESULT,
362     fn Reset() -> HRESULT,
363     fn Clone(
364         ppenum: *mut *mut IEnumFORMATETC,
365     ) -> HRESULT,
366 }}
367 ENUM!{enum ADVF {
368     ADVF_NODATA = 1,
369     ADVF_PRIMEFIRST = 2,
370     ADVF_ONLYONCE = 4,
371     ADVF_DATAONSTOP = 64,
372     ADVFCACHE_NOHANDLER = 8,
373     ADVFCACHE_FORCEBUILTIN = 16,
374     ADVFCACHE_ONSAVE = 32,
375 }}
376 STRUCT!{struct STATDATA {
377     formatetc: FORMATETC,
378     advf: DWORD,
379     pAdvSInk: *mut IAdviseSink,
380     dwConnection: DWORD,
381 }}
382 RIDL!{#[uuid(0x00000105, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
383 interface IEnumSTATDATA(IEnumSTATDATAVtbl): IUnknown(IUnknownVtbl) {
384     fn Next(
385         celt: ULONG,
386         rgelt: *mut STATDATA,
387         pceltFetched: *mut ULONG,
388     ) -> HRESULT,
389     fn Skip(
390         celt: ULONG,
391     ) -> HRESULT,
392     fn Reset() -> HRESULT,
393     fn Clone(
394         ppenum: *mut *mut IEnumSTATDATA,
395     ) -> HRESULT,
396 }}
397 ENUM!{enum TYMED {
398     TYMED_HGLOBAL = 1,
399     TYMED_FILE = 2,
400     TYMED_ISTREAM = 4,
401     TYMED_ISTORAGE = 8,
402     TYMED_GDI = 16,
403     TYMED_MFPICT = 32,
404     TYMED_ENHMF = 64,
405     TYMED_NULL = 0,
406 }}
407 UNION!{union STGMEDIUM_u {
408     [u64; 7], //TODO: I guessed to move on
409     hBitmap hBitmap_mut: HBITMAP,
410     hMetaFilePict hMetaFilePict_mut: HMETAFILEPICT,
411     hEnhMetaFile hEnhMetaFile_mut: HENHMETAFILE,
412     hGlobal hGlobal_mut: HGLOBAL,
413     lpszFileName lpszFileName_mut: LPOLESTR,
414     pstm pstm_mut: *mut IStream,
415     pstg pstg_mut: *mut IStorage,
416 }}
417 STRUCT!{struct STGMEDIUM {
418     tymed: DWORD,
419     u: *mut STGMEDIUM_u,
420     pUnkForRelease: *mut IUnknown,
421 }}
422 RIDL!{#[uuid(0x0000010f, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
423 interface IAdviseSink(IAdviseSinkVtbl): IUnknown(IUnknownVtbl) {
424     fn OnDataChange(
425         pformatetc: *mut FORMATETC,
426         pStgmed: *mut STGMEDIUM,
427     ) -> c_void,
428     fn OnViewChange(
429         dwAspect: DWORD,
430         lindex: LONG,
431     ) -> c_void,
432     fn OnRename(
433         pmk: *mut IMoniker,
434     ) -> c_void,
435     fn OnSave() -> c_void,
436     fn OnClose() -> c_void,
437 }}
438 ENUM!{enum DATADIR {
439     DATADIR_GET = 1,
440     DATADIR_SET = 2,
441 }}
442 pub type LPDATAOBJECT = *mut IDataObject;
443 RIDL!{#[uuid(0x0000010e, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
444 interface IDataObject(IDataObjectVtbl): IUnknown(IUnknownVtbl) {
445     fn GetData(
446         pformatetcIn: *const FORMATETC,
447         pmedium: *mut STGMEDIUM,
448     ) -> HRESULT,
449     fn GetDataHere(
450         pformatetc: *const FORMATETC,
451         pmedium: *mut STGMEDIUM,
452     ) -> HRESULT,
453     fn QueryGetData(
454         pformatetc: *const FORMATETC,
455     ) -> HRESULT,
456     fn GetCanonicalFormatEtc(
457         pformatetcIn: *const FORMATETC,
458         pformatetcOut: *mut FORMATETC,
459     ) -> HRESULT,
460     fn SetData(
461         pformatetc: *const FORMATETC,
462         pformatetcOut: *const FORMATETC,
463         fRelease: BOOL,
464     ) -> HRESULT,
465     fn EnumFormatEtc(
466         dwDirection: DWORD,
467         ppenumFormatEtc: *mut *mut IEnumFORMATETC,
468     ) -> HRESULT,
469     fn DAdvise(
470         pformatetc: *const FORMATETC,
471         advf: DWORD,
472         pAdvSInk: *const IAdviseSink,
473         pdwConnection: *mut DWORD,
474     ) -> HRESULT,
475     fn DUnadvise(
476         dwConnection: DWORD,
477     ) -> HRESULT,
478     fn EnumDAdvise(
479         ppenumAdvise: *const *const IEnumSTATDATA,
480     ) -> HRESULT,
481 }}
482 RIDL!{#[uuid(0xa2f05a09, 0x27a2, 0x42b5, 0xbc, 0x0e, 0xac, 0x16, 0x3e, 0xf4, 0x9d, 0x9b)]
483 interface IApartmentShutdown(IApartmentShutdownVtbl): IUnknown(IUnknownVtbl) {
484     fn OnUninitialize(
485         ui64ApartmentIdentifier: UINT64,
486     ) -> (),
487 }}
488 RIDL!{#[uuid(0x00000003, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
489 interface IMarshal(IMarshalVtbl): IUnknown(IUnknownVtbl) {
490     fn GetUnmarshalClass(
491         riid: REFIID,
492         pv: *mut c_void,
493         dwDestContext: DWORD,
494         pvDestContext: *mut c_void,
495         mshlflags: DWORD,
496         pCid: *mut CLSID,
497     ) -> HRESULT,
498     fn GetMarshalSizeMax(
499         riid: REFIID,
500         pv: *mut c_void,
501         dwDestContext: DWORD,
502         pvDestContext: *mut c_void,
503         mshlflags: DWORD,
504         pSize: *mut DWORD,
505     ) -> HRESULT,
506     fn MarshalInterface(
507         pStm: *mut IStream,
508         riid: REFIID,
509         pv: *mut c_void,
510         dwDestContext: DWORD,
511         pvDestContext: *mut c_void,
512         mshlflags: DWORD,
513     ) -> HRESULT,
514     fn UnmarshalInterface(
515         pStm: *mut IStream,
516         riid: REFIID,
517         ppv: *mut *mut c_void,
518     ) -> HRESULT,
519     fn ReleaseMarshalData(
520         pStm: *mut IStream,
521     ) -> HRESULT,
522     fn DisconnectObject(
523         dwReserved: DWORD,
524     ) -> HRESULT,
525 }}
526