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
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
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
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
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
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
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)
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
)
107 return needed
+ sizeof(GpRect
);
109 needed
+= element
->elementdata
.pathdata
.pathheader
.size
;
110 needed
+= sizeof(DWORD
); /* Extra DWORD for pathheader.size */
112 case RegionDataEmptyRect
:
113 case RegionDataInfiniteRect
:
116 needed
+= get_element_size(element
->elementdata
.combine
.left
);
117 needed
+= get_element_size(element
->elementdata
.combine
.right
);
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(®ion
->node
);
136 static inline GpStatus
clone_element(const region_element
* element
,
137 region_element
** element2
)
141 /* root node is allocated with GpRegion */
143 *element2
= GdipAlloc(sizeof(region_element
));
148 (*element2
)->type
= element
->type
;
150 switch (element
->type
)
153 (*element2
)->elementdata
.rect
= element
->elementdata
.rect
;
155 case RegionDataEmptyRect
:
156 case RegionDataInfiniteRect
:
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
;
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
;
180 delete_element(*element2
);
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(®ion
->node
);
196 region
->header
.num_children
+= 2;
199 /*****************************************************************************
200 * GdipCloneRegion [GDIPLUS.@]
202 * Creates a deep copy of the region
205 * region [I] source region
206 * clone [O] resulting clone
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
));
224 element
= &(*clone
)->node
;
226 (*clone
)->header
= region
->header
;
227 return clone_element(®ion
->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
;
239 TRACE("%p %p %d\n", region
, path
, mode
);
241 if (!(region
&& path
))
242 return InvalidParameter
;
244 stat
= GdipCreateRegionPath(path
, &path_region
);
248 /* simply replace region data */
249 if(mode
== CombineModeReplace
){
250 delete_element(®ion
->node
);
251 memcpy(region
, path_region
, sizeof(GpRegion
));
255 left
= GdipAlloc(sizeof(region_element
));
258 *left
= region
->node
;
260 stat
= clone_element(&path_region
->node
, &right
);
264 fuse_region(region
, left
, right
, mode
);
266 GdipDeleteRegion(path_region
);
271 GdipDeleteRegion(path_region
);
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
;
285 TRACE("%p %p %d\n", region
, rect
, mode
);
287 if (!(region
&& rect
))
288 return InvalidParameter
;
290 stat
= GdipCreateRegionRect(rect
, &rect_region
);
294 /* simply replace region data */
295 if(mode
== CombineModeReplace
){
296 delete_element(®ion
->node
);
297 memcpy(region
, rect_region
, sizeof(GpRegion
));
301 left
= GdipAlloc(sizeof(region_element
));
304 memcpy(left
, ®ion
->node
, sizeof(region_element
));
306 stat
= clone_element(&rect_region
->node
, &right
);
310 fuse_region(region
, left
, right
, mode
);
312 GdipDeleteRegion(rect_region
);
317 GdipDeleteRegion(rect_region
);
321 /*****************************************************************************
322 * GdipCombineRegionRectI [GDIPLUS.@]
324 GpStatus WINGDIPAPI
GdipCombineRegionRectI(GpRegion
*region
,
325 GDIPCONST GpRect
*rect
, CombineMode mode
)
329 TRACE("%p %p %d\n", region
, rect
, mode
);
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
;
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
, ®2copy
);
357 if(stat
!= Ok
) return stat
;
359 delete_element(®ion1
->node
);
360 memcpy(region1
, reg2copy
, sizeof(GpRegion
));
365 left
= GdipAlloc(sizeof(region_element
));
369 *left
= region1
->node
;
370 stat
= clone_element(®ion2
->node
, &right
);
377 fuse_region(region1
, left
, right
, mode
);
378 region1
->header
.num_children
+= region2
->header
.num_children
;
383 /*****************************************************************************
384 * GdipCreateRegion [GDIPLUS.@]
386 GpStatus WINGDIPAPI
GdipCreateRegion(GpRegion
**region
)
388 TRACE("%p\n", region
);
391 return InvalidParameter
;
393 *region
= GdipAlloc(sizeof(GpRegion
));
397 return init_region(*region
, RegionDataInfiniteRect
);
400 /*****************************************************************************
401 * GdipCreateRegionPath [GDIPLUS.@]
403 * Creates a GpRegion from a GpPath
406 * path [I] path to base the region on
407 * region [O] pointer to the newly allocated region
411 * FAILURE: InvalidParameter
414 * If a path has no floating point points, its points will be stored as shorts
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
;
426 DWORD flags
= FLAGS_INTPATH
;
429 TRACE("%p, %p\n", path
, region
);
431 if (!(path
&& region
))
432 return InvalidParameter
;
434 *region
= GdipAlloc(sizeof(GpRegion
));
437 stat
= init_region(*region
, RegionDataPath
);
440 GdipDeleteRegion(*region
);
443 element
= &(*region
)->node
;
444 count
= path
->pathdata
.Count
;
446 /* Test to see if the path is an Integer path */
449 pointsi
= GdipAlloc(sizeof(GpPoint
) * count
);
450 pointsf
= GdipAlloc(sizeof(GpPointF
) * count
);
451 if (!(pointsi
&& pointsf
))
455 GdipDeleteRegion(*region
);
459 stat
= GdipGetPathPointsI(path
, pointsi
, count
);
462 GdipDeleteRegion(*region
);
465 stat
= GdipGetPathPoints(path
, pointsf
, count
);
468 GdipDeleteRegion(*region
);
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
;
485 stat
= GdipClonePath(path
, &element
->elementdata
.pathdata
.path
);
488 GdipDeleteRegion(*region
);
492 /* 3 for headers, once again size doesn't count itself */
493 element
->elementdata
.pathdata
.pathheader
.size
= ((sizeof(DWORD
) * 3));
496 /* Floats, sent out as floats */
498 element
->elementdata
.pathdata
.pathheader
.size
+=
499 (sizeof(DWORD
) * count
* 2);
501 /* INTs, sent out as packed shorts */
503 element
->elementdata
.pathdata
.pathheader
.size
+=
504 (sizeof(DWORD
) * count
);
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
);
518 /*****************************************************************************
519 * GdipCreateRegionRect [GDIPLUS.@]
521 GpStatus WINGDIPAPI
GdipCreateRegionRect(GDIPCONST GpRectF
*rect
,
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
);
535 GdipDeleteRegion(*region
);
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
;
547 GpStatus WINGDIPAPI
GdipCreateRegionRectI(GDIPCONST GpRect
*rect
,
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
);
567 return NotImplemented
;
571 /******************************************************************************
572 * GdipCreateRegionHrgn [GDIPLUS.@]
574 GpStatus WINGDIPAPI
GdipCreateRegionHrgn(HRGN hrgn
, GpRegion
**region
)
578 char buf
[sizeof(RGNDATAHEADER
) + sizeof(RECT
)];
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");
593 return NotImplemented
;
596 if(!GetRegionData(hrgn
, sizeof(rdata
), &rdata
.data
))
599 /* return empty region */
600 if(IsRectEmpty(&rdata
.data
.rdh
.rcBound
)){
601 stat
= GdipCreateRegion(region
);
603 GdipSetEmpty(*region
);
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
);
616 GdipAddPathRectangle(path
, rectf
.X
, rectf
.Y
, rectf
.Width
, rectf
.Height
);
618 stat
= GdipCreateRegionPath(path
, region
);
619 GdipDeletePath(path
);
624 GpStatus WINGDIPAPI
GdipDeleteRegion(GpRegion
*region
)
626 TRACE("%p\n", region
);
629 return InvalidParameter
;
631 delete_element(®ion
->node
);
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
;
657 static inline void write_float(DWORD
* location
, INT
* offset
, const FLOAT write
)
659 ((FLOAT
*)location
)[*offset
] = write
;
663 static inline void write_packed_point(DWORD
* location
, INT
* offset
,
664 const GpPointF
* write
)
670 memcpy(location
+ *offset
, &point
, sizeof(packed_point
));
674 static inline void write_path_types(DWORD
* location
, INT
* offset
,
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
,
690 write_dword(buffer
, filled
, element
->type
);
691 switch (element
->type
)
693 case CombineModeReplace
:
694 case CombineModeIntersect
:
695 case CombineModeUnion
:
697 case CombineModeExclude
:
698 case CombineModeComplement
:
699 write_element(element
->elementdata
.combine
.left
, buffer
, filled
);
700 write_element(element
->elementdata
.combine
.right
, buffer
, filled
);
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
);
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
)
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
);
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
);
735 case RegionDataEmptyRect
:
736 case RegionDataInfiniteRect
:
741 /*****************************************************************************
742 * GdipGetRegionData [GDIPLUS.@]
744 * Returns the header, followed by combining ops and region elements.
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
754 * FAILURE: InvalidParamter
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
774 GpStatus WINGDIPAPI
GdipGetRegionData(GpRegion
*region
, BYTE
*buffer
, UINT size
,
779 TRACE("%p, %p, %d, %p\n", region
, buffer
, size
, needed
);
781 if (!(region
&& buffer
&& size
))
782 return InvalidParameter
;
784 memcpy(buffer
, ®ion
->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(®ion
->node
, (DWORD
*)buffer
, &filled
);
791 *needed
= filled
* sizeof(DWORD
);
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;
812 static GpStatus
get_path_hrgn(GpPath
*path
, GpGraphics
*graphics
, HRGN
*hrgn
)
824 stat
= GdipCreateFromHDC(new_hdc
, &graphics
);
827 ReleaseDC(0, new_hdc
);
832 save_state
= SaveDC(graphics
->hdc
);
833 EndPath(graphics
->hdc
);
835 SetPolyFillMode(graphics
->hdc
, (path
->fill
== FillModeAlternate
? ALTERNATE
838 stat
= trace_path(graphics
, path
);
841 *hrgn
= PathToRegion(graphics
->hdc
);
842 stat
= *hrgn
? Ok
: OutOfMemory
;
845 RestoreDC(graphics
->hdc
, save_state
);
848 ReleaseDC(0, new_hdc
);
849 GdipDeleteGraphics(graphics
);
855 static GpStatus
get_region_hrgn(struct region_element
*element
, GpGraphics
*graphics
, HRGN
*hrgn
)
857 switch (element
->type
)
859 case RegionDataInfiniteRect
:
862 case RegionDataEmptyRect
:
863 *hrgn
= CreateRectRgn(0, 0, 0, 0);
864 return *hrgn
? Ok
: OutOfMemory
;
866 return get_path_hrgn(element
->elementdata
.pathdata
.path
, graphics
, hrgn
);
871 GpRectF
* rc
= &element
->elementdata
.rect
;
873 stat
= GdipCreatePath(FillModeAlternate
, &path
);
876 stat
= GdipAddPathRectangle(path
, rc
->X
, rc
->Y
, rc
->Width
, rc
->Height
);
879 stat
= get_path_hrgn(path
, graphics
, hrgn
);
881 GdipDeletePath(path
);
885 case CombineModeIntersect
:
886 case CombineModeUnion
:
888 case CombineModeExclude
:
889 case CombineModeComplement
:
895 stat
= get_region_hrgn(element
->elementdata
.combine
.left
, graphics
, &left
);
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");
912 case CombineModeUnion
: case CombineModeComplement
:
918 stat
= get_region_hrgn(element
->elementdata
.combine
.right
, graphics
, &right
);
928 /* new region is infinite */
929 switch (element
->type
)
931 case CombineModeIntersect
:
934 case CombineModeXor
: case CombineModeComplement
:
935 FIXME("cannot exclude from an infinite region\n");
937 case CombineModeUnion
: case CombineModeExclude
:
944 switch (element
->type
)
946 case CombineModeIntersect
:
947 ret
= CombineRgn(left
, left
, right
, RGN_AND
);
949 case CombineModeUnion
:
950 ret
= CombineRgn(left
, left
, right
, RGN_OR
);
953 ret
= CombineRgn(left
, left
, right
, RGN_XOR
);
955 case CombineModeExclude
:
956 ret
= CombineRgn(left
, left
, right
, RGN_DIFF
);
958 case CombineModeComplement
:
959 ret
= CombineRgn(left
, right
, left
, RGN_DIFF
);
978 FIXME("GdipGetRegionHRgn unimplemented for region type=%x\n", element
->type
);
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(®ion
->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
);
1009 GpStatus WINGDIPAPI
GdipIsEqualRegion(GpRegion
*region
, GpRegion
*region2
, GpGraphics
*graphics
,
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
);
1033 /*****************************************************************************
1034 * GdipSetEmpty [GDIPLUS.@]
1036 GpStatus WINGDIPAPI
GdipSetEmpty(GpRegion
*region
)
1040 TRACE("%p\n", region
);
1043 return InvalidParameter
;
1045 delete_element(®ion
->node
);
1046 stat
= init_region(region
, RegionDataEmptyRect
);
1051 GpStatus WINGDIPAPI
GdipSetInfinite(GpRegion
*region
)
1055 TRACE("%p\n", region
);
1058 return InvalidParameter
;
1060 delete_element(®ion
->node
);
1061 stat
= init_region(region
, RegionDataInfiniteRect
);
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
;