1 files changed, 309 insertions, 0 deletions
diff --git a/core/src/fxge/Microsoft SDK/include/GdiPlusMatrix.h b/core/src/fxge/Microsoft SDK/include/GdiPlusMatrix.h
new file mode 100644
index 0000000000..7fa3df8cd1
--- /dev/null
+++ b/core/src/fxge/Microsoft SDK/include/GdiPlusMatrix.h
@@ -0,0 +1,309 @@
+/**************************************************************************\
+* 
+* Copyright (c) 1998-2000, Microsoft Corp.  All Rights Reserved.
+*
+* Module Name:
+*
+*   GdiplusMatrix.h
+*
+* Abstract:
+*
+*   GDI+ Matrix class
+*
+\**************************************************************************/
+
+class Matrix : public GdiplusBase
+{
+public:
+    friend class Graphics;
+    friend class GraphicsPath;
+    friend class TextureBrush;
+    friend class LinearGradientBrush;
+    friend class PathGradientBrush;
+    friend class Pen;
+    friend class Region;
+    
+    // Default constructor - set to identity matrix
+
+    Matrix()
+    {
+        GpMatrix *matrix = NULL;
+
+        lastResult = DllExports::GdipCreateMatrix(&matrix);
+    
+        SetNativeMatrix(matrix);
+    }
+
+    Matrix(IN REAL m11, 
+           IN REAL m12,
+           IN REAL m21, 
+           IN REAL m22,
+           IN REAL dx, 
+           IN REAL dy)
+    {
+        GpMatrix *matrix = NULL;
+
+        lastResult = DllExports::GdipCreateMatrix2(m11, m12, m21, m22, 
+                                                      dx, dy, &matrix);
+    
+        SetNativeMatrix(matrix);
+    }
+    
+    Matrix(IN const RectF& rect, 
+           IN const PointF* dstplg)
+    {
+        GpMatrix *matrix = NULL;
+
+        lastResult = DllExports::GdipCreateMatrix3(&rect, 
+                                                   dstplg,
+                                                   &matrix);
+
+        SetNativeMatrix(matrix);
+    }
+
+    Matrix(IN const Rect& rect, 
+           IN const Point* dstplg)
+    {
+        GpMatrix *matrix = NULL;
+
+        lastResult = DllExports::GdipCreateMatrix3I(&rect, 
+                                                    dstplg,
+                                                    &matrix);
+
+        SetNativeMatrix(matrix);
+    }
+
+    ~Matrix()
+    {
+        DllExports::GdipDeleteMatrix(nativeMatrix);
+    }
+
+    Matrix *Clone() const
+    {
+        GpMatrix *cloneMatrix = NULL;
+
+        SetStatus(DllExports::GdipCloneMatrix(nativeMatrix,
+                                                  &cloneMatrix));
+
+        if (lastResult != Ok)
+            return NULL;
+
+        return new Matrix(cloneMatrix);
+    }
+
+    Status GetElements(OUT REAL *m) const 
+    {
+        return SetStatus(DllExports::GdipGetMatrixElements(nativeMatrix, m));
+    }
+    
+    Status SetElements(IN REAL m11, 
+                       IN REAL m12, 
+                       IN REAL m21, 
+                       IN REAL m22, 
+                       IN REAL dx, 
+                       IN REAL dy)
+    {
+        return SetStatus(DllExports::GdipSetMatrixElements(nativeMatrix,
+                            m11, m12, m21, m22, dx, dy));
+    }
+
+    REAL OffsetX() const
+    {
+        REAL elements[6];
+
+        if (GetElements(&elements[0]) == Ok)
+            return elements[4];
+        else 
+            return 0.0f;
+    }
+
+    REAL OffsetY() const
+    {
+       REAL elements[6];
+
+       if (GetElements(&elements[0]) == Ok)
+           return elements[5];
+       else 
+           return 0.0f;
+    }
+
+    Status Reset()
+    {
+        // set identity matrix elements 
+        return SetStatus(DllExports::GdipSetMatrixElements(nativeMatrix,
+                                             1.0, 0.0, 0.0, 1.0, 0.0, 0.0));
+    }
+
+    Status Multiply(IN const Matrix *matrix, 
+                    IN MatrixOrder order = MatrixOrderPrepend)
+    {
+        return SetStatus(DllExports::GdipMultiplyMatrix(nativeMatrix, 
+                                          matrix->nativeMatrix,
+                                          order));
+    }
+
+    Status Translate(IN REAL offsetX, 
+                     IN REAL offsetY, 
+                     IN MatrixOrder order = MatrixOrderPrepend)
+    {
+        return SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix, offsetX, offsetY, order));
+    }
+
+    Status Scale(IN REAL scaleX, 
+                 IN REAL scaleY, 
+                 IN MatrixOrder order = MatrixOrderPrepend)
+    {
+        return SetStatus(DllExports::GdipScaleMatrix(nativeMatrix, scaleX, scaleY, order));
+    }
+
+    Status Rotate(IN REAL angle, 
+                  IN MatrixOrder order = MatrixOrderPrepend)
+    {
+        return SetStatus(DllExports::GdipRotateMatrix(nativeMatrix, angle, order));
+    }
+    
+    Status RotateAt(IN REAL angle, 
+                    IN const PointF& center, 
+                    IN MatrixOrder order = MatrixOrderPrepend)
+    {
+        if(order == MatrixOrderPrepend)
+        {
+            SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix, center.X, center.Y, order));
+            SetStatus(DllExports::GdipRotateMatrix(nativeMatrix, angle, order));
+            return SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix, - center.X, - center.Y, order));
+        }
+        else
+        {
+            SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix, - center.X, - center.Y, order));
+            SetStatus(DllExports::GdipRotateMatrix(nativeMatrix, angle, order));
+            return SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix, center.X, center.Y, order));
+        }
+    }
+
+    Status Shear(IN REAL shearX, 
+                 IN REAL shearY,
+                 IN MatrixOrder order = MatrixOrderPrepend)
+    {
+        return SetStatus(DllExports::GdipShearMatrix(nativeMatrix, shearX, shearY, order));
+    }
+
+    Status Invert()
+    {
+        return SetStatus(DllExports::GdipInvertMatrix(nativeMatrix));
+    }
+
+    // float version
+    Status TransformPoints(IN OUT PointF* pts, 
+                           IN INT count = 1) const
+    {
+        return SetStatus(DllExports::GdipTransformMatrixPoints(nativeMatrix, pts, count));
+    }
+    
+    Status TransformPoints(IN OUT Point* pts, 
+                           IN INT count = 1) const
+    {
+        return SetStatus(DllExports::GdipTransformMatrixPointsI(nativeMatrix, 
+                                                                pts, 
+                                                                count));
+    }
+
+    Status TransformVectors(IN OUT PointF* pts, 
+                            IN INT count = 1) const
+    { 
+        return SetStatus(DllExports::GdipVectorTransformMatrixPoints(nativeMatrix, pts, count));
+    }
+
+    Status TransformVectors(IN OUT Point* pts, 
+                            IN INT count = 1) const
+    { 
+       return SetStatus(DllExports::GdipVectorTransformMatrixPointsI(nativeMatrix, 
+                                                                    pts, 
+                                                                    count));
+    }
+    
+    BOOL IsInvertible() const
+    {
+        BOOL result = FALSE;
+
+        SetStatus(DllExports::GdipIsMatrixInvertible(nativeMatrix, &result));
+    
+        return result;
+    }
+
+    BOOL IsIdentity() const
+    {
+       BOOL result = FALSE;
+
+       SetStatus(DllExports::GdipIsMatrixIdentity(nativeMatrix, &result));
+    
+       return result;
+    }
+
+    BOOL Equals(IN const Matrix *matrix) const
+    {
+       BOOL result = FALSE;
+
+       SetStatus(DllExports::GdipIsMatrixEqual(nativeMatrix,
+                                                 matrix->nativeMatrix, &result));
+   
+       return result;
+    }
+    
+    Status GetLastStatus() const
+    {
+        Status lastStatus = lastResult;
+        lastResult = Ok;
+ 
+        return lastStatus;
+    }
+
+protected:
+
+#ifdef DCR_USE_NEW_250932
+
+private:
+    Matrix(const Matrix &);
+    Matrix& operator=(const Matrix &);
+protected:
+
+#else
+
+    Matrix(const Matrix& matrix)
+    {
+        matrix;
+        SetStatus(NotImplemented);
+        SetNativeMatrix(NULL);
+    }
+
+    Matrix& operator=(const Matrix& matrix)
+    {
+        matrix;
+        SetStatus(NotImplemented);
+        return *this;
+    }
+
+#endif
+
+    Matrix(GpMatrix *nativeMatrix)
+    {
+        lastResult = Ok;
+        SetNativeMatrix(nativeMatrix);
+    }
+    
+    VOID SetNativeMatrix(GpMatrix *nativeMatrix)
+    {
+        this->nativeMatrix = nativeMatrix;
+    }
+
+    Status SetStatus(Status status) const
+    {
+        if (status != Ok)
+            return (lastResult = status);
+        else
+            return status;
+    }
+
+protected:
+    GpMatrix *nativeMatrix;
+    mutable Status lastResult;
+};