Revision control
Copy as Markdown
Other Tools
// Licensed under the Apache License, Version 2.0
// 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;
}