include/objidl.idl

   1 /*
   2  * Copyright 2002 Ove Kaaven
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 import "unknwn.idl";
  20
  21 interface IStream;
  22 interface IStream16;
  23 interface IEnumString;
  24 interface IRunningObjectTable;
  25 interface IMoniker;
  26 interface IAdviseSink;
  27 interface IAsyncManager;
  28
  29 /* FIXME: COSERVERINFO should be moved here from wtypes.idl */
  30
  31 /******************** Fundamentals ********************/
  32
  33 [
  34   local,
  35   object,
  36   uuid(00000003-0000-0000-C000-000000000046)
  37 ]
  38 interface IMarshal : IUnknown
  39 {
  40   typedef [unique] IMarshal *LPMARSHAL;
  41
  42   HRESULT GetUnmarshalClass(
  43     [in] REFIID riid,
  44     [in, unique] void *pv,
  45     [in] DWORD dwDestContext,
  46     [in, unique] void *pvDestContext,
  47     [in] DWORD mshlflags,
  48     [out] CLSID *pCid);
  49
  50   HRESULT GetMarshalSizeMax(
  51     [in] REFIID riid,
  52     [in, unique] void *pv,
  53     [in] DWORD dwDestContext,
  54     [in, unique] void *pvDestContext,
  55     [in] DWORD mshlflags,
  56     [out] DWORD *pSize);
  57
  58   HRESULT MarshalInterface(
  59     [in, unique] IStream *pStm,
  60     [in] REFIID riid,
  61     [in, unique] void *pv,
  62     [in] DWORD dwDestContext,
  63     [in, unique] void *pvDestContext,
  64     [in] DWORD mshlflags);
  65
  66   HRESULT UnmarshalInterface(
  67     [in, unique] IStream *pStm,
  68     [in] REFIID riid,
  69     [out] void **ppv);
  70
  71   HRESULT ReleaseMarshalData(
  72     [in, unique] IStream *pStm);
  73
  74   HRESULT DisconnectObject(
  75     [in] DWORD dwReserved);
  76 }
  77
  78 [
  79   local,
  80   object,
  81   uuid(00000018-0000-0000-C000-000000000046)
  82 ]
  83 interface IStdMarshalInfo : IUnknown
  84 {
  85   typedef [unique] IStdMarshalInfo *LPSTDMARSHALINFO;
  86
  87   HRESULT GetClassForHandler(
  88     [in] DWORD dwDestContext,
  89     [in, unique] void *pvDestContext,
  90     [out] CLSID *pClsid);
  91 }
  92
  93 [
  94   local,
  95   object,
  96   uuid(00000019-0000-0000-C000-000000000046)
  97 ]
  98 interface IExternalConnection : IUnknown
  99 {
 100   typedef [unique] IExternalConnection *LPEXTERNALCONNECTION;
 101
 102   typedef enum tagEXTCONN {
 103     EXTCONN_STRONG   = 0x0001,
 104     EXTCONN_WEAK     = 0x0002,
 105     EXTCONN_CALLABLE = 0x0004
 106   } EXTCONN;
 107
 108   DWORD AddConnection(
 109     [in] DWORD extconn,
 110     [in] DWORD reserved);
 111
 112   DWORD ReleaseConnection(
 113     [in] DWORD extconn,
 114     [in] DWORD reserved,
 115     [in] BOOL fLastReleaseCloses);
 116 }
 117
 118 [
 119   local,
 120   object,
 121   uuid(00000020-0000-0000-C000-000000000046)
 122 ]
 123 interface IMultiQI : IUnknown
 124 {
 125   typedef [unique] IMultiQI *LPMULTIQI;
 126
 127   typedef struct tagMULTI_QI {
 128     const IID *pIID;
 129     IUnknown *pItf;
 130     HRESULT hr;
 131   } MULTI_QI;
 132
 133   HRESULT QueryMultipleInterfaces(
 134     [in] ULONG cMQIs,
 135     [in, out] MULTI_QI *pMQIs);
 136 }
 137
 138 [
 139   local,
 140   object,
 141   uuid(00000002-0000-0000-C000-000000000046)
 142 ]
 143 interface IMalloc : IUnknown
 144 {
 145   typedef [unique] IMalloc *LPMALLOC;
 146
 147   LPVOID Alloc(
 148     [in] ULONG cb);
 149
 150   LPVOID Realloc(
 151     [in] LPVOID pv,
 152     [in] ULONG cb);
 153
 154   void Free(
 155     [in] LPVOID pv);
 156
 157   ULONG GetSize(
 158     [in] LPVOID pv);
 159
 160   int DidAlloc(LPVOID pv);
 161
 162   void HeapMinimize();
 163 }
 164
 165 [
 166   local,
 167   object,
 168   uuid(0000001d-0000-0000-C000-000000000046)
 169 ]
 170 interface IMallocSpy : IUnknown
 171 {
 172   typedef [unique] IMallocSpy *LPMALLOCSPY;
 173
 174   ULONG PreAlloc(
 175     [in] ULONG cbRequest);
 176
 177   LPVOID PostAlloc(
 178     [in] LPVOID pActual);
 179
 180   LPVOID PreFree(
 181     [in] LPVOID pRequest,
 182     [in] BOOL fSpyed);
 183
 184   void PostFree(
 185     [in] BOOL fSpyed);
 186
 187   ULONG PreRealloc(
 188     [in] LPVOID pRequest,
 189     [in] ULONG cbRequest,
 190     [out] LPVOID *ppNewRequest,
 191     [in] BOOL fSpyed);
 192
 193   LPVOID PostRealloc(
 194     [in] LPVOID pActual,
 195     [in] BOOL fSpyed);
 196
 197   LPVOID PreGetSize(
 198     [in] LPVOID pRequest,
 199     [in] BOOL fSpyed);
 200
 201   ULONG PostGetSize(
 202     [in] ULONG cbActual,
 203     [in] BOOL fSpyed);
 204
 205   LPVOID PreDidAlloc(
 206     [in] LPVOID pRequest,
 207     [in] BOOL fSpyed);
 208
 209   int PostDidAlloc(
 210     [in] LPVOID pRequest,
 211     [in] BOOL fSpyed,
 212     [in] int fActual);
 213
 214   void PreHeapMinimize();
 215
 216   void PostHeapMinimize();
 217 }
 218
 219 [
 220   object,
 221   uuid(00000100-0000-0000-C000-000000000046),
 222   pointer_default(unique)
 223 ]
 224 interface IEnumUnknown : IUnknown
 225 {
 226   typedef [unique] IEnumUnknown *LPENUMUNKNOWN;
 227
 228   [local]
 229   HRESULT Next(
 230     [in] ULONG celt,
 231     [out] IUnknown **rgelt,
 232     [out] ULONG *pceltFetched);
 233
 234   [call_as(Next)]
 235   HRESULT RemoteNext(
 236     [in] ULONG celt,
 237     [out, size_is(celt), length_is(*pceltFetched)]
 238     IUnknown **rgelt,
 239     [out] ULONG *pceltFetched);
 240
 241   HRESULT Skip(
 242     [in] ULONG celt);
 243
 244   HRESULT Reset();
 245
 246   HRESULT Clone(
 247     [out] IEnumUnknown **ppenum);
 248 }
 249
 250 [
 251   object,
 252   uuid(00000022-0000-0000-C000-000000000046),
 253   version(1.0),
 254   pointer_default(unique)
 255 ]
 256 interface ISurrogate : IUnknown
 257 {
 258   typedef [unique] ISurrogate *LPSURROGATE;
 259
 260   HRESULT LoadDllServer(
 261     [in] REFCLSID Clsid);
 262   HRESULT FreeSurrogate();
 263 }
 264
 265 [
 266   local,
 267   object,
 268   uuid(00000146-0000-0000-C000-000000000046)
 269 ]
 270 interface IGlobalInterfaceTable : IUnknown
 271 {
 272   typedef [unique] IGlobalInterfaceTable *LPGLOBALINTERFACETABLE;
 273
 274   HRESULT RegisterInterfaceInGlobal(
 275     [in] IUnknown *pUnk,
 276     [in] REFIID riid,
 277     [out] DWORD *pdwCookie);
 278
 279   HRESULT RevokeInterfaceFromGlobal(
 280     [in] DWORD dwCookie);
 281
 282   HRESULT GetInterfaceFromGlobal(
 283     [in] DWORD dwCookie,
 284     [in] REFIID riid,
 285     [out, iid_is(riid)] void **ppv);
 286 }
 287
 288 /******************** Monikers ********************/
 289
 290 [
 291   object,
 292   uuid(0000000e-0000-0000-C000-000000000046),
 293   pointer_default(unique)
 294 ]
 295 interface IBindCtx : IUnknown
 296 {
 297   typedef [unique] IBindCtx *LPBINDCTX;
 298   typedef [unique] IBindCtx *LPBC;
 299
 300   typedef struct tagBIND_OPTS {
 301     DWORD cbStruct;
 302     DWORD grfFlags;
 303     DWORD grfMode;
 304     DWORD dwTickCountDeadline;
 305   } BIND_OPTS, *LPBIND_OPTS;
 306
 307   /* FIXME: C++ crap */
 308   typedef struct tagBIND_OPTS2 {
 309     DWORD cbStruct;
 310     DWORD grfFlags;
 311     DWORD grfMode;
 312     DWORD dwTickCountDeadline;
 313     DWORD dwTrackFlags;
 314     DWORD dwClassContext;
 315     LCID  locale;
 316     COSERVERINFO *pServerInfo;
 317   } BIND_OPTS2, *LPBIND_OPTS2;
 318
 319   typedef enum tagBIND_FLAGS {
 320     BIND_MAYBOTHERUSER   = 1,
 321     BIND_JUSTTESTEXISTENCE = 2
 322   } BIND_FLAGS;
 323
 324   HRESULT RegisterObjectBound(
 325     [in, unique] IUnknown *punk);
 326
 327   HRESULT RevokeObjectBound(
 328     [in, unique] IUnknown *punk);
 329
 330   HRESULT ReleaseBoundObjects();
 331
 332   [local]
 333   HRESULT SetBindOptions(
 334     [in] BIND_OPTS *pbindopts);
 335
 336   [call_as(SetBindOptions)]
 337   HRESULT RemoteSetBindOptions(
 338     [in] BIND_OPTS2 *pbindopts);
 339
 340   [local]
 341   HRESULT GetBindOptions(
 342     [in, out] BIND_OPTS *pbindopts);
 343
 344   [call_as(GetBindOptions)]
 345   HRESULT RemoteGetBindOptions(
 346     [in, out] BIND_OPTS2 *pbindopts);
 347
 348   HRESULT GetRunningObjectTable(
 349     [out] IRunningObjectTable **pprot);
 350
 351   HRESULT RegisterObjectParam(
 352     [in] LPOLESTR pszKey,
 353     [in, unique] IUnknown *punk);
 354
 355   HRESULT GetObjectParam(
 356     [in] LPOLESTR pszKey,
 357     [out] IUnknown **ppunk);
 358
 359   HRESULT EnumObjectParam(
 360     [out] IEnumString **ppenum);
 361
 362   HRESULT RevokeObjectParam(
 363     [in] LPOLESTR pszKey);
 364 }
 365
 366 [
 367   object,
 368   uuid(00000102-0000-0000-C000-000000000046),
 369   pointer_default(unique)
 370 ]
 371 interface IEnumMoniker : IUnknown
 372 {
 373   typedef [unique] IEnumMoniker *LPENUMMONIKER;
 374
 375   [local]
 376   HRESULT Next(
 377     [in] ULONG celt,
 378     [out, size_is(celt), length_is(*pceltFetched)]
 379     IMoniker **rgelt,
 380     [out] ULONG *pceltFetched);
 381
 382   [call_as(Next)]
 383   HRESULT RemoteNext(
 384     [in] ULONG celt,
 385     [out, size_is(celt), length_is(*pceltFetched)]
 386     IMoniker **rgelt,
 387     [out] ULONG *pceltFetched);
 388
 389   HRESULT Skip(
 390     [in] ULONG celt);
 391
 392   HRESULT Reset();
 393
 394   HRESULT Clone(
 395     [out] IEnumMoniker **ppenum);
 396 }
 397
 398 [
 399   object,
 400   uuid(00000126-0000-0000-C000-000000000046)
 401 ]
 402 interface IRunnableObject : IUnknown
 403 {
 404   typedef [unique] IRunnableObject *LPRUNNABLEOBJECT;
 405
 406   HRESULT GetRunningClass(
 407     [out] LPCLSID lpClsid);
 408
 409   HRESULT Run(
 410     [in] LPBINDCTX pbc);
 411
 412   [local]
 413   BOOL IsRunning();
 414
 415   [call_as(IsRunning)]
 416   HRESULT RemoteIsRunning();
 417
 418   HRESULT LockRunning(
 419     [in] BOOL fLock,
 420     [in] BOOL fLastUnlockCloses);
 421
 422   HRESULT SetContainedObject(
 423     [in] BOOL fContained);
 424 }
 425
 426 /* GetObject is defined in wingdi.h as WINELIB_NAME_AW(GetObject),
 427  * which resolves to a compilation failure if __WINESRC__ is defined,
 428  * but GetObject is used as a valid method name below, so we have
 429  * to undefine it if __WINESRC__ is defined */
 430 cpp_quote("#ifdef __WINESRC__")
 431 cpp_quote("#undef GetObject")
 432 cpp_quote("#endif")
 433
 434 [
 435   object,
 436   uuid(00000010-0000-0000-C000-000000000046)
 437 ]
 438 interface IRunningObjectTable : IUnknown
 439 {
 440   typedef [unique] IRunningObjectTable *LPRUNNINGOBJECTTABLE;
 441
 442   HRESULT Register(
 443     [in] DWORD grfFlags,
 444     [in, unique] IUnknown *punkObject,
 445     [in, unique] IMoniker *pmkObjectName,
 446     [out] DWORD *pdwRegister);
 447
 448   HRESULT Revoke(
 449     [in] DWORD dwRegister);
 450
 451   HRESULT IsRunning(
 452     [in, unique] IMoniker *pmkObjectName);
 453
 454   HRESULT GetObject(
 455     [in, unique] IMoniker *pmkObjectName,
 456     [out] IUnknown **ppunkObject);
 457
 458   HRESULT NoteChangeTime(
 459     [in] DWORD dwRegister,
 460     [in] FILETIME *pfiletime);
 461
 462   HRESULT GetTimeOfLastChange(
 463     [in, unique] IMoniker *pmkObjectName,
 464     [out] FILETIME *pfiletime);
 465
 466   HRESULT EnumRunning(
 467     [out] IEnumMoniker **ppenumMoniker);
 468 }
 469
 470 [
 471   object,
 472   uuid(0000010c-0000-0000-C000-000000000046)
 473 ]
 474 interface IPersist : IUnknown
 475 {
 476   typedef [unique] IPersist *LPPERSIST;
 477
 478   HRESULT GetClassID(
 479     [out] CLSID *pClassID);
 480 }
 481
 482 [
 483   object,
 484   uuid(00000109-0000-0000-C000-000000000046),
 485   pointer_default(unique)
 486 ]
 487 interface IPersistStream : IPersist
 488 {
 489   typedef [unique] IPersistStream *LPPERSISTSTREAM;
 490
 491   HRESULT IsDirty();
 492
 493   HRESULT Load(
 494     [in, unique] IStream *pStm);
 495
 496   HRESULT Save(
 497     [in, unique] IStream *pStm,
 498     [in] BOOL fClearDirty);
 499
 500   HRESULT GetSizeMax(
 501     [out] ULARGE_INTEGER *pcbSize);
 502 }
 503
 504 [
 505   object,
 506   uuid(0000000f-0000-0000-C000-000000000046),
 507   pointer_default(unique)
 508 ]
 509 interface IMoniker : IPersistStream
 510 {
 511   typedef [unique] IMoniker *LPMONIKER;
 512
 513   typedef enum tagMKSYS {
 514     MKSYS_NONE             = 0,
 515     MKSYS_GENERICCOMPOSITE = 1,
 516     MKSYS_FILEMONIKER      = 2,
 517     MKSYS_ANTIMONIKER      = 3,
 518     MKSYS_ITEMMONIKER      = 4,
 519     MKSYS_POINTERMONIKER   = 5,
 520     MKSYS_CLASSMONIKER     = 7
 521   } MKSYS;
 522
 523   typedef [v1_enum] enum tagMKREDUCE {
 524     MKRREDUCE_ONE         = 3 << 16,
 525     MKRREDUCE_TOUSER      = 2 << 16,
 526     MKRREDUCE_THROUGHUSER = 1 << 16,
 527     MKRREDUCE_ALL         = 0
 528   } MKRREDUCE;
 529
 530   [local]
 531   HRESULT BindToObject(
 532     [in, unique] IBindCtx *pbc,
 533     [in, unique] IMoniker *pmkToLeft,
 534     [in] REFIID riidResult,
 535     [out, iid_is(riidResult)] void **ppvResult);
 536
 537   [call_as(BindToObject)]
 538   HRESULT RemoteBindToObject(
 539     [in, unique] IBindCtx *pbc,
 540     [in, unique] IMoniker *pmkToLeft,
 541     [in] REFIID riidResult,
 542     [out, iid_is(riidResult)] IUnknown **ppvResult);
 543
 544   [local]
 545   HRESULT BindToStorage(
 546     [in, unique] IBindCtx *pbc,
 547     [in, unique] IMoniker *pmkToLeft,
 548     [in] REFIID riid,
 549     [out, iid_is(riid)] void **ppvObj);
 550
 551   [call_as(BindToStorage)]
 552   HRESULT RemoteBindToStorage(
 553     [in, unique] IBindCtx *pbc,
 554     [in, unique] IMoniker *pmkToLeft,
 555     [in] REFIID riid,
 556     [out, iid_is(riid)] IUnknown **ppvObj);
 557
 558   HRESULT Reduce(
 559     [in, unique] IBindCtx *pbc,
 560     [in] DWORD dwReduceHowFar,
 561     [in, out, unique] IMoniker **ppmkToLeft,
 562     [out] IMoniker **ppmkReduced);
 563
 564   HRESULT ComposeWith(
 565     [in, unique] IMoniker *pmkRight,
 566     [in] BOOL fOnlyIfNotGeneric,
 567     [out] IMoniker **ppmkComposite);
 568
 569   HRESULT Enum(
 570     [in] BOOL fForward,
 571     [out] IEnumMoniker **ppenumMoniker);
 572
 573   HRESULT IsEqual(
 574     [in, unique] IMoniker *pmkOtherMoniker);
 575
 576   HRESULT Hash(
 577     [out] DWORD *pdwHash);
 578
 579   HRESULT IsRunning(
 580     [in, unique] IBindCtx *pbc,
 581     [in, unique] IMoniker *pmkToLeft,
 582     [in, unique] IMoniker *pmkNewlyRunning);
 583
 584   HRESULT GetTimeOfLastChange(
 585     [in, unique] IBindCtx *pbc,
 586     [in, unique] IMoniker *pmkToLeft,
 587     [out] FILETIME *pFileTime);
 588
 589   HRESULT Inverse(
 590     [out] IMoniker **ppmk);
 591
 592   HRESULT CommonPrefixWith(
 593     [in, unique] IMoniker *pmkOther,
 594     [out] IMoniker **ppmkPrefix);
 595
 596   HRESULT RelativePathTo(
 597     [in, unique] IMoniker *pmkOther,
 598     [out] IMoniker **ppmkRelPath);
 599
 600   HRESULT GetDisplayName(
 601     [in, unique] IBindCtx *pbc,
 602     [in, unique] IMoniker *pmkToLeft,
 603     [out] LPOLESTR *ppszDisplayName);
 604
 605   HRESULT ParseDisplayName(
 606     [in, unique] IBindCtx *pbc,
 607     [in, unique] IMoniker *pmkToLeft,
 608     [in] LPOLESTR pszDisplayName,
 609     [out] ULONG *pchEaten,
 610     [out] IMoniker **ppmkOut);
 611
 612   HRESULT IsSystemMoniker(
 613     [out] DWORD *pdwMksys);
 614 }
 615
 616 [
 617   object,
 618   uuid(f29f6bc0-5021-11ce-aa15-00006901293f),
 619   pointer_default(unique)
 620 ]
 621 interface IROTData : IUnknown
 622 {
 623   HRESULT GetComparisonData(
 624     [out, size_is(cbMax)] byte *pbData,
 625     [in] ULONG cbMax,
 626     [out] ULONG *pcbData);
 627 }
 628
 629 [
 630   object,
 631   uuid(00000101-0000-0000-C000-000000000046),
 632   pointer_default(unique)
 633 ]
 634 interface IEnumString : IUnknown
 635 {
 636   typedef [unique] IEnumString *LPENUMSTRING;
 637
 638   [local]
 639   HRESULT Next(
 640     [in] ULONG celt,
 641     [out, size_is(celt), length_is(*pceltFetched)]
 642     LPOLESTR *rgelt,
 643     [out] ULONG *pceltFetched);
 644
 645   [call_as(Next)]
 646   HRESULT RemoteNext(
 647     [in] ULONG celt,
 648     [out, size_is(celt), length_is(*pceltFetched)]
 649     LPOLESTR *rgelt,
 650     [out] ULONG *pceltFetched);
 651
 652   HRESULT Skip(
 653     [in] ULONG celt);
 654
 655   HRESULT Reset();
 656
 657   HRESULT Clone(
 658     [out] IEnumString **ppenum);
 659 }
 660
 661 [
 662   object,
 663   uuid(00000140-0000-0000-C000-000000000046)
 664 ]
 665 interface IClassActivator : IUnknown
 666 {
 667   HRESULT GetClassObject(
 668     [in] REFCLSID rclsid,
 669     [in] DWORD dwClassContext,
 670     [in] LCID locale,
 671     [in] REFIID riid,
 672     [out, iid_is(riid)] void **ppv);
 673 }
 674
 675 /******************** Storage ********************/
 676
 677 [
 678   object,
 679   uuid(0c733a30-2a1c-11ce-ade5-00aa0044773d),
 680   pointer_default(unique)
 681 ]
 682 interface ISequentialStream : IUnknown
 683 {
 684   [local]
 685   HRESULT Read(
 686     [out, size_is(cb), length_is(*pcbRead)]
 687     void *pv,
 688     [in] ULONG cb,
 689     [out] ULONG *pcbRead);
 690
 691   [call_as(Read)]
 692   HRESULT RemoteRead(
 693     [out, size_is(cb), length_is(*pcbRead)]
 694     byte *pv,
 695     [in] ULONG cb,
 696     [out] ULONG *pcbRead);
 697
 698   [local]
 699   HRESULT Write(
 700     [in, size_is(cb)] const void *pv,
 701     [in] ULONG cb,
 702     [out] ULONG *pcbWritten);
 703
 704   [call_as(Write)]
 705   HRESULT RemoteWrite(
 706     [in, size_is(cb)] const byte *pv,
 707     [in] ULONG cb,
 708     [out] ULONG *pcbWritten);
 709 }
 710
 711 [
 712   object,
 713   uuid(0000000c-0000-0000-C000-000000000046),
 714   pointer_default(unique)
 715 ]
 716 interface IStream : ISequentialStream
 717 {
 718   typedef [unique] IStream *LPSTREAM;
 719
 720   typedef struct tagSTATSTG {
 721     LPOLESTR pwcsName;
 722     DWORD type;
 723     ULARGE_INTEGER cbSize;
 724     FILETIME mtime;
 725     FILETIME ctime;
 726     FILETIME atime;
 727     DWORD grfMode;
 728     DWORD grfLocksSupported;
 729     CLSID clsid;
 730     DWORD grfStateBits;
 731     DWORD reserved;
 732   } STATSTG;
 733
 734   typedef enum tagSTGTY {
 735     STGTY_STORAGE   = 1,
 736     STGTY_STREAM    = 2,
 737     STGTY_LOCKBYTES = 3,
 738     STGTY_PROPERTY  = 4
 739   } STGTY;
 740
 741   typedef enum tagSTREAM_SEEK {
 742     STREAM_SEEK_SET = 0,
 743     STREAM_SEEK_CUR = 1,
 744     STREAM_SEEK_END = 2
 745   } STREAM_SEEK;
 746
 747   /* these are defined in Linux's fcntl.h,
 748    * undefine them to avoid conflicts */
 749   cpp_quote("#undef LOCK_MAND")
 750   cpp_quote("#undef LOCK_READ")
 751   cpp_quote("#undef LOCK_WRITE")
 752   cpp_quote("#undef LOCK_RW")
 753
 754   typedef enum tagLOCKTYPE {
 755     LOCK_WRITE      = 1,
 756     LOCK_EXCLUSIVE  = 2,
 757     LOCK_ONLYONCE   = 4
 758   } LOCKTYPE;
 759
 760   [local]
 761   HRESULT Seek(
 762     [in] LARGE_INTEGER dlibMove,
 763     [in] DWORD dwOrigin,
 764     [out] ULARGE_INTEGER *plibNewPosition);
 765
 766   [call_as(Seek)]
 767   HRESULT RemoteSeek(
 768     [in] LARGE_INTEGER dlibMove,
 769     [in] DWORD dwOrigin,
 770     [out] ULARGE_INTEGER *plibNewPosition);
 771
 772   HRESULT SetSize(
 773     [in] ULARGE_INTEGER libNewSize);
 774
 775   [local]
 776   HRESULT CopyTo(
 777     [in, unique] IStream *pstm,
 778     [in] ULARGE_INTEGER cb,
 779     [out] ULARGE_INTEGER *pcbRead,
 780     [out] ULARGE_INTEGER *pcbWritten);
 781
 782   [call_as(CopyTo)]
 783   HRESULT RemoteCopyTo(
 784     [in, unique] IStream *pstm,
 785     [in] ULARGE_INTEGER cb,
 786     [out] ULARGE_INTEGER *pcbRead,
 787     [out] ULARGE_INTEGER *pcbWritten);
 788
 789   HRESULT Commit(
 790     [in] DWORD grfCommitFlags);
 791
 792   HRESULT Revert();
 793
 794   HRESULT LockRegion(
 795     [in] ULARGE_INTEGER libOffset,
 796     [in] ULARGE_INTEGER cb,
 797     [in] DWORD dwLockType);
 798
 799   HRESULT UnlockRegion(
 800     [in] ULARGE_INTEGER libOffset,
 801     [in] ULARGE_INTEGER cb,
 802     [in] DWORD dwLockType);
 803
 804   HRESULT Stat(
 805     [out] STATSTG *pstatstg,
 806     [in] DWORD grfStatFlag);
 807
 808   HRESULT Clone(
 809     [out] IStream **ppstm);
 810 }
 811
 812 [
 813   object,
 814   pointer_default(unique)
 815 ]
 816 interface IStream16 : ISequentialStream
 817 {
 818   typedef [unique] IStream16 *LPSTREAM16;
 819
 820   typedef struct tagSTATSTG16 {
 821     LPOLESTR16 pwcsName;
 822     DWORD type;
 823     ULARGE_INTEGER cbSize;
 824     FILETIME mtime;
 825     FILETIME ctime;
 826     FILETIME atime;
 827     DWORD grfMode;
 828     DWORD grfLocksSupported;
 829     CLSID clsid;
 830     DWORD grfStateBits;
 831     DWORD reserved;
 832   } STATSTG16;
 833
 834   [local]
 835   HRESULT Seek(
 836     [in] LARGE_INTEGER dlibMove,
 837     [in] DWORD dwOrigin,
 838     [out] ULARGE_INTEGER *plibNewPosition);
 839
 840   [call_as(Seek)]
 841   HRESULT RemoteSeek(
 842     [in] LARGE_INTEGER dlibMove,
 843     [in] DWORD dwOrigin,
 844     [out] ULARGE_INTEGER *plibNewPosition);
 845
 846   HRESULT SetSize(
 847     [in] ULARGE_INTEGER libNewSize);
 848
 849   [local]
 850   HRESULT CopyTo(
 851     [in, unique] IStream16 *pstm,
 852     [in] ULARGE_INTEGER cb,
 853     [out] ULARGE_INTEGER *pcbRead,
 854     [out] ULARGE_INTEGER *pcbWritten);
 855
 856   [call_as(CopyTo)]
 857   HRESULT RemoteCopyTo(
 858     [in, unique] IStream16 *pstm,
 859     [in] ULARGE_INTEGER cb,
 860     [out] ULARGE_INTEGER *pcbRead,
 861     [out] ULARGE_INTEGER *pcbWritten);
 862
 863   HRESULT Commit(
 864     [in] DWORD grfCommitFlags);
 865
 866   HRESULT Revert();
 867
 868   HRESULT LockRegion(
 869     [in] ULARGE_INTEGER libOffset,
 870     [in] ULARGE_INTEGER cb,
 871     [in] DWORD dwLockType);
 872
 873   HRESULT UnlockRegion(
 874     [in] ULARGE_INTEGER libOffset,
 875     [in] ULARGE_INTEGER cb,
 876     [in] DWORD dwLockType);
 877
 878   HRESULT Stat(
 879     [out] STATSTG *pstatstg,
 880     [in] DWORD grfStatFlag);
 881
 882   HRESULT Clone(
 883     [out] IStream16 **ppstm);
 884 }
 885
 886 [
 887   object,
 888   uuid(0000000d-0000-0000-C000-000000000046),
 889   pointer_default(unique)
 890 ]
 891 interface IEnumSTATSTG : IUnknown
 892 {
 893   typedef [unique] IEnumSTATSTG *LPENUMSTATSTG;
 894
 895   [local]
 896   HRESULT Next(
 897     [in] ULONG celt,
 898     [out, size_is(celt), length_is(*pceltFetched)]
 899     STATSTG *rgelt,
 900     [out] ULONG *pceltFetched);
 901
 902   [call_as(Next)]
 903   HRESULT RemoteNext(
 904     [in] ULONG celt,
 905     [out, size_is(celt), length_is(*pceltFetched)]
 906     STATSTG *rgelt,
 907     [out] ULONG *pceltFetched);
 908
 909   HRESULT Skip(
 910     [in] ULONG celt);
 911
 912   HRESULT Reset();
 913
 914   HRESULT Clone(
 915     [out] IEnumSTATSTG **ppenum);
 916 }
 917
 918 [
 919   object,
 920   uuid(0000000b-0000-0000-C000-000000000046),
 921   pointer_default(unique)
 922 ]
 923 interface IStorage : IUnknown
 924 {
 925   typedef [unique] IStorage *LPSTORAGE;
 926
 927   typedef struct tagRemSNB {
 928     unsigned long ulCntStr;
 929     unsigned long ulCntChar;
 930     [size_is(ulCntChar)] OLECHAR rgString[];
 931   } RemSNB;
 932
 933   typedef [unique] RemSNB *wireSNB;
 934   typedef [wire_marshal(wireSNB)] OLECHAR **SNB;
 935
 936   HRESULT CreateStream(
 937     [in] LPCOLESTR pwcsName,
 938     [in] DWORD grfMode,
 939     [in] DWORD reserved1,
 940     [in] DWORD reserved2,
 941     [out] IStream **ppstm);
 942
 943   [local]
 944   HRESULT OpenStream(
 945     [in] LPCOLESTR pwcsName,
 946     [in, unique] void *reserved1,
 947     [in] DWORD grfMode,
 948     [in] DWORD reserved2,
 949     [out] IStream **ppstm);
 950
 951   [call_as(OpenStream)]
 952   HRESULT RemoteOpenStream(
 953     [in] LPCOLESTR pwcsName,
 954     [in] unsigned long cbReserved1,
 955     [in, unique, size_is(cbReserved1)] byte *reserved1,
 956     [in] DWORD grfMode,
 957     [in] DWORD reserved2,
 958     [out] IStream **ppstm);
 959
 960   HRESULT CreateStorage(
 961     [in] LPCOLESTR pwcsName,
 962     [in] DWORD grfMode,
 963     [in] DWORD dwStgFmt,
 964     [in] DWORD reserved2,
 965     [out] IStorage **ppstg);
 966
 967   HRESULT OpenStorage(
 968     [in, unique] LPCOLESTR pwcsName,
 969     [in, unique] IStorage *pstgPriority,
 970     [in] DWORD grfMode,
 971     [in, unique] SNB snbExclude,
 972     [in] DWORD reserved,
 973     [out] IStorage **ppstg);
 974
 975   HRESULT CopyTo(
 976     [in] DWORD ciidExclude,
 977     [in, unique, size_is(ciidExclude)] const IID *rgiidExclude,
 978     [in, unique] SNB snbExclude,
 979     [in, unique] IStorage *pstgDest);
 980
 981   HRESULT MoveElementTo(
 982     [in] LPCOLESTR pwcsName,
 983     [in, unique] IStorage *pstgDest,
 984     [in] LPCOLESTR pwcsNewName,
 985     [in] DWORD grfFlags);
 986
 987   HRESULT Commit(
 988     [in] DWORD grfCommitFlags);
 989
 990   HRESULT Revert();
 991
 992   [local]
 993   HRESULT EnumElements(
 994     [in] DWORD reserved1,
 995     [in, unique, size_is(1)] void *reserved2,
 996     [in] DWORD reserved3,
 997     [out] IEnumSTATSTG **ppenum);
 998
 999   [call_as(EnumElements)]
1000   HRESULT RemoteEnumElements(
1001     [in] DWORD reserved1,
1002     [in] unsigned long cbReserved2,
1003     [in, unique, size_is(cbReserved2)] byte *reserved2,
1004     [in] DWORD reserved3,
1005     [out] IEnumSTATSTG **ppenum);
1006
1007   HRESULT DestroyElement(
1008     [in] LPCOLESTR pwcsName);
1009
1010   HRESULT RenameElement(
1011     [in] LPCOLESTR pwcsOldName,
1012     [in] LPCOLESTR pwcsNewName);
1013
1014   HRESULT SetElementTimes(
1015     [in, unique] LPCOLESTR pwcsName,
1016     [in, unique] const FILETIME *pctime,
1017     [in, unique] const FILETIME *patime,
1018     [in, unique] const FILETIME *pmtime);
1019
1020   HRESULT SetClass(
1021     [in] REFCLSID clsid);
1022
1023   HRESULT SetStateBits(
1024     [in] DWORD grfStateBits,
1025     [in] DWORD grfMask);
1026
1027   HRESULT Stat(
1028     [out] STATSTG *pstatstg,
1029     [in] DWORD grfStatFlag);
1030 }
1031
1032 [
1033   object,
1034   pointer_default(unique)
1035 ]
1036 interface IStorage16 : IUnknown
1037 {
1038   typedef [unique] IStorage16 *LPSTORAGE16;
1039
1040   typedef struct tagRemSNB16 {
1041     unsigned long ulCntStr;
1042     unsigned long ulCntChar;
1043     [size_is(ulCntChar)] OLECHAR16 rgString[];
1044   } RemSNB16;
1045
1046   typedef [unique] RemSNB16 *wireSNB16;
1047   typedef [wire_marshal(wireSNB16)] OLECHAR16 **SNB16;
1048
1049   HRESULT CreateStream(
1050     [in] LPCOLESTR16 pwcsName,
1051     [in] DWORD grfMode,
1052     [in] DWORD reserved1,
1053     [in] DWORD reserved2,
1054     [out] IStream16 **ppstm);
1055
1056   [local]
1057   HRESULT OpenStream(
1058     [in] LPCOLESTR16 pwcsName,
1059     [in, unique] void *reserved1,
1060     [in] DWORD grfMode,
1061     [in] DWORD reserved2,
1062     [out] IStream16 **ppstm);
1063
1064   [call_as(OpenStream)]
1065   HRESULT RemoteOpenStream(
1066     [in] LPCOLESTR16 pwcsName,
1067     [in] unsigned long cbReserved1,
1068     [in, unique, size_is(cbReserved1)] byte *reserved1,
1069     [in] DWORD grfMode,
1070     [in] DWORD reserved2,
1071     [out] IStream16 **ppstm);
1072
1073   HRESULT CreateStorage(
1074     [in] LPCOLESTR16 pwcsName,
1075     [in] DWORD grfMode,
1076     [in] DWORD dwStgFmt,
1077     [in] DWORD reserved2,
1078     [out] IStorage16 **ppstg);
1079
1080   HRESULT OpenStorage(
1081     [in, unique] LPCOLESTR16 pwcsName,
1082     [in, unique] IStorage16 *pstgPriority,
1083     [in] DWORD grfMode,
1084     [in, unique] SNB16 snbExclude,
1085     [in] DWORD reserved,
1086     [out] IStorage16 **ppstg);
1087
1088   HRESULT CopyTo(
1089     [in] DWORD ciidExclude,
1090     [in, unique, size_is(ciidExclude)] const IID *rgiidExclude,
1091     [in, unique] SNB16 snbExclude,
1092     [in, unique] IStorage16 *pstgDest);
1093
1094   HRESULT MoveElementTo(
1095     [in] LPCOLESTR16 pwcsName,
1096     [in, unique] IStorage16 *pstgDest,
1097     [in] LPCOLESTR16 pwcsNewName,
1098     [in] DWORD grfFlags);
1099
1100   HRESULT Commit(
1101     [in] DWORD grfCommitFlags);
1102
1103   HRESULT Revert();
1104
1105   [local]
1106   HRESULT EnumElements(
1107     [in] DWORD reserved1,
1108     [in, unique, size_is(1)] void *reserved2,
1109     [in] DWORD reserved3,
1110     [out] IEnumSTATSTG **ppenum);
1111
1112   [call_as(EnumElements)]
1113   HRESULT RemoteEnumElements(
1114     [in] DWORD reserved1,
1115     [in] unsigned long cbReserved2,
1116     [in, unique, size_is(cbReserved2)] byte *reserved2,
1117     [in] DWORD reserved3,
1118     [out] IEnumSTATSTG **ppenum);
1119
1120   HRESULT DestroyElement(
1121     [in] LPCOLESTR16 pwcsName);
1122
1123   HRESULT RenameElement(
1124     [in] LPCOLESTR16 pwcsOldName,
1125     [in] LPCOLESTR16 pwcsNewName);
1126
1127   HRESULT SetElementTimes(
1128     [in, unique] LPCOLESTR16 pwcsName,
1129     [in, unique] const FILETIME *pctime,
1130     [in, unique] const FILETIME *patime,
1131     [in, unique] const FILETIME *pmtime);
1132
1133   HRESULT SetClass(
1134     [in] REFCLSID clsid);
1135
1136   HRESULT SetStateBits(
1137     [in] DWORD grfStateBits,
1138     [in] DWORD grfMask);
1139
1140   HRESULT Stat(
1141     [out] STATSTG *pstatstg,
1142     [in] DWORD grfStatFlag);
1143 }
1144
1145 [
1146   object,
1147   uuid(0000010b-0000-0000-C000-000000000046),
1148   pointer_default(unique)
1149 ]
1150 interface IPersistFile : IPersist
1151 {
1152   typedef [unique] IPersistFile *LPPERSISTFILE;
1153
1154   HRESULT IsDirty();
1155
1156   HRESULT Load(
1157     [in] LPCOLESTR pszFileName,
1158     [in] DWORD dwMode);
1159
1160   HRESULT Save(
1161     [in, unique] LPCOLESTR pszFileName,
1162     [in] BOOL fRemember);
1163
1164   HRESULT SaveCompleted(
1165     [in, unique] LPCOLESTR pszFileName);
1166
1167   HRESULT GetCurFile(
1168     [out] LPOLESTR *ppszFileName);
1169 }
1170
1171 [
1172   object,
1173   uuid(0000010a-0000-0000-C000-000000000046),
1174   pointer_default(unique)
1175 ]
1176 interface IPersistStorage : IPersist
1177 {
1178   typedef [unique] IPersistStorage *LPPERSISTSTORAGE;
1179
1180   HRESULT IsDirty();
1181
1182   HRESULT InitNew(
1183     [in, unique] IStorage *pStg);
1184
1185   HRESULT Load(
1186     [in, unique] IStorage *pStg);
1187
1188   HRESULT Save(
1189     [in, unique] IStorage *pStgSave,
1190     [in] BOOL fSameAsLoad);
1191
1192   HRESULT SaveCompleted(
1193     [in, unique] IStorage *pStgNew);
1194
1195   HRESULT HandsOffStorage();
1196 }
1197
1198 [
1199   object,
1200   uuid(00000012-0000-0000-C000-000000000046),
1201   pointer_default(unique)
1202 ]
1203 interface IRootStorage : IUnknown
1204 {
1205   typedef [unique] IRootStorage *LPROOTSTORAGE;
1206
1207   HRESULT SwitchToFile(
1208     [in] LPOLESTR pszFile);
1209 }
1210
1211 [
1212   object,
1213   uuid(0000000a-0000-0000-C000-000000000046),
1214   pointer_default(unique)
1215 ]
1216 interface ILockBytes : IUnknown
1217 {
1218   typedef [unique] ILockBytes *LPLOCKBYTES;
1219
1220   [local]
1221   HRESULT ReadAt(
1222     [in] ULARGE_INTEGER ulOffset,
1223     [out, size_is(cb), length_is(*pcbRead)]
1224     void *pv,
1225     [in] ULONG cb,
1226     [out] ULONG *pcbRead);
1227
1228   [call_as(ReadAt)]
1229   HRESULT RemoteReadAt(
1230     [in] ULARGE_INTEGER ulOffset,
1231     [out, size_is(cb), length_is(*pcbRead)]
1232     byte *pv,
1233     [in] ULONG cb,
1234     [out] ULONG *pcbRead);
1235
1236   [local]
1237   HRESULT WriteAt(
1238     [in] ULARGE_INTEGER ulOffset,
1239     [in, size_is(cb)] const void *pv,
1240     [in] ULONG cb,
1241     [out] ULONG *pcbWritten);
1242
1243   [call_as(WriteAt)]
1244   HRESULT RemoteWriteAt(
1245     [in] ULARGE_INTEGER ulOffset,
1246     [in, size_is(cb)] const byte *pv,
1247     [in] ULONG cb,
1248     [out] ULONG *pcbWritten);
1249
1250   HRESULT Flush();
1251
1252   HRESULT SetSize(
1253     [in] ULARGE_INTEGER cb);
1254
1255   HRESULT LockRegion(
1256     [in] ULARGE_INTEGER libOffset,
1257     [in] ULARGE_INTEGER cb,
1258     [in] DWORD dwLockType);
1259
1260   HRESULT UnlockRegion(
1261     [in] ULARGE_INTEGER libOffset,
1262     [in] ULARGE_INTEGER cb,
1263     [in] DWORD dwLockType);
1264
1265   HRESULT Stat(
1266     [out] STATSTG *pstatstg,
1267     [in] DWORD grfStatFlag);
1268 }
1269
1270 [
1271   object,
1272   uuid(99caf010-415e-11cf-8814-00aa00b569f5),
1273   pointer_default(unique)
1274 ]
1275 interface IFillLockBytes : IUnknown
1276 {
1277   [local]
1278   HRESULT FillAppend(
1279     [in, size_is(cb)] const void *pv,
1280     [in] ULONG cb,
1281     [out] ULONG *pcbWritten);
1282
1283   [call_as(FillAppend)]
1284   HRESULT RemoteFillAppend(
1285     [in, size_is(cb)] const byte *pv,
1286     [in] ULONG cb,
1287     [out] ULONG *pcbWritten);
1288
1289   [local]
1290   HRESULT FillAt(
1291     [in] ULARGE_INTEGER ulOffset,
1292     [in, size_is(cb)] const void *pv,
1293     [in] ULONG cb,
1294     [out] ULONG *pcbWritten);
1295
1296   [call_as(FillAt)]
1297   HRESULT RemoteFillAt(
1298     [in] ULARGE_INTEGER ulOffset,
1299     [in, size_is(cb)] const byte *pv,
1300     [in] ULONG cb,
1301     [out] ULONG *pcbWritten);
1302
1303   HRESULT SetFillSize(
1304     [in] ULARGE_INTEGER ulSize);
1305
1306   HRESULT Terminate(
1307     [in] BOOL bCanceled);
1308 }
1309
1310 [
1311   object,
1312   uuid(a9d758a0-4617-11cf-95fc-00aa00680db4),
1313   pointer_default(unique)
1314 ]
1315 interface IProgressNotify : IUnknown
1316 {
1317   HRESULT OnProgress(
1318     [in] DWORD dwProgressCurrent,
1319     [in] DWORD dwProgressMaximum,
1320     [in] BOOL fAccurate,
1321     [in] BOOL fOwner);
1322 }
1323
1324 [
1325   local,
1326   object,
1327   uuid(0e6d4d90-6738-11cf-9608-00aa00680db4),
1328   pointer_default(unique)
1329 ]
1330 interface ILayoutStorage : IUnknown
1331 {
1332   typedef struct tagStorageLayout {
1333     DWORD LayoutType;
1334     OLECHAR *pwcsElementName;
1335     LARGE_INTEGER cOffset;
1336     LARGE_INTEGER cBytes;
1337   } StorageLayout;
1338
1339   HRESULT LayoutScript(
1340     [in] StorageLayout *pStorageLayout,
1341     [in] DWORD nEntries,
1342     [in] DWORD glfInterleavedFlag);
1343
1344   HRESULT BeginMonitor();
1345
1346   HRESULT EndMonitor();
1347
1348   HRESULT ReLayoutDocfile(
1349     [in] OLECHAR *pwcsNewDfName);
1350
1351   HRESULT ReLayoutDocfileOnILockBytes(
1352     [in] ILockBytes *pILockBytes);
1353 }
1354
1355 /******************** Data Object ********************/
1356
1357 [
1358   object,
1359   uuid(00000103-0000-0000-C000-000000000046),
1360   pointer_default(unique)
1361 ]
1362 interface IEnumFORMATETC : IUnknown
1363 {
1364   typedef [unique] IEnumFORMATETC *LPENUMFORMATETC;
1365
1366   typedef struct tagDVTARGETDEVICE {
1367     DWORD tdSize;
1368     WORD tdDriverNameOffset;
1369     WORD tdDeviceNameOffset;
1370     WORD tdPortNameOffset;
1371     WORD tdExtDevmodeOffset;
1372     [size_is(tdSize - sizeof(DWORD) - 4*sizeof(WORD))]
1373     BYTE tdData[];
1374   } DVTARGETDEVICE;
1375
1376   typedef CLIPFORMAT *LPCLIPFORMAT;
1377
1378   typedef struct tagFORMATETC {
1379     CLIPFORMAT cfFormat;
1380     [unique] DVTARGETDEVICE *ptd;
1381     DWORD dwAspect;
1382     LONG lindex;
1383     DWORD tymed;
1384   } FORMATETC, *LPFORMATETC;
1385
1386   [local]
1387   HRESULT Next(
1388     [in] ULONG celt,
1389     [out, size_is(celt), length_is(*pceltFetched)]
1390     FORMATETC *rgelt,
1391     [out] ULONG *pceltFetched);
1392
1393   [call_as(Next)]
1394   HRESULT RemoteNext(
1395     [in] ULONG celt,
1396     [out, size_is(celt), length_is(*pceltFetched)]
1397     FORMATETC *rgelt,
1398     [out] ULONG *pceltFetched);
1399
1400   HRESULT Skip(
1401     [in] ULONG celt);
1402
1403   HRESULT Reset();
1404
1405   HRESULT Clone(
1406     [out] IEnumFORMATETC **ppenum);
1407 }
1408
1409 [
1410   object,
1411   uuid(00000105-0000-0000-C000-000000000046),
1412   pointer_default(unique)
1413 ]
1414 interface IEnumSTATDATA : IUnknown
1415 {
1416   typedef [unique] IEnumSTATDATA *LPENUMSTATDATA;
1417
1418   typedef enum tagADVF {
1419     ADVF_NODATA            = 1,
1420     ADVF_PRIMEFIRST        = 2,
1421     ADVF_ONLYONCE          = 4,
1422     ADVF_DATAONSTOP        = 64,
1423     ADVFCACHE_NOHANDLER    = 8,
1424     ADVFCACHE_FORCEBUILTIN = 16,
1425     ADVFCACHE_ONSAVE       = 32
1426   } ADVF;
1427
1428   typedef struct tagSTATDATA
1429   {
1430     FORMATETC formatetc;
1431     DWORD advf;
1432     [unique] IAdviseSink *pAdvSink;
1433     DWORD dwConnection;
1434   } STATDATA, *LPSTATDATA;
1435
1436   [local]
1437   HRESULT Next(
1438     [in] ULONG celt,
1439     [out, size_is(celt), length_is(*pceltFetched)]
1440     STATDATA *rgelt,
1441     [out] ULONG *pceltFetched);
1442
1443   [call_as(Next)]
1444   HRESULT RemoteNext(
1445     [in] ULONG celt,
1446     [out, size_is(celt), length_is(*pceltFetched)]
1447     STATDATA *rgelt,
1448     [out] ULONG *pceltFetched);
1449
1450   HRESULT Skip(
1451     [in] ULONG celt);
1452
1453   HRESULT Reset();
1454
1455   HRESULT Clone(
1456     [out] IEnumSTATDATA **ppenum);
1457 }
1458
1459 [
1460   object,
1461   uuid(0000010f-0000-0000-C000-000000000046),
1462   pointer_default(unique)
1463 ]
1464 interface IAdviseSink : IUnknown
1465 {
1466   typedef IAdviseSink *LPADVISESINK;
1467
1468   typedef [v1_enum] enum tagTYMED {
1469     TYMED_HGLOBAL  = 1,
1470     TYMED_FILE     = 2,
1471     TYMED_ISTREAM  = 4,
1472     TYMED_ISTORAGE = 8,
1473     TYMED_GDI      = 16,
1474     TYMED_MFPICT   = 32,
1475     TYMED_ENHMF    = 64,
1476     TYMED_NULL     = 0
1477   } TYMED;
1478
1479   typedef struct tagRemSTGMEDIUM {
1480     DWORD tymed;
1481     DWORD dwHandleType;
1482     unsigned long pData;
1483     unsigned long pUnkForRelease;
1484     unsigned long cbData;
1485     [size_is(cbData)] byte data[];
1486   } RemSTGMEDIUM;
1487
1488   /* FIXME: C/C++ nameless union version */
1489   typedef struct tagSTGMEDIUM {
1490     DWORD tymed;
1491     [switch_is(tymed)] union {
1492     [case(TYMED_GDI)]      HBITMAP hBitmap;
1493     [case(TYMED_MFPICT)]   HMETAFILEPICT hMetaFilePict;
1494     [case(TYMED_ENHMF)]    HENHMETAFILE hEnhMetaFile;
1495     [case(TYMED_HGLOBAL)]  HGLOBAL hGlobal;
1496     [case(TYMED_FILE)]     LPOLESTR lpszFileName;
1497     [case(TYMED_ISTREAM)]  IStream *pstm;
1498     [case(TYMED_ISTORAGE)] IStorage *pstg;
1499     [default]              ;
1500     };
1501     [unique] IUnknown *pUnkForRelease;
1502   } uSTGMEDIUM;
1503
1504 /* copied from wingdi.h */
1505 #define OBJ_PEN             1
1506 #define OBJ_BRUSH           2
1507 #define OBJ_DC              3
1508 #define OBJ_METADC          4
1509 #define OBJ_PAL             5
1510 #define OBJ_FONT            6
1511 #define OBJ_BITMAP          7
1512 #define OBJ_REGION          8
1513 #define OBJ_METAFILE        9
1514 #define OBJ_MEMDC           10
1515 #define OBJ_EXTPEN          11
1516 #define OBJ_ENHMETADC       12
1517 #define OBJ_ENHMETAFILE     13
1518
1519   typedef union _GDI_OBJECT switch(DWORD ObjectType) u {
1520     case OBJ_BITMAP: wireHBITMAP hBitmap;
1521     case OBJ_PAL:    wireHPALETTE hPalette;
1522     default:         wireHGLOBAL hGeneric;
1523   } GDI_OBJECT;
1524
1525   typedef struct _userSTGMEDIUM {
1526     union _STGMEDIUM_UNION switch(DWORD tymed) u {
1527     case TYMED_NULL:     ;
1528     case TYMED_MFPICT:   wireHMETAFILEPICT hMetaFilePict;
1529     case TYMED_ENHMF:    wireHENHMETAFILE hHEnhMetaFile;
1530     case TYMED_GDI:      GDI_OBJECT *hGdiHandle;
1531     case TYMED_HGLOBAL:  wireHGLOBAL hGlobal;
1532     case TYMED_FILE:     LPOLESTR lpszFileName;
1533     case TYMED_ISTREAM:  BYTE_BLOB *pstm;
1534     case TYMED_ISTORAGE: BYTE_BLOB *pstg;
1535     };
1536     IUnknown *pUnkForRelease;
1537   } userSTGMEDIUM;
1538
1539   typedef [unique] userSTGMEDIUM *wireSTGMEDIUM;
1540   typedef [wire_marshal(wireSTGMEDIUM)] uSTGMEDIUM STGMEDIUM;
1541
1542   typedef [unique] userSTGMEDIUM *wireASYNC_STGMEDIUM;
1543   typedef [wire_marshal(wireASYNC_STGMEDIUM)] STGMEDIUM ASYNC_STGMEDIUM;
1544
1545   typedef STGMEDIUM *LPSTGMEDIUM;
1546
1547   typedef struct _userFLAG_STGMEDIUM {
1548     long ContextFlags;
1549     long fPassOwnership;
1550     userSTGMEDIUM Stgmed;
1551   } userFLAG_STGMEDIUM;
1552
1553   typedef [unique] userFLAG_STGMEDIUM *wireFLAG_STGMEDIUM;
1554
1555   typedef [wire_marshal(wireFLAG_STGMEDIUM)] struct _FLAG_STGMEDIUM {
1556     long ContextFlags;
1557     long fPassOwnership;
1558     STGMEDIUM Stgmed;
1559   } FLAG_STGMEDIUM;
1560
1561   [local]
1562   void OnDataChange(
1563     [in, unique] FORMATETC *pFormatetc,
1564     [in, unique] STGMEDIUM *pStgmed);
1565
1566   [call_as(OnDataChange), async]
1567   HRESULT  RemoteOnDataChange(
1568     [in] IAsyncManager **ppIAM,
1569     [in, unique] FORMATETC *pFormatetc,
1570     [in, unique] ASYNC_STGMEDIUM *pStgmed);
1571
1572   [local]
1573   void OnViewChange(
1574     [in] DWORD dwAspect,
1575     [in] LONG lindex);
1576
1577   [call_as(OnViewChange), async]
1578   HRESULT RemoteOnViewChange(
1579     [in] IAsyncManager **ppIAM,
1580     [in] DWORD dwAspect,
1581     [in] LONG lindex);
1582
1583   [local]
1584   void OnRename(
1585     [in] IMoniker *pmk);
1586
1587   [call_as(OnRename), async]
1588   HRESULT RemoteOnRename(
1589     [in] IAsyncManager **ppIAM,
1590     [in] IMoniker *pmk);
1591
1592   [local]
1593   void OnSave();
1594
1595   [call_as(OnSave), async]
1596   HRESULT RemoteOnSave(
1597     [in] IAsyncManager **ppIAM);
1598
1599   [local]
1600   void OnClose();
1601
1602   [call_as(OnClose)]
1603   HRESULT RemoteOnClose();
1604 }
1605
1606 [
1607   object,
1608   uuid(00000125-0000-0000-C000-000000000046),
1609   pointer_default(unique)
1610 ]
1611 interface IAdviseSink2 : IAdviseSink
1612 {
1613   typedef [unique] IAdviseSink2 *LPADVISESINK2;
1614
1615   [local]
1616   void OnLinkSrcChange(
1617     [in, unique] IMoniker *pmk);
1618
1619   [call_as(OnLinkSrcChange), async]
1620   HRESULT RemoteOnLinkSrcChange(
1621     [in] IAsyncManager **ppIAM,
1622     [in, unique] IMoniker *pmk);
1623 }
1624
1625 [
1626   object,
1627   uuid(0000010e-0000-0000-C000-000000000046),
1628   pointer_default(unique)
1629 ]
1630 interface IDataObject : IUnknown
1631 {
1632   typedef [unique] IDataObject *LPDATAOBJECT;
1633
1634   typedef enum tagDATADIR {
1635     DATADIR_GET = 1,
1636     DATADIR_SET = 2
1637   } DATADIR;
1638
1639   [local]
1640   HRESULT GetData(
1641     [in, unique] FORMATETC *pformatetcIn,
1642     [out] STGMEDIUM *pmedium);
1643
1644   [call_as(GetData)]
1645   HRESULT RemoteGetData(
1646     [in, unique] FORMATETC *pformatetcIn,
1647     [out] STGMEDIUM *pRemoteMedium);
1648
1649   [local]
1650   HRESULT GetDataHere(
1651     [in, unique] FORMATETC *pformatetc,
1652     [in, out] STGMEDIUM *pmedium);
1653
1654   [call_as(GetDataHere)]
1655   HRESULT RemoteGetDataHere(
1656     [in, unique] FORMATETC *pformatetc,
1657     [in, out] STGMEDIUM *pRemoteMedium);
1658
1659   HRESULT QueryGetData(
1660     [in, unique] FORMATETC *pformatetc);
1661
1662   HRESULT GetCanonicalFormatEtc(
1663     [in, unique] FORMATETC *pformatectIn,
1664     [out] FORMATETC *pformatetcOut);
1665
1666   [local]
1667   HRESULT SetData(
1668     [in, unique] FORMATETC *pformatetc,
1669     [in, unique] STGMEDIUM *pmedium,
1670     [in] BOOL fRelease);
1671
1672   [call_as(SetData)]
1673   HRESULT RemoteSetData(
1674     [in, unique] FORMATETC *pformatetc,
1675     [in, unique] FLAG_STGMEDIUM *pmedium,
1676     [in] BOOL fRelease);
1677
1678   HRESULT EnumFormatEtc(
1679     [in] DWORD dwDirection,
1680     [out] IEnumFORMATETC **ppenumFormatEtc);
1681
1682   HRESULT DAdvise(
1683     [in] FORMATETC *pformatetc,
1684     [in] DWORD advf,
1685     [in, unique] IAdviseSink *pAdvSink,
1686     [out] DWORD *pdwConnection);
1687
1688   HRESULT DUnadvise(
1689     [in] DWORD dwConnection);
1690
1691   HRESULT EnumDAdvise(
1692     [out] IEnumSTATDATA **ppenumAdvise);
1693 }
1694
1695 [
1696   local,
1697   object,
1698   uuid(00000110-0000-0000-C000-000000000046)
1699 ]
1700 interface IDataAdviseHolder : IUnknown
1701 {
1702   typedef [unique] IDataAdviseHolder *LPDATAADVISEHOLDER;
1703
1704   HRESULT Advise(
1705     [in, unique] IDataObject *pDataObject,
1706     [in, unique] FORMATETC *pFetc,
1707     [in] DWORD advf,
1708     [in, unique] IAdviseSink *pAdvise,
1709     [out] DWORD *pdwConnection);
1710
1711   HRESULT Unadvise(
1712     [in] DWORD dwConnection);
1713
1714   HRESULT EnumAdvise(
1715     [out] IEnumSTATDATA **ppenumAdvise);
1716
1717   HRESULT SendOnDataChange(
1718     [in, unique] IDataObject *pDataObject,
1719     [in] DWORD dwReserved,
1720     [in] DWORD advf);
1721 }
1722
1723 /******************** Remoting ********************/
1724
1725 [
1726   local,
1727   object,
1728   uuid(00000016-0000-0000-C000-000000000046)
1729 ]
1730 interface IMessageFilter : IUnknown
1731 {
1732   typedef [unique] IMessageFilter *LPMESSAGEFILTER;
1733
1734   typedef enum tagCALLTYPE {
1735     CALLTYPE_TOPLEVEL = 1,
1736     CALLTYPE_NESTED   = 2,
1737     CALLTYPE_ASYNC    = 3,
1738     CALLTYPE_TOPLEVEL_CALLPENDING = 4,
1739     CALLTYPE_ASYNC_CALLPENDING    = 5
1740   } CALLTYPE;
1741
1742   typedef enum tagSERVERCALL {
1743     SERVERCALL_ISHANDLED  = 0,
1744     SERVERCALL_REJECTED   = 1,
1745     SERVERCALL_RETRYLATER = 2
1746   } SERVERCALL;
1747
1748   typedef enum tagPENDINGTYPE {
1749     PENDINGTYPE_TOPLEVEL = 1,
1750     PENDINGTYPE_NESTED   = 2
1751   } PENDINGTYPE;
1752
1753   typedef enum tagPENDINGMSG {
1754     PENDINGMSG_CANCELCALL     = 0,
1755     PENDINGMSG_WAITNOPROCESS  = 1,
1756     PENDINGMSG_WAITDEFPROCESS = 2
1757   } PENDINGMSG;
1758
1759   typedef struct tagINTERFACEINFO {
1760     IUnknown *pUnk;
1761     IID iid;
1762     WORD wMethod;
1763   } INTERFACEINFO, *LPINTERFACEINFO;
1764
1765   DWORD HandleInComingCall(
1766     [in] DWORD dwCallType,
1767     [in] HTASK htaskCaller,
1768     [in] DWORD dwTickCount,
1769     [in] LPINTERFACEINFO lpInterfaceInfo);
1770
1771   DWORD RetryRejectedCall(
1772     [in] HTASK htaskCallee,
1773     [in] DWORD dwTickCount,
1774     [in] DWORD dwRejectType);
1775
1776   DWORD MessagePending(
1777     [in] HTASK htaskCallee,
1778     [in] DWORD dwTickCount,
1779     [in] DWORD dwPendingType);
1780 }
1781
1782 [
1783   local,
1784   object,
1785   uuid(D5F56B60-593B-101A-B569-08002B2DBF7A)
1786 ]
1787 interface IRpcChannelBuffer : IUnknown
1788 {
1789   typedef [unique] IRpcChannelBuffer *LPRPCCHANNELBUFFER;
1790
1791   typedef unsigned long RPCOLEDATAREP;
1792
1793   typedef struct tagRPCOLEMESSAGE {
1794     void *reserved1;
1795     RPCOLEDATAREP dataRepresentation;
1796     void *Buffer;
1797     ULONG cbBuffer;
1798     ULONG iMethod;
1799     void *reserved2[5];
1800     ULONG rpcFlags;
1801   } RPCOLEMESSAGE;
1802
1803   typedef RPCOLEMESSAGE *PRPCOLEMESSAGE;
1804
1805   HRESULT GetBuffer(
1806     [in] RPCOLEMESSAGE *pMessage,
1807     [in] REFIID riid);
1808
1809   HRESULT SendReceive(
1810     [in,out] RPCOLEMESSAGE *pMessage,
1811     [out] ULONG *pStatus);
1812
1813   HRESULT FreeBuffer(
1814     [in] RPCOLEMESSAGE *pMessage);
1815
1816   HRESULT GetDestCtx(
1817     [out] DWORD *pdwDestContext,
1818     [out] void **ppvDestContext);
1819
1820   HRESULT IsConnected();
1821 }
1822
1823 [
1824   local,
1825   object,
1826   uuid(594f31d0-7f19-11d0-b194-00a0c90dc8bf)
1827 ]
1828 interface IRpcChannelBuffer2 : IRpcChannelBuffer
1829 {
1830   typedef [unique] IRpcChannelBuffer2 *LPRPCCHANNELBUFFER2;
1831
1832   HRESULT GetProtocolVersion(
1833     [in,out] DWORD *pdwVersion);
1834 }
1835
1836 [
1837   local,
1838   object,
1839   uuid(25B15600-0115-11d0-BF0D-00AA00B8DFD2)
1840 ]
1841 interface IRpcChannelBuffer3 : IRpcChannelBuffer2
1842 {
1843   typedef [unique] IRpcChannelBuffer3 *LPRPCCHANNELBUFFER3;
1844
1845   HRESULT Send(
1846     [in,out] RPCOLEMESSAGE *pMsg,
1847     [out] ULONG *pulStatus);
1848
1849   HRESULT Receive(
1850     [in,out] RPCOLEMESSAGE *pMsg,
1851     [in] ULONG ulSize,
1852     [out] ULONG *pulStatus);
1853
1854   HRESULT Cancel(
1855     [in] RPCOLEMESSAGE *pMsg);
1856
1857   HRESULT GetCallContext(
1858     [in] RPCOLEMESSAGE *pMsg,
1859     [in] REFIID riid,
1860     [out] void **pInterface);
1861
1862   HRESULT GetDestCtxEx(
1863     [in] RPCOLEMESSAGE *pMsg,
1864     [out] DWORD *pdwDestContext,
1865     [out] void **ppvDestContext);
1866
1867   HRESULT GetState(
1868     [in] RPCOLEMESSAGE *pMsg,
1869     [out] DWORD *pState);
1870
1871   HRESULT RegisterAsync(
1872     [in] RPCOLEMESSAGE *pMsg,
1873     [in] IAsyncManager *pAsyncMgr);
1874 }
1875
1876 [
1877   local,
1878   object,
1879   uuid(D5F56A34-593B-101A-B569-08002B2DBF7A)
1880 ]
1881 interface IRpcProxyBuffer : IUnknown
1882 {
1883   typedef [unique] IRpcProxyBuffer *LPRPCPROXYBUFFER;
1884
1885   HRESULT Connect(
1886     [in, unique] IRpcChannelBuffer *pRpcChannelBuffer);
1887
1888   void Disconnect();
1889 }
1890
1891 [
1892   local,
1893   object,
1894   uuid(D5F56AFC-593B-101A-B569-08002B2DBF7A)
1895 ]
1896 interface IRpcStubBuffer : IUnknown
1897 {
1898   typedef [unique] IRpcStubBuffer *LPRPCSTUBBUFFER;
1899
1900   HRESULT Connect(
1901     [in] IUnknown *pUnkServer);
1902
1903   void Disconnect();
1904
1905   HRESULT Invoke(
1906     [in] RPCOLEMESSAGE *_prpcmsg,
1907     [in] IRpcChannelBuffer *_pRpcChannelBuffer);
1908
1909   IRpcStubBuffer *IsIIDSupported(
1910     [in] REFIID riid);
1911
1912   ULONG CountRefs();
1913
1914   HRESULT DebugServerQueryInterface(
1915     void **ppv);
1916
1917   void DebugServerRelease(
1918     void *pv);
1919 }
1920
1921 [
1922   local,
1923   object,
1924   uuid(D5F569D0-593B-101A-B569-08002B2DBF7A)
1925 ]
1926 interface IPSFactoryBuffer : IUnknown
1927 {
1928   typedef [unique] IPSFactoryBuffer *LPPSFACTORYBUFFER;
1929
1930   HRESULT CreateProxy(
1931     [in] IUnknown *pUnkOuter,
1932     [in] REFIID riid,
1933     [out] IRpcProxyBuffer **ppProxy,
1934     [out] void **ppv);
1935
1936   HRESULT CreateStub(
1937     [in] REFIID riid,
1938     [in, unique] IUnknown *pUnkServer,
1939     [out] IRpcStubBuffer **ppStub);
1940 }
1941
1942 [
1943   local,
1944   object,
1945   uuid(1008c4a0-7613-11cf-9af1-0020af6e72f4)
1946 ]
1947 interface IChannelHook : IUnknown
1948 {
1949   typedef [unique] IChannelHook *LPCHANNELHOOK;
1950
1951   typedef struct SChannelHookCallInfo {
1952     IID iid;
1953     DWORD cbSize;
1954     GUID uCausality;
1955     DWORD dwServerPid;
1956     DWORD iMethod;
1957     void *pObject;
1958   } SChannelHookCallInfo;
1959
1960   void ClientGetSize(
1961     [in] REFGUID uExtent,
1962     [in] REFIID riid,
1963     [out] ULONG *pDataSize);
1964
1965   void ClientFillBuffer(
1966     [in] REFGUID uExtent,
1967     [in] REFIID riid,
1968     [in, out] ULONG *pDataSize,
1969     [in] void *pDataBuffer);
1970
1971   void ClientNotify(
1972     [in] REFGUID uExtent,
1973     [in] REFIID riid,
1974     [in] ULONG cbDataSize,
1975     [in] void *pDataBuffer,
1976     [in] DWORD lDataRep,
1977     [in] HRESULT hrFault);
1978
1979   void ServerNotify(
1980     [in] REFGUID uExtent,
1981     [in] REFIID riid,
1982     [in] ULONG cbDataSize,
1983     [in] void *pDataBuffer,
1984     [in] DWORD lDataRep);
1985
1986   void ServerGetSize(
1987     [in] REFGUID uExtent,
1988     [in] REFIID riid,
1989     [in] HRESULT hrFault,
1990     [out] ULONG *pDataSize);
1991
1992   void ServerFillBuffer(
1993     [in] REFGUID uExtent,
1994     [in] REFIID riid,
1995     [in, out] ULONG *pDataSize,
1996     [in] void *pDataBuffer,
1997     [in] HRESULT hrFault );
1998 }
1999
2000 /******************** Property Storage ********************/
2001
2002 interface IEnumSTATPROPSTG;
2003 interface IEnumSTATPROPSETSTG;
2004
2005 [
2006   object,
2007   uuid(00000138-0000-0000-C000-000000000046),
2008   pointer_default(unique)
2009 ]
2010 interface IPropertyStorage : IUnknown
2011 {
2012   typedef [unique] IPropertyStorage *LPPROPERTYSTORAGE;
2013
2014   extern const FMTID FMTID_SummaryInformation;
2015   extern const FMTID FMTID_DocSummaryInformation;
2016   extern const FMTID FMTID_UserDefinedProperties;
2017
2018   const DWORD PROPSETFLAG_DEFAULT = 0;
2019   const DWORD PROPSETFLAG_NONSIMPLE = 1;
2020   const DWORD PROPSETFLAG_ANSI = 2;
2021   const DWORD PROPSETFLAG_UNBUFFERED = 4;
2022
2023   typedef struct tagPROPVARIANT PROPVARIANT;
2024
2025   #define TYPEDEF_CA(type, name) \
2026     typedef struct tag##name { \
2027       ULONG cElems; \
2028       [size_is(cElems)] \
2029       type *pElems; \
2030     } name
2031
2032   TYPEDEF_CA(unsigned char, CAUB);
2033   TYPEDEF_CA(short, CAI);
2034   TYPEDEF_CA(USHORT, CAUI);
2035   TYPEDEF_CA(long, CAL);
2036   TYPEDEF_CA(ULONG, CAUL);
2037   TYPEDEF_CA(float, CAFLT);
2038   TYPEDEF_CA(double, CADBL);
2039   TYPEDEF_CA(CY, CACY);
2040   TYPEDEF_CA(DATE, CADATE);
2041   TYPEDEF_CA(BSTR, CABSTR);
2042   TYPEDEF_CA(BSTRBLOB, CABSTRBLOB);
2043   TYPEDEF_CA(VARIANT_BOOL, CABOOL);
2044   TYPEDEF_CA(SCODE,  CASCODE);
2045   TYPEDEF_CA(PROPVARIANT, CAPROPVARIANT);
2046   TYPEDEF_CA(LARGE_INTEGER, CAH);
2047   TYPEDEF_CA(ULARGE_INTEGER, CAUH);
2048   TYPEDEF_CA(LPSTR, CALPSTR);
2049   TYPEDEF_CA(LPWSTR, CALPWSTR);
2050   TYPEDEF_CA(FILETIME, CAFILETIME);
2051   TYPEDEF_CA(CLIPDATA, CACLIPDATA);
2052   TYPEDEF_CA(CLSID, CACLSID);
2053
2054   struct tagPROPVARIANT {
2055     VARTYPE vt;
2056     WORD wReserved1;
2057     WORD wReserved2;
2058     WORD wReserved3;
2059     [switch_is(vt & 0x1fff)] union {
2060     [case(VT_EMPTY, VT_NULL)]             ;
2061     [case(VT_UI1)]                        UCHAR bVal;
2062     [case(VT_I2)]                         short iVal;
2063     [case(VT_UI2)]                        USHORT uiVal;
2064     [case(VT_BOOL)]                       VARIANT_BOOL boolVal;
2065 #if 0 /* illegal in C++ */
2066     [case(VT_ILLEGAL)]                    _VARIANT_BOOL bool;
2067 #endif
2068     [case(VT_I4)]                         long lVal;
2069     [case(VT_UI4)]                        ULONG ulVal;
2070     [case(VT_R4)]                         float fltVal;
2071     [case(VT_ERROR)]                      SCODE scode;
2072     [case(VT_I8)]                         LARGE_INTEGER hVal;
2073     [case(VT_UI8)]                        ULARGE_INTEGER uhVal;
2074     [case(VT_R8)]                         double dblVal;
2075     [case(VT_CY)]                         CY cyVal;
2076     [case(VT_DATE)]                       DATE date;
2077     [case(VT_FILETIME)]                   FILETIME filetime;
2078     [case(VT_CLSID)]                      CLSID *puuid;
2079     [case(VT_BLOB, VT_BLOB_OBJECT)]       BLOB blob;
2080     [case(VT_CF)]                         CLIPDATA *pclipdata;
2081     [case(VT_STREAM, VT_STREAMED_OBJECT)] IStream *pStream;
2082     [case(VT_STORAGE, VT_STORED_OBJECT)]  IStorage *pStorage;
2083     [case(VT_BSTR)]                       BSTR bstrVal;
2084     [case(VT_BSTR_BLOB)]                  BSTRBLOB bstrblobVal;
2085     [case(VT_LPSTR)]                      LPSTR pszVal;
2086     [case(VT_LPWSTR)]                     LPWSTR pwszVal;
2087     [case(VT_UI1|VT_VECTOR)]              CAUB caub;
2088     [case(VT_I2|VT_VECTOR)]               CAI cai;
2089     [case(VT_UI2|VT_VECTOR)]              CAUI caui;
2090     [case(VT_BOOL|VT_VECTOR)]             CABOOL cabool;
2091     [case(VT_I4|VT_VECTOR)]               CAL cal;
2092     [case(VT_UI4|VT_VECTOR)]              CAUL caul;
2093     [case(VT_R4|VT_VECTOR)]               CAFLT caflt;
2094     [case(VT_ERROR|VT_VECTOR)]            CASCODE cascode;
2095     [case(VT_I8|VT_VECTOR)]               CAH cah;
2096     [case(VT_UI8|VT_VECTOR)]              CAUH cauh;
2097     [case(VT_R8|VT_VECTOR)]               CADBL cadbl;
2098     [case(VT_CY|VT_VECTOR)]               CACY cacy;
2099     [case(VT_DATE|VT_VECTOR)]             CADATE cadate;
2100     [case(VT_FILETIME|VT_VECTOR)]         CAFILETIME cafiletime;
2101     [case(VT_CLSID|VT_VECTOR)]            CACLSID cauuid;
2102     [case(VT_CF|VT_VECTOR)]               CACLIPDATA caclipdata;
2103     [case(VT_BSTR|VT_VECTOR)]             CABSTR cabstr;
2104     [case(VT_BSTR_BLOB|VT_VECTOR)]        CABSTRBLOB cabstrblob;
2105     [case(VT_LPSTR|VT_VECTOR)]            CALPSTR calpstr;
2106     [case(VT_LPWSTR|VT_VECTOR)]           CALPWSTR calpwstr;
2107     [case(VT_VARIANT|VT_VECTOR)]          CAPROPVARIANT capropvar;
2108     };
2109   };
2110
2111   typedef struct tagPROPVARIANT *LPPROPVARIANT;
2112
2113   /* FIXME: bunches of property IDs */
2114
2115   const ULONG PRSPEC_INVALID = 0xffffffff;
2116   const ULONG PRSPEC_LPWSTR = 0;
2117   const ULONG PRSPEC_PROPID = 1;
2118
2119   typedef struct tagPROPSPEC {
2120     ULONG ulKind;
2121     [switch_is(ulKind)] union {
2122     [case(PRSPEC_PROPID)] PROPID propid;
2123     [case(PRSPEC_LPWSTR)] LPOLESTR lpwstr;
2124     [default]             ;
2125     };
2126   } PROPSPEC;
2127
2128   typedef struct tagSTATPROPSTG {
2129     LPOLESTR lpwstrName;
2130     PROPID propid;
2131     VARTYPE vt;
2132   } STATPROPSTG;
2133
2134   /* FIXME: macros */
2135
2136   typedef struct tagSTATPROPSETSTG {
2137     FMTID fmtid;
2138     CLSID clsid;
2139     DWORD grfFlags;
2140     FILETIME mtime;
2141     FILETIME ctime;
2142     FILETIME atime;
2143     DWORD dwOSVersion;
2144   } STATPROPSETSTG;
2145
2146   HRESULT ReadMultiple(
2147     [in] ULONG cpspec,
2148     [in, size_is(cpspec)] const PROPSPEC rgpspec[],
2149     [out, size_is(cpspec)] PROPVARIANT rgpropvar[]);
2150
2151   HRESULT WriteMultiple(
2152     [in] ULONG cpspec,
2153     [in, size_is(cpspec)] const PROPSPEC rgpspec[],
2154     [in, size_is(cpspec)] const PROPVARIANT rgpropvar[],
2155     [in] PROPID propidNameFirst);
2156
2157   HRESULT DeleteMultiple(
2158     [in] ULONG cpspec,
2159     [in, size_is(cpspec)] const PROPSPEC rgpspec[]);
2160
2161   HRESULT ReadPropertyNames(
2162     [in] ULONG cpropid,
2163     [in, size_is(cpropid)] const PROPID rgpropid[],
2164     [out, size_is(cpropid)] LPOLESTR rglpwstrName[]);
2165
2166   HRESULT WritePropertyNames(
2167     [in] ULONG cpropid,
2168     [in, size_is(cpropid)] const PROPID rgpropid[],
2169     [in, size_is(cpropid)] const LPOLESTR rglpwstrName[]);
2170
2171   HRESULT DeletePropertyNames(
2172     [in] ULONG cpropid,
2173     [in, size_is(cpropid)] const PROPID rgpropid[]);
2174
2175   HRESULT Commit(
2176     [in] DWORD grfCommitFlags);
2177
2178   HRESULT Revert();
2179
2180   HRESULT Enum(
2181     [out] IEnumSTATPROPSTG **ppenum);
2182
2183   HRESULT SetTimes(
2184     [in] const FILETIME *pctime,
2185     [in] const FILETIME *patime,
2186     [in] const FILETIME *pmtime);
2187
2188   HRESULT SetClass(
2189     [in] REFCLSID clsid);
2190
2191   HRESULT Stat(
2192     [out] STATPROPSETSTG *statpsstg);
2193 }
2194
2195 [
2196   object,
2197   uuid(0000013A-0000-0000-C000-000000000046),
2198   pointer_default(unique)
2199 ]
2200 interface IPropertySetStorage : IUnknown
2201 {
2202   typedef [unique] IPropertySetStorage *LPPROPERTYSETSTORAGE;
2203
2204   HRESULT Create(
2205     [in] REFFMTID rfmtid,
2206     [in, unique] const CLSID *pclsid,
2207     [in] DWORD grfFlags,
2208     [in] DWORD grfMode,
2209     [out] IPropertyStorage **ppprstg);
2210
2211   HRESULT Open(
2212     [in] REFFMTID rfmtid,
2213     [in] DWORD grfMode,
2214     [out] IPropertyStorage **ppprstg);
2215
2216   HRESULT Delete(
2217     [in] REFFMTID rfmtid);
2218
2219   HRESULT Enum(
2220     [out] IEnumSTATPROPSETSTG **ppenum);
2221 }
2222
2223 [
2224   object,
2225   uuid(00000139-0000-0000-C000-000000000046),
2226   pointer_default(unique)
2227 ]
2228 interface IEnumSTATPROPSTG : IUnknown
2229 {
2230   typedef [unique] IEnumSTATPROPSTG *LPENUMSTATPROPSTG;
2231
2232   [local]
2233   HRESULT Next(
2234     [in] ULONG celt,
2235     [out, size_is(celt), length_is(*pceltFetched)]
2236     STATPROPSTG *rgelt,
2237     [out] ULONG *pceltFetched);
2238
2239   [call_as(Next)]
2240   HRESULT RemoteNext(
2241     [in] ULONG celt,
2242     [out, size_is(celt), length_is(*pceltFetched)]
2243     STATPROPSTG *rgelt,
2244     [out] ULONG *pceltFetched);
2245
2246   HRESULT Skip(
2247     [in] ULONG celt);
2248
2249   HRESULT Reset();
2250
2251   HRESULT Clone(
2252     [out] IEnumSTATPROPSTG **ppenum);
2253 }
2254
2255 [
2256   object,
2257   uuid(0000013B-0000-0000-C000-000000000046),
2258   pointer_default(unique)
2259 ]
2260 interface IEnumSTATPROPSETSTG : IUnknown
2261 {
2262   typedef [unique] IEnumSTATPROPSETSTG *LPENUMSTATPROPSETSTG;
2263
2264   [local]
2265   HRESULT Next(
2266     [in] ULONG celt,
2267     [out, size_is(celt), length_is(*pceltFetched)]
2268     STATPROPSETSTG *rgelt,
2269     [out] ULONG *pceltFetched);
2270
2271   [call_as(Next)]
2272   HRESULT RemoteNext(
2273     [in] ULONG celt,
2274     [out, size_is(celt), length_is(*pceltFetched)]
2275     STATPROPSETSTG *rgelt,
2276     [out] ULONG *pceltFetched);
2277
2278   HRESULT Skip(
2279     [in] ULONG celt);
2280
2281   HRESULT Reset();
2282
2283   HRESULT Clone(
2284     [out] IEnumSTATPROPSETSTG **ppenum);
2285 }
2286
2287 /******************** Connection Points ********************/
2288 /* FIXME */
2289
2290 /******************** DCOM ********************/
2291
2292 [
2293   local,
2294   object,
2295   uuid(0000013D-0000-0000-C000-000000000046)
2296 ]
2297 interface IClientSecurity : IUnknown
2298 {
2299   typedef struct tagSOLE_AUTHENTICATION_SERVICE {
2300     DWORD dwAuthnSvc;
2301     DWORD dwAuthzSvc;
2302     OLECHAR *pPrincipalName;
2303     HRESULT hr;
2304   } SOLE_AUTHENTICATION_SERVICE;
2305
2306   typedef SOLE_AUTHENTICATION_SERVICE *PSOLE_AUTHENTICATION_SERVICE;
2307
2308   typedef enum tagEOLE_AUTHENTICATION_CAPABILITIES {
2309     EOAC_NONE           = 0x0,
2310     EOAC_MUTUAL_AUTH    = 0x1,
2311     EOAC_CLOAKING       = 0x10,
2312     EOAC_SECURE_REFS    = 0x2,
2313     EOAC_ACCESS_CONTROL = 0x4,
2314     EOAC_APPID          = 0x8
2315   } EOLE_AUTHENTICATION_CAPABILITIES;
2316
2317   HRESULT QueryBlanket(
2318     [in] IUnknown *pProxy,
2319     [out] DWORD *pAuthnSvc,
2320     [out] DWORD *pAuthzSvc,
2321     [out] OLECHAR **pServerPrincName,
2322     [out] DWORD *pAuthnLevel,
2323     [out] DWORD *pImpLevel,
2324     [out] void **pAuthInfo,
2325     [out] DWORD *pCapabilites);
2326
2327   HRESULT SetBlanket(
2328     [in] IUnknown *pProxy,
2329     [in] DWORD AuthnSvc,
2330     [in] DWORD AuthzSvc,
2331     [in] OLECHAR *pServerPrincName,
2332     [in] DWORD AuthnLevel,
2333     [in] DWORD ImpLevel,
2334     [in] void *pAuthInfo,
2335     [in] DWORD Capabilities);
2336
2337   HRESULT CopyProxy(
2338     [in] IUnknown *pProxy,
2339     [out] IUnknown **ppCopy);
2340 }
2341
2342 [
2343   local,
2344   object,
2345   uuid(0000013E-0000-0000-C000-000000000046)
2346 ]
2347 interface IServerSecurity : IUnknown
2348 {
2349   HRESULT QueryBlanket(
2350     [out] DWORD *pAuthnSvc,
2351     [out] DWORD *pAuthzSvc,
2352     [out] OLECHAR **pServerPrincName,
2353     [out] DWORD *pAuthnLevel,
2354     [out] DWORD *pImpLevel,
2355     [out] void **pPrivs,
2356     [out] DWORD *pCapabilities);
2357
2358   HRESULT ImpersonateClient();
2359
2360   HRESULT RevertToSelf();
2361
2362   BOOL IsImpersonating();
2363 }
2364
2365 [
2366   local,
2367   object,
2368   uuid(00000024-0000-0000-C000-000000000046)
2369 ]
2370 interface IAsyncSetup : IUnknown
2371 {
2372   HRESULT GetAsyncManager(
2373     [in] REFIID riid,
2374     [in] IUnknown *pOuter,
2375     [in] DWORD dwFlags,
2376     [out] IUnknown **ppInner,
2377     [out] IAsyncManager **ppAsyncMgr);
2378 }
2379
2380 [
2381   local,
2382   object,
2383   uuid(0000002A-0000-0000-C000-000000000046)
2384 ]
2385 interface IAsyncManager : IUnknown
2386 {
2387   typedef enum tagDCOM_CALL_STATE {
2388     DCOM_NONE          = 0,
2389     DCOM_CALL_COMPLETE = 1,
2390     DCOM_CALL_CANCELED = 2
2391   } DCOM_CALL_STATE;
2392
2393   HRESULT CompleteCall(
2394     [in] HRESULT Result);
2395   HRESULT GetCallContext(
2396     [in] REFIID riid,
2397     [out] void **pInterface);
2398   HRESULT GetState(
2399     [out] ULONG *pulStateFlags);
2400 }