graphics_path.h

 
#ifndef _aspose_drawing_drawing2d_graphics_path_h_
#define _aspose_drawing_drawing2d_graphics_path_h_
 
#include "system/object.h"
#include "system/enum_helpers.h"
#include "drawing/pen.h"
#include "drawing/point.h"
#include "drawing/point_f.h"
#include "drawing/rectangle.h"
#include "drawing/rectangle_f.h"
#include "drawing/font_family.h"
#include "drawing/string_format.h"
#include "drawing/drawing2d/matrix.h"
#include "drawing/drawing2d/fill_mode.h"
#include "drawing/drawing2d/path_data.h"
#include "drawing/drawing2d/path_point_type.h"
 
#include <memory>
 
#ifdef ASPOSECPPLIB_BEING_BUILT
#include <core/SkPath.h>
#endif
 
ASPOSECPP_3RD_PARTY_CLASS(SkPath);
ASPOSECPP_3RD_PARTY_CLASS(SkMatrix);
ASPOSECPP_3RD_PARTY_STRUCT(SkRect);
ASPOSECPP_3RD_PARTY_TYPEDEF(SkScalar, float);
 
 
namespace System { namespace Drawing { class Graphics; } }
namespace System { namespace Drawing { class Region; } }
namespace System { namespace Drawing { namespace Details { namespace Skia { class SkiaData; } } } }
 
namespace System { namespace Drawing { namespace Drawing2D {
 
namespace Detail {
    enum class FigureType {
        Unknown   = (0x0),
        Line      = (0x01 << 0),
        Bezier    = (0x01 << 1),
        Arc       = (0x01 << 2),
        Ellipse   = (0x01 << 3),
        Pie       = (0x01 << 4),
        Rectangle = (0x01 << 5),
        Polygon   = (0x01 << 6),
        Curve     = (0x01 << 7),
        String    = (0x01 << 8)
    };
 
    DECLARE_ENUM_OPERATORS(System::Drawing::Drawing2D::Detail::FigureType);
    DECLARE_USING_GLOBAL_OPERATORS
}
 
class PathGradientBrush;
class ASPOSECPP_SHARED_CLASS GraphicsPath : public Object
{
public:
    ASPOSECPP_SHARED_API GraphicsPath(FillMode fillMode = FillMode::Alternate);
    ASPOSECPP_SHARED_API GraphicsPath(const ArrayPtr<Point>& pts, const ArrayPtr<uint8_t>& types, FillMode fillMode = FillMode::Alternate);
    ASPOSECPP_SHARED_API GraphicsPath(const ArrayPtr<PointF>& pts, const ArrayPtr<uint8_t>& types, FillMode fillMode = FillMode::Alternate);
 
    ASPOSECPP_SHARED_API GraphicsPath(const SkPath& path);
 
    ASPOSECPP_SHARED_API ~GraphicsPath();
 
    ASPOSECPP_SHARED_API SharedPtr<PathData> get_PathData();
    ASPOSECPP_SHARED_API ArrayPtr<uint8_t> get_PathTypes() const;
    ASPOSECPP_SHARED_API ArrayPtr<PointF> get_PathPoints() const;
    ASPOSECPP_SHARED_API int get_PointCount() const;
    ASPOSECPP_SHARED_API void Reverse();
 
    ASPOSECPP_SHARED_API FillMode get_FillMode();
    ASPOSECPP_SHARED_API void set_FillMode(FillMode mode);
 
    ASPOSECPP_SHARED_API void AddBezier(const Point& pt1, const Point& pt2, const Point& pt3, const Point& pt4);
    ASPOSECPP_SHARED_API void AddBezier(const PointF& pt1, const PointF& pt2, const PointF& pt3, const PointF& pt4);
    ASPOSECPP_SHARED_API void AddBezier(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4);
    ASPOSECPP_SHARED_API void AddBezier(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4);
    ASPOSECPP_SHARED_API void AddBeziers(const ArrayPtr<Point>& points);
    ASPOSECPP_SHARED_API void AddBeziers(const ArrayPtr<PointF>& points);
 
    ASPOSECPP_SHARED_API void AddLine(const Point& pt1, const Point& pt2);
    ASPOSECPP_SHARED_API void AddLine(const PointF& pt1, const PointF& pt2);
    ASPOSECPP_SHARED_API void AddLine(int x1, int y1, int x2, int y2);
    ASPOSECPP_SHARED_API void AddLine(float x1, float y1, float x2, float y2);
 
    ASPOSECPP_SHARED_API void AddLines(const ArrayPtr<PointF>& points);
    ASPOSECPP_SHARED_API void AddLines(const ArrayPtr<Point>& points);
 
    ASPOSECPP_SHARED_API void AddString(const String& text, const SharedPtr<FontFamily>& family, int style, float emSize, Point origin,
        const SharedPtr<StringFormat>& stringFormat);
    ASPOSECPP_SHARED_API void AddString(const String& text, const SharedPtr<FontFamily>& family, int style, float emSize, PointF origin,
        const SharedPtr<StringFormat>& stringFormat);
    ASPOSECPP_SHARED_API void AddString(const String& text, const SharedPtr<FontFamily>& family, int style, float emSize, Rectangle layoutRect,
        const SharedPtr<StringFormat>& stringFormat);
    ASPOSECPP_SHARED_API void AddString(const String& text, const SharedPtr<FontFamily>& family, int style, float emSize, RectangleF layoutRect,
        const SharedPtr<StringFormat>& stringFormat);
 
    ASPOSECPP_SHARED_API void AddArc(float x, float y, float width, float height, float startAngle, float sweepAngle);
    ASPOSECPP_SHARED_API void AddArc(int x, int y, int width, int height, float startAngle, float sweepAngle);
    ASPOSECPP_SHARED_API void AddArc(const RectangleF& rect, float startAngle, float sweepAngle);
    ASPOSECPP_SHARED_API void AddArc(const Rectangle& rect, float startAngle, float sweepAngle);
 
    ASPOSECPP_SHARED_API void AddEllipse(float x, float y, float width, float height);
    ASPOSECPP_SHARED_API void AddEllipse(int x, int y, int width, int height);
    ASPOSECPP_SHARED_API void AddEllipse(const RectangleF &rect);
    ASPOSECPP_SHARED_API void AddEllipse(const Rectangle &rect);
 
    ASPOSECPP_SHARED_API void AddPie(float x, float y, float width, float height, float startAngle, float sweepAngle);
    ASPOSECPP_SHARED_API void AddPie(int x, int y, int width, int height, float startAngle, float sweepAngle);
    ASPOSECPP_SHARED_API void AddPie(const Rectangle& rect, float startAngle, float sweepAngle);
 
    ASPOSECPP_SHARED_API void AddPath(const SharedPtr<GraphicsPath>& path, bool connect);
 
    ASPOSECPP_SHARED_API void AddRectangle(const Rectangle& rect);
    ASPOSECPP_SHARED_API void AddRectangle(const RectangleF& rect);
 
    ASPOSECPP_SHARED_API void AddRectangles(const ArrayPtr<Rectangle>& rects);
    ASPOSECPP_SHARED_API void AddRectangles(const ArrayPtr<RectangleF>& rects);
 
    ASPOSECPP_SHARED_API void AddPolygon(const ArrayPtr<PointF>& points);
 
    ASPOSECPP_SHARED_API void AddPolygon(const ArrayPtr<Point>& points);
 
    ASPOSECPP_SHARED_API void AddCurve(const ArrayPtr<PointF>& points, float tension = 0.5);
    ASPOSECPP_SHARED_API void AddCurve(const ArrayPtr<Point>& points, float tension = 0.5);
    ASPOSECPP_SHARED_API void AddCurve(const ArrayPtr<PointF>& points, int offset, int number_of_segments, float tension);
    ASPOSECPP_SHARED_API void AddCurve(const ArrayPtr<Point>& points, int offset, int number_of_segments, float tension);
 
    ASPOSECPP_SHARED_API void AddClosedCurve(const ArrayPtr<PointF>& points, float tension = 0.5);
    ASPOSECPP_SHARED_API void AddClosedCurve(const ArrayPtr<Point>& points, float tension = 0.5);
 
    ASPOSECPP_SHARED_API void StartFigure();
    ASPOSECPP_SHARED_API void CloseFigure();
    ASPOSECPP_SHARED_API void CloseAllFigures();
 
    ASPOSECPP_SHARED_API RectangleF GetBounds(const MatrixPtr& matrix = nullptr, const SharedPtr<Pen>& pen = nullptr) const;
         
    ASPOSECPP_SHARED_API PointF GetLastPoint() const;
 
    ASPOSECPP_SHARED_API void Reset();
 
    ASPOSECPP_SHARED_API void Transform(const MatrixPtr& matrix);
    ASPOSECPP_SHARED_API void Transform(const SkMatrix& matrix);
 
    ASPOSECPP_SHARED_API void Flatten();
    ASPOSECPP_SHARED_API void Flatten(const MatrixPtr& matrix);
    ASPOSECPP_SHARED_API void Flatten(const MatrixPtr& matrix, float flatness);
 
    ASPOSECPP_SHARED_API void Widen(const SharedPtr<Pen>& pen);
 
    ASPOSECPP_SHARED_API bool IsVisible(const PointF& point);
    ASPOSECPP_SHARED_API bool IsVisible(float x, float y);
    ASPOSECPP_SHARED_API bool IsOutlineVisible(const PointF& point, const SharedPtr<Pen>& pen);
 
    virtual ASPOSECPP_SHARED_API SharedPtr<GraphicsPath> Clone();
    void Dispose() { };
 
    Detail::FigureType GetFigureFlags() { return m_figure_flags; }
    ASPOSECPP_SHARED_API void SetMarkers();
    
protected:
    friend class System::Drawing::Graphics;
    friend class CustomLineCap;
    friend class PathGradientBrush;
    friend class Details::Skia::SkiaData;
 
    std::shared_ptr<SkPath> m_sk_path;
    bool m_figure_started = true;
    Detail::FigureType m_figure_flags = Detail::FigureType::Unknown;
 
    ASPOSECPP_SHARED_API void AddBezierImpl(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3, SkScalar x4, SkScalar y4);
    ASPOSECPP_SHARED_API void AddLineImpl(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2);
    ASPOSECPP_SHARED_API void AddArcImpl(SkScalar left, SkScalar top, SkScalar width, SkScalar height, SkScalar startAngle, SkScalar sweepAngle);
    ASPOSECPP_SHARED_API void AddEllipseImpl(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom);
    ASPOSECPP_SHARED_API void AddPieImpl(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom, SkScalar startAngle, SkScalar sweepAngle);
    ASPOSECPP_SHARED_API void AddStringImpl(const String & text, const SharedPtr<FontFamily>& family, int style, float emSize, SkRect layoutRect, const SharedPtr<StringFormat>& stringFormat);
 
    std::shared_ptr<SkPath> GetSkPath(const SharedPtr<Pen>& pen, const SkMatrix& matrix);
 
    ASPOSECPP_SHARED_API ArrayPtr<uint8_t> get_PathTypesImpl(bool forceClose) const;
 
    ASPOSECPP_SHARED_API ArrayPtr<uint8_t> get_PathTypesImpl() const;
 
    static ASPOSECPP_SHARED_API SkPath ConvertCurves(const SkPath& source);
 
    static ASPOSECPP_SHARED_API bool NeedConvertCurves(const SkPath& source);
 
private:
    bool IsClosedPath() const;
    std::shared_ptr<SkPath> GetFlattenPath() const;
};
 
}}}
DECLARE_USING_ENUM_OPERATORS(System::Drawing::Drawing2D::Detail);  
 
 
#endif // _aspose_drawing_drawing2d_graphics_path_h_