dplayx: NS_GetOtherMagic() is not used, so remove it.
[wine] / dlls / gdiplus / region.c
1 /*
2  * Copyright (C) 2008 Google (Lei Zhang)
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include <stdarg.h>
20
21 #include "windef.h"
22 #include "winbase.h"
23 #include "wingdi.h"
24
25 #include "objbase.h"
26
27 #include "gdiplus.h"
28 #include "gdiplus_private.h"
29 #include "wine/debug.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
32
33 /**********************************************************
34  *
35  * Data returned by GdipGetRegionData looks something like this:
36  *
37  * struct region_data_header
38  * {
39  *   DWORD size;     size in bytes of the data - 8.
40  *   DWORD magic1;   probably a checksum.
41  *   DWORD magic2;   always seems to be 0xdbc01001 - version?
42  *   DWORD num_ops;  number of combining ops * 2
43  * };
44  *
45  * Then follows a sequence of combining ops and region elements.
46  *
47  * A region element is either a RECTF or some path data.
48  *
49  * Combining ops are just stored as their CombineMode value.
50  *
51  * Each RECTF is preceded by the DWORD 0x10000000.  An empty rect is
52  * stored as 0x10000002 (with no following RECTF) and an infinite rect
53  * is stored as 0x10000003 (again with no following RECTF).
54  *
55  * Path data is preceded by the DWORD 0x10000001.  Then follows a
56  * DWORD size and then size bytes of data.
57  *
58  * The combining ops are stored in the reverse order to the region
59  * elements and in the reverse order to which the region was
60  * constructed.
61  *
62  * When two or more complex regions (ie those with more than one
63  * element) are combined, the combining op for the two regions comes
64  * first, then the combining ops for the region elements in region 1,
65  * followed by the region elements for region 1, then follows the
66  * combining ops for region 2 and finally region 2's region elements.
67  * Presumably you're supposed to use the 0x1000000x header to find the
68  * end of the op list (the count of the elements in each region is not
69  * stored).
70  *
71  * When a simple region (1 element) is combined, it's treated as if a
72  * single rect/path is being combined.
73  *
74  */
75
76 #define FLAGS_NOFLAGS   0x0
77 #define FLAGS_INTPATH   0x4000
78
79 /* Header size as far as header->size is concerned. This doesn't include
80  * header->size or header->checksum
81  */
82 static const INT sizeheader_size = sizeof(DWORD) * 2;
83
84 typedef struct packed_point
85 {
86     short X;
87     short Y;
88 } packed_point;
89
90 /* Everything is measured in DWORDS; round up if there's a remainder */
91 static inline INT get_pathtypes_size(const GpPath* path)
92 {
93     INT needed = path->pathdata.Count / sizeof(DWORD);
94
95     if (path->pathdata.Count % sizeof(DWORD) > 0)
96         needed++;
97
98     return needed * sizeof(DWORD);
99 }
100
101 static inline INT get_element_size(const region_element* element)
102 {
103     INT needed = sizeof(DWORD); /* DWORD for the type */
104     switch(element->type)
105     {
106         case RegionDataRect:
107             return needed + sizeof(GpRect);
108         case RegionDataPath:
109              needed += element->elementdata.pathdata.pathheader.size;
110              needed += sizeof(DWORD); /* Extra DWORD for pathheader.size */
111              return needed;
112         case RegionDataEmptyRect:
113         case RegionDataInfiniteRect:
114             return needed;
115         default:
116             needed += get_element_size(element->elementdata.combine.left);
117             needed += get_element_size(element->elementdata.combine.right);
118             return needed;
119     }
120
121     return 0;
122 }
123
124 /* Does not check parameters, caller must do that */
125 static inline GpStatus init_region(GpRegion* region, const RegionType type)
126 {
127     region->node.type       = type;
128     region->header.checksum = 0xdeadbeef;
129     region->header.magic    = VERSION_MAGIC;
130     region->header.num_children  = 0;
131     region->header.size     = sizeheader_size + get_element_size(&region->node);
132
133     return Ok;
134 }
135
136 static inline GpStatus clone_element(const region_element* element,
137         region_element** element2)
138 {
139     GpStatus stat;
140
141     /* root node is allocated with GpRegion */
142     if(!*element2){
143         *element2 = GdipAlloc(sizeof(region_element));
144         if (!*element2)
145             return OutOfMemory;
146     }
147
148     (*element2)->type = element->type;
149
150     switch (element->type)
151     {
152         case RegionDataRect:
153             (*element2)->elementdata.rect = element->elementdata.rect;
154             break;
155         case RegionDataEmptyRect:
156         case RegionDataInfiniteRect:
157             break;
158         case RegionDataPath:
159             (*element2)->elementdata.pathdata.pathheader = element->elementdata.pathdata.pathheader;
160             stat = GdipClonePath(element->elementdata.pathdata.path,
161                     &(*element2)->elementdata.pathdata.path);
162             if (stat != Ok) goto clone_out;
163             break;
164         default:
165             (*element2)->elementdata.combine.left  = NULL;
166             (*element2)->elementdata.combine.right = NULL;
167
168             stat = clone_element(element->elementdata.combine.left,
169                     &(*element2)->elementdata.combine.left);
170             if (stat != Ok) goto clone_out;
171             stat = clone_element(element->elementdata.combine.right,
172                     &(*element2)->elementdata.combine.right);
173             if (stat != Ok) goto clone_out;
174             break;
175     }
176
177     return Ok;
178
179 clone_out:
180     delete_element(*element2);
181     *element2 = NULL;
182     return stat;
183 }
184
185 /* Common code for CombineRegion*
186  * All the caller has to do is get its format into an element
187  */
188 static inline void fuse_region(GpRegion* region, region_element* left,
189         region_element* right, const CombineMode mode)
190 {
191     region->node.type = mode;
192     region->node.elementdata.combine.left = left;
193     region->node.elementdata.combine.right = right;
194
195     region->header.size = sizeheader_size + get_element_size(&region->node);
196     region->header.num_children += 2;
197 }
198
199 /*****************************************************************************
200  * GdipCloneRegion [GDIPLUS.@]
201  *
202  * Creates a deep copy of the region
203  *
204  * PARAMS
205  *  region  [I] source region
206  *  clone   [O] resulting clone
207  *
208  * RETURNS
209  *  SUCCESS: Ok
210  *  FAILURE: InvalidParameter or OutOfMemory
211  */
212 GpStatus WINGDIPAPI GdipCloneRegion(GpRegion *region, GpRegion **clone)
213 {
214     region_element *element;
215
216     TRACE("%p %p\n", region, clone);
217
218     if (!(region && clone))
219         return InvalidParameter;
220
221     *clone = GdipAlloc(sizeof(GpRegion));
222     if (!*clone)
223         return OutOfMemory;
224     element = &(*clone)->node;
225
226     (*clone)->header = region->header;
227     return clone_element(&region->node, &element);
228 }
229
230 /*****************************************************************************
231  * GdipCombineRegionPath [GDIPLUS.@]
232  */
233 GpStatus WINGDIPAPI GdipCombineRegionPath(GpRegion *region, GpPath *path, CombineMode mode)
234 {
235     GpRegion *path_region;
236     region_element *left, *right = NULL;
237     GpStatus stat;
238
239     TRACE("%p %p %d\n", region, path, mode);
240
241     if (!(region && path))
242         return InvalidParameter;
243
244     stat = GdipCreateRegionPath(path, &path_region);
245     if (stat != Ok)
246         return stat;
247
248     /* simply replace region data */
249     if(mode == CombineModeReplace){
250         delete_element(&region->node);
251         memcpy(region, path_region, sizeof(GpRegion));
252         return Ok;
253     }
254
255     left = GdipAlloc(sizeof(region_element));
256     if (!left)
257         goto out;
258     *left = region->node;
259
260     stat = clone_element(&path_region->node, &right);
261     if (stat != Ok)
262         goto out;
263
264     fuse_region(region, left, right, mode);
265
266     GdipDeleteRegion(path_region);
267     return Ok;
268
269 out:
270     GdipFree(left);
271     GdipDeleteRegion(path_region);
272     return stat;
273 }
274
275 /*****************************************************************************
276  * GdipCombineRegionRect [GDIPLUS.@]
277  */
278 GpStatus WINGDIPAPI GdipCombineRegionRect(GpRegion *region,
279         GDIPCONST GpRectF *rect, CombineMode mode)
280 {
281     GpRegion *rect_region;
282     region_element *left, *right = NULL;
283     GpStatus stat;
284
285     TRACE("%p %p %d\n", region, rect, mode);
286
287     if (!(region && rect))
288         return InvalidParameter;
289
290     stat = GdipCreateRegionRect(rect, &rect_region);
291     if (stat != Ok)
292         return stat;
293
294     /* simply replace region data */
295     if(mode == CombineModeReplace){
296         delete_element(&region->node);
297         memcpy(region, rect_region, sizeof(GpRegion));
298         return Ok;
299     }
300
301     left = GdipAlloc(sizeof(region_element));
302     if (!left)
303         goto out;
304     memcpy(left, &region->node, sizeof(region_element));
305
306     stat = clone_element(&rect_region->node, &right);
307     if (stat != Ok)
308         goto out;
309
310     fuse_region(region, left, right, mode);
311
312     GdipDeleteRegion(rect_region);
313     return Ok;
314
315 out:
316     GdipFree(left);
317     GdipDeleteRegion(rect_region);
318     return stat;
319 }
320
321 /*****************************************************************************
322  * GdipCombineRegionRectI [GDIPLUS.@]
323  */
324 GpStatus WINGDIPAPI GdipCombineRegionRectI(GpRegion *region,
325         GDIPCONST GpRect *rect, CombineMode mode)
326 {
327     GpRectF rectf;
328
329     TRACE("%p %p %d\n", region, rect, mode);
330
331     if (!rect)
332         return InvalidParameter;
333
334     rectf.X = (REAL)rect->X;
335     rectf.Y = (REAL)rect->Y;
336     rectf.Height = (REAL)rect->Height;
337     rectf.Width = (REAL)rect->Width;
338
339     return GdipCombineRegionRect(region, &rectf, mode);
340 }
341
342 /*****************************************************************************
343  * GdipCombineRegionRegion [GDIPLUS.@]
344  */
345 GpStatus WINGDIPAPI GdipCombineRegionRegion(GpRegion *region1,
346         GpRegion *region2, CombineMode mode)
347 {
348     region_element *left, *right = NULL;
349     GpStatus stat;
350     GpRegion *reg2copy;
351
352     TRACE("%p %p %d\n", region1, region2, mode);
353
354     if(!(region1 && region2))
355         return InvalidParameter;
356
357     /* simply replace region data */
358     if(mode == CombineModeReplace){
359         stat = GdipCloneRegion(region2, &reg2copy);
360         if(stat != Ok)  return stat;
361
362         delete_element(&region1->node);
363         memcpy(region1, reg2copy, sizeof(GpRegion));
364         GdipFree(reg2copy);
365         return Ok;
366     }
367
368     left  = GdipAlloc(sizeof(region_element));
369     if (!left)
370         return OutOfMemory;
371
372     *left = region1->node;
373     stat = clone_element(&region2->node, &right);
374     if (stat != Ok)
375     {
376         GdipFree(left);
377         return OutOfMemory;
378     }
379
380     fuse_region(region1, left, right, mode);
381     region1->header.num_children += region2->header.num_children;
382
383     return Ok;
384 }
385
386 /*****************************************************************************
387  * GdipCreateRegion [GDIPLUS.@]
388  */
389 GpStatus WINGDIPAPI GdipCreateRegion(GpRegion **region)
390 {
391     TRACE("%p\n", region);
392
393     if(!region)
394         return InvalidParameter;
395
396     *region = GdipAlloc(sizeof(GpRegion));
397     if(!*region)
398         return OutOfMemory;
399
400     return init_region(*region, RegionDataInfiniteRect);
401 }
402
403 /*****************************************************************************
404  * GdipCreateRegionPath [GDIPLUS.@]
405  *
406  * Creates a GpRegion from a GpPath
407  *
408  * PARAMS
409  *  path    [I] path to base the region on
410  *  region  [O] pointer to the newly allocated region
411  *
412  * RETURNS
413  *  SUCCESS: Ok
414  *  FAILURE: InvalidParameter
415  *
416  * NOTES
417  *  If a path has no floating point points, its points will be stored as shorts
418  *  (INTPATH)
419  *
420  *  If a path is empty, it is considered to be an INTPATH
421  */
422 GpStatus WINGDIPAPI GdipCreateRegionPath(GpPath *path, GpRegion **region)
423 {
424     region_element* element;
425     GpPoint  *pointsi;
426     GpPointF *pointsf;
427
428     GpStatus stat;
429     DWORD flags = FLAGS_INTPATH;
430     INT count, i;
431
432     TRACE("%p, %p\n", path, region);
433
434     if (!(path && region))
435         return InvalidParameter;
436
437     *region = GdipAlloc(sizeof(GpRegion));
438     if(!*region)
439         return OutOfMemory;
440     stat = init_region(*region, RegionDataPath);
441     if (stat != Ok)
442     {
443         GdipDeleteRegion(*region);
444         return stat;
445     }
446     element = &(*region)->node;
447     count = path->pathdata.Count;
448
449     /* Test to see if the path is an Integer path */
450     if (count)
451     {
452         pointsi = GdipAlloc(sizeof(GpPoint) * count);
453         pointsf = GdipAlloc(sizeof(GpPointF) * count);
454         if (!(pointsi && pointsf))
455         {
456             GdipFree(pointsi);
457             GdipFree(pointsf);
458             GdipDeleteRegion(*region);
459             return OutOfMemory;
460         }
461
462         stat = GdipGetPathPointsI(path, pointsi, count);
463         if (stat != Ok)
464         {
465             GdipDeleteRegion(*region);
466             return stat;
467         }
468         stat = GdipGetPathPoints(path, pointsf, count);
469         if (stat != Ok)
470         {
471             GdipDeleteRegion(*region);
472             return stat;
473         }
474
475         for (i = 0; i < count; i++)
476         {
477             if (!(pointsi[i].X == pointsf[i].X &&
478                   pointsi[i].Y == pointsf[i].Y ))
479             {
480                 flags = FLAGS_NOFLAGS;
481                 break;
482             }
483         }
484         GdipFree(pointsi);
485         GdipFree(pointsf);
486     }
487
488     stat = GdipClonePath(path, &element->elementdata.pathdata.path);
489     if (stat != Ok)
490     {
491         GdipDeleteRegion(*region);
492         return stat;
493     }
494
495     /* 3 for headers, once again size doesn't count itself */
496     element->elementdata.pathdata.pathheader.size = ((sizeof(DWORD) * 3));
497     switch(flags)
498     {
499         /* Floats, sent out as floats */
500         case FLAGS_NOFLAGS:
501             element->elementdata.pathdata.pathheader.size +=
502                 (sizeof(DWORD) * count * 2);
503             break;
504         /* INTs, sent out as packed shorts */
505         case FLAGS_INTPATH:
506             element->elementdata.pathdata.pathheader.size +=
507                 (sizeof(DWORD) * count);
508             break;
509         default:
510             FIXME("Unhandled flags (%08x). Expect wrong results.\n", flags);
511     }
512     element->elementdata.pathdata.pathheader.size += get_pathtypes_size(path);
513     element->elementdata.pathdata.pathheader.magic = VERSION_MAGIC;
514     element->elementdata.pathdata.pathheader.count = count;
515     element->elementdata.pathdata.pathheader.flags = flags;
516     (*region)->header.size = sizeheader_size + get_element_size(element);
517
518     return Ok;
519 }
520
521 /*****************************************************************************
522  * GdipCreateRegionRect [GDIPLUS.@]
523  */
524 GpStatus WINGDIPAPI GdipCreateRegionRect(GDIPCONST GpRectF *rect,
525         GpRegion **region)
526 {
527     GpStatus stat;
528
529     TRACE("%p, %p\n", rect, region);
530
531     if (!(rect && region))
532         return InvalidParameter;
533
534     *region = GdipAlloc(sizeof(GpRegion));
535     stat = init_region(*region, RegionDataRect);
536     if(stat != Ok)
537     {
538         GdipDeleteRegion(*region);
539         return stat;
540     }
541
542     (*region)->node.elementdata.rect.X = rect->X;
543     (*region)->node.elementdata.rect.Y = rect->Y;
544     (*region)->node.elementdata.rect.Width = rect->Width;
545     (*region)->node.elementdata.rect.Height = rect->Height;
546
547     return Ok;
548 }
549
550 /*****************************************************************************
551  * GdipCreateRegionRectI [GDIPLUS.@]
552  */
553 GpStatus WINGDIPAPI GdipCreateRegionRectI(GDIPCONST GpRect *rect,
554         GpRegion **region)
555 {
556     GpRectF rectf;
557
558     TRACE("%p, %p\n", rect, region);
559
560     rectf.X = (REAL)rect->X;
561     rectf.Y = (REAL)rect->Y;
562     rectf.Width = (REAL)rect->Width;
563     rectf.Height = (REAL)rect->Height;
564
565     return GdipCreateRegionRect(&rectf, region);
566 }
567
568 GpStatus WINGDIPAPI GdipCreateRegionRgnData(GDIPCONST BYTE *data, INT size, GpRegion **region)
569 {
570     FIXME("(%p, %d, %p): stub\n", data, size, region);
571
572     *region = NULL;
573     return NotImplemented;
574 }
575
576
577 /******************************************************************************
578  * GdipCreateRegionHrgn [GDIPLUS.@]
579  */
580 GpStatus WINGDIPAPI GdipCreateRegionHrgn(HRGN hrgn, GpRegion **region)
581 {
582     union {
583         RGNDATA data;
584         char buf[sizeof(RGNDATAHEADER) + sizeof(RECT)];
585     } rdata;
586     DWORD size;
587     GpRectF rectf;
588     GpPath *path;
589     GpStatus stat;
590
591     TRACE("(%p, %p)\n", hrgn, region);
592
593     if(!region || !(size = GetRegionData(hrgn, 0, NULL)))
594         return InvalidParameter;
595
596     if(size > sizeof(RGNDATAHEADER) + sizeof(RECT)){
597         FIXME("Only simple rect regions supported.\n");
598         *region = NULL;
599         return NotImplemented;
600     }
601
602     if(!GetRegionData(hrgn, sizeof(rdata), &rdata.data))
603         return GenericError;
604
605     /* return empty region */
606     if(IsRectEmpty(&rdata.data.rdh.rcBound)){
607         stat = GdipCreateRegion(region);
608         if(stat == Ok)
609             GdipSetEmpty(*region);
610         return stat;
611     }
612
613     rectf.X = (REAL)rdata.data.rdh.rcBound.left;
614     rectf.Y = (REAL)rdata.data.rdh.rcBound.top;
615     rectf.Width  = (REAL)rdata.data.rdh.rcBound.right - rectf.X;
616     rectf.Height = (REAL)rdata.data.rdh.rcBound.bottom - rectf.Y;
617
618     stat = GdipCreatePath(FillModeAlternate, &path);
619     if(stat != Ok)
620         return stat;
621
622     GdipAddPathRectangle(path, rectf.X, rectf.Y, rectf.Width, rectf.Height);
623
624     stat = GdipCreateRegionPath(path, region);
625     GdipDeletePath(path);
626
627     return stat;
628 }
629
630 /*****************************************************************************
631  * GdipDeleteRegion [GDIPLUS.@]
632  */
633 GpStatus WINGDIPAPI GdipDeleteRegion(GpRegion *region)
634 {
635     TRACE("%p\n", region);
636
637     if (!region)
638         return InvalidParameter;
639
640     delete_element(&region->node);
641     GdipFree(region);
642
643     return Ok;
644 }
645
646 /*****************************************************************************
647  * GdipGetRegionBounds [GDIPLUS.@]
648  */
649 GpStatus WINGDIPAPI GdipGetRegionBounds(GpRegion *region, GpGraphics *graphics, GpRectF *rect)
650 {
651     HRGN hrgn;
652     RECT r;
653     GpStatus status;
654
655     TRACE("(%p, %p, %p)\n", region, graphics, rect);
656
657     if(!region || !graphics || !rect)
658         return InvalidParameter;
659
660     status = GdipGetRegionHRgn(region, graphics, &hrgn);
661     if(status != Ok)
662         return status;
663
664     /* infinite */
665     if(!hrgn){
666         rect->X = rect->Y = -(REAL)(1 << 22);
667         rect->Width = rect->Height = (REAL)(1 << 23);
668         return Ok;
669     }
670
671     if(!GetRgnBox(hrgn, &r)){
672         DeleteObject(hrgn);
673         return GenericError;
674     }
675
676     rect->X = r.left;
677     rect->Y = r.top;
678     rect->Width  = r.right  - r.left;
679     rect->Height = r.bottom - r.top;
680
681     return Ok;
682 }
683
684 /*****************************************************************************
685  * GdipGetRegionBoundsI [GDIPLUS.@]
686  */
687 GpStatus WINGDIPAPI GdipGetRegionBoundsI(GpRegion *region, GpGraphics *graphics, GpRect *rect)
688 {
689     GpRectF rectf;
690     GpStatus status;
691
692     TRACE("(%p, %p, %p)\n", region, graphics, rect);
693
694     if(!rect)
695         return InvalidParameter;
696
697     status = GdipGetRegionBounds(region, graphics, &rectf);
698     if(status == Ok){
699         rect->X = roundr(rectf.X);
700         rect->Y = roundr(rectf.X);
701         rect->Width  = roundr(rectf.Width);
702         rect->Height = roundr(rectf.Height);
703     }
704
705     return status;
706 }
707
708 static inline void write_dword(DWORD* location, INT* offset, const DWORD write)
709 {
710     location[*offset] = write;
711     (*offset)++;
712 }
713
714 static inline void write_float(DWORD* location, INT* offset, const FLOAT write)
715 {
716     ((FLOAT*)location)[*offset] = write;
717     (*offset)++;
718 }
719
720 static inline void write_packed_point(DWORD* location, INT* offset,
721         const GpPointF* write)
722 {
723     packed_point point;
724
725     point.X = write->X;
726     point.Y = write->Y;
727     memcpy(location + *offset, &point, sizeof(packed_point));
728     (*offset)++;
729 }
730
731 static inline void write_path_types(DWORD* location, INT* offset,
732         const GpPath* path)
733 {
734     memcpy(location + *offset, path->pathdata.Types, path->pathdata.Count);
735
736     /* The unwritten parts of the DWORD (if any) must be cleared */
737     if (path->pathdata.Count % sizeof(DWORD))
738         ZeroMemory(((BYTE*)location) + (*offset * sizeof(DWORD)) +
739                 path->pathdata.Count,
740                 sizeof(DWORD) - path->pathdata.Count % sizeof(DWORD));
741     *offset += (get_pathtypes_size(path) / sizeof(DWORD));
742 }
743
744 static void write_element(const region_element* element, DWORD *buffer,
745         INT* filled)
746 {
747     write_dword(buffer, filled, element->type);
748     switch (element->type)
749     {
750         case CombineModeReplace:
751         case CombineModeIntersect:
752         case CombineModeUnion:
753         case CombineModeXor:
754         case CombineModeExclude:
755         case CombineModeComplement:
756             write_element(element->elementdata.combine.left, buffer, filled);
757             write_element(element->elementdata.combine.right, buffer, filled);
758             break;
759         case RegionDataRect:
760             write_float(buffer, filled, element->elementdata.rect.X);
761             write_float(buffer, filled, element->elementdata.rect.Y);
762             write_float(buffer, filled, element->elementdata.rect.Width);
763             write_float(buffer, filled, element->elementdata.rect.Height);
764             break;
765         case RegionDataPath:
766         {
767             INT i;
768             const GpPath* path = element->elementdata.pathdata.path;
769
770             memcpy(buffer + *filled, &element->elementdata.pathdata.pathheader,
771                     sizeof(element->elementdata.pathdata.pathheader));
772             *filled += sizeof(element->elementdata.pathdata.pathheader) / sizeof(DWORD);
773             switch (element->elementdata.pathdata.pathheader.flags)
774             {
775                 case FLAGS_NOFLAGS:
776                     for (i = 0; i < path->pathdata.Count; i++)
777                     {
778                         write_float(buffer, filled, path->pathdata.Points[i].X);
779                         write_float(buffer, filled, path->pathdata.Points[i].Y);
780                     }
781                     break;
782                 case FLAGS_INTPATH:
783                     for (i = 0; i < path->pathdata.Count; i++)
784                     {
785                         write_packed_point(buffer, filled,
786                                 &path->pathdata.Points[i]);
787                     }
788             }
789             write_path_types(buffer, filled, path);
790             break;
791         }
792         case RegionDataEmptyRect:
793         case RegionDataInfiniteRect:
794             break;
795     }
796 }
797
798 /*****************************************************************************
799  * GdipGetRegionData [GDIPLUS.@]
800  *
801  * Returns the header, followed by combining ops and region elements.
802  *
803  * PARAMS
804  *  region  [I] region to retrieve from
805  *  buffer  [O] buffer to hold the resulting data
806  *  size    [I] size of the buffer
807  *  needed  [O] (optional) how much data was written
808  *
809  * RETURNS
810  *  SUCCESS: Ok
811  *  FAILURE: InvalidParameter
812  *
813  * NOTES
814  *  The header contains the size, a checksum, a version string, and the number
815  *  of children. The size does not count itself or the checksum.
816  *  Version is always something like 0xdbc01001 or 0xdbc01002
817  *
818  *  An element is a RECT, or PATH; Combining ops are stored as their
819  *  CombineMode value. Special regions (infinite, empty) emit just their
820  *  op-code; GpRectFs emit their code followed by their points; GpPaths emit
821  *  their code followed by a second header for the path followed by the actual
822  *  path data. Followed by the flags for each point. The pathheader contains
823  *  the size of the data to follow, a version number again, followed by a count
824  *  of how many points, and any special flags which may apply. 0x4000 means its
825  *  a path of shorts instead of FLOAT.
826  *
827  *  Combining Ops are stored in reverse order from when they were constructed;
828  *  the output is a tree where the left side combining area is always taken
829  *  first.
830  */
831 GpStatus WINGDIPAPI GdipGetRegionData(GpRegion *region, BYTE *buffer, UINT size,
832         UINT *needed)
833 {
834     INT filled = 0;
835
836     TRACE("%p, %p, %d, %p\n", region, buffer, size, needed);
837
838     if (!(region && buffer && size))
839         return InvalidParameter;
840
841     memcpy(buffer, &region->header, sizeof(region->header));
842     filled += sizeof(region->header) / sizeof(DWORD);
843     /* With few exceptions, everything written is DWORD aligned,
844      * so use that as our base */
845     write_element(&region->node, (DWORD*)buffer, &filled);
846
847     if (needed)
848         *needed = filled * sizeof(DWORD);
849
850     return Ok;
851 }
852
853 /*****************************************************************************
854  * GdipGetRegionDataSize [GDIPLUS.@]
855  */
856 GpStatus WINGDIPAPI GdipGetRegionDataSize(GpRegion *region, UINT *needed)
857 {
858     TRACE("%p, %p\n", region, needed);
859
860     if (!(region && needed))
861         return InvalidParameter;
862
863     /* header.size doesn't count header.size and header.checksum */
864     *needed = region->header.size + sizeof(DWORD) * 2;
865
866     return Ok;
867 }
868
869 static GpStatus get_path_hrgn(GpPath *path, GpGraphics *graphics, HRGN *hrgn)
870 {
871     HDC new_hdc=NULL;
872     GpStatus stat;
873     INT save_state;
874
875     if (!graphics)
876     {
877         new_hdc = GetDC(0);
878         if (!new_hdc)
879             return OutOfMemory;
880
881         stat = GdipCreateFromHDC(new_hdc, &graphics);
882         if (stat != Ok)
883         {
884             ReleaseDC(0, new_hdc);
885             return stat;
886         }
887     }
888
889     save_state = SaveDC(graphics->hdc);
890     EndPath(graphics->hdc);
891
892     SetPolyFillMode(graphics->hdc, (path->fill == FillModeAlternate ? ALTERNATE
893                                                                     : WINDING));
894
895     stat = trace_path(graphics, path);
896     if (stat == Ok)
897     {
898         *hrgn = PathToRegion(graphics->hdc);
899         stat = *hrgn ? Ok : OutOfMemory;
900     }
901
902     RestoreDC(graphics->hdc, save_state);
903     if (new_hdc)
904     {
905         ReleaseDC(0, new_hdc);
906         GdipDeleteGraphics(graphics);
907     }
908
909     return stat;
910 }
911
912 static GpStatus get_region_hrgn(struct region_element *element, GpGraphics *graphics, HRGN *hrgn)
913 {
914     switch (element->type)
915     {
916         case RegionDataInfiniteRect:
917             *hrgn = NULL;
918             return Ok;
919         case RegionDataEmptyRect:
920             *hrgn = CreateRectRgn(0, 0, 0, 0);
921             return *hrgn ? Ok : OutOfMemory;
922         case RegionDataPath:
923             return get_path_hrgn(element->elementdata.pathdata.path, graphics, hrgn);
924         case RegionDataRect:
925         {
926             GpPath* path;
927             GpStatus stat;
928             GpRectF* rc = &element->elementdata.rect;
929
930             stat = GdipCreatePath(FillModeAlternate, &path);
931             if (stat != Ok)
932                 return stat;
933             stat = GdipAddPathRectangle(path, rc->X, rc->Y, rc->Width, rc->Height);
934
935             if (stat == Ok)
936                 stat = get_path_hrgn(path, graphics, hrgn);
937
938             GdipDeletePath(path);
939
940             return stat;
941         }
942         case CombineModeIntersect:
943         case CombineModeUnion:
944         case CombineModeXor:
945         case CombineModeExclude:
946         case CombineModeComplement:
947         {
948             HRGN left, right;
949             GpStatus stat;
950             int ret;
951
952             stat = get_region_hrgn(element->elementdata.combine.left, graphics, &left);
953             if (stat != Ok)
954             {
955                 *hrgn = NULL;
956                 return stat;
957             }
958
959             if (left == NULL)
960             {
961                 /* existing region is infinite */
962                 switch (element->type)
963                 {
964                     case CombineModeIntersect:
965                         return get_region_hrgn(element->elementdata.combine.right, graphics, hrgn);
966                     case CombineModeXor: case CombineModeExclude:
967                         FIXME("cannot exclude from an infinite region\n");
968                         /* fall-through */
969                     case CombineModeUnion: case CombineModeComplement:
970                         *hrgn = NULL;
971                         return Ok;
972                 }
973             }
974
975             stat = get_region_hrgn(element->elementdata.combine.right, graphics, &right);
976             if (stat != Ok)
977             {
978                 DeleteObject(left);
979                 *hrgn = NULL;
980                 return stat;
981             }
982
983             if (right == NULL)
984             {
985                 /* new region is infinite */
986                 switch (element->type)
987                 {
988                     case CombineModeIntersect:
989                         *hrgn = left;
990                         return Ok;
991                     case CombineModeXor: case CombineModeComplement:
992                         FIXME("cannot exclude from an infinite region\n");
993                         /* fall-through */
994                     case CombineModeUnion: case CombineModeExclude:
995                         DeleteObject(left);
996                         *hrgn = NULL;
997                         return Ok;
998                 }
999             }
1000
1001             switch (element->type)
1002             {
1003                 case CombineModeIntersect:
1004                     ret = CombineRgn(left, left, right, RGN_AND);
1005                     break;
1006                 case CombineModeUnion:
1007                     ret = CombineRgn(left, left, right, RGN_OR);
1008                     break;
1009                 case CombineModeXor:
1010                     ret = CombineRgn(left, left, right, RGN_XOR);
1011                     break;
1012                 case CombineModeExclude:
1013                     ret = CombineRgn(left, left, right, RGN_DIFF);
1014                     break;
1015                 case CombineModeComplement:
1016                     ret = CombineRgn(left, right, left, RGN_DIFF);
1017                     break;
1018                 default:
1019                     ret = ERROR;
1020             }
1021
1022             DeleteObject(right);
1023
1024             if (ret == ERROR)
1025             {
1026                 DeleteObject(left);
1027                 *hrgn = NULL;
1028                 return GenericError;
1029             }
1030
1031             *hrgn = left;
1032             return Ok;
1033         }
1034         default:
1035             FIXME("GdipGetRegionHRgn unimplemented for region type=%x\n", element->type);
1036             *hrgn = NULL;
1037             return NotImplemented;
1038     }
1039 }
1040
1041 /*****************************************************************************
1042  * GdipGetRegionHRgn [GDIPLUS.@]
1043  */
1044 GpStatus WINGDIPAPI GdipGetRegionHRgn(GpRegion *region, GpGraphics *graphics, HRGN *hrgn)
1045 {
1046     TRACE("(%p, %p, %p)\n", region, graphics, hrgn);
1047
1048     if (!region || !hrgn)
1049         return InvalidParameter;
1050
1051     return get_region_hrgn(&region->node, graphics, hrgn);
1052 }
1053
1054 GpStatus WINGDIPAPI GdipIsEmptyRegion(GpRegion *region, GpGraphics *graphics, BOOL *res)
1055 {
1056     TRACE("(%p, %p, %p)\n", region, graphics, res);
1057
1058     if(!region || !graphics || !res)
1059         return InvalidParameter;
1060
1061     *res = (region->node.type == RegionDataEmptyRect);
1062
1063     return Ok;
1064 }
1065
1066 /*****************************************************************************
1067  * GdipIsEqualRegion [GDIPLUS.@]
1068  */
1069 GpStatus WINGDIPAPI GdipIsEqualRegion(GpRegion *region, GpRegion *region2, GpGraphics *graphics,
1070                                       BOOL *res)
1071 {
1072     HRGN hrgn1, hrgn2;
1073     GpStatus stat;
1074
1075     TRACE("(%p, %p, %p, %p)\n", region, region2, graphics, res);
1076
1077     if(!region || !region2 || !graphics || !res)
1078         return InvalidParameter;
1079
1080     stat = GdipGetRegionHRgn(region, graphics, &hrgn1);
1081     if(stat != Ok)
1082         return stat;
1083     stat = GdipGetRegionHRgn(region2, graphics, &hrgn2);
1084     if(stat != Ok){
1085         DeleteObject(hrgn1);
1086         return stat;
1087     }
1088
1089     *res = EqualRgn(hrgn1, hrgn2);
1090
1091     /* one of GpRegions is infinite */
1092     if(*res == ERROR)
1093         *res = (!hrgn1 && !hrgn2);
1094
1095     DeleteObject(hrgn1);
1096     DeleteObject(hrgn2);
1097
1098     return Ok;
1099 }
1100
1101 /*****************************************************************************
1102  * GdipIsInfiniteRegion [GDIPLUS.@]
1103  */
1104 GpStatus WINGDIPAPI GdipIsInfiniteRegion(GpRegion *region, GpGraphics *graphics, BOOL *res)
1105 {
1106     /* I think graphics is ignored here */
1107     TRACE("(%p, %p, %p)\n", region, graphics, res);
1108
1109     if(!region || !graphics || !res)
1110         return InvalidParameter;
1111
1112     *res = (region->node.type == RegionDataInfiniteRect);
1113
1114     return Ok;
1115 }
1116
1117 /*****************************************************************************
1118  * GdipSetEmpty [GDIPLUS.@]
1119  */
1120 GpStatus WINGDIPAPI GdipSetEmpty(GpRegion *region)
1121 {
1122     GpStatus stat;
1123
1124     TRACE("%p\n", region);
1125
1126     if (!region)
1127         return InvalidParameter;
1128
1129     delete_element(&region->node);
1130     stat = init_region(region, RegionDataEmptyRect);
1131
1132     return stat;
1133 }
1134
1135 GpStatus WINGDIPAPI GdipSetInfinite(GpRegion *region)
1136 {
1137     GpStatus stat;
1138
1139     TRACE("%p\n", region);
1140
1141     if (!region)
1142         return InvalidParameter;
1143
1144     delete_element(&region->node);
1145     stat = init_region(region, RegionDataInfiniteRect);
1146
1147     return stat;
1148 }
1149
1150 GpStatus WINGDIPAPI GdipTransformRegion(GpRegion *region, GpMatrix *matrix)
1151 {
1152     FIXME("(%p, %p): stub\n", region, matrix);
1153
1154     return NotImplemented;
1155 }
1156
1157 /* Translates GpRegion elements with specified offsets */
1158 static void translate_region_element(region_element* element, REAL dx, REAL dy)
1159 {
1160     INT i;
1161
1162     switch(element->type)
1163     {
1164         case RegionDataEmptyRect:
1165         case RegionDataInfiniteRect:
1166             return;
1167         case RegionDataRect:
1168             element->elementdata.rect.X += dx;
1169             element->elementdata.rect.Y += dy;
1170             return;
1171         case RegionDataPath:
1172             for(i = 0; i < element->elementdata.pathdata.path->pathdata.Count; i++){
1173                 element->elementdata.pathdata.path->pathdata.Points[i].X += dx;
1174                 element->elementdata.pathdata.path->pathdata.Points[i].Y += dy;
1175             }
1176             return;
1177         default:
1178             translate_region_element(element->elementdata.combine.left,  dx, dy);
1179             translate_region_element(element->elementdata.combine.right, dx, dy);
1180             return;
1181     }
1182 }
1183
1184 /*****************************************************************************
1185  * GdipTranslateRegion [GDIPLUS.@]
1186  */
1187 GpStatus WINGDIPAPI GdipTranslateRegion(GpRegion *region, REAL dx, REAL dy)
1188 {
1189     TRACE("(%p, %f, %f)\n", region, dx, dy);
1190
1191     if(!region)
1192         return InvalidParameter;
1193
1194     translate_region_element(&region->node, dx, dy);
1195
1196     return Ok;
1197 }
1198
1199 /*****************************************************************************
1200  * GdipTranslateRegionI [GDIPLUS.@]
1201  */
1202 GpStatus WINGDIPAPI GdipTranslateRegionI(GpRegion *region, INT dx, INT dy)
1203 {
1204     TRACE("(%p, %d, %d)\n", region, dx, dy);
1205
1206     return GdipTranslateRegion(region, (REAL)dx, (REAL)dy);
1207 }