projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[REACTOS]
[reactos.git] / rostests / winetests / gdiplus / region.c
1 /*
2 * Unit test suite for gdiplus regions
3 *
4 * Copyright (C) 2008 Huw Davies
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "windows.h"
22 #include "gdiplus.h"
23 #include "wingdi.h"
24 #include "wine/test.h"
25 #include <math.h>
26
27 #define RGNDATA_RECT 0x10000000
28 #define RGNDATA_PATH 0x10000001
29 #define RGNDATA_EMPTY_RECT 0x10000002
30 #define RGNDATA_INFINITE_RECT 0x10000003
31
32 #define RGNDATA_MAGIC 0xdbc01001
33 #define RGNDATA_MAGIC2 0xdbc01002
34
35 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
36
37 #define expectf_(expected, got, precision) ok(fabs(expected - got) < precision, "Expected %.2f, got %.2f\n", expected, got)
38 #define expectf(expected, got) expectf_(expected, got, 0.0001)
39
40 #define expect_magic(value) ok(*value == RGNDATA_MAGIC || *value == RGNDATA_MAGIC2, "Expected a known magic value, got %8x\n", *value)
41
42 #define expect_dword(value, expected) ok(*(value) == expected, "expected %08x got %08x\n", expected, *(value))
43
44 static inline void expect_float(DWORD *value, FLOAT expected)
45 {
46 FLOAT valuef = *(FLOAT*)value;
47 ok(valuef == expected, "expected %f got %f\n", expected, valuef);
48 }
49
50 /* We get shorts back, not INTs like a GpPoint */
51 typedef struct RegionDataPoint
52 {
53 short X, Y;
54 } RegionDataPoint;
55
56 static void verify_region(HRGN hrgn, const RECT *rc)
57 {
58 union
59 {
60 RGNDATA data;
61 char buf[sizeof(RGNDATAHEADER) + sizeof(RECT)];
62 } rgn;
63 const RECT *rect;
64 DWORD ret;
65
66 ret = GetRegionData(hrgn, 0, NULL);
67 if (IsRectEmpty(rc))
68 ok(ret == sizeof(rgn.data.rdh), "expected sizeof(rdh), got %u\n", ret);
69 else
70 ok(ret == sizeof(rgn.data.rdh) + sizeof(RECT), "expected sizeof(rgn), got %u\n", ret);
71
72 if (!ret) return;
73
74 ret = GetRegionData(hrgn, sizeof(rgn), &rgn.data);
75 if (IsRectEmpty(rc))
76 ok(ret == sizeof(rgn.data.rdh), "expected sizeof(rdh), got %u\n", ret);
77 else
78 ok(ret == sizeof(rgn.data.rdh) + sizeof(RECT), "expected sizeof(rgn), got %u\n", ret);
79
80 trace("size %u, type %u, count %u, rgn size %u, bound (%d,%d-%d,%d)\n",
81 rgn.data.rdh.dwSize, rgn.data.rdh.iType,
82 rgn.data.rdh.nCount, rgn.data.rdh.nRgnSize,
83 rgn.data.rdh.rcBound.left, rgn.data.rdh.rcBound.top,
84 rgn.data.rdh.rcBound.right, rgn.data.rdh.rcBound.bottom);
85 if (rgn.data.rdh.nCount != 0)
86 {
87 rect = (const RECT *)rgn.data.Buffer;
88 trace("rect (%d,%d-%d,%d)\n", rect->left, rect->top, rect->right, rect->bottom);
89 ok(EqualRect(rect, rc), "rects don't match\n");
90 }
91
92 ok(rgn.data.rdh.dwSize == sizeof(rgn.data.rdh), "expected sizeof(rdh), got %u\n", rgn.data.rdh.dwSize);
93 ok(rgn.data.rdh.iType == RDH_RECTANGLES, "expected RDH_RECTANGLES, got %u\n", rgn.data.rdh.iType);
94 if (IsRectEmpty(rc))
95 {
96 ok(rgn.data.rdh.nCount == 0, "expected 0, got %u\n", rgn.data.rdh.nCount);
97 ok(rgn.data.rdh.nRgnSize == 0, "expected 0, got %u\n", rgn.data.rdh.nRgnSize);
98 }
99 else
100 {
101 ok(rgn.data.rdh.nCount == 1, "expected 1, got %u\n", rgn.data.rdh.nCount);
102 ok(rgn.data.rdh.nRgnSize == sizeof(RECT), "expected sizeof(RECT), got %u\n", rgn.data.rdh.nRgnSize);
103 }
104 ok(EqualRect(&rgn.data.rdh.rcBound, rc), "rects don't match\n");
105 }
106
107 static void test_getregiondata(void)
108 {
109 GpStatus status;
110 GpRegion *region, *region2;
111 RegionDataPoint *point;
112 UINT needed;
113 DWORD buf[100];
114 GpRect rect;
115 GpPath *path;
116
117 memset(buf, 0xee, sizeof(buf));
118
119 status = GdipCreateRegion(&region);
120 ok(status == Ok, "status %08x\n", status);
121
122 status = GdipGetRegionDataSize(region, &needed);
123 ok(status == Ok, "status %08x\n", status);
124 expect(20, needed);
125 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
126 ok(status == Ok, "status %08x\n", status);
127 expect(20, needed);
128 expect_dword(buf, 12);
129 trace("buf[1] = %08x\n", buf[1]);
130 expect_magic((DWORD*)(buf + 2));
131 expect_dword(buf + 3, 0);
132 expect_dword(buf + 4, RGNDATA_INFINITE_RECT);
133
134 status = GdipSetEmpty(region);
135 ok(status == Ok, "status %08x\n", status);
136 status = GdipGetRegionDataSize(region, &needed);
137 ok(status == Ok, "status %08x\n", status);
138 expect(20, needed);
139 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
140 ok(status == Ok, "status %08x\n", status);
141 expect(20, needed);
142 expect_dword(buf, 12);
143 trace("buf[1] = %08x\n", buf[1]);
144 expect_magic((DWORD*)(buf + 2));
145 expect_dword(buf + 3, 0);
146 expect_dword(buf + 4, RGNDATA_EMPTY_RECT);
147
148 status = GdipSetInfinite(region);
149 ok(status == Ok, "status %08x\n", status);
150 status = GdipGetRegionDataSize(region, &needed);
151 ok(status == Ok, "status %08x\n", status);
152 expect(20, needed);
153 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
154 ok(status == Ok, "status %08x\n", status);
155 expect(20, needed);
156 expect_dword(buf, 12);
157 trace("buf[1] = %08x\n", buf[1]);
158 expect_magic((DWORD*)(buf + 2));
159 expect_dword(buf + 3, 0);
160 expect_dword(buf + 4, RGNDATA_INFINITE_RECT);
161
162 status = GdipDeleteRegion(region);
163 ok(status == Ok, "status %08x\n", status);
164
165 rect.X = 10;
166 rect.Y = 20;
167 rect.Width = 100;
168 rect.Height = 200;
169 status = GdipCreateRegionRectI(&rect, &region);
170 ok(status == Ok, "status %08x\n", status);
171 status = GdipGetRegionDataSize(region, &needed);
172 ok(status == Ok, "status %08x\n", status);
173 expect(36, needed);
174 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
175 ok(status == Ok, "status %08x\n", status);
176 expect(36, needed);
177 expect_dword(buf, 28);
178 trace("buf[1] = %08x\n", buf[1]);
179 expect_magic((DWORD*)(buf + 2));
180 expect_dword(buf + 3, 0);
181 expect_dword(buf + 4, RGNDATA_RECT);
182 expect_float(buf + 5, 10.0);
183 expect_float(buf + 6, 20.0);
184 expect_float(buf + 7, 100.0);
185 expect_float(buf + 8, 200.0);
186
187 rect.X = 50;
188 rect.Y = 30;
189 rect.Width = 10;
190 rect.Height = 20;
191 status = GdipCombineRegionRectI(region, &rect, CombineModeIntersect);
192 ok(status == Ok, "status %08x\n", status);
193 rect.X = 100;
194 rect.Y = 300;
195 rect.Width = 30;
196 rect.Height = 50;
197 status = GdipCombineRegionRectI(region, &rect, CombineModeXor);
198 ok(status == Ok, "status %08x\n", status);
199
200 rect.X = 200;
201 rect.Y = 100;
202 rect.Width = 133;
203 rect.Height = 266;
204 status = GdipCreateRegionRectI(&rect, &region2);
205 ok(status == Ok, "status %08x\n", status);
206 rect.X = 20;
207 rect.Y = 10;
208 rect.Width = 40;
209 rect.Height = 66;
210 status = GdipCombineRegionRectI(region2, &rect, CombineModeUnion);
211 ok(status == Ok, "status %08x\n", status);
212
213 status = GdipCombineRegionRegion(region, region2, CombineModeComplement);
214 ok(status == Ok, "status %08x\n", status);
215
216 rect.X = 400;
217 rect.Y = 500;
218 rect.Width = 22;
219 rect.Height = 55;
220 status = GdipCombineRegionRectI(region, &rect, CombineModeExclude);
221 ok(status == Ok, "status %08x\n", status);
222
223 status = GdipGetRegionDataSize(region, &needed);
224 ok(status == Ok, "status %08x\n", status);
225 expect(156, needed);
226 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
227 ok(status == Ok, "status %08x\n", status);
228 expect(156, needed);
229 expect_dword(buf, 148);
230 trace("buf[1] = %08x\n", buf[1]);
231 expect_magic((DWORD*)(buf + 2));
232 expect_dword(buf + 3, 10);
233 expect_dword(buf + 4, CombineModeExclude);
234 expect_dword(buf + 5, CombineModeComplement);
235 expect_dword(buf + 6, CombineModeXor);
236 expect_dword(buf + 7, CombineModeIntersect);
237 expect_dword(buf + 8, RGNDATA_RECT);
238 expect_float(buf + 9, 10.0);
239 expect_float(buf + 10, 20.0);
240 expect_float(buf + 11, 100.0);
241 expect_float(buf + 12, 200.0);
242 expect_dword(buf + 13, RGNDATA_RECT);
243 expect_float(buf + 14, 50.0);
244 expect_float(buf + 15, 30.0);
245 expect_float(buf + 16, 10.0);
246 expect_float(buf + 17, 20.0);
247 expect_dword(buf + 18, RGNDATA_RECT);
248 expect_float(buf + 19, 100.0);
249 expect_float(buf + 20, 300.0);
250 expect_float(buf + 21, 30.0);
251 expect_float(buf + 22, 50.0);
252 expect_dword(buf + 23, CombineModeUnion);
253 expect_dword(buf + 24, RGNDATA_RECT);
254 expect_float(buf + 25, 200.0);
255 expect_float(buf + 26, 100.0);
256 expect_float(buf + 27, 133.0);
257 expect_float(buf + 28, 266.0);
258 expect_dword(buf + 29, RGNDATA_RECT);
259 expect_float(buf + 30, 20.0);
260 expect_float(buf + 31, 10.0);
261 expect_float(buf + 32, 40.0);
262 expect_float(buf + 33, 66.0);
263 expect_dword(buf + 34, RGNDATA_RECT);
264 expect_float(buf + 35, 400.0);
265 expect_float(buf + 36, 500.0);
266 expect_float(buf + 37, 22.0);
267 expect_float(buf + 38, 55.0);
268
269 status = GdipDeleteRegion(region2);
270 ok(status == Ok, "status %08x\n", status);
271 status = GdipDeleteRegion(region);
272 ok(status == Ok, "status %08x\n", status);
273
274 /* Try some paths */
275
276 status = GdipCreatePath(FillModeAlternate, &path);
277 ok(status == Ok, "status %08x\n", status);
278 GdipAddPathRectangle(path, 12.5, 13.0, 14.0, 15.0);
279
280 status = GdipCreateRegionPath(path, &region);
281 ok(status == Ok, "status %08x\n", status);
282 status = GdipGetRegionDataSize(region, &needed);
283 ok(status == Ok, "status %08x\n", status);
284 expect(72, needed);
285 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
286 ok(status == Ok, "status %08x\n", status);
287 expect(72, needed);
288 expect_dword(buf, 64);
289 trace("buf[1] = %08x\n", buf[1]);
290 expect_magic((DWORD*)(buf + 2));
291 expect_dword(buf + 3, 0);
292 expect_dword(buf + 4, RGNDATA_PATH);
293 expect_dword(buf + 5, 0x00000030);
294 expect_magic((DWORD*)(buf + 6));
295 expect_dword(buf + 7, 0x00000004);
296 expect_dword(buf + 8, 0x00000000);
297 expect_float(buf + 9, 12.5);
298 expect_float(buf + 10, 13.0);
299 expect_float(buf + 11, 26.5);
300 expect_float(buf + 12, 13.0);
301 expect_float(buf + 13, 26.5);
302 expect_float(buf + 14, 28.0);
303 expect_float(buf + 15, 12.5);
304 expect_float(buf + 16, 28.0);
305 expect_dword(buf + 17, 0x81010100);
306
307
308 rect.X = 50;
309 rect.Y = 30;
310 rect.Width = 10;
311 rect.Height = 20;
312 status = GdipCombineRegionRectI(region, &rect, CombineModeIntersect);
313 ok(status == Ok, "status %08x\n", status);
314 status = GdipGetRegionDataSize(region, &needed);
315 ok(status == Ok, "status %08x\n", status);
316 expect(96, needed);
317 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
318 ok(status == Ok, "status %08x\n", status);
319 expect(96, needed);
320 expect_dword(buf, 88);
321 trace("buf[1] = %08x\n", buf[1]);
322 expect_magic((DWORD*)(buf + 2));
323 expect_dword(buf + 3, 2);
324 expect_dword(buf + 4, CombineModeIntersect);
325 expect_dword(buf + 5, RGNDATA_PATH);
326 expect_dword(buf + 6, 0x00000030);
327 expect_magic((DWORD*)(buf + 7));
328 expect_dword(buf + 8, 0x00000004);
329 expect_dword(buf + 9, 0x00000000);
330 expect_float(buf + 10, 12.5);
331 expect_float(buf + 11, 13.0);
332 expect_float(buf + 12, 26.5);
333 expect_float(buf + 13, 13.0);
334 expect_float(buf + 14, 26.5);
335 expect_float(buf + 15, 28.0);
336 expect_float(buf + 16, 12.5);
337 expect_float(buf + 17, 28.0);
338 expect_dword(buf + 18, 0x81010100);
339 expect_dword(buf + 19, RGNDATA_RECT);
340 expect_float(buf + 20, 50.0);
341 expect_float(buf + 21, 30.0);
342 expect_float(buf + 22, 10.0);
343 expect_float(buf + 23, 20.0);
344
345 status = GdipDeleteRegion(region);
346 ok(status == Ok, "status %08x\n", status);
347 status = GdipDeletePath(path);
348 ok(status == Ok, "status %08x\n", status);
349
350 /* Test an empty path */
351 status = GdipCreatePath(FillModeAlternate, &path);
352 expect(Ok, status);
353 status = GdipCreateRegionPath(path, &region);
354 expect(Ok, status);
355 status = GdipGetRegionDataSize(region, &needed);
356 expect(Ok, status);
357 expect(36, needed);
358 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
359 expect(Ok, status);
360 expect(36, needed);
361 expect_dword(buf, 28);
362 trace("buf[1] = %08x\n", buf[1]);
363 expect_magic((DWORD*)(buf + 2));
364 expect_dword(buf + 3, 0);
365 expect_dword(buf + 4, RGNDATA_PATH);
366
367 /* Second signature for pathdata */
368 expect_dword(buf + 5, 12);
369 expect_magic((DWORD*)(buf + 6));
370 expect_dword(buf + 7, 0);
371 /* flags 0x4000 means its a path of shorts instead of FLOAT */
372 ok((*(buf + 8) & (~ 0x00004000)) == 0x00000000,
373 "expected 00000000 got %08x\n", *(buf + 8) & (~ 0x00004000));
374
375 status = GdipDeleteRegion(region);
376 expect(Ok, status);
377
378 /* Test a simple triangle of INTs */
379 status = GdipAddPathLine(path, 5, 6, 7, 8);
380 expect(Ok, status);
381 status = GdipAddPathLine(path, 8, 1, 5, 6);
382 expect(Ok, status);
383 status = GdipClosePathFigure(path);
384 expect(Ok, status);
385 status = GdipCreateRegionPath(path, &region);
386 expect(Ok, status);
387 status = GdipGetRegionDataSize(region, &needed);
388 expect(Ok, status);
389 expect(56, needed);
390 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
391 expect(Ok, status);
392 expect(56, needed);
393 expect_dword(buf, 48);
394 trace("buf[1] = %08x\n", buf[1]);
395 expect_magic((DWORD*)(buf + 2));
396 expect_dword(buf + 3 , 0);
397 expect_dword(buf + 4 , RGNDATA_PATH);
398
399 expect_dword(buf + 5, 32);
400 expect_magic((DWORD*)(buf + 6));
401 expect_dword(buf + 7, 4);
402 expect_dword(buf + 8, 0x00004000); /* ?? */
403
404 point = (RegionDataPoint*)buf + 9;
405 expect(5, point[0].X);
406 expect(6, point[0].Y);
407 expect(7, point[1].X); /* buf + 10 */
408 expect(8, point[1].Y);
409 expect(8, point[2].X); /* buf + 11 */
410 expect(1, point[2].Y);
411 expect(5, point[3].X); /* buf + 12 */
412 expect(6, point[3].Y);
413 expect_dword(buf + 13, 0x81010100); /* 0x01010100 if we don't close the path */
414
415 status = GdipDeletePath(path);
416 expect(Ok, status);
417 status = GdipDeleteRegion(region);
418 expect(Ok, status);
419
420 /* Test a floating-point triangle */
421 status = GdipCreatePath(FillModeAlternate, &path);
422 expect(Ok, status);
423 status = GdipAddPathLine(path, 5.6, 6.2, 7.2, 8.9);
424 expect(Ok, status);
425 status = GdipAddPathLine(path, 8.1, 1.6, 5.6, 6.2);
426 expect(Ok, status);
427 status = GdipCreateRegionPath(path, &region);
428 expect(Ok, status);
429 status = GdipGetRegionDataSize(region, &needed);
430 expect(Ok, status);
431 expect(72, needed);
432 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
433 expect(Ok, status);
434 expect(72, needed);
435 expect_dword(buf, 64);
436 trace("buf[1] = %08x\n", buf[1]);
437 expect_magic((DWORD*)(buf + 2));
438 expect_dword(buf + 3, 0);
439 expect_dword(buf + 4, RGNDATA_PATH);
440
441 expect_dword(buf + 5, 48);
442 expect_magic((DWORD*)(buf + 6));
443 expect_dword(buf + 7, 4);
444 expect_dword(buf + 8, 0);
445 expect_float(buf + 9, 5.6);
446 expect_float(buf + 10, 6.2);
447 expect_float(buf + 11, 7.2);
448 expect_float(buf + 12, 8.9);
449 expect_float(buf + 13, 8.1);
450 expect_float(buf + 14, 1.6);
451 expect_float(buf + 15, 5.6);
452 expect_float(buf + 16, 6.2);
453
454 status = GdipDeletePath(path);
455 expect(Ok, status);
456 status = GdipDeleteRegion(region);
457 expect(Ok, status);
458
459 /* Test for a path with > 4 points, and CombineRegionPath */
460 GdipCreatePath(FillModeAlternate, &path);
461 status = GdipAddPathLine(path, 50, 70.2, 60, 102.8);
462 expect(Ok, status);
463 status = GdipAddPathLine(path, 55.4, 122.4, 40.4, 60.2);
464 expect(Ok, status);
465 status = GdipAddPathLine(path, 45.6, 20.2, 50, 70.2);
466 expect(Ok, status);
467 rect.X = 20;
468 rect.Y = 25;
469 rect.Width = 60;
470 rect.Height = 120;
471 status = GdipCreateRegionRectI(&rect, &region);
472 expect(Ok, status);
473 status = GdipCombineRegionPath(region, path, CombineModeUnion);
474 expect(Ok, status);
475
476 status = GdipGetRegionDataSize(region, &needed);
477 expect(Ok, status);
478 expect(116, needed);
479 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
480 expect(Ok, status);
481 expect(116, needed);
482 expect_dword(buf, 108);
483 trace("buf[1] = %08x\n", buf[1]);
484 expect_magic((DWORD*)(buf + 2));
485 expect_dword(buf + 3, 2);
486 expect_dword(buf + 4, CombineModeUnion);
487 expect_dword(buf + 5, RGNDATA_RECT);
488 expect_float(buf + 6, 20);
489 expect_float(buf + 7, 25);
490 expect_float(buf + 8, 60);
491 expect_float(buf + 9, 120);
492 expect_dword(buf + 10, RGNDATA_PATH);
493
494 expect_dword(buf + 11, 68);
495 expect_magic((DWORD*)(buf + 12));
496 expect_dword(buf + 13, 6);
497 expect_float(buf + 14, 0x0);
498
499 expect_float(buf + 15, 50);
500 expect_float(buf + 16, 70.2);
501 expect_float(buf + 17, 60);
502 expect_float(buf + 18, 102.8);
503 expect_float(buf + 19, 55.4);
504 expect_float(buf + 20, 122.4);
505 expect_float(buf + 21, 40.4);
506 expect_float(buf + 22, 60.2);
507 expect_float(buf + 23, 45.6);
508 expect_float(buf + 24, 20.2);
509 expect_float(buf + 25, 50);
510 expect_float(buf + 26, 70.2);
511 expect_dword(buf + 27, 0x01010100);
512 ok(*(buf + 28) == 0x00000101 || *(buf + 28) == 0x43050101 /* Win 7 */,
513 "expected 00000101 or 43050101 got %08x\n", *(buf + 28));
514
515 status = GdipDeletePath(path);
516 expect(Ok, status);
517 status = GdipDeleteRegion(region);
518 expect(Ok, status);
519 }
520
521 static void test_isinfinite(void)
522 {
523 GpStatus status;
524 GpRegion *region;
525 GpGraphics *graphics = NULL;
526 GpMatrix *m;
527 HDC hdc = GetDC(0);
528 BOOL res;
529
530 status = GdipCreateFromHDC(hdc, &graphics);
531 expect(Ok, status);
532 GdipCreateRegion(&region);
533
534 GdipCreateMatrix2(3.0, 0.0, 0.0, 1.0, 20.0, 30.0, &m);
535
536 /* NULL arguments */
537 status = GdipIsInfiniteRegion(NULL, NULL, NULL);
538 expect(InvalidParameter, status);
539 status = GdipIsInfiniteRegion(region, NULL, NULL);
540 expect(InvalidParameter, status);
541 status = GdipIsInfiniteRegion(NULL, graphics, NULL);
542 expect(InvalidParameter, status);
543 status = GdipIsInfiniteRegion(NULL, NULL, &res);
544 expect(InvalidParameter, status);
545 status = GdipIsInfiniteRegion(region, NULL, &res);
546 expect(InvalidParameter, status);
547
548 res = FALSE;
549 status = GdipIsInfiniteRegion(region, graphics, &res);
550 expect(Ok, status);
551 expect(TRUE, res);
552
553 /* after world transform */
554 status = GdipSetWorldTransform(graphics, m);
555 expect(Ok, status);
556
557 res = FALSE;
558 status = GdipIsInfiniteRegion(region, graphics, &res);
559 expect(Ok, status);
560 expect(TRUE, res);
561
562 GdipDeleteMatrix(m);
563 GdipDeleteRegion(region);
564 GdipDeleteGraphics(graphics);
565 ReleaseDC(0, hdc);
566 }
567
568 static void test_isempty(void)
569 {
570 GpStatus status;
571 GpRegion *region;
572 GpGraphics *graphics = NULL;
573 HDC hdc = GetDC(0);
574 BOOL res;
575
576 status = GdipCreateFromHDC(hdc, &graphics);
577 expect(Ok, status);
578 GdipCreateRegion(&region);
579
580 /* NULL arguments */
581 status = GdipIsEmptyRegion(NULL, NULL, NULL);
582 expect(InvalidParameter, status);
583 status = GdipIsEmptyRegion(region, NULL, NULL);
584 expect(InvalidParameter, status);
585 status = GdipIsEmptyRegion(NULL, graphics, NULL);
586 expect(InvalidParameter, status);
587 status = GdipIsEmptyRegion(NULL, NULL, &res);
588 expect(InvalidParameter, status);
589 status = GdipIsEmptyRegion(region, NULL, &res);
590 expect(InvalidParameter, status);
591
592 /* default is infinite */
593 res = TRUE;
594 status = GdipIsEmptyRegion(region, graphics, &res);
595 expect(Ok, status);
596 expect(FALSE, res);
597
598 status = GdipSetEmpty(region);
599 expect(Ok, status);
600
601 res = FALSE;
602 status = GdipIsEmptyRegion(region, graphics, &res);
603 expect(Ok, status);
604 expect(TRUE, res);
605
606 GdipDeleteRegion(region);
607 GdipDeleteGraphics(graphics);
608 ReleaseDC(0, hdc);
609 }
610
611 static void test_combinereplace(void)
612 {
613 GpStatus status;
614 GpRegion *region, *region2;
615 GpPath *path;
616 GpRectF rectf;
617 UINT needed;
618 DWORD buf[50];
619
620 rectf.X = rectf.Y = 0.0;
621 rectf.Width = rectf.Height = 100.0;
622
623 status = GdipCreateRegionRect(&rectf, &region);
624 expect(Ok, status);
625
626 /* replace with the same rectangle */
627 status = GdipCombineRegionRect(region, &rectf,CombineModeReplace);
628 expect(Ok, status);
629
630 status = GdipGetRegionDataSize(region, &needed);
631 expect(Ok, status);
632 expect(36, needed);
633 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
634 expect(Ok, status);
635 expect(36, needed);
636 expect_dword(buf, 28);
637 trace("buf[1] = %08x\n", buf[1]);
638 expect_magic((DWORD*)(buf + 2));
639 expect_dword(buf + 3, 0);
640 expect_dword(buf + 4, RGNDATA_RECT);
641
642 /* replace with path */
643 status = GdipCreatePath(FillModeAlternate, &path);
644 expect(Ok, status);
645 status = GdipAddPathEllipse(path, 0.0, 0.0, 100.0, 250.0);
646 expect(Ok, status);
647 status = GdipCombineRegionPath(region, path, CombineModeReplace);
648 expect(Ok, status);
649
650 status = GdipGetRegionDataSize(region, &needed);
651 expect(Ok, status);
652 expect(156, needed);
653 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
654 expect(Ok, status);
655 expect(156, needed);
656 expect_dword(buf, 148);
657 trace("buf[1] = %08x\n", buf[1]);
658 expect_magic((DWORD*)(buf + 2));
659 expect_dword(buf + 3, 0);
660 expect_dword(buf + 4, RGNDATA_PATH);
661 GdipDeletePath(path);
662
663 /* replace with infinite rect */
664 status = GdipCreateRegion(&region2);
665 expect(Ok, status);
666 status = GdipCombineRegionRegion(region, region2, CombineModeReplace);
667 expect(Ok, status);
668
669 status = GdipGetRegionDataSize(region, &needed);
670 expect(Ok, status);
671 expect(20, needed);
672 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
673 expect(Ok, status);
674 expect(20, needed);
675 expect_dword(buf, 12);
676 trace("buf[1] = %08x\n", buf[1]);
677 expect_magic((DWORD*)(buf + 2));
678 expect_dword(buf + 3, 0);
679 expect_dword(buf + 4, RGNDATA_INFINITE_RECT);
680 GdipDeleteRegion(region2);
681
682 /* more complex case : replace with a combined region */
683 status = GdipCreateRegionRect(&rectf, &region2);
684 expect(Ok, status);
685 status = GdipCreatePath(FillModeAlternate, &path);
686 expect(Ok, status);
687 status = GdipAddPathEllipse(path, 0.0, 0.0, 100.0, 250.0);
688 expect(Ok, status);
689 status = GdipCombineRegionPath(region2, path, CombineModeUnion);
690 expect(Ok, status);
691 GdipDeletePath(path);
692 status = GdipCombineRegionRegion(region, region2, CombineModeReplace);
693 expect(Ok, status);
694 GdipDeleteRegion(region2);
695
696 status = GdipGetRegionDataSize(region, &needed);
697 expect(Ok, status);
698 expect(180, needed);
699 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
700 expect(Ok, status);
701 expect(180, needed);
702 expect_dword(buf, 172);
703 trace("buf[1] = %08x\n", buf[1]);
704 expect_magic((DWORD*)(buf + 2));
705 expect_dword(buf + 3, 2);
706 expect_dword(buf + 4, CombineModeUnion);
707
708 GdipDeleteRegion(region);
709 }
710
711 static void test_fromhrgn(void)
712 {
713 GpStatus status;
714 GpRegion *region = (GpRegion*)0xabcdef01;
715 HRGN hrgn;
716 UINT needed;
717 DWORD buf[220];
718 RegionDataPoint *point;
719 GpGraphics *graphics = NULL;
720 HDC hdc;
721 BOOL res;
722
723 /* NULL */
724 status = GdipCreateRegionHrgn(NULL, NULL);
725 expect(InvalidParameter, status);
726 status = GdipCreateRegionHrgn(NULL, &region);
727 expect(InvalidParameter, status);
728 status = GdipCreateRegionHrgn((HRGN)0xdeadbeef, &region);
729 expect(InvalidParameter, status);
730 ok(region == (GpRegion*)0xabcdef01, "Expected region not to be created\n");
731
732 /* empty rectangle */
733 hrgn = CreateRectRgn(0, 0, 0, 0);
734 status = GdipCreateRegionHrgn(hrgn, &region);
735 expect(Ok, status);
736 if(status == Ok) {
737
738 hdc = GetDC(0);
739 status = GdipCreateFromHDC(hdc, &graphics);
740 expect(Ok, status);
741 res = FALSE;
742 status = GdipIsEmptyRegion(region, graphics, &res);
743 expect(Ok, status);
744 expect(TRUE, res);
745 GdipDeleteGraphics(graphics);
746 ReleaseDC(0, hdc);
747 GdipDeleteRegion(region);
748
749 }
750 DeleteObject(hrgn);
751
752 /* rectangle */
753 hrgn = CreateRectRgn(0, 0, 100, 10);
754 status = GdipCreateRegionHrgn(hrgn, &region);
755 expect(Ok, status);
756
757 status = GdipGetRegionDataSize(region, &needed);
758 expect(Ok, status);
759 expect(56, needed);
760
761 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
762 expect(Ok, status);
763
764 if(status == Ok){
765
766 expect(56, needed);
767 expect_dword(buf, 48);
768 expect_magic((DWORD*)(buf + 2));
769 expect_dword(buf + 3, 0);
770 expect_dword(buf + 4, RGNDATA_PATH);
771 expect_dword(buf + 5, 0x00000020);
772 expect_magic((DWORD*)(buf + 6));
773 expect_dword(buf + 7, 0x00000004);
774 todo_wine expect_dword(buf + 8, 0x00006000); /* ?? */
775
776 point = (RegionDataPoint*)buf + 9;
777
778 expect(0, point[0].X);
779 expect(0, point[0].Y);
780
781 expect(100,point[1].X); /* buf + 10 */
782 expect(0, point[1].Y);
783 expect(100,point[2].X); /* buf + 11 */
784 expect(10, point[2].Y);
785
786 expect(0, point[3].X); /* buf + 12 */
787
788 expect(10, point[3].Y);
789 expect_dword(buf + 13, 0x81010100); /* closed */
790
791 }
792
793 GdipDeleteRegion(region);
794 DeleteObject(hrgn);
795
796 /* ellipse */
797 hrgn = CreateEllipticRgn(0, 0, 100, 10);
798 status = GdipCreateRegionHrgn(hrgn, &region);
799 expect(Ok, status);
800
801 status = GdipGetRegionDataSize(region, &needed);
802 expect(Ok, status);
803 ok(needed == 216 ||
804 needed == 196, /* win98 */
805 "Got %.8x\n", needed);
806
807 status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
808 expect(Ok, status);
809
810 if(status == Ok && needed == 216) /* Don't try to test win98 layout */
811 {
812 expect(Ok, status);
813 expect(216, needed);
814 expect_dword(buf, 208);
815 expect_magic((DWORD*)(buf + 2));
816 expect_dword(buf + 3, 0);
817 expect_dword(buf + 4, RGNDATA_PATH);
818 expect_dword(buf + 5, 0x000000C0);
819 expect_magic((DWORD*)(buf + 6));
820 expect_dword(buf + 7, 0x00000024);
821 todo_wine expect_dword(buf + 8, 0x00006000); /* ?? */
822 }
823
824 GdipDeleteRegion(region);
825 DeleteObject(hrgn);
826 }
827
828 static void test_gethrgn(void)
829 {
830 GpStatus status;
831 GpRegion *region, *region2;
832 GpPath *path;
833 GpGraphics *graphics;
834 HRGN hrgn;
835 HDC hdc=GetDC(0);
836 static const RECT empty_rect = {0,0,0,0};
837 static const RECT test_rect = {10, 11, 20, 21};
838 static const GpRectF test_rectF = {10.0, 11.0, 10.0, 10.0};
839 static const RECT scaled_rect = {20, 22, 40, 42};
840 static const RECT test_rect2 = {10, 21, 20, 31};
841 static const GpRectF test_rect2F = {10.0, 21.0, 10.0, 10.0};
842 static const RECT test_rect3 = {10, 11, 20, 31};
843 static const GpRectF test_rect3F = {10.0, 11.0, 10.0, 20.0};
844
845 status = GdipCreateFromHDC(hdc, &graphics);
846 ok(status == Ok, "status %08x\n", status);
847
848 status = GdipCreateRegion(&region);
849 ok(status == Ok, "status %08x\n", status);
850
851 status = GdipGetRegionHRgn(NULL, graphics, &hrgn);
852 ok(status == InvalidParameter, "status %08x\n", status);
853 status = GdipGetRegionHRgn(region, graphics, NULL);
854 ok(status == InvalidParameter, "status %08x\n", status);
855
856 status = GdipGetRegionHRgn(region, NULL, &hrgn);
857 ok(status == Ok, "status %08x\n", status);
858 ok(hrgn == NULL, "hrgn=%p\n", hrgn);
859 DeleteObject(hrgn);
860
861 status = GdipGetRegionHRgn(region, graphics, &hrgn);
862 ok(status == Ok, "status %08x\n", status);
863 ok(hrgn == NULL, "hrgn=%p\n", hrgn);
864 DeleteObject(hrgn);
865
866 status = GdipSetEmpty(region);
867 ok(status == Ok, "status %08x\n", status);
868 status = GdipGetRegionHRgn(region, NULL, &hrgn);
869 ok(status == Ok, "status %08x\n", status);
870 verify_region(hrgn, &empty_rect);
871 DeleteObject(hrgn);
872
873 status = GdipCreatePath(FillModeAlternate, &path);
874 ok(status == Ok, "status %08x\n", status);
875 status = GdipAddPathRectangle(path, 10.0, 11.0, 10.0, 10.0);
876 ok(status == Ok, "status %08x\n", status);
877
878 status = GdipCreateRegionPath(path, &region2);
879 ok(status == Ok, "status %08x\n", status);
880 status = GdipGetRegionHRgn(region2, NULL, &hrgn);
881 ok(status == Ok, "status %08x\n", status);
882 verify_region(hrgn, &test_rect);
883 DeleteObject(hrgn);
884
885 /* resulting HRGN is in device coordinates */
886 status = GdipScaleWorldTransform(graphics, 2.0, 2.0, MatrixOrderPrepend);
887 ok(status == Ok, "status %08x\n", status);
888 status = GdipGetRegionHRgn(region2, graphics, &hrgn);
889 ok(status == Ok, "status %08x\n", status);
890 verify_region(hrgn, &scaled_rect);
891 DeleteObject(hrgn);
892
893 status = GdipCombineRegionRect(region2, &test_rectF, CombineModeReplace);
894 ok(status == Ok, "status %08x\n", status);
895 status = GdipGetRegionHRgn(region2, NULL, &hrgn);
896 ok(status == Ok, "status %08x\n", status);
897 verify_region(hrgn, &test_rect);
898 DeleteObject(hrgn);
899
900 status = GdipGetRegionHRgn(region2, graphics, &hrgn);
901 ok(status == Ok, "status %08x\n", status);
902 verify_region(hrgn, &scaled_rect);
903 DeleteObject(hrgn);
904
905 status = GdipSetInfinite(region);
906 ok(status == Ok, "status %08x\n", status);
907 status = GdipCombineRegionRect(region, &test_rectF, CombineModeIntersect);
908 ok(status == Ok, "status %08x\n", status);
909 status = GdipGetRegionHRgn(region, NULL, &hrgn);
910 ok(status == Ok, "status %08x\n", status);
911 verify_region(hrgn, &test_rect);
912 DeleteObject(hrgn);
913
914 status = GdipCombineRegionRect(region, &test_rectF, CombineModeReplace);
915 ok(status == Ok, "status %08x\n", status);
916 status = GdipCombineRegionRect(region, &test_rect2F, CombineModeUnion);
917 ok(status == Ok, "status %08x\n", status);
918 status = GdipGetRegionHRgn(region, NULL, &hrgn);
919 ok(status == Ok, "status %08x\n", status);
920 verify_region(hrgn, &test_rect3);
921 DeleteObject(hrgn);
922
923 status = GdipCombineRegionRect(region, &test_rect3F, CombineModeReplace);
924 ok(status == Ok, "status %08x\n", status);
925 status = GdipCombineRegionRect(region, &test_rect2F, CombineModeXor);
926 ok(status == Ok, "status %08x\n", status);
927 status = GdipGetRegionHRgn(region, NULL, &hrgn);
928 ok(status == Ok, "status %08x\n", status);
929 verify_region(hrgn, &test_rect);
930 DeleteObject(hrgn);
931
932 status = GdipCombineRegionRect(region, &test_rect3F, CombineModeReplace);
933 ok(status == Ok, "status %08x\n", status);
934 status = GdipCombineRegionRect(region, &test_rectF, CombineModeExclude);
935 ok(status == Ok, "status %08x\n", status);
936 status = GdipGetRegionHRgn(region, NULL, &hrgn);
937 ok(status == Ok, "status %08x\n", status);
938 verify_region(hrgn, &test_rect2);
939 DeleteObject(hrgn);
940
941 status = GdipCombineRegionRect(region, &test_rectF, CombineModeReplace);
942 ok(status == Ok, "status %08x\n", status);
943 status = GdipCombineRegionRect(region, &test_rect3F, CombineModeComplement);
944 ok(status == Ok, "status %08x\n", status);
945 status = GdipGetRegionHRgn(region, NULL, &hrgn);
946 ok(status == Ok, "status %08x\n", status);
947 verify_region(hrgn, &test_rect2);
948 DeleteObject(hrgn);
949
950 status = GdipDeletePath(path);
951 ok(status == Ok, "status %08x\n", status);
952 status = GdipDeleteRegion(region);
953 ok(status == Ok, "status %08x\n", status);
954 status = GdipDeleteRegion(region2);
955 ok(status == Ok, "status %08x\n", status);
956 status = GdipDeleteGraphics(graphics);
957 ok(status == Ok, "status %08x\n", status);
958 ReleaseDC(0, hdc);
959 }
960
961 static void test_isequal(void)
962 {
963 GpRegion *region1, *region2;
964 GpGraphics *graphics;
965 GpRectF rectf;
966 GpStatus status;
967 HDC hdc = GetDC(0);
968 BOOL res;
969
970 status = GdipCreateFromHDC(hdc, &graphics);
971 ok(status == Ok, "status %08x\n", status);
972
973 status = GdipCreateRegion(&region1);
974 ok(status == Ok, "status %08x\n", status);
975 status = GdipCreateRegion(&region2);
976 ok(status == Ok, "status %08x\n", status);
977
978 /* NULL */
979 status = GdipIsEqualRegion(NULL, NULL, NULL, NULL);
980 ok(status == InvalidParameter, "status %08x\n", status);
981 status = GdipIsEqualRegion(region1, region2, NULL, NULL);
982 ok(status == InvalidParameter, "status %08x\n", status);
983 status = GdipIsEqualRegion(region1, region2, graphics, NULL);
984 ok(status == InvalidParameter, "status %08x\n", status);
985 status = GdipIsEqualRegion(region1, region2, NULL, &res);
986 ok(status == InvalidParameter, "status %08x\n", status);
987
988 /* infinite regions */
989 res = FALSE;
990 status = GdipIsEqualRegion(region1, region2, graphics, &res);
991 ok(status == Ok, "status %08x\n", status);
992 ok(res, "Expected to be equal.\n");
993 /* empty regions */
994 status = GdipSetEmpty(region1);
995 ok(status == Ok, "status %08x\n", status);
996 status = GdipSetEmpty(region2);
997 ok(status == Ok, "status %08x\n", status);
998 res = FALSE;
999 status = GdipIsEqualRegion(region1, region2, graphics, &res);
1000 ok(status == Ok, "status %08x\n", status);
1001 ok(res, "Expected to be equal.\n");
1002 /* empty & infinite */
1003 status = GdipSetInfinite(region1);
1004 ok(status == Ok, "status %08x\n", status);
1005 res = TRUE;
1006 status = GdipIsEqualRegion(region1, region2, graphics, &res);
1007 ok(status == Ok, "status %08x\n", status);
1008 ok(!res, "Expected to be unequal.\n");
1009 /* rect & (inf/empty) */
1010 rectf.X = rectf.Y = 0.0;
1011 rectf.Width = rectf.Height = 100.0;
1012 status = GdipCombineRegionRect(region1, &rectf, CombineModeReplace);
1013 ok(status == Ok, "status %08x\n", status);
1014 res = TRUE;
1015 status = GdipIsEqualRegion(region1, region2, graphics, &res);
1016 ok(status == Ok, "status %08x\n", status);
1017 ok(!res, "Expected to be unequal.\n");
1018 status = GdipSetInfinite(region2);
1019 ok(status == Ok, "status %08x\n", status);
1020 res = TRUE;
1021 status = GdipIsEqualRegion(region1, region2, graphics, &res);
1022 ok(status == Ok, "status %08x\n", status);
1023 ok(!res, "Expected to be unequal.\n");
1024 /* roughly equal rectangles */
1025 rectf.X = rectf.Y = 0.0;
1026 rectf.Width = rectf.Height = 100.001;
1027 status = GdipCombineRegionRect(region2, &rectf, CombineModeReplace);
1028 ok(status == Ok, "status %08x\n", status);
1029 res = FALSE;
1030 status = GdipIsEqualRegion(region1, region2, graphics, &res);
1031 ok(status == Ok, "status %08x\n", status);
1032 ok(res, "Expected to be equal.\n");
1033 /* equal rectangles */
1034 rectf.X = rectf.Y = 0.0;
1035 rectf.Width = rectf.Height = 100.0;
1036 status = GdipCombineRegionRect(region2, &rectf, CombineModeReplace);
1037 ok(status == Ok, "status %08x\n", status);
1038 res = FALSE;
1039 status = GdipIsEqualRegion(region1, region2, graphics, &res);
1040 ok(status == Ok, "status %08x\n", status);
1041 ok(res, "Expected to be equal.\n");
1042
1043 /* cleanup */
1044 status = GdipDeleteRegion(region1);
1045 ok(status == Ok, "status %08x\n", status);
1046 status = GdipDeleteRegion(region2);
1047 ok(status == Ok, "status %08x\n", status);
1048 status = GdipDeleteGraphics(graphics);
1049 ok(status == Ok, "status %08x\n", status);
1050 ReleaseDC(0, hdc);
1051 }
1052
1053 static void test_translate(void)
1054 {
1055 GpRegion *region, *region2;
1056 GpGraphics *graphics;
1057 GpPath *path;
1058 GpRectF rectf;
1059 GpStatus status;
1060 HDC hdc = GetDC(0);
1061 BOOL res;
1062
1063 status = GdipCreateFromHDC(hdc, &graphics);
1064 ok(status == Ok, "status %08x\n", status);
1065
1066 status = GdipCreatePath(FillModeAlternate, &path);
1067 ok(status == Ok, "status %08x\n", status);
1068
1069 status = GdipCreateRegion(&region);
1070 ok(status == Ok, "status %08x\n", status);
1071 status = GdipCreateRegion(&region2);
1072 ok(status == Ok, "status %08x\n", status);
1073
1074 /* NULL */
1075 status = GdipTranslateRegion(NULL, 0.0, 0.0);
1076 ok(status == InvalidParameter, "status %08x\n", status);
1077
1078 /* infinite */
1079 status = GdipTranslateRegion(region, 10.0, 10.0);
1080 ok(status == Ok, "status %08x\n", status);
1081 /* empty */
1082 status = GdipSetEmpty(region);
1083 ok(status == Ok, "status %08x\n", status);
1084 status = GdipTranslateRegion(region, 10.0, 10.0);
1085 ok(status == Ok, "status %08x\n", status);
1086 /* rect */
1087 rectf.X = 10.0; rectf.Y = 0.0;
1088 rectf.Width = rectf.Height = 100.0;
1089 status = GdipCombineRegionRect(region, &rectf, CombineModeReplace);
1090 ok(status == Ok, "status %08x\n", status);
1091 rectf.X = 15.0; rectf.Y = -2.0;
1092 rectf.Width = rectf.Height = 100.0;
1093 status = GdipCombineRegionRect(region2, &rectf, CombineModeReplace);
1094 ok(status == Ok, "status %08x\n", status);
1095 status = GdipTranslateRegion(region, 5.0, -2.0);
1096 ok(status == Ok, "status %08x\n", status);
1097 res = FALSE;
1098 status = GdipIsEqualRegion(region, region2, graphics, &res);
1099 ok(status == Ok, "status %08x\n", status);
1100 ok(res, "Expected to be equal.\n");
1101 /* path */
1102 status = GdipAddPathEllipse(path, 0.0, 10.0, 100.0, 150.0);
1103 ok(status == Ok, "status %08x\n", status);
1104 status = GdipCombineRegionPath(region, path, CombineModeReplace);
1105 ok(status == Ok, "status %08x\n", status);
1106 status = GdipResetPath(path);
1107 ok(status == Ok, "status %08x\n", status);
1108 status = GdipAddPathEllipse(path, 10.0, 21.0, 100.0, 150.0);
1109 ok(status == Ok, "status %08x\n", status);
1110 status = GdipCombineRegionPath(region2, path, CombineModeReplace);
1111 ok(status == Ok, "status %08x\n", status);
1112 status = GdipTranslateRegion(region, 10.0, 11.0);
1113 ok(status == Ok, "status %08x\n", status);
1114 res = FALSE;
1115 status = GdipIsEqualRegion(region, region2, graphics, &res);
1116 ok(status == Ok, "status %08x\n", status);
1117 ok(res, "Expected to be equal.\n");
1118
1119 status = GdipDeleteRegion(region);
1120 ok(status == Ok, "status %08x\n", status);
1121 status = GdipDeleteRegion(region2);
1122 ok(status == Ok, "status %08x\n", status);
1123 status = GdipDeleteGraphics(graphics);
1124 ok(status == Ok, "status %08x\n", status);
1125 status = GdipDeletePath(path);
1126 ok(status == Ok, "status %08x\n", status);
1127 ReleaseDC(0, hdc);
1128 }
1129
1130 static void test_transform(void)
1131 {
1132 GpRegion *region, *region2;
1133 GpMatrix *matrix;
1134 GpGraphics *graphics;
1135 GpPath *path;
1136 GpRectF rectf;
1137 GpStatus status;
1138 HDC hdc = GetDC(0);
1139 BOOL res;
1140
1141 status = GdipCreateFromHDC(hdc, &graphics);
1142 expect(Ok, status);
1143
1144 status = GdipCreatePath(FillModeAlternate, &path);
1145 expect(Ok, status);
1146
1147 status = GdipCreateRegion(&region);
1148 expect(Ok, status);
1149 status = GdipCreateRegion(&region2);
1150 expect(Ok, status);
1151
1152 status = GdipCreateMatrix(&matrix);
1153 expect(Ok, status);
1154 status = GdipScaleMatrix(matrix, 2.0, 3.0, MatrixOrderAppend);
1155 expect(Ok, status);
1156
1157 /* NULL */
1158 status = GdipTransformRegion(NULL, matrix);
1159 expect(InvalidParameter, status);
1160
1161 status = GdipTransformRegion(region, NULL);
1162 expect(InvalidParameter, status);
1163
1164 /* infinite */
1165 status = GdipTransformRegion(region, matrix);
1166 expect(Ok, status);
1167
1168 res = FALSE;
1169 status = GdipIsEqualRegion(region, region2, graphics, &res);
1170 expect(Ok, status);
1171 ok(res, "Expected to be equal.\n");
1172
1173 /* empty */
1174 status = GdipSetEmpty(region);
1175 expect(Ok, status);
1176 status = GdipTransformRegion(region, matrix);
1177 expect(Ok, status);
1178
1179 status = GdipSetEmpty(region2);
1180 expect(Ok, status);
1181
1182 res = FALSE;
1183 status = GdipIsEqualRegion(region, region2, graphics, &res);
1184 expect(Ok, status);
1185 ok(res, "Expected to be equal.\n");
1186
1187 /* rect */
1188 rectf.X = 10.0;
1189 rectf.Y = 0.0;
1190 rectf.Width = rectf.Height = 100.0;
1191 status = GdipCombineRegionRect(region, &rectf, CombineModeReplace);
1192 expect(Ok, status);
1193 rectf.X = 20.0;
1194 rectf.Y = 0.0;
1195 rectf.Width = 200.0;
1196 rectf.Height = 300.0;
1197 status = GdipCombineRegionRect(region2, &rectf, CombineModeReplace);
1198 expect(Ok, status);
1199 status = GdipTransformRegion(region, matrix);
1200 expect(Ok, status);
1201 res = FALSE;
1202 status = GdipIsEqualRegion(region, region2, graphics, &res);
1203 expect(Ok, status);
1204 ok(res, "Expected to be equal.\n");
1205
1206 /* path */
1207 status = GdipAddPathEllipse(path, 0.0, 10.0, 100.0, 150.0);
1208 expect(Ok, status);
1209 status = GdipCombineRegionPath(region, path, CombineModeReplace);
1210 expect(Ok, status);
1211 status = GdipResetPath(path);
1212 expect(Ok, status);
1213 status = GdipAddPathEllipse(path, 0.0, 30.0, 200.0, 450.0);
1214 expect(Ok, status);
1215 status = GdipCombineRegionPath(region2, path, CombineModeReplace);
1216 expect(Ok, status);
1217 status = GdipTransformRegion(region, matrix);
1218 expect(Ok, status);
1219 res = FALSE;
1220 status = GdipIsEqualRegion(region, region2, graphics, &res);
1221 expect(Ok, status);
1222 ok(res, "Expected to be equal.\n");
1223
1224 status = GdipDeleteRegion(region);
1225 expect(Ok, status);
1226 status = GdipDeleteRegion(region2);
1227 expect(Ok, status);
1228 status = GdipDeleteGraphics(graphics);
1229 expect(Ok, status);
1230 status = GdipDeletePath(path);
1231 expect(Ok, status);
1232 status = GdipDeleteMatrix(matrix);
1233 expect(Ok, status);
1234 ReleaseDC(0, hdc);
1235 }
1236
1237 static void test_scans(void)
1238 {
1239 GpRegion *region;
1240 GpMatrix *matrix;
1241 GpRectF rectf;
1242 GpStatus status;
1243 ULONG count=80085;
1244 INT icount;
1245 GpRectF scans[2];
1246 GpRect scansi[2];
1247
1248 status = GdipCreateRegion(&region);
1249 expect(Ok, status);
1250
1251 status = GdipCreateMatrix(&matrix);
1252 expect(Ok, status);
1253
1254 /* test NULL values */
1255 status = GdipGetRegionScansCount(NULL, &count, matrix);
1256 expect(InvalidParameter, status);
1257
1258 status = GdipGetRegionScansCount(region, NULL, matrix);
1259 expect(InvalidParameter, status);
1260
1261 status = GdipGetRegionScansCount(region, &count, NULL);
1262 expect(InvalidParameter, status);
1263
1264 status = GdipGetRegionScans(NULL, scans, &icount, matrix);
1265 expect(InvalidParameter, status);
1266
1267 status = GdipGetRegionScans(region, scans, NULL, matrix);
1268 expect(InvalidParameter, status);
1269
1270 status = GdipGetRegionScans(region, scans, &icount, NULL);
1271 expect(InvalidParameter, status);
1272
1273 /* infinite */
1274 status = GdipGetRegionScansCount(region, &count, matrix);
1275 expect(Ok, status);
1276 expect(1, count);
1277
1278 status = GdipGetRegionScans(region, NULL, &icount, matrix);
1279 expect(Ok, status);
1280 expect(1, icount);
1281
1282 status = GdipGetRegionScans(region, scans, &icount, matrix);
1283 expect(Ok, status);
1284 expect(1, icount);
1285
1286 status = GdipGetRegionScansI(region, scansi, &icount, matrix);
1287 expect(Ok, status);
1288 expect(1, icount);
1289 expect(-0x400000, scansi[0].X);
1290 expect(-0x400000, scansi[0].Y);
1291 expect(0x800000, scansi[0].Width);
1292 expect(0x800000, scansi[0].Height);
1293
1294 status = GdipGetRegionScans(region, scans, &icount, matrix);
1295 expect(Ok, status);
1296 expect(1, icount);
1297 expectf((double)-0x400000, scans[0].X);
1298 expectf((double)-0x400000, scans[0].Y);
1299 expectf((double)0x800000, scans[0].Width);
1300 expectf((double)0x800000, scans[0].Height);
1301
1302 /* empty */
1303 status = GdipSetEmpty(region);
1304 expect(Ok, status);
1305
1306 status = GdipGetRegionScansCount(region, &count, matrix);
1307 expect(Ok, status);
1308 expect(0, count);
1309
1310 status = GdipGetRegionScans(region, scans, &icount, matrix);
1311 expect(Ok, status);
1312 expect(0, icount);
1313
1314 /* single rectangle */
1315 rectf.X = rectf.Y = 0.0;
1316 rectf.Width = rectf.Height = 5.0;
1317 status = GdipCombineRegionRect(region, &rectf, CombineModeReplace);
1318 expect(Ok, status);
1319
1320 status = GdipGetRegionScansCount(region, &count, matrix);
1321 expect(Ok, status);
1322 expect(1, count);
1323
1324 status = GdipGetRegionScans(region, scans, &icount, matrix);
1325 expect(Ok, status);
1326 expect(1, icount);
1327 expectf(0.0, scans[0].X);
1328 expectf(0.0, scans[0].Y);
1329 expectf(5.0, scans[0].Width);
1330 expectf(5.0, scans[0].Height);
1331
1332 /* two rectangles */
1333 rectf.X = rectf.Y = 5.0;
1334 rectf.Width = rectf.Height = 5.0;
1335 status = GdipCombineRegionRect(region, &rectf, CombineModeUnion);
1336 expect(Ok, status);
1337
1338 status = GdipGetRegionScansCount(region, &count, matrix);
1339 expect(Ok, status);
1340 expect(2, count);
1341
1342 /* Native ignores the initial value of count */
1343 scans[1].X = scans[1].Y = scans[1].Width = scans[1].Height = 8.0;
1344 icount = 1;
1345 status = GdipGetRegionScans(region, scans, &icount, matrix);
1346 expect(Ok, status);
1347 expect(2, icount);
1348 expectf(0.0, scans[0].X);
1349 expectf(0.0, scans[0].Y);
1350 expectf(5.0, scans[0].Width);
1351 expectf(5.0, scans[0].Height);
1352 expectf(5.0, scans[1].X);
1353 expectf(5.0, scans[1].Y);
1354 expectf(5.0, scans[1].Width);
1355 expectf(5.0, scans[1].Height);
1356
1357 status = GdipGetRegionScansI(region, scansi, &icount, matrix);
1358 expect(Ok, status);
1359 expect(2, icount);
1360 expect(0, scansi[0].X);
1361 expect(0, scansi[0].Y);
1362 expect(5, scansi[0].Width);
1363 expect(5, scansi[0].Height);
1364 expect(5, scansi[1].X);
1365 expect(5, scansi[1].Y);
1366 expect(5, scansi[1].Width);
1367 expect(5, scansi[1].Height);
1368
1369 status = GdipDeleteRegion(region);
1370 expect(Ok, status);
1371 status = GdipDeleteMatrix(matrix);
1372 expect(Ok, status);
1373 }
1374
1375 static void test_getbounds(void)
1376 {
1377 GpRegion *region;
1378 GpGraphics *graphics;
1379 GpStatus status;
1380 GpRectF rectf;
1381 HDC hdc = GetDC(0);
1382
1383 status = GdipCreateFromHDC(hdc, &graphics);
1384 ok(status == Ok, "status %08x\n", status);
1385 status = GdipCreateRegion(&region);
1386 ok(status == Ok, "status %08x\n", status);
1387
1388 /* NULL */
1389 status = GdipGetRegionBounds(NULL, NULL, NULL);
1390 ok(status == InvalidParameter, "status %08x\n", status);
1391 status = GdipGetRegionBounds(region, NULL, NULL);
1392 ok(status == InvalidParameter, "status %08x\n", status);
1393 status = GdipGetRegionBounds(region, graphics, NULL);
1394 ok(status == InvalidParameter, "status %08x\n", status);
1395 /* infinite */
1396 rectf.X = rectf.Y = 0.0;
1397 rectf.Height = rectf.Width = 100.0;
1398 status = GdipGetRegionBounds(region, graphics, &rectf);
1399 ok(status == Ok, "status %08x\n", status);
1400 ok(rectf.X == -(REAL)(1 << 22), "Expected X = %.2f, got %.2f\n", -(REAL)(1 << 22), rectf.X);
1401 ok(rectf.Y == -(REAL)(1 << 22), "Expected Y = %.2f, got %.2f\n", -(REAL)(1 << 22), rectf.Y);
1402 ok(rectf.Width == (REAL)(1 << 23), "Expected width = %.2f, got %.2f\n", (REAL)(1 << 23), rectf.Width);
1403 ok(rectf.Height == (REAL)(1 << 23), "Expected height = %.2f, got %.2f\n",(REAL)(1 << 23), rectf.Height);
1404 /* empty */
1405 rectf.X = rectf.Y = 0.0;
1406 rectf.Height = rectf.Width = 100.0;
1407 status = GdipSetEmpty(region);
1408 ok(status == Ok, "status %08x\n", status);
1409 status = GdipGetRegionBounds(region, graphics, &rectf);
1410 ok(status == Ok, "status %08x\n", status);
1411 ok(rectf.X == 0.0, "Expected X = 0.0, got %.2f\n", rectf.X);
1412 ok(rectf.Y == 0.0, "Expected Y = 0.0, got %.2f\n", rectf.Y);
1413 ok(rectf.Width == 0.0, "Expected width = 0.0, got %.2f\n", rectf.Width);
1414 ok(rectf.Height == 0.0, "Expected height = 0.0, got %.2f\n", rectf.Height);
1415 /* rect */
1416 rectf.X = 10.0; rectf.Y = 0.0;
1417 rectf.Width = rectf.Height = 100.0;
1418 status = GdipCombineRegionRect(region, &rectf, CombineModeReplace);
1419 ok(status == Ok, "status %08x\n", status);
1420 rectf.X = rectf.Y = 0.0;
1421 rectf.Height = rectf.Width = 0.0;
1422 status = GdipGetRegionBounds(region, graphics, &rectf);
1423 ok(status == Ok, "status %08x\n", status);
1424 ok(rectf.X == 10.0, "Expected X = 0.0, got %.2f\n", rectf.X);
1425 ok(rectf.Y == 0.0, "Expected Y = 0.0, got %.2f\n", rectf.Y);
1426 ok(rectf.Width == 100.0, "Expected width = 0.0, got %.2f\n", rectf.Width);
1427 ok(rectf.Height == 100.0, "Expected height = 0.0, got %.2f\n", rectf.Height);
1428
1429 /* the world and page transforms are ignored */
1430 GdipScaleWorldTransform(graphics, 2.0, 2.0, MatrixOrderPrepend);
1431 GdipSetPageUnit(graphics, UnitInch);
1432 GdipSetPageScale(graphics, 2.0);
1433 status = GdipGetRegionBounds(region, graphics, &rectf);
1434 ok(status == Ok, "status %08x\n", status);
1435 ok(rectf.X == 10.0, "Expected X = 0.0, got %.2f\n", rectf.X);
1436 ok(rectf.Y == 0.0, "Expected Y = 0.0, got %.2f\n", rectf.Y);
1437 ok(rectf.Width == 100.0, "Expected width = 0.0, got %.2f\n", rectf.Width);
1438
1439 rectf.X = 10.0; rectf.Y = 0.0;
1440 rectf.Width = rectf.Height = 100.0;
1441 status = GdipCombineRegionRect(region, &rectf, CombineModeReplace);
1442 ok(status == Ok, "status %08x\n", status);
1443 rectf.X = rectf.Y = 0.0;
1444 rectf.Height = rectf.Width = 0.0;
1445 status = GdipGetRegionBounds(region, graphics, &rectf);
1446 ok(status == Ok, "status %08x\n", status);
1447 ok(rectf.X == 10.0, "Expected X = 0.0, got %.2f\n", rectf.X);
1448 ok(rectf.Y == 0.0, "Expected Y = 0.0, got %.2f\n", rectf.Y);
1449 ok(rectf.Width == 100.0, "Expected width = 0.0, got %.2f\n", rectf.Width);
1450 ok(rectf.Height == 100.0, "Expected height = 0.0, got %.2f\n", rectf.Height);
1451
1452 status = GdipDeleteRegion(region);
1453 ok(status == Ok, "status %08x\n", status);
1454 status = GdipDeleteGraphics(graphics);
1455 ok(status == Ok, "status %08x\n", status);
1456 ReleaseDC(0, hdc);
1457 }
1458
1459 static void test_isvisiblepoint(void)
1460 {
1461 HDC hdc = GetDC(0);
1462 GpGraphics* graphics;
1463 GpRegion* region;
1464 GpPath* path;
1465 GpRectF rectf;
1466 GpStatus status;
1467 BOOL res;
1468 REAL x, y;
1469
1470 status = GdipCreateFromHDC(hdc, &graphics);
1471 expect(Ok, status);
1472
1473 status = GdipCreateRegion(&region);
1474 expect(Ok, status);
1475
1476 /* null parameters */
1477 status = GdipIsVisibleRegionPoint(NULL, 0, 0, graphics, &res);
1478 expect(InvalidParameter, status);
1479 status = GdipIsVisibleRegionPointI(NULL, 0, 0, graphics, &res);
1480 expect(InvalidParameter, status);
1481
1482 status = GdipIsVisibleRegionPoint(region, 0, 0, NULL, &res);
1483 expect(Ok, status);
1484 status = GdipIsVisibleRegionPointI(region, 0, 0, NULL, &res);
1485 expect(Ok, status);
1486
1487 status = GdipIsVisibleRegionPoint(region, 0, 0, graphics, NULL);
1488 expect(InvalidParameter, status);
1489 status = GdipIsVisibleRegionPointI(region, 0, 0, graphics, NULL);
1490 expect(InvalidParameter, status);
1491
1492 /* infinite region */
1493 status = GdipIsInfiniteRegion(region, graphics, &res);
1494 expect(Ok, status);
1495 ok(res == TRUE, "Region should be infinite\n");
1496
1497 x = 10;
1498 y = 10;
1499 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1500 expect(Ok, status);
1501 ok(res == TRUE, "Expected (%.2f, %.2f) to be visible\n", x, y);
1502 status = GdipIsVisibleRegionPointI(region, (INT)x, (INT)y, graphics, &res);
1503 expect(Ok, status);
1504 ok(res == TRUE, "Expected (%d, %d) to be visible\n", (INT)x, (INT)y);
1505
1506 x = -10;
1507 y = -10;
1508 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1509 expect(Ok, status);
1510 ok(res == TRUE, "Expected (%.2f, %.2f) to be visible\n", x, y);
1511 status = GdipIsVisibleRegionPointI(region, (INT)x, (INT)y, graphics, &res);
1512 expect(Ok, status);
1513 ok(res == TRUE, "Expected (%d, %d) to be visible\n", (INT)x, (INT)y);
1514
1515 /* rectangular region */
1516 rectf.X = 10;
1517 rectf.Y = 20;
1518 rectf.Width = 30;
1519 rectf.Height = 40;
1520
1521 status = GdipCombineRegionRect(region, &rectf, CombineModeReplace);
1522 expect(Ok, status);
1523
1524 x = 0;
1525 y = 0;
1526 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1527 expect(Ok, status);
1528 ok(res == FALSE, "Expected (%.2f, %.2f) not to be visible\n", x, y);
1529 status = GdipIsVisibleRegionPointI(region, (INT)x, (INT)y, graphics, &res);
1530 expect(Ok, status);
1531 ok(res == FALSE, "Expected (%d, %d) not to be visible\n", (INT)x, (INT)y);
1532
1533 x = 9;
1534 y = 19;
1535 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1536 expect(Ok, status);
1537 ok(res == FALSE, "Expected (%.2f, %.2f) to be visible\n", x, y);
1538
1539 x = 9.25;
1540 y = 19.25;
1541 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1542 expect(Ok, status);
1543 ok(res == FALSE, "Expected (%.2f, %.2f) to be visible\n", x, y);
1544
1545 x = 9.5;
1546 y = 19.5;
1547 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1548 expect(Ok, status);
1549 ok(res == TRUE, "Expected (%.2f, %.2f) to be visible\n", x, y);
1550
1551 x = 9.75;
1552 y = 19.75;
1553 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1554 expect(Ok, status);
1555 ok(res == TRUE, "Expected (%.2f, %.2f) to be visible\n", x, y);
1556
1557 x = 10;
1558 y = 20;
1559 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1560 expect(Ok, status);
1561 ok(res == TRUE, "Expected (%.2f, %.2f) to be visible\n", x, y);
1562
1563 x = 25;
1564 y = 40;
1565 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1566 expect(Ok, status);
1567 ok(res == TRUE, "Expected (%.2f, %.2f) to be visible\n", x, y);
1568 status = GdipIsVisibleRegionPointI(region, (INT)x, (INT)y, graphics, &res);
1569 expect(Ok, status);
1570 ok(res == TRUE, "Expected (%d, %d) to be visible\n", (INT)x, (INT)y);
1571
1572 x = 40;
1573 y = 60;
1574 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1575 expect(Ok, status);
1576 ok(res == FALSE, "Expected (%.2f, %.2f) not to be visible\n", x, y);
1577 status = GdipIsVisibleRegionPointI(region, (INT)x, (INT)y, graphics, &res);
1578 expect(Ok, status);
1579 ok(res == FALSE, "Expected (%d, %d) not to be visible\n", (INT)x, (INT)y);
1580
1581 /* translate into the center of the rectangle */
1582 status = GdipTranslateWorldTransform(graphics, 25, 40, MatrixOrderAppend);
1583 expect(Ok, status);
1584
1585 /* native ignores the world transform, so treat these as if
1586 * no transform exists */
1587 x = -20;
1588 y = -30;
1589 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1590 expect(Ok, status);
1591 ok(res == FALSE, "Expected (%.2f, %.2f) not to be visible\n", x, y);
1592 status = GdipIsVisibleRegionPointI(region, (INT)x, (INT)y, graphics, &res);
1593 expect(Ok, status);
1594 ok(res == FALSE, "Expected (%d, %d) not to be visible\n", (INT)x, (INT)y);
1595
1596 x = 0;
1597 y = 0;
1598 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1599 expect(Ok, status);
1600 ok(res == FALSE, "Expected (%.2f, %.2f) not to be visible\n", x, y);
1601 status = GdipIsVisibleRegionPointI(region, (INT)x, (INT)y, graphics, &res);
1602 expect(Ok, status);
1603 ok(res == FALSE, "Expected (%d, %d) not to be visible\n", (INT)x, (INT)y);
1604
1605 x = 25;
1606 y = 40;
1607 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1608 expect(Ok, status);
1609 ok(res == TRUE, "Expected (%.2f, %.2f) to be visible\n", x, y);
1610 status = GdipIsVisibleRegionPointI(region, (INT)x, (INT)y, graphics, &res);
1611 expect(Ok, status);
1612 ok(res == TRUE, "Expected (%d, %d) to be visible\n", (INT)x, (INT)y);
1613
1614 /* translate back to origin */
1615 status = GdipTranslateWorldTransform(graphics, -25, -40, MatrixOrderAppend);
1616 expect(Ok, status);
1617
1618 /* region from path */
1619 status = GdipCreatePath(FillModeAlternate, &path);
1620 expect(Ok, status);
1621
1622 status = GdipAddPathEllipse(path, 10, 20, 30, 40);
1623 expect(Ok, status);
1624
1625 status = GdipCombineRegionPath(region, path, CombineModeReplace);
1626 expect(Ok, status);
1627
1628 x = 11;
1629 y = 21;
1630 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1631 expect(Ok, status);
1632 ok(res == FALSE, "Expected (%.2f, %.2f) not to be visible\n", x, y);
1633 status = GdipIsVisibleRegionPointI(region, (INT)x, (INT)y, graphics, &res);
1634 expect(Ok, status);
1635 ok(res == FALSE, "Expected (%d, %d) not to be visible\n", (INT)x, (INT)y);
1636
1637 x = 25;
1638 y = 40;
1639 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1640 expect(Ok, status);
1641 ok(res == TRUE, "Expected (%.2f, %.2f) to be visible\n", x, y);
1642 status = GdipIsVisibleRegionPointI(region, (INT)x, (INT)y, graphics, &res);
1643 expect(Ok, status);
1644 ok(res == TRUE, "Expected (%d, %d) to be visible\n", (INT)x, (INT)y);
1645
1646 x = 40;
1647 y = 60;
1648 status = GdipIsVisibleRegionPoint(region, x, y, graphics, &res);
1649 expect(Ok, status);
1650 ok(res == FALSE, "Expected (%.2f, %.2f) not to be visible\n", x, y);
1651 status = GdipIsVisibleRegionPointI(region, (INT)x, (INT)y, graphics, &res);
1652 expect(Ok, status);
1653 ok(res == FALSE, "Expected (%d, %d) not to be visible\n", (INT)x, (INT)y);
1654
1655 GdipDeletePath(path);
1656
1657 GdipDeleteRegion(region);
1658 GdipDeleteGraphics(graphics);
1659 ReleaseDC(0, hdc);
1660 }
1661
1662 static void test_isvisiblerect(void)
1663 {
1664 HDC hdc = GetDC(0);
1665 GpGraphics* graphics;
1666 GpRegion* region;
1667 GpPath* path;
1668 GpRectF rectf;
1669 GpStatus status;
1670 BOOL res;
1671 REAL x, y, w, h;
1672
1673 status = GdipCreateFromHDC(hdc, &graphics);
1674 expect(Ok, status);
1675
1676 status = GdipCreateRegion(&region);
1677 expect(Ok, status);
1678
1679 /* null parameters */
1680 status = GdipIsVisibleRegionRect(NULL, 0, 0, 0, 0, graphics, &res);
1681 expect(InvalidParameter, status);
1682 status = GdipIsVisibleRegionRectI(NULL, 0, 0, 0, 0, graphics, &res);
1683 expect(InvalidParameter, status);
1684
1685 status = GdipIsVisibleRegionRect(region, 0, 0, 0, 0, NULL, &res);
1686 expect(Ok, status);
1687 status = GdipIsVisibleRegionRectI(region, 0, 0, 0, 0, NULL, &res);
1688 expect(Ok, status);
1689
1690 status = GdipIsVisibleRegionRect(region, 0, 0, 0, 0, graphics, NULL);
1691 expect(InvalidParameter, status);
1692 status = GdipIsVisibleRegionRectI(region, 0, 0, 0, 0, graphics, NULL);
1693 expect(InvalidParameter, status);
1694
1695 /* infinite region */
1696 status = GdipIsInfiniteRegion(region, graphics, &res);
1697 expect(Ok, status);
1698 ok(res == TRUE, "Region should be infinite\n");
1699
1700 x = 10; w = 10;
1701 y = 10; h = 10;
1702 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1703 expect(Ok, status);
1704 ok(res == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, w, h);
1705
1706 x = -10; w = 5;
1707 y = -10; h = 5;
1708 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1709 expect(Ok, status);
1710 ok(res == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, w, h);
1711
1712 /* rectangular region */
1713 rectf.X = 10;
1714 rectf.Y = 20;
1715 rectf.Width = 30;
1716 rectf.Height = 40;
1717
1718 status = GdipCombineRegionRect(region, &rectf, CombineModeIntersect);
1719 expect(Ok, status);
1720
1721 /* entirely within the region */
1722 x = 11; w = 10;
1723 y = 12; h = 10;
1724 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1725 expect(Ok, status);
1726 ok(res == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, w, h);
1727 status = GdipIsVisibleRegionRectI(region, (INT)x, (INT)y, (INT)w, (INT)h, graphics, &res);
1728 expect(Ok, status);
1729 ok(res == TRUE, "Expected (%d, %d, %d, %d) to be visible\n", (INT)x, (INT)y, (INT)w, (INT)h);
1730
1731 /* entirely outside of the region */
1732 x = 0; w = 5;
1733 y = 0; h = 5;
1734 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1735 expect(Ok, status);
1736 ok(res == FALSE, "Expected (%.2f, %.2f, %.2f, %.2f) not to be visible\n", x, y, w, h);
1737 status = GdipIsVisibleRegionRectI(region, (INT)x, (INT)y, (INT)w, (INT)h, graphics, &res);
1738 expect(Ok, status);
1739 ok(res == FALSE, "Expected (%d, %d, %d, %d) not to be visible\n", (INT)x, (INT)y, (INT)w, (INT)h);
1740
1741 /* corner cases */
1742 x = 0; w = 10;
1743 y = 0; h = 20;
1744 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1745 expect(Ok, status);
1746 ok(res == FALSE, "Expected (%.2f, %.2f, %.2f, %.2f) not to be visible\n", x, y, w, h);
1747
1748 x = 0; w = 10.25;
1749 y = 0; h = 20.25;
1750 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1751 expect(Ok, status);
1752 ok(res == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, w, h);
1753
1754 x = 39; w = 10;
1755 y = 59; h = 10;
1756 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1757 expect(Ok, status);
1758 ok(res == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, w, h);
1759
1760 x = 39.25; w = 10;
1761 y = 59.25; h = 10;
1762 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1763 expect(Ok, status);
1764 ok(res == FALSE, "Expected (%.2f, %.2f, %.2f, %.2f) not to be visible\n", x, y, w, h);
1765
1766 /* corners outside, but some intersection */
1767 x = 0; w = 100;
1768 y = 0; h = 100;
1769 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1770 expect(Ok, status);
1771 ok(res == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, w, h);
1772
1773 x = 0; w = 100;
1774 y = 0; h = 40;
1775 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1776 expect(Ok, status);
1777 ok(res == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, w, h);
1778
1779 x = 0; w = 25;
1780 y = 0; h = 100;
1781 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1782 expect(Ok, status);
1783 ok(res == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, w, h);
1784
1785 /* translate into the center of the rectangle */
1786 status = GdipTranslateWorldTransform(graphics, 25, 40, MatrixOrderAppend);
1787 expect(Ok, status);
1788
1789 /* native ignores the world transform, so treat these as if
1790 * no transform exists */
1791 x = 0; w = 5;
1792 y = 0; h = 5;
1793 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1794 expect(Ok, status);
1795 ok(res == FALSE, "Expected (%.2f, %.2f, %.2f, %.2f) not to be visible\n", x, y, w, h);
1796 status = GdipIsVisibleRegionRectI(region, (INT)x, (INT)y, (INT)w, (INT)h, graphics, &res);
1797 expect(Ok, status);
1798 ok(res == FALSE, "Expected (%d, %d, %d, %d) not to be visible\n", (INT)x, (INT)y, (INT)w, (INT)h);
1799
1800 x = 11; w = 10;
1801 y = 12; h = 10;
1802 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1803 expect(Ok, status);
1804 ok(res == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, w, h);
1805 status = GdipIsVisibleRegionRectI(region, (INT)x, (INT)y, (INT)w, (INT)h, graphics, &res);
1806 expect(Ok, status);
1807 ok(res == TRUE, "Expected (%d, %d, %d, %d) to be visible\n", (INT)x, (INT)y, (INT)w, (INT)h);
1808
1809 /* translate back to origin */
1810 status = GdipTranslateWorldTransform(graphics, -25, -40, MatrixOrderAppend);
1811 expect(Ok, status);
1812
1813 /* region from path */
1814 status = GdipCreatePath(FillModeAlternate, &path);
1815 expect(Ok, status);
1816
1817 status = GdipAddPathEllipse(path, 10, 20, 30, 40);
1818 expect(Ok, status);
1819
1820 status = GdipCombineRegionPath(region, path, CombineModeReplace);
1821 expect(Ok, status);
1822
1823 x = 0; w = 12;
1824 y = 0; h = 22;
1825 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1826 expect(Ok, status);
1827 ok(res == FALSE, "Expected (%.2f, %.2f, %.2f, %.2f) not to be visible\n", x, y, w, h);
1828 status = GdipIsVisibleRegionRectI(region, (INT)x, (INT)y, (INT)w, (INT)h, graphics, &res);
1829 expect(Ok, status);
1830 ok(res == FALSE, "Expected (%d, %d, %d, %d) not to be visible\n", (INT)x, (INT)y, (INT)w, (INT)h);
1831
1832 x = 0; w = 25;
1833 y = 0; h = 40;
1834 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1835 expect(Ok, status);
1836 ok(res == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, w, h);
1837 status = GdipIsVisibleRegionRectI(region, (INT)x, (INT)y, (INT)w, (INT)h, graphics, &res);
1838 expect(Ok, status);
1839 ok(res == TRUE, "Expected (%d, %d, %d, %d) to be visible\n", (INT)x, (INT)y, (INT)w, (INT)h);
1840
1841 x = 38; w = 10;
1842 y = 55; h = 10;
1843 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1844 expect(Ok, status);
1845 ok(res == FALSE, "Expected (%.2f, %.2f, %.2f, %.2f) not to be visible\n", x, y, w, h);
1846 status = GdipIsVisibleRegionRectI(region, (INT)x, (INT)y, (INT)w, (INT)h, graphics, &res);
1847 expect(Ok, status);
1848 ok(res == FALSE, "Expected (%d, %d, %d, %d) not to be visible\n", (INT)x, (INT)y, (INT)w, (INT)h);
1849
1850 x = 0; w = 100;
1851 y = 0; h = 100;
1852 status = GdipIsVisibleRegionRect(region, x, y, w, h, graphics, &res);
1853 expect(Ok, status);
1854 ok(res == TRUE, "Expected (%.2f, %.2f, %.2f, %.2f) to be visible\n", x, y, w, h);
1855 status = GdipIsVisibleRegionRectI(region, (INT)x, (INT)y, (INT)w, (INT)h, graphics, &res);
1856 expect(Ok, status);
1857 ok(res == TRUE, "Expected (%d, %d, %d, %d) to be visible\n", (INT)x, (INT)y, (INT)w, (INT)h);
1858
1859 GdipDeletePath(path);
1860
1861 GdipDeleteRegion(region);
1862 GdipDeleteGraphics(graphics);
1863 ReleaseDC(0, hdc);
1864 }
1865
1866 START_TEST(region)
1867 {
1868 struct GdiplusStartupInput gdiplusStartupInput;
1869 ULONG_PTR gdiplusToken;
1870
1871 gdiplusStartupInput.GdiplusVersion = 1;
1872 gdiplusStartupInput.DebugEventCallback = NULL;
1873 gdiplusStartupInput.SuppressBackgroundThread = 0;
1874 gdiplusStartupInput.SuppressExternalCodecs = 0;
1875
1876 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
1877
1878 test_getregiondata();
1879 test_isinfinite();
1880 test_isempty();
1881 test_combinereplace();
1882 test_fromhrgn();
1883 test_gethrgn();
1884 test_isequal();
1885 test_translate();
1886 test_transform();
1887 test_scans();
1888 test_getbounds();
1889 test_isvisiblepoint();
1890 test_isvisiblerect();
1891
1892 GdiplusShutdown(gdiplusToken);
1893 }
A free Windows-compatible Operating System