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 delete_element(right
);
272 GdipDeleteRegion(path_region
);
276 /*****************************************************************************
277 * GdipCombineRegionRect [GDIPLUS.@]
279 GpStatus WINGDIPAPI
GdipCombineRegionRect(GpRegion
*region
,
280 GDIPCONST GpRectF
*rect
, CombineMode mode
)
282 GpRegion
*rect_region
;
283 region_element
*left
, *right
= NULL
;
286 TRACE("%p %p %d\n", region
, rect
, mode
);
288 if (!(region
&& rect
))
289 return InvalidParameter
;
291 stat
= GdipCreateRegionRect(rect
, &rect_region
);
295 /* simply replace region data */
296 if(mode
== CombineModeReplace
){
297 delete_element(®ion
->node
);
298 memcpy(region
, rect_region
, sizeof(GpRegion
));
302 left
= GdipAlloc(sizeof(region_element
));
305 memcpy(left
, ®ion
->node
, sizeof(region_element
));
307 stat
= clone_element(&rect_region
->node
, &right
);
311 fuse_region(region
, left
, right
, mode
);
313 GdipDeleteRegion(rect_region
);
318 delete_element(right
);
319 GdipDeleteRegion(rect_region
);
323 /*****************************************************************************
324 * GdipCombineRegionRectI [GDIPLUS.@]
326 GpStatus WINGDIPAPI
GdipCombineRegionRectI(GpRegion
*region
,
327 GDIPCONST GpRect
*rect
, CombineMode mode
)
331 TRACE("%p %p %d\n", region
, rect
, mode
);
334 return InvalidParameter
;
336 rectf
.X
= (REAL
)rect
->X
;
337 rectf
.Y
= (REAL
)rect
->Y
;
338 rectf
.Height
= (REAL
)rect
->Height
;
339 rectf
.Width
= (REAL
)rect
->Width
;
341 return GdipCombineRegionRect(region
, &rectf
, mode
);
344 GpStatus WINGDIPAPI
GdipCombineRegionRegion(GpRegion
*region1
,
345 GpRegion
*region2
, CombineMode mode
)
347 region_element
*left
, *right
= NULL
;
351 TRACE("%p %p %d\n", region1
, region2
, mode
);
353 if(!(region1
&& region2
))
354 return InvalidParameter
;
356 /* simply replace region data */
357 if(mode
== CombineModeReplace
){
358 stat
= GdipCloneRegion(region2
, ®2copy
);
359 if(stat
!= Ok
) return stat
;
361 delete_element(®ion1
->node
);
362 memcpy(region1
, reg2copy
, sizeof(GpRegion
));
366 left
= GdipAlloc(sizeof(region_element
));
370 *left
= region1
->node
;
371 stat
= clone_element(®ion2
->node
, &right
);
375 delete_element(right
);
379 fuse_region(region1
, left
, right
, mode
);
380 region1
->header
.num_children
+= region2
->header
.num_children
;
385 /*****************************************************************************
386 * GdipCreateRegion [GDIPLUS.@]
388 GpStatus WINGDIPAPI
GdipCreateRegion(GpRegion
**region
)
390 TRACE("%p\n", region
);
393 return InvalidParameter
;
395 *region
= GdipAlloc(sizeof(GpRegion
));
399 return init_region(*region
, RegionDataInfiniteRect
);
402 /*****************************************************************************
403 * GdipCreateRegionPath [GDIPLUS.@]
405 * Creates a GpRegion from a GpPath
408 * path [I] path to base the region on
409 * region [O] pointer to the newly allocated region
413 * FAILURE: InvalidParameter
416 * If a path has no floating point points, its points will be stored as shorts
419 * If a path is empty, it is considered to be an INTPATH
421 GpStatus WINGDIPAPI
GdipCreateRegionPath(GpPath
*path
, GpRegion
**region
)
423 region_element
* element
;
428 DWORD flags
= FLAGS_INTPATH
;
431 TRACE("%p, %p\n", path
, region
);
433 if (!(path
&& region
))
434 return InvalidParameter
;
436 *region
= GdipAlloc(sizeof(GpRegion
));
439 stat
= init_region(*region
, RegionDataPath
);
442 GdipDeleteRegion(*region
);
445 element
= &(*region
)->node
;
446 count
= path
->pathdata
.Count
;
448 /* Test to see if the path is an Integer path */
451 pointsi
= GdipAlloc(sizeof(GpPoint
) * count
);
452 pointsf
= GdipAlloc(sizeof(GpPointF
) * count
);
453 if (!(pointsi
&& pointsf
))
457 GdipDeleteRegion(*region
);
461 stat
= GdipGetPathPointsI(path
, pointsi
, count
);
464 GdipDeleteRegion(*region
);
467 stat
= GdipGetPathPoints(path
, pointsf
, count
);
470 GdipDeleteRegion(*region
);
474 for (i
= 0; i
< count
; i
++)
476 if (!(pointsi
[i
].X
== pointsf
[i
].X
&&
477 pointsi
[i
].Y
== pointsf
[i
].Y
))
479 flags
= FLAGS_NOFLAGS
;
487 stat
= GdipClonePath(path
, &element
->elementdata
.pathdata
.path
);
490 GdipDeleteRegion(*region
);
494 /* 3 for headers, once again size doesn't count itself */
495 element
->elementdata
.pathdata
.pathheader
.size
= ((sizeof(DWORD
) * 3));
498 /* Floats, sent out as floats */
500 element
->elementdata
.pathdata
.pathheader
.size
+=
501 (sizeof(DWORD
) * count
* 2);
503 /* INTs, sent out as packed shorts */
505 element
->elementdata
.pathdata
.pathheader
.size
+=
506 (sizeof(DWORD
) * count
);
509 FIXME("Unhandled flags (%08x). Expect wrong results.\n", flags
);
511 element
->elementdata
.pathdata
.pathheader
.size
+= get_pathtypes_size(path
);
512 element
->elementdata
.pathdata
.pathheader
.magic
= VERSION_MAGIC
;
513 element
->elementdata
.pathdata
.pathheader
.count
= count
;
514 element
->elementdata
.pathdata
.pathheader
.flags
= flags
;
515 (*region
)->header
.size
= sizeheader_size
+ get_element_size(element
);
520 /*****************************************************************************
521 * GdipCreateRegionRect [GDIPLUS.@]
523 GpStatus WINGDIPAPI
GdipCreateRegionRect(GDIPCONST GpRectF
*rect
,
528 TRACE("%p, %p\n", rect
, region
);
530 if (!(rect
&& region
))
531 return InvalidParameter
;
533 *region
= GdipAlloc(sizeof(GpRegion
));
534 stat
= init_region(*region
, RegionDataRect
);
537 GdipDeleteRegion(*region
);
541 (*region
)->node
.elementdata
.rect
.X
= rect
->X
;
542 (*region
)->node
.elementdata
.rect
.Y
= rect
->Y
;
543 (*region
)->node
.elementdata
.rect
.Width
= rect
->Width
;
544 (*region
)->node
.elementdata
.rect
.Height
= rect
->Height
;
549 GpStatus WINGDIPAPI
GdipCreateRegionRectI(GDIPCONST GpRect
*rect
,
554 TRACE("%p, %p\n", rect
, region
);
556 rectf
.X
= (REAL
)rect
->X
;
557 rectf
.Y
= (REAL
)rect
->Y
;
558 rectf
.Width
= (REAL
)rect
->Width
;
559 rectf
.Height
= (REAL
)rect
->Height
;
561 return GdipCreateRegionRect(&rectf
, region
);
564 GpStatus WINGDIPAPI
GdipCreateRegionRgnData(GDIPCONST BYTE
*data
, INT size
, GpRegion
**region
)
566 FIXME("(%p, %d, %p): stub\n", data
, size
, region
);
569 return NotImplemented
;
572 GpStatus WINGDIPAPI
GdipCreateRegionHrgn(HRGN hrgn
, GpRegion
**region
)
574 FIXME("(%p, %p): stub\n", hrgn
, region
);
577 return NotImplemented
;
580 GpStatus WINGDIPAPI
GdipDeleteRegion(GpRegion
*region
)
582 TRACE("%p\n", region
);
585 return InvalidParameter
;
587 delete_element(®ion
->node
);
593 GpStatus WINGDIPAPI
GdipGetRegionBounds(GpRegion
*region
, GpGraphics
*graphics
, GpRectF
*rect
)
595 FIXME("(%p, %p, %p): stub\n", region
, graphics
, rect
);
597 return NotImplemented
;
600 GpStatus WINGDIPAPI
GdipGetRegionBoundsI(GpRegion
*region
, GpGraphics
*graphics
, GpRect
*rect
)
602 FIXME("(%p, %p, %p): stub\n", region
, graphics
, rect
);
604 return NotImplemented
;
607 static inline void write_dword(DWORD
* location
, INT
* offset
, const DWORD write
)
609 location
[*offset
] = write
;
613 static inline void write_float(DWORD
* location
, INT
* offset
, const FLOAT write
)
615 ((FLOAT
*)location
)[*offset
] = write
;
619 static inline void write_packed_point(DWORD
* location
, INT
* offset
,
620 const GpPointF
* write
)
626 memcpy(location
+ *offset
, &point
, sizeof(packed_point
));
630 static inline void write_path_types(DWORD
* location
, INT
* offset
,
633 memcpy(location
+ *offset
, path
->pathdata
.Types
, path
->pathdata
.Count
);
635 /* The unwritten parts of the DWORD (if any) must be cleared */
636 if (path
->pathdata
.Count
% sizeof(DWORD
))
637 ZeroMemory(((BYTE
*)location
) + (*offset
* sizeof(DWORD
)) +
638 path
->pathdata
.Count
,
639 sizeof(DWORD
) - path
->pathdata
.Count
% sizeof(DWORD
));
640 *offset
+= (get_pathtypes_size(path
) / sizeof(DWORD
));
643 static void write_element(const region_element
* element
, DWORD
*buffer
,
646 write_dword(buffer
, filled
, element
->type
);
647 switch (element
->type
)
649 case CombineModeReplace
:
650 case CombineModeIntersect
:
651 case CombineModeUnion
:
653 case CombineModeExclude
:
654 case CombineModeComplement
:
655 write_element(element
->elementdata
.combine
.left
, buffer
, filled
);
656 write_element(element
->elementdata
.combine
.right
, buffer
, filled
);
659 write_float(buffer
, filled
, element
->elementdata
.rect
.X
);
660 write_float(buffer
, filled
, element
->elementdata
.rect
.Y
);
661 write_float(buffer
, filled
, element
->elementdata
.rect
.Width
);
662 write_float(buffer
, filled
, element
->elementdata
.rect
.Height
);
667 const GpPath
* path
= element
->elementdata
.pathdata
.path
;
669 memcpy(buffer
+ *filled
, &element
->elementdata
.pathdata
.pathheader
,
670 sizeof(element
->elementdata
.pathdata
.pathheader
));
671 *filled
+= sizeof(element
->elementdata
.pathdata
.pathheader
) / sizeof(DWORD
);
672 switch (element
->elementdata
.pathdata
.pathheader
.flags
)
675 for (i
= 0; i
< path
->pathdata
.Count
; i
++)
677 write_float(buffer
, filled
, path
->pathdata
.Points
[i
].X
);
678 write_float(buffer
, filled
, path
->pathdata
.Points
[i
].Y
);
682 for (i
= 0; i
< path
->pathdata
.Count
; i
++)
684 write_packed_point(buffer
, filled
,
685 &path
->pathdata
.Points
[i
]);
688 write_path_types(buffer
, filled
, path
);
691 case RegionDataEmptyRect
:
692 case RegionDataInfiniteRect
:
697 /*****************************************************************************
698 * GdipGetRegionData [GDIPLUS.@]
700 * Returns the header, followed by combining ops and region elements.
703 * region [I] region to retrieve from
704 * buffer [O] buffer to hold the resulting data
705 * size [I] size of the buffer
706 * needed [O] (optional) how much data was written
710 * FAILURE: InvalidParamter
713 * The header contains the size, a checksum, a version string, and the number
714 * of children. The size does not count itself or the checksum.
715 * Version is always something like 0xdbc01001 or 0xdbc01002
717 * An element is a RECT, or PATH; Combining ops are stored as their
718 * CombineMode value. Special regions (infinite, empty) emit just their
719 * op-code; GpRectFs emit their code followed by their points; GpPaths emit
720 * their code followed by a second header for the path followed by the actual
721 * path data. Followed by the flags for each point. The pathheader contains
722 * the size of the data to follow, a version number again, followed by a count
723 * of how many points, and any special flags which may apply. 0x4000 means its
724 * a path of shorts instead of FLOAT.
726 * Combining Ops are stored in reverse order from when they were constructed;
727 * the output is a tree where the left side combining area is always taken
730 GpStatus WINGDIPAPI
GdipGetRegionData(GpRegion
*region
, BYTE
*buffer
, UINT size
,
735 TRACE("%p, %p, %d, %p\n", region
, buffer
, size
, needed
);
737 if (!(region
&& buffer
&& size
))
738 return InvalidParameter
;
740 memcpy(buffer
, ®ion
->header
, sizeof(region
->header
));
741 filled
+= sizeof(region
->header
) / sizeof(DWORD
);
742 /* With few exceptions, everything written is DWORD aligned,
743 * so use that as our base */
744 write_element(®ion
->node
, (DWORD
*)buffer
, &filled
);
747 *needed
= filled
* sizeof(DWORD
);
752 /*****************************************************************************
753 * GdipGetRegionDataSize [GDIPLUS.@]
755 GpStatus WINGDIPAPI
GdipGetRegionDataSize(GpRegion
*region
, UINT
*needed
)
757 TRACE("%p, %p\n", region
, needed
);
759 if (!(region
&& needed
))
760 return InvalidParameter
;
762 /* header.size doesn't count header.size and header.checksum */
763 *needed
= region
->header
.size
+ sizeof(DWORD
) * 2;
768 /*****************************************************************************
769 * GdipGetRegionHRgn [GDIPLUS.@]
771 GpStatus WINGDIPAPI
GdipGetRegionHRgn(GpRegion
*region
, GpGraphics
*graphics
, HRGN
*hrgn
)
773 FIXME("(%p, %p, %p): stub\n", region
, graphics
, hrgn
);
776 return NotImplemented
;
779 GpStatus WINGDIPAPI
GdipIsEmptyRegion(GpRegion
*region
, GpGraphics
*graphics
, BOOL
*res
)
781 TRACE("(%p, %p, %p)\n", region
, graphics
, res
);
783 if(!region
|| !graphics
|| !res
)
784 return InvalidParameter
;
786 *res
= (region
->node
.type
== RegionDataEmptyRect
);
791 GpStatus WINGDIPAPI
GdipIsEqualRegion(GpRegion
*region
, GpRegion
*region2
, GpGraphics
*graphics
,
794 FIXME("(%p, %p, %p, %p): stub\n", region
, region2
, graphics
, res
);
796 return NotImplemented
;
799 /*****************************************************************************
800 * GdipIsInfiniteRegion [GDIPLUS.@]
802 GpStatus WINGDIPAPI
GdipIsInfiniteRegion(GpRegion
*region
, GpGraphics
*graphics
, BOOL
*res
)
804 /* I think graphics is ignored here */
805 TRACE("(%p, %p, %p)\n", region
, graphics
, res
);
807 if(!region
|| !graphics
|| !res
)
808 return InvalidParameter
;
810 *res
= (region
->node
.type
== RegionDataInfiniteRect
);
815 /*****************************************************************************
816 * GdipSetEmpty [GDIPLUS.@]
818 GpStatus WINGDIPAPI
GdipSetEmpty(GpRegion
*region
)
822 TRACE("%p\n", region
);
825 return InvalidParameter
;
827 delete_element(®ion
->node
);
828 stat
= init_region(region
, RegionDataEmptyRect
);
833 GpStatus WINGDIPAPI
GdipSetInfinite(GpRegion
*region
)
837 TRACE("%p\n", region
);
840 return InvalidParameter
;
842 delete_element(®ion
->node
);
843 stat
= init_region(region
, RegionDataInfiniteRect
);
848 GpStatus WINGDIPAPI
GdipTransformRegion(GpRegion
*region
, GpMatrix
*matrix
)
850 FIXME("(%p, %p): stub\n", region
, matrix
);
852 return NotImplemented
;
855 GpStatus WINGDIPAPI
GdipTranslateRegion(GpRegion
*region
, REAL dx
, REAL dy
)
857 FIXME("(%p, %f, %f): stub\n", region
, dx
, dy
);
859 return NotImplemented
;
862 GpStatus WINGDIPAPI
GdipTranslateRegionI(GpRegion
*region
, INT dx
, INT dy
)
864 FIXME("(%p, %d, %d): stub\n", region
, dx
, dy
);
866 return NotImplemented
;