/*****************************************************************************
* 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 =============================================================

//=== 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);
    [propput, id(DISPID_EndColorStr)] 
        HRESULT EndColorStr([in] BSTR newVal);
};

//--- 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 -------------------------------------------------
typedef enum DXWIPEDIRECTION
{
    DXWD_HORIZONTAL,
    DXWD_VERTICAL
} DXWIPEDIRECTION;

typedef enum DXWIPEDISPID
{
    DISPID_DXW_GradientSize = DISPID_DXE_NEXT_ID,
    DISPID_DXW_WipeStyle
} 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 );
};

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

//************************************************************
//
// 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
//
//************************************************************
    [
        object,
        uuid(276A2EE0-0B5D-11d2-A484-00C04F8EFB69),
        dual,
        helpstring("ICrBarn Interface"),
        pointer_default(unique)
    ]
    interface ICrBarn : IDXEffect
    {
    };

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

//************************************************************
//
// 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);
	};

//************************************************************
//
// ICrSpiral Interface
//
//************************************************************
	[
		object,
		uuid(0DE527A0-0C7E-11d2-A484-00C04F8EFB69),
		dual,
		helpstring("ICrSpiral Interface"),
		pointer_default(unique)
	]
	interface ICrSpiral : 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);
	};

//************************************************************
//
// ICrZigzag Interface
//
//************************************************************
	[
		object,
		uuid(4E5A64A0-0C8B-11d2-A484-00C04F8EFB69),
		dual,
		helpstring("ICrZigzag Interface"),
		pointer_default(unique)
	]
	interface ICrZigzag : 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);
	};

//************************************************************
//
// 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);
    };

//************************************************************
//
// 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);
	};

//=== CoClass definitions =================================================
[
    uuid(5E77EB03-937C-11D1-B047-00AA003B6061),
    version(1.0),
    helpstring("DXTMsft 1.0 Type Library")
]
library DXTMSFTLib
{
    importlib("stdole32.tlb");
    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;
    };

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

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

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

    [
        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(7FFE4D08-FBFD-11d1-9A77-0000F8756A10),
        helpstring("DXTWipePP Class")
    ]
    coclass DXTWipePP
    {
        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
    /////////////////////////////////
    [
        uuid(3F69F351-0379-11D2-A484-00C04F8EFB69),
        helpstring("CrIris Class")
    ]
    coclass CrIris
    {
        [default] interface ICrIris;
    };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /////////////////////////////////
    // CrZigZag 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;
    };


    /////////////////////////////////
    // 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;
	};

}; // End of library block