vboosttypes6.idl

此源码为vb圣经编码

// VBoost.idl : IDL source for VBoost.dll
//

// This file will be processed by the MIDL tool to
// produce the type library (VBoost.tlb) and marshalling code.

//import "oaidl.idl";
//import "ocidl.idl";

[
    uuid(20708EE0-24E3-11D3-AB5C-D41203C10000),
    version(1.0),
    helpstring("VBoost Object Types (6.0)")
]
library VBoostTypes
{
    importlib("stdole2.tlb");
    
#ifdef __MKTYPLIB__
#ifdef VARIANT_BOOL
#undef VARIANT_BOOL
#endif
#define VARIANT_BOOL boolean
#endif //__MKTYPLIB__

    typedef struct VBGUID
    {
      long Data1;
      short Data2;
      short Data3;
      unsigned char Data4[8];
    } VBGUID;

    typedef [public] long VBGUIDPtr;

    typedef enum UnkHookFlags
    {
        uhBeforeQI = 1,
        uhAfterQI = 2,
        uhMapIIDs = 4,
        uhAddRef = 8,
        uhRelease = 0x10
    } UnkHookFlags;

    typedef enum ADFlags
    {
        // Ignore the IIDs, running this as a blind filter
        adIgnoreIIDs = 0,
        // Actually use the IID fields
        adUseIIDs = 1,
        // FirstIID is the IID to watch for, and LastIID is the one
        // to replace it with before the bulk of the QI call.  If this is
        // set, then pObject and all other flags are ignored.
        adMapIID = 2,
        // FirstIID to LastIID is the range to block.  This should be the only flag
        // set.  pObject should not be set.
        adBlockIIDs = 4,
        // This gets first shot at any IDispatch QI.  Subsequent uses of this flag are ignored.
        adPrimaryDispatch = 8,
        // Give this object an interface request before the controlling unknown.  This
        // is ignored if no controlling object is sent into the AggregateObjects call. 
        adBeforeHookedUnknown = 0x10,
        // Don't send QI's to this object.  Used for object ownership only.
        adDontQuery = 0x20,
        // Don't put a blind delegator around items returned from this object
        // This breaks COM identity rules, but saves some overhead.  Specifying
        // this flag means that you can't QI back to the original object.
        adNoDelegator = 0x40,
        // This means that the object passed in the AggregateData is not the
        // object corresponding to the IID, but rather a reference to an IDelayCreation
        // interface to use when the interface is received.  Delayed creation is valid
        // only when an IID is actually specified.
        adDelayCreation = 0x80,
        // When this flag is set, then the reference to the IDelayCreation interface
        // is maintained.  Without this flag, the IDelayCreation interface is released
        // and the resolved reference is kept by the aggregator.  This includes
        // adDelayCreation automatically.
        adDelayDontCacheResolved = 0x180,
        // The object passed into pObject is guaranteed to be of the
        // specified interface type.  There is no need to call QueryInterface
        // against the object to guarantee the correct IID.  This must be
        // used with adUseIIDs, only only 1 IID can be specified.  If this flag
        // is used with a delayed interface, then IDelayCreation_Create must return
        // a fully resolved pointer as well.
        adFullyResolved = 0x200,
        // The object passed into pObject is kept as a weak reference by adding
        // a reference to the object itself, but releasing a reference on its
        // controlling IUnknown. The controlling IUnknown reference is restored
        // before the object is released.
        adWeakRefBalanced = 0x400,
        // The object passed into pObject is stored as a raw weak reference. This
        // is a dangerous flag and should be used with caution.
        adWeakRefRaw = 0x800
    } ADFlags;

    typedef struct AggregateData
    {
        stdole.IUnknown* pObject;
        ADFlags Flags;
        short FirstIID;
        short LastIID;
    } AggregateData;

    typedef struct BlindDelegator
    {
        long pVTable;
        stdole.IUnknown* pInner;
        stdole.IUnknown* pOuter;
        long cRefs;
        long pfnDestroy;
    } BlindDelegator;

    typedef [public] long BlindDelegatorPtr;

    [
        odl,
        uuid(20708EE3-24E3-11D3-AB5C-D41203C10000),
        helpstring("IUnknown Hook")
    ]
    interface UnknownHook : IUnknown
    {
        [propget]
        HRESULT Flags([out,retval] UnkHookFlags* puhFlags);
        [propput]
        HRESULT Flags([in] UnkHookFlags uhFlags);
    }

    [
        odl,
        uuid(20708EE4-24E3-11D3-AB5C-D41203C10000),
        helpstring("QueryInterface Hook")
    ]
    interface IQIHook : IUnknown
    {
        HRESULT QIHook([in,out] VBGUID* iid, [in] UnkHookFlags uhFlags, [in, out] stdole.IUnknown** pResult, [in] stdole.IUnknown* HookedUnknown);
        HRESULT MapIID([in,out] VBGUID* iid);
    }

    [
        odl,
        uuid(20708EE5-24E3-11D3-AB5C-D41203C10000),
        helpstring("QueryInterface, AddRef, Release Hook")
    ]
    interface IQIARHook : IUnknown
    {
        HRESULT QIHook([in,out] VBGUID* iid, [in] UnkHookFlags uhFlags, [in, out] stdole.IUnknown** pResult, [in] stdole.IUnknown* HookedUnknown);
        HRESULT MapIID([in,out] VBGUID* iid);
        HRESULT AfterAddRef([in] long Result, [in] long pHookedUnknown);
        HRESULT AfterRelease([in] long Result, [in] long pHookedUnknown);
    }

    [
        odl,
        uuid(20708EE6-24E3-11D3-AB5C-D41203C10000),
        helpstring("Delayed Creation Callback")
    ]
    interface IDelayCreation : IUnknown
    {
        HRESULT Create([in,out] VBGUID* iid, [out, retval] stdole.IUnknown** pResult);
    }

    [
        odl,
        uuid(20708EE7-24E3-11D3-AB5C-D41203C10000),
        helpstring("Fixed size memory manager")
    ]
    interface FixedSizeMemoryManager : IUnknown
    {
        HRESULT Alloc([out,retval] long* retVal);
        void Free([in] long pMemory);
        [propget]
        HRESULT ElementSize([out,retval] long* retVal);
        [propget]
        HRESULT ElementsPerBlock([out,retval] long* retVal);
    }

    [
        odl,
        uuid(20708EE8-24E3-11D3-AB5C-D41203C10000),
        helpstring("Compactible fixed size memory manager")
    ]
    interface CompactibleFixedSizeMemoryManager : FixedSizeMemoryManager
    {
        void Compact();
        [propget]
        HRESULT CompactOnFree([out,retval] VARIANT_BOOL* retVal);
        [propput]
        HRESULT CompactOnFree([in] VARIANT_BOOL RHS);
        [propget]
        HRESULT BufferBlocks([out,retval] short* retVal);
        [propput]
        HRESULT BufferBlocks([in] short RHS);
    }

    [
        odl,
        uuid(20708EE1-24E3-11D3-AB5C-D41203C10000),
        helpstring("VBoost Root Object")
    ]
    interface VBoostRoot : IUnknown
    {
        [helpstring("Hook the controlling IUnknown, notify during QueryInterface.")]
        HRESULT HookQI([in] stdole.IUnknown* pUnk, [in] IQIHook* pQIHook, [in] UnkHookFlags uhFlags, [out] UnknownHook** ppOwner);
        [helpstring("Hook the controlling IUnknown, notify during QueryInterface, AddRef, and Release.")]
        HRESULT HookQIAR([in] stdole.IUnknown* pUnk, [in] IQIARHook* pQIARHook, [in] UnkHookFlags uhFlags, [out] UnknownHook** ppOwner);
        [helpstring("To stop the IID_IUnknown QueryInterface, wrap assigned object with SafeUnknown when assigning to a stdole.IUnknown variable.")]
        HRESULT SafeUnknown([in] IUnknown* pUnknown, [out,retval] stdole.IUnknown** retVal);
        [helpstring("Create blind vtable delegator with the given controlling IUnknown.")]
        HRESULT CreateDelegator([in] stdole.IUnknown *punkOuter, [in] IUnknown *punkDelegatee, [in, defaultvalue(0)] VBGUIDPtr pIID, [in, defaultvalue(0)] BlindDelegatorPtr pEmbedded, [in, defaultvalue(0)] long pfnDestroyEmbedded, [out,retval] stdole.IUnknown **ppvObj);
        [helpstring("Hook the given IUnknown to make it look like an aggregate of the specified objects.")]
        HRESULT AggregateUnknown([in] stdole.IUnknown* pUnk, [in] SAFEARRAY(AggregateData)* pData, [in] SAFEARRAY(VBGUID)* pIIDs, [out] UnknownHook** ppOwner);
        [helpstring("Create a new object which is an aggregate of multiple objects.  pOwner is VarPtr of a long member variable owned by one of the objects in the AggData structure.")]
        HRESULT CreateAggregate([in] SAFEARRAY(AggregateData)* pData, [in] SAFEARRAY(VBGUID)* pIIDs, [in, defaultvalue(0)] long pOwner, [out,retval] stdole.IUnknown **ppvObj);
        [helpstring("Helper function to get a strong reference from a weak reference without QueryInterface or CopyMemory.")]
        void AssignAddRef([out] void * pDst, [in] void* pSrc);
        [helpstring("Get a function pointer for the given function from the blind delegator array.")]
        HRESULT BlindFunctionPointer([in] long FunctionNumber, [out,retval] long* retVal);
        [helpstring("Create a FixedSizeMemoryManager object.")]
        HRESULT CreateFixedSizeMemoryManager([in] long ElementSize, [in] long ElementsPerBlock, [in, defaultvalue(0)] VARIANT_BOOL fCompactible, [out,retval] FixedSizeMemoryManager** retVal);
        [helpstring("Assign one pointer value to another.  *pDst = *pSrc.")]
        void Assign([in] void* pDst, [in] void* pSrc);
        [helpstring("Dereference the value of a pointer. Deref = *Ptr.")]
        long Deref([in] long Ptr);
        [helpstring("Add two long values using unsigned arithmetic.")]
        long UAdd([in] long x, [in] long y);
        [helpstring("Subtract two long values using unsigned arithmetic.")]
        long UDif([in] long x, [in] long y);
        [helpstring("Greater than compare of two unsigned values.")]
        VARIANT_BOOL UGT([in] long x, [in] long y);
        [helpstring("Greater than or equal compare of two unsigned values.")]
        VARIANT_BOOL UGTE([in] long x, [in] long y);
        [helpstring("Assign 0 to the dereferenced pointer. *pDst = 0.")]
        void AssignZero([in] void* pDst);
        [helpstring("Swap values in two pointers.")]
        void AssignSwap([in] void* pLeft, [in] void* pRight);
        [helpstring("Free the current contents of varDst and move varSrc into varDst. varSrc returns Empty.")]
        void MoveVariant([out] VARIANT* varDst, [in,out] VARIANT* varSrc);
        [helpstring("Divide two long values using unsigned arithmetic.")]
        long UDiv([in] long x, [in] long y);
    }