Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-02-20 15:35:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Sync gdiplus with Wine 1.1.29

Browse source 
svn path=/trunk/; revision=42989
This commit is contained in:
Dmitry Chapyshev 2009-09-03 15:07:25 +00:00
parent 2b26c07762
commit 5a6e6bdf2a
10 changed files with 1905 additions and 503 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

51
reactos/dll/win32/gdiplus/brush.c
View file

@ -288,6 +288,17 @@ GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF* startpoint,
(*line)->rect.Width = fabs(startpoint->X - endpoint->X);
(*line)->rect.Height = fabs(startpoint->Y - endpoint->Y);
if ((*line)->rect.Width == 0)
{
(*line)->rect.X -= (*line)->rect.Height / 2.0f;
(*line)->rect.Width = (*line)->rect.Height;
}
else if ((*line)->rect.Height == 0)
{
(*line)->rect.Y -= (*line)->rect.Width / 2.0f;
(*line)->rect.Height = (*line)->rect.Width;
}
(*line)->blendcount = 1;
(*line)->blendfac = GdipAlloc(sizeof(REAL));
(*line)->blendpos = GdipAlloc(sizeof(REAL));
@ -686,9 +697,9 @@ GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage *image,
n_y + n_height > ((GpBitmap*)image)->height)
return InvalidParameter;
IPicture_get_Handle(image->picture, (OLE_HANDLE*)&hbm);
hbm = ((GpBitmap*)image)->hbitmap;
if(!hbm) return GenericError;
IPicture_get_CurDC(image->picture, &hdc);
hdc = ((GpBitmap*)image)->hdc;
bm_is_selected = (hdc != 0);
pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
@ -1342,6 +1353,13 @@ GpStatus WINGDIPAPI GdipSetPathGradientBlend(GpPathGradient *brush, GDIPCONST RE
return NotImplemented;
}
GpStatus WINGDIPAPI GdipSetPathGradientPresetBlend(GpPathGradient *brush,
GDIPCONST ARGB *blend, GDIPCONST REAL *pos, INT count)
{
FIXME("(%p,%p,%p,%i): stub\n", brush, blend, pos, count);
return NotImplemented;
}
GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient *grad,
ARGB argb)
{
@ -1551,12 +1569,33 @@ GpStatus WINGDIPAPI GdipRotateTextureTransform(GpTexture* brush, REAL angle,
GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient *brush, REAL focus,
REAL scale)
{
static int calls;
REAL factors[3];
REAL positions[3];
int num_points = 0;
if(!(calls++))
FIXME("not implemented\n");
TRACE("(%p,%.2f,%.2f)\n", brush, focus, scale);
return NotImplemented;
if (!brush) return InvalidParameter;
if (focus != 0.0)
{
factors[num_points] = 0.0;
positions[num_points] = 0.0;
num_points++;
}
factors[num_points] = scale;
positions[num_points] = focus;
num_points++;
if (focus != 1.0)
{
factors[num_points] = 0.0;
positions[num_points] = 1.0;
num_points++;
}
return GdipSetLineBlend(brush, factors, positions, num_points);
}
GpStatus WINGDIPAPI GdipSetLinePresetBlend(GpLineGradient *brush,

19
reactos/dll/win32/gdiplus/gdiplus.c
View file

@ -399,6 +399,25 @@ BOOL lengthen_path(GpPath *path, INT len)
return TRUE;
}
void convert_32bppARGB_to_32bppPARGB(UINT width, UINT height,
BYTE *dst_bits, INT dst_stride, const BYTE *src_bits, INT src_stride)
{
UINT 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 / 255;
*dst++ = *src++ * alpha / 255;
*dst++ = *src++ * alpha / 255;
*dst++ = *src++;
}
}
}
/* recursive deletion of GpRegion nodes */
inline void delete_element(region_element* element)
{

1
reactos/dll/win32/gdiplus/gdiplus.rbuild
View file

@ -27,6 +27,7 @@
<library>user32</library>
<library>gdi32</library>
<library>kernel32</library>
<library>windowscodecs</library>
<library>ntdll</library>
</module>
</group>

30
reactos/dll/win32/gdiplus/gdiplus.spec
View file

@ -165,11 +165,11 @@
@ stdcall GdipDrawClosedCurveI(ptr ptr ptr long)
@ stdcall GdipDrawCurve2(ptr ptr ptr long long)
@ stdcall GdipDrawCurve2I(ptr ptr ptr long long)
@ stub GdipDrawCurve3
@ stub GdipDrawCurve3I
@ stdcall GdipDrawCurve3(ptr ptr ptr long long long long)
@ stdcall GdipDrawCurve3I(ptr ptr ptr long long long long)
@ stdcall GdipDrawCurve(ptr ptr ptr long)
@ stdcall GdipDrawCurveI(ptr ptr ptr long)
@ stub GdipDrawDriverString
@ stdcall GdipDrawDriverString(ptr ptr long ptr ptr ptr long ptr)
@ stdcall GdipDrawEllipse(ptr ptr long long long long)
@ stdcall GdipDrawEllipseI(ptr ptr long long long long)
@ stdcall GdipDrawImage(ptr ptr long long)
@ -291,7 +291,7 @@
@ stdcall GdipGetImageHeight(ptr ptr)
@ stdcall GdipGetImageHorizontalResolution(ptr ptr)
@ stub GdipGetImageItemData
@ stub GdipGetImagePalette
@ stdcall GdipGetImagePalette(ptr ptr long)
@ stdcall GdipGetImagePaletteSize(ptr ptr)
@ stdcall GdipGetImagePixelFormat(ptr ptr)
@ stdcall GdipGetImageRawFormat(ptr ptr)
@ -400,8 +400,8 @@
@ stub GdipGetTextureImage
@ stdcall GdipGetTextureTransform(ptr ptr)
@ stdcall GdipGetTextureWrapMode(ptr ptr)
@ stub GdipGetVisibleClipBounds
@ stub GdipGetVisibleClipBoundsI
@ stdcall GdipGetVisibleClipBounds(ptr ptr)
@ stdcall GdipGetVisibleClipBoundsI(ptr ptr)
@ stdcall GdipGetWorldTransform(ptr ptr)
@ stdcall GdipGraphicsClear(ptr long)
@ stub GdipGraphicsSetAbort
@ -429,18 +429,18 @@
@ stdcall GdipIsVisiblePathPointI(ptr long long ptr ptr)
@ stdcall GdipIsVisiblePoint(ptr long long ptr)
@ stdcall GdipIsVisiblePointI(ptr long long ptr)
@ stub GdipIsVisibleRect
@ stub GdipIsVisibleRectI
@ stub GdipIsVisibleRegionPoint
@ stub GdipIsVisibleRegionPointI
@ stub GdipIsVisibleRegionRect
@ stub GdipIsVisibleRegionRectI
@ stdcall GdipIsVisibleRect(ptr long long long long ptr)
@ stdcall GdipIsVisibleRectI(ptr long long long long ptr)
@ stdcall GdipIsVisibleRegionPoint(ptr long long ptr ptr)
@ stdcall GdipIsVisibleRegionPointI(ptr long long ptr ptr)
@ stdcall GdipIsVisibleRegionRect(ptr long long long long ptr ptr)
@ stdcall GdipIsVisibleRegionRectI(ptr long long long long ptr ptr)
@ stdcall GdipLoadImageFromFile(wstr ptr)
@ stdcall GdipLoadImageFromFileICM(wstr ptr)
@ stdcall GdipLoadImageFromStream(ptr ptr)
@ stdcall GdipLoadImageFromStreamICM(ptr ptr)
@ stdcall GdipMeasureCharacterRanges(ptr wstr long ptr ptr ptr long ptr)
@ stub GdipMeasureDriverString
@ stdcall GdipMeasureDriverString(ptr ptr long ptr ptr long ptr ptr)
@ stdcall GdipMeasureString(ptr wstr long ptr ptr ptr ptr ptr ptr)
@ stub GdipMultiplyLineTransform
@ stdcall GdipMultiplyMatrix(ptr ptr long)
@ -469,7 +469,7 @@
@ stub GdipRecordMetafile
@ stdcall GdipRecordMetafileFileName(wstr long long ptr long wstr ptr)
@ stdcall GdipRecordMetafileFileNameI(wstr long long ptr long wstr ptr)
@ stub GdipRecordMetafileI
@ stdcall GdipRecordMetafileI(long long ptr long wstr ptr)
@ stub GdipRecordMetafileStream
@ stub GdipRecordMetafileStreamI
@ stdcall GdipReleaseDC(ptr ptr)
@ -556,7 +556,7 @@
@ stdcall GdipSetPathGradientGammaCorrection(ptr long)
@ stub GdipSetPathGradientLinearBlend
@ stub GdipSetPathGradientPath
@ stub GdipSetPathGradientPresetBlend
@ stdcall GdipSetPathGradientPresetBlend(ptr ptr ptr long)
@ stdcall GdipSetPathGradientSigmaBlend(ptr long long)
@ stdcall GdipSetPathGradientSurroundColorsWithCount(ptr ptr ptr)
@ stub GdipSetPathGradientTransform

22
reactos/dll/win32/gdiplus/gdiplus_private.h
View file

@ -29,6 +29,7 @@
#include "objbase.h"
#include "ocidl.h"
#include "wine/list.h"
#include "gdiplus.h"
@ -67,6 +68,11 @@ static inline INT roundr(REAL x)
return (INT) floorf(x + 0.5);
}
static inline INT ceilr(REAL x)
{
return (INT) ceilf(x);
}
static inline REAL deg2rad(REAL degrees)
{
return M_PI * degrees / 180.0;
@ -74,6 +80,9 @@ static inline REAL deg2rad(REAL degrees)
extern const char *debugstr_rectf(CONST RectF* rc);
extern void convert_32bppARGB_to_32bppPARGB(UINT width, UINT height,
BYTE *dst_bits, INT dst_stride, const BYTE *src_bits, INT src_stride);
struct GpPen{
UINT style;
GpUnit unit;
@ -109,6 +118,8 @@ struct GpGraphics{
BOOL busy; /* hdc handle obtained by GdipGetDC */
GpRegion *clip;
UINT textcontrast; /* not used yet. get/set only */
struct list containers;
GraphicsContainer contid; /* last-issued container ID */
};
struct GpBrush{
@ -214,14 +225,25 @@ struct GpBitmap{
ImageLockMode lockmode;
INT numlocks;
BYTE *bitmapbits; /* pointer to the buffer we passed in BitmapLockBits */
HBITMAP hbitmap;
HDC hdc;
BYTE *bits; /* actual image bits if this is a DIB */
INT stride; /* stride of bits if this is a DIB */
};
struct GpCachedBitmap{
GpImage *image;
};
struct color_key{
BOOL enabled;
ARGB low;
ARGB high;
};
struct GpImageAttributes{
WrapMode wrap;
struct color_key colorkeys[ColorAdjustTypeCount];
};
struct GpFont{

721
reactos/dll/win32/gdiplus/graphics.c
View file

File diff suppressed because it is too large Load diff

1363
reactos/dll/win32/gdiplus/image.c
View file

File diff suppressed because it is too large Load diff

11
reactos/dll/win32/gdiplus/imageattributes.c
View file

@ -68,15 +68,16 @@ GpStatus WINGDIPAPI GdipDisposeImageAttributes(GpImageAttributes *imageattr)
GpStatus WINGDIPAPI GdipSetImageAttributesColorKeys(GpImageAttributes *imageattr,
ColorAdjustType type, BOOL enableFlag, ARGB colorLow, ARGB colorHigh)
{
static int calls;
TRACE("(%p,%u,%i,%08x,%08x)\n", imageattr, type, enableFlag, colorLow, colorHigh);
if(!imageattr)
if(!imageattr || type >= ColorAdjustTypeCount)
return InvalidParameter;
if(!(calls++))
FIXME("not implemented\n");
imageattr->colorkeys[type].enabled = enableFlag;
imageattr->colorkeys[type].low = colorLow;
imageattr->colorkeys[type].high = colorHigh;
return NotImplemented;
return Ok;
}
GpStatus WINGDIPAPI GdipSetImageAttributesColorMatrix(GpImageAttributes *imageattr,

157
reactos/dll/win32/gdiplus/region.c
View file

@ -579,51 +579,63 @@ GpStatus WINGDIPAPI GdipCreateRegionRgnData(GDIPCONST BYTE *data, INT size, GpRe
*/
GpStatus WINGDIPAPI GdipCreateRegionHrgn(HRGN hrgn, GpRegion **region)
{
union {
RGNDATA data;
char buf[sizeof(RGNDATAHEADER) + sizeof(RECT)];
} rdata;
DWORD size;
GpRectF rectf;
GpPath *path;
LPRGNDATA buf;
LPRECT rect;
GpStatus stat;
GpPath* path;
GpRegion* local;
int i;
TRACE("(%p, %p)\n", hrgn, region);
if(!region || !(size = GetRegionData(hrgn, 0, NULL)))
return InvalidParameter;
if(size > sizeof(RGNDATAHEADER) + sizeof(RECT)){
FIXME("Only simple rect regions supported.\n");
*region = NULL;
return NotImplemented;
}
buf = GdipAlloc(size);
if(!buf)
return OutOfMemory;
if(!GetRegionData(hrgn, sizeof(rdata), &rdata.data))
if(!GetRegionData(hrgn, size, buf)){
GdipFree(buf);
return GenericError;
}
/* return empty region */
if(IsRectEmpty(&rdata.data.rdh.rcBound)){
stat = GdipCreateRegion(region);
if(stat == Ok)
GdipSetEmpty(*region);
if(buf->rdh.nCount == 0){
if((stat = GdipCreateRegion(&local)) != Ok){
GdipFree(buf);
return stat;
}
if((stat = GdipSetEmpty(local)) != Ok){
GdipFree(buf);
GdipDeleteRegion(local);
return stat;
}
*region = local;
GdipFree(buf);
return Ok;
}
if((stat = GdipCreatePath(FillModeAlternate, &path)) != Ok){
GdipFree(buf);
return stat;
}
rectf.X = (REAL)rdata.data.rdh.rcBound.left;
rectf.Y = (REAL)rdata.data.rdh.rcBound.top;
rectf.Width = (REAL)rdata.data.rdh.rcBound.right - rectf.X;
rectf.Height = (REAL)rdata.data.rdh.rcBound.bottom - rectf.Y;
stat = GdipCreatePath(FillModeAlternate, &path);
if(stat != Ok)
return stat;
GdipAddPathRectangle(path, rectf.X, rectf.Y, rectf.Width, rectf.Height);
rect = (LPRECT)buf->Buffer;
for(i = 0; i < buf->rdh.nCount; i++){
if((stat = GdipAddPathRectangle(path, (REAL)rect->left, (REAL)rect->top,
(REAL)(rect->right - rect->left), (REAL)(rect->bottom - rect->top))) != Ok){
GdipFree(buf);
GdipDeletePath(path);
return stat;
}
rect++;
}
stat = GdipCreateRegionPath(path, region);
GdipDeletePath(path);
GdipFree(buf);
GdipDeletePath(path);
return stat;
}
@ -657,7 +669,8 @@ GpStatus WINGDIPAPI GdipGetRegionBounds(GpRegion *region, GpGraphics *graphics,
if(!region || !graphics || !rect)
return InvalidParameter;
status = GdipGetRegionHRgn(region, graphics, &hrgn);
/* Contrary to MSDN, native ignores the graphics transform. */
status = GdipGetRegionHRgn(region, NULL, &hrgn);
if(status != Ok)
return status;
@ -1114,6 +1127,92 @@ GpStatus WINGDIPAPI GdipIsInfiniteRegion(GpRegion *region, GpGraphics *graphics,
return Ok;
}
/*****************************************************************************
* GdipIsVisibleRegionRect [GDIPLUS.@]
*/
GpStatus WINGDIPAPI GdipIsVisibleRegionRect(GpRegion* region, REAL x, REAL y, REAL w, REAL h, GpGraphics *graphics, BOOL *res)
{
HRGN hrgn;
GpStatus stat;
RECT rect;
TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %p, %p)\n", region, x, y, w, h, graphics, res);
if(!region || !res)
return InvalidParameter;
if((stat = GdipGetRegionHRgn(region, NULL, &hrgn)) != Ok)
return stat;
/* infinite */
if(!hrgn){
*res = TRUE;
return Ok;
}
rect.left = ceilr(x);
rect.top = ceilr(y);
rect.right = ceilr(x + w);
rect.bottom = ceilr(y + h);
*res = RectInRegion(hrgn, &rect);
DeleteObject(hrgn);
return Ok;
}
/*****************************************************************************
* GdipIsVisibleRegionRectI [GDIPLUS.@]
*/
GpStatus WINGDIPAPI GdipIsVisibleRegionRectI(GpRegion* region, INT x, INT y, INT w, INT h, GpGraphics *graphics, BOOL *res)
{
TRACE("(%p, %d, %d, %d, %d, %p, %p)\n", region, x, y, w, h, graphics, res);
if(!region || !res)
return InvalidParameter;
return GdipIsVisibleRegionRect(region, (REAL)x, (REAL)y, (REAL)w, (REAL)h, graphics, res);
}
/*****************************************************************************
* GdipIsVisibleRegionPoint [GDIPLUS.@]
*/
GpStatus WINGDIPAPI GdipIsVisibleRegionPoint(GpRegion* region, REAL x, REAL y, GpGraphics *graphics, BOOL *res)
{
HRGN hrgn;
GpStatus stat;
TRACE("(%p, %.2f, %.2f, %p, %p)\n", region, x, y, graphics, res);
if(!region || !res)
return InvalidParameter;
if((stat = GdipGetRegionHRgn(region, NULL, &hrgn)) != Ok)
return stat;
/* infinite */
if(!hrgn){
*res = TRUE;
return Ok;
}
*res = PtInRegion(hrgn, roundr(x), roundr(y));
DeleteObject(hrgn);
return Ok;
}
/*****************************************************************************
* GdipIsVisibleRegionPointI [GDIPLUS.@]
*/
GpStatus WINGDIPAPI GdipIsVisibleRegionPointI(GpRegion* region, INT x, INT y, GpGraphics *graphics, BOOL *res)
{
TRACE("(%p, %d, %d, %p, %p)\n", region, x, y, graphics, res);
return GdipIsVisibleRegionPoint(region, (REAL)x, (REAL)y, graphics, res);
}
/*****************************************************************************
* GdipSetEmpty [GDIPLUS.@]
*/

33
reactos/include/psdk/gdiplusflat.h
View file

@ -39,11 +39,15 @@ GpStatus WINGDIPAPI GdipSetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap*,R
GpStatus WINGDIPAPI GdipSetAdjustableArrowCapWidth(GpAdjustableArrowCap*,REAL);
/* Bitmap */
GpStatus WINGDIPAPI GdipBitmapApplyEffect(GpBitmap*,CGpEffect*,RECT*,BOOL,VOID**,INT*);
GpStatus WINGDIPAPI GdipBitmapCreateApplyEffect(GpBitmap**,INT,CGpEffect*,RECT*,RECT*,GpBitmap**,BOOL,VOID**,INT*);
GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap*,INT,INT,ARGB*);
GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap*,GDIPCONST GpRect*,UINT,
PixelFormat,BitmapData*);
GpStatus WINGDIPAPI GdipBitmapSetPixel(GpBitmap*,INT,INT,ARGB);
GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap*,BitmapData*);
GpStatus WINGDIPAPI GdipCloneBitmapArea(REAL,REAL,REAL,REAL,PixelFormat,GpBitmap*,GpBitmap**);
GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT,INT,INT,INT,PixelFormat,GpBitmap*,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR*,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR*,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO*,VOID*,GpBitmap**);
@ -55,6 +59,9 @@ GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT,INT,INT,PixelFormat,BYTE*,
GpBitmap**);
GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream*,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream*,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap*,HBITMAP*,ARGB);
GpStatus WINGDIPAPI GdipCreateHICONFromBitmap(GpBitmap*,HICON*);
GpStatus WINGDIPAPI GdipDeleteEffect(CGpEffect*);
/* Brush */
GpStatus WINGDIPAPI GdipCloneBrush(GpBrush*,GpBrush**);
@ -118,6 +125,11 @@ GpStatus WINGDIPAPI GdipIsStyleAvailable(GDIPCONST GpFontFamily *, INT, BOOL*);
/* Graphics */
GpStatus WINGDIPAPI GdipFlush(GpGraphics*, GpFlushIntention);
GpStatus WINGDIPAPI GdipBeginContainer(GpGraphics*,GDIPCONST GpRectF*,GDIPCONST GpRectF*,GpUnit,GraphicsContainer*);
GpStatus WINGDIPAPI GdipBeginContainer2(GpGraphics*,GraphicsContainer*);
GpStatus WINGDIPAPI GdipBeginContainerI(GpGraphics*,GDIPCONST GpRect*,GDIPCONST GpRect*,GpUnit,GraphicsContainer*);
GpStatus WINGDIPAPI GdipEndContainer(GpGraphics*,GraphicsContainer);
GpStatus WINGDIPAPI GdipComment(GpGraphics*,UINT,GDIPCONST BYTE*);
GpStatus WINGDIPAPI GdipCreateFromHDC(HDC,GpGraphics**);
GpStatus WINGDIPAPI GdipCreateFromHDC2(HDC,HANDLE,GpGraphics**);
GpStatus WINGDIPAPI GdipCreateFromHWND(HWND,GpGraphics**);
@ -137,10 +149,16 @@ GpStatus WINGDIPAPI GdipDrawCurve(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT);
GpStatus WINGDIPAPI GdipDrawCurveI(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT);
GpStatus WINGDIPAPI GdipDrawCurve2(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT,REAL);
GpStatus WINGDIPAPI GdipDrawCurve2I(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT,REAL);
GpStatus WINGDIPAPI GdipDrawCurve3(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT,INT,INT,REAL);
GpStatus WINGDIPAPI GdipDrawCurve3I(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT,INT,INT,REAL);
GpStatus WINGDIPAPI GdipDrawEllipse(GpGraphics*,GpPen*,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipDrawEllipseI(GpGraphics*,GpPen*,INT,INT,INT,INT);
GpStatus WINGDIPAPI GdipDrawImage(GpGraphics*,GpImage*,REAL,REAL);
GpStatus WINGDIPAPI GdipDrawImageI(GpGraphics*,GpImage*,INT,INT);
GpStatus WINGDIPAPI GdipDrawImagePointRect(GpGraphics*,GpImage*,REAL,REAL,REAL,REAL,REAL,REAL,GpUnit);
GpStatus WINGDIPAPI GdipDrawImagePointRectI(GpGraphics*,GpImage*,INT,INT,INT,INT,INT,INT,GpUnit);
GpStatus WINGDIPAPI GdipDrawImagePoints(GpGraphics*,GpImage*,GDIPCONST GpPointF*,INT);
GpStatus WINGDIPAPI GdipDrawImagePointsI(GpGraphics*,GpImage*,GDIPCONST GpPoint*,INT);
GpStatus WINGDIPAPI GdipDrawImagePointsRect(GpGraphics*,GpImage*,
GDIPCONST GpPointF*,INT,REAL,REAL,REAL,REAL,GpUnit,
GDIPCONST GpImageAttributes*,DrawImageAbort,VOID*);
@ -210,9 +228,13 @@ GpStatus WINGDIPAPI GdipGetTextContrast(GpGraphics*,UINT*);
GpStatus WINGDIPAPI GdipGetTextRenderingHint(GpGraphics*,TextRenderingHint*);
GpStatus WINGDIPAPI GdipGetWorldTransform(GpGraphics*,GpMatrix*);
GpStatus WINGDIPAPI GdipGraphicsClear(GpGraphics*,ARGB);
GpStatus WINGDIPAPI GdipGetVisibleClipBounds(GpGraphics*,GpRectF*);
GpStatus WINGDIPAPI GdipGetVisibleClipBoundsI(GpGraphics*,GpRect*);
GpStatus WINGDIPAPI GdipIsClipEmpty(GpGraphics*, BOOL*);
GpStatus WINGDIPAPI GdipIsVisiblePoint(GpGraphics*,REAL,REAL,BOOL*);
GpStatus WINGDIPAPI GdipIsVisiblePointI(GpGraphics*,INT,INT,BOOL*);
GpStatus WINGDIPAPI GdipIsVisibleRect(GpGraphics*,REAL,REAL,REAL,REAL,BOOL*);
GpStatus WINGDIPAPI GdipIsVisibleRectI(GpGraphics*,INT,INT,INT,INT,BOOL*);
GpStatus WINGDIPAPI GdipMeasureCharacterRanges(GpGraphics*, GDIPCONST WCHAR*,
INT, GDIPCONST GpFont*, GDIPCONST RectF*, GDIPCONST GpStringFormat*, INT,
GpRegion**);
@ -281,6 +303,8 @@ GpStatus WINGDIPAPI GdipAddPathRectangle(GpPath*,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipAddPathRectangleI(GpPath*,INT,INT,INT,INT);
GpStatus WINGDIPAPI GdipAddPathRectangles(GpPath*,GDIPCONST GpRectF*,INT);
GpStatus WINGDIPAPI GdipAddPathRectanglesI(GpPath*,GDIPCONST GpRect*,INT);
GpStatus WINGDIPAPI GdipAddPathString(GpPath*,GDIPCONST WCHAR*,INT,GDIPCONST GpFontFamily*,INT,REAL,GDIPCONST RectF*,GDIPCONST GpStringFormat*);
GpStatus WINGDIPAPI GdipAddPathStringI(GpPath*,GDIPCONST WCHAR*,INT,GDIPCONST GpFontFamily*,INT,REAL,GDIPCONST Rect*,GDIPCONST GpStringFormat*);
GpStatus WINGDIPAPI GdipClearPathMarkers(GpPath*);
GpStatus WINGDIPAPI GdipClonePath(GpPath*,GpPath**);
GpStatus WINGDIPAPI GdipClosePathFigure(GpPath*);
@ -317,6 +341,7 @@ GpStatus WINGDIPAPI GdipTransformPath(GpPath*,GpMatrix*);
GpStatus WINGDIPAPI GdipCloneImage(GpImage*, GpImage**);
GpStatus WINGDIPAPI GdipCloneImageAttributes(GDIPCONST GpImageAttributes*,GpImageAttributes**);
GpStatus WINGDIPAPI GdipDisposeImage(GpImage*);
GpStatus WINGDIPAPI GdipEmfToWmfBits(HENHMETAFILE,UINT,LPBYTE,INT,INT);
GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage*,ImageItemData*);
GpStatus WINGDIPAPI GdipFindNextImageItem(GpImage*,ImageItemData*);
GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage*,UINT,UINT,PropertyItem*);
@ -326,6 +351,7 @@ GpStatus WINGDIPAPI GdipGetImageFlags(GpImage*,UINT*);
GpStatus WINGDIPAPI GdipGetImageHeight(GpImage*,UINT*);
GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage*,REAL*);
GpStatus WINGDIPAPI GdipGetImageItemData(GpImage*,ImageItemData*);
GpStatus WINGDIPAPI GdipGetImagePalette(GpImage*,ColorPalette*,INT);
GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage*,PixelFormat*);
GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage*,GUID*);
GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage*,UINT,UINT,GpImage**,GetThumbnailImageAbort,VOID*);
@ -389,6 +415,7 @@ GpStatus WINGDIPAPI GdipGetLineBlendCount(GpLineGradient*,INT*);
GpStatus WINGDIPAPI GdipSetLineColors(GpLineGradient*,ARGB,ARGB);
GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient*,BOOL);
GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient*,REAL,REAL);
GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient*,REAL,REAL);
GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient*,GpWrapMode);
/* Matrix */
@ -424,6 +451,8 @@ GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE,BOOL,
GDIPCONST WmfPlaceableFileHeader*,GpMetafile**);
GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR*, GDIPCONST WmfPlaceableFileHeader*,
GpMetafile**);
GpStatus WINGDIPAPI GdipCreateMetafileFromFile(GDIPCONST WCHAR*,GpMetafile**);
GpStatus WINGDIPAPI GdipCreateMetafileFromStream(IStream*,GpMetafile**);
GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit(GpMetafile*,UINT);
/* MetafileHeader */
@ -539,6 +568,10 @@ GpStatus WINGDIPAPI GdipGetRegionHRgn(GpRegion *, GpGraphics *, HRGN *);
GpStatus WINGDIPAPI GdipIsEmptyRegion(GpRegion *, GpGraphics *, BOOL *);
GpStatus WINGDIPAPI GdipIsEqualRegion(GpRegion *, GpRegion *, GpGraphics *, BOOL *);
GpStatus WINGDIPAPI GdipIsInfiniteRegion(GpRegion *, GpGraphics *, BOOL *);
GpStatus WINGDIPAPI GdipIsVisibleRegionPoint(GpRegion *, REAL, REAL, GpGraphics *, BOOL *);
GpStatus WINGDIPAPI GdipIsVisibleRegionPointI(GpRegion *, INT, INT, GpGraphics *, BOOL *);
GpStatus WINGDIPAPI GdipIsVisibleRegionRect(GpRegion *, REAL, REAL, REAL, REAL, GpGraphics *, BOOL *);
GpStatus WINGDIPAPI GdipIsVisibleRegionRectI(GpRegion *, INT, INT, INT, INT, GpGraphics *, BOOL *);
GpStatus WINGDIPAPI GdipSetEmpty(GpRegion *);
GpStatus WINGDIPAPI GdipSetInfinite(GpRegion *);
GpStatus WINGDIPAPI GdipTransformRegion(GpRegion *, GpMatrix *);