texture_brush.h

 
#ifndef _aspose_drawing_texture_brush_h
#define _aspose_drawing_texture_brush_h
 
#include "fwd.h"
#include "brush.h"
#include "image.h"
#include "drawing2d/wrap_mode.h"
#include "drawing2d/matrix.h"
#include "drawing2d/matrix_order.h"
#include "rectangle.h"
#include "rectangle_f.h"
#include "imaging/image_attributes.h"
#include "drawing2d/wrap_mode.h"
 
#include <memory>
 
#ifdef ASPOSECPPLIB_BEING_BUILT
#include "core/SkShader.h"
#endif
 
ASPOSECPP_3RD_PARTY_CLASS(SkBitmap);
ASPOSECPP_3RD_PARTY_CLASS(SkMatrix);
ASPOSECPP_3RD_PARTY_CLASS(SkPaint);
ASPOSECPP_3RD_PARTY_CLASS(SkShader);
 
 
namespace System { namespace Drawing {
class ASPOSECPP_SHARED_CLASS TextureBrush : public Brush
{
    RTTI_INFO(System::Drawing::TextureBrush, ::System::BaseTypesInfo<System::Drawing::Brush>);
 
public:
    friend class Graphics;
 
    ASPOSECPP_SHARED_API TextureBrush(const SharedPtr<Image>& image, Drawing2D::WrapMode wrap_mode = Drawing2D::WrapMode::Tile);
    ASPOSECPP_SHARED_API TextureBrush(const SharedPtr<Image>& image, RectangleF dst_rect, const SharedPtr<Imaging::ImageAttributes>& image_attrs = nullptr);
    ASPOSECPP_SHARED_API TextureBrush(const SharedPtr<Image>& image, Rectangle dst_rect, const SharedPtr<Imaging::ImageAttributes>& image_attrs = nullptr);
    ASPOSECPP_SHARED_API TextureBrush(const SharedPtr<Image>& image, Drawing2D::WrapMode wrap_mode, RectangleF dst_rect);
    ASPOSECPP_SHARED_API TextureBrush(const SharedPtr<Image>& image, Drawing2D::WrapMode wrap_mode, Rectangle dst_rect);
    virtual ASPOSECPP_SHARED_API ~TextureBrush();
 
    ASPOSECPP_SHARED_API SharedPtr<Image> get_Image();
    ASPOSECPP_SHARED_API Drawing2D::WrapMode get_WrapMode();
    ASPOSECPP_SHARED_API void set_WrapMode(Drawing2D::WrapMode wrap_mode);
 
    ASPOSECPP_SHARED_API System::SharedPtr<Drawing2D::Matrix> get_Transform();
    ASPOSECPP_SHARED_API void set_Transform(const System::SharedPtr<Drawing2D::Matrix>& matrix);
 
    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<Drawing2D::Matrix>& matrix, Drawing2D::MatrixOrder order = Drawing2D::MatrixOrder::Prepend);
 
    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;
 
    ASPOSECPP_SHARED_API void InitBrushSettings(const SharedPtr<Image>& image, Drawing2D::WrapMode wrap_mode, Rectangle dst_rect);
 
    SharedPtr<Image> m_image;
    SharedPtr<Drawing2D::Matrix> m_transform_matrix = System::MakeObject<Drawing2D::Matrix>();
    Rectangle m_texture_rect;
 
    Drawing2D::WrapMode m_wrap_mode = Drawing2D::WrapMode::Tile;
    std::unique_ptr<SkBitmap> m_brush_bitmap;
 
private:
    TextureBrush(const TextureBrush& brush);
    MEMBER_FUNCTION_MAKE_OBJECT(TextureBrush, CODEPORTING_ARGS(const TextureBrush& brush), CODEPORTING_ARGS(brush));
};
 
}} // namespace System { namespace Drawing {
 
#endif // #ifndef texture_brush_h