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 use shared::guiddef::{CLSID, FMTID, GUID, REFCLSID, REFFMTID};
7 use shared::minwindef::{
8     BYTE, DWORD, FILETIME, FLOAT, HIBYTE, HIWORD, INT, LOBYTE, LOWORD, UINT, WORD
9 };
10 use shared::ntdef::{
11     BOOLEAN, CHAR, HRESULT, LARGE_INTEGER, LONG, LPSTR, LPWSTR, PVOID, SHORT,
12     UCHAR, ULARGE_INTEGER, ULONG, USHORT
13 };
14 use shared::wtypes::{
15     BSTR, BSTRBLOB, CLIPDATA, CY, DATE, DECIMAL, PROPID, VARIANT_BOOL, VARTYPE
16 };
17 use shared::wtypesbase::{BLOB, DOUBLE, LPOLESTR, SCODE};
18 use um::oaidl::{IDispatch, LPSAFEARRAY};
19 use um::objidlbase::IStream;
20 use um::unknwnbase::{IUnknown, IUnknownVtbl};
21 pub const PROPSETFLAG_DEFAULT: DWORD = 0;
22 pub const PROPSETFLAG_NONSIMPLE: DWORD = 1;
23 pub const PROPSETFLAG_ANSI: DWORD = 2;
24 pub const PROPSETFLAG_UNBUFFERED: DWORD = 4;
25 pub const PROPSET_BEHAVIOR_CASE_SENSITIVE: DWORD = 1;
26 STRUCT!{struct VERSIONEDSTREAM {
27     guidVersion: GUID,
28     pStream: *mut IStream,
29 }}
30 pub type LPVERSIONEDSTREAM = *mut VERSIONEDSTREAM;
31 macro_rules! TYPEDEF_CA {
32     ($type_:ty, $name:ident) => { STRUCT!{struct $name {
33         cElems: $crate::shared::ntdef::ULONG,
34         pElems: *mut $type_,
35     }}}
36 }
37 TYPEDEF_CA!(CHAR, CAC);
38 TYPEDEF_CA!(UCHAR, CAUB);
39 TYPEDEF_CA!(SHORT, CAI);
40 TYPEDEF_CA!(USHORT, CAUI);
41 TYPEDEF_CA!(LONG, CAL);
42 TYPEDEF_CA!(ULONG, CAUL);
43 TYPEDEF_CA!(FLOAT, CAFLT);
44 TYPEDEF_CA!(DOUBLE, CADBL);
45 TYPEDEF_CA!(CY, CACY);
46 TYPEDEF_CA!(DATE, CADATE);
47 TYPEDEF_CA!(BSTR, CABSTR);
48 TYPEDEF_CA!(BSTRBLOB, CABSTRBLOB);
49 TYPEDEF_CA!(VARIANT_BOOL, CABOOL);
50 TYPEDEF_CA!(SCODE, CASCODE);
51 TYPEDEF_CA!(PROPVARIANT, CAPROPVARIANT);
52 TYPEDEF_CA!(LARGE_INTEGER, CAH);
53 TYPEDEF_CA!(ULARGE_INTEGER, CAUH);
54 TYPEDEF_CA!(LPSTR, CALPSTR);
55 TYPEDEF_CA!(LPWSTR, CALPWSTR);
56 TYPEDEF_CA!(FILETIME, CAFILETIME);
57 TYPEDEF_CA!(CLIPDATA, CACLIPDATA);
58 TYPEDEF_CA!(CLSID, CACLSID);
59 UNION!{union PROPVARIANT_data {
60     [u64; 1] [u64; 2],
61     cVal cVal_mut: CHAR,
62     bVal bVal_mut: UCHAR,
63     iVal iVal_mut: SHORT,
64     uiVal uiVal_mut: USHORT,
65     lVal lVal_mut: LONG,
66     ulVal ulVal_mut: ULONG,
67     intVal intVal_mut: INT,
68     uintVal uintVal_mut: UINT,
69     hVal hVal_mut: LARGE_INTEGER,
70     uhVal uhVal_mut: ULARGE_INTEGER,
71     fltVal fltVal_mut: FLOAT,
72     dblVal dblVal_mut: DOUBLE,
73     boolVal boolVal_mut: VARIANT_BOOL,
74     scode scode_mut: SCODE,
75     cyVal cyVal_mut: CY,
76     date date_mut: DATE,
77     filetime filetime_mut: FILETIME,
78     puuid puuid_mut: *mut CLSID,
79     pclipdata pclipdata_mut: *mut CLIPDATA,
80     bstrVal bstrVal_mut: BSTR,
81     bstrblobVal bstrblobVal_mut: BSTRBLOB,
82     blob blob_mut: BLOB,
83     pszVal pszVal_mut: LPSTR,
84     pwszVal pwszVal_mut: LPWSTR,
85     punkVal punkVal_mut: *mut IUnknown,
86     pdispVal pdisp_mut: *mut IDispatch,
87     pStream pStream_mut: *mut IStream,
88     // pStorage pStorage_mut: *mut IStorage,
89     pVersionedStream pVersionedStream_mut: LPVERSIONEDSTREAM,
90     parray parray_mut: LPSAFEARRAY,
91     cac cac_mut: CAC,
92     caub caub_mut: CAUB,
93     cai cai_mut: CAI,
94     caui caui_mut: CAUI,
95     cal cal_mut: CAL,
96     caul caul_mut: CAUL,
97     cah cah_mut: CAH,
98     cauh cauh_mut: CAUH,
99     caflt caflt_mut: CAFLT,
100     cadbl cadbl_mut: CADBL,
101     cabool cabool_mut: CABOOL,
102     cascode cascode_mut: CASCODE,
103     cacy cacy_mut: CACY,
104     cadate cadate_mut: CADATE,
105     cafiletime cafiletime_mut: CAFILETIME,
106     cauuid cauuid_mut: CACLSID,
107     caclipdata caclipdata_mut: CACLIPDATA,
108     cabstr cabstr_mut: CABSTR,
109     cabstrblob cabstrblob_mut: CABSTRBLOB,
110     calpstr calpstr_mut: CALPSTR,
111     calpwstr calpwstr_mut: CALPWSTR,
112     capropvar capropvar_mut: CAPROPVARIANT,
113     pcVal pcVal_mut: *mut CHAR,
114     pbVal pbVal_mut: *mut UCHAR,
115     piVal piVal_mut: *mut SHORT,
116     puiVal puiVal_mut: *mut USHORT,
117     plVal plVal_mut: *mut LONG,
118     pulVal pulVal_mut: *mut ULONG,
119     pintVal pintVal_mut: *mut INT,
120     puintVal puintVal_mut: *mut UINT,
121     pfltVal pfltVal_mut: *mut FLOAT,
122     pdblVal pdblVal_mut: *mut DOUBLE,
123     pboolVal pboolVal_mut: *mut VARIANT_BOOL,
124     pdecVal pdecVal_mut: *mut DECIMAL,
125     pscode pscode_mut: *mut SCODE,
126     pcyVal pcyVal_mut: *mut CY,
127     pdate pdate_mut: *mut DATE,
128     ppunkVal ppunkVal_mut: *mut *mut IUnknown,
129     ppdispVal ppdispVal_mut: *mut *mut IDispatch,
130     ppStream ppStream_mut: *mut *mut IStream,
131     // ppStorage ppStorage_mut: *mut *mut IStorage,
132 }}
133 // This is actually defined as a union between this struct
134 // and DECIMAL. I don't this we need to do that.
135 STRUCT!{struct PROPVARIANT {
136     vt: VARTYPE,
137     wReserved1: WORD,
138     wReserved2: WORD,
139     wReserved3: WORD,
140     data: PROPVARIANT_data,
141 }}
142 pub type LPPROPVARIANT = *mut PROPVARIANT;
143 pub type REFPROPVARIANT = *const PROPVARIANT;
144 pub const PID_DICTIONARY: DWORD = 0;
145 pub const PID_CODEPAGE: DWORD = 0x1;
146 pub const PID_FIRST_USABLE: DWORD = 0x2;
147 pub const PID_FIRST_NAME_DEFAULT: DWORD = 0xfff;
148 pub const PID_LOCALE: DWORD = 0x80000000;
149 pub const PID_MODIFY_TIME: DWORD = 0x80000001;
150 pub const PID_SECURITY: DWORD = 0x80000002;
151 pub const PID_BEHAVIOR: DWORD = 0x80000003;
152 pub const PID_ILLEGAL: DWORD = 0xffffffff;
153 pub const PID_MIN_READONLY: DWORD = 0x80000000;
154 pub const PID_MAX_READONLY: DWORD = 0xbfffffff;
155 pub const PRSPEC_INVALID: ULONG = 0xffffffff;
156 pub const PRSPEC_LPWSTR: ULONG = 0;
157 pub const PRSPEC_PROPID: ULONG = 1;
158 UNION!{union PROPSPEC_u {
159     [u32; 1] [u64; 1],
160     propid propid_mut: PROPID,
161     lpwstr lpwstr_mut: LPOLESTR,
162 }}
163 STRUCT!{struct PROPSPEC {
164     ulKind: ULONG,
165     u: PROPSPEC_u,
166 }}
167 STRUCT!{struct STATPROPSTG {
168     lpwstrName: LPOLESTR,
169     propid: PROPID,
170     vt: VARTYPE,
171 }}
172 #[inline]
PROPSETHDR_OSVER_KIND(dwOSVer: DWORD) -> WORD173 pub fn PROPSETHDR_OSVER_KIND(dwOSVer: DWORD) -> WORD {
174     HIWORD(dwOSVer)
175 }
176 #[inline]
PROPSETHDR_OSVER_MAJOR(dwOSVer: DWORD) -> BYTE177 pub fn PROPSETHDR_OSVER_MAJOR(dwOSVer: DWORD) -> BYTE {
178     LOBYTE(LOWORD(dwOSVer))
179 }
180 #[inline]
PROPSETHDR_OSVER_MINOR(dwOSVer: DWORD) -> BYTE181 pub fn PROPSETHDR_OSVER_MINOR(dwOSVer: DWORD) -> BYTE {
182     HIBYTE(LOWORD(dwOSVer))
183 }
184 pub const PROPSETHDR_OSVERSION_UNKNOWN: DWORD = 0xFFFFFFFF;
185 STRUCT!{struct STATPROPSETSTG {
186     fmtid: FMTID,
187     clsid: CLSID,
188     grfFlags: DWORD,
189     mtime: FILETIME,
190     ctime: FILETIME,
191     atime: FILETIME,
192     dwOSVersion: DWORD,
193 }}
194 RIDL!{#[uuid(0x00000138, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
195 interface IPropertyStorage(IPropertyStorageVtbl): IUnknown(IUnknownVtbl) {
196     fn ReadMultiple(
197         cpspec: ULONG,
198         rgpspec: *const PROPSPEC,
199         rgpropvar: *mut PROPVARIANT,
200     ) -> HRESULT,
201     fn WriteMultiple(
202         cpspec: ULONG,
203         rgpspec: *const PROPSPEC,
204         rgpropvar: *const PROPVARIANT,
205     ) -> HRESULT,
206     fn DeleteMultiple(
207         cpspec: ULONG,
208         rgpspec: *const PROPSPEC,
209     ) -> HRESULT,
210     fn ReadPropertyNames(
211         cppropid: ULONG,
212         rgpropid: *const PROPID,
213         rglpwstrName: *mut LPOLESTR,
214     ) -> HRESULT,
215     fn WritePropertyNames(
216         cppropid: ULONG,
217         rgpropid: *const PROPID,
218         rglpwstrName: *const LPOLESTR,
219     ) -> HRESULT,
220     fn DeletePropertyNames(
221         cppropid: ULONG,
222         rgpropid: *const PROPID,
223     ) -> HRESULT,
224     fn Commit(
225         grfCommitFlags: DWORD,
226     ) -> HRESULT,
227     fn Revert() -> HRESULT,
228     fn Enum(
229         ppenum: *mut *mut IEnumSTATPROPSTG,
230     ) -> HRESULT,
231     fn SetTimes(
232         pctime: *const FILETIME,
233         patime: *const FILETIME,
234         pmtime: *const FILETIME,
235     ) -> HRESULT,
236     fn SetClass(
237         clsid: REFCLSID,
238     ) -> HRESULT,
239     fn Stat(
240         pstatpsstg: *mut STATPROPSETSTG,
241     ) -> HRESULT,
242 }}
243 pub type LPPROPERTYSETSTORAGE = *mut IPropertySetStorage;
244 RIDL!{#[uuid(0x0000013A, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
245 interface IPropertySetStorage(IPropertySetStorageVtbl): IUnknown(IUnknownVtbl) {
246     fn Create(
247         rfmtid: REFFMTID,
248         pclsid: *const CLSID,
249         grfFlags: DWORD,
250         grfMode: DWORD,
251         ppprstg: *mut *mut IPropertyStorage,
252     ) -> HRESULT,
253     fn Open(
254         rfmtid: REFFMTID,
255         grfMode: DWORD,
256         ppprstg: *mut *mut IPropertyStorage,
257     ) -> HRESULT,
258     fn Delete(
259         rfmtid: REFFMTID,
260     ) -> HRESULT,
261     fn Enum(
262         ppenum: *mut *mut IEnumSTATPROPSTG,
263     ) -> HRESULT,
264 }}
265 pub type LPENUMSTATPROPSTG = *mut IEnumSTATPROPSTG;
266 RIDL!{#[uuid(0x00000139, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
267 interface IEnumSTATPROPSTG(IEnumSTATPROPSTGVtbl): IUnknown(IUnknownVtbl) {
268     fn Next(
269         celt: ULONG,
270         rgelt: *mut STATPROPSTG,
271         pceltFetched: *mut ULONG,
272     ) -> HRESULT,
273     fn Skip(
274         celt: ULONG,
275     ) -> HRESULT,
276     fn Revert() -> HRESULT,
277     fn Clone(
278         ppenum: *mut *mut IEnumSTATPROPSTG,
279     ) -> HRESULT,
280 }}
281 pub type LPENUMSTATPROPSETSTG = *mut IEnumSTATPROPSETSTG;
282 RIDL!{#[uuid(0x0000013B, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
283 interface IEnumSTATPROPSETSTG(IEnumSTATPROPSETSTGVtbl): IUnknown(IUnknownVtbl) {
284     fn Next(
285         celt: ULONG,
286         rgelt: *mut STATPROPSETSTG,
287         pceltFetched: *mut ULONG,
288     ) -> HRESULT,
289     fn Skip(
290         celt: ULONG,
291     ) -> HRESULT,
292     fn Revert() -> HRESULT,
293     fn Clone(
294         ppenum: *mut *mut IEnumSTATPROPSETSTG,
295     ) -> HRESULT,
296 }}
297 pub type LPPROPERTYSTORAGE = *mut IPropertyStorage;
298 pub const PIDDI_THUMBNAIL: DWORD = 0x00000002;
299 pub const PIDSI_TITLE: DWORD = 0x00000002;
300 pub const PIDSI_SUBJECT: DWORD = 0x00000003;
301 pub const PIDSI_AUTHOR: DWORD = 0x00000004;
302 pub const PIDSI_KEYWORDS: DWORD = 0x00000005;
303 pub const PIDSI_COMMENTS: DWORD = 0x00000006;
304 pub const PIDSI_TEMPLATE: DWORD = 0x00000007;
305 pub const PIDSI_LASTAUTHOR: DWORD = 0x00000008;
306 pub const PIDSI_REVNUMBER: DWORD = 0x00000009;
307 pub const PIDSI_EDITTIME: DWORD = 0x0000000a;
308 pub const PIDSI_LASTPRINTED: DWORD = 0x0000000b;
309 pub const PIDSI_CREATE_DTM: DWORD = 0x0000000c;
310 pub const PIDSI_LASTSAVE_DTM: DWORD = 0x0000000d;
311 pub const PIDSI_PAGECOUNT: DWORD = 0x0000000e;
312 pub const PIDSI_WORDCOUNT: DWORD = 0x0000000f;
313 pub const PIDSI_CHARCOUNT: DWORD = 0x00000010;
314 pub const PIDSI_THUMBNAIL: DWORD = 0x00000011;
315 pub const PIDSI_APPNAME: DWORD = 0x00000012;
316 pub const PIDSI_DOC_SECURITY: DWORD = 0x00000013;
317 pub const PIDDSI_CATEGORY: DWORD = 0x00000002;
318 pub const PIDDSI_PRESFORMAT: DWORD = 0x00000003;
319 pub const PIDDSI_BYTECOUNT: DWORD = 0x00000004;
320 pub const PIDDSI_LINECOUNT: DWORD = 0x00000005;
321 pub const PIDDSI_PARCOUNT: DWORD = 0x00000006;
322 pub const PIDDSI_SLIDECOUNT: DWORD = 0x00000007;
323 pub const PIDDSI_NOTECOUNT: DWORD = 0x00000008;
324 pub const PIDDSI_HIDDENCOUNT: DWORD = 0x00000009;
325 pub const PIDDSI_MMCLIPCOUNT: DWORD = 0x0000000A;
326 pub const PIDDSI_SCALE: DWORD = 0x0000000B;
327 pub const PIDDSI_HEADINGPAIR: DWORD = 0x0000000C;
328 pub const PIDDSI_DOCPARTS: DWORD = 0x0000000D;
329 pub const PIDDSI_MANAGER: DWORD = 0x0000000E;
330 pub const PIDDSI_COMPANY: DWORD = 0x0000000F;
331 pub const PIDDSI_LINKSDIRTY: DWORD = 0x00000010;
332 pub const PIDMSI_EDITOR: DWORD = 0x00000002;
333 pub const PIDMSI_SUPPLIER: DWORD = 0x00000003;
334 pub const PIDMSI_SOURCE: DWORD = 0x00000004;
335 pub const PIDMSI_SEQUENCE_NO: DWORD = 0x00000005;
336 pub const PIDMSI_PROJECT: DWORD = 0x00000006;
337 pub const PIDMSI_STATUS: DWORD = 0x00000007;
338 pub const PIDMSI_OWNER: DWORD = 0x00000008;
339 pub const PIDMSI_RATING: DWORD = 0x00000009;
340 pub const PIDMSI_PRODUCTION: DWORD = 0x0000000A;
341 pub const PIDMSI_COPYRIGHT: DWORD = 0x0000000B;
342 ENUM!{enum PIDMSI_STATUS_VALUE {
343     PIDMSI_STATUS_NORMAL = 0,
344     PIDMSI_STATUS_NEW,
345     PIDMSI_STATUS_PRELIM,
346     PIDMSI_STATUS_DRAFT,
347     PIDMSI_STATUS_INPROGRESS,
348     PIDMSI_STATUS_EDIT,
349     PIDMSI_STATUS_REVIEW,
350     PIDMSI_STATUS_PROOF,
351     PIDMSI_STATUS_FINAL,
352     PIDMSI_STATUS_OTHER = 0x7fff,
353 }}
354 extern "system" {
PropVariantCopy( pvarDest: *mut PROPVARIANT, pvarSrc: *const PROPVARIANT, ) -> HRESULT355     pub fn PropVariantCopy(
356         pvarDest: *mut PROPVARIANT,
357         pvarSrc: *const PROPVARIANT,
358     ) -> HRESULT;
PropVariantClear( pvar: *mut PROPVARIANT, ) -> HRESULT359     pub fn PropVariantClear(
360         pvar: *mut PROPVARIANT,
361     ) -> HRESULT;
FreePropVariantArray( cVariants: ULONG, rgvars: *mut PROPVARIANT, ) -> HRESULT362     pub fn FreePropVariantArray(
363         cVariants: ULONG,
364         rgvars: *mut PROPVARIANT,
365     ) -> HRESULT;
366 }
367 // #[inline]
368 // pub fn PropVariantInit(pvar: *mut PROPVARIANT) {
369 //     memset(pvar, 0, sizeof(PROPVARIANT))
370 // }
371 STRUCT!{struct SERIALIZEDPROPERTYVALUE {
372     dwType: DWORD,
373     rgb: *mut BYTE,
374 }}
375 pub type PMemoryAllocator = PVOID;
376 extern "system" {
StgConvertVariantToProperty( pvar: *const PROPVARIANT, CodePage: USHORT, pprop: *mut SERIALIZEDPROPERTYVALUE, pcb: *mut ULONG, pid: PROPID, fReserved: BOOLEAN, pcIndirect: *mut ULONG, ) -> *mut SERIALIZEDPROPERTYVALUE377     pub fn StgConvertVariantToProperty(
378         pvar: *const PROPVARIANT,
379         CodePage: USHORT,
380         pprop: *mut SERIALIZEDPROPERTYVALUE,
381         pcb: *mut ULONG,
382         pid: PROPID,
383         fReserved: BOOLEAN,
384         pcIndirect: *mut ULONG,
385     ) -> *mut SERIALIZEDPROPERTYVALUE;
StgConvertPropertyToVariant( pprop: *const SERIALIZEDPROPERTYVALUE, CodePage: USHORT, pvar: *mut PROPVARIANT, pma: *mut PMemoryAllocator ) -> BOOLEAN386     pub fn StgConvertPropertyToVariant(
387         pprop: *const SERIALIZEDPROPERTYVALUE,
388         CodePage: USHORT,
389         pvar: *mut PROPVARIANT,
390         pma: *mut PMemoryAllocator
391     ) -> BOOLEAN;
392 }
393