gdiplus_path.cpp

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

               GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen));
DEFINE_MEMBER(GdipGetPathWorldBoundsI);

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


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipIsVisiblePathPointPtr)(GpPath* path, REAL x, REAL y,
               GpGraphics *graphics, BOOL *result));
DEFINE_MEMBER(GdipIsVisiblePathPoint);

GpStatus WINGDIPAPI
GdipIsVisiblePathPoint(GpPath* path, REAL x, REAL y,
                       GpGraphics *graphics, BOOL *result)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipIsVisiblePathPoint == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipIsVisiblePathPoint);
        }
        if ( g_GdipIsVisiblePathPoint != NULL )
        {
            status = (*g_GdipIsVisiblePathPoint)(path, x, y, graphics, result);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipIsVisiblePathPointIPtr)(GpPath* path, INT x, INT y,
               GpGraphics *graphics, BOOL *result));
DEFINE_MEMBER(GdipIsVisiblePathPointI);

GpStatus WINGDIPAPI
GdipIsVisiblePathPointI(GpPath* path, INT x, INT y,
                        GpGraphics *graphics, BOOL *result)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipIsVisiblePathPointI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipIsVisiblePathPointI);
        }
        if ( g_GdipIsVisiblePathPointI != NULL )
        {
            status = (*g_GdipIsVisiblePathPointI)(path, x, y, graphics, result);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipIsOutlineVisiblePathPointPtr)(GpPath* path, REAL x, REAL y, GpPen *pen,
               GpGraphics *graphics, BOOL *result));
DEFINE_MEMBER(GdipIsOutlineVisiblePathPoint);

GpStatus WINGDIPAPI
GdipIsOutlineVisiblePathPoint(GpPath* path, REAL x, REAL y, GpPen *pen,
                              GpGraphics *graphics, BOOL *result)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipIsOutlineVisiblePathPoint == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipIsOutlineVisiblePathPoint);
        }
        if ( g_GdipIsOutlineVisiblePathPoint != NULL )
        {
            status = (*g_GdipIsOutlineVisiblePathPoint)(path, x, y, pen, graphics, result);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipIsOutlineVisiblePathPointIPtr)(GpPath* path, INT x, INT y, GpPen *pen,
               GpGraphics *graphics, BOOL *result));
DEFINE_MEMBER(GdipIsOutlineVisiblePathPointI);

GpStatus WINGDIPAPI
GdipIsOutlineVisiblePathPointI(GpPath* path, INT x, INT y, GpPen *pen,
                               GpGraphics *graphics, BOOL *result)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipIsOutlineVisiblePathPointI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipIsOutlineVisiblePathPointI);
        }
        if ( g_GdipIsOutlineVisiblePathPointI != NULL )
        {
            status = (*g_GdipIsOutlineVisiblePathPointI)(path, x, y, pen, graphics, result);
        }
    }
    return status;
}


//----------------------------------------------------------------------------
// PathIterator APIs
//----------------------------------------------------------------------------


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipCreatePathIterPtr)(GpPathIterator **iterator, GpPath* path));
DEFINE_MEMBER(GdipCreatePathIter);

GpStatus WINGDIPAPI
GdipCreatePathIter(GpPathIterator **iterator, GpPath* path)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipCreatePathIter == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipCreatePathIter);
        }
        if ( g_GdipCreatePathIter != NULL )
        {
            status = (*g_GdipCreatePathIter)(iterator, path);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipDeletePathIterPtr)(GpPathIterator *iterator));
DEFINE_MEMBER(GdipDeletePathIter);

GpStatus WINGDIPAPI
GdipDeletePathIter(GpPathIterator *iterator)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipDeletePathIter == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipDeletePathIter);
        }
        if ( g_GdipDeletePathIter != NULL )
        {
            status = (*g_GdipDeletePathIter)(iterator);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipPathIterNextSubpathPtr)(GpPathIterator* iterator, INT *resultCount,
                       INT* startIndex, INT* endIndex, BOOL* isClosed));
DEFINE_MEMBER(GdipPathIterNextSubpath);

GpStatus WINGDIPAPI
GdipPathIterNextSubpath(GpPathIterator* iterator, INT *resultCount,
        INT* startIndex, INT* endIndex, BOOL* isClosed)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipPathIterNextSubpath == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipPathIterNextSubpath);
        }
        if ( g_GdipPathIterNextSubpath != NULL )
        {
            status = (*g_GdipPathIterNextSubpath)(iterator, resultCount, startIndex, endIndex, isClosed);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipPathIterNextSubpathPathPtr)(GpPathIterator* iterator, INT* resultCount,
                       GpPath* path, BOOL* isClosed));
DEFINE_MEMBER(GdipPathIterNextSubpathPath);

GpStatus WINGDIPAPI
GdipPathIterNextSubpathPath(GpPathIterator* iterator, INT* resultCount,
        GpPath* path, BOOL* isClosed)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipPathIterNextSubpathPath == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipPathIterNextSubpathPath);
        }
        if ( g_GdipPathIterNextSubpathPath != NULL )
        {
            status = (*g_GdipPathIterNextSubpathPath)(iterator, resultCount, path, isClosed);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipPathIterNextPathTypePtr)(GpPathIterator* iterator, INT* resultCount,
                       BYTE* pathType, INT* startIndex, INT* endIndex));
DEFINE_MEMBER(GdipPathIterNextPathType);

GpStatus WINGDIPAPI
GdipPathIterNextPathType(GpPathIterator* iterator, INT* resultCount,
        BYTE* pathType, INT* startIndex, INT* endIndex)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipPathIterNextPathType == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipPathIterNextPathType);
        }
        if ( g_GdipPathIterNextPathType != NULL )
        {
            status = (*g_GdipPathIterNextPathType)(iterator, resultCount, pathType, startIndex, endIndex);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipPathIterNextMarkerPtr)(GpPathIterator* iterator, INT *resultCount,
                       INT* startIndex, INT* endIndex));
DEFINE_MEMBER(GdipPathIterNextMarker);

GpStatus WINGDIPAPI
GdipPathIterNextMarker(GpPathIterator* iterator, INT *resultCount,
        INT* startIndex, INT* endIndex)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipPathIterNextMarker == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipPathIterNextMarker);
        }
        if ( g_GdipPathIterNextMarker != NULL )
        {
            status = (*g_GdipPathIterNextMarker)(iterator, resultCount, startIndex, endIndex);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipPathIterNextMarkerPathPtr)(GpPathIterator* iterator, INT* resultCount,
                       GpPath* path));
DEFINE_MEMBER(GdipPathIterNextMarkerPath);

GpStatus WINGDIPAPI
GdipPathIterNextMarkerPath(GpPathIterator* iterator, INT* resultCount,
        GpPath* path)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipPathIterNextMarkerPath == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipPathIterNextMarkerPath);
        }
        if ( g_GdipPathIterNextMarkerPath != NULL )
        {
            status = (*g_GdipPathIterNextMarkerPath)(iterator, resultCount, path);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipPathIterGetCountPtr)(GpPathIterator* iterator, INT* count));
DEFINE_MEMBER(GdipPathIterGetCount);

GpStatus WINGDIPAPI
GdipPathIterGetCount(GpPathIterator* iterator, INT* count)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipPathIterGetCount == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipPathIterGetCount);
        }
        if ( g_GdipPathIterGetCount != NULL )
        {
            status = (*g_GdipPathIterGetCount)(iterator, count);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipPathIterGetSubpathCountPtr)(GpPathIterator* iterator, INT* count));
DEFINE_MEMBER(GdipPathIterGetSubpathCount);

GpStatus WINGDIPAPI
GdipPathIterGetSubpathCount(GpPathIterator* iterator, INT* count)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipPathIterGetSubpathCount == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipPathIterGetSubpathCount);
        }
        if ( g_GdipPathIterGetSubpathCount != NULL )
        {
            status = (*g_GdipPathIterGetSubpathCount)(iterator, count);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipPathIterIsValidPtr)(GpPathIterator* iterator, BOOL* valid));
DEFINE_MEMBER(GdipPathIterIsValid);

GpStatus WINGDIPAPI
GdipPathIterIsValid(GpPathIterator* iterator, BOOL* valid)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipPathIterIsValid == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipPathIterIsValid);
        }
        if ( g_GdipPathIterIsValid != NULL )
        {
            status = (*g_GdipPathIterIsValid)(iterator, valid);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipPathIterHasCurvePtr)(GpPathIterator* iterator, BOOL* hasCurve));
DEFINE_MEMBER(GdipPathIterHasCurve);

GpStatus WINGDIPAPI
GdipPathIterHasCurve(GpPathIterator* iterator, BOOL* hasCurve)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipPathIterHasCurve == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipPathIterHasCurve);
        }
        if ( g_GdipPathIterHasCurve != NULL )
        {
            status = (*g_GdipPathIterHasCurve)(iterator, hasCurve);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipPathIterRewindPtr)(GpPathIterator* iterator));
DEFINE_MEMBER(GdipPathIterRewind);

GpStatus WINGDIPAPI
GdipPathIterRewind(GpPathIterator* iterator)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipPathIterRewind == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipPathIterRewind);
        }
        if ( g_GdipPathIterRewind != NULL )
        {
            status = (*g_GdipPathIterRewind)(iterator);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipPathIterEnumeratePtr)(GpPathIterator* iterator, INT* resultCount,
                   GpPointF *points, BYTE *types, INT count));
DEFINE_MEMBER(GdipPathIterEnumerate);

GpStatus WINGDIPAPI
GdipPathIterEnumerate(GpPathIterator* iterator, INT* resultCount,
    GpPointF *points, BYTE *types, INT count)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipPathIterEnumerate == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipPathIterEnumerate);
        }
        if ( g_GdipPathIterEnumerate != NULL )
        {
            status = (*g_GdipPathIterEnumerate)(iterator, resultCount, points, types, count);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipPathIterCopyDataPtr)(GpPathIterator* iterator, INT* resultCount,
                   GpPointF* points, BYTE* types, INT startIndex, INT endIndex));
DEFINE_MEMBER(GdipPathIterCopyData);

GpStatus WINGDIPAPI
GdipPathIterCopyData(GpPathIterator* iterator, INT* resultCount,
    GpPointF* points, BYTE* types, INT startIndex, INT endIndex)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipPathIterCopyData == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipPathIterCopyData);
        }
        if ( g_GdipPathIterCopyData != NULL )
        {
            status = (*g_GdipPathIterCopyData)(iterator, resultCount, points, types, startIndex, endIndex);
        }
    }
    return status;
}


//----------------------------------------------------------------------------
// Platform Shunt
//----------------------------------------------------------------------------

VOID WINAPI
Gdiplus_PathInit()
{
}