sync gdiplus with wine 1.1.35
[reactos.git] / rostests / winetests / gdiplus / graphics.c
1 /*
2 * Unit test suite for graphics objects
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 "wingdi.h"
24 #include "wine/test.h"
25 #include <math.h>
26
27 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
28 #define expectf(expected, got) ok(fabs(expected - got) < 0.0001, "Expected %.2f, got %.2f\n", expected, got)
29 #define TABLE_LEN (23)
30
31 static void test_constructor_destructor(void)
32 {
33 GpStatus stat;
34 GpGraphics *graphics = NULL;
35 HDC hdc = GetDC(0);
36
37 stat = GdipCreateFromHDC(NULL, &graphics);
38 expect(OutOfMemory, stat);
39 stat = GdipDeleteGraphics(graphics);
40 expect(InvalidParameter, stat);
41
42 stat = GdipCreateFromHDC(hdc, &graphics);
43 expect(Ok, stat);
44 stat = GdipDeleteGraphics(graphics);
45 expect(Ok, stat);
46
47 stat = GdipCreateFromHWND(NULL, &graphics);
48 expect(Ok, stat);
49 stat = GdipDeleteGraphics(graphics);
50 expect(Ok, stat);
51
52 stat = GdipCreateFromHWNDICM(NULL, &graphics);
53 expect(Ok, stat);
54 stat = GdipDeleteGraphics(graphics);
55 expect(Ok, stat);
56
57 stat = GdipDeleteGraphics(NULL);
58 expect(InvalidParameter, stat);
59 ReleaseDC(0, hdc);
60 }
61
62 typedef struct node{
63 GraphicsState data;
64 struct node * next;
65 } node;
66
67 /* Linked list prepend function. */
68 static void log_state(GraphicsState data, node ** log)
69 {
70 node * new_entry = HeapAlloc(GetProcessHeap(), 0, sizeof(node));
71
72 new_entry->data = data;
73 new_entry->next = *log;
74 *log = new_entry;
75 }
76
77 /* Checks if there are duplicates in the list, and frees it. */
78 static void check_no_duplicates(node * log)
79 {
80 INT dups = 0;
81 node * temp = NULL;
82 node * temp2 = NULL;
83 node * orig = log;
84
85 if(!log)
86 goto end;
87
88 do{
89 temp = log;
90 while((temp = temp->next)){
91 if(log->data == temp->data){
92 dups++;
93 break;
94 }
95 if(dups > 0)
96 break;
97 }
98 }while((log = log->next));
99
100 temp = orig;
101 do{
102 temp2 = temp->next;
103 HeapFree(GetProcessHeap(), 0, temp);
104 temp = temp2;
105 }while(temp);
106
107 end:
108 expect(0, dups);
109 }
110
111 static void test_save_restore(void)
112 {
113 GpStatus stat;
114 GraphicsState state_a, state_b, state_c;
115 InterpolationMode mode;
116 GpGraphics *graphics1, *graphics2;
117 node * state_log = NULL;
118 HDC hdc = GetDC(0);
119 state_a = state_b = state_c = 0xdeadbeef;
120
121 /* Invalid saving. */
122 GdipCreateFromHDC(hdc, &graphics1);
123 stat = GdipSaveGraphics(graphics1, NULL);
124 expect(InvalidParameter, stat);
125 stat = GdipSaveGraphics(NULL, &state_a);
126 expect(InvalidParameter, stat);
127 GdipDeleteGraphics(graphics1);
128
129 log_state(state_a, &state_log);
130
131 /* Basic save/restore. */
132 GdipCreateFromHDC(hdc, &graphics1);
133 GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
134 stat = GdipSaveGraphics(graphics1, &state_a);
135 expect(Ok, stat);
136 GdipSetInterpolationMode(graphics1, InterpolationModeBicubic);
137 stat = GdipRestoreGraphics(graphics1, state_a);
138 expect(Ok, stat);
139 GdipGetInterpolationMode(graphics1, &mode);
140 todo_wine
141 expect(InterpolationModeBilinear, mode);
142 GdipDeleteGraphics(graphics1);
143
144 log_state(state_a, &state_log);
145
146 /* Restoring garbage doesn't affect saves. */
147 GdipCreateFromHDC(hdc, &graphics1);
148 GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
149 GdipSaveGraphics(graphics1, &state_a);
150 GdipSetInterpolationMode(graphics1, InterpolationModeBicubic);
151 GdipSaveGraphics(graphics1, &state_b);
152 GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
153 stat = GdipRestoreGraphics(graphics1, 0xdeadbeef);
154 expect(Ok, stat);
155 GdipRestoreGraphics(graphics1, state_b);
156 GdipGetInterpolationMode(graphics1, &mode);
157 todo_wine
158 expect(InterpolationModeBicubic, mode);
159 GdipRestoreGraphics(graphics1, state_a);
160 GdipGetInterpolationMode(graphics1, &mode);
161 todo_wine
162 expect(InterpolationModeBilinear, mode);
163 GdipDeleteGraphics(graphics1);
164
165 log_state(state_a, &state_log);
166 log_state(state_b, &state_log);
167
168 /* Restoring older state invalidates newer saves (but not older saves). */
169 GdipCreateFromHDC(hdc, &graphics1);
170 GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
171 GdipSaveGraphics(graphics1, &state_a);
172 GdipSetInterpolationMode(graphics1, InterpolationModeBicubic);
173 GdipSaveGraphics(graphics1, &state_b);
174 GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
175 GdipSaveGraphics(graphics1, &state_c);
176 GdipSetInterpolationMode(graphics1, InterpolationModeHighQualityBilinear);
177 GdipRestoreGraphics(graphics1, state_b);
178 GdipGetInterpolationMode(graphics1, &mode);
179 todo_wine
180 expect(InterpolationModeBicubic, mode);
181 GdipRestoreGraphics(graphics1, state_c);
182 GdipGetInterpolationMode(graphics1, &mode);
183 todo_wine
184 expect(InterpolationModeBicubic, mode);
185 GdipRestoreGraphics(graphics1, state_a);
186 GdipGetInterpolationMode(graphics1, &mode);
187 todo_wine
188 expect(InterpolationModeBilinear, mode);
189 GdipDeleteGraphics(graphics1);
190
191 log_state(state_a, &state_log);
192 log_state(state_b, &state_log);
193 log_state(state_c, &state_log);
194
195 /* Restoring older save from one graphics object does not invalidate
196 * newer save from other graphics object. */
197 GdipCreateFromHDC(hdc, &graphics1);
198 GdipCreateFromHDC(hdc, &graphics2);
199 GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
200 GdipSaveGraphics(graphics1, &state_a);
201 GdipSetInterpolationMode(graphics2, InterpolationModeBicubic);
202 GdipSaveGraphics(graphics2, &state_b);
203 GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
204 GdipSetInterpolationMode(graphics2, InterpolationModeNearestNeighbor);
205 GdipRestoreGraphics(graphics1, state_a);
206 GdipGetInterpolationMode(graphics1, &mode);
207 todo_wine
208 expect(InterpolationModeBilinear, mode);
209 GdipRestoreGraphics(graphics2, state_b);
210 GdipGetInterpolationMode(graphics2, &mode);
211 todo_wine
212 expect(InterpolationModeBicubic, mode);
213 GdipDeleteGraphics(graphics1);
214 GdipDeleteGraphics(graphics2);
215
216 /* You can't restore a state to a graphics object that didn't save it. */
217 GdipCreateFromHDC(hdc, &graphics1);
218 GdipCreateFromHDC(hdc, &graphics2);
219 GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
220 GdipSaveGraphics(graphics1, &state_a);
221 GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
222 GdipSetInterpolationMode(graphics2, InterpolationModeNearestNeighbor);
223 GdipRestoreGraphics(graphics2, state_a);
224 GdipGetInterpolationMode(graphics2, &mode);
225 expect(InterpolationModeNearestNeighbor, mode);
226 GdipDeleteGraphics(graphics1);
227 GdipDeleteGraphics(graphics2);
228
229 log_state(state_a, &state_log);
230
231 /* The same state value should never be returned twice. */
232 todo_wine
233 check_no_duplicates(state_log);
234
235 ReleaseDC(0, hdc);
236 }
237
238 static void test_GdipDrawArc(void)
239 {
240 GpStatus status;
241 GpGraphics *graphics = NULL;
242 GpPen *pen = NULL;
243 HDC hdc = GetDC(0);
244
245 /* make a graphics object and pen object */
246 status = GdipCreateFromHDC(hdc, &graphics);
247 expect(Ok, status);
248 ok(hdc != NULL, "Expected HDC to be initialized\n");
249
250 status = GdipCreateFromHDC(hdc, &graphics);
251 expect(Ok, status);
252 ok(graphics != NULL, "Expected graphics to be initialized\n");
253
254 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
255 expect(Ok, status);
256 ok(pen != NULL, "Expected pen to be initialized\n");
257
258 /* InvalidParameter cases: null graphics, null pen, non-positive width, non-positive height */
259 status = GdipDrawArc(NULL, NULL, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
260 expect(InvalidParameter, status);
261
262 status = GdipDrawArc(graphics, NULL, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
263 expect(InvalidParameter, status);
264
265 status = GdipDrawArc(NULL, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
266 expect(InvalidParameter, status);
267
268 status = GdipDrawArc(graphics, pen, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0);
269 expect(InvalidParameter, status);
270
271 status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
272 expect(InvalidParameter, status);
273
274 /* successful case */
275 status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
276 expect(Ok, status);
277
278 GdipDeletePen(pen);
279 GdipDeleteGraphics(graphics);
280
281 ReleaseDC(0, hdc);
282 }
283
284 static void test_GdipDrawArcI(void)
285 {
286 GpStatus status;
287 GpGraphics *graphics = NULL;
288 GpPen *pen = NULL;
289 HDC hdc = GetDC(0);
290
291 /* make a graphics object and pen object */
292 status = GdipCreateFromHDC(hdc, &graphics);
293 expect(Ok, status);
294 ok(hdc != NULL, "Expected HDC to be initialized\n");
295
296 status = GdipCreateFromHDC(hdc, &graphics);
297 expect(Ok, status);
298 ok(graphics != NULL, "Expected graphics to be initialized\n");
299
300 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
301 expect(Ok, status);
302 ok(pen != NULL, "Expected pen to be initialized\n");
303
304 /* InvalidParameter cases: null graphics, null pen, non-positive width, non-positive height */
305 status = GdipDrawArcI(NULL, NULL, 0, 0, 0, 0, 0, 0);
306 expect(InvalidParameter, status);
307
308 status = GdipDrawArcI(graphics, NULL, 0, 0, 1, 1, 0, 0);
309 expect(InvalidParameter, status);
310
311 status = GdipDrawArcI(NULL, pen, 0, 0, 1, 1, 0, 0);
312 expect(InvalidParameter, status);
313
314 status = GdipDrawArcI(graphics, pen, 0, 0, 1, 0, 0, 0);
315 expect(InvalidParameter, status);
316
317 status = GdipDrawArcI(graphics, pen, 0, 0, 0, 1, 0, 0);
318 expect(InvalidParameter, status);
319
320 /* successful case */
321 status = GdipDrawArcI(graphics, pen, 0, 0, 1, 1, 0, 0);
322 expect(Ok, status);
323
324 GdipDeletePen(pen);
325 GdipDeleteGraphics(graphics);
326
327 ReleaseDC(0, hdc);
328 }
329
330 static void test_GdipDrawBezierI(void)
331 {
332 GpStatus status;
333 GpGraphics *graphics = NULL;
334 GpPen *pen = NULL;
335 HDC hdc = GetDC(0);
336
337 /* make a graphics object and pen object */
338 status = GdipCreateFromHDC(hdc, &graphics);
339 expect(Ok, status);
340 ok(hdc != NULL, "Expected HDC to be initialized\n");
341
342 status = GdipCreateFromHDC(hdc, &graphics);
343 expect(Ok, status);
344 ok(graphics != NULL, "Expected graphics to be initialized\n");
345
346 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
347 expect(Ok, status);
348 ok(pen != NULL, "Expected pen to be initialized\n");
349
350 /* InvalidParameter cases: null graphics, null pen */
351 status = GdipDrawBezierI(NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0);
352 expect(InvalidParameter, status);
353
354 status = GdipDrawBezierI(graphics, NULL, 0, 0, 0, 0, 0, 0, 0, 0);
355 expect(InvalidParameter, status);
356
357 status = GdipDrawBezierI(NULL, pen, 0, 0, 0, 0, 0, 0, 0, 0);
358 expect(InvalidParameter, status);
359
360 /* successful case */
361 status = GdipDrawBezierI(graphics, pen, 0, 0, 0, 0, 0, 0, 0, 0);
362 expect(Ok, status);
363
364 GdipDeletePen(pen);
365 GdipDeleteGraphics(graphics);
366
367 ReleaseDC(0, hdc);
368 }
369
370 static void test_GdipDrawLineI(void)
371 {
372 GpStatus status;
373 GpGraphics *graphics = NULL;
374 GpPen *pen = NULL;
375 HDC hdc = GetDC(0);
376
377 /* make a graphics object and pen object */
378 status = GdipCreateFromHDC(hdc, &graphics);
379 expect(Ok, status);
380 ok(hdc != NULL, "Expected HDC to be initialized\n");
381
382 status = GdipCreateFromHDC(hdc, &graphics);
383 expect(Ok, status);
384 ok(graphics != NULL, "Expected graphics to be initialized\n");
385
386 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
387 expect(Ok, status);
388 ok(pen != NULL, "Expected pen to be initialized\n");
389
390 /* InvalidParameter cases: null graphics, null pen */
391 status = GdipDrawLineI(NULL, NULL, 0, 0, 0, 0);
392 expect(InvalidParameter, status);
393
394 status = GdipDrawLineI(graphics, NULL, 0, 0, 0, 0);
395 expect(InvalidParameter, status);
396
397 status = GdipDrawLineI(NULL, pen, 0, 0, 0, 0);
398 expect(InvalidParameter, status);
399
400 /* successful case */
401 status = GdipDrawLineI(graphics, pen, 0, 0, 0, 0);
402 expect(Ok, status);
403
404 GdipDeletePen(pen);
405 GdipDeleteGraphics(graphics);
406
407 ReleaseDC(0, hdc);
408 }
409
410 static void test_GdipDrawLinesI(void)
411 {
412 GpStatus status;
413 GpGraphics *graphics = NULL;
414 GpPen *pen = NULL;
415 GpPoint *ptf = NULL;
416 HDC hdc = GetDC(0);
417
418 /* make a graphics object and pen object */
419 status = GdipCreateFromHDC(hdc, &graphics);
420 expect(Ok, status);
421 ok(hdc != NULL, "Expected HDC to be initialized\n");
422
423 status = GdipCreateFromHDC(hdc, &graphics);
424 expect(Ok, status);
425 ok(graphics != NULL, "Expected graphics to be initialized\n");
426
427 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
428 expect(Ok, status);
429 ok(pen != NULL, "Expected pen to be initialized\n");
430
431 /* make some arbitrary valid points*/
432 ptf = GdipAlloc(2 * sizeof(GpPointF));
433
434 ptf[0].X = 1;
435 ptf[0].Y = 1;
436
437 ptf[1].X = 2;
438 ptf[1].Y = 2;
439
440 /* InvalidParameter cases: null graphics, null pen, null points, count < 2*/
441 status = GdipDrawLinesI(NULL, NULL, NULL, 0);
442 expect(InvalidParameter, status);
443
444 status = GdipDrawLinesI(graphics, pen, ptf, 0);
445 expect(InvalidParameter, status);
446
447 status = GdipDrawLinesI(graphics, NULL, ptf, 2);
448 expect(InvalidParameter, status);
449
450 status = GdipDrawLinesI(NULL, pen, ptf, 2);
451 expect(InvalidParameter, status);
452
453 /* successful case */
454 status = GdipDrawLinesI(graphics, pen, ptf, 2);
455 expect(Ok, status);
456
457 GdipFree(ptf);
458 GdipDeletePen(pen);
459 GdipDeleteGraphics(graphics);
460
461 ReleaseDC(0, hdc);
462 }
463
464 static void test_Get_Release_DC(void)
465 {
466 GpStatus status;
467 GpGraphics *graphics = NULL;
468 GpPen *pen;
469 GpSolidFill *brush;
470 GpPath *path;
471 HDC hdc = GetDC(0);
472 HDC retdc;
473 REAL r;
474 CompositingQuality quality;
475 CompositingMode compmode;
476 InterpolationMode intmode;
477 GpMatrix *m;
478 GpRegion *region;
479 GpUnit unit;
480 PixelOffsetMode offsetmode;
481 SmoothingMode smoothmode;
482 TextRenderingHint texthint;
483 GpPointF ptf[5];
484 GpPoint pt[5];
485 GpRectF rectf[2];
486 GpRect rect[2];
487 GpRegion *clip;
488 INT i;
489 BOOL res;
490 ARGB color = 0x00000000;
491 HRGN hrgn = CreateRectRgn(0, 0, 10, 10);
492
493 pt[0].X = 10;
494 pt[0].Y = 10;
495 pt[1].X = 20;
496 pt[1].Y = 15;
497 pt[2].X = 40;
498 pt[2].Y = 80;
499 pt[3].X = -20;
500 pt[3].Y = 20;
501 pt[4].X = 50;
502 pt[4].Y = 110;
503
504 for(i = 0; i < 5;i++){
505 ptf[i].X = (REAL)pt[i].X;
506 ptf[i].Y = (REAL)pt[i].Y;
507 }
508
509 rect[0].X = 0;
510 rect[0].Y = 0;
511 rect[0].Width = 50;
512 rect[0].Height = 70;
513 rect[1].X = 0;
514 rect[1].Y = 0;
515 rect[1].Width = 10;
516 rect[1].Height = 20;
517
518 for(i = 0; i < 2;i++){
519 rectf[i].X = (REAL)rect[i].X;
520 rectf[i].Y = (REAL)rect[i].Y;
521 rectf[i].Height = (REAL)rect[i].Height;
522 rectf[i].Width = (REAL)rect[i].Width;
523 }
524
525 GdipCreateMatrix(&m);
526 GdipCreateRegion(&region);
527 GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
528 GdipCreatePath(FillModeAlternate, &path);
529 GdipCreateRegion(&clip);
530
531 status = GdipCreateFromHDC(hdc, &graphics);
532 expect(Ok, status);
533 ok(graphics != NULL, "Expected graphics to be initialized\n");
534 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
535 expect(Ok, status);
536
537 /* NULL arguments */
538 status = GdipGetDC(NULL, NULL);
539 expect(InvalidParameter, status);
540 status = GdipGetDC(graphics, NULL);
541 expect(InvalidParameter, status);
542 status = GdipGetDC(NULL, &retdc);
543 expect(InvalidParameter, status);
544
545 status = GdipReleaseDC(NULL, NULL);
546 expect(InvalidParameter, status);
547 status = GdipReleaseDC(graphics, NULL);
548 expect(InvalidParameter, status);
549 status = GdipReleaseDC(NULL, (HDC)0xdeadbeef);
550 expect(InvalidParameter, status);
551
552 /* Release without Get */
553 status = GdipReleaseDC(graphics, hdc);
554 expect(InvalidParameter, status);
555
556 retdc = NULL;
557 status = GdipGetDC(graphics, &retdc);
558 expect(Ok, status);
559 ok(retdc == hdc, "Invalid HDC returned\n");
560 /* call it once more */
561 status = GdipGetDC(graphics, &retdc);
562 expect(ObjectBusy, status);
563
564 /* try all Graphics calls here */
565 status = Ok;
566 status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
567 expect(ObjectBusy, status); status = Ok;
568 status = GdipDrawArcI(graphics, pen, 0, 0, 1, 1, 0.0, 0.0);
569 expect(ObjectBusy, status); status = Ok;
570 status = GdipDrawBezier(graphics, pen, 0.0, 10.0, 20.0, 15.0, 35.0, -10.0, 10.0, 10.0);
571 expect(ObjectBusy, status); status = Ok;
572 status = GdipDrawBezierI(graphics, pen, 0, 0, 0, 0, 0, 0, 0, 0);
573 expect(ObjectBusy, status); status = Ok;
574 status = GdipDrawBeziers(graphics, pen, ptf, 5);
575 expect(ObjectBusy, status); status = Ok;
576 status = GdipDrawBeziersI(graphics, pen, pt, 5);
577 expect(ObjectBusy, status); status = Ok;
578 status = GdipDrawClosedCurve(graphics, pen, ptf, 5);
579 expect(ObjectBusy, status); status = Ok;
580 status = GdipDrawClosedCurveI(graphics, pen, pt, 5);
581 expect(ObjectBusy, status); status = Ok;
582 status = GdipDrawClosedCurve2(graphics, pen, ptf, 5, 1.0);
583 expect(ObjectBusy, status); status = Ok;
584 status = GdipDrawClosedCurve2I(graphics, pen, pt, 5, 1.0);
585 expect(ObjectBusy, status); status = Ok;
586 status = GdipDrawCurve(graphics, pen, ptf, 5);
587 expect(ObjectBusy, status); status = Ok;
588 status = GdipDrawCurveI(graphics, pen, pt, 5);
589 expect(ObjectBusy, status); status = Ok;
590 status = GdipDrawCurve2(graphics, pen, ptf, 5, 1.0);
591 expect(ObjectBusy, status); status = Ok;
592 status = GdipDrawCurve2I(graphics, pen, pt, 5, 1.0);
593 expect(ObjectBusy, status); status = Ok;
594 status = GdipDrawEllipse(graphics, pen, 0.0, 0.0, 100.0, 50.0);
595 expect(ObjectBusy, status); status = Ok;
596 status = GdipDrawEllipseI(graphics, pen, 0, 0, 100, 50);
597 expect(ObjectBusy, status); status = Ok;
598 /* GdipDrawImage/GdipDrawImageI */
599 /* GdipDrawImagePointsRect/GdipDrawImagePointsRectI */
600 /* GdipDrawImageRectRect/GdipDrawImageRectRectI */
601 /* GdipDrawImageRect/GdipDrawImageRectI */
602 status = GdipDrawLine(graphics, pen, 0.0, 0.0, 100.0, 200.0);
603 expect(ObjectBusy, status); status = Ok;
604 status = GdipDrawLineI(graphics, pen, 0, 0, 100, 200);
605 expect(ObjectBusy, status); status = Ok;
606 status = GdipDrawLines(graphics, pen, ptf, 5);
607 expect(ObjectBusy, status); status = Ok;
608 status = GdipDrawLinesI(graphics, pen, pt, 5);
609 expect(ObjectBusy, status); status = Ok;
610 status = GdipDrawPath(graphics, pen, path);
611 expect(ObjectBusy, status); status = Ok;
612 status = GdipDrawPie(graphics, pen, 0.0, 0.0, 100.0, 100.0, 0.0, 90.0);
613 expect(ObjectBusy, status); status = Ok;
614 status = GdipDrawPieI(graphics, pen, 0, 0, 100, 100, 0.0, 90.0);
615 expect(ObjectBusy, status); status = Ok;
616 status = GdipDrawRectangle(graphics, pen, 0.0, 0.0, 100.0, 300.0);
617 expect(ObjectBusy, status); status = Ok;
618 status = GdipDrawRectangleI(graphics, pen, 0, 0, 100, 300);
619 expect(ObjectBusy, status); status = Ok;
620 status = GdipDrawRectangles(graphics, pen, rectf, 2);
621 expect(ObjectBusy, status); status = Ok;
622 status = GdipDrawRectanglesI(graphics, pen, rect, 2);
623 expect(ObjectBusy, status); status = Ok;
624 /* GdipDrawString */
625 status = GdipFillClosedCurve2(graphics, (GpBrush*)brush, ptf, 5, 1.0, FillModeAlternate);
626 expect(ObjectBusy, status); status = Ok;
627 status = GdipFillClosedCurve2I(graphics, (GpBrush*)brush, pt, 5, 1.0, FillModeAlternate);
628 expect(ObjectBusy, status); status = Ok;
629 status = GdipFillEllipse(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0);
630 expect(ObjectBusy, status); status = Ok;
631 status = GdipFillEllipseI(graphics, (GpBrush*)brush, 0, 0, 100, 100);
632 expect(ObjectBusy, status); status = Ok;
633 status = GdipFillPath(graphics, (GpBrush*)brush, path);
634 expect(ObjectBusy, status); status = Ok;
635 status = GdipFillPie(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0, 0.0, 15.0);
636 expect(ObjectBusy, status); status = Ok;
637 status = GdipFillPieI(graphics, (GpBrush*)brush, 0, 0, 100, 100, 0.0, 15.0);
638 expect(ObjectBusy, status); status = Ok;
639 status = GdipFillPolygon(graphics, (GpBrush*)brush, ptf, 5, FillModeAlternate);
640 expect(ObjectBusy, status); status = Ok;
641 status = GdipFillPolygonI(graphics, (GpBrush*)brush, pt, 5, FillModeAlternate);
642 expect(ObjectBusy, status); status = Ok;
643 status = GdipFillPolygon2(graphics, (GpBrush*)brush, ptf, 5);
644 expect(ObjectBusy, status); status = Ok;
645 status = GdipFillPolygon2I(graphics, (GpBrush*)brush, pt, 5);
646 expect(ObjectBusy, status); status = Ok;
647 status = GdipFillRectangle(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0);
648 expect(ObjectBusy, status); status = Ok;
649 status = GdipFillRectangleI(graphics, (GpBrush*)brush, 0, 0, 100, 100);
650 expect(ObjectBusy, status); status = Ok;
651 status = GdipFillRectangles(graphics, (GpBrush*)brush, rectf, 2);
652 expect(ObjectBusy, status); status = Ok;
653 status = GdipFillRectanglesI(graphics, (GpBrush*)brush, rect, 2);
654 expect(ObjectBusy, status); status = Ok;
655 status = GdipFillRegion(graphics, (GpBrush*)brush, region);
656 expect(ObjectBusy, status); status = Ok;
657 status = GdipFlush(graphics, FlushIntentionFlush);
658 expect(ObjectBusy, status); status = Ok;
659 status = GdipGetClipBounds(graphics, rectf);
660 expect(ObjectBusy, status); status = Ok;
661 status = GdipGetClipBoundsI(graphics, rect);
662 expect(ObjectBusy, status); status = Ok;
663 status = GdipGetCompositingMode(graphics, &compmode);
664 expect(ObjectBusy, status); status = Ok;
665 status = GdipGetCompositingQuality(graphics, &quality);
666 expect(ObjectBusy, status); status = Ok;
667 status = GdipGetInterpolationMode(graphics, &intmode);
668 expect(ObjectBusy, status); status = Ok;
669 status = GdipGetNearestColor(graphics, &color);
670 expect(ObjectBusy, status); status = Ok;
671 status = GdipGetPageScale(graphics, &r);
672 expect(ObjectBusy, status); status = Ok;
673 status = GdipGetPageUnit(graphics, &unit);
674 expect(ObjectBusy, status); status = Ok;
675 status = GdipGetPixelOffsetMode(graphics, &offsetmode);
676 expect(ObjectBusy, status); status = Ok;
677 status = GdipGetSmoothingMode(graphics, &smoothmode);
678 expect(ObjectBusy, status); status = Ok;
679 status = GdipGetTextRenderingHint(graphics, &texthint);
680 expect(ObjectBusy, status); status = Ok;
681 status = GdipGetWorldTransform(graphics, m);
682 expect(ObjectBusy, status); status = Ok;
683 status = GdipGraphicsClear(graphics, 0xdeadbeef);
684 expect(ObjectBusy, status); status = Ok;
685 status = GdipIsVisiblePoint(graphics, 0.0, 0.0, &res);
686 expect(ObjectBusy, status); status = Ok;
687 status = GdipIsVisiblePointI(graphics, 0, 0, &res);
688 expect(ObjectBusy, status); status = Ok;
689 /* GdipMeasureCharacterRanges */
690 /* GdipMeasureString */
691 status = GdipResetClip(graphics);
692 expect(ObjectBusy, status); status = Ok;
693 status = GdipResetWorldTransform(graphics);
694 expect(ObjectBusy, status); status = Ok;
695 /* GdipRestoreGraphics */
696 status = GdipRotateWorldTransform(graphics, 15.0, MatrixOrderPrepend);
697 expect(ObjectBusy, status); status = Ok;
698 /* GdipSaveGraphics */
699 status = GdipScaleWorldTransform(graphics, 1.0, 1.0, MatrixOrderPrepend);
700 expect(ObjectBusy, status); status = Ok;
701 status = GdipSetCompositingMode(graphics, CompositingModeSourceOver);
702 expect(ObjectBusy, status); status = Ok;
703 status = GdipSetCompositingQuality(graphics, CompositingQualityDefault);
704 expect(ObjectBusy, status); status = Ok;
705 status = GdipSetInterpolationMode(graphics, InterpolationModeDefault);
706 expect(ObjectBusy, status); status = Ok;
707 status = GdipSetPageScale(graphics, 1.0);
708 expect(ObjectBusy, status); status = Ok;
709 status = GdipSetPageUnit(graphics, UnitWorld);
710 expect(ObjectBusy, status); status = Ok;
711 status = GdipSetPixelOffsetMode(graphics, PixelOffsetModeDefault);
712 expect(ObjectBusy, status); status = Ok;
713 status = GdipSetSmoothingMode(graphics, SmoothingModeDefault);
714 expect(ObjectBusy, status); status = Ok;
715 status = GdipSetTextRenderingHint(graphics, TextRenderingHintSystemDefault);
716 expect(ObjectBusy, status); status = Ok;
717 status = GdipSetWorldTransform(graphics, m);
718 expect(ObjectBusy, status); status = Ok;
719 status = GdipTranslateWorldTransform(graphics, 0.0, 0.0, MatrixOrderPrepend);
720 expect(ObjectBusy, status); status = Ok;
721 status = GdipSetClipHrgn(graphics, hrgn, CombineModeReplace);
722 expect(ObjectBusy, status); status = Ok;
723 status = GdipSetClipPath(graphics, path, CombineModeReplace);
724 expect(ObjectBusy, status); status = Ok;
725 status = GdipSetClipRect(graphics, 0.0, 0.0, 10.0, 10.0, CombineModeReplace);
726 expect(ObjectBusy, status); status = Ok;
727 status = GdipSetClipRectI(graphics, 0, 0, 10, 10, CombineModeReplace);
728 expect(ObjectBusy, status); status = Ok;
729 status = GdipSetClipRegion(graphics, clip, CombineModeReplace);
730 expect(ObjectBusy, status); status = Ok;
731 status = GdipTranslateClip(graphics, 0.0, 0.0);
732 expect(ObjectBusy, status); status = Ok;
733 status = GdipTranslateClipI(graphics, 0, 0);
734 expect(ObjectBusy, status); status = Ok;
735 status = GdipDrawPolygon(graphics, pen, ptf, 5);
736 expect(ObjectBusy, status); status = Ok;
737 status = GdipDrawPolygonI(graphics, pen, pt, 5);
738 expect(ObjectBusy, status); status = Ok;
739 status = GdipGetDpiX(graphics, &r);
740 expect(ObjectBusy, status); status = Ok;
741 status = GdipGetDpiY(graphics, &r);
742 expect(ObjectBusy, status); status = Ok;
743 status = GdipMultiplyWorldTransform(graphics, m, MatrixOrderPrepend);
744 status = GdipGetClip(graphics, region);
745 expect(ObjectBusy, status); status = Ok;
746 status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, ptf, 5);
747 expect(ObjectBusy, status); status = Ok;
748 /* try to delete before release */
749 status = GdipDeleteGraphics(graphics);
750 expect(ObjectBusy, status);
751
752 status = GdipReleaseDC(graphics, retdc);
753 expect(Ok, status);
754
755 GdipDeletePen(pen);
756 GdipDeleteGraphics(graphics);
757
758 GdipDeletePath(path);
759 GdipDeleteBrush((GpBrush*)brush);
760 GdipDeleteRegion(region);
761 GdipDeleteMatrix(m);
762 DeleteObject(hrgn);
763
764 ReleaseDC(0, hdc);
765 }
766
767 static void test_transformpoints(void)
768 {
769 GpStatus status;
770 GpGraphics *graphics = NULL;
771 HDC hdc = GetDC(0);
772 GpPointF ptf[2];
773 GpPoint pt[2];
774
775 status = GdipCreateFromHDC(hdc, &graphics);
776 expect(Ok, status);
777
778 /* NULL arguments */
779 status = GdipTransformPoints(NULL, CoordinateSpacePage, CoordinateSpaceWorld, NULL, 0);
780 expect(InvalidParameter, status);
781 status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, NULL, 0);
782 expect(InvalidParameter, status);
783 status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, ptf, 0);
784 expect(InvalidParameter, status);
785 status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, ptf, -1);
786 expect(InvalidParameter, status);
787
788 ptf[0].X = 1.0;
789 ptf[0].Y = 0.0;
790 ptf[1].X = 0.0;
791 ptf[1].Y = 1.0;
792 status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, ptf, 2);
793 expect(Ok, status);
794 expectf(1.0, ptf[0].X);
795 expectf(0.0, ptf[0].Y);
796 expectf(0.0, ptf[1].X);
797 expectf(1.0, ptf[1].Y);
798
799 status = GdipTranslateWorldTransform(graphics, 5.0, 5.0, MatrixOrderAppend);
800 expect(Ok, status);
801 status = GdipSetPageUnit(graphics, UnitPixel);
802 expect(Ok, status);
803 status = GdipSetPageScale(graphics, 3.0);
804 expect(Ok, status);
805
806 ptf[0].X = 1.0;
807 ptf[0].Y = 0.0;
808 ptf[1].X = 0.0;
809 ptf[1].Y = 1.0;
810 status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, ptf, 2);
811 expect(Ok, status);
812 expectf(18.0, ptf[0].X);
813 expectf(15.0, ptf[0].Y);
814 expectf(15.0, ptf[1].X);
815 expectf(18.0, ptf[1].Y);
816
817 ptf[0].X = 1.0;
818 ptf[0].Y = 0.0;
819 ptf[1].X = 0.0;
820 ptf[1].Y = 1.0;
821 status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, ptf, 2);
822 expect(Ok, status);
823 expectf(6.0, ptf[0].X);
824 expectf(5.0, ptf[0].Y);
825 expectf(5.0, ptf[1].X);
826 expectf(6.0, ptf[1].Y);
827
828 ptf[0].X = 1.0;
829 ptf[0].Y = 0.0;
830 ptf[1].X = 0.0;
831 ptf[1].Y = 1.0;
832 status = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpacePage, ptf, 2);
833 expect(Ok, status);
834 expectf(3.0, ptf[0].X);
835 expectf(0.0, ptf[0].Y);
836 expectf(0.0, ptf[1].X);
837 expectf(3.0, ptf[1].Y);
838
839 ptf[0].X = 18.0;
840 ptf[0].Y = 15.0;
841 ptf[1].X = 15.0;
842 ptf[1].Y = 18.0;
843 status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, ptf, 2);
844 expect(Ok, status);
845 expectf(1.0, ptf[0].X);
846 expectf(0.0, ptf[0].Y);
847 expectf(0.0, ptf[1].X);
848 expectf(1.0, ptf[1].Y);
849
850 ptf[0].X = 6.0;
851 ptf[0].Y = 5.0;
852 ptf[1].X = 5.0;
853 ptf[1].Y = 6.0;
854 status = GdipTransformPoints(graphics, CoordinateSpaceWorld, CoordinateSpacePage, ptf, 2);
855 expect(Ok, status);
856 expectf(1.0, ptf[0].X);
857 expectf(0.0, ptf[0].Y);
858 expectf(0.0, ptf[1].X);
859 expectf(1.0, ptf[1].Y);
860
861 ptf[0].X = 3.0;
862 ptf[0].Y = 0.0;
863 ptf[1].X = 0.0;
864 ptf[1].Y = 3.0;
865 status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceDevice, ptf, 2);
866 expect(Ok, status);
867 expectf(1.0, ptf[0].X);
868 expectf(0.0, ptf[0].Y);
869 expectf(0.0, ptf[1].X);
870 expectf(1.0, ptf[1].Y);
871
872 pt[0].X = 1;
873 pt[0].Y = 0;
874 pt[1].X = 0;
875 pt[1].Y = 1;
876 status = GdipTransformPointsI(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 2);
877 expect(Ok, status);
878 expect(18, pt[0].X);
879 expect(15, pt[0].Y);
880 expect(15, pt[1].X);
881 expect(18, pt[1].Y);
882
883 GdipDeleteGraphics(graphics);
884 ReleaseDC(0, hdc);
885 }
886
887 static void test_get_set_clip(void)
888 {
889 GpStatus status;
890 GpGraphics *graphics = NULL;
891 HDC hdc = GetDC(0);
892 GpRegion *clip;
893 GpRectF rect;
894 BOOL res;
895
896 status = GdipCreateFromHDC(hdc, &graphics);
897 expect(Ok, status);
898
899 rect.X = rect.Y = 0.0;
900 rect.Height = rect.Width = 100.0;
901
902 status = GdipCreateRegionRect(&rect, &clip);
903
904 /* NULL arguments */
905 status = GdipGetClip(NULL, NULL);
906 expect(InvalidParameter, status);
907 status = GdipGetClip(graphics, NULL);
908 expect(InvalidParameter, status);
909 status = GdipGetClip(NULL, clip);
910 expect(InvalidParameter, status);
911
912 status = GdipSetClipRegion(NULL, NULL, CombineModeReplace);
913 expect(InvalidParameter, status);
914 status = GdipSetClipRegion(graphics, NULL, CombineModeReplace);
915 expect(InvalidParameter, status);
916
917 status = GdipSetClipPath(NULL, NULL, CombineModeReplace);
918 expect(InvalidParameter, status);
919 status = GdipSetClipPath(graphics, NULL, CombineModeReplace);
920 expect(InvalidParameter, status);
921
922 res = FALSE;
923 status = GdipGetClip(graphics, clip);
924 expect(Ok, status);
925 status = GdipIsInfiniteRegion(clip, graphics, &res);
926 expect(Ok, status);
927 expect(TRUE, res);
928
929 /* remains infinite after reset */
930 res = FALSE;
931 status = GdipResetClip(graphics);
932 expect(Ok, status);
933 status = GdipGetClip(graphics, clip);
934 expect(Ok, status);
935 status = GdipIsInfiniteRegion(clip, graphics, &res);
936 expect(Ok, status);
937 expect(TRUE, res);
938
939 /* set to empty and then reset to infinite */
940 status = GdipSetEmpty(clip);
941 expect(Ok, status);
942 status = GdipSetClipRegion(graphics, clip, CombineModeReplace);
943 expect(Ok, status);
944
945 status = GdipGetClip(graphics, clip);
946 expect(Ok, status);
947 res = FALSE;
948 status = GdipIsEmptyRegion(clip, graphics, &res);
949 expect(Ok, status);
950 expect(TRUE, res);
951 status = GdipResetClip(graphics);
952 expect(Ok, status);
953 status = GdipGetClip(graphics, clip);
954 expect(Ok, status);
955 res = FALSE;
956 status = GdipIsInfiniteRegion(clip, graphics, &res);
957 expect(Ok, status);
958 expect(TRUE, res);
959
960 GdipDeleteRegion(clip);
961
962 GdipDeleteGraphics(graphics);
963 ReleaseDC(0, hdc);
964 }
965
966 static void test_isempty(void)
967 {
968 GpStatus status;
969 GpGraphics *graphics = NULL;
970 HDC hdc = GetDC(0);
971 GpRegion *clip;
972 BOOL res;
973
974 status = GdipCreateFromHDC(hdc, &graphics);
975 expect(Ok, status);
976
977 status = GdipCreateRegion(&clip);
978 expect(Ok, status);
979
980 /* NULL */
981 status = GdipIsClipEmpty(NULL, NULL);
982 expect(InvalidParameter, status);
983 status = GdipIsClipEmpty(graphics, NULL);
984 expect(InvalidParameter, status);
985 status = GdipIsClipEmpty(NULL, &res);
986 expect(InvalidParameter, status);
987
988 /* default is infinite */
989 res = TRUE;
990 status = GdipIsClipEmpty(graphics, &res);
991 expect(Ok, status);
992 expect(FALSE, res);
993
994 GdipDeleteRegion(clip);
995
996 GdipDeleteGraphics(graphics);
997 ReleaseDC(0, hdc);
998 }
999
1000 static void test_clear(void)
1001 {
1002 GpStatus status;
1003
1004 status = GdipGraphicsClear(NULL, 0xdeadbeef);
1005 expect(InvalidParameter, status);
1006 }
1007
1008 static void test_textcontrast(void)
1009 {
1010 GpStatus status;
1011 HDC hdc = GetDC(0);
1012 GpGraphics *graphics;
1013 UINT contrast;
1014
1015 status = GdipGetTextContrast(NULL, NULL);
1016 expect(InvalidParameter, status);
1017
1018 status = GdipCreateFromHDC(hdc, &graphics);
1019 expect(Ok, status);
1020
1021 status = GdipGetTextContrast(graphics, NULL);
1022 expect(InvalidParameter, status);
1023 status = GdipGetTextContrast(graphics, &contrast);
1024 expect(4, contrast);
1025
1026 GdipDeleteGraphics(graphics);
1027 ReleaseDC(0, hdc);
1028 }
1029
1030 static void test_GdipDrawString(void)
1031 {
1032 GpStatus status;
1033 GpGraphics *graphics = NULL;
1034 GpFont *fnt = NULL;
1035 RectF rect;
1036 GpStringFormat *format;
1037 GpBrush *brush;
1038 LOGFONTA logfont;
1039 HDC hdc = GetDC(0);
1040 static const WCHAR string[] = {'T','e','s','t',0};
1041
1042 memset(&logfont,0,sizeof(logfont));
1043 strcpy(logfont.lfFaceName,"Arial");
1044 logfont.lfHeight = 12;
1045 logfont.lfCharSet = DEFAULT_CHARSET;
1046
1047 status = GdipCreateFromHDC(hdc, &graphics);
1048 expect(Ok, status);
1049
1050 status = GdipCreateFontFromLogfontA(hdc, &logfont, &fnt);
1051 if (status == FileNotFound)
1052 {
1053 skip("Arial not installed.\n");
1054 return;
1055 }
1056 expect(Ok, status);
1057
1058 status = GdipCreateSolidFill((ARGB)0xdeadbeef, (GpSolidFill**)&brush);
1059 expect(Ok, status);
1060
1061 status = GdipCreateStringFormat(0,0,&format);
1062 expect(Ok, status);
1063
1064 rect.X = 0;
1065 rect.Y = 0;
1066 rect.Width = 0;
1067 rect.Height = 12;
1068
1069 status = GdipDrawString(graphics, string, 4, fnt, &rect, format, brush);
1070 expect(Ok, status);
1071
1072 GdipDeleteGraphics(graphics);
1073 GdipDeleteBrush(brush);
1074 GdipDeleteFont(fnt);
1075 GdipDeleteStringFormat(format);
1076
1077 ReleaseDC(0, hdc);
1078 }
1079
1080
1081 START_TEST(graphics)
1082 {
1083 struct GdiplusStartupInput gdiplusStartupInput;
1084 ULONG_PTR gdiplusToken;
1085
1086 gdiplusStartupInput.GdiplusVersion = 1;
1087 gdiplusStartupInput.DebugEventCallback = NULL;
1088 gdiplusStartupInput.SuppressBackgroundThread = 0;
1089 gdiplusStartupInput.SuppressExternalCodecs = 0;
1090
1091 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
1092
1093 test_constructor_destructor();
1094 test_save_restore();
1095 test_GdipDrawBezierI();
1096 test_GdipDrawArc();
1097 test_GdipDrawArcI();
1098 test_GdipDrawLineI();
1099 test_GdipDrawLinesI();
1100 test_GdipDrawString();
1101 test_Get_Release_DC();
1102 test_transformpoints();
1103 test_get_set_clip();
1104 test_isempty();
1105 test_clear();
1106 test_textcontrast();
1107
1108 GdiplusShutdown(gdiplusToken);
1109 }