source: Daodan/MSYS2/mingw32/i686-w64-mingw32/include/gdiplus/gdiplusmatrix.h

/*
 * gdiplusmatrix.h
 *
 * GDI+ Matrix class
 *
 * This file is part of the w32api package.
 *
 * Contributors:
 *   Created by Markus Koenig <markus@stber-koenig.de>
 *
 * THIS SOFTWARE IS NOT COPYRIGHTED
 *
 * This source code is offered for use in the public domain. You may
 * use, modify or distribute it freely.
 *
 * This code is distributed in the hope that it will be useful but
 * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
 * DISCLAIMED. This includes but is not limited to warranties of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 */

#ifndef __GDIPLUS_MATRIX_H
#define __GDIPLUS_MATRIX_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif

#ifndef __cplusplus
#error "A C++ compiler is required to include gdiplusmatrix.h."
#endif

#define GDIP_MATRIX_PI \
        3.1415926535897932384626433832795028841971693993751058209749445923078164

class Matrix: public GdiplusBase
{
        friend class Graphics;
        friend class GraphicsPath;
        friend class LinearGradientBrush;
        friend class PathGradientBrush;
        friend class Pen;
        friend class Region;
        friend class TextureBrush;

public:
        Matrix(): nativeMatrix(NULL), lastStatus(Ok)
        {
                lastStatus = DllExports::GdipCreateMatrix(&nativeMatrix);
        }
        Matrix(REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy):
                        nativeMatrix(NULL), lastStatus(Ok)
        {
                lastStatus = DllExports::GdipCreateMatrix2(
                                m11, m12, m21, m22, dx, dy,
                                &nativeMatrix);
        }
        Matrix(const RectF& rect, const PointF *dstplg):
                        nativeMatrix(NULL), lastStatus(Ok)
        {
                lastStatus = DllExports::GdipCreateMatrix3(
                                &rect, dstplg, &nativeMatrix);
        }
        Matrix(const Rect& rect, const Point *dstplg):
                        nativeMatrix(NULL), lastStatus(Ok)
        {
                lastStatus = DllExports::GdipCreateMatrix3I(
                                &rect, dstplg, &nativeMatrix);
        }
        ~Matrix()
        {
                DllExports::GdipDeleteMatrix(nativeMatrix);
        }
        Matrix* Clone() const
        {
                GpMatrix *cloneMatrix = NULL;
                Status status = updateStatus(DllExports::GdipCloneMatrix(
                                nativeMatrix, &cloneMatrix));
                if (status == Ok) {
                        Matrix *result = new Matrix(cloneMatrix, lastStatus);
                        if (!result) {
                                DllExports::GdipDeleteMatrix(cloneMatrix);
                                lastStatus = OutOfMemory;
                        }
                        return result;
                } else {
                        return NULL;
                }
        }

        BOOL Equals(const Matrix *matrix) const
        {
                BOOL result;
                updateStatus(DllExports::GdipIsMatrixEqual(
                                nativeMatrix,
                                matrix ? matrix->nativeMatrix : NULL, &result));
                return result;
        }
        Status GetElements(REAL *m) const
        {
                return updateStatus(DllExports::GdipGetMatrixElements(
                                nativeMatrix, m));
        }
        Status GetLastStatus() const
        {
                Status result = lastStatus;
                lastStatus = Ok;
                return result;
        }
        Status Invert()
        {
                return updateStatus(DllExports::GdipInvertMatrix(nativeMatrix));
        }
        BOOL IsIdentity() const
        {
                BOOL result;
                updateStatus(DllExports::GdipIsMatrixIdentity(
                                nativeMatrix, &result));
                return result;
        }
        BOOL IsInvertible() const
        {
                BOOL result;
                updateStatus(DllExports::GdipIsMatrixInvertible(
                                nativeMatrix, &result));
                return result;
        }
        Status Multiply(const Matrix *matrix,
                        MatrixOrder order = MatrixOrderPrepend)
        {
                return updateStatus(DllExports::GdipMultiplyMatrix(
                                nativeMatrix,
                                matrix ? matrix->nativeMatrix : NULL, order));
        }
        REAL OffsetX() const
        {
                REAL m[6];
                updateStatus(DllExports::GdipGetMatrixElements(nativeMatrix, m));
                return m[4];
        }
        REAL OffsetY() const
        {
                REAL m[6];
                updateStatus(DllExports::GdipGetMatrixElements(nativeMatrix, m));
                return m[5];
        }
        Status Reset()
        {
                return updateStatus(DllExports::GdipSetMatrixElements(
                                nativeMatrix,
                                1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
        }
        Status Rotate(REAL angle, MatrixOrder order = MatrixOrderPrepend)
        {
                return updateStatus(DllExports::GdipRotateMatrix(
                                nativeMatrix, angle, order));
        }
        Status RotateAt(REAL angle, const PointF& center,
                        MatrixOrder order = MatrixOrderPrepend)
        {
                REAL angleRadian = angle * GDIP_MATRIX_PI / 180.0f;
                REAL cosAngle = ::cos(angleRadian);
                REAL sinAngle = ::sin(angleRadian);
                REAL x = center.X;
                REAL y = center.Y;

                Matrix matrix2(cosAngle, sinAngle, -sinAngle, cosAngle,
                                x * (1.0f-cosAngle) + y * sinAngle,
                                -x * sinAngle + y * (1.0f-cosAngle));
                Status status = matrix2.GetLastStatus();
                if (status == Ok) {
                        return Multiply(&matrix2, order);
                } else {
                        return lastStatus = status;
                }
        }
        Status Scale(REAL scaleX, REAL scaleY,
                        MatrixOrder order = MatrixOrderPrepend)
        {
                return updateStatus(DllExports::GdipScaleMatrix(
                                nativeMatrix, scaleX, scaleY, order));
        }
        Status SetElements(REAL m11, REAL m12, REAL m21, REAL m22,
                        REAL dx, REAL dy)
        {
                return updateStatus(DllExports::GdipSetMatrixElements(
                                nativeMatrix, m11, m12, m21, m22, dx, dy));
        }
        Status Shear(REAL shearX, REAL shearY,
                        MatrixOrder order = MatrixOrderPrepend)
        {
                return updateStatus(DllExports::GdipShearMatrix(
                                nativeMatrix, shearX, shearY, order));
        }
        Status TransformPoints(PointF *pts, INT count = 1) const
        {
                return updateStatus(DllExports::GdipTransformMatrixPoints(
                                nativeMatrix, pts, count));
        }
        Status TransformPoints(Point *pts, INT count = 1) const
        {
                return updateStatus(DllExports::GdipTransformMatrixPointsI(
                                nativeMatrix, pts, count));
        }
        Status TransformVectors(PointF *pts, INT count = 1) const
        {
                return updateStatus(DllExports::GdipVectorTransformMatrixPoints(
                                nativeMatrix, pts, count));
        }
        Status TransformVectors(Point *pts, INT count = 1) const
        {
                return updateStatus(DllExports::GdipVectorTransformMatrixPointsI(
                                nativeMatrix, pts, count));
        }
        Status Translate(REAL offsetX, REAL offsetY,
                        MatrixOrder order = MatrixOrderPrepend)
        {
                return updateStatus(DllExports::GdipTranslateMatrix(
                                nativeMatrix, offsetX, offsetY, order));
        }

private:
        Matrix(GpMatrix *matrix, Status status):
                nativeMatrix(matrix), lastStatus(status) {}
        Matrix(const Matrix&);
        Matrix& operator=(const Matrix&);

        Status updateStatus(Status newStatus) const
        {
                if (newStatus != Ok) lastStatus = newStatus;
                return newStatus;
        }

        GpMatrix *nativeMatrix;
        mutable Status lastStatus;
};

#undef GDIP_MATRIX_PI

#endif /* __GDIPLUS_MATRIX_H */