[ros-diffs] [bfreisen] 75603: [PSDK][GDIPLUS] Further work on Graphics

Author: bfreisen
Date: Fri Aug 18 08:09:04 2017
New Revision: 75603

URL: http://svn.reactos.org/svn/reactos?rev=75603&view=rev
Log:
[PSDK][GDIPLUS] Further work on Graphics

Modified:
    trunk/reactos/sdk/include/psdk/gdiplusbrush.h
    trunk/reactos/sdk/include/psdk/gdiplusgraphics.h

Modified: trunk/reactos/sdk/include/psdk/gdiplusbrush.h
URL: http://svn.reactos.org/svn/reactos/trunk/reactos/sdk/include/psdk/gdiplusbru...
==============================================================================
--- trunk/reactos/sdk/include/psdk/gdiplusbrush.h	[iso-8859-1] (original)
+++ trunk/reactos/sdk/include/psdk/gdiplusbrush.h	[iso-8859-1] Fri Aug 18 08:09:04 2017
@@ -24,6 +24,7 @@
 class Brush : public GdiplusBase
 {
 public:
+  friend class Graphics;
   friend class Pen;

Brush *Clone(VOID) const

Modified: trunk/reactos/sdk/include/psdk/gdiplusgraphics.h
URL: http://svn.reactos.org/svn/reactos/trunk/reactos/sdk/include/psdk/gdiplusgra...
==============================================================================
--- trunk/reactos/sdk/include/psdk/gdiplusgraphics.h	[iso-8859-1] (original)
+++ trunk/reactos/sdk/include/psdk/gdiplusgraphics.h	[iso-8859-1] Fri Aug 18 08:09:04 2017
@@ -481,42 +481,42 @@

Status FillClosedCurve(const Brush *brush, const Point *points, INT count)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillClosedCurveI(graphics, brush ? brush->brush : NULL, points, count));
   }

Status FillClosedCurve(const Brush *brush, const Point *points, INT count, FillMode fillMode, REAL tension)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillClosedCurve2I(graphics, brush ? brush->brush : NULL, points, count, tension, fillMode));
   }

Status FillClosedCurve(const Brush *brush, const PointF *points, INT count)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillClosedCurve(graphics, brush ? brush->brush : NULL, points, count));
   }

Status FillClosedCurve(const Brush *brush, const PointF *points, INT count, FillMode fillMode, REAL tension)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillClosedCurve2(graphics, brush ? brush->brush : NULL, points, count, tension, fillMode));
   }

Status FillEllipse(const Brush *brush, const Rect &rect)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillEllipseI(graphics, brush ? brush->brush : NULL, rect.X, rect.Y, rect.Width, rect.Height));
   }

Status FillEllipse(const Brush *brush, REAL x, REAL y, REAL width, REAL height)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillEllipse(graphics, brush ? brush->brush : NULL, x, y, width, height));
   }

Status FillEllipse(const Brush *brush, const RectF &rect)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillEllipse(graphics, brush ? brush->brush : NULL, rect.X, rect.Y, rect.Width, rect.Height));
   }

Status FillEllipse(const Brush *brush, INT x, INT y, INT width, INT height)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillEllipseI(graphics, brush ? brush->brush : NULL, x, y, width, height));
   }

Status FillPath(const Brush *brush, const GraphicsPath *path)
@@ -526,72 +526,72 @@

Status FillPie(const Brush *brush, const Rect &rect, REAL startAngle, REAL sweepAngle)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillPieI(graphics, brush ? brush->brush : NULL, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle));
   }

Status FillPie(const Brush *brush, INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillPieI(graphics, brush ? brush->brush : NULL, x, y, width, height, startAngle, sweepAngle));
   }

Status FillPie(const Brush *brush, REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillPie(graphics, brush ? brush->brush : NULL, x, y, width, height, startAngle, sweepAngle));
   }

Status FillPie(const Brush *brush, RectF &rect, REAL startAngle, REAL sweepAngle)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillPie(graphics, brush ? brush->brush : NULL, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle));
   }

Status FillPolygon(const Brush *brush, const Point *points, INT count)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillPolygon2I(graphics, brush ? brush->brush : NULL, points, count));
   }

Status FillPolygon(const Brush *brush, const PointF *points, INT count)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillPolygon2(graphics, brush ? brush->brush : NULL, points, count));
   }

Status FillPolygon(const Brush *brush, const Point *points, INT count, FillMode fillMode)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillPolygonI(graphics, brush ? brush->brush : NULL, points, count, fillMode));
   }

Status FillPolygon(const Brush *brush, const PointF *points, INT count, FillMode fillMode)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillPolygon(graphics, brush ? brush->brush : NULL, points, count, fillMode));
   }

Status FillRectangle(const Brush *brush, const Rect &rect)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillRectangleI(graphics, brush ? brush->brush : NULL, rect.X, rect.Y, rect.Width, rect.Height));
   }

Status FillRectangle(const Brush *brush, const RectF &rect)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillRectangle(graphics, brush ? brush->brush : NULL, rect.X, rect.Y, rect.Width, rect.Height));
   }

Status FillRectangle(const Brush *brush, REAL x, REAL y, REAL width, REAL height)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillRectangle(graphics, brush ? brush->brush : NULL, x, y, width, height));
   }

Status FillRectangle(const Brush *brush, INT x, INT y, INT width, INT height)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillRectangleI(graphics, brush ? brush->brush : NULL, x, y, width, height));
   }

Status FillRectangles(const Brush *brush, const Rect *rects, INT count)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillRectanglesI(graphics, brush ? brush->brush : NULL, rects, count));
   }

Status FillRectangles(const Brush *brush, const RectF *rects, INT count)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipFillRectangles(graphics, brush ? brush->brush : NULL, rects, count));
   }

Status FillRegion(const Brush *brush, const Region *region)
@@ -630,251 +630,294 @@

Status GetClipBounds(Rect* rect) const
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipGetClipBoundsI(graphics, rect));
   }

Status GetClipBounds(RectF* rect) const
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipGetClipBounds(graphics, rect));
   }

CompositingMode GetCompositingMode(VOID)
   {
-    return CompositingModeSourceOver;
+    CompositingMode compositingMode;
+    SetStatus(DllExports::GdipGetCompositingMode(graphics, &compositingMode));
+    return compositingMode;
   }

CompositingQuality GetCompositingQuality(VOID)
   {
-    return CompositingQualityDefault;
+    CompositingQuality compositingQuality;
+    SetStatus(DllExports::GdipGetCompositingQuality(graphics, &compositingQuality));
+    return compositingQuality;
   }

REAL GetDpiX(VOID)
   {
+    REAL dpi;
+    SetStatus(DllExports::GdipGetDpiX(graphics, &dpi));
+    return dpi;
+  }
+
+  REAL GetDpiY(VOID)
+  {
+    REAL dpi;
+    SetStatus(DllExports::GdipGetDpiY(graphics, &dpi));
+    return dpi;
+  }
+
+  static HPALETTE GetHalftonePalette(VOID)
+  {
+    return NULL;
+  }
+
+  HDC GetHDC(VOID)
+  {
+    return NULL;
+  }
+
+  InterpolationMode GetInterpolationMode(VOID)
+  {
+    InterpolationMode interpolationMode;
+    SetStatus(DllExports::GdipGetInterpolationMode(graphics, &interpolationMode));
+    return interpolationMode;
+  }
+
+  Status GetLastStatus(VOID)
+  {
+    return status;
+  }
+
+  Status GetNearestColor(Color* color) const
+  {
+    return NotImplemented;
+  }
+
+  REAL GetPageScale(VOID)
+  {
+    REAL scale;
+    SetStatus(DllExports::GdipGetPageScale(graphics, &scale));
+    return scale;
+  }
+
+  Unit GetPageUnit(VOID)
+  {
+    Unit unit;
+    SetStatus(DllExports::GdipGetPageUnit(graphics, &unit));
+    return unit;
+  }
+
+  PixelOffsetMode GetPixelOffsetMode(VOID)
+  {
+    PixelOffsetMode pixelOffsetMode;
+    SetStatus(DllExports::GdipGetPixelOffsetMode(graphics, &pixelOffsetMode));
+    return pixelOffsetMode;
+  }
+
+  Status GetRenderingOrigin(INT *x, INT *y)
+  {
+    return NotImplemented;  // FIXME: not available: SetStatus(DllExports::GdipGetRenderingOrigin(graphics, x, y));
+  }
+
+  SmoothingMode GetSmoothingMode(VOID) const
+  {
+    SmoothingMode smoothingMode;
+    SetStatus(DllExports::GdipGetSmoothingMode(graphics, &smoothingMode));
+    return smoothingMode;
+  }
+
+  UINT GetTextContrast(VOID) const
+  {
+    UINT contrast;
+    SetStatus(DllExports::GdipGetTextContrast(graphics, &contrast));
+    return contrast;
+  }
+
+  TextRenderingHint GetTextRenderingHint(VOID) const
+  {
+    TextRenderingHint mode;
+    SetStatus(DllExports::GdipGetTextRenderingHint(graphics, &mode));
+    return mode;
+  }
+
+  Status GetTransform(Matrix* matrix)
+  {
+    return NotImplemented;
+  }
+
+  Status GetVisibleClipBounds(Rect* rect) const
+  {
+    return SetStatus(DllExports::GdipGetVisibleClipBoundsI(graphics, rect));
+  }
+
+  Status GetVisibleClipBounds(RectF* rect) const
+  {
+    return SetStatus(DllExports::GdipGetVisibleClipBounds(graphics, rect));
+  }
+
+  Status IntersectClip(const Rect& rect)
+  {
+    return NotImplemented;
+  }
+
+  Status IntersectClip(const Region* region)
+  {
+    return NotImplemented;
+  }
+
+  Status IntersectClip(const RectF& rect)
+  {
+    return NotImplemented;
+  }
+
+  BOOL IsClipEmpty(VOID) const
+  {
+    BOOL result;
+    SetStatus(DllExports::GdipIsClipEmpty(graphics, &result));
+    return result;
+  }
+
+  BOOL IsVisible(const Point& point) const
+  {
+    BOOL result;
+    SetStatus(DllExports::GdipIsVisiblePointI(graphics, point.X, point.Y, &result));
+    return result;
+  }
+
+  BOOL IsVisible(const Rect& rect) const
+  {
+    BOOL result;
+    SetStatus(DllExports::GdipIsVisibleRectI(graphics, rect.X, rect.Y, rect.Width, rect.Height, &result));
+    return result;
+  }
+
+  BOOL IsVisible(REAL x, REAL y) const
+  {
+    BOOL result;
+    SetStatus(DllExports::GdipIsVisiblePoint(graphics, x, y, &result));
+    return result;
+  }
+
+  BOOL IsVisible(const RectF& rect) const
+  {
+    BOOL result;
+    SetStatus(DllExports::GdipIsVisibleRect(graphics, rect.X, rect.Y, rect.Width, rect.Height, &result));
+    return result;
+  }
+
+  BOOL IsVisible(INT x, INT y, INT width, INT height) const
+  {
+    BOOL result;
+    SetStatus(DllExports::GdipIsVisibleRectI(graphics, x, y, width, height, &result));
+    return result;
+  }
+
+  BOOL IsVisible(INT x, INT y) const
+  {
+    BOOL result;
+    SetStatus(DllExports::GdipIsVisiblePointI(graphics, x, y, &result));
+    return result;
+  }
+
+  BOOL IsVisible(const PointF& point) const
+  {
+    BOOL result;
+    SetStatus(DllExports::GdipIsVisiblePoint(graphics, point.X, point.Y, &result));
+    return result;
+  }
+
+  BOOL IsVisible(REAL x, REAL y, REAL width, REAL height) const
+  {
+    BOOL result;
+    SetStatus(DllExports::GdipIsVisibleRect(graphics, x, y, width, height, &result));
+    return result;
+  }
+
+  BOOL IsVisibleClipEmpty(VOID) const
+  {
+    return FALSE;  /* FIXME: not available:
+    BOOL result;
+    SetStatus(DllExports::GdipIsVisibleClipEmpty(graphics, &result));
+    return result;*/
+  }
+
+  Status MeasureCharacterRanges(const WCHAR *string, INT length, const Font *font, const RectF &layoutRect, const StringFormat *stringFormat, INT regionCount, Region *regions) const
+  {
+    return NotImplemented;
+  }
+
+  Status MeasureDriverString(const UINT16 *text, INT length, const Font *font, const PointF *positions, INT flags, const Matrix *matrix, RectF *boundingBox) const
+  {
+    return NotImplemented;
+  }
+
+  Status MeasureString(const WCHAR *string, INT length, const Font *font, const RectF &layoutRect, RectF *boundingBox) const
+  {
+    return NotImplemented;
+  }
+
+  Status MeasureString(const WCHAR *string, INT length, const Font *font, const PointF &origin, const StringFormat *stringFormat, RectF *boundingBox) const
+  {
+    return NotImplemented;
+  }
+
+  Status MeasureString(const WCHAR *string, INT length, const Font *font, const RectF &layoutRect, const StringFormat *stringFormat, RectF *boundingBox, INT *codepointsFitted, INT *linesFilled) const
+  {
+    return NotImplemented;
+  }
+
+  Status MeasureString(const WCHAR *string, INT length, const Font *font, const SizeF &layoutRectSize, const StringFormat *stringFormat, SizeF *size, INT *codepointsFitted, INT *linesFilled) const
+  {
+    return NotImplemented;
+  }
+
+  Status MeasureString(const WCHAR *string, INT length, const Font *font, const PointF &origin, RectF *boundingBox) const
+  {
+    return NotImplemented;
+  }
+
+  Status MultiplyTransform(Matrix *matrix, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  VOID ReleaseHDC(HDC hdc)
+  {
+  }
+
+  Status ResetClip(VOID)
+  {
+    return SetStatus(DllExports::GdipResetClip(graphics));
+  }
+
+  Status ResetTransform(VOID)
+  {
+    return SetStatus(DllExports::GdipResetWorldTransform(graphics));
+  }
+
+  Status Restore(GraphicsState gstate)
+  {
+    return NotImplemented;
+  }
+
+  Status RotateTransform(REAL angle, MatrixOrder order)
+  {
+    return SetStatus(DllExports::GdipRotateWorldTransform(graphics, angle, order));
+  }
+
+  GraphicsState Save(VOID)
+  {
     return 0;
   }

-  REAL GetDpiY(VOID)
-  {
-    return 0;
-  }
-
-  static HPALETTE GetHalftonePalette(VOID)
-  {
-    return NULL;
-  }
-
-  HDC GetHDC(VOID)
-  {
-    return NULL;
-  }
-
-  InterpolationMode GetInterpolationMode(VOID)
-  {
-    return InterpolationModeInvalid;
-  }
-
-  Status GetLastStatus(VOID)
-  {
-    return NotImplemented;
-  }
-
-  Status GetNearestColor(Color* color) const
-  {
-    return NotImplemented;
-  }
-
-  REAL GetPageScale(VOID)
-  {
-    return 0;
-  }
-
-  Unit GetPageUnit(VOID)
-  {
-    return UnitWorld;
-  }
-
-  PixelOffsetMode GetPixelOffsetMode(VOID)
-  {
-    return PixelOffsetModeInvalid;
-  }
-
-  Status GetRenderingOrigin(INT *x, INT *y)
-  {
-    return NotImplemented;
-  }
-
-  SmoothingMode GetSmoothingMode(VOID) const
-  {
-    return SmoothingModeInvalid;
-  }
-
-  UINT GetTextContrast(VOID) const
-  {
-    return 0;
-  }
-
-  TextRenderingHint GetTextRenderingHint(VOID) const
-  {
-    return TextRenderingHintSystemDefault;
-  }
-
-  Status GetTransform(Matrix* matrix)
-  {
-    return NotImplemented;
-  }
-
-  Status GetVisibleClipBounds(Rect* rect) const
-  {
-    return NotImplemented;
-  }
-
-  Status GetVisibleClipBounds(RectF* rect) const
-  {
-    return NotImplemented;
-  }
-
-  Status IntersectClip(const Rect& rect)
-  {
-    return NotImplemented;
-  }
-
-  Status IntersectClip(const Region* region)
-  {
-    return NotImplemented;
-  }
-
-  Status IntersectClip(const RectF& rect)
-  {
-    return NotImplemented;
-  }
-
-  BOOL IsClipEmpty(VOID) const
-  {
-    return FALSE;
-  }
-
-  BOOL IsVisible(const Point& point) const
-  {
-    return FALSE;
-  }
-
-  BOOL IsVisible(const Rect& rect) const
-  {
-    return FALSE;
-  }
-
-  BOOL IsVisible(REAL x, REAL y) const
-  {
-    return FALSE;
-  }
-
-  BOOL IsVisible(const RectF& rect) const
-  {
-    return FALSE;
-  }
-
-  BOOL IsVisible(INT x, INT y, INT width, INT height) const
-  {
-    return FALSE;
-  }
-
-  BOOL IsVisible(INT x, INT y) const
-  {
-    return FALSE;
-  }
-
-  BOOL IsVisible(const PointF& point) const
-  {
-    return FALSE;
-  }
-
-  BOOL IsVisible(REAL x, REAL y, REAL width, REAL height) const
-  {
-    return FALSE;
-  }
-
-  BOOL IsVisibleClipEmpty(VOID) const
-  {
-    return FALSE;
-  }
-
-  Status MeasureCharacterRanges(const WCHAR *string, INT length, const Font *font, const RectF &layoutRect, const StringFormat *stringFormat, INT regionCount, Region *regions) const
-  {
-    return NotImplemented;
-  }
-
-  Status MeasureDriverString(const UINT16 *text, INT length, const Font *font, const PointF *positions, INT flags, const Matrix *matrix, RectF *boundingBox) const
-  {
-    return NotImplemented;
-  }
-
-  Status MeasureString(const WCHAR *string, INT length, const Font *font, const RectF &layoutRect, RectF *boundingBox) const
-  {
-    return NotImplemented;
-  }
-
-  Status MeasureString(const WCHAR *string, INT length, const Font *font, const PointF &origin, const StringFormat *stringFormat, RectF *boundingBox) const
-  {
-    return NotImplemented;
-  }
-
-  Status MeasureString(const WCHAR *string, INT length, const Font *font, const RectF &layoutRect, const StringFormat *stringFormat, RectF *boundingBox, INT *codepointsFitted, INT *linesFilled) const
-  {
-    return NotImplemented;
-  }
-
-  Status MeasureString(const WCHAR *string, INT length, const Font *font, const SizeF &layoutRectSize, const StringFormat *stringFormat, SizeF *size, INT *codepointsFitted, INT *linesFilled) const
-  {
-    return NotImplemented;
-  }
-
-  Status MeasureString(const WCHAR *string, INT length, const Font *font, const PointF &origin, RectF *boundingBox) const
-  {
-    return NotImplemented;
-  }
-
-  Status MultiplyTransform(Matrix *matrix, MatrixOrder order)
-  {
-    return NotImplemented;
-  }
-
-  VOID ReleaseHDC(HDC hdc)
-  {
-  }
-
-  Status ResetClip(VOID)
-  {
-    return NotImplemented;
-  }
-
-  Status ResetTransform(VOID)
-  {
-    return NotImplemented;
-  }
-
-  Status Restore(GraphicsState gstate)
-  {
-    return NotImplemented;
-  }
-
-  Status RotateTransform(REAL angle, MatrixOrder order)
-  {
-    return NotImplemented;
-  }
-
-  GraphicsState Save(VOID)
-  {
-    return 0;
-  }
-
   Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipScaleWorldTransform(graphics, sx, sy, order));
   }

Status SetClip(const Graphics *g, CombineMode combineMode)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipSetClipGraphics(graphics, g ? g->graphics : NULL, combineMode));
   }

Status SetClip(const GraphicsPath *path, CombineMode combineMode)
@@ -889,67 +932,67 @@

Status SetClip(const Rect &rect, CombineMode combineMode)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipSetClipRectI(graphics, rect.X, rect.Y, rect.Width, rect.Height, combineMode));
   }

Status SetClip(HRGN hRgn, CombineMode combineMode)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipSetClipHrgn(graphics, hRgn, combineMode));
   }

Status SetClip(const RectF& rect, CombineMode combineMode)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipSetClipRect(graphics, rect.X, rect.Y, rect.Width, rect.Height, combineMode));
   }

Status SetCompositingMode(CompositingMode compositingMode)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipSetCompositingMode(graphics, compositingMode));
   }

Status SetCompositingQuality(CompositingQuality compositingQuality)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipSetCompositingQuality(graphics, compositingQuality));
   }

Status SetInterpolationMode(InterpolationMode interpolationMode)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipSetInterpolationMode(graphics, interpolationMode));
   }

Status SetPageScale(REAL scale)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipSetPageScale(graphics, scale));
   }

Status SetPageUnit(Unit unit)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipSetPageUnit(graphics, unit));
   }

Status SetPixelOffsetMode(PixelOffsetMode pixelOffsetMode)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipSetPixelOffsetMode(graphics, pixelOffsetMode));
   }

Status SetRenderingOrigin(INT x, INT y)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipSetRenderingOrigin(graphics, x, y));
   }

Status SetSmoothingMode(SmoothingMode smoothingMode)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipSetSmoothingMode(graphics, smoothingMode));
   }

Status SetTextContrast(UINT contrast)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipSetTextContrast(graphics, contrast));
   }

Status SetTextRenderingHint(TextRenderingHint newMode)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipSetTextRenderingHint(graphics, newMode));
   }

Status SetTransform(const Matrix *matrix)
@@ -959,22 +1002,22 @@

Status TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, Point *pts, INT count)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipTransformPointsI(graphics, destSpace, srcSpace, pts, count));
   }

Status TranslateClip(INT dx, INT dy)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipTranslateClipI(graphics, dx, dy));
   }

Status TranslateClip(REAL dx, REAL dy)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipTranslateClip(graphics, dx, dy));
   }

Status TranslateTransform(REAL dx, REAL dy, MatrixOrder order)
   {
-    return NotImplemented;
+    return SetStatus(DllExports::GdipTranslateWorldTransform(graphics, dx, dy, order));
   }

private: