vendor/winapi/src/um/propidl.rs

   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]
 173 pub fn PROPSETHDR_OSVER_KIND(dwOSVer: DWORD) -> WORD {
 174     HIWORD(dwOSVer)
 175 }
 176 #[inline]
 177 pub fn PROPSETHDR_OSVER_MAJOR(dwOSVer: DWORD) -> BYTE {
 178     LOBYTE(LOWORD(dwOSVer))
 179 }
 180 #[inline]
 181 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" {
 355     pub fn PropVariantCopy(
 356         pvarDest: *mut PROPVARIANT,
 357         pvarSrc: *const PROPVARIANT,
 358     ) -> HRESULT;
 359     pub fn PropVariantClear(
 360         pvar: *mut PROPVARIANT,
 361     ) -> HRESULT;
 362     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" {
 377     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;
 386     pub fn StgConvertPropertyToVariant(
 387         pprop: *const SERIALIZEDPROPERTYVALUE,
 388         CodePage: USHORT,
 389         pvar: *mut PROPVARIANT,
 390         pma: *mut PMemoryAllocator
 391     ) -> BOOLEAN;
 392 }