gdiplus_brush.cpp

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

        if ( g_GdipGetLineRect != NULL )
        {
            status = (*g_GdipGetLineRect)(brush, rect);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetLineRectIPtr)(GpLineGradient *brush, GpRect *rect));
DEFINE_MEMBER(GdipGetLineRectI);

GpStatus WINGDIPAPI
GdipGetLineRectI(GpLineGradient *brush, GpRect *rect)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetLineRectI == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetLineRectI);
        }
        if ( g_GdipGetLineRectI != NULL )
        {
            status = (*g_GdipGetLineRectI)(brush, rect);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetLineGammaCorrectionPtr)(GpLineGradient *brush, BOOL useGammaCorrection));
DEFINE_MEMBER(GdipSetLineGammaCorrection);

GpStatus WINGDIPAPI
GdipSetLineGammaCorrection(GpLineGradient *brush, BOOL useGammaCorrection)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipSetLineGammaCorrection == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipSetLineGammaCorrection);
        }
        if ( g_GdipSetLineGammaCorrection != NULL )
        {
            status = (*g_GdipSetLineGammaCorrection)(brush, useGammaCorrection);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetLineGammaCorrectionPtr)(GpLineGradient *brush, BOOL *useGammaCorrection));
DEFINE_MEMBER(GdipGetLineGammaCorrection);

GpStatus WINGDIPAPI
GdipGetLineGammaCorrection(GpLineGradient *brush, BOOL *useGammaCorrection)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetLineGammaCorrection == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetLineGammaCorrection);
        }
        if ( g_GdipGetLineGammaCorrection != NULL )
        {
            status = (*g_GdipGetLineGammaCorrection)(brush, useGammaCorrection);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetLineBlendCountPtr)(GpLineGradient *brush, INT *count));
DEFINE_MEMBER(GdipGetLineBlendCount);

GpStatus WINGDIPAPI
GdipGetLineBlendCount(GpLineGradient *brush, INT *count)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetLineBlendCount == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetLineBlendCount);
        }
        if ( g_GdipGetLineBlendCount != NULL )
        {
            status = (*g_GdipGetLineBlendCount)(brush, count);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetLineBlendPtr)(GpLineGradient *brush, REAL *blend, REAL* positions,INT count));
DEFINE_MEMBER(GdipGetLineBlend);

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


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetLineBlendPtr)(GpLineGradient *brush, GDIPCONST REAL *blend,
                 GDIPCONST REAL* positions, INT count));
DEFINE_MEMBER(GdipSetLineBlend);

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


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetLinePresetBlendCountPtr)(GpLineGradient *brush, INT *count));
DEFINE_MEMBER(GdipGetLinePresetBlendCount);

GpStatus WINGDIPAPI
GdipGetLinePresetBlendCount(GpLineGradient *brush, INT *count)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetLinePresetBlendCount == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetLinePresetBlendCount);
        }
        if ( g_GdipGetLinePresetBlendCount != NULL )
        {
            status = (*g_GdipGetLinePresetBlendCount)(brush, count);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetLinePresetBlendPtr)(GpLineGradient *brush, ARGB *blend,
                                           REAL* positions, INT count));
DEFINE_MEMBER(GdipGetLinePresetBlend);

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


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetLinePresetBlendPtr)(GpLineGradient *brush, GDIPCONST ARGB *blend,
                       GDIPCONST REAL* positions, INT count));
DEFINE_MEMBER(GdipSetLinePresetBlend);

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


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetLineSigmaBlendPtr)(GpLineGradient *brush, REAL focus, REAL scale));
DEFINE_MEMBER(GdipSetLineSigmaBlend);

GpStatus WINGDIPAPI
GdipSetLineSigmaBlend(GpLineGradient *brush, REAL focus, REAL scale)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipSetLineSigmaBlend == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipSetLineSigmaBlend);
        }
        if ( g_GdipSetLineSigmaBlend != NULL )
        {
            status = (*g_GdipSetLineSigmaBlend)(brush, focus, scale);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetLineLinearBlendPtr)(GpLineGradient *brush, REAL focus, REAL scale));
DEFINE_MEMBER(GdipSetLineLinearBlend);

GpStatus WINGDIPAPI
GdipSetLineLinearBlend(GpLineGradient *brush, REAL focus, REAL scale)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipSetLineLinearBlend == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipSetLineLinearBlend);
        }
        if ( g_GdipSetLineLinearBlend != NULL )
        {
            status = (*g_GdipSetLineLinearBlend)(brush, focus, scale);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetLineWrapModePtr)(GpLineGradient *brush, GpWrapMode wrapmode));
DEFINE_MEMBER(GdipSetLineWrapMode);

GpStatus WINGDIPAPI
GdipSetLineWrapMode(GpLineGradient *brush, GpWrapMode wrapmode)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipSetLineWrapMode == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipSetLineWrapMode);
        }
        if ( g_GdipSetLineWrapMode != NULL )
        {
            status = (*g_GdipSetLineWrapMode)(brush, wrapmode);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetLineWrapModePtr)(GpLineGradient *brush, GpWrapMode *wrapmode));
DEFINE_MEMBER(GdipGetLineWrapMode);

GpStatus WINGDIPAPI
GdipGetLineWrapMode(GpLineGradient *brush, GpWrapMode *wrapmode)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetLineWrapMode == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetLineWrapMode);
        }
        if ( g_GdipGetLineWrapMode != NULL )
        {
            status = (*g_GdipGetLineWrapMode)(brush, wrapmode);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipGetLineTransformPtr)(GpLineGradient *brush, GpMatrix *matrix));
DEFINE_MEMBER(GdipGetLineTransform);

GpStatus WINGDIPAPI
GdipGetLineTransform(GpLineGradient *brush, GpMatrix *matrix)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipGetLineTransform == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipGetLineTransform);
        }
        if ( g_GdipGetLineTransform != NULL )
        {
            status = (*g_GdipGetLineTransform)(brush, matrix);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipSetLineTransformPtr)(GpLineGradient *brush, GDIPCONST GpMatrix *matrix));
DEFINE_MEMBER(GdipSetLineTransform);

GpStatus WINGDIPAPI
GdipSetLineTransform(GpLineGradient *brush, GDIPCONST GpMatrix *matrix)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipSetLineTransform == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipSetLineTransform);
        }
        if ( g_GdipSetLineTransform != NULL )
        {
            status = (*g_GdipSetLineTransform)(brush, matrix);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipResetLineTransformPtr)(GpLineGradient* brush));
DEFINE_MEMBER(GdipResetLineTransform);

GpStatus WINGDIPAPI
GdipResetLineTransform(GpLineGradient* brush)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipResetLineTransform == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipResetLineTransform);
        }
        if ( g_GdipResetLineTransform != NULL )
        {
            status = (*g_GdipResetLineTransform)(brush);
        }
    }
    return status;
}


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipMultiplyLineTransformPtr)(GpLineGradient* brush, GDIPCONST GpMatrix *matrix,
                            GpMatrixOrder order));
DEFINE_MEMBER(GdipMultiplyLineTransform);

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


DEFINE_POINTER(GpStatus (WINGDIPAPI *GdipTranslateLineTransformPtr)(GpLineGradient* brush, REAL dx, REAL dy,
                            GpMatrixOrder order));
DEFINE_MEMBER(GdipTranslateLineTransform);

GpStatus WINGDIPAPI
GdipTranslateLineTransform(GpLineGradient* brush, REAL dx, REAL dy, GpMatrixOrder order)
{
    GpStatus status = GdiplusNotInitialized;
    if ( g_hGdiplusModule != NULL )
    {
        if ( g_GdipTranslateLineTransform == NULL )
        {
            INITIALIZE_MEMBER(g_hGdiplusModule, GdipTranslateLineTransform);
        }
        if ( g_GdipTranslateLineTransform != NULL )
        {
            status = (*g_GdipTranslateLineTransform)(brush, dx, dy, order);