hdicoreBezier.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_BEZIER__
#define __HDI_CORE_BEZIER__
 
#if defined(HDI_CORE_AIP_MODE)
 
#include "hdicoreAngle.h"
#include "hdicoreArtboardRect.h"
 
namespace hdi
{
    namespace aip
    {
        class Bezier;
    }
 
    namespace core
    {
        class ArtboardSegPoint;
    
        class Bezier
        {
            public:
                enum AdjustmentResult
                {
                    AdjustmentReflectedStartOut = 1 << 0,
                    AdjustmentReflectedEndIn    = 1 << 1,
                    AdjustmentRotatedStartOut   = 1 << 2,
                    AdjustmentRotatedEndIn      = 1 << 3
                };
                
                Bezier();
 
                Bezier(const Bezier& bez_);
 
                Bezier(const ArtboardSegPoint& segPt1_, const ArtboardSegPoint& segPt2_);
 
                Bezier(
                    const ArtboardPoint& start_,
                    const ArtboardPoint& startOut_,
                    const ArtboardPoint& endIn_,
                    const ArtboardPoint& end_
                );
 
                virtual ~Bezier();
 
                virtual Bezier& operator=(const Bezier& rhs_);
 
                virtual ArtboardPoint startPoint() const;
 
                virtual ArtboardPoint startOutPoint() const;
 
                virtual ArtboardPoint endInPoint() const;
 
                virtual ArtboardPoint endPoint() const;
 
                virtual AdjustmentResult adjustThruPoint(const ArtboardPoint& pt_, const double t_);
 
                virtual void divide(const double t_, Bezier& bez1__, Bezier& bez2__) const;
 
                virtual Bezier section(const double startT_, const double endT_) const;
 
                virtual ArtboardPoint evaluate(const double t_) const;
 
                virtual double length() const;
 
                virtual double sublength(const double startT_, const double endT_) const;
 
                virtual double tAtLength(const double length_) const;
 
                virtual void setPoints(
                    const ArtboardPoint& start_,
                    const ArtboardPoint& startOut_,
                    const ArtboardPoint& endIn_,
                    const ArtboardPoint& end_
                );
                
                virtual Angle tangentAngle(const double t_) const;
                
                virtual Angle normalAngle(const double t_) const;
                
                virtual bool curved() const;
 
                virtual bool radius(const double t_, double& radius__) const;
 
                virtual bool center(const double t_, ArtboardPoint& center__) const;
 
                virtual bool radiusAndCenter(const double t_, double& radius__, ArtboardPoint& center__) const;
 
                virtual bool isCircularArc() const;
 
                virtual ArtboardRect bounds() const;
                
                virtual bool operator==(const Bezier& rhs_) const;
                
                virtual bool operator!=(const Bezier& rhs_) const;
 
 
            private:
                friend aip::Bezier* __accessImpl(const Bezier&);
                friend Bezier __accessCtor(const aip::Bezier&);
 
                aip::Bezier* __impl;
 
                Bezier(const aip::Bezier&);
        };
        
        typedef std::unique_ptr<Bezier> BezierUP;
        typedef std::shared_ptr<Bezier> BezierSP;
        typedef std::weak_ptr<Bezier> BezierWP;
        
        extern aip::Bezier* __accessImpl(const Bezier&);
        extern Bezier __accessCtor(const aip::Bezier&);
    }
}
 
hdi::core::Bezier::AdjustmentResult operator|(
    const hdi::core::Bezier::AdjustmentResult lhs_,
    const hdi::core::Bezier::AdjustmentResult rhs_
);
 
hdi::core::Bezier::AdjustmentResult& operator|=(
    hdi::core::Bezier::AdjustmentResult& lhs__,
    const hdi::core::Bezier::AdjustmentResult rhs_
);
 
#endif
// HDI_CORE_AIP_MODE
 
#endif
// __HDI_CORE_BEZIER__