brush.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "wingdi.h"
#include "objbase.h"
#include "olectl.h"
#include "ole2.h"
#include "gdiplus.h"
#include "gdiplus_private.h"
#include "wine/debug.h"

Include dependency graph for brush.c:

Go to the source code of this file.

Macros
#define	COBJMACROS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (gdiplus)
GpStatus WINGDIPAPI	GdipCloneBrush (GpBrush *brush, GpBrush **clone)
GpStatus	get_hatch_data (GpHatchStyle hatchstyle, const char **result)
GpStatus WINGDIPAPI	GdipCreateHatchBrush (GpHatchStyle hatchstyle, ARGB forecol, ARGB backcol, GpHatch **brush)
static GpStatus	create_line_brush (const GpRectF *rect, ARGB startcolor, ARGB endcolor, GpWrapMode wrap, GpLineGradient **line)
static void	linegradient_init_transform (const GpPointF *startpoint, const GpPointF *endpoint, GpLineGradient *line)
GpStatus WINGDIPAPI	GdipCreateLineBrush (GDIPCONST GpPointF *startpoint, GDIPCONST GpPointF *endpoint, ARGB startcolor, ARGB endcolor, GpWrapMode wrap, GpLineGradient **line)
GpStatus WINGDIPAPI	GdipCreateLineBrushI (GDIPCONST GpPoint *startpoint, GDIPCONST GpPoint *endpoint, ARGB startcolor, ARGB endcolor, GpWrapMode wrap, GpLineGradient **line)
GpStatus WINGDIPAPI	GdipCreateLineBrushFromRect (GDIPCONST GpRectF *rect, ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap, GpLineGradient **line)
GpStatus WINGDIPAPI	GdipCreateLineBrushFromRectI (GDIPCONST GpRect *rect, ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap, GpLineGradient **line)
GpStatus WINGDIPAPI	GdipCreateLineBrushFromRectWithAngle (GDIPCONST GpRectF *rect, ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap, GpLineGradient **line)
GpStatus WINGDIPAPI	GdipCreateLineBrushFromRectWithAngleI (GDIPCONST GpRect *rect, ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap, GpLineGradient **line)
static GpStatus	create_path_gradient (GpPath *path, ARGB centercolor, GpPathGradient **grad)
GpStatus WINGDIPAPI	GdipCreatePathGradient (GDIPCONST GpPointF *points, INT count, GpWrapMode wrap, GpPathGradient **grad)
GpStatus WINGDIPAPI	GdipCreatePathGradientI (GDIPCONST GpPoint *points, INT count, GpWrapMode wrap, GpPathGradient **grad)
GpStatus WINGDIPAPI	GdipCreatePathGradientFromPath (GDIPCONST GpPath *path, GpPathGradient **grad)
GpStatus WINGDIPAPI	GdipCreateSolidFill (ARGB color, GpSolidFill **sf)
GpStatus WINGDIPAPI	GdipCreateTexture (GpImage *image, GpWrapMode wrapmode, GpTexture **texture)
GpStatus WINGDIPAPI	GdipCreateTexture2 (GpImage *image, GpWrapMode wrapmode, REAL x, REAL y, REAL width, REAL height, GpTexture **texture)
GpStatus WINGDIPAPI	GdipCreateTextureIA (GpImage *image, GDIPCONST GpImageAttributes *imageattr, REAL x, REAL y, REAL width, REAL height, GpTexture **texture)
GpStatus WINGDIPAPI	GdipCreateTextureIAI (GpImage *image, GDIPCONST GpImageAttributes *imageattr, INT x, INT y, INT width, INT height, GpTexture **texture)
GpStatus WINGDIPAPI	GdipCreateTexture2I (GpImage *image, GpWrapMode wrapmode, INT x, INT y, INT width, INT height, GpTexture **texture)
GpStatus WINGDIPAPI	GdipGetBrushType (GpBrush *brush, GpBrushType *type)
GpStatus WINGDIPAPI	GdipGetHatchBackgroundColor (GpHatch *brush, ARGB *backcol)
GpStatus WINGDIPAPI	GdipGetHatchForegroundColor (GpHatch *brush, ARGB *forecol)
GpStatus WINGDIPAPI	GdipGetHatchStyle (GpHatch *brush, GpHatchStyle *hatchstyle)
GpStatus WINGDIPAPI	GdipDeleteBrush (GpBrush *brush)
GpStatus WINGDIPAPI	GdipGetLineGammaCorrection (GpLineGradient *line, BOOL *usinggamma)
GpStatus WINGDIPAPI	GdipGetLineWrapMode (GpLineGradient *brush, GpWrapMode *wrapmode)
GpStatus WINGDIPAPI	GdipGetPathGradientBlend (GpPathGradient *brush, REAL *blend, REAL *positions, INT count)
GpStatus WINGDIPAPI	GdipGetPathGradientBlendCount (GpPathGradient *brush, INT *count)
GpStatus WINGDIPAPI	GdipGetPathGradientCenterPoint (GpPathGradient *grad, GpPointF *point)
GpStatus WINGDIPAPI	GdipGetPathGradientCenterPointI (GpPathGradient *grad, GpPoint *point)
GpStatus WINGDIPAPI	GdipGetPathGradientCenterColor (GpPathGradient *grad, ARGB *colors)
GpStatus WINGDIPAPI	GdipGetPathGradientFocusScales (GpPathGradient *grad, REAL *x, REAL *y)
GpStatus WINGDIPAPI	GdipGetPathGradientGammaCorrection (GpPathGradient *grad, BOOL *gamma)
GpStatus WINGDIPAPI	GdipGetPathGradientPath (GpPathGradient *grad, GpPath *path)
GpStatus WINGDIPAPI	GdipGetPathGradientPointCount (GpPathGradient *grad, INT *count)
GpStatus WINGDIPAPI	GdipGetPathGradientRect (GpPathGradient *brush, GpRectF *rect)
GpStatus WINGDIPAPI	GdipGetPathGradientRectI (GpPathGradient *brush, GpRect *rect)
GpStatus WINGDIPAPI	GdipGetPathGradientSurroundColorsWithCount (GpPathGradient *grad, ARGB *argb, INT *count)
GpStatus WINGDIPAPI	GdipGetPathGradientSurroundColorCount (GpPathGradient *brush, INT *count)
GpStatus WINGDIPAPI	GdipGetPathGradientWrapMode (GpPathGradient *brush, GpWrapMode *wrapmode)
GpStatus WINGDIPAPI	GdipGetSolidFillColor (GpSolidFill *sf, ARGB *argb)
GpStatus WINGDIPAPI	GdipGetTextureImage (GpTexture *brush, GpImage **image)
GpStatus WINGDIPAPI	GdipGetTextureTransform (GpTexture *brush, GpMatrix *matrix)
GpStatus WINGDIPAPI	GdipGetTextureWrapMode (GpTexture *brush, GpWrapMode *wrapmode)
GpStatus WINGDIPAPI	GdipMultiplyTextureTransform (GpTexture *brush, GDIPCONST GpMatrix *matrix, GpMatrixOrder order)
GpStatus WINGDIPAPI	GdipResetTextureTransform (GpTexture *brush)
GpStatus WINGDIPAPI	GdipScaleTextureTransform (GpTexture *brush, REAL sx, REAL sy, GpMatrixOrder order)
GpStatus WINGDIPAPI	GdipSetLineBlend (GpLineGradient *brush, GDIPCONST REAL *factors, GDIPCONST REAL *positions, INT count)
GpStatus WINGDIPAPI	GdipGetLineBlend (GpLineGradient *brush, REAL *factors, REAL *positions, INT count)
GpStatus WINGDIPAPI	GdipGetLineBlendCount (GpLineGradient *brush, INT *count)
GpStatus WINGDIPAPI	GdipSetLineGammaCorrection (GpLineGradient *line, BOOL usegamma)
GpStatus WINGDIPAPI	GdipSetLineSigmaBlend (GpLineGradient *line, REAL focus, REAL scale)
GpStatus WINGDIPAPI	GdipSetLineWrapMode (GpLineGradient *line, GpWrapMode wrap)
GpStatus WINGDIPAPI	GdipSetPathGradientBlend (GpPathGradient *brush, GDIPCONST REAL *blend, GDIPCONST REAL *pos, INT count)
GpStatus WINGDIPAPI	GdipSetPathGradientLinearBlend (GpPathGradient *brush, REAL focus, REAL scale)
GpStatus WINGDIPAPI	GdipSetPathGradientPresetBlend (GpPathGradient *brush, GDIPCONST ARGB *blend, GDIPCONST REAL *pos, INT count)
GpStatus WINGDIPAPI	GdipGetPathGradientPresetBlend (GpPathGradient *brush, ARGB *blend, REAL *pos, INT count)
GpStatus WINGDIPAPI	GdipGetPathGradientPresetBlendCount (GpPathGradient *brush, INT *count)
GpStatus WINGDIPAPI	GdipSetPathGradientCenterColor (GpPathGradient *grad, ARGB argb)
GpStatus WINGDIPAPI	GdipSetPathGradientCenterPoint (GpPathGradient *grad, GpPointF *point)
GpStatus WINGDIPAPI	GdipSetPathGradientCenterPointI (GpPathGradient *grad, GpPoint *point)
GpStatus WINGDIPAPI	GdipSetPathGradientFocusScales (GpPathGradient *grad, REAL x, REAL y)
GpStatus WINGDIPAPI	GdipSetPathGradientGammaCorrection (GpPathGradient *grad, BOOL gamma)
GpStatus WINGDIPAPI	GdipSetPathGradientPath (GpPathGradient *grad, GDIPCONST GpPath *path)
GpStatus WINGDIPAPI	GdipSetPathGradientSigmaBlend (GpPathGradient *grad, REAL focus, REAL scale)
GpStatus WINGDIPAPI	GdipSetPathGradientSurroundColorsWithCount (GpPathGradient *grad, GDIPCONST ARGB *argb, INT *count)
GpStatus WINGDIPAPI	GdipSetPathGradientWrapMode (GpPathGradient *grad, GpWrapMode wrap)
GpStatus WINGDIPAPI	GdipSetPathGradientTransform (GpPathGradient *grad, GpMatrix *matrix)
GpStatus WINGDIPAPI	GdipGetPathGradientTransform (GpPathGradient *grad, GpMatrix *matrix)
GpStatus WINGDIPAPI	GdipMultiplyPathGradientTransform (GpPathGradient *grad, GDIPCONST GpMatrix *matrix, GpMatrixOrder order)
GpStatus WINGDIPAPI	GdipResetPathGradientTransform (GpPathGradient *grad)
GpStatus WINGDIPAPI	GdipRotatePathGradientTransform (GpPathGradient *grad, REAL angle, GpMatrixOrder order)
GpStatus WINGDIPAPI	GdipScalePathGradientTransform (GpPathGradient *grad, REAL sx, REAL sy, GpMatrixOrder order)
GpStatus WINGDIPAPI	GdipTranslatePathGradientTransform (GpPathGradient *grad, REAL dx, REAL dy, GpMatrixOrder order)
GpStatus WINGDIPAPI	GdipSetSolidFillColor (GpSolidFill *sf, ARGB argb)
GpStatus WINGDIPAPI	GdipSetTextureTransform (GpTexture *texture, GDIPCONST GpMatrix *matrix)
GpStatus WINGDIPAPI	GdipSetTextureWrapMode (GpTexture *brush, GpWrapMode wrapmode)
GpStatus WINGDIPAPI	GdipSetLineColors (GpLineGradient *brush, ARGB color1, ARGB color2)
GpStatus WINGDIPAPI	GdipGetLineColors (GpLineGradient *brush, ARGB *colors)
GpStatus WINGDIPAPI	GdipRotateTextureTransform (GpTexture *brush, REAL angle, GpMatrixOrder order)
GpStatus WINGDIPAPI	GdipSetLineLinearBlend (GpLineGradient *brush, REAL focus, REAL scale)
GpStatus WINGDIPAPI	GdipSetLinePresetBlend (GpLineGradient *brush, GDIPCONST ARGB *blend, GDIPCONST REAL *positions, INT count)
GpStatus WINGDIPAPI	GdipGetLinePresetBlend (GpLineGradient *brush, ARGB *blend, REAL *positions, INT count)
GpStatus WINGDIPAPI	GdipGetLinePresetBlendCount (GpLineGradient *brush, INT *count)
GpStatus WINGDIPAPI	GdipResetLineTransform (GpLineGradient *brush)
GpStatus WINGDIPAPI	GdipSetLineTransform (GpLineGradient *brush, GDIPCONST GpMatrix *matrix)
GpStatus WINGDIPAPI	GdipGetLineTransform (GpLineGradient *brush, GpMatrix *matrix)
GpStatus WINGDIPAPI	GdipScaleLineTransform (GpLineGradient *brush, REAL sx, REAL sy, GpMatrixOrder order)
GpStatus WINGDIPAPI	GdipMultiplyLineTransform (GpLineGradient *brush, GDIPCONST GpMatrix *matrix, GpMatrixOrder order)
GpStatus WINGDIPAPI	GdipTranslateLineTransform (GpLineGradient *brush, REAL dx, REAL dy, GpMatrixOrder order)
GpStatus WINGDIPAPI	GdipTranslateTextureTransform (GpTexture *brush, REAL dx, REAL dy, GpMatrixOrder order)
GpStatus WINGDIPAPI	GdipGetLineRect (GpLineGradient *brush, GpRectF *rect)
GpStatus WINGDIPAPI	GdipGetLineRectI (GpLineGradient *brush, GpRect *rect)
GpStatus WINGDIPAPI	GdipRotateLineTransform (GpLineGradient *brush, REAL angle, GpMatrixOrder order)

Variables
static const char	HatchBrushes [][8]

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 27 of file brush.c.

Function Documentation

create_line_brush()

static GpStatus create_line_brush ( const GpRectF *  rect, ARGB  startcolor, ARGB  endcolor, GpWrapMode  wrap, GpLineGradient **  line  )

static

Definition at line 297 of file brush.c.

{
    *line = heap_alloc_zero(sizeof(GpLineGradient));
    if(!*line)  return OutOfMemory;
 
    (*line)->brush.bt = BrushTypeLinearGradient;
    (*line)->startcolor = startcolor;
    (*line)->endcolor = endcolor;
    (*line)->wrap = wrap;
    (*line)->gamma = FALSE;
    (*line)->rect = *rect;
    (*line)->blendcount = 1;
    (*line)->blendfac = heap_alloc_zero(sizeof(REAL));
    (*line)->blendpos = heap_alloc_zero(sizeof(REAL));
 
    if (!(*line)->blendfac || !(*line)->blendpos)
    {
        heap_free((*line)->blendfac);
        heap_free((*line)->blendpos);
        heap_free(*line);
        *line = NULL;
        return OutOfMemory;
    }
 
    (*line)->blendfac[0] = 1.0f;
    (*line)->blendpos[0] = 1.0f;
 
    (*line)->pblendcolor = NULL;
    (*line)->pblendpos = NULL;
    (*line)->pblendcount = 0;
 
    GdipSetMatrixElements(&(*line)->transform, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
 
    return Ok;
}

Referenced by GdipCreateLineBrush(), and GdipCreateLineBrushFromRectWithAngle().

create_path_gradient()

static GpStatus create_path_gradient ( GpPath *  path, ARGB  centercolor, GpPathGradient **  grad  )

static

Definition at line 604 of file brush.c.

{
    GpRectF bounds;
 
    if(!path || !grad)
        return InvalidParameter;
 
    if (path->pathdata.Count < 2)
        return OutOfMemory;
 
    GdipGetPathWorldBounds(path, &bounds, NULL, NULL);
 
    *grad = heap_alloc_zero(sizeof(GpPathGradient));
    if (!*grad)
    {
        return OutOfMemory;
    }
 
    GdipSetMatrixElements(&(*grad)->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 
    (*grad)->blendfac = heap_alloc_zero(sizeof(REAL));
    (*grad)->blendpos = heap_alloc_zero(sizeof(REAL));
    (*grad)->surroundcolors = heap_alloc_zero(sizeof(ARGB));
    if(!(*grad)->blendfac || !(*grad)->blendpos || !(*grad)->surroundcolors){
        heap_free((*grad)->blendfac);
        heap_free((*grad)->blendpos);
        heap_free((*grad)->surroundcolors);
        heap_free(*grad);
        *grad = NULL;
        return OutOfMemory;
    }
    (*grad)->blendfac[0] = 1.0;
    (*grad)->blendpos[0] = 1.0;
    (*grad)->blendcount  = 1;
 
    (*grad)->path = path;
 
    (*grad)->brush.bt = BrushTypePathGradient;
    (*grad)->centercolor = centercolor;
    (*grad)->wrap = WrapModeClamp;
    (*grad)->gamma = FALSE;
    /* FIXME: this should be set to the "centroid" of the path by default */
    (*grad)->center.X = bounds.X + bounds.Width / 2;
    (*grad)->center.Y = bounds.Y + bounds.Height / 2;
    (*grad)->focus.X = 0.0;
    (*grad)->focus.Y = 0.0;
    (*grad)->surroundcolors[0] = 0xffffffff;
    (*grad)->surroundcolorcount = 1;
 
    TRACE("<-- %p\n", *grad);
 
    return Ok;
}

Referenced by GdipCreatePathGradient(), GdipCreatePathGradientFromPath(), and GdipCreatePathGradientI().

GdipCloneBrush()

GpStatus WINGDIPAPI GdipCloneBrush	(	GpBrush *	brush,
		GpBrush **	clone
	)

Definition at line 70 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, clone);
 
    if(!brush || !clone)
        return InvalidParameter;
 
    switch(brush->bt){
        case BrushTypeSolidColor:
        {
            *clone = heap_alloc_zero(sizeof(GpSolidFill));
            if (!*clone) return OutOfMemory;
            memcpy(*clone, brush, sizeof(GpSolidFill));
            break;
        }
        case BrushTypeHatchFill:
        {
            GpHatch *hatch = (GpHatch*)brush;
 
            return GdipCreateHatchBrush(hatch->hatchstyle, hatch->forecol, hatch->backcol, (GpHatch**)clone);
        }
        case BrushTypePathGradient:{
            GpPathGradient *src, *dest;
            INT count, pcount;
            GpStatus stat;
 
            *clone = heap_alloc_zero(sizeof(GpPathGradient));
            if (!*clone) return OutOfMemory;
 
            src = (GpPathGradient*) brush,
            dest = (GpPathGradient*) *clone;
 
            memcpy(dest, src, sizeof(GpPathGradient));
 
            stat = GdipClonePath(src->path, &dest->path);
 
            if(stat != Ok){
                heap_free(dest);
                return stat;
            }
 
            dest->transform = src->transform;
 
            /* blending */
            count = src->blendcount;
            dest->blendcount = count;
            dest->blendfac = heap_alloc_zero(count * sizeof(REAL));
            dest->blendpos = heap_alloc_zero(count * sizeof(REAL));
            dest->surroundcolors = heap_alloc_zero(dest->surroundcolorcount * sizeof(ARGB));
            pcount = dest->pblendcount;
            if (pcount)
            {
                dest->pblendcolor = heap_alloc_zero(pcount * sizeof(ARGB));
                dest->pblendpos = heap_alloc_zero(pcount * sizeof(REAL));
            }
 
            if(!dest->blendfac || !dest->blendpos || !dest->surroundcolors ||
               (pcount && (!dest->pblendcolor || !dest->pblendpos))){
                GdipDeletePath(dest->path);
                heap_free(dest->blendfac);
                heap_free(dest->blendpos);
                heap_free(dest->surroundcolors);
                heap_free(dest->pblendcolor);
                heap_free(dest->pblendpos);
                heap_free(dest);
                return OutOfMemory;
            }
 
            memcpy(dest->blendfac, src->blendfac, count * sizeof(REAL));
            memcpy(dest->blendpos, src->blendpos, count * sizeof(REAL));
            memcpy(dest->surroundcolors, src->surroundcolors, dest->surroundcolorcount * sizeof(ARGB));
 
            if (pcount)
            {
                memcpy(dest->pblendcolor, src->pblendcolor, pcount * sizeof(ARGB));
                memcpy(dest->pblendpos, src->pblendpos, pcount * sizeof(REAL));
            }
 
            break;
        }
        case BrushTypeLinearGradient:{
            GpLineGradient *dest, *src;
            INT count, pcount;
 
            dest = heap_alloc_zero(sizeof(GpLineGradient));
            if(!dest)    return OutOfMemory;
 
            src = (GpLineGradient*)brush;
 
            memcpy(dest, src, sizeof(GpLineGradient));
 
            count = dest->blendcount;
            dest->blendfac = heap_alloc_zero(count * sizeof(REAL));
            dest->blendpos = heap_alloc_zero(count * sizeof(REAL));
            pcount = dest->pblendcount;
            if (pcount)
            {
                dest->pblendcolor = heap_alloc_zero(pcount * sizeof(ARGB));
                dest->pblendpos = heap_alloc_zero(pcount * sizeof(REAL));
            }
 
            if (!dest->blendfac || !dest->blendpos ||
                (pcount && (!dest->pblendcolor || !dest->pblendpos)))
            {
                heap_free(dest->blendfac);
                heap_free(dest->blendpos);
                heap_free(dest->pblendcolor);
                heap_free(dest->pblendpos);
                heap_free(dest);
                return OutOfMemory;
            }
 
            dest->transform = src->transform;
 
            memcpy(dest->blendfac, src->blendfac, count * sizeof(REAL));
            memcpy(dest->blendpos, src->blendpos, count * sizeof(REAL));
 
            if (pcount)
            {
                memcpy(dest->pblendcolor, src->pblendcolor, pcount * sizeof(ARGB));
                memcpy(dest->pblendpos, src->pblendpos, pcount * sizeof(REAL));
            }
 
            *clone = &dest->brush;
            break;
        }
        case BrushTypeTextureFill:
        {
            GpStatus stat;
            GpTexture *texture = (GpTexture*)brush;
            GpTexture *new_texture;
            UINT width, height;
 
            stat = GdipGetImageWidth(texture->image, &width);
            if (stat != Ok) return stat;
            stat = GdipGetImageHeight(texture->image, &height);
            if (stat != Ok) return stat;
 
            stat = GdipCreateTextureIA(texture->image, texture->imageattributes, 0, 0, width, height, &new_texture);
 
            if (stat == Ok)
            {
                new_texture->transform = texture->transform;
                *clone = &new_texture->brush;
            }
            else
                *clone = NULL;
 
            return stat;
        }
        default:
            ERR("not implemented for brush type %d\n", brush->bt);
            return NotImplemented;
    }
 
    TRACE("<-- %p\n", *clone);
    return Ok;
}

Referenced by GdipClonePen(), GdipCreatePen2(), GdipGetPenBrushFill(), and GdipSetPenBrushFill().

GdipCreateHatchBrush()

GpStatus WINGDIPAPI GdipCreateHatchBrush	(	GpHatchStyle	hatchstyle,
		ARGB	forecol,
		ARGB	backcol,
		GpHatch **	brush
	)

Definition at line 276 of file brush.c.

{
    TRACE("(%d, %d, %d, %p)\n", hatchstyle, forecol, backcol, brush);
 
    if(!brush)  return InvalidParameter;
 
    if(hatchstyle < HatchStyleMin || hatchstyle > HatchStyleMax)
        return InvalidParameter;
 
    *brush = heap_alloc_zero(sizeof(GpHatch));
    if (!*brush) return OutOfMemory;
 
    (*brush)->brush.bt = BrushTypeHatchFill;
    (*brush)->forecol = forecol;
    (*brush)->backcol = backcol;
    (*brush)->hatchstyle = hatchstyle;
    TRACE("<-- %p\n", *brush);
 
    return Ok;
}

Referenced by GdipCloneBrush(), metafile_deserialize_brush(), test_createHatchBrush(), and test_getHatchStyle().

GdipCreateLineBrush()

GpStatus WINGDIPAPI GdipCreateLineBrush	(	GDIPCONST GpPointF *	startpoint,
		GDIPCONST GpPointF *	endpoint,
		ARGB	startcolor,
		ARGB	endcolor,
		GpWrapMode	wrap,
		GpLineGradient **	line
	)

Definition at line 372 of file brush.c.

{
    GpStatus stat;
    GpRectF rect;
 
    TRACE("(%s, %s, %x, %x, %d, %p)\n", debugstr_pointf(startpoint),
          debugstr_pointf(endpoint), startcolor, endcolor, wrap, line);
 
    if(!line || !startpoint || !endpoint || wrap == WrapModeClamp)
        return InvalidParameter;
 
    if (startpoint->X == endpoint->X && startpoint->Y == endpoint->Y)
        return OutOfMemory;
 
    rect.X = startpoint->X < endpoint->X ? startpoint->X : endpoint->X;
    rect.Y = startpoint->Y < endpoint->Y ? startpoint->Y : endpoint->Y;
    rect.Width = fabs(startpoint->X - endpoint->X);
    rect.Height = fabs(startpoint->Y - endpoint->Y);
 
    if (rect.Width == 0.0f)
    {
        rect.X -= rect.Height / 2.0f;
        rect.Width = rect.Height;
    }
    else if (rect.Height == 0.0f)
    {
        rect.Y -= rect.Width / 2.0f;
        rect.Height = rect.Width;
    }
 
    stat = create_line_brush(&rect, startcolor, endcolor, wrap, line);
    if (stat != Ok)
        return stat;
 
    linegradient_init_transform(startpoint, endpoint, *line);
 
    TRACE("<-- %p\n", *line);
 
    return Ok;
}

Referenced by GdipCreateLineBrushI(), metafile_deserialize_brush(), test_constructor_destructor2(), test_getgamma(), test_gradientgetrect(), test_lineblend(), test_linelinearblend(), test_penfilltype(), and test_transform().

GdipCreateLineBrushFromRect()

GpStatus WINGDIPAPI GdipCreateLineBrushFromRect	(	GDIPCONST GpRectF *	rect,
		ARGB	startcolor,
		ARGB	endcolor,
		LinearGradientMode	mode,
		GpWrapMode	wrap,
		GpLineGradient **	line
	)

Definition at line 436 of file brush.c.

{
    float angle;
 
    TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
          wrap, line);
 
    if(!line || !rect)
        return InvalidParameter;
 
    switch (mode)
    {
    case LinearGradientModeHorizontal:
        angle = 0.0f;
        break;
    case LinearGradientModeVertical:
        angle = 90.0f;
        break;
    case LinearGradientModeForwardDiagonal:
        angle = 45.0f;
        break;
    case LinearGradientModeBackwardDiagonal:
        angle = 135.0f;
        break;
    default:
        return InvalidParameter;
    }
 
    return GdipCreateLineBrushFromRectWithAngle(rect, startcolor, endcolor, angle, TRUE, wrap, line);
}

Referenced by GdipCreateLineBrushFromRectI(), test_gradientgetrect(), and test_transform().

GdipCreateLineBrushFromRectI()

GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI	(	GDIPCONST GpRect *	rect,
		ARGB	startcolor,
		ARGB	endcolor,
		LinearGradientMode	mode,
		GpWrapMode	wrap,
		GpLineGradient **	line
	)

Definition at line 469 of file brush.c.

{
    GpRectF rectF;
 
    TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
          wrap, line);
 
    rectF.X      = (REAL) rect->X;
    rectF.Y      = (REAL) rect->Y;
    rectF.Width  = (REAL) rect->Width;
    rectF.Height = (REAL) rect->Height;
 
    return GdipCreateLineBrushFromRect(&rectF, startcolor, endcolor, mode, wrap, line);
}

Referenced by GdipCreateLineBrushFromRectWithAngleI().

GdipCreateLineBrushFromRectWithAngle()

GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngle	(	GDIPCONST GpRectF *	rect,
		ARGB	startcolor,
		ARGB	endcolor,
		REAL	angle,
		BOOL	isAngleScalable,
		GpWrapMode	wrap,
		GpLineGradient **	line
	)

Definition at line 489 of file brush.c.

{
    GpStatus stat;
    REAL exofs, eyofs, far_x, far_y;
    REAL sin_angle, cos_angle, sin_cos_angle;
    GpPointF start, end;
 
    TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
          wrap, line);
 
    if (!rect || !line || wrap == WrapModeClamp)
        return InvalidParameter;
 
    if (!rect->Width || !rect->Height)
        return OutOfMemory;
 
    angle = fmodf(angle, 360);
    if (angle < 0)
        angle += 360;
 
    if (isAngleScalable)
    {
        float add_angle = 0;
 
        while(angle >= 90) {
            angle -= 180;
            add_angle += M_PI;
        }
 
        if (angle != 90 && angle != -90)
            angle = atan((rect->Width / rect->Height) * tan(deg2rad(angle)));
        else
            angle = deg2rad(angle);
        angle += add_angle;
    }
    else
    {
        angle = deg2rad(angle);
    }
 
    sin_angle = sinf(angle);
    cos_angle = cosf(angle);
    sin_cos_angle = sin_angle * cos_angle;
 
    far_x = rect->X + rect->Width;
    far_y = rect->Y + rect->Height;
 
    if (angle == 0.0f)
    {
        start.X = min(rect->X, far_x);
        start.Y = rect->Y;
        end.X = max(rect->X, far_x);
        end.Y = rect->Y;
    }
    else if (sin_cos_angle >= 0)
    {
        start.X = min(rect->X, far_x);
        start.Y = min(rect->Y, far_y);
        end.X = max(rect->X, far_x);
        end.Y = max(rect->Y, far_y);
    }
    else
    {
        start.X = max(rect->X, far_x);
        start.Y = min(rect->Y, far_y);
        end.X = min(rect->X, far_x);
        end.Y = max(rect->Y, far_y);
    }
 
    stat = create_line_brush(rect, startcolor, endcolor, wrap, line);
    if (stat != Ok || angle == 0.0f)
        return stat;
 
    if (sin_cos_angle >= 0)
    {
        exofs = rect->Height * sin_cos_angle + rect->Width * cos_angle * cos_angle;
        eyofs = rect->Height * sin_angle * sin_angle + rect->Width * sin_cos_angle;
    }
    else
    {
        exofs = rect->Width * sin_angle * sin_angle + rect->Height * sin_cos_angle;
        eyofs = -rect->Width * sin_cos_angle + rect->Height * sin_angle * sin_angle;
    }
 
    if (sin_angle >= 0)
    {
        end.X = rect->X + exofs;
        end.Y = rect->Y + eyofs;
    }
    else
    {
        end.X = start.X;
        end.Y = start.Y;
        start.X = rect->X + exofs;
        start.Y = rect->Y + eyofs;
    }
 
    linegradient_init_transform(&start, &end, *line);
 
    return stat;
}

Referenced by GdipCreateLineBrushFromRect(), test_createLineBrushFromRectWithAngle(), and test_gradientgetrect().

GdipCreateLineBrushFromRectWithAngleI()

GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngleI	(	GDIPCONST GpRect *	rect,
		ARGB	startcolor,
		ARGB	endcolor,
		REAL	angle,
		BOOL	isAngleScalable,
		GpWrapMode	wrap,
		GpLineGradient **	line
	)

Definition at line 593 of file brush.c.

{
    TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
          wrap, line);
 
    return GdipCreateLineBrushFromRectI(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
                                        wrap, line);
}

GdipCreateLineBrushI()

GpStatus WINGDIPAPI GdipCreateLineBrushI	(	GDIPCONST GpPoint *	startpoint,
		GDIPCONST GpPoint *	endpoint,
		ARGB	startcolor,
		ARGB	endcolor,
		GpWrapMode	wrap,
		GpLineGradient **	line
	)

Definition at line 415 of file brush.c.

{
    GpPointF stF;
    GpPointF endF;
 
    TRACE("(%p, %p, %x, %x, %d, %p)\n", startpoint, endpoint,
          startcolor, endcolor, wrap, line);
 
    if(!startpoint || !endpoint)
        return InvalidParameter;
 
    stF.X  = (REAL)startpoint->X;
    stF.Y  = (REAL)startpoint->Y;
    endF.X = (REAL)endpoint->X;
    endF.Y = (REAL)endpoint->Y;
 
    return GdipCreateLineBrush(&stF, &endF, startcolor, endcolor, wrap, line);
}

GdipCreatePathGradient()

GpStatus WINGDIPAPI GdipCreatePathGradient	(	GDIPCONST GpPointF *	points,
		INT	count,
		GpWrapMode	wrap,
		GpPathGradient **	grad
	)

Definition at line 658 of file brush.c.

{
    GpStatus stat;
    GpPath *path;
 
    TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
 
    if(!grad)
        return InvalidParameter;
 
    if(!points || count <= 0)
        return OutOfMemory;
 
    stat = GdipCreatePath(FillModeAlternate, &path);
 
    if (stat == Ok)
    {
        stat = GdipAddPathLine2(path, points, count);
 
        if (stat == Ok)
            stat = create_path_gradient(path, 0xff000000, grad);
 
        if (stat != Ok)
            GdipDeletePath(path);
    }
 
    if (stat == Ok)
        (*grad)->wrap = wrap;
 
    return stat;
}

Referenced by test_getblend(), test_getbounds(), test_gradientblendcount(), test_gradientsurroundcolorcount(), test_pathgradientblend(), test_pathgradientcenterpoint(), test_pathgradientpath(), and test_pathgradientpresetblend().

GdipCreatePathGradientFromPath()

GpStatus WINGDIPAPI GdipCreatePathGradientFromPath	(	GDIPCONST GpPath *	path,
		GpPathGradient **	grad
	)

Definition at line 727 of file brush.c.

{
    GpStatus stat;
    GpPath *new_path;
 
    TRACE("(%p, %p)\n", path, grad);
 
    if(!grad)
        return InvalidParameter;
 
    if (!path)
        return OutOfMemory;
 
    stat = GdipClonePath((GpPath*)path, &new_path);
 
    if (stat == Ok)
    {
        stat = create_path_gradient(new_path, 0xffffffff, grad);
 
        if (stat != Ok)
            GdipDeletePath(new_path);
    }
 
    return stat;
}

GdipCreatePathGradientI()

GpStatus WINGDIPAPI GdipCreatePathGradientI	(	GDIPCONST GpPoint *	points,
		INT	count,
		GpWrapMode	wrap,
		GpPathGradient **	grad
	)

Definition at line 691 of file brush.c.

{
    GpStatus stat;
    GpPath *path;
 
    TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
 
    if(!grad)
        return InvalidParameter;
 
    if(!points || count <= 0)
        return OutOfMemory;
 
    stat = GdipCreatePath(FillModeAlternate, &path);
 
    if (stat == Ok)
    {
        stat = GdipAddPathLine2I(path, points, count);
 
        if (stat == Ok)
            stat = create_path_gradient(path, 0xff000000, grad);
 
        if (stat != Ok)
            GdipDeletePath(path);
    }
 
    if (stat == Ok)
        (*grad)->wrap = wrap;
 
    return stat;
}

GdipCreateSolidFill()

GpStatus WINGDIPAPI GdipCreateSolidFill	(	ARGB	color,
		GpSolidFill **	sf
	)

Definition at line 757 of file brush.c.

{
    TRACE("(%x, %p)\n", color, sf);
 
    if(!sf)  return InvalidParameter;
 
    *sf = heap_alloc_zero(sizeof(GpSolidFill));
    if (!*sf) return OutOfMemory;
 
    (*sf)->brush.bt = BrushTypeSolidColor;
    (*sf)->color = color;
 
    TRACE("<-- %p\n", *sf);
 
    return Ok;
}

Referenced by GdipCreatePen1(), GdipGraphicsClear(), GdipPlayMetafileRecord(), metafile_deserialize_brush(), test_brushfill(), test_clipping(), test_constructor_destructor(), test_containers(), test_fillpath(), test_fillrect(), test_GdipDrawString(), test_GdipFillClosedCurve(), test_GdipFillClosedCurve2(), test_GdipFillClosedCurve2I(), test_GdipFillClosedCurveI(), test_GdipFillPath(), test_GdipFillRectangles(), test_GdipFillRectanglesOnMemoryDCSolidBrush(), test_Get_Release_DC(), test_hdc_caching(), test_nullframerect(), test_pagetransform(), test_penfilltype(), test_string_functions(), test_type(), and test_worldtransform().

GdipCreateTexture()

GpStatus WINGDIPAPI GdipCreateTexture	(	GpImage *	image,
		GpWrapMode	wrapmode,
		GpTexture **	texture
	)

Definition at line 786 of file brush.c.

{
    UINT width, height;
    GpImageAttributes *attributes;
    GpStatus stat;
 
    TRACE("%p, %d %p\n", image, wrapmode, texture);
 
    if (!(image && texture))
        return InvalidParameter;
 
    stat = GdipGetImageWidth(image, &width);
    if (stat != Ok) return stat;
    stat = GdipGetImageHeight(image, &height);
    if (stat != Ok) return stat;
 
    stat = GdipCreateImageAttributes(&attributes);
 
    if (stat == Ok)
    {
        attributes->wrap = wrapmode;
 
        stat = GdipCreateTextureIA(image, attributes, 0, 0, width, height,
            texture);
 
        GdipDisposeImageAttributes(attributes);
    }
 
    return stat;
}

Referenced by metafile_deserialize_brush(), test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipFillRectanglesOnMemoryDCTextureBrush(), test_texturewrap(), and test_transform().

GdipCreateTexture2()

GpStatus WINGDIPAPI GdipCreateTexture2	(	GpImage *	image,
		GpWrapMode	wrapmode,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height,
		GpTexture **	texture
	)

Definition at line 821 of file brush.c.

{
    GpImageAttributes *attributes;
    GpStatus stat;
 
    TRACE("%p %d %f %f %f %f %p\n", image, wrapmode,
            x, y, width, height, texture);
 
    stat = GdipCreateImageAttributes(&attributes);
 
    if (stat == Ok)
    {
        attributes->wrap = wrapmode;
 
        stat = GdipCreateTextureIA(image, attributes, x, y, width, height,
                texture);
 
        GdipDisposeImageAttributes(attributes);
    }
 
    return stat;
}

GdipCreateTexture2I()

GpStatus WINGDIPAPI GdipCreateTexture2I	(	GpImage *	image,
		GpWrapMode	wrapmode,
		INT	x,
		INT	y,
		INT	width,
		INT	height,
		GpTexture **	texture
	)

Definition at line 928 of file brush.c.

{
    GpImageAttributes *imageattr;
    GpStatus stat;
 
    TRACE("%p %d %d %d %d %d %p\n", image, wrapmode, x, y, width, height,
            texture);
 
    stat = GdipCreateImageAttributes(&imageattr);
 
    if (stat == Ok)
    {
        imageattr->wrap = wrapmode;
 
        stat = GdipCreateTextureIA(image, imageattr, x, y, width, height, texture);
        GdipDisposeImageAttributes(imageattr);
    }
 
    return stat;
}

GdipCreateTextureIA()

GpStatus WINGDIPAPI GdipCreateTextureIA	(	GpImage *	image,
		GDIPCONST GpImageAttributes *	imageattr,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height,
		GpTexture **	texture
	)

Definition at line 848 of file brush.c.

{
    GpStatus status;
    GpImage *new_image=NULL;
 
    TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %p)\n", image, imageattr, x, y, width, height,
           texture);
 
    if(!image || !texture || x < 0.0 || y < 0.0 || width < 0.0 || height < 0.0)
        return InvalidParameter;
 
    *texture = NULL;
 
    if(image->type != ImageTypeBitmap){
        FIXME("not implemented for image type %d\n", image->type);
        return NotImplemented;
    }
 
    status = GdipCloneBitmapArea(x, y, width, height, PixelFormatDontCare, (GpBitmap*)image, (GpBitmap**)&new_image);
    if (status != Ok)
        return status;
 
    *texture = heap_alloc_zero(sizeof(GpTexture));
    if (!*texture){
        status = OutOfMemory;
        goto exit;
    }
 
    GdipSetMatrixElements(&(*texture)->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 
    if (imageattr)
    {
        status = GdipCloneImageAttributes(imageattr, &(*texture)->imageattributes);
    }
    else
    {
        status = GdipCreateImageAttributes(&(*texture)->imageattributes);
        if (status == Ok)
            (*texture)->imageattributes->wrap = WrapModeTile;
    }
    if (status == Ok)
    {
        (*texture)->brush.bt = BrushTypeTextureFill;
        (*texture)->image = new_image;
    }
 
exit:
    if (status == Ok)
    {
        TRACE("<-- %p\n", *texture);
    }
    else
    {
        if (*texture)
        {
            GdipDisposeImageAttributes((*texture)->imageattributes);
            heap_free(*texture);
            *texture = NULL;
        }
        GdipDisposeImage(new_image);
        TRACE("<-- error %u\n", status);
    }
 
    return status;
}

Referenced by GdipCloneBrush(), GdipCreateTexture(), GdipCreateTexture2(), GdipCreateTexture2I(), and GdipCreateTextureIAI().

GdipCreateTextureIAI()

GpStatus WINGDIPAPI GdipCreateTextureIAI	(	GpImage *	image,
		GDIPCONST GpImageAttributes *	imageattr,
		INT	x,
		INT	y,
		INT	width,
		INT	height,
		GpTexture **	texture
	)

Definition at line 919 of file brush.c.

{
    TRACE("(%p, %p, %d, %d, %d, %d, %p)\n", image, imageattr, x, y, width, height,
           texture);
 
    return GdipCreateTextureIA(image,imageattr,(REAL)x,(REAL)y,(REAL)width,(REAL)height,texture);
}

GdipDeleteBrush()

GpStatus WINGDIPAPI GdipDeleteBrush

(

GpBrush *

brush

)

Definition at line 994 of file brush.c.

{
    TRACE("(%p)\n", brush);
 
    if(!brush)  return InvalidParameter;
 
    switch(brush->bt)
    {
        case BrushTypePathGradient:
            GdipDeletePath(((GpPathGradient*) brush)->path);
            heap_free(((GpPathGradient*) brush)->blendfac);
            heap_free(((GpPathGradient*) brush)->blendpos);
            heap_free(((GpPathGradient*) brush)->surroundcolors);
            heap_free(((GpPathGradient*) brush)->pblendcolor);
            heap_free(((GpPathGradient*) brush)->pblendpos);
            break;
        case BrushTypeLinearGradient:
            heap_free(((GpLineGradient*)brush)->blendfac);
            heap_free(((GpLineGradient*)brush)->blendpos);
            heap_free(((GpLineGradient*)brush)->pblendcolor);
            heap_free(((GpLineGradient*)brush)->pblendpos);
            break;
        case BrushTypeTextureFill:
            GdipDisposeImage(((GpTexture*)brush)->image);
            GdipDisposeImageAttributes(((GpTexture*)brush)->imageattributes);
            heap_free(((GpTexture*)brush)->bitmap_bits);
            break;
        default:
            break;
    }
 
    heap_free(brush);
 
    return Ok;
}

Referenced by GdipCreatePen1(), GdipDeletePen(), GdipGraphicsClear(), GdipPlayMetafileRecord(), GdipSetPenBrushFill(), metafile_deserialize_brush(), metafile_free_object_table_entry(), METAFILE_PlaybackObject(), test_brushfill(), test_clipping(), test_constructor_destructor(), test_constructor_destructor2(), test_containers(), test_createHatchBrush(), test_createLineBrushFromRectWithAngle(), test_fillpath(), test_fillrect(), test_GdipDrawString(), test_GdipFillClosedCurve(), test_GdipFillClosedCurve2(), test_GdipFillClosedCurve2I(), test_GdipFillClosedCurveI(), test_GdipFillPath(), test_GdipFillRectangles(), test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipFillRectanglesOnMemoryDCSolidBrush(), test_GdipFillRectanglesOnMemoryDCTextureBrush(), test_Get_Release_DC(), test_getblend(), test_getbounds(), test_getgamma(), test_getHatchStyle(), test_gradientblendcount(), test_gradientgetrect(), test_gradientsurroundcolorcount(), test_hdc_caching(), test_lineblend(), test_linelinearblend(), test_nullframerect(), test_pagetransform(), test_pathgradientblend(), test_pathgradientcenterpoint(), test_pathgradientpath(), test_pathgradientpresetblend(), test_penfilltype(), test_string_functions(), test_texturewrap(), test_transform(), test_type(), and test_worldtransform().

GdipGetBrushType()

GpStatus WINGDIPAPI GdipGetBrushType	(	GpBrush *	brush,
		GpBrushType *	type
	)

Definition at line 950 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, type);
 
    if(!brush || !type)  return InvalidParameter;
 
    *type = brush->bt;
 
    return Ok;
}

Referenced by test_brushfill(), and test_type().

GdipGetHatchBackgroundColor()

GpStatus WINGDIPAPI GdipGetHatchBackgroundColor	(	GpHatch *	brush,
		ARGB *	backcol
	)

Definition at line 961 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, backcol);
 
    if(!brush || !backcol)  return InvalidParameter;
 
    *backcol = brush->backcol;
 
    return Ok;
}

GdipGetHatchForegroundColor()

GpStatus WINGDIPAPI GdipGetHatchForegroundColor	(	GpHatch *	brush,
		ARGB *	forecol
	)

Definition at line 972 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, forecol);
 
    if(!brush || !forecol)  return InvalidParameter;
 
    *forecol = brush->forecol;
 
    return Ok;
}

GdipGetHatchStyle()

GpStatus WINGDIPAPI GdipGetHatchStyle	(	GpHatch *	brush,
		GpHatchStyle *	hatchstyle
	)

Definition at line 983 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, hatchstyle);
 
    if(!brush || !hatchstyle)  return InvalidParameter;
 
    *hatchstyle = brush->hatchstyle;
 
    return Ok;
}

Referenced by test_getHatchStyle().

GdipGetLineBlend()

GpStatus WINGDIPAPI GdipGetLineBlend	(	GpLineGradient *	brush,
		REAL *	factors,
		REAL *	positions,
		INT	count
	)

Definition at line 1403 of file brush.c.

{
    TRACE("(%p, %p, %p, %i)\n", brush, factors, positions, count);
 
    if (!brush || !factors || !positions || count <= 0 || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    if (count < brush->blendcount)
        return InsufficientBuffer;
 
    memcpy(factors, brush->blendfac, brush->blendcount * sizeof(REAL));
    memcpy(positions, brush->blendpos, brush->blendcount * sizeof(REAL));
 
    return Ok;
}

Referenced by test_lineblend(), and test_linelinearblend().

GdipGetLineBlendCount()

GpStatus WINGDIPAPI GdipGetLineBlendCount	(	GpLineGradient *	brush,
		INT *	count
	)

Definition at line 1420 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, count);
 
    if (!brush || !count || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    *count = brush->blendcount;
 
    return Ok;
}

Referenced by test_lineblend(), and test_linelinearblend().

GdipGetLineColors()

GpStatus WINGDIPAPI GdipGetLineColors	(	GpLineGradient *	brush,
		ARGB *	colors
	)

Definition at line 1983 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, colors);
 
    if(!brush || !colors || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    colors[0] = brush->startcolor;
    colors[1] = brush->endcolor;
 
    return Ok;
}

Referenced by test_gradientgetrect().

GdipGetLineGammaCorrection()

GpStatus WINGDIPAPI GdipGetLineGammaCorrection	(	GpLineGradient *	line,
		BOOL *	usinggamma
	)

Definition at line 1030 of file brush.c.

{
    TRACE("(%p, %p)\n", line, usinggamma);
 
    if(!line || !usinggamma)
        return InvalidParameter;
 
    *usinggamma = line->gamma;
 
    return Ok;
}

Referenced by test_getgamma().

GdipGetLinePresetBlend()

GpStatus WINGDIPAPI GdipGetLinePresetBlend	(	GpLineGradient *	brush,
		ARGB *	blend,
		REAL *	positions,
		INT	count
	)

Definition at line 2077 of file brush.c.

{
    if (!brush || !blend || !positions || count < 2 || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    if (brush->pblendcount == 0)
        return GenericError;
 
    if (count < brush->pblendcount)
        return InsufficientBuffer;
 
    memcpy(blend, brush->pblendcolor, sizeof(ARGB) * brush->pblendcount);
    memcpy(positions, brush->pblendpos, sizeof(REAL) * brush->pblendcount);
 
    return Ok;
}

Referenced by test_lineblend().

GdipGetLinePresetBlendCount()

GpStatus WINGDIPAPI GdipGetLinePresetBlendCount	(	GpLineGradient *	brush,
		INT *	count
	)

Definition at line 2095 of file brush.c.

{
    if (!brush || !count || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    *count = brush->pblendcount;
 
    return Ok;
}

Referenced by test_lineblend().

GdipGetLineRect()

GpStatus WINGDIPAPI GdipGetLineRect	(	GpLineGradient *	brush,
		GpRectF *	rect
	)

Definition at line 2191 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, rect);
 
    if(!brush || !rect || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    *rect = brush->rect;
 
    return Ok;
}

Referenced by GdipGetLineRectI(), test_gradientgetrect(), and test_transform().

GdipGetLineRectI()

GpStatus WINGDIPAPI GdipGetLineRectI	(	GpLineGradient *	brush,
		GpRect *	rect
	)

Definition at line 2203 of file brush.c.

{
    GpRectF  rectF;
    GpStatus ret;
 
    TRACE("(%p, %p)\n", brush, rect);
 
    if(!rect)
        return InvalidParameter;
 
    ret = GdipGetLineRect(brush, &rectF);
 
    if(ret == Ok){
        rect->X      = gdip_round(rectF.X);
        rect->Y      = gdip_round(rectF.Y);
        rect->Width  = gdip_round(rectF.Width);
        rect->Height = gdip_round(rectF.Height);
    }
 
    return ret;
}

GdipGetLineTransform()

GpStatus WINGDIPAPI GdipGetLineTransform	(	GpLineGradient *	brush,
		GpMatrix *	matrix
	)

Definition at line 2129 of file brush.c.

{
    TRACE("(%p,%p)\n", brush, matrix);
 
    if(!brush || !matrix)
        return InvalidParameter;
 
    *matrix = brush->transform;
 
    return Ok;
}

Referenced by test_gradientgetrect(), and test_transform().

GdipGetLineWrapMode()

GpStatus WINGDIPAPI GdipGetLineWrapMode	(	GpLineGradient *	brush,
		GpWrapMode *	wrapmode
	)

Definition at line 1043 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, wrapmode);
 
    if(!brush || !wrapmode || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    *wrapmode = brush->wrap;
 
    return Ok;
}

GdipGetPathGradientBlend()

GpStatus WINGDIPAPI GdipGetPathGradientBlend	(	GpPathGradient *	brush,
		REAL *	blend,
		REAL *	positions,
		INT	count
	)

Definition at line 1055 of file brush.c.

{
    TRACE("(%p, %p, %p, %d)\n", brush, blend, positions, count);
 
    if(!brush || !blend || !positions || count <= 0 || brush->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    if(count < brush->blendcount)
        return InsufficientBuffer;
 
    memcpy(blend, brush->blendfac, count*sizeof(REAL));
    if(brush->blendcount > 1){
        memcpy(positions, brush->blendpos, count*sizeof(REAL));
    }
 
    return Ok;
}

Referenced by test_getblend(), and test_pathgradientblend().

GdipGetPathGradientBlendCount()

GpStatus WINGDIPAPI GdipGetPathGradientBlendCount	(	GpPathGradient *	brush,
		INT *	count
	)

Definition at line 1074 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, count);
 
    if(!brush || !count || brush->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *count = brush->blendcount;
 
    return Ok;
}

Referenced by test_gradientblendcount(), and test_pathgradientblend().

GdipGetPathGradientCenterColor()

GpStatus WINGDIPAPI GdipGetPathGradientCenterColor	(	GpPathGradient *	grad,
		ARGB *	colors
	)

Definition at line 1121 of file brush.c.

{
    TRACE("(%p,%p)\n", grad, colors);
 
    if (!grad || !colors || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *colors = grad->centercolor;
 
    return Ok;
}

GdipGetPathGradientCenterPoint()

GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint	(	GpPathGradient *	grad,
		GpPointF *	point
	)

Definition at line 1086 of file brush.c.

{
    TRACE("(%p, %p)\n", grad, point);
 
    if(!grad || !point || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    point->X = grad->center.X;
    point->Y = grad->center.Y;
 
    return Ok;
}

Referenced by GdipGetPathGradientCenterPointI(), and test_pathgradientcenterpoint().

GdipGetPathGradientCenterPointI()

GpStatus WINGDIPAPI GdipGetPathGradientCenterPointI	(	GpPathGradient *	grad,
		GpPoint *	point
	)

Definition at line 1100 of file brush.c.

{
    GpStatus ret;
    GpPointF ptf;
 
    TRACE("(%p, %p)\n", grad, point);
 
    if(!point)
        return InvalidParameter;
 
    ret = GdipGetPathGradientCenterPoint(grad,&ptf);
 
    if(ret == Ok){
        point->X = gdip_round(ptf.X);
        point->Y = gdip_round(ptf.Y);
    }
 
    return ret;
}

GdipGetPathGradientFocusScales()

GpStatus WINGDIPAPI GdipGetPathGradientFocusScales	(	GpPathGradient *	grad,
		REAL *	x,
		REAL *	y
	)

Definition at line 1134 of file brush.c.

{
    TRACE("(%p, %p, %p)\n", grad, x, y);
 
    if(!grad || !x || !y || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *x = grad->focus.X;
    *y = grad->focus.Y;
 
    return Ok;
}

GdipGetPathGradientGammaCorrection()

GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection	(	GpPathGradient *	grad,
		BOOL *	gamma
	)

Definition at line 1148 of file brush.c.

{
    TRACE("(%p, %p)\n", grad, gamma);
 
    if(!grad || !gamma || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *gamma = grad->gamma;
 
    return Ok;
}

GdipGetPathGradientPath()

GpStatus WINGDIPAPI GdipGetPathGradientPath	(	GpPathGradient *	grad,
		GpPath *	path
	)

Definition at line 1161 of file brush.c.

{
    static int calls;
 
    TRACE("(%p, %p)\n", grad, path);
 
    if (!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

Referenced by test_pathgradientpath().

GdipGetPathGradientPointCount()

GpStatus WINGDIPAPI GdipGetPathGradientPointCount	(	GpPathGradient *	grad,
		INT *	count
	)

Definition at line 1173 of file brush.c.

{
    TRACE("(%p, %p)\n", grad, count);
 
    if(!grad || !count || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *count = grad->path->pathdata.Count;
 
    return Ok;
}

GdipGetPathGradientPresetBlend()

GpStatus WINGDIPAPI GdipGetPathGradientPresetBlend	(	GpPathGradient *	brush,
		ARGB *	blend,
		REAL *	pos,
		INT	count
	)

Definition at line 1616 of file brush.c.

{
    TRACE("(%p,%p,%p,%i)\n", brush, blend, pos, count);
 
    if (count < 0)
        return OutOfMemory;
 
    if (!brush || !blend || !pos || count < 2 || brush->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    if (brush->pblendcount == 0)
        return GenericError;
 
    if (count != brush->pblendcount)
    {
        /* Native lines up the ends of each array, and copies the destination size. */
        FIXME("Braindead behavior on wrong-sized buffer not implemented.\n");
        return InvalidParameter;
    }
 
    memcpy(blend, brush->pblendcolor, sizeof(ARGB) * brush->pblendcount);
    memcpy(pos, brush->pblendpos, sizeof(REAL) * brush->pblendcount);
 
    return Ok;
}

Referenced by test_pathgradientpresetblend().

GdipGetPathGradientPresetBlendCount()

GpStatus WINGDIPAPI GdipGetPathGradientPresetBlendCount	(	GpPathGradient *	brush,
		INT *	count
	)

Definition at line 1643 of file brush.c.

{
    TRACE("(%p,%p)\n", brush, count);
 
    if (!brush || !count || brush->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *count = brush->pblendcount;
 
    return Ok;
}

Referenced by test_pathgradientpresetblend().

GdipGetPathGradientRect()

GpStatus WINGDIPAPI GdipGetPathGradientRect	(	GpPathGradient *	brush,
		GpRectF *	rect
	)

Definition at line 1186 of file brush.c.

{
    GpStatus stat;
 
    TRACE("(%p, %p)\n", brush, rect);
 
    if(!brush || !rect || brush->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    stat = GdipGetPathWorldBounds(brush->path, rect, NULL, NULL);
 
    return stat;
}

Referenced by GdipGetPathGradientRectI(), and test_getbounds().

GdipGetPathGradientRectI()

GpStatus WINGDIPAPI GdipGetPathGradientRectI	(	GpPathGradient *	brush,
		GpRect *	rect
	)

Definition at line 1200 of file brush.c.

{
    GpRectF rectf;
    GpStatus stat;
 
    TRACE("(%p, %p)\n", brush, rect);
 
    if(!brush || !rect)
        return InvalidParameter;
 
    stat = GdipGetPathGradientRect(brush, &rectf);
    if(stat != Ok)  return stat;
 
    rect->X = gdip_round(rectf.X);
    rect->Y = gdip_round(rectf.Y);
    rect->Width  = gdip_round(rectf.Width);
    rect->Height = gdip_round(rectf.Height);
 
    return Ok;
}

GdipGetPathGradientSurroundColorCount()

GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorCount	(	GpPathGradient *	brush,
		INT *	count
	)

Definition at line 1244 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, count);
 
    if (!brush || !count || brush->brush.bt != BrushTypePathGradient)
       return InvalidParameter;
 
    /* Yes, this actually returns the number of points in the path (which is the
     * required size of a buffer to get the surround colors), rather than the
     * number of surround colors. The real count is returned when getting the
     * colors. */
    *count = brush->path->pathdata.Count;
 
    return Ok;
}

Referenced by test_gradientsurroundcolorcount().

GdipGetPathGradientSurroundColorsWithCount()

GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount	(	GpPathGradient *	grad,
		ARGB *	argb,
		INT *	count
	)

Definition at line 1221 of file brush.c.

{
    INT i;
 
    TRACE("(%p,%p,%p)\n", grad, argb, count);
 
    if(!grad || !argb || !count || (*count < grad->path->pathdata.Count) || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    for (i=0; i<grad->path->pathdata.Count; i++)
    {
        if (i < grad->surroundcolorcount)
            argb[i] = grad->surroundcolors[i];
        else
            argb[i] = grad->surroundcolors[grad->surroundcolorcount-1];
    }
 
    *count = grad->surroundcolorcount;
 
    return Ok;
}

Referenced by test_gradientsurroundcolorcount().

GdipGetPathGradientTransform()

GpStatus WINGDIPAPI GdipGetPathGradientTransform	(	GpPathGradient *	grad,
		GpMatrix *	matrix
	)

Definition at line 1858 of file brush.c.

{
    TRACE("(%p,%p)\n", grad, matrix);
 
    if (!grad || !matrix || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *matrix = grad->transform;
 
    return Ok;
}

GdipGetPathGradientWrapMode()

GpStatus WINGDIPAPI GdipGetPathGradientWrapMode	(	GpPathGradient *	brush,
		GpWrapMode *	wrapmode
	)

Definition at line 1260 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, wrapmode);
 
    if(!brush || !wrapmode || brush->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *wrapmode = brush->wrap;
 
    return Ok;
}

GdipGetSolidFillColor()

GpStatus WINGDIPAPI GdipGetSolidFillColor	(	GpSolidFill *	sf,
		ARGB *	argb
	)

Definition at line 1273 of file brush.c.

{
    TRACE("(%p, %p)\n", sf, argb);
 
    if(!sf || !argb)
        return InvalidParameter;
 
    *argb = sf->color;
 
    return Ok;
}

Referenced by GdipGetPenColor(), and test_brushfill().

GdipGetTextureImage()

GpStatus WINGDIPAPI GdipGetTextureImage	(	GpTexture *	brush,
		GpImage **	image
	)

Definition at line 1288 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, image);
 
    if(!brush || !image)
        return InvalidParameter;
 
    return GdipCloneImage(brush->image, image);
}

GdipGetTextureTransform()

GpStatus WINGDIPAPI GdipGetTextureTransform	(	GpTexture *	brush,
		GpMatrix *	matrix
	)

Definition at line 1301 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, matrix);
 
    if(!brush || !matrix)
        return InvalidParameter;
 
    *matrix = brush->transform;
 
    return Ok;
}

Referenced by test_transform().

GdipGetTextureWrapMode()

GpStatus WINGDIPAPI GdipGetTextureWrapMode	(	GpTexture *	brush,
		GpWrapMode *	wrapmode
	)

Definition at line 1316 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, wrapmode);
 
    if(!brush || !wrapmode)
        return InvalidParameter;
 
    *wrapmode = brush->imageattributes->wrap;
 
    return Ok;
}

Referenced by test_texturewrap().

GdipMultiplyLineTransform()

GpStatus WINGDIPAPI GdipMultiplyLineTransform	(	GpLineGradient *	brush,
		GDIPCONST GpMatrix *	matrix,
		GpMatrixOrder	order
	)

Definition at line 2152 of file brush.c.

{
    TRACE("(%p,%p,%u)\n", brush, matrix, order);
 
    if(!brush)
        return InvalidParameter;
 
    if(!matrix)
        return Ok;
 
    return GdipMultiplyMatrix(&brush->transform, matrix, order);
}

Referenced by test_transform().

GdipMultiplyPathGradientTransform()

GpStatus WINGDIPAPI GdipMultiplyPathGradientTransform	(	GpPathGradient *	grad,
		GDIPCONST GpMatrix *	matrix,
		GpMatrixOrder	order
	)

Definition at line 1871 of file brush.c.

{
    TRACE("(%p,%p,%i)\n", grad, matrix, order);
 
    if (!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    return GdipMultiplyMatrix(&grad->transform, matrix, order);
}

GdipMultiplyTextureTransform()

GpStatus WINGDIPAPI GdipMultiplyTextureTransform	(	GpTexture *	brush,
		GDIPCONST GpMatrix *	matrix,
		GpMatrixOrder	order
	)

Definition at line 1331 of file brush.c.

{
    TRACE("(%p, %p, %d)\n", brush, matrix, order);
 
    if(!brush || !matrix)
        return InvalidParameter;
 
    return GdipMultiplyMatrix(&brush->transform, matrix, order);
}

GdipResetLineTransform()

GpStatus WINGDIPAPI GdipResetLineTransform

(

GpLineGradient *

brush

)

Definition at line 2106 of file brush.c.

{
    TRACE("(%p)\n", brush);
 
    if(!brush)
        return InvalidParameter;
 
    return GdipSetMatrixElements(&brush->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
}

Referenced by test_transform().

GdipResetPathGradientTransform()

GpStatus WINGDIPAPI GdipResetPathGradientTransform

(

GpPathGradient *

grad

)

Definition at line 1882 of file brush.c.

{
    TRACE("(%p)\n", grad);
 
    if (!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    return GdipSetMatrixElements(&grad->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
}

GdipResetTextureTransform()

GpStatus WINGDIPAPI GdipResetTextureTransform

(

GpTexture *

brush

)

Definition at line 1345 of file brush.c.

{
    TRACE("(%p)\n", brush);
 
    if(!brush)
        return InvalidParameter;
 
    return GdipSetMatrixElements(&brush->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
}

Referenced by test_transform().

GdipRotateLineTransform()

GpStatus WINGDIPAPI GdipRotateLineTransform	(	GpLineGradient *	brush,
		REAL	angle,
		GpMatrixOrder	order
	)

Definition at line 2225 of file brush.c.

{
    static int calls;
 
    TRACE("(%p,%0.2f,%u)\n", brush, angle, order);
 
    if(!brush || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    if(!(calls++))
        FIXME("(%p, %.2f, %d) stub\n", brush, angle, order);
 
    return NotImplemented;
}

GdipRotatePathGradientTransform()

GpStatus WINGDIPAPI GdipRotatePathGradientTransform	(	GpPathGradient *	grad,
		REAL	angle,
		GpMatrixOrder	order
	)

Definition at line 1892 of file brush.c.

{
    TRACE("(%p,%0.2f,%i)\n", grad, angle, order);
 
    if (!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    return GdipRotateMatrix(&grad->transform, angle, order);
}

GdipRotateTextureTransform()

GpStatus WINGDIPAPI GdipRotateTextureTransform	(	GpTexture *	brush,
		REAL	angle,
		GpMatrixOrder	order
	)

Definition at line 1999 of file brush.c.

{
    TRACE("(%p, %.2f, %d)\n", brush, angle, order);
 
    if(!brush)
        return InvalidParameter;
 
    return GdipRotateMatrix(&brush->transform, angle, order);
}

GdipScaleLineTransform()

GpStatus WINGDIPAPI GdipScaleLineTransform	(	GpLineGradient *	brush,
		REAL	sx,
		REAL	sy,
		GpMatrixOrder	order
	)

Definition at line 2141 of file brush.c.

{
    TRACE("(%p,%0.2f,%0.2f,%u)\n", brush, sx, sy, order);
 
    if(!brush)
        return InvalidParameter;
 
    return GdipScaleMatrix(&brush->transform, sx, sy, order);
}

Referenced by test_transform().

GdipScalePathGradientTransform()

GpStatus WINGDIPAPI GdipScalePathGradientTransform	(	GpPathGradient *	grad,
		REAL	sx,
		REAL	sy,
		GpMatrixOrder	order
	)

Definition at line 1903 of file brush.c.

{
    TRACE("(%p,%0.2f,%0.2f,%i)\n", grad, sx, sy, order);
 
    if (!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    return GdipScaleMatrix(&grad->transform, sx, sy, order);
}

GdipScaleTextureTransform()

GpStatus WINGDIPAPI GdipScaleTextureTransform	(	GpTexture *	brush,
		REAL	sx,
		REAL	sy,
		GpMatrixOrder	order
	)

Definition at line 1358 of file brush.c.

{
    TRACE("(%p, %.2f, %.2f, %d)\n", brush, sx, sy, order);
 
    if(!brush)
        return InvalidParameter;
 
    return GdipScaleMatrix(&brush->transform, sx, sy, order);
}

GdipSetLineBlend()

GpStatus WINGDIPAPI GdipSetLineBlend	(	GpLineGradient *	brush,
		GDIPCONST REAL *	factors,
		GDIPCONST REAL *	positions,
		INT	count
	)

Definition at line 1369 of file brush.c.

{
    REAL *new_blendfac, *new_blendpos;
 
    TRACE("(%p, %p, %p, %i)\n", brush, factors, positions, count);
 
    if(!brush || !factors || !positions || count <= 0 || brush->brush.bt != BrushTypeLinearGradient ||
       (count >= 2 && (positions[0] != 0.0f || positions[count-1] != 1.0f)))
        return InvalidParameter;
 
    new_blendfac = heap_alloc_zero(count * sizeof(REAL));
    new_blendpos = heap_alloc_zero(count * sizeof(REAL));
 
    if (!new_blendfac || !new_blendpos)
    {
        heap_free(new_blendfac);
        heap_free(new_blendpos);
        return OutOfMemory;
    }
 
    memcpy(new_blendfac, factors, count * sizeof(REAL));
    memcpy(new_blendpos, positions, count * sizeof(REAL));
 
    heap_free(brush->blendfac);
    heap_free(brush->blendpos);
 
    brush->blendcount = count;
    brush->blendfac = new_blendfac;
    brush->blendpos = new_blendpos;
 
    return Ok;
}

Referenced by GdipSetLineLinearBlend(), GdipSetLineSigmaBlend(), metafile_deserialize_brush(), and test_lineblend().

GdipSetLineColors()

GpStatus WINGDIPAPI GdipSetLineColors	(	GpLineGradient *	brush,
		ARGB	color1,
		ARGB	color2
	)

Definition at line 1969 of file brush.c.

{
    TRACE("(%p, %x, %x)\n", brush, color1, color2);
 
    if(!brush || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    brush->startcolor = color1;
    brush->endcolor   = color2;
 
    return Ok;
}

GdipSetLineGammaCorrection()

GpStatus WINGDIPAPI GdipSetLineGammaCorrection	(	GpLineGradient *	line,
		BOOL	usegamma
	)

Definition at line 1432 of file brush.c.

{
    TRACE("(%p, %d)\n", line, usegamma);
 
    if(!line || line->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    line->gamma = usegamma;
 
    return Ok;
}

GdipSetLineLinearBlend()

GpStatus WINGDIPAPI GdipSetLineLinearBlend	(	GpLineGradient *	brush,
		REAL	focus,
		REAL	scale
	)

Definition at line 2010 of file brush.c.

{
    REAL factors[3];
    REAL positions[3];
    int num_points = 0;
 
    TRACE("(%p,%.2f,%.2f)\n", brush, focus, scale);
 
    if (!brush) return InvalidParameter;
 
    if (focus != 0.0)
    {
        factors[num_points] = 0.0;
        positions[num_points] = 0.0;
        num_points++;
    }
 
    factors[num_points] = scale;
    positions[num_points] = focus;
    num_points++;
 
    if (focus != 1.0)
    {
        factors[num_points] = 0.0;
        positions[num_points] = 1.0;
        num_points++;
    }
 
    return GdipSetLineBlend(brush, factors, positions, num_points);
}

Referenced by test_linelinearblend().

GdipSetLinePresetBlend()

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

Definition at line 2042 of file brush.c.

{
    ARGB *new_color;
    REAL *new_pos;
    TRACE("(%p,%p,%p,%i)\n", brush, blend, positions, count);
 
    if (!brush || !blend || !positions || count < 2 || brush->brush.bt != BrushTypeLinearGradient ||
        positions[0] != 0.0f || positions[count-1] != 1.0f)
    {
        return InvalidParameter;
    }
 
    new_color = heap_alloc_zero(count * sizeof(ARGB));
    new_pos = heap_alloc_zero(count * sizeof(REAL));
    if (!new_color || !new_pos)
    {
        heap_free(new_color);
        heap_free(new_pos);
        return OutOfMemory;
    }
 
    memcpy(new_color, blend, sizeof(ARGB) * count);
    memcpy(new_pos, positions, sizeof(REAL) * count);
 
    heap_free(brush->pblendcolor);
    heap_free(brush->pblendpos);
 
    brush->pblendcolor = new_color;
    brush->pblendpos = new_pos;
    brush->pblendcount = count;
 
    return Ok;
}

Referenced by metafile_deserialize_brush(), and test_lineblend().

GdipSetLineSigmaBlend()

GpStatus WINGDIPAPI GdipSetLineSigmaBlend	(	GpLineGradient *	line,
		REAL	focus,
		REAL	scale
	)

Definition at line 1445 of file brush.c.

{
    REAL factors[33];
    REAL positions[33];
    int num_points = 0;
    int i;
    const int precision = 16;
    REAL erf_range; /* we use values erf(-erf_range) through erf(+erf_range) */
    REAL min_erf;
    REAL scale_erf;
 
    TRACE("(%p, %0.2f, %0.2f)\n", line, focus, scale);
 
    if(!line || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0 || line->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    /* we want 2 standard deviations */
    erf_range = 2.0 / sqrt(2);
 
    /* calculate the constants we need to normalize the error function to be
        between 0.0 and scale over the range we need */
    min_erf = erf(-erf_range);
    scale_erf = scale / (-2.0 * min_erf);
 
    if (focus != 0.0)
    {
        positions[0] = 0.0;
        factors[0] = 0.0;
        for (i=1; i<precision; i++)
        {
            positions[i] = focus * i / precision;
            factors[i] = scale_erf * (erf(2 * erf_range * i / precision - erf_range) - min_erf);
        }
        num_points += precision;
    }
 
    positions[num_points] = focus;
    factors[num_points] = scale;
    num_points += 1;
 
    if (focus != 1.0)
    {
        for (i=1; i<precision; i++)
        {
            positions[i+num_points-1] = (focus + ((1.0-focus) * i / precision));
            factors[i+num_points-1] = scale_erf * (erf(erf_range - 2 * erf_range * i / precision) - min_erf);
        }
        num_points += precision;
        positions[num_points-1] = 1.0;
        factors[num_points-1] = 0.0;
    }
 
    return GdipSetLineBlend(line, factors, positions, num_points);
}

GdipSetLineTransform()

GpStatus WINGDIPAPI GdipSetLineTransform	(	GpLineGradient *	brush,
		GDIPCONST GpMatrix *	matrix
	)

Definition at line 2116 of file brush.c.

{
    TRACE("(%p,%p)\n", brush,  matrix);
 
    if(!brush || !matrix)
        return InvalidParameter;
 
    brush->transform = *matrix;
 
    return Ok;
}

Referenced by metafile_deserialize_brush(), and test_transform().

GdipSetLineWrapMode()

GpStatus WINGDIPAPI GdipSetLineWrapMode	(	GpLineGradient *	line,
		GpWrapMode	wrap
	)

Definition at line 1501 of file brush.c.

{
    TRACE("(%p, %d)\n", line, wrap);
 
    if(!line || wrap == WrapModeClamp || line->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    line->wrap = wrap;
 
    return Ok;
}

GdipSetPathGradientBlend()

GpStatus WINGDIPAPI GdipSetPathGradientBlend	(	GpPathGradient *	brush,
		GDIPCONST REAL *	blend,
		GDIPCONST REAL *	pos,
		INT	count
	)

Definition at line 1514 of file brush.c.

{
    REAL *new_blendfac, *new_blendpos;
 
    TRACE("(%p,%p,%p,%i)\n", brush, blend, pos, count);
 
    if(!brush || !blend || !pos || count <= 0 || brush->brush.bt != BrushTypePathGradient ||
       (count >= 2 && (pos[0] != 0.0f || pos[count-1] != 1.0f)))
        return InvalidParameter;
 
    new_blendfac = heap_alloc_zero(count * sizeof(REAL));
    new_blendpos = heap_alloc_zero(count * sizeof(REAL));
 
    if (!new_blendfac || !new_blendpos)
    {
        heap_free(new_blendfac);
        heap_free(new_blendpos);
        return OutOfMemory;
    }
 
    memcpy(new_blendfac, blend, count * sizeof(REAL));
    memcpy(new_blendpos, pos, count * sizeof(REAL));
 
    heap_free(brush->blendfac);
    heap_free(brush->blendpos);
 
    brush->blendcount = count;
    brush->blendfac = new_blendfac;
    brush->blendpos = new_blendpos;
 
    return Ok;
}

Referenced by GdipSetPathGradientLinearBlend(), GdipSetPathGradientSigmaBlend(), and test_pathgradientblend().

GdipSetPathGradientCenterColor()

GpStatus WINGDIPAPI GdipSetPathGradientCenterColor	(	GpPathGradient *	grad,
		ARGB	argb
	)

Definition at line 1656 of file brush.c.

{
    TRACE("(%p, %x)\n", grad, argb);
 
    if(!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    grad->centercolor = argb;
    return Ok;
}

GdipSetPathGradientCenterPoint()

GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint	(	GpPathGradient *	grad,
		GpPointF *	point
	)

Definition at line 1668 of file brush.c.

{
    TRACE("(%p, %s)\n", grad, debugstr_pointf(point));
 
    if(!grad || !point || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    grad->center.X = point->X;
    grad->center.Y = point->Y;
 
    return Ok;
}

Referenced by GdipSetPathGradientCenterPointI(), and test_pathgradientcenterpoint().

GdipSetPathGradientCenterPointI()

GpStatus WINGDIPAPI GdipSetPathGradientCenterPointI	(	GpPathGradient *	grad,
		GpPoint *	point
	)

Definition at line 1682 of file brush.c.

{
    GpPointF ptf;
 
    TRACE("(%p, %p)\n", grad, point);
 
    if(!point)
        return InvalidParameter;
 
    ptf.X = (REAL)point->X;
    ptf.Y = (REAL)point->Y;
 
    return GdipSetPathGradientCenterPoint(grad,&ptf);
}

GdipSetPathGradientFocusScales()

GpStatus WINGDIPAPI GdipSetPathGradientFocusScales	(	GpPathGradient *	grad,
		REAL	x,
		REAL	y
	)

Definition at line 1698 of file brush.c.

{
    TRACE("(%p, %.2f, %.2f)\n", grad, x, y);
 
    if(!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    grad->focus.X = x;
    grad->focus.Y = y;
 
    return Ok;
}

GdipSetPathGradientGammaCorrection()

GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection	(	GpPathGradient *	grad,
		BOOL	gamma
	)

Definition at line 1712 of file brush.c.

{
    TRACE("(%p, %d)\n", grad, gamma);
 
    if(!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    grad->gamma = gamma;
 
    return Ok;
}

GdipSetPathGradientLinearBlend()

GpStatus WINGDIPAPI GdipSetPathGradientLinearBlend	(	GpPathGradient *	brush,
		REAL	focus,
		REAL	scale
	)

Definition at line 1548 of file brush.c.

{
    REAL factors[3];
    REAL positions[3];
    int num_points = 0;
 
    TRACE("(%p,%0.2f,%0.2f)\n", brush, focus, scale);
 
    if (!brush || brush->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    if (focus != 0.0)
    {
        factors[num_points] = 0.0;
        positions[num_points] = 0.0;
        num_points++;
    }
 
    factors[num_points] = scale;
    positions[num_points] = focus;
    num_points++;
 
    if (focus != 1.0)
    {
        factors[num_points] = 0.0;
        positions[num_points] = 1.0;
        num_points++;
    }
 
    return GdipSetPathGradientBlend(brush, factors, positions, num_points);
}

GdipSetPathGradientPath()

GpStatus WINGDIPAPI GdipSetPathGradientPath	(	GpPathGradient *	grad,
		GDIPCONST GpPath *	path
	)

Definition at line 1725 of file brush.c.

{
    static int calls;
 
    TRACE("(%p, %p)\n", grad, path);
 
    if (!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

GdipSetPathGradientPresetBlend()

GpStatus WINGDIPAPI GdipSetPathGradientPresetBlend	(	GpPathGradient *	brush,
		GDIPCONST ARGB *	blend,
		GDIPCONST REAL *	pos,
		INT	count
	)

Definition at line 1581 of file brush.c.

{
    ARGB *new_color;
    REAL *new_pos;
    TRACE("(%p,%p,%p,%i)\n", brush, blend, pos, count);
 
    if (!brush || !blend || !pos || count < 2 || brush->brush.bt != BrushTypePathGradient ||
        pos[0] != 0.0f || pos[count-1] != 1.0f)
    {
        return InvalidParameter;
    }
 
    new_color = heap_alloc_zero(count * sizeof(ARGB));
    new_pos = heap_alloc_zero(count * sizeof(REAL));
    if (!new_color || !new_pos)
    {
        heap_free(new_color);
        heap_free(new_pos);
        return OutOfMemory;
    }
 
    memcpy(new_color, blend, sizeof(ARGB) * count);
    memcpy(new_pos, pos, sizeof(REAL) * count);
 
    heap_free(brush->pblendcolor);
    heap_free(brush->pblendpos);
 
    brush->pblendcolor = new_color;
    brush->pblendpos = new_pos;
    brush->pblendcount = count;
 
    return Ok;
}

Referenced by test_pathgradientpresetblend().

GdipSetPathGradientSigmaBlend()

GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend	(	GpPathGradient *	grad,
		REAL	focus,
		REAL	scale
	)

Definition at line 1737 of file brush.c.

{
    REAL factors[33];
    REAL positions[33];
    int num_points = 0;
    int i;
    const int precision = 16;
    REAL erf_range; /* we use values erf(-erf_range) through erf(+erf_range) */
    REAL min_erf;
    REAL scale_erf;
 
    TRACE("(%p,%0.2f,%0.2f)\n", grad, focus, scale);
 
    if(!grad || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0 || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    /* we want 2 standard deviations */
    erf_range = 2.0 / sqrt(2);
 
    /* calculate the constants we need to normalize the error function to be
        between 0.0 and scale over the range we need */
    min_erf = erf(-erf_range);
    scale_erf = scale / (-2.0 * min_erf);
 
    if (focus != 0.0)
    {
        positions[0] = 0.0;
        factors[0] = 0.0;
        for (i=1; i<precision; i++)
        {
            positions[i] = focus * i / precision;
            factors[i] = scale_erf * (erf(2 * erf_range * i / precision - erf_range) - min_erf);
        }
        num_points += precision;
    }
 
    positions[num_points] = focus;
    factors[num_points] = scale;
    num_points += 1;
 
    if (focus != 1.0)
    {
        for (i=1; i<precision; i++)
        {
            positions[i+num_points-1] = (focus + ((1.0-focus) * i / precision));
            factors[i+num_points-1] = scale_erf * (erf(erf_range - 2 * erf_range * i / precision) - min_erf);
        }
        num_points += precision;
        positions[num_points-1] = 1.0;
        factors[num_points-1] = 0.0;
    }
 
    return GdipSetPathGradientBlend(grad, factors, positions, num_points);
}

GdipSetPathGradientSurroundColorsWithCount()

GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount	(	GpPathGradient *	grad,
		GDIPCONST ARGB *	argb,
		INT *	count
	)

Definition at line 1793 of file brush.c.

{
    ARGB *new_surroundcolors;
    INT i, num_colors;
 
    TRACE("(%p,%p,%p)\n", grad, argb, count);
 
    if(!grad || !argb || !count || (*count <= 0) || grad->brush.bt != BrushTypePathGradient ||
        (*count > grad->path->pathdata.Count))
        return InvalidParameter;
 
    num_colors = *count;
 
    /* If all colors are the same, only store 1 color. */
    if (*count > 1)
    {
        for (i=1; i < num_colors; i++)
            if (argb[i] != argb[i-1])
                break;
 
        if (i == num_colors)
            num_colors = 1;
    }
 
    new_surroundcolors = heap_alloc_zero(num_colors * sizeof(ARGB));
    if (!new_surroundcolors)
        return OutOfMemory;
 
    memcpy(new_surroundcolors, argb, num_colors * sizeof(ARGB));
 
    heap_free(grad->surroundcolors);
 
    grad->surroundcolors = new_surroundcolors;
    grad->surroundcolorcount = num_colors;
 
    return Ok;
}

Referenced by test_gradientsurroundcolorcount().

GdipSetPathGradientTransform()

GpStatus WINGDIPAPI GdipSetPathGradientTransform	(	GpPathGradient *	grad,
		GpMatrix *	matrix
	)

Definition at line 1845 of file brush.c.

{
    TRACE("(%p,%p)\n", grad, matrix);
 
    if (!grad || !matrix || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    grad->transform = *matrix;
 
    return Ok;
}

GdipSetPathGradientWrapMode()

GpStatus WINGDIPAPI GdipSetPathGradientWrapMode	(	GpPathGradient *	grad,
		GpWrapMode	wrap
	)

Definition at line 1832 of file brush.c.

{
    TRACE("(%p, %d)\n", grad, wrap);
 
    if(!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    grad->wrap = wrap;
 
    return Ok;
}

GdipSetSolidFillColor()

GpStatus WINGDIPAPI GdipSetSolidFillColor	(	GpSolidFill *	sf,
		ARGB	argb
	)

Definition at line 1925 of file brush.c.

{
    TRACE("(%p, %x)\n", sf, argb);
 
    if(!sf)
        return InvalidParameter;
 
    sf->color = argb;
    return Ok;
}

Referenced by GdipSetPenColor(), and test_brushfill().

GdipSetTextureTransform()

GpStatus WINGDIPAPI GdipSetTextureTransform	(	GpTexture *	texture,
		GDIPCONST GpMatrix *	matrix
	)

Definition at line 1939 of file brush.c.

{
    TRACE("(%p, %p)\n", texture, matrix);
 
    if(!texture || !matrix)
        return InvalidParameter;
 
    texture->transform = *matrix;
 
    return Ok;
}

Referenced by metafile_deserialize_brush(), and test_transform().

GdipSetTextureWrapMode()

GpStatus WINGDIPAPI GdipSetTextureWrapMode	(	GpTexture *	brush,
		GpWrapMode	wrapmode
	)

Definition at line 1957 of file brush.c.

{
    TRACE("(%p, %d)\n", brush, wrapmode);
 
    if(!brush)
        return InvalidParameter;
 
    brush->imageattributes->wrap = wrapmode;
 
    return Ok;
}

Referenced by test_texturewrap().

GdipTranslateLineTransform()

GpStatus WINGDIPAPI GdipTranslateLineTransform	(	GpLineGradient *	brush,
		REAL	dx,
		REAL	dy,
		GpMatrixOrder	order
	)

Definition at line 2166 of file brush.c.

{
    TRACE("(%p,%f,%f,%d)\n", brush, dx, dy, order);
 
    if(!brush)
        return InvalidParameter;
 
    return GdipTranslateMatrix(&brush->transform, dx, dy, order);
}

Referenced by test_transform().

GdipTranslatePathGradientTransform()

GpStatus WINGDIPAPI GdipTranslatePathGradientTransform	(	GpPathGradient *	grad,
		REAL	dx,
		REAL	dy,
		GpMatrixOrder	order
	)

Definition at line 1914 of file brush.c.

{
    TRACE("(%p,%0.2f,%0.2f,%i)\n", grad, dx, dy, order);
 
    if (!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    return GdipTranslateMatrix(&grad->transform, dx, dy, order);
}

GdipTranslateTextureTransform()

GpStatus WINGDIPAPI GdipTranslateTextureTransform	(	GpTexture *	brush,
		REAL	dx,
		REAL	dy,
		GpMatrixOrder	order
	)

Definition at line 2180 of file brush.c.

{
    TRACE("(%p, %.2f, %.2f, %d)\n", brush, dx, dy, order);
 
    if(!brush)
        return InvalidParameter;
 
    return GdipTranslateMatrix(&brush->transform, dx, dy, order);
}

get_hatch_data()

GpStatus get_hatch_data	(	GpHatchStyle	hatchstyle,
		const char **	result
	)

Definition at line 262 of file brush.c.

{
    if (hatchstyle < ARRAY_SIZE(HatchBrushes))
    {
        *result = HatchBrushes[hatchstyle];
        return Ok;
    }
    else
        return NotImplemented;
}

Referenced by brush_fill_pixels(), and create_hatch_bitmap().

linegradient_init_transform()

static void linegradient_init_transform ( const GpPointF *  startpoint, const GpPointF *  endpoint, GpLineGradient *  line  )

static

Definition at line 334 of file brush.c.

{
    float trans_x = line->rect.X + (line->rect.Width / 2.f);
    float trans_y = line->rect.Y + (line->rect.Height / 2.f);
    float dx = endpoint->X - startpoint->X;
    float dy = endpoint->Y - startpoint->Y;
    float t_cos, t_sin, w_ratio, h_ratio;
    float h;
    GpMatrix rot;
 
    h = sqrtf(dx * dx + dy * dy);
 
    t_cos = dx / h;
    t_sin = dy / h;
 
    w_ratio = (fabs(t_cos) * line->rect.Width + fabs(t_sin) * line->rect.Height) / line->rect.Width;
    h_ratio = (fabs(t_sin) * line->rect.Width + fabs(t_cos) * line->rect.Height) / line->rect.Height;
 
    GdipSetMatrixElements(&line->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 
    GdipSetMatrixElements(&rot, t_cos, t_sin, -1.f * t_sin, t_cos, 0, 0);
 
    /* center about the origin */
    GdipTranslateMatrix(&line->transform, -trans_x, -trans_y, MatrixOrderAppend);
 
    /* scale to normalize gradient along gradient line (?) */
    GdipScaleMatrix(&line->transform, w_ratio, h_ratio, MatrixOrderAppend);
 
    /* rotate so the gradient is horizontal */
    GdipMultiplyMatrix(&line->transform, &rot, MatrixOrderAppend);
 
    /* restore original offset in new coords */
    GdipTranslateMatrix(&line->transform, trans_x, trans_y, MatrixOrderAppend);
}

Referenced by GdipCreateLineBrush(), and GdipCreateLineBrushFromRectWithAngle().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

gdiplus

)

Variable Documentation

HatchBrushes

const char HatchBrushes[][8]

static

Definition at line 229 of file brush.c.

Referenced by get_hatch_data().