/**
 * This file has no copyright assigned and is placed in the Public Domain.
 * This file is part of the w64 mingw-runtime package.
 * No warranty is given; refer to the file DISCLAIMER within this package.
 */
#ifndef _GDIPLUSGRAPHICS_H
#define _GDIPLUSGRAPHICS_H

class Graphics : public GdiplusBase {
public:
  friend class Region;
  friend class GraphicsPath;
  friend class Image;
  friend class Bitmap;
  friend class Metafile;
  friend class Font;
  friend class FontFamily;
  friend class FontCollection;
  friend class CachedBitmap;
  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,WINBOOL icm = FALSE) { return new Graphics(hwnd,icm); }
  static Graphics *FromImage(Image *image) { return new Graphics(image); }
  Graphics(HDC hdc) {
    GpGraphics *graphics = NULL;
    lastResult = DllExports::GdipCreateFromHDC(hdc,&graphics);
    SetNativeGraphics(graphics);
  }
  Graphics(HDC hdc,HANDLE hdevice) {
    GpGraphics *graphics = NULL;
    lastResult = DllExports::GdipCreateFromHDC2(hdc,hdevice,&graphics);
    SetNativeGraphics(graphics);
  }
  Graphics(HWND hwnd,WINBOOL icm = FALSE) {
    GpGraphics *graphics = NULL;
    if(icm) {
      lastResult = DllExports::GdipCreateFromHWNDICM(hwnd,&graphics);
    } else {
      lastResult = DllExports::GdipCreateFromHWND(hwnd,&graphics);
    }
    SetNativeGraphics(graphics);
  }
  Graphics(Image *image) {
    GpGraphics *graphics = NULL;
    if(image!=NULL) {
      lastResult = DllExports::GdipGetImageGraphicsContext(image->nativeImage,&graphics);
    }
    SetNativeGraphics(graphics);
  }
  ~Graphics() {
    DllExports::GdipDeleteGraphics(nativeGraphics);
  }
  VOID Flush(FlushIntention intention = FlushIntentionFlush) {
    DllExports::GdipFlush(nativeGraphics,intention);
  }
  HDC GetHDC() {
    HDC hdc = NULL;
    SetStatus(DllExports::GdipGetDC(nativeGraphics,&hdc));
    return hdc;
  }
  VOID ReleaseHDC(HDC hdc) { SetStatus(DllExports::GdipReleaseDC(nativeGraphics,hdc)); }
  Status SetRenderingOrigin(INT x,INT y) { return SetStatus(DllExports::GdipSetRenderingOrigin(nativeGraphics,x,y)); }
  Status GetRenderingOrigin(INT *x,INT *y) const { return SetStatus(DllExports::GdipGetRenderingOrigin(nativeGraphics,x,y)); }
  Status SetCompositingMode(CompositingMode compositingMode) { return SetStatus(DllExports::GdipSetCompositingMode(nativeGraphics,compositingMode)); }
  CompositingMode GetCompositingMode() const {
    CompositingMode mode;
    SetStatus(DllExports::GdipGetCompositingMode(nativeGraphics,&mode));
    return mode;
  }
  Status SetCompositingQuality(CompositingQuality compositingQuality) { return SetStatus(DllExports::GdipSetCompositingQuality(nativeGraphics,compositingQuality)); }
  CompositingQuality GetCompositingQuality() const {
    CompositingQuality quality;
    SetStatus(DllExports::GdipGetCompositingQuality(nativeGraphics,&quality));
    return quality;
  }
  Status SetTextRenderingHint(TextRenderingHint newMode) { return SetStatus(DllExports::GdipSetTextRenderingHint(nativeGraphics,newMode)); }
  TextRenderingHint GetTextRenderingHint() const {
    TextRenderingHint hint;
    SetStatus(DllExports::GdipGetTextRenderingHint(nativeGraphics,&hint));
    return hint;
  }
  Status SetTextContrast(UINT contrast) { return SetStatus(DllExports::GdipSetTextContrast(nativeGraphics,contrast)); }
  UINT GetTextContrast() const {
    UINT contrast;
    SetStatus(DllExports::GdipGetTextContrast(nativeGraphics,&contrast));
    return contrast;
  }
  InterpolationMode GetInterpolationMode() const {
    InterpolationMode mode = InterpolationModeInvalid;
    SetStatus(DllExports::GdipGetInterpolationMode(nativeGraphics,&mode));
    return mode;
  }
  Status SetInterpolationMode(InterpolationMode interpolationMode) { return SetStatus(DllExports::GdipSetInterpolationMode(nativeGraphics,interpolationMode)); }
  SmoothingMode GetSmoothingMode() const {
    SmoothingMode smoothingMode = SmoothingModeInvalid;
    SetStatus(DllExports::GdipGetSmoothingMode(nativeGraphics,&smoothingMode));
    return smoothingMode;
  }
  Status SetSmoothingMode(SmoothingMode smoothingMode) { return SetStatus(DllExports::GdipSetSmoothingMode(nativeGraphics,smoothingMode)); }
  PixelOffsetMode GetPixelOffsetMode() const {
    PixelOffsetMode pixelOffsetMode = PixelOffsetModeInvalid;
    SetStatus(DllExports::GdipGetPixelOffsetMode(nativeGraphics,&pixelOffsetMode));
    return pixelOffsetMode;
  }
  Status SetPixelOffsetMode(PixelOffsetMode pixelOffsetMode) { return SetStatus(DllExports::GdipSetPixelOffsetMode(nativeGraphics,pixelOffsetMode)); }
  Status SetTransform(const Matrix *matrix) { return SetStatus(DllExports::GdipSetWorldTransform(nativeGraphics,matrix->nativeMatrix)); }
  Status ResetTransform() { return SetStatus(DllExports::GdipResetWorldTransform(nativeGraphics)); }
  Status MultiplyTransform(const Matrix *matrix,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipMultiplyWorldTransform(nativeGraphics,matrix->nativeMatrix,order)); }
  Status TranslateTransform(REAL dx,REAL dy,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipTranslateWorldTransform(nativeGraphics,dx,dy,order)); }
  Status ScaleTransform(REAL sx,REAL sy,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipScaleWorldTransform(nativeGraphics,sx,sy,order)); }
  Status RotateTransform(REAL angle,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipRotateWorldTransform(nativeGraphics,angle,order)); }
  Status GetTransform(Matrix *matrix) const { return SetStatus(DllExports::GdipGetWorldTransform(nativeGraphics,matrix->nativeMatrix)); }
  Status SetPageUnit(Unit unit) { return SetStatus(DllExports::GdipSetPageUnit(nativeGraphics,unit)); }
  Status SetPageScale(REAL scale) { return SetStatus(DllExports::GdipSetPageScale(nativeGraphics,scale)); }
  Unit GetPageUnit() const {
    Unit unit;
    SetStatus(DllExports::GdipGetPageUnit(nativeGraphics,&unit));
    return unit;
  }
  REAL GetPageScale() const {
    REAL scale;
    SetStatus(DllExports::GdipGetPageScale(nativeGraphics,&scale));
    return scale;
  }
  REAL GetDpiX() const {
    REAL dpi;
    SetStatus(DllExports::GdipGetDpiX(nativeGraphics,&dpi));
    return dpi;
  }
  REAL GetDpiY() const {
    REAL dpi;
    SetStatus(DllExports::GdipGetDpiY(nativeGraphics,&dpi));
    return dpi;
  }
  Status TransformPoints(CoordinateSpace destSpace,CoordinateSpace srcSpace,PointF *pts,INT count) const { return SetStatus(DllExports::GdipTransformPoints(nativeGraphics,destSpace,srcSpace,pts,count)); }
  Status TransformPoints(CoordinateSpace destSpace,CoordinateSpace srcSpace,Point *pts,INT count) const { return SetStatus(DllExports::GdipTransformPointsI(nativeGraphics,destSpace,srcSpace,pts,count)); }
  Status GetNearestColor(Color *color) const {
    if(!color) return SetStatus(InvalidParameter);
    ARGB argb = color->GetValue();
    Status status = SetStatus(DllExports::GdipGetNearestColor(nativeGraphics,&argb));
    color->SetValue(argb);
    return status;
  }
  Status DrawLine(const Pen *pen,REAL x1,REAL y1,REAL x2,REAL y2) { return SetStatus(DllExports::GdipDrawLine(nativeGraphics,pen->nativePen,x1,y1,x2,y2)); }
  Status DrawLine(const Pen *pen,const PointF &pt1,const PointF &pt2) { return DrawLine(pen,pt1.X,pt1.Y,pt2.X,pt2.Y); }
  Status DrawLines(const Pen *pen,const PointF *points,INT count) { return SetStatus(DllExports::GdipDrawLines(nativeGraphics,pen->nativePen,points,count)); }
  Status DrawLine(const Pen *pen,INT x1,INT y1,INT x2,INT y2) { return SetStatus(DllExports::GdipDrawLineI(nativeGraphics,pen->nativePen,x1,y1,x2,y2)); }
  Status DrawLine(const Pen *pen,const Point &pt1,const Point &pt2) { return DrawLine(pen,pt1.X,pt1.Y,pt2.X,pt2.Y); }
  Status DrawLines(const Pen *pen,const Point *points,INT count) { return SetStatus(DllExports::GdipDrawLinesI(nativeGraphics,pen->nativePen,points,count)); }
  Status DrawArc(const Pen *pen,REAL x,REAL y,REAL width,REAL height,REAL startAngle,REAL sweepAngle) { return SetStatus(DllExports::GdipDrawArc(nativeGraphics,pen->nativePen,x,y,width,height,startAngle,sweepAngle)); }
  Status DrawArc(const Pen *pen,const RectF &rect,REAL startAngle,REAL sweepAngle) { return DrawArc(pen,rect.X,rect.Y,rect.Width,rect.Height,startAngle,sweepAngle); }
  Status DrawArc(const Pen *pen,INT x,INT y,INT width,INT height,REAL startAngle,REAL sweepAngle) { return SetStatus(DllExports::GdipDrawArcI(nativeGraphics,pen->nativePen,x,y,width,height,startAngle,sweepAngle)); }
  Status DrawArc(const Pen *pen,const Rect &rect,REAL startAngle,REAL sweepAngle) { return DrawArc(pen,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 SetStatus(DllExports::GdipDrawBezier(nativeGraphics,pen->nativePen,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 DrawBezier(pen,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 SetStatus(DllExports::GdipDrawBeziers(nativeGraphics,pen->nativePen,points,count)); }
  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(nativeGraphics,pen->nativePen,x1,y1,x2,y2,x3,y3,x4,y4)); }
  Status DrawBezier(const Pen *pen,const Point &pt1,const Point &pt2,const Point &pt3,const Point &pt4) { return DrawBezier(pen,pt1.X,pt1.Y,pt2.X,pt2.Y,pt3.X,pt3.Y,pt4.X,pt4.Y); }
  Status DrawBeziers(const Pen *pen,const Point *points,INT count) { return SetStatus(DllExports::GdipDrawBeziersI(nativeGraphics,pen->nativePen,points,count)); }
  Status DrawRectangle(const Pen *pen,const RectF &rect) { return DrawRectangle(pen,rect.X,rect.Y,rect.Width,rect.Height); }
  Status DrawRectangle(const Pen *pen,REAL x,REAL y,REAL width,REAL height) { return SetStatus(DllExports::GdipDrawRectangle(nativeGraphics,pen->nativePen,x,y,width,height)); }
  Status DrawRectangles(const Pen *pen,const RectF *rects,INT count) { return SetStatus(DllExports::GdipDrawRectangles(nativeGraphics,pen->nativePen,rects,count)); }
  Status DrawRectangle(const Pen *pen,const Rect &rect) { return DrawRectangle(pen,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(nativeGraphics,pen->nativePen,x,y,width,height)); }
  Status DrawRectangles(const Pen *pen,const Rect *rects,INT count) { return SetStatus(DllExports::GdipDrawRectanglesI(nativeGraphics,pen->nativePen,rects,count)); }
  Status DrawEllipse(const Pen *pen,const RectF &rect) { return DrawEllipse(pen,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(nativeGraphics,pen->nativePen,x,y,width,height)); }
  Status DrawEllipse(const Pen *pen,const Rect &rect) { return DrawEllipse(pen,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(nativeGraphics,pen->nativePen,x,y,width,height)); }
  Status DrawPie(const Pen *pen,const RectF &rect,REAL startAngle,REAL sweepAngle) { return DrawPie(pen,rect.X,rect.Y,rect.Width,rect.Height,startAngle,sweepAngle); }
  Status DrawPie(const Pen *pen,REAL x,REAL y,REAL width,REAL height,REAL startAngle,REAL sweepAngle) { return SetStatus(DllExports::GdipDrawPie(nativeGraphics,pen->nativePen,x,y,width,height,startAngle,sweepAngle)); }
  Status DrawPie(const Pen *pen,const Rect &rect,REAL startAngle,REAL sweepAngle) { return DrawPie(pen,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(nativeGraphics,pen->nativePen,x,y,width,height,startAngle,sweepAngle)); }
  Status DrawPolygon(const Pen *pen,const PointF *points,INT count) { return SetStatus(DllExports::GdipDrawPolygon(nativeGraphics,pen->nativePen,points,count)); }
  Status DrawPolygon(const Pen *pen,const Point *points,INT count) { return SetStatus(DllExports::GdipDrawPolygonI(nativeGraphics,pen->nativePen,points,count)); }
  Status DrawPath(const Pen *pen,const GraphicsPath *path) { return SetStatus(DllExports::GdipDrawPath(nativeGraphics,pen ? pen->nativePen : NULL,path ? path->nativePath : NULL)); }
  Status DrawCurve(const Pen *pen,const PointF *points,INT count) { return SetStatus(DllExports::GdipDrawCurve(nativeGraphics,pen->nativePen,points,count)); }
  Status DrawCurve(const Pen *pen,const PointF *points,INT count,REAL tension) { return SetStatus(DllExports::GdipDrawCurve2(nativeGraphics,pen->nativePen,points,count,tension)); }
  Status DrawCurve(const Pen *pen,const PointF *points,INT count,INT offset,INT numberOfSegments,REAL tension = 0.5f) { return SetStatus(DllExports::GdipDrawCurve3(nativeGraphics,pen->nativePen,points,count,offset,numberOfSegments,tension)); }
  Status DrawCurve(const Pen *pen,const Point *points,INT count) { return SetStatus(DllExports::GdipDrawCurveI(nativeGraphics,pen->nativePen,points,count)); }
  Status DrawCurve(const Pen *pen,const Point *points,INT count,REAL tension) { return SetStatus(DllExports::GdipDrawCurve2I(nativeGraphics,pen->nativePen,points,count,tension)); }
  Status DrawCurve(const Pen *pen,const Point *points,INT count,INT offset,INT numberOfSegments,REAL tension = 0.5f) { return SetStatus(DllExports::GdipDrawCurve3I(nativeGraphics,pen->nativePen,points,count,offset,numberOfSegments,tension)); }
  Status DrawClosedCurve(const Pen *pen,const PointF *points,INT count) { return SetStatus(DllExports::GdipDrawClosedCurve(nativeGraphics,pen->nativePen,points,count)); }
  Status DrawClosedCurve(const Pen *pen,const PointF *points,INT count,REAL tension) { return SetStatus(DllExports::GdipDrawClosedCurve2(nativeGraphics,pen->nativePen,points,count,tension)); }
  Status DrawClosedCurve(const Pen *pen,const Point *points,INT count) { return SetStatus(DllExports::GdipDrawClosedCurveI(nativeGraphics,pen->nativePen,points,count)); }
  Status DrawClosedCurve(const Pen *pen,const Point *points,INT count,REAL tension) { return SetStatus(DllExports::GdipDrawClosedCurve2I(nativeGraphics,pen->nativePen,points,count,tension)); }
  Status Clear(const Color &color) { return SetStatus(DllExports::GdipGraphicsClear(nativeGraphics,color.GetValue())); }
  Status FillRectangle(const Brush *brush,const RectF &rect) { return FillRectangle(brush,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(nativeGraphics,brush->nativeBrush,x,y,width,height)); }
  Status FillRectangles(const Brush *brush,const RectF *rects,INT count) { return SetStatus(DllExports::GdipFillRectangles(nativeGraphics,brush->nativeBrush,rects,count)); }
  Status FillRectangle(const Brush *brush,const Rect &rect) { return FillRectangle(brush,rect.X,rect.Y,rect.Width,rect.Height); }
  Status FillRectangle(const Brush *brush,INT x,INT y,INT width,INT height) { return SetStatus(DllExports::GdipFillRectangleI(nativeGraphics,brush->nativeBrush,x,y,width,height)); }
  Status FillRectangles(const Brush *brush,const Rect *rects,INT count) { return SetStatus(DllExports::GdipFillRectanglesI(nativeGraphics,brush->nativeBrush,rects,count)); }
  Status FillPolygon(const Brush *brush,const PointF *points,INT count) { return FillPolygon(brush,points,count,FillModeAlternate); }
  Status FillPolygon(const Brush *brush,const PointF *points,INT count,FillMode fillMode) { return SetStatus(DllExports::GdipFillPolygon(nativeGraphics,brush->nativeBrush,points,count,fillMode)); }
  Status FillPolygon(const Brush *brush,const Point *points,INT count) { return FillPolygon(brush,points,count,FillModeAlternate); }
  Status FillPolygon(const Brush *brush,const Point *points,INT count,FillMode fillMode) { return SetStatus(DllExports::GdipFillPolygonI(nativeGraphics,brush->nativeBrush,points,count,fillMode)); }
  Status FillEllipse(const Brush *brush,const RectF &rect) { return FillEllipse(brush,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(nativeGraphics,brush->nativeBrush,x,y,width,height)); }
  Status FillEllipse(const Brush *brush,const Rect &rect) { return FillEllipse(brush,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(nativeGraphics,brush->nativeBrush,x,y,width,height)); }
  Status FillPie(const Brush *brush,const RectF &rect,REAL startAngle,REAL sweepAngle) { return FillPie(brush,rect.X,rect.Y,rect.Width,rect.Height,startAngle,sweepAngle); }
  Status FillPie(const Brush *brush,REAL x,REAL y,REAL width,REAL height,REAL startAngle,REAL sweepAngle) { return SetStatus(DllExports::GdipFillPie(nativeGraphics,brush->nativeBrush,x,y,width,height,startAngle,sweepAngle)); }
  Status FillPie(const Brush *brush,const Rect &rect,REAL startAngle,REAL sweepAngle) { return FillPie(brush,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(nativeGraphics,brush->nativeBrush,x,y,width,height,startAngle,sweepAngle)); }
  Status FillPath(const Brush *brush,const GraphicsPath *path) { return SetStatus(DllExports::GdipFillPath(nativeGraphics,brush->nativeBrush,path->nativePath)); }
  Status FillClosedCurve(const Brush *brush,const PointF *points,INT count) { return SetStatus(DllExports::GdipFillClosedCurve(nativeGraphics,brush->nativeBrush,points,count)); }
  Status FillClosedCurve(const Brush *brush,const PointF *points,INT count,FillMode fillMode,REAL tension = 0.5f) { return SetStatus(DllExports::GdipFillClosedCurve2(nativeGraphics,brush->nativeBrush,points,count,tension,fillMode)); }
  Status FillClosedCurve(const Brush *brush,const Point *points,INT count) { return SetStatus(DllExports::GdipFillClosedCurveI(nativeGraphics,brush->nativeBrush,points,count)); }
  Status FillClosedCurve(const Brush *brush,const Point *points,INT count,FillMode fillMode,REAL tension = 0.5f) { return SetStatus(DllExports::GdipFillClosedCurve2I(nativeGraphics,brush->nativeBrush,points,count,tension,fillMode)); }
  Status FillRegion(const Brush *brush,const Region *region) { return SetStatus(DllExports::GdipFillRegion(nativeGraphics,brush->nativeBrush,region->nativeRegion)); }
  Status DrawString(const WCHAR *string,INT length,const Font *font,const RectF &layoutRect,const StringFormat *stringFormat,const Brush *brush) { return SetStatus(DllExports::GdipDrawString(nativeGraphics,string,length,font ? font->nativeFont : NULL,&layoutRect,stringFormat ? stringFormat->nativeFormat : NULL,brush ? brush->nativeBrush : NULL)); }
  Status DrawString(const WCHAR *string,INT length,const Font *font,const PointF &origin,const Brush *brush) {
    RectF rect(origin.X,origin.Y,0.0f,0.0f);
    return SetStatus(DllExports::GdipDrawString(nativeGraphics,string,length,font ? font->nativeFont : NULL,&rect,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 rect(origin.X,origin.Y,0.0f,0.0f);
    return SetStatus(DllExports::GdipDrawString(nativeGraphics,string,length,font ? font->nativeFont : NULL,&rect,stringFormat ? stringFormat->nativeFormat : NULL,brush ? brush->nativeBrush : NULL));
  }
  Status MeasureString(const WCHAR *string,INT length,const Font *font,const RectF &layoutRect,const StringFormat *stringFormat,RectF *boundingBox,INT *codepointsFitted = 0,INT *linesFilled = 0) const { return SetStatus(DllExports::GdipMeasureString(nativeGraphics,string,length,font ? font->nativeFont : NULL,&layoutRect,stringFormat ? stringFormat->nativeFormat : NULL,boundingBox,codepointsFitted,linesFilled)); }
  Status MeasureString(const WCHAR *string,INT length,const Font *font,const SizeF &layoutRectSize,const StringFormat *stringFormat,SizeF *size,INT *codepointsFitted = 0,INT *linesFilled = 0) const {
    RectF layoutRect(0,0,layoutRectSize.Width,layoutRectSize.Height);
    RectF boundingBox;
    Status status;
    if(!size) return SetStatus(InvalidParameter);
    status = SetStatus(DllExports::GdipMeasureString(nativeGraphics,string,length,font ? font->nativeFont : NULL,&layoutRect,stringFormat ? stringFormat->nativeFormat : NULL,size ? &boundingBox : NULL,codepointsFitted,linesFilled));
    if(size && status==Ok) {
      size->Width = boundingBox.Width;
      size->Height = boundingBox.Height;
    }
    return status;
  }
  Status MeasureString(const WCHAR *string,INT length,const Font *font,const PointF &origin,const StringFormat *stringFormat,RectF *boundingBox) const {
    RectF rect(origin.X,origin.Y,0.0f,0.0f);
    return SetStatus(DllExports::GdipMeasureString(nativeGraphics,string,length,font ? font->nativeFont : NULL,&rect,stringFormat ? stringFormat->nativeFormat : NULL,boundingBox,NULL,NULL));
  }
  Status MeasureString(const WCHAR *string,INT length,const Font *font,const RectF &layoutRect,RectF *boundingBox) const { return SetStatus(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,RectF *boundingBox) const {
    RectF rect(origin.X,origin.Y,0.0f,0.0f);
    return SetStatus(DllExports::GdipMeasureString(nativeGraphics,string,length,font ? font->nativeFont : NULL,&rect,NULL,boundingBox,NULL,NULL));
  }
  Status MeasureCharacterRanges(const WCHAR *string,INT length,const Font *font,const RectF &layoutRect,const StringFormat *stringFormat,INT regionCount,Region *regions) const {
    if(!regions || regionCount<=0) return InvalidParameter;
    GpRegion **nativeRegions = new GpRegion *[regionCount];
    if(!nativeRegions) return OutOfMemory;
    for(INT i = 0;i < regionCount;i++) {
      nativeRegions[i] = regions[i].nativeRegion;
    }
    Status status = SetStatus(DllExports::GdipMeasureCharacterRanges(nativeGraphics,string,length,font ? font->nativeFont : NULL,layoutRect,stringFormat ? stringFormat->nativeFormat : NULL,regionCount,nativeRegions));
    delete [] nativeRegions;
    return status;
  }
  Status DrawDriverString(const UINT16 *text,INT length,const Font *font,const Brush *brush,const PointF *positions,INT flags,const Matrix *matrix) { return SetStatus(DllExports::GdipDrawDriverString(nativeGraphics,text,length,font ? font->nativeFont : NULL,brush ? brush->nativeBrush : NULL,positions,flags,matrix ? matrix->nativeMatrix : NULL)); }
  Status MeasureDriverString(const UINT16 *text,INT length,const Font *font,const PointF *positions,INT flags,const Matrix *matrix,RectF *boundingBox) const { return SetStatus(DllExports::GdipMeasureDriverString(nativeGraphics,text,length,font ? font->nativeFont : NULL,positions,flags,matrix ? matrix->nativeMatrix : NULL,boundingBox)); }
  Status DrawCachedBitmap(CachedBitmap *cb,INT x,INT y) { return SetStatus(DllExports::GdipDrawCachedBitmap(nativeGraphics,cb->nativeCachedBitmap,x,y)); }
  Status DrawImage(Image *image,const PointF &point) { return DrawImage(image,point.X,point.Y); }
  Status DrawImage(Image *image,REAL x,REAL y) { return SetStatus(DllExports::GdipDrawImage(nativeGraphics,image ? image->nativeImage : NULL,x,y)); }
  Status DrawImage(Image *image,const RectF &rect) { return DrawImage(image,rect.X,rect.Y,rect.Width,rect.Height); }
  Status DrawImage(Image *image,REAL x,REAL y,REAL width,REAL height) { return SetStatus(DllExports::GdipDrawImageRect(nativeGraphics,image ? image->nativeImage : NULL,x,y,width,height)); }
  Status DrawImage(Image *image,const Point &point) { return DrawImage(image,point.X,point.Y); }
  Status DrawImage(Image *image,INT x,INT y) { return SetStatus(DllExports::GdipDrawImageI(nativeGraphics,image ? image->nativeImage : NULL,x,y)); }
  Status DrawImage(Image *image,const Rect &rect) { return DrawImage(image,rect.X,rect.Y,rect.Width,rect.Height); }
  Status DrawImage(Image *image,INT x,INT y,INT width,INT height) { return SetStatus(DllExports::GdipDrawImageRectI(nativeGraphics,image ? image->nativeImage : NULL,x,y,width,height)); }
  Status DrawImage(Image *image,const PointF *destPoints,INT count) {
    if(count!=3 && count!=4) return SetStatus(InvalidParameter);
    return SetStatus(DllExports::GdipDrawImagePoints(nativeGraphics,image ? image->nativeImage : NULL,destPoints,count));
  }
  Status DrawImage(Image *image,const Point *destPoints,INT count) {
    if(count!=3 && count!=4) return SetStatus(InvalidParameter);
    return SetStatus(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 SetStatus(DllExports::GdipDrawImagePointRect(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 SetStatus(DllExports::GdipDrawImageRectRect(nativeGraphics,image ? image->nativeImage : NULL,destRect.X,destRect.Y,destRect.Width,destRect.Height,srcx,srcy,srcwidth,srcheight,srcUnit,imageAttributes ? imageAttributes->nativeImageAttr : NULL,callback,callbackData)); }
  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 SetStatus(DllExports::GdipDrawImagePointsRect(nativeGraphics,image ? image->nativeImage : NULL,destPoints,count,srcx,srcy,srcwidth,srcheight,srcUnit,imageAttributes ? imageAttributes->nativeImageAttr : NULL,callback,callbackData)); }
  Status DrawImage(Image *image,INT x,INT y,INT srcx,INT srcy,INT srcwidth,INT srcheight,Unit srcUnit) { return SetStatus(DllExports::GdipDrawImagePointRectI(nativeGraphics,image ? image->nativeImage : NULL,x,y,srcx,srcy,srcwidth,srcheight,srcUnit)); }
  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 SetStatus(DllExports::GdipDrawImageRectRectI(nativeGraphics,image ? image->nativeImage : NULL,destRect.X,destRect.Y,destRect.Width,destRect.Height,srcx,srcy,srcwidth,srcheight,srcUnit,imageAttributes ? imageAttributes->nativeImageAttr : 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 SetStatus(DllExports::GdipDrawImagePointsRectI(nativeGraphics,image ? image->nativeImage : NULL,destPoints,count,srcx,srcy,srcwidth,srcheight,srcUnit,imageAttributes ? imageAttributes->nativeImageAttr : NULL,callback,callbackData)); }
  Status EnumerateMetafile(const Metafile *metafile,const PointF &destPoint,EnumerateMetafileProc callback,VOID *callbackData = NULL,const ImageAttributes *imageAttributes = NULL) { return SetStatus(DllExports::GdipEnumerateMetafileDestPoint(nativeGraphics,(const GpMetafile *)(metafile ? metafile->nativeImage:NULL),destPoint,callback,callbackData,imageAttributes ? imageAttributes->nativeImageAttr : NULL)); }
  Status EnumerateMetafile(const Metafile *metafile,const Point &destPoint,EnumerateMetafileProc callback,VOID *callbackData = NULL,const ImageAttributes *imageAttributes = NULL) { return SetStatus(DllExports::GdipEnumerateMetafileDestPointI(nativeGraphics,(const GpMetafile *)(metafile ? metafile->nativeImage:NULL),destPoint,callback,callbackData,imageAttributes ? imageAttributes->nativeImageAttr : NULL)); }
  Status EnumerateMetafile(const Metafile *metafile,const RectF &destRect,EnumerateMetafileProc callback,VOID *callbackData = NULL,const ImageAttributes *imageAttributes = NULL) { return SetStatus(DllExports::GdipEnumerateMetafileDestRect(nativeGraphics,(const GpMetafile *)(metafile ? metafile->nativeImage:NULL),destRect,callback,callbackData,imageAttributes ? imageAttributes->nativeImageAttr : NULL)); }
  Status EnumerateMetafile(const Metafile *metafile,const Rect &destRect,EnumerateMetafileProc callback,VOID *callbackData = NULL,const ImageAttributes *imageAttributes = NULL) { return SetStatus(DllExports::GdipEnumerateMetafileDestRectI(nativeGraphics,(const GpMetafile *)(metafile ? metafile->nativeImage:NULL),destRect,callback,callbackData,imageAttributes ? imageAttributes->nativeImageAttr : NULL)); }
  Status EnumerateMetafile(const Metafile *metafile,const PointF *destPoints,INT count,EnumerateMetafileProc callback,VOID *callbackData = NULL,const ImageAttributes *imageAttributes = NULL) { return SetStatus(DllExports::GdipEnumerateMetafileDestPoints(nativeGraphics,(const GpMetafile *)(metafile ? metafile->nativeImage:NULL),destPoints,count,callback,callbackData,imageAttributes ? imageAttributes->nativeImageAttr : NULL)); }
  Status EnumerateMetafile(const Metafile *metafile,const Point *destPoints,INT count,EnumerateMetafileProc callback,VOID *callbackData = NULL,const ImageAttributes *imageAttributes = NULL) { return SetStatus(DllExports::GdipEnumerateMetafileDestPointsI(nativeGraphics,(const GpMetafile *)(metafile ? metafile->nativeImage:NULL),destPoints,count,callback,callbackData,imageAttributes ? imageAttributes->nativeImageAttr : NULL)); }
  Status EnumerateMetafile(const Metafile *metafile,const PointF &destPoint,const RectF &srcRect,Unit srcUnit,EnumerateMetafileProc callback,VOID *callbackData = NULL,const ImageAttributes *imageAttributes = NULL) { return SetStatus(DllExports::GdipEnumerateMetafileSrcRectDestPoint(nativeGraphics,(const GpMetafile *)(metafile ? metafile->nativeImage:NULL),destPoint,srcRect,srcUnit,callback,callbackData,imageAttributes ? imageAttributes->nativeImageAttr : NULL)); }
  Status EnumerateMetafile(const Metafile *metafile,const Point &destPoint,const Rect &srcRect,Unit srcUnit,EnumerateMetafileProc callback,VOID *callbackData = NULL,const ImageAttributes *imageAttributes = NULL) { return SetStatus(DllExports::GdipEnumerateMetafileSrcRectDestPointI(nativeGraphics,(const GpMetafile *)(metafile ? metafile->nativeImage:NULL),destPoint,srcRect,srcUnit,callback,callbackData,imageAttributes ? imageAttributes->nativeImageAttr : NULL)); }
  Status EnumerateMetafile(const Metafile *metafile,const RectF &destRect,const RectF &srcRect,Unit srcUnit,EnumerateMetafileProc callback,VOID *callbackData = NULL,const ImageAttributes *imageAttributes = NULL) { return SetStatus(DllExports::GdipEnumerateMetafileSrcRectDestRect(nativeGraphics,(const GpMetafile *)(metafile ? metafile->nativeImage:NULL),destRect,srcRect,srcUnit,callback,callbackData,imageAttributes ? imageAttributes->nativeImageAttr : NULL)); }
  Status EnumerateMetafile(const Metafile *metafile,const Rect &destRect,const Rect &srcRect,Unit srcUnit,EnumerateMetafileProc callback,VOID *callbackData = NULL,const ImageAttributes *imageAttributes = NULL) { return SetStatus(DllExports::GdipEnumerateMetafileSrcRectDestRectI(nativeGraphics,(const GpMetafile *)(metafile ? metafile->nativeImage:NULL),destRect,srcRect,srcUnit,callback,callbackData,imageAttributes ? imageAttributes->nativeImageAttr : NULL)); }
  Status EnumerateMetafile(const Metafile *metafile,const PointF *destPoints,INT count,const RectF &srcRect,Unit srcUnit,EnumerateMetafileProc callback,VOID *callbackData = NULL,const ImageAttributes *imageAttributes = NULL) { return SetStatus(DllExports::GdipEnumerateMetafileSrcRectDestPoints(nativeGraphics,(const GpMetafile *)(metafile ? metafile->nativeImage:NULL),destPoints,count,srcRect,srcUnit,callback,callbackData,imageAttributes ? imageAttributes->nativeImageAttr : NULL)); }
  Status EnumerateMetafile(const Metafile *metafile,const Point *destPoints,INT count,const Rect &srcRect,Unit srcUnit,EnumerateMetafileProc callback,VOID *callbackData = NULL,const ImageAttributes *imageAttributes = NULL) { return SetStatus(DllExports::GdipEnumerateMetafileSrcRectDestPointsI(nativeGraphics,(const GpMetafile *)(metafile ? metafile->nativeImage:NULL),destPoints,count,srcRect,srcUnit,callback,callbackData,imageAttributes ? imageAttributes->nativeImageAttr : NULL)); }
  Status SetClip(const Graphics *g,CombineMode combineMode = CombineModeReplace) { return SetStatus(DllExports::GdipSetClipGraphics(nativeGraphics,g->nativeGraphics,combineMode)); }
  Status SetClip(const RectF &rect,CombineMode combineMode = CombineModeReplace) { return SetStatus(DllExports::GdipSetClipRect(nativeGraphics,rect.X,rect.Y,rect.Width,rect.Height,combineMode)); }
  Status SetClip(const Rect &rect,CombineMode combineMode = CombineModeReplace) { return SetStatus(DllExports::GdipSetClipRectI(nativeGraphics,rect.X,rect.Y,rect.Width,rect.Height,combineMode)); }
  Status SetClip(const GraphicsPath *path,CombineMode combineMode = CombineModeReplace) { return SetStatus(DllExports::GdipSetClipPath(nativeGraphics,path->nativePath,combineMode)); }
  Status SetClip(const Region *region,CombineMode combineMode = CombineModeReplace) { return SetStatus(DllExports::GdipSetClipRegion(nativeGraphics,region->nativeRegion,combineMode)); }
  Status SetClip(HRGN hRgn,CombineMode combineMode = CombineModeReplace) { return SetStatus(DllExports::GdipSetClipHrgn(nativeGraphics,hRgn,combineMode)); }
  Status IntersectClip(const RectF &rect) { return SetStatus(DllExports::GdipSetClipRect(nativeGraphics,rect.X,rect.Y,rect.Width,rect.Height,CombineModeIntersect)); }
  Status IntersectClip(const Rect &rect) { return SetStatus(DllExports::GdipSetClipRectI(nativeGraphics,rect.X,rect.Y,rect.Width,rect.Height,CombineModeIntersect)); }
  Status IntersectClip(const Region *region) { return SetStatus(DllExports::GdipSetClipRegion(nativeGraphics,region->nativeRegion,CombineModeIntersect)); }
  Status ExcludeClip(const RectF &rect) { return SetStatus(DllExports::GdipSetClipRect(nativeGraphics,rect.X,rect.Y,rect.Width,rect.Height,CombineModeExclude)); }
  Status ExcludeClip(const Rect &rect) { return SetStatus(DllExports::GdipSetClipRectI(nativeGraphics,rect.X,rect.Y,rect.Width,rect.Height,CombineModeExclude)); }
  Status ExcludeClip(const Region *region) { return SetStatus(DllExports::GdipSetClipRegion(nativeGraphics,region->nativeRegion,CombineModeExclude)); }
  Status ResetClip() { return SetStatus(DllExports::GdipResetClip(nativeGraphics)); }
  Status TranslateClip(REAL dx,REAL dy) { return SetStatus(DllExports::GdipTranslateClip(nativeGraphics,dx,dy)); }
  Status TranslateClip(INT dx,INT dy) { return SetStatus(DllExports::GdipTranslateClipI(nativeGraphics,dx,dy)); }
  Status GetClip(Region *region) const { return SetStatus(DllExports::GdipGetClip(nativeGraphics,region->nativeRegion)); }
  Status GetClipBounds(RectF *rect) const { return SetStatus(DllExports::GdipGetClipBounds(nativeGraphics,rect)); }
  Status GetClipBounds(Rect *rect) const { return SetStatus(DllExports::GdipGetClipBoundsI(nativeGraphics,rect)); }
  WINBOOL IsClipEmpty() const {
    WINBOOL booln = FALSE;
    SetStatus(DllExports::GdipIsClipEmpty(nativeGraphics,&booln));
    return booln;
  }
  Status GetVisibleClipBounds(RectF *rect) const { return SetStatus(DllExports::GdipGetVisibleClipBounds(nativeGraphics,rect)); }
  Status GetVisibleClipBounds(Rect *rect) const { return SetStatus(DllExports::GdipGetVisibleClipBoundsI(nativeGraphics,rect)); }
  WINBOOL IsVisibleClipEmpty() const {
    WINBOOL booln = FALSE;
    SetStatus(DllExports::GdipIsVisibleClipEmpty(nativeGraphics,&booln));
    return booln;
  }
  WINBOOL IsVisible(INT x,INT y) const { return IsVisible(Point(x,y)); }
  WINBOOL IsVisible(const Point &point) const {
    WINBOOL booln = FALSE;
    SetStatus(DllExports::GdipIsVisiblePointI(nativeGraphics,point.X,point.Y,&booln));
    return booln;
  }
  WINBOOL IsVisible(INT x,INT y,INT width,INT height) const { return IsVisible(Rect(x,y,width,height)); }
  WINBOOL IsVisible(const Rect &rect) const {
    WINBOOL booln = TRUE;
    SetStatus(DllExports::GdipIsVisibleRectI(nativeGraphics,rect.X,rect.Y,rect.Width,rect.Height,&booln));
    return booln;
  }
  WINBOOL IsVisible(REAL x,REAL y) const { return IsVisible(PointF(x,y)); }
  WINBOOL IsVisible(const PointF &point) const {
    WINBOOL booln = FALSE;
    SetStatus(DllExports::GdipIsVisiblePoint(nativeGraphics,point.X,point.Y,&booln));
    return booln;
  }
  WINBOOL IsVisible(REAL x,REAL y,REAL width,REAL height) const { return IsVisible(RectF(x,y,width,height)); }
  WINBOOL IsVisible(const RectF &rect) const {
    WINBOOL booln = TRUE;
    SetStatus(DllExports::GdipIsVisibleRect(nativeGraphics,rect.X,rect.Y,rect.Width,rect.Height,&booln));
    return booln;
  }
  GraphicsState Save() const {
    GraphicsState gstate;
    SetStatus(DllExports::GdipSaveGraphics(nativeGraphics,&gstate));
    return gstate;
  }
  Status Restore(GraphicsState gstate) { return SetStatus(DllExports::GdipRestoreGraphics(nativeGraphics,gstate)); }
  GraphicsContainer BeginContainer(const RectF &dstrect,const RectF &srcrect,Unit unit) {
    GraphicsContainer state;
    SetStatus(DllExports::GdipBeginContainer(nativeGraphics,&dstrect,&srcrect,unit,&state));
    return state;
  }
  GraphicsContainer BeginContainer(const Rect &dstrect,const Rect &srcrect,Unit unit) {
    GraphicsContainer state;
    SetStatus(DllExports::GdipBeginContainerI(nativeGraphics,&dstrect,&srcrect,unit,&state));
    return state;
  }
  GraphicsContainer BeginContainer() {
    GraphicsContainer state;
    SetStatus(DllExports::GdipBeginContainer2(nativeGraphics,&state));
    return state;
  }
  Status EndContainer(GraphicsContainer state) { return SetStatus(DllExports::GdipEndContainer(nativeGraphics,state)); }
  Status AddMetafileComment(const BYTE *data,UINT sizeData) { return SetStatus(DllExports::GdipComment(nativeGraphics,sizeData,data)); }
  static HPALETTE GetHalftonePalette() { return DllExports::GdipCreateHalftonePalette(); }
  Status GetLastStatus() const {
    Status lastStatus = lastResult;
    lastResult = Ok;
    return lastStatus;
  }
private:
  Graphics(const Graphics &);
  Graphics& operator=(const Graphics &);
protected:
  Graphics(GpGraphics *graphics) {
    lastResult = Ok;
    SetNativeGraphics(graphics);
  }
  VOID SetNativeGraphics(GpGraphics *graphics) {
    this->nativeGraphics = graphics;
  }
  Status SetStatus(Status status) const {
    if(status!=Ok) return (lastResult = status);
    else return status;
  }
  GpGraphics *GetNativeGraphics() const { return this->nativeGraphics; }
  GpPen *GetNativePen(const Pen *pen) { return pen->nativePen; }
protected:
  GpGraphics *nativeGraphics;
  mutable Status lastResult;
};

inline Status GraphicsPath::GetBounds(RectF *bounds,const Matrix *matrix,const Pen *pen) const {
  GpMatrix *nativeMatrix = NULL;
  GpPen *nativePen = NULL;
  if(matrix) nativeMatrix = matrix->nativeMatrix;
  if(pen) nativePen = pen->nativePen;
  return SetStatus(DllExports::GdipGetPathWorldBounds(nativePath,bounds,nativeMatrix,nativePen));
}

inline Status GraphicsPath::GetBounds(Rect *bounds,const Matrix *matrix,const Pen *pen) const {
  GpMatrix *nativeMatrix = NULL;
  GpPen *nativePen = NULL;
  if(matrix) nativeMatrix = matrix->nativeMatrix;
  if(pen) nativePen = pen->nativePen;
  return SetStatus(DllExports::GdipGetPathWorldBoundsI(nativePath,bounds,nativeMatrix,nativePen));
}

inline WINBOOL GraphicsPath::IsVisible(REAL x,REAL y,const Graphics *g) const {
  WINBOOL booln = FALSE;
  GpGraphics *nativeGraphics = NULL;
  if(g) nativeGraphics = g->nativeGraphics;
  SetStatus(DllExports::GdipIsVisiblePathPoint(nativePath,x,y,nativeGraphics,&booln));
  return booln;
}

inline WINBOOL GraphicsPath::IsVisible(INT x,INT y,const Graphics *g) const {
  WINBOOL booln = FALSE;
  GpGraphics *nativeGraphics = NULL;
  if(g) nativeGraphics = g->nativeGraphics;
  SetStatus(DllExports::GdipIsVisiblePathPointI(nativePath,x,y,nativeGraphics,&booln));
  return booln;
}

inline WINBOOL GraphicsPath::IsOutlineVisible(REAL x,REAL y,const Pen *pen,const Graphics *g) const {
  WINBOOL booln = FALSE;
  GpGraphics *nativeGraphics = NULL;
  GpPen *nativePen = NULL;
  if(g) nativeGraphics = g->nativeGraphics;
  if(pen) nativePen = pen->nativePen;
  SetStatus(DllExports::GdipIsOutlineVisiblePathPoint(nativePath,x,y,nativePen,nativeGraphics,&booln));
  return booln;
}

inline WINBOOL GraphicsPath::IsOutlineVisible(INT x,INT y,const Pen *pen,const Graphics *g) const {
  WINBOOL booln = FALSE;
  GpGraphics *nativeGraphics = NULL;
  GpPen *nativePen = NULL;
  if(g) nativeGraphics = g->nativeGraphics;
  if(pen) nativePen = pen->nativePen;
  SetStatus(DllExports::GdipIsOutlineVisiblePathPointI(nativePath,x,y,nativePen,nativeGraphics,&booln));
  return booln;
}

#endif