pen.h

 
#ifndef _aspose_drawing_pen_h_
#define _aspose_drawing_pen_h_
 
#include "drawing/color.h"
#include "drawing/brush.h"
#include "drawing/drawing2d/line_cap.h"
#include "drawing/drawing2d/line_join.h"
#include "drawing/drawing2d/dash_cap.h"
#include "drawing/drawing2d/dash_style.h"
#include "drawing/drawing2d/pen_alignment.h"
#include "drawing/drawing2d/matrix.h"
#include "drawing/drawing2d/matrix_order.h"
#include "drawing/drawing2d/pen_type.h"
#include "system/exceptions.h"
#include <cstdint>
 
#ifdef ASPOSECPPLIB_BEING_BUILT
#include "core/SkColor.h"
#include "core/SkPath.h"
#include "core/SkPathEffect.h"
#endif
 
ASPOSECPP_3RD_PARTY_TYPEDEF(SkColor, std::uint32_t);
ASPOSECPP_3RD_PARTY_CLASS(SkPaint);
ASPOSECPP_3RD_PARTY_CLASS(SkPath);
ASPOSECPP_3RD_PARTY_CLASS(SkPathEffect);
ASPOSECPP_3RD_PARTY_TYPEDEF(SkScalar, float);
 
template <typename T> class sk_sp;
 
namespace System { namespace Drawing {
 
namespace Drawing2D { class CustomLineCap; }
namespace Drawing2D { class GraphicsPath; }
namespace Details { namespace Skia { class SkPaints; } }
 
class ASPOSECPP_SHARED_CLASS Pen : public Object
{
public:
    ASPOSECPP_SHARED_API Pen(const Color & color);
    ASPOSECPP_SHARED_API Pen(const Color & color, float width);
    ASPOSECPP_SHARED_API Pen(const SharedPtr<Brush>& brush);
    ASPOSECPP_SHARED_API Pen(const SharedPtr<Brush>& brush, float width);
 
    ASPOSECPP_SHARED_API Drawing2D::PenAlignment get_Alignment() const;
    ASPOSECPP_SHARED_API void set_Alignment(Drawing2D::PenAlignment value);
 
    ASPOSECPP_SHARED_API float get_Width() const;
    ASPOSECPP_SHARED_API void set_Width(float value);
 
    ASPOSECPP_SHARED_API Drawing2D::LineCap get_StartCap() const;
    ASPOSECPP_SHARED_API void set_StartCap(Drawing2D::LineCap value);
 
    ASPOSECPP_SHARED_API Drawing2D::LineCap get_EndCap() const;
    ASPOSECPP_SHARED_API void set_EndCap(Drawing2D::LineCap value);
 
    ASPOSECPP_SHARED_API Drawing2D::LineJoin get_LineJoin() const;
    ASPOSECPP_SHARED_API void set_LineJoin(Drawing2D::LineJoin value);
 
    ASPOSECPP_SHARED_API float get_MiterLimit() const;
    ASPOSECPP_SHARED_API void set_MiterLimit(float value);
 
    ASPOSECPP_SHARED_API float get_DashOffset() const;
    ASPOSECPP_SHARED_API void set_DashOffset(float value);
 
    ASPOSECPP_SHARED_API Drawing2D::DashCap get_DashCap() const;
    ASPOSECPP_SHARED_API void set_DashCap(Drawing2D::DashCap value);
 
    ASPOSECPP_SHARED_API Drawing2D::DashStyle get_DashStyle() const;
    ASPOSECPP_SHARED_API void set_DashStyle(Drawing2D::DashStyle value);
 
    ASPOSECPP_SHARED_API System::ArrayPtr<float> get_DashPattern() const;
    ASPOSECPP_SHARED_API void set_DashPattern(const System::ArrayPtr<float>& value);
 
    ASPOSECPP_SHARED_API System::ArrayPtr<float> get_CompoundArray() const;
    ASPOSECPP_SHARED_API void set_CompoundArray(const System::ArrayPtr<float>& value);
 
    ASPOSECPP_SHARED_API SharedPtr<Drawing2D::Matrix> get_Transform();
    ASPOSECPP_SHARED_API void set_Transform(const SharedPtr<Drawing2D::Matrix>& value);
 
    ASPOSECPP_SHARED_API void set_CustomStartCap(const SharedPtr<Drawing2D::CustomLineCap>& value);
    ASPOSECPP_SHARED_API void set_CustomEndCap(const SharedPtr<Drawing2D::CustomLineCap>& value);
    
    ASPOSECPP_SHARED_API void set_Brush(const SharedPtr<Brush>& brush);
    ASPOSECPP_SHARED_API SharedPtr<Brush> get_Brush();
 
    ASPOSECPP_SHARED_API void set_Color(const Color & color);
    ASPOSECPP_SHARED_API Color get_Color() const;
    ASPOSECPP_SHARED_API SharedPtr<Pen> Clone();
 
    ASPOSECPP_SHARED_API void ResetTransform();
 
    ASPOSECPP_SHARED_API void MultiplyTransform(const SharedPtr<Drawing2D::Matrix>& matrix, Drawing2D::MatrixOrder order = Drawing2D::MatrixOrder::Prepend);
    
    ASPOSECPP_SHARED_API void RotateTransform(float angle, Drawing2D::MatrixOrder order = Drawing2D::MatrixOrder::Prepend);
    ASPOSECPP_SHARED_API void ScaleTransform(float sx, float sy, Drawing2D::MatrixOrder order = Drawing2D::MatrixOrder::Prepend);
    ASPOSECPP_SHARED_API void TranslateTransform(float dx, float dy, Drawing2D::MatrixOrder order = Drawing2D::MatrixOrder::Prepend);
    ASPOSECPP_SHARED_API void SetLineCap(Drawing2D::LineCap startCap, Drawing2D::LineCap endCap, Drawing2D::DashCap dashCap);
    ASPOSECPP_SHARED_API Drawing2D::PenType get_PenType() const;
    void Dispose() { };
 
protected:
    friend class Graphics;
    friend class System::Drawing::Drawing2D::GraphicsPath;
    virtual ASPOSECPP_SHARED_API void Apply(SkPaint &paint, const SharedPtr<Drawing2D::Matrix>& matrix, bool antialiased = false,
        bool is_closed_path = false);
 
private:
    void Init();
    System::ArrayPtr<float> GetPatternForDashStyle(Drawing2D::DashStyle value);
 
    Details::Skia::SkPaints MakeCustomCaps(const SkPaint& base_paint, float& start_cap_inset, float& end_cap_inset,
                            float scale_x, float scale_y) const;
    
    Details::Skia::SkPaints MakeMainEffects(const SkPaint& base_paint, const SharedPtr<Drawing2D::Matrix>& matrix,
                                            float phase, float start_cap_inset, float end_cap_inset,
                                            bool is_closed_path) const;
    Details::Skia::SkPaints MakeCompoundEffect(const SkPaint& base_paint, sk_sp<SkPathEffect> dash_path_effect) const;
 
    void AppendCapsPath(const SkPath* src_path, SkPath* dest_path, SharedPtr<Drawing2D::CustomLineCap> start_cap,
        SharedPtr<Drawing2D::CustomLineCap> end_cap) const;
    
    void ApplyOutlineEffect(const SkPath* src_path, SkPath* dest_path) const;
 
    bool IsApplyDashCaps(bool is_closed_path) const;
 
private:
    SharedPtr<Brush> m_brush;
    SkScalar m_sk_width;
 
    float m_sk_miter_limit = 10.0f;
    float m_dash_offset = 0;
 
    Drawing2D::DashCap m_dash_cap;
    Drawing2D::LineCap m_start_cap;
    Drawing2D::LineCap m_end_cap;
    Drawing2D::DashStyle m_dash_style;
    Drawing2D::LineJoin m_line_join;
    Drawing2D::PenAlignment m_pen_alignment;
 
    ArrayPtr<float> m_dash_pattern;
    ArrayPtr<float> m_compound_array;
 
    SharedPtr<Drawing2D::CustomLineCap> m_custom_start_cap;
    SharedPtr<Drawing2D::CustomLineCap> m_custom_end_cap;
 
    SharedPtr<Drawing2D::Matrix> m_transform_matrix;
};
 
}} // System::Drawing
 
#endif // _aspose_drawing_pen_h_