1 #ifdef WIN32
2 #ifndef __cplusplus
3 #error Please compile with a C++ compiler.
4 #endif
5 #endif
6
7 #if defined(USE_WINDOWS_GDIPLUS)
8 #include <Windows.h>
9 #include <GdiPlus.h>
10
11 #pragma comment(lib, "gdiplus.lib")
12 #else
13 #include <GdiPlusFlat.h>
14 #endif
15
16 #if defined(USE_WINDOWS_GDIPLUS)
17 using namespace Gdiplus;
18 using namespace DllExports;
19 #endif
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <assert.h>
24 #include "testhelpers.h"
25
getImageGraphics(GpImage ** image)26 static GpGraphics *getImageGraphics (GpImage **image)
27 {
28 GpStatus status;
29 WCHAR *filePath;
30 GpGraphics *graphics;
31
32 filePath = createWchar ("test.bmp");
33 status = GdipLoadImageFromFile (filePath, image);
34 assertEqualInt (status, Ok);
35
36 freeWchar (filePath);
37
38 status = GdipGetImageGraphicsContext (*image, &graphics);
39 assertEqualInt (status, Ok);
40
41 return graphics;
42 }
43
44 #if defined(USE_WINDOWS_GDIPLUS)
45 HWND hwnd;
46
WndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)47 LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
48 {
49 switch(msg)
50 {
51 case WM_CLOSE:
52 DestroyWindow(hwnd);
53 break;
54 case WM_DESTROY:
55 PostQuitMessage(0);
56 break;
57 default:
58 return DefWindowProc(hwnd, msg, wParam, lParam);
59 }
60 return 0;
61 }
62 #endif
63
test_createFromHDC()64 static void test_createFromHDC()
65 {
66 GpStatus status;
67 GpImage *image;
68 GpGraphics *graphicsOriginal;
69 HDC hdc;
70 GpGraphics *graphics;
71 TextRenderingHint textRenderingHint;
72
73 graphicsOriginal = getImageGraphics (&image);
74
75 status = GdipSetTextRenderingHint (graphicsOriginal, TextRenderingHintClearTypeGridFit);
76 assertEqualInt (status, Ok);
77
78 status = GdipGetDC (graphicsOriginal, &hdc);
79 assertEqualInt (status, Ok);
80
81 status = GdipCreateFromHDC (hdc, &graphics);
82 assertEqualInt (status, Ok);
83 assert (graphics != NULL);
84
85 // The graphics from the HDC should not have the same values as the original graphics.
86 status = GdipGetTextRenderingHint (graphics, &textRenderingHint);
87 assertEqualInt (status, Ok);
88 assertEqualInt (textRenderingHint, TextRenderingHintSystemDefault);
89
90 // Modifying the graphics from the HDC should not modify the original graphics.
91 status = GdipSetTextRenderingHint (graphics, TextRenderingHintSingleBitPerPixelGridFit);
92 assertEqualInt (status, Ok);
93
94 GdipReleaseDC (graphicsOriginal, hdc);
95
96 status = GdipGetTextRenderingHint (graphicsOriginal, &textRenderingHint);
97 assertEqualInt (status, Ok);
98 assertEqualInt (textRenderingHint, TextRenderingHintClearTypeGridFit);
99
100 #if defined(USE_WINDOWS_GDIPLUS)
101 {
102 HDC hdc;
103 INT x;
104 INT y;
105
106 // Window DC.
107 hdc = GetDC (hwnd);
108
109 SetViewportOrgEx (hdc, 10, 20, NULL);
110 SetWindowOrgEx (hdc, 30, 40, NULL);
111
112 status = GdipCreateFromHDC (hdc, &graphics);
113 assertEqualInt (status, Ok);
114
115 GdipGetRenderingOrigin (graphics, &x, &y);
116 assertEqualInt (10, x);
117 assertEqualInt (20, y);
118
119 ReleaseDC (hwnd, hdc);
120 }
121 #endif
122
123 // Negative tests.
124 status = GdipCreateFromHDC (0, &graphics);
125 assertEqualInt (status, OutOfMemory);
126
127 status = GdipCreateFromHDC (0, NULL);
128 assertEqualInt (status, InvalidParameter);
129
130 GdipDisposeImage (image);
131 GdipDeleteGraphics (graphicsOriginal);
132 GdipDeleteGraphics (graphics);
133 }
134
test_createFromHDC2()135 static void test_createFromHDC2()
136 {
137 GpStatus status;
138 GpImage *image;
139 GpGraphics *graphicsOriginal;
140 HDC hdc;
141 GpGraphics *graphics;
142 TextRenderingHint textRenderingHint;
143
144 graphicsOriginal = getImageGraphics (&image);
145
146 status = GdipSetTextRenderingHint (graphicsOriginal, TextRenderingHintClearTypeGridFit);
147 assertEqualInt (status, Ok);
148
149 status = GdipGetDC (graphicsOriginal, &hdc);
150 assertEqualInt (status, Ok);
151
152 status = GdipCreateFromHDC2 (hdc, NULL, &graphics);
153 assertEqualInt (status, Ok);
154 assert (graphics != NULL);
155
156 // The graphics from the HDC should not have the same values as the original graphics.
157 status = GdipGetTextRenderingHint (graphics, &textRenderingHint);
158 assertEqualInt (status, Ok);
159 assertEqualInt (textRenderingHint, TextRenderingHintSystemDefault);
160
161 // Modifying the graphics from the HDC should not modify the original graphics.
162 status = GdipSetTextRenderingHint (graphics, TextRenderingHintSingleBitPerPixelGridFit);
163 assertEqualInt (status, Ok);
164
165 GdipReleaseDC (graphicsOriginal, hdc);
166
167 status = GdipGetTextRenderingHint (graphicsOriginal, &textRenderingHint);
168 assertEqualInt (status, Ok);
169 assertEqualInt (textRenderingHint, TextRenderingHintClearTypeGridFit);
170
171 #if defined(USE_WINDOWS_GDIPLUS)
172 {
173 HDC hdc;
174 INT x;
175 INT y;
176
177 // Window DC.
178 hdc = GetDC (hwnd);
179
180 SetViewportOrgEx (hdc, 10, 20, NULL);
181 SetWindowOrgEx (hdc, 30, 40, NULL);
182
183 status = GdipCreateFromHDC2 (hdc, NULL, &graphics);
184 assertEqualInt (status, Ok);
185
186 GdipGetRenderingOrigin (graphics, &x, &y);
187 assertEqualInt (10, x);
188 assertEqualInt (20, y);
189
190 ReleaseDC (hwnd, hdc);
191 }
192 #endif
193
194 // Negative tests.
195 status = GdipCreateFromHDC2 (0, NULL, &graphics);
196 assertEqualInt (status, OutOfMemory);
197
198 status = GdipCreateFromHDC2 (0, NULL, NULL);
199 assertEqualInt (status, InvalidParameter);
200
201 GdipDisposeImage (image);
202 GdipDeleteGraphics (graphicsOriginal);
203 GdipDeleteGraphics (graphics);
204 }
205
test_createFromHWND()206 static void test_createFromHWND()
207 {
208 GpStatus status;
209 GpGraphics *graphics;
210 #if defined(USE_WINDOWS_GDIPLUS)
211 GpRectF bounds;
212 #endif
213
214 status = GdipCreateFromHWND (0, NULL);
215 assertEqualInt (status, InvalidParameter);
216
217 // Libgdiplus does not implement GdipCreateFromHwnd.
218 #if defined(USE_WINDOWS_GDIPLUS)
219 // HWND of zero means the current screen.
220 status = GdipCreateFromHWND (0, &graphics);
221 assertEqualInt (status, Ok);
222 assert (graphics != NULL);
223
224 GdipDeleteGraphics (graphics);
225
226 status = GdipCreateFromHWND (hwnd, &graphics);
227 assertEqualInt (status, Ok);
228 assert (graphics != NULL);
229
230 status = GdipGetVisibleClipBounds (graphics, &bounds);
231 assertEqualInt (status, Ok);
232 assertEqualFloat (bounds.X, 0);
233 assertEqualFloat (bounds.Y, 0);
234 assertEqualFloat (bounds.Width, 484);
235 assertEqualFloat (bounds.Height, 61);
236
237 GdipDeleteGraphics (graphics);
238 #else
239 status = GdipCreateFromHWND (0, &graphics);
240 assertEqualInt (status, NotImplemented);
241 #endif
242 }
243
test_createFromHWNDICM()244 static void test_createFromHWNDICM()
245 {
246 GpStatus status;
247 GpGraphics *graphics;
248
249 status = GdipCreateFromHWNDICM (0, NULL);
250 assertEqualInt (status, InvalidParameter);
251
252 // Libgdiplus does not implement GdipCreateFromHwndICM.
253 #if defined(USE_WINDOWS_GDIPLUS)
254 // HWND of zero means the current screen.
255 status = GdipCreateFromHWNDICM (0, &graphics);
256 assertEqualInt (status, Ok);
257 assert (graphics != NULL);
258
259 status = GdipCreateFromHWNDICM (hwnd, &graphics);
260 assertEqualInt (status, Ok);
261 assert (graphics != NULL);
262
263 GdipDeleteGraphics (graphics);
264 #else
265 status = GdipCreateFromHWNDICM (0, &graphics);
266 assertEqualInt (status, NotImplemented);
267 #endif
268 }
269
test_hdc()270 static void test_hdc ()
271 {
272 GpStatus status;
273 GpImage *image;
274 GpGraphics *graphics;
275 HDC hdc;
276
277 graphics = getImageGraphics (&image);
278
279 // Negative tests.
280 status = GdipGetDC (NULL, &hdc);
281 assertEqualInt (status, InvalidParameter);
282
283 status = GdipGetDC (graphics, NULL);
284 assertEqualInt (status, InvalidParameter);
285
286 status = GdipGetDC (graphics, &hdc);
287 assertEqualInt (status, Ok);
288 assert (hdc != 0);
289
290 status = GdipGetDC (graphics, &hdc);
291 assertEqualInt (status, ObjectBusy);
292
293 status = GdipGetDC (graphics, NULL);
294 assertEqualInt (status, InvalidParameter);
295
296 status = GdipReleaseDC (NULL, hdc);
297 assertEqualInt (status, InvalidParameter);
298
299 status = GdipReleaseDC (NULL, 0);
300 assertEqualInt (status, InvalidParameter);
301
302 status = GdipReleaseDC (graphics, 0);
303 assertEqualInt (status, InvalidParameter);
304
305 status = GdipReleaseDC (graphics, hdc);
306 assertEqualInt (status, Ok);
307
308 status = GdipReleaseDC (graphics, hdc);
309 assertEqualInt (status, InvalidParameter);
310
311 GdipDisposeImage (image);
312 GdipDeleteGraphics (graphics);
313 }
314
test_compositingMode()315 static void test_compositingMode ()
316 {
317 GpStatus status;
318 GpImage *image;
319 GpGraphics *graphics;
320 CompositingMode mode;
321
322 graphics = getImageGraphics (&image);
323
324 // Default get.
325 status = GdipGetCompositingMode(graphics, &mode);
326 assertEqualInt (status, Ok);
327 assertEqualInt (mode, CompositingModeSourceOver);
328
329 // CompositingModeSourceOver.
330 status = GdipSetCompositingMode (graphics, CompositingModeSourceOver);
331 assertEqualInt (status, Ok);
332
333 status = GdipGetCompositingMode(graphics, &mode);
334 assertEqualInt (status, Ok);
335 assertEqualInt (mode, CompositingModeSourceOver);
336
337 // CompositingModeSourceOver.
338 status = GdipSetCompositingMode (graphics, CompositingModeSourceCopy);
339 assertEqualInt (status, Ok);
340
341 status = GdipGetCompositingMode(graphics, &mode);
342 assertEqualInt (status, Ok);
343 assertEqualInt (mode, CompositingModeSourceCopy);
344
345 // Invalid CompositingMode.
346 status = GdipSetCompositingMode (graphics, (CompositingMode) (CompositingModeSourceCopy + 1));
347 assertEqualInt (status, Ok);
348
349 status = GdipGetCompositingMode(graphics, &mode);
350 assertEqualInt (status, Ok);
351 assertEqualInt (mode, (CompositingMode) (CompositingModeSourceCopy + 1));
352
353 // Invalid CompositingMode.
354 status = GdipSetCompositingMode (graphics, (CompositingMode) (CompositingModeSourceOver - 1));
355 assertEqualInt (status, Ok);
356
357 status = GdipGetCompositingMode(graphics, &mode);
358 assertEqualInt (status, Ok);
359 assertEqualInt (mode, (CompositingMode) (CompositingModeSourceOver - 1));
360
361 // Negative tests.
362 status = GdipSetCompositingMode (NULL, CompositingModeSourceCopy);
363 assertEqualInt (status, InvalidParameter);
364
365 status = GdipGetCompositingMode (NULL, &mode);
366 assertEqualInt (status, InvalidParameter);
367
368 status = GdipGetCompositingMode (graphics, NULL);
369 assertEqualInt (status, InvalidParameter);
370
371 HDC hdc;
372 GdipGetDC (graphics, &hdc);
373
374 status = GdipGetCompositingMode (graphics, &mode);
375 assertEqualInt (status, ObjectBusy);
376
377 status = GdipGetCompositingMode (graphics, NULL);
378 assertEqualInt (status, InvalidParameter);
379
380 status = GdipSetCompositingMode (graphics, CompositingModeSourceCopy);
381 assertEqualInt (status, ObjectBusy);
382
383 GdipReleaseDC (graphics, hdc);
384
385 GdipDisposeImage (image);
386 GdipDeleteGraphics (graphics);
387 }
388
test_compositingQuality()389 static void test_compositingQuality ()
390 {
391 GpStatus status;
392 GpImage *image;
393 GpGraphics *graphics;
394 CompositingQuality quality;
395
396 graphics = getImageGraphics (&image);
397
398 // Default get.
399 status = GdipGetCompositingQuality (graphics, &quality);
400 assertEqualInt (status, Ok);
401 assertEqualInt (quality, CompositingQualityDefault);
402
403 // CompositingQualityInvalid.
404 status = GdipSetCompositingQuality (graphics, CompositingQualityInvalid);
405 assertEqualInt (status, Ok);
406
407 status = GdipGetCompositingQuality (graphics, &quality);
408 assertEqualInt (status, Ok);
409 assertEqualInt (quality, CompositingQualityInvalid);
410
411 // CompositingQualityDefault.
412 status = GdipSetCompositingQuality (graphics, CompositingQualityDefault);
413 assertEqualInt (status, Ok);
414
415 status = GdipGetCompositingQuality (graphics, &quality);
416 assertEqualInt (status, Ok);
417 assertEqualInt (quality, CompositingQualityDefault);
418
419 // CompositingQualityHighSpeed.
420 status = GdipSetCompositingQuality (graphics, CompositingQualityHighSpeed);
421 assertEqualInt (status, Ok);
422
423 status = GdipGetCompositingQuality (graphics, &quality);
424 assertEqualInt (status, Ok);
425 assertEqualInt (quality, CompositingQualityHighSpeed);
426
427 // CompositingQualityHighQuality.
428 status = GdipSetCompositingQuality (graphics, CompositingQualityHighQuality);
429 assertEqualInt (status, Ok);
430
431 status = GdipGetCompositingQuality (graphics, &quality);
432 assertEqualInt (status, Ok);
433 assertEqualInt (quality, CompositingQualityHighQuality);
434
435 // CompositingQualityGammaCorrected.
436 status = GdipSetCompositingQuality (graphics, CompositingQualityGammaCorrected);
437 assertEqualInt (status, Ok);
438
439 status = GdipGetCompositingQuality (graphics, &quality);
440 assertEqualInt (status, Ok);
441 assertEqualInt (quality, CompositingQualityGammaCorrected);
442
443 // CompositingQualityAssumeLinear.
444 status = GdipSetCompositingQuality (graphics, CompositingQualityAssumeLinear);
445 assertEqualInt (status, Ok);
446
447 status = GdipGetCompositingQuality (graphics, &quality);
448 assertEqualInt (status, Ok);
449 assertEqualInt (quality, CompositingQualityAssumeLinear);
450
451 // Invalid CompositingQuality.
452 status = GdipSetCompositingQuality (graphics, (CompositingQuality) (CompositingQualityAssumeLinear + 1));
453 assertEqualInt (status, Ok);
454
455 status = GdipGetCompositingQuality (graphics, &quality);
456 assertEqualInt (status, Ok);
457 assertEqualInt (quality, (CompositingQuality) (CompositingQualityAssumeLinear + 1));
458
459 // Invalid CompositingQuality.
460 status = GdipSetCompositingQuality (graphics, (CompositingQuality) (CompositingQualityInvalid - 1));
461 assertEqualInt (status, Ok);
462
463 status = GdipGetCompositingQuality (graphics, &quality);
464 assertEqualInt (status, Ok);
465 assertEqualInt (quality, (CompositingQuality) (CompositingQualityInvalid - 1));
466
467 // Negative tests.
468 status = GdipGetCompositingQuality(NULL, &quality);
469 assertEqualInt (status, InvalidParameter);
470
471 status = GdipGetCompositingQuality (graphics, NULL);
472 assertEqualInt (status, InvalidParameter);
473
474 status = GdipSetCompositingQuality (NULL, CompositingQualityAssumeLinear);
475 assertEqualInt (status, InvalidParameter);
476
477 HDC hdc;
478 GdipGetDC (graphics, &hdc);
479
480 status = GdipGetCompositingQuality (graphics, &quality);
481 assertEqualInt (status, ObjectBusy);
482
483 status = GdipGetCompositingQuality (graphics, NULL);
484 assertEqualInt (status, InvalidParameter);
485
486 status = GdipSetCompositingQuality(graphics, CompositingQualityAssumeLinear);
487 assertEqualInt (status, ObjectBusy);
488
489 GdipReleaseDC (graphics, hdc);
490
491 GdipDisposeImage (image);
492 GdipDeleteGraphics (graphics);
493 }
494
test_renderingOrigin()495 static void test_renderingOrigin ()
496 {
497 GpStatus status;
498 GpImage *image;
499 GpGraphics *graphics;
500 int x;
501 int y;
502
503 graphics = getImageGraphics (&image);
504
505 // Default get.
506 status = GdipGetRenderingOrigin (graphics, &x, &y);
507 assertEqualInt (status, Ok);
508 assertEqualInt (x, 0);
509 assertEqualInt (y, 0);
510
511 // Positive.
512 status = GdipSetRenderingOrigin (graphics, 1, 2);
513 assertEqualInt (status, Ok);
514
515 status = GdipGetRenderingOrigin (graphics, &x, &y);
516 assertEqualInt (status, Ok);
517 assertEqualInt (x, 1);
518 assertEqualInt (y, 2);
519
520 // Zero.
521 status = GdipSetRenderingOrigin (graphics, 0, 0);
522 assertEqualInt (status, Ok);
523
524 status = GdipGetRenderingOrigin (graphics, &x, &y);
525 assertEqualInt (status, Ok);
526 assertEqualInt (x, 0);
527 assertEqualInt (y, 0);
528
529 // Negative.
530 status = GdipSetRenderingOrigin (graphics, -1, -2);
531 assertEqualInt (status, Ok);
532
533 status = GdipGetRenderingOrigin (graphics, &x, &y);
534 assertEqualInt (status, Ok);
535 assertEqualInt (x, -1);
536 assertEqualInt (y, -2);
537
538 // Negative tests.
539 status = GdipGetRenderingOrigin (NULL, &x, &y);
540 assertEqualInt (status, InvalidParameter);
541
542 status = GdipGetRenderingOrigin (graphics, NULL, &y);
543 assertEqualInt (status, InvalidParameter);
544
545 status = GdipGetRenderingOrigin (graphics, &x, NULL);
546 assertEqualInt (status, InvalidParameter);
547
548 status = GdipSetRenderingOrigin(NULL, 0, 0);
549 assertEqualInt (status, InvalidParameter);
550
551 HDC hdc;
552 GdipGetDC (graphics, &hdc);
553
554 status = GdipGetRenderingOrigin(graphics, &x, &y);
555 assertEqualInt (status, ObjectBusy);
556
557 status = GdipGetRenderingOrigin(graphics, NULL, &y);
558 assertEqualInt (status, InvalidParameter);
559
560 status = GdipGetRenderingOrigin(graphics, &x, NULL);
561 assertEqualInt (status, InvalidParameter);
562
563 status = GdipSetRenderingOrigin (graphics, 1, 2);
564 assertEqualInt (status, ObjectBusy);
565
566 GdipReleaseDC (graphics, hdc);
567
568 GdipDisposeImage (image);
569 GdipDeleteGraphics (graphics);
570 }
571
test_textRenderingHint()572 static void test_textRenderingHint ()
573 {
574 GpStatus status;
575 GpImage *image;
576 GpGraphics *graphics;
577 TextRenderingHint textRenderingHint;
578
579 graphics = getImageGraphics (&image);
580
581 // Default get.
582 status = GdipGetTextRenderingHint (graphics, &textRenderingHint);
583 assertEqualInt (status, Ok);
584 assertEqualInt (textRenderingHint, TextRenderingHintSystemDefault);
585
586 // TextRenderingHintSystemDefault.
587 status = GdipSetTextRenderingHint (graphics, TextRenderingHintSystemDefault);
588 assertEqualInt (status, Ok);
589
590 status = GdipGetTextRenderingHint (graphics, &textRenderingHint);
591 assertEqualInt (status, Ok);
592 assertEqualInt (textRenderingHint, TextRenderingHintSystemDefault);
593
594 // TextRenderingHintSingleBitPerPixelGridFit.
595 status = GdipSetTextRenderingHint (graphics, TextRenderingHintSingleBitPerPixelGridFit);
596 assertEqualInt (status, Ok);
597
598 status = GdipGetTextRenderingHint (graphics, &textRenderingHint);
599 assertEqualInt (status, Ok);
600 assertEqualInt (textRenderingHint, TextRenderingHintSingleBitPerPixelGridFit);
601
602 // TextRenderingHintSingleBitPerPixel.
603 status = GdipSetTextRenderingHint (graphics, TextRenderingHintSingleBitPerPixel);
604 assertEqualInt (status, Ok);
605
606 status = GdipGetTextRenderingHint (graphics, &textRenderingHint);
607 assertEqualInt (status, Ok);
608 assertEqualInt (textRenderingHint, TextRenderingHintSingleBitPerPixel);
609
610 // TextRenderingHintAntiAliasGridFit.
611 status = GdipSetTextRenderingHint (graphics, TextRenderingHintAntiAliasGridFit);
612 assertEqualInt (status, Ok);
613
614 status = GdipGetTextRenderingHint (graphics, &textRenderingHint);
615 assertEqualInt (status, Ok);
616 assertEqualInt (textRenderingHint, TextRenderingHintAntiAliasGridFit);
617
618 // TextRenderingHintAntiAlias.
619 status = GdipSetTextRenderingHint (graphics, TextRenderingHintAntiAlias);
620 assertEqualInt (status, Ok);
621
622 status = GdipGetTextRenderingHint (graphics, &textRenderingHint);
623 assertEqualInt (status, Ok);
624 assertEqualInt (textRenderingHint, TextRenderingHintAntiAlias);
625
626 // TextRenderingHintClearTypeGridFit.
627 status = GdipSetTextRenderingHint (graphics, TextRenderingHintClearTypeGridFit);
628 assertEqualInt (status, Ok);
629
630 status = GdipGetTextRenderingHint (graphics, &textRenderingHint);
631 assertEqualInt (status, Ok);
632 assertEqualInt (textRenderingHint, TextRenderingHintClearTypeGridFit);
633
634 // Negative tests.
635 status = GdipGetTextRenderingHint (NULL, &textRenderingHint);
636 assertEqualInt (status, InvalidParameter);
637
638 status = GdipGetTextRenderingHint (graphics, NULL);
639 assertEqualInt (status, InvalidParameter);
640
641 status = GdipSetTextRenderingHint (NULL, TextRenderingHintAntiAlias);
642 assertEqualInt (status, InvalidParameter);
643
644 status = GdipSetTextRenderingHint (graphics, (TextRenderingHint)(TextRenderingHintClearTypeGridFit + 1));
645 assertEqualInt (status, InvalidParameter);
646
647 HDC hdc;
648 GdipGetDC (graphics, &hdc);
649
650 status = GdipGetTextRenderingHint(graphics, &textRenderingHint);
651 assertEqualInt (status, ObjectBusy);
652
653 status = GdipGetTextRenderingHint(graphics, NULL);
654 assertEqualInt (status, InvalidParameter);
655
656 status = GdipSetTextRenderingHint (graphics, TextRenderingHintClearTypeGridFit);
657 assertEqualInt (status, ObjectBusy);
658
659 status = GdipSetTextRenderingHint (graphics, (TextRenderingHint)(TextRenderingHintClearTypeGridFit + 1));
660 assertEqualInt (status, ObjectBusy);
661
662 GdipReleaseDC (graphics, hdc);
663
664 GdipDisposeImage (image);
665 GdipDeleteGraphics (graphics);
666 }
667
test_textContrast()668 static void test_textContrast ()
669 {
670 GpStatus status;
671 GpImage *image;
672 GpGraphics *graphics;
673 UINT textContrast;
674
675 graphics = getImageGraphics (&image);
676
677 // Default get.
678 status = GdipGetTextContrast (graphics, &textContrast);
679 assertEqualInt (status, Ok);
680 assertEqualInt (textContrast, 4);
681
682 // Large.
683 status = GdipSetTextContrast (graphics, 12);
684 assertEqualInt (status, Ok);
685
686 status = GdipGetTextContrast (graphics, &textContrast);
687 assertEqualInt (status, Ok);
688 assertEqualInt (textContrast, 12);
689
690 // Zero.
691 status = GdipSetTextContrast (graphics, 0);
692 assertEqualInt (status, Ok);
693
694 status = GdipGetTextContrast (graphics, &textContrast);
695 assertEqualInt (status, Ok);
696 assertEqualInt (textContrast, 0);
697
698 // Negative tests.
699 status = GdipGetTextContrast (NULL, &textContrast);
700 assertEqualInt (status, InvalidParameter);
701
702 status = GdipGetTextContrast (graphics, NULL);
703 assertEqualInt (status, InvalidParameter);
704
705 status = GdipSetTextContrast(NULL, 1);
706 assertEqualInt (status, InvalidParameter);
707
708 status = GdipSetTextContrast (graphics, -1);
709 assertEqualInt (status, InvalidParameter);
710
711 status = GdipSetTextContrast (graphics, 13);
712 assertEqualInt (status, InvalidParameter);
713
714 HDC hdc;
715 GdipGetDC (graphics, &hdc);
716
717 status = GdipGetTextContrast (graphics, &textContrast);
718 assertEqualInt (status, ObjectBusy);
719
720 status = GdipGetTextContrast (graphics, NULL);
721 assertEqualInt (status, InvalidParameter);
722
723 status = GdipSetTextContrast (graphics, 1);
724 assertEqualInt (status, ObjectBusy);
725
726 status = GdipSetTextContrast (graphics, 13);
727 assertEqualInt (status, ObjectBusy);
728
729 GdipReleaseDC (graphics, hdc);
730
731 GdipDisposeImage (image);
732 GdipDeleteGraphics (graphics);
733 }
734
test_smoothingMode()735 static void test_smoothingMode ()
736 {
737 GpStatus status;
738 GpImage *image;
739 GpGraphics *graphics;
740 SmoothingMode smoothingMode;
741
742 graphics = getImageGraphics (&image);
743
744 // Default get.
745 status = GdipGetSmoothingMode (graphics, &smoothingMode);
746 assertEqualInt (status, Ok);
747 assertEqualInt (smoothingMode, SmoothingModeNone);
748
749 // Default -> None
750 status = GdipSetSmoothingMode (graphics, SmoothingModeDefault);
751 assertEqualInt (status, Ok);
752
753 status = GdipGetSmoothingMode (graphics, &smoothingMode);
754 assertEqualInt (status, Ok);
755 assertEqualInt (smoothingMode, SmoothingModeNone);
756
757 // HighSpeed -> None
758 status = GdipSetSmoothingMode(graphics, SmoothingModeHighSpeed);
759 assertEqualInt (status, Ok);
760
761 status = GdipGetSmoothingMode(graphics, &smoothingMode);
762 assertEqualInt (status, Ok);
763 assertEqualInt (smoothingMode, SmoothingModeNone);
764
765 // HighQuality -> AntiAlias
766 status = GdipSetSmoothingMode (graphics, SmoothingModeHighQuality);
767 assertEqualInt (status, Ok);
768
769 status = GdipGetSmoothingMode (graphics, &smoothingMode);
770 assertEqualInt (status, Ok);
771 assertEqualInt (smoothingMode, SmoothingModeAntiAlias);
772
773 // SmoothingModeNone.
774 status = GdipSetSmoothingMode(graphics, SmoothingModeNone);
775 assertEqualInt (status, Ok);
776
777 status = GdipGetSmoothingMode(graphics, &smoothingMode);
778 assertEqualInt (status, Ok);
779 assertEqualInt (smoothingMode, SmoothingModeNone);
780
781 // SmoothingModeAntiAlias.
782 status = GdipSetSmoothingMode(graphics, SmoothingModeAntiAlias);
783 assertEqualInt (status, Ok);
784
785 status = GdipGetSmoothingMode(graphics, &smoothingMode);
786 assertEqualInt (status, Ok);
787 assertEqualInt (smoothingMode, SmoothingModeAntiAlias);
788
789 // SmoothingModeAntiAlias8x8.
790 status = GdipSetSmoothingMode(graphics, (SmoothingMode) (SmoothingModeAntiAlias + 1));
791 assertEqualInt (status, Ok);
792
793 status = GdipGetSmoothingMode(graphics, &smoothingMode);
794 assertEqualInt (status, Ok);
795 assertEqualInt (smoothingMode, (SmoothingMode) (SmoothingModeAntiAlias + 1));
796
797 // Negative tests.
798 status = GdipGetSmoothingMode (NULL, &smoothingMode);
799 assertEqualInt (status, InvalidParameter);
800
801 status = GdipGetSmoothingMode (graphics, NULL);
802 assertEqualInt (status, InvalidParameter);
803
804 status = GdipSetSmoothingMode (NULL, SmoothingModeAntiAlias);
805 assertEqualInt (status, InvalidParameter);
806
807 status = GdipSetSmoothingMode (graphics, SmoothingModeInvalid);
808 assertEqualInt (status, InvalidParameter);
809
810 status = GdipSetSmoothingMode (graphics, (SmoothingMode) (SmoothingModeAntiAlias + 2));
811 assertEqualInt (status, InvalidParameter);
812
813 HDC hdc;
814 GdipGetDC (graphics, &hdc);
815
816 status = GdipGetSmoothingMode (graphics, &smoothingMode);
817 assertEqualInt (status, ObjectBusy);
818
819 status = GdipGetSmoothingMode (graphics, NULL);
820 assertEqualInt (status, InvalidParameter);
821
822 status = GdipSetSmoothingMode (graphics, SmoothingModeHighQuality);
823 assertEqualInt (status, ObjectBusy);
824
825 status = GdipSetSmoothingMode (graphics, SmoothingModeInvalid);
826 assertEqualInt (status, ObjectBusy);
827
828 status = GdipSetSmoothingMode (graphics, (SmoothingMode) (SmoothingModeInvalid - 1));
829 assertEqualInt (status, ObjectBusy);
830
831 status = GdipSetSmoothingMode (graphics, (SmoothingMode) (SmoothingModeAntiAlias + 2));
832 assertEqualInt (status, ObjectBusy);
833
834 GdipReleaseDC (graphics, hdc);
835
836 GdipDisposeImage (image);
837 GdipDeleteGraphics (graphics);
838 }
839
test_pixelOffsetMode()840 static void test_pixelOffsetMode ()
841 {
842 GpStatus status;
843 GpImage *image;
844 GpGraphics *graphics;
845 PixelOffsetMode pixelOffsetMode;
846
847 graphics = getImageGraphics (&image);
848
849 // Default get.
850 status = GdipGetPixelOffsetMode (graphics, &pixelOffsetMode);
851 assertEqualInt (status, Ok);
852 assertEqualInt (pixelOffsetMode, PixelOffsetModeDefault);
853
854 // PixelOffsetModeDefault.
855 status = GdipSetPixelOffsetMode (graphics, PixelOffsetModeDefault);
856 assertEqualInt (status, Ok);
857
858 status = GdipGetPixelOffsetMode (graphics, &pixelOffsetMode);
859 assertEqualInt (status, Ok);
860 assertEqualInt (pixelOffsetMode, PixelOffsetModeDefault);
861
862 // PixelOffsetModeHighSpeed.
863 status = GdipSetPixelOffsetMode(graphics, PixelOffsetModeHighSpeed);
864 assertEqualInt (status, Ok);
865
866 status = GdipGetPixelOffsetMode(graphics, &pixelOffsetMode);
867 assertEqualInt (status, Ok);
868 assertEqualInt (pixelOffsetMode, PixelOffsetModeHighSpeed);
869
870 // PixelOffsetModeHighQuality.
871 status = GdipSetPixelOffsetMode (graphics, PixelOffsetModeHighQuality);
872 assertEqualInt (status, Ok);
873
874 status = GdipGetPixelOffsetMode (graphics, &pixelOffsetMode);
875 assertEqualInt (status, Ok);
876 assertEqualInt (pixelOffsetMode, PixelOffsetModeHighQuality);
877
878 // PixelOffsetModeNone.
879 status = GdipSetPixelOffsetMode (graphics, PixelOffsetModeNone);
880 assertEqualInt (status, Ok);
881
882 status = GdipGetPixelOffsetMode (graphics, &pixelOffsetMode);
883 assertEqualInt (status, Ok);
884 assertEqualInt (pixelOffsetMode, PixelOffsetModeNone);
885
886 // PixelOffsetModeHalf.
887 status = GdipSetPixelOffsetMode (graphics, PixelOffsetModeHalf);
888 assertEqualInt (status, Ok);
889
890 status = GdipGetPixelOffsetMode (graphics, &pixelOffsetMode);
891 assertEqualInt (status, Ok);
892 assertEqualInt (pixelOffsetMode, PixelOffsetModeHalf);
893
894 // Negative tests.
895 status = GdipGetPixelOffsetMode (NULL, &pixelOffsetMode);
896 assertEqualInt (status, InvalidParameter);
897
898 status = GdipGetPixelOffsetMode (graphics, NULL);
899 assertEqualInt (status, InvalidParameter);
900
901 status = GdipSetPixelOffsetMode(NULL, PixelOffsetModeDefault);
902 assertEqualInt (status, InvalidParameter);
903
904 status = GdipSetPixelOffsetMode (graphics, PixelOffsetModeInvalid);
905 assertEqualInt (status, InvalidParameter);
906
907 status = GdipSetPixelOffsetMode (graphics, (PixelOffsetMode)(PixelOffsetModeInvalid - 1));
908 assertEqualInt (status, InvalidParameter);
909
910 status = GdipSetPixelOffsetMode (graphics, (PixelOffsetMode)(PixelOffsetModeHalf + 1));
911 assertEqualInt (status, InvalidParameter);
912
913 HDC hdc;
914 GdipGetDC (graphics, &hdc);
915
916 status = GdipGetPixelOffsetMode (graphics, &pixelOffsetMode);
917 assertEqualInt (status, ObjectBusy);
918
919 status = GdipGetPixelOffsetMode (graphics, NULL);
920 assertEqualInt (status, InvalidParameter);
921
922 status = GdipSetPixelOffsetMode (graphics, PixelOffsetModeDefault);
923 assertEqualInt (status, ObjectBusy);
924
925 status = GdipSetPixelOffsetMode (graphics, (PixelOffsetMode)(PixelOffsetModeInvalid - 1));
926 assertEqualInt (status, ObjectBusy);
927
928 status = GdipSetPixelOffsetMode (graphics, PixelOffsetModeInvalid);
929 assertEqualInt (status, ObjectBusy);
930
931 status = GdipSetPixelOffsetMode (graphics, (PixelOffsetMode)(PixelOffsetModeHalf + 1));
932 assertEqualInt (status, ObjectBusy);
933
934 GdipReleaseDC (graphics, hdc);
935
936 GdipDisposeImage (image);
937 GdipDeleteGraphics (graphics);
938 }
939
test_interpolationMode()940 static void test_interpolationMode ()
941 {
942 GpStatus status;
943 GpImage *image;
944 GpGraphics *graphics;
945 InterpolationMode interpolationMode;
946
947 graphics = getImageGraphics (&image);
948
949 // Default get
950 status = GdipGetInterpolationMode (graphics, &interpolationMode);
951 assertEqualInt (status, Ok);
952 assertEqualInt (interpolationMode, InterpolationModeBilinear);
953
954 // Default -> Bilinear
955 status = GdipSetInterpolationMode (graphics, InterpolationModeDefault);
956 assertEqualInt (status, Ok);
957
958 status = GdipGetInterpolationMode (graphics, &interpolationMode);
959 assertEqualInt (status, Ok);
960 assertEqualInt (interpolationMode, InterpolationModeBilinear);
961
962 // LowQuality -> NearestNeighbor
963 status = GdipSetInterpolationMode(graphics, InterpolationModeLowQuality);
964 assertEqualInt (status, Ok);
965
966 status = GdipGetInterpolationMode (graphics, &interpolationMode);
967 assertEqualInt (status, Ok);
968 assertEqualInt (interpolationMode, InterpolationModeBilinear);
969
970 // HighQuality -> HighQualityBicubic
971 status = GdipSetInterpolationMode (graphics, InterpolationModeHighQuality);
972 assertEqualInt (status, Ok);
973
974 status = GdipGetInterpolationMode (graphics, &interpolationMode);
975 assertEqualInt (status, Ok);
976 assertEqualInt (interpolationMode, InterpolationModeHighQualityBicubic);
977
978 // InterpolationModeBilinear.
979 status = GdipSetInterpolationMode (graphics, InterpolationModeBilinear);
980 assertEqualInt (status, Ok);
981
982 status = GdipGetInterpolationMode (graphics, &interpolationMode);
983 assertEqualInt (status, Ok);
984 assertEqualInt (interpolationMode, InterpolationModeBilinear);
985
986 // InterpolationModeBicubic.
987 status = GdipSetInterpolationMode (graphics, InterpolationModeBicubic);
988 assertEqualInt (status, Ok);
989
990 status = GdipGetInterpolationMode (graphics, &interpolationMode);
991 assertEqualInt (status, Ok);
992 assertEqualInt (interpolationMode, InterpolationModeBicubic);
993
994 // InterpolationModeNearestNeighbor.
995 status = GdipSetInterpolationMode (graphics, InterpolationModeNearestNeighbor);
996 assertEqualInt (status, Ok);
997
998 status = GdipGetInterpolationMode (graphics, &interpolationMode);
999 assertEqualInt (status, Ok);
1000 assertEqualInt (interpolationMode, InterpolationModeNearestNeighbor);
1001
1002 // InterpolationModeHighQualityBilinear.
1003 status = GdipSetInterpolationMode (graphics, InterpolationModeHighQualityBilinear);
1004 assertEqualInt (status, Ok);
1005
1006 status = GdipGetInterpolationMode (graphics, &interpolationMode);
1007 assertEqualInt (status, Ok);
1008 assertEqualInt (interpolationMode, InterpolationModeHighQualityBilinear);
1009
1010 // InterpolationModeHighQualityBicubic.
1011 status = GdipSetInterpolationMode (graphics, InterpolationModeHighQualityBicubic);
1012 assertEqualInt (status, Ok);
1013
1014 status = GdipGetInterpolationMode (graphics, &interpolationMode);
1015 assertEqualInt (status, Ok);
1016 assertEqualInt (interpolationMode, InterpolationModeHighQualityBicubic);
1017
1018 // Negative tests.
1019 status = GdipGetInterpolationMode (NULL, &interpolationMode);
1020 assertEqualInt (status, InvalidParameter);
1021
1022 // This causes an access violation in GDI+.
1023 #if !defined(USE_WINDOWS_GDIPLUS)
1024 status = GdipGetInterpolationMode (graphics, NULL);
1025 assertEqualInt (status, InvalidParameter);
1026 #endif
1027
1028 status = GdipSetInterpolationMode (NULL, InterpolationModeBicubic);
1029 assertEqualInt (status, InvalidParameter);
1030
1031 status = GdipSetInterpolationMode (graphics, InterpolationModeInvalid);
1032 assertEqualInt (status, InvalidParameter);
1033
1034 status = GdipSetInterpolationMode (graphics, (InterpolationMode)(InterpolationModeInvalid - 1));
1035 assertEqualInt (status, InvalidParameter);
1036
1037 status = GdipSetInterpolationMode (graphics, (InterpolationMode)(InterpolationModeHighQualityBicubic + 1));
1038 assertEqualInt (status, InvalidParameter);
1039
1040 HDC hdc;
1041 GdipGetDC (graphics, &hdc);
1042
1043 status = GdipGetInterpolationMode (graphics, &interpolationMode);
1044 assertEqualInt (status, ObjectBusy);
1045
1046 status = GdipGetInterpolationMode (graphics, NULL);
1047 assertEqualInt (status, ObjectBusy);
1048
1049 status = GdipSetInterpolationMode (graphics, InterpolationModeBicubic);
1050 assertEqualInt (status, ObjectBusy);
1051
1052 status = GdipSetInterpolationMode (graphics, InterpolationModeInvalid);
1053 assertEqualInt (status, ObjectBusy);
1054
1055 status = GdipSetInterpolationMode (graphics, (InterpolationMode)(InterpolationModeInvalid - 1));
1056 assertEqualInt (status, ObjectBusy);
1057
1058 status = GdipSetInterpolationMode (graphics, (InterpolationMode)(InterpolationModeHighQualityBicubic + 1));
1059 assertEqualInt (status, ObjectBusy);
1060
1061 GdipReleaseDC (graphics, hdc);
1062
1063 GdipDisposeImage (image);
1064 GdipDeleteGraphics (graphics);
1065 }
1066
test_transform()1067 static void test_transform ()
1068 {
1069 GpStatus status;
1070 GpImage *image;
1071 GpGraphics *graphics;
1072 GpMatrix *matrix;
1073 GpMatrix *setMatrix;
1074 GpMatrix *nonInvertibleMatrix;
1075
1076 graphics = getImageGraphics (&image);
1077
1078 status = GdipCreateMatrix2 (0, 0, 0, 0, 0, 0, &matrix);
1079 assertEqualInt (status, Ok);
1080
1081 status = GdipCreateMatrix2 (146, 66, 158, 104, 42, 150, &setMatrix);
1082 assertEqualInt (status, Ok);
1083
1084 status = GdipCreateMatrix2 (123, 24, 82, 16, 47, 30, &nonInvertibleMatrix);
1085 assertEqualInt (status, Ok);
1086
1087 // Default get.
1088 status = GdipGetWorldTransform (graphics, matrix);
1089 assertEqualInt (status, Ok);
1090 verifyMatrix (matrix, 1, 0, 0, 1, 0, 0);
1091
1092 status = GdipSetWorldTransform (graphics, setMatrix);
1093 assertEqualInt (status, Ok);
1094
1095 status = GdipGetWorldTransform (graphics, matrix);
1096 assertEqualInt (status, Ok);
1097
1098 BOOL result;
1099 GdipIsMatrixEqual (matrix, setMatrix, &result);
1100 assertEqualInt (result, 1);
1101
1102 // Negative tests.
1103 status = GdipGetWorldTransform (NULL, matrix);
1104 assertEqualInt (status, InvalidParameter);
1105
1106 status = GdipGetWorldTransform (graphics, NULL);
1107 assertEqualInt (status, InvalidParameter);
1108
1109 status = GdipSetWorldTransform (NULL, matrix);
1110 assertEqualInt (status, InvalidParameter);
1111
1112 status = GdipSetWorldTransform (graphics, NULL);
1113 assertEqualInt (status, InvalidParameter);
1114
1115 status = GdipSetWorldTransform (graphics, nonInvertibleMatrix);
1116 assertEqualInt (status, InvalidParameter);
1117
1118 HDC hdc;
1119 GdipGetDC (graphics, &hdc);
1120
1121 status = GdipGetWorldTransform (graphics, matrix);
1122 assertEqualInt (status, ObjectBusy);
1123
1124 status = GdipGetWorldTransform (graphics, NULL);
1125 assertEqualInt (status, InvalidParameter);
1126
1127 status = GdipSetWorldTransform (graphics, matrix);
1128 assertEqualInt (status, ObjectBusy);
1129
1130 status = GdipSetWorldTransform (graphics, NULL);
1131 assertEqualInt (status, ObjectBusy);
1132
1133 status = GdipSetWorldTransform (graphics, nonInvertibleMatrix);
1134 assertEqualInt (status, ObjectBusy);
1135
1136 GdipReleaseDC (graphics, hdc);
1137
1138 GdipDeleteMatrix (matrix);
1139 GdipDeleteMatrix (setMatrix);
1140 GdipDeleteMatrix (nonInvertibleMatrix);
1141 GdipDisposeImage (image);
1142 GdipDeleteGraphics (graphics);
1143 }
1144
test_pageUnit()1145 static void test_pageUnit ()
1146 {
1147 GpStatus status;
1148 GpImage *image;
1149 GpGraphics *graphics;
1150 Unit pageUnit;
1151
1152 graphics = getImageGraphics (&image);
1153
1154 // UnitDisplay.
1155 status = GdipSetPageUnit (graphics, UnitDisplay);
1156 assertEqualInt (status, Ok);
1157
1158 status = GdipGetPageUnit (graphics, &pageUnit);
1159 assertEqualInt (status, Ok);
1160 assertEqualInt (pageUnit, UnitDisplay);
1161
1162 // UnitPixel.
1163 status = GdipSetPageUnit (graphics, UnitPixel);
1164 assertEqualInt (status, Ok);
1165
1166 status = GdipGetPageUnit (graphics, &pageUnit);
1167 assertEqualInt (status, Ok);
1168 assertEqualInt (pageUnit, UnitPixel);
1169
1170 // UnitPoint.
1171 status = GdipSetPageUnit (graphics, UnitPoint);
1172 assertEqualInt (status, Ok);
1173
1174 status = GdipGetPageUnit (graphics, &pageUnit);
1175 assertEqualInt (status, Ok);
1176 assertEqualInt (pageUnit, UnitPoint);
1177
1178 // UnitInch.
1179 status = GdipSetPageUnit (graphics, UnitInch);
1180 assertEqualInt (status, Ok);
1181
1182 status = GdipGetPageUnit (graphics, &pageUnit);
1183 assertEqualInt (status, Ok);
1184 assertEqualInt (pageUnit, UnitInch);
1185
1186 // UnitDocument.
1187 status = GdipSetPageUnit (graphics, UnitDocument);
1188 assertEqualInt (status, Ok);
1189
1190 status = GdipGetPageUnit (graphics, &pageUnit);
1191 assertEqualInt (status, Ok);
1192 assertEqualInt (pageUnit, UnitDocument);
1193
1194 // UnitMillimeter.
1195 status = GdipSetPageUnit (graphics, UnitMillimeter);
1196 assertEqualInt (status, Ok);
1197
1198 status = GdipGetPageUnit (graphics, &pageUnit);
1199 assertEqualInt (status, Ok);
1200 assertEqualInt (pageUnit, UnitMillimeter);
1201
1202 // Negative tests.
1203 status = GdipGetPageUnit (NULL, &pageUnit);
1204 assertEqualInt (status, InvalidParameter);
1205
1206 status = GdipGetPageUnit (graphics, NULL);
1207 assertEqualInt (status, InvalidParameter);
1208
1209 status = GdipSetPageUnit (NULL, UnitDisplay);
1210 assertEqualInt (status, InvalidParameter);
1211
1212 status = GdipSetPageUnit (graphics, (Unit)(UnitWorld - 1));
1213 assertEqualInt (status, InvalidParameter);
1214
1215 #if defined(USE_WINDOWS_GDIPLUS)
1216 status = GdipSetPageUnit (graphics, (Unit)(UnitMillimeter + 1));
1217 assertEqualInt (status, InvalidParameter);
1218 #else
1219 status = GdipSetPageUnit (graphics, (Unit)(UnitCairoPoint + 1));
1220 assertEqualInt (status, InvalidParameter);
1221 #endif
1222
1223 status = GdipSetPageUnit (graphics, UnitWorld);
1224 assertEqualInt (status, InvalidParameter);
1225
1226 HDC hdc;
1227 GdipGetDC (graphics, &hdc);
1228
1229 status = GdipGetPageUnit (graphics, &pageUnit);
1230 assertEqualInt (status, ObjectBusy);
1231
1232 status = GdipGetPageUnit (graphics, NULL);
1233 assertEqualInt (status, InvalidParameter);
1234
1235 status = GdipSetPageUnit (graphics, UnitDisplay);
1236 assertEqualInt (status, ObjectBusy);
1237
1238 status = GdipSetPageUnit (graphics, UnitWorld);
1239 assertEqualInt (status, ObjectBusy);
1240
1241 #if defined(USE_WINDOWS_GDIPLUS)
1242 status = GdipSetPageUnit (graphics, (Unit)(UnitMillimeter + 1));
1243 assertEqualInt (status, ObjectBusy);
1244 #else
1245 status = GdipSetPageUnit (graphics, (Unit)(UnitCairoPoint + 1));
1246 assertEqualInt (status, ObjectBusy);
1247 #endif
1248
1249 GdipReleaseDC (graphics, hdc);
1250
1251 GdipDisposeImage (image);
1252 GdipDeleteGraphics (graphics);
1253 }
1254
test_pageScale()1255 static void test_pageScale ()
1256 {
1257 GpStatus status;
1258 GpImage *image;
1259 GpGraphics *graphics;
1260 REAL pageScale;
1261
1262 graphics = getImageGraphics (&image);
1263
1264 status = GdipSetPageScale (graphics, 1);
1265 assertEqualInt (status, Ok);
1266
1267 status = GdipGetPageScale (graphics, &pageScale);
1268 assertEqualInt (status, Ok);
1269 assertEqualFloat (pageScale, 1);
1270
1271 status = GdipSetPageScale (graphics, (REAL) 1000000032);
1272 assertEqualInt (status, Ok);
1273
1274 status = GdipGetPageScale (graphics, &pageScale);
1275 assertEqualInt (status, Ok);
1276 assertEqualFloat (pageScale, (REAL) 1000000032);
1277
1278 // Negative tests.
1279 status = GdipGetPageScale (NULL, &pageScale);
1280 assertEqualInt (status, InvalidParameter);
1281
1282 status = GdipGetPageScale (graphics, NULL);
1283 assertEqualInt (status, InvalidParameter);
1284
1285 status = GdipSetPageScale (NULL, UnitDisplay);
1286 assertEqualInt (status, InvalidParameter);
1287
1288 status = GdipSetPageScale (graphics, -INFINITY);
1289 assertEqualInt (status, InvalidParameter);
1290
1291 status = GdipSetPageScale (graphics, -1);
1292 assertEqualInt (status, InvalidParameter);
1293
1294 status = GdipSetPageScale (graphics, 0);
1295 assertEqualInt (status, InvalidParameter);
1296
1297 status = GdipSetPageScale (graphics, FLT_MAX);
1298 assertEqualInt (status, InvalidParameter);
1299
1300 // 1000000032 appears to be the max value accepted by GDI+.
1301 status = GdipSetPageScale (graphics, (REAL) 1000000033);
1302 assertEqualInt (status, InvalidParameter);
1303
1304 HDC hdc;
1305 GdipGetDC (graphics, &hdc);
1306
1307 status = GdipGetPageScale (graphics, &pageScale);
1308 assertEqualInt (status, ObjectBusy);
1309
1310 status = GdipGetPageScale (graphics, NULL);
1311 assertEqualInt (status, InvalidParameter);
1312
1313 status = GdipSetPageScale (graphics, 1);
1314 assertEqualInt (status, ObjectBusy);
1315
1316 status = GdipSetPageScale (graphics, 1);
1317 assertEqualInt (status, ObjectBusy);
1318
1319 status = GdipSetPageScale (graphics, 0);
1320 assertEqualInt (status, ObjectBusy);
1321
1322 status = GdipSetPageScale (graphics, (REAL) 1000000033);
1323 assertEqualInt (status, ObjectBusy);
1324
1325 GdipReleaseDC (graphics, hdc);
1326
1327 GdipDisposeImage (image);
1328 GdipDeleteGraphics (graphics);
1329 }
1330
test_dpiX()1331 static void test_dpiX ()
1332 {
1333 GpStatus status;
1334 GpImage *image;
1335 GpGraphics *graphics;
1336 REAL dpiX;
1337
1338 graphics = getImageGraphics (&image);
1339
1340 status = GdipGetDpiX (graphics, &dpiX);
1341 assertEqualInt (status, Ok);
1342 assert (dpiX > 0);
1343
1344 // Negative tests.
1345 status = GdipGetDpiX (NULL, &dpiX);
1346 assertEqualInt (status, InvalidParameter);
1347
1348 status = GdipGetDpiX (graphics, NULL);
1349 assertEqualInt (status, InvalidParameter);
1350
1351 HDC hdc;
1352 GdipGetDC (graphics, &hdc);
1353
1354 status = GdipGetDpiX (graphics, &dpiX);
1355 assertEqualInt (status, ObjectBusy);
1356
1357 status = GdipGetDpiX (graphics, NULL);
1358 assertEqualInt (status, InvalidParameter);
1359
1360 GdipReleaseDC(graphics, hdc);
1361
1362 GdipDisposeImage (image);
1363 GdipDeleteGraphics (graphics);
1364 }
1365
test_dpiY()1366 static void test_dpiY ()
1367 {
1368 GpStatus status;
1369 GpImage *image;
1370 GpGraphics *graphics;
1371 REAL dpiY;
1372
1373 graphics = getImageGraphics (&image);
1374
1375 status = GdipGetDpiY (graphics, &dpiY);
1376 assertEqualInt (status, Ok);
1377 assert (dpiY > 0);
1378
1379 // Negative tests.
1380 status = GdipGetDpiY (NULL, &dpiY);
1381 assertEqualInt (status, InvalidParameter);
1382
1383 status = GdipGetDpiY (graphics, NULL);
1384 assertEqualInt (status, InvalidParameter);
1385
1386 HDC hdc;
1387 GdipGetDC(graphics, &hdc);
1388
1389 status = GdipGetDpiY (graphics, &dpiY);
1390 assertEqualInt (status, ObjectBusy);
1391
1392 status = GdipGetDpiY (graphics, NULL);
1393 assertEqualInt (status, InvalidParameter);
1394
1395 GdipReleaseDC (graphics, hdc);
1396
1397 GdipDisposeImage (image);
1398 GdipDeleteGraphics (graphics);
1399 }
1400
test_flush()1401 static void test_flush ()
1402 {
1403 GpStatus status;
1404 GpImage *image;
1405 GpGraphics *graphics;
1406
1407 graphics = getImageGraphics (&image);
1408
1409 status = GdipFlush (graphics, FlushIntentionFlush);
1410 assertEqualInt (status, Ok);
1411
1412 status = GdipFlush (graphics, FlushIntentionSync);
1413 assertEqualInt (status, Ok);
1414
1415 status = GdipFlush (graphics, (FlushIntention)(FlushIntentionFlush - 1));
1416 assertEqualInt (status, Ok);
1417
1418 status = GdipFlush (graphics, (FlushIntention)(FlushIntentionSync + 1));
1419 assertEqualInt (status, Ok);
1420
1421 // Negative tests.
1422 status = GdipFlush (NULL, FlushIntentionFlush);
1423 assertEqualInt (status, InvalidParameter);
1424
1425 HDC hdc;
1426 status = GdipGetDC (graphics, &hdc);
1427
1428 status = GdipFlush (graphics, FlushIntentionSync);
1429 assertEqualInt (status, ObjectBusy);
1430
1431 GdipReleaseDC (graphics, hdc);
1432
1433 GdipDisposeImage (image);
1434 GdipDeleteGraphics (graphics);
1435 }
1436
test_delete()1437 static void test_delete ()
1438 {
1439 GpStatus status;
1440 GpImage *image;
1441 GpGraphics *graphics;
1442
1443 graphics = getImageGraphics (&image);
1444
1445 HDC hdc;
1446 status = GdipGetDC (graphics, &hdc);
1447
1448 status = GdipDeleteGraphics (graphics);
1449 assertEqualInt (status, ObjectBusy);
1450
1451 GdipReleaseDC (graphics, hdc);
1452
1453 status = GdipDeleteGraphics (graphics);
1454 assertEqualInt (status, Ok);
1455
1456 status = GdipDeleteGraphics (NULL);
1457 assertEqualInt (status, InvalidParameter);
1458
1459 GdipDisposeImage (image);
1460 }
1461
test_rotateWorldTransform()1462 static void test_rotateWorldTransform ()
1463 {
1464 GpStatus status;
1465 GpMatrix *transform;
1466 GpMatrix *matrix;
1467 GpImage *image;
1468 GpGraphics *graphics;
1469 GpRegion *clip;
1470 GpRectF visibleClipBounds;
1471
1472 GpRectF rect = {0, 0, 32, 32};
1473 GdipCreateRegionRect (&rect, &clip);
1474 GdipCreateMatrix2 (1, 2, 3, 4, 5, 6, &transform);
1475 GdipCreateMatrix (&matrix);
1476
1477 // MatrixOrderPrepend.
1478 graphics = getImageGraphics (&image);
1479
1480 GdipSetWorldTransform (graphics, transform);
1481 status = GdipRotateWorldTransform (graphics, 90, MatrixOrderPrepend);
1482
1483 GdipGetWorldTransform (graphics, matrix);
1484 verifyMatrix (matrix, 3, 4, -1, -2, 5, 6);
1485
1486 GdipDeleteGraphics (graphics);
1487 GdipDisposeImage (image);
1488
1489 // MatrixOrderAppend.
1490 graphics = getImageGraphics (&image);
1491
1492 GdipSetWorldTransform (graphics, transform);
1493 status = GdipRotateWorldTransform (graphics, 90, MatrixOrderAppend);
1494
1495 GdipGetWorldTransform (graphics, matrix);
1496 verifyMatrix (matrix, -2, 1, -4, 3, -6, 5);
1497
1498 GdipDeleteGraphics (graphics);
1499 GdipDisposeImage (image);
1500
1501 // With clip region.
1502 graphics = getImageGraphics (&image);
1503 GdipSetClipRegion (graphics, clip, CombineModeReplace);
1504
1505 status = GdipRotateWorldTransform (graphics, 90, MatrixOrderPrepend);
1506 assertEqualInt (status, Ok);
1507
1508 status = GdipGetVisibleClipBounds (graphics, &visibleClipBounds);
1509 assertEqualInt (status, Ok);
1510 assertEqualFloat (0, visibleClipBounds.X);
1511 assertEqualFloat (-32, visibleClipBounds.Y);
1512 assertEqualFloat (32, visibleClipBounds.Width);
1513 assertEqualFloat (32, visibleClipBounds.Height);
1514
1515 // Negative tests.
1516 status = GdipRotateWorldTransform (NULL, 0, MatrixOrderAppend);
1517 assertEqualInt (status, InvalidParameter);
1518
1519 status = GdipRotateWorldTransform (graphics, 0, (MatrixOrder) (MatrixOrderAppend + 1));
1520 assertEqualInt (status, InvalidParameter);
1521
1522 HDC hdc;
1523 status = GdipGetDC (graphics, &hdc);
1524
1525 status = GdipRotateWorldTransform (graphics, 0, MatrixOrderAppend);
1526 assertEqualInt (status, ObjectBusy);
1527
1528 status = GdipRotateWorldTransform (graphics, 0, (MatrixOrder) (MatrixOrderAppend + 1));
1529 assertEqualInt (status, ObjectBusy);
1530
1531 GdipReleaseDC (graphics, hdc);
1532
1533 GdipDeleteGraphics (graphics);
1534 GdipDeleteRegion (clip);
1535 GdipDeleteMatrix (transform);
1536 GdipDeleteMatrix (matrix);
1537 }
1538
test_resetClip()1539 static void test_resetClip ()
1540 {
1541 GpStatus status;
1542 GpImage *image;
1543 GpGraphics *graphics;
1544 GpRectF bounds;
1545
1546 graphics = getImageGraphics (&image);
1547 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
1548
1549 status = GdipResetClip (graphics);
1550 assertEqualInt (status, Ok);
1551
1552 GdipGetClipBounds (graphics, &bounds);
1553 assertEqualInt (status, Ok);
1554 assertEqualFloat (bounds.X, -4194304);
1555 assertEqualFloat (bounds.Y, -4194304);
1556 assertEqualFloat (bounds.Width, 8388608);
1557 assertEqualFloat (bounds.Height, 8388608);
1558
1559 // Negative tests.
1560 status = GdipResetClip (NULL);
1561 assertEqualInt (status, InvalidParameter);
1562
1563 HDC hdc;
1564 status = GdipGetDC (graphics, &hdc);
1565
1566 status = GdipResetClip (graphics);
1567 assertEqualInt (status, ObjectBusy);
1568
1569 GdipReleaseDC (graphics, hdc);
1570
1571 GdipDeleteGraphics (graphics);
1572 GdipDisposeImage (image);
1573 }
1574
test_getClip()1575 static void test_getClip ()
1576 {
1577 GpStatus status;
1578 GpImage *image;
1579 GpGraphics *graphics;
1580 GpMatrix *transform;
1581 GpRegion *clip;
1582
1583 GpRectF bounds = {1, 2, 3, 4};
1584 GdipCreateRegionRect (&bounds, &clip);
1585
1586 graphics = getImageGraphics (&image);
1587 GdipCreateMatrix2 (1, 2, 3, 4, 5, 6, &transform);
1588
1589 // Default get - no transform.
1590 status = GdipGetClip (graphics, clip);
1591 assertEqualInt (status, Ok);
1592
1593 GdipGetRegionBounds (clip, graphics, &bounds);
1594 assertEqualFloat (bounds.X, -4194304);
1595 assertEqualFloat (bounds.Y, -4194304);
1596 assertEqualFloat (bounds.Width, 8388608);
1597 assertEqualFloat (bounds.Height, 8388608);
1598
1599 // Default get - translate transform.
1600 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
1601 status = GdipGetClip (graphics, clip);
1602 assertEqualInt (status, Ok);
1603
1604 GdipGetRegionBounds (clip, graphics, &bounds);
1605 assertEqualFloat (bounds.X, -4194304);
1606 assertEqualFloat (bounds.Y, -4194304);
1607 assertEqualFloat (bounds.Width, 8388608);
1608 assertEqualFloat (bounds.Height, 8388608);
1609
1610 GdipResetWorldTransform (graphics);
1611
1612 // Default get - complex transform.
1613 GdipSetWorldTransform (graphics, transform);
1614 status = GdipGetClip (graphics, clip);
1615 assertEqualInt (status, Ok);
1616
1617 GdipGetRegionBounds (clip, graphics, &bounds);
1618 assertEqualFloat (bounds.X, -4194304);
1619 assertEqualFloat (bounds.Y, -4194304);
1620 assertEqualFloat (bounds.Width, 8388608);
1621 assertEqualFloat (bounds.Height, 8388608);
1622
1623 GdipResetWorldTransform (graphics);
1624
1625 // Empty clip - no transform.
1626 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
1627 status = GdipGetClip (graphics, clip);
1628 assertEqualInt (status, Ok);
1629
1630 GdipGetRegionBounds (clip, graphics, &bounds);
1631 assertEqualFloat (bounds.X, 0);
1632 assertEqualFloat (bounds.Y, 0);
1633 assertEqualFloat (bounds.Width, 0);
1634 assertEqualFloat (bounds.Height, 0);
1635
1636 // Empty clip - translate transform.
1637 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
1638 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
1639 status = GdipGetClip (graphics, clip);
1640 assertEqualInt (status, Ok);
1641
1642 GdipGetRegionBounds (clip, graphics, &bounds);
1643 assertEqualFloat (bounds.X, 0);
1644 assertEqualFloat (bounds.Y, 0);
1645 assertEqualFloat (bounds.Width, 0);
1646 assertEqualFloat (bounds.Height, 0);
1647
1648 GdipResetWorldTransform (graphics);
1649
1650 // Empty clip - complex transform.
1651 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
1652 GdipSetWorldTransform (graphics, transform);
1653 status = GdipGetClip (graphics, clip);
1654 assertEqualInt (status, Ok);
1655
1656 GdipGetRegionBounds (clip, graphics, &bounds);
1657 assertEqualFloat (bounds.X, 0);
1658 assertEqualFloat (bounds.Y, 0);
1659 assertEqualFloat (bounds.Width, 0);
1660 assertEqualFloat (bounds.Height, 0);
1661
1662 GdipResetWorldTransform (graphics);
1663
1664 // Custom clip - no transform.
1665 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
1666 status = GdipGetClip (graphics, clip);
1667 assertEqualInt (status, Ok);
1668
1669 GdipGetRegionBounds (clip, graphics, &bounds);
1670 assertEqualFloat (bounds.X, 10);
1671 assertEqualFloat (bounds.Y, 20);
1672 assertEqualFloat (bounds.Width, 30);
1673 assertEqualFloat (bounds.Height, 40);
1674
1675 // Custom clip - translate transform.
1676 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
1677 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
1678 status = GdipGetClip (graphics, clip);
1679 assertEqualInt (status, Ok);
1680
1681 GdipGetRegionBounds (clip, graphics, &bounds);
1682 assertEqualFloat (bounds.X, 20);
1683 assertEqualFloat (bounds.Y, 40);
1684 assertEqualFloat (bounds.Width, 30);
1685 assertEqualFloat (bounds.Height, 40);
1686
1687 GdipResetWorldTransform (graphics);
1688
1689 // Custom clip - complex transform.
1690 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
1691 GdipSetWorldTransform (graphics, transform);
1692 status = GdipGetClip (graphics, clip);
1693 assertEqualInt (status, Ok);
1694
1695 GdipGetRegionBounds (clip, graphics, &bounds);
1696 assertEqualFloat (bounds.X, -49);
1697 assertEqualFloat (bounds.Y, -22);
1698 assertEqualFloat (bounds.Width, 120);
1699 assertEqualFloat (bounds.Height, 50);
1700
1701 // Negative tests.
1702 status = GdipGetClip (NULL, clip);
1703 assertEqualInt (status, InvalidParameter);
1704
1705 status = GdipGetClip (graphics, NULL);
1706 assertEqualInt (status, InvalidParameter);
1707
1708 HDC hdc;
1709 status = GdipGetDC (graphics, &hdc);
1710
1711 status = GdipGetClip (graphics, clip);
1712 assertEqualInt (status, ObjectBusy);
1713
1714 status = GdipGetClip (graphics, NULL);
1715 assertEqualInt (status, InvalidParameter);
1716
1717 GdipReleaseDC (graphics, hdc);
1718
1719 GdipDeleteGraphics (graphics);
1720 GdipDisposeImage (image);
1721 GdipDeleteMatrix (transform);
1722 }
1723
test_getClipBounds()1724 static void test_getClipBounds ()
1725 {
1726 GpStatus status;
1727 GpImage *image;
1728 GpGraphics *graphics;
1729 GpMatrix *transform;
1730 GpRegion *emptyRegion;
1731 GpRectF bounds;
1732
1733 graphics = getImageGraphics (&image);
1734 GdipCreateMatrix2 (1, 2, 3, 4, 5, 6, &transform);
1735
1736 GdipCreateRegion (&emptyRegion);
1737 GdipSetEmpty (emptyRegion);
1738
1739 // Default get - no transform.
1740 status = GdipGetClipBounds (graphics, &bounds);
1741 assertEqualInt (status, Ok);
1742 assertEqualFloat (bounds.X, -4194304);
1743 assertEqualFloat (bounds.Y, -4194304);
1744 assertEqualFloat (bounds.Width, 8388608);
1745 assertEqualFloat (bounds.Height, 8388608);
1746
1747 // Default get - translate transform.
1748 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
1749 status = GdipGetClipBounds (graphics, &bounds);
1750 assertEqualInt (status, Ok);
1751 // FIXME: should be transformed: https://github.com/mono/libgdiplus/issues/437
1752 #if defined(USE_WINDOWS_GDIPLUS)
1753 assertEqualFloat (bounds.X, -4194294);
1754 assertEqualFloat (bounds.Y, -4194284);
1755 #endif
1756 assertEqualFloat (bounds.Width, 8388608);
1757 assertEqualFloat (bounds.Height, 8388608);
1758
1759 GdipResetWorldTransform (graphics);
1760
1761 // Default get - complex transform.
1762 GdipSetWorldTransform (graphics, transform);
1763 status = GdipGetClipBounds (graphics, &bounds);
1764 assertEqualInt (status, Ok);
1765 // FIXME: should be transformed: https://github.com/mono/libgdiplus/issues/437
1766 #if defined(USE_WINDOWS_GDIPLUS)
1767 assertEqualFloat (bounds.X, -14680063);
1768 assertEqualFloat (bounds.Y, -6291458);
1769 assertEqualFloat (bounds.Width, 29360128);
1770 assertEqualFloat (bounds.Height, 12582912);
1771 #endif
1772
1773 GdipResetWorldTransform (graphics);
1774
1775 // Empty clip - no transform.
1776 GdipSetClipRegion (graphics, emptyRegion, CombineModeReplace);
1777 status = GdipGetClipBounds (graphics, &bounds);
1778 assertEqualInt (status, Ok);
1779 assertEqualFloat (bounds.X, 0);
1780 assertEqualFloat (bounds.Y, 0);
1781 assertEqualFloat (bounds.Width, 0);
1782 assertEqualFloat (bounds.Height, 0);
1783
1784 // Empty clip - translate transform.
1785 GdipSetClipRegion (graphics, emptyRegion, CombineModeReplace);
1786 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
1787
1788 status = GdipGetClipBounds (graphics, &bounds);
1789 assertEqualInt (status, Ok);
1790 assertEqualFloat (bounds.X, 10);
1791 assertEqualFloat (bounds.Y, 20);
1792 assertEqualFloat (bounds.Width, 0);
1793 assertEqualFloat (bounds.Height, 0);
1794
1795 GdipResetWorldTransform (graphics);
1796
1797 // Empty clip - complex transform.
1798 GdipSetClipRegion (graphics, emptyRegion, CombineModeReplace);
1799 GdipSetWorldTransform (graphics, transform);
1800
1801 status = GdipGetClipBounds (graphics, &bounds);
1802 assertEqualInt (status, Ok);
1803 assertEqualFloat (bounds.X, 1);
1804 assertEqualFloat (bounds.Y, -2);
1805 assertEqualFloat (bounds.Width, 0);
1806 assertEqualFloat (bounds.Height, 0);
1807
1808 GdipResetWorldTransform (graphics);
1809
1810 // Empty clip rect - no transform.
1811 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
1812 status = GdipGetClipBounds (graphics, &bounds);
1813 assertEqualInt (status, Ok);
1814 assertEqualFloat (bounds.X, 0);
1815 assertEqualFloat (bounds.Y, 0);
1816 assertEqualFloat (bounds.Width, 0);
1817 assertEqualFloat (bounds.Height, 0);
1818
1819 // Empty clip rect - translate transform.
1820 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
1821 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
1822
1823 status = GdipGetClipBounds (graphics, &bounds);
1824 assertEqualInt (status, Ok);
1825 assertEqualFloat (bounds.X, 10);
1826 assertEqualFloat (bounds.Y, 20);
1827 assertEqualFloat (bounds.Width, 0);
1828 assertEqualFloat (bounds.Height, 0);
1829
1830 GdipResetWorldTransform (graphics);
1831
1832 // Empty clip rect - complex transform.
1833 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
1834 GdipSetWorldTransform (graphics, transform);
1835
1836 status = GdipGetClipBounds (graphics, &bounds);
1837 assertEqualInt (status, Ok);
1838 assertEqualFloat (bounds.X, 1);
1839 assertEqualFloat (bounds.Y, -2);
1840 assertEqualFloat (bounds.Width, 0);
1841 assertEqualFloat (bounds.Height, 0);
1842
1843 GdipResetWorldTransform (graphics);
1844
1845 // Custom clip - no transform.
1846 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
1847
1848 status = GdipGetClipBounds (graphics, &bounds);
1849 assertEqualInt (status, Ok);
1850 assertEqualFloat (bounds.X, 10);
1851 assertEqualFloat (bounds.Y, 20);
1852 assertEqualFloat (bounds.Width, 30);
1853 assertEqualFloat (bounds.Height, 40);
1854
1855 // Custom clip - translate transform.
1856 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
1857 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
1858
1859 status = GdipGetClipBounds (graphics, &bounds);
1860 assertEqualInt (status, Ok);
1861 assertEqualFloat (bounds.X, 20);
1862 assertEqualFloat (bounds.Y, 40);
1863 assertEqualFloat (bounds.Width, 30);
1864 assertEqualFloat (bounds.Height, 40);
1865
1866 GdipResetWorldTransform (graphics);
1867
1868 // Custom clip - complex transform.
1869 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
1870 GdipSetWorldTransform (graphics, transform);
1871
1872 status = GdipGetClipBounds (graphics, &bounds);
1873 assertEqualInt (status, Ok);
1874 assertEqualFloat (bounds.X, -49);
1875 assertEqualFloat (bounds.Y, -22);
1876 assertEqualFloat (bounds.Width, 120);
1877 assertEqualFloat (bounds.Height, 50);
1878
1879 // Negative tests.
1880 status = GdipGetClipBounds (NULL, &bounds);
1881 assertEqualInt (status, InvalidParameter);
1882
1883 status = GdipGetClipBounds (graphics, NULL);
1884 assertEqualInt (status, InvalidParameter);
1885
1886 HDC hdc;
1887 status = GdipGetDC (graphics, &hdc);
1888
1889 status = GdipGetClipBounds (graphics, &bounds);
1890 assertEqualInt (status, ObjectBusy);
1891
1892 status = GdipGetClipBounds (graphics, NULL);
1893 assertEqualInt (status, InvalidParameter);
1894
1895 GdipReleaseDC (graphics, hdc);
1896
1897 GdipDeleteGraphics (graphics);
1898 GdipDisposeImage (image);
1899 GdipDeleteMatrix (transform);
1900 GdipDeleteRegion (emptyRegion);
1901 }
1902
test_getClipBoundsI()1903 static void test_getClipBoundsI ()
1904 {
1905 GpStatus status;
1906 GpImage *image;
1907 GpGraphics *graphics;
1908 GpMatrix *transform;
1909 GpRegion *emptyRegion;
1910 GpRect bounds;
1911
1912 graphics = getImageGraphics (&image);
1913 GdipCreateMatrix2 (1, 2, 3, 4, 5, 6, &transform);
1914
1915 GdipCreateRegion (&emptyRegion);
1916 GdipSetEmpty (emptyRegion);
1917
1918 // Default get - no transform.
1919 status = GdipGetClipBoundsI (graphics, &bounds);
1920 assertEqualInt (status, Ok);
1921 assertEqualInt (bounds.X, -4194304);
1922 assertEqualInt (bounds.Y, -4194304);
1923 assertEqualInt (bounds.Width, 8388608);
1924 assertEqualInt (bounds.Height, 8388608);
1925
1926 // Default get - translate transform.
1927 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
1928 status = GdipGetClipBoundsI (graphics, &bounds);
1929 assertEqualInt (status, Ok);
1930 // FIXME: should be transformed: https://github.com/mono/libgdiplus/issues/437
1931 #if defined(USE_WINDOWS_GDIPLUS)
1932 assertEqualInt (bounds.X, -4194294);
1933 assertEqualInt (bounds.Y, -4194284);
1934 #endif
1935 assertEqualInt (bounds.Width, 8388608);
1936 assertEqualInt (bounds.Height, 8388608);
1937
1938 GdipResetWorldTransform (graphics);
1939
1940 // Default get - complex transform.
1941 GdipSetWorldTransform (graphics, transform);
1942 status = GdipGetClipBoundsI (graphics, &bounds);
1943 assertEqualInt (status, Ok);
1944 // FIXME: should be transformed: https://github.com/mono/libgdiplus/issues/437
1945 #if defined(USE_WINDOWS_GDIPLUS)
1946 assertEqualInt (bounds.X, -14680063);
1947 assertEqualInt (bounds.Y, -6291458);
1948 assertEqualInt (bounds.Width, 29360128);
1949 assertEqualInt (bounds.Height, 12582912);
1950 #endif
1951
1952 GdipResetWorldTransform (graphics);
1953
1954 // Empty clip - no transform.
1955 GdipSetClipRegion (graphics, emptyRegion, CombineModeReplace);
1956 status = GdipGetClipBoundsI (graphics, &bounds);
1957 assertEqualInt (status, Ok);
1958 assertEqualInt (bounds.X, 0);
1959 assertEqualInt (bounds.Y, 0);
1960 assertEqualInt (bounds.Width, 0);
1961 assertEqualInt (bounds.Height, 0);
1962
1963 // Empty clip - translate transform.
1964 GdipSetClipRegion (graphics, emptyRegion, CombineModeReplace);
1965 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
1966
1967 status = GdipGetClipBoundsI (graphics, &bounds);
1968 assertEqualInt (status, Ok);
1969 assertEqualInt (bounds.X, 10);
1970 assertEqualInt (bounds.Y, 20);
1971 assertEqualInt (bounds.Width, 0);
1972 assertEqualInt (bounds.Height, 0);
1973
1974 GdipResetWorldTransform (graphics);
1975
1976 // Empty clip - complex transform.
1977 GdipSetClipRegion (graphics, emptyRegion, CombineModeReplace);
1978 GdipSetWorldTransform (graphics, transform);
1979
1980 status = GdipGetClipBoundsI (graphics, &bounds);
1981 assertEqualInt (status, Ok);
1982 assertEqualInt (bounds.X, 1);
1983 assertEqualInt (bounds.Y, -2);
1984 assertEqualInt (bounds.Width, 0);
1985 assertEqualInt (bounds.Height, 0);
1986
1987 GdipResetWorldTransform (graphics);
1988
1989 // Empty clip rect - no transform.
1990 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
1991 status = GdipGetClipBoundsI (graphics, &bounds);
1992 assertEqualInt (status, Ok);
1993 assertEqualInt (bounds.X, 0);
1994 assertEqualInt (bounds.Y, 0);
1995 assertEqualInt (bounds.Width, 0);
1996 assertEqualInt (bounds.Height, 0);
1997
1998 // Empty clip rect - translate transform.
1999 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
2000 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2001
2002 status = GdipGetClipBoundsI (graphics, &bounds);
2003 assertEqualInt (status, Ok);
2004 assertEqualInt (bounds.X, 10);
2005 assertEqualInt (bounds.Y, 20);
2006 assertEqualInt (bounds.Width, 0);
2007 assertEqualInt (bounds.Height, 0);
2008
2009 GdipResetWorldTransform (graphics);
2010
2011 // Empty clip rect - complex transform.
2012 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
2013 GdipSetWorldTransform (graphics, transform);
2014
2015 status = GdipGetClipBoundsI (graphics, &bounds);
2016 assertEqualInt (status, Ok);
2017 assertEqualInt (bounds.X, 1);
2018 assertEqualInt (bounds.Y, -2);
2019 assertEqualInt (bounds.Width, 0);
2020 assertEqualInt (bounds.Height, 0);
2021
2022 GdipResetWorldTransform (graphics);
2023
2024 // Custom clip - no transform.
2025 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2026
2027 status = GdipGetClipBoundsI (graphics, &bounds);
2028 assertEqualInt (status, Ok);
2029 assertEqualInt (bounds.X, 10);
2030 assertEqualInt (bounds.Y, 20);
2031 assertEqualInt (bounds.Width, 30);
2032 assertEqualInt (bounds.Height, 40);
2033
2034 // Custom clip - translate transform.
2035 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2036 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2037
2038 status = GdipGetClipBoundsI (graphics, &bounds);
2039 assertEqualInt (status, Ok);
2040 assertEqualInt (bounds.X, 20);
2041 assertEqualInt (bounds.Y, 40);
2042 assertEqualInt (bounds.Width, 30);
2043 assertEqualInt (bounds.Height, 40);
2044
2045 GdipResetWorldTransform (graphics);
2046
2047 // Custom clip - complex transform.
2048 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2049 GdipSetWorldTransform (graphics, transform);
2050
2051 status = GdipGetClipBoundsI (graphics, &bounds);
2052 assertEqualInt (status, Ok);
2053 assertEqualInt (bounds.X, -49);
2054 assertEqualInt (bounds.Y, -22);
2055 assertEqualInt (bounds.Width, 120);
2056 assertEqualInt (bounds.Height, 50);
2057
2058 // Negative tests.
2059 status = GdipGetClipBoundsI (NULL, &bounds);
2060 assertEqualInt (status, InvalidParameter);
2061
2062 status = GdipGetClipBoundsI (graphics, NULL);
2063 assertEqualInt (status, InvalidParameter);
2064
2065 HDC hdc;
2066 status = GdipGetDC (graphics, &hdc);
2067
2068 status = GdipGetClipBoundsI (graphics, &bounds);
2069 assertEqualInt (status, ObjectBusy);
2070
2071 status = GdipGetClipBoundsI (graphics, NULL);
2072 assertEqualInt (status, InvalidParameter);
2073
2074 GdipReleaseDC (graphics, hdc);
2075
2076 GdipDeleteGraphics (graphics);
2077 GdipDisposeImage (image);
2078 GdipDeleteMatrix (transform);
2079 GdipDeleteRegion (emptyRegion);
2080 }
2081
test_getVisibleClipBounds()2082 static void test_getVisibleClipBounds ()
2083 {
2084 GpStatus status;
2085 GpImage *image;
2086 GpGraphics *graphics;
2087 GpMatrix *transform;
2088 GpRectF bounds;
2089
2090 graphics = getImageGraphics (&image);
2091 GdipCreateMatrix2 (1, 2, 3, 4, 5, 6, &transform);
2092
2093 // Default get - no transform.
2094 status = GdipGetVisibleClipBounds (graphics, &bounds);
2095 assertEqualInt (status, Ok);
2096 assertEqualFloat (bounds.X, 0);
2097 assertEqualFloat (bounds.Y, 0);
2098 assertEqualFloat (bounds.Width, 100);
2099 assertEqualFloat (bounds.Height, 68);
2100
2101 // Default get - translate transform.
2102 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2103 status = GdipGetVisibleClipBounds (graphics, &bounds);
2104 assertEqualInt (status, Ok);
2105 assertEqualFloat (bounds.X, 10);
2106 assertEqualFloat (bounds.Y, 20);
2107 assertEqualFloat (bounds.Width, 100);
2108 assertEqualFloat (bounds.Height, 68);
2109
2110 GdipResetWorldTransform (graphics);
2111
2112 // Default get - complex transform.
2113 GdipSetWorldTransform (graphics, transform);
2114 status = GdipGetVisibleClipBounds (graphics, &bounds);
2115 assertEqualInt (status, Ok);
2116 // FIXME: should be transformed: https://github.com/mono/libgdiplus/issues/309
2117 #if defined(USE_WINDOWS_GDIPLUS)
2118 assertEqualFloat (bounds.X, -199);
2119 assertEqualFloat (bounds.Y, -36);
2120 assertEqualFloat (bounds.Width, 302);
2121 assertEqualFloat (bounds.Height, 134);
2122 #endif
2123
2124 GdipResetWorldTransform (graphics);
2125
2126 // Empty clip - no transform.
2127 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
2128
2129 status = GdipGetVisibleClipBounds (graphics, &bounds);
2130 assertEqualInt (status, Ok);
2131 assertEqualFloat (bounds.X, 0);
2132 assertEqualFloat (bounds.Y, 0);
2133 assertEqualFloat (bounds.Width, 0);
2134 assertEqualFloat (bounds.Height, 0);
2135
2136 // Empty clip - translate transform.
2137 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
2138 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2139
2140 status = GdipGetVisibleClipBounds (graphics, &bounds);
2141 assertEqualInt (status, Ok);
2142 assertEqualFloat (bounds.X, 10);
2143 assertEqualFloat (bounds.Y, 20);
2144 assertEqualFloat (bounds.Width, 0);
2145 assertEqualFloat (bounds.Height, 0);
2146
2147 GdipResetWorldTransform (graphics);
2148
2149 // Empty clip - complex transform.
2150 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
2151 GdipSetWorldTransform (graphics, transform);
2152
2153 status = GdipGetVisibleClipBounds (graphics, &bounds);
2154 assertEqualInt (status, Ok);
2155 assertEqualFloat (bounds.X, 1);
2156 assertEqualFloat (bounds.Y, -2);
2157 assertEqualFloat (bounds.Width, 0);
2158 assertEqualFloat (bounds.Height, 0);
2159
2160 GdipResetWorldTransform (graphics);
2161
2162 // Custom clip - no transform.
2163 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2164 status = GdipGetVisibleClipBounds (graphics, &bounds);
2165 assertEqualInt (status, Ok);
2166 assertEqualFloat (bounds.X, 10);
2167 assertEqualFloat (bounds.Y, 20);
2168 assertEqualFloat (bounds.Width, 30);
2169 assertEqualFloat (bounds.Height, 40);
2170
2171 // Custom clip - translate transform.
2172 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2173 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2174
2175 status = GdipGetVisibleClipBounds (graphics, &bounds);
2176 assertEqualInt (status, Ok);
2177 assertEqualFloat (bounds.X, 20);
2178 assertEqualFloat (bounds.Y, 40);
2179 assertEqualFloat (bounds.Width, 30);
2180 assertEqualFloat (bounds.Height, 40);
2181
2182 GdipResetWorldTransform (graphics);
2183
2184 // Custom clip - complex transform.
2185 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2186 GdipSetWorldTransform (graphics, transform);
2187
2188 status = GdipGetVisibleClipBounds (graphics, &bounds);
2189 assertEqualInt (status, Ok);
2190 // FIXME: should be transformed: https://github.com/mono/libgdiplus/issues/309
2191 #if defined(USE_WINDOWS_GDIPLUS)
2192 assertEqualFloat (bounds.X, -49);
2193 assertEqualFloat (bounds.Y, -22);
2194 assertEqualFloat (bounds.Width, 120);
2195 assertEqualFloat (bounds.Height, 50);
2196 #endif
2197
2198 GdipResetWorldTransform (graphics);
2199
2200 // Negative tests.
2201 status = GdipGetVisibleClipBounds (NULL, &bounds);
2202 assertEqualInt (status, InvalidParameter);
2203
2204 status = GdipGetVisibleClipBounds (graphics, NULL);
2205 assertEqualInt (status, InvalidParameter);
2206
2207 HDC hdc;
2208 status = GdipGetDC (graphics, &hdc);
2209
2210 status = GdipGetVisibleClipBounds (graphics, &bounds);
2211 assertEqualInt (status, ObjectBusy);
2212
2213 status = GdipGetVisibleClipBounds (graphics, NULL);
2214 assertEqualInt (status, InvalidParameter);
2215
2216 GdipReleaseDC (graphics, hdc);
2217
2218 GdipDeleteGraphics (graphics);
2219 GdipDisposeImage (image);
2220 GdipDeleteMatrix (transform);
2221 }
2222
test_getVisibleClipBoundsI()2223 static void test_getVisibleClipBoundsI ()
2224 {
2225 GpStatus status;
2226 GpImage *image;
2227 GpGraphics *graphics;
2228 GpMatrix *transform;
2229 GpRect bounds;
2230
2231 graphics = getImageGraphics (&image);
2232 GdipCreateMatrix2 (1, 2, 3, 4, 5, 6, &transform);
2233
2234 // Default get - no transform
2235 status = GdipGetVisibleClipBoundsI (graphics, &bounds);
2236 assertEqualInt (status, Ok);
2237 assertEqualInt (bounds.X, 0);
2238 assertEqualInt (bounds.Y, 0);
2239 assertEqualInt (bounds.Width, 100);
2240 assertEqualInt (bounds.Height, 68);
2241
2242 // Default get - translate transform.
2243 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2244 status = GdipGetVisibleClipBoundsI (graphics, &bounds);
2245 assertEqualInt (status, Ok);
2246 assertEqualInt (bounds.X, 10);
2247 assertEqualInt (bounds.Y, 20);
2248 assertEqualInt (bounds.Width, 100);
2249 assertEqualInt (bounds.Height, 68);
2250
2251 GdipResetWorldTransform (graphics);
2252
2253 // Default get - complex transform.
2254 GdipSetWorldTransform (graphics, transform);
2255 status = GdipGetVisibleClipBoundsI (graphics, &bounds);
2256 // FIXME: should be transformed: https://github.com/mono/libgdiplus/issues/309
2257 #if defined(USE_WINDOWS_GDIPLUS)
2258 assertEqualInt (bounds.X, -199);
2259 assertEqualInt (bounds.Y, -36);
2260 assertEqualInt (bounds.Width, 302);
2261 assertEqualInt (bounds.Height, 134);
2262 #endif
2263
2264 GdipResetWorldTransform (graphics);
2265
2266 // Empty clip - no transform.
2267 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
2268
2269 status = GdipGetVisibleClipBoundsI (graphics, &bounds);
2270 assertEqualInt (status, Ok);
2271 assertEqualInt (bounds.X, 0);
2272 assertEqualInt (bounds.Y, 0);
2273 assertEqualInt (bounds.Width, 0);
2274 assertEqualInt (bounds.Height, 0);
2275
2276 // Empty clip - translate transform.
2277 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
2278 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2279
2280 status = GdipGetVisibleClipBoundsI (graphics, &bounds);
2281 assertEqualInt (status, Ok);
2282 assertEqualInt (bounds.X, 10);
2283 assertEqualInt (bounds.Y, 20);
2284 assertEqualInt (bounds.Width, 0);
2285 assertEqualInt (bounds.Height, 0);
2286
2287 GdipResetWorldTransform (graphics);
2288
2289 // Empty clip - complex transform.
2290 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
2291 GdipSetWorldTransform (graphics, transform);
2292
2293 status = GdipGetVisibleClipBoundsI (graphics, &bounds);
2294 assertEqualInt (status, Ok);
2295 assertEqualInt (bounds.X, 1);
2296 assertEqualInt (bounds.Y, -2);
2297 assertEqualInt (bounds.Width, 0);
2298 assertEqualInt (bounds.Height, 0);
2299
2300 GdipResetWorldTransform (graphics);
2301
2302 // Custom clip - no transform.
2303 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2304 status = GdipGetVisibleClipBoundsI (graphics, &bounds);
2305 assertEqualInt (status, Ok);
2306 assertEqualInt (bounds.X, 10);
2307 assertEqualInt (bounds.Y, 20);
2308 assertEqualInt (bounds.Width, 30);
2309 assertEqualInt (bounds.Height, 40);
2310
2311 // Custom clip - translate transform.
2312 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2313 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2314
2315 status = GdipGetVisibleClipBoundsI (graphics, &bounds);
2316 assertEqualInt (status, Ok);
2317 assertEqualInt (bounds.X, 20);
2318 assertEqualInt (bounds.Y, 40);
2319 assertEqualInt (bounds.Width, 30);
2320 assertEqualInt (bounds.Height, 40);
2321
2322 GdipResetWorldTransform (graphics);
2323
2324 // Custom clip - complex transform.
2325 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2326 GdipSetWorldTransform (graphics, transform);
2327
2328 status = GdipGetVisibleClipBoundsI (graphics, &bounds);
2329 assertEqualInt (status, Ok);
2330 // FIXME: should be transformed: https://github.com/mono/libgdiplus/issues/309
2331 #if defined(USE_WINDOWS_GDIPLUS)
2332 assertEqualInt (bounds.X, -49);
2333 assertEqualInt (bounds.Y, -22);
2334 assertEqualInt (bounds.Width, 120);
2335 assertEqualInt (bounds.Height, 50);
2336 #endif
2337
2338 // Negative tests.
2339 status = GdipGetVisibleClipBoundsI (NULL, &bounds);
2340 assertEqualInt (status, InvalidParameter);
2341
2342 status = GdipGetVisibleClipBoundsI (graphics, NULL);
2343 assertEqualInt (status, InvalidParameter);
2344
2345 HDC hdc;
2346 status = GdipGetDC (graphics, &hdc);
2347
2348 status = GdipGetVisibleClipBoundsI (graphics, &bounds);
2349 assertEqualInt (status, ObjectBusy);
2350
2351 status = GdipGetVisibleClipBoundsI (graphics, NULL);
2352 assertEqualInt (status, InvalidParameter);
2353
2354 GdipReleaseDC (graphics, hdc);
2355
2356 GdipDeleteGraphics (graphics);
2357 GdipDisposeImage (image);
2358 GdipDeleteMatrix (transform);
2359 }
2360
test_isClipEmpty()2361 static void test_isClipEmpty ()
2362 {
2363 GpStatus status;
2364 GpImage *image;
2365 GpGraphics *graphics;
2366 BOOL isEmpty;
2367
2368 graphics = getImageGraphics (&image);
2369
2370 // Default clip.
2371 status = GdipIsClipEmpty (graphics, &isEmpty);
2372 assertEqualInt (status, Ok);
2373 assertEqualInt (isEmpty, FALSE);
2374
2375 // Empty clip - no transform.
2376 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
2377
2378 status = GdipIsClipEmpty (graphics, &isEmpty);
2379 assertEqualInt (status, Ok);
2380 assertEqualInt (isEmpty, TRUE);
2381
2382 // Empty width clip - no transform.
2383 GdipSetClipRect (graphics, 10, 20, 0, 40, CombineModeReplace);
2384
2385 status = GdipIsClipEmpty (graphics, &isEmpty);
2386 assertEqualInt (status, Ok);
2387 assertEqualInt (isEmpty, TRUE);
2388
2389 // Empty height clip - no transform.
2390 GdipSetClipRect (graphics, 10, 20, 30, 0, CombineModeReplace);
2391
2392 status = GdipIsClipEmpty (graphics, &isEmpty);
2393 assertEqualInt (status, Ok);
2394 assertEqualInt (isEmpty, TRUE);
2395
2396 // Empty clip - transformed.
2397 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
2398 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2399
2400 status = GdipIsClipEmpty (graphics, &isEmpty);
2401 assertEqualInt (status, Ok);
2402 assertEqualInt (isEmpty, TRUE);
2403
2404 // Custom clip - no transform.
2405 GdipResetWorldTransform (graphics);
2406 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2407
2408 status = GdipIsClipEmpty (graphics, &isEmpty);
2409 assertEqualInt (status, Ok);
2410 assertEqualInt (isEmpty, FALSE);
2411
2412 // Custom clip - transformed.
2413 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2414 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2415
2416 status = GdipIsClipEmpty (graphics, &isEmpty);
2417 assertEqualInt (status, Ok);
2418 assertEqualInt (isEmpty, FALSE);
2419
2420 // Negative tests.
2421 status = GdipIsClipEmpty (NULL, &isEmpty);
2422 assertEqualInt (status, InvalidParameter);
2423
2424 status = GdipIsClipEmpty (graphics, NULL);
2425 assertEqualInt (status, InvalidParameter);
2426
2427 HDC hdc;
2428 status = GdipGetDC (graphics, &hdc);
2429
2430 status = GdipIsClipEmpty (graphics, &isEmpty);
2431 assertEqualInt (status, ObjectBusy);
2432
2433 status = GdipIsClipEmpty (graphics, NULL);
2434 assertEqualInt (status, InvalidParameter);
2435
2436 GdipReleaseDC (graphics, hdc);
2437
2438 GdipDeleteGraphics (graphics);
2439 GdipDisposeImage (image);
2440 }
2441
test_isVisibleClipEmpty()2442 static void test_isVisibleClipEmpty ()
2443 {
2444 GpStatus status;
2445 GpImage *image;
2446 GpGraphics *graphics;
2447 BOOL isEmpty;
2448
2449 graphics = getImageGraphics (&image);
2450
2451 // Default clip.
2452 status = GdipIsVisibleClipEmpty (graphics, &isEmpty);
2453 assertEqualInt (status, Ok);
2454 assertEqualInt (isEmpty, FALSE);
2455
2456 // Empty clip - no transform.
2457 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
2458
2459 status = GdipIsVisibleClipEmpty (graphics, &isEmpty);
2460 assertEqualInt (status, Ok);
2461 assertEqualInt (isEmpty, TRUE);
2462
2463 // Empty width clip - no transform.
2464 GdipSetClipRect (graphics, 10, 20, 0, 40, CombineModeReplace);
2465
2466 status = GdipIsVisibleClipEmpty (graphics, &isEmpty);
2467 assertEqualInt (status, Ok);
2468 assertEqualInt (isEmpty, TRUE);
2469
2470 // Empty height clip - no transform.
2471 GdipSetClipRect (graphics, 10, 20, 30, 0, CombineModeReplace);
2472
2473 status = GdipIsVisibleClipEmpty (graphics, &isEmpty);
2474 assertEqualInt (status, Ok);
2475 assertEqualInt (isEmpty, TRUE);
2476
2477 // Empty clip - transformed.
2478 GdipSetClipRect (graphics, 0, 0, 0, 0, CombineModeReplace);
2479 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2480
2481 status = GdipIsVisibleClipEmpty (graphics, &isEmpty);
2482 assertEqualInt (status, Ok);
2483 assertEqualInt (isEmpty, TRUE);
2484
2485 // Custom clip - no transform.
2486 GdipResetWorldTransform (graphics);
2487 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2488
2489 status = GdipIsVisibleClipEmpty (graphics, &isEmpty);
2490 assertEqualInt (status, Ok);
2491 assertEqualInt (isEmpty, FALSE);
2492
2493 // Custom clip - transformed.
2494 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2495 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2496
2497 status = GdipIsVisibleClipEmpty (graphics, &isEmpty);
2498 assertEqualInt (status, Ok);
2499 assertEqualInt (isEmpty, FALSE);
2500
2501 // Negative tests.
2502 status = GdipIsVisibleClipEmpty (NULL, &isEmpty);
2503 assertEqualInt (status, InvalidParameter);
2504
2505 status = GdipIsVisibleClipEmpty (graphics, NULL);
2506 assertEqualInt (status, InvalidParameter);
2507
2508 HDC hdc;
2509 status = GdipGetDC (graphics, &hdc);
2510
2511 status = GdipIsVisibleClipEmpty (graphics, &isEmpty);
2512 assertEqualInt (status, ObjectBusy);
2513
2514 status = GdipIsVisibleClipEmpty (graphics, NULL);
2515 assertEqualInt (status, InvalidParameter);
2516
2517 GdipReleaseDC (graphics, hdc);
2518
2519 GdipDeleteGraphics (graphics);
2520 GdipDisposeImage (image);
2521 }
2522
test_setClipGraphics()2523 static void test_setClipGraphics ()
2524 {
2525 GpStatus status;
2526 GpImage *image;
2527 GpGraphics *graphics;
2528 GpGraphics *otherGraphics;
2529 GpRegion *clip;
2530 GpRectF bounds;
2531
2532 graphics = getImageGraphics (&image);
2533 otherGraphics = getImageGraphics (&image);
2534 GdipCreateRegion (&clip);
2535
2536 // No transform.
2537 GdipSetClipRect (otherGraphics, 10, 20, 30, 40, CombineModeReplace);
2538
2539 status = GdipSetClipGraphics (graphics, otherGraphics, CombineModeReplace);
2540 assertEqualInt (status, Ok);
2541
2542 status = GdipGetClipBounds (graphics, &bounds);
2543 assertEqualInt (status, Ok);
2544 assertEqualFloat (bounds.X, 10);
2545 assertEqualFloat (bounds.Y, 20);
2546 assertEqualFloat (bounds.Width, 30);
2547 assertEqualFloat (bounds.Height, 40);
2548
2549 // Source graphics transformed.
2550 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2551
2552 status = GdipSetClipGraphics (graphics, otherGraphics, CombineModeReplace);
2553 assertEqualInt (status, Ok);
2554
2555 status = GdipGetClipBounds (graphics, &bounds);
2556 assertEqualInt (status, Ok);
2557 // FIXME this is incorrect: https://github.com/mono/libgdiplus/issues/308
2558 #if defined(USE_WINDOWS_GDIPLUS)
2559 assertEqualFloat (bounds.X, 20);
2560 assertEqualFloat (bounds.Y, 40);
2561 assertEqualFloat (bounds.Width, 30);
2562 assertEqualFloat (bounds.Height, 40);
2563 #endif
2564
2565 // Target graphics transformed.
2566 GdipResetWorldTransform (graphics);
2567 GdipTranslateWorldTransform (otherGraphics, -10, -20, MatrixOrderAppend);
2568
2569 status = GdipSetClipGraphics (graphics, otherGraphics, CombineModeReplace);
2570 assertEqualInt (status, Ok);
2571
2572 status = GdipGetClipBounds (graphics, &bounds);
2573 assertEqualInt (status, Ok);
2574 assertEqualFloat (bounds.X, 10);
2575 assertEqualFloat (bounds.Y, 20);
2576 assertEqualFloat (bounds.Width, 30);
2577 assertEqualFloat (bounds.Height, 40);
2578
2579 // Negative tests.
2580 status = GdipSetClipGraphics (NULL, otherGraphics, CombineModeReplace);
2581 assertEqualInt (status, InvalidParameter);
2582
2583 status = GdipSetClipGraphics (graphics, NULL, CombineModeReplace);
2584 assertEqualInt (status, InvalidParameter);
2585
2586 status = GdipSetClipGraphics (graphics, otherGraphics, (CombineMode) (CombineModeComplement + 1));
2587 assertEqualInt (status, InvalidParameter);
2588
2589 HDC hdc;
2590 status = GdipGetDC (graphics, &hdc);
2591
2592 status = GdipSetClipGraphics (graphics, otherGraphics, CombineModeReplace);
2593 assertEqualInt (status, ObjectBusy);
2594
2595 status = GdipSetClipGraphics (graphics, NULL, CombineModeReplace);
2596 assertEqualInt (status, ObjectBusy);
2597
2598 status = GdipSetClipGraphics (graphics, NULL, (CombineMode) (CombineModeComplement + 1));
2599 assertEqualInt (status, ObjectBusy);
2600
2601 GdipReleaseDC (graphics, hdc);
2602
2603 status = GdipGetDC (otherGraphics, &hdc);
2604
2605 status = GdipSetClipGraphics (graphics, otherGraphics, CombineModeReplace);
2606 assertEqualInt (status, ObjectBusy);
2607
2608 status = GdipSetClipGraphics (NULL, otherGraphics, CombineModeReplace);
2609 assertEqualInt (status, InvalidParameter);
2610
2611 status = GdipSetClipGraphics (graphics, otherGraphics, (CombineMode) (CombineModeComplement + 1));
2612 assertEqualInt (status, ObjectBusy);
2613
2614 GdipReleaseDC (otherGraphics, hdc);
2615
2616 GdipDeleteGraphics (graphics);
2617 GdipDeleteGraphics (otherGraphics);
2618 GdipDisposeImage (image);
2619 }
2620
test_setClipHrgn()2621 static void test_setClipHrgn ()
2622 {
2623 GpStatus status;
2624 GpImage *image;
2625 GpRegion *region;
2626 GpGraphics *graphics;
2627 HRGN hrgn;
2628 GpRectF bounds;
2629
2630 graphics = getImageGraphics (&image);
2631 GpRectF rect = {10, 20, 30, 40};
2632 GdipCreateRegionRect (&rect, ®ion);
2633 GdipGetRegionHRgn (region, graphics, &hrgn);
2634
2635 // No transform.
2636 status = GdipSetClipHrgn (graphics, hrgn, CombineModeReplace);
2637 assertEqualInt (status, Ok);
2638
2639 status = GdipGetClipBounds (graphics, &bounds);
2640 assertEqualInt (status, Ok);
2641 assertEqualFloat (bounds.X, 10);
2642 assertEqualFloat (bounds.Y, 20);
2643 assertEqualFloat (bounds.Width, 30);
2644 assertEqualFloat (bounds.Height, 40);
2645
2646 // Target graphics transformed.
2647 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2648
2649 status = GdipSetClipHrgn (graphics, hrgn, CombineModeReplace);
2650 assertEqualInt (status, Ok);
2651
2652 status = GdipGetClipBounds (graphics, &bounds);
2653 assertEqualInt (status, Ok);
2654 // FIXME: no transformation applied.
2655 #if defined(USE_WINDOWS_GDIPLUS)
2656 assertEqualFloat (bounds.X, 20);
2657 assertEqualFloat (bounds.Y, 40);
2658 assertEqualFloat (bounds.Width, 30);
2659 assertEqualFloat (bounds.Height, 40);
2660 #endif
2661
2662 // Negative tests.
2663 status = GdipSetClipHrgn (NULL, hrgn, CombineModeReplace);
2664 assertEqualInt (status, InvalidParameter);
2665
2666 status = GdipSetClipHrgn (graphics, NULL, CombineModeReplace);
2667 assertEqualInt (status, InvalidParameter);
2668
2669 status = GdipSetClipHrgn (graphics, hrgn, (CombineMode) (CombineModeComplement + 1));
2670 assertEqualInt (status, InvalidParameter);
2671
2672 HDC hdc;
2673 status = GdipGetDC (graphics, &hdc);
2674
2675 status = GdipSetClipHrgn (graphics, hrgn, CombineModeReplace);
2676 assertEqualInt (status, ObjectBusy);
2677
2678 status = GdipSetClipHrgn (graphics, NULL, CombineModeReplace);
2679 assertEqualInt (status, ObjectBusy);
2680
2681 status = GdipSetClipHrgn (graphics, hrgn, (CombineMode) (CombineModeComplement + 1));
2682 assertEqualInt (status, ObjectBusy);
2683
2684 GdipReleaseDC (graphics, hdc);
2685
2686 GdipDeleteGraphics (graphics);
2687 GdipDeleteRegion (region);
2688 }
2689
test_setClipRect()2690 static void test_setClipRect ()
2691 {
2692 GpStatus status;
2693 GpImage *image;
2694 GpGraphics *graphics;
2695 GpRectF bounds;
2696 UINT scansCount;
2697 GpRegion *region;
2698 GpMatrix *matrix;
2699
2700 graphics = getImageGraphics (&image);
2701 GdipCreateRegion (®ion);
2702 GdipCreateMatrix (&matrix);
2703
2704 // Positive width, positive height.
2705 status = GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2706 assertEqualInt (status, Ok);
2707
2708 status = GdipGetClipBounds (graphics, &bounds);
2709 assertEqualInt (status, Ok);
2710 assertEqualFloat (bounds.X, 10);
2711 assertEqualFloat (bounds.Y, 20);
2712 assertEqualFloat (bounds.Width, 30);
2713 assertEqualFloat (bounds.Height, 40);
2714
2715 // Positive width, zero height.
2716 status = GdipSetClipRect (graphics, 10, 20, 30, 0, CombineModeReplace);
2717 assertEqualInt (status, Ok);
2718
2719 status = GdipGetClip (graphics, region);
2720 assertEqualInt (status, Ok);
2721
2722 status = GdipGetRegionScansCount (region, &scansCount, matrix);
2723 assertEqualInt (status, Ok);
2724 assertEqualInt (scansCount, 0);
2725
2726 status = GdipGetClipBounds (graphics, &bounds);
2727 assertEqualInt (status, Ok);
2728 assertEqualFloat (bounds.X, 0);
2729 assertEqualFloat (bounds.Y, 0);
2730 assertEqualFloat (bounds.Width, 0);
2731 assertEqualFloat (bounds.Height, 0);
2732
2733 // Positive width, negative height.
2734 status = GdipSetClipRect (graphics, 10, 20, 30, -40, CombineModeReplace);
2735 assertEqualInt (status, Ok);
2736
2737 status = GdipGetClip (graphics, region);
2738 assertEqualInt (status, Ok);
2739
2740 status = GdipGetRegionScansCount (region, &scansCount, matrix);
2741 assertEqualInt (status, Ok);
2742 assertEqualInt (scansCount, 1);
2743
2744 status = GdipGetClipBounds (graphics, &bounds);
2745 assertEqualInt (status, Ok);
2746 assertEqualFloat (bounds.X, 10);
2747 assertEqualFloat (bounds.Y, -20);
2748 assertEqualFloat (bounds.Width, 30);
2749 assertEqualFloat (bounds.Height, 40);
2750
2751 // Zero width, positive height.
2752 status = GdipSetClipRect (graphics, 10, 20, 0, 40, CombineModeReplace);
2753 assertEqualInt (status, Ok);
2754
2755 status = GdipGetClip (graphics, region);
2756 assertEqualInt (status, Ok);
2757
2758 status = GdipGetRegionScansCount (region, &scansCount, matrix);
2759 assertEqualInt (status, Ok);
2760 assertEqualInt (scansCount, 0);
2761
2762 status = GdipGetClipBounds (graphics, &bounds);
2763 assertEqualInt (status, Ok);
2764 assertEqualFloat (bounds.X, 0);
2765 assertEqualFloat (bounds.Y, 0);
2766 assertEqualFloat (bounds.Width, 0);
2767 assertEqualFloat (bounds.Height, 0);
2768
2769 // Zero width, zero height.
2770 status = GdipSetClipRect (graphics, 10, 20, 0, 0, CombineModeReplace);
2771 assertEqualInt (status, Ok);
2772
2773 status = GdipGetClip (graphics, region);
2774 assertEqualInt (status, Ok);
2775
2776 status = GdipGetRegionScansCount (region, &scansCount, matrix);
2777 assertEqualInt (status, Ok);
2778 assertEqualInt (scansCount, 0);
2779
2780 status = GdipGetClipBounds (graphics, &bounds);
2781 assertEqualInt (status, Ok);
2782 assertEqualFloat (bounds.X, 0);
2783 assertEqualFloat (bounds.Y, 0);
2784 assertEqualFloat (bounds.Width, 0);
2785 assertEqualFloat (bounds.Height, 0);
2786
2787 // Zero width, negative height.
2788 status = GdipSetClipRect (graphics, 10, 20, 0, -40, CombineModeReplace);
2789 assertEqualInt (status, Ok);
2790
2791 status = GdipGetClip (graphics, region);
2792 assertEqualInt (status, Ok);
2793
2794 status = GdipGetRegionScansCount (region, &scansCount, matrix);
2795 assertEqualInt (status, Ok);
2796 assertEqualInt (scansCount, 0);
2797
2798 status = GdipGetClipBounds (graphics, &bounds);
2799 assertEqualInt (status, Ok);
2800 assertEqualFloat (bounds.X, 0);
2801 assertEqualFloat (bounds.Y, 0);
2802 assertEqualFloat (bounds.Width, 0);
2803 assertEqualFloat (bounds.Height, 0);
2804
2805 // Negative width, positive height.
2806 status = GdipSetClipRect (graphics, 10, 20, -30, 40, CombineModeReplace);
2807 assertEqualInt (status, Ok);
2808
2809 status = GdipGetClip (graphics, region);
2810 assertEqualInt (status, Ok);
2811
2812 status = GdipGetRegionScansCount (region, &scansCount, matrix);
2813 assertEqualInt (status, Ok);
2814 assertEqualInt (scansCount, 1);
2815
2816 status = GdipGetClipBounds (graphics, &bounds);
2817 assertEqualInt (status, Ok);
2818 assertEqualFloat (bounds.X, -20);
2819 assertEqualFloat (bounds.Y, 20);
2820 assertEqualFloat (bounds.Width, 30);
2821 assertEqualFloat (bounds.Height, 40);
2822
2823 // Negative width, zero height.
2824 status = GdipSetClipRect (graphics, 10, 20, -30, 0, CombineModeReplace);
2825 assertEqualInt (status, Ok);
2826
2827 status = GdipGetClip (graphics, region);
2828 assertEqualInt (status, Ok);
2829
2830 status = GdipGetRegionScansCount (region, &scansCount, matrix);
2831 assertEqualInt (status, Ok);
2832 assertEqualInt (scansCount, 0);
2833
2834 status = GdipGetClipBounds (graphics, &bounds);
2835 assertEqualInt (status, Ok);
2836 assertEqualFloat (bounds.X, 0);
2837 assertEqualFloat (bounds.Y, 0);
2838 assertEqualFloat (bounds.Width, 0);
2839 assertEqualFloat (bounds.Height, 0);
2840
2841 // Negative width, negative height.
2842 status = GdipSetClipRect (graphics, 10, 20, -30, -40, CombineModeReplace);
2843 assertEqualInt (status, Ok);
2844
2845 status = GdipGetClip (graphics, region);
2846 assertEqualInt (status, Ok);
2847
2848 status = GdipGetRegionScansCount (region, &scansCount, matrix);
2849 assertEqualInt (status, Ok);
2850 assertEqualInt (scansCount, 1);
2851
2852 status = GdipGetClipBounds (graphics, &bounds);
2853 assertEqualInt (status, Ok);
2854 assertEqualFloat (bounds.X, -20);
2855 assertEqualFloat (bounds.Y, -20);
2856 assertEqualFloat (bounds.Width, 30);
2857 assertEqualFloat (bounds.Height, 40);
2858
2859 // Target graphics transformed.
2860 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
2861
2862 status = GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2863 assertEqualInt (status, Ok);
2864
2865 status = GdipGetClipBounds (graphics, &bounds);
2866 assertEqualInt (status, Ok);
2867 assertEqualFloat (bounds.X, 10);
2868 assertEqualFloat (bounds.Y, 20);
2869 assertEqualFloat (bounds.Width, 30);
2870 assertEqualFloat (bounds.Height, 40);
2871
2872 // Negative tests.
2873 status = GdipSetClipRect (NULL, 10, 20, 30, 40, CombineModeReplace);
2874 assertEqualInt (status, InvalidParameter);
2875
2876 status = GdipSetClipRect (graphics, 10, 20, 30, 40, (CombineMode) (CombineModeComplement + 1));
2877 assertEqualInt (status, InvalidParameter);
2878
2879 HDC hdc;
2880 status = GdipGetDC (graphics, &hdc);
2881
2882 status = GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
2883 assertEqualInt (status, ObjectBusy);
2884
2885 status = GdipSetClipRect (graphics, 10, 20, 30, 40, (CombineMode) (CombineModeComplement + 1));
2886 assertEqualInt (status, ObjectBusy);
2887
2888 GdipReleaseDC (graphics, hdc);
2889
2890 GdipDeleteGraphics (graphics);
2891 GdipDisposeImage (image);
2892 GdipDeleteRegion (region);
2893 GdipDeleteMatrix (matrix);
2894 }
2895
test_setClipRectI()2896 static void test_setClipRectI ()
2897 {
2898 GpStatus status;
2899 GpImage *image;
2900 GpGraphics *graphics;
2901 GpRectF bounds;
2902 UINT scansCount;
2903 GpRegion *region;
2904 GpMatrix *matrix;
2905
2906 graphics = getImageGraphics (&image);
2907 GdipCreateRegion (®ion);
2908 GdipCreateMatrix (&matrix);
2909
2910 // Positive width, positive height.
2911 status = GdipSetClipRectI (graphics, 10, 20, 30, 40, CombineModeReplace);
2912 assertEqualInt (status, Ok);
2913
2914 status = GdipGetClipBounds (graphics, &bounds);
2915 assertEqualInt (status, Ok);
2916 assertEqualFloat (bounds.X, 10);
2917 assertEqualFloat (bounds.Y, 20);
2918 assertEqualFloat (bounds.Width, 30);
2919 assertEqualFloat (bounds.Height, 40);
2920
2921 // Positive width, zero height.
2922 status = GdipSetClipRectI (graphics, 10, 20, 30, 0, CombineModeReplace);
2923 assertEqualInt (status, Ok);
2924
2925 status = GdipGetClip (graphics, region);
2926 assertEqualInt (status, Ok);
2927
2928 status = GdipGetRegionScansCount (region, &scansCount, matrix);
2929 assertEqualInt (status, Ok);
2930 assertEqualInt (scansCount, 0);
2931
2932 status = GdipGetClipBounds (graphics, &bounds);
2933 assertEqualInt (status, Ok);
2934 assertEqualFloat (bounds.X, 0);
2935 assertEqualFloat (bounds.Y, 0);
2936 assertEqualFloat (bounds.Width, 0);
2937 assertEqualFloat (bounds.Height, 0);
2938
2939 // Positive width, negative height.
2940 status = GdipSetClipRectI (graphics, 10, 20, 30, -40, CombineModeReplace);
2941 assertEqualInt (status, Ok);
2942
2943 status = GdipGetClip (graphics, region);
2944 assertEqualInt (status, Ok);
2945
2946 status = GdipGetRegionScansCount (region, &scansCount, matrix);
2947 assertEqualInt (status, Ok);
2948 assertEqualInt (scansCount, 1);
2949
2950 status = GdipGetClipBounds (graphics, &bounds);
2951 assertEqualInt (status, Ok);
2952 assertEqualFloat (bounds.X, 10);
2953 assertEqualFloat (bounds.Y, -20);
2954 assertEqualFloat (bounds.Width, 30);
2955 assertEqualFloat (bounds.Height, 40);
2956
2957 // Zero width, positive height.
2958 status = GdipSetClipRectI (graphics, 10, 20, 0, 40, CombineModeReplace);
2959 assertEqualInt (status, Ok);
2960
2961 status = GdipGetClip (graphics, region);
2962 assertEqualInt (status, Ok);
2963
2964 status = GdipGetRegionScansCount (region, &scansCount, matrix);
2965 assertEqualInt (status, Ok);
2966 assertEqualInt (scansCount, 0);
2967
2968 status = GdipGetClipBounds (graphics, &bounds);
2969 assertEqualInt (status, Ok);
2970 assertEqualFloat (bounds.X, 0);
2971 assertEqualFloat (bounds.Y, 0);
2972 assertEqualFloat (bounds.Width, 0);
2973 assertEqualFloat (bounds.Height, 0);
2974
2975 // Zero width, zero height.
2976 status = GdipSetClipRectI (graphics, 10, 20, 0, 0, CombineModeReplace);
2977 assertEqualInt (status, Ok);
2978
2979 status = GdipGetClip (graphics, region);
2980 assertEqualInt (status, Ok);
2981
2982 status = GdipGetRegionScansCount (region, &scansCount, matrix);
2983 assertEqualInt (status, Ok);
2984 assertEqualInt (scansCount, 0);
2985
2986 status = GdipGetClipBounds (graphics, &bounds);
2987 assertEqualInt (status, Ok);
2988 assertEqualFloat (bounds.X, 0);
2989 assertEqualFloat (bounds.Y, 0);
2990 assertEqualFloat (bounds.Width, 0);
2991 assertEqualFloat (bounds.Height, 0);
2992
2993 // Zero width, negative height.
2994 status = GdipSetClipRectI (graphics, 10, 20, 0, -40, CombineModeReplace);
2995 assertEqualInt (status, Ok);
2996
2997 status = GdipGetClip (graphics, region);
2998 assertEqualInt (status, Ok);
2999
3000 status = GdipGetRegionScansCount (region, &scansCount, matrix);
3001 assertEqualInt (status, Ok);
3002 assertEqualInt (scansCount, 0);
3003
3004 status = GdipGetClipBounds (graphics, &bounds);
3005 assertEqualInt (status, Ok);
3006 assertEqualFloat (bounds.X, 0);
3007 assertEqualFloat (bounds.Y, 0);
3008 assertEqualFloat (bounds.Width, 0);
3009 assertEqualFloat (bounds.Height, 0);
3010
3011 // Negative width, positive height.
3012 status = GdipSetClipRectI (graphics, 10, 20, -30, 40, CombineModeReplace);
3013 assertEqualInt (status, Ok);
3014
3015 status = GdipGetClip (graphics, region);
3016 assertEqualInt (status, Ok);
3017
3018 status = GdipGetRegionScansCount (region, &scansCount, matrix);
3019 assertEqualInt (status, Ok);
3020 assertEqualInt (scansCount, 1);
3021
3022 status = GdipGetClipBounds (graphics, &bounds);
3023 assertEqualInt (status, Ok);
3024 assertEqualFloat (bounds.X, -20);
3025 assertEqualFloat (bounds.Y, 20);
3026 assertEqualFloat (bounds.Width, 30);
3027 assertEqualFloat (bounds.Height, 40);
3028
3029 // Negative width, zero height.
3030 status = GdipSetClipRectI (graphics, 10, 20, -30, 0, CombineModeReplace);
3031 assertEqualInt (status, Ok);
3032
3033 status = GdipGetClip (graphics, region);
3034 assertEqualInt (status, Ok);
3035
3036 status = GdipGetRegionScansCount (region, &scansCount, matrix);
3037 assertEqualInt (status, Ok);
3038 assertEqualInt (scansCount, 0);
3039
3040 status = GdipGetClipBounds (graphics, &bounds);
3041 assertEqualInt (status, Ok);
3042 assertEqualFloat (bounds.X, 0);
3043 assertEqualFloat (bounds.Y, 0);
3044 assertEqualFloat (bounds.Width, 0);
3045 assertEqualFloat (bounds.Height, 0);
3046
3047 // Negative width, negative height.
3048 status = GdipSetClipRectI (graphics, 10, 20, -30, -40, CombineModeReplace);
3049 assertEqualInt (status, Ok);
3050
3051 status = GdipGetClip (graphics, region);
3052 assertEqualInt (status, Ok);
3053
3054 status = GdipGetRegionScansCount (region, &scansCount, matrix);
3055 assertEqualInt (status, Ok);
3056 assertEqualInt (scansCount, 1);
3057
3058 status = GdipGetClipBounds (graphics, &bounds);
3059 assertEqualInt (status, Ok);
3060 assertEqualFloat (bounds.X, -20);
3061 assertEqualFloat (bounds.Y, -20);
3062 assertEqualFloat (bounds.Width, 30);
3063 assertEqualFloat (bounds.Height, 40);
3064
3065 // Target graphics transformed.
3066 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
3067
3068 status = GdipSetClipRectI (graphics, 10, 20, 30, 40, CombineModeReplace);
3069 assertEqualInt (status, Ok);
3070
3071 status = GdipGetClipBounds (graphics, &bounds);
3072 assertEqualInt (status, Ok);
3073 assertEqualFloat (bounds.X, 10);
3074 assertEqualFloat (bounds.Y, 20);
3075 assertEqualFloat (bounds.Width, 30);
3076 assertEqualFloat (bounds.Height, 40);
3077
3078 // Negative tests.
3079 status = GdipSetClipRectI (NULL, 10, 20, 30, 40, CombineModeReplace);
3080 assertEqualInt (status, InvalidParameter);
3081
3082 status = GdipSetClipRectI (graphics, 10, 20, 30, 40, (CombineMode) (CombineModeComplement + 1));
3083 assertEqualInt (status, InvalidParameter);
3084
3085 HDC hdc;
3086 status = GdipGetDC (graphics, &hdc);
3087
3088 status = GdipSetClipRectI (graphics, 10, 20, 30, 40, CombineModeReplace);
3089 assertEqualInt (status, ObjectBusy);
3090
3091 status = GdipSetClipRectI (graphics, 10, 20, 30, 40, (CombineMode) (CombineModeComplement + 1));
3092 assertEqualInt (status, ObjectBusy);
3093
3094 GdipReleaseDC (graphics, hdc);
3095
3096 GdipDeleteGraphics (graphics);
3097 GdipDisposeImage (image);
3098 GdipDeleteRegion (region);
3099 GdipDeleteMatrix (matrix);
3100 }
3101
test_setClipRegion()3102 static void test_setClipRegion ()
3103 {
3104 GpStatus status;
3105 GpImage *image;
3106 GpRegion *region;
3107 GpGraphics *graphics;
3108 GpRectF bounds;
3109
3110 graphics = getImageGraphics (&image);
3111 GpRectF rect = {10, 20, 30, 40};
3112 GdipCreateRegionRect (&rect, ®ion);
3113
3114 // No transform.
3115 status = GdipSetClipRegion (graphics, region, CombineModeReplace);
3116 assertEqualInt (status, Ok);
3117
3118 status = GdipGetClipBounds (graphics, &bounds);
3119 assertEqualInt (status, Ok);
3120 assertEqualFloat (bounds.X, 10);
3121 assertEqualFloat (bounds.Y, 20);
3122 assertEqualFloat (bounds.Width, 30);
3123 assertEqualFloat (bounds.Height, 40);
3124
3125 // Target graphics transformed.
3126 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
3127
3128 status = GdipSetClipRegion (graphics, region, CombineModeReplace);
3129 assertEqualInt (status, Ok);
3130
3131 status = GdipGetClipBounds (graphics, &bounds);
3132 assertEqualInt (status, Ok);
3133 assertEqualFloat (bounds.X, 10);
3134 assertEqualFloat (bounds.Y, 20);
3135 assertEqualFloat (bounds.Width, 30);
3136 assertEqualFloat (bounds.Height, 40);
3137
3138 // Negative tests.
3139 status = GdipSetClipRegion (NULL, region, CombineModeReplace);
3140 assertEqualInt (status, InvalidParameter);
3141
3142 status = GdipSetClipRegion (graphics, NULL, CombineModeReplace);
3143 assertEqualInt (status, InvalidParameter);
3144
3145 status = GdipSetClipRegion (graphics, region, (CombineMode) (CombineModeComplement + 1));
3146 assertEqualInt (status, InvalidParameter);
3147
3148 HDC hdc;
3149 status = GdipGetDC (graphics, &hdc);
3150
3151 status = GdipSetClipRegion (graphics, region, CombineModeReplace);
3152 assertEqualInt (status, ObjectBusy);
3153
3154 status = GdipSetClipRegion (graphics, NULL, CombineModeReplace);
3155 assertEqualInt (status, ObjectBusy);
3156
3157 status = GdipSetClipRegion (graphics, region, (CombineMode) (CombineModeComplement + 1));
3158 assertEqualInt (status, ObjectBusy);
3159
3160 GdipReleaseDC (graphics, hdc);
3161
3162 GdipDeleteGraphics (graphics);
3163 GdipDeleteRegion (region);
3164 GdipDisposeImage (image);
3165 }
3166
test_setClipPath()3167 static void test_setClipPath ()
3168 {
3169 GpStatus status;
3170 GpImage *image;
3171 GpGraphics *graphics;
3172 GpRectF bounds;
3173 GpPath *path;
3174
3175 graphics = getImageGraphics (&image);
3176 GdipCreatePath (FillModeAlternate, &path);
3177 GdipAddPathRectangle (path, 10, 20, 30, 40);
3178
3179 // No transform.
3180 status = GdipSetClipPath (graphics, path, CombineModeReplace);
3181 assertEqualInt (status, Ok);
3182
3183 status = GdipGetClipBounds (graphics, &bounds);
3184 assertEqualInt (status, Ok);
3185 assertEqualFloat (bounds.X, 10);
3186 assertEqualFloat (bounds.Y, 20);
3187 assertEqualFloat (bounds.Width, 30);
3188 assertEqualFloat (bounds.Height, 40);
3189
3190 // Target graphics transformed.
3191 GdipTranslateWorldTransform (graphics, -10, -20, MatrixOrderAppend);
3192
3193 status = GdipSetClipPath (graphics, path, CombineModeReplace);
3194 assertEqualInt (status, Ok);
3195
3196 status = GdipGetClipBounds (graphics, &bounds);
3197 assertEqualInt (status, Ok);
3198 assertEqualFloat (bounds.X, 10);
3199 assertEqualFloat (bounds.Y, 20);
3200 assertEqualFloat (bounds.Width, 30);
3201 assertEqualFloat (bounds.Height, 40);
3202
3203 // Negative tests.
3204 status = GdipSetClipPath (NULL, path, CombineModeReplace);
3205 assertEqualInt (status, InvalidParameter);
3206
3207 status = GdipSetClipPath (graphics, NULL, CombineModeReplace);
3208 assertEqualInt (status, InvalidParameter);
3209
3210 status = GdipSetClipPath (graphics, path, (CombineMode) (CombineModeComplement + 1));
3211 assertEqualInt (status, InvalidParameter);
3212
3213 HDC hdc;
3214 status = GdipGetDC (graphics, &hdc);
3215
3216 status = GdipSetClipPath (graphics, path, CombineModeReplace);
3217 assertEqualInt (status, ObjectBusy);
3218
3219 status = GdipSetClipPath (graphics, NULL, CombineModeReplace);
3220 assertEqualInt (status, ObjectBusy);
3221
3222 status = GdipSetClipPath (graphics, path, (CombineMode) (CombineModeComplement + 1));
3223 assertEqualInt (status, ObjectBusy);
3224
3225 GdipReleaseDC (graphics, hdc);
3226
3227 GdipDeleteGraphics (graphics);
3228 GdipDisposeImage (image);
3229 GdipDeletePath (path);
3230 }
3231
test_translateClip()3232 static void test_translateClip ()
3233 {
3234 GpStatus status;
3235 GpImage *image;
3236 GpGraphics *graphics;
3237 GpRectF bounds;
3238
3239 graphics = getImageGraphics (&image);
3240
3241 // Non-infinite.
3242 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
3243
3244 status = GdipTranslateClip (graphics, 0, 0);
3245 assertEqualInt (status, Ok);
3246
3247 status = GdipGetClipBounds (graphics, &bounds);
3248 assertEqualInt (status, Ok);
3249 assertEqualFloat (bounds.X, 10);
3250 assertEqualFloat (bounds.Y, 20);
3251 assertEqualFloat (bounds.Width, 30);
3252 assertEqualFloat (bounds.Height, 40);
3253
3254 // Negative.
3255 status = GdipTranslateClip (graphics, -10, -20);
3256 assertEqualInt (status, Ok);
3257
3258 status = GdipGetClipBounds (graphics, &bounds);
3259 assertEqualInt (status, Ok);
3260 assertEqualFloat (bounds.X, 0);
3261 assertEqualFloat (bounds.Y, 0);
3262 assertEqualFloat (bounds.Width, 30);
3263 assertEqualFloat (bounds.Height, 40);
3264
3265 // Positive.
3266 status = GdipTranslateClip (graphics, 10, 20);
3267 assertEqualInt (status, Ok);
3268
3269 status = GdipGetClipBounds (graphics, &bounds);
3270 assertEqualInt (status, Ok);
3271 assertEqualFloat (bounds.X, 10);
3272 assertEqualFloat (bounds.Y, 20);
3273 assertEqualFloat (bounds.Width, 30);
3274 assertEqualFloat (bounds.Height, 40);
3275
3276 // Negative tests.
3277 status = GdipTranslateClip (NULL, 10, 20);
3278 assertEqualInt (status, InvalidParameter);
3279
3280 HDC hdc;
3281 status = GdipGetDC (graphics, &hdc);
3282
3283 status = GdipTranslateClip (graphics, 10, 20);
3284 assertEqualInt (status, ObjectBusy);
3285
3286 GdipReleaseDC (graphics, hdc);
3287
3288 GdipDeleteGraphics (graphics);
3289 GdipDisposeImage (image);
3290 }
3291
test_translateClipI()3292 static void test_translateClipI ()
3293 {
3294 GpStatus status;
3295 GpImage *image;
3296 GpGraphics *graphics;
3297 GpRectF bounds;
3298
3299 graphics = getImageGraphics (&image);
3300
3301 // Non-infinite.
3302 GdipSetClipRect (graphics, 10, 20, 30, 40, CombineModeReplace);
3303
3304 status = GdipTranslateClipI (graphics, 0, 0);
3305 assertEqualInt (status, Ok);
3306
3307 status = GdipGetClipBounds (graphics, &bounds);
3308 assertEqualInt (status, Ok);
3309 assertEqualFloat (bounds.X, 10);
3310 assertEqualFloat (bounds.Y, 20);
3311 assertEqualFloat (bounds.Width, 30);
3312 assertEqualFloat (bounds.Height, 40);
3313
3314 // Negative.
3315 status = GdipTranslateClipI (graphics, -10, -20);
3316 assertEqualInt (status, Ok);
3317
3318 status = GdipGetClipBounds (graphics, &bounds);
3319 assertEqualInt (status, Ok);
3320 assertEqualFloat (bounds.X, 0);
3321 assertEqualFloat (bounds.Y, 0);
3322 assertEqualFloat (bounds.Width, 30);
3323 assertEqualFloat (bounds.Height, 40);
3324
3325 // Positive.
3326 status = GdipTranslateClipI (graphics, 10, 20);
3327 assertEqualInt (status, Ok);
3328
3329 status = GdipGetClipBounds (graphics, &bounds);
3330 assertEqualInt (status, Ok);
3331 assertEqualFloat (bounds.X, 10);
3332 assertEqualFloat (bounds.Y, 20);
3333 assertEqualFloat (bounds.Width, 30);
3334 assertEqualFloat (bounds.Height, 40);
3335
3336 // Negative tests.
3337 status = GdipTranslateClipI (NULL, 10, 20);
3338 assertEqualInt (status, InvalidParameter);
3339
3340 HDC hdc;
3341 status = GdipGetDC (graphics, &hdc);
3342
3343 status = GdipTranslateClipI (graphics, 10, 20);
3344 assertEqualInt (status, ObjectBusy);
3345
3346 GdipReleaseDC (graphics, hdc);
3347
3348 GdipDeleteGraphics (graphics);
3349 GdipDisposeImage (image);
3350 }
3351
test_region_mask()3352 static void test_region_mask()
3353 {
3354 ARGB color;
3355 GpStatus status;
3356 GpBitmap* bitmap = NULL;
3357 GpGraphics* graphics = NULL;
3358 GpPath* rectPath = NULL;
3359 GpPath* polyPath = NULL;
3360 GpRegion* region = NULL;
3361 GpSolidFill* brush = NULL;
3362 static GpPoint polyPoints[] = { { 100, 100 }, { 200, 75 }, { 300, 100 }, { 325, 200 }, { 300, 300 }, { 200, 325 }, { 100, 300 }, { 75, 200 } };
3363
3364 status = GdipCreateBitmapFromScan0 (400, 400, 0, PixelFormat32bppARGB, NULL, &bitmap);
3365 assertEqualInt (status, Ok);
3366 status = GdipGetImageGraphicsContext (bitmap, &graphics);
3367 assertEqualInt (status, Ok);
3368 GdipGraphicsClear (graphics, 0xFF808080);
3369
3370 status = GdipCreatePath (FillModeAlternate, &rectPath);
3371 assertEqualInt (status, Ok);
3372 GdipAddPathRectangleI (rectPath, 50, 50, 300, 300);
3373
3374 status = GdipCreatePath (FillModeAlternate, &polyPath);
3375 assertEqualInt (status, Ok);
3376 GdipAddPathPolygonI (polyPath, polyPoints, sizeof(polyPoints) / sizeof(polyPoints[0]));
3377
3378 status = GdipCreateRegion (®ion);
3379 assertEqualInt (status, Ok);
3380 GdipSetEmpty (region);
3381 GdipCombineRegionPath (region, rectPath, CombineModeUnion);
3382 GdipCombineRegionPath (region, polyPath, CombineModeExclude);
3383
3384 status = GdipCreateSolidFill (0xFF00FF00, &brush);
3385 assertEqualInt (status, Ok);
3386
3387 GdipFillRegion (graphics, brush, region);
3388
3389 status = GdipBitmapGetPixel (bitmap, 0, 0, &color);
3390 assertEqualInt(status, Ok);
3391 assertEqualInt(color, 0xFF808080);
3392 status = GdipBitmapGetPixel (bitmap, 50, 50, &color);
3393 assertEqualInt(status, Ok);
3394 assertEqualInt(color, 0xFF00FF00);
3395 status = GdipBitmapGetPixel (bitmap, 200, 200, &color);
3396 assertEqualInt(status, Ok);
3397 assertEqualInt(color, 0xFF808080);
3398
3399 //GdipSaveImageToFile (bitmap, (const WCHAR*)createWchar( "test-image.png" ), &png_clsid, NULL);
3400
3401 GdipDeleteGraphics (graphics);
3402 GdipDeletePath (rectPath);
3403 GdipDeletePath (polyPath);
3404 GdipDeleteRegion (region);
3405 GdipDeleteBrush (brush);
3406 GdipDisposeImage (bitmap);
3407 }
3408
test_premultiplication()3409 static void test_premultiplication ()
3410 {
3411 GpStatus status;
3412 GpBitmap *bitmap;
3413 GpBitmap *bitmapBackground;
3414 GpGraphics *graphicsBackground;
3415
3416 BYTE bpp32ArgbData[] = { 0xFF, 0xFF, 0xFF, 0x80 };
3417 ARGB bpp32ArgbPixels[] = { 0x80FFFFFF };
3418 ARGB bpp32RgbPixelsPre[] = { 0xFF000000 };
3419 ARGB bpp32RgbPixels[] = { 0xFF808080 };
3420
3421 status = GdipCreateBitmapFromScan0 (1, 1, 4, PixelFormat32bppARGB, bpp32ArgbData, &bitmap);
3422 assertEqualInt (status, Ok);
3423 verifyBitmap (bitmap, memoryBmpRawFormat, PixelFormat32bppARGB, 1, 1, ImageFlagsHasAlpha, 0, TRUE);
3424 verifyPixels (bitmap, bpp32ArgbPixels);
3425 status = GdipCreateBitmapFromScan0 (1, 1, 4, PixelFormat32bppRGB, NULL, &bitmapBackground);
3426 assertEqualInt (status, Ok);
3427 status = GdipBitmapSetPixel (bitmapBackground, 0, 0, 0);
3428 assertEqualInt (status, Ok);
3429 verifyPixels (bitmapBackground, bpp32RgbPixelsPre);
3430 GdipGetImageGraphicsContext (bitmapBackground, &graphicsBackground);
3431 status = GdipDrawImage (graphicsBackground, (GpImage *)bitmap, 0, 0);
3432 assertEqualInt (status, Ok);
3433 GdipDeleteGraphics (graphicsBackground);
3434 verifyPixels (bitmapBackground, bpp32RgbPixels);
3435 GdipDisposeImage ((GpImage *) bitmapBackground);
3436 GdipDisposeImage ((GpImage *) bitmap);
3437 }
3438
test_world_transform_in_container()3439 static void test_world_transform_in_container ()
3440 {
3441 GpStatus status;
3442 GpImage *image;
3443 GpGraphics *graphics;
3444 GraphicsContainer state;
3445 GpMatrix *matrix;
3446 GpMatrix *setMatrix;
3447
3448 graphics = getImageGraphics (&image);
3449
3450 status = GdipCreateMatrix2 (0, 0, 0, 0, 0, 0, &matrix);
3451 assertEqualInt (status, Ok);
3452
3453 status = GdipCreateMatrix2 (2, 0, 0, 2, 10, 20, &setMatrix);
3454 assertEqualInt (status, Ok);
3455
3456 status = GdipSetWorldTransform (graphics, setMatrix);
3457 assertEqualInt (status, Ok);
3458
3459 status = GdipGetWorldTransform (graphics, matrix);
3460 assertEqualInt (status, Ok);
3461 BOOL result;
3462 GdipIsMatrixEqual (matrix, setMatrix, &result);
3463 assertEqualInt (result, 1);
3464
3465 status = GdipBeginContainer2 (graphics, &state);
3466 assertEqualInt (status, Ok);
3467
3468 status = GdipGetWorldTransform (graphics, matrix);
3469 assertEqualInt (status, Ok);
3470 GdipIsMatrixIdentity (matrix, &result);
3471 assertEqualInt (result, 1);
3472
3473 status = GdipSetWorldTransform (graphics, setMatrix);
3474 assertEqualInt (status, Ok);
3475
3476 status = GdipGetWorldTransform (graphics, matrix);
3477 assertEqualInt (status, Ok);
3478 GdipIsMatrixEqual (matrix, setMatrix, &result);
3479 assertEqualInt (result, 1);
3480
3481 status = GdipResetWorldTransform (graphics);
3482 assertEqualInt (status, Ok);
3483
3484 status = GdipGetWorldTransform (graphics, matrix);
3485 assertEqualInt (status, Ok);
3486 GdipIsMatrixIdentity (matrix, &result);
3487 assertEqualInt (result, 1);
3488
3489 status = GdipEndContainer (graphics, state);
3490 assertEqualInt (status, Ok);
3491
3492 status = GdipGetWorldTransform (graphics, matrix);
3493 assertEqualInt (status, Ok);
3494 GdipIsMatrixEqual (matrix, setMatrix, &result);
3495 assertEqualInt (result, 1);
3496
3497 GdipDeleteMatrix (matrix);
3498 GdipDeleteMatrix (setMatrix);
3499 GdipDisposeImage (image);
3500 GdipDeleteGraphics (graphics);
3501 }
3502
test_world_transform_respects_page_unit_document()3503 static void test_world_transform_respects_page_unit_document ()
3504 {
3505 GpStatus status;
3506 GpBitmap *bitmap;
3507 GpGraphics *graphics;
3508 GpMatrix *matrix;
3509 GpSolidFill *brush;
3510
3511 // Test Graphics with UnitDocument and 72 dpi
3512 status = GdipCreateBitmapFromScan0 (612, 792, 0, PixelFormat32bppARGB, NULL, &bitmap);
3513 assertEqualInt (status, Ok);
3514
3515 status = GdipBitmapSetResolution (bitmap, 72, 72);
3516 assertEqualInt (status, Ok);
3517
3518 status = GdipGetImageGraphicsContext (bitmap, &graphics);
3519 assertEqualInt (status, Ok);
3520
3521 status = GdipSetPageUnit (graphics, UnitDocument);
3522 assertEqualInt (status, Ok);
3523
3524 const ARGB FillColor = 0xFF000000;
3525 status = GdipCreateSolidFill (FillColor, &brush);
3526 assertEqualInt (status, Ok);
3527
3528 int rectX = 360;
3529 int rectY = 111;
3530 GdipCreateMatrix2 (1, 0, 0, 1, rectX, rectY, &matrix);
3531 status = GdipSetWorldTransform (graphics, matrix);
3532 assertEqualInt (status, Ok);
3533
3534 int rectWidth = 74;
3535 int rectHeight = 72;
3536 status = GdipFillRectangleI (graphics, brush, 0, 0, rectWidth, rectHeight);
3537 assertEqualInt (status, Ok);
3538
3539 //CLSID png_clsid = { 0x557cf406, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } };
3540 //WCHAR *filePath = createWchar ("test_world_transform_respects_page_unit_document.png");
3541 //status = GdipSaveImageToFile (bitmap, filePath, &png_clsid, NULL);
3542
3543 int points[] = {
3544 rectX + 2,
3545 rectY + 2,
3546 rectX + rectWidth / 2,
3547 rectY + rectHeight / 2,
3548 rectX + rectWidth - 1,
3549 rectY + rectHeight - 1
3550 };
3551 for (int i = 0; i < sizeof (points) / sizeof (points[0]); i += 2) {
3552 ARGB color;
3553 status = GdipBitmapGetPixel (bitmap, (int)(points[i] * 72 / 300.0f), (int)(points[i + 1] * 72 / 300.0f), &color);
3554 assertEqualInt (status, Ok);
3555 assertEqualInt (color, FillColor);
3556 }
3557
3558 GdipDisposeImage ((GpImage *)bitmap);
3559 GdipDeleteGraphics (graphics);
3560 GdipDeleteBrush (brush);
3561 }
3562
test_world_transform_respects_page_unit_point()3563 static void test_world_transform_respects_page_unit_point ()
3564 {
3565 GpStatus status;
3566 GpBitmap *bitmap;
3567 GpGraphics *graphics;
3568 GpSolidFill *brush;
3569 const float TargetResolution = 300;
3570 double scaleFactor = TargetResolution / 72;
3571
3572 // Test Graphics with UnitPoint and 72 dpi
3573 status = GdipCreateBitmapFromScan0 ((int)(612 * scaleFactor), (int)(792 * scaleFactor), 0, PixelFormat32bppARGB, NULL, &bitmap);
3574 assertEqualInt (status, Ok);
3575
3576 status = GdipBitmapSetResolution (bitmap, TargetResolution, TargetResolution);
3577 assertEqualInt (status, Ok);
3578
3579 status = GdipGetImageGraphicsContext (bitmap, &graphics);
3580 assertEqualInt (status, Ok);
3581
3582 status = GdipSetPageUnit (graphics, UnitPoint);
3583 assertEqualInt (status, Ok);
3584
3585 const ARGB FillColor = 0xFF000000;
3586 status = GdipCreateSolidFill (FillColor, &brush);
3587 assertEqualInt (status, Ok);
3588
3589 int rectX = 360;
3590 int rectY = 111;
3591 int rectWidth = 74;
3592 int rectHeight = 72;
3593 status = GdipTranslateWorldTransform (graphics, rectX, rectY, MatrixOrderPrepend);
3594 assertEqualInt (status, Ok);
3595
3596 status = GdipFillRectangleI (graphics, brush, 0, 0, rectWidth, rectHeight);
3597 assertEqualInt (status, Ok);
3598
3599 //CLSID png_clsid = { 0x557cf406, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } };
3600 //WCHAR *filePath = createWchar ("test_world_transform_respects_page_unit_point.png");
3601 //status = GdipSaveImageToFile (bitmap, filePath, &png_clsid, NULL);
3602
3603 int points[] = {
3604 rectX,
3605 rectY,
3606 rectX + rectWidth / 2,
3607 rectY + rectHeight / 2,
3608 rectX + rectWidth - 1,
3609 rectY + rectHeight - 1
3610 };
3611 for (int i = 0; i < sizeof (points) / sizeof (points[0]); i += 2) {
3612 ARGB color;
3613 status = GdipBitmapGetPixel (bitmap, points[i], points[i + 1], &color);
3614 assertEqualInt (status, Ok);
3615 assertEqualInt (color, 0);
3616
3617 status = GdipBitmapGetPixel (bitmap, (int)(points[i] * scaleFactor) + 1, (int)(points[i + 1] * scaleFactor) + 1, &color);
3618 assertEqualInt (status, Ok);
3619 assertEqualInt (color, FillColor);
3620 }
3621
3622 GdipDisposeImage ((GpImage *)bitmap);
3623 GdipDeleteGraphics (graphics);
3624 GdipDeleteBrush (brush);
3625 }
3626
3627 int
main(int argc,char ** argv)3628 main (int argc, char**argv)
3629 {
3630 STARTUP;
3631
3632 #if defined(USE_WINDOWS_GDIPLUS)
3633 WNDCLASS wc;
3634 HINSTANCE hInstance = GetModuleHandle (NULL);
3635
3636 wc.style = 0;
3637 wc.lpfnWndProc = WndProc;
3638 wc.cbClsExtra = 0;
3639 wc.cbWndExtra = 0;
3640 wc.hInstance = hInstance;
3641 wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
3642 wc.hCursor = LoadCursor(NULL, IDC_ARROW);
3643 wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
3644 wc.lpszMenuName = NULL;
3645 wc.lpszClassName = L"Window_Class";
3646
3647 RegisterClass (&wc);
3648 hwnd = CreateWindow (L"Window_Class", L"Window_Title", WS_OVERLAPPEDWINDOW, 20, 30, 500, 100, NULL, NULL, hInstance, NULL);
3649 #endif
3650
3651 test_createFromHDC ();
3652 test_createFromHDC2 ();
3653 test_createFromHWND ();
3654 test_createFromHWNDICM ();
3655 test_hdc ();
3656 test_compositingMode ();
3657 test_compositingQuality ();
3658 test_renderingOrigin ();
3659 test_textRenderingHint ();
3660 test_textContrast ();
3661 test_smoothingMode ();
3662 test_pixelOffsetMode ();
3663 test_interpolationMode ();
3664 test_transform ();
3665 test_pageUnit ();
3666 test_pageScale ();
3667 test_dpiX ();
3668 test_dpiY ();
3669 test_flush ();
3670 test_delete ();
3671 test_rotateWorldTransform ();
3672 test_resetClip ();
3673 test_getClip ();
3674 test_getClipBounds ();
3675 test_getClipBoundsI ();
3676 test_getVisibleClipBounds ();
3677 test_getVisibleClipBoundsI ();
3678 test_isClipEmpty ();
3679 test_isVisibleClipEmpty ();
3680 test_setClipGraphics ();
3681 test_setClipHrgn ();
3682 test_setClipRect ();
3683 test_setClipRectI ();
3684 test_setClipRegion ();
3685 test_setClipPath ();
3686 test_translateClip ();
3687 test_translateClipI ();
3688 test_region_mask ();
3689 test_premultiplication ();
3690 test_world_transform_in_container ();
3691 test_world_transform_respects_page_unit_document ();
3692 test_world_transform_respects_page_unit_point ();
3693
3694 #if defined(USE_WINDOWS_GDIPLUS)
3695 DestroyWindow (hwnd);
3696 #endif
3697
3698 SHUTDOWN;
3699 return 0;
3700 }
3701