static void test_pathgradientcenterpoint(void)
{
static const GpPointF path_points[] = {{0,0}, {3,0}, {0,4}};
GpStatus status;
GpPathGradient *grad;
GpPointF point;
status = GdipCreatePathGradient(path_points+1, 2, WrapModeClamp, &grad);
expect(Ok, status);
status = GdipGetPathGradientCenterPoint(NULL, &point);
expect(InvalidParameter, status);
status = GdipGetPathGradientCenterPoint(grad, NULL);
expect(InvalidParameter, status);
status = GdipGetPathGradientCenterPoint(grad, &point);
expect(Ok, status);
expectf(1.5, point.X);
expectf(2.0, point.Y);
status = GdipSetPathGradientCenterPoint(NULL, &point);
expect(InvalidParameter, status);
status = GdipSetPathGradientCenterPoint(grad, NULL);
expect(InvalidParameter, status);
point.X = 10.0;
point.Y = 15.0;
status = GdipSetPathGradientCenterPoint(grad, &point);
expect(Ok, status);
point.X = point.Y = -1;
status = GdipGetPathGradientCenterPoint(grad, &point);
expect(Ok, status);
expectf(10.0, point.X);
expectf(15.0, point.Y);
status = GdipDeleteBrush((GpBrush*)grad);
expect(Ok, status);
status = GdipCreatePathGradient(path_points, 3, WrapModeClamp, &grad);
expect(Ok, status);
status = GdipGetPathGradientCenterPoint(grad, &point);
expect(Ok, status);
todo_wine expectf(1.0, point.X);
todo_wine expectf(4.0/3.0, point.Y);
status = GdipDeleteBrush((GpBrush*)grad);
expect(Ok, status);
}
GpStatus WINGDIPAPI GdipCreatePathGradientI(GDIPCONST GpPoint* points,
INT count, GpWrapMode wrap, GpPathGradient **grad)
{
GpPointF *pointsF;
GpStatus ret;
INT i;
if(!points || !grad)
return InvalidParameter;
if(count <= 0)
return OutOfMemory;
pointsF = GdipAlloc(sizeof(GpPointF) * count);
if(!pointsF)
return OutOfMemory;
for(i = 0; i < count; i++){
pointsF[i].X = (REAL)points[i].X;
pointsF[i].Y = (REAL)points[i].Y;
}
ret = GdipCreatePathGradient(pointsF, count, wrap, grad);
GdipFree(pointsF);
return ret;
}
static void test_pathgradientpath(void)
{
GpStatus status;
GpPath *path=NULL;
GpPathGradient *grad=NULL;
status = GdipCreatePathGradient(blendcount_ptf, 2, WrapModeClamp, &grad);
expect(Ok, status);
status = GdipGetPathGradientPath(grad, NULL);
expect(NotImplemented, status);
status = GdipCreatePath(FillModeWinding, &path);
expect(Ok, status);
status = GdipGetPathGradientPath(NULL, path);
expect(NotImplemented, status);
status = GdipGetPathGradientPath(grad, path);
expect(NotImplemented, status);
status = GdipDeletePath(path);
expect(Ok, status);
status = GdipDeleteBrush((GpBrush*)grad);
expect(Ok, status);
}
static void test_getbounds(void)
{
GpStatus status;
GpPathGradient *brush;
GpRectF bounds;
status = GdipCreatePathGradient(getbounds_ptf, 4, WrapModeClamp, &brush);
expect(Ok, status);
status = GdipGetPathGradientRect(NULL, NULL);
expect(InvalidParameter, status);
status = GdipGetPathGradientRect(brush, NULL);
expect(InvalidParameter, status);
status = GdipGetPathGradientRect(NULL, &bounds);
expect(InvalidParameter, status);
status = GdipGetPathGradientRect(brush, &bounds);
expect(Ok, status);
expectf(0.0, bounds.X);
expectf(20.0, bounds.Y);
expectf(50.0, bounds.Width);
expectf(30.0, bounds.Height);
GdipDeleteBrush((GpBrush*) brush);
}
static void test_getblend(void)
{
GpStatus status;
GpPathGradient *brush;
REAL blends[4];
REAL pos[4];
status = GdipCreatePathGradient(getblend_ptf, 2, WrapModeClamp, &brush);
expect(Ok, status);
/* check some invalid parameters combinations */
status = GdipGetPathGradientBlend(NULL, NULL, NULL, -1);
expect(InvalidParameter, status);
status = GdipGetPathGradientBlend(brush,NULL, NULL, -1);
expect(InvalidParameter, status);
status = GdipGetPathGradientBlend(NULL, blends,NULL, -1);
expect(InvalidParameter, status);
status = GdipGetPathGradientBlend(NULL, NULL, pos, -1);
expect(InvalidParameter, status);
status = GdipGetPathGradientBlend(NULL, NULL, NULL, 1);
expect(InvalidParameter, status);
blends[0] = (REAL)0xdeadbeef;
pos[0] = (REAL)0xdeadbeef;
status = GdipGetPathGradientBlend(brush, blends, pos, 1);
expect(Ok, status);
expectf(1.0, blends[0]);
expectf((REAL)0xdeadbeef, pos[0]);
GdipDeleteBrush((GpBrush*) brush);
}
static void test_gradientsurroundcolorcount(void)
{
GpStatus status;
GpPathGradient *grad;
ARGB *color;
INT count = 3;
status = GdipCreatePathGradient(blendcount_ptf, 2, WrapModeClamp, &grad);
expect(Ok, status);
color = GdipAlloc(sizeof(ARGB[3]));
status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(InvalidParameter, status);
GdipFree(color);
count = 2;
color = GdipAlloc(sizeof(ARGB[2]));
color[0] = 0x00ff0000;
color[1] = 0x0000ff00;
status = GdipSetPathGradientSurroundColorsWithCount(NULL, color, &count);
expect(InvalidParameter, status);
status = GdipSetPathGradientSurroundColorsWithCount(grad, NULL, &count);
expect(InvalidParameter, status);
/* WinXP crashes on this test */
if(0)
{
status = GdipSetPathGradientSurroundColorsWithCount(grad, color, NULL);
expect(InvalidParameter, status);
}
status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
todo_wine expect(Ok, status);
expect(2, count);
status = GdipGetPathGradientSurroundColorCount(NULL, &count);
expect(InvalidParameter, status);
status = GdipGetPathGradientSurroundColorCount(grad, NULL);
expect(InvalidParameter, status);
count = 0;
status = GdipGetPathGradientSurroundColorCount(grad, &count);
todo_wine expect(Ok, status);
todo_wine expect(2, count);
GdipFree(color);
GdipDeleteBrush((GpBrush*)grad);
}
static void test_gradientblendcount(void)
{
GpStatus status;
GpPathGradient *brush;
INT count;
status = GdipCreatePathGradient(blendcount_ptf, 2, WrapModeClamp, &brush);
expect(Ok, status);
status = GdipGetPathGradientBlendCount(NULL, NULL);
expect(InvalidParameter, status);
status = GdipGetPathGradientBlendCount(NULL, &count);
expect(InvalidParameter, status);
status = GdipGetPathGradientBlendCount(brush, NULL);
expect(InvalidParameter, status);
status = GdipGetPathGradientBlendCount(brush, &count);
expect(Ok, status);
expect(1, count);
GdipDeleteBrush((GpBrush*) brush);
}
static void test_gradientsurroundcolorcount(void)
{
GpStatus status;
GpPathGradient *grad;
ARGB color[3];
INT count;
status = GdipCreatePathGradient(blendcount_ptf, 2, WrapModeClamp, &grad);
expect(Ok, status);
count = 0;
status = GdipGetPathGradientSurroundColorCount(grad, &count);
expect(Ok, status);
expect(2, count);
color[0] = color[1] = color[2] = 0xdeadbeef;
count = 3;
status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(Ok, status);
expect(1, count);
expect(0xffffffff, color[0]);
expect(0xffffffff, color[1]);
expect(0xdeadbeef, color[2]);
color[0] = color[1] = color[2] = 0xdeadbeef;
count = 2;
status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(Ok, status);
expect(1, count);
expect(0xffffffff, color[0]);
expect(0xffffffff, color[1]);
expect(0xdeadbeef, color[2]);
color[0] = color[1] = color[2] = 0xdeadbeef;
count = 1;
status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(InvalidParameter, status);
expect(1, count);
expect(0xdeadbeef, color[0]);
expect(0xdeadbeef, color[1]);
expect(0xdeadbeef, color[2]);
color[0] = color[1] = color[2] = 0xdeadbeef;
count = 0;
status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(InvalidParameter, status);
expect(0, count);
expect(0xdeadbeef, color[0]);
expect(0xdeadbeef, color[1]);
expect(0xdeadbeef, color[2]);
count = 3;
status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(InvalidParameter, status);
count = 2;
color[0] = 0x00ff0000;
color[1] = 0x0000ff00;
status = GdipSetPathGradientSurroundColorsWithCount(NULL, color, &count);
expect(InvalidParameter, status);
status = GdipSetPathGradientSurroundColorsWithCount(grad, NULL, &count);
expect(InvalidParameter, status);
/* WinXP crashes on this test */
if(0)
{
status = GdipSetPathGradientSurroundColorsWithCount(grad, color, NULL);
expect(InvalidParameter, status);
}
status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(Ok, status);
expect(2, count);
status = GdipGetPathGradientSurroundColorCount(NULL, &count);
expect(InvalidParameter, status);
status = GdipGetPathGradientSurroundColorCount(grad, NULL);
expect(InvalidParameter, status);
count = 0;
status = GdipGetPathGradientSurroundColorCount(grad, &count);
expect(Ok, status);
expect(2, count);
color[0] = color[1] = color[2] = 0xdeadbeef;
count = 2;
status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(Ok, status);
expect(2, count);
expect(0x00ff0000, color[0]);
expect(0x0000ff00, color[1]);
expect(0xdeadbeef, color[2]);
count = 1;
status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(Ok, status);
expect(1, count);
count = 0;
status = GdipGetPathGradientSurroundColorCount(grad, &count);
expect(Ok, status);
expect(2, count);
/* If all colors are the same, count is set to 1. */
color[0] = color[1] = 0;
count = 2;
status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(Ok, status);
expect(2, count);
color[0] = color[1] = color[2] = 0xdeadbeef;
count = 2;
status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(Ok, status);
expect(1, count);
expect(0x00000000, color[0]);
expect(0x00000000, color[1]);
expect(0xdeadbeef, color[2]);
color[0] = color[1] = 0xff00ff00;
count = 2;
status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(Ok, status);
expect(2, count);
color[0] = color[1] = color[2] = 0xdeadbeef;
count = 2;
status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(Ok, status);
expect(1, count);
expect(0xff00ff00, color[0]);
expect(0xff00ff00, color[1]);
expect(0xdeadbeef, color[2]);
count = 0;
status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(InvalidParameter, status);
expect(0, count);
GdipDeleteBrush((GpBrush*)grad);
status = GdipCreatePathGradient(getbounds_ptf, 3, WrapModeClamp, &grad);
expect(Ok, status);
color[0] = color[1] = color[2] = 0xdeadbeef;
count = 3;
status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(Ok, status);
expect(1, count);
expect(0xffffffff, color[0]);
expect(0xffffffff, color[1]);
expect(0xffffffff, color[2]);
color[0] = color[1] = color[2] = 0xdeadbeef;
count = 2;
status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
expect(InvalidParameter, status);
expect(2, count);
expect(0xdeadbeef, color[0]);
expect(0xdeadbeef, color[1]);
expect(0xdeadbeef, color[2]);
count = 0;
status = GdipGetPathGradientSurroundColorCount(grad, &count);
expect(Ok, status);
expect(3, count);
GdipDeleteBrush((GpBrush*)grad);
}
static void test_pathgradientblend(void)
{
static const GpPointF path_points[] = {{0,0}, {3,0}, {0,4}};
GpPathGradient *brush;
GpStatus status;
INT count, i;
const REAL factors[5] = {0.0f, 0.1f, 0.5f, 0.9f, 1.0f};
const REAL positions[5] = {0.0f, 0.2f, 0.5f, 0.8f, 1.0f};
REAL res_factors[6] = {0.3f, 0.0f, 0.0f, 0.0f, 0.0f};
REAL res_positions[6] = {0.3f, 0.0f, 0.0f, 0.0f, 0.0f};
status = GdipCreatePathGradient(path_points, 3, WrapModeClamp, &brush);
expect(Ok, status);
status = GdipGetPathGradientBlendCount(NULL, &count);
expect(InvalidParameter, status);
status = GdipGetPathGradientBlendCount(brush, NULL);
expect(InvalidParameter, status);
status = GdipGetPathGradientBlendCount(brush, &count);
expect(Ok, status);
expect(1, count);
status = GdipGetPathGradientBlend(NULL, res_factors, res_positions, 1);
expect(InvalidParameter, status);
status = GdipGetPathGradientBlend(brush, NULL, res_positions, 1);
expect(InvalidParameter, status);
status = GdipGetPathGradientBlend(brush, res_factors, NULL, 1);
expect(InvalidParameter, status);
status = GdipGetPathGradientBlend(brush, res_factors, res_positions, 0);
expect(InvalidParameter, status);
status = GdipGetPathGradientBlend(brush, res_factors, res_positions, -1);
expect(InvalidParameter, status);
status = GdipGetPathGradientBlend(brush, res_factors, res_positions, 1);
expect(Ok, status);
status = GdipGetPathGradientBlend(brush, res_factors, res_positions, 2);
expect(Ok, status);
status = GdipSetPathGradientBlend(NULL, factors, positions, 5);
expect(InvalidParameter, status);
status = GdipSetPathGradientBlend(brush, NULL, positions, 5);
expect(InvalidParameter, status);
status = GdipSetPathGradientBlend(brush, factors, NULL, 5);
expect(InvalidParameter, status);
status = GdipSetPathGradientBlend(brush, factors, positions, 0);
expect(InvalidParameter, status);
status = GdipSetPathGradientBlend(brush, factors, positions, -1);
expect(InvalidParameter, status);
/* leave off the 0.0 position */
status = GdipSetPathGradientBlend(brush, &factors[1], &positions[1], 4);
expect(InvalidParameter, status);
/* leave off the 1.0 position */
status = GdipSetPathGradientBlend(brush, factors, positions, 4);
expect(InvalidParameter, status);
status = GdipSetPathGradientBlend(brush, factors, positions, 5);
expect(Ok, status);
status = GdipGetPathGradientBlendCount(brush, &count);
expect(Ok, status);
expect(5, count);
status = GdipGetPathGradientBlend(brush, res_factors, res_positions, 4);
expect(InsufficientBuffer, status);
status = GdipGetPathGradientBlend(brush, res_factors, res_positions, 5);
expect(Ok, status);
for (i=0; i<5; i++)
{
expectf(factors[i], res_factors[i]);
expectf(positions[i], res_positions[i]);
}
status = GdipGetPathGradientBlend(brush, res_factors, res_positions, 6);
expect(Ok, status);
status = GdipSetPathGradientBlend(brush, factors, positions, 1);
expect(Ok, status);
status = GdipGetPathGradientBlendCount(brush, &count);
expect(Ok, status);
expect(1, count);
status = GdipGetPathGradientBlend(brush, res_factors, res_positions, 1);
expect(Ok, status);
status = GdipDeleteBrush((GpBrush*)brush);
expect(Ok, status);
}
static void test_pathgradientpresetblend(void)
{
static const GpPointF path_points[] = {{0,0}, {3,0}, {0,4}};
GpStatus status;
GpPathGradient *grad;
INT count;
int i;
const REAL positions[5] = {0.0f, 0.2f, 0.5f, 0.8f, 1.0f};
const REAL two_positions[2] = {0.0f, 1.0f};
const ARGB colors[5] = {0xff0000ff, 0xff00ff00, 0xff00ffff, 0xffff0000, 0xffffffff};
REAL res_positions[6] = {0.3f, 0.0f, 0.0f, 0.0f, 0.0f};
ARGB res_colors[6] = {0xdeadbeef, 0, 0, 0, 0};
status = GdipCreatePathGradient(path_points+1, 2, WrapModeClamp, &grad);
expect(Ok, status);
status = GdipGetPathGradientPresetBlendCount(NULL, &count);
expect(InvalidParameter, status);
status = GdipGetPathGradientPresetBlendCount(grad, NULL);
expect(InvalidParameter, status);
status = GdipGetPathGradientPresetBlendCount(grad, &count);
expect(Ok, status);
expect(0, count);
status = GdipGetPathGradientPresetBlend(NULL, res_colors, res_positions, 1);
expect(InvalidParameter, status);
status = GdipGetPathGradientPresetBlend(grad, NULL, res_positions, 1);
expect(InvalidParameter, status);
status = GdipGetPathGradientPresetBlend(grad, res_colors, NULL, 1);
expect(InvalidParameter, status);
status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, 0);
expect(InvalidParameter, status);
status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, -1);
expect(OutOfMemory, status);
status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, 1);
expect(InvalidParameter, status);
status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, 2);
expect(GenericError, status);
status = GdipSetPathGradientPresetBlend(NULL, colors, positions, 5);
expect(InvalidParameter, status);
status = GdipSetPathGradientPresetBlend(grad, NULL, positions, 5);
expect(InvalidParameter, status);
if (0)
{
/* crashes on windows xp */
status = GdipSetPathGradientPresetBlend(grad, colors, NULL, 5);
expect(InvalidParameter, status);
}
status = GdipSetPathGradientPresetBlend(grad, colors, positions, 0);
expect(InvalidParameter, status);
status = GdipSetPathGradientPresetBlend(grad, colors, positions, -1);
expect(InvalidParameter, status);
status = GdipSetPathGradientPresetBlend(grad, colors, positions, 1);
expect(InvalidParameter, status);
/* leave off the 0.0 position */
status = GdipSetPathGradientPresetBlend(grad, &colors[1], &positions[1], 4);
expect(InvalidParameter, status);
/* leave off the 1.0 position */
status = GdipSetPathGradientPresetBlend(grad, colors, positions, 4);
expect(InvalidParameter, status);
status = GdipSetPathGradientPresetBlend(grad, colors, positions, 5);
expect(Ok, status);
status = GdipGetPathGradientPresetBlendCount(grad, &count);
expect(Ok, status);
expect(5, count);
if (0)
{
/* Native GdipGetPathGradientPresetBlend seems to copy starting from
* the end of each array and do no bounds checking. This is so braindead
* I'm not going to copy it. */
res_colors[0] = 0xdeadbeef;
res_positions[0] = 0.3;
status = GdipGetPathGradientPresetBlend(grad, &res_colors[1], &res_positions[1], 4);
expect(Ok, status);
expect(0xdeadbeef, res_colors[0]);
expectf(0.3, res_positions[0]);
for (i=1; i<5; i++)
{
expect(colors[i], res_colors[i]);
expectf(positions[i], res_positions[i]);
}
status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, 6);
expect(Ok, status);
for (i=0; i<5; i++)
{
expect(colors[i], res_colors[i+1]);
expectf(positions[i], res_positions[i+1]);
}
}
status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, 5);
expect(Ok, status);
for (i=0; i<5; i++)
{
expect(colors[i], res_colors[i]);
expectf(positions[i], res_positions[i]);
}
status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, 0);
expect(InvalidParameter, status);
status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, -1);
expect(OutOfMemory, status);
status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, 1);
expect(InvalidParameter, status);
status = GdipSetPathGradientPresetBlend(grad, colors, two_positions, 2);
expect(Ok, status);
status = GdipDeleteBrush((GpBrush*)grad);
expect(Ok, status);
}
