mirror of
https://github.com/QB64-Phoenix-Edition/QB64pe.git
synced 2024-09-07 15:20:18 +00:00
240 lines
6 KiB
C++
240 lines
6 KiB
C++
/*
|
|
* 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 */
|