GdiPlusMatrix.h
上传用户:jinlangri
上传日期:2022-07-17
资源大小:10774k
文件大小:8k
源码类别:

GDI/图象编程

开发平台:

Visual C++

  1. /**************************************************************************
  2. * Copyright (c) 1998-2000, Microsoft Corp.  All Rights Reserved.
  3. *
  4. * Module Name:
  5. *
  6. *   GdiplusMatrix.h
  7. *
  8. * Abstract:
  9. *
  10. *   GDI+ Matrix class
  11. *
  12. **************************************************************************/
  13. class Matrix : public GdiplusBase
  14. {
  15. public:
  16.     friend class Graphics;
  17.     friend class GraphicsPath;
  18.     friend class TextureBrush;
  19.     friend class LinearGradientBrush;
  20.     friend class PathGradientBrush;
  21.     friend class Pen;
  22.     friend class Region;
  23.     
  24.     // Default constructor - set to identity matrix
  25.     Matrix()
  26.     {
  27.         GpMatrix *matrix = NULL;
  28.         lastResult = DllExports::GdipCreateMatrix(&matrix);
  29.     
  30.         SetNativeMatrix(matrix);
  31.     }
  32.     Matrix(IN REAL m11, 
  33.            IN REAL m12,
  34.            IN REAL m21, 
  35.            IN REAL m22,
  36.            IN REAL dx, 
  37.            IN REAL dy)
  38.     {
  39.         GpMatrix *matrix = NULL;
  40.         lastResult = DllExports::GdipCreateMatrix2(m11, m12, m21, m22, 
  41.                                                       dx, dy, &matrix);
  42.     
  43.         SetNativeMatrix(matrix);
  44.     }
  45.     
  46.     Matrix(IN const RectF& rect, 
  47.            IN const PointF* dstplg)
  48.     {
  49.         GpMatrix *matrix = NULL;
  50.         lastResult = DllExports::GdipCreateMatrix3(&rect, 
  51.                                                    dstplg,
  52.                                                    &matrix);
  53.         SetNativeMatrix(matrix);
  54.     }
  55.     Matrix(IN const Rect& rect, 
  56.            IN const Point* dstplg)
  57.     {
  58.         GpMatrix *matrix = NULL;
  59.         lastResult = DllExports::GdipCreateMatrix3I(&rect, 
  60.                                                     dstplg,
  61.                                                     &matrix);
  62.         SetNativeMatrix(matrix);
  63.     }
  64.     ~Matrix()
  65.     {
  66.         DllExports::GdipDeleteMatrix(nativeMatrix);
  67.     }
  68.     Matrix *Clone() const
  69.     {
  70.         GpMatrix *cloneMatrix = NULL;
  71.         SetStatus(DllExports::GdipCloneMatrix(nativeMatrix,
  72.                                                   &cloneMatrix));
  73.         if (lastResult != Ok)
  74.             return NULL;
  75.         return new Matrix(cloneMatrix);
  76.     }
  77.     Status GetElements(OUT REAL *m) const 
  78.     {
  79.         return SetStatus(DllExports::GdipGetMatrixElements(nativeMatrix, m));
  80.     }
  81.     
  82.     Status SetElements(IN REAL m11, 
  83.                        IN REAL m12, 
  84.                        IN REAL m21, 
  85.                        IN REAL m22, 
  86.                        IN REAL dx, 
  87.                        IN REAL dy)
  88.     {
  89.         return SetStatus(DllExports::GdipSetMatrixElements(nativeMatrix,
  90.                             m11, m12, m21, m22, dx, dy));
  91.     }
  92.     REAL OffsetX() const
  93.     {
  94.         REAL elements[6];
  95.         if (GetElements(&elements[0]) == Ok)
  96.             return elements[4];
  97.         else 
  98.             return 0.0f;
  99.     }
  100.     REAL OffsetY() const
  101.     {
  102.        REAL elements[6];
  103.        if (GetElements(&elements[0]) == Ok)
  104.            return elements[5];
  105.        else 
  106.            return 0.0f;
  107.     }
  108.     Status Reset()
  109.     {
  110.         // set identity matrix elements 
  111.         return SetStatus(DllExports::GdipSetMatrixElements(nativeMatrix,
  112.                                              1.0, 0.0, 0.0, 1.0, 0.0, 0.0));
  113.     }
  114.     Status Multiply(IN const Matrix *matrix, 
  115.                     IN MatrixOrder order = MatrixOrderPrepend)
  116.     {
  117.         return SetStatus(DllExports::GdipMultiplyMatrix(nativeMatrix, 
  118.                                           matrix->nativeMatrix,
  119.                                           order));
  120.     }
  121.     Status Translate(IN REAL offsetX, 
  122.                      IN REAL offsetY, 
  123.                      IN MatrixOrder order = MatrixOrderPrepend)
  124.     {
  125.         return SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix, offsetX, offsetY, order));
  126.     }
  127.     Status Scale(IN REAL scaleX, 
  128.                  IN REAL scaleY, 
  129.                  IN MatrixOrder order = MatrixOrderPrepend)
  130.     {
  131.         return SetStatus(DllExports::GdipScaleMatrix(nativeMatrix, scaleX, scaleY, order));
  132.     }
  133.     Status Rotate(IN REAL angle, 
  134.                   IN MatrixOrder order = MatrixOrderPrepend)
  135.     {
  136.         return SetStatus(DllExports::GdipRotateMatrix(nativeMatrix, angle, order));
  137.     }
  138.     
  139.     Status RotateAt(IN REAL angle, 
  140.                     IN const PointF& center, 
  141.                     IN MatrixOrder order = MatrixOrderPrepend)
  142.     {
  143.         if(order == MatrixOrderPrepend)
  144.         {
  145.             SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix, center.X, center.Y, order));
  146.             SetStatus(DllExports::GdipRotateMatrix(nativeMatrix, angle, order));
  147.             return SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix, - center.X, - center.Y, order));
  148.         }
  149.         else
  150.         {
  151.             SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix, - center.X, - center.Y, order));
  152.             SetStatus(DllExports::GdipRotateMatrix(nativeMatrix, angle, order));
  153.             return SetStatus(DllExports::GdipTranslateMatrix(nativeMatrix, center.X, center.Y, order));
  154.         }
  155.     }
  156.     Status Shear(IN REAL shearX, 
  157.                  IN REAL shearY,
  158.                  IN MatrixOrder order = MatrixOrderPrepend)
  159.     {
  160.         return SetStatus(DllExports::GdipShearMatrix(nativeMatrix, shearX, shearY, order));
  161.     }
  162.     Status Invert()
  163.     {
  164.         return SetStatus(DllExports::GdipInvertMatrix(nativeMatrix));
  165.     }
  166.     // float version
  167.     Status TransformPoints(IN OUT PointF* pts, 
  168.                            IN INT count = 1) const
  169.     {
  170.         return SetStatus(DllExports::GdipTransformMatrixPoints(nativeMatrix, pts, count));
  171.     }
  172.     
  173.     Status TransformPoints(IN OUT Point* pts, 
  174.                            IN INT count = 1) const
  175.     {
  176.         return SetStatus(DllExports::GdipTransformMatrixPointsI(nativeMatrix, 
  177.                                                                 pts, 
  178.                                                                 count));
  179.     }
  180.     Status TransformVectors(IN OUT PointF* pts, 
  181.                             IN INT count = 1) const
  182.     { 
  183.         return SetStatus(DllExports::GdipVectorTransformMatrixPoints(nativeMatrix, pts, count));
  184.     }
  185.     Status TransformVectors(IN OUT Point* pts, 
  186.                             IN INT count = 1) const
  187.     { 
  188.        return SetStatus(DllExports::GdipVectorTransformMatrixPointsI(nativeMatrix, 
  189.                                                                     pts, 
  190.                                                                     count));
  191.     }
  192.     
  193.     BOOL IsInvertible() const
  194.     {
  195.         BOOL result = FALSE;
  196.         SetStatus(DllExports::GdipIsMatrixInvertible(nativeMatrix, &result));
  197.     
  198.         return result;
  199.     }
  200.     BOOL IsIdentity() const
  201.     {
  202.        BOOL result = FALSE;
  203.        SetStatus(DllExports::GdipIsMatrixIdentity(nativeMatrix, &result));
  204.     
  205.        return result;
  206.     }
  207.     BOOL Equals(IN const Matrix *matrix) const
  208.     {
  209.        BOOL result = FALSE;
  210.        SetStatus(DllExports::GdipIsMatrixEqual(nativeMatrix,
  211.                                                  matrix->nativeMatrix, &result));
  212.    
  213.        return result;
  214.     }
  215.     
  216.     Status GetLastStatus() const
  217.     {
  218.         Status lastStatus = lastResult;
  219.         lastResult = Ok;
  220.  
  221.         return lastStatus;
  222.     }
  223. protected:
  224. #ifdef DCR_USE_NEW_250932
  225. private:
  226.     Matrix(const Matrix &);
  227.     Matrix& operator=(const Matrix &);
  228. protected:
  229. #else
  230.     Matrix(const Matrix& matrix)
  231.     {
  232.         matrix;
  233.         SetStatus(NotImplemented);
  234.         SetNativeMatrix(NULL);
  235.     }
  236.     Matrix& operator=(const Matrix& matrix)
  237.     {
  238.         matrix;
  239.         SetStatus(NotImplemented);
  240.         return *this;
  241.     }
  242. #endif
  243.     Matrix(GpMatrix *nativeMatrix)
  244.     {
  245.         lastResult = Ok;
  246.         SetNativeMatrix(nativeMatrix);
  247.     }
  248.     
  249.     VOID SetNativeMatrix(GpMatrix *nativeMatrix)
  250.     {
  251.         this->nativeMatrix = nativeMatrix;
  252.     }
  253.     Status SetStatus(Status status) const
  254.     {
  255.         if (status != Ok)
  256.             return (lastResult = status);
  257.         else
  258.             return status;
  259.     }
  260. protected:
  261.     GpMatrix *nativeMatrix;
  262.     mutable Status lastResult;
  263. };