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/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	CGpEffect
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
struct	gdip_font_link_section
struct	gdip_font_link_info
struct	gdip_format_string_info

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	PIXELFORMATBPP(x)   ((x) ? ((x) >> 8) & 255 : 24)
#define	WineCoordinateSpaceGdiDevice   ((GpCoordinateSpace)4)
#define	EmfPlusObjectTableSize   64

Typedefs
typedef struct region_element	region_element
typedef enum EffectType	EffectType
typedef struct CGpEffect	CGpEffect
typedef enum EmfPlusObjectType	EmfPlusObjectType
typedef enum RegionType	RegionType
typedef GpStatus(*	gdip_format_string_callback) (struct gdip_format_string_info *info)

Enumerations
enum	EffectType {   NoneEffect , BlurEffect , SharpenEffect , TintEffect ,   RedEyeCorrectionEffect , ColorMatrixEffect , ColorLUTEffect , BrightnessContrastEffect ,   HueSaturationLightnessEffect , ColorBalanceEffect , LevelsEffect , ColorCurveEffect }
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)
HBITMAP	ARGB2BMP (ARGB color)
INT	arc2polybezier (GpPointF *points, REAL x1, REAL y1, REAL x2, REAL y2, REAL startAngle, REAL sweepAngle)
REAL	gdiplus_atan2 (REAL dy, REAL dx)
GpStatus	hresult_to_status (HRESULT res)
REAL	units_to_pixels (REAL units, GpUnit unit, REAL dpi, BOOL printer_display)
REAL	pixels_to_units (REAL pixels, GpUnit unit, REAL dpi, BOOL printer_display)
REAL	units_scale (GpUnit from, GpUnit to, REAL dpi, BOOL printer_display)
GpStatus	gdi_dc_acquire (GpGraphics *graphics, HDC *hdc)
void	gdi_dc_release (GpGraphics *graphics, HDC hdc)
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)
GpStatus	gdip_transform_points (GpGraphics *graphics, GpCoordinateSpace dst_space, GpCoordinateSpace src_space, GpPointF *points, INT count)
void	transform_properties (GpGraphics *, GDIPCONST GpMatrix *, BOOL, REAL *, REAL *, REAL *)
GpStatus	graphics_from_image (GpImage *image, GpGraphics **graphics)
GpStatus	encode_image_png (GpImage *image, IStream *stream, GDIPCONST EncoderParameters *params)
GpStatus	terminate_encoder_wic (GpImage *image)
GpStatus	METAFILE_GetGraphicsContext (GpMetafile *metafile, GpGraphics **result)
GpStatus	METAFILE_GetDC (GpMetafile *metafile, HDC *hdc)
GpStatus	METAFILE_ReleaseDC (GpMetafile *metafile, HDC hdc)
GpStatus	METAFILE_GraphicsClear (GpMetafile *metafile, ARGB color)
GpStatus	METAFILE_FillRectangles (GpMetafile *metafile, GpBrush *brush, GDIPCONST GpRectF *rects, INT count)
GpStatus	METAFILE_SetClipRect (GpMetafile *metafile, REAL x, REAL y, REAL width, REAL height, CombineMode mode)
GpStatus	METAFILE_SetClipRegion (GpMetafile *metafile, GpRegion *region, CombineMode mode)
GpStatus	METAFILE_SetPageTransform (GpMetafile *metafile, GpUnit unit, REAL scale)
GpStatus	METAFILE_SetWorldTransform (GpMetafile *metafile, GDIPCONST GpMatrix *transform)
GpStatus	METAFILE_ScaleWorldTransform (GpMetafile *metafile, REAL sx, REAL sy, MatrixOrder order)
GpStatus	METAFILE_MultiplyWorldTransform (GpMetafile *metafile, GDIPCONST GpMatrix *matrix, MatrixOrder order)
GpStatus	METAFILE_RotateWorldTransform (GpMetafile *metafile, REAL angle, MatrixOrder order)
GpStatus	METAFILE_TranslateWorldTransform (GpMetafile *metafile, REAL dx, REAL dy, MatrixOrder order)
GpStatus	METAFILE_ResetWorldTransform (GpMetafile *metafile)
GpStatus	METAFILE_BeginContainer (GpMetafile *metafile, GDIPCONST GpRectF *dstrect, GDIPCONST GpRectF *srcrect, GpUnit unit, DWORD StackIndex)
GpStatus	METAFILE_BeginContainerNoParams (GpMetafile *metafile, DWORD StackIndex)
GpStatus	METAFILE_EndContainer (GpMetafile *metafile, DWORD StackIndex)
GpStatus	METAFILE_SaveGraphics (GpMetafile *metafile, DWORD StackIndex)
GpStatus	METAFILE_RestoreGraphics (GpMetafile *metafile, DWORD StackIndex)
GpStatus	METAFILE_GraphicsDeleted (GpMetafile *metafile)
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)
GpStatus	METAFILE_AddSimpleProperty (GpMetafile *metafile, SHORT prop, SHORT val)
GpStatus	METAFILE_DrawPath (GpMetafile *metafile, GpPen *pen, GpPath *path)
GpStatus	METAFILE_FillPath (GpMetafile *metafile, GpBrush *brush, GpPath *path)
GpStatus	METAFILE_DrawDriverString (GpMetafile *metafile, GDIPCONST UINT16 *text, INT length, GDIPCONST GpFont *font, GDIPCONST GpStringFormat *format, GDIPCONST GpBrush *brush, GDIPCONST PointF *positions, INT flags, GDIPCONST GpMatrix *matrix)
GpStatus	METAFILE_FillRegion (GpMetafile *metafile, GpBrush *brush, GpRegion *region)
void	METAFILE_Free (GpMetafile *metafile)
GpStatus	METAFILE_DrawEllipse (GpMetafile *metafile, GpPen *pen, GpRectF *rect)
GpStatus	METAFILE_FillEllipse (GpMetafile *metafile, GpBrush *brush, GpRectF *rect)
GpStatus	METAFILE_DrawRectangles (GpMetafile *metafile, GpPen *pen, const GpRectF *rects, INT count)
GpStatus	METAFILE_FillPie (GpMetafile *metafile, GpBrush *brush, const GpRectF *rect, REAL startAngle, REAL sweepAngle)
GpStatus	METAFILE_DrawArc (GpMetafile *metafile, GpPen *pen, const GpRectF *rect, REAL startAngle, REAL sweepAngle)
GpStatus	METAFILE_OffsetClip (GpMetafile *metafile, REAL dx, REAL dy)
GpStatus	METAFILE_ResetClip (GpMetafile *metafile)
GpStatus	METAFILE_SetClipPath (GpMetafile *metafile, GpPath *path, CombineMode mode)
GpStatus	METAFILE_SetRenderingOrigin (GpMetafile *metafile, INT x, INT y)
void	calc_curve_bezier (const GpPointF *pts, REAL tension, REAL *x1, REAL *y1, REAL *x2, REAL *y2)
void	calc_curve_bezier_endp (REAL xend, REAL yend, REAL xadj, REAL yadj, REAL tension, REAL *x, REAL *y)
void	get_font_hfont (GpGraphics *graphics, GDIPCONST GpFont *font, GDIPCONST GpStringFormat *format, HFONT *hfont, LOGFONTW *lfw_return, GDIPCONST GpMatrix *matrix)
void	free_installed_fonts (void)
BOOL	lengthen_path (GpPath *path, INT len)
GpStatus	widen_flat_path_anchors (GpPath *flat_path, GpPen *pen, REAL pen_width, GpPath **anchors)
DWORD	write_region_data (const GpRegion *region, void *data)
DWORD	write_path_data (GpPath *path, void *data)
GpStatus	trace_path (GpGraphics *graphics, GpPath *path)
void	delete_element (region_element *element)
GpStatus	get_hatch_data (GpHatchStyle hatchstyle, const unsigned char **result)
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)
const char *	debugstr_pointf (const PointF *pt)
const char *	debugstr_matrix (const GpMatrix *matrix)
void	convert_32bppARGB_to_32bppPARGB (UINT width, UINT height, BYTE *dst_bits, INT dst_stride, const BYTE *src_bits, INT src_stride)
GpStatus	convert_pixels (INT width, INT height, INT dst_stride, BYTE *dst_bits, PixelFormat dst_format, ColorPalette *dst_palette, INT src_stride, const BYTE *src_bits, PixelFormat src_format, ColorPalette *src_palette)
PixelFormat	apply_image_attributes (const GpImageAttributes *attributes, LPBYTE data, UINT width, UINT height, INT stride, ColorAdjustType type, PixelFormat fmt)
void	init_generic_string_formats (void)
void	free_generic_string_formats (void)
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 (GpGraphics *graphics, 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)
void	get_log_fontW (const GpFont *, GpGraphics *, LOGFONTW *)
static BOOL	image_lock (GpImage *image)
static void	image_unlock (GpImage *image)
static BOOL	has_gdi_dc (GpGraphics *graphics)
static void	set_rect (GpRectF *rect, REAL x, REAL y, REAL width, REAL height)

Variables
const struct GpStringFormat	default_drawstring_format

Macro Definition Documentation

EmfPlusObjectTableSize

#define EmfPlusObjectTableSize   64

Definition at line 413 of file gdiplus_private.h.

GIF_DISPOSE_DO_NOT_DISPOSE

#define GIF_DISPOSE_DO_NOT_DISPOSE   1

Definition at line 48 of file gdiplus_private.h.

GIF_DISPOSE_RESTORE_TO_BKGND

#define GIF_DISPOSE_RESTORE_TO_BKGND   2

Definition at line 49 of file gdiplus_private.h.

GIF_DISPOSE_RESTORE_TO_PREV

#define GIF_DISPOSE_RESTORE_TO_PREV   3

Definition at line 50 of file gdiplus_private.h.

GIF_DISPOSE_UNSPECIFIED

#define GIF_DISPOSE_UNSPECIFIED   0

Definition at line 47 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 37 of file gdiplus_private.h.

INCH_HIMETRIC

#define INCH_HIMETRIC   (2540)

Definition at line 40 of file gdiplus_private.h.

MAX_ARC_PTS

#define MAX_ARC_PTS   (13)

Definition at line 38 of file gdiplus_private.h.

MAX_DASHLEN

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

Definition at line 39 of file gdiplus_private.h.

PIXELFORMATBPP

#define PIXELFORMATBPP

(

x

)

((x) ? ((x) >> 8) & 255 : 24)

Definition at line 52 of file gdiplus_private.h.

TENSION_CONST

#define TENSION_CONST   (0.3)

Definition at line 45 of file gdiplus_private.h.

VALID_MAGIC

#define VALID_MAGIC

(

x

)

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

Definition at line 44 of file gdiplus_private.h.

VERSION_MAGIC

#define VERSION_MAGIC   0xdbc01001

Definition at line 42 of file gdiplus_private.h.

VERSION_MAGIC2

#define VERSION_MAGIC2   0xdbc01002

Definition at line 43 of file gdiplus_private.h.

WineCoordinateSpaceGdiDevice

#define WineCoordinateSpaceGdiDevice   ((GpCoordinateSpace)4)

Definition at line 65 of file gdiplus_private.h.

Typedef Documentation

CGpEffect

typedef struct CGpEffect CGpEffect

EffectType

typedef enum EffectType EffectType

EmfPlusObjectType

typedef enum EmfPlusObjectType EmfPlusObjectType

gdip_format_string_callback

typedef GpStatus(* gdip_format_string_callback) (struct gdip_format_string_info *info)

Definition at line 666 of file gdiplus_private.h.

region_element

typedef struct region_element region_element

Definition at line 149 of file gdiplus_private.h.

RegionType

typedef enum RegionType RegionType

Enumeration Type Documentation

EffectType

enum EffectType

Enumerator
NoneEffect
BlurEffect
SharpenEffect
TintEffect
RedEyeCorrectionEffect
ColorMatrixEffect
ColorLUTEffect
BrightnessContrastEffect
HueSaturationLightnessEffect
ColorBalanceEffect
LevelsEffect
ColorCurveEffect

Definition at line 382 of file gdiplus_private.h.

                        {
    NoneEffect,
    BlurEffect,
    SharpenEffect,
    TintEffect,
    RedEyeCorrectionEffect,
    ColorMatrixEffect,
    ColorLUTEffect,
    BrightnessContrastEffect,
    HueSaturationLightnessEffect,
    ColorBalanceEffect,
    LevelsEffect,
    ColorCurveEffect,
} EffectType;

EmfPlusObjectType

enum EmfPlusObjectType

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

Definition at line 415 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 523 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 585 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 796 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 (y=0; y<height; y++)
            for (x=0; x<width; x++)
            {
                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 (y=0; y<height; y++)
            for (x=0; x<width; x++)
            {
                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 (y=0; y<height; y++)
            {
                for (x=0; x<width; x++)
                {
                    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 (y=0; y<height; y++)
            for (x=0; x<width; x++)
            {
                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 partial_end_angle, end_angle;
 
    end_angle = deg2rad(start_angle + sweep_angle);
    start_angle = deg2rad(start_angle);
 
    if (width != height)
    {
        start_angle = unstretch_angle(start_angle, width, height);
        end_angle = unstretch_angle(end_angle, width, height);
    }
 
    for(i = 0; i < MAX_ARC_PTS - 1; i += 3){
        /* check if we've overshot the end angle */
        if( sweep_angle > 0.0 )
        {
            if (start_angle >= end_angle) break;
            partial_end_angle = min(start_angle + M_PI_2, end_angle);
        }
        else
        {
            if (start_angle <= end_angle) break;
            partial_end_angle = max(start_angle - M_PI_2, end_angle);
        }
 
        if (points)
            add_arc_part(&points[i], left, top, width, height, start_angle, partial_end_angle, i == 0);
 
        start_angle = partial_end_angle;
    }
 
    if (i == 0) return 0;
    else return i+1;
}

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

ARGB2BMP()

HBITMAP ARGB2BMP

(

ARGB

color

)

Definition at line 274 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 261 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 626 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 389 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 GdipAddPathCurve3().

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 406 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 GdipAddPathCurve3().

ceilr()

static INT ceilr ( REAL  x )

inlinestatic

Definition at line 159 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 169 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 193 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 445 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,
		ColorPalette *	dst_palette,
		INT	src_stride,
		const BYTE *	src_bits,
		PixelFormat	src_format,
		ColorPalette *	src_palette
	)

Definition at line 589 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 = (src_palette && index < src_palette->Count) ? src_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_indexed_to_indexed(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 = (src_palette && index < src_palette->Count) ? src_palette->Entries[index] : 0; \
            setpixel_function(color[2], color[1], color[0], color[3], dst_bits+dst_stride*y, x, dst_palette); \
        } \
    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, dst_palette); \
        } \
    return Ok; \
} while (0);
 
    switch (src_format)
    {
    case PixelFormat1bppIndexed:
        switch (dst_format)
        {
        case PixelFormat4bppIndexed:
            convert_indexed_to_indexed(getpixel_1bppIndexed, setpixel_4bppIndexed);
        case PixelFormat8bppIndexed:
            convert_indexed_to_indexed(getpixel_1bppIndexed, setpixel_8bppIndexed);
        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 PixelFormat1bppIndexed:
            convert_indexed_to_indexed(getpixel_4bppIndexed, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_indexed_to_indexed(getpixel_4bppIndexed, setpixel_8bppIndexed);
        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 PixelFormat1bppIndexed:
            convert_indexed_to_indexed(getpixel_8bppIndexed, setpixel_1bppIndexed);
        case PixelFormat4bppIndexed:
            convert_indexed_to_indexed(getpixel_8bppIndexed, setpixel_4bppIndexed);
        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 PixelFormat4bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_4bppIndexed);
        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 PixelFormat4bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_4bppIndexed);
        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 PixelFormat4bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_4bppIndexed);
        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 PixelFormat4bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_4bppIndexed);
        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 PixelFormat4bppIndexed:
            convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_4bppIndexed);
        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 PixelFormat4bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_4bppIndexed);
        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 PixelFormat4bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_4bppIndexed);
        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 PixelFormat4bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_4bppIndexed);
        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 PixelFormat4bppIndexed:
            convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_4bppIndexed);
        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 PixelFormat4bppIndexed:
            convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_4bppIndexed);
        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 PixelFormat4bppIndexed:
            convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_4bppIndexed);
        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_indexed_to_indexed
#undef convert_rgb_to_rgb
#undef convert_rgb_to_indexed
 
    return NotImplemented;
}

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

debugstr_matrix()

const char * debugstr_matrix

(

const GpMatrix *

matrix

)

Definition at line 498 of file gdiplus.c.

{
    if (!matrix) return "(null)";
    return wine_dbg_sprintf("%p(%0.2f,%0.2f,%0.2f,%0.2f,%0.2f,%0.2f)",matrix, matrix->matrix[0], matrix->matrix[1],
                            matrix->matrix[2], matrix->matrix[3], matrix->matrix[4], matrix->matrix[5]);
}

Referenced by GdipCloneMatrix(), GdipDrawDriverString(), GdipGetLineTransform(), GdipGetMatrixElements(), GdipGetPathGradientTransform(), GdipGetPathWorldBounds(), GdipGetPathWorldBoundsI(), GdipGetPenTransform(), GdipGetRegionScansCount(), GdipGetTextureTransform(), GdipGetWorldTransform(), GdipInvertMatrix(), GdipIsMatrixEqual(), GdipIsMatrixIdentity(), GdipIsMatrixInvertible(), GdipMeasureDriverString(), GdipMultiplyLineTransform(), GdipMultiplyMatrix(), GdipMultiplyPathGradientTransform(), GdipMultiplyPenTransform(), GdipMultiplyTextureTransform(), GdipMultiplyWorldTransform(), GdipRotateMatrix(), GdipScaleMatrix(), GdipSetLineTransform(), GdipSetMatrixElements(), GdipSetPathGradientTransform(), GdipSetPenTransform(), GdipSetTextureTransform(), GdipSetWorldTransform(), GdipShearMatrix(), GdipTransformMatrixPoints(), GdipTransformMatrixPointsI(), GdipTransformPath(), GdipTransformRegion(), GdipTranslateMatrix(), GdipVectorTransformMatrixPoints(), GdipVectorTransformMatrixPointsI(), GdipWarpPath(), and GdipWidenPath().

debugstr_pointf()

const char * debugstr_pointf

(

const PointF *

pt

)

Definition at line 492 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 486 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(), GdipCreateLineBrushFromRect(), GdipCreateLineBrushFromRectWithAngle(), GdipCreateMatrix3(), GdipCreateRegionRect(), GdipDrawImageFX(), GdipDrawString(), GdipEnumerateMetafileSrcRectDestPoints(), GdipGetRegionBounds(), GdipMeasureCharacterRanges(), GdipMeasureString(), GdipRecordMetafile(), GdipRecordMetafileFileName(), and GdipRecordMetafileStream().

deg2rad()

static REAL deg2rad ( REAL  degrees )

inlinestatic

Definition at line 164 of file gdiplus_private.h.

{
    return M_PI * degrees / 180.0;
}

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

delete_element()

void delete_element

(

region_element *

element

)

Definition at line 465 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);
            free(element->elementdata.combine.left);
            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 4859 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.

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

Referenced by DllMain().

free_installed_fonts()

void free_installed_fonts

(

void

)

Definition at line 1567 of file font.c.

{
    INT i;
 
    for (i = 0; i < installedFontCollection.count; i++)
        free(installedFontCollection.FontFamilies[i]);
    free(installedFontCollection.FontFamilies);
 
    installedFontCollection.FontFamilies = NULL;
    installedFontCollection.allocated = 0;
}

Referenced by DllMain(), and GdipNewInstalledFontCollection().

gdi_dc_acquire()

GpStatus gdi_dc_acquire	(	GpGraphics *	graphics,
		HDC *	hdc
	)

Definition at line 54 of file graphics.c.

{
    if (graphics->hdc != NULL)
    {
        *hdc = graphics->hdc;
        graphics->hdc_refs++;
        return Ok;
    }
    else if (graphics->owndc)
    {
        *hdc = graphics->hdc = GetDC(graphics->hwnd);
        if (!graphics->hdc)
            return OutOfMemory;
        graphics->hdc_refs++;
        return Ok;
    }
 
    *hdc = NULL;
    return InvalidParameter;
}

Referenced by alpha_blend_pixels_hrgn(), brush_fill_path(), draw_cap(), draw_poly(), GDI32_GdipDrawDriverString(), GDI32_GdipDrawPath(), GDI32_GdipFillPath(), GDI32_GdipFillRegion(), gdi_alpha_blend(), gdi_transform_acquire(), GdipDrawImagePointsRect(), GdipDrawString(), GdipMeasureCharacterRanges(), GdipMeasureString(), get_path_hrgn(), and trace_path().

gdi_dc_release()

void gdi_dc_release	(	GpGraphics *	graphics,
		HDC	hdc
	)

Definition at line 75 of file graphics.c.

{
    assert(graphics->hdc_refs > 0);
    graphics->hdc_refs--;
 
    if (graphics->owndc && !graphics->hdc_refs)
    {
        assert(graphics->hdc == hdc);
        graphics->hdc = NULL;
        ReleaseDC(graphics->hwnd, hdc);
    }
}

Referenced by alpha_blend_pixels_hrgn(), brush_fill_path(), draw_cap(), draw_poly(), GDI32_GdipDrawDriverString(), GDI32_GdipDrawPath(), GDI32_GdipFillPath(), GDI32_GdipFillRegion(), gdi_alpha_blend(), gdi_transform_release(), GdipDrawImagePointsRect(), GdipDrawString(), GdipMeasureCharacterRanges(), GdipMeasureString(), get_path_hrgn(), and trace_path().

gdi_transform_acquire()

GpStatus gdi_transform_acquire

(

GpGraphics *

graphics

)

Definition at line 7228 of file graphics.c.

{
    if (graphics->gdi_transform_acquire_count == 0 && has_gdi_dc(graphics))
    {
        HDC hdc;
        GpStatus stat;
 
        stat = gdi_dc_acquire(graphics, &hdc);
        if (stat != Ok)
            return stat;
 
        graphics->gdi_transform_save = SaveDC(hdc);
        ModifyWorldTransform(hdc, NULL, MWT_IDENTITY);
        SetGraphicsMode(hdc, GM_COMPATIBLE);
        SetMapMode(hdc, MM_TEXT);
        SetWindowOrgEx(hdc, 0, 0, NULL);
        SetViewportOrgEx(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 7250 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);
        gdi_dc_release(graphics, graphics->hdc);
    }
    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	(	GpGraphics *	graphics,
		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 5478 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, unixstyle_newline = TRUE;
    struct gdip_format_string_info info;
 
    info.graphics = graphics;
    info.hdc = hdc;
    info.rect = rect;
    info.bounds = &bounds;
    info.user_data = user_data;
 
    if(length == -1) length = lstrlenW(string);
 
    stringdup = calloc(length + 1, sizeof(WCHAR));
    if(!stringdup) return OutOfMemory;
 
    info.string = stringdup;
 
    if (!format)
        format = &default_drawstring_format;
 
    info.format = format;
 
    nwidth = (int)(rect->Width + 0.005f);
    nheight = (int)(rect->Height + 0.005f);
    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 = calloc(hotkeyprefix_count, sizeof(INT));
        if (!hotkeyprefix_offsets)
        {
            free(stringdup);
            return OutOfMemory;
        }
    }
 
    hotkeyprefix_count = 0;
 
    for(i = 0, j = 0; i < length; i++){
 
        /* 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;
 
    generate_font_link_info(&info, length, font);
 
    while(sum < length){
        font_link_get_text_extent_point(&info, sum, length - sum, nwidth, &fit, &size);
        fitcpy = fit;
 
        if(fit == 0)
            break;
 
        for(lret = 0; lret < fit; lret++) {
            if(*(stringdup + sum + lret) == '\n')
            {
               unixstyle_newline = TRUE;
               break;
            }
 
            if(*(stringdup + sum + lret) == '\r' && lret + 1 < fit
               && *(stringdup + sum + lret + 1) == '\n')
            {
               unixstyle_newline = FALSE;
               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 if (!(format->attr & StringFormatFlagsNoWrap))
                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;
 
        font_link_get_text_extent_point(&info, sum, lineend, nwidth, &j, &size);
 
        bounds.Width = size.cx;
 
        if(height + size.cy > nheight)
        {
            if (format->attr & StringFormatFlagsLineLimit)
                break;
            bounds.Height = nheight - height;
        }
        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;
 
        info.index = sum;
        info.length = lineend;
        info.lineno = lineno;
        info.underlined_indexes = &hotkeyprefix_offsets[hotkeyprefix_pos];
        info.underlined_index_count = hotkeyprefix_end_pos-hotkeyprefix_pos;
 
        stat = callback(&info);
 
        if (stat != Ok)
            break;
 
 
        if (unixstyle_newline)
        {
            height += size.cy;
            lineno++;
            sum += fit + (lret < fitcpy ? 1 : 0);
        }
        else
        {
            height += size.cy;
            lineno++;
            sum += fit + (lret < fitcpy ? 2 : 0);
        }
 
        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;
    }
 
    release_font_link_info(&info.font_link_info);
    free(stringdup);
    free(hotkeyprefix_offsets);
 
    return stat;
}

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

gdip_round()

static INT gdip_round ( REAL  x )

inlinestatic

Definition at line 154 of file gdiplus_private.h.

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

Referenced by blend_colors(), calc_curve_bezier_endp(), GDI32_GdipDrawDriverString(), GdipCloneBitmapArea(), GdipGetClipBoundsI(), 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(), png_add_unit_properties(), 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 7344 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(), GdipMeasureDriverString(), GdipTransformPoints(), get_graphics_bounds(), prepare_dc(), SOFTWARE_GdipDrawDriverString(), SOFTWARE_GdipDrawPath(), and transform_properties().

gdiplus_atan2()

REAL gdiplus_atan2	(	REAL	dy,
		REAL	dx
	)

Definition at line 306 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(), shorten_line_percent(), transform_properties(), and unstretch_angle().

get_font_hfont()

void get_font_hfont	(	GpGraphics *	graphics,
		GDIPCONST GpFont *	font,
		GDIPCONST GpStringFormat *	format,
		HFONT *	hfont,
		LOGFONTW *	lfw_return,
		GDIPCONST GpMatrix *	matrix
	)

Definition at line 2385 of file graphics.c.

{
    HDC hdc = CreateCompatibleDC(0);
    REAL angle, rel_width, rel_height, font_height;
    LOGFONTW lfw;
    HFONT unscaled_font;
    TEXTMETRICW textmet;
 
    if (font->unit == UnitPixel || font->unit == UnitWorld)
        font_height = font->emSize;
    else
    {
        REAL unit_scale, res;
 
        res = (graphics->unit == UnitDisplay || graphics->unit == UnitPixel) ? graphics->xres : graphics->yres;
        unit_scale = units_scale(font->unit, graphics->unit, res, graphics->printer_display);
 
        font_height = font->emSize * unit_scale;
    }
 
    transform_properties(graphics, matrix, TRUE, &rel_width, &rel_height, &angle);
    /* If the font unit is not pixels scaling should not be applied */
    if (font->unit != UnitPixel && font->unit != UnitWorld)
    {
        rel_width /= graphics->scale;
        rel_height /= graphics->scale;
    }
 
    get_log_fontW(font, graphics, &lfw);
    lfw.lfHeight = -gdip_round(font_height * rel_height);
    unscaled_font = CreateFontIndirectW(&lfw);
 
    SelectObject(hdc, unscaled_font);
    GetTextMetricsW(hdc, &textmet);
 
    lfw.lfWidth = gdip_round(textmet.tmAveCharWidth * rel_width / rel_height);
    lfw.lfEscapement = lfw.lfOrientation = gdip_round((angle / M_PI) * 1800.0);
 
    *hfont = CreateFontIndirectW(&lfw);
 
    if (lfw_return)
        *lfw_return = lfw;
 
    DeleteDC(hdc);
    DeleteObject(unscaled_font);
}

Referenced by font_link_get_text_extent_point(), format_string_callback(), GDI32_GdipDrawDriverString(), GdipDrawString(), GdipMeasureCharacterRanges(), GdipMeasureDriverString(), GdipMeasureString(), generate_font_link_info(), and SOFTWARE_GdipDrawDriverString().

get_graphics_transform()

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

Definition at line 7266 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)
    {
        if(graphics->unit != UnitDisplay)
        {
            scale_x = units_to_pixels(graphics->scale, graphics->unit, graphics->xres, graphics->printer_display);
            scale_y = units_to_pixels(graphics->scale, graphics->unit, graphics->yres, graphics->printer_display);
        }
        else
        {
            scale_x = units_to_pixels(1.0, graphics->unit, graphics->xres, graphics->printer_display);
            scale_y = units_to_pixels(1.0, graphics->unit, graphics->yres, graphics->printer_display);
        }
 
        if (dst_space < src_space)
        {
            /* transform towards world space */
            switch ((int)src_space)
            {
            case WineCoordinateSpaceGdiDevice:
            {
                GpMatrix gdixform = graphics->gdi_transform;
                stat = GdipInvertMatrix(&gdixform);
                if (stat != Ok)
                    break;
                memcpy(matrix->matrix, gdixform.matrix, sizeof(matrix->matrix));
                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:
                memcpy(matrix->matrix, &graphics->worldtrans, sizeof(matrix->matrix));
                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 unsigned char **	result
	)

Definition at line 288 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 2353 of file graphics.c.

{
    REAL height;
 
    if (font->unit == UnitPixel)
    {
        height = units_to_pixels(font->emSize, graphics->unit, graphics->yres, graphics->printer_display);
    }
    else
    {
        if (graphics->unit == UnitDisplay || graphics->unit == UnitPixel)
            height = units_to_pixels(font->emSize, font->unit, graphics->xres, graphics->printer_display);
        else
            height = units_to_pixels(font->emSize, font->unit, graphics->yres, graphics->printer_display);
    }
 
    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;
    lstrcpyW(lf->lfFaceName, font->family->FamilyName);
}

Referenced by GdipAddPathString(), GdipGetLogFontW(), and get_font_hfont().

graphics_from_image()

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

Definition at line 2520 of file graphics.c.

{
    GpStatus retval;
 
    *graphics = calloc(1, 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){
        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);
    (*graphics)->contid = 0;
 
    TRACE("<-- %p\n", *graphics);
 
    return Ok;
}

Referenced by GdipGetImageGraphicsContext(), and METAFILE_GetGraphicsContext().

has_gdi_dc()

static BOOL has_gdi_dc ( GpGraphics *  graphics )

inlinestatic

Definition at line 685 of file gdiplus_private.h.

{
    return graphics->hdc != NULL || graphics->owndc;
}

Referenced by draw_driver_string(), gdi_transform_acquire(), GdipDrawPath(), GdipDrawString(), GdipFlush(), GdipMeasureCharacterRanges(), GdipMeasureString(), get_graphics_bounds(), and get_path_hrgn().

hresult_to_status()

GpStatus hresult_to_status

(

HRESULT

res

)

Definition at line 314 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_frame_wic(), GdipCreateStreamOnFile(), GdipGetAllPropertyItems(), GdipGetPropertyIdList(), GdipGetPropertySize(), GdipLoadImageFromStream(), get_decoder_info(), initialize_decoder_wic(), initialize_encoder_wic(), load_emf(), load_wmf(), METAFILE_CreateCompressedImageStream(), METAFILE_FillEmfPlusBitmap(), METAFILE_GraphicsDeleted(), select_frame_gif(), and terminate_encoder_wic().

image_lock()

static BOOL image_lock ( GpImage *  image )

inlinestatic

Definition at line 675 of file gdiplus_private.h.

{
    return TryAcquireSRWLockExclusive(&image->lock);
}

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

image_unlock()

static void image_unlock ( GpImage *  image )

inlinestatic

Definition at line 680 of file gdiplus_private.h.

{
    ReleaseSRWLockExclusive(&image->lock);
}

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 619 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 415 of file gdiplus.c.

{
    /* initial allocation */
    if(path->datalen == 0){
        path->datalen = len * 2;
 
        path->pathdata.Points = calloc(path->datalen, sizeof(PointF));
        if(!path->pathdata.Points) return FALSE;
 
        path->pathdata.Types = calloc(1, path->datalen);
        if(!path->pathdata.Types){
            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 = realloc(path->pathdata.Points, path->datalen * sizeof(PointF));
        if(!path->pathdata.Points) return FALSE;
 
        path->pathdata.Types = realloc(path->pathdata.Types, path->datalen);
        if(!path->pathdata.Types) return FALSE;
    }
 
    return TRUE;
}

Referenced by extend_current_figure(), format_string_callback(), GdipAddPathEllipse(), GdipAddPathPath(), GdipAddPathPie(), GdipAddPathPolygon(), GdipPathIterNextMarkerPath(), GdipPathIterNextSubpathPath(), and read_element().

METAFILE_AddSimpleProperty()

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

Definition at line 4839 of file metafile.c.

{
    EmfPlusRecordHeader *record;
    GpStatus stat;
 
    if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
        return Ok;
 
    stat = METAFILE_AllocateRecord(metafile, prop, sizeof(*record), (void**)&record);
    if (stat != Ok) return stat;
 
    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 1564 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusBeginContainer *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeBeginContainer, sizeof(*record), (void**)&record);
        if (stat != Ok)
            return stat;
 
        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 1587 of file metafile.c.

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

Referenced by begin_container().

METAFILE_DrawArc()

GpStatus METAFILE_DrawArc	(	GpMetafile *	metafile,
		GpPen *	pen,
		const GpRectF *	rect,
		REAL	startAngle,
		REAL	sweepAngle
	)

Definition at line 5536 of file metafile.c.

{
    EmfPlusDrawArc *record;
    GpStatus stat;
    BOOL integer_rect;
    DWORD pen_id;
 
    if (metafile->metafile_type == MetafileTypeEmf)
    {
        FIXME("stub!\n");
        return NotImplemented;
    }
 
    stat = METAFILE_AddPenObject(metafile, pen, &pen_id);
    if (stat != Ok) return stat;
 
    integer_rect = is_integer_rect(rect);
 
    stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeDrawArc, FIELD_OFFSET(EmfPlusDrawArc, RectData) +
        (integer_rect ? sizeof(record->RectData.rect) : sizeof(record->RectData.rectF)),
        (void **)&record);
    if (stat != Ok)
        return stat;
 
    record->Header.Flags = pen_id;
    if (integer_rect)
        record->Header.Flags |= 0x4000;
    record->StartAngle = startAngle;
    record->SweepAngle = sweepAngle;
 
    if (integer_rect)
    {
        record->RectData.rect.X = (SHORT)rect->X;
        record->RectData.rect.Y = (SHORT)rect->Y;
        record->RectData.rect.Width = (SHORT)rect->Width;
        record->RectData.rect.Height = (SHORT)rect->Height;
    }
    else
        memcpy(&record->RectData.rectF, rect, sizeof(*rect));
 
    METAFILE_WriteRecords(metafile);
 
    return Ok;
}

Referenced by GdipDrawArc().

METAFILE_DrawDriverString()

GpStatus METAFILE_DrawDriverString	(	GpMetafile *	metafile,
		GDIPCONST UINT16 *	text,
		INT	length,
		GDIPCONST GpFont *	font,
		GDIPCONST GpStringFormat *	format,
		GDIPCONST GpBrush *	brush,
		GDIPCONST PointF *	positions,
		INT	flags,
		GDIPCONST GpMatrix *	matrix
	)

Definition at line 5322 of file metafile.c.

{
    DWORD brush_id;
    DWORD font_id;
    DWORD alloc_size;
    GpStatus stat;
    EmfPlusDrawDriverString *draw_string_record;
    BYTE *cursor;
    BOOL inline_color;
    BOOL include_matrix = FALSE;
 
    if (length <= 0)
        return InvalidParameter;
 
    if (metafile->metafile_type != MetafileTypeEmfPlusOnly &&
            metafile->metafile_type != MetafileTypeEmfPlusDual)
    {
        FIXME("metafile type not supported: %i\n", metafile->metafile_type);
        return NotImplemented;
    }
 
    stat = METAFILE_AddFontObject(metafile, font, &font_id);
    if (stat != Ok)
        return stat;
 
    inline_color = (brush->bt == BrushTypeSolidColor);
    if (!inline_color)
    {
        stat = METAFILE_AddBrushObject(metafile, brush, &brush_id);
        if (stat != Ok)
            return stat;
    }
 
    if (matrix)
    {
        BOOL identity;
 
        stat = GdipIsMatrixIdentity(matrix, &identity);
        if (stat != Ok)
           return stat;
 
        include_matrix = !identity;
    }
 
    alloc_size = FIELD_OFFSET(EmfPlusDrawDriverString, VariableData) +
        length * (sizeof(*text) + sizeof(*positions));
 
    if (include_matrix)
        alloc_size += sizeof(*matrix);
 
    /* Pad record to DWORD alignment. */
    alloc_size = (alloc_size + 3) & ~3;
 
    stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeDrawDriverString, alloc_size, (void**)&draw_string_record);
    if (stat != Ok)
        return stat;
 
    draw_string_record->Header.Flags = font_id;
    draw_string_record->DriverStringOptionsFlags = flags;
    draw_string_record->MatrixPresent = include_matrix;
    draw_string_record->GlyphCount = length;
 
    if (inline_color)
    {
        draw_string_record->Header.Flags |= 0x8000;
        draw_string_record->brush.Color = ((GpSolidFill*)brush)->color;
    }
    else
        draw_string_record->brush.BrushId = brush_id;
 
    cursor = &draw_string_record->VariableData[0];
 
    memcpy(cursor, text, length * sizeof(*text));
    cursor += length * sizeof(*text);
 
    if (flags & DriverStringOptionsRealizedAdvance)
    {
        static BOOL fixme_written = FALSE;
 
        /* Native never writes DriverStringOptionsRealizedAdvance. Instead,
           in the case of RealizedAdvance, each glyph position is computed
           and serialized.
 
           While native GDI+ is capable of playing back metafiles with this
           flag set, it is possible that some application might rely on
           metafiles produced from GDI+ not setting this flag. Ideally we
           would also compute the position of each glyph here, serialize those
           values, and not set DriverStringOptionsRealizedAdvance. */
        if (!fixme_written)
        {
            fixme_written = TRUE;
            FIXME("serializing RealizedAdvance flag and single GlyphPos with padding\n");
        }
 
        *((PointF*)cursor) = *positions;
    }
    else
        memcpy(cursor, positions, length * sizeof(*positions));
 
    if (include_matrix)
    {
        cursor += length * sizeof(*positions);
        memcpy(cursor, matrix, sizeof(*matrix));
    }
 
    METAFILE_WriteRecords(metafile);
 
    return Ok;
}

Referenced by draw_driver_string().

METAFILE_DrawEllipse()

GpStatus METAFILE_DrawEllipse	(	GpMetafile *	metafile,
		GpPen *	pen,
		GpRectF *	rect
	)

Definition at line 5095 of file metafile.c.

{
    EmfPlusDrawEllipse *record;
    BOOL is_int_rect;
    GpStatus stat;
    DWORD pen_id;
 
    if (metafile->metafile_type == MetafileTypeEmf)
    {
        FIXME("stub!\n");
        return NotImplemented;
    }
 
    stat = METAFILE_AddPenObject(metafile, pen, &pen_id);
    if (stat != Ok) return stat;
 
    is_int_rect = is_integer_rect(rect);
 
    stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeDrawEllipse,
            FIELD_OFFSET(EmfPlusDrawEllipse, RectData) + (is_int_rect ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)),
            (void **)&record);
    if (stat != Ok) return stat;
    record->Header.Type = EmfPlusRecordTypeDrawEllipse;
    record->Header.Flags = pen_id;
    if (is_int_rect)
    {
        record->Header.Flags |= 0x4000;
        record->RectData.rect.X = (SHORT)rect->X;
        record->RectData.rect.Y = (SHORT)rect->Y;
        record->RectData.rect.Width = (SHORT)rect->Width;
        record->RectData.rect.Height = (SHORT)rect->Height;
    }
    else
        memcpy(&record->RectData.rectF, rect, sizeof(*rect));
 
    METAFILE_WriteRecords(metafile);
    return Ok;
}

Referenced by GdipDrawEllipse().

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 4759 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, EmfPlusRecordTypeDrawImagePoints,
        sizeof(EmfPlusDrawImagePoints), (void **)&draw_image_record);
    if (stat != Ok) return stat;
 
    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, metafile->printer_display);
    draw_image_record->SrcRect.Y = units_to_pixels(srcy, srcUnit, metafile->image.yres, metafile->printer_display);
    draw_image_record->SrcRect.Width = units_to_pixels(srcwidth, srcUnit, metafile->image.xres, metafile->printer_display);
    draw_image_record->SrcRect.Height = units_to_pixels(srcheight, srcUnit, metafile->image.yres, metafile->printer_display);
    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 5065 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, EmfPlusRecordTypeDrawPath,
        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_DrawRectangles()

GpStatus METAFILE_DrawRectangles	(	GpMetafile *	metafile,
		GpPen *	pen,
		const GpRectF *	rects,
		INT	count
	)

Definition at line 5481 of file metafile.c.

{
    EmfPlusDrawRects *record;
    GpStatus stat;
    BOOL integer_rects = TRUE;
    DWORD pen_id;
    int i;
 
    if (metafile->metafile_type == MetafileTypeEmf)
    {
        FIXME("stub!\n");
        return NotImplemented;
    }
 
    stat = METAFILE_AddPenObject(metafile, pen, &pen_id);
    if (stat != Ok) return stat;
 
    for (i = 0; i < count; i++)
    {
        if (!is_integer_rect(&rects[i]))
        {
            integer_rects = FALSE;
            break;
        }
    }
 
    stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeDrawRects, FIELD_OFFSET(EmfPlusDrawRects, RectData) +
        count * (integer_rects ? sizeof(record->RectData.rect) : sizeof(record->RectData.rectF)),
        (void **)&record);
    if (stat != Ok)
        return stat;
 
    record->Header.Flags = pen_id;
    if (integer_rects)
        record->Header.Flags |= 0x4000;
    record->Count = count;
 
    if (integer_rects)
    {
        for (i = 0; i < count; i++)
        {
            record->RectData.rect[i].X = (SHORT)rects[i].X;
            record->RectData.rect[i].Y = (SHORT)rects[i].Y;
            record->RectData.rect[i].Width = (SHORT)rects[i].Width;
            record->RectData.rect[i].Height = (SHORT)rects[i].Height;
        }
    }
    else
        memcpy(record->RectData.rectF, rects, sizeof(*rects) * count);
 
    METAFILE_WriteRecords(metafile);
 
    return Ok;
}

Referenced by GdipDrawRectangles().

METAFILE_EndContainer()

GpStatus METAFILE_EndContainer	(	GpMetafile *	metafile,
		DWORD	StackIndex
	)

Definition at line 1607 of file metafile.c.

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

Referenced by end_container().

METAFILE_FillEllipse()

GpStatus METAFILE_FillEllipse	(	GpMetafile *	metafile,
		GpBrush *	brush,
		GpRectF *	rect
	)

Definition at line 5175 of file metafile.c.

{
    BOOL is_int_rect, inline_color;
    EmfPlusFillEllipse *record;
    DWORD brush_id = -1;
    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;
    }
 
    is_int_rect = is_integer_rect(rect);
 
    stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeFillEllipse,
            FIELD_OFFSET(EmfPlusFillEllipse, RectData) + (is_int_rect ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)),
            (void **)&record);
    if (stat != Ok) return stat;
    if (inline_color)
    {
        record->Header.Flags = 0x8000;
        record->BrushId = ((GpSolidFill *)brush)->color;
    }
    else
        record->BrushId = brush_id;
 
    if (is_int_rect)
    {
        record->Header.Flags |= 0x4000;
        record->RectData.rect.X = (SHORT)rect->X;
        record->RectData.rect.Y = (SHORT)rect->Y;
        record->RectData.rect.Width = (SHORT)rect->Width;
        record->RectData.rect.Height = (SHORT)rect->Height;
    }
    else
        memcpy(&record->RectData.rectF, rect, sizeof(*rect));
 
    METAFILE_WriteRecords(metafile);
    return Ok;
}

Referenced by GdipFillEllipse().

METAFILE_FillPath()

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

Definition at line 5134 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, EmfPlusRecordTypeFillPath,
            sizeof(EmfPlusFillPath), (void**)&fill_path_record);
    if (stat != Ok) return stat;
    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_FillPie()

GpStatus METAFILE_FillPie	(	GpMetafile *	metafile,
		GpBrush *	brush,
		const GpRectF *	rect,
		REAL	startAngle,
		REAL	sweepAngle
	)

Definition at line 5224 of file metafile.c.

{
    BOOL is_int_rect, inline_color;
    EmfPlusFillPie *record;
    DWORD brush_id = -1;
    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;
    }
 
    is_int_rect = is_integer_rect(rect);
 
    stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeFillPie,
            FIELD_OFFSET(EmfPlusFillPie, RectData) + (is_int_rect ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)),
            (void **)&record);
    if (stat != Ok) return stat;
    if (inline_color)
    {
        record->Header.Flags = 0x8000;
        record->BrushId = ((GpSolidFill *)brush)->color;
    }
    else
        record->BrushId = brush_id;
 
    record->StartAngle = startAngle;
    record->SweepAngle = sweepAngle;
 
    if (is_int_rect)
    {
        record->Header.Flags |= 0x4000;
        record->RectData.rect.X = (SHORT)rect->X;
        record->RectData.rect.Y = (SHORT)rect->Y;
        record->RectData.rect.Width = (SHORT)rect->Width;
        record->RectData.rect.Height = (SHORT)rect->Height;
    }
    else
        memcpy(&record->RectData.rectF, rect, sizeof(*rect));
 
    METAFILE_WriteRecords(metafile);
    return Ok;
}

Referenced by GdipFillPie().

METAFILE_FillRectangles()

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

Definition at line 1261 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, EmfPlusRecordTypeFillRects,
            sizeof(EmfPlusFillRects) + count * (integer_rects ? sizeof(EmfPlusRect) : sizeof(GpRectF)),
            (void**)&record);
        if (stat != Ok)
            return stat;
 
        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_FillRegion()

GpStatus METAFILE_FillRegion	(	GpMetafile *	metafile,
		GpBrush *	brush,
		GpRegion *	region
	)

Definition at line 5434 of file metafile.c.

{
    GpStatus stat;
    DWORD brush_id;
    DWORD region_id;
    EmfPlusFillRegion *fill_region_record;
    BOOL inline_color;
 
    if (metafile->metafile_type != MetafileTypeEmfPlusOnly &&
            metafile->metafile_type != MetafileTypeEmfPlusDual)
    {
        FIXME("metafile type not supported: %i\n", metafile->metafile_type);
        return NotImplemented;
    }
 
    inline_color = (brush->bt == BrushTypeSolidColor);
    if (!inline_color)
    {
        stat = METAFILE_AddBrushObject(metafile, brush, &brush_id);
        if (stat != Ok)
            return stat;
    }
 
    stat = METAFILE_AddRegionObject(metafile, region, &region_id);
    if (stat != Ok)
        return stat;
 
    stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeFillRegion, sizeof(EmfPlusFillRegion),
        (void**)&fill_region_record);
    if (stat != Ok)
        return stat;
 
    fill_region_record->Header.Flags = region_id;
 
    if (inline_color)
    {
        fill_region_record->Header.Flags |= 0x8000;
        fill_region_record->data.Color = ((GpSolidFill*)brush)->color;
    }
    else
        fill_region_record->data.BrushId = brush_id;
 
    METAFILE_WriteRecords(metafile);
 
    return Ok;
}

Referenced by GdipFillRegion().

METAFILE_Free()

void METAFILE_Free

(

GpMetafile *

metafile

)

Definition at line 687 of file metafile.c.

{
    unsigned int i;
 
    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 941 of file metafile.c.

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

Referenced by GdipGetDC().

METAFILE_GetGraphicsContext()

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

Definition at line 921 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 = metafile->logical_dpix;
        metafile->record_graphics->yres = metafile->logical_dpiy;
        metafile->record_graphics->printer_display = metafile->printer_display;
    }
 
    return stat;
}

Referenced by GdipGetImageGraphicsContext().

METAFILE_GraphicsClear()

GpStatus METAFILE_GraphicsClear	(	GpMetafile *	metafile,
		ARGB	color
	)

Definition at line 960 of file metafile.c.

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

Referenced by GdipGraphicsClear().

METAFILE_GraphicsDeleted()

GpStatus METAFILE_GraphicsDeleted

(

GpMetafile *

metafile

)

Definition at line 1675 of file metafile.c.

{
    GpStatus stat;
 
    stat = METAFILE_WriteEndOfFile(metafile);
    metafile->record_graphics = NULL;
 
    metafile->hemf = CloseEnhMetaFile(metafile->record_dc);
    metafile->record_dc = NULL;
 
    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;
 
            gdi_bounds_rc = header.EmfHeader.rclBounds;
            if (gdi_bounds_rc.right > gdi_bounds_rc.left &&
                gdi_bounds_rc.bottom > gdi_bounds_rc.top)
            {
                GpPointF *af_min = &metafile->auto_frame_min;
                GpPointF *af_max = &metafile->auto_frame_max;
 
                af_min->X = fmin(af_min->X, gdi_bounds_rc.left);
                af_min->Y = fmin(af_min->Y, gdi_bounds_rc.top);
                af_max->X = fmax(af_max->X, gdi_bounds_rc.right);
                af_max->Y = fmax(af_max->Y, gdi_bounds_rc.bottom);
            }
 
            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);
 
            buffer_size = GetEnhMetaFileBits(metafile->hemf, 0, NULL);
            buffer = malloc(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;
 
                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 = malloc(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);
 
            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 1482 of file metafile.c.

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

Referenced by GdipMultiplyWorldTransform().

METAFILE_OffsetClip()

GpStatus METAFILE_OffsetClip	(	GpMetafile *	metafile,
		REAL	dx,
		REAL	dy
	)

Definition at line 5581 of file metafile.c.

{
    EmfPlusOffsetClip *record;
    GpStatus stat;
 
    if (metafile->metafile_type == MetafileTypeEmf)
    {
        FIXME("stub!\n");
        return NotImplemented;
    }
 
    stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeOffsetClip,
        sizeof(*record), (void **)&record);
    if (stat != Ok)
        return stat;
 
    record->dx = dx;
    record->dy = dy;
 
    METAFILE_WriteRecords(metafile);
 
    return Ok;
}

Referenced by GdipTranslateClip().

METAFILE_ReleaseDC()

GpStatus METAFILE_ReleaseDC	(	GpMetafile *	metafile,
		HDC	hdc
	)

Definition at line 1667 of file metafile.c.

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

Referenced by GdipReleaseDC().

METAFILE_ResetClip()

GpStatus METAFILE_ResetClip

(

GpMetafile *

metafile

)

Definition at line 5605 of file metafile.c.

{
    EmfPlusRecordHeader *record;
    GpStatus stat;
 
    if (metafile->metafile_type == MetafileTypeEmf)
    {
        FIXME("stub!\n");
        return NotImplemented;
    }
 
    stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeResetClip,
        sizeof(*record), (void **)&record);
    if (stat != Ok)
        return stat;
 
    METAFILE_WriteRecords(metafile);
 
    return Ok;
}

Referenced by GdipResetClip().

METAFILE_ResetWorldTransform()

GpStatus METAFILE_ResetWorldTransform

(

GpMetafile *

metafile

)

Definition at line 1546 of file metafile.c.

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

Referenced by GdipResetWorldTransform().

METAFILE_RestoreGraphics()

GpStatus METAFILE_RestoreGraphics	(	GpMetafile *	metafile,
		DWORD	StackIndex
	)

Definition at line 1647 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusContainerRecord *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeRestore,
            sizeof(EmfPlusContainerRecord), (void **)&record);
        if (stat != Ok)
            return stat;
 
        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 1503 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusRotateWorldTransform *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeRotateWorldTransform,
            sizeof(EmfPlusRotateWorldTransform), (void **)&record);
        if (stat != Ok)
            return stat;
 
        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 1627 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusContainerRecord *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeSave,
            sizeof(EmfPlusContainerRecord), (void **)&record);
        if (stat != Ok)
            return stat;
 
        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 1460 of file metafile.c.

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

Referenced by GdipScaleWorldTransform().

METAFILE_SetClipPath()

GpStatus METAFILE_SetClipPath	(	GpMetafile *	metafile,
		GpPath *	path,
		CombineMode	mode
	)

Definition at line 5626 of file metafile.c.

{
    EmfPlusRecordHeader *record;
    DWORD path_id;
    GpStatus stat;
 
    if (metafile->metafile_type == MetafileTypeEmf)
    {
        FIXME("stub!\n");
        return NotImplemented;
    }
 
    stat = METAFILE_AddPathObject(metafile, path, &path_id);
    if (stat != Ok) return stat;
 
    stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeSetClipPath,
        sizeof(*record), (void **)&record);
    if (stat != Ok)
        return stat;
 
    record->Flags = ((mode & 0xf) << 8) | path_id;
 
    METAFILE_WriteRecords(metafile);
 
    return Ok;
}

Referenced by GdipSetClipPath().

METAFILE_SetClipRect()

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

Definition at line 1350 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusSetClipRect *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeSetClipRect,
                sizeof(EmfPlusSetClipRect), (void **)&record);
        if (stat != Ok)
            return stat;
 
        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 1395 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, EmfPlusRecordTypeSetClipRegion, sizeof(*record), (void**)&record);
    if (stat != Ok) return stat;
 
    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 1419 of file metafile.c.

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

Referenced by GdipResetPageTransform(), GdipSetPageScale(), and GdipSetPageUnit().

METAFILE_SetRenderingOrigin()

GpStatus METAFILE_SetRenderingOrigin	(	GpMetafile *	metafile,
		INT	x,
		INT	y
	)

Definition at line 5653 of file metafile.c.

{
    EmfPlusSetRenderingOrigin *record;
    GpStatus stat;
 
    if (metafile->metafile_type == MetafileTypeEmf)
    {
        FIXME("stub!\n");
        return NotImplemented;
    }
 
    stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeSetRenderingOrigin,
        sizeof(*record), (void **)&record);
    if (stat != Ok)
        return stat;
 
    record->x = x;
    record->y = y;
 
    METAFILE_WriteRecords(metafile);
 
    return Ok;
}

Referenced by GdipSetRenderingOrigin().

METAFILE_SetWorldTransform()

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

Definition at line 1440 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusSetWorldTransform *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeSetWorldTransform,
            sizeof(EmfPlusSetWorldTransform), (void **)&record);
        if (stat != Ok)
            return stat;
 
        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 1524 of file metafile.c.

{
    if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
    {
        EmfPlusTranslateWorldTransform *record;
        GpStatus stat;
 
        stat = METAFILE_AllocateRecord(metafile, EmfPlusRecordTypeTranslateWorldTransform,
            sizeof(EmfPlusTranslateWorldTransform), (void **)&record);
        if (stat != Ok)
            return stat;
 
        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,
		BOOL	printer_display
	)

Definition at line 356 of file gdiplus.c.

{
    switch (unit)
    {
    case UnitPixel:
    case UnitWorld:
        return pixels;
    case UnitDisplay:
        if (printer_display)
            return pixels * 100.0 / dpi;
        else
            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().

set_rect()

static void set_rect ( GpRectF *  rect, REAL  x, REAL  y, REAL  width, REAL  height  )

inlinestatic

Definition at line 690 of file gdiplus_private.h.

{
    rect->X = x;
    rect->Y = y;
    rect->Width = width;
    rect->Height = height;
}

Referenced by GdipAddPathRectanglesI(), GdipAddPathStringI(), GdipCombineRegionRectI(), GdipCreateLineBrushFromRectI(), GdipCreateMatrix3I(), GdipCreateRegionRectI(), GdipDrawArc(), GdipDrawEllipse(), GdipDrawImagePointsRect(), GdipDrawRectangle(), GdipDrawRectanglesI(), GdipFillEllipse(), GdipFillPie(), GdipFillRectangle(), GdipFillRectangleI(), GdipFillRectanglesI(), GdipMeasureDriverString(), GdipMeasureString(), GdipRecordMetafileI(), GdipRecordMetafileStreamI(), GdipSetClipRect(), and test_boundsrect().

terminate_encoder_wic()

GpStatus terminate_encoder_wic

(

GpImage *

image

)

Definition at line 4655 of file image.c.

{
    if (!image->encoder)
        return Ok;
    else
    {
        HRESULT hr = IWICBitmapEncoder_Commit(image->encoder);
        IWICBitmapEncoder_Release(image->encoder);
        image->encoder = NULL;
        return hresult_to_status(hr);
    }
}

Referenced by encode_image_wic(), free_image_data(), GdipSaveAddImage(), GdipSaveImageToFile(), initialize_encoder_wic(), and move_bitmap().

trace_path()

GpStatus trace_path	(	GpGraphics *	graphics,
		GpPath *	path
	)

Definition at line 2127 of file graphics.c.

{
    HDC hdc;
    GpStatus result;
 
    result = gdi_dc_acquire(graphics, &hdc);
    if (result != Ok)
        return result;
 
    BeginPath(hdc);
    result = draw_poly(graphics, NULL, path->pathdata.Points,
                       path->pathdata.Types, path->pathdata.Count, FALSE);
    EndPath(hdc);
 
    gdi_dc_release(graphics, hdc);
 
    return result;
}

Referenced by get_path_hrgn().

transform_properties()

void transform_properties	(	GpGraphics *	graphics,
		GDIPCONST GpMatrix *	matrix,
		BOOL	graphics_transform,
		REAL *	rel_width,
		REAL *	rel_height,
		REAL *	angle
	)

Definition at line 5696 of file graphics.c.

{
    GpPointF pt[3] = {{0.0f, 0.0f}, {1.0f, 0.0f}, {0.0f, 1.0f}};
    GpMatrix xform;
 
    if (matrix)
    {
        xform = *matrix;
        GdipTransformMatrixPoints(&xform, pt, 3);
    }
 
    if (graphics_transform)
        gdip_transform_points(graphics, WineCoordinateSpaceGdiDevice, CoordinateSpaceWorld, pt, 3);
 
    if (rel_width)
        *rel_width = hypotf(pt[1].Y - pt[0].Y, pt[1].X - pt[0].X);
    if (rel_height)
        *rel_height = hypotf(pt[2].Y - pt[0].Y, pt[2].X - pt[0].X);
    if (angle)
        *angle = -gdiplus_atan2((pt[1].Y - pt[0].Y), (pt[1].X - pt[0].X));
}

Referenced by GdipDrawString(), GdipGetLogFontW(), GdipMeasureCharacterRanges(), GdipMeasureString(), and get_font_hfont().

units_scale()

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

Definition at line 382 of file gdiplus.c.

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

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,
		BOOL	printer_display
	)

Definition at line 329 of file gdiplus.c.

{
    switch (unit)
    {
    case UnitPixel:
    case UnitWorld:
        return units;
    case UnitDisplay:
        if (printer_display)
            return units * dpi * 0.01f;
        else
            return units;
    case UnitPoint:
        return units * dpi * inch_per_point;
    case UnitInch:
        return units * dpi;
    case UnitDocument:
        return units * dpi * (1.0f / 300.0f); /* Per MSDN */
    case UnitMillimeter:
        return units * dpi * inch_per_mm;
    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().

widen_flat_path_anchors()

GpStatus widen_flat_path_anchors	(	GpPath *	flat_path,
		GpPen *	pen,
		REAL	pen_width,
		GpPath **	anchors
	)

Definition at line 2551 of file graphicspath.c.

{
    GpStatus stat;
    path_list_node_t *points=NULL, *last_point=NULL;
 
    if (!flat_path || !pen)
        return InvalidParameter;
 
    if (init_path_list(&points, 314.0, 22.0))
    {
        last_point = points;
 
        stat = GdipCreatePath(flat_path->fill, anchors);
        if (stat == Ok)
        {
            widen_anchors(flat_path, pen, pen_width, &last_point);
 
            if (!path_list_to_path(points->next, *anchors))
                stat = OutOfMemory;
 
            if (stat != Ok)
            {
                GdipDeletePath(*anchors);
                *anchors = NULL;
            }
        }
        free_path_list(points);
    }
    else
        stat = OutOfMemory;
 
    /* FIXME: Apply insets to flat_path */
 
    return stat;
}

Referenced by SOFTWARE_GdipDrawThinPath().

write_path_data()

DWORD write_path_data	(	GpPath *	path,
		void *	data
	)

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

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

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

Variable Documentation

default_drawstring_format

const struct GpStringFormat default_drawstring_format

extern

Definition at line 35 of file stringformat.c.

Referenced by gdip_format_string(), GdipAddPathString(), and init_generic_string_formats().