region.c File Reference

#include <assert.h>
#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 void	get_region_bounding_box (struct region_element *element, REAL *min_x, REAL *min_y, REAL *max_x, REAL *max_y, BOOL *empty, BOOL *infinite)
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 78 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 144 of file region.c.

{
    GpStatus stat;
 
    /* root node is allocated with GpRegion */
    if(!*element2){
        *element2 = calloc(1, 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 193 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 215 of file region.c.

{
    region_element *element;
 
    TRACE("%p %p\n", region, clone);
 
    if (!(region && clone))
        return InvalidParameter;
 
    *clone = calloc(1, 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 236 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));
        free(path_region);
        return Ok;
    }
 
    left = malloc(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;
 
    free(left);
    GdipDeleteRegion(path_region);
    return stat;
}

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

GdipCombineRegionRect()

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

Definition at line 282 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));
        free(rect_region);
        return Ok;
    }
 
    left = malloc(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;
 
    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 329 of file region.c.

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

Referenced by SOFTWARE_GdipDrawThinPath(), and 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));
        free(reg2copy);
        return Ok;
    }
 
    left = malloc(sizeof(region_element));
    if (!left)
        return OutOfMemory;
 
    *left = region1->node;
    stat = clone_element(&region2->node, &right);
    if (stat != Ok)
    {
        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(), test_getregiondata(), and test_incombinedregion().

GdipCreateRegion()

GpStatus WINGDIPAPI GdipCreateRegion

(

GpRegion **

region

)

Definition at line 390 of file region.c.

{
    TRACE("%p\n", region);
 
    if(!region)
        return InvalidParameter;
 
    *region = calloc(1, 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_incombinedregion(), 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 502 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 = malloc(size);
    if(!buf)
        return OutOfMemory;
 
    if(!GetRegionData(hrgn, size, buf)){
        free(buf);
        return GenericError;
    }
 
    if(buf->rdh.nCount == 0){
        if((stat = GdipCreateRegion(&local)) != Ok){
            free(buf);
            return stat;
        }
        if((stat = GdipSetEmpty(local)) != Ok){
            free(buf);
            GdipDeleteRegion(local);
            return stat;
        }
        *region = local;
        free(buf);
        return Ok;
    }
 
    if((stat = GdipCreatePath(FillModeAlternate, &path)) != Ok){
        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){
            free(buf);
            GdipDeletePath(path);
            return stat;
        }
        rect++;
    }
 
    stat = GdipCreateRegionPath(path, region);
 
    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 = calloc(1, 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_GdipDrawThinPath(), 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("%s, %p\n", debugstr_rectf(rect), region);
 
    if (!(rect && region))
        return InvalidParameter;
 
    *region = calloc(1, 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_fillregion(), test_get_set_clip(), test_gethrgn(), and test_incombinedregion().

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);
 
    set_rect(&rectf, rect->X, rect->Y, rect->Width, rect->Height);
    return GdipCreateRegionRect(&rectf, region);
}

Referenced by test_getregiondata().

GdipCreateRegionRgnData()

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

Definition at line 939 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 567 of file region.c.

{
    TRACE("%p\n", region);
 
    if (!region)
        return InvalidParameter;
 
    delete_element(&region->node);
    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_GdipDrawThinPath(), SOFTWARE_GdipFillPath(), SOFTWARE_GdipFillRegion(), test_clip_xform(), test_clipping(), test_clipping_2(), test_combinereplace(), test_excludeinfinite(), test_fillregion(), test_font_height_scaling(), test_fromhrgn(), test_GdipCreateRegionRgnData(), test_Get_Release_DC(), test_get_set_clip(), test_getbounds(), test_gethrgn(), test_getregiondata(), test_incombinedregion(), 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 583 of file region.c.

{
    REAL min_x, min_y, max_x, max_y;
    BOOL empty, infinite;
 
    TRACE("(%p, %p, %p)\n", region, graphics, rect);
 
    if(!region || !graphics || !rect)
        return InvalidParameter;
 
    /* Contrary to MSDN, native ignores the graphics transform. */
    get_region_bounding_box(&region->node, &min_x, &min_y, &max_x, &max_y, &empty, &infinite);
 
    /* infinite */
    if(infinite){
        rect->X = rect->Y = -(REAL)(1 << 22);
        rect->Width = rect->Height = (REAL)(1 << 23);
        TRACE("%p => infinite\n", region);
        return Ok;
    }
 
    if(empty){
        rect->X = rect->Y = rect->Width = rect->Height = 0.0;
        TRACE("%p => empty\n", region);
        return Ok;
    }
 
    rect->X = min_x;
    rect->Y = min_y;
    rect->Width  = max_x - min_x;
    rect->Height = max_y - min_y;
    TRACE("%p => %s\n", region, debugstr_rectf(rect));
 
    return Ok;
}

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 622 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;
}

GdipGetRegionData()

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

Definition at line 740 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 978 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 1201 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(), GdipIsEqualRegion(), GdipIsVisiblePathPoint(), GdipIsVisibleRegionPoint(), GdipIsVisibleRegionRect(), get_clip_hrgn(), get_region_scans_data(), SOFTWARE_GdipDrawThinPath(), 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 1878 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;
            }
        }
 
        free(data);
    }
 
    return Ok;
}

Referenced by test_excludeinfinite(), and test_scans().

GdipGetRegionScansCount()

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

Definition at line 1823 of file region.c.

{
    GpStatus stat;
    LPRGNDATA data;
 
    TRACE("(%p, %p, %s)\n", region, count, debugstr_matrix(matrix));
 
    if (!region || !count || !matrix)
        return InvalidParameter;
 
    stat = get_region_scans_data(region, matrix, &data);
 
    if (stat == Ok)
    {
        *count = data->rdh.nCount;
        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 1844 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;
            }
        }
 
        free(data);
    }
 
    return Ok;
}

Referenced by test_scans().

GdipIsEmptyRegion()

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

Definition at line 1211 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 1233 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 1268 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 1529 of file region.c.

{
    HRGN hrgn;
    GpStatus stat;
    REAL min_x, min_y, max_x, max_y;
    BOOL empty, infinite;
 
    TRACE("(%p, %.2f, %.2f, %p, %p)\n", region, x, y, graphics, res);
 
    if(!region || !res)
        return InvalidParameter;
 
    x = gdip_round(x);
    y = gdip_round(y);
 
    /* Check for cases where we can skip quantization. */
    get_region_bounding_box(&region->node, &min_x, &min_y, &max_x, &max_y, &empty, &infinite);
    if (empty || x < min_x || y < min_y || x > max_x || y > max_y)
    {
        *res = infinite;
        return Ok;
    }
 
    if((stat = GdipGetRegionHRgn(region, NULL, &hrgn)) != Ok)
        return stat;
 
    /* infinite */
    if(!hrgn){
        *res = TRUE;
        return Ok;
    }
 
    *res = PtInRegion(hrgn, x, y);
 
    DeleteObject(hrgn);
 
    return Ok;
}

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

GdipIsVisibleRegionPointI()

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

Definition at line 1571 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 1284 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 1315 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 1581 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_incombinedregion(), test_isempty(), test_isequal(), test_scans(), test_string_functions(), test_transform(), and test_translate().

GdipSetInfinite()

GpStatus WINGDIPAPI GdipSetInfinite

(

GpRegion *

region

)

Definition at line 1596 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 1702 of file region.c.

{
    TRACE("(%p, %s)\n", region, debugstr_matrix(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 1742 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(), GdipTranslateRegionI(), test_getregiondata(), and test_translate().

GdipTranslateRegionI()

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

Definition at line 1757 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 110 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 991 of file region.c.

{
    HDC new_hdc=NULL, hdc;
    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)
    {
        hdc = 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 (has_gdi_dc(graphics))
    {
        stat = gdi_dc_acquire(graphics, &hdc);
        if (stat != Ok)
            return stat;
    }
    else
    {
        graphics->hdc = hdc = new_hdc = CreateCompatibleDC(0);
        if (!new_hdc)
            return OutOfMemory;
    }
 
    save_state = SaveDC(hdc);
    EndPath(hdc);
 
    SetPolyFillMode(hdc, (path->fill == FillModeAlternate ? ALTERNATE : WINDING));
 
    gdi_transform_acquire(graphics);
 
    stat = trace_path(graphics, path);
    if (stat == Ok)
    {
        *hrgn = PathToRegion(hdc);
        stat = *hrgn ? Ok : OutOfMemory;
    }
 
    gdi_transform_release(graphics);
 
    RestoreDC(hdc, save_state);
    if (new_hdc)
    {
        DeleteDC(new_hdc);
        if (new_graphics)
            GdipDeleteGraphics(new_graphics);
        else
            graphics->hdc = NULL;
    }
    else
        gdi_dc_release(graphics, hdc);
 
    return stat;
}

Referenced by get_region_hrgn().

get_region_bounding_box()

static void get_region_bounding_box ( struct region_element *  element, REAL *  min_x, REAL *  min_y, REAL *  max_x, REAL *  max_y, BOOL *  empty, BOOL *  infinite  )

static

Definition at line 1330 of file region.c.

{
    REAL left_min_x, left_min_y, left_max_x, left_max_y;
    BOOL left_empty, left_infinite;
    REAL right_min_x, right_min_y, right_max_x, right_max_y;
    BOOL right_empty, right_infinite;
    /* For combine modes, we convert the mode to flags as follows to simplify the logic:
     * 0x8 = point in combined region if it's in both
     * 0x4 = point in combined region if it's in left and not right
     * 0x2 = point in combined region if it's not in left and is in right
     * 0x1 = point in combined region if it's in neither region */
    int flags;
    const int combine_mode_flags[] = {
        0xa, /* CombineModeReplace - shouldn't be used */
        0x8, /* CombineModeIntersect */
        0xe, /* CombineModeUnion */
        0x6, /* CombineModeXor */
        0x4, /* CombineModeExclude */
        0x2, /* CombineModeComplement */
    };
 
    /* handle unit elements first */
    switch (element->type)
    {
        case RegionDataInfiniteRect:
            *min_x = *min_y = *max_x = *max_y = 0.0;
            *empty = TRUE;
            *infinite = TRUE;
            return;
        case RegionDataEmptyRect:
            *min_x = *min_y = *max_x = *max_y = 0.0;
            *empty = TRUE;
            *infinite = FALSE;
            return;
        case RegionDataPath:
        {
            GpPath *path = element->elementdata.path;
            int i;
 
            if (path->pathdata.Count <= 1) {
                *min_x = *min_y = *max_x = *max_y = 0.0;
                *empty = TRUE;
                *infinite = FALSE;
                return;
            }
 
            *min_x = *max_x = path->pathdata.Points[0].X;
            *min_y = *max_y = path->pathdata.Points[0].Y;
            *empty = FALSE;
            *infinite = FALSE;
 
            for (i=1; i < path->pathdata.Count; i++)
            {
                if (path->pathdata.Points[i].X < *min_x)
                    *min_x = path->pathdata.Points[i].X;
                else if (path->pathdata.Points[i].X > *max_x)
                    *max_x = path->pathdata.Points[i].X;
                if (path->pathdata.Points[i].Y < *min_y)
                    *min_y = path->pathdata.Points[i].Y;
                else if (path->pathdata.Points[i].Y > *max_y)
                    *max_y = path->pathdata.Points[i].Y;
            }
 
            return;
        }
        case RegionDataRect:
            *min_x = element->elementdata.rect.X;
            *min_y = element->elementdata.rect.Y;
            *max_x = element->elementdata.rect.X + element->elementdata.rect.Width;
            *max_y = element->elementdata.rect.Y + element->elementdata.rect.Height;
            *empty = FALSE;
            *infinite = FALSE;
            return;
    }
 
    /* Should be only combine modes left */
    assert(element->type < ARRAY_SIZE(combine_mode_flags));
 
    flags = combine_mode_flags[element->type];
 
    get_region_bounding_box(element->elementdata.combine.left,
        &left_min_x, &left_min_y, &left_max_x, &left_max_y, &left_empty, &left_infinite);
 
    if (left_infinite)
    {
        /* change our function so we can ignore the infinity */
        flags = ((flags & 0x3) << 2) | ((flags & 0xc) >> 2);
    }
 
    if (left_empty && (flags & 0x3) == 0) {
        /* no points in region regardless of right region, return empty */
        *empty = TRUE;
        *infinite = FALSE;
        return;
    }
 
    if (left_empty && (flags & 0x3) == 0x3) {
        /* all points in region regardless of right region, return infinite */
        *empty = TRUE;
        *infinite = TRUE;
        return;
    }
 
    get_region_bounding_box(element->elementdata.combine.right,
        &right_min_x, &right_min_y, &right_max_x, &right_max_y, &right_empty, &right_infinite);
 
    if (right_infinite)
    {
        /* change our function so we can ignore the infinity */
        flags = ((flags & 0x5) << 1) | ((flags & 0xa) >> 1);
    }
 
    /* result is infinite if points in neither region are in the result */
    *infinite = (flags & 0x1);
 
    if (*infinite)
    {
        /* Again, we modify our function to ignore the infinity.
         * The points we care about are the ones that are different from the outside of our box,
         * not the points inside the region, so we invert the whole thing.
         * From here we can assume 0x1 is not set. */
        flags ^= 0xf;
    }
 
    if (left_empty)
    {
        /* We already took care of the cases where the right region doesn't matter,
         * so we can just use the right bounding box. */
        *min_x = right_min_x;
        *min_y = right_min_y;
        *max_x = right_max_x;
        *max_y = right_max_y;
        *empty = right_empty;
        return;
    }
 
    if (right_empty)
    {
        /* With no points in right region, and infinities eliminated, we only care
         * about flag 0x4, the case where a point is in left region and not right. */
        if (flags & 0x4)
        {
            /* We have a copy of the left region. */
            *min_x = left_min_x;
            *min_y = left_min_y;
            *max_x = left_max_x;
            *max_y = left_max_y;
            *empty = left_empty;
            return;
        }
        /* otherwise, it's an empty (or infinite) region */
        *empty = TRUE;
        return;
    }
 
    /* From here we know 0x1 isn't set, and we know at least one flag is set.
     * We can ignore flag 0x8 because we must assume that any point within the
     * intersection of the bounding boxes might be within the region. */
    switch (flags & 0x6)
    {
    case 0x0:
        /* intersection */
        *min_x = fmaxf(left_min_x, right_min_x);
        *min_y = fmaxf(left_min_y, right_min_y);
        *max_x = fminf(left_max_x, right_max_x);
        *max_y = fminf(left_max_y, right_max_y);
        *empty = *min_x > *max_x || *min_y > *max_y;
        return;
    case 0x2:
        /* right (or complement) */
        *min_x = right_min_x;
        *min_y = right_min_y;
        *max_x = right_max_x;
        *max_y = right_max_y;
        *empty = right_empty;
        return;
    case 0x4:
        /* left (or exclude) */
        *min_x = left_min_x;
        *min_y = left_min_y;
        *max_x = left_max_x;
        *max_y = left_max_y;
        *empty = left_empty;
        return;
    case 0x6:
        /* union (or xor) */
        *min_x = fminf(left_min_x, right_min_x);
        *min_y = fminf(left_min_y, right_min_y);
        *max_x = fmaxf(left_max_x, right_max_x);
        *max_y = fmaxf(left_max_y, right_max_y);
        *empty = FALSE;
        return;
    }
}

Referenced by GdipGetRegionBounds(), GdipIsVisibleRegionPoint(), and get_region_bounding_box().

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 CombineModeComplement:
                        *hrgn = CreateRectRgn(0, 0, 0, 0);
                        return *hrgn ? Ok : OutOfMemory;
                    case CombineModeUnion:
                        *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 CombineModeExclude:
                        DeleteObject(left);
                        *hrgn = CreateRectRgn(0, 0, 0, 0);
                        return *hrgn ? Ok : OutOfMemory;
                    case CombineModeUnion:
                        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=%lx\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 1764 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 = malloc(data_size);
 
                if (*data)
                    GetRegionData(hrgn, data_size, *data);
                else
                    stat = OutOfMemory;
 
                DeleteObject(hrgn);
            }
            else
            {
                data_size = sizeof(RGNDATAHEADER) + sizeof(RECT);
 
                *data = calloc(1, 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 136 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 768 of file region.c.

{
    GpStatus status;
    const DWORD *type;
 
    type = buffer_read(mbuf, sizeof(*type));
    if (!type) return Ok;
 
    TRACE("type %#lx\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 = calloc(1, sizeof(region_element));
        if (!left) return OutOfMemory;
        right = calloc(1, sizeof(region_element));
        if (!right)
        {
            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;
            }
        }
 
        free(left);
        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 %#lx\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 %#lx\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 %lu 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 %lu 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 %lu 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 %lu 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 %#lx 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 1612 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));
                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 1713 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 643 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 655 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 649 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 689 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().