linear_gradient_brush.h

 
#pragma once
 
#include <array>
#include <tuple>
 
#include "fwd.h"
#include "drawing/brush.h"
#include "drawing/color.h"
#include "drawing/rectangle_f.h"
#include "drawing/drawing2d/linear_gradient_mode.h"
#include "drawing/drawing2d/matrix.h"
#include "drawing/drawing2d/matrix_order.h"
#include "drawing/drawing2d/wrap_mode.h"
 
#include <cstdint>
 
#ifdef ASPOSECPPLIB_BEING_BUILT
#include <core/SkPoint.h>
#include <core/SkColor.h>
#include <core/SkScalar.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 {
 
namespace Detail {
    typedef std::array<SkPoint, 2> SkPoints;
    ASPOSECPP_3RD_PARTY_TYPE_HOLDER_HIDDEN_TYPE(SkPoints, SkPoints, 2*2*sizeof(float), float, SkPointsHolder);
}
 
class Blend;
class ColorBlend;
 
class ASPOSECPP_SHARED_CLASS LinearGradientBrush: public Brush
{
    RTTI_INFO(System::Drawing::Drawing2D::LinearGradientBrush, ::System::BaseTypesInfo<System::Drawing::Brush>);
 
public:
    ASPOSECPP_SHARED_API LinearGradientBrush(const PointF& point1, const PointF& point2, const Color& color1, const Color& color2);
    ASPOSECPP_SHARED_API LinearGradientBrush(const Point& point1, const Point& point2, const Color& color1, const Color& color2);
    ASPOSECPP_SHARED_API LinearGradientBrush(const RectangleF& rect, const Color& color1, const Color& color2, LinearGradientMode linearGradientMode);
    ASPOSECPP_SHARED_API LinearGradientBrush(const Rectangle& rect, const Color& color1, const Color& color2, LinearGradientMode linearGradientMode);
    ASPOSECPP_SHARED_API LinearGradientBrush(const RectangleF& rect, const Color& color1, const Color& color2, float angle, bool isAngleScaleable = false);
    ASPOSECPP_SHARED_API LinearGradientBrush(const Rectangle& rect, const Color& color1, const Color& color2, float angle, bool isAngleScaleable = false);
 
    ASPOSECPP_SHARED_API void ResetTransform();
    ASPOSECPP_SHARED_API void MultiplyTransform(const SharedPtr<Matrix>& matrix, MatrixOrder order = MatrixOrder::Prepend);
    ASPOSECPP_SHARED_API void RotateTransform(float angle, MatrixOrder order = MatrixOrder::Prepend);
    ASPOSECPP_SHARED_API void ScaleTransform(float sx, float sy, MatrixOrder order = MatrixOrder::Prepend);
    ASPOSECPP_SHARED_API void TranslateTransform(float dx, float dy, Drawing2D::MatrixOrder order = Drawing2D::MatrixOrder::Prepend);
 
    ASPOSECPP_SHARED_API WrapMode get_WrapMode() const;
    ASPOSECPP_SHARED_API void set_WrapMode(WrapMode value);
    ASPOSECPP_SHARED_API SharedPtr<Blend> get_Blend() const;
    ASPOSECPP_SHARED_API void set_Blend(const SharedPtr<Blend>& value);
 
    ASPOSECPP_SHARED_API SharedPtr<ColorBlend> get_InterpolationColors() const;
    ASPOSECPP_SHARED_API void set_InterpolationColors(const SharedPtr<ColorBlend>& value);
 
    ASPOSECPP_SHARED_API SharedPtr<Matrix> get_Transform() const;
    ASPOSECPP_SHARED_API void set_Transform(const SharedPtr<Matrix>& value);
 
    ASPOSECPP_SHARED_API void SetSigmaBellShape(float focus, float scale = 1.0f);
 
    ASPOSECPP_SHARED_API RectangleF get_Rectangle();
 
    ASPOSECPP_SHARED_API bool get_GammaCorrection() const;
    ASPOSECPP_SHARED_API void set_GammaCorrection(bool value);
 
    ASPOSECPP_SHARED_API ArrayPtr<Color> get_LinearColors() const;
    ASPOSECPP_SHARED_API void set_LinearColors(const ArrayPtr<Color>& value);
 
    ASPOSECPP_SHARED_API void SetBlendTriangularShape(float focus, float scale = 1.0f);
    ASPOSECPP_SHARED_API SharedPtr<Brush> Clone() override;
 
protected:
    ASPOSECPP_SHARED_API void Apply(SkPaint& paint, const SharedPtr<Drawing2D::Matrix>& matrix, bool apply_shift) override;
 
private:
    typedef std::tuple<Detail::SkPointsHolder, RectangleF, float, bool> GradientInnerData;
 
    LinearGradientBrush(const GradientInnerData& data, const Color& color1, const Color& color2);
 
    static GradientInnerData CalculateInnerData(const PointF& point1, const PointF& point2);
    static GradientInnerData CalculateInnerData(const RectangleF& rect, float angle, bool isAngleScaleable);
 
    static float GetAngleFromMode(LinearGradientMode mode);
 
    void SetupInitialMatrix(bool isAngleScaleable);
 
    void InterpolateColors();
 
private:
    const Detail::SkPointsHolder m_points;
    const RectangleF m_rectangle;
    const float m_angle;
 
    SkColor m_color1;
    SkColor m_color2;
 
    std::vector<SkColor> m_colors;
    std::vector<float> m_factors;
    std::vector<SkScalar> m_positions;
    bool m_interpolation_colors = false;
 
    WrapMode m_wrap_mode = WrapMode::Tile;
    SharedPtr<Drawing2D::Matrix> m_transform_matrix;
 
    bool m_gamma_correction = false;
};
 
}}}