path_gradient_brush.h

 
#ifndef _aspose_drawing_drawing2d_path_gradient_brush_h_
#define _aspose_drawing_drawing2d_path_gradient_brush_h_
 
#include "fwd.h"
#include "drawing/color.h"
#include "drawing/brush.h"
#include "drawing/rectangle_f.h"
#include "drawing/drawing2d/wrap_mode.h"
#include "drawing/drawing2d/matrix_order.h"
#include "drawing/point_f.h"
#include "system/array.h"
 
#ifdef ASPOSECPPLIB_BEING_BUILT
#include <core/SkColor.h>
#include <core/SkPoint.h>
#endif
ASPOSECPP_3RD_PARTY_TYPEDEF(SkColor, std::uint32_t);
ASPOSECPP_3RD_PARTY_CLASS(SkPaint);
ASPOSECPP_3RD_PARTY_STRUCT(SkPoint);
ASPOSECPP_3RD_PARTY_TYPEDEF(SkScalar, float);
 
 
namespace System { namespace Drawing { namespace Drawing2D {
 
class Blend;
class ColorBlend;
class GraphicsPath;
class Matrix;
class ASPOSECPP_SHARED_CLASS PathGradientBrush: public Brush
{
    RTTI_INFO(System::Drawing::Drawing2D::PathGradientBrush, ::System::BaseTypesInfo<System::Drawing::Brush>);
 
public:
 
    ASPOSECPP_SHARED_API PathGradientBrush(const ArrayPtr<PointF>& points, WrapMode wrapMode = WrapMode::Clamp);
    ASPOSECPP_SHARED_API PathGradientBrush(const ArrayPtr<Point>& points, WrapMode wrapMode = WrapMode::Clamp);
    ASPOSECPP_SHARED_API PathGradientBrush(const SharedPtr<GraphicsPath>& path);
 
    ASPOSECPP_SHARED_API WrapMode get_WrapMode() const;
    ASPOSECPP_SHARED_API void set_WrapMode(WrapMode value);
 
    ASPOSECPP_SHARED_API SharedPtr<ColorBlend> get_InterpolationColors() const;
    ASPOSECPP_SHARED_API void set_InterpolationColors(const SharedPtr<ColorBlend>& value);
 
    ASPOSECPP_SHARED_API PointF get_CenterPoint() const;
    ASPOSECPP_SHARED_API void set_CenterPoint(const PointF& value);
 
    ASPOSECPP_SHARED_API Color get_CenterColor() const;
    ASPOSECPP_SHARED_API ArrayPtr<Color> get_SurroundColors() const;
 
    ASPOSECPP_SHARED_API void ResetTransform();
    ASPOSECPP_SHARED_API void ScaleTransform(float sx, float sy, Drawing2D::MatrixOrder order = Drawing2D::MatrixOrder::Prepend);
    ASPOSECPP_SHARED_API void RotateTransform(float angle, 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 MultiplyTransform(const SharedPtr<Matrix>& matrix, MatrixOrder order = MatrixOrder::Prepend);
    ASPOSECPP_SHARED_API SharedPtr<Matrix> get_Transform() const;
    ASPOSECPP_SHARED_API void set_Transform(const SharedPtr<Matrix>& value);
 
    ASPOSECPP_SHARED_API void set_SurroundColors(const ArrayPtr<Color>& value);
    ASPOSECPP_SHARED_API void set_CenterColor(Color value);
    ASPOSECPP_SHARED_API void set_FocusScales(const PointF& value);
    ASPOSECPP_SHARED_API void SetSigmaBellShape(float focus, float scale = 1.0f);
    ASPOSECPP_SHARED_API SharedPtr<Blend> get_Blend() const;
    ASPOSECPP_SHARED_API void set_Blend(const SharedPtr<Blend>& value);
    ASPOSECPP_SHARED_API PointF get_FocusScales() const;
    ASPOSECPP_SHARED_API RectangleF get_Rectangle();
    ASPOSECPP_SHARED_API void SetBlendTriangularShape(float focus, float scale = 1.0f);
 
    virtual ASPOSECPP_SHARED_API SharedPtr<Brush> Clone() override;
 
protected:
    virtual ASPOSECPP_SHARED_API void Apply(SkPaint& paint, const SharedPtr<Drawing2D::Matrix>& matrix, bool apply_shift) override;
 
private:
    void ApplyPathGradient(SkPaint& paint, const SharedPtr<Drawing2D::Matrix>& matrix) const;
 
    void CalculateGradientColors() const;
 
private:
 
    PointF m_focus_scales;
    PointF m_center_point;
 
    SkColor m_center_color;
    ArrayPtr<Color> m_surround_colors;
 
    mutable std::vector<SkColor> m_colors;
    std::vector<float> m_factors;
    std::vector<SkScalar> m_positions;
    bool m_interpolation_colors = false;
 
    const RectangleF m_path_bounds;
    std::vector<SkPoint> m_path_points;
    WrapMode m_wrap_mode;
    SharedPtr<Matrix> m_transform_matrix;
 
};
 
}}}
 
#endif // _aspose_drawing_drawing2d_path_gradient_brush_h_