gdiplus_private.h File Reference

#include <math.h>
#include <stdarg.h>
#include "windef.h"
#include "wingdi.h"
#include "winbase.h"
#include "winuser.h"
#include "objbase.h"
#include "ocidl.h"
#include "wincodecsdk.h"
#include "wine/heap.h"
#include "wine/list.h"
#include "gdiplus.h"

Include dependency graph for gdiplus_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	GpMatrix
struct	GpPen
struct	GpGraphics
struct	GpBrush
struct	GpHatch
struct	GpSolidFill
struct	GpPathGradient
struct	GpLineGradient
struct	GpTexture
struct	GpPath
struct	GpPathIterator
struct	GpCustomLineCap
struct	GpAdjustableArrowCap
struct	GpImage
struct	emfplus_object
struct	GpMetafile
struct	GpBitmap
struct	GpCachedBitmap
struct	color_key
struct	color_matrix
struct	color_remap_table
struct	GpImageAttributes
struct	GpFont
struct	GpStringFormat
struct	GpFontCollection
struct	GpFontFamily
struct	region_element
struct	GpRegion
struct	memory_buffer

Macros
#define	GP_DEFAULT_PENSTYLE   (PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT | PS_JOIN_MITER)
#define	MAX_ARC_PTS   (13)
#define	MAX_DASHLEN   (16) /* this is a limitation of gdi */
#define	INCH_HIMETRIC   (2540)
#define	VERSION_MAGIC   0xdbc01001
#define	VERSION_MAGIC2   0xdbc01002
#define	VALID_MAGIC(x)   (((x) & 0xfffff000) == 0xdbc01000)
#define	TENSION_CONST   (0.3)
#define	GIF_DISPOSE_UNSPECIFIED   0
#define	GIF_DISPOSE_DO_NOT_DISPOSE   1
#define	GIF_DISPOSE_RESTORE_TO_BKGND   2
#define	GIF_DISPOSE_RESTORE_TO_PREV   3
#define	WineCoordinateSpaceGdiDevice   ((GpCoordinateSpace)4)
#define	EmfPlusObjectTableSize   64

Typedefs
typedef struct region_element	region_element
typedef enum EmfPlusObjectType	EmfPlusObjectType
typedef enum RegionType	RegionType
typedef GpStatus(*	gdip_format_string_callback) (HDC hdc, GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font, GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, INT lineno, const RectF *bounds, INT *underlined_indexes, INT underlined_index_count, void *user_data)

Enumerations
enum	EmfPlusObjectType {   ObjectTypeInvalid , ObjectTypeBrush , ObjectTypePen , ObjectTypePath ,   ObjectTypeRegion , ObjectTypeImage , ObjectTypeFont , ObjectTypeStringFormat ,   ObjectTypeImageAttributes , ObjectTypeCustomLineCap , ObjectTypeMax = ObjectTypeCustomLineCap }
enum	imageattr_noop { IMAGEATTR_NOOP_UNDEFINED , IMAGEATTR_NOOP_SET , IMAGEATTR_NOOP_CLEAR }
enum	RegionType { RegionDataRect = 0x10000000 , RegionDataPath = 0x10000001 , RegionDataEmptyRect = 0x10000002 , RegionDataInfiniteRect = 0x10000003 }

Functions
COLORREF	ARGB2COLORREF (ARGB color) DECLSPEC_HIDDEN
HBITMAP	ARGB2BMP (ARGB color) DECLSPEC_HIDDEN
INT	arc2polybezier (GpPointF *points, REAL x1, REAL y1, REAL x2, REAL y2, REAL startAngle, REAL sweepAngle) DECLSPEC_HIDDEN
REAL	gdiplus_atan2 (REAL dy, REAL dx) DECLSPEC_HIDDEN
GpStatus	hresult_to_status (HRESULT res) DECLSPEC_HIDDEN
REAL	units_to_pixels (REAL units, GpUnit unit, REAL dpi) DECLSPEC_HIDDEN
REAL	pixels_to_units (REAL pixels, GpUnit unit, REAL dpi) DECLSPEC_HIDDEN
REAL	units_scale (GpUnit from, GpUnit to, REAL dpi) DECLSPEC_HIDDEN
GpStatus	gdi_transform_acquire (GpGraphics *graphics)
GpStatus	gdi_transform_release (GpGraphics *graphics)
GpStatus	get_graphics_transform (GpGraphics *graphics, GpCoordinateSpace dst_space, GpCoordinateSpace src_space, GpMatrix *matrix) DECLSPEC_HIDDEN
GpStatus	gdip_transform_points (GpGraphics *graphics, GpCoordinateSpace dst_space, GpCoordinateSpace src_space, GpPointF *points, INT count) DECLSPEC_HIDDEN
GpStatus	graphics_from_image (GpImage *image, GpGraphics **graphics) DECLSPEC_HIDDEN
GpStatus	encode_image_png (GpImage *image, IStream *stream, GDIPCONST EncoderParameters *params) DECLSPEC_HIDDEN
GpStatus	METAFILE_GetGraphicsContext (GpMetafile *metafile, GpGraphics **result) DECLSPEC_HIDDEN
GpStatus	METAFILE_GetDC (GpMetafile *metafile, HDC *hdc) DECLSPEC_HIDDEN
GpStatus	METAFILE_ReleaseDC (GpMetafile *metafile, HDC hdc) DECLSPEC_HIDDEN
GpStatus	METAFILE_GraphicsClear (GpMetafile *metafile, ARGB color) DECLSPEC_HIDDEN
GpStatus	METAFILE_FillRectangles (GpMetafile *metafile, GpBrush *brush, GDIPCONST GpRectF *rects, INT count) DECLSPEC_HIDDEN
GpStatus	METAFILE_SetClipRect (GpMetafile *metafile, REAL x, REAL y, REAL width, REAL height, CombineMode mode) DECLSPEC_HIDDEN
GpStatus	METAFILE_SetClipRegion (GpMetafile *metafile, GpRegion *region, CombineMode mode) DECLSPEC_HIDDEN
GpStatus	METAFILE_SetPageTransform (GpMetafile *metafile, GpUnit unit, REAL scale) DECLSPEC_HIDDEN
GpStatus	METAFILE_SetWorldTransform (GpMetafile *metafile, GDIPCONST GpMatrix *transform) DECLSPEC_HIDDEN
GpStatus	METAFILE_ScaleWorldTransform (GpMetafile *metafile, REAL sx, REAL sy, MatrixOrder order) DECLSPEC_HIDDEN
GpStatus	METAFILE_MultiplyWorldTransform (GpMetafile *metafile, GDIPCONST GpMatrix *matrix, MatrixOrder order) DECLSPEC_HIDDEN
GpStatus	METAFILE_RotateWorldTransform (GpMetafile *metafile, REAL angle, MatrixOrder order) DECLSPEC_HIDDEN
GpStatus	METAFILE_TranslateWorldTransform (GpMetafile *metafile, REAL dx, REAL dy, MatrixOrder order) DECLSPEC_HIDDEN
GpStatus	METAFILE_ResetWorldTransform (GpMetafile *metafile) DECLSPEC_HIDDEN
GpStatus	METAFILE_BeginContainer (GpMetafile *metafile, GDIPCONST GpRectF *dstrect, GDIPCONST GpRectF *srcrect, GpUnit unit, DWORD StackIndex) DECLSPEC_HIDDEN
GpStatus	METAFILE_BeginContainerNoParams (GpMetafile *metafile, DWORD StackIndex) DECLSPEC_HIDDEN
GpStatus	METAFILE_EndContainer (GpMetafile *metafile, DWORD StackIndex) DECLSPEC_HIDDEN
GpStatus	METAFILE_SaveGraphics (GpMetafile *metafile, DWORD StackIndex) DECLSPEC_HIDDEN
GpStatus	METAFILE_RestoreGraphics (GpMetafile *metafile, DWORD StackIndex) DECLSPEC_HIDDEN
GpStatus	METAFILE_GraphicsDeleted (GpMetafile *metafile) DECLSPEC_HIDDEN
GpStatus	METAFILE_DrawImagePointsRect (GpMetafile *metafile, GpImage *image, GDIPCONST GpPointF *points, INT count, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes *imageAttributes, DrawImageAbort callback, VOID *callbackData) DECLSPEC_HIDDEN
GpStatus	METAFILE_AddSimpleProperty (GpMetafile *metafile, SHORT prop, SHORT val) DECLSPEC_HIDDEN
GpStatus	METAFILE_DrawPath (GpMetafile *metafile, GpPen *pen, GpPath *path) DECLSPEC_HIDDEN
GpStatus	METAFILE_FillPath (GpMetafile *metafile, GpBrush *brush, GpPath *path) DECLSPEC_HIDDEN
void	METAFILE_Free (GpMetafile *metafile) DECLSPEC_HIDDEN
void	calc_curve_bezier (const GpPointF *pts, REAL tension, REAL *x1, REAL *y1, REAL *x2, REAL *y2) DECLSPEC_HIDDEN
void	calc_curve_bezier_endp (REAL xend, REAL yend, REAL xadj, REAL yadj, REAL tension, REAL *x, REAL *y) DECLSPEC_HIDDEN
void	free_installed_fonts (void) DECLSPEC_HIDDEN
BOOL	lengthen_path (GpPath *path, INT len) DECLSPEC_HIDDEN
DWORD	write_region_data (const GpRegion *region, void *data) DECLSPEC_HIDDEN
DWORD	write_path_data (GpPath *path, void *data) DECLSPEC_HIDDEN
GpStatus	trace_path (GpGraphics *graphics, GpPath *path) DECLSPEC_HIDDEN
void	delete_element (region_element *element) DECLSPEC_HIDDEN
GpStatus	get_hatch_data (GpHatchStyle hatchstyle, const char **result) DECLSPEC_HIDDEN
static INT	gdip_round (REAL x)
static INT	ceilr (REAL x)
static REAL	deg2rad (REAL degrees)
static ARGB	color_over (ARGB bg, ARGB fg)
static ARGB	color_over_fgpremult (ARGB bg, ARGB fg)
const char *	debugstr_rectf (const RectF *rc) DECLSPEC_HIDDEN
const char *	debugstr_pointf (const PointF *pt) DECLSPEC_HIDDEN
void	convert_32bppARGB_to_32bppPARGB (UINT width, UINT height, BYTE *dst_bits, INT dst_stride, const BYTE *src_bits, INT src_stride) DECLSPEC_HIDDEN
GpStatus	convert_pixels (INT width, INT height, INT dst_stride, BYTE *dst_bits, PixelFormat dst_format, INT src_stride, const BYTE *src_bits, PixelFormat src_format, ColorPalette *palette) DECLSPEC_HIDDEN
PixelFormat	apply_image_attributes (const GpImageAttributes *attributes, LPBYTE data, UINT width, UINT height, INT stride, ColorAdjustType type, PixelFormat fmt) DECLSPEC_HIDDEN
void	init_generic_string_formats (void) DECLSPEC_HIDDEN
void	free_generic_string_formats (void) DECLSPEC_HIDDEN
static void	init_memory_buffer (struct memory_buffer *mbuf, const BYTE *buffer, INT size)
static const void *	buffer_read (struct memory_buffer *mbuf, INT size)
GpStatus	gdip_format_string (HDC hdc, GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font, GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, int ignore_empty_clip, gdip_format_string_callback callback, void *user_data) DECLSPEC_HIDDEN
void	get_log_fontW (const GpFont *, GpGraphics *, LOGFONTW *) DECLSPEC_HIDDEN
static BOOL	image_lock (GpImage *image, BOOL *unlock)
static void	image_unlock (GpImage *image, BOOL unlock)

Variables
const struct GpStringFormat default_drawstring_format	DECLSPEC_HIDDEN

Macro Definition Documentation

EmfPlusObjectTableSize

#define EmfPlusObjectTableSize   64

Definition at line 358 of file gdiplus_private.h.

GIF_DISPOSE_DO_NOT_DISPOSE

#define GIF_DISPOSE_DO_NOT_DISPOSE   1

Definition at line 49 of file gdiplus_private.h.

GIF_DISPOSE_RESTORE_TO_BKGND

#define GIF_DISPOSE_RESTORE_TO_BKGND   2

Definition at line 50 of file gdiplus_private.h.

GIF_DISPOSE_RESTORE_TO_PREV

#define GIF_DISPOSE_RESTORE_TO_PREV   3

Definition at line 51 of file gdiplus_private.h.

GIF_DISPOSE_UNSPECIFIED

#define GIF_DISPOSE_UNSPECIFIED   0

Definition at line 48 of file gdiplus_private.h.

GP_DEFAULT_PENSTYLE

#define GP_DEFAULT_PENSTYLE   (PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT | PS_JOIN_MITER)

Definition at line 38 of file gdiplus_private.h.

INCH_HIMETRIC

#define INCH_HIMETRIC   (2540)

Definition at line 41 of file gdiplus_private.h.

MAX_ARC_PTS

#define MAX_ARC_PTS   (13)

Definition at line 39 of file gdiplus_private.h.

MAX_DASHLEN

#define MAX_DASHLEN   (16) /* this is a limitation of gdi */

Definition at line 40 of file gdiplus_private.h.

TENSION_CONST

#define TENSION_CONST   (0.3)

Definition at line 46 of file gdiplus_private.h.

VALID_MAGIC

#define VALID_MAGIC

(

x

)

(((x) & 0xfffff000) == 0xdbc01000)

Definition at line 45 of file gdiplus_private.h.

VERSION_MAGIC

#define VERSION_MAGIC   0xdbc01001

Definition at line 43 of file gdiplus_private.h.

VERSION_MAGIC2

#define VERSION_MAGIC2   0xdbc01002

Definition at line 44 of file gdiplus_private.h.

WineCoordinateSpaceGdiDevice

#define WineCoordinateSpaceGdiDevice   ((GpCoordinateSpace)4)

Definition at line 64 of file gdiplus_private.h.

Typedef Documentation

EmfPlusObjectType

typedef enum EmfPlusObjectType EmfPlusObjectType

gdip_format_string_callback

typedef GpStatus(* gdip_format_string_callback) (HDC hdc, GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font, GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, INT lineno, const RectF *bounds, INT *underlined_indexes, INT underlined_index_count, void *user_data)

Definition at line 579 of file gdiplus_private.h.

region_element

typedef struct region_element region_element

Definition at line 122 of file gdiplus_private.h.

RegionType

typedef enum RegionType RegionType

Enumeration Type Documentation

EmfPlusObjectType

enum EmfPlusObjectType

Enumerator
ObjectTypeInvalid
ObjectTypeBrush
ObjectTypePen
ObjectTypePath
ObjectTypeRegion
ObjectTypeImage
ObjectTypeFont
ObjectTypeStringFormat
ObjectTypeImageAttributes
ObjectTypeCustomLineCap
ObjectTypeMax

Definition at line 360 of file gdiplus_private.h.

{
    ObjectTypeInvalid,
    ObjectTypeBrush,
    ObjectTypePen,
    ObjectTypePath,
    ObjectTypeRegion,
    ObjectTypeImage,
    ObjectTypeFont,
    ObjectTypeStringFormat,
    ObjectTypeImageAttributes,
    ObjectTypeCustomLineCap,
    ObjectTypeMax = ObjectTypeCustomLineCap,
} EmfPlusObjectType;

imageattr_noop

enum imageattr_noop

Enumerator
IMAGEATTR_NOOP_UNDEFINED
IMAGEATTR_NOOP_SET
IMAGEATTR_NOOP_CLEAR

Definition at line 467 of file gdiplus_private.h.

                   {
    IMAGEATTR_NOOP_UNDEFINED,
    IMAGEATTR_NOOP_SET,
    IMAGEATTR_NOOP_CLEAR,
};

RegionType

enum RegionType

Enumerator
RegionDataRect
RegionDataPath
RegionDataEmptyRect
RegionDataInfiniteRect

Definition at line 527 of file gdiplus_private.h.

{
    RegionDataRect          = 0x10000000,
    RegionDataPath          = 0x10000001,
    RegionDataEmptyRect     = 0x10000002,
    RegionDataInfiniteRect  = 0x10000003,
} RegionType;

Function Documentation

apply_image_attributes()

PixelFormat apply_image_attributes	(	const GpImageAttributes *	attributes,
		LPBYTE	data,
		UINT	width,
		UINT	height,
		INT	stride,
		ColorAdjustType	type,
		PixelFormat	fmt
	)

Definition at line 710 of file graphics.c.

{
    UINT x, y;
    INT i;
 
    if ((attributes->noop[type] == IMAGEATTR_NOOP_UNDEFINED &&
            attributes->noop[ColorAdjustTypeDefault] == IMAGEATTR_NOOP_SET) ||
            (attributes->noop[type] == IMAGEATTR_NOOP_SET))
        return fmt;
 
    if (attributes->colorkeys[type].enabled ||
        attributes->colorkeys[ColorAdjustTypeDefault].enabled)
    {
        const struct color_key *key;
        BYTE min_blue, min_green, min_red;
        BYTE max_blue, max_green, max_red;
 
        if (!data || fmt != PixelFormat32bppARGB)
            return PixelFormat32bppARGB;
 
        if (attributes->colorkeys[type].enabled)
            key = &attributes->colorkeys[type];
        else
            key = &attributes->colorkeys[ColorAdjustTypeDefault];
 
        min_blue = key->low&0xff;
        min_green = (key->low>>8)&0xff;
        min_red = (key->low>>16)&0xff;
 
        max_blue = key->high&0xff;
        max_green = (key->high>>8)&0xff;
        max_red = (key->high>>16)&0xff;
 
        for (x=0; x<width; x++)
            for (y=0; y<height; y++)
            {
                ARGB *src_color;
                BYTE blue, green, red;
                src_color = (ARGB*)(data + stride * y + sizeof(ARGB) * x);
                blue = *src_color&0xff;
                green = (*src_color>>8)&0xff;
                red = (*src_color>>16)&0xff;
                if (blue >= min_blue && green >= min_green && red >= min_red &&
                    blue <= max_blue && green <= max_green && red <= max_red)
                    *src_color = 0x00000000;
            }
    }
 
    if (attributes->colorremaptables[type].enabled ||
        attributes->colorremaptables[ColorAdjustTypeDefault].enabled)
    {
        const struct color_remap_table *table;
 
        if (!data || fmt != PixelFormat32bppARGB)
            return PixelFormat32bppARGB;
 
        if (attributes->colorremaptables[type].enabled)
            table = &attributes->colorremaptables[type];
        else
            table = &attributes->colorremaptables[ColorAdjustTypeDefault];
 
        for (x=0; x<width; x++)
            for (y=0; y<height; y++)
            {
                ARGB *src_color;
                src_color = (ARGB*)(data + stride * y + sizeof(ARGB) * x);
                for (i=0; i<table->mapsize; i++)
                {
                    if (*src_color == table->colormap[i].oldColor.Argb)
                    {
                        *src_color = table->colormap[i].newColor.Argb;
                        break;
                    }
                }
            }
    }
 
    if (attributes->colormatrices[type].enabled ||
        attributes->colormatrices[ColorAdjustTypeDefault].enabled)
    {
        const struct color_matrix *colormatrices;
        int color_matrix[5][5];
        int gray_matrix[5][5];
        BOOL identity;
 
        if (!data || fmt != PixelFormat32bppARGB)
            return PixelFormat32bppARGB;
 
        if (attributes->colormatrices[type].enabled)
            colormatrices = &attributes->colormatrices[type];
        else
            colormatrices = &attributes->colormatrices[ColorAdjustTypeDefault];
 
        identity = round_color_matrix(&colormatrices->colormatrix, color_matrix);
 
        if (colormatrices->flags == ColorMatrixFlagsAltGray)
            identity = (round_color_matrix(&colormatrices->graymatrix, gray_matrix) && identity);
 
        if (!identity)
        {
            for (x=0; x<width; x++)
            {
                for (y=0; y<height; y++)
                {
                    ARGB *src_color;
                    src_color = (ARGB*)(data + stride * y + sizeof(ARGB) * x);
 
                    if (colormatrices->flags == ColorMatrixFlagsDefault ||
                        !color_is_gray(*src_color))
                    {
                        *src_color = transform_color(*src_color, color_matrix);
                    }
                    else if (colormatrices->flags == ColorMatrixFlagsAltGray)
                    {
                        *src_color = transform_color(*src_color, gray_matrix);
                    }
                }
            }
        }
    }
 
    if (attributes->gamma_enabled[type] ||
        attributes->gamma_enabled[ColorAdjustTypeDefault])
    {
        REAL gamma;
 
        if (!data || fmt != PixelFormat32bppARGB)
            return PixelFormat32bppARGB;
 
        if (attributes->gamma_enabled[type])
            gamma = attributes->gamma[type];
        else
            gamma = attributes->gamma[ColorAdjustTypeDefault];
 
        for (x=0; x<width; x++)
            for (y=0; y<height; y++)
            {
                ARGB *src_color;
                BYTE blue, green, red;
                src_color = (ARGB*)(data + stride * y + sizeof(ARGB) * x);
 
                blue = *src_color&0xff;
                green = (*src_color>>8)&0xff;
                red = (*src_color>>16)&0xff;
 
                /* FIXME: We should probably use a table for this. */
                blue = floorf(powf(blue / 255.0, gamma) * 255.0);
                green = floorf(powf(green / 255.0, gamma) * 255.0);
                red = floorf(powf(red / 255.0, gamma) * 255.0);
 
                *src_color = (*src_color & 0xff000000) | (red << 16) | (green << 8) | blue;
            }
    }
 
    return fmt;
}

Referenced by brush_fill_pixels(), GdipDrawImagePointsRect(), and GdipGetImageAttributesAdjustedPalette().

arc2polybezier()

INT arc2polybezier	(	GpPointF *	points,
		REAL	x1,
		REAL	y1,
		REAL	x2,
		REAL	y2,
		REAL	startAngle,
		REAL	sweepAngle
	)

Definition at line 223 of file gdiplus.c.

{
    INT i;
    REAL end_angle, start_angle, endAngle;
 
    endAngle = startAngle + sweepAngle;
    unstretch_angle(&startAngle, x2 / 2.0, y2 / 2.0);
    unstretch_angle(&endAngle, x2 / 2.0, y2 / 2.0);
 
    /* start_angle and end_angle are the iterative variables */
    start_angle = startAngle;
 
    for(i = 0; i < MAX_ARC_PTS - 1; i += 3){
        /* check if we've overshot the end angle */
        if( sweepAngle > 0.0 )
        {
            if (start_angle >= endAngle) break;
            end_angle = min(start_angle + M_PI_2, endAngle);
        }
        else
        {
            if (start_angle <= endAngle) break;
            end_angle = max(start_angle - M_PI_2, endAngle);
        }
 
        if (points)
            add_arc_part(&points[i], x1, y1, x2, y2, start_angle, end_angle, i == 0);
 
        start_angle += M_PI_2 * (sweepAngle < 0.0 ? -1.0 : 1.0);
    }
 
    if (i == 0) return 0;
    else return i+1;
}

Referenced by GdipAddPathArc(), GdipAddPathEllipse(), and GdipAddPathPie().

ARGB2BMP()

HBITMAP ARGB2BMP

(

ARGB

color

)

Definition at line 272 of file gdiplus.c.

{
    BITMAPINFO bi;
    HBITMAP result;
    RGBQUAD *bits;
    int alpha;
 
    if ((color & 0xff000000) == 0xff000000) return 0;
 
    bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
    bi.bmiHeader.biWidth = 1;
    bi.bmiHeader.biHeight = 1;
    bi.bmiHeader.biPlanes = 1;
    bi.bmiHeader.biBitCount = 32;
    bi.bmiHeader.biCompression = BI_RGB;
    bi.bmiHeader.biSizeImage = 0;
    bi.bmiHeader.biXPelsPerMeter = 0;
    bi.bmiHeader.biYPelsPerMeter = 0;
    bi.bmiHeader.biClrUsed = 0;
    bi.bmiHeader.biClrImportant = 0;
 
    result = CreateDIBSection(0, &bi, DIB_RGB_COLORS, (void*)&bits, NULL, 0);
 
    bits[0].rgbReserved = alpha = (color>>24)&0xff;
    bits[0].rgbRed = ((color>>16)&0xff)*alpha/255;
    bits[0].rgbGreen = ((color>>8)&0xff)*alpha/255;
    bits[0].rgbBlue = (color&0xff)*alpha/255;
 
    return result;
}

Referenced by brush_fill_path().

ARGB2COLORREF()

COLORREF ARGB2COLORREF

(

ARGB

color

)

Definition at line 259 of file gdiplus.c.

{
    /*
    Packing of these color structures:
    COLORREF:   00bbggrr
    ARGB:       aarrggbb
    FIXME:doesn't handle alpha channel
    */
    return ((color & 0x0000ff) << 16) +
           (color & 0x00ff00) +
           ((color & 0xff0000) >> 16);
}

Referenced by create_gdi_logbrush(), and get_gdi_brush_color().

buffer_read()

static const void * buffer_read ( struct memory_buffer *  mbuf, INT  size  )

inlinestatic

Definition at line 568 of file gdiplus_private.h.

{
    if (mbuf->size - mbuf->pos >= size)
    {
        const void *data = mbuf->buffer + mbuf->pos;
        mbuf->pos += size;
        return data;
    }
    return NULL;
}

Referenced by GdipCreateRegionRgnData(), metafile_deserialize_region(), metafile_read_region_node(), and read_element().

calc_curve_bezier()

void calc_curve_bezier	(	const GpPointF *	pts,
		REAL	tension,
		REAL *	x1,
		REAL *	y1,
		REAL *	x2,
		REAL *	y2
	)

Definition at line 379 of file gdiplus.c.

{
    REAL xdiff, ydiff;
 
    /* calculate tangent */
    xdiff = pts[2].X - pts[0].X;
    ydiff = pts[2].Y - pts[0].Y;
 
    /* apply tangent to get control points */
    *x1 = pts[1].X - tension * xdiff;
    *y1 = pts[1].Y - tension * ydiff;
    *x2 = pts[1].X + tension * xdiff;
    *y2 = pts[1].Y + tension * ydiff;
}

Referenced by GdipAddPathClosedCurve2(), and GdipAddPathCurve2().

calc_curve_bezier_endp()

void calc_curve_bezier_endp	(	REAL	xend,
		REAL	yend,
		REAL	xadj,
		REAL	yadj,
		REAL	tension,
		REAL *	x,
		REAL *	y
	)

Definition at line 396 of file gdiplus.c.

{
    /* tangent at endpoints is the line from the endpoint to the adjacent point */
    *x = gdip_round(tension * (xadj - xend) + xend);
    *y = gdip_round(tension * (yadj - yend) + yend);
}

Referenced by GdipAddPathCurve2().

ceilr()

static INT ceilr ( REAL  x )

inlinestatic

Definition at line 132 of file gdiplus_private.h.

{
    return (INT) ceilf(x);
}

Referenced by GdipIsVisibleRegionRect().

color_over()

static ARGB color_over ( ARGB  bg, ARGB  fg  )

inlinestatic

Definition at line 142 of file gdiplus_private.h.

{
    BYTE b, g, r, a;
    BYTE bg_alpha, fg_alpha;
 
    fg_alpha = (fg>>24)&0xff;
 
    if (fg_alpha == 0xff) return fg;
 
    if (fg_alpha == 0) return bg;
 
    bg_alpha = (((bg>>24)&0xff) * (0xff-fg_alpha)) / 0xff;
 
    if (bg_alpha == 0) return fg;
 
    a = bg_alpha + fg_alpha;
    b = ((bg&0xff)*bg_alpha + (fg&0xff)*fg_alpha)/a;
    g = (((bg>>8)&0xff)*bg_alpha + ((fg>>8)&0xff)*fg_alpha)/a;
    r = (((bg>>16)&0xff)*bg_alpha + ((fg>>16)&0xff)*fg_alpha)/a;
 
    return (a<<24)|(r<<16)|(g<<8)|b;
}

Referenced by alpha_blend_bmp_pixels().

color_over_fgpremult()

static ARGB color_over_fgpremult ( ARGB  bg, ARGB  fg  )

inlinestatic

Definition at line 166 of file gdiplus_private.h.

{
    BYTE b, g, r, a;
    BYTE bg_alpha, fg_alpha;
 
    fg_alpha = (fg>>24)&0xff;
 
    if (fg_alpha == 0) return bg;
 
    bg_alpha = (((bg>>24)&0xff) * (0xff-fg_alpha)) / 0xff;
 
    a = bg_alpha + fg_alpha;
    b = ((bg&0xff)*bg_alpha + (fg&0xff)*0xff)/a;
    g = (((bg>>8)&0xff)*bg_alpha + ((fg>>8)&0xff)*0xff)/a;
    r = (((bg>>16)&0xff)*bg_alpha + ((fg>>16)&0xff)*0xff)/a;
 
    return (a<<24)|(r<<16)|(g<<8)|b;
}

Referenced by alpha_blend_bmp_pixels().

convert_32bppARGB_to_32bppPARGB()

void convert_32bppARGB_to_32bppPARGB	(	UINT	width,
		UINT	height,
		BYTE *	dst_bits,
		INT	dst_stride,
		const BYTE *	src_bits,
		INT	src_stride
	)

Definition at line 435 of file gdiplus.c.

{
    INT x, y;
    for (y=0; y<height; y++)
    {
        const BYTE *src=src_bits+y*src_stride;
        BYTE *dst=dst_bits+y*dst_stride;
        for (x=0; x<width; x++)
        {
            BYTE alpha=src[3];
            *dst++ = (*src++ * alpha + 127) / 255;
            *dst++ = (*src++ * alpha + 127) / 255;
            *dst++ = (*src++ * alpha + 127) / 255;
            *dst++ = *src++;
        }
    }
}

Referenced by alpha_blend_hdc_pixels(), and convert_pixels().

convert_pixels()

GpStatus convert_pixels	(	INT	width,
		INT	height,
		INT	dst_stride,
		BYTE *	dst_bits,
		PixelFormat	dst_format,
		INT	src_stride,
		const BYTE *	src_bits,
		PixelFormat	src_format,
		ColorPalette *	palette
	)

Definition at line 562 of file image.c.

{
    INT x, y;
 
    if (src_format == dst_format ||
        (dst_format == PixelFormat32bppRGB && PIXELFORMATBPP(src_format) == 32))
    {
        UINT widthbytes = PIXELFORMATBPP(src_format) * width / 8;
        for (y=0; y<height; y++)
            memcpy(dst_bits+dst_stride*y, src_bits+src_stride*y, widthbytes);
        return Ok;
    }
 
#define convert_indexed_to_rgb(getpixel_function, setpixel_function) do { \
    for (y=0; y<height; y++) \
        for (x=0; x<width; x++) { \
            BYTE index; \
            ARGB argb; \
            BYTE *color = (BYTE *)&argb; \
            getpixel_function(&index, src_bits+src_stride*y, x); \
            argb = (palette && index < palette->Count) ? palette->Entries[index] : 0; \
            setpixel_function(color[2], color[1], color[0], color[3], dst_bits+dst_stride*y, x); \
        } \
    return Ok; \
} while (0);
 
#define convert_rgb_to_rgb(getpixel_function, setpixel_function) do { \
    for (y=0; y<height; y++) \
        for (x=0; x<width; x++) { \
            BYTE r, g, b, a; \
            getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
            setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x); \
        } \
    return Ok; \
} while (0);
 
#define convert_rgb_to_indexed(getpixel_function, setpixel_function) do { \
    for (y=0; y<height; y++) \
        for (x=0; x<width; x++) { \
            BYTE r, g, b, a; \
            getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
            setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x, palette); \
        } \
    return Ok; \
} while (0);
 
    switch (src_format)
    {
    case PixelFormat1bppIndexed:
        switch (dst_format)
        {
        case PixelFormat16bppGrayScale:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat4bppIndexed:
        switch (dst_format)
        {
        case PixelFormat16bppGrayScale:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat8bppIndexed:
        switch (dst_format)
        {
        case PixelFormat16bppGrayScale:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat16bppGrayScale:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_8bppIndexed);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat16bppRGB555:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat16bppRGB565:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppRGB555);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat16bppARGB1555:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppRGB565);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat24bppRGB:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppARGB1555);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat32bppRGB:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_24bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat32bppARGB:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_24bppRGB);
        case PixelFormat32bppPARGB:
            convert_32bppARGB_to_32bppPARGB(width, height, dst_bits, dst_stride, src_bits, src_stride);
            return Ok;
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat32bppPARGB:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_32bppARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat48bppRGB:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppPARGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat64bppARGB:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_48bppRGB);
        default:
            break;
        }
        break;
    case PixelFormat64bppPARGB:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    default:
        break;
    }
 
#undef convert_indexed_to_rgb
#undef convert_rgb_to_rgb
 
    return NotImplemented;
}

Referenced by GdipBitmapLockBits(), GdipBitmapUnlockBits(), GdipCloneBitmapArea(), GdipCreateHBITMAPFromBitmap(), and GdipDrawImagePointsRect().

debugstr_pointf()

const char * debugstr_pointf

(

const PointF *

pt

)

Definition at line 482 of file gdiplus.c.

{
    if (!pt) return "(null)";
    return wine_dbg_sprintf("(%0.2f,%0.2f)", pt->X, pt->Y);
}

Referenced by GdipCreateLineBrush(), GdipDrawImagePointsRect(), GdipEnumerateMetafileSrcRectDestPoints(), and GdipSetPathGradientCenterPoint().

debugstr_rectf()

const char * debugstr_rectf

(

const RectF *

rc

)

Definition at line 476 of file gdiplus.c.

{
    if (!rc) return "(null)";
    return wine_dbg_sprintf("(%0.2f,%0.2f,%0.2f,%0.2f)", rc->X, rc->Y, rc->Width, rc->Height);
}

Referenced by GdipBeginContainer(), GdipCombineRegionRect(), GdipDrawString(), GdipEnumerateMetafileSrcRectDestPoints(), GdipGetRegionBounds(), GdipMeasureCharacterRanges(), and GdipMeasureString().

deg2rad()

static REAL deg2rad ( REAL  degrees )

inlinestatic

Definition at line 137 of file gdiplus_private.h.

{
    return M_PI * degrees / 180.0;
}

Referenced by GdipCreateLineBrushFromRectWithAngle(), GdipRotateMatrix(), and unstretch_angle().

delete_element()

void delete_element

(

region_element *

element

)

Definition at line 455 of file gdiplus.c.

{
    switch(element->type)
    {
        case RegionDataRect:
            break;
        case RegionDataPath:
            GdipDeletePath(element->elementdata.path);
            break;
        case RegionDataEmptyRect:
        case RegionDataInfiniteRect:
            break;
        default:
            delete_element(element->elementdata.combine.left);
            delete_element(element->elementdata.combine.right);
            heap_free(element->elementdata.combine.left);
            heap_free(element->elementdata.combine.right);
            break;
    }
}

Referenced by clone_element(), delete_element(), GdipCombineRegionPath(), GdipCombineRegionRect(), GdipCombineRegionRegion(), GdipDeleteRegion(), GdipGetClip(), GdipSetEmpty(), and GdipSetInfinite().

encode_image_png()

GpStatus encode_image_png	(	GpImage *	image,
		IStream *	stream,
		GDIPCONST EncoderParameters *	params
	)

Definition at line 4650 of file image.c.

{
    return encode_image_wic(image, stream, &GUID_ContainerFormatPng, params);
}

Referenced by METAFILE_CreateCompressedImageStream().

free_generic_string_formats()

void free_generic_string_formats

(

void

)

Definition at line 67 of file stringformat.c.

{
    heap_free(generic_default_format.character_ranges);
    heap_free(generic_default_format.tabs);
 
    heap_free(generic_typographic_format.character_ranges);
    heap_free(generic_typographic_format.tabs);
}

Referenced by DllMain().

free_installed_fonts()

void free_installed_fonts

(

void

)

Definition at line 1608 of file font.c.

{
    while (installedFontCollection.count)
        GdipDeleteFontFamily(installedFontCollection.FontFamilies[--installedFontCollection.count]);
    heap_free(installedFontCollection.FontFamilies);
    installedFontCollection.FontFamilies = NULL;
    installedFontCollection.allocated = 0;
}

Referenced by DllMain(), and GdipNewInstalledFontCollection().

gdi_transform_acquire()

GpStatus gdi_transform_acquire

(

GpGraphics *

graphics

)

Definition at line 6842 of file graphics.c.

{
    if (graphics->gdi_transform_acquire_count == 0 && graphics->hdc)
    {
        graphics->gdi_transform_save = SaveDC(graphics->hdc);
        SetGraphicsMode(graphics->hdc, GM_COMPATIBLE);
        SetMapMode(graphics->hdc, MM_TEXT);
        SetWindowOrgEx(graphics->hdc, 0, 0, NULL);
        SetViewportOrgEx(graphics->hdc, 0, 0, NULL);
    }
    graphics->gdi_transform_acquire_count++;
    return Ok;
}

Referenced by GDI32_GdipDrawDriverString(), GDI32_GdipDrawPath(), GDI32_GdipFillPath(), GdipDrawImagePointsRect(), GdipDrawString(), GdipMeasureCharacterRanges(), GdipMeasureString(), get_path_hrgn(), SOFTWARE_GdipDrawDriverString(), SOFTWARE_GdipDrawThinPath(), and SOFTWARE_GdipFillRegion().

gdi_transform_release()

GpStatus gdi_transform_release

(

GpGraphics *

graphics

)

Definition at line 6856 of file graphics.c.

{
    if (graphics->gdi_transform_acquire_count <= 0)
    {
        ERR("called without matching gdi_transform_acquire\n");
        return GenericError;
    }
    if (graphics->gdi_transform_acquire_count == 1 && graphics->hdc)
    {
        RestoreDC(graphics->hdc, graphics->gdi_transform_save);
    }
    graphics->gdi_transform_acquire_count--;
    return Ok;
}

Referenced by GDI32_GdipDrawDriverString(), GDI32_GdipDrawPath(), GDI32_GdipFillPath(), GdipDrawImagePointsRect(), GdipDrawString(), GdipMeasureCharacterRanges(), GdipMeasureString(), get_path_hrgn(), SOFTWARE_GdipDrawDriverString(), SOFTWARE_GdipDrawThinPath(), and SOFTWARE_GdipFillRegion().

gdip_format_string()

GpStatus gdip_format_string	(	HDC	hdc,
		GDIPCONST WCHAR *	string,
		INT	length,
		GDIPCONST GpFont *	font,
		GDIPCONST RectF *	rect,
		GDIPCONST GpStringFormat *	format,
		int	ignore_empty_clip,
		gdip_format_string_callback	callback,
		void *	user_data
	)

Definition at line 5201 of file graphics.c.

{
    WCHAR* stringdup;
    int sum = 0, height = 0, fit, fitcpy, i, j, lret, nwidth,
        nheight, lineend, lineno = 0;
    RectF bounds;
    StringAlignment halign;
    GpStatus stat = Ok;
    SIZE size;
    HotkeyPrefix hkprefix;
    INT *hotkeyprefix_offsets=NULL;
    INT hotkeyprefix_count=0;
    INT hotkeyprefix_pos=0, hotkeyprefix_end_pos=0;
    BOOL seen_prefix = FALSE;
 
    if(length == -1) length = lstrlenW(string);
 
    stringdup = heap_alloc_zero((length + 1) * sizeof(WCHAR));
    if(!stringdup) return OutOfMemory;
 
    if (!format)
        format = &default_drawstring_format;
 
    nwidth = rect->Width;
    nheight = rect->Height;
    if (ignore_empty_clip)
    {
        if (!nwidth) nwidth = INT_MAX;
        if (!nheight) nheight = INT_MAX;
    }
 
    hkprefix = format->hkprefix;
 
    if (hkprefix == HotkeyPrefixShow)
    {
        for (i=0; i<length; i++)
        {
            if (string[i] == '&')
                hotkeyprefix_count++;
        }
    }
 
    if (hotkeyprefix_count)
        hotkeyprefix_offsets = heap_alloc_zero(sizeof(INT) * hotkeyprefix_count);
 
    hotkeyprefix_count = 0;
 
    for(i = 0, j = 0; i < length; i++){
        /* FIXME: This makes the indexes passed to callback inaccurate. */
        if(!isprintW(string[i]) && (string[i] != '\n'))
            continue;
 
        /* FIXME: tabs should be handled using tabstops from stringformat */
        if (string[i] == '\t')
            continue;
 
        if (seen_prefix && hkprefix == HotkeyPrefixShow && string[i] != '&')
            hotkeyprefix_offsets[hotkeyprefix_count++] = j;
        else if (!seen_prefix && hkprefix != HotkeyPrefixNone && string[i] == '&')
        {
            seen_prefix = TRUE;
            continue;
        }
 
        seen_prefix = FALSE;
 
        stringdup[j] = string[i];
        j++;
    }
 
    length = j;
 
    halign = format->align;
 
    while(sum < length){
        GetTextExtentExPointW(hdc, stringdup + sum, length - sum,
                              nwidth, &fit, NULL, &size);
        fitcpy = fit;
 
        if(fit == 0)
            break;
 
        for(lret = 0; lret < fit; lret++)
            if(*(stringdup + sum + lret) == '\n')
                break;
 
        /* Line break code (may look strange, but it imitates windows). */
        if(lret < fit)
            lineend = fit = lret;    /* this is not an off-by-one error */
        else if(fit < (length - sum)){
            if(*(stringdup + sum + fit) == ' ')
                while(*(stringdup + sum + fit) == ' ')
                    fit++;
            else
                while(*(stringdup + sum + fit - 1) != ' '){
                    fit--;
 
                    if(*(stringdup + sum + fit) == '\t')
                        break;
 
                    if(fit == 0){
                        fit = fitcpy;
                        break;
                    }
                }
            lineend = fit;
            while(*(stringdup + sum + lineend - 1) == ' ' ||
                  *(stringdup + sum + lineend - 1) == '\t')
                lineend--;
        }
        else
            lineend = fit;
 
        GetTextExtentExPointW(hdc, stringdup + sum, lineend,
                              nwidth, &j, NULL, &size);
 
        bounds.Width = size.cx;
 
        if(height + size.cy > nheight)
        {
            if (format->attr & StringFormatFlagsLineLimit)
                break;
            bounds.Height = nheight - (height + size.cy);
        }
        else
            bounds.Height = size.cy;
 
        bounds.Y = rect->Y + height;
 
        switch (halign)
        {
        case StringAlignmentNear:
        default:
            bounds.X = rect->X;
            break;
        case StringAlignmentCenter:
            bounds.X = rect->X + (rect->Width/2) - (bounds.Width/2);
            break;
        case StringAlignmentFar:
            bounds.X = rect->X + rect->Width - bounds.Width;
            break;
        }
 
        for (hotkeyprefix_end_pos=hotkeyprefix_pos; hotkeyprefix_end_pos<hotkeyprefix_count; hotkeyprefix_end_pos++)
            if (hotkeyprefix_offsets[hotkeyprefix_end_pos] >= sum + lineend)
                break;
 
        stat = callback(hdc, stringdup, sum, lineend,
            font, rect, format, lineno, &bounds,
            &hotkeyprefix_offsets[hotkeyprefix_pos],
            hotkeyprefix_end_pos-hotkeyprefix_pos, user_data);
 
        if (stat != Ok)
            break;
 
        sum += fit + (lret < fitcpy ? 1 : 0);
        height += size.cy;
        lineno++;
 
        hotkeyprefix_pos = hotkeyprefix_end_pos;
 
        if(height > nheight)
            break;
 
        /* Stop if this was a linewrap (but not if it was a linebreak). */
        if ((lret == fitcpy) && (format->attr & StringFormatFlagsNoWrap))
            break;
    }
 
    heap_free(stringdup);
    heap_free(hotkeyprefix_offsets);
 
    return stat;
}

Referenced by GdipAddPathString(), GdipDrawString(), GdipMeasureCharacterRanges(), and GdipMeasureString().

gdip_round()

static INT gdip_round ( REAL  x )

inlinestatic

Definition at line 127 of file gdiplus_private.h.

{
    return (INT) floorf(x + 0.5);
}

Referenced by calc_curve_bezier_endp(), GDI32_GdipDrawDriverString(), GdipCloneBitmapArea(), GdipGetLineRectI(), GdipGetLogFontW(), GdipGetMetafileHeaderFromEmf(), GdipGetMetafileHeaderFromMetafile(), GdipGetPathGradientCenterPointI(), GdipGetPathGradientRectI(), GdipGetPathPointsI(), GdipGetPathWorldBoundsI(), GdipGetRegionBoundsI(), GdipGetVisibleClipBoundsI(), GdipIsVisiblePathPoint(), GdipIsVisibleRegionPoint(), GdipTransformMatrixPointsI(), GdipTransformPointsI(), GdipVectorTransformMatrixPointsI(), get_bitmap_sample_size(), get_font_hfont(), is_integer_path(), prepare_dc(), round_color_matrix(), round_points(), SOFTWARE_GdipDrawThinPath(), and unstretch_angle().

gdip_transform_points()

GpStatus gdip_transform_points	(	GpGraphics *	graphics,
		GpCoordinateSpace	dst_space,
		GpCoordinateSpace	src_space,
		GpPointF *	points,
		INT	count
	)

Definition at line 6948 of file graphics.c.

{
    GpMatrix matrix;
    GpStatus stat;
 
    stat = get_graphics_transform(graphics, dst_space, src_space, &matrix);
    if (stat != Ok) return stat;
 
    return GdipTransformMatrixPoints(&matrix, points, count);
}

Referenced by brush_fill_pixels(), draw_cap(), draw_poly(), GDI32_GdipDrawDriverString(), GdipDrawImagePointsRect(), GdipDrawString(), GdipMeasureCharacterRanges(), GdipMeasureDriverString(), GdipMeasureString(), GdipTransformPoints(), get_font_hfont(), get_graphics_bounds(), prepare_dc(), SOFTWARE_GdipDrawDriverString(), and SOFTWARE_GdipDrawPath().

gdiplus_atan2()

REAL gdiplus_atan2	(	REAL	dy,
		REAL	dx
	)

Definition at line 304 of file gdiplus.c.

{
    if((dx == 0.0) && (dy != 0.0))
        return dy > 0.0 ? M_PI_2 : -M_PI_2;
 
    return atan2(dy, dx);
}

Referenced by draw_cap(), GdipGetLogFontW(), get_font_hfont(), shorten_line_percent(), and unstretch_angle().

get_graphics_transform()

GpStatus get_graphics_transform	(	GpGraphics *	graphics,
		GpCoordinateSpace	dst_space,
		GpCoordinateSpace	src_space,
		GpMatrix *	matrix
	)

Definition at line 6871 of file graphics.c.

{
    GpStatus stat = Ok;
    REAL scale_x, scale_y;
 
    GdipSetMatrixElements(matrix, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 
    if (dst_space != src_space)
    {
        scale_x = units_to_pixels(1.0, graphics->unit, graphics->xres);
        scale_y = units_to_pixels(1.0, graphics->unit, graphics->yres);
 
        if(graphics->unit != UnitDisplay)
        {
            scale_x *= graphics->scale;
            scale_y *= graphics->scale;
        }
 
        if (dst_space < src_space)
        {
            /* transform towards world space */
            switch ((int)src_space)
            {
            case WineCoordinateSpaceGdiDevice:
            {
                GpMatrix gdixform;
                gdixform = graphics->gdi_transform;
                stat = GdipInvertMatrix(&gdixform);
                if (stat != Ok)
                    break;
                GdipMultiplyMatrix(matrix, &gdixform, MatrixOrderAppend);
                if (dst_space == CoordinateSpaceDevice)
                    break;
                /* else fall-through */
            }
            case CoordinateSpaceDevice:
                GdipScaleMatrix(matrix, 1.0/scale_x, 1.0/scale_y, MatrixOrderAppend);
                if (dst_space == CoordinateSpacePage)
                    break;
                /* else fall-through */
            case CoordinateSpacePage:
            {
                GpMatrix inverted_transform = graphics->worldtrans;
                stat = GdipInvertMatrix(&inverted_transform);
                if (stat == Ok)
                    GdipMultiplyMatrix(matrix, &inverted_transform, MatrixOrderAppend);
                break;
            }
            }
        }
        else
        {
            /* transform towards device space */
            switch ((int)src_space)
            {
            case CoordinateSpaceWorld:
                GdipMultiplyMatrix(matrix, &graphics->worldtrans, MatrixOrderAppend);
                if (dst_space == CoordinateSpacePage)
                    break;
                /* else fall-through */
            case CoordinateSpacePage:
                GdipScaleMatrix(matrix, scale_x, scale_y, MatrixOrderAppend);
                if (dst_space == CoordinateSpaceDevice)
                    break;
                /* else fall-through */
            case CoordinateSpaceDevice:
            {
                GdipMultiplyMatrix(matrix, &graphics->gdi_transform, MatrixOrderAppend);
                break;
            }
            }
        }
    }
    return stat;
}

Referenced by brush_fill_pixels(), gdip_transform_points(), GdipGetClip(), GdipGetVisibleClipBounds(), GdipIsOutlineVisiblePathPoint(), GdipSetClipHrgn(), GdipSetClipPath(), GdipSetClipRect(), GdipSetClipRegion(), get_clip_hrgn(), metafile_set_clip_region(), SOFTWARE_GdipDrawPath(), SOFTWARE_GdipDrawThinPath(), and SOFTWARE_GdipFillRegion().

get_hatch_data()

GpStatus get_hatch_data	(	GpHatchStyle	hatchstyle,
		const char **	result
	)

Definition at line 262 of file brush.c.

{
    if (hatchstyle < ARRAY_SIZE(HatchBrushes))
    {
        *result = HatchBrushes[hatchstyle];
        return Ok;
    }
    else
        return NotImplemented;
}

Referenced by brush_fill_pixels(), and create_hatch_bitmap().

get_log_fontW()

void get_log_fontW	(	const GpFont *	font,
		GpGraphics *	graphics,
		LOGFONTW *	lf
	)

Definition at line 2305 of file graphics.c.

{
    REAL height;
 
    if (font->unit == UnitPixel)
    {
        height = units_to_pixels(font->emSize, graphics->unit, graphics->yres);
    }
    else
    {
        if (graphics->unit == UnitDisplay || graphics->unit == UnitPixel)
            height = units_to_pixels(font->emSize, font->unit, graphics->xres);
        else
            height = units_to_pixels(font->emSize, font->unit, graphics->yres);
    }
 
    lf->lfHeight = -(height + 0.5);
    lf->lfWidth = 0;
    lf->lfEscapement = 0;
    lf->lfOrientation = 0;
    lf->lfWeight = font->otm.otmTextMetrics.tmWeight;
    lf->lfItalic = font->otm.otmTextMetrics.tmItalic ? 1 : 0;
    lf->lfUnderline = font->otm.otmTextMetrics.tmUnderlined ? 1 : 0;
    lf->lfStrikeOut = font->otm.otmTextMetrics.tmStruckOut ? 1 : 0;
    lf->lfCharSet = font->otm.otmTextMetrics.tmCharSet;
    lf->lfOutPrecision = OUT_DEFAULT_PRECIS;
    lf->lfClipPrecision = CLIP_DEFAULT_PRECIS;
    lf->lfQuality = DEFAULT_QUALITY;
    lf->lfPitchAndFamily = 0;
    strcpyW(lf->lfFaceName, font->family->FamilyName);
}

Referenced by GdipAddPathString(), and get_font_hfont().

graphics_from_image()

GpStatus graphics_from_image	(	GpImage *	image,
		GpGraphics **	graphics
	)

Definition at line 2484 of file graphics.c.

{
    GpStatus retval;
 
    *graphics = heap_alloc_zero(sizeof(GpGraphics));
    if(!*graphics)  return OutOfMemory;
 
    GdipSetMatrixElements(&(*graphics)->worldtrans, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
    GdipSetMatrixElements(&(*graphics)->gdi_transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 
    if((retval = GdipCreateRegion(&(*graphics)->clip)) != Ok){
        heap_free(*graphics);
        return retval;
    }
 
    (*graphics)->hdc = NULL;
    (*graphics)->hwnd = NULL;
    (*graphics)->owndc = FALSE;
    (*graphics)->image = image;
    /* We have to store the image type here because the image may be freed
     * before GdipDeleteGraphics is called, and metafiles need special treatment. */
    (*graphics)->image_type = image->type;
    (*graphics)->smoothing = SmoothingModeDefault;
    (*graphics)->compqual = CompositingQualityDefault;
    (*graphics)->interpolation = InterpolationModeBilinear;
    (*graphics)->pixeloffset = PixelOffsetModeDefault;
    (*graphics)->compmode = CompositingModeSourceOver;
    (*graphics)->unit = UnitDisplay;
    (*graphics)->scale = 1.0;
    (*graphics)->xres = image->xres;
    (*graphics)->yres = image->yres;
    (*graphics)->busy = FALSE;
    (*graphics)->textcontrast = 4;
    list_init(&(*graphics)->containers);
#ifdef __REACTOS__
    (*graphics)->contid = GDIP_GET_NEW_CONTID_FOR(*graphics);
#else
    (*graphics)->contid = 0;
#endif
 
    TRACE("<-- %p\n", *graphics);
 
    return Ok;
}

Referenced by GdipGetImageGraphicsContext(), and METAFILE_GetGraphicsContext().

hresult_to_status()

GpStatus hresult_to_status

(

HRESULT

res

)

Definition at line 312 of file gdiplus.c.

{
    switch(res){
        case S_OK:
            return Ok;
        case E_OUTOFMEMORY:
            return OutOfMemory;
        case E_INVALIDARG:
            return InvalidParameter;
        default:
            return GenericError;
    }
}

Referenced by create_optimal_palette(), decode_frame_wic(), decode_image_gif(), decode_image_png(), encode_image_wic(), GdipCreateStreamOnFile(), GdipGetAllPropertyItems(), GdipGetPropertyIdList(), GdipGetPropertySize(), GdipLoadImageFromStream(), get_decoder_info(), initialize_decoder_wic(), load_emf(), load_wmf(), METAFILE_CreateCompressedImageStream(), METAFILE_FillEmfPlusBitmap(), METAFILE_GraphicsDeleted(), and select_frame_gif().

image_lock()

static BOOL image_lock ( GpImage *  image, BOOL *  unlock  )

inlinestatic

Definition at line 592 of file gdiplus_private.h.

{
    LONG tid = GetCurrentThreadId(), owner_tid;
    owner_tid = InterlockedCompareExchange(&image->busy, tid, 0);
    *unlock = !owner_tid;
    return !owner_tid || owner_tid==tid;
}

Referenced by GdipBitmapLockBits(), GdipBitmapUnlockBits(), GdipCreateHBITMAPFromBitmap(), GdipImageRotateFlip(), and GdipImageSelectActiveFrame().

image_unlock()

static void image_unlock ( GpImage *  image, BOOL  unlock  )

inlinestatic

Definition at line 600 of file gdiplus_private.h.

{
    if (unlock) image->busy = 0;
}

Referenced by GdipBitmapLockBits(), GdipBitmapUnlockBits(), GdipCreateHBITMAPFromBitmap(), GdipImageRotateFlip(), and GdipImageSelectActiveFrame().

init_generic_string_formats()

void init_generic_string_formats

(

void

)

Definition at line 56 of file stringformat.c.

{
    memcpy(&generic_default_format, &default_drawstring_format, sizeof(generic_default_format));
 
    memcpy(&generic_typographic_format, &default_drawstring_format, sizeof(generic_typographic_format));
    generic_typographic_format.attr = StringFormatFlagsNoFitBlackBox | StringFormatFlagsLineLimit |
        StringFormatFlagsNoClip;
    generic_typographic_format.trimming = StringTrimmingNone;
    generic_typographic_format.generic_typographic = TRUE;
}

Referenced by DllMain().

init_memory_buffer()

static void init_memory_buffer ( struct memory_buffer *  mbuf, const BYTE *  buffer, INT  size  )

inlinestatic

Definition at line 561 of file gdiplus_private.h.

{
    mbuf->buffer = buffer;
    mbuf->size = size;
    mbuf->pos = 0;
}

Referenced by GdipCreateRegionRgnData(), and metafile_deserialize_region().

lengthen_path()

BOOL lengthen_path	(	GpPath *	path,
		INT	len
	)

Definition at line 405 of file gdiplus.c.

{
    /* initial allocation */
    if(path->datalen == 0){
        path->datalen = len * 2;
 
        path->pathdata.Points = heap_alloc_zero(path->datalen * sizeof(PointF));
        if(!path->pathdata.Points)   return FALSE;
 
        path->pathdata.Types = heap_alloc_zero(path->datalen);
        if(!path->pathdata.Types){
            heap_free(path->pathdata.Points);
            return FALSE;
        }
    }
    /* reallocation, double size of arrays */
    else if(path->datalen - path->pathdata.Count < len){
        while(path->datalen - path->pathdata.Count < len)
            path->datalen *= 2;
 
        path->pathdata.Points = heap_realloc(path->pathdata.Points, path->datalen * sizeof(PointF));
        if(!path->pathdata.Points)  return FALSE;
 
        path->pathdata.Types = heap_realloc(path->pathdata.Types, path->datalen);
        if(!path->pathdata.Types)   return FALSE;
    }
 
    return TRUE;
}

Referenced by format_string_callback(), GdipAddPathArc(), GdipAddPathBezier(), GdipAddPathBeziers(), GdipAddPathEllipse(), GdipAddPathLine(), GdipAddPathLine2(), GdipAddPathPath(), GdipAddPathPie(), GdipAddPathPolygon(), GdipFlattenPath(), GdipPathIterNextMarkerPath(), GdipPathIterNextSubpathPath(), GdipWidenPath(), and read_element().

METAFILE_AddSimpleProperty()

GpStatus METAFILE_AddSimpleProperty	(	GpMetafile *	metafile,
		SHORT	prop,
		SHORT	val
	)

Definition at line 4269 of file metafile.c.

{
    EmfPlusRecordHeader *record;
    GpStatus stat;
 
    if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
        return Ok;
 
    stat = METAFILE_AllocateRecord(metafile, sizeof(*record), (void**)&record);
    if (stat != Ok) return stat;
 
    record->Type = prop;
    record->Flags = val;
 
    METAFILE_WriteRecords(metafile);
    return Ok;
}

Referenced by GdipSetCompositingMode(), GdipSetCompositingQuality(), GdipSetInterpolationMode(), GdipSetPixelOffsetMode(), GdipSetSmoothingMode(), and GdipSetTextRenderingHint().

METAFILE_BeginContainer()

GpStatus METAFILE_BeginContainer	(	GpMetafile *	metafile,
		GDIPCONST GpRectF *	dstrect,
		GDIPCONST GpRectF *	srcrect,
		GpUnit	unit,
		DWORD	StackIndex
	)

Definition at line 1376 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusBeginContainer *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile, sizeof(*record), (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Header.Type = EmfPlusRecordTypeBeginContainer;
        record->Header.Flags = unit & 0xff;
        record->DestRect = *dstrect;
        record->SrcRect = *srcrect;
        record->StackIndex = StackIndex;
 
        METAFILE_WriteRecords(metafile);
    }
 
    return Ok;
}

Referenced by GdipBeginContainer().

METAFILE_BeginContainerNoParams()

GpStatus METAFILE_BeginContainerNoParams	(	GpMetafile *	metafile,
		DWORD	StackIndex
	)

Definition at line 1400 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusContainerRecord *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile,
            sizeof(EmfPlusContainerRecord),
            (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Header.Type = EmfPlusRecordTypeBeginContainerNoParams;
        record->Header.Flags = 0;
        record->StackIndex = StackIndex;
 
        METAFILE_WriteRecords(metafile);
    }
 
    return Ok;
}

Referenced by begin_container().

METAFILE_DrawImagePointsRect()

GpStatus METAFILE_DrawImagePointsRect	(	GpMetafile *	metafile,
		GpImage *	image,
		GDIPCONST GpPointF *	points,
		INT	count,
		REAL	srcx,
		REAL	srcy,
		REAL	srcwidth,
		REAL	srcheight,
		GpUnit	srcUnit,
		GDIPCONST GpImageAttributes *	imageAttributes,
		DrawImageAbort	callback,
		VOID *	callbackData
	)

Definition at line 4190 of file metafile.c.

{
    EmfPlusDrawImagePoints *draw_image_record;
    DWORD image_id, attributes_id;
    GpStatus stat;
 
    if (count != 3) return InvalidParameter;
 
    if (metafile->metafile_type == MetafileTypeEmf)
    {
        FIXME("MetafileTypeEmf metafiles not supported\n");
        return NotImplemented;
    }
    else
        FIXME("semi-stub\n");
 
    if (!imageAttributes)
    {
        stat = METAFILE_AddImageObject(metafile, image, &image_id);
    }
    else if (image->type == ImageTypeBitmap)
    {
        INT width = ((GpBitmap*)image)->width;
        INT height = ((GpBitmap*)image)->height;
        GpGraphics *graphics;
        GpBitmap *bitmap;
 
        stat = GdipCreateBitmapFromScan0(width, height,
                0, PixelFormat32bppARGB, NULL, &bitmap);
        if (stat != Ok) return stat;
 
        stat = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
        if (stat != Ok)
        {
            GdipDisposeImage((GpImage*)bitmap);
            return stat;
        }
 
        stat = GdipDrawImageRectRectI(graphics, image, 0, 0, width, height,
                0, 0, width, height, UnitPixel, imageAttributes, NULL, NULL);
        GdipDeleteGraphics(graphics);
        if (stat != Ok)
        {
            GdipDisposeImage((GpImage*)bitmap);
            return stat;
        }
 
        stat = METAFILE_AddImageObject(metafile, (GpImage*)bitmap, &image_id);
        GdipDisposeImage((GpImage*)bitmap);
    }
    else
    {
        FIXME("imageAttributes not supported (image type %d)\n", image->type);
        return NotImplemented;
    }
    if (stat != Ok) return stat;
 
    stat = METAFILE_AddImageAttributesObject(metafile, imageAttributes, &attributes_id);
    if (stat != Ok) return stat;
 
    stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusDrawImagePoints), (void**)&draw_image_record);
    if (stat != Ok) return stat;
    draw_image_record->Header.Type = EmfPlusRecordTypeDrawImagePoints;
    draw_image_record->Header.Flags = image_id;
    draw_image_record->ImageAttributesID = attributes_id;
    draw_image_record->SrcUnit = UnitPixel;
    draw_image_record->SrcRect.X = units_to_pixels(srcx, srcUnit, metafile->image.xres);
    draw_image_record->SrcRect.Y = units_to_pixels(srcy, srcUnit, metafile->image.yres);
    draw_image_record->SrcRect.Width = units_to_pixels(srcwidth, srcUnit, metafile->image.xres);
    draw_image_record->SrcRect.Height = units_to_pixels(srcheight, srcUnit, metafile->image.yres);
    draw_image_record->count = 3;
    memcpy(draw_image_record->PointData.pointsF, points, 3 * sizeof(*points));
    METAFILE_WriteRecords(metafile);
    return Ok;
}

Referenced by GdipDrawImagePointsRect().

METAFILE_DrawPath()

GpStatus METAFILE_DrawPath	(	GpMetafile *	metafile,
		GpPen *	pen,
		GpPath *	path
	)

Definition at line 4476 of file metafile.c.

{
    EmfPlusDrawPath *draw_path_record;
    DWORD path_id;
    DWORD pen_id;
    GpStatus stat;
 
    if (metafile->metafile_type == MetafileTypeEmf)
    {
        FIXME("stub!\n");
        return NotImplemented;
    }
 
    stat = METAFILE_AddPenObject(metafile, pen, &pen_id);
    if (stat != Ok) return stat;
 
    stat = METAFILE_AddPathObject(metafile, path, &path_id);
    if (stat != Ok) return stat;
 
    stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusDrawPath), (void**)&draw_path_record);
    if (stat != Ok) return stat;
    draw_path_record->Header.Type = EmfPlusRecordTypeDrawPath;
    draw_path_record->Header.Flags = path_id;
    draw_path_record->PenId = pen_id;
 
    METAFILE_WriteRecords(metafile);
    return Ok;
}

Referenced by GdipDrawPath().

METAFILE_EndContainer()

GpStatus METAFILE_EndContainer	(	GpMetafile *	metafile,
		DWORD	StackIndex
	)

Definition at line 1423 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusContainerRecord *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile,
            sizeof(EmfPlusContainerRecord),
            (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Header.Type = EmfPlusRecordTypeEndContainer;
        record->Header.Flags = 0;
        record->StackIndex = StackIndex;
 
        METAFILE_WriteRecords(metafile);
    }
 
    return Ok;
}

Referenced by end_container().

METAFILE_FillPath()

GpStatus METAFILE_FillPath	(	GpMetafile *	metafile,
		GpBrush *	brush,
		GpPath *	path
	)

Definition at line 4505 of file metafile.c.

{
    EmfPlusFillPath *fill_path_record;
    DWORD brush_id = -1, path_id;
    BOOL inline_color;
    GpStatus stat;
 
    if (metafile->metafile_type == MetafileTypeEmf)
    {
        FIXME("stub!\n");
        return NotImplemented;
    }
 
    inline_color = brush->bt == BrushTypeSolidColor;
    if (!inline_color)
    {
        stat = METAFILE_AddBrushObject(metafile, brush, &brush_id);
        if (stat != Ok) return stat;
    }
 
    stat = METAFILE_AddPathObject(metafile, path, &path_id);
    if (stat != Ok) return stat;
 
    stat = METAFILE_AllocateRecord(metafile,
            sizeof(EmfPlusFillPath), (void**)&fill_path_record);
    if (stat != Ok) return stat;
    fill_path_record->Header.Type = EmfPlusRecordTypeFillPath;
    if (inline_color)
    {
        fill_path_record->Header.Flags = 0x8000 | path_id;
        fill_path_record->data.Color = ((GpSolidFill *)brush)->color;
    }
    else
    {
        fill_path_record->Header.Flags = path_id;
        fill_path_record->data.BrushId = brush_id;
    }
 
    METAFILE_WriteRecords(metafile);
    return Ok;
}

Referenced by GdipFillPath().

METAFILE_FillRectangles()

GpStatus METAFILE_FillRectangles	(	GpMetafile *	metafile,
		GpBrush *	brush,
		GDIPCONST GpRectF *	rects,
		INT	count
	)

Definition at line 1051 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusFillRects *record;
        GpStatus stat;
        BOOL integer_rects = TRUE;
        int i;
        DWORD brushid;
        int flags = 0;
 
        if (brush->bt == BrushTypeSolidColor)
        {
            flags |= 0x8000;
            brushid = ((GpSolidFill*)brush)->color;
        }
        else
        {
            stat = METAFILE_AddBrushObject(metafile, brush, &brushid);
            if (stat != Ok)
                return stat;
        }
 
        for (i=0; i<count; i++)
        {
            if (!is_integer_rect(&rects[i]))
            {
                integer_rects = FALSE;
                break;
            }
        }
 
        if (integer_rects)
            flags |= 0x4000;
 
        stat = METAFILE_AllocateRecord(metafile,
            sizeof(EmfPlusFillRects) + count * (integer_rects ? sizeof(EmfPlusRect) : sizeof(GpRectF)),
            (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Header.Type = EmfPlusRecordTypeFillRects;
        record->Header.Flags = flags;
        record->BrushID = brushid;
        record->Count = count;
 
        if (integer_rects)
        {
            EmfPlusRect *record_rects = (EmfPlusRect*)(record+1);
            for (i=0; i<count; i++)
            {
                record_rects[i].X = (SHORT)rects[i].X;
                record_rects[i].Y = (SHORT)rects[i].Y;
                record_rects[i].Width = (SHORT)rects[i].Width;
                record_rects[i].Height = (SHORT)rects[i].Height;
            }
        }
        else
            memcpy(record+1, rects, sizeof(GpRectF) * count);
 
        METAFILE_WriteRecords(metafile);
    }
 
    if (metafile->auto_frame)
    {
        GpPointF corners[4];
        int i;
 
        for (i=0; i<count; i++)
        {
            corners[0].X = rects[i].X;
            corners[0].Y = rects[i].Y;
            corners[1].X = rects[i].X + rects[i].Width;
            corners[1].Y = rects[i].Y;
            corners[2].X = rects[i].X;
            corners[2].Y = rects[i].Y + rects[i].Height;
            corners[3].X = rects[i].X + rects[i].Width;
            corners[3].Y = rects[i].Y + rects[i].Height;
 
            GdipTransformPoints(metafile->record_graphics, CoordinateSpaceDevice,
                CoordinateSpaceWorld, corners, 4);
 
            METAFILE_AdjustFrame(metafile, corners, 4);
        }
    }
 
    return Ok;
}

Referenced by GdipFillRectangles().

METAFILE_Free()

void METAFILE_Free

(

GpMetafile *

metafile

)

Definition at line 590 of file metafile.c.

{
    unsigned int i;
 
    heap_free(metafile->comment_data);
    DeleteEnhMetaFile(CloseEnhMetaFile(metafile->record_dc));
    if (!metafile->preserve_hemf)
        DeleteEnhMetaFile(metafile->hemf);
    if (metafile->record_graphics)
    {
        WARN("metafile closed while recording\n");
        /* not sure what to do here; for now just prevent the graphics from functioning or using this object */
        metafile->record_graphics->image = NULL;
        metafile->record_graphics->busy = TRUE;
    }
 
    if (metafile->record_stream)
        IStream_Release(metafile->record_stream);
 
    for (i = 0; i < ARRAY_SIZE(metafile->objtable); i++)
        metafile_free_object_table_entry(metafile, i);
}

Referenced by free_image_data().

METAFILE_GetDC()

GpStatus METAFILE_GetDC	(	GpMetafile *	metafile,
		HDC *	hdc
	)

Definition at line 927 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusRecordHeader *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusRecordHeader), (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Type = EmfPlusRecordTypeGetDC;
        record->Flags = 0;
 
        METAFILE_WriteRecords(metafile);
    }
 
    *hdc = metafile->record_dc;
 
    return Ok;
}

Referenced by GdipGetDC().

METAFILE_GetGraphicsContext()

GpStatus METAFILE_GetGraphicsContext	(	GpMetafile *	metafile,
		GpGraphics **	result
	)

Definition at line 908 of file metafile.c.

{
    GpStatus stat;
 
    if (!metafile->record_dc || metafile->record_graphics)
        return InvalidParameter;
 
    stat = graphics_from_image((GpImage*)metafile, &metafile->record_graphics);
 
    if (stat == Ok)
    {
        *result = metafile->record_graphics;
        metafile->record_graphics->xres = 96.0;
        metafile->record_graphics->yres = 96.0;
    }
 
    return stat;
}

Referenced by GdipGetImageGraphicsContext().

METAFILE_GraphicsClear()

GpStatus METAFILE_GraphicsClear	(	GpMetafile *	metafile,
		ARGB	color
	)

Definition at line 949 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusClear *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusClear), (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Header.Type = EmfPlusRecordTypeClear;
        record->Header.Flags = 0;
        record->Color = color;
 
        METAFILE_WriteRecords(metafile);
    }
 
    return Ok;
}

Referenced by GdipGraphicsClear().

METAFILE_GraphicsDeleted()

GpStatus METAFILE_GraphicsDeleted

(

GpMetafile *

metafile

)

Definition at line 1500 of file metafile.c.

{
    GpStatus stat;
 
    stat = METAFILE_WriteEndOfFile(metafile);
    metafile->record_graphics = NULL;
 
    metafile->hemf = CloseEnhMetaFile(metafile->record_dc);
    metafile->record_dc = NULL;
 
    heap_free(metafile->comment_data);
    metafile->comment_data = NULL;
    metafile->comment_data_size = 0;
 
    if (stat == Ok)
    {
        MetafileHeader header;
 
        stat = GdipGetMetafileHeaderFromEmf(metafile->hemf, &header);
        if (stat == Ok && metafile->auto_frame &&
            metafile->auto_frame_max.X >= metafile->auto_frame_min.X)
        {
            RECTL bounds_rc, gdi_bounds_rc;
            REAL x_scale = 2540.0 / header.DpiX;
            REAL y_scale = 2540.0 / header.DpiY;
            BYTE* buffer;
            UINT buffer_size;
 
            bounds_rc.left = floorf(metafile->auto_frame_min.X * x_scale);
            bounds_rc.top = floorf(metafile->auto_frame_min.Y * y_scale);
            bounds_rc.right = ceilf(metafile->auto_frame_max.X * x_scale);
            bounds_rc.bottom = ceilf(metafile->auto_frame_max.Y * y_scale);
 
            gdi_bounds_rc = header.u.EmfHeader.rclBounds;
            if (gdi_bounds_rc.right > gdi_bounds_rc.left && gdi_bounds_rc.bottom > gdi_bounds_rc.top)
            {
                bounds_rc.left = min(bounds_rc.left, gdi_bounds_rc.left);
                bounds_rc.top = min(bounds_rc.top, gdi_bounds_rc.top);
                bounds_rc.right = max(bounds_rc.right, gdi_bounds_rc.right);
                bounds_rc.bottom = max(bounds_rc.bottom, gdi_bounds_rc.bottom);
            }
 
            buffer_size = GetEnhMetaFileBits(metafile->hemf, 0, NULL);
            buffer = heap_alloc(buffer_size);
            if (buffer)
            {
                HENHMETAFILE new_hemf;
 
                GetEnhMetaFileBits(metafile->hemf, buffer_size, buffer);
 
                ((ENHMETAHEADER*)buffer)->rclFrame = bounds_rc;
 
                new_hemf = SetEnhMetaFileBits(buffer_size, buffer);
 
                if (new_hemf)
                {
                    DeleteEnhMetaFile(metafile->hemf);
                    metafile->hemf = new_hemf;
                }
                else
                    stat = OutOfMemory;
 
                heap_free(buffer);
            }
            else
                stat = OutOfMemory;
 
            if (stat == Ok)
                stat = GdipGetMetafileHeaderFromEmf(metafile->hemf, &header);
        }
        if (stat == Ok)
        {
            metafile->bounds.X = header.X;
            metafile->bounds.Y = header.Y;
            metafile->bounds.Width = header.Width;
            metafile->bounds.Height = header.Height;
        }
    }
 
    if (stat == Ok && metafile->record_stream)
    {
        BYTE *buffer;
        UINT buffer_size;
 
        buffer_size = GetEnhMetaFileBits(metafile->hemf, 0, NULL);
 
        buffer = heap_alloc(buffer_size);
        if (buffer)
        {
            HRESULT hr;
 
            GetEnhMetaFileBits(metafile->hemf, buffer_size, buffer);
 
            hr = IStream_Write(metafile->record_stream, buffer, buffer_size, NULL);
 
            if (FAILED(hr))
                stat = hresult_to_status(hr);
 
            heap_free(buffer);
        }
        else
            stat = OutOfMemory;
    }
 
    if (metafile->record_stream)
    {
        IStream_Release(metafile->record_stream);
        metafile->record_stream = NULL;
    }
 
    return stat;
}

Referenced by GdipDeleteGraphics().

METAFILE_MultiplyWorldTransform()

GpStatus METAFILE_MultiplyWorldTransform	(	GpMetafile *	metafile,
		GDIPCONST GpMatrix *	matrix,
		MatrixOrder	order
	)

Definition at line 1284 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusMultiplyWorldTransform *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile,
            sizeof(EmfPlusMultiplyWorldTransform),
            (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Header.Type = EmfPlusRecordTypeMultiplyWorldTransform;
        record->Header.Flags = (order == MatrixOrderAppend ? 0x2000 : 0);
        memcpy(record->MatrixData, matrix->matrix, sizeof(record->MatrixData));
 
        METAFILE_WriteRecords(metafile);
    }
 
    return Ok;
}

Referenced by GdipMultiplyWorldTransform().

METAFILE_ReleaseDC()

GpStatus METAFILE_ReleaseDC	(	GpMetafile *	metafile,
		HDC	hdc
	)

Definition at line 1492 of file metafile.c.

{
    if (hdc != metafile->record_dc)
        return InvalidParameter;
 
    return Ok;
}

Referenced by GdipReleaseDC().

METAFILE_ResetWorldTransform()

GpStatus METAFILE_ResetWorldTransform

(

GpMetafile *

metafile

)

Definition at line 1354 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusRecordHeader *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile,
            sizeof(EmfPlusRecordHeader),
            (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Type = EmfPlusRecordTypeResetWorldTransform;
        record->Flags = 0;
 
        METAFILE_WriteRecords(metafile);
    }
 
    return Ok;
}

Referenced by GdipResetWorldTransform().

METAFILE_RestoreGraphics()

GpStatus METAFILE_RestoreGraphics	(	GpMetafile *	metafile,
		DWORD	StackIndex
	)

Definition at line 1469 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusContainerRecord *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile,
            sizeof(EmfPlusContainerRecord),
            (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Header.Type = EmfPlusRecordTypeRestore;
        record->Header.Flags = 0;
        record->StackIndex = StackIndex;
 
        METAFILE_WriteRecords(metafile);
    }
 
    return Ok;
}

Referenced by end_container().

METAFILE_RotateWorldTransform()

GpStatus METAFILE_RotateWorldTransform	(	GpMetafile *	metafile,
		REAL	angle,
		MatrixOrder	order
	)

Definition at line 1307 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusRotateWorldTransform *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile,
            sizeof(EmfPlusRotateWorldTransform),
            (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Header.Type = EmfPlusRecordTypeRotateWorldTransform;
        record->Header.Flags = (order == MatrixOrderAppend ? 0x2000 : 0);
        record->Angle = angle;
 
        METAFILE_WriteRecords(metafile);
    }
 
    return Ok;
}

Referenced by GdipRotateWorldTransform().

METAFILE_SaveGraphics()

GpStatus METAFILE_SaveGraphics	(	GpMetafile *	metafile,
		DWORD	StackIndex
	)

Definition at line 1446 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusContainerRecord *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile,
            sizeof(EmfPlusContainerRecord),
            (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Header.Type = EmfPlusRecordTypeSave;
        record->Header.Flags = 0;
        record->StackIndex = StackIndex;
 
        METAFILE_WriteRecords(metafile);
    }
 
    return Ok;
}

Referenced by begin_container().

METAFILE_ScaleWorldTransform()

GpStatus METAFILE_ScaleWorldTransform	(	GpMetafile *	metafile,
		REAL	sx,
		REAL	sy,
		MatrixOrder	order
	)

Definition at line 1260 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusScaleWorldTransform *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile,
            sizeof(EmfPlusScaleWorldTransform),
            (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Header.Type = EmfPlusRecordTypeScaleWorldTransform;
        record->Header.Flags = (order == MatrixOrderAppend ? 0x2000 : 0);
        record->Sx = sx;
        record->Sy = sy;
 
        METAFILE_WriteRecords(metafile);
    }
 
    return Ok;
}

Referenced by GdipScaleWorldTransform().

METAFILE_SetClipRect()

GpStatus METAFILE_SetClipRect	(	GpMetafile *	metafile,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height,
		CombineMode	mode
	)

Definition at line 1141 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusSetClipRect *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile,
            sizeof(EmfPlusSetClipRect),
            (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Header.Type = EmfPlusRecordTypeSetClipRect;
        record->Header.Flags = (mode & 0xf) << 8;
        record->ClipRect.X = x;
        record->ClipRect.Y = y;
        record->ClipRect.Width = width;
        record->ClipRect.Height = height;
 
        METAFILE_WriteRecords(metafile);
    }
 
    return Ok;
}

Referenced by GdipSetClipRect().

METAFILE_SetClipRegion()

GpStatus METAFILE_SetClipRegion	(	GpMetafile *	metafile,
		GpRegion *	region,
		CombineMode	mode
	)

Definition at line 1189 of file metafile.c.

{
    EmfPlusRecordHeader *record;
    DWORD region_id;
    GpStatus stat;
 
    if (metafile->metafile_type == MetafileTypeEmf)
    {
        FIXME("stub!\n");
        return NotImplemented;
    }
 
    stat = METAFILE_AddRegionObject(metafile, region, &region_id);
    if (stat != Ok) return stat;
 
    stat = METAFILE_AllocateRecord(metafile, sizeof(*record), (void**)&record);
    if (stat != Ok) return stat;
 
    record->Type = EmfPlusRecordTypeSetClipRegion;
    record->Flags = region_id | mode << 8;
 
    METAFILE_WriteRecords(metafile);
    return Ok;
}

Referenced by GdipSetClipRegion().

METAFILE_SetPageTransform()

GpStatus METAFILE_SetPageTransform	(	GpMetafile *	metafile,
		GpUnit	unit,
		REAL	scale
	)

Definition at line 1214 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusSetPageTransform *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile,
            sizeof(EmfPlusSetPageTransform),
            (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Header.Type = EmfPlusRecordTypeSetPageTransform;
        record->Header.Flags = unit;
        record->PageScale = scale;
 
        METAFILE_WriteRecords(metafile);
    }
 
    return Ok;
}

Referenced by GdipSetPageScale(), and GdipSetPageUnit().

METAFILE_SetWorldTransform()

GpStatus METAFILE_SetWorldTransform	(	GpMetafile *	metafile,
		GDIPCONST GpMatrix *	transform
	)

Definition at line 1237 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusSetWorldTransform *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile,
            sizeof(EmfPlusSetWorldTransform),
            (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Header.Type = EmfPlusRecordTypeSetWorldTransform;
        record->Header.Flags = 0;
        memcpy(record->MatrixData, transform->matrix, sizeof(record->MatrixData));
 
        METAFILE_WriteRecords(metafile);
    }
 
    return Ok;
}

Referenced by GdipSetWorldTransform().

METAFILE_TranslateWorldTransform()

GpStatus METAFILE_TranslateWorldTransform	(	GpMetafile *	metafile,
		REAL	dx,
		REAL	dy,
		MatrixOrder	order
	)

Definition at line 1330 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusTranslateWorldTransform *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile,
            sizeof(EmfPlusTranslateWorldTransform),
            (void**)&record);
        if (stat != Ok)
            return stat;
 
        record->Header.Type = EmfPlusRecordTypeTranslateWorldTransform;
        record->Header.Flags = (order == MatrixOrderAppend ? 0x2000 : 0);
        record->dx = dx;
        record->dy = dy;
 
        METAFILE_WriteRecords(metafile);
    }
 
    return Ok;
}

Referenced by GdipTranslateWorldTransform().

pixels_to_units()

REAL pixels_to_units	(	REAL	pixels,
		GpUnit	unit,
		REAL	dpi
	)

Definition at line 350 of file gdiplus.c.

{
    switch (unit)
    {
    case UnitPixel:
    case UnitWorld:
    case UnitDisplay:
        return pixels;
    case UnitPoint:
        return pixels * point_per_inch / dpi;
    case UnitInch:
        return pixels / dpi;
    case UnitDocument:
        return pixels * 300.0 / dpi;
    case UnitMillimeter:
        return pixels * mm_per_inch / dpi;
    default:
        FIXME("Unhandled unit type: %d\n", unit);
        return 0;
    }
}

Referenced by GdipGetFontHeight(), and units_scale().

trace_path()

GpStatus trace_path	(	GpGraphics *	graphics,
		GpPath *	path
	)

Definition at line 2087 of file graphics.c.

{
    GpStatus result;
 
    BeginPath(graphics->hdc);
    result = draw_poly(graphics, NULL, path->pathdata.Points,
                       path->pathdata.Types, path->pathdata.Count, FALSE);
    EndPath(graphics->hdc);
    return result;
}

Referenced by get_path_hrgn().

units_scale()

REAL units_scale	(	GpUnit	from,
		GpUnit	to,
		REAL	dpi
	)

Definition at line 372 of file gdiplus.c.

{
    REAL pixels = units_to_pixels(1.0, from, dpi);
    return pixels_to_units(pixels, to, dpi);
}

Referenced by GdipDrawImagePointRect(), GdipDrawString(), GdipMeasureCharacterRanges(), GdipMeasureString(), get_font_hfont(), and test_GdipMeasureString().

units_to_pixels()

REAL units_to_pixels	(	REAL	units,
		GpUnit	unit,
		REAL	dpi
	)

Definition at line 327 of file gdiplus.c.

{
    switch (unit)
    {
    case UnitPixel:
    case UnitWorld:
    case UnitDisplay:
        return units;
    case UnitPoint:
        return units * dpi / point_per_inch;
    case UnitInch:
        return units * dpi;
    case UnitDocument:
        return units * dpi / 300.0; /* Per MSDN */
    case UnitMillimeter:
        return units * dpi / mm_per_inch;
    default:
        FIXME("Unhandled unit type: %d\n", unit);
        return 0;
    }
}

Referenced by GdipBeginContainer(), GdipCreateFont(), GdipDrawImagePointsRect(), GdipEnumerateMetafileDestPoint(), GdipGetFontHeightGivenDPI(), GdipGetImageDimension(), GdipGetImageHeight(), GdipGetImageWidth(), GdipGetLogFontW(), GdipPlayMetafileRecord(), get_graphics_transform(), get_log_fontW(), METAFILE_DrawImagePointsRect(), METAFILE_PlaybackUpdateWorldTransform(), prepare_dc(), test_font_height_scaling(), test_GdipMeasureString(), test_measured_extra_space(), and units_scale().

write_path_data()

DWORD write_path_data	(	GpPath *	path,
		void *	data
	)

Definition at line 2491 of file graphicspath.c.

{
    struct path_header *header = data;
    BOOL integer_path = is_integer_path(path);
    DWORD i, size;
    BYTE *types;
 
    size = sizeof(struct path_header) + path->pathdata.Count;
    if (integer_path)
        size += sizeof(short[2]) * path->pathdata.Count;
    else
        size += sizeof(float[2]) * path->pathdata.Count;
    size = (size + 3) & ~3;
 
    if (!data) return size;
 
    header->version = VERSION_MAGIC2;
    header->count = path->pathdata.Count;
    header->flags = integer_path ? FLAGS_INTPATH : 0;
 
    if (integer_path)
    {
        short *points = (short*)(header + 1);
        for (i = 0; i < path->pathdata.Count; i++)
        {
            points[2*i] = path->pathdata.Points[i].X;
            points[2*i + 1] = path->pathdata.Points[i].Y;
        }
        types = (BYTE*)(points + 2*i);
    }
    else
    {
        float *points = (float*)(header + 1);
        for (i = 0; i < path->pathdata.Count; i++)
        {
            points[2*i]  = path->pathdata.Points[i].X;
            points[2*i + 1] = path->pathdata.Points[i].Y;
        }
        types = (BYTE*)(points + 2*i);
    }
 
    for (i=0; i<path->pathdata.Count; i++)
        types[i] = path->pathdata.Types[i];
    memset(types + i, 0, ((path->pathdata.Count + 3) & ~3) - path->pathdata.Count);
    return size;
}

Referenced by get_element_size(), METAFILE_AddPathObject(), and 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().

Variable Documentation

DECLSPEC_HIDDEN

const struct GpStringFormat default_drawstring_format DECLSPEC_HIDDEN

extern

Definition at line 289 of file d3dcompiler_private.h.