include/gdiplus/gdiplusgraphics.h

/*
 * gdiplusgraphics.h
 *
 * GDI+ Graphics 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_GRAPHICS_H
#define __GDIPLUS_GRAPHICS_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif

#ifndef __cplusplus
#error "A C++ compiler is required to include gdiplusgraphics.h."
#endif

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

public:
        static Graphics* FromHDC(HDC hdc)
        {
                return new Graphics(hdc);
        }
        static Graphics* FromHDC(HDC hdc, HANDLE hdevice)
        {
                return new Graphics(hdc, hdevice);
        }
        static Graphics* FromHWND(HWND hwnd, BOOL icm = FALSE)
        {
                return new Graphics(hwnd, icm);
        }
        static Graphics* FromImage(Image *image)
        {
                return new Graphics(image);
        }
        static HPALETTE GetHalftonePalette()
        {
                return DllExports::GdipCreateHalftonePalette();
        }

        Graphics(Image *image): nativeGraphics(NULL), lastStatus(Ok)
        {
                lastStatus = DllExports::GdipGetImageGraphicsContext(
                                image ? image->nativeImage : NULL,
                                &nativeGraphics);
        }
        Graphics(HDC hdc): nativeGraphics(NULL), lastStatus(Ok)
        {
                lastStatus = DllExports::GdipCreateFromHDC(
                                hdc, &nativeGraphics);
        }
        Graphics(HDC hdc, HANDLE hdevice): nativeGraphics(NULL), lastStatus(Ok)
        {
                lastStatus = DllExports::GdipCreateFromHDC2(
                                hdc, hdevice, &nativeGraphics);
        }
        Graphics(HWND hwnd, BOOL icm = FALSE):
                nativeGraphics(NULL), lastStatus(Ok)
        {
                if (icm) {
                        lastStatus = DllExports::GdipCreateFromHWNDICM(
                                        hwnd, &nativeGraphics);
                } else {
                        lastStatus = DllExports::GdipCreateFromHWND(
                                        hwnd, &nativeGraphics);
                }
        }
        ~Graphics()
        {
                DllExports::GdipDeleteGraphics(nativeGraphics);
        }

        Status AddMetafileComment(const BYTE *data, UINT sizeData)
        {
                return updateStatus(DllExports::GdipComment(
                                nativeGraphics, sizeData, data));
        }
        GraphicsContainer BeginContainer()
        {
                GraphicsContainer result = 0;
                updateStatus(DllExports::GdipBeginContainer2(
                                nativeGraphics, &result));
                return result;
        }
        GraphicsContainer BeginContainer(const RectF& dstrect,
                        const RectF& srcrect, Unit unit)
        {
                GraphicsContainer result = 0;
                updateStatus(DllExports::GdipBeginContainer(
                                nativeGraphics, &dstrect, &srcrect, unit,
                                &result));
                return result;
        }
        GraphicsContainer BeginContainer(const Rect& dstrect,
                        const Rect& srcrect, Unit unit)
        {
                GraphicsContainer result = 0;
                updateStatus(DllExports::GdipBeginContainerI(
                                nativeGraphics, &dstrect, &srcrect, unit,
                                &result));
                return result;
        }
        Status Clear(const Color& color)
        {
                return updateStatus(DllExports::GdipGraphicsClear(
                                nativeGraphics, color.GetValue()));
        }
        Status DrawArc(const Pen *pen, REAL x, REAL y, REAL width, REAL height,
                        REAL startAngle, REAL sweepAngle)
        {
                return updateStatus(DllExports::GdipDrawArc(
                                nativeGraphics, pen ? pen->nativePen : 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 updateStatus(DllExports::GdipDrawArcI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                x, y, width, height, startAngle, sweepAngle));
        }
        Status DrawArc(const Pen *pen, const RectF& rect,
                        REAL startAngle, REAL sweepAngle)
        {
                return updateStatus(DllExports::GdipDrawArc(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height,
                                startAngle, sweepAngle));
        }
        Status DrawArc(const Pen *pen, const Rect& rect,
                        REAL startAngle, REAL sweepAngle)
        {
                return updateStatus(DllExports::GdipDrawArcI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height,
                                startAngle, sweepAngle));
        }
        Status DrawBezier(const Pen *pen,
                        REAL x1, REAL y1, REAL x2, REAL y2,
                        REAL x3, REAL y3, REAL x4, REAL y4)
        {
                return updateStatus(DllExports::GdipDrawBezier(
                                nativeGraphics, pen ? pen->nativePen : 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 updateStatus(DllExports::GdipDrawBezierI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                x1, y1, x2, y2, x3, y3, x4, y4));
        }
        Status DrawBezier(const Pen *pen,
                        const PointF& pt1, const PointF& pt2,
                        const PointF& pt3, const PointF& pt4)
        {
                return updateStatus(DllExports::GdipDrawBezier(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                pt1.X, pt1.Y, pt2.X, pt2.Y,
                                pt3.X, pt3.Y, pt4.X, pt4.Y));
        }
        Status DrawBezier(const Pen *pen,
                        const Point& pt1, const Point& pt2,
                        const Point& pt3, const Point& pt4)
        {
                return updateStatus(DllExports::GdipDrawBezierI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                pt1.X, pt1.Y, pt2.X, pt2.Y,
                                pt3.X, pt3.Y, pt4.X, pt4.Y));
        }
        Status DrawBeziers(const Pen *pen, const PointF *points, INT count)
        {
                return updateStatus(DllExports::GdipDrawBeziers(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count));
        }
        Status DrawBeziers(const Pen *pen, const Point *points, INT count)
        {
                return updateStatus(DllExports::GdipDrawBeziersI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count));
        }
        Status DrawCachedBitmap(CachedBitmap *cb, INT x, INT y)
        {
                return updateStatus(DllExports::GdipDrawCachedBitmap(
                                nativeGraphics,
                                cb ? cb->nativeCachedBitmap : NULL,
                                x, y));
        }
        Status DrawClosedCurve(const Pen *pen, const PointF *points, INT count)
        {
                return updateStatus(DllExports::GdipDrawClosedCurve(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count));
        }
        Status DrawClosedCurve(const Pen *pen, const Point *points, INT count)
        {
                return updateStatus(DllExports::GdipDrawClosedCurveI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count));
        }
        Status DrawClosedCurve(const Pen *pen, const PointF *points, INT count,
                        REAL tension)
        {
                return updateStatus(DllExports::GdipDrawClosedCurve2(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count, tension));
        }
        Status DrawClosedCurve(const Pen *pen, const Point *points, INT count,
                        REAL tension)
        {
                return updateStatus(DllExports::GdipDrawClosedCurve2I(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count, tension));
        }
        Status DrawCurve(const Pen *pen, const PointF *points, INT count)
        {
                return updateStatus(DllExports::GdipDrawCurve(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count));
        }
        Status DrawCurve(const Pen *pen, const Point *points, INT count)
        {
                return updateStatus(DllExports::GdipDrawCurveI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count));
        }
        Status DrawCurve(const Pen *pen, const PointF *points, INT count,
                        REAL tension)
        {
                return updateStatus(DllExports::GdipDrawCurve2(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count, tension));
        }
        Status DrawCurve(const Pen *pen, const Point *points, INT count,
                        REAL tension)
        {
                return updateStatus(DllExports::GdipDrawCurve2I(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count, tension));
        }
        Status DrawCurve(const Pen *pen, const PointF *points, INT count,
                        INT offset, INT numberOfSegments, REAL tension)
        {
                return updateStatus(DllExports::GdipDrawCurve3(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count, offset,
                                numberOfSegments, tension));
        }
        Status DrawCurve(const Pen *pen, const Point *points, INT count,
                        INT offset, INT numberOfSegments, REAL tension)
        {
                return updateStatus(DllExports::GdipDrawCurve3I(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count, offset,
                                numberOfSegments, tension));
        }
        Status DrawDriverString(const UINT16 *text, INT length,
                        const Font *font, const Brush *brush,
                        const PointF *positions, INT flags,
                        const Matrix *matrix)
        {
                return updateStatus(DllExports::GdipDrawDriverString(
                                nativeGraphics, text, length,
                                font ? font->nativeFont : NULL,
                                brush ? brush->nativeBrush : NULL,
                                positions, flags,
                                matrix ? matrix->nativeMatrix : NULL));
        }
        Status DrawEllipse(const Pen *pen,
                        REAL x, REAL y, REAL width, REAL height)
        {
                return updateStatus(DllExports::GdipDrawEllipse(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                x, y, width, height));
        }
        Status DrawEllipse(const Pen *pen, INT x, INT y, INT width, INT height)
        {
                return updateStatus(DllExports::GdipDrawEllipseI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                x, y, width, height));
        }
        Status DrawEllipse(const Pen *pen, const RectF& rect)
        {
                return updateStatus(DllExports::GdipDrawEllipse(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height));
        }
        Status DrawEllipse(const Pen *pen, const Rect& rect)
        {
                return updateStatus(DllExports::GdipDrawEllipseI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height));
        }
        Status DrawImage(Image *image, REAL x, REAL y)
        {
                return updateStatus(DllExports::GdipDrawImage(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                x, y));
        }
        Status DrawImage(Image *image, INT x, INT y)
        {
                return updateStatus(DllExports::GdipDrawImageI(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                x, y));
        }
        Status DrawImage(Image *image, const PointF& point)
        {
                return updateStatus(DllExports::GdipDrawImage(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                point.X, point.Y));
        }
        Status DrawImage(Image *image, const Point& point)
        {
                return updateStatus(DllExports::GdipDrawImageI(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                point.X, point.Y));
        }
        Status DrawImage(Image *image, REAL x, REAL y, REAL width, REAL height)
        {
                return updateStatus(DllExports::GdipDrawImageRect(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                x, y, width, height));
        }
        Status DrawImage(Image *image, INT x, INT y, INT width, INT height)
        {
                return updateStatus(DllExports::GdipDrawImageRectI(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                x, y, width, height));
        }
        Status DrawImage(Image *image, const RectF& rect)
        {
                return updateStatus(DllExports::GdipDrawImageRect(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height));
        }
        Status DrawImage(Image *image, const Rect& rect)
        {
                return updateStatus(DllExports::GdipDrawImageRectI(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height));
        }
        Status DrawImage(Image *image, const PointF *destPoints, INT count)
        {
                return updateStatus(DllExports::GdipDrawImagePoints(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                destPoints, count));
        }
        Status DrawImage(Image *image, const Point *destPoints, INT count)
        {
                return updateStatus(DllExports::GdipDrawImagePointsI(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                destPoints, count));
        }
        Status DrawImage(Image *image, REAL x, REAL y, REAL srcx, REAL srcy,
                        REAL srcwidth, REAL srcheight, Unit srcUnit)
        {
                return updateStatus(DllExports::GdipDrawImagePointRect(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                x, y, srcx, srcy, srcwidth, srcheight,
                                srcUnit));
        }
        Status DrawImage(Image *image, INT x, INT y, INT srcx, INT srcy,
                        INT srcwidth, INT srcheight, Unit srcUnit)
        {
                return updateStatus(DllExports::GdipDrawImagePointRectI(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                x, y, srcx, srcy, srcwidth, srcheight,
                                srcUnit));
        }
        Status DrawImage(Image *image, const RectF& destRect,
                        REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
                        Unit srcUnit,
                        const ImageAttributes *imageAttributes = NULL,
                        DrawImageAbort callback = NULL,
                        VOID *callbackData = NULL)
        {
                return updateStatus(DllExports::GdipDrawImageRectRect(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                destRect.X, destRect.Y,
                                destRect.Width, destRect.Height,
                                srcx, srcy, srcwidth, srcheight, srcUnit,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL,
                                callback, callbackData));
        }
        Status DrawImage(Image *image, const Rect& destRect,
                        INT srcx, INT srcy, INT srcwidth, INT srcheight,
                        Unit srcUnit,
                        const ImageAttributes *imageAttributes = NULL,
                        DrawImageAbort callback = NULL,
                        VOID *callbackData = NULL)
        {
                return updateStatus(DllExports::GdipDrawImageRectRectI(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                destRect.X, destRect.Y,
                                destRect.Width, destRect.Height,
                                srcx, srcy, srcwidth, srcheight, srcUnit,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL,
                                callback, callbackData));
        }
        Status DrawImage(Image *image, const RectF& destRect,
                        const RectF& sourceRect, Unit srcUnit,
                        const ImageAttributes *imageAttributes = NULL)
        {
                return updateStatus(DllExports::GdipDrawImageRectRectI(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                destRect.X, destRect.Y,
                                destRect.Width, destRect.Height,
                                sourceRect.X, sourceRect.Y,
                                sourceRect.Width, sourceRect.Height, srcUnit,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL,
                                NULL, NULL));
        }
        Status DrawImage(Image *image, const PointF *destPoints, INT count,
                        REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
                        Unit srcUnit,
                        const ImageAttributes *imageAttributes = NULL,
                        DrawImageAbort callback = NULL,
                        VOID *callbackData = NULL)
        {
                return updateStatus(DllExports::GdipDrawImagePointsRect(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                destPoints, count,
                                srcx, srcy, srcwidth, srcheight, srcUnit,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL,
                                callback, callbackData));
        }
        Status DrawImage(Image *image, const Point *destPoints, INT count,
                        INT srcx, INT srcy, INT srcwidth, INT srcheight,
                        Unit srcUnit,
                        const ImageAttributes *imageAttributes = NULL,
                        DrawImageAbort callback = NULL,
                        VOID *callbackData = NULL)
        {
                return updateStatus(DllExports::GdipDrawImagePointsRectI(
                                nativeGraphics,
                                image ? image->nativeImage : NULL,
                                destPoints, count,
                                srcx, srcy, srcwidth, srcheight, srcUnit,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL,
                                callback, callbackData));
        }
        // TODO: [GDI+ 1.1] Graphics::DrawImage(..Effect..)
        //Status DrawImage(Image *image, RectF *sourceRect, Matrix *matrix,
        //              Effect *effect, ImageAttributes *imageAttributes,
        //              Unit srcUnit)
        //{
        //      return updateStatus(DllExports::GdipDrawImageFX(
        //                      nativeGraphics,
        //                      image ? image->nativeImage : NULL,
        //                      sourceRect,
        //                      matrix ? matrix->nativeMatrix : NULL,
        //                      effect ? effect->nativeEffect : NULL,
        //                      imageAttributes ? imageAttributes->nativeImageAttributes : NULL,
        //                      srcUnit));
        //}
        Status DrawLine(const Pen *pen, REAL x1, REAL y1, REAL x2, REAL y2)
        {
                return updateStatus(DllExports::GdipDrawLine(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                x1, y1, x2, y2));
        }
        Status DrawLine(const Pen *pen, INT x1, INT y1, INT x2, INT y2)
        {
                return updateStatus(DllExports::GdipDrawLineI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                x1, y1, x2, y2));
        }
        Status DrawLine(const Pen *pen, const PointF& pt1, const PointF& pt2)
        {
                return updateStatus(DllExports::GdipDrawLine(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                pt1.X, pt1.Y, pt2.X, pt2.Y));
        }
        Status DrawLine(const Pen *pen, const Point& pt1, const Point& pt2)
        {
                return updateStatus(DllExports::GdipDrawLineI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                pt1.X, pt1.Y, pt2.X, pt2.Y));
        }
        Status DrawLines(const Pen *pen, const PointF *points, INT count)
        {
                return updateStatus(DllExports::GdipDrawLines(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count));
        }
        Status DrawLines(const Pen *pen, const Point *points, INT count)
        {
                return updateStatus(DllExports::GdipDrawLinesI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count));
        }
        Status DrawPath(const Pen *pen, const GraphicsPath *path)
        {
                return updateStatus(DllExports::GdipDrawPath(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                path ? path->nativePath : NULL));
        }
        Status DrawPie(const Pen *pen, REAL x, REAL y, REAL width, REAL height,
                        REAL startAngle, REAL sweepAngle)
        {
                return updateStatus(DllExports::GdipDrawPie(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                x, y, width, height, startAngle, sweepAngle));
        }
        Status DrawPie(const Pen *pen, INT x, INT y, INT width, INT height,
                        REAL startAngle, REAL sweepAngle)
        {
                return updateStatus(DllExports::GdipDrawPieI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                x, y, width, height, startAngle, sweepAngle));
        }
        Status DrawPie(const Pen *pen, const RectF& rect,
                        REAL startAngle, REAL sweepAngle)
        {
                return updateStatus(DllExports::GdipDrawPie(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height,
                                startAngle, sweepAngle));
        }
        Status DrawPie(const Pen *pen, const Rect& rect,
                        REAL startAngle, REAL sweepAngle)
        {
                return updateStatus(DllExports::GdipDrawPieI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height,
                                startAngle, sweepAngle));
        }
        Status DrawPolygon(const Pen *pen, const PointF *points, INT count)
        {
                return updateStatus(DllExports::GdipDrawPolygon(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count));
        }
        Status DrawPolygon(const Pen *pen, const Point *points, INT count)
        {
                return updateStatus(DllExports::GdipDrawPolygonI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                points, count));
        }
        Status DrawRectangle(const Pen *pen,
                        REAL x, REAL y, REAL width, REAL height)
        {
                return updateStatus(DllExports::GdipDrawRectangle(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                x, y, width, height));
        }
        Status DrawRectangle(const Pen *pen,
                        INT x, INT y, INT width, INT height)
        {
                return updateStatus(DllExports::GdipDrawRectangleI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                x, y, width, height));
        }
        Status DrawRectangle(const Pen *pen, const RectF& rect)
        {
                return updateStatus(DllExports::GdipDrawRectangle(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height));
        }
        Status DrawRectangle(const Pen *pen, const Rect& rect)
        {
                return updateStatus(DllExports::GdipDrawRectangleI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height));
        }
        Status DrawRectangles(const Pen *pen, const RectF *rects, INT count)
        {
                return updateStatus(DllExports::GdipDrawRectangles(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                rects, count));
        }
        Status DrawRectangles(const Pen *pen, const Rect *rects, INT count)
        {
                return updateStatus(DllExports::GdipDrawRectanglesI(
                                nativeGraphics, pen ? pen->nativePen : NULL,
                                rects, count));
        }
        Status DrawString(const WCHAR *string, INT length, const Font *font,
                        const PointF& origin, const Brush *brush)
        {
                RectF layoutRect(origin.X, origin.Y, 0.0f, 0.0f);
                return updateStatus(DllExports::GdipDrawString(
                                nativeGraphics, string, length,
                                font ? font->nativeFont : NULL,
                                &layoutRect, NULL,
                                brush ? brush->nativeBrush : NULL));
        }
        Status DrawString(const WCHAR *string, INT length,
                        const Font *font, const PointF& origin,
                        const StringFormat *stringFormat, const Brush *brush)
        {
                RectF layoutRect(origin.X, origin.Y, 0.0f, 0.0f);
                return updateStatus(DllExports::GdipDrawString(
                                nativeGraphics, string, length,
                                font ? font->nativeFont : NULL,
                                &layoutRect,
                                stringFormat ? stringFormat->nativeStringFormat : NULL,
                                brush ? brush->nativeBrush : NULL));
        }
        Status DrawString(const WCHAR *string, INT length,
                        const Font *font, const RectF& layoutRect,
                        const StringFormat *stringFormat, const Brush *brush)
        {
                return updateStatus(DllExports::GdipDrawString(
                                nativeGraphics, string, length,
                                font ? font->nativeFont : NULL,
                                &layoutRect,
                                stringFormat ? stringFormat->nativeStringFormat : NULL,
                                brush ? brush->nativeBrush : NULL));
        }
        Status EndContainer(GraphicsContainer state)
        {
                return updateStatus(DllExports::GdipEndContainer(
                                nativeGraphics, state));
        }
        Status EnumerateMetafile(const Metafile *metafile,
                        const PointF& destPoint,
                        EnumerateMetafileProc callback,
                        VOID *callbackData = NULL,
                        ImageAttributes *imageAttributes = NULL)
        {
                return updateStatus(DllExports::GdipEnumerateMetafileDestPoint(
                                nativeGraphics,
                                metafile ? ((GpMetafile*) metafile->nativeImage) : NULL,
                                destPoint, callback, callbackData,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL));
        }
        Status EnumerateMetafile(const Metafile *metafile,
                        const Point& destPoint,
                        EnumerateMetafileProc callback,
                        VOID *callbackData = NULL,
                        ImageAttributes *imageAttributes = NULL)
        {
                return updateStatus(DllExports::GdipEnumerateMetafileDestPointI(
                                nativeGraphics,
                                metafile ? ((GpMetafile*) metafile->nativeImage) : NULL,
                                destPoint, callback, callbackData,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL));
        }
        Status EnumerateMetafile(const Metafile *metafile,
                        const RectF& destRect,
                        EnumerateMetafileProc callback,
                        VOID *callbackData = NULL,
                        ImageAttributes *imageAttributes = NULL)
        {
                return updateStatus(DllExports::GdipEnumerateMetafileDestRect(
                                nativeGraphics,
                                metafile ? ((GpMetafile*) metafile->nativeImage) : NULL,
                                destRect, callback, callbackData,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL));
        }
        Status EnumerateMetafile(const Metafile *metafile,
                        const Rect& destRect,
                        EnumerateMetafileProc callback,
                        VOID *callbackData = NULL,
                        ImageAttributes *imageAttributes = NULL)
        {
                return updateStatus(DllExports::GdipEnumerateMetafileDestRectI(
                                nativeGraphics,
                                metafile ? ((GpMetafile*) metafile->nativeImage) : NULL,
                                destRect, callback, callbackData,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL));
        }
        Status EnumerateMetafile(const Metafile *metafile,
                        const PointF *destPoints, INT count,
                        EnumerateMetafileProc callback,
                        VOID *callbackData = NULL,
                        ImageAttributes *imageAttributes = NULL)
        {
                return updateStatus(DllExports::GdipEnumerateMetafileDestPoints(
                                nativeGraphics,
                                metafile ? ((GpMetafile*) metafile->nativeImage) : NULL,
                                destPoints, count, callback, callbackData,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL));
        }
        Status EnumerateMetafile(const Metafile *metafile,
                        const Point *destPoints, INT count,
                        EnumerateMetafileProc callback,
                        VOID *callbackData = NULL,
                        ImageAttributes *imageAttributes = NULL)
        {
                return updateStatus(DllExports::GdipEnumerateMetafileDestPointsI(
                                nativeGraphics,
                                metafile ? ((GpMetafile*) metafile->nativeImage) : NULL,
                                destPoints, count, callback, callbackData,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL));
        }
        Status EnumerateMetafile(const Metafile *metafile,
                        const PointF& destPoint,
                        const RectF& srcRect, Unit srcUnit,
                        EnumerateMetafileProc callback,
                        VOID *callbackData = NULL,
                        ImageAttributes *imageAttributes = NULL)
        {
                return updateStatus(DllExports::GdipEnumerateMetafileSrcRectDestPoint(
                                nativeGraphics,
                                metafile ? ((GpMetafile*) metafile->nativeImage) : NULL,
                                destPoint, srcRect, srcUnit,
                                callback, callbackData,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL));
        }
        Status EnumerateMetafile(const Metafile *metafile,
                        const Point& destPoint,
                        const Rect& srcRect, Unit srcUnit,
                        EnumerateMetafileProc callback,
                        VOID *callbackData = NULL,
                        ImageAttributes *imageAttributes = NULL)
        {
                return updateStatus(DllExports::GdipEnumerateMetafileSrcRectDestPointI(
                                nativeGraphics,
                                metafile ? ((GpMetafile*) metafile->nativeImage) : NULL,
                                destPoint, srcRect, srcUnit,
                                callback, callbackData,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL));
        }
        Status EnumerateMetafile(const Metafile *metafile,
                        const RectF& destRect,
                        const RectF& srcRect, Unit srcUnit,
                        EnumerateMetafileProc callback,
                        VOID *callbackData = NULL,
                        ImageAttributes *imageAttributes = NULL)
        {
                return updateStatus(DllExports::GdipEnumerateMetafileSrcRectDestRect(
                                nativeGraphics,
                                metafile ? ((GpMetafile*) metafile->nativeImage) : NULL,
                                destRect, srcRect, srcUnit,
                                callback, callbackData,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL));
        }
        Status EnumerateMetafile(const Metafile *metafile,
                        const Rect& destRect,
                        const Rect& srcRect, Unit srcUnit,
                        EnumerateMetafileProc callback,
                        VOID *callbackData = NULL,
                        ImageAttributes *imageAttributes = NULL)
        {
                return updateStatus(DllExports::GdipEnumerateMetafileSrcRectDestRectI(
                                nativeGraphics,
                                metafile ? ((GpMetafile*) metafile->nativeImage) : NULL,
                                destRect, srcRect, srcUnit,
                                callback, callbackData,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL));
        }
        Status EnumerateMetafile(const Metafile *metafile,
                        const PointF* destPoints, INT count,
                        const RectF& srcRect, Unit srcUnit,
                        EnumerateMetafileProc callback,
                        VOID *callbackData = NULL,
                        ImageAttributes *imageAttributes = NULL)
        {
                return updateStatus(DllExports::GdipEnumerateMetafileSrcRectDestPoints(
                                nativeGraphics,
                                metafile ? ((GpMetafile*) metafile->nativeImage) : NULL,
                                destPoints, count, srcRect, srcUnit,
                                callback, callbackData,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL));
        }
        Status EnumerateMetafile(const Metafile *metafile,
                        const Point* destPoints, INT count,
                        const Rect& srcRect, Unit srcUnit,
                        EnumerateMetafileProc callback,
                        VOID *callbackData = NULL,
                        ImageAttributes *imageAttributes = NULL)
        {
                return updateStatus(DllExports::GdipEnumerateMetafileSrcRectDestPointsI(
                                nativeGraphics,
                                metafile ? ((GpMetafile*) metafile->nativeImage) : NULL,
                                destPoints, count, srcRect, srcUnit,
                                callback, callbackData,
                                imageAttributes ? imageAttributes->nativeImageAttributes : NULL));
        }
        Status ExcludeClip(const RectF& rect)
        {
                return updateStatus(DllExports::GdipSetClipRect(
                                nativeGraphics,
                                rect.X, rect.Y, rect.Width, rect.Height,
                                CombineModeExclude));
        }
        Status ExcludeClip(const Rect& rect)
        {
                return updateStatus(DllExports::GdipSetClipRectI(
                                nativeGraphics,
                                rect.X, rect.Y, rect.Width, rect.Height,
                                CombineModeExclude));
        }
        Status ExcludeClip(const Region *region)
        {
                return updateStatus(DllExports::GdipSetClipRegion(
                                nativeGraphics,
                                region ? region->nativeRegion : NULL,
                                CombineModeExclude));
        }
        Status FillClosedCurve(const Brush *brush,
                        const PointF *points, INT count)
        {
                return updateStatus(DllExports::GdipFillClosedCurve(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                points, count));
        }
        Status FillClosedCurve(const Brush *brush,
                        const Point *points, INT count)
        {
                return updateStatus(DllExports::GdipFillClosedCurveI(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                points, count));
        }
        Status FillClosedCurve(const Brush *brush,
                        const PointF *points, INT count,
                        FillMode fillMode, REAL tension = 0.5f)
        {
                return updateStatus(DllExports::GdipFillClosedCurve2(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                points, count, tension, fillMode));
        }
        Status FillClosedCurve(const Brush *brush,
                        const Point *points, INT count,
                        FillMode fillMode, REAL tension = 0.5f)
        {
                return updateStatus(DllExports::GdipFillClosedCurve2I(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                points, count, tension, fillMode));
        }
        Status FillEllipse(const Brush *brush,
                        REAL x, REAL y, REAL width, REAL height)
        {
                return updateStatus(DllExports::GdipFillEllipse(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                x, y, width, height));
        }
        Status FillEllipse(const Brush *brush,
                        INT x, INT y, INT width, INT height)
        {
                return updateStatus(DllExports::GdipFillEllipseI(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                x, y, width, height));
        }
        Status FillEllipse(const Brush *brush, const RectF& rect)
        {
                return updateStatus(DllExports::GdipFillEllipse(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height));
        }
        Status FillEllipse(const Brush *brush, const Rect& rect)
        {
                return updateStatus(DllExports::GdipFillEllipseI(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height));
        }
        Status FillPath(const Brush *brush, const GraphicsPath *path)
        {
                return updateStatus(DllExports::GdipFillPath(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                path ? path->nativePath : NULL));
        }
        Status FillPie(const Brush *brush,
                        REAL x, REAL y, REAL width, REAL height,
                        REAL startAngle, REAL sweepAngle)
        {
                return updateStatus(DllExports::GdipFillPie(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                x, y, width, height, startAngle, sweepAngle));
        }
        Status FillPie(const Brush *brush, INT x, INT y, INT width, INT height,
                        REAL startAngle, REAL sweepAngle)
        {
                return updateStatus(DllExports::GdipFillPieI(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                x, y, width, height, startAngle, sweepAngle));
        }
        Status FillPie(const Brush *brush, const RectF& rect,
                        REAL startAngle, REAL sweepAngle)
        {
                return updateStatus(DllExports::GdipFillPie(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height,
                                startAngle, sweepAngle));
        }
        Status FillPie(const Brush *brush, const Rect& rect,
                        REAL startAngle, REAL sweepAngle)
        {
                return updateStatus(DllExports::GdipFillPieI(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height,
                                startAngle, sweepAngle));
        }
        Status FillPolygon(const Brush *brush, const PointF *points, INT count)
        {
                return updateStatus(DllExports::GdipFillPolygon(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                points, count, FillModeAlternate));
        }
        Status FillPolygon(const Brush *brush, const Point *points, INT count)
        {
                return updateStatus(DllExports::GdipFillPolygonI(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                points, count, FillModeAlternate));
        }
        Status FillPolygon(const Brush *brush, const PointF *points, INT count,
                        FillMode fillMode)
        {
                return updateStatus(DllExports::GdipFillPolygon(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                points, count, fillMode));
        }
        Status FillPolygon(const Brush *brush, const Point *points, INT count,
                        FillMode fillMode)
        {
                return updateStatus(DllExports::GdipFillPolygonI(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                points, count, fillMode));
        }
        Status FillRectangle(const Brush *brush,
                        REAL x, REAL y, REAL width, REAL height)
        {
                return updateStatus(DllExports::GdipFillRectangle(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                x, y, width, height));
        }
        Status FillRectangle(const Brush *brush,
                        INT x, INT y, INT width, INT height)
        {
                return updateStatus(DllExports::GdipFillRectangleI(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                x, y, width, height));
        }
        Status FillRectangle(const Brush *brush, const RectF& rect)
        {
                return updateStatus(DllExports::GdipFillRectangle(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height));
        }
        Status FillRectangle(const Brush *brush, const Rect& rect)
        {
                return updateStatus(DllExports::GdipFillRectangleI(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                rect.X, rect.Y, rect.Width, rect.Height));
        }
        Status FillRectangles(const Brush *brush, const RectF *rects, INT count)
        {
                return updateStatus(DllExports::GdipFillRectangles(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                rects, count));
        }
        Status FillRectangles(const Brush *brush, const Rect *rects, INT count)
        {
                return updateStatus(DllExports::GdipFillRectanglesI(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                rects, count));
        }
        Status FillRegion(const Brush *brush, const Region *region)
        {
                return updateStatus(DllExports::GdipFillRegion(
                                nativeGraphics,
                                brush ? brush->nativeBrush : NULL,
                                region ? region->nativeRegion : NULL));
        }
        VOID Flush(FlushIntention intention = FlushIntentionFlush)
        {
                updateStatus(DllExports::GdipFlush(nativeGraphics, intention));
        }
        Status GetClip(Region *region) const
        {
                return updateStatus(DllExports::GdipGetClip(
                                nativeGraphics,
                                region ? region->nativeRegion : NULL));
        }
        Status GetClipBounds(RectF *rect) const
        {
                return updateStatus(DllExports::GdipGetClipBounds(
                                nativeGraphics, rect));
        }
        Status GetClipBounds(Rect *rect) const
        {
                return updateStatus(DllExports::GdipGetClipBoundsI(
                                nativeGraphics, rect));
        }
        CompositingMode GetCompositingMode() const
        {
                CompositingMode result = CompositingModeSourceOver;
                updateStatus(DllExports::GdipGetCompositingMode(
                                nativeGraphics, &result));
                return result;
        }
        CompositingQuality GetCompositingQuality() const
        {
                CompositingQuality result = CompositingQualityDefault;
                updateStatus(DllExports::GdipGetCompositingQuality(
                                nativeGraphics, &result));
                return result;
        }
        REAL GetDpiX() const
        {
                REAL result = 0.0f;
                updateStatus(DllExports::GdipGetDpiX(nativeGraphics, &result));
                return result;
        }
        REAL GetDpiY() const
        {
                REAL result = 0.0f;
                updateStatus(DllExports::GdipGetDpiY(nativeGraphics, &result));
                return result;
        }
        HDC GetHDC()
        {
                HDC result = NULL;
                updateStatus(DllExports::GdipGetDC(nativeGraphics, &result));
                return result;
        }
        InterpolationMode GetInterpolationMode() const
        {
                InterpolationMode result = InterpolationModeDefault;
                updateStatus(DllExports::GdipGetInterpolationMode(
                                nativeGraphics, &result));
                return result;
        }
        Status GetLastStatus() const
        {
                Status result = lastStatus;
                lastStatus = Ok;
                return result;
        }
        Status GetNearestColor(Color *color) const
        {
                return updateStatus(DllExports::GdipGetNearestColor(
                                nativeGraphics, color ? &color->Value : NULL));
        }
        REAL GetPageScale() const
        {
                REAL result = 0.0f;
                updateStatus(DllExports::GdipGetPageScale(
                                nativeGraphics, &result));
                return result;
        }
        Unit GetPageUnit() const
        {
                Unit result = UnitWorld;
                updateStatus(DllExports::GdipGetPageUnit(
                                nativeGraphics, &result));
                return result;
        }
        PixelOffsetMode GetPixelOffsetMode() const
        {
                PixelOffsetMode result = PixelOffsetModeDefault;
                updateStatus(DllExports::GdipGetPixelOffsetMode(
                                nativeGraphics, &result));
                return result;
        }
        Status GetRenderingOrigin(INT *x, INT *y) const
        {
                return updateStatus(DllExports::GdipGetRenderingOrigin(
                                nativeGraphics, x, y));
        }
        SmoothingMode GetSmoothingMode() const
        {
                SmoothingMode result = SmoothingModeDefault;
                updateStatus(DllExports::GdipGetSmoothingMode(
                                nativeGraphics, &result));
                return result;
        }
        UINT GetTextContrast() const
        {
                UINT result = 0;
                updateStatus(DllExports::GdipGetTextContrast(
                                nativeGraphics, &result));
                return result;
        }
        TextRenderingHint GetTextRenderingHint() const
        {
                TextRenderingHint result = TextRenderingHintSystemDefault;
                updateStatus(DllExports::GdipGetTextRenderingHint(
                                nativeGraphics, &result));
                return result;
        }
        Status GetTransform(Matrix *matrix) const
        {
                return updateStatus(DllExports::GdipGetWorldTransform(
                                nativeGraphics,
                                matrix ? matrix->nativeMatrix : NULL));
        }
        Status GetVisibleClipBounds(RectF *rect) const
        {
                return updateStatus(DllExports::GdipGetVisibleClipBounds(
                                nativeGraphics, rect));
        }
        Status GetVisibleClipBounds(Rect *rect) const
        {
                return updateStatus(DllExports::GdipGetVisibleClipBoundsI(
                                nativeGraphics, rect));
        }
        Status IntersectClip(const RectF& rect)
        {
                return updateStatus(DllExports::GdipSetClipRect(
                                nativeGraphics,
                                rect.X, rect.Y, rect.Width, rect.Height,
                                CombineModeIntersect));
        }
        Status IntersectClip(const Rect& rect)
        {
                return updateStatus(DllExports::GdipSetClipRectI(
                                nativeGraphics,
                                rect.X, rect.Y, rect.Width, rect.Height,
                                CombineModeIntersect));
        }
        Status IntersectClip(const Region *region)
        {
                return updateStatus(DllExports::GdipSetClipRegion(
                                nativeGraphics,
                                region ? region->nativeRegion : NULL,
                                CombineModeIntersect));
        }
        BOOL IsClipEmpty() const
        {
                BOOL result = FALSE;
                updateStatus(DllExports::GdipIsClipEmpty(
                                nativeGraphics, &result));
                return result;
        }
        BOOL IsVisible(REAL x, REAL y) const
        {
                BOOL result = FALSE;
                updateStatus(DllExports::GdipIsVisiblePoint(
                                nativeGraphics, x, y, &result));
                return result;
        }
        BOOL IsVisible(INT x, INT y) const
        {
                BOOL result = FALSE;
                updateStatus(DllExports::GdipIsVisiblePointI(
                                nativeGraphics, x, y, &result));
                return result;
        }
        BOOL IsVisible(const PointF& point) const
        {
                BOOL result = FALSE;
                updateStatus(DllExports::GdipIsVisiblePoint(
                                nativeGraphics, point.X, point.Y, &result));
                return result;
        }
        BOOL IsVisible(const Point& point) const
        {
                BOOL result = FALSE;
                updateStatus(DllExports::GdipIsVisiblePointI(
                                nativeGraphics, point.X, point.Y, &result));
                return result;
        }
        BOOL IsVisible(REAL x, REAL y, REAL width, REAL height) const
        {
                BOOL result = FALSE;
                updateStatus(DllExports::GdipIsVisibleRect(
                                nativeGraphics, x, y, width, height, &result));
                return result;
        }
        BOOL IsVisible(INT x, INT y, INT width, INT height) const
        {
                BOOL result = FALSE;
                updateStatus(DllExports::GdipIsVisibleRectI(
                                nativeGraphics, x, y, width, height, &result));
                return result;
        }
        BOOL IsVisible(const RectF& rect) const
        {
                BOOL result = FALSE;
                updateStatus(DllExports::GdipIsVisibleRect(
                                nativeGraphics, rect.X, rect.Y,
                                rect.Width, rect.Height, &result));
                return result;
        }
        BOOL IsVisible(const Rect& rect) const
        {
                BOOL result = FALSE;
                updateStatus(DllExports::GdipIsVisibleRectI(
                                nativeGraphics, rect.X, rect.Y,
                                rect.Width, rect.Height, &result));
                return result;
        }
        BOOL IsVisibleClipEmpty() const
        {
                BOOL result = FALSE;
                updateStatus(DllExports::GdipIsVisibleClipEmpty(
                                nativeGraphics, &result));
                return result;
        }
        Status MeasureCharacterRanges(const WCHAR *string, INT length,
                        const Font *font, const RectF& layoutRect,
                        const StringFormat *stringFormat,
                        INT regionCount, Region *regions) const
        {
                if (regionCount <= 0 || !regions)
                        return lastStatus = InvalidParameter;

                GpRegion **nativeRegionArray = (GpRegion**)
                        DllExports::GdipAlloc(regionCount * sizeof(GpRegion*));
                if (!nativeRegionArray)
                        return lastStatus = OutOfMemory;
                for (int i = 0; i < regionCount; ++i) {
                        nativeRegionArray[i] = regions[i].nativeRegion;
                }
                Status status = updateStatus(DllExports::GdipMeasureCharacterRanges(
                                nativeGraphics, string, length,
                                font ? font->nativeFont : NULL,
                                layoutRect,
                                stringFormat ? stringFormat->nativeStringFormat : NULL,
                                regionCount, nativeRegionArray));
                DllExports::GdipFree(nativeRegionArray);
                return status;
        }
        Status MeasureDriverString(const UINT16 *text, INT length,
                        const Font *font, const PointF *positions, INT flags,
                        const Matrix *matrix, RectF *boundingBox) const
        {
                return updateStatus(DllExports::GdipMeasureDriverString(
                                nativeGraphics, text, length,
                                font ? font->nativeFont : NULL,
                                positions, flags,
                                matrix ? matrix->nativeMatrix : NULL,
                                boundingBox));
        }
        Status MeasureString(const WCHAR *string, INT length,
                        const Font *font, const RectF& layoutRect,
                        RectF *boundingBox) const
        {
                return updateStatus(DllExports::GdipMeasureString(
                                nativeGraphics, string, length,
                                font ? font->nativeFont : NULL,
                                &layoutRect, NULL, boundingBox, NULL, NULL));
        }
        Status MeasureString(const WCHAR *string, INT length,
                        const Font *font, const RectF& layoutRect,
                        const StringFormat *stringFormat, RectF *boundingBox,
                        INT *codepointsFitted = NULL,
                        INT *linesFitted = NULL) const
        {
                return updateStatus(DllExports::GdipMeasureString(
                                nativeGraphics, string, length,
                                font ? font->nativeFont : NULL,
                                &layoutRect,
                                stringFormat ? stringFormat->nativeStringFormat : NULL,
                                boundingBox, codepointsFitted, linesFitted));
        }
        Status MeasureString(const WCHAR *string, INT length,
                        const Font *font, const SizeF& layoutRectSize,
                        const StringFormat *stringFormat, SizeF *size,
                        INT *codepointsFitted = NULL,
                        INT *linesFitted = NULL) const
        {
                if (!size) return lastStatus = InvalidParameter;
                RectF layoutRect(PointF(0.0f, 0.0f), layoutRectSize);
                RectF boundingBox;
                Status status = updateStatus(DllExports::GdipMeasureString(
                                nativeGraphics, string, length,
                                font ? font->nativeFont : NULL,
                                &layoutRect,
                                stringFormat ? stringFormat->nativeStringFormat : NULL,
                                &boundingBox, codepointsFitted, linesFitted));
                boundingBox.GetSize(size);
                return status;
        }
        Status MeasureString(const WCHAR *string, INT length,
                        const Font *font, const PointF& origin,
                        RectF *boundingBox) const
        {
                RectF layoutRect(origin, SizeF(0.0f, 0.0f));
                return updateStatus(DllExports::GdipMeasureString(
                                nativeGraphics, string, length,
                                font ? font->nativeFont : NULL,
                                &layoutRect, NULL, boundingBox, NULL, NULL));
        }
        Status MeasureString(const WCHAR *string, INT length,
                        const Font *font, const PointF& origin,
                        const StringFormat *stringFormat,
                        RectF *boundingBox) const
        {
                RectF layoutRect(origin, SizeF(0.0f, 0.0f));
                return updateStatus(DllExports::GdipMeasureString(
                                nativeGraphics, string, length,
                                font ? font->nativeFont : NULL,
                                &layoutRect,
                                stringFormat ? stringFormat->nativeStringFormat : NULL,
                                boundingBox, NULL, NULL));
        }
        Status MultiplyTransform(const Matrix *matrix,
                        MatrixOrder order = MatrixOrderPrepend)
        {
                return updateStatus(DllExports::GdipMultiplyWorldTransform(
                                nativeGraphics,
                                matrix ? matrix->nativeMatrix : NULL, order));
        }
        VOID ReleaseHDC(HDC hdc)
        {
                updateStatus(DllExports::GdipReleaseDC(nativeGraphics, hdc));
        }
        Status ResetClip()
        {
                return updateStatus(DllExports::GdipResetClip(nativeGraphics));
        }
        Status ResetTransform()
        {
                return updateStatus(DllExports::GdipResetWorldTransform(
                                nativeGraphics));
        }
        Status Restore(GraphicsState state)
        {
                return updateStatus(DllExports::GdipRestoreGraphics(
                                nativeGraphics, state));
        }
        Status RotateTransform(REAL angle,
                        MatrixOrder order = MatrixOrderPrepend)
        {
                return updateStatus(DllExports::GdipRotateWorldTransform(
                                nativeGraphics, angle, order));
        }
        GraphicsState Save() const
        {
                GraphicsState result = 0;
                updateStatus(DllExports::GdipSaveGraphics(
                                nativeGraphics, &result));
                return result;
        }
        Status ScaleTransform(REAL sx, REAL sy,
                        MatrixOrder order = MatrixOrderPrepend)
        {
                return updateStatus(DllExports::GdipScaleWorldTransform(
                                nativeGraphics, sx, sy, order));
        }
        VOID SetAbort()
        {
                updateStatus(NotImplemented);
        }
        Status SetClip(const Graphics *g,
                        CombineMode combineMode = CombineModeReplace)
        {
                return updateStatus(DllExports::GdipSetClipGraphics(
                                nativeGraphics, g ? g->nativeGraphics : NULL,
                                combineMode));
        }
        Status SetClip(const RectF& rect,
                        CombineMode combineMode = CombineModeReplace)
        {
                return updateStatus(DllExports::GdipSetClipRect(
                                nativeGraphics,
                                rect.X, rect.Y, rect.Width, rect.Height,
                                combineMode));
        }
        Status SetClip(const Rect& rect,
                        CombineMode combineMode = CombineModeReplace)
        {
                return updateStatus(DllExports::GdipSetClipRectI(
                                nativeGraphics,
                                rect.X, rect.Y, rect.Width, rect.Height,
                                combineMode));
        }
        Status SetClip(const GraphicsPath *path,
                        CombineMode combineMode = CombineModeReplace)
        {
                return updateStatus(DllExports::GdipSetClipPath(
                                nativeGraphics,
                                path ? path->nativePath : NULL,
                                combineMode));
        }
        Status SetClip(const Region *region,
                        CombineMode combineMode = CombineModeReplace)
        {
                return updateStatus(DllExports::GdipSetClipRegion(
                                nativeGraphics,
                                region ? region->nativeRegion : NULL,
                                combineMode));
        }
        Status SetClip(HRGN hRgn, CombineMode combineMode = CombineModeReplace)
        {
                return updateStatus(DllExports::GdipSetClipHrgn(
                                nativeGraphics, hRgn, combineMode));
        }
        Status SetCompositingMode(CompositingMode compositingMode)
        {
                return updateStatus(DllExports::GdipSetCompositingMode(
                                nativeGraphics, compositingMode));
        }
        Status SetCompositingQuality(CompositingQuality compositingQuality)
        {
                return updateStatus(DllExports::GdipSetCompositingQuality(
                                nativeGraphics, compositingQuality));
        }
        Status SetInterpolationMode(InterpolationMode interpolationMode)
        {
                return updateStatus(DllExports::GdipSetInterpolationMode(
                                nativeGraphics, interpolationMode));
        }
        Status SetPageScale(REAL scale)
        {
                return updateStatus(DllExports::GdipSetPageScale(
                                nativeGraphics, scale));
        }
        Status SetPageUnit(Unit unit)
        {
                return updateStatus(DllExports::GdipSetPageUnit(
                                nativeGraphics, unit));
        }
        Status SetPixelOffsetMode(PixelOffsetMode pixelOffsetMode)
        {
                return updateStatus(DllExports::GdipSetPixelOffsetMode(
                                nativeGraphics, pixelOffsetMode));
        }
        Status SetRenderingOrigin(INT x, INT y)
        {
                return updateStatus(DllExports::GdipSetRenderingOrigin(
                                nativeGraphics, x, y));
        }
        Status SetSmoothingMode(SmoothingMode smoothingMode)
        {
                return updateStatus(DllExports::GdipSetSmoothingMode(
                                nativeGraphics, smoothingMode));
        }
        Status SetTextContrast(UINT contrast)
        {
                return updateStatus(DllExports::GdipSetTextContrast(
                                nativeGraphics, contrast));
        }
        Status SetTextRenderingHint(TextRenderingHint textRenderingHint)
        {
                return updateStatus(DllExports::GdipSetTextRenderingHint(
                                nativeGraphics, textRenderingHint));
        }
        Status SetTransform(const Matrix *matrix)
        {
                return updateStatus(DllExports::GdipSetWorldTransform(
                                nativeGraphics,
                                matrix ? matrix->nativeMatrix : NULL));
        }
        Status TransformPoints(CoordinateSpace destSpace,
                        CoordinateSpace srcSpace,
                        PointF *pts, INT count) const
        {
                return updateStatus(DllExports::GdipTransformPoints(
                                nativeGraphics, destSpace, srcSpace,
                                pts, count));
        }
        Status TransformPoints(CoordinateSpace destSpace,
                        CoordinateSpace srcSpace,
                        Point *pts, INT count) const
        {
                return updateStatus(DllExports::GdipTransformPointsI(
                                nativeGraphics, destSpace, srcSpace,
                                pts, count));
        }
        Status TranslateClip(REAL dx, REAL dy)
        {
                return updateStatus(DllExports::GdipTranslateClip(
                                nativeGraphics, dx, dy));
        }
        Status TranslateClip(INT dx, INT dy)
        {
                return updateStatus(DllExports::GdipTranslateClipI(
                                nativeGraphics, dx, dy));
        }
        Status TranslateTransform(REAL dx, REAL dy,
                        MatrixOrder order = MatrixOrderPrepend)
        {
                return updateStatus(DllExports::GdipTranslateWorldTransform(
                                nativeGraphics, dx, dy, order));
        }

private:
        Graphics(const Graphics&);
        Graphics& operator=(const Graphics&);

        Status updateStatus(Status newStatus) const
        {
                if (newStatus != Ok) lastStatus = newStatus;
                return newStatus;
        }

        GpGraphics *nativeGraphics;
        mutable Status lastStatus;
};

#endif /* __GDIPLUS_GRAPHICS_H */
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	47693 byte(s)
Log Message:	Daodan: Replace MinGW build env with an up-to-date MSYS2 env