source: trunk/ab5.0/ablib/src/Classes/System/Drawing/Graphics.ab

' Classes/System/Drawing/Graphics.ab

Namespace System
Namespace Drawing

Class ImageAttributes
Public
    nativeImage As *GpImageAttributes
End Class
Class Region
Public
    nativeRegion As *GpRegion
End Class
Class GraphicsPath
Public
    Sub GraphicsPath(native As *GpPath)
        nativePath = native
    End Sub
    Function NativePath() As *GpPath
    End Function
    nativePath As *GpPath
End Class
Class CachedBitmap
Public
    nativeCachedBitmap As *GpCachedBitmap
End Class

Delegate Function EnumerateMetafileProc(recordType As Imaging.EmfPlusRecordType, flags As DWord, dataSize As DWord, data As *Byte, callbackData As VoidPtr) As Boolean

Namespace Detail

TypeDef NativeEnumerateMetafileProc = *Function(recordType As Imaging.EmfPlusRecordType, flags As DWord, dataSize As DWord, data As *Byte, callbackData As VoidPtr) As Boolean

Type EnumerateMetafileProcData
    Proc As EnumerateMetafileProc
    Data As VoidPtr
End Type

Function NativeEnumerateMetafileProcEntry(recordType As Imaging.EmfPlusRecordType, flags As DWord, dataSize As DWord, data As *Byte, callbackData As VoidPtr) As Boolean
    Dim procData = callbackData As *EnumerateMetafileProcData
    Dim proc = procData->Proc
    NativeEnumerateMetafileProcEntry = proc(recordType, flags, dataSize, data, procData->Data)
End Function

End Namespace

Class Graphics
Public
    '=========================================================================
    ' Properties
    '=========================================================================
    Const Function Clip() As Region
        Clip = New Region
        SetStatus(GdipGetClip(nativeGraphics, Clip.nativeRegion))
    End Function

    Sub Clip(region As Region)
        Imports System.Drawing.Drawing2D
        SetStatus(GdipSetClipRegion(nativeGraphics, region.nativeRegion, CombineMode.Replace))
    End Sub

    Const Function ClipBounds() As RectangleF
        SetStatus(GdipGetClipBounds(nativeGraphics, ClipBounds))
    End Function

    Const Function ClipBoundsI() As Rectangle
        SetStatus(GdipGetClipBoundsI(nativeGraphics, ClipBoundsI))
    End Function
/*
    Const Function CompositingMode() As Drawing2D.CompositingMode
        SetStatus(GdipGetCompositingMode(nativeGraphics, CompositingMode))
    End Function

    Sub CompositingMode(mode As Drawing2D.CompositingMode)
        SetStatus(GdipSetCompositingMode(nativeGraphics, mode))
    End Sub

    Function CompositingQuality() As Drawing2D.CompositingQuality
        SetStatus(GdipGetCompositingQuality(nativeGraphics, CompositingQuality))
    End Function

    Sub CompositingQuality(cq As Drawing2D.CompositingQuality)
        Return SetStatus(GdipSetCompositingQuality(nativeGraphics, cq))
    End Sub
*/
    Const Function DpiX() As Single
        SetStatus(GdipGetDpiX(nativeGraphics, DpiX))
    End Function

    Const Function DpiY() As Single
        SetStatus(GdipGetDpiY(nativeGraphics, DpiY))
    End Function
/*
    Const Function InterpolationMode() As Drawing2D.InterpolationMode
        SetStatus(GdipGetInterpolationMode(nativeGraphics, InterpolationMode))
    End Function

    Sub InterpolationMode(im As Drawing2D.InterpolationMode)
        InterpolationMode = SetStatus(GdipSetInterpolationMode(nativeGraphics, im))
    End Sub
*/
    Const Function IsClipEmpty() As Boolean
        Dim b = FALSE As BOOL
        SetStatus(GdipIsClipEmpty(nativeGraphics, b))
        IsClipEmpty = b As Boolean
    End Function

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

    Sub PageScale(scale As Single)
        SetStatus(GdipSetPageScale(nativeGraphics, scale))
    End Sub

    Const Function PageScale() As Single
        SetStatus(GdipGetPageScale(nativeGraphics, PageScale))
    End Function
/*
    Const Function PageUnit() As GraphicsUnit
        SetStatus(GdipGetPageUnit(nativeGraphics, PageUnit))
    End Function
*/
    Sub PageUnit(unit As GraphicsUnit)
        SetStatus(GdipSetPageUnit(nativeGraphics, unit))
    End Sub
/*
    Function PixelOffsetMode() As Drawing2D.PixelOffsetMode
        PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.Invalid
        SetStatus(GdipGetPixelOffsetMode(nativeGraphics, PixelOffsetMode))
    End Function
*/
    Sub PixelOffsetMode(mode As Drawing2D.PixelOffsetMode)
        SetStatus(GdipSetPixelOffsetMode(nativeGraphics, mode))
    End Sub

    Function RenderingOrigin() As Point
        With RenderingOrigin
            .X = 0
            .Y = 0
            SetStatus(GdipGetRenderingOrigin(nativeGraphics, .X, .Y))
        End With
    End Function

    Sub RenderingOrigin(pt As Point)
        SetStatus(GdipSetRenderingOrigin(nativeGraphics, pt.X, pt.Y))
    End Sub
/*
    Function SmoothingMode() As Drawing2D.SmoothingMode
        SetStatus(GdipGetSmoothingMode(nativeGraphics, SmoothingMode))
    End Function
*/
    Sub SmoothingMode(mode As Drawing2D.SmoothingMode)
        SetStatus(GdipSetSmoothingMode(nativeGraphics, mode))
    End Sub

    Function TextContrast() As DWord
        SetStatus(GdipGetTextContrast(nativeGraphics, TextContrast))
    End Function

    Sub TextContrast(contrast As DWord)
        SetStatus(GdipSetTextContrast(nativeGraphics, contrast))
    End Sub
/*
    Function TextRenderingHint() As Text.TextRenderingHint
        SetStatus(GdipGetTextRenderingHint(nativeGraphics, ByVal VarPtr(TextRenderingHint)))
    End Function
*/
    Sub TextRenderingHint(mode As TextRenderingHint)
        SetStatus(GdipSetTextRenderingHint(nativeGraphics, mode))
    End Sub

    Function Transform() As Drawing2D.Matrix
        Dim native As *GpMatrix
        SetStatus(GdipGetWorldTransform(nativeGraphics, native))
        Transform = New Drawing2D.Matrix(native)
    End Function

    Sub Transform(matrix As Drawing2D.Matrix)
        SetStatus(GdipSetWorldTransform(nativeGraphics, matrix.nativeMatrix))
    End Sub

    Function VisibleClipBounds() As RectangleF
        SetStatus(GdipGetVisibleClipBounds(nativeGraphics, VisibleClipBounds))
    End Function

    Function VisibleClipBoundsI() As Rectangle
        SetStatus(GdipGetVisibleClipBoundsI(nativeGraphics, VisibleClipBoundsI))
    End Function

    '=========================================================================
    ' Methods
    '=========================================================================
    Static Function FromHDC(hdc As HDC) As Graphics
        Dim graphics = 0 As *GpGraphics
        SetStatus(GdipCreateFromHDC(hdc, graphics))
        Return New Graphics(graphics)
    End Function

    Static Function FromHDC(hdc As HDC, hdevice As HANDLE) As Graphics
        Dim graphics = 0 As *GpGraphics
        SetStatus(GdipCreateFromHDC2(hdc, hdevice, graphics))
        Return New Graphics(graphics)
    End Function

    Static Function FromHwnd(hwnd As HWND) As Graphics
        Dim graphics = 0 As *GpGraphics
        SetStatus(GdipCreateFromHWND(hwnd, graphics))
        Return New Graphics(graphics)
    End Function

    Static Function FromHwnd(hwnd As HWND, icm As Boolean) As Graphics
        Dim graphics = 0 As *GpGraphics
        If icm Then
            SetStatus(GdipCreateFromHWNDICM(hwnd, graphics))
        Else
            SetStatus(GdipCreateFromHWND(hwnd, graphics))
        End If
        Return New Graphics(graphics)
    End Function

    Static Function FromImage(image As Image) As Graphics
        If ActiveBasic.IsNothing(image) Then
            Throw New ArgumentNullException("image")
        End If
        Dim graphics = 0 As *GpGraphics
        SetStatus(GdipGetImageGraphicsContext(image.NativeImage, graphics))
        Return New Graphics(graphics)
    End Function

    Sub Dispose()
        GdipDeleteGraphics(nativeGraphics)
        nativeGraphics = 0
    End Sub

    Sub ~Graphics()
        Dispose()
    End Sub

    Sub Flush()
        GdipFlush(nativeGraphics, System.Drawing.Drawing2D.FlushIntention.Flush)
    End Sub

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

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

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

    Sub ResetTransform()
        SetStatus(GdipResetWorldTransform(nativeGraphics))
    End Sub

    Sub MultiplyTransform(matrix As Drawing2D.Matrix)
        SetStatus(GdipMultiplyWorldTransform(nativeGraphics, matrix.nativeMatrix, System.Drawing.Drawing2D.MatrixOrder.Prepend))
    End Sub

    Sub MultiplyTransform(matrix As Drawing2D.Matrix, order As Drawing2D.MatrixOrder)
        SetStatus(GdipMultiplyWorldTransform(nativeGraphics, matrix.nativeMatrix, order))
    End Sub

    Sub TranslateTransform(dx As Single, dy As Single)
        SetStatus(GdipTranslateWorldTransform(nativeGraphics, dx, dy, System.Drawing.Drawing2D.MatrixOrder.Prepend))
    End Sub

    Sub TranslateTransform(dx As Single, dy As Single, order As Drawing2D.MatrixOrder)
        SetStatus(GdipTranslateWorldTransform(nativeGraphics, dx, dy, order))
    End Sub

    Sub ScaleTransform(sx As Single, sy As Single)
        SetStatus(GdipScaleWorldTransform(nativeGraphics, sx, sy, System.Drawing.Drawing2D.MatrixOrder.Prepend))
    End Sub

    Sub ScaleTransform(sx As Single, sy As Single, order As Drawing2D.MatrixOrder)
        SetStatus(GdipScaleWorldTransform(nativeGraphics, sx, sy, order))
    End Sub

    Sub RotateTransform(angle As Single)
        SetStatus(GdipRotateWorldTransform(nativeGraphics, angle, System.Drawing.Drawing2D.MatrixOrder.Prepend))
    End Sub

    Sub RotateTransform(angle As Single, order As Drawing2D.MatrixOrder)
        SetStatus(GdipRotateWorldTransform(nativeGraphics, angle, order))
    End Sub

    Sub TransformPoints(destSpace As Drawing2D.CoordinateSpace, srcSpace As Drawing2D.CoordinateSpace, pts As *PointF, count As Long)
        SetStatus(GdipTransformPoints(nativeGraphics, destSpace, srcSpace, pts, count))
    End Sub

    Sub TransformPoints(destSpace As Drawing2D.CoordinateSpace, srcSpace As Drawing2D.CoordinateSpace, pts As *Point, count As Long)
        SetStatus(GdipTransformPointsI(nativeGraphics, destSpace, srcSpace, pts, count))
    End Sub

    Const Function GetNearestColor(color As Color) As Color
        GetNearestColor = color
        SetStatus(GdipGetNearestColor(nativeGraphics, GetNearestColor))
    End Function

    Sub DrawLine(pen As Pen, x1 As Single, y1 As Single, x2 As Single, y2 As Single)
        SetStatus(GdipDrawLine(nativeGraphics, pen.NativePen, x1, y1, x2, y2))
    End Sub

    Sub DrawLine(pen As Pen, ByRef pt1 As PointF, ByRef pt2 As PointF)
        DrawLine(pen, pt1.X, pt1.Y, pt2.X, pt2.Y)
    End Sub

    Sub DrawLines(pen As Pen, points As *PointF, count As Long)
        SetStatus(GdipDrawLines(nativeGraphics, pen.NativePen, points, count))
    End Sub

    Sub DrawLine(pen As Pen, x1 As Long, y1 As Long, x2 As Long, y2 As Long)
        SetStatus(GdipDrawLineI(nativeGraphics, pen.NativePen, x1, y1, x2, y2))
    End Sub

    Sub DrawLine(pen As Pen, ByRef pt1 As Point, ByRef pt2 As Point)
        DrawLine(pen, pt1.X, pt1.Y, pt2.X, pt2.Y)
    End Sub

    Sub DrawLines(pen As Pen, points As *Point, count As Long)
        SetStatus(GdipDrawLinesI(nativeGraphics, pen.NativePen, points, count))
    End Sub

    Sub DrawArc(pen As Pen, x As Single, y As Single, width As Single, height As Single, startAngle As Single, sweepAngle As Single)
        SetStatus(GdipDrawArc(nativeGraphics, pen.NativePen, x, y, width, height, startAngle, sweepAngle))
    End Sub

    Sub DrawArc(pen As Pen, ByRef rect As RectangleF, startAngle As Single, sweepAngle As Single)
        DrawArc(pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle)
    End Sub

    Sub DrawArc(pen As Pen, x As Long, y As Long, width As Long, height As Long, startAngle As Single, sweepAngle As Single)
        SetStatus(GdipDrawArcI(nativeGraphics, pen.NativePen, x, y, width, height, startAngle, sweepAngle))
    End Sub

    Sub DrawArc(pen As Pen, ByRef rect As Rectangle, startAngle As Single, sweepAngle As Single)
        DrawArc(pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle)
    End Sub

    Sub DrawBezier(pen As 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)
        SetStatus(GdipDrawBezier(nativeGraphics, pen.NativePen, x1, y1,x2, y2, x3, y3, x4, y4))
    End Sub

    Sub DrawBezier(pen As Pen, ByRef pt1 As PointF, ByRef pt2 As PointF, ByRef pt3 As PointF, ByRef pt4 As PointF)
        DrawBezier(pen, pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y)
    End Sub

    Sub DrawBeziers(pen As Pen, points As *PointF, count As Long)
        SetStatus(GdipDrawBeziers(nativeGraphics, pen.NativePen, points, count))
    End Sub

    Sub DrawBezier(pen As 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)
        SetStatus(GdipDrawBezierI(nativeGraphics, pen.NativePen, x1, y1, x2, y2, x3, y3, x4, y4))
    End Sub

    Sub DrawBezier(pen As Pen, ByRef pt1 As Point, ByRef pt2 As Point, ByRef pt3 As Point, ByRef pt4 As Point)
        DrawBezier(pen, pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y)
    End Sub

    Sub DrawBeziers(pen As Pen, points As *Point, count As Long)
        SetStatus(GdipDrawBeziersI(nativeGraphics, pen.NativePen, points, count))
    End Sub

    Sub DrawRectangle(pen As Pen, ByRef rect As RectangleF)
        DrawRectangle(pen, rect.X, rect.Y, rect.Width, rect.Height)
    End Sub

    Sub DrawRectangle(pen As Pen, x As Single, y As Single, width As Single, height As Single)
        SetStatus(GdipDrawRectangle(nativeGraphics, pen.NativePen, x, y, width, height))
    End Sub

    Sub DrawRectangles(pen As Pen, rects As *RectangleF, count As Long)
        SetStatus(GdipDrawRectangles(nativeGraphics, pen.NativePen, rects, count))
    End Sub

    Sub DrawRectangle(pen As Pen, ByRef rect As Rectangle)
        DrawRectangle(pen, rect.X, rect.Y, rect.Width, rect.Height)
    End Sub

    Sub DrawRectangle(pen As Pen, x As Long, y As Long, width As Long, height As Long)
        SetStatus(GdipDrawRectangleI(nativeGraphics, pen.NativePen, x, y, width, height))
    End Sub

    Sub DrawRectangles(pen As Pen, rects As *Rectangle, count As Long)
        SetStatus(GdipDrawRectanglesI(nativeGraphics, pen.NativePen, rects, count))
    End Sub

    Sub DrawEllipse(pen As Pen, ByRef rect As RectangleF)
        DrawEllipse(pen, rect.X, rect.Y, rect.Width, rect.Height)
    End Sub

    Sub DrawEllipse(pen As Pen, x As Single, y As Single, width As Single, height As Single)
        SetStatus(GdipDrawEllipse(nativeGraphics, pen.NativePen, x, y, width, height))
    End Sub

    Sub DrawEllipse(pen As Pen, ByRef rect As Rectangle)
        DrawEllipse(pen, rect.X, rect.Y, rect.Width, rect.Height)
    End Sub

    Sub DrawEllipse(pen As Pen, x As Long, y As Long, width As Long, height As Long)
        SetStatus(GdipDrawEllipseI(nativeGraphics, pen.NativePen, x, y, width, height))
    End Sub

    Sub DrawPie(pen As Pen, ByRef rect As RectangleF, startAngle As Single, sweepAngle As Single)
        DrawPie(pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle)
    End Sub

    Sub DrawPie(pen As Pen, x As Single, y As Single, width As Single, height As Single, startAngle As Single, sweepAngle As Single)
        SetStatus(GdipDrawPie(nativeGraphics, pen.NativePen, x, y, width, height, startAngle, sweepAngle))
    End Sub

    Sub DrawPie(pen As Pen, ByRef rect As Rectangle, startAngle As Single, sweepAngle As Single)
        DrawPie(pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle)
    End Sub

    Sub DrawPie(pen As Pen, x As Long, y As Long, width As Long, height As Long, startAngle As Single, sweepAngle As Single)
        SetStatus(GdipDrawPieI(nativeGraphics, pen.NativePen, x, y, width, height, startAngle, sweepAngle))
    End Sub

    Sub DrawPolygon(pen As Pen, points As *PointF, count As Long)
        SetStatus(GdipDrawPolygon(nativeGraphics, pen.NativePen, points, count))
    End Sub

    Sub DrawPolygon(pen As Pen, points As *Point, count As Long)
        SetStatus(GdipDrawPolygonI(nativeGraphics, pen.NativePen, points, count))
    End Sub

    Sub DrawPath(pen As Pen, path As GraphicsPath)
        If ActiveBasic.IsNothing(pen) Or ActiveBasic.IsNothing(path) Then
            Throw New ArgumentNullException("pen or path or both")
        End If
        SetStatus(GdipDrawPath(nativeGraphics, pen.NativePen, path.nativePath))
    End Sub

    Sub DrawCurve(pen As Pen, points As *PointF, count As Long)
        SetStatus(GdipDrawCurve(nativeGraphics, pen.NativePen, points, count))
    End Sub

    Sub DrawCurve(pen As Pen, points As *PointF, count As Long, tension As Single)
        SetStatus(GdipDrawCurve2(nativeGraphics, pen.NativePen, points,count, tension))
    End Sub

    Sub DrawCurve(pen As Pen, points As *PointF, count As Long, offset As Long, numberOfSegments As Long)
        SetStatus(GdipDrawCurve3(nativeGraphics, pen.NativePen, points, count, offset,numberOfSegments, 0.5))
    End Sub

    Sub DrawCurve(pen As Pen, points As *PointF, count As Long, offset As Long, numberOfSegments As Long, tension As Single)
        SetStatus(GdipDrawCurve3(nativeGraphics, pen.NativePen, points, count, offset,numberOfSegments, tension))
    End Sub

    Sub DrawCurve(pen As Pen, points As *Point, count As Long)
        SetStatus(GdipDrawCurveI(nativeGraphics, pen.NativePen, points, count))
    End Sub

    Sub DrawCurve(pen As Pen, points As *Point, count As Long, tension As Single)
        SetStatus(GdipDrawCurve2I(nativeGraphics, pen.NativePen, points, count, tension))
    End Sub

    Sub DrawCurve(pen As Pen, points As *Point, count As Long, offset As Long, numberOfSegments As Long)
        SetStatus(GdipDrawCurve3I(nativeGraphics, pen.NativePen, points, count, offset, numberOfSegments, 0.5))
    End Sub

    Sub DrawCurve(pen As Pen, points As *Point, count As Long, offset As Long, numberOfSegments As Long, tension As Single)
        SetStatus(GdipDrawCurve3I(nativeGraphics, pen.NativePen, points, count, offset, numberOfSegments, tension))
    End Sub

    Sub DrawClosedCurve(pen As Pen, points As *PointF, count As Long)
        SetStatus(GdipDrawClosedCurve(nativeGraphics, pen.NativePen, points, count))
    End Sub

    Sub DrawClosedCurve(pen As Pen, points As *PointF, count As Long, tension As Single)
        SetStatus(GdipDrawClosedCurve2(nativeGraphics, pen.NativePen, points, count, tension))
    End Sub

    Sub DrawClosedCurve(pen As Pen, points As *Point, count As Long)
        SetStatus(GdipDrawClosedCurveI(nativeGraphics, pen.NativePen, points, count))
    End Sub

    Sub DrawClosedCurve(pen As Pen, points As *Point, count As Long, tension As Single)
        SetStatus(GdipDrawClosedCurve2I(nativeGraphics, pen.NativePen, points, count, tension))
    End Sub

    Sub Clear(color As Color)
        SetStatus(GdipGraphicsClear(nativeGraphics, color))
    End Sub

    Sub FillRectangle(brush As Brush, ByRef rect As RectangleF)
        FillRectangle(brush, rect.X, rect.Y, rect.Width, rect.Height)
    End Sub

    Sub FillRectangle(brush As Brush, x As Single, y As Single, width As Single, height As Single)
        SetStatus(GdipFillRectangle(nativeGraphics, brush.NativeBrush, x, y, width, height))
    End Sub

    Sub FillRectangles(brush As Brush, rects As *RectangleF, count As Long)
        SetStatus(GdipFillRectangles(nativeGraphics,brush.NativeBrush,rects, count))
    End Sub

    Sub FillRectangle(brush As Brush, ByRef rect As Rectangle)
        FillRectangle(brush, rect.X, rect.Y, rect.Width, rect.Height)
    End Sub

    Sub FillRectangle(brush As Brush, x As Long, y As Long, width As Long, height As Long)
        SetStatus(GdipFillRectangleI(nativeGraphics, brush.NativeBrush, x, y, width, height))
    End Sub

    Sub FillRectangles(brush As Brush, rects As *Rectangle, count As Long)
        SetStatus(GdipFillRectanglesI(nativeGraphics, brush.NativeBrush, rects, count))
    End Sub

'   Sub FillPolygon(brush As Brush, points As *PointF, count As Long)
'       FillPolygon(brush, points, count, System.Drawing.Drawing2D.FillMode.Alternate)
'   End Sub

    Sub FillPolygon(brush As Brush, points As *PointF, count As Long, fillMode As Drawing2D.FillMode)
        SetStatus(GdipFillPolygon(nativeGraphics, brush.NativeBrush, points, count, fillMode))
    End Sub

'   Sub FillPolygon(brush As Brush, points As *Point, count As Long)
'       FillPolygon(brush, points, count, System.Drawing.Drawing2D.FillMode.Alternate)
'   End Sub

    Sub FillPolygon(brush As Brush, points As *Point, count As Long, fillMode As Drawing2D.FillMode)
        SetStatus(GdipFillPolygonI(nativeGraphics, brush.NativeBrush, points, count, fillMode))
    End Sub

    Sub FillEllipse(brush As Brush, ByRef rect As RectangleF)
        FillEllipse(brush, rect.X, rect.Y, rect.Width, rect.Height)
    End Sub

    Sub FillEllipse(brush As Brush, x As Single, y As Single, width As Single, height As Single)
        SetStatus(GdipFillEllipse(nativeGraphics, brush.NativeBrush, x, y, width, height))
    End Sub

    Sub FillEllipse(brush As Brush, ByRef rect As Rectangle)
        FillEllipse(brush, rect.X, rect.Y, rect.Width, rect.Height)
    End Sub

    Sub FillEllipse(brush As Brush, x As Long, y As Long, width As Long, height As Long)
        SetStatus(GdipFillEllipseI(nativeGraphics, brush.NativeBrush, x, y, width, height))
    End Sub

    Sub FillPie(brush As Brush, ByRef rect As RectangleF, startAngle As Single, sweepAngle As Single)
        FillPie(brush, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle)
    End Sub

    Sub FillPie(brush As Brush, x As Single, y As Single, width As Single, height As Single, startAngle As Single, sweepAngle As Single)
        SetStatus(GdipFillPie(nativeGraphics, brush.NativeBrush, x, y, width, height, startAngle, sweepAngle))
    End Sub

    Sub FillPie(brush As Brush, ByRef rect As Rectangle, startAngle As Single, sweepAngle As Single)
        FillPie(brush, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle)
    End Sub

    Sub FillPie(brush As Brush, x As Long, y As Long, width As Long, height As Long, startAngle As Single, sweepAngle As Single)
        SetStatus(GdipFillPieI(nativeGraphics, brush.NativeBrush, x, y, width, height, startAngle, sweepAngle))
    End Sub

    Sub FillPath(brush As Brush, path As GraphicsPath)
        If ActiveBasic.IsNothing(brush) Or ActiveBasic.IsNothing(path) Then
            Throw New ArgumentNullException("brush or path or both")
        End If
        SetStatus(GdipFillPath(nativeGraphics, brush.NativeBrush, path.nativePath))
    End Sub

    Sub FillClosedCurve(brush As Brush, points As *PointF, count As Long)
        SetStatus(GdipFillClosedCurve(nativeGraphics, brush.NativeBrush, points, count))
    End Sub

    Sub FillClosedCurve(brush As Brush, points As *PointF, count As Long, fillMode As Drawing2D.FillMode)
        SetStatus(GdipFillClosedCurve2(nativeGraphics, brush.NativeBrush, points, count, 0.5, fillMode))
    End Sub

    Sub FillClosedCurve(brush As Brush, points As *PointF, count As Long, fillMode As Drawing2D.FillMode, tension As Single)
        SetStatus(GdipFillClosedCurve2(nativeGraphics, brush.NativeBrush, points, count, tension, fillMode))
    End Sub

    Sub FillClosedCurve(brush As Brush, points As *Point, count As Long)
        SetStatus(GdipFillClosedCurveI(nativeGraphics, brush.NativeBrush, points, count))
    End Sub

    Sub FillClosedCurve(brush As Brush, points As *Point, count As Long, fillMode As Drawing2D.FillMode)
        SetStatus(GdipFillClosedCurve2I(nativeGraphics, brush.NativeBrush, points, count, 0.5, fillMode))
    End Sub

    Sub FillClosedCurve(brush As Brush, points As *Point, count As Long, fillMode As Drawing2D.FillMode, tension As Single)
        SetStatus(GdipFillClosedCurve2I(nativeGraphics, brush.NativeBrush, points, count, tension, fillMode))
    End Sub

    Sub FillRegion(brush As Brush, region As Region)
        SetStatus(GdipFillRegion(nativeGraphics, brush.NativeBrush, region.nativeRegion))
    End Sub

'DrawStringは次の組み合わせからなる。
'(PCWSTR, Long) or String
'PointF or (Single, Single) or Rectangle
'StringFormatの有無
    Sub DrawString(str As PCWSTR, length As Long, font As Font, brush As Brush, ByRef origin As PointF, stringFormat = Nothing As StringFormat)
        DrawString(str, length, font, brush, origin.X, origin.Y, stringFormat)
    End Sub

    Sub DrawString(str As PCWSTR, length As Long, font As Font, brush As Brush, x As Single, y As Single, stringFormat = Nothing As StringFormat)
        Dim rc As RectangleF
        rc.X = x
        rc.Y = y
        rc.Width = 0
        rc.Height = 0
        DrawString(str, length, font, brush, rc, stringFormat)
    End Sub

    Sub DrawString(str As PCWSTR, length As Long, font As Font, brush As Brush, ByRef layoutRect As RectangleF, stringFormat = Nothing As StringFormat)
        Dim nativeFont = getNativeFont(font)
        Dim nativeFormat = GetNativeStringFormat(stringFormat)
        Dim nativeBrush = getNativeBrush(brush)
        SetStatus(GdipDrawString(nativeGraphics, str, length, nativeFont, layoutRect, nativeFormat, nativeBrush))
    End Sub

    Sub DrawString(s As String, font As Font, brush As Brush, ByRef origin As PointF, stringFormat = Nothing As StringFormat)
        DrawString(s, font, brush, origin.X, origin.Y, stringFormat)
    End Sub

    Sub DrawString(s As String, font As Font, brush As Brush, x As Single, y As Single, stringFormat = Nothing As StringFormat)
        Dim rc As RectangleF
        rc.X = x
        rc.Y = y
        rc.Width = 0
        rc.Height = 0
        DrawString(s, font, brush, rc, stringFormat)
    End Sub

    Sub DrawString(s As String, font As Font, brush As Brush, ByRef layoutRect As RectangleF, stringFormat = Nothing As StringFormat)
        Dim wcs As PCWSTR
        Dim len = GetStr(s, wcs) As Long
        DrawString(wcs, len As Long, font, brush, layoutRect, stringFormat)
    End Sub

    Function MeasureString(s As String, font As Font) As SizeF
        Dim pt As PointF
        MeasureString = MeasureString(s, font, pt, Nothing)
    End Function

    Function MeasureString(s As String, font As Font, ByRef layoutRectSize As SizeF) As SizeF
        MeasureString = MeasureString(s, font, layoutRectSize, Nothing)
    End Function

    Function MeasureString(s As String, font As Font, ByRef layoutRectSize As SizeF, stringFormat As StringFormat) As SizeF
        Dim wcs As PCWSTR
        Dim len = GetStr(s, wcs) As Long
        MeasureString = MeasureString(wcs, len, font, layoutRectSize, stringFormat)
    End Function

    Function MeasureString(s As String, font As Font, ByRef origin As PointF, stringFormat As StringFormat) As SizeF
        Dim wcs As PCWSTR
        Dim len = GetStr(s, wcs) As Long
        MeasureString = MeasureString(wcs, len, font, origin, stringFormat)
    End Function

    Function MeasureString(s As String, font As Font, width As Long, stringFormat As StringFormat) As SizeF
        Dim wcs As PCWSTR
        Dim len = GetStr(s, wcs) As Long
        MeasureString = MeasureString(wcs, len, font, width, stringFormat)
    End Function

    Function MeasureString(s As String, font As Font, ByRef layoutRectSize As SizeF, stringFormat As StringFormat, ByRef codepointsFitted As Long, ByRef linesFilled As Long) As SizeF
        Dim wcs As PCWSTR
        Dim len = GetStr(s, wcs) As Long
        MeasureString = MeasureString(wcs, len, font, layoutRectSize, stringFormat, codepointsFitted, linesFilled)
    End Function

    Function MeasureString(str As PCWSTR, length As Long, font As Font) As SizeF
        Dim pt As PointF
        MeasureString = MeasureString(str, length, font, pt, Nothing)
    End Function

    Function MeasureString(str As PCWSTR, length As Long, font As Font, ByRef layoutRectSize As SizeF) As SizeF
        MeasureString = MeasureString(str, length, font, layoutRectSize, Nothing)
    End Function

    Function MeasureString(str As PCWSTR, length As Long, font As Font, ByRef layoutRectSize As SizeF, stringFormat As StringFormat) As SizeF
        MeasureString = measureStringPt(str, length, font, layoutRectSize, stringFormat, 0, 0)
    End Function

    Function MeasureString(str As PCWSTR, length As Long, font As Font, ByRef origin As PointF, stringFormat As StringFormat) As SizeF
        Dim layoutRect As RectangleF
        With layoutRect
            .X = origin.X
            .Y = origin.Y
            .Width = 0
            .Height = 0
        End With
        MeasureString = measureString(str, length, font, layoutRect, stringFormat, 0, 0)
    End Function

    Function MeasureString(str As PCWSTR, length As Long, font As Font, width As Long, stringFormat As StringFormat) As SizeF
        Dim layoutRect As RectangleF
        With layoutRect
            .X = 0
            .Y = 0
            .Width = width
            .Height = 0
        End With
        MeasureString = measureString(str, length, font, layoutRect, stringFormat, 0, 0)
    End Function

    Function MeasureString(str As PCWSTR, length As Long, font As Font, ByRef layoutRectSize As SizeF, stringFormat As StringFormat, ByRef codepointsFitted As Long, ByRef linesFilled As Long) As SizeF
        MeasureString = measureStringPt(str, length, font, layoutRectSize, stringFormat, VarPtr(codepointsFitted), VarPtr(linesFilled))
    End Function

Private
    Function measureStringPt(str As PCWSTR, length As Long, font As Font, ByRef layoutRectSize As SizeF, stringFormat As StringFormat, codepointsFitted As *Long, linesFilled As *Long) As SizeF
        Dim layoutRect As RectangleF
        With layoutRect
            .X = 0
            .Y = 0
            .Width = layoutRectSize.Width
            .Height = layoutRectSize.Height
        End With
        measureStringPt = measureString(str, length, font, layoutRect, stringFormat, codepointsFitted, linesFilled)
    End Function

    Function measureString(str As PCWSTR, length As Long, font As Font, ByRef layoutRect As RectangleF, stringFormat As StringFormat, codepointsFitted As *Long, linesFilled As *Long) As SizeF
        Dim nativeFont = getNativeFont(font)
        Dim nativeFormat = GetNativeStringFormat(stringFormat)
        Dim boundingBox As RectangleF
        SetStatus(GdipMeasureString(nativeGraphics, str, length, nativeFont, layoutRect, nativeFormat, boundingBox, codepointsFitted, linesFilled))
        measureString.Width = boundingBox.Width
        measureString.Height = boundingBox.Height
    End Function

Public

    Function MeasureCharacterRanges(s As String, font As Font, ByRef layoutRect As RectangleF, stringFormat As StringFormat) As System.Collections.Generic.IList<Region>
        Dim wcs As PCWSTR
        Dim len = GetStr(s, wcs)
        MeasureCharacterRanges = MeasureCharacterRanges(wcs, len, font, layoutRect, stringFormat)
    End Function

    Function MeasureCharacterRanges(str As PCWSTR, length As Long, font As Font, ByRef layoutRect As RectangleF, stringFormat As StringFormat) As System.Collections.Generic.IList<Region>
        If ActiveBasic.IsNothing(stringFormat) Then
            stringFormat = New StringFormat
        End If
        Dim count As Long
        SetStatus(GdipGetStringFormatMeasurableCharacterRangeCount(stringFormat.NativeFormat, count))
        Dim nativeRegions As **GpRegion 'ここで = GC_mallocとすると、エラーになる。
        nativeRegions = GC_malloc(count * SizeOf(*GpRegion))
        Dim regions = New System.Collections.Generic.List<Region>(count)
        MeasureCharacterRanges = regions

        Dim i As Long
        For i = 0 To ELM(count)
            Dim t = regions[i]
            nativeRegions[i] = t.nativeRegion
        Next
        Dim nativeFont = getNativeFont(font)
        SetStatus(GdipMeasureCharacterRanges(nativeGraphics, str, length, nativeFont, layoutRect, stringFormat.NativeFormat, count, nativeRegions))
    End Function

    'DrawDriverString
    'MeasureDriverString

    Sub DrawCachedBitmap(cb As CachedBitmap, x As Long, y As Long)
        SetStatus(GdipDrawCachedBitmap(nativeGraphics, cb.nativeCachedBitmap, x, y))
    End Sub

    Sub DrawImage(image As Image, ByRef point As PointF)
        DrawImage(image, point.X, point.Y)
    End Sub

    Sub DrawImage(image As Image, x As Single, y As Single)
        Dim nativeImage = getNativeImage(image)
        SetStatus(GdipDrawImage(nativeGraphics, nativeImage, x, y))
    End Sub

    Sub DrawImage(image As Image, ByRef rect As RectangleF)
        DrawImage(image, rect.X, rect.Y, rect.Width, rect.Height)
    End Sub

    Sub DrawImage(image As Image, x As Single, y As Single, width As Single, height As Single)
        Dim nativeImage = getNativeImage(image)
        SetStatus(GdipDrawImageRect(nativeGraphics, nativeImage, x, y, width, height))
    End Sub

    Sub DrawImage(image As Image, ByRef point As Point)
        DrawImage(image, point.X, point.Y)
    End Sub

    Sub DrawImage(image As Image, x As Long, y As Long)
        Dim nativeImage = getNativeImage(image)
        SetStatus(GdipDrawImageI(nativeGraphics, nativeImage, x, y))
    End Sub

    Sub DrawImage(image As Image, ByRef rect As Rectangle)
        DrawImage(image, rect.X, rect.Y, rect.Width, rect.Height)
    End Sub

    Sub DrawImage(image As Image, x As Long, y As Long, width As Long, height As Long)
        Dim nativeImage = getNativeImage(image)
        SetStatus(GdipDrawImageRectI(nativeGraphics, nativeImage, x, y, width, height))
    End Sub

    ' 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

    Sub DrawImage(image As Image, destPoints As *PointF, count As Long)
        If count <> 3 And count <> 4 Then
            SetStatus(InvalidParameter)
        End If

        Dim nativeImage = getNativeImage(image)
        SetStatus(GdipDrawImagePoints(nativeGraphics, nativeImage, destPoints, count))
    End Sub

    Sub DrawImage(image As Image, destPoints As *Point, count As Long)
        If count <> 3 And count <> 4 Then
            SetStatus(InvalidParameter)
        End If

        Dim nativeImage = getNativeImage(image)
        SetStatus(GdipDrawImagePointsI(nativeGraphics, nativeImage, destPoints, count))
    End Sub

    Sub DrawImage(image As Image, ByRef destRect As Rectangle, ByRef src As Rectangle, srcUnit As GraphicsUnit)
        DrawImage(image, destRect, src.X, src.Y, src.Width, src.Height, srcUnit)
    End Sub

    Sub DrawImage(image As Image, ByRef destRect As RectangleF, ByRef src As RectangleF, srcUnit As GraphicsUnit)
        DrawImage(image, destRect, src.X, src.Y, src.Width, src.Height, srcUnit)
    End Sub

    Sub DrawImage(image As Image, x As Long, y As Long, ByRef src As Rectangle, srcUnit As GraphicsUnit)
        Dim nativeImage = getNativeImage(image)
        SetStatus(GdipDrawImagePointRectI(nativeGraphics, nativeImage, x, y, src.X, src.Y, src.Width, src.Height, srcUnit))
    End Sub

    Sub DrawImage(image As Image, x As Single, y As Single, ByRef src As RectangleF, srcUnit As GraphicsUnit)
        Dim nativeImage = getNativeImage(image)
        SetStatus(GdipDrawImagePointRect(nativeGraphics, nativeImage, x, y, src.X, src.Y, src.Width, src.Height, srcUnit))
    End Sub

    Sub DrawImage(image As Image, destPoints As *Point, count As Long, ByRef src As Rectangle, srcUnit As GraphicsUnit, _
        imageAttr = Nothing As ImageAttributes, callback = Nothing As DrawImageAbort, callbackData = 0 As VoidPtr)

        Dim nativeImage = getNativeImage(image)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        SetStatus(GdipDrawImagePointsRectI(nativeGraphics, nativeImage, destPoints, count,
            src.X, src.Y, src.Width, src.Height, srcUnit, nativeImageAttr, callback, callbackData))
    End Sub

    Sub DrawImage(image As Image, destPoints As *PointF, count As Long, ByRef src As RectangleF, srcUnit As GraphicsUnit,
        imageAttr = Nothing As ImageAttributes, callback = Nothing As DrawImageAbort, callbackData = 0 As VoidPtr)

        Dim nativeImage = getNativeImage(image)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        SetStatus(GdipDrawImagePointsRect(nativeGraphics, nativeImage, destPoints, count,
            src.X, src.Y, src.Width, src.Height, srcUnit, nativeImageAttr, callback, callbackData))
    End Sub

    Sub DrawImage(image As Image, ByRef destRect As RectangleF,
        srcx As Single, srcy As Single, srcwidth As Single, srcheight As Single, srcUnit As GraphicsUnit,
        imageAttr = Nothing As ImageAttributes, callback = Nothing As DrawImageAbort, callbackData = 0 As VoidPtr)

        Dim nativeImage = getNativeImage(image)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        SetStatus(GdipDrawImageRectRect(nativeGraphics, nativeImageAttr,
            destRect.X, destRect.Y, destRect.Width, destRect.Height, srcx, srcy, srcwidth, srcheight,
            srcUnit, nativeImageAttr, callback, callbackData))
    End Sub

    Sub DrawImage(image As Image, ByRef destRect As Rectangle,
        srcx As Long, srcy As Long, srcwidth As Long, srcheight As Long, srcUnit As GraphicsUnit,
        imageAttr = Nothing As ImageAttributes, callback = Nothing As DrawImageAbort, callbackData = 0 As VoidPtr)

        Dim nativeImage = getNativeImage(image)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        SetStatus(GdipDrawImageRectRectI(nativeGraphics, nativeImage,
            destRect.X, destRect.Y, destRect.Width, destRect.Height,
            srcx, srcy, srcwidth, srcheight, srcUnit, nativeImageAttr, callback, callbackData))
    End Sub

    Sub EnumerateMetafile(metafile As Imaging.Metafile, ByRef destPoint As PointF,
        callback As EnumerateMetafileProc, callbackData = 0 As VoidPtr, imageAttr = Nothing As ImageAttributes)

        Dim nativeImage = getNativeImage(metafile)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        Dim procData As Detail.EnumerateMetafileProcData
        procData.Proc = callback
        procData.Data = callbackData
        SetStatus(GdipEnumerateMetafileDestPoint(nativeGraphics,
            nativeImage, destPoint, AddressOf(Detail.NativeEnumerateMetafileProcEntry), VarPtr(procData), nativeImageAttr))
    End Sub

    Sub EnumerateMetafile(metafile As Imaging.Metafile, ByRef destPoint As Point,
        callback As EnumerateMetafileProc, callbackData = 0 As VoidPtr, imageAttr = Nothing As ImageAttributes)

        Dim nativeImage = getNativeImage(metafile)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        Dim procData As Detail.EnumerateMetafileProcData
        procData.Proc = callback
        procData.Data = callbackData
        SetStatus(GdipEnumerateMetafileDestPointI(nativeGraphics,
            nativeImage, destPoint, AddressOf(Detail.NativeEnumerateMetafileProcEntry), VarPtr(procData), nativeImageAttr))
    End Sub

    Sub EnumerateMetafile(metafile As Imaging.Metafile, ByRef destRect As RectangleF,
        callback As EnumerateMetafileProc, callbackData = 0 As VoidPtr, imageAttr = Nothing As ImageAttributes)

        Dim nativeImage = getNativeImage(metafile)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        Dim procData As Detail.EnumerateMetafileProcData
        procData.Proc = callback
        procData.Data = callbackData
        SetStatus(GdipEnumerateMetafileDestRect(nativeGraphics,
            nativeImage, destRect, AddressOf(Detail.NativeEnumerateMetafileProcEntry), VarPtr(procData), nativeImageAttr))
    End Sub

    Sub EnumerateMetafile(metafile As Imaging.Metafile, ByRef destRect As Rectangle,
        callback As EnumerateMetafileProc, callbackData = 0 As VoidPtr, imageAttr = Nothing As ImageAttributes)

        Dim nativeImage = getNativeImage(metafile)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        Dim procData As Detail.EnumerateMetafileProcData
        procData.Proc = callback
        procData.Data = callbackData
        SetStatus(GdipEnumerateMetafileDestRectI(nativeGraphics,
            nativeImage, destRect, AddressOf(Detail.NativeEnumerateMetafileProcEntry), VarPtr(procData), nativeImageAttr))
    End Sub

    Sub EnumerateMetafile(metafile As Imaging.Metafile, destPoints As *PointF, count As Long,
        callback As EnumerateMetafileProc, callbackData = 0 As VoidPtr, imageAttr = Nothing As ImageAttributes)

        Dim nativeImage = getNativeImage(metafile)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        Dim procData As Detail.EnumerateMetafileProcData
        procData.Proc = callback
        procData.Data = callbackData
        SetStatus(GdipEnumerateMetafileDestPoints(nativeGraphics,
            nativeImage,destPoints, count, AddressOf(Detail.NativeEnumerateMetafileProcEntry), VarPtr(procData), nativeImageAttr))
    End Sub

    Sub EnumerateMetafile(metafile As Imaging.Metafile, destPoints As *Point, count As Long,
        callback As EnumerateMetafileProc, callbackData = 0 As VoidPtr, imageAttr = Nothing As ImageAttributes)

        Dim nativeImage = getNativeImage(metafile)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        Dim procData As Detail.EnumerateMetafileProcData
        procData.Proc = callback
        procData.Data = callbackData
        SetStatus(GdipEnumerateMetafileDestPointsI(nativeGraphics,
            nativeImage,destPoints, count, AddressOf(Detail.NativeEnumerateMetafileProcEntry), VarPtr(procData), nativeImageAttr))
    End Sub

    Sub EnumerateMetafile(metafile As Imaging.Metafile,
        ByRef destPoint As PointF, ByRef srcRect As RectangleF, srcUnit As GraphicsUnit,
        callback As EnumerateMetafileProc, callbackData = 0 As VoidPtr, imageAttr = Nothing As ImageAttributes)

        Dim nativeImage = getNativeImage(metafile)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        Dim procData As Detail.EnumerateMetafileProcData
        procData.Proc = callback
        procData.Data = callbackData
        SetStatus(GdipEnumerateMetafileSrcRectDestPoint(nativeGraphics,
            nativeImage, destPoint, srcRect, srcUnit, AddressOf(Detail.NativeEnumerateMetafileProcEntry), VarPtr(procData), nativeImageAttr))
    End Sub

    Sub EnumerateMetafile(metafile As Imaging.Metafile,
        ByRef destPoint As Point, ByRef srcRect As Rectangle, srcUnit As GraphicsUnit,
        callback As EnumerateMetafileProc, callbackData = 0 As VoidPtr, imageAttr = Nothing As ImageAttributes)

        Dim nativeImage = getNativeImage(metafile)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        Dim procData As Detail.EnumerateMetafileProcData
        procData.Proc = callback
        procData.Data = callbackData
        SetStatus(GdipEnumerateMetafileSrcRectDestPointI(nativeGraphics,
            nativeImage, destPoint, srcRect, srcUnit, AddressOf(Detail.NativeEnumerateMetafileProcEntry), VarPtr(procData), nativeImageAttr))
    End Sub

    Sub EnumerateMetafile(metafile As Imaging.Metafile,
        ByRef destRect As RectangleF, ByRef srcRect As RectangleF, srcUnit As GraphicsUnit,
        callback As EnumerateMetafileProc, callbackData = 0 As VoidPtr, imageAttr = Nothing As ImageAttributes)

        Dim nativeImage = getNativeImage(metafile)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        Dim procData As Detail.EnumerateMetafileProcData
        procData.Proc = callback
        procData.Data = callbackData
        SetStatus(GdipEnumerateMetafileSrcRectDestRect(nativeGraphics,
            nativeImage, destRect, srcRect, srcUnit, AddressOf(Detail.NativeEnumerateMetafileProcEntry), VarPtr(procData), nativeImageAttr))
    End Sub

    Sub EnumerateMetafile(metafile As Imaging.Metafile,
        ByRef destRect As Rectangle, ByRef srcRect As Rectangle, srcUnit As GraphicsUnit,
        callback As EnumerateMetafileProc, callbackData = 0 As VoidPtr, imageAttr = Nothing As ImageAttributes)

        Dim nativeImage = getNativeImage(metafile)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        Dim procData As Detail.EnumerateMetafileProcData
        procData.Proc = callback
        procData.Data = callbackData
        SetStatus(GdipEnumerateMetafileSrcRectDestRectI(nativeGraphics,
            nativeImage, destRect, srcRect, srcUnit, AddressOf(Detail.NativeEnumerateMetafileProcEntry), VarPtr(procData), nativeImageAttr))
    End Sub

    Sub EnumerateMetafile(metafile As Imaging.Metafile,
        destPoints As *PointF, count As Long, ByRef srcRect As RectangleF, srcUnit As GraphicsUnit,
        callback As EnumerateMetafileProc, callbackData = 0 As VoidPtr, imageAttr = Nothing As ImageAttributes)

        Dim nativeImage = getNativeImage(metafile)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        Dim procData As Detail.EnumerateMetafileProcData
        procData.Proc = callback
        procData.Data = callbackData
        SetStatus(GdipEnumerateMetafileSrcRectDestPoints(nativeGraphics,
            nativeImage, destPoints, count, srcRect, srcUnit, AddressOf(Detail.NativeEnumerateMetafileProcEntry), VarPtr(procData), nativeImageAttr))
    End Sub

    Sub EnumerateMetafile(metafile As Imaging.Metafile,
        destPoints As *Point, count As Long, ByRef srcRect As Rectangle, srcUnit As GraphicsUnit,
        callback As EnumerateMetafileProc, callbackData = 0 As VoidPtr, imageAttr = Nothing As ImageAttributes)

        Dim nativeImage = getNativeImage(metafile)
        Dim nativeImageAttr = getNativeImageAttributes(imageAttr)
        Dim procData As Detail.EnumerateMetafileProcData
        procData.Proc = callback
        procData.Data = callbackData
        SetStatus(GdipEnumerateMetafileSrcRectDestPointsI(nativeGraphics, nativeImage,
            destPoints, count, srcRect, srcUnit, AddressOf(Detail.NativeEnumerateMetafileProcEntry), VarPtr(procData), nativeImageAttr))
    End Sub

    Sub SetClip(g As Graphics)
        SetClip(g, System.Drawing.Drawing2D.CombineMode.Replace)
    End Sub

    Sub SetClip(g As Graphics, combineMode As Drawing2D.CombineMode)
        SetStatus(GdipSetClipGraphics(nativeGraphics, g.nativeGraphics, combineMode))
    End Sub

    Sub SetClip(ByRef rc As RectangleF)
        SetClip(rc, System.Drawing.Drawing2D.CombineMode.Replace)
    End Sub

    Sub SetClip(ByRef rc As RectangleF, combineMode As Drawing2D.CombineMode)
        SetStatus(GdipSetClipRect(nativeGraphics, rc.X, rc.Y, rc.Width, rc.Height, combineMode))
    End Sub

    Sub SetClip(ByRef rc As Rectangle)
        SetClip(rc, System.Drawing.Drawing2D.CombineMode.Replace)
    End Sub

    Sub SetClip(ByRef rc As Rectangle, combineMode As Drawing2D.CombineMode)
        SetStatus(GdipSetClipRectI(nativeGraphics, rc.X, rc.Y, rc.Width, rc.Height, combineMode))
    End Sub

    Sub SetClip(path As GraphicsPath)
        SetClip(path, System.Drawing.Drawing2D.CombineMode.Replace)
    End Sub

    Sub SetClip(path As GraphicsPath, combineMode As Drawing2D.CombineMode)
        SetStatus(GdipSetClipPath(nativeGraphics, path.nativePath, combineMode))
    End Sub

    Sub SetClip(region As Region)
        SetClip(region, System.Drawing.Drawing2D.CombineMode.Replace)
    End Sub

    Sub SetClip(region As Region, combineMode As Drawing2D.CombineMode)
        SetStatus(GdipSetClipRegion(nativeGraphics, region.nativeRegion, combineMode))
    End Sub

    Sub SetClip(hrgn As HRGN)
        SetClip(hrgn, System.Drawing.Drawing2D.CombineMode.Replace)
    End Sub

    Sub SetClip(hrgn As HRGN, combineMode As Drawing2D.CombineMode)
        SetStatus(GdipSetClipHrgn(nativeGraphics, hrgn, combineMode))
    End Sub

    Sub IntersectClip(ByRef rc As RectangleF)
        SetStatus(GdipSetClipRect(nativeGraphics, rc.X, rc.Y, rc.Width, rc.Height, System.Drawing.Drawing2D.CombineMode.Intersect))
    End Sub

    Sub IntersectClip(ByRef rc As Rectangle)
        SetStatus(GdipSetClipRectI(nativeGraphics, rc.X, rc.Y, rc.Width, rc.Height, System.Drawing.Drawing2D.CombineMode.Intersect))
    End Sub

    Sub IntersectClip(region As Region)
        SetStatus(GdipSetClipRegion(nativeGraphics, region.nativeRegion, System.Drawing.Drawing2D.CombineMode.Intersect))
    End Sub

    Sub ExcludeClip(ByRef rc As RectangleF)
        SetStatus(GdipSetClipRect(nativeGraphics, rc.X, rc.Y, rc.Width, rc.Height, System.Drawing.Drawing2D.CombineMode.Exclude))
    End Sub

    Sub ExcludeClip(ByRef rc As Rectangle)
        SetStatus(GdipSetClipRectI(nativeGraphics, rc.X, rc.Y, rc.Width, rc.Height, System.Drawing.Drawing2D.CombineMode.Exclude))
    End Sub

    Sub ExcludeClip(region As Region)
        SetStatus(GdipSetClipRegion(nativeGraphics, region.nativeRegion, System.Drawing.Drawing2D.CombineMode.Exclude))
    End Sub

    Sub ResetClip()
        SetStatus(GdipResetClip(nativeGraphics))
    End Sub

    Sub TranslateClip(dx As Single, dy As Single)
        SetStatus(GdipTranslateClip(nativeGraphics, dx, dy))
    End Sub

    Sub TranslateClip(dx As Long, dy As Long)
        SetStatus(GdipTranslateClipI(nativeGraphics, dx, dy))
    End Sub

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

    Const Function IsVisible(ByRef pt As Point) As Boolean
        IsVisible(pt.X, pt.Y)
    End Function

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

    Const Function IsVisible(ByRef rc As Rectangle) As Boolean
        IsVisible = IsVisible(rc.X, rc.Y, rc.Width, rc.Height)
    End Function

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

    Const Function IsVisible(ByRef pt As PointF) As Boolean
        IsVisible = IsVisible(pt.X, pt.Y)
    End Function

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

    Const Function IsVisible(ByRef rc As RectangleF) As Boolean
        IsVisible = IsVisible(rc.X, rc.Y, rc.Width, rc.Height)
    End Function

    Const Function Save() As Drawing2D.GraphicsState
        SetStatus(GdipSaveGraphics(nativeGraphics, Save))
    End Function

    Sub Restore(gstate As Drawing2D.GraphicsState)
        SetStatus(GdipRestoreGraphics(nativeGraphics, gstate))
    End Sub

    Function BeginContainer(ByRef dstrect As RectangleF, ByRef srcrect As RectangleF, unit As GraphicsUnit) As Drawing2D.GraphicsContainer
        SetStatus(GdipBeginContainer(nativeGraphics, dstrect, srcrect, unit, BeginContainer))
    End Function

    Function BeginContainer(ByRef dstrect As Rectangle, ByRef srcrect As Rectangle, unit As GraphicsUnit) As Drawing2D.GraphicsContainer
        SetStatus(GdipBeginContainerI(nativeGraphics, dstrect, srcrect, unit, BeginContainer))
    End Function

    Function BeginContainer() As Drawing2D.GraphicsContainer
        SetStatus(GdipBeginContainer2(nativeGraphics, BeginContainer))
    End Function

    Sub EndContainer(state As Drawing2D.GraphicsContainer)
        SetStatus(GdipEndContainer(nativeGraphics, state))
    End Sub

    Sub AddMetafileComment(data As *Byte, sizeData As DWord)
        SetStatus(GdipComment(nativeGraphics, sizeData, data))
    End Sub

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

    Function NativeGraphics() As *GpGraphics
        NativeGraphics = nativeGraphics
    End Function

    Sub Graphics(graphics As *GpGraphics)
        nativeGraphics = graphics
    End Sub

Private
    Static Function getNativePen(pen As Pen) As *GpPen
        If ActiveBasic.IsNothing(pen) Then
            getNativePen = 0
        Else
            getNativePen = pen.NativePen
        End If
    End Function

    Static Function getNativeBrush(br As Brush) As *GpBrush
        If ActiveBasic.IsNothing(br) Then
            getNativeBrush = 0
        Else
            getNativeBrush = br.NativeBrush
        End If
    End Function

    Static Function getNativeFont(font As Font) As *GpFont
        If ActiveBasic.IsNothing(font) Then
            getNativeFont = 0
        Else
            getNativeFont = font.NativeFont
        End If
    End Function

    Static Function getNativeImage(image As Image) As *GpImage
        If ActiveBasic.IsNothing(image) Then
            getNativeImage = 0
        Else
            getNativeImage = image.NativeImage
        End If
    End Function

    Static Function getNativeImageAttributes(imageAttr As ImageAttributes) As *GpImageAttributes
        If ActiveBasic.IsNothing(imageAttr) Then
            getNativeImageAttributes = 0
        Else
            getNativeImageAttributes = imageAttr.nativeImage
        End If
    End Function

    nativeGraphics As *GpGraphics
End Class

End Namespace
End Namespace