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