include/psdk/gdiplusgraphics.h

/*
 * GdiPlusGraphics.h
 *
 * Windows GDI+
 *
 * This file is part of the w32api package.
 *
 * 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 _GDIPLUSGRAPHICS_H
#define _GDIPLUSGRAPHICS_H

class Image;
class ImageAttributes;
class CachedBitmap;
class Region;
class Font;
class GraphicsPath;
class Metafile;

class Graphics : public GdiplusBase
{
  friend class Region;
  friend class Font;
  friend class Bitmap;
  friend class CachedBitmap;

public:
  Graphics(Image *image)
  {
  }

  Graphics(HDC hdc)
  {
    GpGraphics *graphics = NULL;
    status = DllExports::GdipCreateFromHDC(hdc, &graphics);
    SetGraphics(graphics);
  }

  Graphics(HDC hdc, HANDLE hdevice)
  {
  }

  Graphics(HWND hwnd, BOOL icm)
  {
  }

  Status AddMetafileComment(const BYTE *data, UINT sizeData)
  {
    return SetStatus(DllExports::GdipComment(graphics, sizeData, data));
  }

  GraphicsContainer BeginContainer(VOID)
  {
    return GraphicsContainer();
  }

  GraphicsContainer BeginContainer(const RectF &dstrect, const RectF &srcrect, Unit unit)
  {
    return GraphicsContainer();
  }

  GraphicsContainer BeginContainer(const Rect &dstrect, const Rect &srcrect, Unit unit)
  {
    return GraphicsContainer();
  }

  Status Clear(const Color &color)
  {
    return SetStatus(DllExports::GdipGraphicsClear(graphics, color.GetValue()));
  }

  Status DrawArc(const Pen *pen, const Rect &rect, REAL startAngle, REAL sweepAngle)
  {
    return SetStatus(DllExports::GdipDrawArcI(graphics, pen ? pen->pen : NULL, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle));
  }

  Status DrawArc(const Pen *pen, const RectF &rect, REAL startAngle, REAL sweepAngle)
  {
    return SetStatus(DllExports::GdipDrawArcI(graphics, pen ? pen->pen : NULL, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle));
  }

  Status DrawArc(const Pen *pen, REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
  {
    return SetStatus(DllExports::GdipDrawArc(graphics, pen ? pen->pen : NULL, x, y, width, height, startAngle, sweepAngle));
  }

  Status DrawArc(const Pen *pen, INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
  {
    return SetStatus(DllExports::GdipDrawArcI(graphics, pen ? pen->pen : NULL, x, y, width, height, startAngle, sweepAngle));
  }

  Status DrawBezier(const Pen *pen, const Point &pt1, const Point &pt2, const Point &pt3, const Point &pt4)
  {
    return SetStatus(DllExports::GdipDrawBezierI(graphics, pen ? pen->pen : NULL, pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y));
  }

  Status DrawBezier(const Pen *pen, const PointF &pt1, const PointF &pt2, const PointF &pt3, const PointF &pt4)
  {
    return SetStatus(DllExports::GdipDrawBezier(graphics, pen ? pen->pen : NULL, pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y));
  }

  Status DrawBezier(const Pen *pen, REAL x1, REAL y1, REAL x2, REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
  {
    return SetStatus(DllExports::GdipDrawBezier(graphics, pen ? pen->pen : NULL, x1, y1, x2, y2, x3, y3, x4, y4));
  }

  Status DrawBezier(const Pen *pen, INT x1, INT y1, INT x2, INT y2, INT x3, INT y3, INT x4, INT y4)
  {
    return SetStatus(DllExports::GdipDrawBezierI(graphics, pen ? pen->pen : NULL, x1, y1, x2, y2, x3, y3, x4, y4));
  }

  Status DrawBeziers(const Pen *pen, const Point *points, INT count)
  {
    return SetStatus(DllExports::GdipDrawBeziersI(graphics, pen ? pen->pen : NULL, points, count));
  }

  Status DrawBeziers(const Pen *pen, const PointF *points, INT count)
  {
    return SetStatus(DllExports::GdipDrawBeziers(graphics, pen ? pen->pen : NULL, points, count));
  }

  Status DrawCachedBitmap(CachedBitmap *cb, INT x, INT y)
  {
    return NotImplemented;
  }

  Status DrawClosedCurve(const Pen *pen, const Point *points, INT count)
  {
    return SetStatus(DllExports::GdipDrawClosedCurveI(graphics, pen ? pen->pen : NULL, points, count));
  }

  Status DrawClosedCurve(const Pen *pen, const PointF *points, INT count)
  {
    return SetStatus(DllExports::GdipDrawClosedCurve(graphics, pen ? pen->pen : NULL, points, count));
  }

  Status DrawClosedCurve(const Pen *pen, const PointF *points, INT count, REAL tension)
  {
    return SetStatus(DllExports::GdipDrawClosedCurve2(graphics, pen ? pen->pen : NULL, points, count, tension));
  }

  Status DrawClosedCurve(const Pen *pen, const Point *points, INT count, REAL tension)
  {
    return SetStatus(DllExports::GdipDrawClosedCurve2I(graphics, pen ? pen->pen : NULL, points, count, tension));
  }

  Status DrawCurve(const Pen *pen, const Point *points, INT count)
  {
    return SetStatus(DllExports::GdipDrawCurveI(graphics, pen ? pen->pen : NULL, points, count));
  }

  Status DrawCurve(const Pen *pen, const PointF *points, INT count)
  {
    return SetStatus(DllExports::GdipDrawCurve(graphics, pen ? pen->pen : NULL, points, count));
  }

  Status DrawCurve(const Pen *pen, const PointF *points, INT count, REAL tension)
  {
    return SetStatus(DllExports::GdipDrawCurve2(graphics, pen ? pen->pen : NULL, points, count, tension));
  }

  Status DrawCurve(const Pen *pen, const Point *points, INT count, INT offset, INT numberOfSegments, REAL tension)
  {
    return SetStatus(DllExports::GdipDrawCurve3I(graphics, pen ? pen->pen : NULL, points, count, offset, numberOfSegments, tension));
  }

  Status DrawCurve(const Pen *pen, const PointF *points, INT count, INT offset, INT numberOfSegments, REAL tension)
  {
    return SetStatus(DllExports::GdipDrawCurve3(graphics, pen ? pen->pen : NULL, points, count, offset, numberOfSegments, tension));
  }

  Status DrawCurve(const Pen *pen, const Point *points, INT count, REAL tension)
  {
    return SetStatus(DllExports::GdipDrawCurve2I(graphics, pen ? pen->pen : NULL, points, count, tension));
  }

  Status DrawDriverString(const UINT16 *text, INT length, const Font *font, const Brush *brush, const PointF *positions, INT flags, const Matrix *matrix)
  {
    return NotImplemented;
  }

  Status DrawEllipse(const Pen *pen, const Rect &rect)
  {
    return SetStatus(DllExports::GdipDrawEllipseI(graphics, pen ? pen->pen : NULL, rect.X, rect.Y, rect.Width, rect.Height));
  }

  Status DrawEllipse(const Pen *pen, REAL x, REAL y, REAL width, REAL height)
  {
    return SetStatus(DllExports::GdipDrawEllipse(graphics, pen ? pen->pen : NULL, x, y, width, height));
  }

  Status DrawEllipse(const Pen *pen, const RectF &rect)
  {
    return SetStatus(DllExports::GdipDrawEllipse(graphics, pen ? pen->pen : NULL, rect.X, rect.Y, rect.Width, rect.Height));
  }

  Status DrawEllipse(const Pen *pen, INT x, INT y, INT width, INT height)
  {
    return SetStatus(DllExports::GdipDrawEllipseI(graphics, pen ? pen->pen : NULL, x, y, width, height));
  }

  Status DrawImage(Image *image, const Point *destPoints, INT count)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, INT x, INT y)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, const Point &point)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, REAL x, REAL y)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, const PointF &point)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, const PointF *destPoints, INT count)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, REAL x, REAL y, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight, Unit srcUnit)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, const RectF &rect)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, INT x, INT y, INT width, INT height)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, const PointF *destPoints, INT count, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight, Unit srcUnit, ImageAttributes *imageAttributes, DrawImageAbort callback, VOID *callbackData)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, const Rect &destRect, INT srcx, INT srcy, INT srcwidth, INT srcheight, Unit srcUnit, ImageAttributes *imageAttributes, DrawImageAbort callback, VOID *callbackData)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, const Point *destPoints, INT count, INT srcx, INT srcy, INT srcwidth, INT srcheight, Unit srcUnit, ImageAttributes *imageAttributes, DrawImageAbort callback, VOID *callbackData)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, REAL x, REAL y, REAL width, REAL height)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, const Rect &rect)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, INT x, INT y, INT srcx, INT srcy, INT srcwidth, INT srcheight, Unit srcUnit)
  {
    return NotImplemented;
  }

  Status DrawImage(Image *image, const RectF &destRect, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight, Unit srcUnit, ImageAttributes *imageAttributes, DrawImageAbort callback, VOID *callbackData)
  {
    return NotImplemented;
  }

  Status DrawLine(const Pen *pen, const Point &pt1, const Point &pt2)
  {
    return SetStatus(DllExports::GdipDrawLineI(graphics, pen ? pen->pen : NULL, pt1.X, pt1.Y, pt2.X, pt2.Y));
  }

  Status DrawLine(const Pen *pen, const PointF &pt1, const Point &pt2)
  {
    return SetStatus(DllExports::GdipDrawLine(graphics, pen ? pen->pen : NULL, pt1.X, pt1.Y, pt2.X, pt2.Y));
  }

  Status DrawLine(const Pen *pen, REAL x1, REAL y1, REAL x2, REAL y2)
  {
    return SetStatus(DllExports::GdipDrawLine(graphics, pen ? pen->pen : NULL, x1, y1, x2, y2));
  }

  Status DrawLine(const Pen *pen, INT x1, INT y1, INT x2, INT y2)
  {
    return SetStatus(DllExports::GdipDrawLine(graphics, pen ? pen->pen : NULL, x1, y1, x2, y2));
  }

  Status DrawLines(const Pen *pen, const Point *points, INT count)
  {
    return SetStatus(DllExports::GdipDrawLinesI(graphics, pen ? pen->pen : NULL, points, count));
  }

  Status DrawLines(const Pen *pen, const PointF *points, INT count)
  {
    return SetStatus(DllExports::GdipDrawLines(graphics, pen ? pen->pen : NULL, points, count));
  }

  Status DrawPath(const Pen *pen, const GraphicsPath *path)
  {
    return NotImplemented;
  }

  Status DrawPie(const Pen *pen, const Rect &rect, REAL startAngle, REAL sweepAngle)
  {
    return SetStatus(DllExports::GdipDrawPieI(graphics, pen ? pen->pen : NULL, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle));
  }

  Status DrawPie(const Pen *pen, INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
  {
    return SetStatus(DllExports::GdipDrawPieI(graphics, pen ? pen->pen : NULL, x, y, width, height, startAngle, sweepAngle));
  }

  Status DrawPie(const Pen *pen, REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
  {
    return SetStatus(DllExports::GdipDrawPie(graphics, pen ? pen->pen : NULL, x, y, width, height, startAngle, sweepAngle));
  }

  Status DrawPie(const Pen *pen, const RectF &rect, REAL startAngle, REAL sweepAngle)
  {
    return SetStatus(DllExports::GdipDrawPie(graphics, pen ? pen->pen : NULL, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle));
  }

  Status DrawPolygon(const Pen *pen, const Point *points, INT count)
  {
    return SetStatus(DllExports::GdipDrawPolygonI(graphics, pen ? pen->pen : NULL, points, count));
  }

  Status DrawPolygon(const Pen *pen, const PointF *points, INT count)
  {
    return SetStatus(DllExports::GdipDrawPolygon(graphics, pen ? pen->pen : NULL, points, count));
  }

  Status DrawRectangle(const Pen *pen, const Rect &rect)
  {
    return SetStatus(DllExports::GdipDrawRectangleI(graphics, pen ? pen->pen : NULL, rect.X, rect.Y, rect.Width, rect.Height));
  }

  Status DrawRectangle(const Pen *pen, INT x, INT y, INT width, INT height)
  {
    return SetStatus(DllExports::GdipDrawRectangleI(graphics, pen ? pen->pen : NULL, x, y, width, height));
  }

  Status DrawRectangle(const Pen *pen, REAL x, REAL y, REAL width, REAL height)
  {
    return SetStatus(DllExports::GdipDrawRectangle(graphics, pen ? pen->pen : NULL, x, y, width, height));
  }

  Status DrawRectangle(const Pen *pen, const RectF &rect)
  {
    return SetStatus(DllExports::GdipDrawRectangleI(graphics, pen ? pen->pen : NULL, rect.X, rect.Y, rect.Width, rect.Height));
  }

  Status DrawRectangles(const Pen *pen, const Rect *rects, INT count)
  {
    return SetStatus(DllExports::GdipDrawRectanglesI(graphics, pen ? pen->pen : NULL, rects, count));
  }

  Status DrawRectangles(const Pen *pen, const RectF *rects, INT count)
  {
    return SetStatus(DllExports::GdipDrawRectangles(graphics, pen ? pen->pen : NULL, rects, count));
  }

  Status DrawString(const WCHAR *string, INT length, const Font *font, const RectF &layoutRect, const StringFormat *stringFormat, const Brush *brush)
  {
    return NotImplemented;
  }

  Status DrawString(const WCHAR *string, INT length, const Font *font, const PointF &origin, const Brush *brush)
  {
    return NotImplemented;
  }

  Status DrawString(const WCHAR *string, INT length, const Font *font, const PointF &origin, const StringFormat *stringFormat, const Brush *brush)
  {
    return NotImplemented;
  }

  Status EndContainer(GraphicsContainer state)
  {
    return SetStatus(DllExports::GdipEndContainer(graphics, state));
  }

  Status EnumerateMetafile(const Metafile *metafile, const Metafile &destPoint, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
  {
    return NotImplemented;
  }

  Status EnumerateMetafile(const Metafile *metafile, const Point *destPoints, INT count, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
  {
    return NotImplemented;
  }

  Status EnumerateMetafile(const Metafile *metafile, const Point &destPoint, const Rect &srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
  {
    return NotImplemented;
  }

  Status EnumerateMetafile(const Metafile *metafile, const PointF *destPoints, INT count, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
  {
    return NotImplemented;
  }

  Status EnumerateMetafile(const Metafile *metafile, const Rect &destRect, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
  {
    return NotImplemented;
  }

  Status EnumerateMetafile(const Metafile *metafile, const RectF &destRect, const RectF &srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
  {
    return NotImplemented;
  }

  Status EnumerateMetafile(const Metafile *metafile, const RectF &destRect, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
  {
    return NotImplemented;
  }

  Status EnumerateMetafile(const Metafile *metafile, const PointF &destPoint, const Rect &srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
  {
    return NotImplemented;
  }

  Status EnumerateMetafile(const Metafile *metafile, const Point *destPoints, INT count, const Rect &srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
  {
    return NotImplemented;
  }

  Status EnumerateMetafile(const Metafile *metafile, const Rect &destRect, const Rect &srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
  {
    return NotImplemented;
  }

  Status EnumerateMetafile(const Metafile *metafile, const Point *destPoints, INT count, const RectF &srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
  {
    return NotImplemented;
  }

  Status EnumerateMetafile(const Metafile *metafile, const PointF &destPoint, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
  {
    return NotImplemented;
  }

  Status ExcludeClip(const Rect& rect)
  {
    return NotImplemented;
  }

  Status ExcludeClip(const RectF &rect)
  {
    return NotImplemented;
  }

  Status ExcludeClip(const Region *region)
  {
    return NotImplemented;
  }

  Status FillClosedCurve(const Brush *brush, const Point *points, INT count)
  {
    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 SetStatus(DllExports::GdipFillClosedCurve2I(graphics, brush ? brush->brush : NULL, points, count, tension, fillMode));
  }

  Status FillClosedCurve(const Brush *brush, const PointF *points, INT count)
  {
    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 SetStatus(DllExports::GdipFillClosedCurve2(graphics, brush ? brush->brush : NULL, points, count, tension, fillMode));
  }

  Status FillEllipse(const Brush *brush, const Rect &rect)
  {
    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 SetStatus(DllExports::GdipFillEllipse(graphics, brush ? brush->brush : NULL, x, y, width, height));
  }

  Status FillEllipse(const Brush *brush, const RectF &rect)
  {
    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 SetStatus(DllExports::GdipFillEllipseI(graphics, brush ? brush->brush : NULL, x, y, width, height));
  }

  Status FillPath(const Brush *brush, const GraphicsPath *path)
  {
    return NotImplemented;
  }

  Status FillPie(const Brush *brush, const Rect &rect, REAL startAngle, REAL sweepAngle)
  {
    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 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 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 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 SetStatus(DllExports::GdipFillPolygon2I(graphics, brush ? brush->brush : NULL, points, count));
  }

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

  Status FillPolygon(const Brush *brush, const Point *points, INT count, FillMode fillMode)
  {
    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 SetStatus(DllExports::GdipFillPolygon(graphics, brush ? brush->brush : NULL, points, count, fillMode));
  }

  Status FillRectangle(const Brush *brush, const Rect &rect)
  {
    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 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 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 SetStatus(DllExports::GdipFillRectangleI(graphics, brush ? brush->brush : NULL, x, y, width, height));
  }

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

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

  Status FillRegion(const Brush *brush, const Region *region)
  {
    return NotImplemented;
  }

  VOID Flush(FlushIntention intention)
  {
  }

  static Graphics *FromHDC(HDC hdc)
  {
    return NULL;
  }

  static Graphics *FromHDC(HDC hdc, HANDLE hDevice)
  {
    return NULL;
  }

  static Graphics *FromHWND(HWND hWnd, BOOL icm)
  {
    return NULL;
  }

  static Graphics *FromImage(Image *image)
  {
    return NULL;
  }

  Status GetClip(Region *region) const
  {
    return NotImplemented;
  }

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

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

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

  CompositingQuality GetCompositingQuality(VOID)
  {
    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;
  }

  Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
  {
    return SetStatus(DllExports::GdipScaleWorldTransform(graphics, sx, sy, order));
  }

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

  Status SetClip(const GraphicsPath *path, CombineMode combineMode)
  {
    return NotImplemented;
  }

  Status SetClip(const Region *region, CombineMode combineMode)
  {
    return NotImplemented;
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

  Status SetTransform(const Matrix *matrix)
  {
    return NotImplemented;
  }

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

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

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

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

private:
  Status SetStatus(Status status) const
  {
    if (status == Ok)
      return status;
    this->status = status;
    return status;
  }

  VOID SetGraphics(GpGraphics *graphics)
  {
    this->graphics = graphics;
  }

private:
  mutable Status status;
  GpGraphics *graphics;
};

#endif /* _GDIPLUSGRAPHICS_H */