[rustc.git] / vendor / winapi / src / um / objidl.rs

// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// All files in the project carrying such notice may not be copied, modified, or distributed
// except according to those terms.
//! this ALWAYS GENERATED file contains the definitions for the interfaces
use ctypes::c_void;
use shared::basetsd::UINT64;
use shared::guiddef::{CLSID, IID, REFCLSID, REFIID};
use shared::minwindef::{BOOL, BYTE, DWORD, FILETIME, HGLOBAL, ULONG, WORD};
use shared::ntdef::LONG;
use shared::windef::{HBITMAP, HENHMETAFILE};
use shared::wtypes::{CLIPFORMAT, HMETAFILEPICT};
use shared::wtypesbase::{LPOLESTR, OLECHAR};
use um::objidlbase::{IEnumString, IStream, STATSTG};
use um::unknwnbase::{IUnknown, IUnknownVtbl};
use um::winnt::{HRESULT, ULARGE_INTEGER};
//8402
STRUCT!{struct BIND_OPTS {
    cbStruct: DWORD,
    grfFlags: DWORD,
    grfMode: DWORD,
    dwTickCountDeadline: DWORD,
}}
pub type LPBIND_OPTS = *mut BIND_OPTS;
//8479
RIDL!{#[uuid(0x0000000e, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IBindCtx(IBindCtxVtbl): IUnknown(IUnknownVtbl) {
    fn RegisterObjectBound(
        punk: *mut IUnknown,
    ) -> HRESULT,
    fn RevokeObjectBound(
        punk: *mut IUnknown,
    ) -> HRESULT,
    fn ReleaseBoundObjects() -> HRESULT,
    fn SetBindOptions(
        pbindopts: *mut BIND_OPTS,
    ) -> HRESULT,
    fn GetBindOptions(
        pbindopts: *mut BIND_OPTS,
    ) -> HRESULT,
    fn GetRunningObjectTable(
        pprot: *mut *mut IRunningObjectTable,
    ) -> HRESULT,
    fn RegisterObjectParam(
        pszKey: LPOLESTR,
        punk: *mut IUnknown,
    ) -> HRESULT,
    fn GetObjectParam(
        pszKey: LPOLESTR,
        ppunk: *mut *mut IUnknown,
    ) -> HRESULT,
    fn EnumObjectParam(
        ppenum: *mut *mut IEnumString,
    ) -> HRESULT,
    fn RevokeObjectParam(
        pszKey: LPOLESTR,
    ) -> HRESULT,
}}
//8681
RIDL!{#[uuid(0x00000102, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IEnumMoniker(IEnumMonikerVtbl): IUnknown(IUnknownVtbl) {
    fn Next(
        celt: ULONG,
        rgelt: *mut *mut IMoniker,
        pceltFetched: *mut ULONG,
    ) -> HRESULT,
    fn Skip(
        celt: ULONG,
    ) -> HRESULT,
    fn Reset() -> HRESULT,
    fn Clone(
        ppenum: *mut *mut IEnumMoniker,
    ) -> HRESULT,
}}
//8958
RIDL!{#[uuid(0x00000010, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IRunningObjectTable(IRunningObjectTableVtbl): IUnknown(IUnknownVtbl) {
    fn Register(
        grfFlags: DWORD,
        punkObject: *mut IUnknown,
        pmkObjectName: *mut IMoniker,
        pdwRegister: *mut DWORD,
    ) -> HRESULT,
    fn Revoke(
        dwRegister: DWORD,
    ) -> HRESULT,
    fn IsRunning(
        pmkObjectName: *mut IMoniker,
    ) -> HRESULT,
    fn GetObject(
        pmkObjectName: *mut IMoniker,
        ppunkObject: *mut *mut IUnknown,
    ) -> HRESULT,
    fn NoteChangeTime(
        dwRegister: DWORD,
        pfiletime: *mut FILETIME,
    ) -> HRESULT,
    fn GetTimeOfLastChange(
        pmkObjectName: *mut IMoniker,
        pfiletime: *mut FILETIME,
    ) -> HRESULT,
    fn EnumRunning(
        ppenumMoniker: *mut *mut IEnumMoniker,
    ) -> HRESULT,
}}
//9125
RIDL!{#[uuid(0x0000010c, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IPersist(IPersistVtbl): IUnknown(IUnknownVtbl) {
    fn GetClassID(
        pClassID: *mut CLSID,
    ) -> HRESULT,
}}
//9207
RIDL!{#[uuid(0x00000109, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IPersistStream(IPersistStreamVtbl): IPersist(IPersistVtbl) {
    fn IsDirty() -> HRESULT,
    fn Load(
        pStm: *mut IStream,
    ) -> HRESULT,
    fn Save(
        pStm: *mut IStream,
        fClearDirty: BOOL,
    ) -> HRESULT,
    fn GetSizeMax(
        pcbSize: *mut ULARGE_INTEGER,
    ) -> HRESULT,
}}
//9350
RIDL!{#[uuid(0x0000000f, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IMoniker(IMonikerVtbl): IPersistStream(IPersistStreamVtbl) {
    fn BindToObject(
        pbc: *mut IBindCtx,
        pmkToLeft: *mut IMoniker,
        riidResult: REFIID,
        ppvResult: *mut *mut c_void,
    ) -> HRESULT,
    fn BindToStorage(
        pbc: *mut IBindCtx,
        pmkToLeft: *mut IMoniker,
        riid: REFIID,
        ppvObj: *mut *mut c_void,
    ) -> HRESULT,
    fn Reduce(
        pbc: *mut IBindCtx,
        dwReduceHowFar: DWORD,
        ppmkToLeft: *mut *mut IMoniker,
        ppmkReduced: *mut *mut IMoniker,
    ) -> HRESULT,
    fn ComposeWith(
        pmkRight: *mut IMoniker,
        fOnlyIfNotGeneric: BOOL,
        ppmkComposite: *mut *mut IMoniker,
    ) -> HRESULT,
    fn Enum(
        fForward: BOOL,
        ppenumMoniker: *mut *mut IEnumMoniker,
    ) -> HRESULT,
    fn IsEqual(
        pmkOtherMoniker: *mut IMoniker,
    ) -> HRESULT,
    fn Hash(
        pdwHash: *mut DWORD,
    ) -> HRESULT,
    fn IsRunning(
        pbc: *mut IBindCtx,
        pmkToLeft: *mut IMoniker,
        pmkNewlyRunning: *mut IMoniker,
    ) -> HRESULT,
    fn GetTimeOfLastChange(
        pbc: *mut IBindCtx,
        pmkToLeft: *mut IMoniker,
        pFileTime: *mut FILETIME,
    ) -> HRESULT,
    fn Inverse(
        ppmk: *mut *mut IMoniker,
    ) -> HRESULT,
    fn CommonPrefixWith(
        pmkOther: *mut IMoniker,
        ppmkPrefix: *mut *mut IMoniker,
    ) -> HRESULT,
    fn RelativePathTo(
        pmkOther: *mut IMoniker,
        ppmkRelPath: *mut *mut IMoniker,
    ) -> HRESULT,
    fn GetDisplayName(
        pbc: *mut IBindCtx,
        pmkToLeft: *mut IMoniker,
        ppszDisplayName: *mut LPOLESTR,
    ) -> HRESULT,
    fn ParseDisplayName(
        pbc: *mut IBindCtx,
        pmkToLeft: *mut IMoniker,
        pszDisplayName: LPOLESTR,
        pchEaten: *mut ULONG,
        ppmkOut: *mut *mut IMoniker,
    ) -> HRESULT,
    fn IsSystemMoniker(
        pdwMksys: *mut DWORD,
    ) -> HRESULT,
}}
ENUM!{enum EOLE_AUTHENTICATION_CAPABILITIES {
    EOAC_NONE = 0,
    EOAC_MUTUAL_AUTH = 0x1,
    EOAC_STATIC_CLOAKING = 0x20,
    EOAC_DYNAMIC_CLOAKING = 0x40,
    EOAC_ANY_AUTHORITY = 0x80,
    EOAC_MAKE_FULLSIC = 0x100,
    EOAC_DEFAULT = 0x800,
    EOAC_SECURE_REFS = 0x2,
    EOAC_ACCESS_CONTROL = 0x4,
    EOAC_APPID = 0x8,
    EOAC_DYNAMIC = 0x10,
    EOAC_REQUIRE_FULLSIC = 0x200,
    EOAC_AUTO_IMPERSONATE = 0x400,
    EOAC_NO_CUSTOM_MARSHAL = 0x2000,
    EOAC_DISABLE_AAA = 0x1000,
}}
STRUCT!{struct SOLE_AUTHENTICATION_SERVICE {
    dwAuthnSvc: DWORD,
    dwAuthzSvc: DWORD,
    pPrincipalName: *mut OLECHAR,
    hr: HRESULT,
}}
RIDL!{#[uuid(0x0000000d, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IEnumSTATSTG(IEnumSTATSTGVtbl): IUnknown(IUnknownVtbl) {
    fn Next(
        celt: ULONG,
        rgelt: *mut STATSTG,
        pceltFetched: *mut ULONG,
    ) -> HRESULT,
    fn Skip(
        celt: ULONG,
    ) -> HRESULT,
    fn Reset() -> HRESULT,
    fn Clone(
        ppenum: *mut *mut IEnumSTATSTG,
    ) -> HRESULT,
}}
pub type SNB = *const *const OLECHAR;
RIDL!{#[uuid(0x0000000b, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IStorage(IStorageVtbl): IUnknown(IUnknownVtbl) {
    fn CreateStream(
        pwcsName: *const OLECHAR,
        grfMode: DWORD,
        reserved1: DWORD,
        reserved2: DWORD,
        ppstm: *mut *mut IStream,
    ) -> HRESULT,
    fn OpenStream(
        pwcsName: *const OLECHAR,
        reserved1: *const c_void,
        grfMode: DWORD,
        reserved2: DWORD,
        ppstm: *mut *mut IStream,
    ) -> HRESULT,
    fn CreateStorage(
        pwcsName: *const OLECHAR,
        grfMode: DWORD,
        reserved1: DWORD,
        reserved2: DWORD,
        ppstg: *mut *mut IStorage,
    ) -> HRESULT,
    fn OpenStorage(
        pwcsName: *const OLECHAR,
        pstgPriority: IStorage,
        grfMode: DWORD,
        snbExclude: SNB,
        reserved: DWORD,
        ppstg: *mut *mut IStorage,
    ) -> HRESULT,
    fn CopyTo(
        ciidExclude: DWORD,
        rgiidExclude: *const IID,
        snbExclude: SNB,
        pstgDest: *const IStorage,
    ) -> HRESULT,
    fn MoveElementTo(
        pwcsName: *const OLECHAR,
        pstgDest: *const IStorage,
        pwcsNewName: *const OLECHAR,
        grfFlags: DWORD,
    ) -> HRESULT,
    fn Commit(
        grfCommitFlags: DWORD,
    ) -> HRESULT,
    fn Revert() -> HRESULT,
    fn EnumElements(
        reserved1: DWORD,
        reserved2: *const c_void,
        reserved3: DWORD,
        ppenum: *mut *mut IEnumSTATSTG,
    ) -> HRESULT,
    fn DestroyElement(
        pwcsName: *const OLECHAR,
    ) -> HRESULT,
    fn RenameElement(
        pwcsOldName: *const OLECHAR,
        pwcsNewName: *const OLECHAR,
    ) -> HRESULT,
    fn SetElementTimes(
        pwcsName: *const OLECHAR,
        pctime: *const FILETIME,
        patime: *const FILETIME,
        pmtime: *const FILETIME,
    ) -> HRESULT,
    fn SetClass(
        clsid: REFCLSID,
    ) -> HRESULT,
    fn SetStateBits(
        grfStateBits: DWORD,
        grfMask: DWORD,
    ) -> HRESULT,
    fn Stat(
        pstatstg: *mut STATSTG,
        grfStatFlag: DWORD,
    ) -> HRESULT,
}}
STRUCT!{struct DVTARGETDEVICE {
    tdSize: DWORD,
    tdDriverNameOffset: WORD,
    tdDeviceNameOffset: WORD,
    tdPortNameOffset: WORD,
    tdExtDevmodeOFfset: WORD,
    tdData: [BYTE; 1],
}}
STRUCT!{struct FORMATETC {
    cfFormat: CLIPFORMAT,
    ptd: *const DVTARGETDEVICE,
    dwAspect: DWORD,
    lindex: LONG,
    tymed: DWORD,
}}
RIDL!{#[uuid(0x00000103, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IEnumFORMATETC(IEnumFORMATETCVtbl): IUnknown(IUnknownVtbl) {
    fn Next(
        celt: ULONG,
        rgelt: *mut FORMATETC,
        pceltFetched: *mut ULONG,
    ) -> HRESULT,
    fn Skip(
        celt: ULONG,
    ) -> HRESULT,
    fn Reset() -> HRESULT,
    fn Clone(
        ppenum: *mut *mut IEnumFORMATETC,
    ) -> HRESULT,
}}
ENUM!{enum ADVF {
    ADVF_NODATA = 1,
    ADVF_PRIMEFIRST = 2,
    ADVF_ONLYONCE = 4,
    ADVF_DATAONSTOP = 64,
    ADVFCACHE_NOHANDLER = 8,
    ADVFCACHE_FORCEBUILTIN = 16,
    ADVFCACHE_ONSAVE = 32,
}}
STRUCT!{struct STATDATA {
    formatetc: FORMATETC,
    advf: DWORD,
    pAdvSInk: *mut IAdviseSink,
    dwConnection: DWORD,
}}
RIDL!{#[uuid(0x00000105, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IEnumSTATDATA(IEnumSTATDATAVtbl): IUnknown(IUnknownVtbl) {
    fn Next(
        celt: ULONG,
        rgelt: *mut STATDATA,
        pceltFetched: *mut ULONG,
    ) -> HRESULT,
    fn Skip(
        celt: ULONG,
    ) -> HRESULT,
    fn Reset() -> HRESULT,
    fn Clone(
        ppenum: *mut *mut IEnumSTATDATA,
    ) -> HRESULT,
}}
ENUM!{enum TYMED {
    TYMED_HGLOBAL = 1,
    TYMED_FILE = 2,
    TYMED_ISTREAM = 4,
    TYMED_ISTORAGE = 8,
    TYMED_GDI = 16,
    TYMED_MFPICT = 32,
    TYMED_ENHMF = 64,
    TYMED_NULL = 0,
}}
UNION!{union STGMEDIUM_u {
    [u64; 7], //TODO: I guessed to move on
    hBitmap hBitmap_mut: HBITMAP,
    hMetaFilePict hMetaFilePict_mut: HMETAFILEPICT,
    hEnhMetaFile hEnhMetaFile_mut: HENHMETAFILE,
    hGlobal hGlobal_mut: HGLOBAL,
    lpszFileName lpszFileName_mut: LPOLESTR,
    pstm pstm_mut: *mut IStream,
    pstg pstg_mut: *mut IStorage,
}}
STRUCT!{struct STGMEDIUM {
    tymed: DWORD,
    u: *mut STGMEDIUM_u,
    pUnkForRelease: *mut IUnknown,
}}
RIDL!{#[uuid(0x0000010f, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IAdviseSink(IAdviseSinkVtbl): IUnknown(IUnknownVtbl) {
    fn OnDataChange(
        pformatetc: *mut FORMATETC,
        pStgmed: *mut STGMEDIUM,
    ) -> c_void,
    fn OnViewChange(
        dwAspect: DWORD,
        lindex: LONG,
    ) -> c_void,
    fn OnRename(
        pmk: *mut IMoniker,
    ) -> c_void,
    fn OnSave() -> c_void,
    fn OnClose() -> c_void,
}}
ENUM!{enum DATADIR {
    DATADIR_GET = 1,
    DATADIR_SET = 2,
}}
pub type LPDATAOBJECT = *mut IDataObject;
RIDL!{#[uuid(0x0000010e, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IDataObject(IDataObjectVtbl): IUnknown(IUnknownVtbl) {
    fn GetData(
        pformatetcIn: *const FORMATETC,
        pmedium: *mut STGMEDIUM,
    ) -> HRESULT,
    fn GetDataHere(
        pformatetc: *const FORMATETC,
        pmedium: *mut STGMEDIUM,
    ) -> HRESULT,
    fn QueryGetData(
        pformatetc: *const FORMATETC,
    ) -> HRESULT,
    fn GetCanonicalFormatEtc(
        pformatetcIn: *const FORMATETC,
        pformatetcOut: *mut FORMATETC,
    ) -> HRESULT,
    fn SetData(
        pformatetc: *const FORMATETC,
        pformatetcOut: *const FORMATETC,
        fRelease: BOOL,
    ) -> HRESULT,
    fn EnumFormatEtc(
        dwDirection: DWORD,
        ppenumFormatEtc: *mut *mut IEnumFORMATETC,
    ) -> HRESULT,
    fn DAdvise(
        pformatetc: *const FORMATETC,
        advf: DWORD,
        pAdvSInk: *const IAdviseSink,
        pdwConnection: *mut DWORD,
    ) -> HRESULT,
    fn DUnadvise(
        dwConnection: DWORD,
    ) -> HRESULT,
    fn EnumDAdvise(
        ppenumAdvise: *const *const IEnumSTATDATA,
    ) -> HRESULT,
}}
RIDL!{#[uuid(0xa2f05a09, 0x27a2, 0x42b5, 0xbc, 0x0e, 0xac, 0x16, 0x3e, 0xf4, 0x9d, 0x9b)]
interface IApartmentShutdown(IApartmentShutdownVtbl): IUnknown(IUnknownVtbl) {
    fn OnUninitialize(
        ui64ApartmentIdentifier: UINT64,
    ) -> (),
}}
RIDL!{#[uuid(0x00000003, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IMarshal(IMarshalVtbl): IUnknown(IUnknownVtbl) {
    fn GetUnmarshalClass(
        riid: REFIID,
        pv: *mut c_void,
        dwDestContext: DWORD,
        pvDestContext: *mut c_void,
        mshlflags: DWORD,
        pCid: *mut CLSID,
    ) -> HRESULT,
    fn GetMarshalSizeMax(
        riid: REFIID,
        pv: *mut c_void,
        dwDestContext: DWORD,
        pvDestContext: *mut c_void,
        mshlflags: DWORD,
        pSize: *mut DWORD,
    ) -> HRESULT,
    fn MarshalInterface(
        pStm: *mut IStream,
        riid: REFIID,
        pv: *mut c_void,
        dwDestContext: DWORD,
        pvDestContext: *mut c_void,
        mshlflags: DWORD,
    ) -> HRESULT,
    fn UnmarshalInterface(
        pStm: *mut IStream,
        riid: REFIID,
        ppv: *mut *mut c_void,
    ) -> HRESULT,
    fn ReleaseMarshalData(
        pStm: *mut IStream,
    ) -> HRESULT,
    fn DisconnectObject(
        dwReserved: DWORD,
    ) -> HRESULT,
}}
Commit	Line	Data
ff7c6d11 XL	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;
0bf4aa26 XL	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};
ff7c6d11	14	use shared::wtypesbase::{LPOLESTR, OLECHAR};
0bf4aa26	15	use um::objidlbase::{IEnumString, IStream, STATSTG};
ff7c6d11 XL	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
0bf4aa26	27	RIDL!{#[uuid(0x0000000e, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
ff7c6d11 XL	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,
0bf4aa26	59	}}
ff7c6d11	60	//8681
0bf4aa26	61	RIDL!{#[uuid(0x00000102, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
ff7c6d11 XL	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,
0bf4aa26	75	}}
ff7c6d11	76	//8958
0bf4aa26	77	RIDL!{#[uuid(0x00000010, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
ff7c6d11 XL	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,
0bf4aa26	106	}}
ff7c6d11	107	//9125
0bf4aa26	108	RIDL!{#[uuid(0x0000010c, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
ff7c6d11 XL	109	interface IPersist(IPersistVtbl): IUnknown(IUnknownVtbl) {
	110	fn GetClassID(
	111	pClassID: *mut CLSID,
	112	) -> HRESULT,
0bf4aa26	113	}}
ff7c6d11	114	//9207
0bf4aa26	115	RIDL!{#[uuid(0x00000109, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
ff7c6d11 XL	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,
0bf4aa26	128	}}
ff7c6d11	129	//9350
0bf4aa26	130	RIDL!{#[uuid(0x0000000f, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
ff7c6d11 XL	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,
0bf4aa26	201	}}
ff7c6d11 XL	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	}}
0bf4aa26 XL	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	STRUCT!{struct DVTARGETDEVICE {
320	tdSize: DWORD,
321	tdDriverNameOffset: WORD,
322	tdDeviceNameOffset: WORD,
323	tdPortNameOffset: WORD,
324	tdExtDevmodeOFfset: WORD,
325	tdData: [BYTE; 1],
326	}}
327	STRUCT!{struct FORMATETC {
328	cfFormat: CLIPFORMAT,
329	ptd: *const DVTARGETDEVICE,
330	dwAspect: DWORD,
331	lindex: LONG,
332	tymed: DWORD,
333	}}
334	RIDL!{#[uuid(0x00000103, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
335	interface IEnumFORMATETC(IEnumFORMATETCVtbl): IUnknown(IUnknownVtbl) {
336	fn Next(
337	celt: ULONG,
338	rgelt: *mut FORMATETC,
339	pceltFetched: *mut ULONG,
340	) -> HRESULT,
341	fn Skip(
342	celt: ULONG,
343	) -> HRESULT,
344	fn Reset() -> HRESULT,
345	fn Clone(
346	ppenum: mut mut IEnumFORMATETC,
347	) -> HRESULT,
348	}}
349	ENUM!{enum ADVF {
350	ADVF_NODATA = 1,
351	ADVF_PRIMEFIRST = 2,
352	ADVF_ONLYONCE = 4,
353	ADVF_DATAONSTOP = 64,
354	ADVFCACHE_NOHANDLER = 8,
355	ADVFCACHE_FORCEBUILTIN = 16,
356	ADVFCACHE_ONSAVE = 32,
357	}}
358	STRUCT!{struct STATDATA {
359	formatetc: FORMATETC,
360	advf: DWORD,
361	pAdvSInk: *mut IAdviseSink,
362	dwConnection: DWORD,
363	}}
364	RIDL!{#[uuid(0x00000105, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
365	interface IEnumSTATDATA(IEnumSTATDATAVtbl): IUnknown(IUnknownVtbl) {
366	fn Next(
367	celt: ULONG,
368	rgelt: *mut STATDATA,
369	pceltFetched: *mut ULONG,
370	) -> HRESULT,
371	fn Skip(
372	celt: ULONG,
373	) -> HRESULT,
374	fn Reset() -> HRESULT,
375	fn Clone(
376	ppenum: mut mut IEnumSTATDATA,
377	) -> HRESULT,
378	}}
379	ENUM!{enum TYMED {
380	TYMED_HGLOBAL = 1,
381	TYMED_FILE = 2,
382	TYMED_ISTREAM = 4,
383	TYMED_ISTORAGE = 8,
384	TYMED_GDI = 16,
385	TYMED_MFPICT = 32,
386	TYMED_ENHMF = 64,
387	TYMED_NULL = 0,
388	}}
389	UNION!{union STGMEDIUM_u {
390	[u64; 7], //TODO: I guessed to move on
391	hBitmap hBitmap_mut: HBITMAP,
392	hMetaFilePict hMetaFilePict_mut: HMETAFILEPICT,
393	hEnhMetaFile hEnhMetaFile_mut: HENHMETAFILE,
394	hGlobal hGlobal_mut: HGLOBAL,
395	lpszFileName lpszFileName_mut: LPOLESTR,
396	pstm pstm_mut: *mut IStream,
397	pstg pstg_mut: *mut IStorage,
398	}}
399	STRUCT!{struct STGMEDIUM {
400	tymed: DWORD,
401	u: *mut STGMEDIUM_u,
402	pUnkForRelease: *mut IUnknown,
403	}}
404	RIDL!{#[uuid(0x0000010f, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
405	interface IAdviseSink(IAdviseSinkVtbl): IUnknown(IUnknownVtbl) {
406	fn OnDataChange(
407	pformatetc: *mut FORMATETC,
408	pStgmed: *mut STGMEDIUM,
409	) -> c_void,
410	fn OnViewChange(
411	dwAspect: DWORD,
412	lindex: LONG,
413	) -> c_void,
414	fn OnRename(
415	pmk: *mut IMoniker,
416	) -> c_void,
417	fn OnSave() -> c_void,
418	fn OnClose() -> c_void,
419	}}
420	ENUM!{enum DATADIR {
421	DATADIR_GET = 1,
422	DATADIR_SET = 2,
423	}}
424	pub type LPDATAOBJECT = *mut IDataObject;
425	RIDL!{#[uuid(0x0000010e, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
426	interface IDataObject(IDataObjectVtbl): IUnknown(IUnknownVtbl) {
427	fn GetData(
428	pformatetcIn: *const FORMATETC,
429	pmedium: *mut STGMEDIUM,
430	) -> HRESULT,
431	fn GetDataHere(
432	pformatetc: *const FORMATETC,
433	pmedium: *mut STGMEDIUM,
434	) -> HRESULT,
435	fn QueryGetData(
436	pformatetc: *const FORMATETC,
437	) -> HRESULT,
438	fn GetCanonicalFormatEtc(
439	pformatetcIn: *const FORMATETC,
440	pformatetcOut: *mut FORMATETC,
441	) -> HRESULT,
442	fn SetData(
443	pformatetc: *const FORMATETC,
444	pformatetcOut: *const FORMATETC,
445	fRelease: BOOL,
446	) -> HRESULT,
447	fn EnumFormatEtc(
448	dwDirection: DWORD,
449	ppenumFormatEtc: mut mut IEnumFORMATETC,
450	) -> HRESULT,
451	fn DAdvise(
452	pformatetc: *const FORMATETC,
453	advf: DWORD,
454	pAdvSInk: *const IAdviseSink,
455	pdwConnection: *mut DWORD,
456	) -> HRESULT,
457	fn DUnadvise(
458	dwConnection: DWORD,
459	) -> HRESULT,
460	fn EnumDAdvise(
461	ppenumAdvise: const const IEnumSTATDATA,
462	) -> HRESULT,
463	}}
464	RIDL!{#[uuid(0xa2f05a09, 0x27a2, 0x42b5, 0xbc, 0x0e, 0xac, 0x16, 0x3e, 0xf4, 0x9d, 0x9b)]
ff7c6d11 XL	465	interface IApartmentShutdown(IApartmentShutdownVtbl): IUnknown(IUnknownVtbl) {
	466	fn OnUninitialize(
	467	ui64ApartmentIdentifier: UINT64,
	468	) -> (),
0bf4aa26 XL	469	}}
0bf4aa26 XL	470	RIDL!{#[uuid(0x00000003, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
ff7c6d11 XL	471	interface IMarshal(IMarshalVtbl): IUnknown(IUnknownVtbl) {
	472	fn GetUnmarshalClass(
	473	riid: REFIID,
	474	pv: *mut c_void,
	475	dwDestContext: DWORD,
	476	pvDestContext: *mut c_void,
	477	mshlflags: DWORD,
	478	pCid: *mut CLSID,
	479	) -> HRESULT,
	480	fn GetMarshalSizeMax(
	481	riid: REFIID,
	482	pv: *mut c_void,
	483	dwDestContext: DWORD,
	484	pvDestContext: *mut c_void,
	485	mshlflags: DWORD,
	486	pSize: *mut DWORD,
	487	) -> HRESULT,
	488	fn MarshalInterface(
	489	pStm: *mut IStream,
	490	riid: REFIID,
	491	pv: *mut c_void,
	492	dwDestContext: DWORD,
	493	pvDestContext: *mut c_void,
	494	mshlflags: DWORD,
	495	) -> HRESULT,
	496	fn UnmarshalInterface(
	497	pStm: *mut IStream,
	498	riid: REFIID,
	499	ppv: mut mut c_void,
	500	) -> HRESULT,
	501	fn ReleaseMarshalData(
	502	pStm: *mut IStream,
	503	) -> HRESULT,
	504	fn DisconnectObject(
	505	dwReserved: DWORD,
	506	) -> HRESULT,
0bf4aa26	507	}}