idombrush.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2026 Hybrid Software Helix Ltd. All rights reserved.
 */
 
#ifndef EDLIDOMBRUSH_H
#define EDLIDOMBRUSH_H

 
#include <edl/edlnamespaces.h>
#include <edl/idomnode.h>
#include <edl/idomhashable.h>
#include <edl/edlfwd.h>
#include <jawsmako/optionalcontent.h>
 
#include <edl/edltypes.h>
#include <edl/idomnode.h>
#include <edl/iedlenum.h>
#include <edl/idomcolor.h>
#include <edl/idomfunction.h>
#include <edl/idomimageresource.h>
#include <edl/idomgroup.h>
 
_BEGIN_EDL_DOM_NAMESPACE

class IDOMBrush : public IEDLObject
{
  public:
    typedef enum
    {
        eSolidColor,             
        eLinearGradient,         
        eRadialGradient,         
        eImage,                       
        eMasked,                 
        eVisual,                 
        eSoftMask,                 
        eTilingPattern,               
        eType1ShadingPattern,       
        eType2ShadingPattern,       
        eType3ShadingPattern,       
        eType4567ShadingPattern, 
        eNull                      
    } eBrushType;

    virtual eBrushType getBrushType() const = 0;

    virtual float getOpacity() const = 0;

    virtual void setOpacity(float opc) = 0;

    virtual IDOMBrushPtr getAdjustedForUseInTransformedNode(IEDLClassFactory *pFactory, const FMatrix &nodeTransform);
};
#define edlobj2IDOMBrush(src) edl_cast((IDOMBrush *)NULL, src)
 
template <class T, IDOMBrush::eBrushType BT>
static inline CSmartPtr<T> dom2BrushType(const IDOMBrushPtr &src)
{
    if (src && src->getBrushType() == BT)
    {
        return CSmartPtr<T>(static_cast<T *>((IDOMBrush *)src), true);
    }
    else
    {
        return CSmartPtr<T>();
    }
}

class IDOMTransformableBrush : public IDOMBrush
{
  public:
    virtual const FMatrix &getRenderTransform() const = 0;

    virtual void setRenderTransform(const FMatrix &matrix) = 0;
};
#define edlobj2IDOMTransformableBrush(src) edl_cast((IDOMTransformableBrush *)NULL, src)
static inline IDOMTransformableBrushPtr dom2IDOMTransformableBrush(const IDOMBrushPtr &src)
{
    if (src)
    {
        switch (src->getBrushType())
        {
            case IDOMBrush::eSolidColor:
            case IDOMBrush::eNull:
                return IDOMTransformableBrushPtr();
            default:
                return IDOMTransformableBrushPtr(static_cast<IDOMTransformableBrush *>((IDOMBrush *) src), true);
        }
    }
    else
    {
        return nullptr;
    }
}

class IDOMGradientStop : public IEDLObject
{
#define IDOMGradientStopClassID 0x5c788994, 0xc0bb4387, 0x96ff4086, 0x874b16db
  public:

    static EDL_API IDOMGradientStopPtr create(IEDLClassFactory *pFactory, const IDOMColorPtr &color, double offset);

    class Data : public CClassParams
    {
      public:
        double offset;
        IDOMColorPtr color;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMGradientStopClassID);
        return id;
    };

    virtual IDOMColorPtr getColor() const = 0;

    virtual void setColor(const IDOMColorPtr &color) = 0;

    virtual double getOffset() const = 0;

    virtual void setOffset(double offset) = 0;
 
};
#define edlobj2IDOMGradientStop(src) edl_cast((IDOMGradientStop *)NULL, src)
typedef CEDLVector<IDOMGradientStopPtr> CDOMGradientStopVect;
 

class IDOMSolidColorBrush : public IDOMBrush, public IDOMHashable
{
#define IDOMSolidColorBrushClassID 0x9dc4c01e, 0x8fe545f7, 0xa51b15c6, 0xed751103
  public:

    static EDL_API IDOMSolidColorBrushPtr create(IEDLClassFactory *pFactory, const IDOMColorPtr &color, float opacity = 1.0f);

    static IDOMSolidColorBrushPtr createSolidGray(IEDLClassFactory *pFactory, float gray = 0.0f)
    {
        return IDOMSolidColorBrush::create(pFactory, IDOMColor::createSolidGray(pFactory, gray));
    }

    static IDOMSolidColorBrushPtr createSolidRgb(IEDLClassFactory *pFactory, float r = 0.0f, float g = 0.0f, float b = 0.0f)
    {
        return IDOMSolidColorBrush::create(pFactory, IDOMColor::createSolidRgb(pFactory, r, g, b));
    }

    static IDOMSolidColorBrushPtr createSolidCmyk(IEDLClassFactory *pFactory, float c = 0.0f, float m = 0.0f, float y = 0.0f, float k = 0.0f)
    {
        return IDOMSolidColorBrush::create(pFactory, IDOMColor::createSolidCmyk(pFactory, c, m, y, k));
    }

    static EDL_API IDOMSolidColorBrushPtr createWithSpaceAndComponents(IEDLClassFactory *pFactory, const IDOMColorSpacePtr &space, double opacity,
                                        double component1,        double component2  = 0.0, double component3  = 0.0, double component4  = 0.0, double component5  = 0.0,
                                        double component6  = 0.0, double component7  = 0.0, double component8  = 0.0, double component9  = 0.0, double component10 = 0.0,
                                        double component11 = 0.0, double component12 = 0.0, double component13 = 0.0, double component14 = 0.0, double component15 = 0.0,
                                        double component16 = 0.0, double component17 = 0.0, double component18 = 0.0, double component19 = 0.0, double component20 = 0.0,
                                        double component21 = 0.0, double component22 = 0.0, double component23 = 0.0, double component24 = 0.0, double component25 = 0.0,
                                        double component26 = 0.0, double component27 = 0.0, double component28 = 0.0, double component29 = 0.0, double component30 = 0.0,
                                        double component31 = 0.0, double component32 = 0.0
                                    );

    static EDL_API IDOMSolidColorBrushPtr createWithSpaceAndComponentsFromVect(IEDLClassFactory *pFactory, const IDOMColorSpacePtr &space, float opacity, const CEDLVector<float> &components);
 
#ifdef SWIG
#if SWIGJAVA
    %apply float[] { const float *components };
#endif
#if SWIGCSHARP
    %apply float INPUT[] { const float *components };
#endif
#endif
    static EDL_API IDOMSolidColorBrushPtr createWithSpaceAndComponentsFromArray(IEDLClassFactory *pFactory, const IDOMColorSpacePtr &space, float opacity, const float *components);
#ifdef SWIG
    %clear const float *components;
#endif

    class Data : public CClassParams
    {
      public:
        Data(): opacity(1.0)
        {}
        float opacity;
        IDOMColorPtr color;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMSolidColorBrushClassID);
        return id;
    };

    virtual IDOMColorPtr getColor() const = 0;

    virtual void setColor(const IDOMColorPtr &color) = 0;
 
};
#define edlobj2IDOMSolidColorBrush(src) edl_cast((IDOMSolidColorBrush *)NULL, src)
#define dom2IDOMSolidColorBrush(src) dom2BrushType<IDOMSolidColorBrush, IDOMBrush::eSolidColor>(src)
 

typedef enum
{
    eSRgbLinearInterpolation,   
    eSCRgbLinearInterpolation   
} eColorInterpolationMode;

typedef enum
{
    ePad,       
    eReflect,   
    eRepeat,    
    eNoSpread   
} eSpreadMethod;

class IDOMGradientBrush : public IDOMTransformableBrush
{
  public:
    virtual eColorInterpolationMode getColorInterpolationMode() const = 0;

    virtual void setColorInterpolationMode(eColorInterpolationMode cim) = 0;

    virtual eSpreadMethod getSpreadMethod() const = 0;

    virtual void setSpreadMethod(eSpreadMethod sm) = 0;

    virtual void setGradientStops(const CDOMGradientStopVect &stops) = 0;

    virtual const CDOMGradientStopVect &getGradientStops() const = 0;

    virtual void addGradientStop(const IDOMGradientStopPtr &ptrGradientStop) = 0;

    virtual void normalizeStops(IEDLClassFactory *pFactory, const IDOMColorSpacePtr &ptrColorSpace = IDOMColorSpacePtr(),
                                eRenderingIntent intent = eRelativeColorimetric, eBlackPointCompensation bpc = eBPCDefault) = 0;
};
#define edlobj2IDOMGradientBrush(src) edl_cast((IDOMGradientBrush *)NULL, src)
static inline IDOMGradientBrushPtr dom2IDOMGradientBrush(const IDOMBrushPtr &src)
{
    if (src)
    {
        switch (src->getBrushType())
        {
            case IDOMBrush::eLinearGradient:
            case IDOMBrush::eRadialGradient:
                return IDOMGradientBrushPtr(static_cast<IDOMGradientBrush *>((IDOMBrush *)src), true);
            default:
                return IDOMGradientBrushPtr();
        }
    }
    else
    {
        return IDOMGradientBrushPtr();
    }
}

class IDOMLinearGradientBrush : public IDOMGradientBrush, public IDOMHashable
{
#define IDOMLinearGradientBrushClassID 0x59493763, 0x87084cf5, 0x8033bfd1, 0x0740e0f2
  public:

    static EDL_API IDOMLinearGradientBrushPtr create(IEDLClassFactory *pFactory,
                                                     const FPoint &startPoint, const FPoint &endPoint,
                                                     const CDOMGradientStopVect &stops, float opacity = 1.0f,
                                                     const FMatrix &renderTransform = FMatrix(),
                                                     eSpreadMethod spreadMethod = eNoSpread,
                                                     eColorInterpolationMode colorInterpolationMode = eSRgbLinearInterpolation);

    class Data : public CClassParams
    {
      public:
        Data(): opacity(1.0), colorInterpolationMode(eSRgbLinearInterpolation), spreadMethod(ePad)
        {}
        float opacity;
        FPoint startPoint;
        FPoint endPoint;
        CDOMGradientStopVect stops;
        eColorInterpolationMode colorInterpolationMode;
        eSpreadMethod spreadMethod;
        FMatrix renderTransform;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMLinearGradientBrushClassID);
        return id;
    };

    virtual const FPoint &getStartPoint() const = 0;

    virtual void setStartPoint(const FPoint &pt) = 0;

    virtual const FPoint &getEndPoint() const = 0;

    virtual void setEndPoint(const FPoint &pt) = 0;

    virtual IDOMShadingPatternType2BrushPtr createShading(IEDLClassFactory *pFactory,
                                                          bool ignoreSpreadMethod,
                                                          bool useFirstStopColorSpace) = 0;

    virtual IDOMBrushPtr createPdfBrush(IEDLClassFactory *pFactory, bool useFirstStopColorSpace = false) = 0;
};
#define edlobj2IDOMLinearGradientBrush(src) edl_cast((IDOMLinearGradientBrush *)NULL, src)
#define dom2IDOMLinearGradientBrush(src) dom2BrushType<IDOMLinearGradientBrush, IDOMBrush::eLinearGradient>(src)
 

class IDOMRadialGradientBrush : public IDOMGradientBrush, public IDOMHashable
{
#define IDOMRadialGradientBrushClassID 0xfd36410b, 0x387f4656, 0x9c2c276f, 0xcba05c91
  public:

    static EDL_API IDOMRadialGradientBrushPtr create(IEDLClassFactory *pFactory,
                                                     const FPoint &center, const FPoint &gradientOrigin,
                                                     double radiusX, double radiusY,
                                                     const CDOMGradientStopVect &stops, float opacity = 1.0f,
                                                     const FMatrix &renderTransform = FMatrix(),
                                                     eSpreadMethod spreadMethod = eNoSpread,
                                                     eColorInterpolationMode colorInterpolationMode = eSRgbLinearInterpolation);

    class Data : public CClassParams
    {
      public:
        Data(): opacity(1.0), spreadMethod(ePad), colorInterpolationMode(eSRgbLinearInterpolation),
                radiusX (0.0), radiusY (0.0)
        {}
        float opacity;
        eColorInterpolationMode colorInterpolationMode;
        eSpreadMethod spreadMethod;
        FPoint center;
        FPoint gradientOrigin;
        double radiusX;
        double radiusY;
        CDOMGradientStopVect stops;
        FMatrix renderTransform;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMRadialGradientBrushClassID);
        return id;
    };
 

    virtual const FPoint &getCenter() const = 0;

    virtual void setCenter(const FPoint &pt) = 0;

    virtual const FPoint &getGradientOrigin() const = 0;

    virtual void setGradientOrigin(const FPoint &pt) = 0;

    virtual double getRadiusX() const = 0;

    virtual void setRadiusX(double r) = 0;

    virtual double getRadiusY() const = 0;

    virtual void setRadiusY(double r) = 0;

    virtual IDOMShadingPatternType3BrushPtr createShading(IEDLClassFactory *pFactory, const FRect &fillArea, bool useFirstStopColorSpace = false) = 0;

    virtual IDOMRadialGradientBrushPtr getSimplifiedGradient(IEDLClassFactory *pFactory, const FRect &fillArea) = 0;
 
};
#define edlobj2IDOMRadialGradientBrush(src) edl_cast((IDOMRadialGradientBrush *)NULL, src)
#define dom2IDOMRadialGradientBrush(src) dom2BrushType<IDOMRadialGradientBrush, IDOMBrush::eRadialGradient>(src)
 

typedef enum
{
    eAbsolute      
} eViewUnits;

typedef enum
{
    eNoTile,    
    eTile,      
    eFlipX,     
    eFlipY,     
    eFlipXY     
} eTilingMode;
 

class IDOMImageBrush : public IDOMTransformableBrush, public IDOMHashable
{
#define IDOMImageBrushClassID 0xebe9f8fd, 0xc5c34d21, 0xae76465a, 0x4b4e64a0
  public:

    static EDL_API IDOMImageBrushPtr create(IEDLClassFactory *pFactory,
                                            const IDOMImagePtr &image,
                                            const FRect &viewBox, const FRect &viewPort,
                                            const FMatrix &renderTransform = FMatrix(),
                                            float opacity = 1.0f,
                                            eTilingMode tileMode = eNoTile,
                                            const CDOMAlternateImageVect &alternateImages = CDOMAlternateImageVect(),
                                            const JawsMako::IOptionalContentDetailsPtr &optionalContentDetails =         JawsMako::IOptionalContentDetailsPtr(),
                                            const JawsMako::IPDFDictionaryPtr &propertiesDictionary = JawsMako::IPDFDictionaryPtr());

    class Data : public CClassParams
    {
      public:
        Data(): opacity(1.0), tileMode(eNoTile), viewBoxUnits(eAbsolute), viewPortUnits(eAbsolute)
        {
        }
        float                                opacity;
        FRect                                viewBox;
        FRect                                viewPort;
        eTilingMode                          tileMode;
        eViewUnits                           viewBoxUnits;
        eViewUnits                           viewPortUnits;
        IDOMImagePtr                         ptrImageSource;
        IDOMICCProfilePtr                    ptrICCProfile;
        FMatrix                              renderTransform;
        JawsMako::IOptionalContentDetailsPtr optionalContentDetails;
        CDOMAlternateImageVect               alternateImages;
        JawsMako::IPDFDictionaryPtr          propertiesDictionary;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageBrushClassID);
        return id;
    };

    virtual eTilingMode getTileMode() const = 0;

    virtual void setTileMode(eTilingMode tm) = 0;

    virtual eViewUnits getViewBoxUnits() const = 0;

    virtual void setViewBoxUnits(eViewUnits vu) = 0;

    virtual eViewUnits getViewPortUnits() const = 0;

    virtual void setViewPortUnits(eViewUnits vu) = 0;

    virtual const FRect &getViewBox() const = 0;

    virtual void setViewBox(const FRect &vb) = 0;

    virtual const FRect &getViewPort() const = 0;

    virtual void setViewPort(const FRect &vp) = 0;

    virtual IDOMICCProfilePtr getICCProfile() const = 0;

    virtual void setICCProfile(const IDOMICCProfilePtr &icc) = 0;

    virtual IDOMImagePtr getImageSource() const = 0;

    virtual void setImageSource(const IDOMImagePtr &ptrImageSource) = 0;

    virtual CDOMAlternateImageVect getAlternateImages() const = 0;

    virtual void setAlternateImages(const CDOMAlternateImageVect &alternates) = 0;

    virtual JawsMako::IOptionalContentDetailsPtr getOptionalContentDetails() const = 0;

    virtual void setOptionalContentDetails(const JawsMako::IOptionalContentDetailsPtr &details) = 0;

    virtual JawsMako::IPDFDictionaryPtr getPdfPropertiesDictionary() const = 0;

    virtual void setPdfPropertiesDictionary(const JawsMako::IPDFDictionaryPtr &propertiesDictionary) = 0;

    virtual IDOMTilingPatternBrushPtr getEquivalentTilingBrush(IEDLClassFactory *pFactory) = 0;

    virtual IDOMVisualBrushPtr getEquivalentVisualBrush(IEDLClassFactory *pFactory) = 0;
};
#define edlobj2IDOMImageBrush(src) edl_cast((IDOMImageBrush *)NULL, src)
static inline IDOMImageBrushPtr dom2IDOMImageBrush(const IDOMBrushPtr &src)
{
    if (src)
    {
        switch (src->getBrushType())
        {
            case IDOMBrush::eImage:
            case IDOMBrush::eMasked:
                return IDOMImageBrushPtr(static_cast<IDOMImageBrush *>((IDOMBrush *)src), true);
            default:
                return IDOMImageBrushPtr();
        }
    }
    else
    {
        return IDOMImageBrushPtr();
    }
}

class IDOMMaskedBrush : public IDOMImageBrush
{
#define IDOMMaskedBrushClassID 0x8EC7F5C6, 0xC56049d1, 0x9E2864EB, 0x0E7A90A6
  public:

    static EDL_API IDOMMaskedBrushPtr create(IEDLClassFactory *pFactory,
                                             const IDOMImagePtr &mask,
                                             const IDOMBrushPtr &brush,
                                             const FRect &viewBox, const FRect &viewPort,
                                             const FMatrix &renderTransform = FMatrix(),
                                             float opacity = 1.0f,
                                             const CDOMAlternateImageVect &alternateImages = CDOMAlternateImageVect(),
                                             const JawsMako::IOptionalContentDetailsPtr &optionalContentDetails =
                                                JawsMako::IOptionalContentDetailsPtr(),
                                             const JawsMako::IPDFDictionaryPtr &propertiesDictionary = JawsMako::IPDFDictionaryPtr());

    class Data : public CClassParams
    {
      public:
        Data(): opacity(1.0), viewBoxUnits(eAbsolute), viewPortUnits(eAbsolute)
        {
        }
        float                                opacity;
        FRect                                viewBox;
        FRect                                viewPort;
        eViewUnits                           viewBoxUnits;
        eViewUnits                           viewPortUnits;
        IDOMImagePtr                         imageMask;
        IDOMBrushPtr                         brush;
        FMatrix                              renderTransform;
        JawsMako::IOptionalContentDetailsPtr optionalContentDetails;
        CDOMAlternateImageVect               alternateImages;
        JawsMako::IPDFDictionaryPtr          propertiesDictionary;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMMaskedBrushClassID);
        return id;
    };

    virtual IDOMBrushPtr getBrush () const = 0;

    virtual void setBrush (const IDOMBrushPtr &brush) = 0;

    virtual bool getIsSoftMask(IEDLClassFactory *pFactory) = 0;

    virtual IDOMBrushPtr getEquivalentXPSBrush(IEDLClassFactory *pFactory, const FRect &enclosedBounds) = 0;

    virtual IDOMImageBrushPtr getSimpleImageBrush(IEDLClassFactory *pFactory) = 0;
 
};
#define edlobj2IDOMMaskedBrush(src) edl_cast((IDOMMaskedBrush *)NULL, src)
#define dom2IDOMMaskedBrush(src) dom2BrushType<IDOMMaskedBrush, IDOMBrush::eMasked>(src)

class IDOMVisualBrush : public IDOMTransformableBrush
{
#define IDOMVisualBrushClassID 0xa811d50a, 0xfebd4be7, 0xa3901ac9, 0x0bd52265
  public:

    static EDL_API IDOMVisualBrushPtr create(IEDLClassFactory *pFactory,
                                             const IDOMNodePtr &visual,
                                             const FRect &viewBox, const FRect &viewPort,
                                             const FMatrix &renderTransform = FMatrix(),
                                             float opacity = 1.0f,
                                             eTilingMode tileMode = eNoTile);

    class Data : public CClassParams
    {
      public:
        Data(): opacity(1.0), tileMode(eNoTile), viewBoxUnits(eAbsolute), viewPortUnits(eAbsolute)
        {
        }
        float       opacity;
        FRect       viewBox;
        FRect       viewPort;
        eTilingMode tileMode;
        eViewUnits  viewBoxUnits;
        eViewUnits  viewPortUnits;
        IDOMNodePtr ptrVisual;
        FMatrix     renderTransform;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMVisualBrushClassID);
        return id;
    };

    virtual eTilingMode getTileMode() const = 0;

    virtual void setTileMode(eTilingMode tm) = 0;

    virtual eViewUnits getViewBoxUnits() const = 0;

    virtual void setViewBoxUnits(eViewUnits vu) = 0;

    virtual eViewUnits getViewPortUnits() const = 0;

    virtual void setViewPortUnits(eViewUnits vu) = 0;

    virtual const FRect &getViewBox() const = 0;

    virtual void setViewBox(const FRect &vb) = 0;

    virtual const FRect &getViewPort() const = 0;

    virtual void setViewPort(const FRect &vp) = 0;

    virtual IDOMNodePtr getVisual() const = 0;

    virtual void setVisual(const IDOMNodePtr &ptrVisual) = 0;

    virtual IDOMTilingPatternBrushPtr getEquivalentTilingBrush(IEDLClassFactory *pFactory) = 0;

    virtual IDOMVisualBrushPtr getEquivalentSimpleVisualBrush(IEDLClassFactory *pFactory) = 0;
};
 
#define edlobj2IDOMVisualBrush(src) edl_cast((IDOMVisualBrush *)NULL, src)
#define dom2IDOMVisualBrush(src) dom2BrushType<IDOMVisualBrush, IDOMBrush::eVisual>(src)
 

class IDOMVisualRoot : public IDOMNode
{
#define IDOMVisualRootClassID 0x2309ff5c, 0x29c64c63, 0xbf58de4d, 0x7819ee02
  public:

    static const CClassID &classID()
    {
        static CClassID id(IDOMVisualRootClassID);
        return id;
    }
 
   /*
    * @brief  Create a visual root node.
    *         Throws an IEDLError on failure.
    * @param  pFactory The factory to use.
    * @return @b IDOMVisualRootPtr The new visual root node.
    */
   static EDL_API IDOMVisualRootPtr create(IEDLClassFactory *pFactory);
 
};
#define edlobj2IDOMVisualRoot(src) edl_cast((IDOMVisualRoot *)NULL, src)
 

class IDOMSoftMaskBrush : public IDOMTransformableBrush
{
#define IDOMSoftMaskBrushClassID 0x27315fbf, 0x8f3246a9, 0x929eb580, 0x13f7955d
  public:
    typedef enum
    {
        eAlpha,
        eLuminosity
    } eSoftMaskType;

    static EDL_API IDOMSoftMaskBrushPtr create(IEDLClassFactory *pFactory,
                                               const IDOMTransparencyGroupPtr &group,
                                               eSoftMaskType type,
                                               const FMatrix &renderTransform = FMatrix(),
                                               const IDOMColorPtr &backdropColor = IDOMColorPtr(),
                                               const IDOMFunctionPtr &transfer = IDOMFunctionPtr());
    
    static EDL_API IDOMSoftMaskBrushPtr createFromBrushOpacity(IEDLClassFactory *pFactory,
                                                               const IDOMBrushPtr &opacityBrush,
                                                               const FRect &bounds,
                                                               const IDOMColorSpacePtr &graySpace = IDOMColorSpacePtr());

    class Data : public CClassParams
    {
      public:
        Data() : type(eAlpha), opacity(1.0)
        {
        }
        eSoftMaskType            type;
        float                    opacity;
        IDOMTransparencyGroupPtr group;
        IDOMColorPtr             backdropColor;
        IDOMFunctionPtr          transfer;
        FMatrix                  renderTransform;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMSoftMaskBrushClassID);
        return id;
    };

    virtual eSoftMaskType getSoftMaskType() const = 0;

    virtual IDOMTransparencyGroupPtr getGroup() const = 0;

    virtual IDOMColorPtr getBackdropColor() const = 0;

    virtual IDOMFunctionPtr getTransferFunction() const = 0;
 
};
 
#define edlobj2IDOMSoftMaskBrush(src) edl_cast((IDOMSoftMaskBrush *)NULL, src)
#define dom2IDOMSoftMaskBrush(src) dom2BrushType<IDOMSoftMaskBrush, IDOMBrush::eSoftMask>(src)
 

class IDOMTilingPatternBrush : public IDOMTransformableBrush
{
#define IDOMTilingPatternBrushClassID 0xE987B191, 0x552840e1, 0xAFA8EC97, 0x2C6EE3DC
  public:

    static EDL_API IDOMTilingPatternBrushPtr create(IEDLClassFactory *pFactory,
                                                    const IDOMNodePtr &visual, const FRect &bBox,
                                                    uint8 paintType, const IDOMColorPtr &color,
                                                    float xStep, float yStep,
                                                    uint8 tilingType = 1,
                                                    const FMatrix &renderTransform = FMatrix());

    class Data : public CClassParams
    {
      public:
        Data()
        {
            opacity     = 1.0f;
            paintType   = 0;
            patternType = 1;
            tilingType  = 1;
            opacity     = 1.0f;
            bBox        = FBox(0.0, 0.0, 1.0, 1.0);
            xstep       = 1;
            ystep       = 1;
            renderTransform = FMatrix();
        }
        float           opacity;
        uint8           patternType;
        FBox            bBox;
        float           xstep;
        float           ystep;
        uint8           paintType;
        uint8           tilingType;
        FMatrix         renderTransform;
 
        /* for uncolored patterns, these are the color to use for the
         * specific invocation of setpattern
         */
        IDOMColorPtr    patternColor;
 
        IDOMNodePtr     visual;
    };

    static const CClassID &classID()
    {
        static CClassID id (IDOMTilingPatternBrushClassID);
        return id;
    };

    virtual uint8 getPatternType () const = 0;

    virtual const FBox &getBBox () const = 0;

    virtual void setBBox (const FBox &bBox) = 0;
 
#ifdef SWIG
    %apply float &OUTPUT { float &xstep };
    %apply float &OUTPUT { float &ystep };
#endif
    virtual void getTilingStep (float &xstep, float &ystep) const = 0;
#ifdef SWIG
    %clear float &xstep;
    %clear float &ystep;
#endif

    virtual void setTilingStep (float xstep, float ystep) = 0;

    virtual void setPaintType (uint8 paintType) = 0;

    virtual uint8 getPaintType () const = 0;

    virtual void setTilingType (uint8 tilingType) = 0;

    virtual uint8 getTilingType () const = 0;

    virtual void setPatternColor (const IDOMColorPtr &color) = 0;

    virtual IDOMColorPtr getPatternColor () const = 0;

    virtual IDOMNodePtr getVisual() const = 0;

    virtual void setVisual(const IDOMNodePtr &ptrVisual) = 0;

    virtual IDOMVisualBrushPtr getEquivalentVisualBrush(IEDLClassFactory *pFactory) = 0;

    virtual IDOMTilingPatternBrushPtr getColoredTilingPatternBrush(IEDLClassFactory *pFactory,
                                                                   bool overprint = false) = 0;
 
};
#define edlobj2IDOMTilingPatternBrush(src) edl_cast((IDOMTilingPatternBrush *)NULL, src)
#define dom2IDOMTilingPatternBrush(src) dom2BrushType<IDOMTilingPatternBrush, IDOMBrush::eTilingPattern>(src)
 

class IDOMShadingPatternBrush : public IDOMTransformableBrush
{
  public:

    virtual uint8 getShadingType () const = 0;

    virtual bool getBBox (FBox &bBox) const = 0;

    virtual void setBBox (const FBox &bBox) = 0;

    virtual void setBackgroundColor (const IDOMColorPtr &color) = 0;

    virtual IDOMColorPtr getBackgroundColor () const = 0;

    virtual void setColorSpace (const IDOMColorSpacePtr &colorSpace) = 0;

    virtual IDOMColorSpacePtr getColorSpace () const = 0;

    virtual void setColorSpace (IEDLClassFactory *pFactory, const IDOMColorSpacePtr &colorSpace, eRenderingIntent intent, eBlackPointCompensation bpc) = 0;

    virtual void deIndex (IEDLClassFactory *pFactory) = 0;

    virtual void setAntiAlias (bool antiAlias) = 0;

    virtual bool getAntiAlias () const = 0;

    virtual void setFunction (const IDOMFunctionPtr &function) = 0;

    virtual IDOMFunctionPtr getFunction () const = 0;
 
};
#define edlobj2IDOMShadingPatternBrush(src) edl_cast((IDOMShadingPatternBrush *)NULL, src)
static inline IDOMShadingPatternBrushPtr dom2IDOMShadingPatternBrush(const IDOMBrushPtr &src)
{
    if (src)
    {
        switch (src->getBrushType())
        {
            case IDOMBrush::eType1ShadingPattern:
            case IDOMBrush::eType2ShadingPattern:
            case IDOMBrush::eType3ShadingPattern:
            case IDOMBrush::eType4567ShadingPattern:
                return IDOMShadingPatternBrushPtr(static_cast<IDOMShadingPatternBrush *>((IDOMBrush *)src), true);
            default:
                return IDOMShadingPatternBrushPtr();
        }
    }
    else
    {
        return IDOMShadingPatternBrushPtr();
    }
}
 

 
class IDOMShadingPatternType1Brush : public IDOMShadingPatternBrush, public IDOMHashable
{
#define IDOMShadingPatternType1BrushClassID 0x599BD13A, 0xB5B74368, 0xA728CDF8, 0x621F8CC0
  public:
 
#ifdef SWIG
#if SWIGJAVA
    %apply float[] { float domain[4] };
#endif
#if SWIGCSHARP
    %apply float INPUT[] { float domain[4] };
#endif
#endif
    static EDL_API IDOMShadingPatternType1BrushPtr create(IEDLClassFactory *pFactory,
                                                          const IDOMColorSpacePtr &colorSpace,
                                                          float domain[4],
                                                          const IDOMFunctionPtr &function,
                                                          bool hasBBox = false,
                                                          const FBox &bBox = FBox(),
                                                          const IDOMColorPtr &background = IDOMColorPtr(),
                                                          const FMatrix &matrix = FMatrix(),
                                                          const FMatrix &renderTransform = FMatrix(),
                                                          bool antiAlias = false,
                                                          float opacity = 1.0f);
#ifdef SWIG
    %clear float domain[4];
#endif

    class Data : public CClassParams
    {
      public:
        Data()
        {
            opacity     = 1.0f;
            shadingType = 1;
            antiAlias   = false;
            hasBBox     = false;
 
            bBox = FBox();
 
            domain [0]  = 0.0;
            domain [1]  = 1.0;
            domain [2]  = 0.0;
            domain [3]  = 1.0;
 
            function    = NULL;
        }
 
        /* common to all shading types */
        float                       opacity;
        int                         shadingType;
        FBox                        bBox;
        bool                        hasBBox;
        bool                        antiAlias;
        IDOMColorSpacePtr           colorSpace;
        IDOMColorPtr                background;
        FMatrix                     renderTransform;
 
 
        /* type 1 info */
        float                       domain [4];
        FMatrix                     matrix;
        IDOMFunctionPtr             function;
    };

    static const CClassID &classID()
    {
        static CClassID id (IDOMShadingPatternType1BrushClassID);
        return id;
    };
 
#ifdef SWIG
#if SWIGJAVA
    %apply float[] { float domain[4] };
#endif
#if SWIGCSHARP
    %apply float INPUT[] { float domain[4] };
#endif
#endif
    virtual void setDomain (float domain[4]) = 0;
#ifdef SWIG
    %clear float domain[4];
#endif

    virtual const float *getDomain () const = 0;

    virtual void setMatrix (const FMatrix &matrix) = 0;

    virtual const FMatrix &getMatrix () = 0;
};
#define edlobj2IDOMShadingPatternType1Brush(src) edl_cast((IDOMShadingPatternType1Brush *)NULL, src)
#define dom2IDOMShadingPatternType1Brush(src) dom2BrushType<IDOMShadingPatternType1Brush, IDOMBrush::eType1ShadingPattern>(src)
 

class IDOMShadingPatternType2Brush : public IDOMShadingPatternBrush, public IDOMHashable
{
#define IDOMShadingPatternType2BrushClassID 0xDDD7C873, 0x2C0045b6, 0xB67E54BE, 0x04AD6190
  public:
 
#ifdef SWIG
#if SWIGJAVA
    %apply float[] { float domain[2] };
#endif
#if SWIGCSHARP
    %apply float INPUT[] { float domain[2] };
#endif
#endif
    static EDL_API IDOMShadingPatternType2BrushPtr create(IEDLClassFactory *pFactory,
                                                          const FPoint &startPoint,
                                                          const FPoint &endPoint,
                                                          const IDOMColorSpacePtr &colorSpace,
                                                          float domain[2],
                                                          const IDOMFunctionPtr &function,
                                                          bool extendStart = false,
                                                          bool extendEnd = false,
                                                          bool hasBBox = false,
                                                          const FBox &bBox = FBox(),
                                                          const IDOMColorPtr &background = IDOMColorPtr(),
                                                          const FMatrix &renderTransform = FMatrix(),
                                                          bool antiAlias = false,
                                                          float opacity = 1.0f);
#ifdef SWIG
    %clear float domain[2];
#endif

    class Data : public CClassParams
    {
      public:
        Data()
        {
            opacity     = 1.0f;
            shadingType = 2;
            antiAlias   = false;
            hasBBox     = false;
 
            bBox        = FBox();
 
            startPoint  = FPoint();
            endPoint    = FPoint();
 
            domain [0]  = 0.0;
            domain [1]  = 1.0;
 
            function    = NULL;
 
            extend [0]  = false;
            extend [1]  = false;
        }
 
        /* common to all shading types */
        float                       opacity;
        uint8                       shadingType;
        FBox                        bBox;
        bool                        hasBBox;
        bool                        antiAlias;
        IDOMColorSpacePtr           colorSpace;
        IDOMColorPtr                background;
        FMatrix                     renderTransform;
 
        /* type 2 info */
        FPoint                      startPoint;
        FPoint                      endPoint;
        float                       domain [2];
        IDOMFunctionPtr             function;
        bool                        extend [2];
    };

    static const CClassID &classID()
    {
        static CClassID id (IDOMShadingPatternType2BrushClassID);
        return id;
    };
 
#ifdef SWIG
#if SWIGJAVA
    %apply float[] { float domain[2] };
#endif
#if SWIGCSHARP
    %apply float INPUT[] { float domain[2] };
#endif
#endif
    virtual void setDomain (float domain[2]) = 0;
#ifdef SWIG
    %clear float domain[2];
#endif

    virtual const float *getDomain () const = 0;

    virtual void setStartPoint (const FPoint &point) = 0;

    virtual const FPoint &getStartPoint () const = 0;

    virtual void setEndPoint (const FPoint &point) = 0;

    virtual const FPoint &getEndPoint () const = 0;

    virtual void setExtend (bool extendStart, bool extendEnd) = 0;
 
#ifdef SWIG
    %apply bool &OUTPUT { bool &extendStart };
    %apply bool &OUTPUT { bool &extendEnd   };
#endif
    virtual void getExtend (bool &extendStart, bool &extendEnd) const = 0;
#ifdef SWIG
    %clear bool &extendStart;
    %clear bool &extendEnd;
#endif

    virtual IDOMBrushPtr getEquivalentSimpleBrush(IEDLClassFactory *pFactory, uint32 maxSamples = 255) = 0;
};
 
#define edlobj2IDOMShadingPatternType2Brush(src) edl_cast((IDOMShadingPatternType2Brush *)NULL, src)
#define dom2IDOMShadingPatternType2Brush(src) dom2BrushType<IDOMShadingPatternType2Brush, IDOMBrush::eType2ShadingPattern>(src)
 

 
class IDOMShadingPatternType3Brush : public IDOMShadingPatternBrush, public IDOMHashable
{
#define IDOMShadingPatternType3BrushClassID 0x383008FE, 0xB7D64314, 0x9B715287, 0xA57ACBDA
  public:
 
#ifdef SWIG
#if SWIGJAVA
    %apply float[] { float domain[2] };
#endif
#if SWIGCSHARP
    %apply float INPUT[] { float domain[2] };
#endif
#endif
    static EDL_API IDOMShadingPatternType3BrushPtr create(IEDLClassFactory *pFactory,
                                                          const FPoint &startCircleCenter,
                                                          float startCircleRadius,
                                                          const FPoint &endCircleCenter,
                                                          float endCircleRadius,
                                                          const IDOMColorSpacePtr &colorSpace,
                                                          float domain[2],
                                                          const IDOMFunctionPtr &function,
                                                          bool extendStart = false,
                                                          bool extendEnd = false,
                                                          bool hasBBox = false,
                                                          const FBox &bBox = FBox(),
                                                          const IDOMColorPtr &background = IDOMColorPtr(),
                                                          const FMatrix &renderTransform = FMatrix(),
                                                          bool antiAlias = false,
                                                          float opacity = 1.0f);
#ifdef SWIG
    %clear float domain[2];
#endif
    class Data : public CClassParams
    {
      public:
        Data()
        {
            opacity           = 1.0f;
            shadingType       = 3;
            antiAlias         = false;
            hasBBox           = false;
 
            bBox              = FBox();
 
            startCircleCenter = FPoint();
            startCircleRadius = 0.0f;
            endCircleCenter   = FPoint();
            endCircleRadius   = 0.0f;
 
            domain [0]        = 0.0;
            domain [1]        = 1.0;
 
            function          = NULL;
 
            extend [0]        = false;
            extend [1]        = false;
        }
 
        /* common to all shading types */
        float                       opacity;
        uint8                       shadingType;
        FBox                        bBox;
        bool                        hasBBox;
        bool                        antiAlias;
        IDOMColorSpacePtr           colorSpace;
        IDOMColorPtr                background;
        FMatrix                     renderTransform;
 
 
        /* type 3 info */
        FPoint                      startCircleCenter;
        float                       startCircleRadius;
        FPoint                      endCircleCenter;
        float                       endCircleRadius;
        float                       domain [2];
        IDOMFunctionPtr             function;
        bool                        extend [2];
    };

    static const CClassID &classID()
    {
        static CClassID id (IDOMShadingPatternType3BrushClassID);
        return id;
    };
 
#ifdef SWIG
#if SWIGJAVA
    %apply float[] { float domain[2] };
#endif
#if SWIGCSHARP
    %apply float INPUT[] { float domain[2] };
#endif
#endif
    virtual void setDomain (float domain[2]) = 0;
#ifdef SWIG
    %clear float domain[2];
#endif

    virtual const float *getDomain () const = 0;

    virtual void setStartCircleCenter (const FPoint &point) = 0;

    virtual const FPoint &getStartCircleCenter () const = 0;

    virtual void setStartCircleRadius(float radius) = 0;

    virtual float getStartCircleRadius() const = 0;

    virtual void setEndCircleCenter (const FPoint &point) = 0;

    virtual const FPoint &getEndCircleCenter () const = 0;

    virtual void setEndCircleRadius(float radius) = 0;

    virtual float getEndCircleRadius() const = 0;

    virtual void setExtend (bool extendStart, bool extendEnd) = 0;
 
#ifdef SWIG
    %apply bool &OUTPUT { bool &extendStart };
    %apply bool &OUTPUT { bool &extendEnd   };
#endif
    virtual void getExtend (bool &extendStart, bool &extendEnd) const = 0;
#ifdef SWIG
    %clear bool &extendStart;
    %clear bool &extendEnd;
#endif

    virtual IDOMBrushPtr getEquivalentSimpleBrush(IEDLClassFactory *pFactory, uint32 maxSamples = 255) = 0;
};
 
#define edlobj2IDOMShadingPatternType3Brush(src) edl_cast((IDOMShadingPatternType3Brush *)NULL, src)
#define dom2IDOMShadingPatternType3Brush(src) dom2BrushType<IDOMShadingPatternType3Brush, IDOMBrush::eType3ShadingPattern>(src)
 

 
class IDOMShadingPatternType4567Brush : public IDOMShadingPatternBrush, public IDOMHashable
{
#define IDOMShadingPatternType4567BrushClassID 0x7204F554, 0x95984d30, 0xA090074B, 0xC03337EE
  public:

    static EDL_API IDOMShadingPatternType4567BrushPtr create(IEDLClassFactory *pFactory,
                                                             uint8 shadingType,
                                                             const IDOMColorSpacePtr &colorSpace,
                                                             const JawsMako::IPDFStringPtr &dataSource,
                                                             const uint8 bitsPerCoordinate = 0,
                                                             const uint8 bitsPerComponent = 0,
                                                             const uint8 bitsPerFlag = 0,
                                                             const int32 verticesPerRow = 0,
                                                             const CEDLVector<float> &decode = CEDLVector<float>(),
                                                             const IDOMFunctionPtr &function = IDOMFunctionPtr(),
                                                             bool hasBBox = false,
                                                             const FBox &bBox = FBox(),
                                                             const IDOMColorPtr &background = IDOMColorPtr(),
                                                             const FMatrix &renderTransform = FMatrix(),
                                                             bool antiAlias = false,
                                                             float opacity = 1.0f);

    class CMeshEntry
    {
      public:
        CMeshEntry() : flag(0) {}
        uint8 flag;                           
        CEDLVector<FPoint>            points; 
        CEDLVector<CEDLVector<float> > colors;
 
        bool operator== (const CMeshEntry &other) const
        {
            return      (other.flag         == flag)
                    &&  (other.points       == points)
                    &&  (other.colors       == colors);
        }
 
        bool operator!= (const CMeshEntry &other) const
        {
            return ! (*this == other);
        }
    };
    typedef CEDLVector<CMeshEntry> CMeshEntryVect;

    static EDL_API IDOMShadingPatternType4567BrushPtr create(IEDLClassFactory *pFactory,
                                                             uint8 shadingType,
                                                             const IDOMColorSpacePtr &colorSpace,
                                                             const IDOMFunctionPtr &function,
                                                             const CMeshEntryVect &meshEntries,
                                                             const uint8 bitsPerCoordinate = 16,
                                                             const uint8 bitsPerComponent = 8,
                                                             const uint8 bitsPerFlag = 8,
                                                             const int32 verticesPerRow = 0,
                                                             const CEDLVector<float> &decode = CEDLVector<float>(),
                                                             bool hasBBox = false,
                                                             const FBox &bBox = FBox(),
                                                             const IDOMColorPtr &background = IDOMColorPtr(),
                                                             const FMatrix &renderTransform = FMatrix(),
                                                             bool antiAlias = false,
                                                             float opacity = 1.0f);

    class Data : public CClassParams
    {
      public:
            Data()
            {
                opacity     = 1.0f;
                shadingType = 4;
                antiAlias   = false;
                hasBBox     = false;
 
                bBox        = FBox();
 
                bitsPerCoordinate   = 0;
                bitsPerFlag         = 0;
                bitsPerComponent    = 0;
                verticesPerRow      = 0;
                decode.resize(0);
                function            = NULL;
                dataSource          = NULL;
            }
 
            virtual ~Data()
            {
            }
 
            /* common to all shading types */
            float                       opacity;
            uint8                       shadingType;
            FBox                        bBox;
            bool                        hasBBox;
            bool                        antiAlias;
            IDOMColorSpacePtr           colorSpace;
            IDOMColorPtr                background;
            FMatrix                     renderTransform;
 
            /* type 4, 5, 6, 7 info */
            uint8                       bitsPerCoordinate;
            uint8                       bitsPerFlag;
            uint8                       bitsPerComponent;
            int32                       verticesPerRow;
            JawsMako::IPDFStringPtr     dataSource;
            CEDLVector<float>           decode;
            IDOMFunctionPtr             function;
    };

    static const CClassID &classID()
    {
        static CClassID id (IDOMShadingPatternType4567BrushClassID);
        return id;
    };

    virtual void setShadingType (uint8 shadingType) = 0;

    virtual void setDataSource (const JawsMako::IPDFStringPtr &dataSource) = 0;

    virtual JawsMako::IPDFStringPtr getDataSource () const  = 0;

    virtual void setBitsPerCoordinate (uint8 bitsPerCoordinate) = 0;

    virtual uint8 getBitsPerCoordinate () const  = 0;

    virtual void setBitsPerComponent (uint8 bitsPerComponent) = 0;

    virtual uint8 getBitsPerComponent () const  = 0;

    virtual void setBitsPerFlag (uint8 bitsPerFlag) = 0;

    virtual uint8 getBitsPerFlag () const  = 0;

    virtual void setVerticesPerRow (int32 verticesPerRow) = 0;

    virtual int32 getVerticesPerRow () const  = 0;

    virtual void setDecode (const CEDLVector<float> &decode) = 0;

    virtual const CEDLVector<float> &getDecode () const  = 0;

    virtual CMeshEntryVect getMeshEntries() const = 0;

    virtual void setMeshEntries(const CMeshEntryVect &meshEntries) = 0;
};
#define edlobj2IDOMShadingPatternType4567Brush(src) edl_cast((IDOMShadingPatternType4567Brush *)NULL, src)
#define dom2IDOMShadingPatternType4567Brush(src) dom2BrushType<IDOMShadingPatternType4567Brush, IDOMBrush::eType4567ShadingPattern>(src)

 
class IDOMNullBrush : public IDOMBrush, public IDOMHashable
{
#define IDOMNullBrushClassID 0x98F3706B, 0x403E4a41, 0xA975A9B6, 0xD52C99CC
  public:

    static EDL_API IDOMNullBrushPtr create(IEDLClassFactory *pFactory);

    class Data : public CClassParams
    {
      public:
        Data(): opacity(1.0)
        {}
        float opacity;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMNullBrushClassID);
        return id;
    };
};
#define edlobj2IDOMNullBrush(src) edl_cast((IDOMNullBrush *)NULL, src)
#define dom2IDOMNullBrush(src) dom2BrushType<IDOMNullBrush, IDOMBrush::eNull>(src)
 
_END_EDL_DOM_NAMESPACE
 
 
#endif /* EDLIDOMBRUSH_H */