gdiplus_brush.cpp

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

    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetPathGradientPointCount == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPathGradientPointCount);
        }
        if ( g_GdipGetPathGradientPointCount != NULL )
        {
            status = (*g_GdipGetPathGradientPointCount)(brush, count);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPathGradientSurroundColorCountPtr)(GpPathGradient *brush, INT* count));
DEFINE_MEMBER(GdipGetPathGradientSurroundColorCount);

GpStatus WINGDIPAPI
GdipGetPathGradientSurroundColorCount(GpPathGradient *brush, INT* count)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetPathGradientSurroundColorCount == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPathGradientSurroundColorCount);
        }
        if ( g_GdipGetPathGradientSurroundColorCount != NULL )
        {
            status = (*g_GdipGetPathGradientSurroundColorCount)(brush, count);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetPathGradientGammaCorrectionPtr)(GpPathGradient *brush,  BOOL useGammaCorrection));
DEFINE_MEMBER(GdipSetPathGradientGammaCorrection);

GpStatus WINGDIPAPI
GdipSetPathGradientGammaCorrection(GpPathGradient *brush, BOOL useGammaCorrection)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipSetPathGradientGammaCorrection == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipSetPathGradientGammaCorrection);
        }
        if ( g_GdipSetPathGradientGammaCorrection != NULL )
        {
            status = (*g_GdipSetPathGradientGammaCorrection)(brush, useGammaCorrection);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPathGradientGammaCorrectionPtr)(GpPathGradient *brush, 
                                   BOOL *useGammaCorrection));
DEFINE_MEMBER(GdipGetPathGradientGammaCorrection);

GpStatus WINGDIPAPI
GdipGetPathGradientGammaCorrection(GpPathGradient *brush, BOOL *useGammaCorrection)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetPathGradientGammaCorrection == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPathGradientGammaCorrection);
        }
        if ( g_GdipGetPathGradientGammaCorrection != NULL )
        {
            status = (*g_GdipGetPathGradientGammaCorrection)(brush, useGammaCorrection);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPathGradientBlendCountPtr)(GpPathGradient *brush,INT *count));
DEFINE_MEMBER(GdipGetPathGradientBlendCount);

GpStatus WINGDIPAPI
GdipGetPathGradientBlendCount(GpPathGradient *brush, INT *count)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetPathGradientBlendCount == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPathGradientBlendCount);
        }
        if ( g_GdipGetPathGradientBlendCount != NULL )
        {
            status = (*g_GdipGetPathGradientBlendCount)(brush, count);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPathGradientBlendPtr)(GpPathGradient *brush,
                                    REAL *blend, REAL *positions, INT count));
DEFINE_MEMBER(GdipGetPathGradientBlend);

GpStatus WINGDIPAPI
GdipGetPathGradientBlend(GpPathGradient *brush, REAL *blend, REAL *positions, INT count)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetPathGradientBlend == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPathGradientBlend);
        }
        if ( g_GdipGetPathGradientBlend != NULL )
        {
            status = (*g_GdipGetPathGradientBlend)(brush, blend, positions, count);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetPathGradientBlendPtr)(GpPathGradient *brush,
                GDIPCONST REAL *blend, GDIPCONST REAL *positions, INT count));
DEFINE_MEMBER(GdipSetPathGradientBlend);

GpStatus WINGDIPAPI
GdipSetPathGradientBlend(GpPathGradient *brush,
                GDIPCONST REAL *blend, GDIPCONST REAL *positions, INT count)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipSetPathGradientBlend == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipSetPathGradientBlend);
        }
        if ( g_GdipSetPathGradientBlend != NULL )
        {
            status = (*g_GdipSetPathGradientBlend)(brush, blend, positions, count);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPathGradientPresetBlendCountPtr)(GpPathGradient *brush, INT *count));
DEFINE_MEMBER(GdipGetPathGradientPresetBlendCount);

GpStatus WINGDIPAPI
GdipGetPathGradientPresetBlendCount(GpPathGradient *brush, INT *count)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetPathGradientPresetBlendCount == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPathGradientPresetBlendCount);
        }
        if ( g_GdipGetPathGradientPresetBlendCount != NULL )
        {
            status = (*g_GdipGetPathGradientPresetBlendCount)(brush, count);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPathGradientPresetBlendPtr)(GpPathGradient *brush, ARGB *blend,
                                                REAL* positions, INT count));
DEFINE_MEMBER(GdipGetPathGradientPresetBlend);

GpStatus WINGDIPAPI
GdipGetPathGradientPresetBlend(GpPathGradient *brush, ARGB *blend, REAL* positions, INT count)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetPathGradientPresetBlend == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPathGradientPresetBlend);
        }
        if ( g_GdipGetPathGradientPresetBlend != NULL )
        {
            status = (*g_GdipGetPathGradientPresetBlend)(brush, blend, positions, count);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetPathGradientPresetBlendPtr)(GpPathGradient *brush, GDIPCONST ARGB *blend,
                                        GDIPCONST REAL* positions, INT count));
DEFINE_MEMBER(GdipSetPathGradientPresetBlend);

GpStatus WINGDIPAPI
GdipSetPathGradientPresetBlend(GpPathGradient *brush, GDIPCONST ARGB *blend,
                                        GDIPCONST REAL* positions, INT count)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipSetPathGradientPresetBlend == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipSetPathGradientPresetBlend);
        }
        if ( g_GdipSetPathGradientPresetBlend != NULL )
        {
            status = (*g_GdipSetPathGradientPresetBlend)(brush, blend, positions, count);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetPathGradientSigmaBlendPtr)(GpPathGradient *brush, REAL focus, REAL scale));
DEFINE_MEMBER(GdipSetPathGradientSigmaBlend);

GpStatus WINGDIPAPI
GdipSetPathGradientSigmaBlend(GpPathGradient *brush, REAL focus, REAL scale)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipSetPathGradientSigmaBlend == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipSetPathGradientSigmaBlend);
        }
        if ( g_GdipSetPathGradientSigmaBlend != NULL )
        {
            status = (*g_GdipSetPathGradientSigmaBlend)(brush, focus, scale);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetPathGradientLinearBlendPtr)(GpPathGradient *brush, REAL focus, REAL scale));
DEFINE_MEMBER(GdipSetPathGradientLinearBlend);

GpStatus WINGDIPAPI
GdipSetPathGradientLinearBlend(GpPathGradient *brush, REAL focus, REAL scale)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipSetPathGradientLinearBlend == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipSetPathGradientLinearBlend);
        }
        if ( g_GdipSetPathGradientLinearBlend != NULL )
        {
            status = (*g_GdipSetPathGradientLinearBlend)(brush, focus, scale);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPathGradientWrapModePtr)(GpPathGradient *brush,GpWrapMode *wrapmode));
DEFINE_MEMBER(GdipGetPathGradientWrapMode);

GpStatus WINGDIPAPI
GdipGetPathGradientWrapMode(GpPathGradient *brush, GpWrapMode *wrapmode)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetPathGradientWrapMode == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPathGradientWrapMode);
        }
        if ( g_GdipGetPathGradientWrapMode != NULL )
        {
            status = (*g_GdipGetPathGradientWrapMode)(brush, wrapmode);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetPathGradientWrapModePtr)(GpPathGradient *brush,GpWrapMode wrapmode));
DEFINE_MEMBER(GdipSetPathGradientWrapMode);

GpStatus WINGDIPAPI
GdipSetPathGradientWrapMode(GpPathGradient *brush, GpWrapMode wrapmode)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipSetPathGradientWrapMode == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipSetPathGradientWrapMode);
        }
        if ( g_GdipSetPathGradientWrapMode != NULL )
        {
            status = (*g_GdipSetPathGradientWrapMode)(brush, wrapmode);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetPathGradientTransformPtr)(GpPathGradient *brush,GpMatrix *matrix));
DEFINE_MEMBER(GdipGetPathGradientTransform);

GpStatus WINGDIPAPI
GdipGetPathGradientTransform(GpPathGradient *brush, GpMatrix *matrix)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetPathGradientTransform == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetPathGradientTransform);
        }
        if ( g_GdipGetPathGradientTransform != NULL )
        {
            status = (*g_GdipGetPathGradientTransform)(brush, matrix);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetPathGradientTransformPtr)(GpPathGradient *brush, GpMatrix *matrix));
DEFINE_MEMBER(GdipSetPathGradientTransform);

GpStatus WINGDIPAPI
GdipSetPathGradientTransform(GpPathGradient *brush, GpMatrix *matrix)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipSetPathGradientTransform == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipSetPathGradientTransform);
        }
        if ( g_GdipSetPathGradientTransform != NULL )
        {
            status = (*g_GdipSetPathGradientTransform)(brush, matrix);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipResetPathGradientTransformPtr)(GpPathGradient* brush));
DEFINE_MEMBER(GdipResetPathGradientTransform);

GpStatus WINGDIPAPI
GdipResetPathGradientTransform(GpPathGradient* brush)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipResetPathGradientTransform == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipResetPathGradientTransform);
        }
        if ( g_GdipResetPathGradientTransform != NULL )
        {
            status = (*g_GdipResetPathGradientTransform)(brush);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipMultiplyPathGradientTransformPtr)(GpPathGradient* brush, 
                                  GDIPCONST GpMatrix *matrix,GpMatrixOrder order));
DEFINE_MEMBER(GdipMultiplyPathGradientTransform);

GpStatus WINGDIPAPI
GdipMultiplyPathGradientTransform(GpPathGradient* brush, 
                                  GDIPCONST GpMatrix *matrix,
                                  GpMatrixOrder order)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipMultiplyPathGradientTransform == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipMultiplyPathGradientTransform);
        }
        if ( g_GdipMultiplyPathGradientTransform != NULL )
        {
            status = (*g_GdipMultiplyPathGradientTransform)(brush, matrix, order);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipTranslatePathGradientTransformPtr)(GpPathGradient* brush, REAL dx, REAL dy,
                                   GpMatrixOrder order));
DEFINE_MEMBER(GdipTranslatePathGradientTransform);

GpStatus WINGDIPAPI
GdipTranslatePathGradientTransform(GpPathGradient* brush, REAL dx, REAL dy,
                                   GpMatrixOrder o