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     GpGraphics *graphics = NULL;
 713     HDC hdc;
 714     BOOL res;
 715
 716     /* NULL */
 717     status = GdipCreateRegionHrgn(NULL, NULL);
 718     expect(InvalidParameter, status);
 719     status = GdipCreateRegionHrgn(NULL, &region);
 720     expect(InvalidParameter, status);
 721     status = GdipCreateRegionHrgn((HRGN)0xdeadbeef, &region);
 722     expect(InvalidParameter, status);
 723
 724     /* empty rectangle */
 725     hrgn = CreateRectRgn(0, 0, 0, 0);
 726     status = GdipCreateRegionHrgn(hrgn, &region);
 727     expect(Ok, status);
 728     if(status == Ok) {
 729
 730     hdc = GetDC(0);
 731     status = GdipCreateFromHDC(hdc, &graphics);
 732     expect(Ok, status);
 733     res = FALSE;
 734     status = GdipIsEmptyRegion(region, graphics, &res);
 735     expect(Ok, status);
 736     expect(TRUE, res);
 737     GdipDeleteGraphics(graphics);
 738     ReleaseDC(0, hdc);
 739     GdipDeleteRegion(region);
 740
 741     }
 742     DeleteObject(hrgn);
 743
 744     /* rectangle */
 745     hrgn = CreateRectRgn(0, 0, 100, 10);
 746     status = GdipCreateRegionHrgn(hrgn, &region);
 747     expect(Ok, status);
 748
 749     status = GdipGetRegionDataSize(region, &needed);
 750     expect(Ok, status);
 751     expect(56, needed);
 752
 753     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 754     expect(Ok, status);
 755
 756     if(status == Ok){
 757
 758     expect(56, needed);
 759     expect_dword(buf, 48);
 760     expect_magic((DWORD*)(buf + 2));
 761     expect_dword(buf + 3, 0);
 762     expect_dword(buf + 4, RGNDATA_PATH);
 763     expect_dword(buf + 5, 0x00000020);
 764     expect_magic((DWORD*)(buf + 6));
 765     expect_dword(buf + 7, 0x00000004);
 766     todo_wine expect_dword(buf + 8, 0x00006000); /* ?? */
 767
 768     point = (RegionDataPoint*)buf + 9;
 769
 770     expect(0,  point[0].X);
 771     expect(0,  point[0].Y);
 772
 773     expect(100,point[1].X); /* buf + 10 */
 774     expect(0,  point[1].Y);
 775     expect(100,point[2].X); /* buf + 11 */
 776     expect(10, point[2].Y);
 777
 778     expect(0,  point[3].X); /* buf + 12 */
 779
 780     expect(10, point[3].Y);
 781     expect_dword(buf + 13, 0x81010100); /* closed */
 782
 783     }
 784
 785     GdipDeleteRegion(region);
 786     DeleteObject(hrgn);
 787
 788     /* ellipse */
 789     hrgn = CreateEllipticRgn(0, 0, 100, 10);
 790     status = GdipCreateRegionHrgn(hrgn, &region);
 791     todo_wine expect(Ok, status);
 792
 793     status = GdipGetRegionDataSize(region, &needed);
 794 todo_wine{
 795     expect(Ok, status);
 796     ok(needed == 216 ||
 797        needed == 196, /* win98 */
 798        "Got %.8x\n", needed);
 799 }
 800     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
 801     todo_wine expect(Ok, status);
 802
 803     if(status == Ok && needed == 216) /* Don't try to test win98 layout */
 804     {
 805 todo_wine{
 806     expect(Ok, status);
 807     expect(216, needed);
 808     expect_dword(buf, 208);
 809     expect_magic((DWORD*)(buf + 2));
 810     expect_dword(buf + 3, 0);
 811     expect_dword(buf + 4, RGNDATA_PATH);
 812     expect_dword(buf + 5, 0x000000C0);
 813     expect_magic((DWORD*)(buf + 6));
 814     expect_dword(buf + 7, 0x00000024);
 815     expect_dword(buf + 8, 0x00006000); /* ?? */
 816 }
 817     }
 818
 819     GdipDeleteRegion(region);
 820     DeleteObject(hrgn);
 821 }
 822
 823 static void test_gethrgn(void)
 824 {
 825     GpStatus status;
 826     GpRegion *region, *region2;
 827     GpPath *path;
 828     GpGraphics *graphics;
 829     HRGN hrgn;
 830     HDC hdc=GetDC(0);
 831     static const RECT empty_rect = {0,0,0,0};
 832     static const RECT test_rect = {10, 11, 20, 21};
 833     static const GpRectF test_rectF = {10.0, 11.0, 10.0, 10.0};
 834     static const RECT scaled_rect = {20, 22, 40, 42};
 835     static const RECT test_rect2 = {10, 21, 20, 31};
 836     static const GpRectF test_rect2F = {10.0, 21.0, 10.0, 10.0};
 837     static const RECT test_rect3 = {10, 11, 20, 31};
 838     static const GpRectF test_rect3F = {10.0, 11.0, 10.0, 20.0};
 839
 840     status = GdipCreateFromHDC(hdc, &graphics);
 841     ok(status == Ok, "status %08x\n", status);
 842
 843     status = GdipCreateRegion(&region);
 844     ok(status == Ok, "status %08x\n", status);
 845
 846     status = GdipGetRegionHRgn(NULL, graphics, &hrgn);
 847     ok(status == InvalidParameter, "status %08x\n", status);
 848     status = GdipGetRegionHRgn(region, graphics, NULL);
 849     ok(status == InvalidParameter, "status %08x\n", status);
 850
 851     status = GdipGetRegionHRgn(region, NULL, &hrgn);
 852     ok(status == Ok, "status %08x\n", status);
 853     ok(hrgn == NULL, "hrgn=%p\n", hrgn);
 854     DeleteObject(hrgn);
 855
 856     status = GdipGetRegionHRgn(region, graphics, &hrgn);
 857     ok(status == Ok, "status %08x\n", status);
 858     ok(hrgn == NULL, "hrgn=%p\n", hrgn);
 859     DeleteObject(hrgn);
 860
 861     status = GdipSetEmpty(region);
 862     ok(status == Ok, "status %08x\n", status);
 863     status = GdipGetRegionHRgn(region, NULL, &hrgn);
 864     ok(status == Ok, "status %08x\n", status);
 865     verify_region(hrgn, &empty_rect);
 866     DeleteObject(hrgn);
 867
 868     status = GdipCreatePath(FillModeAlternate, &path);
 869     ok(status == Ok, "status %08x\n", status);
 870     status = GdipAddPathRectangle(path, 10.0, 11.0, 10.0, 10.0);
 871     ok(status == Ok, "status %08x\n", status);
 872
 873     status = GdipCreateRegionPath(path, &region2);
 874     ok(status == Ok, "status %08x\n", status);
 875     status = GdipGetRegionHRgn(region2, NULL, &hrgn);
 876     ok(status == Ok, "status %08x\n", status);
 877     verify_region(hrgn, &test_rect);
 878     DeleteObject(hrgn);
 879
 880     /* resulting HRGN is in device coordinates */
 881     status = GdipScaleWorldTransform(graphics, 2.0, 2.0, MatrixOrderPrepend);
 882     ok(status == Ok, "status %08x\n", status);
 883     status = GdipGetRegionHRgn(region2, graphics, &hrgn);
 884     ok(status == Ok, "status %08x\n", status);
 885     verify_region(hrgn, &scaled_rect);
 886     DeleteObject(hrgn);
 887
 888     status = GdipCombineRegionRect(region2, &test_rectF, CombineModeReplace);
 889     ok(status == Ok, "status %08x\n", status);
 890     status = GdipGetRegionHRgn(region2, NULL, &hrgn);
 891     ok(status == Ok, "status %08x\n", status);
 892     verify_region(hrgn, &test_rect);
 893     DeleteObject(hrgn);
 894
 895     status = GdipGetRegionHRgn(region2, graphics, &hrgn);
 896     ok(status == Ok, "status %08x\n", status);
 897     verify_region(hrgn, &scaled_rect);
 898     DeleteObject(hrgn);
 899
 900     status = GdipSetInfinite(region);
 901     ok(status == Ok, "status %08x\n", status);
 902     status = GdipCombineRegionRect(region, &test_rectF, CombineModeIntersect);
 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_rect);
 907     DeleteObject(hrgn);
 908
 909     status = GdipCombineRegionRect(region, &test_rectF, CombineModeReplace);
 910     ok(status == Ok, "status %08x\n", status);
 911     status = GdipCombineRegionRect(region, &test_rect2F, CombineModeUnion);
 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_rect3);
 916     DeleteObject(hrgn);
 917
 918     status = GdipCombineRegionRect(region, &test_rect3F, CombineModeReplace);
 919     ok(status == Ok, "status %08x\n", status);
 920     status = GdipCombineRegionRect(region, &test_rect2F, CombineModeXor);
 921     ok(status == Ok, "status %08x\n", status);
 922     status = GdipGetRegionHRgn(region, NULL, &hrgn);
 923     ok(status == Ok, "status %08x\n", status);
 924     verify_region(hrgn, &test_rect);
 925     DeleteObject(hrgn);
 926
 927     status = GdipCombineRegionRect(region, &test_rect3F, CombineModeReplace);
 928     ok(status == Ok, "status %08x\n", status);
 929     status = GdipCombineRegionRect(region, &test_rectF, CombineModeExclude);
 930     ok(status == Ok, "status %08x\n", status);
 931     status = GdipGetRegionHRgn(region, NULL, &hrgn);
 932     ok(status == Ok, "status %08x\n", status);
 933     verify_region(hrgn, &test_rect2);
 934     DeleteObject(hrgn);
 935
 936     status = GdipCombineRegionRect(region, &test_rectF, CombineModeReplace);
 937     ok(status == Ok, "status %08x\n", status);
 938     status = GdipCombineRegionRect(region, &test_rect3F, CombineModeComplement);
 939     ok(status == Ok, "status %08x\n", status);
 940     status = GdipGetRegionHRgn(region, NULL, &hrgn);
 941     ok(status == Ok, "status %08x\n", status);
 942     verify_region(hrgn, &test_rect2);
 943     DeleteObject(hrgn);
 944
 945     status = GdipDeletePath(path);
 946     ok(status == Ok, "status %08x\n", status);
 947     status = GdipDeleteRegion(region);
 948     ok(status == Ok, "status %08x\n", status);
 949     status = GdipDeleteRegion(region2);
 950     ok(status == Ok, "status %08x\n", status);
 951     status = GdipDeleteGraphics(graphics);
 952     ok(status == Ok, "status %08x\n", status);
 953     ReleaseDC(0, hdc);
 954 }
 955
 956 static void test_isequal(void)
 957 {
 958     GpRegion *region1, *region2;
 959     GpGraphics *graphics;
 960     GpRectF rectf;
 961     GpStatus status;
 962     HDC hdc = GetDC(0);
 963     BOOL res;
 964
 965     status = GdipCreateFromHDC(hdc, &graphics);
 966     ok(status == Ok, "status %08x\n", status);
 967
 968     status = GdipCreateRegion(&region1);
 969     ok(status == Ok, "status %08x\n", status);
 970     status = GdipCreateRegion(&region2);
 971     ok(status == Ok, "status %08x\n", status);
 972
 973     /* NULL */
 974     status = GdipIsEqualRegion(NULL, NULL, NULL, NULL);
 975     ok(status == InvalidParameter, "status %08x\n", status);
 976     status = GdipIsEqualRegion(region1, region2, NULL, NULL);
 977     ok(status == InvalidParameter, "status %08x\n", status);
 978     status = GdipIsEqualRegion(region1, region2, graphics, NULL);
 979     ok(status == InvalidParameter, "status %08x\n", status);
 980     status = GdipIsEqualRegion(region1, region2, NULL, &res);
 981     ok(status == InvalidParameter, "status %08x\n", status);
 982
 983     /* infinite regions */
 984     res = FALSE;
 985     status = GdipIsEqualRegion(region1, region2, graphics, &res);
 986     ok(status == Ok, "status %08x\n", status);
 987     ok(res, "Expected to be equal.\n");
 988     /* empty regions */
 989     status = GdipSetEmpty(region1);
 990     ok(status == Ok, "status %08x\n", status);
 991     status = GdipSetEmpty(region2);
 992     ok(status == Ok, "status %08x\n", status);
 993     res = FALSE;
 994     status = GdipIsEqualRegion(region1, region2, graphics, &res);
 995     ok(status == Ok, "status %08x\n", status);
 996     ok(res, "Expected to be equal.\n");
 997     /* empty & infinite */
 998     status = GdipSetInfinite(region1);
 999     ok(status == Ok, "status %08x\n", status);
1000     res = TRUE;
1001     status = GdipIsEqualRegion(region1, region2, graphics, &res);
1002     ok(status == Ok, "status %08x\n", status);
1003     ok(!res, "Expected to be unequal.\n");
1004     /* rect & (inf/empty) */
1005     rectf.X = rectf.Y = 0.0;
1006     rectf.Width = rectf.Height = 100.0;
1007     status = GdipCombineRegionRect(region1, &rectf, CombineModeReplace);
1008     ok(status == Ok, "status %08x\n", status);
1009     res = TRUE;
1010     status = GdipIsEqualRegion(region1, region2, graphics, &res);
1011     ok(status == Ok, "status %08x\n", status);
1012     ok(!res, "Expected to be unequal.\n");
1013     status = GdipSetInfinite(region2);
1014     ok(status == Ok, "status %08x\n", status);
1015     res = TRUE;
1016     status = GdipIsEqualRegion(region1, region2, graphics, &res);
1017     ok(status == Ok, "status %08x\n", status);
1018     ok(!res, "Expected to be unequal.\n");
1019     /* roughly equal rectangles */
1020     rectf.X = rectf.Y = 0.0;
1021     rectf.Width = rectf.Height = 100.001;
1022     status = GdipCombineRegionRect(region2, &rectf, CombineModeReplace);
1023     ok(status == Ok, "status %08x\n", status);
1024     res = FALSE;
1025     status = GdipIsEqualRegion(region1, region2, graphics, &res);
1026     ok(status == Ok, "status %08x\n", status);
1027     ok(res, "Expected to be equal.\n");
1028     /* equal rectangles */
1029     rectf.X = rectf.Y = 0.0;
1030     rectf.Width = rectf.Height = 100.0;
1031     status = GdipCombineRegionRect(region2, &rectf, CombineModeReplace);
1032     ok(status == Ok, "status %08x\n", status);
1033     res = FALSE;
1034     status = GdipIsEqualRegion(region1, region2, graphics, &res);
1035     ok(status == Ok, "status %08x\n", status);
1036     ok(res, "Expected to be equal.\n");
1037
1038     /* cleanup */
1039     status = GdipDeleteRegion(region1);
1040     ok(status == Ok, "status %08x\n", status);
1041     status = GdipDeleteRegion(region2);
1042     ok(status == Ok, "status %08x\n", status);
1043     status = GdipDeleteGraphics(graphics);
1044     ok(status == Ok, "status %08x\n", status);
1045     ReleaseDC(0, hdc);
1046 }
1047
1048 static void test_translate(void)
1049 {
1050     GpRegion *region, *region2;
1051     GpGraphics *graphics;
1052     GpPath *path;
1053     GpRectF rectf;
1054     GpStatus status;
1055     HDC hdc = GetDC(0);
1056     BOOL res;
1057
1058     status = GdipCreateFromHDC(hdc, &graphics);
1059     ok(status == Ok, "status %08x\n", status);
1060
1061     status = GdipCreatePath(FillModeAlternate, &path);
1062     ok(status == Ok, "status %08x\n", status);
1063
1064     status = GdipCreateRegion(&region);
1065     ok(status == Ok, "status %08x\n", status);
1066     status = GdipCreateRegion(&region2);
1067     ok(status == Ok, "status %08x\n", status);
1068
1069     /* NULL */
1070     status = GdipTranslateRegion(NULL, 0.0, 0.0);
1071     ok(status == InvalidParameter, "status %08x\n", status);
1072
1073     /* infinite */
1074     status = GdipTranslateRegion(region, 10.0, 10.0);
1075     ok(status == Ok, "status %08x\n", status);
1076     /* empty */
1077     status = GdipSetEmpty(region);
1078     ok(status == Ok, "status %08x\n", status);
1079     status = GdipTranslateRegion(region, 10.0, 10.0);
1080     ok(status == Ok, "status %08x\n", status);
1081     /* rect */
1082     rectf.X = 10.0; rectf.Y = 0.0;
1083     rectf.Width = rectf.Height = 100.0;
1084     status = GdipCombineRegionRect(region, &rectf, CombineModeReplace);
1085     ok(status == Ok, "status %08x\n", status);
1086     rectf.X = 15.0; rectf.Y = -2.0;
1087     rectf.Width = rectf.Height = 100.0;
1088     status = GdipCombineRegionRect(region2, &rectf, CombineModeReplace);
1089     ok(status == Ok, "status %08x\n", status);
1090     status = GdipTranslateRegion(region, 5.0, -2.0);
1091     ok(status == Ok, "status %08x\n", status);
1092     res = FALSE;
1093     status = GdipIsEqualRegion(region, region2, graphics, &res);
1094     ok(status == Ok, "status %08x\n", status);
1095     ok(res, "Expected to be equal.\n");
1096     /* path */
1097     status = GdipAddPathEllipse(path, 0.0, 10.0, 100.0, 150.0);
1098     ok(status == Ok, "status %08x\n", status);
1099     status = GdipCombineRegionPath(region, path, CombineModeReplace);
1100     ok(status == Ok, "status %08x\n", status);
1101     status = GdipResetPath(path);
1102     ok(status == Ok, "status %08x\n", status);
1103     status = GdipAddPathEllipse(path, 10.0, 21.0, 100.0, 150.0);
1104     ok(status == Ok, "status %08x\n", status);
1105     status = GdipCombineRegionPath(region2, path, CombineModeReplace);
1106     ok(status == Ok, "status %08x\n", status);
1107     status = GdipTranslateRegion(region, 10.0, 11.0);
1108     ok(status == Ok, "status %08x\n", status);
1109     res = FALSE;
1110     status = GdipIsEqualRegion(region, region2, graphics, &res);
1111     ok(status == Ok, "status %08x\n", status);
1112     ok(res, "Expected to be equal.\n");
1113
1114     status = GdipDeleteRegion(region);
1115     ok(status == Ok, "status %08x\n", status);
1116     status = GdipDeleteRegion(region2);
1117     ok(status == Ok, "status %08x\n", status);
1118     status = GdipDeleteGraphics(graphics);
1119     ok(status == Ok, "status %08x\n", status);
1120     status = GdipDeletePath(path);
1121     ok(status == Ok, "status %08x\n", status);
1122     ReleaseDC(0, hdc);
1123 }
1124
1125 static void test_getbounds(void)
1126 {
1127     GpRegion *region;
1128     GpGraphics *graphics;
1129     GpStatus status;
1130     GpRectF rectf;
1131     HDC hdc = GetDC(0);
1132
1133     status = GdipCreateFromHDC(hdc, &graphics);
1134     ok(status == Ok, "status %08x\n", status);
1135     status = GdipCreateRegion(&region);
1136     ok(status == Ok, "status %08x\n", status);
1137
1138     /* NULL */
1139     status = GdipGetRegionBounds(NULL, NULL, NULL);
1140     ok(status == InvalidParameter, "status %08x\n", status);
1141     status = GdipGetRegionBounds(region, NULL, NULL);
1142     ok(status == InvalidParameter, "status %08x\n", status);
1143     status = GdipGetRegionBounds(region, graphics, NULL);
1144     ok(status == InvalidParameter, "status %08x\n", status);
1145     /* infinite */
1146     rectf.X = rectf.Y = 0.0;
1147     rectf.Height = rectf.Width = 100.0;
1148     status = GdipGetRegionBounds(region, graphics, &rectf);
1149     ok(status == Ok, "status %08x\n", status);
1150     ok(rectf.X == -(REAL)(1 << 22), "Expected X = %.2f, got %.2f\n", -(REAL)(1 << 22), rectf.X);
1151     ok(rectf.Y == -(REAL)(1 << 22), "Expected Y = %.2f, got %.2f\n", -(REAL)(1 << 22), rectf.Y);
1152     ok(rectf.Width  == (REAL)(1 << 23), "Expected width = %.2f, got %.2f\n", (REAL)(1 << 23), rectf.Width);
1153     ok(rectf.Height == (REAL)(1 << 23), "Expected height = %.2f, got %.2f\n",(REAL)(1 << 23), rectf.Height);
1154     /* empty */
1155     rectf.X = rectf.Y = 0.0;
1156     rectf.Height = rectf.Width = 100.0;
1157     status = GdipSetEmpty(region);
1158     ok(status == Ok, "status %08x\n", status);
1159     status = GdipGetRegionBounds(region, graphics, &rectf);
1160     ok(status == Ok, "status %08x\n", status);
1161     ok(rectf.X == 0.0, "Expected X = 0.0, got %.2f\n", rectf.X);
1162     ok(rectf.Y == 0.0, "Expected Y = 0.0, got %.2f\n", rectf.Y);
1163     ok(rectf.Width  == 0.0, "Expected width = 0.0, got %.2f\n", rectf.Width);
1164     ok(rectf.Height == 0.0, "Expected height = 0.0, got %.2f\n", rectf.Height);
1165     /* rect */
1166     rectf.X = 10.0; rectf.Y = 0.0;
1167     rectf.Width = rectf.Height = 100.0;
1168     status = GdipCombineRegionRect(region, &rectf, CombineModeReplace);
1169     ok(status == Ok, "status %08x\n", status);
1170     rectf.X = rectf.Y = 0.0;
1171     rectf.Height = rectf.Width = 0.0;
1172     status = GdipGetRegionBounds(region, graphics, &rectf);
1173     ok(status == Ok, "status %08x\n", status);
1174     ok(rectf.X == 10.0, "Expected X = 0.0, got %.2f\n", rectf.X);
1175     ok(rectf.Y == 0.0, "Expected Y = 0.0, got %.2f\n", rectf.Y);
1176     ok(rectf.Width  == 100.0, "Expected width = 0.0, got %.2f\n", rectf.Width);
1177     ok(rectf.Height == 100.0, "Expected height = 0.0, got %.2f\n", rectf.Height);
1178
1179     status = GdipDeleteRegion(region);
1180     ok(status == Ok, "status %08x\n", status);
1181     status = GdipDeleteGraphics(graphics);
1182     ok(status == Ok, "status %08x\n", status);
1183     ReleaseDC(0, hdc);
1184 }
1185
1186 START_TEST(region)
1187 {
1188     struct GdiplusStartupInput gdiplusStartupInput;
1189     ULONG_PTR gdiplusToken;
1190
1191     gdiplusStartupInput.GdiplusVersion              = 1;
1192     gdiplusStartupInput.DebugEventCallback          = NULL;
1193     gdiplusStartupInput.SuppressBackgroundThread    = 0;
1194     gdiplusStartupInput.SuppressExternalCodecs      = 0;
1195
1196     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
1197
1198     test_getregiondata();
1199     test_isinfinite();
1200     test_isempty();
1201     test_combinereplace();
1202     test_fromhrgn();
1203     test_gethrgn();
1204     test_isequal();
1205     test_translate();
1206     test_getbounds();
1207
1208     GdiplusShutdown(gdiplusToken);
1209 }