idompath.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2025 Global Graphics Software Ltd. All rights reserved.
 */
 
#ifndef EDLIDOMPATH_H
#define EDLIDOMPATH_H
 
#include <edl/edltypes.h>
#include <edl/edlgeom.h>
#include <edl/iedlobject.h>
#include <edl/idomnode.h>
#include <edl/idomshape.h>
#include <edl/idombrush.h>
#include <edl/idomtarget.h>
#include <edl/edlblend.h>
#include <edl/idompathgeometry.h>
#include <edl/idomedgemode.h>
#include <edl/edlrenderingintent.h>
#include <edl/edlblackpointcompensation.h>
 
_BEGIN_EDL_DOM_NAMESPACE
 
class IDOMPathNode;
DECL_SMART_PTR(IDOMPathNode);

class IDOMPathNode : public IDOMNode
{
  public:
#define IDOMPathNodeClassID 0xF0E21B7F, 0x89174e0e, 0x90DD88A5, 0x89D6F6BE
    static const CClassID &classID()
    {
        static CClassID id(IDOMPathNodeClassID);
        return id;
    }

    typedef enum
    {
        eMiterJoin,        
        eBevelJoin,        
        eRoundJoin         
    } eStrokeLineJoin;

    typedef enum
    {
        eClipLongMiters, 
        eBevelLongMiters    
    } eStrokeMiterLimitTreatment;

    typedef enum
    {
        eFlatCap,          
        eSquareCap,        
        eRoundCap,         
        eTriangleCap       
    } eStrokeLineCap;

    static EDL_API IDOMPathNodePtr createFilled(IEDLClassFactory *pFactory,
                                                const IDOMPathGeometryPtr &geometry,
                                                const IDOMBrushPtr &brush,
                                                const FMatrix renderTransform = FMatrix(),
                                                const IDOMPathGeometryPtr &clip = IDOMPathGeometryPtr(),
                                                float opacity = 1.0f,
                                                eBlendMode blendMode = eBlendModeNormal,
                                                eEdgeMode edgeMode = eEMDefault);

    static EDL_API IDOMPathNodePtr createStroked(IEDLClassFactory *pFactory,
                                                 const IDOMPathGeometryPtr &geometry,
                                                 const IDOMBrushPtr &brush,
                                                 const FMatrix renderTransform = FMatrix(),
                                                 const IDOMPathGeometryPtr &clip = IDOMPathGeometryPtr(),
                                                 double strokeThickness = 1.0,
                                                 double miterLimit = 10.0,
                                                 eStrokeLineJoin join = eMiterJoin,
                                                 eStrokeLineCap startCap = eFlatCap,
                                                 eStrokeLineCap endCap = eFlatCap,
                                                 eStrokeLineCap dashCap = eFlatCap,
                                                 eStrokeMiterLimitTreatment miterTreatment = eClipLongMiters,
                                                 double dashOffset = 0.0,
                                                 const CEDLVector<double> dashPattern = CEDLVector<double>(),
                                                 bool zeroWidthLinesAreVisible = false,
                                                 float opacity = 1.0f,
                                                 eBlendMode blendMode = eBlendModeNormal,
                                                 eEdgeMode edgeMode = eEMDefault);

    static EDL_API IDOMPathNodePtr createImage(IEDLClassFactory *pFactory,
                                               const IDOMImagePtr &image,
                                               const FRect &viewPort,
                                               const FMatrix &renderTransform = FMatrix());

    class Data : public CClassParams
    {
      public:
        Data():
            opacity(1.0),
            strokeThickness(1.0),
            miterLimit(10.0),
            strokeLineJoin(eMiterJoin),
            strokeStartLineCap(eFlatCap),
            strokeEndLineCap(eFlatCap),
            strokeDashLineCap(eFlatCap),
            strokeDashOffset(0.0),
            blendMode(eBlendModeNormal),
            strokeMiterLimitTreatment(eClipLongMiters),
            zeroWidthLinesAreVisible(false),
            edgeMode(eEMDefault),
            snapsToDevicePixels(false),
            overprintMode(false),
            fillOverprint(false),
            strokeOverprint(false),
            strokeAdjust(false)
        {}
        float               opacity;
        double              strokeThickness;
        double              miterLimit;
        eStrokeLineJoin     strokeLineJoin;
        eStrokeLineCap      strokeStartLineCap;
        eStrokeLineCap      strokeEndLineCap;
        eStrokeLineCap      strokeDashLineCap;
        eStrokeMiterLimitTreatment strokeMiterLimitTreatment;
        double              strokeDashOffset;
        bool                snapsToDevicePixels;
        EDLString           language;
        EDLString           automationPropertiesName;
        EDLString           automationPropertiesHelpText;
        FMatrix             renderTransform;
        IDOMTargetPtr       ptrNavigateLink;
        IDOMBrushPtr        ptrFill;
        IDOMBrushPtr        ptrStroke;
        IDOMBrushPtr        ptrOpacityMask;
        IDOMPathGeometryPtr ptrPathData;
        IDOMPathGeometryPtr ptrClip;
        eBlendMode          blendMode;
        eEdgeMode           edgeMode;
        bool                zeroWidthLinesAreVisible;
        bool                overprintMode;
        bool                fillOverprint;
        bool                strokeOverprint;
        bool                strokeAdjust;
    };

    virtual const FMatrix &getRenderTransform() const = 0;

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

    virtual float getOpacity() const = 0;

    virtual void setOpacity(float opc) = 0;

    virtual eBlendMode getBlendMode() const = 0;

    virtual void setBlendMode(eBlendMode blendMode) = 0;

    virtual eEdgeMode getEdgeMode () const = 0;

    virtual void setEdgeMode (eEdgeMode em) = 0;

    virtual double getStrokeThickness() const = 0;

    virtual void setStrokeThickness(double st) = 0;

    virtual bool getShouldZeroWidthLinesBeVisible() const = 0;

    virtual void setShouldZeroWidthLinesBeVisible(bool visible) = 0;

    virtual double getStrokeMiterLimit() const = 0;

    virtual void setStrokeMiterLimit(double sml) = 0;

    virtual eStrokeMiterLimitTreatment getStrokeMiterLimitTreatment() const = 0;

    virtual void setStrokeMiterLimitTreatment(eStrokeMiterLimitTreatment treatment) = 0;

    virtual double getStrokeDashOffset() const = 0;

    virtual void setStrokeDashOffset(double sdo) = 0;

    virtual eStrokeLineJoin getStrokeLineJoin() const = 0;

    virtual void setStrokeLineJoin(eStrokeLineJoin slj) = 0;

    virtual eStrokeLineCap getStrokeStartLineCap() const = 0;

    virtual void setStrokeStartLineCap(eStrokeLineCap slc) = 0;

    virtual eStrokeLineCap getStrokeEndLineCap() const = 0;

    virtual void setStrokeEndLineCap(eStrokeLineCap slc) = 0;

    virtual eStrokeLineCap getStrokeDashLineCap() const = 0;

    virtual void setStrokeDashLineCap(eStrokeLineCap slc) = 0;

    virtual bool getSnapsToDevicePixels() const = 0;

    virtual void setSnapsToDevicePixels(bool s2dp) = 0;

    virtual EDLString getLanguage () const = 0;

    virtual void setLanguage (const EDLString &lang) = 0;

    virtual IDOMTargetPtr getNavigateLink () const = 0;

    virtual void setNavigateLink (const IDOMTargetPtr &target) = 0;

    virtual EDLString getAutomationPropertiesName () const = 0;

    virtual void setAutomationPropertiesName (const EDLString &propname) = 0;

    virtual EDLString getAutomationPropertiesHelpText () const = 0;

    virtual void setAutomationPropertiesHelpText (const EDLString &helptext) = 0;

    virtual bool getIsDashed() = 0;

    virtual const CEDLVector<double> &getStrokeDashPattern () const = 0;

    virtual void setStrokeDashPattern (const CEDLVector<double> &pattern) = 0;

    virtual uint32 getStrokeDashsCount() = 0;

    virtual void clearStrokeDashCollection() = 0;

    virtual void addStrokeDash(double value) = 0;

    virtual IDOMBrushPtr getFill() const = 0;

    virtual void setFill(const IDOMBrushPtr &ptrFill) = 0;

    virtual IDOMBrushPtr getStroke() const = 0;

    virtual void setStroke(const IDOMBrushPtr &ptrStroke) = 0;

    virtual IDOMBrushPtr getOpacityMask() const = 0;

    virtual void setOpacityMask(const IDOMBrushPtr &ptrOpacityMask) = 0;

    virtual IDOMPathGeometryPtr getPathData() const = 0;

    virtual void setPathData(const IDOMPathGeometryPtr &ptrPathData) = 0;

    virtual IDOMPathGeometryPtr getClip() const = 0;

    virtual void setClip(const IDOMPathGeometryPtr &ptrClip) = 0;

    virtual IDOMNodePtr split(IEDLClassFactory *pFactory) = 0;

    virtual IDOMShapePtr getShape(const FMatrix &transform, float resolution, IEDLClassFactory *pFactory) = 0;

    virtual bool getFillOverprints() const = 0;

    virtual void setFillOverprints(bool overprint = true) = 0;

    virtual bool getStrokeOverprints() const = 0;

    virtual void setStrokeOverprints(bool overprint = true) = 0;

    virtual bool getOverprintMode() const = 0;

    virtual void setOverprintMode(bool mode = true) = 0;

    virtual bool getStrokeAdjust() const = 0;

    virtual void setStrokeAdjust(bool adjust = true) = 0;

    virtual eRenderingIntent getRenderingIntent() const = 0;

    virtual void setRenderingIntent(eRenderingIntent intent) = 0;

    virtual eBlackPointCompensation getBlackPointCompensation() const = 0;

    virtual void setBlackPointCompensation(eBlackPointCompensation compensation) = 0;
 
};
#define edlobj2IDOMPathNode(src) edl_cast((IDOMPathNode *)NULL, src)
#define dom2IDOMPathNode(src) dom2NodeType<IDOMPathNode, eDOMPathNode>(src)
 
 
_END_EDL_DOM_NAMESPACE
 
#endif /* EDLIDOMPATH_H */