' Classes/System/Drawing/Graphics.ab

#ifndef __SYSTEM_DRAWING_GRAPHICS_AB__
#define __SYSTEM_DRAWING_GRAPHICS_AB__

#include <GdiPlusGpStabus.ab>
#include <GdiPlusFlat.ab>
#include <Classes/System/Drawing/Graphics/misc.ab>
#include <Classes/System/Drawing/Graphics/Rectangle.ab>
#include <Classes/System/Drawing/Graphics/RectangleF.ab>
#include <Classes/System/Drawing/Graphics/Point.ab>
#include <Classes/System/Drawing/Graphics/PointF.ab>
#include <Classes/System/Drawing/Graphics/SizeF.ab>
#include <Classes/System/Drawing/Graphics/Brush.ab>
#include <Classes/System/Drawing/Graphics/Pen.ab>
#include <Classes/System/Drawing/Graphics/Region.ab>
#include <Classes/System/Drawing/Graphics/StringFormat.ab>
#include <Classes/System/Drawing/Graphics/Image.ab>
#include <Classes/System/Drawing/Graphics/Drawing2D/misc.ab>
#include <Classes/System/Drawing/Graphics/Drawing2D/Matrix.ab>

Class Graphics
Public
	'=========================================================================
	' Properties
	'=========================================================================
	Const Function Clip() As Region
		Dim r As Regino
		GetClip(r)
		Return r
	End Function

	Sub Clip(ByRef region As /*Const*/ Region)
		SetClip(region, CombineMode.Replace)
	End Sub

	Const Function ClipBounds() As RectangleF
		Dim rc As RectangleF
		GetClipBounds(rc)
		Return rc
	End Function

	Sub ClipBounds(rc As RectangleF)
		SetClipBounds(rc)
	End Sub

	Function CompositingMode() As CompositingMode
		Return GetCompositingMode()
	End Function

	Sub CompositingMode(mode As CompositingMode)
		SetCompositingMode(mode)
	End Sub

	Function CompositingQuality() As CompositingQuality
		Return GetCompositingQuality()
	End Function

	Sub CompositingQuality(cq As CompositingQuality)
		SetCompositingQuality(cq)
	End Sub

	Const Function DpiX() As Single
		Dim dpi As Single
		SetStatus(GdipGetDpiX(nativeGraphics, dpi))
		Return dpi
	End Function

	Const Function DpiY() As Single
		Dim dpi As Single
		SetStatus(GdipGetDpiY(nativeGraphics, dpi))
		Return dpi
	End Function

	Const Function InterpolationMode() As InterpolationMode
		Return GetInterpolationMode()
	End Function

	Sub InterpolationMode(im As InterpolationMode)
		SetInterpolationMode(im)
	End Sub

	Const Function IsClipEmpty() As BOOL
		Dim b = FALSE As BOOL
		SetStatus(GdipIsClipEmpty(nativeGraphics, b))
		Return b
	End Function

	Const Function IsVisibleClipEmpty() As BOOL
		Dim b = FALSE As BOOL
		SetStatus(GdipIsVisibleClipEmpty(nativeGraphics, b))
		Return b
	End Function

	Function PageScale(scale As Single) As Status
		Return SetStatus(GdipSetPageScale(nativeGraphics, scale))
	End Function

	Const Function PageScale() As Single
		Dim scale As Single
		SetStatus(GdipGetPageScale(nativeGraphics, scale))
		Return scale
	End Function

	Const Function PageUnit() As GraphicsUnit
		Dim unit As GraphicsUnit
		SetStatus(GdipGetPageUnit(nativeGraphics, unit))
		Return unit
	End Function

	Function PageUnit(unit As GraphicsUnit) As Status
		Return SetStatus(GdipSetPageUnit(nativeGraphics, unit))
	End Function

	Function PixelOffsetMode() As PixelOffsetMode
		Return GetPixelOffsetMode()
	End Function

	Sub PixelOffsetMode(mode  As PixelOffsetMode)
		SetPixelOffsetMode(mode)
	End Sub

	Function RenderingOrigin() As Point
		Dim pt As Point
		GetRenderingOrigin(pt.X, pt.Y)
		Return pt
	End Function

	Sub RenderingOrigin(pt As Point)
		SetRenderingOrigin(pt.X, pt.Y)
	End Sub

	Function SmoothingMode() As SmoothingMode
		Return GetSmoothingMode()
	End Function

	Sub SmoothingMode(mode As SmoothingMode)
		SetSmoothingMode(mode)
	End Sub

	Function TextContrast() As DWord
		Return GetTextContrast()
	End Function

	Sub TextContrast(contrast As DWord)
		SetTextContrast(contrast)
	End Sub

	Function TextRenderingHint() As TextRenderingHint
		Return GetTextRenderingHint()
	End Function

	Sub TextRenderingHint(mode As TextRenderingHint)
		SetTextRenderingHint(mode)
	End Sub

	Function Transform() As Matrix
		Dim matrix As Matrix
		GetTransform(matrix)
		Return matrix
	End Function

	Sub Transform(ByRef matrix As Matrix)
		SetTransform(matirx)
	End Sub

	Function VisibleClipBounds() As RectangleF
		Dim rc As RectangleF
		GetVisibleClipBounds(rc)
		Return rc
	End Function

	'=========================================================================
	' Methods
	'=========================================================================
	Static Function FromHDC(hdc As HDC) As *Graphics
		Return New Graphics(hdc)
	End Function

	Static Function FromHDC(hdc As HDC, hdevice As HANDLE) As *Graphics
		Return New Graphics(hdc, hdevice)
	End Function

	Static Function FromHWND(hwnd As HWND) As *Graphics
		Return New Graphics(hwnd, FALSE)
	End Function

	Static Function FromHWND(hwnd As DWord, icm As BOOL) As *Graphics
		Return New Graphics(hwnd, icm)
	End Function

	Static Function FromImage(image As *Image) As *Graphics
		Return New Graphics(image)
	End Function

	Sub Graphics(hdc As HDC)
		Dim graphics = 0 As *GpGraphics
		lastResult = GdipCreateFromHDC(hdc, graphics)
		SetNativeGraphics(graphics)
	End Sub

	Sub Graphics(hdc As HDC, hdevice As HANDLE)
		Dim graphics = 0 As *GpGraphics
		lastResult = GdipCreateFromHDC2(hdc, hdevice, graphics)
		SetNativeGraphics(graphics)
	End Sub

	Sub Graphics(hwnd As HWND)
		Dim graphics = 0 As *GpGraphics
		lastResult = GdipCreateFromHWND(hwnd, graphics)
		SetNativeGraphics(graphics)
	End Sub

	Sub Graphics(hwnd As HWND, icm As BOOL)
		Dim graphics = 0 As *GpGraphics
		If icm <> FALSE Then
			lastResult = GdipCreateFromHWNDICM(hwnd, graphics)
		Else
			lastResult = GdipCreateFromHWND(hwnd, graphics)
		End If
		SetNativeGraphics(graphics)
	End Sub

	Sub Graphics(image As *Image)
		Dim graphics = 0 As *GpGraphics
		If (image != 0)
			lastResult = GdipGetImageGraphicsContext(image->nativeImage, graphics)
		End If
		SetNativeGraphics(graphics)
	End Sub

	Sub ~Graphics()
		GdipDeleteGraphics(nativeGraphics)
	End Sub

	Sub Flush()
		GdipFlush(nativeGraphics, FlushIntention.Flush)
	End Sub

	Sub Flush(intention As FlushIntention)
		GdipFlush(nativeGraphics, intention)
	End Sub

	'------------------------------------------------------------------------
	' GDI Interop methods
	'------------------------------------------------------------------------

	' Locks the graphics until ReleaseDC is called

	Function GetHDC() As HDC
		Dim hdc = 0 As HDC
		SetStatus(GdipGetDC(nativeGraphics, hdc))
		Return hdc
	End Function

	Sub ReleaseHDC(hdc As HDC)
		SetStatus(GdipReleaseDC(nativeGraphics, hdc))
	End Sub

	'------------------------------------------------------------------------
	' Rendering modes
	'------------------------------------------------------------------------

	Function SetRenderingOrigin(x As Long, y As Long) As Status
		Return SetStatus(GdipSetRenderingOrigin(nativeGraphics, x, y))
	End Function

	Const Function GetRenderingOrigin(ByRef x As Long, ByRef y As Long) As Status
		Return SetStatus(GdipGetRenderingOrigin(nativeGraphics, x, y))
	End Function

	Function SetCompositingMode(compositingMode As CompositingMode) As Status
		Return SetStatus(GdipSetCompositingMode(nativeGraphics, compositingMode))
	End Function

	Const Function GetCompositingMode() As CompositingMode
		Dim mode As CompositingMode
		SetStatus(GdipGetCompositingMode(nativeGraphics, mode))
		Return mode
	End Function

	Function SetCompositingQuality(compositingQuality As CompositingQuality)
		Return SetStatus(GdipSetCompositingQuality(nativeGraphics, compositingQuality))
	End Function

	Const Function GetCompositingQuality() As CompositingQuality
		Dim quality As CompositingQuality
		SetStatus(GdipGetCompositingQuality(nativeGraphics, quality))
		Return quality
	End Function

	Function SetTextRenderingHint(newMode As TextRenderingHint) As Status
		Return SetStatus(GdipSetTextRenderingHint(nativeGraphics, newMode))
	End Function

	Const Function GetTextRenderingHint() As TextRenderingHint
		Dim hint As TextRenderingHint
		SetStatus(GdipGetTextRenderingHint(nativeGraphics, hint))
		Return hint
	End Function

	Function SetTextContrast(contrast As DWord) As Status
		Return SetStatus(GdipSetTextContrast(nativeGraphics, contrast))
	End Function

	Const Function GetTextContrast() As DWord
		Dim contrast As DWord
		SetStatus(GdipGetTextContrast(nativeGraphics, contrast))
		Return contrast
	End Function

	Const Function GetInterpolationMode() As InterpolationMode
		Dim mode = InterpolationMode.Invalid As InterpolationMode
		SetStatus(GdipGetInterpolationMode(nativeGraphics, mode))
		Return mode
	End Function

	Function SetInterpolationMode(interpolationMode As InterpolationMode) As Status
		Return SetStatus(GdipSetInterpolationMode(nativeGraphics, interpolationMode))
	End Function

	Const Function GetSmoothingMode() As SmoothingMode
		Dim smoothingMode = SmoothingMode.Invalid As SmoothingMode
		SetStatus(GdipGetSmoothingMode(nativeGraphics, smoothingMode))
		Return smoothingMode
	End Function

	Function SetSmoothingMode(smoothingMode As SmoothingMode) As Status
		Return SetStatus(GdipSetSmoothingMode(nativeGraphics, smoothingMode))
	End Function

	Const Function GetPixelOffsetMode() As PixelOffsetMode
		Dim pixelOffsetMode = PixelOffsetMode.Invalid As PixelOffsetMode
		SetStatus(GdipGetPixelOffsetMode(nativeGraphics, pixelOffsetMode))
		Return pixelOffsetMode
	End Function

	Function SetPixelOffsetMode(pixelOffsetMode As PixelOffsetMode) As Status
		Return SetStatus(GdipSetPixelOffsetMode(nativeGraphics, pixelOffsetMode))
	End Function

	'------------------------------------------------------------------------
	' Manipulate current world transform
	'------------------------------------------------------------------------

	Function SetTransform(ByRef matrix As /*Const*/ *Matrix) As Status
		Return SetStatus(GdipSetWorldTransform(nativeGraphics, matrix->nativeMatrix))
	End Function

	Function ResetTransform() As Status
		Return SetStatus(GdipResetWorldTransform(nativeGraphics))
	End Function

	Function MultiplyTransform(ByRef matrix As /*Const*/ Matrix) As Status
		Return SetStatus(GdipMultiplyWorldTransform(nativeGraphics, matrix->nativeMatrix, MatrixOrder.Prepend))
	End Function

	Function MultiplyTransform(ByRef matrix As /*Const*/ Matrix, order As MatrixOrder) As Status
		Return SetStatus(GdipMultiplyWorldTransform(nativeGraphics, matrix->nativeMatrix, order))
	End Function

	Function TranslateTransform(dx As Single, dy As Single) As Status
		Return SetStatus(GdipTranslateWorldTransform(nativeGraphics, dx, dy, MatrixOrder.Prepend))
	End Function

	Function TranslateTransform(dx As Single, dy As Single, order As MatrixOrder) As Status
		Return SetStatus(GdipTranslateWorldTransform(nativeGraphics, dx, dy, order))
	End Function

	Function ScaleTransform(sx As Single, sy As Single) As Status
		Return SetStatus(GdipScaleWorldTransform(nativeGraphics, sx, sy, MatrixOrder.Prepend))
	End Function

	Function ScaleTransform(sx As Single, sy As Single, order As MatrixOrder) As Status
		Return SetStatus(GdipScaleWorldTransform(nativeGraphics, sx, sy, order))
	End Function

	Function RotateTransform(angle As Single) As Status
		Return SetStatus(GdipRotateWorldTransform(nativeGraphics, angle, MatrixOrder.Prepend))
	End Function

	Function RotateTransform(angle As Single, order As MatrixOrder) As Status
		Return SetStatus(GdipRotateWorldTransform(nativeGraphics, angle, order))
	End Function

	Const Function GetTransform(ByRef matrix As Matrix) As Status
		Return SetStatus(GdipGetWorldTransform(nativeGraphics, matrix->nativeMatrix))
	End Function

	Const Function TransformPoints(destSpace As CoordinateSpace, srcSpace As CoordinateSpace, pts As PointF, count As Long) As Status
		Return SetStatus(GdipTransformPoints(nativeGraphics, destSpace, srcSpace, pts, count))
	End Function

	Const Function TransformPoints(destSpace As CoordinateSpace, srcSpace As CoordinateSpace, pts As Point, count As Long) As Status
		Return SetStatus(GdipTransformPointsI(nativeGraphics, destSpace, srcSpace, pts, count))
	End Function

	'------------------------------------------------------------------------
	' GetNearestColor (for <= 8bpp surfaces).	Note: Alpha is ignored.
	'------------------------------------------------------------------------

	Const Function GetNearestColor(ByRef color As Color) As Status
		Dim argb = color->Value
		Dim status = SetStatus(GdipGetNearestColor(nativeGraphics, argb))
		color->Value = argb
		Return status
	End Function

	Function DrawLine(ByRef pen As /*Const*/ Pen, x1 As Single, y1 As Single, x2 As Single, y2 As Single) As Status
		Return SetStatus(GdipDrawLine(nativeGraphics, pen->nativePen, x1, y1, x2, y2))
	End Function

	Function DrawLine(ByRef pen As /*Const*/ Pen, ByRef pt1 As /*Const*/ PointF, ByRef pt2 As /*Const*/ PointF) As Status
		Return DrawLine(pen, pt1.X, pt1.Y, pt2.X, pt2.Y)
	End Function

	Function DrawLines(ByRef pen As /*Const*/ Pen, points As /*Const*/ *PointF, count As Long) As Status
		Return SetStatus(GdipDrawLines(nativeGraphics, pen->nativePen, points, count))
	End Function

	Function DrawLine(ByRef pen As /*Const*/ Pen, x1 As Long, y1 As Long, x2 As Long, y2 As Long) As Status
		Return SetStatus(GdipDrawLineI(nativeGraphics, pen->nativePen, x1, y1, x2, y2))
	End Function

	Function DrawLine(ByRef pen As /*Const*/ Pen, ByRef pt1 As /*Const*/ Point, ByRef pt2 As /*Const*/ Point) As Status
		Return DrawLine(pen, pt1.X, pt1.Y, pt2.X, pt2.Y)
	End Function

	Function DrawLines(ByRef pen As /*Const*/ Pen, points As /*Const*/ *Point, count As Long) As Status
		Return SetStatus(GdipDrawLinesI(nativeGraphics, pen->nativePen, points, count))
	End Function

	Function DrawArc(ByRef pen As /*Const*/ Pen, x As Single, y As Single, width As Single, height As Single, startAngle As Single, sweepAngle As Single) As Status
		Return SetStatus(GdipDrawArc(nativeGraphics, pen->nativePen, x, y, width, height, startAngle, sweepAngle))
	End Function

	Function DrawArc(ByRef pen As /*Const*/ Pen, ByRef rect As /*Const*/ RectangleF, startAngle As Single, sweepAngle As Single) As Status
		Return DrawArc(pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle)
	End Function

	Function DrawArc(ByRef pen As /*Const*/ Pen, x As Long, y As Long, width As Long, height As Long, startAngle As Single, sweepAngle As Single) As Status
		Return SetStatus(GdipDrawArcI(nativeGraphics, pen->nativePen, x, y, width, height, startAngle, sweepAngle))
	End Function

	Function DrawArc(ByRef pen As /*Const*/ Pen, ByRef rect As /*Const*/ RectangleF, startAngle As Single, sweepAngle As Single) As Status
		Return DrawArc(pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle)
	End Function

	Function DrawBezier(ByRef pen As /*Const*/ Pen, x1 As Single, y1 As Single, x2 As Single, y2 As Single, x3 As Single, y3 As Single, x4 As Single, y4 As Single) As Status
		Return SetStatus(GdipDrawBezier(nativeGraphics, pen->nativePen, x1, y1,x2, y2, x3, y3, x4, y4))
	End Function

	Function DrawBezier(ByRef pen As /*Const*/ Pen, ByRef pt1 As /*Const*/ PointF, ByRef pt2 As /*Const*/ PointF, ByRef pt3 As /*Const*/ PointF, ByRef pt4 As /*Const*/ PointF) As Status
		Return DrawBezier(pen, pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y)
	End Function

	Function DrawBeziers(ByRef pen As /*Const*/ Pen, points As /*Const*/ *PointF, count As Long) As Status
		Return SetStatus(GdipDrawBeziers(nativeGraphics, pen->nativePen, points, count))
	End Function

	Function DrawBezier(ByRef pen As /*Const*/ Pen, x1 As Long, y1 As Long, x2 As Long, y2 As Long, x3 As Long, y3 As Long, x4 As Long, y4 As Long) As Status
		Return SetStatus(GdipDrawBezierI(nativeGraphics, pen->nativePen, x1, y1, x2, y2, x3, y3, x4, y4))
	End Function

	Function DrawBezier(ByRef pen As /*Const*/ Pen, ByRef pt1 As /*Const*/ Point, ByRef pt2 As /*Const*/ Point, ByRef pt3 As /*Const*/ Point, ByRef pt4 As /*Const*/ Point) As Status
		Return DrawBezier(pen pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y)
	End Function

	Function DrawBeziers(ByRef pen As /*Const*/ Pen, points As /*Const*/ *Point count As Long) As Status
		Return SetStatus(GdipDrawBeziersI(nativeGraphics, pen->nativePen, points, count))
	End Function

	Function DrawRectangle(ByRef pen As /*Const*/ Pen, ByRef rect As /*Const*/ RectangleF) As Status
		Return DrawRectangle(pen, rect.X, rect.Y, rect.Width, rect.Height)
	End Function

	Function DrawRectangle(ByRef pen As /*Const*/ Pen, x As Single, y As Single, width As Single, height As Single) As Status
		Return SetStatus(GdipDrawRectangle(nativeGraphics, pen->nativePen, x, y, width, height))
	End Function

	Function DrawRectangles(ByRef pen As /*Const*/ Pen, rects As /*Const*/ *RectangleF, count As Long) As Status
		Return SetStatus(GdipDrawRectangles(nativeGraphics, pen->nativePen, rects, count))
	End Function

	Function DrawRectangle(ByRef pen As /*Const*/ Pen, ByRef rect As /*Const*/ Rectangle) As Status
		Return DrawRectangle(pen, rect.X, rect.Y, rect.Width, rect.Height)
	End Function

	Function DrawRectangle(ByRef pen As /*Const*/ Pen, x As Long, y As Long, width As Long, height As Long) As Status
		Return SetStatus(GdipDrawRectangleI(nativeGraphics, pen->nativePen, x, y, width, height))
	End Function

	Function DrawRectangles(ByRef pen As /*Const*/ Pen, rects As /*Const*/ *Rectangle,  count As Long) As Status
		Return SetStatus(GdipDrawRectanglesI(nativeGraphics, pen->nativePen, rects, count))
	End Function

	Function DrawEllipse(ByRef pen As /*Const*/ Pen, ByRef rect As /*Const*/ RectangleF) As Status
		Return DrawEllipse(pen, rect.X, rect.Y, rect.Width, rect.Height)
	End Function

	Function DrawEllipse(ByRef pen As /*Const*/ Pen, x As Single, y As Single, width As Single, height As Single) As Status
		Return SetStatus(GdipDrawEllipse(nativeGraphics, pen->nativePen, x, y, width, height))
	End Function

	Function DrawEllipse(ByRef pen As /*Const*/ Pen, ByRef rect As /*Const*/ Rectangle) As Status
		Return DrawEllipse(pen, rect.X, rect.Y, rect.Width, rect.Height)
	End Function

	Function DrawEllipse(ByRef pen As /*Const*/ Pen, x As Long, y As Long, width As Long, height As Long) As Status
		Return SetStatus(GdipDrawEllipseI(nativeGraphics, pen->nativePen, x, y, width, height))
	End Function

	Function DrawPie(ByRef pen As /*Const*/ Pen, ByRef rect As /*Const*/ RectangleF, startAngle As Single, sweepAngle As Single) As Status
		Return DrawPie(pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle)
	End Function

	Function DrawPie(ByRef pen As /*Const*/ Pen, x As Single, y As Single, width As Single, height As Single, startAngle As Single, sweepAngle As Single) As Status
		Return SetStatus(GdipDrawPie(nativeGraphics, pen->nativePen, x, y, width, height, startAngle, sweepAngle))
	End Function

	Function DrawPie(ByRef pen As /*Const*/ Pen, ByRef rect As /*Const*/ Rectangle, startAngle As Single, sweepAngle As Single) As Status
		Return DrawPie(pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle)
	End Function

	Function DrawPie(ByRef pen As /*Const*/ Pen, x As Long, y As Long, width As Long, height As Long, startAngle As Single, sweepAngle As Single) As Status
		Return SetStatus(GdipDrawPieI(nativeGraphics, pen->nativePen, x, y, width, height, startAngle, sweepAngle))
	End Function

	Function DrawPolygon(ByRef pen As /*Const*/ Pen, points As /*Const*/ *PointF, count As Long) As Status
		Return SetStatus(GdipDrawPolygon(nativeGraphics, pen->nativePen, points, count))
	End Function

	Function DrawPolygon(ByRef pen As /*Const*/ Pen, points As /*Const*/ *Point, count As Long) As Status
		Return SetStatus(GdipDrawPolygonI(nativeGraphics, pen->nativePen, points, count))
	End Function

	Function DrawPath(ByRef pen As /*Const*/ Pen, ByRef path As /*Const*/ GraphicsPath) As Status
		Return SetStatus(GdipDrawPath(nativeGraphics, pen->nativePen, path->nativePath))
'		Return SetStatus(GdipDrawPath(nativeGraphics, pen ? pen->nativePen : NULL, path ? path->nativePath : NULL))
	End Function

	Function DrawCurve(ByRef pen As /*Const*/ Pen, points As /*Const*/ *PointF, count As Long) As Status
		Return SetStatus(GdipDrawCurve(nativeGraphics, pen->nativePen, points, count))
	End Function

	Function DrawCurve(ByRef pen As /*Const*/ Pen, points As /*Const*/ *PointF, count As Long, tension As Single) As Status
		Return SetStatus(GdipDrawCurve2(nativeGraphics, pen->nativePen, points,count, tension))
	End Function

	Function DrawCurve(ByRef pen As /*Const*/ Pen, points As /*Const*/ *PointF, count As Long, offset As Long, numberOfSegments As Long) As Status
		Return SetStatus(GdipDrawCurve3(nativeGraphics, pen->nativePen, points, count, offset,numberOfSegments, 0.5))
	End Function

	Function DrawCurve(ByRef pen As /*Const*/ Pen, points As /*Const*/ *PointF, count As Long, offset As Long, numberOfSegments As Long, tension As Single) As Status
		Return SetStatus(GdipDrawCurve3(nativeGraphics, pen->nativePen, points, count, offset,numberOfSegments, tension))
	End Function

	Function DrawCurve(ByRef pen As /*Const*/ Pen, points As /*Const*/ *Point, count As Long) As Status
		Return SetStatus(GdipDrawCurveI(nativeGraphics, pen->nativePen, points, count))
	End Function

	Function DrawCurve(ByRef pen As /*Const*/ Pen, points As /*Const*/ *Point, count As Long, tension As Single) As Status
		Return SetStatus(GdipDrawCurve2I(nativeGraphics, pen->nativePen, points, count, tension))
	End Function

	Function DrawCurve(ByRef pen As /*Const*/ Pen, points As /*Const*/ *Point, count As Long, offset As Long, numberOfSegments As Long) As Status
		Return SetStatus(GdipDrawCurve3I(nativeGraphics, pen->nativePen, points, count, offset, numberOfSegments, 0.5))
	End Function

	Function DrawCurve(ByRef pen As /*Const*/ Pen, points As /*Const*/ *Point, count As Long, offset As Long, numberOfSegments As Long, tension As Single) As Status
		Return SetStatus(GdipDrawCurve3I(nativeGraphics, pen->nativePen, points, count, offset, numberOfSegments, tension))
	End Function

	Function DrawClosedCurve(ByRef pen As /*Const*/ Pen, points As /*Const*/ *PointF, count As Long) As Status
		Return SetStatus(GdipDrawClosedCurve(nativeGraphics, pen->nativePen, points, count))
	End Function

	Function DrawClosedCurve(ByRef pen As /*Const*/ Pen, points As /*Const*/ *PointF, count As Long, tension As Single) As Status
		Return SetStatus(GdipDrawClosedCurve2(nativeGraphics, pen->nativePen, points, count, tension))
	End Function

	Function DrawClosedCurve(ByRef pen As /*Const*/ Pen, points As /*Const*/ *Point, count As Long) As Status
		Return SetStatus(GdipDrawClosedCurveI(nativeGraphics, pen->nativePen, points, count))
	End Function

	Function DrawClosedCurve(ByRef pen As /*Const*/ Pen, points As /*Const*/ *Point, count As Long, tension As Single) As Status
		Return SetStatus(GdipDrawClosedCurve2I(nativeGraphics, pen->nativePen, points, count, tension))
	End Function

	Function Clear(ByRef color As /*Const*/ Color) As Status
		Return SetStatus(GdipGraphicsClear(nativeGraphics, color.Value))
	End Function

	Function FillRectangle(ByRef brush As /*Const*/ Brush, ByRef rect As /*Const*/ RectangleF) As Status
		Return FillRectangle(brush, rect.X, rect.Y, rect.Width, rect.Height)
	End Function

	Function FillRectangle(ByRef brush As /*Const*/ Brush, x As Single, y As Single, width As Single, height As Single) As Status
		Return SetStatus(GdipFillRectangle(nativeGraphics, brush->nativeBrush, x, y, width, height))
	End Function

	Function FillRectangles(ByRef brush As /*Const*/ Brush, rects As /*Const*/ *RectangleF, count As Long) As Status
		Return SetStatus(GdipFillRectangles(nativeGraphics,brush->nativeBrush,rects, count))
	End Function

	Function FillRectangle(ByRef brush As /*Const*/ Brush, ByRef rect As /*Const*/ Rectangle) As Status
		Return FillRectangle(brush, rect.X, rect.Y, rect.Width, rect.Height)
	End Function

	Function FillRectangle(ByRef brush As /*Const*/ Brush, x As Long, y As Long, width As Long, height As Long) As Status
		Return SetStatus(GdipFillRectangleI(nativeGraphics, brush->nativeBrush, x, y, width, height))
	End Function

	Function FillRectangles(ByRef brush As /*Const*/ Brush, rects As /*Const*/ *Rectangle, count As Long) As Status
		Return SetStatus(GdipFillRectanglesI(nativeGraphics, brush->nativeBrush, rects, count))
	End Function

	Function FillPolygon(ByRef brush As /*Const*/ Brush, points As /*Const*/ *PointF, count As Long) As Status
		Return FillPolygon(brush, points, count, FillModeAlternate)
	End Function

	Function FillPolygon(ByRef brush As /*Const*/ Brush, points As /*Const*/ *PointF, count As Long, fillMode As FillMode) As Status
		Return SetStatus(GdipFillPolygon(nativeGraphics, brush->nativeBrush, points, count, fillMode))
	End Function

	Function FillPolygon(ByRef brush As /*Const*/ Brush, points As /*Const*/ *Point, count As Long) As Status
		Return FillPolygon(brush, points, count, FillModeAlternate)
	End Function

	Function FillPolygon(ByRef brush As /*Const*/ Brush, points As /*Const*/ *Point, count As Long, fillMode As FillMode) As Status
		Return SetStatus(GdipFillPolygonI(nativeGraphics, brush->nativeBrush, points, count, fillMode))
	End Function

	Function FillEllipse(ByRef brush As /*Const*/ Brush, ByRef rect As /*Const*/ RectangleF) As Status
		Return FillEllipse(brush, rect.X, rect.Y, rect.Width, rect.Height)
	End Function

	Function FillEllipse(ByRef brush As /*Const*/ Brush, x As Single, y As Single, width As Single, height As Single) As Status
		Return SetStatus(GdipFillEllipse(nativeGraphics, brush->nativeBrush, x, y, width, height))
	End Function

	Function FillEllipse(ByRef brush As /*Const*/ Brush, ByRef rect As /*Const*/ Rectangle) As Status
		Return FillEllipse(brush, rect.X, rect.Y, rect.Width, rect.Height)
	End Function

	Function FillEllipse(ByRef brush As /*Const*/ Brush, x As Long, y As Long, width As Long, height As Long) As Status
		Return SetStatus(GdipFillEllipseI(nativeGraphics, brush->nativeBrush, x, y, width, height))
	End Function

	Function FillPie(ByRef brush As /*Const*/ Brush, ByRef rect As /*Const*/ RectangleF, startAngle As Single, sweepAngle As Single) As Status
		Return FillPie(brush, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle)
	End Function

	Function FillPie(ByRef brush As /*Const*/ Brush, x As Single, y As Single, width As Single, height As Single, startAngle As Single, sweepAngle As Single) As Status
		Return SetStatus(GdipFillPie(nativeGraphics, brush->nativeBrush, x, y, width, height, startAngle, sweepAngle))
	End Function

	Function FillPie(ByRef brush As /*Const*/ Brush, ByRef rect As /*Const*/ Rectangle, startAngle As Single, sweepAngle As Single) As Status
		Return FillPie(brush, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle)
	End Function

	Function FillPie(ByRef brush As /*Const*/ Brush, x As Long, y As Long, width As Long, height As Long, startAngle As Single, sweepAngle As Single) As Status
		Return SetStatus(GdipFillPieI(nativeGraphics, brush->nativeBrush, x, y, width, height, startAngle, sweepAngle))
	End Function

	Function FillPath(ByRef brush As /*Const*/ Brush, ByRef path As /*Const*/ GraphicsPath) As Status
		Return SetStatus(GdipFillPath(nativeGraphics, brush->nativeBrush, path->nativePath))
	End Function

	Function FillClosedCurve(ByRef brush As /*Const*/ Brush, points As /*Const*/ *PointF, count As Long) As Status
		Return SetStatus(GdipFillClosedCurve(nativeGraphics, brush->nativeBrush, points, count))
	End Function

	Function FillClosedCurve(ByRef brush As /*Const*/ Brush, points As /*Const*/ *PointF, count As Long, fillMode As FillMode) As Status
		Return SetStatus(GdipFillClosedCurve2(nativeGraphics, brush->nativeBrush, points, count, 0.5, fillMode))
	End Function

	Function FillClosedCurve(ByRef brush As /*Const*/ Brush, points As /*Const*/ *PointF, count As Long, fillMode As FillMode, tension As Single) As Status
		Return SetStatus(GdipFillClosedCurve2(nativeGraphics, brush->nativeBrush, points, count, tension, fillMode))
	End Function

	Function FillClosedCurve(ByRef brush As /*Const*/ Brush, points As /*Const*/ *Point, count As Long) As Status
		Return SetStatus(GdipFillClosedCurveI(nativeGraphics, brush->nativeBrush, points, count))
	End Function

	Function FillClosedCurve(ByRef brush As /*Const*/ Brush, points As /*Const*/ *Point, count As Long, fillMode As FillMode) As Status
		Return SetStatus(GdipFillClosedCurve2I(nativeGraphics, brush->nativeBrush, points, count, 0.5, fillMode))
	End Function

	Function FillClosedCurve(ByRef brush As /*Const*/ Brush, points As /*Const*/ *Point, count As Long, fillMode As FillMode, tension As Single) As Status
		Return SetStatus(GdipFillClosedCurve2I(nativeGraphics, brush->nativeBrush, points, count, tension, fillMode))
	End Function

	Function FillRegion(ByRef brush As /*Const*/ Brush, ByRef region As /*Const*/ Region) As Status
		Return SetStatus(GdipFillRegion(nativeGraphics, brush->nativeBrush, region->nativeRegion))
	End Function

	Function DrawString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font, ByRef layoutRect As /*Const*/ RectangleF) As Status
		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Return SetStatus(GdipDrawString( nativeGraphics, str, length, nativeFont, layoutRect, 0, 0))
	End Function

	Function DrawString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font, ByRef layoutRect As /*Const*/ RectangleF,
		ByRef stringFormat As /*Const*/ StringFormat, ByRef brush As /*Const*/ Brush) As Status

		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Dim nativeFormat As *GpStringFormat
		If VarPtr(layoutRect) <> 0 Then
			nativeFormat = layoutRect.nativeFormat
		Else
			nativeFormat = 0
		End If
		Return SetStatus(GdipDrawString( nativeGraphics, str, length, nativeFont, layoutRect, nativeFormat, 0))
	End Function

	Function DrawString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font, ByRef layoutRect As /*Const*/ RectangleF,
		ByRef stringFormat As /*Const*/ StringFormat, ByRef brush As /*Const*/ Brush) As Status

		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Dim nativeFormat As *GpStringFormat
		If VarPtr(stringFormat) <> 0 Then
			nativeFormat = stringFormat.nativeFormat
		Else
			nativeFormat = 0
		End If
		Dim nativeBrush As *GpBrush
		If VarPtr(brush) <> 0 Then
			nativeBrush = brush.nativeFormat
		Else
			nativeBrush = 0
		End If
		Return SetStatus(GdipDrawString(nativeGraphics, str, length, nativeFont, layoutRect, nativeFormat, nativeBrush))
	End Function

	Function DrawString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font, ByRef origin As /*Const*/ PointF) As Status
		Dim rect As RectangleF(origin.X, origin.Y, 0.0, 0.0)
		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Return SetStatus(GdipDrawString(nativeGraphics, str, length, nativeFont, rect, 0, 0))
	End Function

	Function DrawString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font, ByRef origin As /*Const*/ PointF,
		ByRef brush As /*Const*/ Brush) As Status

		Dim rect As RectangleF(origin.X, origin.Y, 0.0, 0.0)
		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Dim nativeBrush As *GpBrush
		If VarPtr(brush) <> 0 Then
			nativeBrush = brush.nativeFormat
		Else
			nativeBrush = 0
		End If
		Return SetStatus(GdipDrawString(nativeGraphics, str, length, nativeFont, rect, 0, nativeBrush))
	End Function

	Function DrawString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font, ByRef origin As /*Const*/ PointF) As Status
		Dim rect As RectangleF(origin.X, origin.Y, 0.0, 0.0)
		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Return SetStatus(GdipDrawString(nativeGraphics, str, length, nativeFont, rect, 0, 0))
	End Function

	Function DrawString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font, ByRef origin As /*Const*/ PointF,
		ByRef stringFormat As /*Const*/ StringFormat) As Status

		Dim rect As RectangleF(origin.X, origin.Y, 0.0, 0.0)
		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Dim nativeFormat As *GpStringFormat
		If VarPtr(stringFormat) <> 0 Then
			nativeFormat = stringFormat.nativeFormat
		Else
			nativeFormat = 0
		End If
		Return SetStatus(GdipDrawString(nativeGraphics, str, length, nativeFont, rect, nativeFormat, 0))
	End Function

	Function DrawString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font, ByRef origin As /*Const*/ PointF,
		ByRef stringFormat As /*Const*/ StringFormat, ByRef brush As /*Const*/ Brush) As Status

		Dim rect As RectangleF(origin.X, origin.Y, 0.0, 0.0)
		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Dim nativeFormat As *GpStringFormat
		If VarPtr(stringFormat) <> 0 Then
			nativeFormat = stringFormat.nativeFormat
		Else
			nativeFormat = 0
		End If
		If VarPtr(brush) <> 0 Then
			nativeBrush = brush.nativeFormat
		Else
			nativeBrush = 0
		End If
		Return SetStatus(GdipDrawString( nativeGraphics, str, length, nativeFont, rect, nativeFormat, nativeBrush))
	End Function

	Const Function MeasureString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font, ByRef layoutRect As /*Const*/ RectangleF,
		ByRef stringFormat As /*Const*/ StringFormat, ByRef boundingBox As RectangleF) As Status

		Return MeasureString(str, length, font, layoutRect, stringFormat, boundingBox, ByVal 0, ByVal 0)
	End Function

	Const Function MeasureString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font, ByRef layoutRect As /*Const*/ RectangleF,
		ByRef stringFormat As /*Const*/ StringFormat, ByRef boundingBox As RectangleF,
		ByRef codepointsFitted As Long) As Status

		Return MeasureString(str, length, font, layoutRect, stringFormat, boundingBox, codepointsFitted, ByVal 0)
	End Function

	Const Function MeasureString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font, ByRef layoutRect As /*Const*/ RectangleF,
		ByRef stringFormat As /*Const*/ StringFormat, ByRef boundingBox As RectangleF,
		ByRef codepointsFitted As Long, ByRef linesFilled As Long) As Status

		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Dim nativeFormat As *GpStringFormat
		If VarPtr(stringFormat) <> 0 Then
			nativeFormat = stringFormat.nativeFormat
		Else
			nativeFormat = 0
		End If
		Return SetStatus(GdipMeasureString(nativeGraphics, str, length, nativeFont, layoutRect, nativeFormat,
			boundingBox, codepointsFitted, linesFilled))
	End Function

	Const Function MeasureString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font,
		ByRef layoutRectSize As /*Const*/ SizeF, ByRef stringFormat As /*Const*/ StringFormat,
		ByRef size As SizeF) As Status

			Return MeasureString, str, length, font, layoutRectSize, stringFormat, size, ByVal 0, ByVal 0)
	End Function

	Const Function MeasureString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font,
		ByRef layoutRectSize As /*Const*/ SizeF, ByRef stringFormat As /*Const*/ StringFormat,
		ByRef size As SizeF, ByRef codepointsFitted As Long) As Status

			Return MeasureString, str, length, font, layoutRectSize, stringFormat, size, codepointsFitted, ByVal 0)
	End Function

	Const Function MeasureString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font,
		ByRef layoutRectSize As /*Const*/ SizeF, ByRef stringFormat As /*Const*/ StringFormat,
		ByRef size As SizeF, ByRef codepointsFitted As Long, ByRef linesFilled As Long) As Status

		Dim layoutRect As RectangleF(0, 0, layoutRectSize.Width, layoutRectSize.Height)
		Dim boundingBox As RectangleF, pBoundingBox As *RectangleF
		If VarPtr(size) <> 0 Then
			pBoundingBox = VarPtr(boundingBox)
		Else
			pBoundingBox = 0
		End If

		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Dim nativeFormat As *GpStringFormat
		If VarPtr(stringFormat) <> 0 Then
			nativeFormat = stringFormat.nativeFormat
		Else
			nativeFormat = 0
		End If
		Dim status = SetStatus(GdipMeasureString(nativeGraphics, str, length,
			nativeFont, layoutRect, nativeFormat, pBoundingBox, codepointsFitted, linesFilled))

		If VarPtr(size) <> 0 And status = Ok Then
			size.Width  = boundingBox.Width
			size.Height = boundingBox.Height
		End Function

		Return status
	End Function

	Const Function MeasureString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font,
		ByRef origin As /*Const*/ PointF, ByRef stringFormat As /*Const*/ StringFormat,
		ByRef boundingBox As RectangleF) As Status

		Dim rect As RectangleF(origin.X, origin.Y, 0.0f, 0.0f)
		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Dim nativeFormat As *GpStringFormat
		If VarPtr(stringFormat) <> 0 Then
			nativeFormat = stringFormat.nativeFormat
		Else
			nativeFormat = 0
		End If

		Return SetStatus(GdipMeasureString(nativeGraphics, str, length, nativeFont, rect, nativeFormat, boundingBox, 0, 0))
	End Function

	Const Function MeasureString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font,
		ByRef layoutRect As /*Const*/ RectangleF, ByRef boundingBox As RectangleF) As Status

		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If

		Return SetStatus(GdipMeasureString(nativeGraphics, str, length, nativeFont, layoutRect, 0, boundingBox, 0, 0))
	End Function

	Const Function MeasureString(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font,
		ByRef origin As /*Const*/ PointF, ByRef boundingBox As RectangleF) As Status
		Dim rect As RectangleF(origin.X, origin.Y, 0.0, 0.0)

		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Return SetStatus(GdipMeasureString(nativeGraphics, str, length, nativeFont, rect, 0, boundingBox, 0, 0))
	End Function

	Const Function MeasureCharacterRanges(str As PCWSTR, length As Long, ByRef font As /*Const*/ Font,
		ByRef layoutRect As /*Const*/ RectangleF, ByRef stringFormat As /*Const*/ StringFormat,
		regionCount As Long, regions As *Region) As Status
		If regions = 0 Or regionCount <= 0 Then
			Return InvalidParameter
		End If

		Dim nativeRegions = _System_malloc(regionCount * SizeOf (GpRegion*)) As **GpRegion

		If nativeRegions = 0 Then
			Return OutOfMemory
		End If

		Dim i As Long
		For i = 0 To regionCount
			nativeRegions[i] = regions[i].nativeRegion
		Next

		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Dim nativeFormat As *GpStringFormat
		If VarPtr(stringFormat) <> 0 Then
			nativeFormat = stringFormat.nativeFormat
		Else
			nativeFormat = 0
		End If

		Dim status = SetStatus(GdipMeasureCharacterRanges(nativeGraphics,
			str, length, nativeFont, layoutRect, nativeFormat,regionCount, nativeRegions))
		_System_free(nativeRegions)
		Return status
	End Function

	Function DrawDriverString(text As /*Const*/ Word, length As Long, ByRef font As /*Const*/ Font,
		ByRef brush As /*Const*/ Brush, positions As /*Const*/ *PointF, flags As Long) As Status

		Return DrawDriverString(text, length, font, brush, positions, flags, ByVal 0)
	End Function

	Function DrawDriverString(text As /*Const*/ Word, length As Long, ByRef font As /*Const*/ Font,
		ByRef brush As /*Const*/ Brush, positions As /*Const*/ *PointF, flags As Long, ByRef matrix As /*Const*/ Matrix) As Status

		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Dim nativeBrush As *GpBrush
		If VarPtr(brush) <> 0 Then
			nativeBrush = brush.nativeBrush
		Else
			nativeBrush = 0
		End If
		Dim nativeMatrix As *GpMatrix
		If VarPtr(matrix) <> 0 Then
			nativeMatrix = matrix.nativeMatrix
		Else
			nativeMatrix = 0
		End If
		Return SetStatus(GdipDrawDriverString(nativeGraphics, text, length, nativeFont, nativeBrush, positions, flags, nativeMatrix))
	End Function

	Const Function MeasureDriverString(text As /*Const*/ Word, length As Long, ByRef font As /*Const*/ Font,
		positions As /*Const*/ *PointF, flags As Long, ByRef matrix As /*Const*/ Matrix, ByRef boundingBox As RectangleF) As Status

		Dim nativeFont As *GpFont
		If VarPtr(font) <> 0 Then
			nativeFont = font.nativeFormat
		Else
			nativeFont = 0
		End If
		Dim nativeMatrix As *GpMatrix
		If VarPtr(matrix) <> 0 Then
			nativeMatrix = matrix.nativeMatrix
		Else
			nativeMatrix = 0
		End If
		Return SetStatus(GdipMeasureDriverString(nativeGraphics, text, length, nativeFont, positions, flags, nativeMatrix, boundingBox))
	End Function

	' Draw a cached bitmap on this graphics destination offset by
	' x, y. Note this will fail with WrongState if the CachedBitmap
	' native format differs from this Graphics.

	Function DrawCachedBitmap(ByRef cb As CachedBitma, x As Long, y As Long) As Status
		Return SetStatus(GdipDrawCachedBitmap(nativeGraphics, cb->nativeCachedBitmap, x, y))
	End Function

	Function DrawImage(ByRef image As Image, ByRef point As /*Const*/ PointF) As Status
		Return DrawImage(image, point.X, point.Y)
	End Function

	Function DrawImage(ByRef image As Image, x As Single, y As Single) As Status
		Dim nativeImage As *GpImage
		If VarPtr(image) <> 0 Then
			nativeImage = image.nativeImage
		Else
			nativeImage = 0
		End If
		Return SetStatus(GdipDrawImage(nativeGraphics, nativeImage, x, y))
	End Function

	Function DrawImage(ByRef image As Image, ByRef rect As /*Const*/ RectangleF) As Status
		Return DrawImage(image, rect.X, rect.Y, rect.Width, rect.Height)
	End Function

	Function DrawImage(ByRef image As Image, x As Single, y As Single, width As Single, height As Single) As Status
		Dim nativeImage As *GpImage
		If VarPtr(image) <> 0 Then
			nativeImage = image.nativeImage
		Else
			nativeImage = 0
		End If
		Return SetStatus(GdipDrawImageRect(nativeGraphics, nativeImage, x, y, width, height))
	End Function

	Function DrawImage(ByRef image As Image, ByRef point As /*Const*/ Point) As Status
		Return DrawImage(image, point.X, point.Y) As Status
	End Function

	Function DrawImage(ByRef image As Image, x As Long, y As Long) As Status
		Dim nativeImage As *GpImage
		If VarPtr(image) <> 0 Then
			nativeImage = image.nativeImage
		Else
			nativeImage = 0
		End If
		Return SetStatus(GdipDrawImageI(nativeGraphics, nativeImage, x, y))
	End Function

	Function DrawImage(ByRef image As Image, ByRef rect As /*Const*/ Rectangle) As Status
		Return DrawImage(image, rect.X, rect.Y, rect.Width, rect.Height)
	End Function

	Function DrawImage(ByRef image As Image, x As Long, y As Long, width As Long, height As Long) As Status
		Dim nativeImage As *GpImage
		If VarPtr(image) <> 0 Then
			nativeImage = image.nativeImage
		Else
			nativeImage = 0
		End If
		Return SetStatus(GdipDrawImageRectI(nativeGraphics, nativeImage, x, y, width, height))
	End Function

	' Affine Draw Image
	' destPoints.length = 3: rect => parallelogram
	'	   destPoints[0] <=> top-left corner of the source rectangle
	'	   destPoints[1] <=> top-right corner
	'	   destPoints[2] <=> bottom-left corner
	' destPoints.length = 4: rect => quad
	'	   destPoints[3] <=> bottom-right corner

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ PointF, count As Long) As Status
		If count <> 3 And count <> 4 Then
			Return SetStatus(InvalidParameter)
		End If

		Dim nativeImage As *GpImage
		If VarPtr(image) <> 0 Then
			nativeImage = image.nativeImage
		Else
			nativeImage = 0
		End If
		Return SetStatus(GdipDrawImagePoints(nativeGraphics, nativeImage, destPoints, count))
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ Point, count As Long) As Status
		If count <> 3 And count <> 4 Then
			Return SetStatus(InvalidParameter)
		End If

		Dim nativeImage As *GpImage
		If VarPtr(image) <> 0 Then
			nativeImage = image.nativeImage
		Else
			nativeImage = 0
		End If
		Return SetStatus(GdipDrawImagePointsI(nativeGraphics, nativeImage, destPoints, count))
	End Function

	Function DrawImage(ByRef image As Image, x As Single, y As Single,
		srcx As Single, srcy As Single, srcwidth As Single, srcheight As Single, srcUnit As GraphicsUnit) As Status

		Dim nativeImage As *GpImage
		If VarPtr(image) <> 0 Then
			nativeImage = image.nativeImage
		Else
			nativeImage = 0
		End If
		Return SetStatus(GdipDrawImagePointRect(nativeGraphics, nativeImage, x, y, srcx, srcy, srcwidth, srcheight, srcUnit))
	End Function

	Function DrawImage(ByRef image As Image, ByRef destRect As /*Const*/ RectangleF,
		srcx As Single, srcy As Single, srcwidth As Single, srcheight As Single, srcUnit As GraphicsUnit) As Status

		Return DrawImage(image, destRect, srcx, srcy, srcwidth, srcheight, srcUnit, 0, 0, 0)
	End Function

	Function DrawImage(ByRef image As Image, ByRef destRect As /*Const*/ RectangleF,
		srcx As Single, srcy As Single, srcwidth As Single, srcheight As Single, srcUnit As GraphicsUnit,
		ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Return DrawImage(image, destRect, srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, 0, 0)
	End Function

	Function DrawImage(ByRef image As Image, ByRef destRect As /*Const*/ RectangleF,
		srcx As Single, srcy As Single, srcwidth As Single, srcheight As Single, srcUnit As GraphicsUnit,
		ByRef imageAttributes As /*Const*/ ImageAttributes,
		callback As DrawImageAbort) As Status

		Return DrawImage(image, destRect, srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback, 0)
	End Function

	Function DrawImage(ByRef image As Image, ByRef destRect As /*Const*/ RectangleF,
		srcx As Single, srcy As Single, srcwidth As Single, srcheight As Single, srcUnit As GraphicsUnit,
		ByRef imageAttributes As /*Const*/ ImageAttributes, callback As DrawImageAbort, callbackData As VoidPtr) As Status

		Dim nativeImage As *GpImage
		If VarPtr(image) <> 0 Then
			nativeImage = image.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipDrawImageRectRect(nativeGraphics, nativeImageAttr,
			destRect.X, destRect.Y, destRect.Width, destRect.Height, srcx, srcy, srcwidth, srcheight,
			srcUnit, nativeImageAttr, callback, callbackData))
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ PointF, count As Long,
		srcx As Single, srcy As Single, srcwidth As Single, srcheight As Single, srcUnit As GraphicsUnit) As Status

		Return DrawImage(image, destPoints, count, srcx, srcy, srcwidth, srcheight, srcUnit, 0, 0, 0)
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ PointF, count As Long,
		srcx As Single, srcy As Single, srcwidth As Single, srcheight As Single, srcUnit As GraphicsUnit,
		ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Return DrawImage(image, destPoints, count, srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, 0, 0)
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ PointF, count As Long,
		srcx As Single, srcy As Single, srcwidth As Single, srcheight As Single, srcUnit As GraphicsUnit,
		ByRef imageAttributes As /*Const*/ ImageAttributes,
		callback As DrawImageAbort) As Status

		Return DrawImage(image, destPoints, count, srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback, 0)
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ PointF, count As Long,
		srcx As Single, srcy As Single, srcwidth As Single, srcheight As Single, srcUnit As GraphicsUnit,
		ByRef imageAttributes As /*Const*/ ImageAttributes, callback As DrawImageAbort, callbackData As VoidPtr) As Status

		Dim nativeImage As *GpImage
		If VarPtr(image) <> 0 Then
			nativeImage = image.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipDrawImagePointsRect(nativeGraphics, nativeImage, destPoints, count,
			srcx, srcy, srcwidth, srcheight, srcUnit, nativeImageAttr, callback, callbackData))
	End Function

	Function DrawImage(ByRef image As Image, x As Long, y As Long,
		srcx As Long, srcy As Long, srcwidth As Long, srcheight As Long, srcUnit As GraphicsUnit) As Status

		Dim nativeImage As *GpImage
		If VarPtr(image) <> 0 Then
			nativeImage = image.nativeImage
		Else
			nativeImage = 0
		End If
		Return SetStatus(GdipDrawImagePointRectI(nativeGraphics, nativeImage, x, y, srcx, srcy, srcwidth, srcheight, srcUnit))
	End Function

	Function DrawImage(ByRef image As Image, ByRef destRect As /*Const*/ Rectangle,
		srcx As Single, srcy As Single, srcwidth As Single, srcheight As Single, srcUnit As GraphicsUnit) As Status

		Return DrawImage(image, destRect, srcx, srcy, srcwidth, srcheight, srcUnit, 0, 0, 0)
	End Function

	Function DrawImage(ByRef image As Image, ByRef destRect As /*Const*/ Rectangle,
		srcx As Single, srcy As Single, srcwidth As Single, srcheight As Single, srcUnit As GraphicsUnit,
		ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Return DrawImage(image, destRect, srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, 0, 0)
	End Function

	Function DrawImage(ByRef image As Image, ByRef destRect As /*Const*/ Rectangle,
		srcx As Single, srcy As Single, srcwidth As Single, srcheight As Single, srcUnit As GraphicsUnit,
		ByRef imageAttributes As /*Const*/ ImageAttributes, callback As DrawImageAbort) As Status

		Return DrawImage(image, destRect, srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback, 0)
	End Function

	Function DrawImage(ByRef image As Image, ByRef destRect As /*Const*/ Rectangle,
		srcx As Long, srcy As Long, srcwidth As Long, srcheight As Long, srcUnit As GraphicsUnit,
		ByRef imageAttributes As /*Const*/ ImageAttributes, callback As DrawImageAbort, callbackData As VoidPtr) As Status

		Dim nativeImage As *GpImage
		If VarPtr(image) <> 0 Then
			nativeImage = image.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipDrawImageRectRectI(nativeGraphics, nativeImage,
			destRect.X, destRect.Y, destRect.Width, destRect.Height,
			srcx, srcy, srcwidth, srcheight, srcUnit, nativeImageAttr, callback, callbackData))
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ Point, count As Long,
		srcx As Long, srcy As Long, srcwidth As Long, srcheight As Long, srcUnit As GraphicsUnit) As Status

		Return DrawImage(image, destPoints, count, srcx, srcy, srcwidth, srcheight, srcUnit, 0, 0, 0)
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ Point, count As Long,
		srcx As Long, srcy As Long, srcwidth As Long, srcheight As Long, srcUnit As GraphicsUnit,
		ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Return DrawImage(image, destPoints, count, srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, 0, 0)
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ Point, count As Long,
		srcx As Long, srcy As Long, srcwidth As Long, srcheight As Long, srcUnit As GraphicsUnit,
		ByRef imageAttributes As /*Const*/ ImageAttributes,
		DrawImageAbort callback As DrawImageAbort) As Status

		Return DrawImage(image, destPoints, count, srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback, 0)
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ Point, count As Long,
		srcx As Long, srcy As Long, srcwidth As Long, srcheight As Long, srcUnit As GraphicsUnit,
		ByRef imageAttributes As /*Const*/ ImageAttributes, callback As DrawImageAbort, callbackData As VoidPtr) As Status

		Dim nativeImage As *GpImage
		If VarPtr(image) <> 0 Then
			nativeImage = image.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipDrawImagePointsRectI(nativeGraphics, nativeImage, destPoints, count,
			srcx, srcy, srcwidth, srcheight, srcUnit, nativeImageAttr, callback, callbackData))
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ *Point, count As Long, ByRef srcRect As Rectangle, srcUnit As GraphicsUnit) As Status
		Return DrawImage(image, destPoints, count, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, srcUnit)
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ *PointF, count As Long, ByRef srcRect As RectangleF, srcUnit As GraphicsUnit) As Status
		Return DrawImage(image, destPoints, count, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, srcUnit)
	End Function

	Function DrawImage(ByRef image As Image, x As Long, y As Long, ByRef srcRect As Rectangle, srcUnit As GraphicsUnit) As Status
		Return DrawImage(image, x, y, count, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, srcUnit)
	End Function

	Function DrawImage(ByRef image As Image, x As Single, y As Single, ByRef srcRect As RectangleF, srcUnit As GraphicsUnit) As Status
		Return DrawImage(image, x, y, count, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, srcUnit)
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ *Point, count As Long, ByRef srcRect As Rectangle, srcUnit As GraphicsUnit, ByRef imageAttributes As /*Const*/ ImageAttributes) As Status
		Return DrawImage(image, destPoints, count, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, srcUnit, imageAttributes)
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ *PointF, count As Long, ByRef srcRect As RectangleF, srcUnit As GraphicsUnit, ByRef imageAttributes As /*Const*/ ImageAttributes) As Status
		Return DrawImage(image, destPoints, count, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, srcUnit, imageAttributes)
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ *Point, count As Long, ByRef srcRect As Rectangle, srcUnit As GraphicsUnit, ByRef imageAttributes As /*Const*/ ImageAttributes, callback As DrawImageAbort) As Status
		Return DrawImage(image, destPoints, count, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, srcUnit, imageAttributes, callback)
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ *PointF, count As Long, ByRef srcRect As RectangleF, srcUnit As GraphicsUnit, ByRef imageAttributes As /*Const*/ ImageAttributes, callback As DrawImageAbort) As Status
		Return DrawImage(image, destPoints, count, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, srcUnit, imageAttributes, callback)
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ *Point, count As Long, ByRef srcRect As Rectangle, srcUnit As GraphicsUnit, ByRef imageAttributes As /*Const*/ ImageAttributes, callback As DrawImageAbort, callbackData As VoidPtr) As Status
		Return DrawImage(image, destPoints, count, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, srcUnit, imageAttributes, callback, callbackData)
	End Function

	Function DrawImage(ByRef image As Image, destPoints As /*Const*/ *PointF, count As Long, ByRef srcRect As RectangleF, srcUnit As GraphicsUnit, ByRef imageAttributes As /*Const*/ ImageAttributes, callback As DrawImageAbort, callbackData As VoidPtr) As Status
		Return DrawImage(image, destPoints, count, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, srcUnit, imageAttributes, callback, callbackData)
	End Function

	' The following methods are for playing an EMF+ to a graphics
	' via the enumeration interface.  Each record of the EMF+ is
	' sent to the callback (along with the callbackData).	Then
	' the callback can invoke the Metafile::PlayRecord method
	' to play the particular record.

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, ByRef destPoint As /*Const*/ PointF,
		callback As EnumerateMetafileProc) As Status

		Return EnumerateMetafile(metafile, destPoint, callback, 0, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, ByRef destPoint As /*Const*/ PointF,
		callback As EnumerateMetafileProc, callbackData As VoidPtr) As Status

		Return EnumerateMetafile(metafile, destPoint, callback, callbackData, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, ByRef destPoint As /*Const*/ PointF,
		callback As EnumerateMetafileProc, callbackData As VoidPtr, ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Dim nativeImage As /*Const*/ *GpMetafile
		If VarPtr(metafile) <> 0 Then
			nativeImage = metafile.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipEnumerateMetafileDestPoint(nativeGraphics,
			nativeImage, destPoint, callback, callbackData,nativeImageAttr))
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, ByRef destPoint As /*Const*/ Point,
		callback As EnumerateMetafileProc) As Status

		Return EnumerateMetafile(metafile, destPoint, callback, 0, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, ByRef destPoint As /*Const*/ Point,
		callback As EnumerateMetafileProc, callbackData As VoidPtr) As Status

		Return EnumerateMetafile(metafile, destPoint, callback, callbackData, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, ByRef destPoint As /*Const*/ Point,
		callback As EnumerateMetafileProc, callbackData As VoidPtr, ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Dim nativeImage As /*Const*/ *GpMetafile
		If VarPtr(metafile) <> 0 Then
			nativeImage = metafile.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipEnumerateMetafileDestPointI(nativeGraphics,
			nativeImage, destPoint, callback, callbackData,nativeImageAttr))
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, ByRef destRect As /*Const*/ RectangleF,
		callback As EnumerateMetafileProc) As Status

		Return EnumerateMetafile(metafile, destRect, callback, 0, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, ByRef destRect As /*Const*/ RectangleF,
		callback As EnumerateMetafileProc, callbackData As VoidPtr) As Status

		Return EnumerateMetafile(metafile, destRect, callback, callbackData, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, ByRef destRect As /*Const*/ RectangleF,
		callback As EnumerateMetafileProc, callbackData As VoidPtr, ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Dim nativeImage As /*Const*/ *GpMetafile
		If VarPtr(metafile) <> 0 Then
			nativeImage = metafile.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipEnumerateMetafileDestRect(nativeGraphics,
			nativeImage, destRect, callback, callbackData, nativeImageAttr))
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, ByRef destRect As /*Const*/ Rectangle,
		callback As EnumerateMetafileProc) As Status

		Return EnumerateMetafile(metafile, destRect, callback, 0, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, ByRef destRect As /*Const*/ Rectangle,
		callback As EnumerateMetafileProc, callbackData As VoidPtr) As Status

		Return EnumerateMetafile(metafile, destRect, callback, callbackData, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, ByRef destRect As /*Const*/ Rectangle,
		callback As EnumerateMetafileProc, callbackData As VoidPtr, ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Dim nativeImage As /*Const*/ *GpMetafile
		If VarPtr(metafile) <> 0 Then
			nativeImage = metafile.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipEnumerateMetafileDestRectI(nativeGraphics,
			nativeImage, destRect, callback, callbackData, nativeImageAttr))
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, destPoints As /*Const*/ *PointF, count As Long,
		callback As EnumerateMetafileProc) As Status

		Return EnumerateMetafile(metafile, destPoints, count, callback, 0, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, destPoints As /*Const*/ *PointF, count As Long,
		callback As EnumerateMetafileProc, callbackData As VoidPtr) As Status

		Return EnumerateMetafile(metafile, destPoints, count, callback, callbackData, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, destPoints As /*Const*/ *PointF, count As Long,
		callback As EnumerateMetafileProc, callbackData As VoidPtr, ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Dim nativeImage As /*Const*/ *GpMetafile
		If VarPtr(metafile) <> 0 Then
			nativeImage = metafile.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipEnumerateMetafileDestPoints(nativeGraphics,
			nativeImage,destPoints, count, callback, callbackData, nativeImageAttr))
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, destPoints As /*Const*/ *Point, count As Long,
		callback As EnumerateMetafileProc) As Status

		Return EnumerateMetafile(metafile, destPoints, count, callback, 0, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, destPoints As /*Const*/ *Point, count As Long,
		callback As EnumerateMetafileProc, callbackData As VoidPtr) As Status

		Return EnumerateMetafile(metafile, destPoints, count, callback, callbackData, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile, destPoints As /*Const*/ *Point, count As Long,
		callback As EnumerateMetafileProc, callbackData As VoidPtr, ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Dim nativeImage As /*Const*/ *GpMetafile
		If VarPtr(metafile) <> 0 Then
			nativeImage = metafile.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipEnumerateMetafileDestPointsI(nativeGraphics,
			nativeImage,destPoints, count, callback, callbackData, nativeImageAttr))
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		ByRef destPoint As /*Const*/ PointF, ByRef srcRect As /*Const*/ RectangleF, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc) As Status

		Return EnumerateMetafile(metafile, destPoint, count, srcUnit, callback, 0, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		ByRef destPoint As /*Const*/ PointF, ByRef srcRect As /*Const*/ RectangleF, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc, callbackData As VoidPtr) As Status

		Return EnumerateMetafile(metafile, destPoint, srcRect, srcUnit, callback, callbackData, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		ByRef destPoint As /*Const*/ PointF, ByRef srcRect As /*Const*/ RectangleF, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc, callbackData As VoidPtr, ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Dim nativeImage As /*Const*/ *GpMetafile
		If VarPtr(metafile) <> 0 Then
			nativeImage = metafile.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipEnumerateMetafileSrcRectDestPoint(nativeGraphics,
			nativeImage, destPoint, srcRect, srcUnit, callback, callbackData, nativeImageAttr)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		ByRef destPoint As /*Const*/ Point, ByRef srcRect As /*Const*/ Rectangle, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc) As Status

		Return EnumerateMetafile(metafile, destPoint, count, srcUnit, callback, 0, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		ByRef destPoint As /*Const*/ Point, ByRef srcRect As /*Const*/ Rectangle, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc, callbackData As VoidPtr) As Status

		Return EnumerateMetafile(metafile, destPoint, srcRect, srcUnit, callback, callbackData, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		ByRef destPoint As /*Const*/ Point, ByRef srcRect As /*Const*/ Rectangle, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc, callbackData As VoidPtr, ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Dim nativeImage As /*Const*/ *GpMetafile
		If VarPtr(metafile) <> 0 Then
			nativeImage = metafile.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipEnumerateMetafileSrcRectDestPointI(nativeGraphics,
			nativeImage, destPoint, srcRect, srcUnit, callback, callbackData, nativeImageAttr)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		ByRef destRect As /*Const*/ RectangleF, ByRef srcRect As /*Const*/ RectangleF, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc) As Status

		Return EnumerateMetafile(metafile, destRect, count, srcUnit, callback, 0, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		ByRef destRect As /*Const*/ RectangleF, ByRef srcRect As /*Const*/ RectangleF, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc, callbackData As VoidPtr) As Status

		Return EnumerateMetafile(metafile, destRect, srcRect, srcUnit, callback, callbackData, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		ByRef destRect As /*Const*/ RectangleF, ByRef srcRect As /*Const*/ RectangleF, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc, callbackData As VoidPtr, ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Dim nativeImage As /*Const*/ *GpMetafile
		If VarPtr(metafile) <> 0 Then
			nativeImage = metafile.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipEnumerateMetafileSrcRectDestRect(nativeGraphics,
			nativeImage, destRect, srcRect, srcUnit, callback, callbackData, nativeImageAttr))
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		ByRef destRect As /*Const*/ Rectangle, ByRef srcRect As /*Const*/ Rectangle, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc) As Status

		Return EnumerateMetafile(metafile, destRect, srcRect, srcUnit, callback, 0, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		ByRef destRect As /*Const*/ Rectangle, ByRef srcRect As /*Const*/ Rectangle, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc, callbackData As VoidPtr) As Status

		Return EnumerateMetafile(metafile, destRect, srcRect, srcUnit, callback, callbackData, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		ByRef destRect As /*Const*/ Rectangle, ByRef srcRect As /*Const*/ Rectangle, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc, callbackData As VoidPtr, ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Dim nativeImage As /*Const*/ *GpMetafile
		If VarPtr(metafile) <> 0 Then
			nativeImage = metafile.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipEnumerateMetafileSrcRectDestRectI(nativeGraphics,
			nativeImage, destRect, srcRect, srcUnit, callback, callbackData, nativeImageAttr))
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		destPoints As /*Const*/ *PointF, count As Long, ByRef srcRect As /*Const*/ RectangleF, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc) As Status

		Return EnumerateMetafile(metafile, destPoints, count, srcRect, srcUnit, callback, 0, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		destPoints As /*Const*/ *PointF, count As Long, ByRef srcRect As /*Const*/ RectangleF, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc, callbackData As VoidPtr) As Status

		Return EnumerateMetafile(metafile, destPoints, count, srcRect, srcUnit, callback, callbackData, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		destPoints As /*Const*/ *PointF, count As Long, ByRef srcRect As /*Const*/ RectangleF, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc, callbackData As VoidPtr, ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Dim nativeImage As /*Const*/ *GpMetafile
		If VarPtr(metafile) <> 0 Then
			nativeImage = metafile.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipEnumerateMetafileSrcRectDestPoints(nativeGraphics,
			nativeImage, destPoints, count, srcRect, srcUnit, callback, callbackData, nativeImageAttr)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		destPoints As /*Const*/ *Point, count As Long, ByRef srcRect As /*Const*/ Rectangle, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc) As Status

		Return EnumerateMetafile(metafile, destPoints, count, srcRect, srcUnit, callback, 0, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		destPoints As /*Const*/ *Point, count As Long, ByRef srcRect As /*Const*/ Rectangle, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc, callbackData As VoidPtr) As Status

		Return EnumerateMetafile(metafile, destPoints, count, srcRect, srcUnit, callback, callbackData, 0)
	End Function

	Function EnumerateMetafile(ByRef metafile As /*Const*/ Metafile,
		destPoints As /*Const*/ *Point, count As Long, ByRef srcRect As /*Const*/ Rectangle, srcUnit As GraphicsUnit,
		callback As EnumerateMetafileProc, callbackData As VoidPtr, ByRef imageAttributes As /*Const*/ ImageAttributes) As Status

		Dim nativeImage As /*Const*/ *GpMetafile
		If VarPtr(metafile) <> 0 Then
			nativeImage = metafile.nativeImage
		Else
			nativeImage = 0
		End If
		Dim nativeImageAttr As *GpImageAttributes
		If VarPtr(imageAttributes) <> 0 Then
			nativeImageAttr = image.nativeImageAttr
		Else
			nativeImageAttr = 0
		End If

		Return SetStatus(GdipEnumerateMetafileSrcRectDestPointsI(nativeGraphics,
			nativeImage, destPoints, count, srcRect, srcUnit, callback, callbackData, nativeImageAttr)
	End Function

	Function SetClip(ByRef g As /*Const*/ Graphics) As Status
		Return SetClip(g, CombineMode.Replace)
	End Function

	Function SetClip(ByRef rc As /*Const*/ RectangleF) As Status
		Return SetStatus(GdipSetClipRect(nativeGraphics, rc.X, rc.Y, rc.Width, rc.Height, CombineMode.Replace))
	End Function

	Function SetClip(ByRef rc As /*Const*/ Rectangle) As Status
		Return SetStatus(GdipSetClipRectI(nativeGraphics, rc.X, rc.Y, rc.Width, rc.Height, CombineMode.Replace))
	End Function

	Function SetClip(ByRef path As /*Const*/ GraphicsPath) As Status
		Return SetStatus(GdipSetClipPath(nativeGraphics, path->nativePath, CombineMode.Replace))
	End Function

	Function SetClip(ByRef region As /*Const*/ Region) As Status
		Return SetStatus(GdipSetClipRegion(nativeGraphics, region->nativeRegion, CombineMode.Replace))
	End Function

	Function SetClip(ByRef g As /*Const*/ Graphics, combineMode As CombineMode) As Status
		Return SetStatus(GdipSetClipGraphics(nativeGraphics, g->nativeGraphics, combineMode))
	End Function

	Function SetClip(ByRef rc As /*Const*/ RectangleF, combineMode As CombineMode) As Status
		Return SetStatus(GdipSetClipRect(nativeGraphics, rc.X, rc.Y, rc.Width, rc.Height, combineMode))
	End Function

	Function SetClip(ByRef rc As /*Const*/ Rectangle, combineMode As CombineMode) As Status
		Return SetStatus(GdipSetClipRectI(nativeGraphics, rc.X, rc.Y, rc.Width, rc.Height, combineMode))
	End Function

	Function SetClip(ByRef path As /*Const*/ GraphicsPath, combineMode As CombineMode) As Status
		Return SetStatus(GdipSetClipPath(nativeGraphics, path->nativePath, combineMode))
	End Function

	Function SetClip(ByRef region As /*Const*/ Region, combineMode As CombineMode) As Status
		Return SetStatus(GdipSetClipRegion(nativeGraphics, region->nativeRegion, combineMode))
	End Function

	' This is different than the other SetClip methods because it assumes
	' that the HRGN is already in device units, so it doesn't transform
	' the coordinates in the HRGN.

	Function SetClip(hrgn As HRGN, combineMode As CombineMode /* = CombineModeReplace*/) As Status
		Return SetStatus(GdipSetClipHrgn(nativeGraphics, hrgn, combineMode))
	End Function

	Function IntersectClip(ByRef rc As /*Const*/ RectangleF) As Status
		Return SetStatus(GdipSetClipRect(nativeGraphics, rc.X, rc.Y, rc.Width, rc.Height, CombineMode.Intersect))
	End Function

	Function IntersectClip(ByRef rc As /*Const*/ Rectangle) As Status
		Return SetStatus(GdipSetClipRectI(nativeGraphics, rc.X, rc.Y, rc.Width, rc.Height, CombineMode.Intersect))
	End Function

	Function IntersectClip(ByRef region As /*Const*/ Region) As Status
		Return SetStatus(GdipSetClipRegion(nativeGraphics, region->nativeRegion, CombineMode.Intersect))
	End Function

	Function ExcludeClip(ByRef rc As /*Const*/ RectangleF) As Status
		Return SetStatus(GdipSetClipRect(nativeGraphics, rc.X, rc.Y, rc.Width, rc.Height, CombineMode.Exclude))
	End Function

	Function ExcludeClip(ByRef rc As /*Const*/ Rectangle) As Status
		Return SetStatus(GdipSetClipRectI(nativeGraphics, rc.X, rc.Y, rc.Width, rc.Height, CombineMode.Exclude))
	End Function

	Function ExcludeClip(ByRef region As /*Const*/ Region) As Status
		Return SetStatus(GdipSetClipRegion(nativeGraphics, region->nativeRegion, CombineMode.Exclude))
	End Function

	Function ResetClip() As Status
		Return SetStatus(GdipResetClip(nativeGraphics))
	End Function

	Function TranslateClip(dx As Single, dy As Single) As Status
		Return SetStatus(GdipTranslateClip(nativeGraphics, dx, dy))
	End Function

	Function TranslateClip(dx As Long, dy As Long) As Status
		Return SetStatus(GdipTranslateClipI(nativeGraphics, dx, dy))
	End Function

	Const Function GetClip(ByRef region As Region) As Status
		Return SetStatus(GdipGetClip(nativeGraphics, region->nativeRegion))
	End Function

	Const Function GetClipBounds(ByRef rc As RectangleF) As Status
		Return SetStatus(GdipGetClipBounds(nativeGraphics, rc))
	End Function

	Const Function GetClipBounds(ByRef rc As Rectangle) As Status
		Return SetStatus(GdipGetClipBoundsI(nativeGraphics, rc))
	End Function

	Const Function GetVisibleClipBounds(ByRef rc As RectangleF) As Status
		Return SetStatus(GdipGetVisibleClipBounds(nativeGraphics, rc))
	End Function

	Const Function GetVisibleClipBounds(ByRef rc As Rectangle) As Status
		Return SetStatus(GdipGetVisibleClipBoundsI(nativeGraphics, rc))
	End Function

	Const Function IsVisible(x As Long, y As Long) As BOOL
		Dim b = FALSE As BOOL
		SetStatus(GdipIsVisiblePointI(nativeGraphics, x, y, b))
		Return b
	End Function

	Const Function IsVisible(ByRef pt As /*Const*/ Point) As BOOL
		Return IsVisible(pt.X, pt.Y)
	End Function

	Const Function IsVisible(x As Long, y As Long, width As Long, height As Long) As BOOL
		Dim b = FALSE As BOOL
		SetStatus(GdipIsVisibleRectI(nativeGraphics, x, y, width, height, b))
		Return b
	End Function

	Const Function IsVisible(ByRef rc As /*Const*/ Rectangle) As BOOL
		Return IsVisible(rc.X, rc.Y, rc.Width, rc.Height)
	End Function

	Const Function IsVisible(x As Single, y As Single) As BOOL
		Dim b = FALSE As BOOL
		SetStatus(GdipIsVisiblePoint(nativeGraphics, x, y, b))
		Return b
	End Function

	Const Function IsVisible(ByRef point As /*Const*/ PointF) As BOOL
		Return IsVisible(pt.X, pt.Y)
	End Function

	Const Function IsVisible(x As Single, y As Single, width As Single, height As Single) As BOOL
		Dim b = FALSE As BOOL
		SetStatus(GdipIsVisibleRect(nativeGraphics, x, y, width, height, b))
		Return b
	End Function

	Const Function IsVisible(ByRef rect As /*Const*/ RectangleF) As BOOL
		Return IsVisible(rc.X, rc.Y, rc.Width, rc.Height)
	End Function

	Const Function Save() As GraphicsState
		Dim gstate As GraphicsState
		SetStatus(GdipSaveGraphics(nativeGraphics, state))
		Return gstate
	End Function

	Function Restore(gstate As GraphicsState)
		Return SetStatus(GdipRestoreGraphics(nativeGraphics, gstate))
	End Function

	Function BeginContainer(ByRef dstrect As /*Const*/ RectangleF, ByRef srcrect As /*Const*/ RectangleF, unit As GraphicsUnit) As GraphicsContainer
		Dim state As GraphicsContainer
		SetStatus(GdipBeginContainer(nativeGraphics, dstrect, srcrect, unit, state))
		Return state
	End Function

	Function BeginContainer(ByRef dstrect As /*Const*/ Rectangle, ByRef srcrect As /*Const*/ Rectangle, unit As GraphicsUnit) As GraphicsContainer
		Dim state As GraphicsContainer
		SetStatus(GdipBeginContainerI(nativeGraphics, dstrect, srcrect, unit, state))
		Return state
	End Function

	Function BeginContainer() As GraphicsContainer
		Dim state As GraphicsContainer
		SetStatus(GdipBeginContainer2(nativeGraphics, state))
		Return state
	End Function

	Function EndContainer(state As GraphicsContainer) As Status
		Return SetStatus(GdipEndContainer(nativeGraphics, state))
	End Function

	' Only valid when recording metafiles.

	Function AddMetafileComment(data As /*Const*/ *Byte, sizeData As DWord)
		Return SetStatus(GdipComment(nativeGraphics, sizeData, data))
	End Function

	Static Function GetHalftonePalette() As HPALETTE
		Return GdipCreateHalftonePalette()
	End Function

	Const Function GetLastStatus() As Status
		Dim lastStatus = lastResult
		lastResult = Status.Ok
		Return lastStatus
	End Function

Private
	Sub Graphics(ByRef gr As Graphics)
		Debug
	End Sub
	Sub Operator =(ByRef gr As Graphics)
		Debug
	End Sub

Protected
	Sub Graphics(graphics As *GpGraphics)
		lastResult = Ok
		SetNativeGraphics(graphics)
	End Sub

	Sub SetNativeGraphics(graphics As *GpGraphics)
		This.nativeGraphics = graphics
	End Sub

	Const Function SetStatus(status As Status) As Status
		If status <> Status.Ok Then
			lastResult = status
		End If
		Return status
	End Function

	Const Function GetNativeGraphics() As *GpGraphics
		Return This.nativeGraphics
	End Function

	Function GetNativePen(const Pen* pen) As *GpPen
		Return pen->nativePen
	End Function

Protected
	nativeGraphics As *GpGraphics
	lastResult As /*Mutable*/ Status
End Class

#endif