objidl.idl

c语言编程软件vc6.0中文绿色版_vc6.0官方下载

    void ServerFillBuffer(
        [in]      REFGUID uExtent,
        [in]      REFIID  riid,
        [in, out] ULONG  *pDataSize,
        [in]      void   *pDataBuffer,
        [in]      HRESULT hrFault );
};

cpp_quote( "#endif //DCOM" )

/****************************************************************************
 *  Property Storage Interfaces
 ****************************************************************************/

interface IPropertyStorage;
interface IEnumSTATPROPSTG;
interface IEnumSTATPROPSETSTG;

[
    object,
    uuid(00000138-0000-0000-C000-000000000046),
    pointer_default(unique)
]

interface IPropertyStorage : IUnknown
{

    cpp_quote("")
    cpp_quote("// Well-known Property Set Format IDs")
    extern const FMTID FMTID_SummaryInformation;
    extern const FMTID FMTID_DocSummaryInformation;
    extern const FMTID FMTID_UserDefinedProperties;

    cpp_quote("")
    cpp_quote("// Flags for IPropertySetStorage::Create")
    const DWORD PROPSETFLAG_DEFAULT = 0;
    const DWORD PROPSETFLAG_NONSIMPLE = 1;
    const DWORD PROPSETFLAG_ANSI = 2;
    cpp_quote("// This flag is only supported on StgCreatePropStg & StgOpenPropStg")
    const DWORD PROPSETFLAG_UNBUFFERED = 4;

    typedef [unique] IPropertyStorage * LPPROPERTYSTORAGE;

    typedef struct tagPROPVARIANT PROPVARIANT;

    #define TYPEDEF_CA(type, name) \
        typedef struct tag##name\
        {\
            ULONG   cElems;\
            [size_is( cElems )]\
            type *  pElems;\
        } name

    TYPEDEF_CA(unsigned char,       CAUB);
    TYPEDEF_CA(short,               CAI);
    TYPEDEF_CA(USHORT,              CAUI);
    TYPEDEF_CA(long,                CAL);
    TYPEDEF_CA(ULONG,               CAUL);
    TYPEDEF_CA(float,               CAFLT);
    TYPEDEF_CA(double,              CADBL);
    TYPEDEF_CA(CY,                  CACY);
    TYPEDEF_CA(DATE,                CADATE);
    TYPEDEF_CA(BSTR,                CABSTR);
    TYPEDEF_CA(BSTRBLOB,            CABSTRBLOB);
    TYPEDEF_CA(VARIANT_BOOL,        CABOOL);
    TYPEDEF_CA(SCODE,               CASCODE);
    TYPEDEF_CA(PROPVARIANT,         CAPROPVARIANT);
    TYPEDEF_CA(LARGE_INTEGER,       CAH);
    TYPEDEF_CA(ULARGE_INTEGER,      CAUH);
    TYPEDEF_CA(LPSTR,               CALPSTR);
    TYPEDEF_CA(LPWSTR,              CALPWSTR);
    TYPEDEF_CA(FILETIME,            CAFILETIME);
    TYPEDEF_CA(CLIPDATA,            CACLIPDATA);
    TYPEDEF_CA(CLSID,               CACLSID);

cpp_quote("// Disable the warning about the obsolete member named 'bool'")
cpp_quote("// 'bool', 'true', 'false', 'mutable', 'explicit', & 'typename'")
cpp_quote("// are reserved keywords")
cpp_quote("#pragma warning(disable:4237)")

    struct tagPROPVARIANT
    {
        VARTYPE vt;
        WORD    wReserved1;
        WORD    wReserved2;
        WORD    wReserved3;
        [switch_is((unsigned short) (vt & 0x1fff))] union
        {
            [case(VT_EMPTY, VT_NULL)]
                ;
            [case(VT_UI1)]
                UCHAR               bVal;
            [case(VT_I2)]
                short               iVal;
            [case(VT_UI2)]
                USHORT              uiVal;
            [case(VT_BOOL)]
                VARIANT_BOOL        boolVal;
            [case(VT_ILLEGAL)]  // obsolete field name; use boolVal
                _VARIANT_BOOL        bool;
            [case(VT_I4)]
                long                lVal;
            [case(VT_UI4)]
                ULONG               ulVal;
            [case(VT_R4)]
                float               fltVal;
            [case(VT_ERROR)]
                SCODE               scode;
            [case(VT_I8)]
                LARGE_INTEGER       hVal;
            [case(VT_UI8)]
                ULARGE_INTEGER      uhVal;
            [case(VT_R8)]
                double              dblVal;
            [case(VT_CY)]
                CY                  cyVal;
            [case(VT_DATE)]
                DATE                date;
            [case(VT_FILETIME)]
                FILETIME            filetime;
            [case(VT_CLSID)]
                CLSID *             puuid;
            [case(VT_BLOB, VT_BLOB_OBJECT)]
                BLOB                blob;
            [case(VT_CF)]
                CLIPDATA            *pclipdata;
            [case(VT_STREAM, VT_STREAMED_OBJECT)]
                IStream *           pStream;
            [case(VT_STORAGE, VT_STORED_OBJECT)]
                IStorage *          pStorage;
            [case(VT_BSTR)]
                BSTR                bstrVal;
            [case(VT_BSTR_BLOB)]        // System use only
                BSTRBLOB            bstrblobVal;
            [case(VT_LPSTR)]
                LPSTR               pszVal;
            [case(VT_LPWSTR)]
                LPWSTR              pwszVal;
            [case(VT_UI1|VT_VECTOR)]
                CAUB                caub;
            [case(VT_I2|VT_VECTOR)]
                CAI                 cai;
            [case(VT_UI2|VT_VECTOR)]
                CAUI                caui;
            [case(VT_BOOL|VT_VECTOR)]
                CABOOL              cabool;
            [case(VT_I4|VT_VECTOR)]
                CAL                 cal;
            [case(VT_UI4|VT_VECTOR)]
                CAUL                caul;
            [case(VT_R4|VT_VECTOR)]
                CAFLT               caflt;
            [case(VT_ERROR|VT_VECTOR)]
                CASCODE             cascode;
            [case(VT_I8|VT_VECTOR)]
                CAH                 cah;
            [case(VT_UI8|VT_VECTOR)]
                CAUH                cauh;
            [case(VT_R8|VT_VECTOR)]
                CADBL               cadbl;
            [case(VT_CY|VT_VECTOR)]
                CACY                cacy;
            [case(VT_DATE|VT_VECTOR)]
                CADATE              cadate;
            [case(VT_FILETIME|VT_VECTOR)]
                CAFILETIME          cafiletime;
            [case(VT_CLSID|VT_VECTOR)]
                CACLSID             cauuid;
            [case(VT_CF|VT_VECTOR)]
                CACLIPDATA          caclipdata;
            [case(VT_BSTR|VT_VECTOR)]
                CABSTR              cabstr;
            [case(VT_BSTR_BLOB|VT_VECTOR)]  // System use only
                CABSTRBLOB          cabstrblob;
            [case(VT_LPSTR|VT_VECTOR)]
                CALPSTR             calpstr;
            [case(VT_LPWSTR|VT_VECTOR)]
                CALPWSTR            calpwstr;
            [case(VT_VARIANT|VT_VECTOR)]
                CAPROPVARIANT       capropvar;
        };
    };

    typedef struct tagPROPVARIANT * LPPROPVARIANT;

    cpp_quote("// Reserved global Property IDs")
    const PROPID PID_DICTIONARY         = 0x00000000;
    const PROPID PID_CODEPAGE           = 0x00000001;
    const PROPID PID_FIRST_USABLE       = 0x00000002;
    const PROPID PID_FIRST_NAME_DEFAULT = 0x00000fff;
    const PROPID PID_LOCALE             = 0x80000000;
    const PROPID PID_MODIFY_TIME        = 0x80000001;
    const PROPID PID_SECURITY           = 0x80000002;
    const PROPID PID_ILLEGAL            = 0xffffffff;


    cpp_quote("// Property IDs for the SummaryInformation Property Set")
    cpp_quote("")
    cpp_quote("#define PIDSI_TITLE               0x00000002L  // VT_LPSTR")
    cpp_quote("#define PIDSI_SUBJECT             0x00000003L  // VT_LPSTR")
    cpp_quote("#define PIDSI_AUTHOR              0x00000004L  // VT_LPSTR")
    cpp_quote("#define PIDSI_KEYWORDS            0x00000005L  // VT_LPSTR")
    cpp_quote("#define PIDSI_COMMENTS            0x00000006L  // VT_LPSTR")
    cpp_quote("#define PIDSI_TEMPLATE            0x00000007L  // VT_LPSTR")
    cpp_quote("#define PIDSI_LASTAUTHOR          0x00000008L  // VT_LPSTR")
    cpp_quote("#define PIDSI_REVNUMBER           0x00000009L  // VT_LPSTR")
    cpp_quote("#define PIDSI_EDITTIME            0x0000000aL  // VT_FILETIME (UTC)")
    cpp_quote("#define PIDSI_LASTPRINTED         0x0000000bL  // VT_FILETIME (UTC)")
    cpp_quote("#define PIDSI_CREATE_DTM          0x0000000cL  // VT_FILETIME (UTC)")
    cpp_quote("#define PIDSI_LASTSAVE_DTM        0x0000000dL  // VT_FILETIME (UTC)")
    cpp_quote("#define PIDSI_PAGECOUNT           0x0000000eL  // VT_I4")
    cpp_quote("#define PIDSI_WORDCOUNT           0x0000000fL  // VT_I4")
    cpp_quote("#define PIDSI_CHARCOUNT           0x00000010L  // VT_I4")
    cpp_quote("#define PIDSI_THUMBNAIL           0x00000011L  // VT_CF")
    cpp_quote("#define PIDSI_APPNAME             0x00000012L  // VT_LPSTR")
    cpp_quote("#define PIDSI_DOC_SECURITY        0x00000013L  // VT_I4")

    const ULONG PRSPEC_INVALID = 0xffffffff;
    const ULONG PRSPEC_LPWSTR = 0;
    const ULONG PRSPEC_PROPID = 1;

    typedef struct tagPROPSPEC
    {

        ULONG   ulKind;
        [switch_is(ulKind)] union
        {
            [case(PRSPEC_PROPID)]
                PROPID      propid;
            [case(PRSPEC_LPWSTR)]
                LPOLESTR    lpwstr;
            [default] ;
        } ;

    } PROPSPEC;

    typedef struct tagSTATPROPSTG
    {

        LPOLESTR    lpwstrName;
        PROPID      propid;
        VARTYPE     vt;

    } STATPROPSTG;

    cpp_quote("// Macros for parsing the OS Version of the Property Set Header")
    cpp_quote("#define PROPSETHDR_OSVER_KIND(dwOSVer)      HIWORD( (dwOSVer) )")
    cpp_quote("#define PROPSETHDR_OSVER_MAJOR(dwOSVer)     LOBYTE(LOWORD( (dwOSVer) ))")
    cpp_quote("#define PROPSETHDR_OSVER_MINOR(dwOSVer)     HIBYTE(LOWORD( (dwOSVer) ))")
    cpp_quote("#define PROPSETHDR_OSVERSION_UNKNOWN        0xFFFFFFFF")


    typedef struct tagSTATPROPSETSTG
    {

        FMTID       fmtid;
        CLSID       clsid;
        DWORD       grfFlags;
        FILETIME    mtime;
        FILETIME    ctime;
        FILETIME    atime;
        DWORD       dwOSVersion;

    } STATPROPSETSTG;


    // When this IDL file is used for "IProp.dll" (the
    // standalone property set DLL), we must have local
    // and remotable routines (call_as routines are used
    // to remove BSTRs, which are not remotable with some
    // RPC run-times).
    //
    // For the remotable routines, we must use pointer
    // parameters (e.g. "*rgspec" rather than "rgspec[]")
    // so that the MIDL 2.0 compiler will generate an
    // interpereted proxy/stub, rather than inline.

#ifdef IPROPERTY_DLL
    [local]
#endif
    HRESULT ReadMultiple(
        [in]    ULONG                   cpspec,
        [in, size_is(cpspec)]
                const PROPSPEC          rgpspec[],
        [out, size_is(cpspec)]
                PROPVARIANT             rgpropvar[]
        );

#ifdef IPROPERTY_DLL
    [call_as(ReadMultiple)]
    HRESULT RemoteReadMultiple(
        [out]   BOOL                    *pfBstrPresent,
        [in]    ULONG                   cpspec,
        [in, size_is(cpspec)]
                const PROPSPEC          *rgpspec,
        [out, size_is(cpspec)]
                PROPVARIANT             *rgpropvar
        );
#endif

#ifdef IPROPERTY_DLL
    [local]
#endif
    HRESULT WriteMultiple(
        [in]    ULONG                   cpspec,
        [in, size_is(cpspec)]
                const PROPSPEC          rgpspec[],
        [in, size_is(cpspec)]
                const PROPVARIANT       rgpropvar[],
        [in]    PROPID                  propidNameFirst
        );

#ifdef IPROPERTY_DLL
    [call_as(WriteMultiple)]
    HRESULT RemoteWriteMultiple(
        [in]    BOOL                    fBstrPresent,
        [in]    ULONG                   cpspec,
        [in, size_is(cpspec)]
                const PROPSPEC          *rgpspec,
        [in, size_is(cpspec)]
                const PROPVARIANT       *rgpropvar,
        [in]    PROPID                  propidNameFirst
        );
#endif

#ifdef IPROPERTY_DLL
    [local]
#endif
    HRESULT DeleteMultiple(
        [in]    ULONG                   cpspec,
        [in, size_is(cpspec)]
                const PROPSPEC          rgpspec[]
        );

#ifdef IPROPERTY_DLL
    [call_as(DeleteMultiple)]
    HRESULT RemoteDeleteMultiple(
        [in]    ULONG                   cpspec,
        [in, size_is(cpspec)]
                const PROPSPEC          *rgpspec
        );
#endif

    HRESULT ReadPropertyNames(
        [in]    ULONG                   cpropid,
        [in, size_is(cpropid)]
                const PROPID            rgpropid[],
        [out, size_is(cpropid)]
                LPOLESTR                rglpwstrName[]
        );

    HRESULT WritePropertyNames(
        [in]    ULONG                   cpropid,
        [in, size_is(cpropid)]
                const PROPID            rgpropid[],
        [in, size_is(cpropid)]
                const LPOLESTR          rglpwstrName[]
        );

    HRESULT DeletePropertyNames(
        [in]    ULONG                   cpropid,
        [in, size_is(cpropid)]
                const PROPID            rgpropid[]
        );

    HRESULT Commit(
        [in]    DWORD                   grfCommitFlags
        );

    HRESULT Revert();

    HRESULT Enum(
        [out]   IEnumSTATPROPSTG **     ppenum
        );

    HRESULT SetTimes(
        [in]    FILETIME const *        pctime,
        [in]    FILETIME const *        patime,
        [in]    FILETIME const *        pmtime
        );

    HRESULT SetClass(
        [in]    REFCLSID                clsid
        );

    HRESULT Stat(
        [out]   STATPROPSETSTG *        pstatpsstg
        );
}

[
    object,
    uuid(0000013A-0000-0000-C000-000000000046),
    pointer_default(unique)
]

interface IPropertySetStorage : IUnknown
{

    typedef [unique] IPropertySetStorage * LPPROPERTYSETSTORAGE;

    HRESULT Create(
        [in]    REFFMTID                rfmtid,
        [in, unique]
                const CLSID *           pclsid,
        [in]    DWORD                   grfFlags,
        [in]    DWORD                   grfMode,
        [out]   IPropertyStorage **     ppprstg
        );

    HRESULT Open(
        [in]    REFFMTID                rfmtid,
        [in]    DWORD                   grfMode,
        [out]   IPropertyStorage **     ppprstg
        );

    HRESULT Delete(
        [in]    REFFMTID                rfmtid
        );

    HRESULT Enum(
        [out]   IEnumSTATPROPSETSTG **  ppenum
        );

}


[
    object,
    uuid(00000139-0000-0000-C000-000000000046),
    pointer_default(unique)
]

interface IEnumSTATPROPSTG : IUnknown
{

    typedef [unique] IEnumSTATPROPSTG * LPENUMSTATPROPSTG;

    [local]
    HRESULT Next(
        [in]    ULONG                   celt,
        [out, size_is(celt), length_is(*pceltFetched)]
                STATPROPSTG *           rgelt,
        [out]   ULONG *                 pceltFetched
        );

    [call_as(Next)]
    HRESULT RemoteNext(
        [in]    ULONG                   celt,
        [out, size_is(celt), length_is(*pceltFetched)]
                STATPROPSTG *           rgelt,
        [out]   ULONG *                 pceltFetched
        );

    HRESULT Skip(
        [in]    ULONG                   celt
        );

    HRESULT Reset();

    HRESULT Clone(
        [out]   IEnumSTATPROPSTG **     ppenum
        );
}


[
    object,
    uuid(0000013B-0000-0000-C000-000000000046),
    pointer_default(unique)
]

interface IEnumSTATPROPSETSTG : IUnknown
{

    typedef [unique] IEnumSTATPROPSETSTG * LPENUMSTATPROPSETSTG;

    [local]
    HRESULT Next(
        [in]    ULONG                   celt,
        [out, size_is(celt), length_is(*pceltFetched)]
                STATPROPSETSTG *        rgelt,
        [out]   ULONG *                 pceltFetched
        );

    [call_as(Next)]
    HRESULT RemoteNext(
        [in]    ULONG                   celt,
        [out, size_is(celt), length_is(*pceltFetched)]
                STATPROPSETSTG *        rgelt,
        [out]   ULONG *                 pceltFetched
        );

    HRESULT Skip(
        [in]    ULONG                   celt
        );

    HRESULT Reset();

    HRESULT Clone(
        [out]   IEnumSTATPROPSETSTG **  ppenum
        );
}


cpp_quote("WINOLEAPI PropVariantCopy ( PROPVARIANT * pvarDest, const PROPVARIANT * pvarSrc );")
cpp_quote("WINOLEAPI PropVariantClear ( PROPVARIANT * pvar );")
cpp_quote("WINOLEAPI FreePropVariantArray ( ULONG cVariants, PROPVARIANT * rgvars );")

cpp_quote("")
cpp_quote("#define _PROPVARIANTINIT_DEFINED_")
cpp_quote("#   ifdef __cplusplus")
cpp_quote("inline void PropVariantInit ( PROPVARIANT * pvar )")
cpp_quote("{")
cpp_quote("    memset ( pvar, 0, sizeof(PROPVARIANT) );")
cpp_quote("}")
cpp_quote("#   else")
cpp_quote("#   define PropVariantInit(pvar) memset ( pvar, 0, sizeof(PROPVARIANT) )")
cpp_quote("#   endif")
cpp_quote("")

cpp_quote("")
cpp_quote("#ifndef _STGCREATEPROPSTG_DEFINED_")
cpp_quote("WINOLEAPI StgCreatePropStg( IUnknown* pUnk, REFFMTID fmtid, const CLSID *pclsid, DWORD grfFlags, DWORD dwReserved, IPropertyStorage **ppPropStg );")
cpp_quote("WINOLEAPI StgOpenPropStg( IUnknown* pUnk, REFFMTID fmtid, DWORD grfFlags, DWORD dwReserved, IPropertyStorage **ppPropStg );")
cpp_quote("WINOLEAPI StgCreatePropSetStg( IStorage *pStorage, DWORD dwReserved, IPropertySetSto