dlls/gdiplus/tests/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
  26 #define RGNDATA_RECT            0x10000000
  27 #define RGNDATA_PATH            0x10000001
  28 #define RGNDATA_EMPTY_RECT      0x10000002
  29 #define RGNDATA_INFINITE_RECT   0x10000003
  30
  31 #define RGNDATA_MAGIC           0xdbc01001
  32 #define RGNDATA_MAGIC2          0xdbc01002
  33
  34 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
  35
  36 #define expect_magic(value) ok(*value == RGNDATA_MAGIC || *value == RGNDATA_MAGIC2, "Expected a known magic value, got %8x\n", *value)
  37
  38 #define expect_dword(value, expected) ok(*(value) == expected, "expected %08x got %08x\n", expected, *(value))
  39
  40 static inline void expect_float(DWORD *value, FLOAT expected)
  41 {
  42     FLOAT valuef = *(FLOAT*)value;
  43     ok(valuef == expected, "expected %f got %f\n", expected, valuef);
  44 }
  45
  46 /* We get shorts back, not INTs like a GpPoint */
  47 typedef struct RegionDataPoint
  48 {
  49     short X, Y;
  50 } RegionDataPoint;
  51
  52 static void verify_region(HRGN hrgn, const RECT *rc)
  53 {
  54     union
  55     {
  56         RGNDATA data;
  57         char buf[sizeof(RGNDATAHEADER) + sizeof(RECT)];
  58     } rgn;
  59     const RECT *rect;
  60     DWORD ret;
  61
  62     ret = GetRegionData(hrgn, 0, NULL);
  63     if (IsRectEmpty(rc))
  64         ok(ret == sizeof(rgn.data.rdh), "expected sizeof(rdh), got %u\n", ret);
  65     else
  66         ok(ret == sizeof(rgn.data.rdh) + sizeof(RECT), "expected sizeof(rgn), got %u\n", ret);
  67
  68     if (!ret) return;
  69
  70     ret = GetRegionData(hrgn, sizeof(rgn), &rgn.data);
  71     if (IsRectEmpty(rc))
  72         ok(ret == sizeof(rgn.data.rdh), "expected sizeof(rdh), got %u\n", ret);
  73     else
  74         ok(ret == sizeof(rgn.data.rdh) + sizeof(RECT), "expected sizeof(rgn), got %u\n", ret);
  75
  76     trace("size %u, type %u, count %u, rgn size %u, bound (%d,%d-%d,%d)\n",
  77           rgn.data.rdh.dwSize, rgn.data.rdh.iType,
  78           rgn.data.rdh.nCount, rgn.data.rdh.nRgnSize,
  79           rgn.data.rdh.rcBound.left, rgn.data.rdh.rcBound.top,
  80           rgn.data.rdh.rcBound.right, rgn.data.rdh.rcBound.bottom);
  81     if (rgn.data.rdh.nCount != 0)
  82     {
  83         rect = (const RECT *)rgn.data.Buffer;
  84         trace("rect (%d,%d-%d,%d)\n", rect->left, rect->top, rect->right, rect->bottom);
  85         ok(EqualRect(rect, rc), "rects don't match\n");
  86     }
  87
  88     ok(rgn.data.rdh.dwSize == sizeof(rgn.data.rdh), "expected sizeof(rdh), got %u\n", rgn.data.rdh.dwSize);
  89     ok(rgn.data.rdh.iType == RDH_RECTANGLES, "expected RDH_RECTANGLES, got %u\n", rgn.data.rdh.iType);
  90     if (IsRectEmpty(rc))
  91     {
  92         ok(rgn.data.rdh.nCount == 0, "expected 0, got %u\n", rgn.data.rdh.nCount);
  93         ok(rgn.data.rdh.nRgnSize == 0,  "expected 0, got %u\n", rgn.data.rdh.nRgnSize);
  94     }
  95     else
  96     {
  97         ok(rgn.data.rdh.nCount == 1, "expected 1, got %u\n", rgn.data.rdh.nCount);
  98         ok(rgn.data.rdh.nRgnSize == sizeof(RECT),  "expected sizeof(RECT), got %u\n", rgn.data.rdh.nRgnSize);
  99     }
 100     ok(EqualRect(&rgn.data.rdh.rcBound, rc), "rects don't match\n");
 101 }
 102
 103 static void test_getregiondata(void)
 104 {
 105     GpStatus status;
 106     GpRegion *region, *region2;
 107     RegionDataPoint *point;
 108     UINT needed;
 109     DWORD buf[100];
 110     GpRect rect;
 111     GpPath *path;
 112
 113     memset(buf, 0xee, sizeof(buf));
 114
 115     status = GdipCreateRegion(&region);
 116     ok(status == Ok, "status %08x\n", status);
 117
 118     status = GdipGetRegionDataSize(region, &needed);
 119     ok(status == Ok, "status %08x\n", status);
 120     expect(20, needed);
 121     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 122     ok(status == Ok, "status %08x\n", status);
 123     expect(20, needed);
 124     expect_dword(buf, 12);
 125     trace("buf[1] = %08x\n", buf[1]);
 126     expect_magic((DWORD*)(buf + 2));
 127     expect_dword(buf + 3, 0);
 128     expect_dword(buf + 4, RGNDATA_INFINITE_RECT);
 129
 130     status = GdipSetEmpty(region);
 131     ok(status == Ok, "status %08x\n", status);
 132     status = GdipGetRegionDataSize(region, &needed);
 133     ok(status == Ok, "status %08x\n", status);
 134     expect(20, needed);
 135     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 136     ok(status == Ok, "status %08x\n", status);
 137     expect(20, needed);
 138     expect_dword(buf, 12);
 139     trace("buf[1] = %08x\n", buf[1]);
 140     expect_magic((DWORD*)(buf + 2));
 141     expect_dword(buf + 3, 0);
 142     expect_dword(buf + 4, RGNDATA_EMPTY_RECT);
 143
 144     status = GdipSetInfinite(region);
 145     ok(status == Ok, "status %08x\n", status);
 146     status = GdipGetRegionDataSize(region, &needed);
 147     ok(status == Ok, "status %08x\n", status);
 148     expect(20, needed);
 149     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 150     ok(status == Ok, "status %08x\n", status);
 151     expect(20, needed);
 152     expect_dword(buf, 12);
 153     trace("buf[1] = %08x\n", buf[1]);
 154     expect_magic((DWORD*)(buf + 2));
 155     expect_dword(buf + 3, 0);
 156     expect_dword(buf + 4, RGNDATA_INFINITE_RECT);
 157
 158     status = GdipDeleteRegion(region);
 159     ok(status == Ok, "status %08x\n", status);
 160
 161     rect.X = 10;
 162     rect.Y = 20;
 163     rect.Width = 100;
 164     rect.Height = 200;
 165     status = GdipCreateRegionRectI(&rect, &region);
 166     ok(status == Ok, "status %08x\n", status);
 167     status = GdipGetRegionDataSize(region, &needed);
 168     ok(status == Ok, "status %08x\n", status);
 169     expect(36, needed);
 170     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 171     ok(status == Ok, "status %08x\n", status);
 172     expect(36, needed);
 173     expect_dword(buf, 28);
 174     trace("buf[1] = %08x\n", buf[1]);
 175     expect_magic((DWORD*)(buf + 2));
 176     expect_dword(buf + 3, 0);
 177     expect_dword(buf + 4, RGNDATA_RECT);
 178     expect_float(buf + 5, 10.0);
 179     expect_float(buf + 6, 20.0);
 180     expect_float(buf + 7, 100.0);
 181     expect_float(buf + 8, 200.0);
 182
 183     rect.X = 50;
 184     rect.Y = 30;
 185     rect.Width = 10;
 186     rect.Height = 20;
 187     status = GdipCombineRegionRectI(region, &rect, CombineModeIntersect);
 188     ok(status == Ok, "status %08x\n", status);
 189     rect.X = 100;
 190     rect.Y = 300;
 191     rect.Width = 30;
 192     rect.Height = 50;
 193     status = GdipCombineRegionRectI(region, &rect, CombineModeXor);
 194     ok(status == Ok, "status %08x\n", status);
 195
 196     rect.X = 200;
 197     rect.Y = 100;
 198     rect.Width = 133;
 199     rect.Height = 266;
 200     status = GdipCreateRegionRectI(&rect, &region2);
 201     ok(status == Ok, "status %08x\n", status);
 202     rect.X = 20;
 203     rect.Y = 10;
 204     rect.Width = 40;
 205     rect.Height = 66;
 206     status = GdipCombineRegionRectI(region2, &rect, CombineModeUnion);
 207     ok(status == Ok, "status %08x\n", status);
 208
 209     status = GdipCombineRegionRegion(region, region2, CombineModeComplement);
 210     ok(status == Ok, "status %08x\n", status);
 211
 212     rect.X = 400;
 213     rect.Y = 500;
 214     rect.Width = 22;
 215     rect.Height = 55;
 216     status = GdipCombineRegionRectI(region, &rect, CombineModeExclude);
 217     ok(status == Ok, "status %08x\n", status);
 218
 219     status = GdipGetRegionDataSize(region, &needed);
 220     ok(status == Ok, "status %08x\n", status);
 221     expect(156, needed);
 222     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 223     ok(status == Ok, "status %08x\n", status);
 224     expect(156, needed);
 225     expect_dword(buf, 148);
 226     trace("buf[1] = %08x\n", buf[1]);
 227     expect_magic((DWORD*)(buf + 2));
 228     expect_dword(buf + 3, 10);
 229     expect_dword(buf + 4, CombineModeExclude);
 230     expect_dword(buf + 5, CombineModeComplement);
 231     expect_dword(buf + 6, CombineModeXor);
 232     expect_dword(buf + 7, CombineModeIntersect);
 233     expect_dword(buf + 8, RGNDATA_RECT);
 234     expect_float(buf + 9, 10.0);
 235     expect_float(buf + 10, 20.0);
 236     expect_float(buf + 11, 100.0);
 237     expect_float(buf + 12, 200.0);
 238     expect_dword(buf + 13, RGNDATA_RECT);
 239     expect_float(buf + 14, 50.0);
 240     expect_float(buf + 15, 30.0);
 241     expect_float(buf + 16, 10.0);
 242     expect_float(buf + 17, 20.0);
 243     expect_dword(buf + 18, RGNDATA_RECT);
 244     expect_float(buf + 19, 100.0);
 245     expect_float(buf + 20, 300.0);
 246     expect_float(buf + 21, 30.0);
 247     expect_float(buf + 22, 50.0);
 248     expect_dword(buf + 23, CombineModeUnion);
 249     expect_dword(buf + 24, RGNDATA_RECT);
 250     expect_float(buf + 25, 200.0);
 251     expect_float(buf + 26, 100.0);
 252     expect_float(buf + 27, 133.0);
 253     expect_float(buf + 28, 266.0);
 254     expect_dword(buf + 29, RGNDATA_RECT);
 255     expect_float(buf + 30, 20.0);
 256     expect_float(buf + 31, 10.0);
 257     expect_float(buf + 32, 40.0);
 258     expect_float(buf + 33, 66.0);
 259     expect_dword(buf + 34, RGNDATA_RECT);
 260     expect_float(buf + 35, 400.0);
 261     expect_float(buf + 36, 500.0);
 262     expect_float(buf + 37, 22.0);
 263     expect_float(buf + 38, 55.0);
 264
 265     status = GdipDeleteRegion(region2);
 266     ok(status == Ok, "status %08x\n", status);
 267     status = GdipDeleteRegion(region);
 268     ok(status == Ok, "status %08x\n", status);
 269
 270     /* Try some paths */
 271
 272     status = GdipCreatePath(FillModeAlternate, &path);
 273     ok(status == Ok, "status %08x\n", status);
 274     GdipAddPathRectangle(path, 12.5, 13.0, 14.0, 15.0);
 275
 276     status = GdipCreateRegionPath(path, &region);
 277     ok(status == Ok, "status %08x\n", status);
 278     status = GdipGetRegionDataSize(region, &needed);
 279     ok(status == Ok, "status %08x\n", status);
 280     expect(72, needed);
 281     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 282     ok(status == Ok, "status %08x\n", status);
 283     expect(72, needed);
 284     expect_dword(buf, 64);
 285     trace("buf[1] = %08x\n", buf[1]);
 286     expect_magic((DWORD*)(buf + 2));
 287     expect_dword(buf + 3, 0);
 288     expect_dword(buf + 4, RGNDATA_PATH);
 289     expect_dword(buf + 5, 0x00000030);
 290     expect_magic((DWORD*)(buf + 6));
 291     expect_dword(buf + 7, 0x00000004);
 292     expect_dword(buf + 8, 0x00000000);
 293     expect_float(buf + 9, 12.5);
 294     expect_float(buf + 10, 13.0);
 295     expect_float(buf + 11, 26.5);
 296     expect_float(buf + 12, 13.0);
 297     expect_float(buf + 13, 26.5);
 298     expect_float(buf + 14, 28.0);
 299     expect_float(buf + 15, 12.5);
 300     expect_float(buf + 16, 28.0);
 301     expect_dword(buf + 17, 0x81010100);
 302
 303
 304     rect.X = 50;
 305     rect.Y = 30;
 306     rect.Width = 10;
 307     rect.Height = 20;
 308     status = GdipCombineRegionRectI(region, &rect, CombineModeIntersect);
 309     ok(status == Ok, "status %08x\n", status);
 310     status = GdipGetRegionDataSize(region, &needed);
 311     ok(status == Ok, "status %08x\n", status);
 312     expect(96, needed);
 313     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 314     ok(status == Ok, "status %08x\n", status);
 315     expect(96, needed);
 316     expect_dword(buf, 88);
 317     trace("buf[1] = %08x\n", buf[1]);
 318     expect_magic((DWORD*)(buf + 2));
 319     expect_dword(buf + 3, 2);
 320     expect_dword(buf + 4, CombineModeIntersect);
 321     expect_dword(buf + 5, RGNDATA_PATH);
 322     expect_dword(buf + 6, 0x00000030);
 323     expect_magic((DWORD*)(buf + 7));
 324     expect_dword(buf + 8, 0x00000004);
 325     expect_dword(buf + 9, 0x00000000);
 326     expect_float(buf + 10, 12.5);
 327     expect_float(buf + 11, 13.0);
 328     expect_float(buf + 12, 26.5);
 329     expect_float(buf + 13, 13.0);
 330     expect_float(buf + 14, 26.5);
 331     expect_float(buf + 15, 28.0);
 332     expect_float(buf + 16, 12.5);
 333     expect_float(buf + 17, 28.0);
 334     expect_dword(buf + 18, 0x81010100);
 335     expect_dword(buf + 19, RGNDATA_RECT);
 336     expect_float(buf + 20, 50.0);
 337     expect_float(buf + 21, 30.0);
 338     expect_float(buf + 22, 10.0);
 339     expect_float(buf + 23, 20.0);
 340
 341     status = GdipDeleteRegion(region);
 342     ok(status == Ok, "status %08x\n", status);
 343     status = GdipDeletePath(path);
 344     ok(status == Ok, "status %08x\n", status);
 345
 346     /* Test an empty path */
 347     status = GdipCreatePath(FillModeAlternate, &path);
 348     expect(Ok, status);
 349     status = GdipCreateRegionPath(path, &region);
 350     expect(Ok, status);
 351     status = GdipGetRegionDataSize(region, &needed);
 352     expect(Ok, status);
 353     expect(36, needed);
 354     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 355     expect(Ok, status);
 356     expect(36, needed);
 357     expect_dword(buf, 28);
 358     trace("buf[1] = %08x\n", buf[1]);
 359     expect_magic((DWORD*)(buf + 2));
 360     expect_dword(buf + 3, 0);
 361     expect_dword(buf + 4, RGNDATA_PATH);
 362
 363     /* Second signature for pathdata */
 364     expect_dword(buf + 5, 12);
 365     expect_magic((DWORD*)(buf + 6));
 366     expect_dword(buf + 7, 0);
 367     expect_dword(buf + 8, 0x00004000);
 368
 369     status = GdipDeleteRegion(region);
 370     expect(Ok, status);
 371
 372     /* Test a simple triangle of INTs */
 373     status = GdipAddPathLine(path, 5, 6, 7, 8);
 374     expect(Ok, status);
 375     status = GdipAddPathLine(path, 8, 1, 5, 6);
 376     expect(Ok, status);
 377     status = GdipClosePathFigure(path);
 378     expect(Ok, status);
 379     status = GdipCreateRegionPath(path, &region);
 380     expect(Ok, status);
 381     status = GdipGetRegionDataSize(region, &needed);
 382     expect(Ok, status);
 383     expect(56, needed);
 384     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 385     expect(Ok, status);
 386     expect(56, needed);
 387     expect_dword(buf, 48);
 388     trace("buf[1] = %08x\n", buf[1]);
 389     expect_magic((DWORD*)(buf + 2));
 390     expect_dword(buf + 3 , 0);
 391     expect_dword(buf + 4 , RGNDATA_PATH);
 392
 393     expect_dword(buf + 5, 32);
 394     expect_magic((DWORD*)(buf + 6));
 395     expect_dword(buf + 7, 4);
 396     expect_dword(buf + 8, 0x00004000); /* ?? */
 397
 398     point = (RegionDataPoint*)buf + 9;
 399     expect(5, point[0].X);
 400     expect(6, point[0].Y);
 401     expect(7, point[1].X); /* buf + 10 */
 402     expect(8, point[1].Y);
 403     expect(8, point[2].X); /* buf + 11 */
 404     expect(1, point[2].Y);
 405     expect(5, point[3].X); /* buf + 12 */
 406     expect(6, point[3].Y);
 407     expect_dword(buf + 13, 0x81010100); /* 0x01010100 if we don't close the path */
 408
 409     status = GdipDeletePath(path);
 410     expect(Ok, status);
 411     status = GdipDeleteRegion(region);
 412     expect(Ok, status);
 413
 414     /* Test a floating-point triangle */
 415     status = GdipCreatePath(FillModeAlternate, &path);
 416     expect(Ok, status);
 417     status = GdipAddPathLine(path, 5.6, 6.2, 7.2, 8.9);
 418     expect(Ok, status);
 419     status = GdipAddPathLine(path, 8.1, 1.6, 5.6, 6.2);
 420     expect(Ok, status);
 421     status = GdipCreateRegionPath(path, &region);
 422     expect(Ok, status);
 423     status = GdipGetRegionDataSize(region, &needed);
 424     expect(Ok, status);
 425     expect(72, needed);
 426     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 427     expect(Ok, status);
 428     expect(72, needed);
 429     expect_dword(buf, 64);
 430     trace("buf[1] = %08x\n", buf[1]);
 431     expect_magic((DWORD*)(buf + 2));
 432     expect_dword(buf + 3, 0);
 433     expect_dword(buf + 4, RGNDATA_PATH);
 434
 435     expect_dword(buf + 5, 48);
 436     expect_magic((DWORD*)(buf + 6));
 437     expect_dword(buf + 7, 4);
 438     expect_dword(buf + 8, 0);
 439     expect_float(buf + 9, 5.6);
 440     expect_float(buf + 10, 6.2);
 441     expect_float(buf + 11, 7.2);
 442     expect_float(buf + 12, 8.9);
 443     expect_float(buf + 13, 8.1);
 444     expect_float(buf + 14, 1.6);
 445     expect_float(buf + 15, 5.6);
 446     expect_float(buf + 16, 6.2);
 447
 448     status = GdipDeletePath(path);
 449     expect(Ok, status);
 450     status = GdipDeleteRegion(region);
 451     expect(Ok, status);
 452
 453     /* Test for a path with > 4 points, and CombineRegionPath */
 454     GdipCreatePath(FillModeAlternate, &path);
 455     status = GdipAddPathLine(path, 50, 70.2, 60, 102.8);
 456     expect(Ok, status);
 457     status = GdipAddPathLine(path, 55.4, 122.4, 40.4, 60.2);
 458     expect(Ok, status);
 459     status = GdipAddPathLine(path, 45.6, 20.2, 50, 70.2);
 460     expect(Ok, status);
 461     rect.X = 20;
 462     rect.Y = 25;
 463     rect.Width = 60;
 464     rect.Height = 120;
 465     status = GdipCreateRegionRectI(&rect, &region);
 466     expect(Ok, status);
 467     status = GdipCombineRegionPath(region, path, CombineModeUnion);
 468     expect(Ok, status);
 469
 470     status = GdipGetRegionDataSize(region, &needed);
 471     expect(Ok, status);
 472     expect(116, needed);
 473     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 474     expect(Ok, status);
 475     expect(116, needed);
 476     expect_dword(buf, 108);
 477     trace("buf[1] = %08x\n", buf[1]);
 478     expect_magic((DWORD*)(buf + 2));
 479     expect_dword(buf + 3, 2);
 480     expect_dword(buf + 4, CombineModeUnion);
 481     expect_dword(buf + 5, RGNDATA_RECT);
 482     expect_float(buf + 6, 20);
 483     expect_float(buf + 7, 25);
 484     expect_float(buf + 8, 60);
 485     expect_float(buf + 9, 120);
 486     expect_dword(buf + 10, RGNDATA_PATH);
 487
 488     expect_dword(buf + 11, 68);
 489     expect_magic((DWORD*)(buf + 12));
 490     expect_dword(buf + 13, 6);
 491     expect_float(buf + 14, 0x0);
 492
 493     expect_float(buf + 15, 50);
 494     expect_float(buf + 16, 70.2);
 495     expect_float(buf + 17, 60);
 496     expect_float(buf + 18, 102.8);
 497     expect_float(buf + 19, 55.4);
 498     expect_float(buf + 20, 122.4);
 499     expect_float(buf + 21, 40.4);
 500     expect_float(buf + 22, 60.2);
 501     expect_float(buf + 23, 45.6);
 502     expect_float(buf + 24, 20.2);
 503     expect_float(buf + 25, 50);
 504     expect_float(buf + 26, 70.2);
 505     expect_dword(buf + 27, 0x01010100);
 506     expect_dword(buf + 28, 0x00000101);
 507
 508     status = GdipDeletePath(path);
 509     expect(Ok, status);
 510     status = GdipDeleteRegion(region);
 511     expect(Ok, status);
 512 }
 513
 514 static void test_isinfinite(void)
 515 {
 516     GpStatus status;
 517     GpRegion *region;
 518     GpGraphics *graphics = NULL;
 519     GpMatrix *m;
 520     HDC hdc = GetDC(0);
 521     BOOL res;
 522
 523     status = GdipCreateFromHDC(hdc, &graphics);
 524     expect(Ok, status);
 525     GdipCreateRegion(&region);
 526
 527     GdipCreateMatrix2(3.0, 0.0, 0.0, 1.0, 20.0, 30.0, &m);
 528
 529     /* NULL arguments */
 530     status = GdipIsInfiniteRegion(NULL, NULL, NULL);
 531     expect(InvalidParameter, status);
 532     status = GdipIsInfiniteRegion(region, NULL, NULL);
 533     expect(InvalidParameter, status);
 534     status = GdipIsInfiniteRegion(NULL, graphics, NULL);
 535     expect(InvalidParameter, status);
 536     status = GdipIsInfiniteRegion(NULL, NULL, &res);
 537     expect(InvalidParameter, status);
 538     status = GdipIsInfiniteRegion(region, NULL, &res);
 539     expect(InvalidParameter, status);
 540
 541     res = FALSE;
 542     status = GdipIsInfiniteRegion(region, graphics, &res);
 543     expect(Ok, status);
 544     expect(TRUE, res);
 545
 546     /* after world transform */
 547     status = GdipSetWorldTransform(graphics, m);
 548     expect(Ok, status);
 549
 550     res = FALSE;
 551     status = GdipIsInfiniteRegion(region, graphics, &res);
 552     expect(Ok, status);
 553     expect(TRUE, res);
 554
 555     GdipDeleteMatrix(m);
 556     GdipDeleteRegion(region);
 557     GdipDeleteGraphics(graphics);
 558     ReleaseDC(0, hdc);
 559 }
 560
 561 static void test_isempty(void)
 562 {
 563     GpStatus status;
 564     GpRegion *region;
 565     GpGraphics *graphics = NULL;
 566     HDC hdc = GetDC(0);
 567     BOOL res;
 568
 569     status = GdipCreateFromHDC(hdc, &graphics);
 570     expect(Ok, status);
 571     GdipCreateRegion(&region);
 572
 573     /* NULL arguments */
 574     status = GdipIsEmptyRegion(NULL, NULL, NULL);
 575     expect(InvalidParameter, status);
 576     status = GdipIsEmptyRegion(region, NULL, NULL);
 577     expect(InvalidParameter, status);
 578     status = GdipIsEmptyRegion(NULL, graphics, NULL);
 579     expect(InvalidParameter, status);
 580     status = GdipIsEmptyRegion(NULL, NULL, &res);
 581     expect(InvalidParameter, status);
 582     status = GdipIsEmptyRegion(region, NULL, &res);
 583     expect(InvalidParameter, status);
 584
 585     /* default is infinite */
 586     res = TRUE;
 587     status = GdipIsEmptyRegion(region, graphics, &res);
 588     expect(Ok, status);
 589     expect(FALSE, res);
 590
 591     status = GdipSetEmpty(region);
 592     expect(Ok, status);
 593
 594     res = FALSE;
 595     status = GdipIsEmptyRegion(region, graphics, &res);
 596     expect(Ok, status);
 597     expect(TRUE, res);
 598
 599     GdipDeleteRegion(region);
 600     GdipDeleteGraphics(graphics);
 601     ReleaseDC(0, hdc);
 602 }
 603
 604 static void test_combinereplace(void)
 605 {
 606     GpStatus status;
 607     GpRegion *region, *region2;
 608     GpPath *path;
 609     GpRectF rectf;
 610     UINT needed;
 611     DWORD buf[50];
 612
 613     rectf.X = rectf.Y = 0.0;
 614     rectf.Width = rectf.Height = 100.0;
 615
 616     status = GdipCreateRegionRect(&rectf, &region);
 617     expect(Ok, status);
 618
 619     /* replace with the same rectangle */
 620     status = GdipCombineRegionRect(region, &rectf,CombineModeReplace);
 621     expect(Ok, status);
 622
 623     status = GdipGetRegionDataSize(region, &needed);
 624     expect(Ok, status);
 625     expect(36, needed);
 626     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 627     expect(Ok, status);
 628     expect(36, needed);
 629     expect_dword(buf, 28);
 630     trace("buf[1] = %08x\n", buf[1]);
 631     expect_magic((DWORD*)(buf + 2));
 632     expect_dword(buf + 3, 0);
 633     expect_dword(buf + 4, RGNDATA_RECT);
 634
 635     /* replace with path */
 636     status = GdipCreatePath(FillModeAlternate, &path);
 637     expect(Ok, status);
 638     status = GdipAddPathEllipse(path, 0.0, 0.0, 100.0, 250.0);
 639     expect(Ok, status);
 640     status = GdipCombineRegionPath(region, path, CombineModeReplace);
 641     expect(Ok, status);
 642
 643     status = GdipGetRegionDataSize(region, &needed);
 644     expect(Ok, status);
 645     expect(156, needed);
 646     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 647     expect(Ok, status);
 648     expect(156, needed);
 649     expect_dword(buf, 148);
 650     trace("buf[1] = %08x\n", buf[1]);
 651     expect_magic((DWORD*)(buf + 2));
 652     expect_dword(buf + 3, 0);
 653     expect_dword(buf + 4, RGNDATA_PATH);
 654     GdipDeletePath(path);
 655
 656     /* replace with infinite rect */
 657     status = GdipCreateRegion(&region2);
 658     expect(Ok, status);
 659     status = GdipCombineRegionRegion(region, region2, CombineModeReplace);
 660     expect(Ok, status);
 661
 662     status = GdipGetRegionDataSize(region, &needed);
 663     expect(Ok, status);
 664     expect(20, needed);
 665     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 666     expect(Ok, status);
 667     expect(20, needed);
 668     expect_dword(buf, 12);
 669     trace("buf[1] = %08x\n", buf[1]);
 670     expect_magic((DWORD*)(buf + 2));
 671     expect_dword(buf + 3, 0);
 672     expect_dword(buf + 4, RGNDATA_INFINITE_RECT);
 673     GdipDeleteRegion(region2);
 674
 675     /* more complex case : replace with a combined region */
 676     status = GdipCreateRegionRect(&rectf, &region2);
 677     expect(Ok, status);
 678     status = GdipCreatePath(FillModeAlternate, &path);
 679     expect(Ok, status);
 680     status = GdipAddPathEllipse(path, 0.0, 0.0, 100.0, 250.0);
 681     expect(Ok, status);
 682     status = GdipCombineRegionPath(region2, path, CombineModeUnion);
 683     expect(Ok, status);
 684     GdipDeletePath(path);
 685     status = GdipCombineRegionRegion(region, region2, CombineModeReplace);
 686     expect(Ok, status);
 687     GdipDeleteRegion(region2);
 688
 689     status = GdipGetRegionDataSize(region, &needed);
 690     expect(Ok, status);
 691     expect(180, needed);
 692     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 693     expect(Ok, status);
 694     expect(180, needed);
 695     expect_dword(buf, 172);
 696     trace("buf[1] = %08x\n", buf[1]);
 697     expect_magic((DWORD*)(buf + 2));
 698     expect_dword(buf + 3, 2);
 699     expect_dword(buf + 4, CombineModeUnion);
 700
 701     GdipDeleteRegion(region);
 702 }
 703
 704 static void test_fromhrgn(void)
 705 {
 706     GpStatus status;
 707     GpRegion *region;
 708     HRGN hrgn;
 709     UINT needed;
 710     DWORD buf[220];
 711     RegionDataPoint *point;
 712
 713     /* NULL */
 714     status = GdipCreateRegionHrgn(NULL, NULL);
 715     expect(InvalidParameter, status);
 716     status = GdipCreateRegionHrgn(NULL, &region);
 717     expect(InvalidParameter, status);
 718     status = GdipCreateRegionHrgn((HRGN)0xdeadbeef, &region);
 719     todo_wine expect(InvalidParameter, status);
 720
 721     /* rectangle */
 722     hrgn = CreateRectRgn(0, 0, 100, 10);
 723     status = GdipCreateRegionHrgn(hrgn, &region);
 724     todo_wine expect(Ok, status);
 725
 726     status = GdipGetRegionDataSize(region, &needed);
 727 todo_wine{
 728     expect(Ok, status);
 729     expect(56, needed);
 730 }
 731
 732     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 733     todo_wine expect(Ok, status);
 734
 735     if(status == Ok){
 736 todo_wine{
 737     expect(56, needed);
 738     expect_dword(buf, 48);
 739     expect_magic((DWORD*)(buf + 2));
 740     expect_dword(buf + 3, 0);
 741     expect_dword(buf + 4, RGNDATA_PATH);
 742     expect_dword(buf + 5, 0x00000020);
 743     expect_magic((DWORD*)(buf + 6));
 744     expect_dword(buf + 7, 0x00000004);
 745     expect_dword(buf + 8, 0x00006000); /* ?? */
 746 }
 747     point = (RegionDataPoint*)buf + 9;
 748
 749     expect(0,  point[0].X);
 750     expect(0,  point[0].Y);
 751
 752 todo_wine{
 753     expect(100,point[1].X); /* buf + 10 */
 754     expect(0,  point[1].Y);
 755     expect(100,point[2].X); /* buf + 11 */
 756     expect(10, point[2].Y);
 757 }
 758     expect(0,  point[3].X); /* buf + 12 */
 759
 760 todo_wine{
 761     expect(10, point[3].Y);
 762     expect_dword(buf + 13, 0x81010100); /* closed */
 763 }
 764     }
 765
 766     GdipDeleteRegion(region);
 767     DeleteObject(hrgn);
 768
 769     /* ellipse */
 770     hrgn = CreateEllipticRgn(0, 0, 100, 10);
 771     status = GdipCreateRegionHrgn(hrgn, &region);
 772     todo_wine expect(Ok, status);
 773
 774     status = GdipGetRegionDataSize(region, &needed);
 775 todo_wine{
 776     expect(Ok, status);
 777     expect(216, needed);
 778 }
 779     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 780 todo_wine{
 781     expect(Ok, status);
 782     expect(216, needed);
 783     expect_dword(buf, 208);
 784     expect_magic((DWORD*)(buf + 2));
 785     expect_dword(buf + 3, 0);
 786     expect_dword(buf + 4, RGNDATA_PATH);
 787     expect_dword(buf + 5, 0x000000C0);
 788     expect_magic((DWORD*)(buf + 6));
 789     expect_dword(buf + 7, 0x00000024);
 790     expect_dword(buf + 8, 0x00006000); /* ?? */
 791 }
 792     GdipDeleteRegion(region);
 793     DeleteObject(hrgn);
 794 }
 795
 796 static void test_gethrgn(void)
 797 {
 798     GpStatus status;
 799     GpRegion *region, *region2;
 800     GpPath *path;
 801     GpGraphics *graphics;
 802     HRGN hrgn;
 803     HDC hdc=GetDC(0);
 804     static const RECT empty_rect = {0,0,0,0};
 805     static const RECT test_rect = {10, 11, 20, 21};
 806     static const GpRectF test_rectF = {10.0, 11.0, 10.0, 10.0};
 807     static const RECT scaled_rect = {20, 22, 40, 42};
 808     static const RECT test_rect2 = {10, 21, 20, 31};
 809     static const GpRectF test_rect2F = {10.0, 21.0, 10.0, 10.0};
 810     static const RECT test_rect3 = {10, 11, 20, 31};
 811     static const GpRectF test_rect3F = {10.0, 11.0, 10.0, 20.0};
 812
 813     status = GdipCreateFromHDC(hdc, &graphics);
 814     ok(status == Ok, "status %08x\n", status);
 815
 816     status = GdipCreateRegion(&region);
 817     ok(status == Ok, "status %08x\n", status);
 818
 819     status = GdipGetRegionHRgn(NULL, graphics, &hrgn);
 820     ok(status == InvalidParameter, "status %08x\n", status);
 821     status = GdipGetRegionHRgn(region, graphics, NULL);
 822     ok(status == InvalidParameter, "status %08x\n", status);
 823
 824     status = GdipGetRegionHRgn(region, NULL, &hrgn);
 825     ok(status == Ok, "status %08x\n", status);
 826     ok(hrgn == NULL, "hrgn=%p\n", hrgn);
 827     DeleteObject(hrgn);
 828
 829     status = GdipGetRegionHRgn(region, graphics, &hrgn);
 830     ok(status == Ok, "status %08x\n", status);
 831     ok(hrgn == NULL, "hrgn=%p\n", hrgn);
 832     DeleteObject(hrgn);
 833
 834     status = GdipSetEmpty(region);
 835     ok(status == Ok, "status %08x\n", status);
 836     status = GdipGetRegionHRgn(region, NULL, &hrgn);
 837     ok(status == Ok, "status %08x\n", status);
 838     verify_region(hrgn, &empty_rect);
 839     DeleteObject(hrgn);
 840
 841     status = GdipCreatePath(FillModeAlternate, &path);
 842     ok(status == Ok, "status %08x\n", status);
 843     status = GdipAddPathRectangle(path, 10.0, 11.0, 10.0, 10.0);
 844     ok(status == Ok, "status %08x\n", status);
 845
 846     status = GdipCreateRegionPath(path, &region2);
 847     ok(status == Ok, "status %08x\n", status);
 848     status = GdipGetRegionHRgn(region2, NULL, &hrgn);
 849     ok(status == Ok, "status %08x\n", status);
 850     verify_region(hrgn, &test_rect);
 851     DeleteObject(hrgn);
 852
 853     /* resulting HRGN is in device coordinates */
 854     status = GdipScaleWorldTransform(graphics, 2.0, 2.0, MatrixOrderPrepend);
 855     ok(status == Ok, "status %08x\n", status);
 856     status = GdipGetRegionHRgn(region2, graphics, &hrgn);
 857     ok(status == Ok, "status %08x\n", status);
 858     verify_region(hrgn, &scaled_rect);
 859     DeleteObject(hrgn);
 860
 861     status = GdipCombineRegionRect(region2, &test_rectF, CombineModeReplace);
 862     ok(status == Ok, "status %08x\n", status);
 863     status = GdipGetRegionHRgn(region2, NULL, &hrgn);
 864     ok(status == Ok, "status %08x\n", status);
 865     verify_region(hrgn, &test_rect);
 866     DeleteObject(hrgn);
 867
 868     status = GdipGetRegionHRgn(region2, graphics, &hrgn);
 869     ok(status == Ok, "status %08x\n", status);
 870     verify_region(hrgn, &scaled_rect);
 871     DeleteObject(hrgn);
 872
 873     status = GdipSetInfinite(region);
 874     ok(status == Ok, "status %08x\n", status);
 875     status = GdipCombineRegionRect(region, &test_rectF, CombineModeIntersect);
 876     ok(status == Ok, "status %08x\n", status);
 877     status = GdipGetRegionHRgn(region, NULL, &hrgn);
 878     ok(status == Ok, "status %08x\n", status);
 879     verify_region(hrgn, &test_rect);
 880     DeleteObject(hrgn);
 881
 882     status = GdipCombineRegionRect(region, &test_rectF, CombineModeReplace);
 883     ok(status == Ok, "status %08x\n", status);
 884     status = GdipCombineRegionRect(region, &test_rect2F, CombineModeUnion);
 885     ok(status == Ok, "status %08x\n", status);
 886     status = GdipGetRegionHRgn(region, NULL, &hrgn);
 887     ok(status == Ok, "status %08x\n", status);
 888     verify_region(hrgn, &test_rect3);
 889     DeleteObject(hrgn);
 890
 891     status = GdipCombineRegionRect(region, &test_rect3F, CombineModeReplace);
 892     ok(status == Ok, "status %08x\n", status);
 893     status = GdipCombineRegionRect(region, &test_rect2F, CombineModeXor);
 894     ok(status == Ok, "status %08x\n", status);
 895     status = GdipGetRegionHRgn(region, NULL, &hrgn);
 896     ok(status == Ok, "status %08x\n", status);
 897     verify_region(hrgn, &test_rect);
 898     DeleteObject(hrgn);
 899
 900     status = GdipCombineRegionRect(region, &test_rect3F, CombineModeReplace);
 901     ok(status == Ok, "status %08x\n", status);
 902     status = GdipCombineRegionRect(region, &test_rectF, CombineModeExclude);
 903     ok(status == Ok, "status %08x\n", status);
 904     status = GdipGetRegionHRgn(region, NULL, &hrgn);
 905     ok(status == Ok, "status %08x\n", status);
 906     verify_region(hrgn, &test_rect2);
 907     DeleteObject(hrgn);
 908
 909     status = GdipCombineRegionRect(region, &test_rectF, CombineModeReplace);
 910     ok(status == Ok, "status %08x\n", status);
 911     status = GdipCombineRegionRect(region, &test_rect3F, CombineModeComplement);
 912     ok(status == Ok, "status %08x\n", status);
 913     status = GdipGetRegionHRgn(region, NULL, &hrgn);
 914     ok(status == Ok, "status %08x\n", status);
 915     verify_region(hrgn, &test_rect2);
 916     DeleteObject(hrgn);
 917
 918     status = GdipDeletePath(path);
 919     ok(status == Ok, "status %08x\n", status);
 920     status = GdipDeleteRegion(region);
 921     ok(status == Ok, "status %08x\n", status);
 922     status = GdipDeleteRegion(region2);
 923     ok(status == Ok, "status %08x\n", status);
 924     status = GdipDeleteGraphics(graphics);
 925     ok(status == Ok, "status %08x\n", status);
 926     ReleaseDC(0, hdc);
 927 }
 928
 929 START_TEST(region)
 930 {
 931     struct GdiplusStartupInput gdiplusStartupInput;
 932     ULONG_PTR gdiplusToken;
 933
 934     gdiplusStartupInput.GdiplusVersion              = 1;
 935     gdiplusStartupInput.DebugEventCallback          = NULL;
 936     gdiplusStartupInput.SuppressBackgroundThread    = 0;
 937     gdiplusStartupInput.SuppressExternalCodecs      = 0;
 938
 939     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 940
 941     test_getregiondata();
 942     test_isinfinite();
 943     test_isempty();
 944     test_combinereplace();
 945     test_fromhrgn();
 946     test_gethrgn();
 947
 948     GdiplusShutdown(gdiplusToken);
 949 }