hdicorePathArt.h

Go to the documentation of this file.

#ifndef __HDI_CORE_PATH_ART__
#define __HDI_CORE_PATH_ART__

#include <vector>

#include "hdicoreArtboardPoint.h"
#include "hdicorePathStyle.h"

namespace hdi
{
    namespace core
    {
        class Angle;
        class Art;
        class Bezier;
        class HitData;
        class ArtboardSegPoint;
    
        class PathArt
        {
            public:
                typedef std::vector<ArtboardSegPoint> ArtboardSegPointVector;
                typedef std::vector< HitData* > HitDataVector;
            
                static const int16_t maxSegments = 32000;

                enum WindingOrderType
                {
                    WindingUnknown      = 0,
                    Clockwise           = 1,    // determined by positive area
                    CounterClockwise    = 2     // determined by negative area
                };

                enum SegPointSelectionState
                {
                    SegPointNotSelected     = 0,
                    SegPointAnchorSelected  = 1 << 0,
                    SegPointInSelected      = 1 << 1,
                    SegPointOutSelected     = 1 << 2,
                    SegPointAllSelected     = (SegPointAnchorSelected | SegPointInSelected | SegPointOutSelected)
                };

                enum TrimDirectionType
                {
                    TrimGreaterDirectionOnly    = 1 << 0,
                    TrimLesserDirectionOnly     = 1 << 1,
                    TrimBothDirections          = (TrimGreaterDirectionOnly | TrimLesserDirectionOnly)
                };
                
                enum TrimError
                {
                    NoTrimError                         = 0,
                    HitDataArtMustMatchTrimPathArtError = 10,
                    TrimPathIsClosedError               = 20,
                    TrimPathNeedsAtLeast2PointsError    = 30,
                    InvalidSourcePathForTrimming        = 40
                };
                
                enum ExtendError
                {
                    NoExtendError                           = 0,
                    HitDataArtMustMatchExtendPathArtError   = 110,
                    NoExtendIntersectionsFoundError         = 120,
                    ExtendPathEndSegmentsOnlyError          = 130,
                    ExtendPathIsClosedError                 = 140,
                    ExtendPathNeedsAtLeast2PointsError      = 150,
                    InvalidSourcePathForExtending           = 160
                };

                ~PathArt();
                
                bool isGuide() const;

                bool closed() const;

                void setClosed(const bool closed_);

                PathStyle style() const;

                void setStyle(const PathStyle& style_);

                int16_t segCount() const;

                int16_t segPointCount() const;

                void setSegCount(const int16_t count_);

                void setSegPointCount(const int16_t count_);

                std::auto_ptr<hdi::core::Bezier> bezier(const int16_t segIndex_) const;

                ArtboardPoint midPoint() const;

                void endPoints(ArtboardPoint& start__, ArtboardPoint& end__) const;

                bool hasLength() const;

                double length() const;

                double sublength(const int16_t startSegPt_, const int16_t endSegPt_) const;

                double sublength(
                    const int16_t startSeg_,
                    const double startT_,
                    const int16_t endSeg_,
                    const double endT_
                ) const;

                double tAtLength(const int16_t segNum_, const double length_) const;

                double area() const;
                
                bool hasStraightSegs() const;

                bool isStraight() const;

                bool isRectangular() const;

                bool isCircular() const;

                bool angle(Angle& angle__) const;

                ArtboardSegPointVector segs(const int16_t segIndex_, const int16_t count_) const;

                ArtboardSegPointVector segPoints(const int16_t segPtIndex_, const int16_t count_) const;

                ArtboardSegPointVector phantomSeg() const;

                ArtboardSegPointVector phantomSegPoints() const;

                void setSegs(const int16_t segIndex_, const ArtboardSegPointVector& segPts_);

                void setSegPoints(const int16_t segPtIndex_, const ArtboardSegPointVector& segPts_);
                
                bool allSegPointsSelected() const;

                bool segSelected(const int16_t segIndex_) const;

                SegPointSelectionState segPointSelected(const int16_t segPtIndex_) const;

                bool setSegPointSelected(const int16_t segPtIndex_, const SegPointSelectionState selected_);

                void insertSegs(const int16_t segIndex_, const ArtboardSegPointVector& segPts_);

                void insertSegPoints(const int16_t segPtIndex_, const ArtboardSegPointVector& segPts_);

                void deleteSegs(const int16_t segIndex_, const int16_t count_);

                void deleteSegPoints(const int16_t segPtIndex_, const int16_t count_);

                void rotateSegPoints(const int16_t delta_);

                void reverseSegs();

                WindingOrderType windingOrder() const;

                void setWindingOrder(const WindingOrderType winding_);
                
                #if HDI_CORE_COMPILE_AI17_PLUS

                    enum StrokeAlignment
                    {
                        UnknownStrokeAlignment  = 0,
                        CenterStrokeAlignment   = 10,
                        InsideStrokeAlignment   = 20,
                        OutsideStrokeAlignment  = 30
                    };
                
                    void setStrokeAlignment(const StrokeAlignment align_);
                #endif

                void insertSegPointAtT(const int16_t segIndex_, const double t_);

                int16_t segPointClosestToPoint(const ArtboardPoint& pt_) const;

                bool containsPoint(const ArtboardPoint& pt_) const;

                HitDataVector getIntersections(const bool guides_ = false) const;

                HitDataVector getIntersections(const Art& target_, const bool guides_ = false) const;

                TrimError trim(
                    const HitData& center_,
                    const bool delete_,
                    const TrimDirectionType dir_,
                    const bool guides_,
                    Art& split__
                );

                ExtendError extend(const HitData& from_, const HitData& to_, const bool guides_);


            private:
                // Only Art can construct a new PathArt object
                friend class Art;

                Art* __art;
                
                PathArt();

                PathArt(Art* const art_);
            
                PathArt(const PathArt&);
            
                PathArt& operator=(const PathArt&);
        };
    }
}

hdi::core::PathArt::SegPointSelectionState operator|(
    const hdi::core::PathArt::SegPointSelectionState lhs_,
    const hdi::core::PathArt::SegPointSelectionState rhs_
);

hdi::core::PathArt::SegPointSelectionState& operator|=(
    hdi::core::PathArt::SegPointSelectionState& lhs__,
    const hdi::core::PathArt::SegPointSelectionState rhs_
);

hdi::core::PathArt::TrimDirectionType operator|(
    const hdi::core::PathArt::TrimDirectionType lhs_,
    const hdi::core::PathArt::TrimDirectionType rhs_
);

hdi::core::PathArt::TrimDirectionType& operator|=(
    hdi::core::PathArt::TrimDirectionType& lhs__,
    const hdi::core::PathArt::TrimDirectionType rhs_
);

#endif
// __HDI_CORE_PATH_ART__