gdiplus_path.cpp

Windows Mobile平台上使用GDI+。GDI+功能很强大

            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathLine2I);
        }
        if ( g_GdipAddPathLine2I != NULL )
        {
            status = (*g_GdipAddPathLine2I)(path, points, count);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathArcIPtr)(GpPath *path, INT x, INT y, INT width, INT height,
               REAL startAngle, REAL sweepAngle));
DEFINE_MEMBER(GdipAddPathArcI);

GpStatus WINGDIPAPI
GdipAddPathArcI(GpPath *path, INT x, INT y, INT width, INT height,
                        REAL startAngle, REAL sweepAngle)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathArcI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathArcI);
        }
        if ( g_GdipAddPathArcI != NULL )
        {
            status = (*g_GdipAddPathArcI)(path, x, y, width, height, startAngle, sweepAngle);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathBezierIPtr)(GpPath *path, INT x1, INT y1, INT x2, INT y2,
               INT x3, INT y3, INT x4, INT y4));
DEFINE_MEMBER(GdipAddPathBezierI);

GpStatus WINGDIPAPI
GdipAddPathBezierI(GpPath *path, INT x1, INT y1, INT x2, INT y2,
                           INT x3, INT y3, INT x4, INT y4)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathBezierI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathBezierI);
        }
        if ( g_GdipAddPathBezierI != NULL )
        {
            status = (*g_GdipAddPathBezierI)(path, x1, y1, x2, y2, x3, y3, x4, y4);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathBeziersIPtr)(GpPath *path, GDIPCONST GpPoint *points, INT count));
DEFINE_MEMBER(GdipAddPathBeziersI);

GpStatus WINGDIPAPI
GdipAddPathBeziersI(GpPath *path, GDIPCONST GpPoint *points, INT count)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathBeziersI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathBeziersI);
        }
        if ( g_GdipAddPathBeziersI != NULL )
        {
            status = (*g_GdipAddPathBeziersI)(path, points, count);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathCurveIPtr)(GpPath *path, GDIPCONST GpPoint *points, INT count));
DEFINE_MEMBER(GdipAddPathCurveI);

GpStatus WINGDIPAPI
GdipAddPathCurveI(GpPath *path, GDIPCONST GpPoint *points, INT count)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathCurveI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathCurveI);
        }
        if ( g_GdipAddPathCurveI != NULL )
        {
            status = (*g_GdipAddPathCurveI)(path, points, count);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathCurve2IPtr)(GpPath *path, GDIPCONST GpPoint *points, INT count,
               REAL tension));
DEFINE_MEMBER(GdipAddPathCurve2I);

GpStatus WINGDIPAPI
GdipAddPathCurve2I(GpPath *path, GDIPCONST GpPoint *points, INT count,
                           REAL tension)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathCurve2I == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathCurve2I);
        }
        if ( g_GdipAddPathCurve2I != NULL )
        {
            status = (*g_GdipAddPathCurve2I)(path, points, count, tension);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathCurve3IPtr)(GpPath *path, GDIPCONST GpPoint *points, INT count,
               INT offset, INT numberOfSegments, REAL tension));
DEFINE_MEMBER(GdipAddPathCurve3I);

GpStatus WINGDIPAPI
GdipAddPathCurve3I(GpPath *path, GDIPCONST GpPoint *points, INT count,
                           INT offset, INT numberOfSegments, REAL tension)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathCurve3I == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathCurve3I);
        }
        if ( g_GdipAddPathCurve3I != NULL )
        {
            status = (*g_GdipAddPathCurve3I)(path, points, count, offset, numberOfSegments, tension);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathClosedCurveIPtr)(GpPath *path, GDIPCONST GpPoint *points, INT count));
DEFINE_MEMBER(GdipAddPathClosedCurveI);

GpStatus WINGDIPAPI
GdipAddPathClosedCurveI(GpPath *path, GDIPCONST GpPoint *points, INT count)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathClosedCurveI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathClosedCurveI);
        }
        if ( g_GdipAddPathClosedCurveI != NULL )
        {
            status = (*g_GdipAddPathClosedCurveI)(path, points, count);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathClosedCurve2IPtr)(GpPath *path, GDIPCONST GpPoint *points, INT count,
               REAL tension));
DEFINE_MEMBER(GdipAddPathClosedCurve2I);

GpStatus WINGDIPAPI
GdipAddPathClosedCurve2I(GpPath *path, GDIPCONST GpPoint *points, INT count,
                                 REAL tension)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathClosedCurve2I == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathClosedCurve2I);
        }
        if ( g_GdipAddPathClosedCurve2I != NULL )
        {
            status = (*g_GdipAddPathClosedCurve2I)(path, points, count, tension);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathRectangleIPtr)(GpPath *path, INT x, INT y, INT width, INT height));
DEFINE_MEMBER(GdipAddPathRectangleI);

GpStatus WINGDIPAPI
GdipAddPathRectangleI(GpPath *path, INT x, INT y, INT width, INT height)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathRectangleI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathRectangleI);
        }
        if ( g_GdipAddPathRectangleI != NULL )
        {
            status = (*g_GdipAddPathRectangleI)(path, x, y, width, height);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathRectanglesIPtr)(GpPath *path, GDIPCONST GpRect *rects, INT count));
DEFINE_MEMBER(GdipAddPathRectanglesI);

GpStatus WINGDIPAPI
GdipAddPathRectanglesI(GpPath *path, GDIPCONST GpRect *rects, INT count)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathRectanglesI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathRectanglesI);
        }
        if ( g_GdipAddPathRectanglesI != NULL )
        {
            status = (*g_GdipAddPathRectanglesI)(path, rects, count);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathEllipseIPtr)(GpPath *path, INT x, INT y, INT width, INT height));
DEFINE_MEMBER(GdipAddPathEllipseI);

GpStatus WINGDIPAPI
GdipAddPathEllipseI(GpPath *path, INT x, INT y, INT width, INT height)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathEllipseI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathEllipseI);
        }
        if ( g_GdipAddPathEllipseI != NULL )
        {
            status = (*g_GdipAddPathEllipseI)(path, x, y, width, height);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathPieIPtr)(GpPath *path, INT x, INT y, INT width, INT height,
               REAL startAngle, REAL sweepAngle));
DEFINE_MEMBER(GdipAddPathPieI);

GpStatus WINGDIPAPI
GdipAddPathPieI(GpPath *path, INT x, INT y, INT width, INT height,
                        REAL startAngle, REAL sweepAngle)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathPieI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathPieI);
        }
        if ( g_GdipAddPathPieI != NULL )
        {
            status = (*g_GdipAddPathPieI)(path, x, y, width, height, startAngle, sweepAngle);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathPolygonIPtr)(GpPath *path, GDIPCONST GpPoint *points, INT count));
DEFINE_MEMBER(GdipAddPathPolygonI);

GpStatus WINGDIPAPI
GdipAddPathPolygonI(GpPath *path, GDIPCONST GpPoint *points, INT count)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathPolygonI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathPolygonI);
        }
        if ( g_GdipAddPathPolygonI != NULL )
        {
            status = (*g_GdipAddPathPolygonI)(path, points, count);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipFlattenPathPtr)(GpPath *path, GpMatrix* matrix, REAL flatness));
DEFINE_MEMBER(GdipFlattenPath);

GpStatus WINGDIPAPI
GdipFlattenPath(GpPath *path, GpMatrix* matrix, REAL flatness)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipFlattenPath == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipFlattenPath);
        }
        if ( g_GdipFlattenPath != NULL )
        {
            status = (*g_GdipFlattenPath)(path, matrix, flatness);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipWindingModeOutlinePtr)(GpPath *path, GpMatrix *matrix,REAL flatness));
DEFINE_MEMBER(GdipWindingModeOutline);

GpStatus WINGDIPAPI
GdipWindingModeOutline(GpPath *path, GpMatrix *matrix,REAL flatness)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipWindingModeOutline == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipWindingModeOutline);
        }
        if ( g_GdipWindingModeOutline != NULL )
        {
            status = (*g_GdipWindingModeOutline)(path, matrix, flatness);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipWidenPathPtr)(GpPath *nativePath,GpPen *pen,
                           GpMatrix *matrix, REAL flatness));
DEFINE_MEMBER(GdipWidenPath);

GpStatus WINGDIPAPI
GdipWidenPath(
    GpPath *nativePath,
    GpPen *pen,
    GpMatrix *matrix,
    REAL flatness
)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipWidenPath == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipWidenPath);
        }
        if ( g_GdipWidenPath != NULL )
        {
            status = (*g_GdipWidenPath)(nativePath, pen, matrix, flatness);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipWarpPathPtr)(GpPath *path, GpMatrix* matrix,
                           GDIPCONST GpPointF *points, INT count,
                           REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
                           WarpMode warpMode, REAL flatness));
DEFINE_MEMBER(GdipWarpPath);

GpStatus WINGDIPAPI
GdipWarpPath(GpPath *path, GpMatrix* matrix,
            GDIPCONST GpPointF *points, INT count,
            REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
            WarpMode warpMode, REAL flatness)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipWarpPath == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipWarpPath);
        }
        if ( g_GdipWarpPath != NULL )
        {
            status = (*g_GdipWarpPath)(path, matrix, points, count, srcx, srcy, srcwidth, srcheight, warpMode, flatness);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipTransformPathPtr)(GpPath* path, GpMatrix* matrix));
DEFINE_MEMBER(GdipTransformPath);

GpStatus WINGDIPAPI
GdipTransformPath(GpPath* path, GpMatrix* matrix)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipTransformPath == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipTransformPath);
        }
        if ( g_GdipTransformPath != NULL )
        {
            status = (*g_GdipTransformPath)(path, matrix);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPathWorldBoundsPtr)(GpPath* path, GpRectF* bounds, 
               GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen));
DEFINE_MEMBER(GdipGetPathWorldBounds);

GpStatus WINGDIPAPI
GdipGetPathWorldBounds(GpPath* path, GpRectF* bounds, 
                       GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetPathWorldBounds == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPathWorldBounds);
        }
        if ( g_GdipGetPathWorldBounds != NULL )
        {
            status = (*g_GdipGetPathWorldBounds)(path, bounds, matrix, pen);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPathWorldBoundsIPtr)(GpPath* path, GpRect* bounds,