Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

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

1 files changed, 392 insertions, 0 deletions

diff --git a/vendor/winapi/src/um/propidl.rs b/vendor/winapi/src/um/propidl.rs
new file mode 100644
index 000000000..fd25abb03
--- /dev/null
+++ b/vendor/winapi/src/um/propidl.rs
@@ -0,0 +1,392 @@
+// 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;
+}