msvcrt/tests: Remove a space before a '\n'.
[wine/gsoc-2012-control.git] / dlls / gdiplus / region.c
blobe4cc7d829dbc7a7c5aa751818188f0dfe8314cc5
1 /*
2 * Copyright (C) 2008 Google (Lei Zhang)
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.
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.
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
19 #include <stdarg.h>
21 #include "windef.h"
22 #include "winbase.h"
23 #include "wingdi.h"
25 #include "objbase.h"
27 #include "gdiplus.h"
28 #include "gdiplus_private.h"
29 #include "wine/debug.h"
31 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
33 /**********************************************************
35 * Data returned by GdipGetRegionData looks something like this:
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 * };
45 * Then follows a sequence of combining ops and region elements.
47 * A region element is either a RECTF or some path data.
49 * Combining ops are just stored as their CombineMode value.
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).
55 * Path data is preceded by the DWORD 0x10000001. Then follows a
56 * DWORD size and then size bytes of data.
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.
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).
71 * When a simple region (1 element) is combined, it's treated as if a
72 * single rect/path is being combined.
76 #define FLAGS_NOFLAGS 0x0
77 #define FLAGS_INTPATH 0x4000
79 /* Header size as far as header->size is concerned. This doesn't include
80 * header->size or header->checksum
82 static const INT sizeheader_size = sizeof(DWORD) * 2;
84 typedef struct packed_point
86 short X;
87 short Y;
88 } packed_point;
90 /* Everything is measured in DWORDS; round up if there's a remainder */
91 static inline INT get_pathtypes_size(const GpPath* path)
93 INT needed = path->pathdata.Count / sizeof(DWORD);
95 if (path->pathdata.Count % sizeof(DWORD) > 0)
96 needed++;
98 return needed * sizeof(DWORD);
101 static inline INT get_element_size(const region_element* element)
103 INT needed = sizeof(DWORD); /* DWORD for the type */
104 switch(element->type)
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;
121 return 0;
124 /* Does not check parameters, caller must do that */
125 static inline GpStatus init_region(GpRegion* region, const RegionType type)
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);
133 return Ok;
136 static inline GpStatus clone_element(const region_element* element,
137 region_element** element2)
139 GpStatus stat;
141 /* root node is allocated with GpRegion */
142 if(!*element2){
143 *element2 = GdipAlloc(sizeof(region_element));
144 if (!*element2)
145 return OutOfMemory;
148 (*element2)->type = element->type;
150 switch (element->type)
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;
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;
177 return Ok;
179 clone_out:
180 delete_element(*element2);
181 *element2 = NULL;
182 return stat;
185 /* Common code for CombineRegion*
186 * All the caller has to do is get its format into an element
188 static inline void fuse_region(GpRegion* region, region_element* left,
189 region_element* right, const CombineMode mode)
191 region->node.type = mode;
192 region->node.elementdata.combine.left = left;
193 region->node.elementdata.combine.right = right;
195 region->header.size = sizeheader_size + get_element_size(&region->node);
196 region->header.num_children += 2;
199 /*****************************************************************************
200 * GdipCloneRegion [GDIPLUS.@]
202 * Creates a deep copy of the region
204 * PARAMS
205 * region [I] source region
206 * clone [O] resulting clone
208 * RETURNS
209 * SUCCESS: Ok
210 * FAILURE: InvalidParameter or OutOfMemory
212 GpStatus WINGDIPAPI GdipCloneRegion(GpRegion *region, GpRegion **clone)
214 region_element *element;
216 TRACE("%p %p\n", region, clone);
218 if (!(region && clone))
219 return InvalidParameter;
221 *clone = GdipAlloc(sizeof(GpRegion));
222 if (!*clone)
223 return OutOfMemory;
224 element = &(*clone)->node;
226 (*clone)->header = region->header;
227 return clone_element(&region->node, &element);
230 /*****************************************************************************
231 * GdipCombineRegionPath [GDIPLUS.@]
233 GpStatus WINGDIPAPI GdipCombineRegionPath(GpRegion *region, GpPath *path, CombineMode mode)
235 GpRegion *path_region;
236 region_element *left, *right = NULL;
237 GpStatus stat;
239 TRACE("%p %p %d\n", region, path, mode);
241 if (!(region && path))
242 return InvalidParameter;
244 stat = GdipCreateRegionPath(path, &path_region);
245 if (stat != Ok)
246 return stat;
248 /* simply replace region data */
249 if(mode == CombineModeReplace){
250 delete_element(&region->node);
251 memcpy(region, path_region, sizeof(GpRegion));
252 return Ok;
255 left = GdipAlloc(sizeof(region_element));
256 if (!left)
257 goto out;
258 *left = region->node;
260 stat = clone_element(&path_region->node, &right);
261 if (stat != Ok)
262 goto out;
264 fuse_region(region, left, right, mode);
266 GdipDeleteRegion(path_region);
267 return Ok;
269 out:
270 GdipFree(left);
271 GdipDeleteRegion(path_region);
272 return stat;
275 /*****************************************************************************
276 * GdipCombineRegionRect [GDIPLUS.@]
278 GpStatus WINGDIPAPI GdipCombineRegionRect(GpRegion *region,
279 GDIPCONST GpRectF *rect, CombineMode mode)
281 GpRegion *rect_region;
282 region_element *left, *right = NULL;
283 GpStatus stat;
285 TRACE("%p %p %d\n", region, rect, mode);
287 if (!(region && rect))
288 return InvalidParameter;
290 stat = GdipCreateRegionRect(rect, &rect_region);
291 if (stat != Ok)
292 return stat;
294 /* simply replace region data */
295 if(mode == CombineModeReplace){
296 delete_element(&region->node);
297 memcpy(region, rect_region, sizeof(GpRegion));
298 return Ok;
301 left = GdipAlloc(sizeof(region_element));
302 if (!left)
303 goto out;
304 memcpy(left, &region->node, sizeof(region_element));
306 stat = clone_element(&rect_region->node, &right);
307 if (stat != Ok)
308 goto out;
310 fuse_region(region, left, right, mode);
312 GdipDeleteRegion(rect_region);
313 return Ok;
315 out:
316 GdipFree(left);
317 GdipDeleteRegion(rect_region);
318 return stat;
321 /*****************************************************************************
322 * GdipCombineRegionRectI [GDIPLUS.@]
324 GpStatus WINGDIPAPI GdipCombineRegionRectI(GpRegion *region,
325 GDIPCONST GpRect *rect, CombineMode mode)
327 GpRectF rectf;
329 TRACE("%p %p %d\n", region, rect, mode);
331 if (!rect)
332 return InvalidParameter;
334 rectf.X = (REAL)rect->X;
335 rectf.Y = (REAL)rect->Y;
336 rectf.Height = (REAL)rect->Height;
337 rectf.Width = (REAL)rect->Width;
339 return GdipCombineRegionRect(region, &rectf, mode);
342 GpStatus WINGDIPAPI GdipCombineRegionRegion(GpRegion *region1,
343 GpRegion *region2, CombineMode mode)
345 region_element *left, *right = NULL;
346 GpStatus stat;
347 GpRegion *reg2copy;
349 TRACE("%p %p %d\n", region1, region2, mode);
351 if(!(region1 && region2))
352 return InvalidParameter;
354 /* simply replace region data */
355 if(mode == CombineModeReplace){
356 stat = GdipCloneRegion(region2, &reg2copy);
357 if(stat != Ok) return stat;
359 delete_element(&region1->node);
360 memcpy(region1, reg2copy, sizeof(GpRegion));
361 GdipFree(reg2copy);
362 return Ok;
365 left = GdipAlloc(sizeof(region_element));
366 if (!left)
367 return OutOfMemory;
369 *left = region1->node;
370 stat = clone_element(&region2->node, &right);
371 if (stat != Ok)
373 GdipFree(left);
374 return OutOfMemory;
377 fuse_region(region1, left, right, mode);
378 region1->header.num_children += region2->header.num_children;
380 return Ok;
383 /*****************************************************************************
384 * GdipCreateRegion [GDIPLUS.@]
386 GpStatus WINGDIPAPI GdipCreateRegion(GpRegion **region)
388 TRACE("%p\n", region);
390 if(!region)
391 return InvalidParameter;
393 *region = GdipAlloc(sizeof(GpRegion));
394 if(!*region)
395 return OutOfMemory;
397 return init_region(*region, RegionDataInfiniteRect);
400 /*****************************************************************************
401 * GdipCreateRegionPath [GDIPLUS.@]
403 * Creates a GpRegion from a GpPath
405 * PARAMS
406 * path [I] path to base the region on
407 * region [O] pointer to the newly allocated region
409 * RETURNS
410 * SUCCESS: Ok
411 * FAILURE: InvalidParameter
413 * NOTES
414 * If a path has no floating point points, its points will be stored as shorts
415 * (INTPATH)
417 * If a path is empty, it is considered to be an INTPATH
419 GpStatus WINGDIPAPI GdipCreateRegionPath(GpPath *path, GpRegion **region)
421 region_element* element;
422 GpPoint *pointsi;
423 GpPointF *pointsf;
425 GpStatus stat;
426 DWORD flags = FLAGS_INTPATH;
427 INT count, i;
429 TRACE("%p, %p\n", path, region);
431 if (!(path && region))
432 return InvalidParameter;
434 *region = GdipAlloc(sizeof(GpRegion));
435 if(!*region)
436 return OutOfMemory;
437 stat = init_region(*region, RegionDataPath);
438 if (stat != Ok)
440 GdipDeleteRegion(*region);
441 return stat;
443 element = &(*region)->node;
444 count = path->pathdata.Count;
446 /* Test to see if the path is an Integer path */
447 if (count)
449 pointsi = GdipAlloc(sizeof(GpPoint) * count);
450 pointsf = GdipAlloc(sizeof(GpPointF) * count);
451 if (!(pointsi && pointsf))
453 GdipFree(pointsi);
454 GdipFree(pointsf);
455 GdipDeleteRegion(*region);
456 return OutOfMemory;
459 stat = GdipGetPathPointsI(path, pointsi, count);
460 if (stat != Ok)
462 GdipDeleteRegion(*region);
463 return stat;
465 stat = GdipGetPathPoints(path, pointsf, count);
466 if (stat != Ok)
468 GdipDeleteRegion(*region);
469 return stat;
472 for (i = 0; i < count; i++)
474 if (!(pointsi[i].X == pointsf[i].X &&
475 pointsi[i].Y == pointsf[i].Y ))
477 flags = FLAGS_NOFLAGS;
478 break;
481 GdipFree(pointsi);
482 GdipFree(pointsf);
485 stat = GdipClonePath(path, &element->elementdata.pathdata.path);
486 if (stat != Ok)
488 GdipDeleteRegion(*region);
489 return stat;
492 /* 3 for headers, once again size doesn't count itself */
493 element->elementdata.pathdata.pathheader.size = ((sizeof(DWORD) * 3));
494 switch(flags)
496 /* Floats, sent out as floats */
497 case FLAGS_NOFLAGS:
498 element->elementdata.pathdata.pathheader.size +=
499 (sizeof(DWORD) * count * 2);
500 break;
501 /* INTs, sent out as packed shorts */
502 case FLAGS_INTPATH:
503 element->elementdata.pathdata.pathheader.size +=
504 (sizeof(DWORD) * count);
505 break;
506 default:
507 FIXME("Unhandled flags (%08x). Expect wrong results.\n", flags);
509 element->elementdata.pathdata.pathheader.size += get_pathtypes_size(path);
510 element->elementdata.pathdata.pathheader.magic = VERSION_MAGIC;
511 element->elementdata.pathdata.pathheader.count = count;
512 element->elementdata.pathdata.pathheader.flags = flags;
513 (*region)->header.size = sizeheader_size + get_element_size(element);
515 return Ok;
518 /*****************************************************************************
519 * GdipCreateRegionRect [GDIPLUS.@]
521 GpStatus WINGDIPAPI GdipCreateRegionRect(GDIPCONST GpRectF *rect,
522 GpRegion **region)
524 GpStatus stat;
526 TRACE("%p, %p\n", rect, region);
528 if (!(rect && region))
529 return InvalidParameter;
531 *region = GdipAlloc(sizeof(GpRegion));
532 stat = init_region(*region, RegionDataRect);
533 if(stat != Ok)
535 GdipDeleteRegion(*region);
536 return stat;
539 (*region)->node.elementdata.rect.X = rect->X;
540 (*region)->node.elementdata.rect.Y = rect->Y;
541 (*region)->node.elementdata.rect.Width = rect->Width;
542 (*region)->node.elementdata.rect.Height = rect->Height;
544 return Ok;
547 GpStatus WINGDIPAPI GdipCreateRegionRectI(GDIPCONST GpRect *rect,
548 GpRegion **region)
550 GpRectF rectf;
552 TRACE("%p, %p\n", rect, region);
554 rectf.X = (REAL)rect->X;
555 rectf.Y = (REAL)rect->Y;
556 rectf.Width = (REAL)rect->Width;
557 rectf.Height = (REAL)rect->Height;
559 return GdipCreateRegionRect(&rectf, region);
562 GpStatus WINGDIPAPI GdipCreateRegionRgnData(GDIPCONST BYTE *data, INT size, GpRegion **region)
564 FIXME("(%p, %d, %p): stub\n", data, size, region);
566 *region = NULL;
567 return NotImplemented;
571 /******************************************************************************
572 * GdipCreateRegionHrgn [GDIPLUS.@]
574 GpStatus WINGDIPAPI GdipCreateRegionHrgn(HRGN hrgn, GpRegion **region)
576 union {
577 RGNDATA data;
578 char buf[sizeof(RGNDATAHEADER) + sizeof(RECT)];
579 } rdata;
580 DWORD size;
581 GpRectF rectf;
582 GpPath *path;
583 GpStatus stat;
585 TRACE("(%p, %p)\n", hrgn, region);
587 if(!region || !(size = GetRegionData(hrgn, 0, NULL)))
588 return InvalidParameter;
590 if(size > sizeof(RGNDATAHEADER) + sizeof(RECT)){
591 FIXME("Only simple rect regions supported.\n");
592 *region = NULL;
593 return NotImplemented;
596 if(!GetRegionData(hrgn, sizeof(rdata), &rdata.data))
597 return GenericError;
599 /* return empty region */
600 if(IsRectEmpty(&rdata.data.rdh.rcBound)){
601 stat = GdipCreateRegion(region);
602 if(stat == Ok)
603 GdipSetEmpty(*region);
604 return stat;
607 rectf.X = (REAL)rdata.data.rdh.rcBound.left;
608 rectf.Y = (REAL)rdata.data.rdh.rcBound.top;
609 rectf.Width = (REAL)rdata.data.rdh.rcBound.right - rectf.X;
610 rectf.Height = (REAL)rdata.data.rdh.rcBound.bottom - rectf.Y;
612 stat = GdipCreatePath(FillModeAlternate, &path);
613 if(stat != Ok)
614 return stat;
616 GdipAddPathRectangle(path, rectf.X, rectf.Y, rectf.Width, rectf.Height);
618 stat = GdipCreateRegionPath(path, region);
619 GdipDeletePath(path);
621 return stat;
624 GpStatus WINGDIPAPI GdipDeleteRegion(GpRegion *region)
626 TRACE("%p\n", region);
628 if (!region)
629 return InvalidParameter;
631 delete_element(&region->node);
632 GdipFree(region);
634 return Ok;
637 GpStatus WINGDIPAPI GdipGetRegionBounds(GpRegion *region, GpGraphics *graphics, GpRectF *rect)
639 FIXME("(%p, %p, %p): stub\n", region, graphics, rect);
641 return NotImplemented;
644 GpStatus WINGDIPAPI GdipGetRegionBoundsI(GpRegion *region, GpGraphics *graphics, GpRect *rect)
646 FIXME("(%p, %p, %p): stub\n", region, graphics, rect);
648 return NotImplemented;
651 static inline void write_dword(DWORD* location, INT* offset, const DWORD write)
653 location[*offset] = write;
654 (*offset)++;
657 static inline void write_float(DWORD* location, INT* offset, const FLOAT write)
659 ((FLOAT*)location)[*offset] = write;
660 (*offset)++;
663 static inline void write_packed_point(DWORD* location, INT* offset,
664 const GpPointF* write)
666 packed_point point;
668 point.X = write->X;
669 point.Y = write->Y;
670 memcpy(location + *offset, &point, sizeof(packed_point));
671 (*offset)++;
674 static inline void write_path_types(DWORD* location, INT* offset,
675 const GpPath* path)
677 memcpy(location + *offset, path->pathdata.Types, path->pathdata.Count);
679 /* The unwritten parts of the DWORD (if any) must be cleared */
680 if (path->pathdata.Count % sizeof(DWORD))
681 ZeroMemory(((BYTE*)location) + (*offset * sizeof(DWORD)) +
682 path->pathdata.Count,
683 sizeof(DWORD) - path->pathdata.Count % sizeof(DWORD));
684 *offset += (get_pathtypes_size(path) / sizeof(DWORD));
687 static void write_element(const region_element* element, DWORD *buffer,
688 INT* filled)
690 write_dword(buffer, filled, element->type);
691 switch (element->type)
693 case CombineModeReplace:
694 case CombineModeIntersect:
695 case CombineModeUnion:
696 case CombineModeXor:
697 case CombineModeExclude:
698 case CombineModeComplement:
699 write_element(element->elementdata.combine.left, buffer, filled);
700 write_element(element->elementdata.combine.right, buffer, filled);
701 break;
702 case RegionDataRect:
703 write_float(buffer, filled, element->elementdata.rect.X);
704 write_float(buffer, filled, element->elementdata.rect.Y);
705 write_float(buffer, filled, element->elementdata.rect.Width);
706 write_float(buffer, filled, element->elementdata.rect.Height);
707 break;
708 case RegionDataPath:
710 INT i;
711 const GpPath* path = element->elementdata.pathdata.path;
713 memcpy(buffer + *filled, &element->elementdata.pathdata.pathheader,
714 sizeof(element->elementdata.pathdata.pathheader));
715 *filled += sizeof(element->elementdata.pathdata.pathheader) / sizeof(DWORD);
716 switch (element->elementdata.pathdata.pathheader.flags)
718 case FLAGS_NOFLAGS:
719 for (i = 0; i < path->pathdata.Count; i++)
721 write_float(buffer, filled, path->pathdata.Points[i].X);
722 write_float(buffer, filled, path->pathdata.Points[i].Y);
724 break;
725 case FLAGS_INTPATH:
726 for (i = 0; i < path->pathdata.Count; i++)
728 write_packed_point(buffer, filled,
729 &path->pathdata.Points[i]);
732 write_path_types(buffer, filled, path);
733 break;
735 case RegionDataEmptyRect:
736 case RegionDataInfiniteRect:
737 break;
741 /*****************************************************************************
742 * GdipGetRegionData [GDIPLUS.@]
744 * Returns the header, followed by combining ops and region elements.
746 * PARAMS
747 * region [I] region to retrieve from
748 * buffer [O] buffer to hold the resulting data
749 * size [I] size of the buffer
750 * needed [O] (optional) how much data was written
752 * RETURNS
753 * SUCCESS: Ok
754 * FAILURE: InvalidParamter
756 * NOTES
757 * The header contains the size, a checksum, a version string, and the number
758 * of children. The size does not count itself or the checksum.
759 * Version is always something like 0xdbc01001 or 0xdbc01002
761 * An element is a RECT, or PATH; Combining ops are stored as their
762 * CombineMode value. Special regions (infinite, empty) emit just their
763 * op-code; GpRectFs emit their code followed by their points; GpPaths emit
764 * their code followed by a second header for the path followed by the actual
765 * path data. Followed by the flags for each point. The pathheader contains
766 * the size of the data to follow, a version number again, followed by a count
767 * of how many points, and any special flags which may apply. 0x4000 means its
768 * a path of shorts instead of FLOAT.
770 * Combining Ops are stored in reverse order from when they were constructed;
771 * the output is a tree where the left side combining area is always taken
772 * first.
774 GpStatus WINGDIPAPI GdipGetRegionData(GpRegion *region, BYTE *buffer, UINT size,
775 UINT *needed)
777 INT filled = 0;
779 TRACE("%p, %p, %d, %p\n", region, buffer, size, needed);
781 if (!(region && buffer && size))
782 return InvalidParameter;
784 memcpy(buffer, &region->header, sizeof(region->header));
785 filled += sizeof(region->header) / sizeof(DWORD);
786 /* With few exceptions, everything written is DWORD aligned,
787 * so use that as our base */
788 write_element(&region->node, (DWORD*)buffer, &filled);
790 if (needed)
791 *needed = filled * sizeof(DWORD);
793 return Ok;
796 /*****************************************************************************
797 * GdipGetRegionDataSize [GDIPLUS.@]
799 GpStatus WINGDIPAPI GdipGetRegionDataSize(GpRegion *region, UINT *needed)
801 TRACE("%p, %p\n", region, needed);
803 if (!(region && needed))
804 return InvalidParameter;
806 /* header.size doesn't count header.size and header.checksum */
807 *needed = region->header.size + sizeof(DWORD) * 2;
809 return Ok;
812 static GpStatus get_path_hrgn(GpPath *path, GpGraphics *graphics, HRGN *hrgn)
814 HDC new_hdc=NULL;
815 GpStatus stat;
816 INT save_state;
818 if (!graphics)
820 new_hdc = GetDC(0);
821 if (!new_hdc)
822 return OutOfMemory;
824 stat = GdipCreateFromHDC(new_hdc, &graphics);
825 if (stat != Ok)
827 ReleaseDC(0, new_hdc);
828 return stat;
832 save_state = SaveDC(graphics->hdc);
833 EndPath(graphics->hdc);
835 SetPolyFillMode(graphics->hdc, (path->fill == FillModeAlternate ? ALTERNATE
836 : WINDING));
838 stat = trace_path(graphics, path);
839 if (stat == Ok)
841 *hrgn = PathToRegion(graphics->hdc);
842 stat = *hrgn ? Ok : OutOfMemory;
845 RestoreDC(graphics->hdc, save_state);
846 if (new_hdc)
848 ReleaseDC(0, new_hdc);
849 GdipDeleteGraphics(graphics);
852 return stat;
855 static GpStatus get_region_hrgn(struct region_element *element, GpGraphics *graphics, HRGN *hrgn)
857 switch (element->type)
859 case RegionDataInfiniteRect:
860 *hrgn = NULL;
861 return Ok;
862 case RegionDataEmptyRect:
863 *hrgn = CreateRectRgn(0, 0, 0, 0);
864 return *hrgn ? Ok : OutOfMemory;
865 case RegionDataPath:
866 return get_path_hrgn(element->elementdata.pathdata.path, graphics, hrgn);
867 case RegionDataRect:
869 GpPath* path;
870 GpStatus stat;
871 GpRectF* rc = &element->elementdata.rect;
873 stat = GdipCreatePath(FillModeAlternate, &path);
874 if (stat != Ok)
875 return stat;
876 stat = GdipAddPathRectangle(path, rc->X, rc->Y, rc->Width, rc->Height);
878 if (stat == Ok)
879 stat = get_path_hrgn(path, graphics, hrgn);
881 GdipDeletePath(path);
883 return stat;
885 case CombineModeIntersect:
886 case CombineModeUnion:
887 case CombineModeXor:
888 case CombineModeExclude:
889 case CombineModeComplement:
891 HRGN left, right;
892 GpStatus stat;
893 int ret;
895 stat = get_region_hrgn(element->elementdata.combine.left, graphics, &left);
896 if (stat != Ok)
898 *hrgn = NULL;
899 return stat;
902 if (left == NULL)
904 /* existing region is infinite */
905 switch (element->type)
907 case CombineModeIntersect:
908 return get_region_hrgn(element->elementdata.combine.right, graphics, hrgn);
909 case CombineModeXor: case CombineModeExclude:
910 FIXME("cannot exclude from an infinite region\n");
911 /* fall-through */
912 case CombineModeUnion: case CombineModeComplement:
913 *hrgn = NULL;
914 return Ok;
918 stat = get_region_hrgn(element->elementdata.combine.right, graphics, &right);
919 if (stat != Ok)
921 DeleteObject(left);
922 *hrgn = NULL;
923 return stat;
926 if (right == NULL)
928 /* new region is infinite */
929 switch (element->type)
931 case CombineModeIntersect:
932 *hrgn = left;
933 return Ok;
934 case CombineModeXor: case CombineModeComplement:
935 FIXME("cannot exclude from an infinite region\n");
936 /* fall-through */
937 case CombineModeUnion: case CombineModeExclude:
938 DeleteObject(left);
939 *hrgn = NULL;
940 return Ok;
944 switch (element->type)
946 case CombineModeIntersect:
947 ret = CombineRgn(left, left, right, RGN_AND);
948 break;
949 case CombineModeUnion:
950 ret = CombineRgn(left, left, right, RGN_OR);
951 break;
952 case CombineModeXor:
953 ret = CombineRgn(left, left, right, RGN_XOR);
954 break;
955 case CombineModeExclude:
956 ret = CombineRgn(left, left, right, RGN_DIFF);
957 break;
958 case CombineModeComplement:
959 ret = CombineRgn(left, right, left, RGN_DIFF);
960 break;
961 default:
962 ret = ERROR;
965 DeleteObject(right);
967 if (ret == ERROR)
969 DeleteObject(left);
970 *hrgn = NULL;
971 return GenericError;
974 *hrgn = left;
975 return Ok;
977 default:
978 FIXME("GdipGetRegionHRgn unimplemented for region type=%x\n", element->type);
979 *hrgn = NULL;
980 return NotImplemented;
984 /*****************************************************************************
985 * GdipGetRegionHRgn [GDIPLUS.@]
987 GpStatus WINGDIPAPI GdipGetRegionHRgn(GpRegion *region, GpGraphics *graphics, HRGN *hrgn)
989 TRACE("(%p, %p, %p)\n", region, graphics, hrgn);
991 if (!region || !hrgn)
992 return InvalidParameter;
994 return get_region_hrgn(&region->node, graphics, hrgn);
997 GpStatus WINGDIPAPI GdipIsEmptyRegion(GpRegion *region, GpGraphics *graphics, BOOL *res)
999 TRACE("(%p, %p, %p)\n", region, graphics, res);
1001 if(!region || !graphics || !res)
1002 return InvalidParameter;
1004 *res = (region->node.type == RegionDataEmptyRect);
1006 return Ok;
1009 GpStatus WINGDIPAPI GdipIsEqualRegion(GpRegion *region, GpRegion *region2, GpGraphics *graphics,
1010 BOOL *res)
1012 FIXME("(%p, %p, %p, %p): stub\n", region, region2, graphics, res);
1014 return NotImplemented;
1017 /*****************************************************************************
1018 * GdipIsInfiniteRegion [GDIPLUS.@]
1020 GpStatus WINGDIPAPI GdipIsInfiniteRegion(GpRegion *region, GpGraphics *graphics, BOOL *res)
1022 /* I think graphics is ignored here */
1023 TRACE("(%p, %p, %p)\n", region, graphics, res);
1025 if(!region || !graphics || !res)
1026 return InvalidParameter;
1028 *res = (region->node.type == RegionDataInfiniteRect);
1030 return Ok;
1033 /*****************************************************************************
1034 * GdipSetEmpty [GDIPLUS.@]
1036 GpStatus WINGDIPAPI GdipSetEmpty(GpRegion *region)
1038 GpStatus stat;
1040 TRACE("%p\n", region);
1042 if (!region)
1043 return InvalidParameter;
1045 delete_element(&region->node);
1046 stat = init_region(region, RegionDataEmptyRect);
1048 return stat;
1051 GpStatus WINGDIPAPI GdipSetInfinite(GpRegion *region)
1053 GpStatus stat;
1055 TRACE("%p\n", region);
1057 if (!region)
1058 return InvalidParameter;
1060 delete_element(&region->node);
1061 stat = init_region(region, RegionDataInfiniteRect);
1063 return stat;
1066 GpStatus WINGDIPAPI GdipTransformRegion(GpRegion *region, GpMatrix *matrix)
1068 FIXME("(%p, %p): stub\n", region, matrix);
1070 return NotImplemented;
1073 GpStatus WINGDIPAPI GdipTranslateRegion(GpRegion *region, REAL dx, REAL dy)
1075 FIXME("(%p, %f, %f): stub\n", region, dx, dy);
1077 return NotImplemented;
1080 GpStatus WINGDIPAPI GdipTranslateRegionI(GpRegion *region, INT dx, INT dy)
1082 FIXME("(%p, %d, %d): stub\n", region, dx, dy);
1084 return NotImplemented;