gdiplus_path.cpp

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

DEFINE_MEMBER(GdipAddPathLine);

GpStatus WINGDIPAPI
GdipAddPathLine(GpPath *path, REAL x1, REAL y1, REAL x2, REAL y2)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathLine == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathLine);
        }
        if ( g_GdipAddPathLine != NULL )
        {
            status = (*g_GdipAddPathLine)(path, x1, y1, x2, y2);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathLine2Ptr)(GpPath *path, GDIPCONST GpPointF *points, INT count));
DEFINE_MEMBER(GdipAddPathLine2);

GpStatus WINGDIPAPI
GdipAddPathLine2(GpPath *path, GDIPCONST GpPointF *points, INT count)

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

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathArcPtr)(GpPath *path, REAL x, REAL y, REAL width, REAL height,
               REAL startAngle, REAL sweepAngle));
DEFINE_MEMBER(GdipAddPathArc);

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

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

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathBezierPtr)(GpPath *path, REAL x1, REAL y1, REAL x2, REAL y2,
                         REAL x3, REAL y3, REAL x4, REAL y4));
DEFINE_MEMBER(GdipAddPathBezier);

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

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

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathBeziersPtr)(GpPath *path, GDIPCONST GpPointF *points, INT count));
DEFINE_MEMBER(GdipAddPathBeziers);

GpStatus WINGDIPAPI
GdipAddPathBeziers(GpPath *path, GDIPCONST GpPointF *points, INT count)

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

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathCurvePtr)(GpPath *path, GDIPCONST GpPointF *points, INT count));
DEFINE_MEMBER(GdipAddPathCurve);

GpStatus WINGDIPAPI
GdipAddPathCurve(GpPath *path, GDIPCONST GpPointF *points, INT count)

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

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathCurve2Ptr)(GpPath *path, GDIPCONST GpPointF *points, INT count,
               REAL tension));
DEFINE_MEMBER(GdipAddPathCurve2);

GpStatus WINGDIPAPI
GdipAddPathCurve2(GpPath *path, GDIPCONST GpPointF *points, INT count,
                           REAL tension)

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

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathCurve3Ptr)(GpPath *path, GDIPCONST GpPointF *points, INT count,
               INT offset, INT numberOfSegments, REAL tension));
DEFINE_MEMBER(GdipAddPathCurve3);

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

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

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathClosedCurvePtr)(GpPath *path, GDIPCONST GpPointF *points, INT count));
DEFINE_MEMBER(GdipAddPathClosedCurve);

GpStatus WINGDIPAPI
GdipAddPathClosedCurve(GpPath *path, GDIPCONST GpPointF *points, INT count)

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

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathClosedCurve2Ptr)(GpPath *path, GDIPCONST GpPointF *points, INT count,
               REAL tension));
DEFINE_MEMBER(GdipAddPathClosedCurve2);

GpStatus WINGDIPAPI
GdipAddPathClosedCurve2(GpPath *path, GDIPCONST GpPointF *points, INT count,
                                 REAL tension)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathClosedCurve2 == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathClosedCurve2);
        }
        if ( g_GdipAddPathClosedCurve2 != NULL )
        {
            status = (*g_GdipAddPathClosedCurve2)(path, points, count, tension);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathRectanglePtr)(GpPath *path, REAL x, REAL y, REAL width, REAL height));
DEFINE_MEMBER(GdipAddPathRectangle);

GpStatus WINGDIPAPI
GdipAddPathRectangle(GpPath *path, REAL x, REAL y, REAL width, REAL height)

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

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathRectanglesPtr)(GpPath *path, GDIPCONST GpRectF *rects, INT count));
DEFINE_MEMBER(GdipAddPathRectangles);

GpStatus WINGDIPAPI
GdipAddPathRectangles(GpPath *path, GDIPCONST GpRectF *rects, INT count)

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

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathEllipsePtr)(GpPath *path, REAL x, REAL y, REAL width,
               REAL height));
DEFINE_MEMBER(GdipAddPathEllipse);

GpStatus WINGDIPAPI
GdipAddPathEllipse(GpPath *path, REAL x, REAL y, REAL width,
                            REAL height)

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

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathPiePtr)(GpPath *path, REAL x, REAL y, REAL width, REAL height,
               REAL startAngle, REAL sweepAngle));
DEFINE_MEMBER(GdipAddPathPie);

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

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

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathPolygonPtr)(GpPath *path, GDIPCONST GpPointF *points, INT count));
DEFINE_MEMBER(GdipAddPathPolygon);

GpStatus WINGDIPAPI
GdipAddPathPolygon(GpPath *path, GDIPCONST GpPointF *points, INT count)

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

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathPathPtr)(GpPath *path, GDIPCONST GpPath* addingPath, BOOL connect));
DEFINE_MEMBER(GdipAddPathPath);

GpStatus WINGDIPAPI
GdipAddPathPath(GpPath *path, GDIPCONST GpPath* addingPath, BOOL connect)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathPath == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathPath);
        }
        if ( g_GdipAddPathPath != NULL )
        {
            status = (*g_GdipAddPathPath)(path, addingPath, connect);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathStringPtr)(GpPath *path, GDIPCONST WCHAR *string,
               INT length, GDIPCONST GpFontFamily *family, INT style,
               REAL emSize, GDIPCONST RectF *layoutRect,
               GDIPCONST GpStringFormat *format));
DEFINE_MEMBER(GdipAddPathString);

GpStatus WINGDIPAPI
GdipAddPathString(GpPath *path, GDIPCONST WCHAR *string,
                        INT length, GDIPCONST GpFontFamily *family, INT style,
                        REAL emSize, GDIPCONST RectF *layoutRect,
                        GDIPCONST GpStringFormat *format)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathString == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathString);
        }
        if ( g_GdipAddPathString != NULL )
        {
            status = (*g_GdipAddPathString)(path, string, length, family, style, emSize, layoutRect, format);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathStringIPtr)(GpPath *path, GDIPCONST WCHAR *string,
               INT length, GDIPCONST GpFontFamily *family, INT style,
               REAL emSize, GDIPCONST Rect *layoutRect,
               GDIPCONST GpStringFormat *format));
DEFINE_MEMBER(GdipAddPathStringI);

GpStatus WINGDIPAPI
GdipAddPathStringI(GpPath *path, GDIPCONST WCHAR *string,
                        INT length, GDIPCONST GpFontFamily *family, INT style,
                        REAL emSize, GDIPCONST Rect *layoutRect,
                        GDIPCONST GpStringFormat *format)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathStringI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathStringI);
        }
        if ( g_GdipAddPathStringI != NULL )
        {
            status = (*g_GdipAddPathStringI)(path, string, length, family, style, emSize, layoutRect, format);
        }
    }
    return status;
}

DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipAddPathLineIPtr)(GpPath *path, INT x1, INT y1, INT x2, INT y2));
DEFINE_MEMBER(GdipAddPathLineI);

GpStatus WINGDIPAPI
GdipAddPathLineI(GpPath *path, INT x1, INT y1, INT x2, INT y2)

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathLineI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipAddPathLineI);
        }
        if ( g_GdipAddPathLineI != NULL )
        {
            status = (*g_GdipAddPathLineI)(path, x1, y1, x2, y2);
        }
    }
    return status;
}

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

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

{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipAddPathLine2I == NULL )
        {