region.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "objbase.h"
#include "gdiplus.h"
#include "gdiplus_private.h"
#include "wine/debug.h"

Include dependency graph for region.c:

Go to the source code of this file.

Classes
struct	region_header
struct	region_data_header
struct	path_header
struct	packed_point

Macros
#define	FLAGS_INTPATH   0x4000

Typedefs
typedef struct packed_point	packed_point

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (gdiplus)
static INT	get_element_size (const region_element *element)
static GpStatus	init_region (GpRegion *region, const RegionType type)
static GpStatus	clone_element (const region_element *element, region_element **element2)
static void	fuse_region (GpRegion *region, region_element *left, region_element *right, const CombineMode mode)
GpStatus WINGDIPAPI	GdipCloneRegion (GpRegion *region, GpRegion **clone)
GpStatus WINGDIPAPI	GdipCombineRegionPath (GpRegion *region, GpPath *path, CombineMode mode)
GpStatus WINGDIPAPI	GdipCombineRegionRect (GpRegion *region, GDIPCONST GpRectF *rect, CombineMode mode)
GpStatus WINGDIPAPI	GdipCombineRegionRectI (GpRegion *region, GDIPCONST GpRect *rect, CombineMode mode)
GpStatus WINGDIPAPI	GdipCombineRegionRegion (GpRegion *region1, GpRegion *region2, CombineMode mode)
GpStatus WINGDIPAPI	GdipCreateRegion (GpRegion **region)
GpStatus WINGDIPAPI	GdipCreateRegionPath (GpPath *path, GpRegion **region)
GpStatus WINGDIPAPI	GdipCreateRegionRect (GDIPCONST GpRectF *rect, GpRegion **region)
GpStatus WINGDIPAPI	GdipCreateRegionRectI (GDIPCONST GpRect *rect, GpRegion **region)
GpStatus WINGDIPAPI	GdipCreateRegionHrgn (HRGN hrgn, GpRegion **region)
GpStatus WINGDIPAPI	GdipDeleteRegion (GpRegion *region)
GpStatus WINGDIPAPI	GdipGetRegionBounds (GpRegion *region, GpGraphics *graphics, GpRectF *rect)
GpStatus WINGDIPAPI	GdipGetRegionBoundsI (GpRegion *region, GpGraphics *graphics, GpRect *rect)
static void	write_dword (DWORD *location, INT *offset, const DWORD write)
static void	write_float (DWORD *location, INT *offset, const FLOAT write)
static void	write_element (const region_element *element, DWORD *buffer, INT *filled)
DWORD	write_region_data (const GpRegion *region, void *data)
GpStatus WINGDIPAPI	GdipGetRegionData (GpRegion *region, BYTE *buffer, UINT size, UINT *needed)
static GpStatus	read_element (struct memory_buffer *mbuf, GpRegion *region, region_element *node, INT *count)
GpStatus WINGDIPAPI	GdipCreateRegionRgnData (GDIPCONST BYTE *data, INT size, GpRegion **region)
GpStatus WINGDIPAPI	GdipGetRegionDataSize (GpRegion *region, UINT *needed)
static GpStatus	get_path_hrgn (GpPath *path, GpGraphics *graphics, HRGN *hrgn)
static GpStatus	get_region_hrgn (struct region_element *element, GpGraphics *graphics, HRGN *hrgn)
GpStatus WINGDIPAPI	GdipGetRegionHRgn (GpRegion *region, GpGraphics *graphics, HRGN *hrgn)
GpStatus WINGDIPAPI	GdipIsEmptyRegion (GpRegion *region, GpGraphics *graphics, BOOL *res)
GpStatus WINGDIPAPI	GdipIsEqualRegion (GpRegion *region, GpRegion *region2, GpGraphics *graphics, BOOL *res)
GpStatus WINGDIPAPI	GdipIsInfiniteRegion (GpRegion *region, GpGraphics *graphics, BOOL *res)
GpStatus WINGDIPAPI	GdipIsVisibleRegionRect (GpRegion *region, REAL x, REAL y, REAL w, REAL h, GpGraphics *graphics, BOOL *res)
GpStatus WINGDIPAPI	GdipIsVisibleRegionRectI (GpRegion *region, INT x, INT y, INT w, INT h, GpGraphics *graphics, BOOL *res)
GpStatus WINGDIPAPI	GdipIsVisibleRegionPoint (GpRegion *region, REAL x, REAL y, GpGraphics *graphics, BOOL *res)
GpStatus WINGDIPAPI	GdipIsVisibleRegionPointI (GpRegion *region, INT x, INT y, GpGraphics *graphics, BOOL *res)
GpStatus WINGDIPAPI	GdipSetEmpty (GpRegion *region)
GpStatus WINGDIPAPI	GdipSetInfinite (GpRegion *region)
static GpStatus	transform_region_element (region_element *element, GpMatrix *matrix)
GpStatus WINGDIPAPI	GdipTransformRegion (GpRegion *region, GpMatrix *matrix)
static void	translate_region_element (region_element *element, REAL dx, REAL dy)
GpStatus WINGDIPAPI	GdipTranslateRegion (GpRegion *region, REAL dx, REAL dy)
GpStatus WINGDIPAPI	GdipTranslateRegionI (GpRegion *region, INT dx, INT dy)
static GpStatus	get_region_scans_data (GpRegion *region, GpMatrix *matrix, LPRGNDATA *data)
GpStatus WINGDIPAPI	GdipGetRegionScansCount (GpRegion *region, UINT *count, GpMatrix *matrix)
GpStatus WINGDIPAPI	GdipGetRegionScansI (GpRegion *region, GpRect *scans, INT *count, GpMatrix *matrix)
GpStatus WINGDIPAPI	GdipGetRegionScans (GpRegion *region, GpRectF *scans, INT *count, GpMatrix *matrix)

Macro Definition Documentation

FLAGS_INTPATH

#define FLAGS_INTPATH   0x4000

Definition at line 77 of file region.c.

Typedef Documentation

packed_point

typedef struct packed_point packed_point

Function Documentation

clone_element()

static GpStatus clone_element ( const region_element *  element, region_element **  element2  )

inlinestatic

Definition at line 140 of file region.c.

{
    GpStatus stat;
 
    /* root node is allocated with GpRegion */
    if(!*element2){
        *element2 = heap_alloc_zero(sizeof(region_element));
        if (!*element2)
            return OutOfMemory;
    }
 
    (*element2)->type = element->type;
 
    switch (element->type)
    {
        case RegionDataRect:
            (*element2)->elementdata.rect = element->elementdata.rect;
            return Ok;
        case RegionDataEmptyRect:
        case RegionDataInfiniteRect:
            return Ok;
        case RegionDataPath:
            stat = GdipClonePath(element->elementdata.path, &(*element2)->elementdata.path);
            if (stat == Ok) return Ok;
            break;
        default:
            (*element2)->elementdata.combine.left  = NULL;
            (*element2)->elementdata.combine.right = NULL;
 
            stat = clone_element(element->elementdata.combine.left,
                    &(*element2)->elementdata.combine.left);
            if (stat == Ok)
            {
                stat = clone_element(element->elementdata.combine.right,
                        &(*element2)->elementdata.combine.right);
                if (stat == Ok) return Ok;
            }
            break;
    }
 
    delete_element(*element2);
    *element2 = NULL;
    return stat;
}

Referenced by clone_element(), GdipCloneRegion(), GdipCombineRegionPath(), GdipCombineRegionRect(), and GdipCombineRegionRegion().

fuse_region()

static void fuse_region ( GpRegion *  region, region_element *  left, region_element *  right, const CombineMode  mode  )

inlinestatic

Definition at line 189 of file region.c.

{
    region->node.type = mode;
    region->node.elementdata.combine.left = left;
    region->node.elementdata.combine.right = right;
    region->num_children += 2;
}

Referenced by GdipCombineRegionPath(), GdipCombineRegionRect(), and GdipCombineRegionRegion().

GdipCloneRegion()

GpStatus WINGDIPAPI GdipCloneRegion	(	GpRegion *	region,
		GpRegion **	clone
	)

Definition at line 211 of file region.c.

{
    region_element *element;
 
    TRACE("%p %p\n", region, clone);
 
    if (!(region && clone))
        return InvalidParameter;
 
    *clone = heap_alloc_zero(sizeof(GpRegion));
    if (!*clone)
        return OutOfMemory;
    element = &(*clone)->node;
 
    (*clone)->num_children = region->num_children;
    return clone_element(&region->node, &element);
}

Referenced by GdipCombineRegionRegion(), GdipGetClip(), GdipPlayMetafileRecord(), GdipSetClipRegion(), get_clip_hrgn(), get_region_scans_data(), init_container(), restore_container(), and SOFTWARE_GdipFillRegion().

GdipCombineRegionPath()

GpStatus WINGDIPAPI GdipCombineRegionPath	(	GpRegion *	region,
		GpPath *	path,
		CombineMode	mode
	)

Definition at line 232 of file region.c.

{
    GpRegion *path_region;
    region_element *left, *right = NULL;
    GpStatus stat;
 
    TRACE("%p %p %d\n", region, path, mode);
 
    if (!(region && path))
        return InvalidParameter;
 
    stat = GdipCreateRegionPath(path, &path_region);
    if (stat != Ok)
        return stat;
 
    /* simply replace region data */
    if(mode == CombineModeReplace){
        delete_element(&region->node);
        memcpy(region, path_region, sizeof(GpRegion));
        heap_free(path_region);
        return Ok;
    }
 
    left = heap_alloc_zero(sizeof(region_element));
    if (left)
    {
        *left = region->node;
        stat = clone_element(&path_region->node, &right);
        if (stat == Ok)
        {
            fuse_region(region, left, right, mode);
            GdipDeleteRegion(path_region);
            return Ok;
        }
    }
    else
        stat = OutOfMemory;
 
    heap_free(left);
    GdipDeleteRegion(path_region);
    return stat;
}

Referenced by GdipEnumerateMetafileSrcRectDestPoints(), GdipSetClipPath(), test_combinereplace(), test_getregiondata(), test_isvisiblepoint(), test_isvisiblerect(), test_transform(), and test_translate().

GdipCombineRegionRect()

GpStatus WINGDIPAPI GdipCombineRegionRect	(	GpRegion *	region,
		GDIPCONST GpRectF *	rect,
		CombineMode	mode
	)

Definition at line 278 of file region.c.

{
    GpRegion *rect_region;
    region_element *left, *right = NULL;
    GpStatus stat;
 
    TRACE("%p %s %d\n", region, debugstr_rectf(rect), mode);
 
    if (!(region && rect))
        return InvalidParameter;
 
    stat = GdipCreateRegionRect(rect, &rect_region);
    if (stat != Ok)
        return stat;
 
    /* simply replace region data */
    if(mode == CombineModeReplace){
        delete_element(&region->node);
        memcpy(region, rect_region, sizeof(GpRegion));
        heap_free(rect_region);
        return Ok;
    }
 
    left = heap_alloc_zero(sizeof(region_element));
    if (left)
    {
        memcpy(left, &region->node, sizeof(region_element));
        stat = clone_element(&rect_region->node, &right);
        if (stat == Ok)
        {
            fuse_region(region, left, right, mode);
            GdipDeleteRegion(rect_region);
            return Ok;
        }
    }
    else
        stat = OutOfMemory;
 
    heap_free(left);
    GdipDeleteRegion(rect_region);
    return stat;
}

Referenced by GdipCombineRegionRectI(), get_visible_clip_region(), measure_ranges_callback(), SOFTWARE_GdipFillRegion(), test_clipping(), test_clipping_2(), test_combinereplace(), test_excludeinfinite(), test_getbounds(), test_gethrgn(), test_isequal(), test_isvisiblepoint(), test_isvisiblerect(), test_scans(), test_transform(), and test_translate().

GdipCombineRegionRectI()

GpStatus WINGDIPAPI GdipCombineRegionRectI	(	GpRegion *	region,
		GDIPCONST GpRect *	rect,
		CombineMode	mode
	)

Definition at line 325 of file region.c.

{
    GpRectF rectf;
 
    TRACE("%p %p %d\n", region, rect, mode);
 
    if (!rect)
        return InvalidParameter;
 
    rectf.X = (REAL)rect->X;
    rectf.Y = (REAL)rect->Y;
    rectf.Height = (REAL)rect->Height;
    rectf.Width = (REAL)rect->Width;
 
    return GdipCombineRegionRect(region, &rectf, mode);
}

Referenced by test_getregiondata().

GdipCombineRegionRegion()

GpStatus WINGDIPAPI GdipCombineRegionRegion	(	GpRegion *	region1,
		GpRegion *	region2,
		CombineMode	mode
	)

Definition at line 346 of file region.c.

{
    region_element *left, *right = NULL;
    GpStatus stat;
    GpRegion *reg2copy;
 
    TRACE("%p %p %d\n", region1, region2, mode);
 
    if(!(region1 && region2))
        return InvalidParameter;
 
    /* simply replace region data */
    if(mode == CombineModeReplace){
        stat = GdipCloneRegion(region2, &reg2copy);
        if(stat != Ok)  return stat;
 
        delete_element(&region1->node);
        memcpy(region1, reg2copy, sizeof(GpRegion));
        heap_free(reg2copy);
        return Ok;
    }
 
    left  = heap_alloc_zero(sizeof(region_element));
    if (!left)
        return OutOfMemory;
 
    *left = region1->node;
    stat = clone_element(&region2->node, &right);
    if (stat != Ok)
    {
        heap_free(left);
        return OutOfMemory;
    }
 
    fuse_region(region1, left, right, mode);
    region1->num_children += region2->num_children;
 
    return Ok;
}

Referenced by GdipPlayMetafileRecord(), GdipSetClipGraphics(), GdipSetClipHrgn(), GdipSetClipRect(), GdipSetClipRegion(), get_visible_clip_region(), METAFILE_PlaybackUpdateClip(), metafile_set_clip_region(), test_combinereplace(), and test_getregiondata().

GdipCreateRegion()

GpStatus WINGDIPAPI GdipCreateRegion

(

GpRegion **

region

)

Definition at line 390 of file region.c.

{
    TRACE("%p\n", region);
 
    if(!region)
        return InvalidParameter;
 
    *region = heap_alloc_zero(sizeof(GpRegion));
    if(!*region)
        return OutOfMemory;
 
    TRACE("=> %p\n", *region);
 
    return init_region(*region, RegionDataInfiniteRect);
}

Referenced by GdipCreateFromHDC2(), GdipCreateRegionHrgn(), GdipCreateRegionRgnData(), GdipEnumerateMetafileSrcRectDestPoints(), GdipGetClipBounds(), GdipGetVisibleClipBounds(), GdipIsVisibleClipEmpty(), GdipIsVisiblePoint(), GdipIsVisibleRect(), get_visible_clip_region(), graphics_from_image(), metafile_deserialize_region(), test_clip_xform(), test_clipping(), test_clipping_2(), test_combinereplace(), test_excludeinfinite(), test_font_height_scaling(), test_GdipCreateRegionRgnData(), test_Get_Release_DC(), test_getbounds(), test_gethrgn(), test_getregiondata(), test_isempty(), test_isequal(), test_isinfinite(), test_isvisiblepoint(), test_isvisiblerect(), test_measure_string(), test_scans(), test_string_functions(), test_transform(), and test_translate().

GdipCreateRegionHrgn()

GpStatus WINGDIPAPI GdipCreateRegionHrgn	(	HRGN	hrgn,
		GpRegion **	region
	)

Definition at line 506 of file region.c.

{
    DWORD size;
    LPRGNDATA buf;
    LPRECT rect;
    GpStatus stat;
    GpPath* path;
    GpRegion* local;
    DWORD i;
 
    TRACE("(%p, %p)\n", hrgn, region);
 
    if(!region || !(size = GetRegionData(hrgn, 0, NULL)))
        return InvalidParameter;
 
    buf = heap_alloc_zero(size);
    if(!buf)
        return OutOfMemory;
 
    if(!GetRegionData(hrgn, size, buf)){
        heap_free(buf);
        return GenericError;
    }
 
    if(buf->rdh.nCount == 0){
        if((stat = GdipCreateRegion(&local)) != Ok){
            heap_free(buf);
            return stat;
        }
        if((stat = GdipSetEmpty(local)) != Ok){
            heap_free(buf);
            GdipDeleteRegion(local);
            return stat;
        }
        *region = local;
        heap_free(buf);
        return Ok;
    }
 
    if((stat = GdipCreatePath(FillModeAlternate, &path)) != Ok){
        heap_free(buf);
        return stat;
    }
 
    rect = (LPRECT)buf->Buffer;
    for(i = 0; i < buf->rdh.nCount; i++){
        if((stat = GdipAddPathRectangle(path, (REAL)rect->left, (REAL)rect->top,
                        (REAL)(rect->right - rect->left), (REAL)(rect->bottom - rect->top))) != Ok){
            heap_free(buf);
            GdipDeletePath(path);
            return stat;
        }
        rect++;
    }
 
    stat = GdipCreateRegionPath(path, region);
 
    heap_free(buf);
    GdipDeletePath(path);
    return stat;
}

Referenced by GdipSetClipHrgn(), and test_fromhrgn().

GdipCreateRegionPath()

GpStatus WINGDIPAPI GdipCreateRegionPath	(	GpPath *	path,
		GpRegion **	region
	)

Definition at line 425 of file region.c.

{
    region_element* element;
    GpStatus stat;
 
    TRACE("%p, %p\n", path, region);
 
    if (!(path && region))
        return InvalidParameter;
 
    *region = heap_alloc_zero(sizeof(GpRegion));
    if(!*region)
        return OutOfMemory;
    stat = init_region(*region, RegionDataPath);
    if (stat != Ok)
    {
        GdipDeleteRegion(*region);
        return stat;
    }
    element = &(*region)->node;
 
    stat = GdipClonePath(path, &element->elementdata.path);
    if (stat != Ok)
    {
        GdipDeleteRegion(*region);
        return stat;
    }
 
    return Ok;
}

Referenced by GdipCombineRegionPath(), GdipCreateRegionHrgn(), GdipIsVisiblePathPoint(), GdipPlayMetafileRecord(), SOFTWARE_GdipFillPath(), test_gethrgn(), test_getregiondata(), and transform_region_element().

GdipCreateRegionRect()

GpStatus WINGDIPAPI GdipCreateRegionRect	(	GDIPCONST GpRectF *	rect,
		GpRegion **	region
	)

Definition at line 459 of file region.c.

{
    GpStatus stat;
 
    TRACE("%p, %p\n", rect, region);
 
    if (!(rect && region))
        return InvalidParameter;
 
    *region = heap_alloc_zero(sizeof(GpRegion));
    stat = init_region(*region, RegionDataRect);
    if(stat != Ok)
    {
        GdipDeleteRegion(*region);
        return stat;
    }
 
    (*region)->node.elementdata.rect.X = rect->X;
    (*region)->node.elementdata.rect.Y = rect->Y;
    (*region)->node.elementdata.rect.Width = rect->Width;
    (*region)->node.elementdata.rect.Height = rect->Height;
 
    return Ok;
}

Referenced by GdipCombineRegionRect(), GdipCreateRegionRectI(), GdipPlayMetafileRecord(), GdipSetClipRect(), test_clipping(), test_combinereplace(), test_get_set_clip(), and test_gethrgn().

GdipCreateRegionRectI()

GpStatus WINGDIPAPI GdipCreateRegionRectI	(	GDIPCONST GpRect *	rect,
		GpRegion **	region
	)

Definition at line 488 of file region.c.

{
    GpRectF rectf;
 
    TRACE("%p, %p\n", rect, region);
 
    rectf.X = (REAL)rect->X;
    rectf.Y = (REAL)rect->Y;
    rectf.Width = (REAL)rect->Width;
    rectf.Height = (REAL)rect->Height;
 
    return GdipCreateRegionRect(&rectf, region);
}

Referenced by test_getregiondata().

GdipCreateRegionRgnData()

GpStatus WINGDIPAPI GdipCreateRegionRgnData	(	GDIPCONST BYTE *	data,
		INT	size,
		GpRegion **	region
	)

Definition at line 946 of file region.c.

{
    const struct region_data_header *region_data_header;
    struct memory_buffer mbuf;
    GpStatus status;
    INT count;
 
    TRACE("(%p, %d, %p)\n", data, size, region);
 
    if (!data || !size)
        return InvalidParameter;
 
    init_memory_buffer(&mbuf, data, size);
 
    region_data_header = buffer_read(&mbuf, sizeof(*region_data_header));
    if (!region_data_header || !VALID_MAGIC(region_data_header->header.magic))
        return InvalidParameter;
 
    status = GdipCreateRegion(region);
    if (status != Ok)
        return status;
 
    count = 0;
    status = read_element(&mbuf, *region, &(*region)->node, &count);
    if (status == Ok && !count)
        status = InvalidParameter;
 
    if (status != Ok)
    {
        GdipDeleteRegion(*region);
        *region = NULL;
    }
 
    return status;
}

Referenced by test_GdipCreateRegionRgnData(), and test_region_data().

GdipDeleteRegion()

GpStatus WINGDIPAPI GdipDeleteRegion

(

GpRegion *

region

)

Definition at line 571 of file region.c.

{
    TRACE("%p\n", region);
 
    if (!region)
        return InvalidParameter;
 
    delete_element(&region->node);
    heap_free(region);
 
    return Ok;
}

Referenced by delete_container(), GdipCombineRegionPath(), GdipCombineRegionRect(), GdipCreateRegionHrgn(), GdipCreateRegionPath(), GdipCreateRegionRect(), GdipCreateRegionRgnData(), GdipDeleteGraphics(), GdipEnumerateMetafileSrcRectDestPoints(), GdipGetClip(), GdipGetClipBounds(), GdipGetVisibleClipBounds(), GdipIsVisibleClipEmpty(), GdipIsVisiblePathPoint(), GdipIsVisiblePoint(), GdipIsVisibleRect(), GdipPlayMetafileRecord(), GdipSetClipHrgn(), GdipSetClipRect(), GdipSetClipRegion(), get_clip_hrgn(), get_region_scans_data(), get_visible_clip_region(), metafile_deserialize_region(), metafile_free_object_table_entry(), restore_container(), SOFTWARE_GdipFillPath(), SOFTWARE_GdipFillRegion(), test_clip_xform(), test_clipping(), test_clipping_2(), test_combinereplace(), test_excludeinfinite(), test_font_height_scaling(), test_fromhrgn(), test_GdipCreateRegionRgnData(), test_Get_Release_DC(), test_get_set_clip(), test_getbounds(), test_gethrgn(), test_getregiondata(), test_isempty(), test_isequal(), test_isinfinite(), test_isvisiblepoint(), test_isvisiblerect(), test_measure_string(), test_region_data(), test_scans(), test_string_functions(), test_transform(), and test_translate().

GdipGetRegionBounds()

GpStatus WINGDIPAPI GdipGetRegionBounds	(	GpRegion *	region,
		GpGraphics *	graphics,
		GpRectF *	rect
	)

Definition at line 587 of file region.c.

{
    HRGN hrgn;
    RECT r;
    GpStatus status;
 
    TRACE("(%p, %p, %p)\n", region, graphics, rect);
 
    if(!region || !graphics || !rect)
        return InvalidParameter;
 
    /* Contrary to MSDN, native ignores the graphics transform. */
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    if(status != Ok)
        return status;
 
    /* infinite */
    if(!hrgn){
        rect->X = rect->Y = -(REAL)(1 << 22);
        rect->Width = rect->Height = (REAL)(1 << 23);
        TRACE("%p => infinite\n", region);
        return Ok;
    }
 
    if(GetRgnBox(hrgn, &r)){
        rect->X = r.left;
        rect->Y = r.top;
        rect->Width  = r.right  - r.left;
        rect->Height = r.bottom - r.top;
        TRACE("%p => %s\n", region, debugstr_rectf(rect));
    }
    else
        status = GenericError;
 
    DeleteObject(hrgn);
 
    return status;
}

Referenced by GdipGetClipBounds(), GdipGetRegionBoundsI(), GdipGetVisibleClipBounds(), GdipIsEmptyRegion(), test_clipping(), test_font_height_scaling(), test_getbounds(), and test_measure_string().

GdipGetRegionBoundsI()

GpStatus WINGDIPAPI GdipGetRegionBoundsI	(	GpRegion *	region,
		GpGraphics *	graphics,
		GpRect *	rect
	)

Definition at line 629 of file region.c.

{
    GpRectF rectf;
    GpStatus status;
 
    TRACE("(%p, %p, %p)\n", region, graphics, rect);
 
    if(!rect)
        return InvalidParameter;
 
    status = GdipGetRegionBounds(region, graphics, &rectf);
    if(status == Ok){
        rect->X = gdip_round(rectf.X);
        rect->Y = gdip_round(rectf.Y);
        rect->Width  = gdip_round(rectf.Width);
        rect->Height = gdip_round(rectf.Height);
    }
 
    return status;
}

Referenced by GdipGetClipBoundsI().

GdipGetRegionData()

GpStatus WINGDIPAPI GdipGetRegionData	(	GpRegion *	region,
		BYTE *	buffer,
		UINT	size,
		UINT *	needed
	)

Definition at line 747 of file region.c.

{
    struct region_data_header *region_data_header;
    UINT required;
 
    TRACE("%p, %p, %d, %p\n", region, buffer, size, needed);
 
    if (!region || !buffer || !size)
        return InvalidParameter;
 
    required = FIELD_OFFSET(struct region_data_header, header) + write_region_data(region, NULL);
    if (size < required)
    {
        if (needed) *needed = size;
        return InsufficientBuffer;
    }
 
    region_data_header = (struct region_data_header *)buffer;
    region_data_header->size = write_region_data(region, &region_data_header->header);
    region_data_header->checksum = 0;
 
    if (needed)
        *needed = required;
 
    return Ok;
}

Referenced by get_region_type(), test_clip_xform(), test_combinereplace(), test_fromhrgn(), test_GdipCreateRegionRgnData(), test_getregiondata(), and test_region_data().

GdipGetRegionDataSize()

GpStatus WINGDIPAPI GdipGetRegionDataSize	(	GpRegion *	region,
		UINT *	needed
	)

Definition at line 985 of file region.c.

{
    TRACE("%p, %p\n", region, needed);
 
    if (!(region && needed))
        return InvalidParameter;
 
    /* header.size doesn't count header.size and header.checksum */
    *needed = FIELD_OFFSET(struct region_data_header, header) + write_region_data(region, NULL);
 
    return Ok;
}

Referenced by get_region_type(), test_combinereplace(), test_fromhrgn(), test_getregiondata(), and test_region_data().

GdipGetRegionHRgn()

GpStatus WINGDIPAPI GdipGetRegionHRgn	(	GpRegion *	region,
		GpGraphics *	graphics,
		HRGN *	hrgn
	)

Definition at line 1194 of file region.c.

{
    TRACE("(%p, %p, %p)\n", region, graphics, hrgn);
 
    if (!region || !hrgn)
        return InvalidParameter;
 
    return get_region_hrgn(&region->node, graphics, hrgn);
}

Referenced by GDI32_GdipFillRegion(), GdipGetRegionBounds(), GdipIsEqualRegion(), GdipIsVisiblePathPoint(), GdipIsVisibleRegionPoint(), GdipIsVisibleRegionRect(), get_clip_hrgn(), get_region_scans_data(), SOFTWARE_GdipFillRegion(), test_clipping(), test_clipping_2(), and test_gethrgn().

GdipGetRegionScans()

GpStatus WINGDIPAPI GdipGetRegionScans	(	GpRegion *	region,
		GpRectF *	scans,
		INT *	count,
		GpMatrix *	matrix
	)

Definition at line 1656 of file region.c.

{
    GpStatus stat;
    DWORD i;
    LPRGNDATA data;
    RECT *rects;
 
    if (!region || !count || !matrix)
        return InvalidParameter;
 
    stat = get_region_scans_data(region, matrix, &data);
 
    if (stat == Ok)
    {
        *count = data->rdh.nCount;
        rects = (RECT*)data->Buffer;
 
        if (scans)
        {
            for (i=0; i<data->rdh.nCount; i++)
            {
                scans[i].X = rects[i].left;
                scans[i].Y = rects[i].top;
                scans[i].Width = rects[i].right - rects[i].left;
                scans[i].Height = rects[i].bottom - rects[i].top;
            }
        }
 
        heap_free(data);
    }
 
    return Ok;
}

Referenced by test_excludeinfinite(), and test_scans().

GdipGetRegionScansCount()

GpStatus WINGDIPAPI GdipGetRegionScansCount	(	GpRegion *	region,
		UINT *	count,
		GpMatrix *	matrix
	)

Definition at line 1601 of file region.c.

{
    GpStatus stat;
    LPRGNDATA data;
 
    TRACE("(%p, %p, %p)\n", region, count, matrix);
 
    if (!region || !count || !matrix)
        return InvalidParameter;
 
    stat = get_region_scans_data(region, matrix, &data);
 
    if (stat == Ok)
    {
        *count = data->rdh.nCount;
        heap_free(data);
    }
 
    return stat;
}

Referenced by test_excludeinfinite(), and test_scans().

GdipGetRegionScansI()

GpStatus WINGDIPAPI GdipGetRegionScansI	(	GpRegion *	region,
		GpRect *	scans,
		INT *	count,
		GpMatrix *	matrix
	)

Definition at line 1622 of file region.c.

{
    GpStatus stat;
    DWORD i;
    LPRGNDATA data;
    RECT *rects;
 
    if (!region || !count || !matrix)
        return InvalidParameter;
 
    stat = get_region_scans_data(region, matrix, &data);
 
    if (stat == Ok)
    {
        *count = data->rdh.nCount;
        rects = (RECT*)data->Buffer;
 
        if (scans)
        {
            for (i=0; i<data->rdh.nCount; i++)
            {
                scans[i].X = rects[i].left;
                scans[i].Y = rects[i].top;
                scans[i].Width = rects[i].right - rects[i].left;
                scans[i].Height = rects[i].bottom - rects[i].top;
            }
        }
 
        heap_free(data);
    }
 
    return Ok;
}

Referenced by test_scans().

GdipIsEmptyRegion()

GpStatus WINGDIPAPI GdipIsEmptyRegion	(	GpRegion *	region,
		GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 1204 of file region.c.

{
    GpStatus status;
    GpRectF rect;
 
    TRACE("(%p, %p, %p)\n", region, graphics, res);
 
    if(!region || !graphics || !res)
        return InvalidParameter;
 
    status = GdipGetRegionBounds(region, graphics, &rect);
    if (status != Ok) return status;
 
    *res = rect.Width == 0.0 && rect.Height == 0.0;
    TRACE("=> %d\n", *res);
 
    return Ok;
}

Referenced by GdipIsClipEmpty(), GdipIsVisibleClipEmpty(), test_fromhrgn(), test_GdipCreateRegionRgnData(), test_get_set_clip(), test_isempty(), and test_string_functions().

GdipIsEqualRegion()

GpStatus WINGDIPAPI GdipIsEqualRegion	(	GpRegion *	region,
		GpRegion *	region2,
		GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 1226 of file region.c.

{
    HRGN hrgn1, hrgn2;
    GpStatus stat;
 
    TRACE("(%p, %p, %p, %p)\n", region, region2, graphics, res);
 
    if(!region || !region2 || !graphics || !res)
        return InvalidParameter;
 
    stat = GdipGetRegionHRgn(region, graphics, &hrgn1);
    if(stat != Ok)
        return stat;
    stat = GdipGetRegionHRgn(region2, graphics, &hrgn2);
    if(stat != Ok){
        DeleteObject(hrgn1);
        return stat;
    }
 
    *res = EqualRgn(hrgn1, hrgn2);
 
    /* one of GpRegions is infinite */
    if(*res == ERROR)
        *res = (!hrgn1 && !hrgn2);
 
    DeleteObject(hrgn1);
    DeleteObject(hrgn2);
 
    return Ok;
}

Referenced by test_isequal(), test_transform(), and test_translate().

GdipIsInfiniteRegion()

GpStatus WINGDIPAPI GdipIsInfiniteRegion	(	GpRegion *	region,
		GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 1261 of file region.c.

{
    /* I think graphics is ignored here */
    TRACE("(%p, %p, %p)\n", region, graphics, res);
 
    if(!region || !graphics || !res)
        return InvalidParameter;
 
    *res = (region->node.type == RegionDataInfiniteRect);
 
    return Ok;
}

Referenced by test_GdipCreateRegionRgnData(), test_get_set_clip(), test_isinfinite(), test_isvisiblepoint(), and test_isvisiblerect().

GdipIsVisibleRegionPoint()

GpStatus WINGDIPAPI GdipIsVisibleRegionPoint	(	GpRegion *	region,
		REAL	x,
		REAL	y,
		GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 1320 of file region.c.

{
    HRGN hrgn;
    GpStatus stat;
 
    TRACE("(%p, %.2f, %.2f, %p, %p)\n", region, x, y, graphics, res);
 
    if(!region || !res)
        return InvalidParameter;
 
    if((stat = GdipGetRegionHRgn(region, NULL, &hrgn)) != Ok)
        return stat;
 
    /* infinite */
    if(!hrgn){
        *res = TRUE;
        return Ok;
    }
 
    *res = PtInRegion(hrgn, gdip_round(x), gdip_round(y));
 
    DeleteObject(hrgn);
 
    return Ok;
}

Referenced by GdipIsVisiblePoint(), GdipIsVisibleRegionPointI(), and test_isvisiblepoint().

GdipIsVisibleRegionPointI()

GpStatus WINGDIPAPI GdipIsVisibleRegionPointI	(	GpRegion *	region,
		INT	x,
		INT	y,
		GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 1349 of file region.c.

{
    TRACE("(%p, %d, %d, %p, %p)\n", region, x, y, graphics, res);
 
    return GdipIsVisibleRegionPoint(region, (REAL)x, (REAL)y, graphics, res);
}

Referenced by test_isvisiblepoint().

GdipIsVisibleRegionRect()

GpStatus WINGDIPAPI GdipIsVisibleRegionRect	(	GpRegion *	region,
		REAL	x,
		REAL	y,
		REAL	w,
		REAL	h,
		GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 1277 of file region.c.

{
    HRGN hrgn;
    GpStatus stat;
    RECT rect;
 
    TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %p, %p)\n", region, x, y, w, h, graphics, res);
 
    if(!region || !res)
        return InvalidParameter;
 
    if((stat = GdipGetRegionHRgn(region, NULL, &hrgn)) != Ok)
        return stat;
 
    /* infinite */
    if(!hrgn){
        *res = TRUE;
        return Ok;
    }
 
    SetRect(&rect, ceilr(x), ceilr(y), ceilr(x + w), ceilr(y + h));
    *res = RectInRegion(hrgn, &rect);
 
    DeleteObject(hrgn);
 
    return Ok;
}

Referenced by GdipIsVisibleRect(), GdipIsVisibleRegionRectI(), and test_isvisiblerect().

GdipIsVisibleRegionRectI()

GpStatus WINGDIPAPI GdipIsVisibleRegionRectI	(	GpRegion *	region,
		INT	x,
		INT	y,
		INT	w,
		INT	h,
		GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 1308 of file region.c.

{
    TRACE("(%p, %d, %d, %d, %d, %p, %p)\n", region, x, y, w, h, graphics, res);
    if(!region || !res)
        return InvalidParameter;
 
    return GdipIsVisibleRegionRect(region, (REAL)x, (REAL)y, (REAL)w, (REAL)h, graphics, res);
}

Referenced by test_isvisiblerect().

GdipSetEmpty()

GpStatus WINGDIPAPI GdipSetEmpty

(

GpRegion *

region

)

Definition at line 1359 of file region.c.

{
    GpStatus stat;
 
    TRACE("%p\n", region);
 
    if (!region)
        return InvalidParameter;
 
    delete_element(&region->node);
    stat = init_region(region, RegionDataEmptyRect);
 
    return stat;
}

Referenced by GdipCreateRegionHrgn(), GdipMeasureCharacterRanges(), test_clipping(), test_clipping_2(), test_GdipCreateRegionRgnData(), test_get_set_clip(), test_getbounds(), test_gethrgn(), test_getregiondata(), test_isempty(), test_isequal(), test_scans(), test_string_functions(), test_transform(), and test_translate().

GdipSetInfinite()

GpStatus WINGDIPAPI GdipSetInfinite

(

GpRegion *

region

)

Definition at line 1374 of file region.c.

{
    GpStatus stat;
 
    TRACE("%p\n", region);
 
    if (!region)
        return InvalidParameter;
 
    delete_element(&region->node);
    stat = init_region(region, RegionDataInfiniteRect);
 
    return stat;
}

Referenced by GdipResetClip(), test_gethrgn(), test_getregiondata(), and test_isequal().

GdipTransformRegion()

GpStatus WINGDIPAPI GdipTransformRegion	(	GpRegion *	region,
		GpMatrix *	matrix
	)

Definition at line 1480 of file region.c.

{
    TRACE("(%p, %p)\n", region, matrix);
 
    if (!region || !matrix)
        return InvalidParameter;
 
    return transform_region_element(&region->node, matrix);
}

Referenced by GdipGetClip(), GdipGetVisibleClipBounds(), GdipSetClipHrgn(), GdipSetClipRect(), GdipSetClipRegion(), get_clip_hrgn(), get_region_scans_data(), metafile_set_clip_region(), SOFTWARE_GdipFillRegion(), test_clipping(), test_getregiondata(), and test_transform().

GdipTranslateRegion()

GpStatus WINGDIPAPI GdipTranslateRegion	(	GpRegion *	region,
		REAL	dx,
		REAL	dy
	)

Definition at line 1520 of file region.c.

{
    TRACE("(%p, %f, %f)\n", region, dx, dy);
 
    if(!region)
        return InvalidParameter;
 
    translate_region_element(&region->node, dx, dy);
 
    return Ok;
}

Referenced by GdipTranslateClip(), GdipTranslateClipI(), GdipTranslateRegionI(), test_getregiondata(), and test_translate().

GdipTranslateRegionI()

GpStatus WINGDIPAPI GdipTranslateRegionI	(	GpRegion *	region,
		INT	dx,
		INT	dy
	)

Definition at line 1535 of file region.c.

{
    TRACE("(%p, %d, %d)\n", region, dx, dy);
 
    return GdipTranslateRegion(region, (REAL)dx, (REAL)dy);
}

get_element_size()

static INT get_element_size ( const region_element *  element )

inlinestatic

Definition at line 106 of file region.c.

{
    INT needed = sizeof(DWORD); /* DWORD for the type */
    switch(element->type)
    {
        case RegionDataRect:
            return needed + sizeof(GpRect);
        case RegionDataPath:
        {
            needed += write_path_data(element->elementdata.path, NULL);
            needed += sizeof(DWORD); /* Extra DWORD for path size */
            return needed;
        }
        case RegionDataEmptyRect:
        case RegionDataInfiniteRect:
            return needed;
        default:
            needed += get_element_size(element->elementdata.combine.left);
            needed += get_element_size(element->elementdata.combine.right);
            return needed;
    }
 
    return 0;
}

Referenced by get_element_size(), and write_region_data().

get_path_hrgn()

static GpStatus get_path_hrgn ( GpPath *  path, GpGraphics *  graphics, HRGN *  hrgn  )

static

Definition at line 998 of file region.c.

{
    HDC new_hdc=NULL;
    GpGraphics *new_graphics=NULL;
    GpStatus stat;
    INT save_state;
 
    if (!path->pathdata.Count)  /* PathToRegion doesn't support empty paths */
    {
        *hrgn = CreateRectRgn( 0, 0, 0, 0 );
        return *hrgn ? Ok : OutOfMemory;
    }
 
    if (!graphics)
    {
        new_hdc = CreateCompatibleDC(0);
        if (!new_hdc)
            return OutOfMemory;
 
        stat = GdipCreateFromHDC(new_hdc, &new_graphics);
        graphics = new_graphics;
        if (stat != Ok)
        {
            DeleteDC(new_hdc);
            return stat;
        }
    }
    else if (!graphics->hdc)
    {
        graphics->hdc = new_hdc = CreateCompatibleDC(0);
        if (!new_hdc)
            return OutOfMemory;
    }
 
    save_state = SaveDC(graphics->hdc);
    EndPath(graphics->hdc);
 
    SetPolyFillMode(graphics->hdc, (path->fill == FillModeAlternate ? ALTERNATE
                                                                    : WINDING));
 
    gdi_transform_acquire(graphics);
 
    stat = trace_path(graphics, path);
    if (stat == Ok)
    {
        *hrgn = PathToRegion(graphics->hdc);
        stat = *hrgn ? Ok : OutOfMemory;
    }
 
    gdi_transform_release(graphics);
 
    RestoreDC(graphics->hdc, save_state);
    if (new_hdc)
    {
        DeleteDC(new_hdc);
        if (new_graphics)
            GdipDeleteGraphics(new_graphics);
        else
            graphics->hdc = NULL;
    }
 
    return stat;
}

Referenced by get_region_hrgn().

get_region_hrgn()

static GpStatus get_region_hrgn ( struct region_element *  element, GpGraphics *  graphics, HRGN *  hrgn  )

static

Definition at line 1062 of file region.c.

{
    switch (element->type)
    {
        case RegionDataInfiniteRect:
            *hrgn = NULL;
            return Ok;
        case RegionDataEmptyRect:
            *hrgn = CreateRectRgn(0, 0, 0, 0);
            return *hrgn ? Ok : OutOfMemory;
        case RegionDataPath:
            return get_path_hrgn(element->elementdata.path, graphics, hrgn);
        case RegionDataRect:
        {
            GpPath* path;
            GpStatus stat;
            GpRectF* rc = &element->elementdata.rect;
 
            stat = GdipCreatePath(FillModeAlternate, &path);
            if (stat != Ok)
                return stat;
            stat = GdipAddPathRectangle(path, rc->X, rc->Y, rc->Width, rc->Height);
 
            if (stat == Ok)
                stat = get_path_hrgn(path, graphics, hrgn);
 
            GdipDeletePath(path);
 
            return stat;
        }
        case CombineModeIntersect:
        case CombineModeUnion:
        case CombineModeXor:
        case CombineModeExclude:
        case CombineModeComplement:
        {
            HRGN left, right;
            GpStatus stat;
            int ret;
 
            stat = get_region_hrgn(element->elementdata.combine.left, graphics, &left);
            if (stat != Ok)
            {
                *hrgn = NULL;
                return stat;
            }
 
            if (left == NULL)
            {
                /* existing region is infinite */
                switch (element->type)
                {
                    case CombineModeIntersect:
                        return get_region_hrgn(element->elementdata.combine.right, graphics, hrgn);
                    case CombineModeXor: case CombineModeExclude:
                        left = CreateRectRgn(-(1 << 22), -(1 << 22), 1 << 22, 1 << 22);
                        break;
                    case CombineModeUnion: case CombineModeComplement:
                        *hrgn = NULL;
                        return Ok;
                }
            }
 
            stat = get_region_hrgn(element->elementdata.combine.right, graphics, &right);
            if (stat != Ok)
            {
                DeleteObject(left);
                *hrgn = NULL;
                return stat;
            }
 
            if (right == NULL)
            {
                /* new region is infinite */
                switch (element->type)
                {
                    case CombineModeIntersect:
                        *hrgn = left;
                        return Ok;
                    case CombineModeXor: case CombineModeComplement:
                        right = CreateRectRgn(-(1 << 22), -(1 << 22), 1 << 22, 1 << 22);
                        break;
                    case CombineModeUnion: case CombineModeExclude:
                        DeleteObject(left);
                        *hrgn = NULL;
                        return Ok;
                }
            }
 
            switch (element->type)
            {
                case CombineModeIntersect:
                    ret = CombineRgn(left, left, right, RGN_AND);
                    break;
                case CombineModeUnion:
                    ret = CombineRgn(left, left, right, RGN_OR);
                    break;
                case CombineModeXor:
                    ret = CombineRgn(left, left, right, RGN_XOR);
                    break;
                case CombineModeExclude:
                    ret = CombineRgn(left, left, right, RGN_DIFF);
                    break;
                case CombineModeComplement:
                    ret = CombineRgn(left, right, left, RGN_DIFF);
                    break;
                default:
                    ret = ERROR;
            }
 
            DeleteObject(right);
 
            if (ret == ERROR)
            {
                DeleteObject(left);
                *hrgn = NULL;
                return GenericError;
            }
 
            *hrgn = left;
            return Ok;
        }
        default:
            FIXME("GdipGetRegionHRgn unimplemented for region type=%x\n", element->type);
            *hrgn = NULL;
            return NotImplemented;
    }
}

Referenced by GdipGetRegionHRgn(), and get_region_hrgn().

get_region_scans_data()

static GpStatus get_region_scans_data ( GpRegion *  region, GpMatrix *  matrix, LPRGNDATA *  data  )

static

Definition at line 1542 of file region.c.

{
    GpRegion *region_copy;
    GpStatus stat;
    HRGN hrgn;
    DWORD data_size;
 
    stat = GdipCloneRegion(region, &region_copy);
 
    if (stat == Ok)
    {
        stat = GdipTransformRegion(region_copy, matrix);
 
        if (stat == Ok)
            stat = GdipGetRegionHRgn(region_copy, NULL, &hrgn);
 
        if (stat == Ok)
        {
            if (hrgn)
            {
                data_size = GetRegionData(hrgn, 0, NULL);
 
                *data = heap_alloc_zero(data_size);
 
                if (*data)
                    GetRegionData(hrgn, data_size, *data);
                else
                    stat = OutOfMemory;
 
                DeleteObject(hrgn);
            }
            else
            {
                data_size = sizeof(RGNDATAHEADER) + sizeof(RECT);
 
                *data = heap_alloc_zero(data_size);
 
                if (*data)
                {
                    (*data)->rdh.dwSize = sizeof(RGNDATAHEADER);
                    (*data)->rdh.iType = RDH_RECTANGLES;
                    (*data)->rdh.nCount = 1;
                    (*data)->rdh.nRgnSize = sizeof(RECT);
                    (*data)->rdh.rcBound.left = (*data)->rdh.rcBound.top = -0x400000;
                    (*data)->rdh.rcBound.right = (*data)->rdh.rcBound.bottom = 0x400000;
 
                    memcpy((*data)->Buffer, &(*data)->rdh.rcBound, sizeof(RECT));
                }
                else
                    stat = OutOfMemory;
            }
        }
 
        GdipDeleteRegion(region_copy);
    }
 
    return stat;
}

Referenced by GdipGetRegionScans(), GdipGetRegionScansCount(), and GdipGetRegionScansI().

init_region()

static GpStatus init_region ( GpRegion *  region, const RegionType  type  )

inlinestatic

Definition at line 132 of file region.c.

{
    region->node.type    = type;
    region->num_children = 0;
 
    return Ok;
}

Referenced by GdipCreateRegion(), GdipCreateRegionPath(), GdipCreateRegionRect(), GdipSetEmpty(), and GdipSetInfinite().

read_element()

static GpStatus read_element ( struct memory_buffer *  mbuf, GpRegion *  region, region_element *  node, INT *  count  )

static

Definition at line 775 of file region.c.

{
    GpStatus status;
    const DWORD *type;
 
    type = buffer_read(mbuf, sizeof(*type));
    if (!type) return Ok;
 
    TRACE("type %#x\n", *type);
 
    node->type = *type;
 
    switch (node->type)
    {
    case CombineModeReplace:
    case CombineModeIntersect:
    case CombineModeUnion:
    case CombineModeXor:
    case CombineModeExclude:
    case CombineModeComplement:
    {
        region_element *left, *right;
 
        left = heap_alloc_zero(sizeof(region_element));
        if (!left) return OutOfMemory;
        right = heap_alloc_zero(sizeof(region_element));
        if (!right)
        {
            heap_free(left);
            return OutOfMemory;
        }
 
        status = read_element(mbuf, region, left, count);
        if (status == Ok)
        {
            status = read_element(mbuf, region, right, count);
            if (status == Ok)
            {
                node->elementdata.combine.left = left;
                node->elementdata.combine.right = right;
                region->num_children += 2;
                return Ok;
            }
        }
 
        heap_free(left);
        heap_free(right);
        return status;
    }
 
    case RegionDataRect:
    {
        const GpRectF *rc;
 
        rc = buffer_read(mbuf, sizeof(*rc));
        if (!rc)
        {
            ERR("failed to read rect data\n");
            return InvalidParameter;
        }
 
        node->elementdata.rect = *rc;
        *count += 1;
        return Ok;
    }
 
    case RegionDataPath:
    {
        GpPath *path;
        const struct path_header *path_header;
        const BYTE *types;
 
        path_header = buffer_read(mbuf, sizeof(*path_header));
        if (!path_header)
        {
            ERR("failed to read path header\n");
            return InvalidParameter;
        }
        if (!VALID_MAGIC(path_header->magic))
        {
            ERR("invalid path header magic %#x\n", path_header->magic);
            return InvalidParameter;
        }
 
        /* Windows always fails to create an empty path in a region */
        if (!path_header->count)
        {
            TRACE("refusing to create an empty path in a region\n");
            return GenericError;
        }
 
        status = GdipCreatePath(FillModeAlternate, &path);
        if (status) return status;
 
        node->elementdata.path = path;
 
        if (!lengthen_path(path, path_header->count))
            return OutOfMemory;
 
        path->pathdata.Count = path_header->count;
 
        if (path_header->flags & ~FLAGS_INTPATH)
            FIXME("unhandled path flags %#x\n", path_header->flags);
 
        if (path_header->flags & FLAGS_INTPATH)
        {
            const packed_point *pt;
            DWORD i;
 
            pt = buffer_read(mbuf, sizeof(*pt) * path_header->count);
            if (!pt)
            {
                ERR("failed to read packed %u path points\n", path_header->count);
                return InvalidParameter;
            }
 
            for (i = 0; i < path_header->count; i++)
            {
                path->pathdata.Points[i].X = (REAL)pt[i].X;
                path->pathdata.Points[i].Y = (REAL)pt[i].Y;
            }
        }
        else
        {
            const GpPointF *ptf;
 
            ptf = buffer_read(mbuf, sizeof(*ptf) * path_header->count);
            if (!ptf)
            {
                ERR("failed to read %u path points\n", path_header->count);
                return InvalidParameter;
            }
            memcpy(path->pathdata.Points, ptf, sizeof(*ptf) * path_header->count);
        }
 
        types = buffer_read(mbuf, path_header->count);
        if (!types)
        {
            ERR("failed to read %u path types\n", path_header->count);
            return InvalidParameter;
        }
        memcpy(path->pathdata.Types, types, path_header->count);
        if (path_header->count & 3)
        {
            if (!buffer_read(mbuf, 4 - (path_header->count & 3)))
            {
                ERR("failed to read rounding %u bytes\n", 4 - (path_header->count & 3));
                return InvalidParameter;
            }
        }
 
        *count += 1;
        return Ok;
    }
 
    case RegionDataEmptyRect:
    case RegionDataInfiniteRect:
        *count += 1;
        return Ok;
 
    default:
        FIXME("element type %#x is not supported\n", *type);
        break;
    }
 
    return InvalidParameter;
}

Referenced by GdipCreateRegionRgnData(), and read_element().

transform_region_element()

static GpStatus transform_region_element ( region_element *  element, GpMatrix *  matrix  )

static

Definition at line 1390 of file region.c.

{
    GpStatus stat;
 
    switch(element->type)
    {
        case RegionDataEmptyRect:
        case RegionDataInfiniteRect:
            return Ok;
        case RegionDataRect:
        {
            GpRegion *new_region;
            GpPath *path;
 
            if (matrix->matrix[1] == 0.0 && matrix->matrix[2] == 0.0)
            {
                GpPointF points[2];
 
                points[0].X = element->elementdata.rect.X;
                points[0].Y = element->elementdata.rect.Y;
                points[1].X = element->elementdata.rect.X + element->elementdata.rect.Width;
                points[1].Y = element->elementdata.rect.Y + element->elementdata.rect.Height;
 
                stat = GdipTransformMatrixPoints(matrix, points, 2);
                if (stat != Ok)
                    return stat;
 
                if (points[0].X > points[1].X)
                {
                    REAL temp;
                    temp = points[0].X;
                    points[0].X = points[1].X;
                    points[1].X = temp;
                }
 
                if (points[0].Y > points[1].Y)
                {
                    REAL temp;
                    temp = points[0].Y;
                    points[0].Y = points[1].Y;
                    points[1].Y = temp;
                }
 
                element->elementdata.rect.X = points[0].X;
                element->elementdata.rect.Y = points[0].Y;
                element->elementdata.rect.Width = points[1].X - points[0].X;
                element->elementdata.rect.Height = points[1].Y - points[0].Y;
                return Ok;
            }
 
            /* We can't rotate/shear a rectangle, so convert it to a path. */
            stat = GdipCreatePath(FillModeAlternate, &path);
            if (stat == Ok)
            {
                stat = GdipAddPathRectangle(path,
                    element->elementdata.rect.X, element->elementdata.rect.Y,
                    element->elementdata.rect.Width, element->elementdata.rect.Height);
 
                if (stat == Ok)
                    stat = GdipCreateRegionPath(path, &new_region);
 
                GdipDeletePath(path);
            }
 
            if (stat == Ok)
            {
                /* Steal the element from the created region. */
                memcpy(element, &new_region->node, sizeof(region_element));
                heap_free(new_region);
            }
            else
                return stat;
        }
        /* Fall-through to do the actual conversion. */
        case RegionDataPath:
            if (!element->elementdata.path->pathdata.Count)
                return Ok;
 
            stat = GdipTransformMatrixPoints(matrix,
                element->elementdata.path->pathdata.Points,
                element->elementdata.path->pathdata.Count);
            return stat;
        default:
            stat = transform_region_element(element->elementdata.combine.left, matrix);
            if (stat == Ok)
                stat = transform_region_element(element->elementdata.combine.right, matrix);
            return stat;
    }
}

Referenced by GdipTransformRegion(), and transform_region_element().

translate_region_element()

static void translate_region_element ( region_element *  element, REAL  dx, REAL  dy  )

static

Definition at line 1491 of file region.c.

{
    INT i;
 
    switch(element->type)
    {
        case RegionDataEmptyRect:
        case RegionDataInfiniteRect:
            return;
        case RegionDataRect:
            element->elementdata.rect.X += dx;
            element->elementdata.rect.Y += dy;
            return;
        case RegionDataPath:
            for(i = 0; i < element->elementdata.path->pathdata.Count; i++){
                element->elementdata.path->pathdata.Points[i].X += dx;
                element->elementdata.path->pathdata.Points[i].Y += dy;
            }
            return;
        default:
            translate_region_element(element->elementdata.combine.left,  dx, dy);
            translate_region_element(element->elementdata.combine.right, dx, dy);
            return;
    }
}

Referenced by GdipTranslateRegion(), and translate_region_element().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

gdiplus

)

write_dword()

static void write_dword ( DWORD *  location, INT *  offset, const DWORD  write  )

inlinestatic

Definition at line 650 of file region.c.

{
    location[*offset] = write;
    (*offset)++;
}

Referenced by write_element().

write_element()

static void write_element ( const region_element *  element, DWORD *  buffer, INT *  filled  )

static

Definition at line 662 of file region.c.

{
    write_dword(buffer, filled, element->type);
    switch (element->type)
    {
        case CombineModeReplace:
        case CombineModeIntersect:
        case CombineModeUnion:
        case CombineModeXor:
        case CombineModeExclude:
        case CombineModeComplement:
            write_element(element->elementdata.combine.left, buffer, filled);
            write_element(element->elementdata.combine.right, buffer, filled);
            break;
        case RegionDataRect:
            write_float(buffer, filled, element->elementdata.rect.X);
            write_float(buffer, filled, element->elementdata.rect.Y);
            write_float(buffer, filled, element->elementdata.rect.Width);
            write_float(buffer, filled, element->elementdata.rect.Height);
            break;
        case RegionDataPath:
        {
            DWORD size = write_path_data(element->elementdata.path, buffer + *filled + 1);
            write_dword(buffer, filled, size);
            *filled += size / sizeof(DWORD);
            break;
        }
        case RegionDataEmptyRect:
        case RegionDataInfiniteRect:
            break;
    }
}

Referenced by write_element(), and write_region_data().

write_float()

static void write_float ( DWORD *  location, INT *  offset, const FLOAT  write  )

inlinestatic

Definition at line 656 of file region.c.

{
    ((FLOAT*)location)[*offset] = write;
    (*offset)++;
}

Referenced by write_element().

write_region_data()

DWORD write_region_data	(	const GpRegion *	region,
		void *	data
	)

Definition at line 696 of file region.c.

{
    struct region_header *header = data;
    INT filled = 0;
    DWORD size;
 
    size = sizeof(struct region_header) + get_element_size(&region->node);
    if (!data) return size;
 
    header->magic = VERSION_MAGIC2;
    header->num_children = region->num_children;
    filled += 2;
    /* With few exceptions, everything written is DWORD aligned,
     * so use that as our base */
    write_element(&region->node, (DWORD*)data, &filled);
    return size;
}

Referenced by GdipGetRegionData(), GdipGetRegionDataSize(), and METAFILE_AddRegionObject().