idompathgeometry.h

Go to the documentation of this file.

/*
 *  idompathgeometry.h
 *
 *  Copyright (C) 2007-2026 Hybrid Software Helix Ltd. All rights reserved.
 */
 
#ifndef EDLIDOMPATHGEOMETRY_H
#define EDLIDOMPATHGEOMETRY_H
 
#include <edl/edltypes.h>
#include <edl/edlfwd.h>
#include <edl/edlgeom.h>
#include <edl/iedlobject.h>
#include <edl/edlnamespaces.h>
#include <edl/idomshape.h>
#include <edl/idomhashable.h>
_BEGIN_EDL_DOM_NAMESPACE
 
class IDOMPathSegment;
DECL_SMART_PTR(IDOMPathSegment);
class IDOMArcSegment;
DECL_SMART_PTR(IDOMArcSegment);
class IDOMPolyLineSegment;
DECL_SMART_PTR(IDOMPolyLineSegment);
class IDOMPolyBezierSegment;
DECL_SMART_PTR(IDOMPolyBezierSegment);
class IDOMPolyQuadraticBezierSegment;
DECL_SMART_PTR(IDOMPolyQuadraticBezierSegment);
class IDOMPathFigure;
DECL_SMART_PTR(IDOMPathFigure);

class IDOMPathSegment : public IEDLObject, public IDOMHashable
{
  public:
    typedef enum
    {
        eUnknownSegment,     
        eArc,                
        ePolyLine,           
        ePolyBezier,         
        ePolyQuadraticBezier 
    } eSegmentType;

    virtual eSegmentType getSegmentType() const = 0;

    virtual bool getIsStroked() const = 0;
    virtual void setIsStroked(bool isStroked) = 0;
    virtual FRect getBounds(FPoint &startPoint) const= 0;
    virtual const FPoint &getEndPoint() const = 0;
    virtual bool getIsImmutable() const = 0;
    virtual void setImmutable() = 0;
};
#define edlobj2IDOMPathSegment(src) edl_cast((IDOMPathSegment *) nullptr, src)

class IDOMArcSegment : public IDOMPathSegment
{
  public:
#define IDOMArcSegmentClassID 0xFC8F943E, 0x23E94b1a, 0x8A078F67, 0x63F188CA
    static const CClassID &classID()
    {
        static CClassID id(IDOMArcSegmentClassID);
        return id;
    }

    typedef enum
    {
        eSDClockwise,
        eSDCounterclockwise
    } eSweepDirection;

    class Data : public CClassParams
    {
      public:
        Data(): isStroked(true), immutable(false),
                isLargeArc (false),
                radiusX (0.0),
                radiusY (0.0),
                rotationAngle (0.0),
                sweepDirection (eSDClockwise)
        {}
        bool            immutable; // True if editing should not be allowed for this segment.
        FPoint          point;
        double          radiusX;
        double          radiusY;
        double          rotationAngle;
        bool            isLargeArc;
        bool            isStroked;
        eSweepDirection sweepDirection;
    };

    static EDL_API IDOMArcSegmentPtr create(IEDLClassFactory *factory,
                                            bool isStroked = false,
                                            const FPoint &point = FPoint(),
                                            double radiusX = 0.0, double radiusY = 0.0, double rotationAngle = 0.0,
                                            bool isLargeArc = false,
                                            eSweepDirection sweepDirection = eSDClockwise);

    virtual const FPoint &getPoint() const = 0;

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

    virtual double getRadiusX() const = 0;

    virtual void setRadiusX(double radiusX) = 0;

 
    virtual double getRadiusY() const = 0;
 
    virtual void setRadiusY(double radiusY) = 0;
 
    virtual double getRotationAngle() const = 0;
    virtual void setRotationAngle(double rA) = 0;

    virtual bool getIsLargeArc() const = 0;

    virtual void setIsLargeArc(bool isLA) = 0;

    virtual eSweepDirection getSweepDirection() const = 0;

    virtual void setSweepDirection(eSweepDirection sd) = 0;
    virtual IDOMPathSegmentPtr convertToSimpleSegment(IEDLClassFactory *factory, const FPoint &startPoint) const = 0;
};
#define edlobj2IDOMArcSegment(src) edl_cast((IDOMArcSegment *) nullptr, src)

class IDOMPolyLineSegment : public IDOMPathSegment
{
#define IDOMPolyLineSegmentClassID 0x858ed3ce, 0xc14b4bdf, 0x8f1fb58b, 0xa046afd2
  public:
    static const CClassID &classID()
    {
        static CClassID id(IDOMPolyLineSegmentClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        Data(): isStroked(true), immutable(false)
        {}
        bool        immutable; // True if editing should not be allowed for this segment.
        bool        isStroked;
        CFPointVect points;
    };

    static EDL_API IDOMPolyLineSegmentPtr create(IEDLClassFactory *factory,
                                                 bool isStroked = true,
                                                 const CFPointVect &points = CFPointVect());

    virtual const CFPointVect &getPoints() const = 0;
    virtual uint32 getPointsCount() const = 0;
    virtual void clearPoints() = 0;
    virtual void addPoint(const FPoint &point) = 0;
};
#define edlobj2IDOMPolyLineSegment(src) edl_cast((IDOMPolyLineSegment *) nullptr, src)

class IDOMPolyBezierSegment : public IDOMPathSegment
{
#define IDOMPolyBezierSegmentClassID 0xb2c0876c, 0x5f1b4e0a, 0xb6f0babb, 0x23061b1e
  public:
    static const CClassID &classID()
    {
        static CClassID id(IDOMPolyBezierSegmentClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        Data(): isStroked(true), immutable(false)
        {}
        bool        immutable; // True if editing should not be allowed for this segment.
        bool        isStroked;
        CFPointVect points;
    };

    static EDL_API IDOMPolyBezierSegmentPtr create(IEDLClassFactory *factory,
                                                   bool isStroked = true,
                                                   const CFPointVect &points = CFPointVect());

    virtual const CFPointVect &getPoints() const = 0;
    virtual uint32 getPointsCount() const = 0;
    virtual void clearPoints() = 0;
    virtual void addPoint(const FPoint &point) = 0;
};
#define edlobj2IDOMPolyBezierSegment(src) edl_cast((IDOMPolyBezierSegment *) nullptr, src)

class IDOMPolyQuadraticBezierSegment : public IDOMPathSegment
{
#define IDOMPolyQuadraticBezierSegmentClassID 0x8c8ae8b7, 0x7ad64100, 0x8e55774e, 0x7e06ba34
  public:
    static const CClassID &classID()
    {
        static CClassID id(IDOMPolyQuadraticBezierSegmentClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        Data(): isStroked(true), immutable(false)
        {}
        bool        immutable; // True if editing should not be allowed for this segment.
        bool        isStroked;
        CFPointVect points;
    };

    static EDL_API IDOMPolyQuadraticBezierSegmentPtr create(IEDLClassFactory *factory,
                                                            bool isStroked = true,
                                                            const CFPointVect &points = CFPointVect());
    virtual const CFPointVect &getPoints() const = 0;
    virtual uint32 getPointsCount() const = 0;
    virtual void clearPoints() = 0;
    virtual void addPoint(const FPoint &point) = 0;
    virtual IDOMPolyBezierSegmentPtr convertToCubicBezierSegment(IEDLClassFactory *factory, const FPoint &startPoint) const = 0;
};
#define edlobj2IDOMPolyQuadraticBezierSegment(src) edl_cast((IDOMPolyQuadraticBezierSegment *) nullptr, src)
 
typedef CEDLVector<IDOMPathSegmentPtr> CDOMPathSegmentVect;

class IDOMPathFigure : public IEDLObject, public IDOMHashable
{
  public:
#define IDOMPathFigureClassID 0x69B82E30, 0xA5D24512, 0xB44599CE, 0x21AF0BFC
    static const CClassID &classID()
    {
        static CClassID id(IDOMPathFigureClassID);
        return id;
    }

    class Data : public CClassParams
    {
      public:
        Data(): isFilled(true), isClosed(false), immutable(false)
        {}
        bool                immutable; // True if editing should not be allowed for this segment.
        FPoint              startPoint;
        bool                isClosed;
        bool                isFilled;
        CDOMPathSegmentVect segments;
    };

    static EDL_API IDOMPathFigurePtr create(IEDLClassFactory *factory,
                                            const FPoint &startPoint = FPoint(),
                                            bool isClosed = false,
                                            bool isFilled = true,
                                            const CDOMPathSegmentVect &segments = CDOMPathSegmentVect());

    virtual bool getIsClosed() const = 0;
    virtual void setIsClosed(bool closed) = 0;
    virtual const FPoint &getStartPoint() const = 0;
    virtual void setStartPoint(const FPoint &sp) = 0;
    virtual bool getIsFilled() const = 0;
    virtual void setIsFilled(bool filled) = 0;
    virtual const CDOMPathSegmentVect &getSegments() const = 0;
    virtual uint32 getSegmentsCount() const = 0;
    virtual void clearSegments() = 0;
    virtual void addSegment(const IDOMPathSegmentPtr &pathSegment) = 0;
    virtual FRect getBounds() const = 0;
 
#ifdef SWIG
    %apply bool &OUTPUT { bool &firstLineIsX };
    %apply bool &OUTPUT { bool &closed };
#endif
    virtual bool getIsRect(FPoint &startPoint, FPoint &oppositePoint, bool &firstLineIsX, bool &closed) = 0;
#ifdef SWIG
    %clear bool &firstLineIsX;
    %clear bool &closed;
#endif

    virtual bool getIsImmutable() const = 0;
    virtual void setImmutable() = 0;
};
#define edlobj2IDOMPathFigure(src) edl_cast((IDOMPathFigure *) nullptr, src)
 
typedef CEDLVector<IDOMPathFigurePtr> CDOMPathFigureVect;
 
class IDOMPathGeometry;
DECL_SMART_PTR(IDOMPathGeometry);

class IDOMPathGeometry : public IEDLObject, public IDOMHashable
{
  public:
#define IDOMPathGeometryClassID 0xCC10E2AC, 0x4F8946d6, 0xA99ACB94, 0xC0379682

    typedef enum
    {
        eFREvenOdd,  
        eFRNonZero   
    } eFillRule;

    static EDL_API IDOMPathGeometryPtr create(IEDLClassFactory *factory, const FRect &rect, bool close = true,
                                              const FMatrix &renderTransform = FMatrix());

    static EDL_API IDOMPathGeometryPtr create(IEDLClassFactory *factory, const EDLSysString &abbreviatedGeometry,
                                              const FMatrix &renderTransform = FMatrix());

    static EDL_API IDOMPathGeometryPtr create(IEDLClassFactory *factory, const CDOMPathFigureVect &figures = CDOMPathFigureVect(),
                                              const FMatrix &renderTransform = FMatrix(), eFillRule fillRule = eFREvenOdd);

    static EDL_API IDOMPathGeometryPtr createEllipse(IEDLClassFactory *factory, const FRect &rect,
                                                     const FMatrix &renderTransform = FMatrix());
 

    static EDL_API IDOMPathGeometryPtr createPolygon(IEDLClassFactory *factory, const FRect &rect, uint32 numSides, double rotationAngle = 0.0);
 

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

    class Data : public CClassParams
    {
      public:
        Data(): fillRule(eFREvenOdd)
        {}
      public:
        eFillRule          fillRule;
        FMatrix            renderTransform;
        CDOMPathFigureVect figures;
    };

    virtual eFillRule getFillRule() const = 0;
    virtual void setFillRule(eFillRule fr) = 0;
    virtual const FMatrix &getRenderTransform() const = 0;
    virtual void setRenderTransform(const FMatrix &matrix) = 0;
    virtual CDOMPathFigureVect getFigures() const = 0;
    virtual uint32 getFiguresCount() const = 0;
    virtual void clearFigures() = 0;
    virtual void addFigure(const IDOMPathFigurePtr &pathFigure) = 0;
    virtual bool getFiguresImmutable() const = 0;

    virtual IDOMPathGeometryPtr getMutableGeometry(IEDLClassFactory *factory) const = 0;

    virtual FRect getBounds(bool applyTransform = true) const = 0;

    virtual bool getIsRect(FRect &rect) = 0;
 
#ifdef SWIG
    %apply bool &OUTPUT { bool &firstLineIsX };
    %apply bool &OUTPUT { bool &closed };
#endif
    virtual bool getIsRect(FPoint &startPoint,
                           FPoint &oppositePoint,
                           bool &firstLineIsX,
                           bool &closed) = 0;
#ifdef SWIG
    %clear bool &firstLineIsX;
    %clear bool &closed;
#endif

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

    virtual IDOMPathGeometryPtr getSimplifiedGeometry(IEDLClassFactory *pFactory, bool simplifyQuads, bool simplifyArcs) = 0;

    virtual IDOMPathGeometryPtr getFlattenedGeometry(IEDLClassFactory *pFactory, const FMatrix &transform, float resolution) = 0;
};
#define edlobj2IDOMPathGeometry(src) edl_cast((IDOMPathGeometry *) nullptr, src)
 
class IDOMPathGeometryBuilder;
DECL_SMART_PTR(IDOMPathGeometryBuilder);

class IDOMPathGeometryBuilder : public IEDLObject
{
  public:
 
#define IDOMPathGeometryBuilderClassID 0x4E87AB69, 0x634E44A5, 0x93DB169C, 0xC7C2643B

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

    static EDL_API IDOMPathGeometryBuilderPtr create(IEDLClassFactory *factory);

    virtual void moveTo(const FPoint &point, bool absolute = true) = 0;

    virtual void lineTo(const FPoint &point, bool absolute = true, bool stroked = true) = 0;

    virtual void curveTo(const FPoint &control0, const FPoint &control1, const FPoint &point,
                         bool absolute = true, bool stroked = true) = 0;

    virtual void quadCurveTo(const FPoint &control, const FPoint &point, bool absolute = true, bool stroked = true) = 0;

    virtual void arcTo(const FPoint &radius, double rotation, bool isLargeArc, IDOMArcSegment::eSweepDirection sweepDirection,
                       const FPoint &point, bool absolute = true, bool stroked = true) = 0;

    virtual void close(bool stroked = true) = 0;

    virtual IDOMPathGeometryPtr createGeometry(IEDLClassFactory *pFactory, IDOMPathGeometry::eFillRule fillRule, bool ignoreDegenerateSubpaths = false,
                                               const FMatrix &renderTransform = FMatrix()) const = 0;
};
#define edlobj2IDOMPathGeometryBuilder(obj) IDOMPathGeometryBuilderPtr(dynamic_cast<IDOMPathGeometryBuilder *>((IRCObject *) obj), true)
 
_END_EDL_DOM_NAMESPACE
 
#endif /* EDLIDOMPATHGEOMETRY_H */