sync gdiplus with wine 1.1.35
[reactos.git] / rostests / winetests / gdiplus / brush.c
1 /*
2 * Unit test suite for brushes
3 *
4 * Copyright (C) 2007 Google (Evan Stade)
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "windows.h"
22 #include "gdiplus.h"
23 #include "wine/test.h"
24 #include <math.h>
25
26 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
27 #define expectf(expected, got) ok(fabs(expected - got) < 0.0001, "Expected %.2f, got %.2f\n", expected, got)
28
29 static void test_constructor_destructor(void)
30 {
31 GpStatus status;
32 GpSolidFill *brush = NULL;
33
34 status = GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
35 expect(Ok, status);
36 ok(brush != NULL, "Expected brush to be initialized\n");
37
38 status = GdipDeleteBrush(NULL);
39 expect(InvalidParameter, status);
40
41 status = GdipDeleteBrush((GpBrush*) brush);
42 expect(Ok, status);
43 }
44
45 static void test_type(void)
46 {
47 GpStatus status;
48 GpBrushType bt;
49 GpSolidFill *brush = NULL;
50
51 GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
52
53 status = GdipGetBrushType((GpBrush*)brush, &bt);
54 expect(Ok, status);
55 expect(BrushTypeSolidColor, bt);
56
57 GdipDeleteBrush((GpBrush*) brush);
58 }
59 static GpPointF blendcount_ptf[] = {{0.0, 0.0},
60 {50.0, 50.0}};
61 static void test_gradientblendcount(void)
62 {
63 GpStatus status;
64 GpPathGradient *brush;
65 INT count;
66
67 status = GdipCreatePathGradient(blendcount_ptf, 2, WrapModeClamp, &brush);
68 expect(Ok, status);
69
70 status = GdipGetPathGradientBlendCount(NULL, NULL);
71 expect(InvalidParameter, status);
72 status = GdipGetPathGradientBlendCount(NULL, &count);
73 expect(InvalidParameter, status);
74 status = GdipGetPathGradientBlendCount(brush, NULL);
75 expect(InvalidParameter, status);
76
77 status = GdipGetPathGradientBlendCount(brush, &count);
78 expect(Ok, status);
79 expect(1, count);
80
81 GdipDeleteBrush((GpBrush*) brush);
82 }
83
84 static GpPointF getblend_ptf[] = {{0.0, 0.0},
85 {50.0, 50.0}};
86 static void test_getblend(void)
87 {
88 GpStatus status;
89 GpPathGradient *brush;
90 REAL blends[4];
91 REAL pos[4];
92
93 status = GdipCreatePathGradient(getblend_ptf, 2, WrapModeClamp, &brush);
94 expect(Ok, status);
95
96 /* check some invalid parameters combinations */
97 status = GdipGetPathGradientBlend(NULL, NULL, NULL, -1);
98 expect(InvalidParameter, status);
99 status = GdipGetPathGradientBlend(brush,NULL, NULL, -1);
100 expect(InvalidParameter, status);
101 status = GdipGetPathGradientBlend(NULL, blends,NULL, -1);
102 expect(InvalidParameter, status);
103 status = GdipGetPathGradientBlend(NULL, NULL, pos, -1);
104 expect(InvalidParameter, status);
105 status = GdipGetPathGradientBlend(NULL, NULL, NULL, 1);
106 expect(InvalidParameter, status);
107
108 blends[0] = (REAL)0xdeadbeef;
109 pos[0] = (REAL)0xdeadbeef;
110 status = GdipGetPathGradientBlend(brush, blends, pos, 1);
111 expect(Ok, status);
112 expectf(1.0, blends[0]);
113 expectf((REAL)0xdeadbeef, pos[0]);
114
115 GdipDeleteBrush((GpBrush*) brush);
116 }
117
118 static GpPointF getbounds_ptf[] = {{0.0, 20.0},
119 {50.0, 50.0},
120 {21.0, 25.0},
121 {25.0, 46.0}};
122 static void test_getbounds(void)
123 {
124 GpStatus status;
125 GpPathGradient *brush;
126 GpRectF bounds;
127
128 status = GdipCreatePathGradient(getbounds_ptf, 4, WrapModeClamp, &brush);
129 expect(Ok, status);
130
131 status = GdipGetPathGradientRect(NULL, NULL);
132 expect(InvalidParameter, status);
133 status = GdipGetPathGradientRect(brush, NULL);
134 expect(InvalidParameter, status);
135 status = GdipGetPathGradientRect(NULL, &bounds);
136 expect(InvalidParameter, status);
137
138 status = GdipGetPathGradientRect(brush, &bounds);
139 expect(Ok, status);
140 expectf(0.0, bounds.X);
141 expectf(20.0, bounds.Y);
142 expectf(50.0, bounds.Width);
143 expectf(30.0, bounds.Height);
144
145 GdipDeleteBrush((GpBrush*) brush);
146 }
147
148 static void test_getgamma(void)
149 {
150 GpStatus status;
151 GpLineGradient *line;
152 GpPointF start, end;
153 BOOL gamma;
154
155 start.X = start.Y = 0.0;
156 end.X = end.Y = 100.0;
157
158 status = GdipCreateLineBrush(&start, &end, (ARGB)0xdeadbeef, 0xdeadbeef, WrapModeTile, &line);
159 expect(Ok, status);
160
161 /* NULL arguments */
162 status = GdipGetLineGammaCorrection(NULL, NULL);
163 expect(InvalidParameter, status);
164 status = GdipGetLineGammaCorrection(line, NULL);
165 expect(InvalidParameter, status);
166 status = GdipGetLineGammaCorrection(NULL, &gamma);
167 expect(InvalidParameter, status);
168
169 GdipDeleteBrush((GpBrush*)line);
170 }
171
172 static void test_transform(void)
173 {
174 GpStatus status;
175 GpTexture *texture;
176 GpGraphics *graphics = NULL;
177 GpBitmap *bitmap;
178 HDC hdc = GetDC(0);
179 GpMatrix *m, *m1;
180 BOOL res;
181
182 status = GdipCreateMatrix2(2.0, 0.0, 0.0, 0.0, 0.0, 0.0, &m);
183 expect(Ok, status);
184
185 status = GdipCreateFromHDC(hdc, &graphics);
186 expect(Ok, status);
187 status = GdipCreateBitmapFromGraphics(1, 1, graphics, &bitmap);
188 expect(Ok, status);
189
190 status = GdipCreateTexture((GpImage*)bitmap, WrapModeTile, &texture);
191 expect(Ok, status);
192
193 /* NULL */
194 status = GdipGetTextureTransform(NULL, NULL);
195 expect(InvalidParameter, status);
196 status = GdipGetTextureTransform(texture, NULL);
197 expect(InvalidParameter, status);
198
199 /* get default value - identity matrix */
200 status = GdipGetTextureTransform(texture, m);
201 expect(Ok, status);
202 status = GdipIsMatrixIdentity(m, &res);
203 expect(Ok, status);
204 expect(TRUE, res);
205 /* set and get then */
206 status = GdipCreateMatrix2(2.0, 0.0, 0.0, 2.0, 0.0, 0.0, &m1);
207 expect(Ok, status);
208 status = GdipSetTextureTransform(texture, m1);
209 expect(Ok, status);
210 status = GdipGetTextureTransform(texture, m);
211 expect(Ok, status);
212 status = GdipIsMatrixEqual(m, m1, &res);
213 expect(Ok, status);
214 expect(TRUE, res);
215 /* reset */
216 status = GdipResetTextureTransform(texture);
217 expect(Ok, status);
218 status = GdipGetTextureTransform(texture, m);
219 expect(Ok, status);
220 status = GdipIsMatrixIdentity(m, &res);
221 expect(Ok, status);
222 expect(TRUE, res);
223
224 status = GdipDeleteBrush((GpBrush*)texture);
225 expect(Ok, status);
226
227 status = GdipDeleteMatrix(m1);
228 expect(Ok, status);
229 status = GdipDeleteMatrix(m);
230 expect(Ok, status);
231 status = GdipDisposeImage((GpImage*)bitmap);
232 expect(Ok, status);
233 status = GdipDeleteGraphics(graphics);
234 expect(Ok, status);
235 ReleaseDC(0, hdc);
236 }
237
238 static void test_texturewrap(void)
239 {
240 GpStatus status;
241 GpTexture *texture;
242 GpGraphics *graphics = NULL;
243 GpBitmap *bitmap;
244 HDC hdc = GetDC(0);
245 GpWrapMode wrap;
246
247 status = GdipCreateFromHDC(hdc, &graphics);
248 expect(Ok, status);
249 status = GdipCreateBitmapFromGraphics(1, 1, graphics, &bitmap);
250 expect(Ok, status);
251
252 status = GdipCreateTexture((GpImage*)bitmap, WrapModeTile, &texture);
253 expect(Ok, status);
254
255 /* NULL */
256 status = GdipGetTextureWrapMode(NULL, NULL);
257 expect(InvalidParameter, status);
258 status = GdipGetTextureWrapMode(texture, NULL);
259 expect(InvalidParameter, status);
260 status = GdipGetTextureWrapMode(NULL, &wrap);
261 expect(InvalidParameter, status);
262
263 /* get */
264 wrap = WrapModeClamp;
265 status = GdipGetTextureWrapMode(texture, &wrap);
266 expect(Ok, status);
267 expect(WrapModeTile, wrap);
268 /* set, then get */
269 wrap = WrapModeClamp;
270 status = GdipSetTextureWrapMode(texture, wrap);
271 expect(Ok, status);
272 wrap = WrapModeTile;
273 status = GdipGetTextureWrapMode(texture, &wrap);
274 expect(Ok, status);
275 expect(WrapModeClamp, wrap);
276
277 status = GdipDeleteBrush((GpBrush*)texture);
278 expect(Ok, status);
279 status = GdipDisposeImage((GpImage*)bitmap);
280 expect(Ok, status);
281 status = GdipDeleteGraphics(graphics);
282 expect(Ok, status);
283 ReleaseDC(0, hdc);
284 }
285
286 static void test_gradientgetrect(void)
287 {
288 GpLineGradient *brush;
289 GpRectF rectf;
290 GpStatus status;
291 GpPointF pt1, pt2;
292
293 pt1.X = pt1.Y = 1.0;
294 pt2.X = pt2.Y = 100.0;
295 status = GdipCreateLineBrush(&pt1, &pt2, 0, 0, WrapModeTile, &brush);
296 expect(Ok, status);
297 memset(&rectf, 0, sizeof(GpRectF));
298 status = GdipGetLineRect(brush, &rectf);
299 expect(Ok, status);
300 expectf(1.0, rectf.X);
301 expectf(1.0, rectf.Y);
302 expectf(99.0, rectf.Width);
303 expectf(99.0, rectf.Height);
304 status = GdipDeleteBrush((GpBrush*)brush);
305 /* vertical gradient */
306 pt1.X = pt1.Y = pt2.X = 0.0;
307 pt2.Y = 10.0;
308 status = GdipCreateLineBrush(&pt1, &pt2, 0, 0, WrapModeTile, &brush);
309 expect(Ok, status);
310 memset(&rectf, 0, sizeof(GpRectF));
311 status = GdipGetLineRect(brush, &rectf);
312 expect(Ok, status);
313 todo_wine expectf(-5.0, rectf.X);
314 expectf(0.0, rectf.Y);
315 todo_wine expectf(10.0, rectf.Width);
316 expectf(10.0, rectf.Height);
317 status = GdipDeleteBrush((GpBrush*)brush);
318 /* horizontal gradient */
319 pt1.X = pt1.Y = pt2.Y = 0.0;
320 pt2.X = 10.0;
321 status = GdipCreateLineBrush(&pt1, &pt2, 0, 0, WrapModeTile, &brush);
322 expect(Ok, status);
323 memset(&rectf, 0, sizeof(GpRectF));
324 status = GdipGetLineRect(brush, &rectf);
325 expect(Ok, status);
326 expectf(0.0, rectf.X);
327 todo_wine expectf(-5.0, rectf.Y);
328 expectf(10.0, rectf.Width);
329 todo_wine expectf(10.0, rectf.Height);
330 status = GdipDeleteBrush((GpBrush*)brush);
331 /* slope = -1 */
332 pt1.X = pt1.Y = 0.0;
333 pt2.X = 20.0;
334 pt2.Y = -20.0;
335 status = GdipCreateLineBrush(&pt1, &pt2, 0, 0, WrapModeTile, &brush);
336 expect(Ok, status);
337 memset(&rectf, 0, sizeof(GpRectF));
338 status = GdipGetLineRect(brush, &rectf);
339 expect(Ok, status);
340 expectf(0.0, rectf.X);
341 expectf(-20.0, rectf.Y);
342 expectf(20.0, rectf.Width);
343 expectf(20.0, rectf.Height);
344 status = GdipDeleteBrush((GpBrush*)brush);
345 /* slope = 1/100 */
346 pt1.X = pt1.Y = 0.0;
347 pt2.X = 100.0;
348 pt2.Y = 1.0;
349 status = GdipCreateLineBrush(&pt1, &pt2, 0, 0, WrapModeTile, &brush);
350 expect(Ok, status);
351 memset(&rectf, 0, sizeof(GpRectF));
352 status = GdipGetLineRect(brush, &rectf);
353 expect(Ok, status);
354 expectf(0.0, rectf.X);
355 expectf(0.0, rectf.Y);
356 expectf(100.0, rectf.Width);
357 expectf(1.0, rectf.Height);
358 status = GdipDeleteBrush((GpBrush*)brush);
359 /* from rect with LinearGradientModeHorizontal */
360 rectf.X = rectf.Y = 10.0;
361 rectf.Width = rectf.Height = 100.0;
362 status = GdipCreateLineBrushFromRect(&rectf, 0, 0, LinearGradientModeHorizontal,
363 WrapModeTile, &brush);
364 expect(Ok, status);
365 memset(&rectf, 0, sizeof(GpRectF));
366 status = GdipGetLineRect(brush, &rectf);
367 expect(Ok, status);
368 expectf(10.0, rectf.X);
369 expectf(10.0, rectf.Y);
370 expectf(100.0, rectf.Width);
371 expectf(100.0, rectf.Height);
372 status = GdipDeleteBrush((GpBrush*)brush);
373 /* passing negative Width/Height to LinearGradientModeHorizontal */
374 rectf.X = rectf.Y = 10.0;
375 rectf.Width = rectf.Height = -100.0;
376 status = GdipCreateLineBrushFromRect(&rectf, 0, 0, LinearGradientModeHorizontal,
377 WrapModeTile, &brush);
378 expect(Ok, status);
379 memset(&rectf, 0, sizeof(GpRectF));
380 status = GdipGetLineRect(brush, &rectf);
381 expect(Ok, status);
382 expectf(10.0, rectf.X);
383 expectf(10.0, rectf.Y);
384 expectf(-100.0, rectf.Width);
385 expectf(-100.0, rectf.Height);
386 status = GdipDeleteBrush((GpBrush*)brush);
387 }
388
389 static void test_lineblend(void)
390 {
391 GpLineGradient *brush;
392 GpStatus status;
393 GpPointF pt1, pt2;
394 INT count=10;
395 int i;
396 const REAL factors[5] = {0.0f, 0.1f, 0.5f, 0.9f, 1.0f};
397 const REAL positions[5] = {0.0f, 0.2f, 0.5f, 0.8f, 1.0f};
398 REAL res_factors[6] = {0.3f, 0.0f, 0.0f, 0.0f, 0.0f};
399 REAL res_positions[6] = {0.3f, 0.0f, 0.0f, 0.0f, 0.0f};
400
401 pt1.X = pt1.Y = 1.0;
402 pt2.X = pt2.Y = 100.0;
403 status = GdipCreateLineBrush(&pt1, &pt2, 0, 0, WrapModeTile, &brush);
404 expect(Ok, status);
405
406 status = GdipGetLineBlendCount(NULL, &count);
407 expect(InvalidParameter, status);
408
409 status = GdipGetLineBlendCount(brush, NULL);
410 expect(InvalidParameter, status);
411
412 status = GdipGetLineBlendCount(brush, &count);
413 expect(Ok, status);
414 expect(1, count);
415
416 status = GdipGetLineBlend(NULL, res_factors, res_positions, 1);
417 expect(InvalidParameter, status);
418
419 status = GdipGetLineBlend(brush, NULL, res_positions, 1);
420 expect(InvalidParameter, status);
421
422 status = GdipGetLineBlend(brush, res_factors, NULL, 1);
423 expect(InvalidParameter, status);
424
425 status = GdipGetLineBlend(brush, res_factors, res_positions, 0);
426 expect(InvalidParameter, status);
427
428 status = GdipGetLineBlend(brush, res_factors, res_positions, -1);
429 expect(InvalidParameter, status);
430
431 status = GdipGetLineBlend(brush, res_factors, res_positions, 1);
432 expect(Ok, status);
433
434 status = GdipGetLineBlend(brush, res_factors, res_positions, 2);
435 expect(Ok, status);
436
437 status = GdipSetLineBlend(NULL, factors, positions, 5);
438 expect(InvalidParameter, status);
439
440 status = GdipSetLineBlend(brush, NULL, positions, 5);
441 expect(InvalidParameter, status);
442
443 status = GdipSetLineBlend(brush, factors, NULL, 5);
444 expect(InvalidParameter, status);
445
446 status = GdipSetLineBlend(brush, factors, positions, 0);
447 expect(InvalidParameter, status);
448
449 status = GdipSetLineBlend(brush, factors, positions, -1);
450 expect(InvalidParameter, status);
451
452 /* leave off the 0.0 position */
453 status = GdipSetLineBlend(brush, &factors[1], &positions[1], 4);
454 expect(InvalidParameter, status);
455
456 /* leave off the 1.0 position */
457 status = GdipSetLineBlend(brush, factors, positions, 4);
458 expect(InvalidParameter, status);
459
460 status = GdipSetLineBlend(brush, factors, positions, 5);
461 expect(Ok, status);
462
463 status = GdipGetLineBlendCount(brush, &count);
464 expect(Ok, status);
465 expect(5, count);
466
467 status = GdipGetLineBlend(brush, res_factors, res_positions, 4);
468 expect(InsufficientBuffer, status);
469
470 status = GdipGetLineBlend(brush, res_factors, res_positions, 5);
471 expect(Ok, status);
472
473 for (i=0; i<5; i++)
474 {
475 expectf(factors[i], res_factors[i]);
476 expectf(positions[i], res_positions[i]);
477 }
478
479 status = GdipGetLineBlend(brush, res_factors, res_positions, 6);
480 expect(Ok, status);
481
482 status = GdipSetLineBlend(brush, factors, positions, 1);
483 expect(Ok, status);
484
485 status = GdipGetLineBlendCount(brush, &count);
486 expect(Ok, status);
487 expect(1, count);
488
489 status = GdipGetLineBlend(brush, res_factors, res_positions, 1);
490 expect(Ok, status);
491
492 status = GdipDeleteBrush((GpBrush*)brush);
493 expect(Ok, status);
494 }
495
496 START_TEST(brush)
497 {
498 struct GdiplusStartupInput gdiplusStartupInput;
499 ULONG_PTR gdiplusToken;
500
501 gdiplusStartupInput.GdiplusVersion = 1;
502 gdiplusStartupInput.DebugEventCallback = NULL;
503 gdiplusStartupInput.SuppressBackgroundThread = 0;
504 gdiplusStartupInput.SuppressExternalCodecs = 0;
505
506 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
507
508 test_constructor_destructor();
509 test_type();
510 test_gradientblendcount();
511 test_getblend();
512 test_getbounds();
513 test_getgamma();
514 test_transform();
515 test_texturewrap();
516 test_gradientgetrect();
517 test_lineblend();
518
519 GdiplusShutdown(gdiplusToken);
520 }