/*****************************************************************************
* dxtmsft.idl *
*-------------*
*
*   Description:
*       This is the IDL file for DirectX installable transform coclass,
*   interface, and type definitions.
*
*-----------------------------------------------------------------------------
*   Date: 07/07/97
*   Copyright Microsoft Corporation 1997
*   All rights reserved.
*-----------------------------------------------------------------------------
*   11/09/98 a-MatCal   Added Chroma and Drop Shadow interfaces, classes,
*                       and property pages.
*****************************************************************************/

//--- Import base idl
import "oaidl.idl";
import "ocidl.idl";
import "dxtrans.idl";

cpp_quote("#include <dxtmsft3.h>")

//--- Additional includes

//--- Export

//=== Forward References ====================================================
interface IDXTComposite;
interface IDXMapper;
interface IDXLUTBuilder;
interface IDXDLUTBuilder;
interface IDXTConvolution;

//--- Chrome Wrapper interfaces
interface ICrBlur;

//=== Constants =============================================================

cpp_quote("//")
cpp_quote("//   DXTransforms Image Transforms Type Library Version Info")
cpp_quote("//")
cpp_quote("#define DXTMSFT_TLB_MAJOR_VER 1")
cpp_quote("#define DXTMSFT_TLB_MINOR_VER 1")

//=== Struct & Enum definitions =============================================

//=== Interface definitions =================================================

//--- IDXLUTBuilder -----------------------------------
typedef enum OPIDDXLUTBUILDER
{
    OPID_DXLUTBUILDER_Gamma,
    OPID_DXLUTBUILDER_Opacity,
    OPID_DXLUTBUILDER_Brightness,
    OPID_DXLUTBUILDER_Contrast,
    OPID_DXLUTBUILDER_ColorBalance,
    OPID_DXLUTBUILDER_Posterize,
    OPID_DXLUTBUILDER_Invert,
    OPID_DXLUTBUILDER_Threshold,
    OPID_DXLUTBUILDER_NUM_OPS
} OPIDDXLUTBUILDER;

typedef enum DXLUTCOLOR
{
    DXLUTCOLOR_RED,
    DXLUTCOLOR_GREEN,
    DXLUTCOLOR_BLUE
} DXLUTCOLOR;

[
    uuid(F4370FC1-CADB-11D0-B52C-00A0C9054373),
    helpstring("IDXLUTBuilder Interface"),
    pointer_default(unique)
]
interface IDXLUTBuilder : IUnknown
{
    HRESULT GetNumBuildSteps([out]ULONG *pulNumSteps );
    HRESULT GetBuildOrder([out, size_is(ulSize)]OPIDDXLUTBUILDER OpOrder[],
                          [in]ULONG ulSize );
    HRESULT SetBuildOrder( [in, size_is(ulNumSteps)] const OPIDDXLUTBUILDER OpOrder[],
                           [in]ULONG ulNumSteps );
    HRESULT SetGamma([in] float newVal);
    HRESULT GetGamma([out] float *pVal);
    HRESULT GetOpacity([out] float *pVal);
    HRESULT SetOpacity([in] float newVal);
    HRESULT GetBrightness([in, out]ULONG *pulCount, [out, size_is(*pulCount)]float Weights[]);
    HRESULT SetBrightness([in]ULONG ulCount, [in, size_is(ulCount)]const float Weights[]);
    HRESULT GetContrast([in, out]ULONG *pulCount, [out, size_is(*pulCount)]float Weights[]);
    HRESULT SetContrast([in]ULONG ulCount, [in, size_is(ulCount)]const float Weights[]);
    HRESULT GetColorBalance( [in]DXLUTCOLOR Color, [in, out]ULONG *pulCount, [out, size_is(*pulCount)]float Weights[] );
    HRESULT SetColorBalance( [in]DXLUTCOLOR Color, [in]ULONG ulCount, [in, size_is(ulCount)]const float Weights[] );
    HRESULT GetLevelsPerChannel([out] ULONG *pVal);
    HRESULT SetLevelsPerChannel([in] ULONG newVal);
    HRESULT GetInvert([out]float *pThreshold);
    HRESULT SetInvert([in]float Threshold);
    HRESULT GetThreshold([out] float *pVal);
    HRESULT SetThreshold([in] float newVal);
};

[
    object,
    uuid(73068231-35EE-11d1-81A1-0000F87557DB),
    dual,
    helpstring("IDXDLUTBuilder Interface"),
    pointer_default(unique)
]
interface IDXDLUTBuilder : IDispatch
{
    [propget, id(1)]
        HRESULT NumBuildSteps( [out, retval]long *pNumSteps );
    [propget, id(2)]
        HRESULT BuildOrder( [out, retval]VARIANT *pOpOrder );
    [propput, id(2)]
        HRESULT BuildOrder( [in]VARIANT *pOpOrder );
    [propget, id(3)]
        HRESULT Gamma([out, retval] float *pVal);
    [propput, id(3)]
        HRESULT Gamma([in] float newVal);
    [propget, id(4)]
        HRESULT Opacity([out, retval] float *pVal);
    [propput, id(4)]
        HRESULT Opacity([in] float newVal);
    [propget, id(5)]
        HRESULT Brightness( [out, retval]VARIANT *pWeights );
    [propput, id(5)]
        HRESULT Brightness([in]VARIANT *pWeights );
    [propget, id(6)]
        HRESULT Contrast( [out, retval]VARIANT *pWeights);
    [propput, id(6)]
        HRESULT Contrast( [in]VARIANT *pWeights);
    [propget, id(7)]
        HRESULT ColorBalance( [in]DXLUTCOLOR Color, [out, retval]VARIANT *pWeights );
    [propput, id(7)]
        HRESULT ColorBalance( [in]DXLUTCOLOR Color, [in]VARIANT *pWeights );
    [propget, id(8)]
        HRESULT LevelsPerChannel([out, retval]long *pVal);
    [propput, id(8)]
        HRESULT LevelsPerChannel([in]long newVal);
    [propget, id(9)]
        HRESULT Invert( [out, retval]float *pThreshold );
    [propput, id(9)]
        HRESULT Invert( [in]float Threshold );
    [propget, id(10)]
        HRESULT Threshold([out, retval]float *pVal);
    [propput, id(10)]
        HRESULT Threshold([in]float newVal);
};

//--- IDXTGradientD --------------------------------------------------------
// This is the dispatch control interface for the gradient transform
//
typedef enum DXGRADIENTTYPE
{
    DXGRADIENT_VERTICAL,
    DXGRADIENT_HORIZONTAL,
    DXGRADIENT_NUM_GRADIENTS
} DXGRADIENTTYPE;

typedef enum DXGRADDISPID
{
    DISPID_GradientType = 1,
    DISPID_StartColor,
    DISPID_EndColor,
    DISPID_GradientWidth,
    DISPID_GradientHeight,
    DISPID_GradientAspect,
    DISPID_StartColorStr,
    DISPID_EndColorStr,
} DXGRADDISPID;

[
    object,
    uuid(623E2881-FC0E-11d1-9A77-0000F8756A10),
    dual,
    helpstring("IDXTGradientD Interface"),
    pointer_default(unique)
]
interface IDXTGradientD : IDispatch
{
    [propput, id(DISPID_GradientType)]
        HRESULT GradientType( [in]DXGRADIENTTYPE eType );
    [propget, id(DISPID_GradientType)]
        HRESULT GradientType( [out, retval]DXGRADIENTTYPE* peType );
    [propput, id(DISPID_StartColor)]
        HRESULT StartColor([in] OLE_COLOR newVal);
    [propget, id(DISPID_StartColor)]
        HRESULT StartColor([out, retval] OLE_COLOR *pVal);
    [propput, id(DISPID_EndColor)] 
        HRESULT EndColor([in] OLE_COLOR newVal);
    [propget, id(DISPID_EndColor)]
        HRESULT EndColor([out, retval] OLE_COLOR *pVal);
    [propput, id(DISPID_GradientWidth)] 
        HRESULT GradientWidth([in] long newVal);
    [propget, id(DISPID_GradientWidth)]
        HRESULT GradientWidth([out, retval] long *pVal);
    [propput, id(DISPID_GradientHeight)] 
        HRESULT GradientHeight([in] long newVal);
    [propget, id(DISPID_GradientHeight)]
        HRESULT GradientHeight([out, retval] long *pVal);
    [propput, id(DISPID_GradientAspect)] 
        HRESULT KeepAspectRatio([in] VARIANT_BOOL newVal);
    [propget, id(DISPID_GradientAspect)]
        HRESULT KeepAspectRatio([out, retval] VARIANT_BOOL *pVal);
    [propput, id(DISPID_StartColorStr)]
        HRESULT StartColorStr([in] BSTR newVal);
    [propget, id(DISPID_StartColorStr)]
        HRESULT StartColorStr([out, retval] BSTR* pVal);
    [propput, id(DISPID_EndColorStr)] 
        HRESULT EndColorStr([in] BSTR newVal);
    [propget, id(DISPID_EndColorStr)]
        HRESULT EndColorStr([out, retval] BSTR* pVal);
};

//--- IDXTConvolution --------------------------------------------------------
typedef enum DXCONVFILTERTYPE
{
    DXCFILTER_SRCCOPY,      // No filtering
    DXCFILTER_BOX7X7,
    DXCFILTER_BLUR3X3,      
    DXCFILTER_SHARPEN,
    DXCFILTER_EMBOSS,
    DXCFILTER_ENGRAVE,
    DXCFILTER_NUM_FILTERS,  // This must be the at the end of the predefine filter list
    DXCFILTER_CUSTOM      
} DXCONVFILTERTYPE;

[
    uuid(7BA7F8AF-E5EA-11d1-81DD-0000F87557DB),
    helpstring("IDXTConvolution Interface"),
    pointer_default(unique)
]
interface IDXTConvolution : IUnknown
{
    HRESULT SetFilterType( [in]DXCONVFILTERTYPE eType );
    HRESULT GetFilterType( [out]DXCONVFILTERTYPE* peType );
    HRESULT SetCustomFilter( [in]float *pFilter, [in]SIZE Size );
    HRESULT SetConvertToGray( [in]BOOL bConvertToGray );
    HRESULT GetConvertToGray( [out]BOOL* pbConvertToGray );
    HRESULT SetBias( [in]float Bias );
    HRESULT GetBias( [out]float* pBias );
    HRESULT SetExcludeAlpha( [in]BOOL bExcludeAlpha );
    HRESULT GetExcludeAlpha( [out]BOOL* pbExcludeAlpha );
};

//--- IDXMapper -------------------------------------------------
// This is the coordinate mapping interface for a mapper object
//
[
    uuid(555278E5-05DB-11D1-883A-3C8B00C10000),
    helpstring("IDXMapper Interface"),
    pointer_default(unique)
]
interface IDXMapper : IUnknown
{
    HRESULT MapIn2Out( [in]DXVEC* pInPt, [out]DXVEC* pOutPt );
    HRESULT MapOut2In( [in]DXVEC* pOutPt, [out]DXVEC* pInPt );
};

//--- IDXDMapper -------------------------------------------------
// This is the coordinate mapping interface for a mapper object
//
[
    object,
    uuid(7FD9088B-35ED-11d1-81A1-0000F87557DB),
    dual,
    helpstring("IDXDMapper Interface"),
    pointer_default(unique)
]
interface IDXDMapper : IDispatch
{
    HRESULT MapIn2Out( [in]SAFEARRAY(VARIANT) *pInPt, [out]SAFEARRAY(VARIANT) *pOutPt );
    HRESULT MapOut2In( [in]SAFEARRAY(VARIANT) *pOutPt, [out]SAFEARRAY(VARIANT) *pInPt );
};

//--- IDXTComposite -------------------------------------------------
// This is the compositor transform control interface
typedef enum DXCOMPFUNC
{
    DXCOMPFUNC_SWAP_AB  = 0x10,
    DXCOMPFUNC_FUNCMASK = 0xF,
    //--- Compositing functions
    DXCOMPFUNC_CLEAR = 0,
    DXCOMPFUNC_MIN,
    DXCOMPFUNC_MAX,
    DXCOMPFUNC_A,
    DXCOMPFUNC_A_OVER_B,
    DXCOMPFUNC_A_IN_B,
    DXCOMPFUNC_A_OUT_B,
    DXCOMPFUNC_A_ATOP_B,
    DXCOMPFUNC_A_SUBTRACT_B,
    DXCOMPFUNC_A_ADD_B,
    DXCOMPFUNC_A_XOR_B,
    DXCOMPFUNC_B            = ( DXCOMPFUNC_A            | DXCOMPFUNC_SWAP_AB ),
    DXCOMPFUNC_B_OVER_A     = ( DXCOMPFUNC_A_OVER_B     | DXCOMPFUNC_SWAP_AB ),
    DXCOMPFUNC_B_IN_A       = ( DXCOMPFUNC_A_IN_B       | DXCOMPFUNC_SWAP_AB ),
    DXCOMPFUNC_B_OUT_A      = ( DXCOMPFUNC_A_OUT_B      | DXCOMPFUNC_SWAP_AB ),
    DXCOMPFUNC_B_ATOP_A     = ( DXCOMPFUNC_A_ATOP_B     | DXCOMPFUNC_SWAP_AB ),
    DXCOMPFUNC_B_SUBTRACT_A = ( DXCOMPFUNC_A_SUBTRACT_B | DXCOMPFUNC_SWAP_AB ),
    DXCOMPFUNC_B_ADD_A      = ( DXCOMPFUNC_A_ADD_B      | DXCOMPFUNC_SWAP_AB ), 
    DXCOMPFUNC_NUMFUNCS             // This is used for range checking only
} DXCOMPFUNC;

typedef enum DXCOMPOSITEDISPID
{
    DISPID_DXCOMPOSITE_Function = 1,
} DXCOMPOSITEDISPID;

[
    object,
    uuid(9A43A843-0831-11D1-817F-0000F87557DB),
    dual,
    helpstring("IDXTComposite Interface"),
    pointer_default(unique)
]
interface IDXTComposite : IDispatch
{
    [propput, id(DISPID_DXCOMPOSITE_Function)]
        HRESULT Function([in] DXCOMPFUNC eFunc );
    [propget, id(DISPID_DXCOMPOSITE_Function)]
        HRESULT Function([out, retval]DXCOMPFUNC *peFunc );
};


//+-----------------------------------------------------------------------------
//
//  IDXTWipe Interface
//
//------------------------------------------------------------------------------

    typedef enum DXWIPEDIRECTION
    {
        DXWD_HORIZONTAL,
        DXWD_VERTICAL
    } DXWIPEDIRECTION;

    typedef enum DXWIPEDISPID
    {
        DISPID_DXW_GradientSize = DISPID_DXE_NEXT_ID,
        DISPID_DXW_WipeStyle,
        DISPID_DXW_Motion
    } DXWIPEDISPID;

    [
        object,
        uuid(AF279B2F-86EB-11D1-81BF-0000F87557DB),
        dual,
        helpstring("IDXTWipe Interface"),
        pointer_default(unique)
    ]
    interface IDXTWipe : IDXEffect
    {
        [propget, id(DISPID_DXW_GradientSize)]
            HRESULT GradientSize( [out, retval]float *pPercentSize );
        [propput, id(DISPID_DXW_GradientSize)]
            HRESULT GradientSize( [in]float PercentSize );
        [propget, id(DISPID_DXW_WipeStyle)]
            HRESULT WipeStyle( [out, retval]DXWIPEDIRECTION *pVal );
        [propput, id(DISPID_DXW_WipeStyle)]
            HRESULT WipeStyle( [in]DXWIPEDIRECTION newVal );
    };


//+-----------------------------------------------------------------------------
//
//  IDXTWipe2 Interface
//
//------------------------------------------------------------------------------

    [
        object,
        uuid(E1FF8091-442B-4801-88B6-2B47B1611FD2),
        dual,
        helpstring("IDXTWipe2 Interface"),
        pointer_default(unique)
    ]
    interface IDXTWipe2 : IDXTWipe
    {
        [propget, id(DISPID_DXW_Motion)] 
            HRESULT Motion([out, retval] BSTR * pbstrMotion);
        [propput, id(DISPID_DXW_Motion)]
            HRESULT Motion([in] BSTR bstrMotion);
    };


//--- ICrBlur -------------------------------------------------
typedef enum CRBLURDISPID
{
    DISPID_CRB_MakeShadow = 1,
    DISPID_CRB_ShadowOpacity,
    DISPID_CRB_PixelRadius
} CRBLURDISPID;

[
    object,
    uuid(9F7C7827-E87A-11d1-81E0-0000F87557DB),
    dual,
    helpstring("ICrBlur Interface"),
    pointer_default(unique)
]
interface ICrBlur : IDispatch
{
    [propget, id(DISPID_CRB_MakeShadow)]
        HRESULT MakeShadow( [out, retval]VARIANT_BOOL *pVal );
    [propput, id(DISPID_CRB_MakeShadow)]
        HRESULT MakeShadow( [in]VARIANT_BOOL newVal );
    [propget, id(DISPID_CRB_ShadowOpacity)]
        HRESULT ShadowOpacity( [out, retval]float *pVal );
    [propput, id(DISPID_CRB_ShadowOpacity)]
        HRESULT ShadowOpacity( [in]float newVal );
    [propget, id(DISPID_CRB_PixelRadius)]
        HRESULT PixelRadius( [out, retval]float *pPixelRadius );
    [propput, id(DISPID_CRB_PixelRadius)]
        HRESULT PixelRadius( [in]float PixelRadius );
};

//--- ICrEngrave -------------------------------------------------
typedef enum CRENGRAVEDISPID
{
    DISPID_CREN_Bias = 1,
} CRENGRAVEDISPID;

[
    object,
    uuid(E4ACFB7F-053E-11d2-81EA-0000F87557DB),
    dual,
    helpstring("ICrEngrave Interface"),
    pointer_default(unique)
]
interface ICrEngrave : IDispatch
{
    [propget, id(DISPID_CREN_Bias)]
        HRESULT Bias( [out, retval]float *pVal );
    [propput, id(DISPID_CREN_Bias)]
        HRESULT Bias( [in]float newVal );
};

//--- ICrEmboss -------------------------------------------------
typedef enum CREMBOSSDISPID
{
    DISPID_CREM_Bias = 1,
} CREMBOSSDISPID;

[
    object,
    uuid(E4ACFB80-053E-11d2-81EA-0000F87557DB),
    dual,
    helpstring("ICrEmboss Interface"),
    pointer_default(unique)
]
interface ICrEmboss : IDispatch
{
    [propget, id(DISPID_CREM_Bias)]
        HRESULT Bias( [out, retval]float *pVal );
    [propput, id(DISPID_CREM_Bias)]
        HRESULT Bias( [in]float newVal );
};

//--- IDXTFade -------------------------------------------------
[
    object,
    uuid(16B280C4-EE70-11D1-9066-00C04FD9189D),
    dual,
    helpstring("IDXTFade Interface"),
    pointer_default(unique)
]
interface IDXTFade : IDXEffect
{
    [propget, id(1)] HRESULT Overlap([out, retval] float *pVal);
    [propput, id(1)] HRESULT Overlap([in] float newVal);
    [propget, id(2)] HRESULT Center([out, retval] BOOL *pVal);
    [propput, id(2)] HRESULT Center([in] BOOL newVal);
};

//--- IDXBasicImage -------------------------------------------------
[
    object,
    uuid(16B280C7-EE70-11D1-9066-00C04FD9189D),
    dual,
    helpstring("IDXBasicImage Interface"),
    pointer_default(unique)
]
interface IDXBasicImage : IDispatch
{
    [propget, id(1)] HRESULT Rotation([out, retval] int *pVal);
    [propput, id(1)] HRESULT Rotation([in] int newVal);
    [propget, id(2)] HRESULT Mirror([out, retval] BOOL *pVal);
    [propput, id(2)] HRESULT Mirror([in] BOOL newVal);
    [propget, id(3)] HRESULT GrayScale([out, retval] BOOL *pVal);
    [propput, id(3)] HRESULT GrayScale([in] BOOL newVal);
    [propget, id(4)] HRESULT Opacity([out, retval] float *pVal);
    [propput, id(4)] HRESULT Opacity([in] float newVal);
    [propget, id(5)] HRESULT Invert([out, retval] BOOL *pVal);
    [propput, id(5)] HRESULT Invert([in] BOOL newVal);
    [propget, id(6)] HRESULT XRay([out, retval] BOOL *pVal);
    [propput, id(6)] HRESULT XRay([in] BOOL newVal);
    [propget, id(7)] HRESULT Mask([out, retval] BOOL *pVal);
    [propput, id(7)] HRESULT Mask([in] BOOL newVal);
    [propget, id(8)] HRESULT MaskColor([out, retval] int *pVal);
    [propput, id(8)] HRESULT MaskColor([in] int newVal);
};


//--- IDXPixelate ---------------------------------------------------

[
    object,
    uuid(D33E180F-FBE9-11d1-906A-00C04FD9189D),
    dual,
    helpstring("IDXPixelate Interface"),
    pointer_default(unique)
]
interface IDXPixelate : IDXEffect
{
    [propget, id(1)] HRESULT MaxSquare([out, retval] int *pVal);
    [propput, id(1)] HRESULT MaxSquare([in] int newVal);
}


//+-----------------------------------------------------------------------------
//
//  ICrIris Interface
//
//------------------------------------------------------------------------------

    typedef enum DISPID_CRIRIS {
        DISPID_CRIRIS_IRISSTYLE = 1,
        DISPID_CRIRIS_MOTION
    } DISPID_CRIRIS;

    [
        object,
        uuid(3F69F350-0379-11D2-A484-00C04F8EFB69),
        dual,
        helpstring("ICrIris Interface"),
        pointer_default(unique)
    ]
    interface ICrIris : IDXEffect
    {
        [propget, id(DISPID_CRIRIS_IRISSTYLE)]
            HRESULT irisStyle([out, retval] BSTR *pVal);
        [propput, id(DISPID_CRIRIS_IRISSTYLE)] 
            HRESULT irisStyle([in] BSTR newVal);
    };


//+-----------------------------------------------------------------------------
//
//  ICrIris2 Interface
//
//------------------------------------------------------------------------------

    [
        object,
        uuid(F7B06961-BA8C-4970-918B-1C60CB9FF180),
        dual,
        helpstring("ICrIris2 Interface"),
        pointer_default(unique)
    ]
    interface ICrIris2 : ICrIris
    {
        [propget, id(DISPID_CRIRIS_MOTION)]
            HRESULT Motion([out, retval] BSTR * pbstrMotion);
        [propput, id(DISPID_CRIRIS_MOTION)]
            HRESULT Motion([in] BSTR bstrMotion);
    };


//************************************************************
//
// ICrSlide Interface
//
//************************************************************
    [
        object,
        uuid(810E402E-056B-11D2-A484-00C04F8EFB69),
        dual,
        helpstring("ICrSlide Interface"),
        pointer_default(unique)
    ]
    interface ICrSlide : IDXEffect
    {
        [propget, id(1)] HRESULT bands([out, retval] short *pVal);
        [propput, id(1)] HRESULT bands([in] short newVal);

        [propget, id(2)] HRESULT slideStyle([out, retval] BSTR *pVal);
        [propput, id(2)] HRESULT slideStyle([in] BSTR newVal);
    };


//+-----------------------------------------------------------------------------
//
//  ICrRadialWipe Interface
//
//------------------------------------------------------------------------------

    [
        object,
        uuid(424B71AE-0695-11D2-A484-00C04F8EFB69),
        dual,
        helpstring("ICrRadialWipe Interface"),
        pointer_default(unique)
    ]
    interface ICrRadialWipe : IDXEffect
    {
        [propget, id(1)] HRESULT wipeStyle([out, retval] BSTR *pVal);
        [propput, id(1)] HRESULT wipeStyle([in] BSTR newVal);
    };


//+-----------------------------------------------------------------------------
//
//  ICrBarn Interface
//
//------------------------------------------------------------------------------

    typedef enum DISPID_CRBARN {
        DISPID_CRBARN_MOTION = 1,
        DISPID_CRBARN_ORIENTATION
    } DISPID_CRBARN;

    [
        object,
        uuid(276A2EE0-0B5D-11D2-A484-00C04F8EFB69),
        dual,
        helpstring("ICrBarn Interface"),
        pointer_default(unique)
    ]
    interface ICrBarn : IDXEffect
    {
    };


//+-----------------------------------------------------------------------------
//
//  ICrBarn2 Interface
//
//------------------------------------------------------------------------------

    [
        object,
        uuid(B66A7A1B-8FC6-448C-A2EB-3C55957478A1),
        dual,
        helpstring("ICrBarn2 Interface"),
        pointer_default(unique)
    ]
    interface ICrBarn2 : ICrBarn
    {
        [propget, id(DISPID_CRBARN_MOTION)]
            HRESULT Motion([out, retval] BSTR * pbstrMotion);
        [propput, id(DISPID_CRBARN_MOTION)]
            HRESULT Motion([in] BSTR bstrMotion);
        [propget, id(DISPID_CRBARN_ORIENTATION)]
            HRESULT Orientation([out, retval] BSTR * pbstrOrientation);
        [propput, id(DISPID_CRBARN_ORIENTATION)]
            HRESULT Orientation([in] BSTR bstrOrientation);
    };


//+-----------------------------------------------------------------------------
//
//  ICrBlinds Interface
//
//------------------------------------------------------------------------------

    typedef enum DISPID_CRBLINDS {
        DISPID_CRBLINDS_BANDS = 1,
        DISPID_CRBLINDS_DIRECTION
    } DISPID_CRBLINDS;

    [
        object,
        uuid(5AF5C340-0BA9-11d2-A484-00C04F8EFB69),
        dual,
        helpstring("ICrBlinds Interface"),
        pointer_default(unique)
    ]
    interface ICrBlinds : IDXEffect
    {
        [propget, id(DISPID_CRBLINDS_BANDS)] 
            HRESULT bands([out, retval] short * pVal);
        [propput, id(DISPID_CRBLINDS_BANDS)] 
            HRESULT bands([in] short newVal);
    };


//+-----------------------------------------------------------------------------
//
//  ICrBlinds2 Interface
//
//------------------------------------------------------------------------------

    [
        object,
        uuid(7059D403-599A-4264-8140-641EB8AE1F64),
        dual,
        helpstring("ICrBlinds2 Interface"),
        pointer_default(unique)
    ]
    interface ICrBlinds2 : ICrBlinds
    {
        [propget, id(DISPID_CRBLINDS_DIRECTION)]
            HRESULT Direction([out, retval] BSTR * pbstrDirection);
        [propput, id(DISPID_CRBLINDS_DIRECTION)]
            HRESULT Direction([in] BSTR bstrDirection);
    };


//************************************************************
//
// ICrInset Interface
//
//************************************************************
	[
		object,
		uuid(05C5EE20-0BA6-11d2-A484-00C04F8EFB69),
		dual,
		helpstring("ICrInset Interface"),
		pointer_default(unique)
	]
	interface ICrInset : IDXEffect
	{
	};

//************************************************************
//
// ICrStretch Interface
//
//************************************************************
	[
		object,
		uuid(6684AF00-0A87-11d2-A484-00C04F8EFB69),
		dual,
		helpstring("ICrStretch Interface"),
		pointer_default(unique)
	]
	interface ICrStretch : IDXEffect
	{
		[propget, id(1)] HRESULT stretchStyle([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT stretchStyle([in] BSTR newVal);
	};

//************************************************************
//
// IDXTGridSize Interface
//
//************************************************************
    [
        object,
        uuid(D6BBE91E-FF60-11d2-8F6E-00A0C9697274),
        dual,
        helpstring("IDXTGridSize Interface"),
        pointer_default(unique)
    ]
    interface IDXTGridSize : IDXEffect
    {
        [propget, id(1)] HRESULT gridSizeX([out, retval] short *pX);
        [propput, id(1)] HRESULT gridSizeX([in] short newX);
        [propget, id(2)] HRESULT gridSizeY([out, retval] short *pY);
        [propput, id(2)] HRESULT gridSizeY([in] short newY);
    }

//************************************************************
//
// ICrSpiral Interface
//
//************************************************************
	[
		object,
		uuid(0DE527A0-0C7E-11d2-A484-00C04F8EFB69),
		dual,
		helpstring("ICrSpiral Interface"),
		pointer_default(unique)
	]
	interface ICrSpiral : IDXTGridSize
	{
	};

//************************************************************
//
// ICrZigzag Interface
//
//************************************************************
	[
		object,
		uuid(4E5A64A0-0C8B-11d2-A484-00C04F8EFB69),
		dual,
		helpstring("ICrZigzag Interface"),
		pointer_default(unique)
	]
	interface ICrZigzag : IDXTGridSize
	{
	};

//************************************************************
//
// ICrWheel Interface
//
//************************************************************
	[
		object,
		uuid(3943DE80-1464-11d2-A484-00C04F8EFB69),
		dual,
		helpstring("ICrWheel Interface"),
		pointer_default(unique)
	]
	interface ICrWheel : IDXEffect
	{
		[propget, id(1)] HRESULT spokes([out, retval] short *pX);
		[propput, id(1)] HRESULT spokes([in] short newX);
	};

//************************************************************
//
// IDXTChroma Interface
//
//************************************************************
    [
        object,
        uuid(1D4637E2-383C-11d2-952A-00C04FA34F05),
        dual,
        helpstring("IDXTChroma Interface"),
        pointer_default(unique)
    ]
    interface IDXTChroma : IDispatch
    {
        [propput, id(1)] HRESULT Color([in] VARIANT newVal);
        [propget, id(1)] HRESULT Color([out, retval] VARIANT *pVal);
    };

//************************************************************
//
// IDXTDropShadow Interface
//
//************************************************************
    [
        object,
        uuid(1D4637E3-383C-11d2-952A-00C04FA34F05),
        dual,
        helpstring("IDXTDropShadow Interface"),
        pointer_default(unique)
    ]
    interface IDXTDropShadow : IDispatch
    {
        [propget, id(1)] HRESULT Color([out, retval] VARIANT *pVal);
        [propput, id(1)] HRESULT Color([in] VARIANT newVal);
        [propget, id(2)] HRESULT OffX([out, retval] int *pVal);
        [propput, id(2)] HRESULT OffX([in] int newVal);
        [propget, id(3)] HRESULT OffY([out, retval] int *pVal);
        [propput, id(3)] HRESULT OffY([in] int newVal);
        [propget, id(4)] HRESULT Positive([out, retval] VARIANT_BOOL *pVal);
        [propput, id(4)] HRESULT Positive([in] VARIANT_BOOL newVal);
    };


//+-----------------------------------------------------------------------------
//
//  IDXTCheckerBoard Interface
//
//------------------------------------------------------------------------------

    typedef enum DISPID_DXTCHECKERBOARD {
        DISPID_DXTCHECKERBOARD_DIRECTION = 1,
        DISPID_DXTCHECKERBOARD_SQUARESX,
        DISPID_DXTCHECKERBOARD_SQUARESY
    } DISPID_DXTCHECKERBOARD;

    [
        object,
        uuid(AD3C2576-117C-4510-84DD-B668971DCFD1),
        dual,
        helpstring("IDXTCheckerBoard Interface"),
        pointer_default(unique)
    ]
    interface IDXTCheckerBoard : IDXEffect
    {
        [propget, id(DISPID_DXTCHECKERBOARD_DIRECTION)] 
            HRESULT Direction([out, retval] BSTR * pbstrDirection);
        [propput, id(DISPID_DXTCHECKERBOARD_DIRECTION)] 
            HRESULT Direction([in] BSTR bstrDirection);
        [propget, id(DISPID_DXTCHECKERBOARD_SQUARESX)] 
            HRESULT SquaresX([out, retval] int * pnSquaresX);
        [propput, id(DISPID_DXTCHECKERBOARD_SQUARESX)] 
            HRESULT SquaresX([in] int nSquaresX);
        [propget, id(DISPID_DXTCHECKERBOARD_SQUARESY)] 
            HRESULT SquaresY([out, retval] int * pnSquaresY);
        [propput, id(DISPID_DXTCHECKERBOARD_SQUARESY)] 
            HRESULT SquaresY([in] int nSquaresY);
    };


//+-----------------------------------------------------------------------------
//
//  IDXTRevealTrans Interface
//
//------------------------------------------------------------------------------

    [
        object,
        uuid(B8095006-A128-464B-8B2D-90580AEE2B05),
        dual,
        helpstring("IDXTRevealTrans Interface"),
        pointer_default(unique)
    ]
    interface IDXTRevealTrans : IDXEffect
    {
        [propget, id(1)] HRESULT Transition([out, retval] int * pnTransition);
        [propput, id(1)] HRESULT Transition([in] int nTransition);
    };


//+-----------------------------------------------------------------------------
//
//  IDXTMask Interface
//
//------------------------------------------------------------------------------

    [ 
        object,
        uuid(A1067146-B063-47d7-A54A-2C2309E9889D),
        dual,
        helpstring("IDXTMask Interface"),
        pointer_default(unique)
    ]
    interface IDXTMask : IDispatch
    {
        [propget, id(1)] HRESULT Color([out, retval] VARIANT * pvarColor);
        [propput, id(1)] HRESULT Color([in] VARIANT varColor);
    };


//+-----------------------------------------------------------------------------
//
//  IDXTRedirect Interface
//
//------------------------------------------------------------------------------

    typedef enum DISPID_DXTREDIRECT {
        DISPID_DXTREDIRECT_ELEMENTIMAGE = 1,
        DISPID_DXTREDIRECT_SETDAVIEWHANDLER,
        DISPID_DXTREDIRECT_HASIMAGEBEENALLOCATED,
        DISPID_DXTREDIRECT_DOREDIRECTION
    } DISPID_DXTREDIRECT;

    [
        object,
        uuid(02F5140B-626F-4019-9C9E-2DAA1E93E8FC),
        dual,
        helpstring("IDXTRedirect Interface"),
        pointer_default(unique)
    ]
    interface IDXTRedirect : IDispatch
    {
        [id(DISPID_DXTREDIRECT_ELEMENTIMAGE)] 
            HRESULT ElementImage([out, retval] VARIANT * pvarImage);
	[id(DISPID_DXTREDIRECT_SETDAVIEWHANDLER)]
            HRESULT SetDAViewHandler([in] IDispatch * pDispViewHandler);
        [id(DISPID_DXTREDIRECT_HASIMAGEBEENALLOCATED)]
            HRESULT HasImageBeenAllocated([out, retval] BOOL * pfAllocated);
        [id(DISPID_DXTREDIRECT_DOREDIRECTION)]
            HRESULT DoRedirection([in] IUnknown * pInputSurface,
                                  [in] HDC hdcOutput,
                                  [in] RECT * pDrawRect);
    };


//+-----------------------------------------------------------------------------
//
//  IDXTAlphaImageLoader Interface
//
//------------------------------------------------------------------------------

    typedef enum DISPID_DXTALPHAIMAGELOADER
    {
        DISPID_DXTALPHAIMAGELOADER_SRC = 1,
        DISPID_DXTALPHAIMAGELOADER_SIZINGMETHOD,
    } DISPID_DXTALPHAIMAGELOADER;

    [
        object,
        uuid(A5F2D3E8-7A7E-48E5-BC75-40790BE4A941),
        dual,
        helpstring("IDXTAlphaImageLoader Interface"),
        pointer_default(unique)
    ]
    interface IDXTAlphaImageLoader : IDispatch
    {
        [propget, id(DISPID_DXTALPHAIMAGELOADER_SRC)] 
            HRESULT Src([out, retval] BSTR * pbstrSrc);
        [propput, id(DISPID_DXTALPHAIMAGELOADER_SRC)]
            HRESULT Src([in] BSTR bstrSrc);
        [propget, id(DISPID_DXTALPHAIMAGELOADER_SIZINGMETHOD)]
            HRESULT SizingMethod([out, retval] BSTR * pbstrSizingMethod);
        [propput, id(DISPID_DXTALPHAIMAGELOADER_SIZINGMETHOD)]
            HRESULT SizingMethod([in] BSTR bstrSizingMethod);
    };


//+-----------------------------------------------------------------------------
//
//  IDXTRandomBars Interface
//
//------------------------------------------------------------------------------

    typedef enum DISPID_DXTRANDOMBARS
    {
        DISPID_DXTRANDOMBARS_ORIENTATION = 1
    } DISPID_DXTRANDOMBARS;

    [
        object,
        uuid(8A6D2022-4A8F-4EB9-BB25-AA05201F9C84),
        dual,
        helpstring("IDXTRandomBars Interface"),
        pointer_default(unique)
    ]
    interface IDXTRandomBars : IDXEffect
    {
        [propget, id(DISPID_DXTRANDOMBARS_ORIENTATION)]
            HRESULT Orientation([out, retval] BSTR * pbstrOrientation);
        [propput, id(DISPID_DXTRANDOMBARS_ORIENTATION)]
            HRESULT Orientation([in] BSTR bstrOrientation);
    };


//+-----------------------------------------------------------------------------
//
//  IDXTStrips Interface
//
//------------------------------------------------------------------------------

    typedef enum DISPID_DXTSTRIPS
    {
        DISPID_DXTSTRIPS_MOTION = 1,
    } DISPID_DXTSTRIPS;

    [
        object,
        uuid(A83C9B5C-FB11-4AF5-8F65-D03F151D3ED5),
        dual,
        helpstring("IDXTStrips Interface"),
        pointer_default(unique)
    ]
    interface IDXTStrips : IDXEffect
    {
        [propget, id(DISPID_DXTSTRIPS_MOTION)]
            HRESULT Motion([out, retval] BSTR * pbstrMotion);
        [propput, id(DISPID_DXTSTRIPS_MOTION)]
            HRESULT Motion([in] BSTR bstrMotion);
    };


//************************************************************
//
// IDXTMetaRoll Interface
//
//************************************************************

	[
		object,
		uuid(9C61F46D-0530-11D2-8F98-00C04FB92EB7),
		dual,
		helpstring("IDXTMetaRoll Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaRoll : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaRipple Interface
//
//************************************************************

	[
		object,
		uuid(AA0D4D02-06A3-11D2-8F98-00C04FB92EB7),
		dual,
		helpstring("IDXTMetaRipple Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaRipple : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaPageTurn Interface
//
//************************************************************

	[
		object,
		uuid(AA0D4D07-06A3-11D2-8F98-00C04FB92EB7),
		dual,
		helpstring("IDXTMetaPageTurn Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaPageTurn : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaLiquid Interface
//
//************************************************************

	[
		object,
		uuid(AA0D4D09-06A3-11D2-8F98-00C04FB92EB7),
		dual,
		helpstring("IDXTMetaLiquid Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaLiquid : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaCenterPeel Interface
//
//************************************************************

	[
		object,
		uuid(AA0D4D0B-06A3-11D2-8F98-00C04FB92EB7),
		dual,
		helpstring("IDXTMetaCenterPeel Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaCenterPeel : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaPeelSmall Interface
//
//************************************************************

	[
		object,
		uuid(AA0D4D0D-06A3-11D2-8F98-00C04FB92EB7),
		dual,
		helpstring("IDXTMetaPeelSmall Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaPeelSmall : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaPeelPiece Interface
//
//************************************************************

	[
		object,
		uuid(AA0D4D0F-06A3-11D2-8F98-00C04FB92EB7),
		dual,
		helpstring("IDXTMetaPeelPiece Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaPeelPiece : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaPeelSplit Interface
//
//************************************************************

	[
		object,
		uuid(AA0D4D11-06A3-11D2-8F98-00C04FB92EB7),
		dual,
		helpstring("IDXTMetaPeelSplit Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaPeelSplit : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaWater Interface
//
//************************************************************

	[
		object,
		uuid(107045C4-06E0-11D2-8D6D-00C04F8EF8E0),
		dual,
		helpstring("IDXTMetaWater Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaWater : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaLightWipe Interface
//
//************************************************************

	[
		object,
		uuid(107045C7-06E0-11D2-8D6D-00C04F8EF8E0),
		dual,
		helpstring("IDXTMetaLightWipe Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaLightWipe : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaRadialScaleWipe Interface
//
//************************************************************

	[
		object,
		uuid(107045C9-06E0-11D2-8D6D-00C04F8EF8E0),
		dual,
		helpstring("IDXTMetaRadialScaleWipe Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaRadialScaleWipe : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaWhiteOut Interface
//
//************************************************************

	[
		object,
		uuid(107045CB-06E0-11D2-8D6D-00C04F8EF8E0),
		dual,
		helpstring("IDXTMetaWhiteOut Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaWhiteOut : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaTwister Interface
//
//************************************************************

	[
		object,
		uuid(107045CE-06E0-11D2-8D6D-00C04F8EF8E0),
		dual,
		helpstring("IDXTMetaTwister Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaTwister : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaBurnFilm Interface
//
//************************************************************

	[
		object,
		uuid(107045D0-06E0-11D2-8D6D-00C04F8EF8E0),
		dual,
		helpstring("IDXTMetaBurnFilm Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaBurnFilm : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaJaws Interface
//
//************************************************************

	[
		object,
		uuid(2A54C903-07AA-11D2-8D6D-00C04F8EF8E0),
		dual,
		helpstring("IDXTMetaJaws Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaJaws : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaColorFade Interface
//
//************************************************************

	[
		object,
		uuid(2A54C907-07AA-11D2-8D6D-00C04F8EF8E0),
		dual,
		helpstring("IDXTMetaColorFade Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaColorFade : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaFlowMotion Interface
//
//************************************************************

	[
		object,
		uuid(2A54C90A-07AA-11D2-8D6D-00C04F8EF8E0),
		dual,
		helpstring("IDXTMetaFlowMotion Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaFlowMotion : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaVacuum Interface
//
//************************************************************

	[
		object,
		uuid(2A54C90C-07AA-11D2-8D6D-00C04F8EF8E0),
		dual,
		helpstring("IDXTMetaVacuum Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaVacuum : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaGriddler Interface
//
//************************************************************

	[
		object,
		uuid(2A54C910-07AA-11D2-8D6D-00C04F8EF8E0),
		dual,
		helpstring("IDXTMetaGriddler Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaGriddler : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaGriddler2 Interface
//
//************************************************************

	[
		object,
		uuid(2A54C912-07AA-11D2-8D6D-00C04F8EF8E0),
		dual,
		helpstring("IDXTMetaGriddler2 Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaGriddler2 : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaThreshold Interface
//
//************************************************************

	[
		object,
		uuid(2A54C914-07AA-11D2-8D6D-00C04F8EF8E0),
		dual,
		helpstring("IDXTMetaThreshold Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaThreshold : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};

//************************************************************
//
// IDXTMetaWormHole Interface
//
//************************************************************

	[
		object,
		uuid(0E6AE021-0C83-11D2-8CD4-00104BC75D9A),
		dual,
		helpstring("IDXTMetaWormHole Interface"),
		pointer_default(unique)
	]
	interface IDXTMetaWormHole : IDXEffect
	{
		[propget, id(1)] HRESULT Copyright([out, retval] BSTR *pVal);
		[propput, id(1)] HRESULT Copyright([in] BSTR newVal);
	};


// CSS Transforms

//************************************************************
//
// IDXTAlpha Interface
//
//************************************************************
    [
        object,
        uuid(1D4637E0-383C-11d2-952A-00C04FA34F05),
        dual,
        helpstring("IDXTAlpha Interface"),
        pointer_default(unique)
    ]
    interface IDXTAlpha : IDispatch
    {
        [propget, id(1)] HRESULT Opacity([out, retval] long *pVal);
        [propput, id(1)] HRESULT Opacity([in] long newVal);
        [propget, id(2)] HRESULT FinishOpacity([out, retval] long *pVal);
        [propput, id(2)] HRESULT FinishOpacity([in] long newVal);
        [propget, id(3)] HRESULT Style([out, retval] long *pVal);
        [propput, id(3)] HRESULT Style([in] long newVal);
        [propget, id(4)] HRESULT StartX([out, retval] long *pVal);
        [propput, id(4)] HRESULT StartX([in] long newVal);
        [propget, id(5)] HRESULT StartY([out, retval] long *pVal);
        [propput, id(5)] HRESULT StartY([in] long newVal);
        [propget, id(6)] HRESULT FinishX([out, retval] long *pVal);
        [propput, id(6)] HRESULT FinishX([in] long newVal);
        [propget, id(7)] HRESULT FinishY([out, retval] long *pVal);
        [propput, id(7)] HRESULT FinishY([in] long newVal);
    };

//************************************************************
//
// IDXTGlow Interface
//
//************************************************************
    [
        object,
        uuid(1D4637E4-383C-11d2-952A-00C04FA34F05),
        dual,
        helpstring("IDXTGlow Interface"),
        pointer_default(unique)
    ]
    interface IDXTGlow : IDispatch
    {
        [propget, id(1)] HRESULT Color([out, retval] VARIANT * pvarColor);
        [propput, id(1)] HRESULT Color([in] VARIANT varColor);
        [propget, id(2)] HRESULT Strength([out, retval] long *pVal);
        [propput, id(2)] HRESULT Strength([in] long newVal);
    };

//************************************************************
//
// IDXTShadow Interface
//
//************************************************************
    [
        object,
        uuid(1D4637E6-383C-11d2-952A-00C04FA34F05),
        dual,
        helpstring("IDXTShadow Interface"),
        pointer_default(unique)
    ]
    interface IDXTShadow : IDispatch
    {
        [propput, id(1)] HRESULT Color([in] BSTR bstrColor);
        [propget, id(1)] HRESULT Color([out, retval] BSTR * pbstrColor);
        [propget, id(2)] HRESULT Direction([out, retval] long *pVal);
        [propput, id(2)] HRESULT Direction([in] long newVal);
        [propget, id(3)] HRESULT Strength([out, retval] long *pVal);
        [propput, id(3)] HRESULT Strength([in] long newVal);
    };

//+-----------------------------------------------------------------------------
//
//  IDXTWave Interface
//
//------------------------------------------------------------------------------

    typedef enum DISPID_DXTWAVE {
        DISPID_DXTWAVE_ADD = 1,
        DISPID_DXTWAVE_FREQ,
        DISPID_DXTWAVE_LIGHTSTRENGTH,
        DISPID_DXTWAVE_PHASE,
        DISPID_DXTWAVE_STRENGTH
    } DISPID_DXTWAVE;

    [
        object,
        uuid(1D4637E7-383C-11d2-952A-00C04FA34F05),
        dual,
        helpstring("IDXTWave Interface"),
        pointer_default(unique)
    ]
    interface IDXTWave : IDispatch
    {
        [propget, id(DISPID_DXTWAVE_ADD)] 
            HRESULT Add([out, retval] VARIANT_BOOL *pVal);
        [propput, id(DISPID_DXTWAVE_ADD)] 
            HRESULT Add([in] VARIANT_BOOL newVal);
        [propget, id(DISPID_DXTWAVE_FREQ)] 
            HRESULT Freq([out, retval] long *pVal);
        [propput, id(DISPID_DXTWAVE_FREQ)] 
            HRESULT Freq([in] long newVal);
        [propget, id(DISPID_DXTWAVE_LIGHTSTRENGTH)] 
            HRESULT LightStrength([out, retval] int *pVal);
        [propput, id(DISPID_DXTWAVE_LIGHTSTRENGTH)] 
            HRESULT LightStrength([in] int newVal);
        [propget, id(DISPID_DXTWAVE_PHASE)] 
            HRESULT Phase([out, retval] int *pVal);
        [propput, id(DISPID_DXTWAVE_PHASE)] 
            HRESULT Phase([in] int newVal);
        [propget, id(DISPID_DXTWAVE_STRENGTH)] 
            HRESULT Strength([out, retval] long *pVal);
        [propput, id(DISPID_DXTWAVE_STRENGTH)] 
            HRESULT Strength([in] long newVal);
    };


//************************************************************
//
// IDXTLight Interface
//
//************************************************************

    [
        object,
        uuid(F9EFBEC1-4302-11D2-952A-00C04FA34F05),
        dual,
        helpstring("IDXTLight Interface"),
        pointer_default(unique)
    ]
    interface IDXTLight : IDispatch
    {
        [id(1)] HRESULT addAmbient(int r, int g, int b, int strength);
        [id(2)] HRESULT addPoint(int x, int y, int z, int r, int g, int b, int strength);
        [id(3)] HRESULT addCone(int x, int y, int z, int tx, int ty, int r, int g, int b, int strength, int spread);
        [id(4)] HRESULT moveLight(int lightNum, int x, int y, int z, BOOL fAbsolute);
        [id(5)] HRESULT ChangeStrength(int lightNum, int dStrength, BOOL fAbsolute);
        [id(6)] HRESULT ChangeColor(int lightNum, int R, int G, int B, BOOL fAbsolute);
        [id(7)] HRESULT Clear();
    };


//+-----------------------------------------------------------------------------
//
//  IDXTMotionBlur Interface
//
//------------------------------------------------------------------------------

    typedef enum DISPID_DXTMOTIONBLUR {
        DISPID_DXTMOTIONBLUR_ADD = 1,
        DISPID_DXTMOTIONBLUR_DIRECTION,
        DISPID_DXTMOTIONBLUR_STRENGTH
    } DISPID_DXTMOTIONBLUR;

    [
        object,
        uuid(089057BE-D3F5-4A2C-B10A-A5130184A0F7),
        dual,
        helpstring("IDXTMotionBlur Interface"),
        pointer_default(unique)
    ]
    interface IDXTMotionBlur : IDispatch
    {
        [propget, id(DISPID_DXTMOTIONBLUR_ADD)] 
            HRESULT Add([out, retval] VARIANT_BOOL * pfAdd);
        [propput, id(DISPID_DXTMOTIONBLUR_ADD)]
            HRESULT Add([in] VARIANT_BOOL fAdd);
        [propget, id(DISPID_DXTMOTIONBLUR_DIRECTION)]
            HRESULT Direction([out, retval] short * pnDirection);
        [propput, id(DISPID_DXTMOTIONBLUR_DIRECTION)]
            HRESULT Direction([in] short nDirection);
        [propget, id(DISPID_DXTMOTIONBLUR_STRENGTH)]
            HRESULT Strength([out, retval] long * pnStrength);
        [propput, id(DISPID_DXTMOTIONBLUR_STRENGTH)]
            HRESULT Strength([in] long nStrength);
    };


//+-----------------------------------------------------------------------------
//
//  IDXTMatrix Interface
//
//------------------------------------------------------------------------------

    typedef enum DISPID_DXTMATRIX {
        DISPID_DXTMATRIX_M11 = 1,
        DISPID_DXTMATRIX_M12,
        DISPID_DXTMATRIX_DX,
        DISPID_DXTMATRIX_M21,
        DISPID_DXTMATRIX_M22,
        DISPID_DXTMATRIX_DY,
        DISPID_DXTMATRIX_SIZINGMETHOD,
        DISPID_DXTMATRIX_FILTERTYPE
    } DISPID_DXTMATRIX;

    [
        object,
        uuid(AC66A493-0F0C-4C76-825C-9D68BEDE9188),
        dual,
        helpstring("IDXTMatrix Interface"),
        pointer_default(unique)
    ]
    interface IDXTMatrix : IDispatch
    {
        [propget, id(DISPID_DXTMATRIX_M11)]
            HRESULT M11([out, retval] float * pflM11);
        [propput, id(DISPID_DXTMATRIX_M11)]
            HRESULT M11([in] const float flM11);
        [propget, id(DISPID_DXTMATRIX_M12)]
            HRESULT M12([out, retval] float * pflM12);
        [propput, id(DISPID_DXTMATRIX_M12)]
            HRESULT M12([in] const float flM12);
        [propget, id(DISPID_DXTMATRIX_DX)]
            HRESULT Dx([out, retval] float * pfldx);
        [propput, id(DISPID_DXTMATRIX_DX)]
            HRESULT Dx([in] const float fldx);
        [propget, id(DISPID_DXTMATRIX_M21)]
            HRESULT M21([out, retval] float * pflM21);
        [propput, id(DISPID_DXTMATRIX_M21)]
            HRESULT M21([in] const float flM21);
        [propget, id(DISPID_DXTMATRIX_M22)]
            HRESULT M22([out, retval] float * pflM22);
        [propput, id(DISPID_DXTMATRIX_M22)]
            HRESULT M22([in] const float flM22);
        [propget, id(DISPID_DXTMATRIX_DY)]
            HRESULT Dy([out, retval] float * pfldy);
        [propput, id(DISPID_DXTMATRIX_DY)]
            HRESULT Dy([in] const float fldy);
        [propget, id(DISPID_DXTMATRIX_SIZINGMETHOD)]
            HRESULT SizingMethod([out, retval] BSTR * pbstrSizingMethod);
        [propput, id(DISPID_DXTMATRIX_SIZINGMETHOD)]
            HRESULT SizingMethod([in] const BSTR bstrSizingMethod);
        [propget, id(DISPID_DXTMATRIX_FILTERTYPE)]
            HRESULT FilterType([out, retval] BSTR * pbstrFilterType);
        [propput, id(DISPID_DXTMATRIX_FILTERTYPE)]
            HRESULT FilterType([in] const BSTR bstrFilterType);
    };


//+-----------------------------------------------------------------------------
//
//  IDXTICMFilter Interface
//
//------------------------------------------------------------------------------

    typedef enum DISPID_DXTICMFILTER {
        DISPID_DXTICMFILTER_COLORSPACE = 1,
        DISPID_DXTICMFILTER_INTENT
    } DISPID_DXTICMFILTER;

    [
        object,
        uuid(734321ED-1E7B-4E1C-BBFA-89C819800E2F),
        dual,
        helpstring("IDXTICMFilter Interface"),
        pointer_default(unique)
    ]
    interface IDXTICMFilter : IDispatch
    {
        [propget, id(DISPID_DXTICMFILTER_COLORSPACE)]
            HRESULT ColorSpace([out, retval] BSTR * pbstrColorSpace);
        [propput, id(DISPID_DXTICMFILTER_COLORSPACE)]
            HRESULT ColorSpace([in] BSTR bstrColorSpace);
        [propget, id(DISPID_DXTICMFILTER_INTENT)]
            HRESULT Intent([out, retval] short * pnIntent);
        [propput, id(DISPID_DXTICMFILTER_INTENT)]
            HRESULT Intent([in] short nIntent);
	};


///////////////////////////////////////////////////////////////////////////
//
//=== CoClass definitions =================================================
//
///////////////////////////////////////////////////////////////////////////
[
    uuid(5E77EB03-937C-11D1-B047-00AA003B6061),
    version(1.1),
    helpstring("Microsoft DirectX Transforms Image Transforms Type Library")
]
library DXTMSFTLib
{
    importlib("stdole2.tlb");

////////////////////////////

    [
        uuid(9A43A844-0831-11D1-817F-0000F87557DB),
        helpstring("DXTComposite Class")
    ]
    coclass DXTComposite
    {
        [default] interface IDXTComposite;
    };

////////////////////////////

    [
        uuid(1E54333B-2A00-11d1-8198-0000F87557DB),
        helpstring("DXLUTBuilder Class")
    ]
    coclass DXLUTBuilder
    {
        [default] interface IDXDLUTBuilder;
        interface IDXLUTBuilder;
        interface IDXLookupTable;
    };

////////////////////////////

    [
        uuid(623E2882-FC0E-11d1-9A77-0000F8756A10),
        helpstring("DXTGradientD Class")
    ]
    coclass DXTGradientD
    {
        [default] interface IDXTGradientD;
    };

//+-----------------------------------------------------------------------------
//
//  DXTWipe class (not optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(AF279B30-86EB-11D1-81BF-0000F87557DB),
        helpstring("DXTWipe Class")
    ]
    coclass DXTWipe
    {
        [default] interface IDXTWipe2;
    };


//+-----------------------------------------------------------------------------
//
//  DXTGradientWipe class (optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(B96F67A2-30C2-47E8-BD85-70A2C948B50F),
        helpstring("DXTGradientWipe Class")
    ]
    coclass DXTGradientWipe
    {
        [default] interface IDXTWipe2;
    };


//+-----------------------------------------------------------------------------
//
//  DXTWipe, DXTGradientWipe property page
//
//------------------------------------------------------------------------------

    [
        uuid(7FFE4D08-FBFD-11d1-9A77-0000F8756A10),
        helpstring("DXTWipePP Class")
    ]
    coclass DXTWipePP
    {
        interface IUnknown;
    };


////////////////////////////

    [
        uuid(2BC0EF29-E6BA-11d1-81DD-0000F87557DB),
        helpstring("DXTConvolution Class")
    ]
    coclass DXTConvolution
    {
        [default] interface IDXTConvolution;
    };

////////////////////////////

    [
        uuid(7312498D-E87A-11d1-81E0-0000F87557DB),
        helpstring("CrBlur Class")
    ]
    coclass CrBlur
    {
        [default] interface ICrBlur;
    };

////////////////////////////

    [
        uuid(F515306D-0156-11d2-81EA-0000F87557DB),
        helpstring("CrEmboss Class")
    ]
    coclass CrEmboss
    {
        [default] interface ICrEmboss;
    };

////////////////////////////

    [
        uuid(F515306E-0156-11d2-81EA-0000F87557DB),
        helpstring("CrEngrave Class")
    ]
    coclass CrEngrave
    {
        [default] interface ICrEngrave;
    };

////////////////////////////

    [
        uuid(16B280C5-EE70-11D1-9066-00C04FD9189D),
        helpstring("DXFade Class")
    ]
    coclass DXFade
    {
        [default] interface IDXTFade;
    };

////////////////////////////

    [
        uuid(16B280C6-EE70-11D1-9066-00C04FD9189D),
        helpstring("FadePP Class")
    ]
    coclass FadePP
    {
        interface IUnknown;
    };

////////////////////////////

    [
        uuid(16B280C8-EE70-11D1-9066-00C04FD9189D),
        helpstring("BasicImageEffects Class")
    ]
    coclass BasicImageEffects
    {
        [default] interface IDXBasicImage;
    };

////////////////////////////

    [
        uuid(16B280C9-EE70-11D1-9066-00C04FD9189D),
        helpstring("BasicImageEffectsPP Class")
    ]
    coclass BasicImageEffectsPP
    {
        interface IUnknown;
    };

////////////////////////////

    [
        uuid(4CCEA634-FBE0-11d1-906A-00C04FD9189D),
        helpstring("Pixelate Effect Class")
    ]
    coclass Pixelate
    {
        [default] interface IDXPixelate;
    }

////////////////////////////

    [
        uuid(4CCEA635-FBE0-11d1-906A-00C04FD9189D),
        helpstring("Pixelate Property Page Class")
    ]
    coclass PixelatePP
    {
        interface IUnknown;
    };

////////////////////////////

    [
        uuid(623E287E-FC0E-11d1-9A77-0000F8756A10),
        helpstring("CrBlurPP Class")
    ]
    coclass CrBlurPP
    {
        interface IUnknown;
    };

////////////////////////////

    [
        uuid(623E2880-FC0E-11d1-9A77-0000F8756A10),
        helpstring("GradientPP Class")
    ]
    coclass GradientPP
    {
        interface IUnknown;
    };

////////////////////////////

    [
        uuid(25B33660-FD83-11d1-8ADE-444553540001),
        helpstring("CompositePP Class")
    ]
    coclass CompositePP
    {
        interface IUnknown;
    };

////////////////////////////

    [
        uuid(25B33661-FD83-11d1-8ADE-444553540001),
        helpstring("ConvolvePP Class")
    ]
    coclass ConvolvePP
    {
        interface IUnknown;
    };

////////////////////////////

    [
        uuid(25B33662-FD83-11d1-8ADE-444553540001),
        helpstring("LUTBuilderPP Class")
    ]
    coclass LUTBuilderPP
    {
        interface IUnknown;
    };


//+-----------------------------------------------------------------------------
//
//  CrIris class (not optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(3F69F351-0379-11D2-A484-00C04F8EFB69),
        helpstring("CrIris Class")
    ]
    coclass CrIris
    {
        [default] interface ICrIris2;
    };


//+-----------------------------------------------------------------------------
//
//  DXTIris class (optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(049F2CE6-D996-4721-897A-DB15CE9EB73D),
        helpstring("DXTIris Class")
    ]
    coclass DXTIris
    {
        [default] interface ICrIris2;
    };


//+-----------------------------------------------------------------------------
//
//  CrIris, DXTIris property page
//
//------------------------------------------------------------------------------

    [
        uuid(80DE22C4-0F44-11D2-8B82-00A0C93C09B2),
        helpstring("CrIrisPP Class")
    ]
    coclass CrIrisPP
    {
        interface IUnknown;
    };


//+-----------------------------------------------------------------------------
//
// CrSlide class (not optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(810E402F-056B-11D2-A484-00C04F8EFB69),
        helpstring("CrSlide Class")
    ]
    coclass CrSlide
    {
        [default] interface ICrSlide;
    };


//+-----------------------------------------------------------------------------
//
// DXTSlide class (optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(D1C5A1E7-CC47-4E32-BDD2-4B3C5FC50AF5),
        helpstring("DXTSlide Class")
    ]
    coclass DXTSlide
    {
        [default] interface ICrSlide;
    };


//+-----------------------------------------------------------------------------
//
// CrSlide, DXTSlide property page
//
//------------------------------------------------------------------------------

    [
        uuid(CC8CEDE1-1003-11d2-8B82-00A0C93C09B2),
        helpstring("CrSlidePP Class")
    ]
    coclass CrSlidePP
    {
        interface IUnknown;
    };


//+-----------------------------------------------------------------------------
//
//  CrRadialWipe class (not optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(424B71AF-0695-11D2-A484-00C04F8EFB69),
        helpstring("CrRadialWipe")
    ]
    coclass CrRadialWipe
    {
        [default] interface ICrRadialWipe;
    };


//+-----------------------------------------------------------------------------
//
//  DXTRadialWipe class (optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(164484A9-35D9-4FB7-9FAB-48273B96AA1D),
        helpstring("DXTRadialWipe")
    ]
    coclass DXTRadialWipe
    {
        [default] interface ICrRadialWipe;
    };


//+-----------------------------------------------------------------------------
//
//  CrRadialWipe, DXTRadialWipe property page
//
//------------------------------------------------------------------------------

    [
        uuid(33D932E0-0F48-11d2-8B82-00A0C93C09B2),
        helpstring("CrRadialWipe Property Page")
    ]
    coclass CrRadialWipePP
    {
        interface IUnknown;
    };


//+-----------------------------------------------------------------------------
//
//  CrBarn class (not optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(C3BDF740-0B58-11d2-A484-00C04F8EFB69),
        helpstring("CrBarn Class")
    ]
    coclass CrBarn
    {
        [default] interface ICrBarn2;
    };


//+-----------------------------------------------------------------------------
//
//  DXTBarn class (optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(EC9BA17D-60B5-462B-A6D8-14B89057E22A),
        helpstring("DXTBarn Class")
    ]
    coclass DXTBarn
    {
        [default] interface ICrBarn2;
    };


//+-----------------------------------------------------------------------------
//
//  CrBarn, DXTBarn property page
//
//------------------------------------------------------------------------------

    [
        uuid(FCAD7436-F151-4110-B97E-32BD607FBDB8),
        helpstring("CrBarn Property Page")
    ]
    coclass CrBarnPP
    {
        interface IUnknown;
    };


//+-----------------------------------------------------------------------------
//
//  CrBlinds class (not optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(00C429C0-0BA9-11d2-A484-00C04F8EFB69),
        helpstring("CrBlinds Class")
    ]
    coclass CrBlinds
    {
        [default] interface ICrBlinds2;
    };


//+-----------------------------------------------------------------------------
//
//  DXTBlinds class (optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(9A4A4A51-FB3A-4F4B-9B57-A2912A289769),
        helpstring("DXTBlinds Class")
    ]
    coclass DXTBlinds
    {
        [default] interface ICrBlinds2;
    };


//+-----------------------------------------------------------------------------
//
//  CrBlinds, DXTBlinds property page
//
//------------------------------------------------------------------------------

    [
        uuid(213052C1-100D-11d2-8B82-00A0C93C09B2),
        helpstring("CrBlindPP Class")
    ]
    coclass CrBlindPP
    {
        interface IUnknown;
    };


//+-----------------------------------------------------------------------------
//
//  CrStretch class (not optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(7658F2A2-0A83-11d2-A484-00C04F8EFB69),
        helpstring("CrStretch Class")
    ]
    coclass CrStretch
    {
        [default] interface ICrStretch;
    };


//+-----------------------------------------------------------------------------
//
//  DXTStretch class (optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(F088DE73-BDD0-4E3C-81F8-6D32F4FE9D28),
        helpstring("DXTStretch Class")
    ]
    coclass DXTStretch
    {
        [default] interface ICrStretch;
    };


//+-----------------------------------------------------------------------------
//
//  CrStretch, DXTStretch property page
//
//------------------------------------------------------------------------------

    [
        uuid(15FB95E0-0F77-11d2-8B82-00A0C93C09B2),
        helpstring("CrStretchPP Class")
    ]
    coclass CrStretchPP
    {
        interface IUnknown;
    };


//+-----------------------------------------------------------------------------
//
//  CrInset class (not optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(93073C40-0BA5-11d2-A484-00C04F8EFB69),
        helpstring("CrInset Class")
    ]
    coclass CrInset
    {
        [default] interface ICrInset;
    };


//+-----------------------------------------------------------------------------
//
//  DXTInset class (optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(76F363F2-7E9F-4ED7-A6A7-EE30351B6628),
        helpstring("DXTInset Class")
    ]
    coclass DXTInset
    {
        [default] interface ICrInset;
    };


//+-----------------------------------------------------------------------------
//
//  CrSpiral class (not optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(ACA97E00-0C7D-11d2-A484-00C04F8EFB69),
        helpstring("CrSpiral Class")
    ]
    coclass CrSpiral
    {
        [default] interface ICrSpiral;
    };


//+-----------------------------------------------------------------------------
//
//  DXTSpiral class (optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(4A03DCB9-6E17-4A39-8845-4EE7DC5331A5),
        helpstring("DXTSpiral Class")
    ]
    coclass DXTSpiral
    {
        [default] interface ICrSpiral;
    };


//+-----------------------------------------------------------------------------
//
//  CrSpiral, DXTSpiral property page
//
//------------------------------------------------------------------------------

    [
        uuid(C6A4FE81-1022-11d2-8B82-00A0C93C09B2),
        helpstring("CrSpiralPP Class")
    ]
    coclass CrSpiralPP
    {
        interface IUnknown;
    };

//+-----------------------------------------------------------------------------
//
//  CrZigzag class (not optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(E6E73D20-0C8A-11D2-A484-00C04F8EFB69),
        helpstring("CrZigzag Class")
    ]
    coclass CrZigzag
    {
        [default] interface ICrZigzag;
    };

//+-----------------------------------------------------------------------------
//
//  DXTZigzag class (optimized)
//
//------------------------------------------------------------------------------

    [
        uuid(23E26328-3928-40F2-95E5-93CAD69016EB),
        helpstring("DXTZigZag Class")
    ]
    coclass DXTZigzag
    {
        [default] interface ICrZigZag;
    };


//+-----------------------------------------------------------------------------
//
//  CrZigzag, DXTZigZag property page
//
//------------------------------------------------------------------------------

    [
        uuid(1559A3C1-102B-11d2-8B82-00A0C93C09B2),
        helpstring("CrZigzagPP Class")
    ]
    coclass CrZigzagPP
    {
        interface IUnknown;
    };


    /////////////////////////////////
    // CrWheel Class
    /////////////////////////////////
    [
        uuid(5AE1DAE0-1461-11d2-A484-00C04F8EFB69),
        helpstring("CrWheel Class")
    ]
    coclass CrWheel
    {
        [default] interface ICrWheel;
    };

    /////////////////////////////////
    // CrWheel Property Page
    /////////////////////////////////
    [
        uuid(FA9F6180-1464-11d2-A484-00C04F8EFB69),
        helpstring("CrWheelPP Class")
    ]
    coclass CrWheelPP
    {
        interface IUnknown;
    };

    /////////////////////////////////
    // DXTChroma Class
    /////////////////////////////////
    [
        uuid(421516C1-3CF8-11D2-952A-00C04FA34F05),
        helpstring("Chroma Class")
    ]
    coclass DXTChroma
    {
        [default] interface IDXTChroma;
    };

    /////////////////////////////////
    // DXTChroma Property Page
    /////////////////////////////////
    [
        uuid(EC7E0760-4C76-11D2-8ADE-00A0C98E6527),
        helpstring("ChromaPP Class")
    ]
    coclass DXTChromaPP
    {
        interface IUnknown;
    };

    /////////////////////////////////
    // DXTDropShadow Class
    /////////////////////////////////
    [
        uuid(ADC6CB86-424C-11D2-952A-00C04FA34F05),
        helpstring("DropShadow Class")
    ]
    coclass DXTDropShadow
    {
        [default] interface IDXTDropShadow;
    };

    /////////////////////////////////
    // DXTDropShadow Property Page
    /////////////////////////////////
    [
        uuid(EC7E0761-4C76-11D2-8ADE-00A0C98E6527),
        helpstring("DropShadowPP Class")
    ]
    coclass DXTDropShadowPP
    {
        interface IUnknown;
    };


//+-----------------------------------------------------------------------------
//
//  DXTCheckerBoard Class
//
//------------------------------------------------------------------------------

    [
        uuid(B3EE7802-8224-4787-A1EA-F0DE16DEABD3),
        helpstring("DXTCheckerBoard Class")
    ]
    coclass DXTCheckerBoard
    {
        [default] interface IDXTCheckerBoard;
    };


//+-----------------------------------------------------------------------------
//
//  DXTCheckerBoard Property Page
//
//------------------------------------------------------------------------------

    [
        uuid(CBF47525-98D2-45ea-B843-FD213D932B10),
        helpstring("DXTCheckerBoardPP Class")
    ]
    coclass DXTCheckerBoardPP
    {
        interface IUnknown;
    };


//+-----------------------------------------------------------------------------
//
//  DXTRevealTrans Class
//
//------------------------------------------------------------------------------

    [
        uuid(E31E87C4-86EA-4940-9B8A-5BD5D179A737),
        helpstring("DXTRevealTrans Class")
    ]
    coclass DXTRevealTrans
    {
        [default] interface IDXTRevealTrans;
    };


//+-----------------------------------------------------------------------------
//
//  DXTMaskFilter Class
//
//------------------------------------------------------------------------------

    [
        uuid(3A04D93B-1EDD-4f3f-A375-A03EC19572C4),
        helpstring("DXTMaskFilter Class")
    ]
    coclass DXTMaskFilter
    {
        [default] interface IDXTMask;
    };


//+-----------------------------------------------------------------------------
//
//  DXTRedirect Class
//
//------------------------------------------------------------------------------

    [
        uuid(42B07B28-2280-4937-B035-0293FB812781),
        helpstring("DXTRedirect Class")
    ]
    coclass DXTRedirect
    {
        [default] interface IDXTRedirect;
    };


//+-----------------------------------------------------------------------------
//
//  DXTAlphaImageLoader Class
//
//------------------------------------------------------------------------------

    [
        uuid(0C7EFBDE-0303-4C6F-A4F7-31FA2BE5E397),
        helpstring("DXTAlphaImageLoader Class")
    ]
    coclass DXTAlphaImageLoader
    {
        [default] interface IDXTAlphaImageLoader;
    };

      
//+-----------------------------------------------------------------------------
//
//  DXTAlphaImageLoader Property Page
//
//------------------------------------------------------------------------------

    [
        uuid(8C80CE2D-850D-47DA-8ECD-55023562D167),
        helpstring("DXTAlphaImageLoader Property Page")
    ]
    coclass DXTAlphaImageLoaderPP
    {
        interface IUnknown;
    };


//+-----------------------------------------------------------------------------
//
//  DXTRandomDissolve Class
//
//------------------------------------------------------------------------------

    [
        uuid(F7F4A1B6-8E87-452F-A2D7-3077F508DBC0),
        helpstring("DXTRandomDissolve Class")
    ]
    coclass DXTRandomDissolve
    {
        [default] interface IDXEffect;
    };


//+-----------------------------------------------------------------------------
//
//  DXTRandomBars Class
//
//------------------------------------------------------------------------------

    [
        uuid(2E7700B7-27C4-437F-9FBF-1E8BE2817566),
        helpstring("DXTRandomBars Class")
    ]
    coclass DXTRandomBars
    {
        [default] interface IDXTRandomBars;
    };
        

//+-----------------------------------------------------------------------------
//
//  DXTRandomBars Property Page
//
//------------------------------------------------------------------------------

    [
        uuid(E3E6AE11-7FDC-40C4-AFBF-1DCEA82862CC),
        helpstring("DXTRandomBars Property Page")
    ]
    coclass DXTRandomBarsPP
    {
        [default] interface IUnknown;
    };


//+-----------------------------------------------------------------------------
//
//  DXTStrips Class
//
//------------------------------------------------------------------------------

    [
        uuid(63A4B1FC-259A-4A5B-8129-A83B8C9E6F4F),
        helpstring("DXTStrips Class")
    ]
    coclass DXTStrips
    {
        [default] interface IDXTStrips;
    };


//+-----------------------------------------------------------------------------
//
//  DXTStrips Property Page
//
//------------------------------------------------------------------------------

    [
        uuid(FEC0B7EE-7AEC-4067-9EE1-FACFB7CE9AF9),
        helpstring("DXTStrips Property Page")
    ]
    coclass DXTStripsPP
    {
        interface IUnknown;
    };


    /////////////////////////////////
    // DXTMetaRoll Class
    /////////////////////////////////
	[
		uuid(9C61F46E-0530-11D2-8F98-00C04FB92EB7),
		helpstring("MetaCreations Roll")
	]
	coclass DXTMetaRoll
	{
		[default] interface IDXTMetaRoll;
	};


    /////////////////////////////////
    // DXTMetaRipple Class
    /////////////////////////////////
	[
		uuid(AA0D4D03-06A3-11D2-8F98-00C04FB92EB7),
		helpstring("MetaCreations Ripple")
	]
	coclass DXTMetaRipple
	{
		[default] interface IDXTMetaRipple;
	};


    /////////////////////////////////
    // DXTMetaPageTurn Class
    /////////////////////////////////
	[
		uuid(AA0D4D08-06A3-11D2-8F98-00C04FB92EB7),
		helpstring("MetaCreations PageTurn")
	]
	coclass DXTMetaPageTurn
	{
		[default] interface IDXTMetaPageTurn;
	};


    /////////////////////////////////
    // DXTMetaLiquid Class
    /////////////////////////////////
	[
		uuid(AA0D4D0A-06A3-11D2-8F98-00C04FB92EB7),
		helpstring("MetaCreations Liquid")
	]
	coclass DXTMetaLiquid
	{
		[default] interface IDXTMetaLiquid;
	};


    /////////////////////////////////
    // DXTMetaCenterPeel Class
    /////////////////////////////////
	[
		uuid(AA0D4D0C-06A3-11D2-8F98-00C04FB92EB7),
		helpstring("MetaCreations CenterPeel")
	]
	coclass DXTMetaCenterPeel
	{
		[default] interface IDXTMetaCenterPeel;
	};


    /////////////////////////////////
    // DXTMetaPeelSmall Class
    /////////////////////////////////
	[
		uuid(AA0D4D0E-06A3-11D2-8F98-00C04FB92EB7),
		helpstring("MetaCreations PeelSmall")
	]
	coclass DXTMetaPeelSmall
	{
		[default] interface IDXTMetaPeelSmall;
	};


    /////////////////////////////////
    // DXTMetaPeelPiece Class
    /////////////////////////////////
	[
		uuid(AA0D4D10-06A3-11D2-8F98-00C04FB92EB7),
		helpstring("MetaCreations PeelPiece")
	]
	coclass DXTMetaPeelPiece
	{
		[default] interface IDXTMetaPeelPiece;
	};


    /////////////////////////////////
    // DXTMetaPeelSplit Class
    /////////////////////////////////
	[
		uuid(AA0D4D12-06A3-11D2-8F98-00C04FB92EB7),
		helpstring("MetaCreations PeelSplit")
	]
	coclass DXTMetaPeelSplit
	{
		[default] interface IDXTMetaPeelSplit;
	};


    /////////////////////////////////
    // DXTMetaWater Class
    /////////////////////////////////
	[
		uuid(107045C5-06E0-11D2-8D6D-00C04F8EF8E0),
		helpstring("DXTMetaWater Class")
	]
	coclass DXTMetaWater
	{
		[default] interface IDXTMetaWater;
	};


    /////////////////////////////////
    // DXTMetaLightWipe Class
    /////////////////////////////////
	[
		uuid(107045C8-06E0-11D2-8D6D-00C04F8EF8E0),
		helpstring("DXTMetaLightWipe Class")
	]
	coclass DXTMetaLightWipe
	{
		[default] interface IDXTMetaLightWipe;
	};


    /////////////////////////////////
    // DXTMetaRadialScaleWipe Class
    /////////////////////////////////
	[
		uuid(107045CA-06E0-11D2-8D6D-00C04F8EF8E0),
		helpstring("DXTMetaRadialScaleWipe Class")
	]
	coclass DXTMetaRadialScaleWipe
	{
		[default] interface IDXTMetaRadialScaleWipe;
	};


    /////////////////////////////////
    // DXTMetaWhiteOut Class
    /////////////////////////////////
	[
		uuid(107045CC-06E0-11D2-8D6D-00C04F8EF8E0),
		helpstring("DXTMetaWhiteOut Class")
	]
	coclass DXTMetaWhiteOut
	{
		[default] interface IDXTMetaWhiteOut;
	};


    /////////////////////////////////
    // DXTMetaTwister Class
    /////////////////////////////////
	[
		uuid(107045CF-06E0-11D2-8D6D-00C04F8EF8E0),
		helpstring("DXTMetaTwister Class")
	]
	coclass DXTMetaTwister
	{
		[default] interface IDXTMetaTwister;
	};


    /////////////////////////////////
    // DXTMetaBurnFilm Class
    /////////////////////////////////
	[
		uuid(107045D1-06E0-11D2-8D6D-00C04F8EF8E0),
		helpstring("DXTMetaBurnFilm Class")
	]
	coclass DXTMetaBurnFilm
	{
		[default] interface IDXTMetaBurnFilm;
	};


    /////////////////////////////////
    // DXTMetaJaws Class
    /////////////////////////////////
	[
		uuid(2A54C904-07AA-11D2-8D6D-00C04F8EF8E0),
		helpstring("DXTMetaJaws Class")
	]
	coclass DXTMetaJaws
	{
		[default] interface IDXTMetaJaws;
	};


    /////////////////////////////////
    // DXTMetaColorFade Class
    /////////////////////////////////
	[
		uuid(2A54C908-07AA-11D2-8D6D-00C04F8EF8E0),
		helpstring("DXTMetaColorFade Class")
	]
	coclass DXTMetaColorFade
	{
		[default] interface IDXTMetaColorFade;
	};


    /////////////////////////////////
    // DXTMetaFlowMotion Class
    /////////////////////////////////
	[
		uuid(2A54C90B-07AA-11D2-8D6D-00C04F8EF8E0),
		helpstring("DXTMetaFlowMotion Class")
	]
	coclass DXTMetaFlowMotion
	{
		[default] interface IDXTMetaFlowMotion;
	};


    /////////////////////////////////
    // DXTMetaVacuum Class
    /////////////////////////////////
	[
		uuid(2A54C90D-07AA-11D2-8D6D-00C04F8EF8E0),
		helpstring("DXTMetaVacuum Class")
	]
	coclass DXTMetaVacuum
	{
		[default] interface IDXTMetaVacuum;
	};


    /////////////////////////////////
    // DXTMetaGriddler Class
    /////////////////////////////////
	[
		uuid(2A54C911-07AA-11D2-8D6D-00C04F8EF8E0),
		helpstring("DXTMetaGriddler Class")
	]
	coclass DXTMetaGriddler
	{
		[default] interface IDXTMetaGriddler;
	};


    /////////////////////////////////
    // DXTMetaGriddler2 Class
    /////////////////////////////////
	[
		uuid(2A54C913-07AA-11D2-8D6D-00C04F8EF8E0),
		helpstring("DXTMetaGriddler2 Class")
	]
	coclass DXTMetaGriddler2
	{
		[default] interface IDXTMetaGriddler2;
	};


    /////////////////////////////////
    // DXTMetaThreshold Class
    /////////////////////////////////
	[
		uuid(2A54C915-07AA-11D2-8D6D-00C04F8EF8E0),
		helpstring("DXTMetaThreshold Class")
	]
	coclass DXTMetaThreshold
	{
		[default] interface IDXTMetaThreshold;
	};


    /////////////////////////////////
    // DXTMetaWormHole Class
    /////////////////////////////////
	[
		uuid(0E6AE022-0C83-11D2-8CD4-00104BC75D9A),
		helpstring("DXTMetaWormHole Class")
	]
	coclass DXTMetaWormHole
	{
		[default] interface IDXTMetaWormHole;
	};

    /////////////////////////////////
    // DXTGlow Class
    /////////////////////////////////
    [
        uuid(9F8E6421-3D9B-11D2-952A-00C04FA34F05),
        helpstring("DXTGlow Class")
    ]
    coclass DXTGlow
    {
        [default] interface IDXTGlow;
    };

    /////////////////////////////////
    // DXTShadow Class
    /////////////////////////////////
    [
        uuid(E71B4063-3E59-11D2-952A-00C04FA34F05),
        helpstring("DXTShadow Class")
    ]
    coclass DXTShadow
    {
        [default] interface IDXTShadow;
    };

    /////////////////////////////////
    // DXTAlpha Class
    /////////////////////////////////
    [
        uuid(ADC6CB82-424C-11D2-952A-00C04FA34F05),
        helpstring("DXTAlpha Class")
    ]
    coclass DXTAlpha
    {
        [default] interface IDXTAlpha;
    };

    /////////////////////////////////
    // DXTWave Class
    /////////////////////////////////
    [
        uuid(ADC6CB88-424C-11D2-952A-00C04FA34F05),
        helpstring("DXTWave Class")
    ]
    coclass DXTWave
    {
        [default] interface IDXTWave;
    };

    /////////////////////////////////
    // DXTLight Class
    /////////////////////////////////
    [
        uuid(F9EFBEC2-4302-11D2-952A-00C04FA34F05),
        helpstring("DXTLight Class")
    ]
    coclass DXTLight
    {
        [default] interface IDXTLight;
    };

    /////////////////////////////////
    // DXTAlphaPP Class
    /////////////////////////////////
    [
        uuid(D687A7E0-4BA4-11D2-8ADE-00A0C98E6527),
        helpstring("DXTAlphaPP Class")
    ]
    coclass DXTAlphaPP
    {
        interface IUnknown;
    };
    /////////////////////////////////
    // DXTGlowPP Class
    /////////////////////////////////
    [
        uuid(EC7E0764-4C76-11D2-8ADE-00A0C98E6527),
        helpstring("DXTGlowPP Class")
    ]
    coclass DXTGlowPP
    {
        interface IUnknown;
    };
    /////////////////////////////////
    // DXTShadowPP Class
    /////////////////////////////////
    [
        uuid(EC7E0765-4C76-11D2-8ADE-00A0C98E6527),
        helpstring("DXTShadowPP Class")
    ]
    coclass DXTShadowPP
    {
        interface IUnknown;
    };
    /////////////////////////////////
    // DXTWavePP Class
    /////////////////////////////////
    [
        uuid(F12456C0-4C9E-11D2-8ADE-00A0C98E6527),
        helpstring("DXTWavePP Class")
    ]
    coclass DXTWavePP
    {
        interface IUnknown;
    };
    /////////////////////////////////
    // DXTLightPP Class
    /////////////////////////////////
    [
        uuid(694AF25F-124D-11d3-91D5-00C04F8EFB69),
        helpstring("DXTLightPP Class")
    ]
    coclass DXTLightPP
    {
        interface IUnknown;
    };


//+-----------------------------------------------------------------------------
//
//  DXTMotionBlur class
//
//------------------------------------------------------------------------------

    [
        uuid(DD13DE77-D3BA-42D4-B5C6-7745FA4E2D4B),
        helpstring("DXTMotionBlur Class")
    ]
    coclass DXTMotionBlur
    {
        [default] interface IDXTMotionBlur;
    };


//+-----------------------------------------------------------------------------
//
//  DXTMotionBlur property page
//
//------------------------------------------------------------------------------

    [
        uuid(926433E1-7F8F-4BC6-BEC4-8C126C6B7DC4),
        helpstring("DXTMotionBlurPP Class")
    ]
    coclass DXTMotionBlurPP
    {
        interface IUnknown;
    };


//+-----------------------------------------------------------------------------
//
//  DXTMatrix class
//
//------------------------------------------------------------------------------

    [
        uuid(4ABF5A06-5568-4834-BEE3-327A6D95A685),
        helpstring("DXTMatrix Class")
    ]
    coclass DXTMatrix
    {
        [default] interface IDXTMatrix;
    };


//+-----------------------------------------------------------------------------
//
//  DXTMatrixPP class
//
//------------------------------------------------------------------------------

    [
        uuid(C591103A-B3A8-4D47-A3F7-2AEEE4B8013F),
        helpstring("DXTMatrixPP Class")
    ]
    coclass DXTMatrixPP
    {
        interface IUnknown;
    };


//+-----------------------------------------------------------------------------
//
//  DXTICMFilter class
//
//------------------------------------------------------------------------------

    [
        uuid(A1BFB370-5A9F-4429-BB72-B13E2FEAEDEF),
        helpstring("DXTICMFilter Class")
    ]
    coclass DXTICMFilter
    {
        [default] interface IDXTICMFilter;
    };


//+-----------------------------------------------------------------------------
//
//  DXTICMFilterPP class
//
//------------------------------------------------------------------------------

    [
        uuid(1958FB12-31E6-47E5-AA49-B23D12C853E6),
        helpstring("DXTICMFilterPP Class")
    ]
    coclass DXTICMFilterPP
    {
        interface IUnknown;
    };


}; // End of library block