matrix.h

 
#ifndef _aspose_drawing_drawing2d_matrix_h_
#define _aspose_drawing_drawing2d_matrix_h_
 
#include "system/array.h"
#include "fwd.h"
 
#include "drawing/drawing2d/matrix_order.h"
#include "drawing/point.h"
#include "drawing/point_f.h"
#include "drawing/point.h"
#include "drawing/rectangle_f.h"
 
#include "system/details/array_view.h"
 
#include <cstdint>
 
#ifdef ASPOSECPPLIB_BEING_BUILT
#include "core/SkMatrix.h"
#endif
 
ASPOSECPP_3RD_PARTY_CLASS(SkMatrix);
 
namespace System { namespace Drawing { class Graphics; } }
namespace System { namespace Drawing { class Region; } }
namespace System { namespace Drawing { class TextureBrush; } }
namespace System { namespace Drawing { class Pen; } }
 
namespace System { namespace Drawing { namespace Drawing2D {
 
namespace Detail {
    ASPOSECPP_3RD_PARTY_TYPE_HOLDER(SkMatrix, SkMatrix, 9*sizeof(float) + sizeof(std::int32_t), float, SkMatrixHolder);
}
 
 
    class Matrix;
    typedef SharedPtr<Matrix> MatrixPtr;
 
    class ASPOSECPP_SHARED_CLASS Matrix: public Object
    {
    public:
        ASPOSECPP_SHARED_API Matrix();
        ASPOSECPP_SHARED_API Matrix(float m11, float m12, float m21, float m22, float dx, float dy);
        ASPOSECPP_SHARED_API Matrix(const Rectangle& rect, const ArrayPtr<Point>& plgpts);
        ASPOSECPP_SHARED_API Matrix(const RectangleF& rect, const ArrayPtr<PointF>& plgpts);
        virtual ASPOSECPP_SHARED_API ~Matrix();
 
        ASPOSECPP_SHARED_API System::ArrayPtr<float> get_Elements() const;
        ASPOSECPP_SHARED_API float get_OffsetX() const;
        ASPOSECPP_SHARED_API float get_OffsetY() const;
        ASPOSECPP_SHARED_API bool get_IsIdentity() const;
        ASPOSECPP_SHARED_API bool get_IsInvertible() const;
 
        ASPOSECPP_SHARED_API void Invert();
        ASPOSECPP_SHARED_API void Reset();
        ASPOSECPP_SHARED_API void Multiply(const SharedPtr<Matrix>& matrix);
        ASPOSECPP_SHARED_API void Multiply(const SharedPtr<Matrix>& matrix, MatrixOrder order);
        ASPOSECPP_SHARED_API void Rotate(float angle);
        ASPOSECPP_SHARED_API void Rotate(float angle, MatrixOrder order);
        ASPOSECPP_SHARED_API void RotateAt(float angle, const PointF& point);
        ASPOSECPP_SHARED_API void RotateAt(float angle, const PointF& point, MatrixOrder order);
        ASPOSECPP_SHARED_API void Scale(float scaleX, float scaleY);
        ASPOSECPP_SHARED_API void Scale(float scaleX, float scaleY, MatrixOrder order);
 
        ASPOSECPP_SHARED_API void Shear(float shearX, float shearY);
        ASPOSECPP_SHARED_API void Shear(float shearX, float shearY, MatrixOrder order);
        ASPOSECPP_SHARED_API void Translate(float offsetX, float offsetY);
        ASPOSECPP_SHARED_API void Translate(float offsetX, float offsetY, MatrixOrder order);
 
        ASPOSECPP_SHARED_API void TransformPoints(const ArrayPtr<Point>& pts);
        ASPOSECPP_SHARED_API void TransformPoints(const System::Details::ArrayView<Point>& pts);
 
        ASPOSECPP_SHARED_API void TransformPoints(const ArrayPtr<PointF>& pts);
        ASPOSECPP_SHARED_API void TransformPoints(const System::Details::ArrayView<PointF>& pts);
 
        ASPOSECPP_SHARED_API void TransformVectors(const ArrayPtr<Point>& pts);
        ASPOSECPP_SHARED_API void TransformVectors(const System::Details::ArrayView<Point>& pts);
 
        ASPOSECPP_SHARED_API void TransformVectors(const ArrayPtr<PointF>& pts);
        ASPOSECPP_SHARED_API void TransformVectors(const System::Details::ArrayView<PointF>& pts);
 
        ASPOSECPP_SHARED_API void VectorTransformPoints(const ArrayPtr<Point>& pts);
        ASPOSECPP_SHARED_API void VectorTransformPoints(const System::Details::ArrayView<Point>& pts);
 
        bool Equals(ptr obj) override;
 
        ASPOSECPP_SHARED_API SharedPtr<Matrix> Clone() const;
 
        void Dispose() {}
 
    private:
 
        friend class GraphicsPath;
        friend class System::Drawing::TextureBrush;
        friend class System::Drawing::Graphics;
        friend class System::Drawing::Region;
        friend class System::Drawing::Pen;
        friend class LinearGradientBrush;
        friend class PathGradientBrush;
        friend class HatchBrush;
 
        Detail::SkMatrixHolder m_sk_matrix;
        bool m_is_identity = true;
 
        void Assign(const SkMatrix& m);
 
#if defined(_DEBUG) && defined(_MSC_VER)
        struct MatrixDebugHelper
        {
            float fMat[9];
            uint32_t fTypeMask;
        };
#endif
    };
 
}}}
 
 
#endif