path: root/vendor/winapi/src/um/propidl.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.
use shared::guiddef::{CLSID, FMTID, GUID, REFCLSID, REFFMTID};
use shared::minwindef::{
    BYTE, DWORD, FILETIME, FLOAT, HIBYTE, HIWORD, INT, LOBYTE, LOWORD, UINT, WORD
};
use shared::ntdef::{
    BOOLEAN, CHAR, HRESULT, LARGE_INTEGER, LONG, LPSTR, LPWSTR, PVOID, SHORT,
    UCHAR, ULARGE_INTEGER, ULONG, USHORT
};
use shared::wtypes::{
    BSTR, BSTRBLOB, CLIPDATA, CY, DATE, DECIMAL, PROPID, VARIANT_BOOL, VARTYPE
};
use shared::wtypesbase::{BLOB, DOUBLE, LPOLESTR, SCODE};
use um::oaidl::{IDispatch, LPSAFEARRAY};
use um::objidlbase::IStream;
use um::unknwnbase::{IUnknown, IUnknownVtbl};
pub const PROPSETFLAG_DEFAULT: DWORD = 0;
pub const PROPSETFLAG_NONSIMPLE: DWORD = 1;
pub const PROPSETFLAG_ANSI: DWORD = 2;
pub const PROPSETFLAG_UNBUFFERED: DWORD = 4;
pub const PROPSET_BEHAVIOR_CASE_SENSITIVE: DWORD = 1;
STRUCT!{struct VERSIONEDSTREAM {
    guidVersion: GUID,
    pStream: *mut IStream,
}}
pub type LPVERSIONEDSTREAM = *mut VERSIONEDSTREAM;
macro_rules! TYPEDEF_CA {
    ($type_:ty, $name:ident) => { STRUCT!{struct $name {
        cElems: $crate::shared::ntdef::ULONG,
        pElems: *mut $type_,
    }}}
}
TYPEDEF_CA!(CHAR, CAC);
TYPEDEF_CA!(UCHAR, CAUB);
TYPEDEF_CA!(SHORT, CAI);
TYPEDEF_CA!(USHORT, CAUI);
TYPEDEF_CA!(LONG, CAL);
TYPEDEF_CA!(ULONG, CAUL);
TYPEDEF_CA!(FLOAT, CAFLT);
TYPEDEF_CA!(DOUBLE, CADBL);
TYPEDEF_CA!(CY, CACY);
TYPEDEF_CA!(DATE, CADATE);
TYPEDEF_CA!(BSTR, CABSTR);
TYPEDEF_CA!(BSTRBLOB, CABSTRBLOB);
TYPEDEF_CA!(VARIANT_BOOL, CABOOL);
TYPEDEF_CA!(SCODE, CASCODE);
TYPEDEF_CA!(PROPVARIANT, CAPROPVARIANT);
TYPEDEF_CA!(LARGE_INTEGER, CAH);
TYPEDEF_CA!(ULARGE_INTEGER, CAUH);
TYPEDEF_CA!(LPSTR, CALPSTR);
TYPEDEF_CA!(LPWSTR, CALPWSTR);
TYPEDEF_CA!(FILETIME, CAFILETIME);
TYPEDEF_CA!(CLIPDATA, CACLIPDATA);
TYPEDEF_CA!(CLSID, CACLSID);
UNION!{union PROPVARIANT_data {
    [u64; 1] [u64; 2],
    cVal cVal_mut: CHAR,
    bVal bVal_mut: UCHAR,
    iVal iVal_mut: SHORT,
    uiVal uiVal_mut: USHORT,
    lVal lVal_mut: LONG,
    ulVal ulVal_mut: ULONG,
    intVal intVal_mut: INT,
    uintVal uintVal_mut: UINT,
    hVal hVal_mut: LARGE_INTEGER,
    uhVal uhVal_mut: ULARGE_INTEGER,
    fltVal fltVal_mut: FLOAT,
    dblVal dblVal_mut: DOUBLE,
    boolVal boolVal_mut: VARIANT_BOOL,
    scode scode_mut: SCODE,
    cyVal cyVal_mut: CY,
    date date_mut: DATE,
    filetime filetime_mut: FILETIME,
    puuid puuid_mut: *mut CLSID,
    pclipdata pclipdata_mut: *mut CLIPDATA,
    bstrVal bstrVal_mut: BSTR,
    bstrblobVal bstrblobVal_mut: BSTRBLOB,
    blob blob_mut: BLOB,
    pszVal pszVal_mut: LPSTR,
    pwszVal pwszVal_mut: LPWSTR,
    punkVal punkVal_mut: *mut IUnknown,
    pdispVal pdisp_mut: *mut IDispatch,
    pStream pStream_mut: *mut IStream,
    // pStorage pStorage_mut: *mut IStorage,
    pVersionedStream pVersionedStream_mut: LPVERSIONEDSTREAM,
    parray parray_mut: LPSAFEARRAY,
    cac cac_mut: CAC,
    caub caub_mut: CAUB,
    cai cai_mut: CAI,
    caui caui_mut: CAUI,
    cal cal_mut: CAL,
    caul caul_mut: CAUL,
    cah cah_mut: CAH,
    cauh cauh_mut: CAUH,
    caflt caflt_mut: CAFLT,
    cadbl cadbl_mut: CADBL,
    cabool cabool_mut: CABOOL,
    cascode cascode_mut: CASCODE,
    cacy cacy_mut: CACY,
    cadate cadate_mut: CADATE,
    cafiletime cafiletime_mut: CAFILETIME,
    cauuid cauuid_mut: CACLSID,
    caclipdata caclipdata_mut: CACLIPDATA,
    cabstr cabstr_mut: CABSTR,
    cabstrblob cabstrblob_mut: CABSTRBLOB,
    calpstr calpstr_mut: CALPSTR,
    calpwstr calpwstr_mut: CALPWSTR,
    capropvar capropvar_mut: CAPROPVARIANT,
    pcVal pcVal_mut: *mut CHAR,
    pbVal pbVal_mut: *mut UCHAR,
    piVal piVal_mut: *mut SHORT,
    puiVal puiVal_mut: *mut USHORT,
    plVal plVal_mut: *mut LONG,
    pulVal pulVal_mut: *mut ULONG,
    pintVal pintVal_mut: *mut INT,
    puintVal puintVal_mut: *mut UINT,
    pfltVal pfltVal_mut: *mut FLOAT,
    pdblVal pdblVal_mut: *mut DOUBLE,
    pboolVal pboolVal_mut: *mut VARIANT_BOOL,
    pdecVal pdecVal_mut: *mut DECIMAL,
    pscode pscode_mut: *mut SCODE,
    pcyVal pcyVal_mut: *mut CY,
    pdate pdate_mut: *mut DATE,
    ppunkVal ppunkVal_mut: *mut *mut IUnknown,
    ppdispVal ppdispVal_mut: *mut *mut IDispatch,
    ppStream ppStream_mut: *mut *mut IStream,
    // ppStorage ppStorage_mut: *mut *mut IStorage,
}}
// This is actually defined as a union between this struct
// and DECIMAL. I don't this we need to do that.
STRUCT!{struct PROPVARIANT {
    vt: VARTYPE,
    wReserved1: WORD,
    wReserved2: WORD,
    wReserved3: WORD,
    data: PROPVARIANT_data,
}}
pub type LPPROPVARIANT = *mut PROPVARIANT;
pub type REFPROPVARIANT = *const PROPVARIANT;
pub const PID_DICTIONARY: DWORD = 0;
pub const PID_CODEPAGE: DWORD = 0x1;
pub const PID_FIRST_USABLE: DWORD = 0x2;
pub const PID_FIRST_NAME_DEFAULT: DWORD = 0xfff;
pub const PID_LOCALE: DWORD = 0x80000000;
pub const PID_MODIFY_TIME: DWORD = 0x80000001;
pub const PID_SECURITY: DWORD = 0x80000002;
pub const PID_BEHAVIOR: DWORD = 0x80000003;
pub const PID_ILLEGAL: DWORD = 0xffffffff;
pub const PID_MIN_READONLY: DWORD = 0x80000000;
pub const PID_MAX_READONLY: DWORD = 0xbfffffff;
pub const PRSPEC_INVALID: ULONG = 0xffffffff;
pub const PRSPEC_LPWSTR: ULONG = 0;
pub const PRSPEC_PROPID: ULONG = 1;
UNION!{union PROPSPEC_u {
    [u32; 1] [u64; 1],
    propid propid_mut: PROPID,
    lpwstr lpwstr_mut: LPOLESTR,
}}
STRUCT!{struct PROPSPEC {
    ulKind: ULONG,
    u: PROPSPEC_u,
}}
STRUCT!{struct STATPROPSTG {
    lpwstrName: LPOLESTR,
    propid: PROPID,
    vt: VARTYPE,
}}
#[inline]
pub fn PROPSETHDR_OSVER_KIND(dwOSVer: DWORD) -> WORD {
    HIWORD(dwOSVer)
}
#[inline]
pub fn PROPSETHDR_OSVER_MAJOR(dwOSVer: DWORD) -> BYTE {
    LOBYTE(LOWORD(dwOSVer))
}
#[inline]
pub fn PROPSETHDR_OSVER_MINOR(dwOSVer: DWORD) -> BYTE {
    HIBYTE(LOWORD(dwOSVer))
}
pub const PROPSETHDR_OSVERSION_UNKNOWN: DWORD = 0xFFFFFFFF;
STRUCT!{struct STATPROPSETSTG {
    fmtid: FMTID,
    clsid: CLSID,
    grfFlags: DWORD,
    mtime: FILETIME,
    ctime: FILETIME,
    atime: FILETIME,
    dwOSVersion: DWORD,
}}
RIDL!{#[uuid(0x00000138, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IPropertyStorage(IPropertyStorageVtbl): IUnknown(IUnknownVtbl) {
    fn ReadMultiple(
        cpspec: ULONG,
        rgpspec: *const PROPSPEC,
        rgpropvar: *mut PROPVARIANT,
    ) -> HRESULT,
    fn WriteMultiple(
        cpspec: ULONG,
        rgpspec: *const PROPSPEC,
        rgpropvar: *const PROPVARIANT,
    ) -> HRESULT,
    fn DeleteMultiple(
        cpspec: ULONG,
        rgpspec: *const PROPSPEC,
    ) -> HRESULT,
    fn ReadPropertyNames(
        cppropid: ULONG,
        rgpropid: *const PROPID,
        rglpwstrName: *mut LPOLESTR,
    ) -> HRESULT,
    fn WritePropertyNames(
        cppropid: ULONG,
        rgpropid: *const PROPID,
        rglpwstrName: *const LPOLESTR,
    ) -> HRESULT,
    fn DeletePropertyNames(
        cppropid: ULONG,
        rgpropid: *const PROPID,
    ) -> HRESULT,
    fn Commit(
        grfCommitFlags: DWORD,
    ) -> HRESULT,
    fn Revert() -> HRESULT,
    fn Enum(
        ppenum: *mut *mut IEnumSTATPROPSTG,
    ) -> HRESULT,
    fn SetTimes(
        pctime: *const FILETIME,
        patime: *const FILETIME,
        pmtime: *const FILETIME,
    ) -> HRESULT,
    fn SetClass(
        clsid: REFCLSID,
    ) -> HRESULT,
    fn Stat(
        pstatpsstg: *mut STATPROPSETSTG,
    ) -> HRESULT,
}}
pub type LPPROPERTYSETSTORAGE = *mut IPropertySetStorage;
RIDL!{#[uuid(0x0000013A, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IPropertySetStorage(IPropertySetStorageVtbl): IUnknown(IUnknownVtbl) {
    fn Create(
        rfmtid: REFFMTID,
        pclsid: *const CLSID,
        grfFlags: DWORD,
        grfMode: DWORD,
        ppprstg: *mut *mut IPropertyStorage,
    ) -> HRESULT,
    fn Open(
        rfmtid: REFFMTID,
        grfMode: DWORD,
        ppprstg: *mut *mut IPropertyStorage,
    ) -> HRESULT,
    fn Delete(
        rfmtid: REFFMTID,
    ) -> HRESULT,
    fn Enum(
        ppenum: *mut *mut IEnumSTATPROPSTG,
    ) -> HRESULT,
}}
pub type LPENUMSTATPROPSTG = *mut IEnumSTATPROPSTG;
RIDL!{#[uuid(0x00000139, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IEnumSTATPROPSTG(IEnumSTATPROPSTGVtbl): IUnknown(IUnknownVtbl) {
    fn Next(
        celt: ULONG,
        rgelt: *mut STATPROPSTG,
        pceltFetched: *mut ULONG,
    ) -> HRESULT,
    fn Skip(
        celt: ULONG,
    ) -> HRESULT,
    fn Revert() -> HRESULT,
    fn Clone(
        ppenum: *mut *mut IEnumSTATPROPSTG,
    ) -> HRESULT,
}}
pub type LPENUMSTATPROPSETSTG = *mut IEnumSTATPROPSETSTG;
RIDL!{#[uuid(0x0000013B, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
interface IEnumSTATPROPSETSTG(IEnumSTATPROPSETSTGVtbl): IUnknown(IUnknownVtbl) {
    fn Next(
        celt: ULONG,
        rgelt: *mut STATPROPSETSTG,
        pceltFetched: *mut ULONG,
    ) -> HRESULT,
    fn Skip(
        celt: ULONG,
    ) -> HRESULT,
    fn Revert() -> HRESULT,
    fn Clone(
        ppenum: *mut *mut IEnumSTATPROPSETSTG,
    ) -> HRESULT,
}}
pub type LPPROPERTYSTORAGE = *mut IPropertyStorage;
pub const PIDDI_THUMBNAIL: DWORD = 0x00000002;
pub const PIDSI_TITLE: DWORD = 0x00000002;
pub const PIDSI_SUBJECT: DWORD = 0x00000003;
pub const PIDSI_AUTHOR: DWORD = 0x00000004;
pub const PIDSI_KEYWORDS: DWORD = 0x00000005;
pub const PIDSI_COMMENTS: DWORD = 0x00000006;
pub const PIDSI_TEMPLATE: DWORD = 0x00000007;
pub const PIDSI_LASTAUTHOR: DWORD = 0x00000008;
pub const PIDSI_REVNUMBER: DWORD = 0x00000009;
pub const PIDSI_EDITTIME: DWORD = 0x0000000a;
pub const PIDSI_LASTPRINTED: DWORD = 0x0000000b;
pub const PIDSI_CREATE_DTM: DWORD = 0x0000000c;
pub const PIDSI_LASTSAVE_DTM: DWORD = 0x0000000d;
pub const PIDSI_PAGECOUNT: DWORD = 0x0000000e;
pub const PIDSI_WORDCOUNT: DWORD = 0x0000000f;
pub const PIDSI_CHARCOUNT: DWORD = 0x00000010;
pub const PIDSI_THUMBNAIL: DWORD = 0x00000011;
pub const PIDSI_APPNAME: DWORD = 0x00000012;
pub const PIDSI_DOC_SECURITY: DWORD = 0x00000013;
pub const PIDDSI_CATEGORY: DWORD = 0x00000002;
pub const PIDDSI_PRESFORMAT: DWORD = 0x00000003;
pub const PIDDSI_BYTECOUNT: DWORD = 0x00000004;
pub const PIDDSI_LINECOUNT: DWORD = 0x00000005;
pub const PIDDSI_PARCOUNT: DWORD = 0x00000006;
pub const PIDDSI_SLIDECOUNT: DWORD = 0x00000007;
pub const PIDDSI_NOTECOUNT: DWORD = 0x00000008;
pub const PIDDSI_HIDDENCOUNT: DWORD = 0x00000009;
pub const PIDDSI_MMCLIPCOUNT: DWORD = 0x0000000A;
pub const PIDDSI_SCALE: DWORD = 0x0000000B;
pub const PIDDSI_HEADINGPAIR: DWORD = 0x0000000C;
pub const PIDDSI_DOCPARTS: DWORD = 0x0000000D;
pub const PIDDSI_MANAGER: DWORD = 0x0000000E;
pub const PIDDSI_COMPANY: DWORD = 0x0000000F;
pub const PIDDSI_LINKSDIRTY: DWORD = 0x00000010;
pub const PIDMSI_EDITOR: DWORD = 0x00000002;
pub const PIDMSI_SUPPLIER: DWORD = 0x00000003;
pub const PIDMSI_SOURCE: DWORD = 0x00000004;
pub const PIDMSI_SEQUENCE_NO: DWORD = 0x00000005;
pub const PIDMSI_PROJECT: DWORD = 0x00000006;
pub const PIDMSI_STATUS: DWORD = 0x00000007;
pub const PIDMSI_OWNER: DWORD = 0x00000008;
pub const PIDMSI_RATING: DWORD = 0x00000009;
pub const PIDMSI_PRODUCTION: DWORD = 0x0000000A;
pub const PIDMSI_COPYRIGHT: DWORD = 0x0000000B;
ENUM!{enum PIDMSI_STATUS_VALUE {
    PIDMSI_STATUS_NORMAL = 0,
    PIDMSI_STATUS_NEW,
    PIDMSI_STATUS_PRELIM,
    PIDMSI_STATUS_DRAFT,
    PIDMSI_STATUS_INPROGRESS,
    PIDMSI_STATUS_EDIT,
    PIDMSI_STATUS_REVIEW,
    PIDMSI_STATUS_PROOF,
    PIDMSI_STATUS_FINAL,
    PIDMSI_STATUS_OTHER = 0x7fff,
}}
extern "system" {
    pub fn PropVariantCopy(
        pvarDest: *mut PROPVARIANT,
        pvarSrc: *const PROPVARIANT,
    ) -> HRESULT;
    pub fn PropVariantClear(
        pvar: *mut PROPVARIANT,
    ) -> HRESULT;
    pub fn FreePropVariantArray(
        cVariants: ULONG,
        rgvars: *mut PROPVARIANT,
    ) -> HRESULT;
}
// #[inline]
// pub fn PropVariantInit(pvar: *mut PROPVARIANT) {
//     memset(pvar, 0, sizeof(PROPVARIANT))
// }
STRUCT!{struct SERIALIZEDPROPERTYVALUE {
    dwType: DWORD,
    rgb: *mut BYTE,
}}
pub type PMemoryAllocator = PVOID;
extern "system" {
    pub fn StgConvertVariantToProperty(
        pvar: *const PROPVARIANT,
        CodePage: USHORT,
        pprop: *mut SERIALIZEDPROPERTYVALUE,
        pcb: *mut ULONG,
        pid: PROPID,
        fReserved: BOOLEAN,
        pcIndirect: *mut ULONG,
    ) -> *mut SERIALIZEDPROPERTYVALUE;
    pub fn StgConvertPropertyToVariant(
        pprop: *const SERIALIZEDPROPERTYVALUE,
        CodePage: USHORT,
        pvar: *mut PROPVARIANT,
        pma: *mut PMemoryAllocator
    ) -> BOOLEAN;
}