dlls/gdiplus/region.c

   1 /*
   2  * Copyright (C) 2008 Google (Lei Zhang)
   3  * Copyright (C) 2013 Dmitry Timoshkov
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdarg.h>
  21
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "wingdi.h"
  25
  26 #include "objbase.h"
  27
  28 #include "gdiplus.h"
  29 #include "gdiplus_private.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  33
  34 /**********************************************************
  35  *
  36  * Data returned by GdipGetRegionData looks something like this:
  37  *
  38  * struct region_data_header
  39  * {
  40  *   DWORD size;     size in bytes of the data - 8.
  41  *   DWORD magic1;   probably a checksum.
  42  *   DWORD magic2;   always seems to be 0xdbc01001 - version?
  43  *   DWORD num_ops;  number of combining ops * 2
  44  * };
  45  *
  46  * Then follows a sequence of combining ops and region elements.
  47  *
  48  * A region element is either a RECTF or some path data.
  49  *
  50  * Combining ops are just stored as their CombineMode value.
  51  *
  52  * Each RECTF is preceded by the DWORD 0x10000000.  An empty rect is
  53  * stored as 0x10000002 (with no following RECTF) and an infinite rect
  54  * is stored as 0x10000003 (again with no following RECTF).
  55  *
  56  * Path data is preceded by the DWORD 0x10000001.  Then follows a
  57  * DWORD size and then size bytes of data.
  58  *
  59  * The combining ops are stored in the reverse order to the region
  60  * elements and in the reverse order to which the region was
  61  * constructed.
  62  *
  63  * When two or more complex regions (ie those with more than one
  64  * element) are combined, the combining op for the two regions comes
  65  * first, then the combining ops for the region elements in region 1,
  66  * followed by the region elements for region 1, then follows the
  67  * combining ops for region 2 and finally region 2's region elements.
  68  * Presumably you're supposed to use the 0x1000000x header to find the
  69  * end of the op list (the count of the elements in each region is not
  70  * stored).
  71  *
  72  * When a simple region (1 element) is combined, it's treated as if a
  73  * single rect/path is being combined.
  74  *
  75  */
  76
  77 #define FLAGS_INTPATH   0x4000
  78
  79 struct memory_buffer
  80 {
  81     const BYTE *buffer;
  82     INT size, pos;
  83 };
  84
  85 struct region_header
  86 {
  87     DWORD magic;
  88     DWORD num_children;
  89 };
  90
  91 struct region_data_header
  92 {
  93     DWORD size;
  94     DWORD checksum;
  95     struct region_header header;
  96 };
  97
  98 struct path_header
  99 {
 100     DWORD size;
 101     DWORD magic;
 102     DWORD count;
 103     DWORD flags;
 104 };
 105
 106 typedef struct packed_point
 107 {
 108     short X;
 109     short Y;
 110 } packed_point;
 111
 112 static inline INT get_element_size(const region_element* element)
 113 {
 114     INT needed = sizeof(DWORD); /* DWORD for the type */
 115     switch(element->type)
 116     {
 117         case RegionDataRect:
 118             return needed + sizeof(GpRect);
 119         case RegionDataPath:
 120         {
 121             needed += write_path_data(element->elementdata.path, NULL);
 122             needed += sizeof(DWORD); /* Extra DWORD for path size */
 123             return needed;
 124         }
 125         case RegionDataEmptyRect:
 126         case RegionDataInfiniteRect:
 127             return needed;
 128         default:
 129             needed += get_element_size(element->elementdata.combine.left);
 130             needed += get_element_size(element->elementdata.combine.right);
 131             return needed;
 132     }
 133
 134     return 0;
 135 }
 136
 137 /* Does not check parameters, caller must do that */
 138 static inline GpStatus init_region(GpRegion* region, const RegionType type)
 139 {
 140     region->node.type    = type;
 141     region->num_children = 0;
 142
 143     return Ok;
 144 }
 145
 146 static inline GpStatus clone_element(const region_element* element,
 147         region_element** element2)
 148 {
 149     GpStatus stat;
 150
 151     /* root node is allocated with GpRegion */
 152     if(!*element2){
 153         *element2 = heap_alloc_zero(sizeof(region_element));
 154         if (!*element2)
 155             return OutOfMemory;
 156     }
 157
 158     (*element2)->type = element->type;
 159
 160     switch (element->type)
 161     {
 162         case RegionDataRect:
 163             (*element2)->elementdata.rect = element->elementdata.rect;
 164             return Ok;
 165         case RegionDataEmptyRect:
 166         case RegionDataInfiniteRect:
 167             return Ok;
 168         case RegionDataPath:
 169             stat = GdipClonePath(element->elementdata.path, &(*element2)->elementdata.path);
 170             if (stat == Ok) return Ok;
 171             break;
 172         default:
 173             (*element2)->elementdata.combine.left  = NULL;
 174             (*element2)->elementdata.combine.right = NULL;
 175
 176             stat = clone_element(element->elementdata.combine.left,
 177                     &(*element2)->elementdata.combine.left);
 178             if (stat == Ok)
 179             {
 180                 stat = clone_element(element->elementdata.combine.right,
 181                         &(*element2)->elementdata.combine.right);
 182                 if (stat == Ok) return Ok;
 183             }
 184             break;
 185     }
 186
 187     delete_element(*element2);
 188     *element2 = NULL;
 189     return stat;
 190 }
 191
 192 /* Common code for CombineRegion*
 193  * All the caller has to do is get its format into an element
 194  */
 195 static inline void fuse_region(GpRegion* region, region_element* left,
 196         region_element* right, const CombineMode mode)
 197 {
 198     region->node.type = mode;
 199     region->node.elementdata.combine.left = left;
 200     region->node.elementdata.combine.right = right;
 201     region->num_children += 2;
 202 }
 203
 204 /*****************************************************************************
 205  * GdipCloneRegion [GDIPLUS.@]
 206  *
 207  * Creates a deep copy of the region
 208  *
 209  * PARAMS
 210  *  region  [I] source region
 211  *  clone   [O] resulting clone
 212  *
 213  * RETURNS
 214  *  SUCCESS: Ok
 215  *  FAILURE: InvalidParameter or OutOfMemory
 216  */
 217 GpStatus WINGDIPAPI GdipCloneRegion(GpRegion *region, GpRegion **clone)
 218 {
 219     region_element *element;
 220
 221     TRACE("%p %p\n", region, clone);
 222
 223     if (!(region && clone))
 224         return InvalidParameter;
 225
 226     *clone = heap_alloc_zero(sizeof(GpRegion));
 227     if (!*clone)
 228         return OutOfMemory;
 229     element = &(*clone)->node;
 230
 231     (*clone)->num_children = region->num_children;
 232     return clone_element(&region->node, &element);
 233 }
 234
 235 /*****************************************************************************
 236  * GdipCombineRegionPath [GDIPLUS.@]
 237  */
 238 GpStatus WINGDIPAPI GdipCombineRegionPath(GpRegion *region, GpPath *path, CombineMode mode)
 239 {
 240     GpRegion *path_region;
 241     region_element *left, *right = NULL;
 242     GpStatus stat;
 243
 244     TRACE("%p %p %d\n", region, path, mode);
 245
 246     if (!(region && path))
 247         return InvalidParameter;
 248
 249     stat = GdipCreateRegionPath(path, &path_region);
 250     if (stat != Ok)
 251         return stat;
 252
 253     /* simply replace region data */
 254     if(mode == CombineModeReplace){
 255         delete_element(&region->node);
 256         memcpy(region, path_region, sizeof(GpRegion));
 257         heap_free(path_region);
 258         return Ok;
 259     }
 260
 261     left = heap_alloc_zero(sizeof(region_element));
 262     if (left)
 263     {
 264         *left = region->node;
 265         stat = clone_element(&path_region->node, &right);
 266         if (stat == Ok)
 267         {
 268             fuse_region(region, left, right, mode);
 269             GdipDeleteRegion(path_region);
 270             return Ok;
 271         }
 272     }
 273     else
 274         stat = OutOfMemory;
 275
 276     heap_free(left);
 277     GdipDeleteRegion(path_region);
 278     return stat;
 279 }
 280
 281 /*****************************************************************************
 282  * GdipCombineRegionRect [GDIPLUS.@]
 283  */
 284 GpStatus WINGDIPAPI GdipCombineRegionRect(GpRegion *region,
 285         GDIPCONST GpRectF *rect, CombineMode mode)
 286 {
 287     GpRegion *rect_region;
 288     region_element *left, *right = NULL;
 289     GpStatus stat;
 290
 291     TRACE("%p %s %d\n", region, debugstr_rectf(rect), mode);
 292
 293     if (!(region && rect))
 294         return InvalidParameter;
 295
 296     stat = GdipCreateRegionRect(rect, &rect_region);
 297     if (stat != Ok)
 298         return stat;
 299
 300     /* simply replace region data */
 301     if(mode == CombineModeReplace){
 302         delete_element(&region->node);
 303         memcpy(region, rect_region, sizeof(GpRegion));
 304         heap_free(rect_region);
 305         return Ok;
 306     }
 307
 308     left = heap_alloc_zero(sizeof(region_element));
 309     if (left)
 310     {
 311         memcpy(left, &region->node, sizeof(region_element));
 312         stat = clone_element(&rect_region->node, &right);
 313         if (stat == Ok)
 314         {
 315             fuse_region(region, left, right, mode);
 316             GdipDeleteRegion(rect_region);
 317             return Ok;
 318         }
 319     }
 320     else
 321         stat = OutOfMemory;
 322
 323     heap_free(left);
 324     GdipDeleteRegion(rect_region);
 325     return stat;
 326 }
 327
 328 /*****************************************************************************
 329  * GdipCombineRegionRectI [GDIPLUS.@]
 330  */
 331 GpStatus WINGDIPAPI GdipCombineRegionRectI(GpRegion *region,
 332         GDIPCONST GpRect *rect, CombineMode mode)
 333 {
 334     GpRectF rectf;
 335
 336     TRACE("%p %p %d\n", region, rect, mode);
 337
 338     if (!rect)
 339         return InvalidParameter;
 340
 341     rectf.X = (REAL)rect->X;
 342     rectf.Y = (REAL)rect->Y;
 343     rectf.Height = (REAL)rect->Height;
 344     rectf.Width = (REAL)rect->Width;
 345
 346     return GdipCombineRegionRect(region, &rectf, mode);
 347 }
 348
 349 /*****************************************************************************
 350  * GdipCombineRegionRegion [GDIPLUS.@]
 351  */
 352 GpStatus WINGDIPAPI GdipCombineRegionRegion(GpRegion *region1,
 353         GpRegion *region2, CombineMode mode)
 354 {
 355     region_element *left, *right = NULL;
 356     GpStatus stat;
 357     GpRegion *reg2copy;
 358
 359     TRACE("%p %p %d\n", region1, region2, mode);
 360
 361     if(!(region1 && region2))
 362         return InvalidParameter;
 363
 364     /* simply replace region data */
 365     if(mode == CombineModeReplace){
 366         stat = GdipCloneRegion(region2, &reg2copy);
 367         if(stat != Ok)  return stat;
 368
 369         delete_element(&region1->node);
 370         memcpy(region1, reg2copy, sizeof(GpRegion));
 371         heap_free(reg2copy);
 372         return Ok;
 373     }
 374
 375     left  = heap_alloc_zero(sizeof(region_element));
 376     if (!left)
 377         return OutOfMemory;
 378
 379     *left = region1->node;
 380     stat = clone_element(&region2->node, &right);
 381     if (stat != Ok)
 382     {
 383         heap_free(left);
 384         return OutOfMemory;
 385     }
 386
 387     fuse_region(region1, left, right, mode);
 388     region1->num_children += region2->num_children;
 389
 390     return Ok;
 391 }
 392
 393 /*****************************************************************************
 394  * GdipCreateRegion [GDIPLUS.@]
 395  */
 396 GpStatus WINGDIPAPI GdipCreateRegion(GpRegion **region)
 397 {
 398     TRACE("%p\n", region);
 399
 400     if(!region)
 401         return InvalidParameter;
 402
 403     *region = heap_alloc_zero(sizeof(GpRegion));
 404     if(!*region)
 405         return OutOfMemory;
 406
 407     TRACE("=> %p\n", *region);
 408
 409     return init_region(*region, RegionDataInfiniteRect);
 410 }
 411
 412 /*****************************************************************************
 413  * GdipCreateRegionPath [GDIPLUS.@]
 414  *
 415  * Creates a GpRegion from a GpPath
 416  *
 417  * PARAMS
 418  *  path    [I] path to base the region on
 419  *  region  [O] pointer to the newly allocated region
 420  *
 421  * RETURNS
 422  *  SUCCESS: Ok
 423  *  FAILURE: InvalidParameter
 424  *
 425  * NOTES
 426  *  If a path has no floating point points, its points will be stored as shorts
 427  *  (INTPATH)
 428  *
 429  *  If a path is empty, it is considered to be an INTPATH
 430  */
 431 GpStatus WINGDIPAPI GdipCreateRegionPath(GpPath *path, GpRegion **region)
 432 {
 433     region_element* element;
 434     GpStatus stat;
 435
 436     TRACE("%p, %p\n", path, region);
 437
 438     if (!(path && region))
 439         return InvalidParameter;
 440
 441     *region = heap_alloc_zero(sizeof(GpRegion));
 442     if(!*region)
 443         return OutOfMemory;
 444     stat = init_region(*region, RegionDataPath);
 445     if (stat != Ok)
 446     {
 447         GdipDeleteRegion(*region);
 448         return stat;
 449     }
 450     element = &(*region)->node;
 451
 452     stat = GdipClonePath(path, &element->elementdata.path);
 453     if (stat != Ok)
 454     {
 455         GdipDeleteRegion(*region);
 456         return stat;
 457     }
 458
 459     return Ok;
 460 }
 461
 462 /*****************************************************************************
 463  * GdipCreateRegionRect [GDIPLUS.@]
 464  */
 465 GpStatus WINGDIPAPI GdipCreateRegionRect(GDIPCONST GpRectF *rect,
 466         GpRegion **region)
 467 {
 468     GpStatus stat;
 469
 470     TRACE("%p, %p\n", rect, region);
 471
 472     if (!(rect && region))
 473         return InvalidParameter;
 474
 475     *region = heap_alloc_zero(sizeof(GpRegion));
 476     stat = init_region(*region, RegionDataRect);
 477     if(stat != Ok)
 478     {
 479         GdipDeleteRegion(*region);
 480         return stat;
 481     }
 482
 483     (*region)->node.elementdata.rect.X = rect->X;
 484     (*region)->node.elementdata.rect.Y = rect->Y;
 485     (*region)->node.elementdata.rect.Width = rect->Width;
 486     (*region)->node.elementdata.rect.Height = rect->Height;
 487
 488     return Ok;
 489 }
 490
 491 /*****************************************************************************
 492  * GdipCreateRegionRectI [GDIPLUS.@]
 493  */
 494 GpStatus WINGDIPAPI GdipCreateRegionRectI(GDIPCONST GpRect *rect,
 495         GpRegion **region)
 496 {
 497     GpRectF rectf;
 498
 499     TRACE("%p, %p\n", rect, region);
 500
 501     rectf.X = (REAL)rect->X;
 502     rectf.Y = (REAL)rect->Y;
 503     rectf.Width = (REAL)rect->Width;
 504     rectf.Height = (REAL)rect->Height;
 505
 506     return GdipCreateRegionRect(&rectf, region);
 507 }
 508
 509 /******************************************************************************
 510  * GdipCreateRegionHrgn [GDIPLUS.@]
 511  */
 512 GpStatus WINGDIPAPI GdipCreateRegionHrgn(HRGN hrgn, GpRegion **region)
 513 {
 514     DWORD size;
 515     LPRGNDATA buf;
 516     LPRECT rect;
 517     GpStatus stat;
 518     GpPath* path;
 519     GpRegion* local;
 520     DWORD i;
 521
 522     TRACE("(%p, %p)\n", hrgn, region);
 523
 524     if(!region || !(size = GetRegionData(hrgn, 0, NULL)))
 525         return InvalidParameter;
 526
 527     buf = heap_alloc_zero(size);
 528     if(!buf)
 529         return OutOfMemory;
 530
 531     if(!GetRegionData(hrgn, size, buf)){
 532         heap_free(buf);
 533         return GenericError;
 534     }
 535
 536     if(buf->rdh.nCount == 0){
 537         if((stat = GdipCreateRegion(&local)) != Ok){
 538             heap_free(buf);
 539             return stat;
 540         }
 541         if((stat = GdipSetEmpty(local)) != Ok){
 542             heap_free(buf);
 543             GdipDeleteRegion(local);
 544             return stat;
 545         }
 546         *region = local;
 547         heap_free(buf);
 548         return Ok;
 549     }
 550
 551     if((stat = GdipCreatePath(FillModeAlternate, &path)) != Ok){
 552         heap_free(buf);
 553         return stat;
 554     }
 555
 556     rect = (LPRECT)buf->Buffer;
 557     for(i = 0; i < buf->rdh.nCount; i++){
 558         if((stat = GdipAddPathRectangle(path, (REAL)rect->left, (REAL)rect->top,
 559                         (REAL)(rect->right - rect->left), (REAL)(rect->bottom - rect->top))) != Ok){
 560             heap_free(buf);
 561             GdipDeletePath(path);
 562             return stat;
 563         }
 564         rect++;
 565     }
 566
 567     stat = GdipCreateRegionPath(path, region);
 568
 569     heap_free(buf);
 570     GdipDeletePath(path);
 571     return stat;
 572 }
 573
 574 /*****************************************************************************
 575  * GdipDeleteRegion [GDIPLUS.@]
 576  */
 577 GpStatus WINGDIPAPI GdipDeleteRegion(GpRegion *region)
 578 {
 579     TRACE("%p\n", region);
 580
 581     if (!region)
 582         return InvalidParameter;
 583
 584     delete_element(&region->node);
 585     heap_free(region);
 586
 587     return Ok;
 588 }
 589
 590 /*****************************************************************************
 591  * GdipGetRegionBounds [GDIPLUS.@]
 592  */
 593 GpStatus WINGDIPAPI GdipGetRegionBounds(GpRegion *region, GpGraphics *graphics, GpRectF *rect)
 594 {
 595     HRGN hrgn;
 596     RECT r;
 597     GpStatus status;
 598
 599     TRACE("(%p, %p, %p)\n", region, graphics, rect);
 600
 601     if(!region || !graphics || !rect)
 602         return InvalidParameter;
 603
 604     /* Contrary to MSDN, native ignores the graphics transform. */
 605     status = GdipGetRegionHRgn(region, NULL, &hrgn);
 606     if(status != Ok)
 607         return status;
 608
 609     /* infinite */
 610     if(!hrgn){
 611         rect->X = rect->Y = -(REAL)(1 << 22);
 612         rect->Width = rect->Height = (REAL)(1 << 23);
 613         TRACE("%p => infinite\n", region);
 614         return Ok;
 615     }
 616
 617     if(GetRgnBox(hrgn, &r)){
 618         rect->X = r.left;
 619         rect->Y = r.top;
 620         rect->Width  = r.right  - r.left;
 621         rect->Height = r.bottom - r.top;
 622         TRACE("%p => %s\n", region, debugstr_rectf(rect));
 623     }
 624     else
 625         status = GenericError;
 626
 627     DeleteObject(hrgn);
 628
 629     return status;
 630 }
 631
 632 /*****************************************************************************
 633  * GdipGetRegionBoundsI [GDIPLUS.@]
 634  */
 635 GpStatus WINGDIPAPI GdipGetRegionBoundsI(GpRegion *region, GpGraphics *graphics, GpRect *rect)
 636 {
 637     GpRectF rectf;
 638     GpStatus status;
 639
 640     TRACE("(%p, %p, %p)\n", region, graphics, rect);
 641
 642     if(!rect)
 643         return InvalidParameter;
 644
 645     status = GdipGetRegionBounds(region, graphics, &rectf);
 646     if(status == Ok){
 647         rect->X = gdip_round(rectf.X);
 648         rect->Y = gdip_round(rectf.Y);
 649         rect->Width  = gdip_round(rectf.Width);
 650         rect->Height = gdip_round(rectf.Height);
 651     }
 652
 653     return status;
 654 }
 655
 656 static inline void write_dword(DWORD* location, INT* offset, const DWORD write)
 657 {
 658     location[*offset] = write;
 659     (*offset)++;
 660 }
 661
 662 static inline void write_float(DWORD* location, INT* offset, const FLOAT write)
 663 {
 664     ((FLOAT*)location)[*offset] = write;
 665     (*offset)++;
 666 }
 667
 668 static void write_element(const region_element* element, DWORD *buffer,
 669         INT* filled)
 670 {
 671     write_dword(buffer, filled, element->type);
 672     switch (element->type)
 673     {
 674         case CombineModeReplace:
 675         case CombineModeIntersect:
 676         case CombineModeUnion:
 677         case CombineModeXor:
 678         case CombineModeExclude:
 679         case CombineModeComplement:
 680             write_element(element->elementdata.combine.left, buffer, filled);
 681             write_element(element->elementdata.combine.right, buffer, filled);
 682             break;
 683         case RegionDataRect:
 684             write_float(buffer, filled, element->elementdata.rect.X);
 685             write_float(buffer, filled, element->elementdata.rect.Y);
 686             write_float(buffer, filled, element->elementdata.rect.Width);
 687             write_float(buffer, filled, element->elementdata.rect.Height);
 688             break;
 689         case RegionDataPath:
 690         {
 691             DWORD size = write_path_data(element->elementdata.path, buffer + *filled + 1);
 692             write_dword(buffer, filled, size);
 693             *filled += size / sizeof(DWORD);
 694             break;
 695         }
 696         case RegionDataEmptyRect:
 697         case RegionDataInfiniteRect:
 698             break;
 699     }
 700 }
 701
 702 DWORD write_region_data(const GpRegion *region, void *data)
 703 {
 704     struct region_header *header = data;
 705     INT filled = 0;
 706     DWORD size;
 707
 708     size = sizeof(struct region_header) + get_element_size(&region->node);
 709     if (!data) return size;
 710
 711     header->magic = VERSION_MAGIC2;
 712     header->num_children = region->num_children;
 713     filled += 2;
 714     /* With few exceptions, everything written is DWORD aligned,
 715      * so use that as our base */
 716     write_element(&region->node, (DWORD*)data, &filled);
 717     return size;
 718 }
 719
 720 /*****************************************************************************
 721  * GdipGetRegionData [GDIPLUS.@]
 722  *
 723  * Returns the header, followed by combining ops and region elements.
 724  *
 725  * PARAMS
 726  *  region  [I] region to retrieve from
 727  *  buffer  [O] buffer to hold the resulting data
 728  *  size    [I] size of the buffer
 729  *  needed  [O] (optional) how much data was written
 730  *
 731  * RETURNS
 732  *  SUCCESS: Ok
 733  *  FAILURE: InvalidParameter
 734  *
 735  * NOTES
 736  *  The header contains the size, a checksum, a version string, and the number
 737  *  of children. The size does not count itself or the checksum.
 738  *  Version is always something like 0xdbc01001 or 0xdbc01002
 739  *
 740  *  An element is a RECT, or PATH; Combining ops are stored as their
 741  *  CombineMode value. Special regions (infinite, empty) emit just their
 742  *  op-code; GpRectFs emit their code followed by their points; GpPaths emit
 743  *  their code followed by a second header for the path followed by the actual
 744  *  path data. Followed by the flags for each point. The pathheader contains
 745  *  the size of the data to follow, a version number again, followed by a count
 746  *  of how many points, and any special flags which may apply. 0x4000 means it's
 747  *  a path of shorts instead of FLOAT.
 748  *
 749  *  Combining Ops are stored in reverse order from when they were constructed;
 750  *  the output is a tree where the left side combining area is always taken
 751  *  first.
 752  */
 753 GpStatus WINGDIPAPI GdipGetRegionData(GpRegion *region, BYTE *buffer, UINT size,
 754         UINT *needed)
 755 {
 756     struct region_data_header *region_data_header;
 757     UINT required;
 758
 759     TRACE("%p, %p, %d, %p\n", region, buffer, size, needed);
 760
 761     if (!region || !buffer || !size)
 762         return InvalidParameter;
 763
 764     required = FIELD_OFFSET(struct region_data_header, header) + write_region_data(region, NULL);
 765     if (size < required)
 766     {
 767         if (needed) *needed = size;
 768         return InsufficientBuffer;
 769     }
 770
 771     region_data_header = (struct region_data_header *)buffer;
 772     region_data_header->size = write_region_data(region, &region_data_header->header);
 773     region_data_header->checksum = 0;
 774
 775     if (needed)
 776         *needed = required;
 777
 778     return Ok;
 779 }
 780
 781 static inline void init_memory_buffer(struct memory_buffer *mbuf, const BYTE *buffer, INT size)
 782 {
 783     mbuf->buffer = buffer;
 784     mbuf->size = size;
 785     mbuf->pos = 0;
 786 }
 787
 788 static inline const void *buffer_read(struct memory_buffer *mbuf, INT size)
 789 {
 790     if (mbuf->size - mbuf->pos >= size)
 791     {
 792         const void *data = mbuf->buffer + mbuf->pos;
 793         mbuf->pos += size;
 794         return data;
 795     }
 796     return NULL;
 797 }
 798
 799 static GpStatus read_element(struct memory_buffer *mbuf, GpRegion *region, region_element *node, INT *count)
 800 {
 801     GpStatus status;
 802     const DWORD *type;
 803
 804     type = buffer_read(mbuf, sizeof(*type));
 805     if (!type) return Ok;
 806
 807     TRACE("type %#x\n", *type);
 808
 809     node->type = *type;
 810
 811     switch (node->type)
 812     {
 813     case CombineModeReplace:
 814     case CombineModeIntersect:
 815     case CombineModeUnion:
 816     case CombineModeXor:
 817     case CombineModeExclude:
 818     case CombineModeComplement:
 819     {
 820         region_element *left, *right;
 821
 822         left = heap_alloc_zero(sizeof(region_element));
 823         if (!left) return OutOfMemory;
 824         right = heap_alloc_zero(sizeof(region_element));
 825         if (!right)
 826         {
 827             heap_free(left);
 828             return OutOfMemory;
 829         }
 830
 831         status = read_element(mbuf, region, left, count);
 832         if (status == Ok)
 833         {
 834             status = read_element(mbuf, region, right, count);
 835             if (status == Ok)
 836             {
 837                 node->elementdata.combine.left = left;
 838                 node->elementdata.combine.right = right;
 839                 region->num_children += 2;
 840                 return Ok;
 841             }
 842         }
 843
 844         heap_free(left);
 845         heap_free(right);
 846         return status;
 847     }
 848
 849     case RegionDataRect:
 850     {
 851         const GpRectF *rc;
 852
 853         rc = buffer_read(mbuf, sizeof(*rc));
 854         if (!rc)
 855         {
 856             ERR("failed to read rect data\n");
 857             return InvalidParameter;
 858         }
 859
 860         node->elementdata.rect = *rc;
 861         *count += 1;
 862         return Ok;
 863     }
 864
 865     case RegionDataPath:
 866     {
 867         GpPath *path;
 868         const struct path_header *path_header;
 869         const BYTE *types;
 870
 871         path_header = buffer_read(mbuf, sizeof(*path_header));
 872         if (!path_header)
 873         {
 874             ERR("failed to read path header\n");
 875             return InvalidParameter;
 876         }
 877         if (!VALID_MAGIC(path_header->magic))
 878         {
 879             ERR("invalid path header magic %#x\n", path_header->magic);
 880             return InvalidParameter;
 881         }
 882
 883         /* Windows always fails to create an empty path in a region */
 884         if (!path_header->count)
 885         {
 886             TRACE("refusing to create an empty path in a region\n");
 887             return GenericError;
 888         }
 889
 890         status = GdipCreatePath(FillModeAlternate, &path);
 891         if (status) return status;
 892
 893         node->elementdata.path = path;
 894
 895         if (!lengthen_path(path, path_header->count))
 896             return OutOfMemory;
 897
 898         path->pathdata.Count = path_header->count;
 899
 900         if (path_header->flags & ~FLAGS_INTPATH)
 901             FIXME("unhandled path flags %#x\n", path_header->flags);
 902
 903         if (path_header->flags & FLAGS_INTPATH)
 904         {
 905             const packed_point *pt;
 906             DWORD i;
 907
 908             pt = buffer_read(mbuf, sizeof(*pt) * path_header->count);
 909             if (!pt)
 910             {
 911                 ERR("failed to read packed %u path points\n", path_header->count);
 912                 return InvalidParameter;
 913             }
 914
 915             for (i = 0; i < path_header->count; i++)
 916             {
 917                 path->pathdata.Points[i].X = (REAL)pt[i].X;
 918                 path->pathdata.Points[i].Y = (REAL)pt[i].Y;
 919             }
 920         }
 921         else
 922         {
 923             const GpPointF *ptf;
 924
 925             ptf = buffer_read(mbuf, sizeof(*ptf) * path_header->count);
 926             if (!ptf)
 927             {
 928                 ERR("failed to read %u path points\n", path_header->count);
 929                 return InvalidParameter;
 930             }
 931             memcpy(path->pathdata.Points, ptf, sizeof(*ptf) * path_header->count);
 932         }
 933
 934         types = buffer_read(mbuf, path_header->count);
 935         if (!types)
 936         {
 937             ERR("failed to read %u path types\n", path_header->count);
 938             return InvalidParameter;
 939         }
 940         memcpy(path->pathdata.Types, types, path_header->count);
 941         if (path_header->count & 3)
 942         {
 943             if (!buffer_read(mbuf, 4 - (path_header->count & 3)))
 944             {
 945                 ERR("failed to read rounding %u bytes\n", 4 - (path_header->count & 3));
 946                 return InvalidParameter;
 947             }
 948         }
 949
 950         *count += 1;
 951         return Ok;
 952     }
 953
 954     case RegionDataEmptyRect:
 955     case RegionDataInfiniteRect:
 956         *count += 1;
 957         return Ok;
 958
 959     default:
 960         FIXME("element type %#x is not supported\n", *type);
 961         break;
 962     }
 963
 964     return InvalidParameter;
 965 }
 966
 967 /*****************************************************************************
 968  * GdipCreateRegionRgnData [GDIPLUS.@]
 969  */
 970 GpStatus WINGDIPAPI GdipCreateRegionRgnData(GDIPCONST BYTE *data, INT size, GpRegion **region)
 971 {
 972     const struct region_data_header *region_data_header;
 973     struct memory_buffer mbuf;
 974     GpStatus status;
 975     INT count;
 976
 977     TRACE("(%p, %d, %p)\n", data, size, region);
 978
 979     if (!data || !size)
 980         return InvalidParameter;
 981
 982     init_memory_buffer(&mbuf, data, size);
 983
 984     region_data_header = buffer_read(&mbuf, sizeof(*region_data_header));
 985     if (!region_data_header || !VALID_MAGIC(region_data_header->header.magic))
 986         return InvalidParameter;
 987
 988     status = GdipCreateRegion(region);
 989     if (status != Ok)
 990         return status;
 991
 992     count = 0;
 993     status = read_element(&mbuf, *region, &(*region)->node, &count);
 994     if (status == Ok && !count)
 995         status = InvalidParameter;
 996
 997     if (status != Ok)
 998     {
 999         GdipDeleteRegion(*region);
1000         *region = NULL;
1001     }
1002
1003     return status;
1004 }
1005
1006 /*****************************************************************************
1007  * GdipGetRegionDataSize [GDIPLUS.@]
1008  */
1009 GpStatus WINGDIPAPI GdipGetRegionDataSize(GpRegion *region, UINT *needed)
1010 {
1011     TRACE("%p, %p\n", region, needed);
1012
1013     if (!(region && needed))
1014         return InvalidParameter;
1015
1016     /* header.size doesn't count header.size and header.checksum */
1017     *needed = FIELD_OFFSET(struct region_data_header, header) + write_region_data(region, NULL);
1018
1019     return Ok;
1020 }
1021
1022 static GpStatus get_path_hrgn(GpPath *path, GpGraphics *graphics, HRGN *hrgn)
1023 {
1024     HDC new_hdc=NULL;
1025     GpGraphics *new_graphics=NULL;
1026     GpStatus stat;
1027     INT save_state;
1028
1029     if (!path->pathdata.Count)  /* PathToRegion doesn't support empty paths */
1030     {
1031         *hrgn = CreateRectRgn( 0, 0, 0, 0 );
1032         return *hrgn ? Ok : OutOfMemory;
1033     }
1034
1035     if (!graphics)
1036     {
1037         new_hdc = CreateCompatibleDC(0);
1038         if (!new_hdc)
1039             return OutOfMemory;
1040
1041         stat = GdipCreateFromHDC(new_hdc, &new_graphics);
1042         graphics = new_graphics;
1043         if (stat != Ok)
1044         {
1045             DeleteDC(new_hdc);
1046             return stat;
1047         }
1048     }
1049     else if (!graphics->hdc)
1050     {
1051         graphics->hdc = new_hdc = CreateCompatibleDC(0);
1052         if (!new_hdc)
1053             return OutOfMemory;
1054     }
1055
1056     save_state = SaveDC(graphics->hdc);
1057     EndPath(graphics->hdc);
1058
1059     SetPolyFillMode(graphics->hdc, (path->fill == FillModeAlternate ? ALTERNATE
1060                                                                     : WINDING));
1061
1062     stat = trace_path(graphics, path);
1063     if (stat == Ok)
1064     {
1065         *hrgn = PathToRegion(graphics->hdc);
1066         stat = *hrgn ? Ok : OutOfMemory;
1067     }
1068
1069     RestoreDC(graphics->hdc, save_state);
1070     if (new_hdc)
1071     {
1072         DeleteDC(new_hdc);
1073         if (new_graphics)
1074             GdipDeleteGraphics(new_graphics);
1075         else
1076             graphics->hdc = NULL;
1077     }
1078
1079     return stat;
1080 }
1081
1082 static GpStatus get_region_hrgn(struct region_element *element, GpGraphics *graphics, HRGN *hrgn)
1083 {
1084     switch (element->type)
1085     {
1086         case RegionDataInfiniteRect:
1087             *hrgn = NULL;
1088             return Ok;
1089         case RegionDataEmptyRect:
1090             *hrgn = CreateRectRgn(0, 0, 0, 0);
1091             return *hrgn ? Ok : OutOfMemory;
1092         case RegionDataPath:
1093             return get_path_hrgn(element->elementdata.path, graphics, hrgn);
1094         case RegionDataRect:
1095         {
1096             GpPath* path;
1097             GpStatus stat;
1098             GpRectF* rc = &element->elementdata.rect;
1099
1100             stat = GdipCreatePath(FillModeAlternate, &path);
1101             if (stat != Ok)
1102                 return stat;
1103             stat = GdipAddPathRectangle(path, rc->X, rc->Y, rc->Width, rc->Height);
1104
1105             if (stat == Ok)
1106                 stat = get_path_hrgn(path, graphics, hrgn);
1107
1108             GdipDeletePath(path);
1109
1110             return stat;
1111         }
1112         case CombineModeIntersect:
1113         case CombineModeUnion:
1114         case CombineModeXor:
1115         case CombineModeExclude:
1116         case CombineModeComplement:
1117         {
1118             HRGN left, right;
1119             GpStatus stat;
1120             int ret;
1121
1122             stat = get_region_hrgn(element->elementdata.combine.left, graphics, &left);
1123             if (stat != Ok)
1124             {
1125                 *hrgn = NULL;
1126                 return stat;
1127             }
1128
1129             if (left == NULL)
1130             {
1131                 /* existing region is infinite */
1132                 switch (element->type)
1133                 {
1134                     case CombineModeIntersect:
1135                         return get_region_hrgn(element->elementdata.combine.right, graphics, hrgn);
1136                     case CombineModeXor: case CombineModeExclude:
1137                         left = CreateRectRgn(-(1 << 22), -(1 << 22), 1 << 22, 1 << 22);
1138                         break;
1139                     case CombineModeUnion: case CombineModeComplement:
1140                         *hrgn = NULL;
1141                         return Ok;
1142                 }
1143             }
1144
1145             stat = get_region_hrgn(element->elementdata.combine.right, graphics, &right);
1146             if (stat != Ok)
1147             {
1148                 DeleteObject(left);
1149                 *hrgn = NULL;
1150                 return stat;
1151             }
1152
1153             if (right == NULL)
1154             {
1155                 /* new region is infinite */
1156                 switch (element->type)
1157                 {
1158                     case CombineModeIntersect:
1159                         *hrgn = left;
1160                         return Ok;
1161                     case CombineModeXor: case CombineModeComplement:
1162                         right = CreateRectRgn(-(1 << 22), -(1 << 22), 1 << 22, 1 << 22);
1163                         break;
1164                     case CombineModeUnion: case CombineModeExclude:
1165                         DeleteObject(left);
1166                         *hrgn = NULL;
1167                         return Ok;
1168                 }
1169             }
1170
1171             switch (element->type)
1172             {
1173                 case CombineModeIntersect:
1174                     ret = CombineRgn(left, left, right, RGN_AND);
1175                     break;
1176                 case CombineModeUnion:
1177                     ret = CombineRgn(left, left, right, RGN_OR);
1178                     break;
1179                 case CombineModeXor:
1180                     ret = CombineRgn(left, left, right, RGN_XOR);
1181                     break;
1182                 case CombineModeExclude:
1183                     ret = CombineRgn(left, left, right, RGN_DIFF);
1184                     break;
1185                 case CombineModeComplement:
1186                     ret = CombineRgn(left, right, left, RGN_DIFF);
1187                     break;
1188                 default:
1189                     ret = ERROR;
1190             }
1191
1192             DeleteObject(right);
1193
1194             if (ret == ERROR)
1195             {
1196                 DeleteObject(left);
1197                 *hrgn = NULL;
1198                 return GenericError;
1199             }
1200
1201             *hrgn = left;
1202             return Ok;
1203         }
1204         default:
1205             FIXME("GdipGetRegionHRgn unimplemented for region type=%x\n", element->type);
1206             *hrgn = NULL;
1207             return NotImplemented;
1208     }
1209 }
1210
1211 /*****************************************************************************
1212  * GdipGetRegionHRgn [GDIPLUS.@]
1213  */
1214 GpStatus WINGDIPAPI GdipGetRegionHRgn(GpRegion *region, GpGraphics *graphics, HRGN *hrgn)
1215 {
1216     TRACE("(%p, %p, %p)\n", region, graphics, hrgn);
1217
1218     if (!region || !hrgn)
1219         return InvalidParameter;
1220
1221     return get_region_hrgn(&region->node, graphics, hrgn);
1222 }
1223
1224 GpStatus WINGDIPAPI GdipIsEmptyRegion(GpRegion *region, GpGraphics *graphics, BOOL *res)
1225 {
1226     GpStatus status;
1227     GpRectF rect;
1228
1229     TRACE("(%p, %p, %p)\n", region, graphics, res);
1230
1231     if(!region || !graphics || !res)
1232         return InvalidParameter;
1233
1234     status = GdipGetRegionBounds(region, graphics, &rect);
1235     if (status != Ok) return status;
1236
1237     *res = rect.Width == 0.0 && rect.Height == 0.0;
1238     TRACE("=> %d\n", *res);
1239
1240     return Ok;
1241 }
1242
1243 /*****************************************************************************
1244  * GdipIsEqualRegion [GDIPLUS.@]
1245  */
1246 GpStatus WINGDIPAPI GdipIsEqualRegion(GpRegion *region, GpRegion *region2, GpGraphics *graphics,
1247                                       BOOL *res)
1248 {
1249     HRGN hrgn1, hrgn2;
1250     GpStatus stat;
1251
1252     TRACE("(%p, %p, %p, %p)\n", region, region2, graphics, res);
1253
1254     if(!region || !region2 || !graphics || !res)
1255         return InvalidParameter;
1256
1257     stat = GdipGetRegionHRgn(region, graphics, &hrgn1);
1258     if(stat != Ok)
1259         return stat;
1260     stat = GdipGetRegionHRgn(region2, graphics, &hrgn2);
1261     if(stat != Ok){
1262         DeleteObject(hrgn1);
1263         return stat;
1264     }
1265
1266     *res = EqualRgn(hrgn1, hrgn2);
1267
1268     /* one of GpRegions is infinite */
1269     if(*res == ERROR)
1270         *res = (!hrgn1 && !hrgn2);
1271
1272     DeleteObject(hrgn1);
1273     DeleteObject(hrgn2);
1274
1275     return Ok;
1276 }
1277
1278 /*****************************************************************************
1279  * GdipIsInfiniteRegion [GDIPLUS.@]
1280  */
1281 GpStatus WINGDIPAPI GdipIsInfiniteRegion(GpRegion *region, GpGraphics *graphics, BOOL *res)
1282 {
1283     /* I think graphics is ignored here */
1284     TRACE("(%p, %p, %p)\n", region, graphics, res);
1285
1286     if(!region || !graphics || !res)
1287         return InvalidParameter;
1288
1289     *res = (region->node.type == RegionDataInfiniteRect);
1290
1291     return Ok;
1292 }
1293
1294 /*****************************************************************************
1295  * GdipIsVisibleRegionRect [GDIPLUS.@]
1296  */
1297 GpStatus WINGDIPAPI GdipIsVisibleRegionRect(GpRegion* region, REAL x, REAL y, REAL w, REAL h, GpGraphics *graphics, BOOL *res)
1298 {
1299     HRGN hrgn;
1300     GpStatus stat;
1301     RECT rect;
1302
1303     TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %p, %p)\n", region, x, y, w, h, graphics, res);
1304
1305     if(!region || !res)
1306         return InvalidParameter;
1307
1308     if((stat = GdipGetRegionHRgn(region, NULL, &hrgn)) != Ok)
1309         return stat;
1310
1311     /* infinite */
1312     if(!hrgn){
1313         *res = TRUE;
1314         return Ok;
1315     }
1316
1317     SetRect(&rect, ceilr(x), ceilr(y), ceilr(x + w), ceilr(y + h));
1318     *res = RectInRegion(hrgn, &rect);
1319
1320     DeleteObject(hrgn);
1321
1322     return Ok;
1323 }
1324
1325 /*****************************************************************************
1326  * GdipIsVisibleRegionRectI [GDIPLUS.@]
1327  */
1328 GpStatus WINGDIPAPI GdipIsVisibleRegionRectI(GpRegion* region, INT x, INT y, INT w, INT h, GpGraphics *graphics, BOOL *res)
1329 {
1330     TRACE("(%p, %d, %d, %d, %d, %p, %p)\n", region, x, y, w, h, graphics, res);
1331     if(!region || !res)
1332         return InvalidParameter;
1333
1334     return GdipIsVisibleRegionRect(region, (REAL)x, (REAL)y, (REAL)w, (REAL)h, graphics, res);
1335 }
1336
1337 /*****************************************************************************
1338  * GdipIsVisibleRegionPoint [GDIPLUS.@]
1339  */
1340 GpStatus WINGDIPAPI GdipIsVisibleRegionPoint(GpRegion* region, REAL x, REAL y, GpGraphics *graphics, BOOL *res)
1341 {
1342     HRGN hrgn;
1343     GpStatus stat;
1344
1345     TRACE("(%p, %.2f, %.2f, %p, %p)\n", region, x, y, graphics, res);
1346
1347     if(!region || !res)
1348         return InvalidParameter;
1349
1350     if((stat = GdipGetRegionHRgn(region, NULL, &hrgn)) != Ok)
1351         return stat;
1352
1353     /* infinite */
1354     if(!hrgn){
1355         *res = TRUE;
1356         return Ok;
1357     }
1358
1359     *res = PtInRegion(hrgn, gdip_round(x), gdip_round(y));
1360
1361     DeleteObject(hrgn);
1362
1363     return Ok;
1364 }
1365
1366 /*****************************************************************************
1367  * GdipIsVisibleRegionPointI [GDIPLUS.@]
1368  */
1369 GpStatus WINGDIPAPI GdipIsVisibleRegionPointI(GpRegion* region, INT x, INT y, GpGraphics *graphics, BOOL *res)
1370 {
1371     TRACE("(%p, %d, %d, %p, %p)\n", region, x, y, graphics, res);
1372
1373     return GdipIsVisibleRegionPoint(region, (REAL)x, (REAL)y, graphics, res);
1374 }
1375
1376 /*****************************************************************************
1377  * GdipSetEmpty [GDIPLUS.@]
1378  */
1379 GpStatus WINGDIPAPI GdipSetEmpty(GpRegion *region)
1380 {
1381     GpStatus stat;
1382
1383     TRACE("%p\n", region);
1384
1385     if (!region)
1386         return InvalidParameter;
1387
1388     delete_element(&region->node);
1389     stat = init_region(region, RegionDataEmptyRect);
1390
1391     return stat;
1392 }
1393
1394 GpStatus WINGDIPAPI GdipSetInfinite(GpRegion *region)
1395 {
1396     GpStatus stat;
1397
1398     TRACE("%p\n", region);
1399
1400     if (!region)
1401         return InvalidParameter;
1402
1403     delete_element(&region->node);
1404     stat = init_region(region, RegionDataInfiniteRect);
1405
1406     return stat;
1407 }
1408
1409 /* Transforms GpRegion elements with given matrix */
1410 static GpStatus transform_region_element(region_element* element, GpMatrix *matrix)
1411 {
1412     GpStatus stat;
1413
1414     switch(element->type)
1415     {
1416         case RegionDataEmptyRect:
1417         case RegionDataInfiniteRect:
1418             return Ok;
1419         case RegionDataRect:
1420         {
1421             /* We can't transform a rectangle, so convert it to a path. */
1422             GpRegion *new_region;
1423             GpPath *path;
1424
1425             stat = GdipCreatePath(FillModeAlternate, &path);
1426             if (stat == Ok)
1427             {
1428                 stat = GdipAddPathRectangle(path,
1429                     element->elementdata.rect.X, element->elementdata.rect.Y,
1430                     element->elementdata.rect.Width, element->elementdata.rect.Height);
1431
1432                 if (stat == Ok)
1433                     stat = GdipCreateRegionPath(path, &new_region);
1434
1435                 GdipDeletePath(path);
1436             }
1437
1438             if (stat == Ok)
1439             {
1440                 /* Steal the element from the created region. */
1441                 memcpy(element, &new_region->node, sizeof(region_element));
1442                 heap_free(new_region);
1443             }
1444             else
1445                 return stat;
1446         }
1447         /* Fall-through to do the actual conversion. */
1448         case RegionDataPath:
1449             if (!element->elementdata.path->pathdata.Count)
1450                 return Ok;
1451
1452             stat = GdipTransformMatrixPoints(matrix,
1453                 element->elementdata.path->pathdata.Points,
1454                 element->elementdata.path->pathdata.Count);
1455             return stat;
1456         default:
1457             stat = transform_region_element(element->elementdata.combine.left, matrix);
1458             if (stat == Ok)
1459                 stat = transform_region_element(element->elementdata.combine.right, matrix);
1460             return stat;
1461     }
1462 }
1463
1464 GpStatus WINGDIPAPI GdipTransformRegion(GpRegion *region, GpMatrix *matrix)
1465 {
1466     TRACE("(%p, %p)\n", region, matrix);
1467
1468     if (!region || !matrix)
1469         return InvalidParameter;
1470
1471     return transform_region_element(&region->node, matrix);
1472 }
1473
1474 /* Translates GpRegion elements with specified offsets */
1475 static void translate_region_element(region_element* element, REAL dx, REAL dy)
1476 {
1477     INT i;
1478
1479     switch(element->type)
1480     {
1481         case RegionDataEmptyRect:
1482         case RegionDataInfiniteRect:
1483             return;
1484         case RegionDataRect:
1485             element->elementdata.rect.X += dx;
1486             element->elementdata.rect.Y += dy;
1487             return;
1488         case RegionDataPath:
1489             for(i = 0; i < element->elementdata.path->pathdata.Count; i++){
1490                 element->elementdata.path->pathdata.Points[i].X += dx;
1491                 element->elementdata.path->pathdata.Points[i].Y += dy;
1492             }
1493             return;
1494         default:
1495             translate_region_element(element->elementdata.combine.left,  dx, dy);
1496             translate_region_element(element->elementdata.combine.right, dx, dy);
1497             return;
1498     }
1499 }
1500
1501 /*****************************************************************************
1502  * GdipTranslateRegion [GDIPLUS.@]
1503  */
1504 GpStatus WINGDIPAPI GdipTranslateRegion(GpRegion *region, REAL dx, REAL dy)
1505 {
1506     TRACE("(%p, %f, %f)\n", region, dx, dy);
1507
1508     if(!region)
1509         return InvalidParameter;
1510
1511     translate_region_element(&region->node, dx, dy);
1512
1513     return Ok;
1514 }
1515
1516 /*****************************************************************************
1517  * GdipTranslateRegionI [GDIPLUS.@]
1518  */
1519 GpStatus WINGDIPAPI GdipTranslateRegionI(GpRegion *region, INT dx, INT dy)
1520 {
1521     TRACE("(%p, %d, %d)\n", region, dx, dy);
1522
1523     return GdipTranslateRegion(region, (REAL)dx, (REAL)dy);
1524 }
1525
1526 static GpStatus get_region_scans_data(GpRegion *region, GpMatrix *matrix, LPRGNDATA *data)
1527 {
1528     GpRegion *region_copy;
1529     GpStatus stat;
1530     HRGN hrgn;
1531     DWORD data_size;
1532
1533     stat = GdipCloneRegion(region, &region_copy);
1534
1535     if (stat == Ok)
1536     {
1537         stat = GdipTransformRegion(region_copy, matrix);
1538
1539         if (stat == Ok)
1540             stat = GdipGetRegionHRgn(region_copy, NULL, &hrgn);
1541
1542         if (stat == Ok)
1543         {
1544             if (hrgn)
1545             {
1546                 data_size = GetRegionData(hrgn, 0, NULL);
1547
1548                 *data = heap_alloc_zero(data_size);
1549
1550                 if (*data)
1551                     GetRegionData(hrgn, data_size, *data);
1552                 else
1553                     stat = OutOfMemory;
1554
1555                 DeleteObject(hrgn);
1556             }
1557             else
1558             {
1559                 data_size = sizeof(RGNDATAHEADER) + sizeof(RECT);
1560
1561                 *data = heap_alloc_zero(data_size);
1562
1563                 if (*data)
1564                 {
1565                     (*data)->rdh.dwSize = sizeof(RGNDATAHEADER);
1566                     (*data)->rdh.iType = RDH_RECTANGLES;
1567                     (*data)->rdh.nCount = 1;
1568                     (*data)->rdh.nRgnSize = sizeof(RECT);
1569                     (*data)->rdh.rcBound.left = (*data)->rdh.rcBound.top = -0x400000;
1570                     (*data)->rdh.rcBound.right = (*data)->rdh.rcBound.bottom = 0x400000;
1571
1572                     memcpy((*data)->Buffer, &(*data)->rdh.rcBound, sizeof(RECT));
1573                 }
1574                 else
1575                     stat = OutOfMemory;
1576             }
1577         }
1578
1579         GdipDeleteRegion(region_copy);
1580     }
1581
1582     return stat;
1583 }
1584
1585 GpStatus WINGDIPAPI GdipGetRegionScansCount(GpRegion *region, UINT *count, GpMatrix *matrix)
1586 {
1587     GpStatus stat;
1588     LPRGNDATA data;
1589
1590     TRACE("(%p, %p, %p)\n", region, count, matrix);
1591
1592     if (!region || !count || !matrix)
1593         return InvalidParameter;
1594
1595     stat = get_region_scans_data(region, matrix, &data);
1596
1597     if (stat == Ok)
1598     {
1599         *count = data->rdh.nCount;
1600         heap_free(data);
1601     }
1602
1603     return stat;
1604 }
1605
1606 GpStatus WINGDIPAPI GdipGetRegionScansI(GpRegion *region, GpRect *scans, INT *count, GpMatrix *matrix)
1607 {
1608     GpStatus stat;
1609     DWORD i;
1610     LPRGNDATA data;
1611     RECT *rects;
1612
1613     if (!region || !count || !matrix)
1614         return InvalidParameter;
1615
1616     stat = get_region_scans_data(region, matrix, &data);
1617
1618     if (stat == Ok)
1619     {
1620         *count = data->rdh.nCount;
1621         rects = (RECT*)data->Buffer;
1622
1623         if (scans)
1624         {
1625             for (i=0; i<data->rdh.nCount; i++)
1626             {
1627                 scans[i].X = rects[i].left;
1628                 scans[i].Y = rects[i].top;
1629                 scans[i].Width = rects[i].right - rects[i].left;
1630                 scans[i].Height = rects[i].bottom - rects[i].top;
1631             }
1632         }
1633
1634         heap_free(data);
1635     }
1636
1637     return Ok;
1638 }
1639
1640 GpStatus WINGDIPAPI GdipGetRegionScans(GpRegion *region, GpRectF *scans, INT *count, GpMatrix *matrix)
1641 {
1642     GpStatus stat;
1643     DWORD i;
1644     LPRGNDATA data;
1645     RECT *rects;
1646
1647     if (!region || !count || !matrix)
1648         return InvalidParameter;
1649
1650     stat = get_region_scans_data(region, matrix, &data);
1651
1652     if (stat == Ok)
1653     {
1654         *count = data->rdh.nCount;
1655         rects = (RECT*)data->Buffer;
1656
1657         if (scans)
1658         {
1659             for (i=0; i<data->rdh.nCount; i++)
1660             {
1661                 scans[i].X = rects[i].left;
1662                 scans[i].Y = rects[i].top;
1663                 scans[i].Width = rects[i].right - rects[i].left;
1664                 scans[i].Height = rects[i].bottom - rects[i].top;
1665             }
1666         }
1667
1668         heap_free(data);
1669     }
1670
1671     return Ok;
1672 }