libs/newlib-cygwin
libs
/
newlib-cygwin
mirror of git://sourceware.org/git/newlib-cygwin.git
4
0
Fork 0
Code Issues Projects Releases Wiki Activity

2010-07-08 Markus Koenig <basilo@users.sourceforge.net> 

* include/gdiplus.h: New file.
        * include/gdiplus/gdiplus.h: New file.
        * include/gdiplus/gdiplusbase.h: New file.
        * include/gdiplus/gdiplusbrush.h: New file.
        * include/gdiplus/gdipluscolor.h: New file.
        * include/gdiplus/gdipluscolormatrix.h: New file.
        * include/gdiplus/gdipluseffects.h: New file.
        * include/gdiplus/gdiplusenums.h: New file.
        * include/gdiplus/gdiplusflat.h: New file.
        * include/gdiplus/gdiplusgpstubs.h: New file.
        * include/gdiplus/gdiplusgraphics.h: New file.
        * include/gdiplus/gdiplusheaders.h: New file.
        * include/gdiplus/gdiplusimageattributes.h: New file.
        * include/gdiplus/gdiplusimagecodec.h: New file.
        * include/gdiplus/gdiplusimaging.h: New file.
        * include/gdiplus/gdiplusimpl.h: New file.
        * include/gdiplus/gdiplusinit.h: New file.
        * include/gdiplus/gdipluslinecaps.h: New file.
        * include/gdiplus/gdiplusmatrix.h: New file.
        * include/gdiplus/gdiplusmem.h: New file.
        * include/gdiplus/gdiplusmetafile.h: New file.
        * include/gdiplus/gdiplusmetaheader.h: New file.
        * include/gdiplus/gdipluspath.h: New file.
        * include/gdiplus/gdipluspen.h: New file.
        * include/gdiplus/gdipluspixelformats.h: New file.
        * include/gdiplus/gdiplusstringformat.h: New file.
        * include/gdiplus/gdiplustypes.h: New file.
        * lib/gdiplus.c: New file containing GDI+ variable definitions
        and GUIDs.
        * lib/gdiplus.def: New file.
        * lib/Makefile.in: Add gdiplus.o to EXTRA_OBJS,
        add gdiplus.c to SOURCES.
        * lib/test.c: Include gdiplus.h.
This commit is contained in:
Chris Sutcliffe 2010-07-08 23:14:54 +00:00
parent 975a85f42c
commit cc077128d3
32 changed files with 11109 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
winsup/w32api/ChangeLog
View File

@ -1,3 +1,39 @@
2010-07-08 Markus Koenig <basilo@users.sourceforge.net>
* include/gdiplus.h: New file.
* include/gdiplus/gdiplus.h: New file.
* include/gdiplus/gdiplusbase.h: New file.
* include/gdiplus/gdiplusbrush.h: New file.
* include/gdiplus/gdipluscolor.h: New file.
* include/gdiplus/gdipluscolormatrix.h: New file.
* include/gdiplus/gdipluseffects.h: New file.
* include/gdiplus/gdiplusenums.h: New file.
* include/gdiplus/gdiplusflat.h: New file.
* include/gdiplus/gdiplusgpstubs.h: New file.
* include/gdiplus/gdiplusgraphics.h: New file.
* include/gdiplus/gdiplusheaders.h: New file.
* include/gdiplus/gdiplusimageattributes.h: New file.
* include/gdiplus/gdiplusimagecodec.h: New file.
* include/gdiplus/gdiplusimaging.h: New file.
* include/gdiplus/gdiplusimpl.h: New file.
* include/gdiplus/gdiplusinit.h: New file.
* include/gdiplus/gdipluslinecaps.h: New file.
* include/gdiplus/gdiplusmatrix.h: New file.
* include/gdiplus/gdiplusmem.h: New file.
* include/gdiplus/gdiplusmetafile.h: New file.
* include/gdiplus/gdiplusmetaheader.h: New file.
* include/gdiplus/gdipluspath.h: New file.
* include/gdiplus/gdipluspen.h: New file.
* include/gdiplus/gdipluspixelformats.h: New file.
* include/gdiplus/gdiplusstringformat.h: New file.
* include/gdiplus/gdiplustypes.h: New file.
* lib/gdiplus.c: New file containing GDI+ variable definitions
and GUIDs.
* lib/gdiplus.def: New file.
* lib/Makefile.in: Add gdiplus.o to EXTRA_OBJS,
add gdiplus.c to SOURCES.
* lib/test.c: Include gdiplus.h.
2010-06-28 Rick Rankin <rrankin1424-mingw@yahoo.com>
* include/psapi.h (PROCESS_MEMORY_COUNTERS_EX, PERFORMANCE_INFORMATION,

1
winsup/w32api/include/gdiplus.h Executable file
View File

@ -0,0 +1 @@
#include "gdiplus/gdiplus.h"

81
winsup/w32api/include/gdiplus/gdiplus.h Executable file
View File

@ -0,0 +1,81 @@
/*
* gdiplus.h
*
* GDI+ main header
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_H
#define __GDIPLUS_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#ifndef RC_INVOKED
#include <stddef.h>
#include <math.h>
#include <windef.h>
#include <wingdi.h>
#include <basetyps.h>
typedef _COM_interface IStream IStream;
typedef _COM_interface IDirectDrawSurface7 IDirectDrawSurface7;
#ifdef __cplusplus
namespace Gdiplus {
#endif
typedef float REAL;
typedef SHORT INT16;
typedef WORD UINT16;
#include "gdiplusenums.h"
#include "gdiplustypes.h"
#include "gdiplusgpstubs.h"
#include "gdiplusimaging.h"
#include "gdiplusinit.h"
#include "gdiplusmem.h"
#include "gdiplusmetaheader.h"
#include "gdipluspixelformats.h"
#include "gdipluscolor.h"
#include "gdipluscolormatrix.h"
#include "gdiplusflat.h"
#include "gdipluseffects.h"
#include "gdiplusimagecodec.h"
#ifdef __cplusplus
#include "gdiplusbase.h"
#include "gdiplusheaders.h"
#include "gdiplusimageattributes.h"
#include "gdiplusmatrix.h"
#include "gdiplusbrush.h"
#include "gdiplusmetafile.h"
#include "gdipluspen.h"
#include "gdiplusstringformat.h"
#include "gdipluspath.h"
#include "gdiplusgraphics.h"
#include "gdipluslinecaps.h"
#include "gdiplusimpl.h"
} /* namespace Gdiplus */
#endif /* __cplusplus */
#endif /* !RC_INVOKED */
#endif /* __GDIPLUS_H */

54
winsup/w32api/include/gdiplus/gdiplusbase.h Executable file
View File

@ -0,0 +1,54 @@
/*
* gdiplusbase.h
*
* GDI+ base class
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_BASE_H
#define __GDIPLUS_BASE_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#ifndef __cplusplus
#error "A C++ compiler is required to include gdiplusbase.h."
#endif
class GdiplusBase
{
public:
static void* operator new(size_t in_size)
{
return DllExports::GdipAlloc(in_size);
}
static void* operator new[](size_t in_size)
{
return DllExports::GdipAlloc(in_size);
}
static void operator delete(void *in_pVoid)
{
DllExports::GdipFree(in_pVoid);
}
static void operator delete[](void *in_pVoid)
{
DllExports::GdipFree(in_pVoid);
}
};
#endif /* __GDIPLUS_BASE_H */

606
winsup/w32api/include/gdiplus/gdiplusbrush.h Executable file
View File

@ -0,0 +1,606 @@
/*
* gdiplusbrush.h
*
* GDI+ brush classes
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_BRUSH_H
#define __GDIPLUS_BRUSH_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#ifndef __cplusplus
#error "A C++ compiler is required to include gdiplusbrush.h."
#endif
class Brush: public GdiplusBase
{
friend class HatchBrush;
friend class LinearGradientBrush;
friend class PathGradientBrush;
friend class SolidBrush;
friend class TextureBrush;
friend class Graphics;
friend class Pen;
public:
virtual ~Brush()
{
DllExports::GdipDeleteBrush(nativeBrush);
}
virtual Brush* Clone() const // each subclass must implement this
{
lastStatus = NotImplemented;
return NULL;
}
Status GetLastStatus() const
{
Status result = lastStatus;
lastStatus = Ok;
return result;
}
BrushType GetType() const
{
BrushType result = BrushTypeSolidColor;
updateStatus(DllExports::GdipGetBrushType(nativeBrush, &result));
return result;
}
private:
Brush(): nativeBrush(NULL), lastStatus(Ok) {}
Brush(GpBrush *brush, Status status):
nativeBrush(brush), lastStatus(status) {}
Brush(const Brush& brush);
Brush& operator=(const Brush&);
Status updateStatus(Status newStatus) const
{
if (newStatus != Ok) lastStatus = newStatus;
return newStatus;
}
GpBrush *nativeBrush;
mutable Status lastStatus;
};
class HatchBrush: public Brush
{
public:
HatchBrush(HatchStyle hatchStyle,
const Color& foreColor,
const Color& backColor = Color())
{
GpHatch *nativeHatch = NULL;
lastStatus = DllExports::GdipCreateHatchBrush(hatchStyle,
foreColor.GetValue(), backColor.GetValue(),
&nativeHatch);
nativeBrush = nativeHatch;
}
virtual HatchBrush* Clone() const
{
GpBrush *cloneBrush = NULL;
Status status = updateStatus(DllExports::GdipCloneBrush(
nativeBrush, &cloneBrush));
if (status == Ok) {
HatchBrush *result =
new HatchBrush(cloneBrush, lastStatus);
if (!result) {
DllExports::GdipDeleteBrush(cloneBrush);
updateStatus(OutOfMemory);
}
return result;
} else {
return NULL;
}
}
Status GetBackgroundColor(Color *color) const
{
return updateStatus(DllExports::GdipGetHatchBackgroundColor(
(GpHatch*) nativeBrush,
color ? &color->Value : NULL));
}
Status GetForegroundColor(Color *color) const
{
return updateStatus(DllExports::GdipGetHatchForegroundColor(
(GpHatch*) nativeBrush,
color ? &color->Value : NULL));
}
HatchStyle GetHatchStyle() const
{
HatchStyle result;
updateStatus(DllExports::GdipGetHatchStyle(
(GpHatch*) nativeBrush, &result));
return result;
}
private:
HatchBrush(GpBrush *brush, Status status): Brush(brush, status) {}
HatchBrush(const HatchBrush& brush);
HatchBrush& operator=(const HatchBrush&);
};
class LinearGradientBrush: public Brush
{
public:
LinearGradientBrush(const PointF& point1, const PointF& point2,
const Color& color1, const Color& color2)
{
GpLineGradient *nativeLineGradient = NULL;
lastStatus = DllExports::GdipCreateLineBrush(
&point1, &point2,
color1.GetValue(), color2.GetValue(),
WrapModeTile, &nativeLineGradient);
nativeBrush = nativeLineGradient;
}
LinearGradientBrush(const Point& point1, const Point& point2,
const Color& color1, const Color& color2)
{
GpLineGradient *nativeLineGradient = NULL;
lastStatus = DllExports::GdipCreateLineBrushI(
&point1, &point2,
color1.GetValue(), color2.GetValue(),
WrapModeTile, &nativeLineGradient);
nativeBrush = nativeLineGradient;
}
LinearGradientBrush(const RectF& rect, const Color& color1,
const Color& color2, LinearGradientMode mode)
{
GpLineGradient *nativeLineGradient = NULL;
lastStatus = DllExports::GdipCreateLineBrushFromRect(
&rect, color1.GetValue(), color2.GetValue(),
mode, WrapModeTile, &nativeLineGradient);
nativeBrush = nativeLineGradient;
}
LinearGradientBrush(const Rect& rect, const Color& color1,
const Color& color2, LinearGradientMode mode)
{
GpLineGradient *nativeLineGradient = NULL;
lastStatus = DllExports::GdipCreateLineBrushFromRectI(
&rect, color1.GetValue(), color2.GetValue(),
mode, WrapModeTile, &nativeLineGradient);
nativeBrush = nativeLineGradient;
}
LinearGradientBrush(const RectF& rect, const Color& color1,
const Color& color2, REAL angle,
BOOL isAngleScalable = FALSE)
{
GpLineGradient *nativeLineGradient = NULL;
lastStatus = DllExports::GdipCreateLineBrushFromRectWithAngle(
&rect, color1.GetValue(), color2.GetValue(),
angle, isAngleScalable, WrapModeTile,
&nativeLineGradient);
nativeBrush = nativeLineGradient;
}
LinearGradientBrush(const Rect& rect, const Color& color1,
const Color& color2, REAL angle,
BOOL isAngleScalable = FALSE)
{
GpLineGradient *nativeLineGradient = NULL;
lastStatus = DllExports::GdipCreateLineBrushFromRectWithAngleI(
&rect, color1.GetValue(), color2.GetValue(),
angle, isAngleScalable, WrapModeTile,
&nativeLineGradient);
nativeBrush = nativeLineGradient;
}
virtual LinearGradientBrush* Clone() const
{
GpBrush *cloneBrush = NULL;
Status status = updateStatus(DllExports::GdipCloneBrush(
nativeBrush, &cloneBrush));
if (status == Ok) {
LinearGradientBrush *result =
new LinearGradientBrush(cloneBrush, lastStatus);
if (!result) {
DllExports::GdipDeleteBrush(cloneBrush);
updateStatus(OutOfMemory);
}
return result;
} else {
return NULL;
}
}
Status GetBlend(REAL *blendFactors, REAL *blendPositions,
INT count) const
{
return updateStatus(DllExports::GdipGetLineBlend(
(GpLineGradient*) nativeBrush,
blendFactors, blendPositions, count));
}
INT GetBlendCount() const
{
INT result = 0;
updateStatus(DllExports::GdipGetLineBlendCount(
(GpLineGradient*) nativeBrush, &result));
return result;
}
BOOL GetGammaCorrection() const
{
BOOL result = FALSE;
updateStatus(DllExports::GdipGetLineGammaCorrection(
(GpLineGradient*) nativeBrush, &result));
return result;
}
INT GetInterpolationColorCount() const
{
INT result = 0;
updateStatus(DllExports::GdipGetLinePresetBlendCount(
(GpLineGradient*) nativeBrush, &result));
return result;
}
Status GetInterpolationColors(Color *presetColors,
REAL *blendPositions, INT count) const
{
if (!presetColors || count <= 0)
return lastStatus = InvalidParameter;
ARGB *presetArgb =
(ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB));
if (!presetArgb)
return lastStatus = OutOfMemory;
Status status = updateStatus(DllExports::GdipGetLinePresetBlend(
(GpLineGradient*) nativeBrush, presetArgb,
blendPositions, count));
for (INT i = 0; i < count; ++i) {
presetColors[i].SetValue(presetArgb[i]);
}
DllExports::GdipFree((void*) presetArgb);
return status;
}
Status GetLinearColors(Color *colors) const
{
if (!colors) return lastStatus = InvalidParameter;
ARGB colorsArgb[2];
Status status = updateStatus(DllExports::GdipGetLineColors(
(GpLineGradient*) nativeBrush, colorsArgb));
colors[0].SetValue(colorsArgb[0]);
colors[1].SetValue(colorsArgb[1]);
return status;
}
Status GetRectangle(RectF *rect) const
{
return updateStatus(DllExports::GdipGetLineRect(
(GpLineGradient*) nativeBrush, rect));
}
Status GetRectangle(Rect *rect) const
{
return updateStatus(DllExports::GdipGetLineRectI(
(GpLineGradient*) nativeBrush, rect));
}
Status GetTransform(Matrix *matrix) const
{
return updateStatus(DllExports::GdipGetLineTransform(
(GpLineGradient*) nativeBrush,
matrix ? matrix->nativeMatrix : NULL));
}
WrapMode GetWrapMode() const
{
WrapMode wrapMode = WrapModeTile;
updateStatus(DllExports::GdipGetLineWrapMode(
(GpLineGradient*) nativeBrush, &wrapMode));
return wrapMode;
}
Status MultiplyTransform(const Matrix *matrix,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipMultiplyLineTransform(
(GpLineGradient*) nativeBrush,
matrix ? matrix->nativeMatrix : NULL, order));
}
Status ResetTransform()
{
return updateStatus(DllExports::GdipResetLineTransform(
(GpLineGradient*) nativeBrush));
}
Status RotateTranform(REAL angle, MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipRotateLineTransform(
(GpLineGradient*) nativeBrush, angle, order));
}
Status ScaleTransform(REAL sx, REAL sy,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipScaleLineTransform(
(GpLineGradient*) nativeBrush, sx, sy, order));
}
Status SetBlend(const REAL *blendFactors,
const REAL *blendPositions, INT count)
{
return updateStatus(DllExports::GdipSetLineBlend(
(GpLineGradient*) nativeBrush,
blendFactors, blendPositions, count));
}
Status SetBlendBellShape(REAL focus, REAL scale = 1.0f)
{
return updateStatus(DllExports::GdipSetLineSigmaBlend(
(GpLineGradient*) nativeBrush,
focus, scale));
}
Status SetBlendTriangularShape(REAL focus, REAL scale = 1.0f)
{
return updateStatus(DllExports::GdipSetLineLinearBlend(
(GpLineGradient*) nativeBrush,
focus, scale));
}
Status SetGammaCorrection(BOOL useGammaCorrection)
{
return updateStatus(DllExports::GdipSetLineGammaCorrection(
(GpLineGradient*) nativeBrush,
useGammaCorrection));
}
Status SetInterpolationColors(const Color *presetColors,
const REAL *blendPositions, INT count)
{
if (!presetColors || count < 0)
return lastStatus = InvalidParameter;
ARGB *presetArgb =
(ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB));
if (!presetArgb)
return lastStatus = OutOfMemory;
for (INT i = 0; i < count; ++i) {
presetArgb[i] = presetColors[i].GetValue();
}
Status status = updateStatus(DllExports::GdipSetLinePresetBlend(
(GpLineGradient*) nativeBrush,
presetArgb, blendPositions, count));
DllExports::GdipFree((void*) presetArgb);
return status;
}
Status SetLinearColors(const Color& color1, const Color& color2)
{
return updateStatus(DllExports::GdipSetLineColors(
(GpLineGradient*) nativeBrush,
color1.GetValue(), color2.GetValue()));
}
Status SetTransform(const Matrix *matrix)
{
return updateStatus(DllExports::GdipSetLineTransform(
(GpLineGradient*) nativeBrush,
matrix ? matrix->nativeMatrix : NULL));
}
Status SetWrapMode(WrapMode wrapMode)
{
return updateStatus(DllExports::GdipSetLineWrapMode(
(GpLineGradient*) nativeBrush, wrapMode));
}
Status TranslateTransform(REAL dx, REAL dy,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipTranslateLineTransform(
(GpLineGradient*) nativeBrush, dx, dy, order));
}
private:
LinearGradientBrush(GpBrush *brush, Status status): Brush(brush, status) {}
LinearGradientBrush(const LinearGradientBrush& brush);
LinearGradientBrush& operator=(const LinearGradientBrush&);
};
class SolidBrush: public Brush
{
public:
SolidBrush(const Color& color)
{
GpSolidFill *nativeSolidFill = NULL;
lastStatus = DllExports::GdipCreateSolidFill(
color.GetValue(), &nativeSolidFill);
nativeBrush = nativeSolidFill;
}
virtual SolidBrush* Clone() const
{
GpBrush *cloneBrush = NULL;
Status status = updateStatus(DllExports::GdipCloneBrush(
nativeBrush, &cloneBrush));
if (status == Ok) {
SolidBrush *result =
new SolidBrush(cloneBrush, lastStatus);
if (!result) {
DllExports::GdipDeleteBrush(cloneBrush);
updateStatus(OutOfMemory);
}
return result;
} else {
return NULL;
}
}
Status GetColor(Color *color) const
{
return updateStatus(DllExports::GdipGetSolidFillColor(
(GpSolidFill*) nativeBrush,
color ? &color->Value : NULL));
}
Status SetColor(const Color& color)
{
return updateStatus(DllExports::GdipSetSolidFillColor(
(GpSolidFill*) nativeBrush, color.GetValue()));
}
private:
SolidBrush(GpBrush *brush, Status status): Brush(brush, status) {}
SolidBrush(const SolidBrush&);
SolidBrush& operator=(const SolidBrush&);
};
class TextureBrush: public Brush
{
public:
TextureBrush(Image *image, WrapMode wrapMode = WrapModeTile)
{
GpTexture *nativeTexture = NULL;
lastStatus = DllExports::GdipCreateTexture(
image ? image->nativeImage : NULL,
wrapMode, &nativeTexture);
nativeBrush = nativeTexture;
}
TextureBrush(Image *image, WrapMode wrapMode,
REAL dstX, REAL dstY, REAL dstWidth, REAL dstHeight)
{
GpTexture *nativeTexture = NULL;
lastStatus = DllExports::GdipCreateTexture2(
image ? image->nativeImage : NULL,
wrapMode, dstX, dstY, dstWidth, dstHeight,
&nativeTexture);
nativeBrush = nativeTexture;
}
TextureBrush(Image *image, WrapMode wrapMode,
INT dstX, INT dstY, INT dstWidth, INT dstHeight)
{
GpTexture *nativeTexture = NULL;
lastStatus = DllExports::GdipCreateTexture2I(
image ? image->nativeImage : NULL,
wrapMode, dstX, dstY, dstWidth, dstHeight,
&nativeTexture);
nativeBrush = nativeTexture;
}
TextureBrush(Image *image, WrapMode wrapMode, const RectF& dstRect)
{
GpTexture *nativeTexture = NULL;
lastStatus = DllExports::GdipCreateTexture2(
image ? image->nativeImage : NULL, wrapMode,
dstRect.X, dstRect.Y,
dstRect.Width, dstRect.Height, &nativeTexture);
nativeBrush = nativeTexture;
}
TextureBrush(Image *image, WrapMode wrapMode, const Rect& dstRect)
{
GpTexture *nativeTexture = NULL;
lastStatus = DllExports::GdipCreateTexture2I(
image ? image->nativeImage : NULL, wrapMode,
dstRect.X, dstRect.Y,
dstRect.Width, dstRect.Height, &nativeTexture);
nativeBrush = nativeTexture;
}
TextureBrush(Image *image, const RectF& dstRect,
ImageAttributes *imageAttributes = NULL)
{
GpTexture *nativeTexture = NULL;
lastStatus = DllExports::GdipCreateTextureIA(
image ? image->nativeImage : NULL,
imageAttributes ? imageAttributes->nativeImageAttributes : NULL,
dstRect.X, dstRect.Y,
dstRect.Width, dstRect.Height, &nativeTexture);
nativeBrush = nativeTexture;
}
TextureBrush(Image *image, const Rect& dstRect,
ImageAttributes *imageAttributes = NULL)
{
GpTexture *nativeTexture = NULL;
lastStatus = DllExports::GdipCreateTextureIAI(
image ? image->nativeImage : NULL,
imageAttributes ? imageAttributes->nativeImageAttributes : NULL,
dstRect.X, dstRect.Y,
dstRect.Width, dstRect.Height, &nativeTexture);
nativeBrush = nativeTexture;
}
virtual TextureBrush* Clone() const
{
GpBrush *cloneBrush = NULL;
Status status = updateStatus(DllExports::GdipCloneBrush(
nativeBrush, &cloneBrush));
if (status == Ok) {
TextureBrush *result =
new TextureBrush(cloneBrush, lastStatus);
if (!result) {
DllExports::GdipDeleteBrush(cloneBrush);
updateStatus(OutOfMemory);
}
return result;
} else {
return NULL;
}
}
//TODO: implement TextureBrush::GetImage()
//Image *GetImage() const
//{
// // where is the Image allocated (static,member,new,other)?
// // GdipGetTextureImage just returns a GpImage*
// updateStatus(NotImplemented);
// return NULL;
//}
Status GetTransfrom(Matrix *matrix) const
{
return updateStatus(DllExports::GdipGetTextureTransform(
(GpTexture*) nativeBrush,
matrix ? matrix->nativeMatrix : NULL));
}
WrapMode GetWrapMode() const
{
WrapMode result = WrapModeTile;
updateStatus(DllExports::GdipGetTextureWrapMode(
(GpTexture*) nativeBrush, &result));
return result;
}
Status MultiplyTransform(const Matrix *matrix,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipMultiplyTextureTransform(
(GpTexture*) nativeBrush,
matrix ? matrix->nativeMatrix : NULL, order));
}
Status ResetTransform()
{
return updateStatus(DllExports::GdipResetTextureTransform(
(GpTexture*) nativeBrush));
}
Status RotateTransform(REAL angle,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipRotateTextureTransform(
(GpTexture*) nativeBrush, angle, order));
}
Status ScaleTransform(REAL sx, REAL sy,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipScaleTextureTransform(
(GpTexture*) nativeBrush, sx, sy, order));
}
Status SetTransform(const Matrix *matrix)
{
return updateStatus(DllExports::GdipSetTextureTransform(
(GpTexture*) nativeBrush,
matrix ? matrix->nativeMatrix : NULL));
}
Status SetWrapMode(WrapMode wrapMode)
{
return updateStatus(DllExports::GdipSetTextureWrapMode(
(GpTexture*) nativeBrush, wrapMode));
}
Status TranslateTransform(REAL dx, REAL dy,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipTranslateTextureTransform(
(GpTexture*) nativeBrush, dx, dy, order));
}
private:
TextureBrush(GpBrush *brush, Status status): Brush(brush, status) {}
TextureBrush(const TextureBrush&);
TextureBrush& operator=(const TextureBrush&);
};
#endif /* __GDIPLUS_BRUSH_H */

262
winsup/w32api/include/gdiplus/gdipluscolor.h Executable file
View File

@ -0,0 +1,262 @@
/*
* gdipluscolor.h
*
* GDI+ color
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_COLOR_H
#define __GDIPLUS_COLOR_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
typedef enum ColorChannelFlags {
ColorChannelFlagsC = 0,
ColorChannelFlagsM = 1,
ColorChannelFlagsY = 2,
ColorChannelFlagsK = 3,
ColorChannelFlagsLast = 4
} ColorChannelFlags;
typedef struct Color
{
#ifdef __cplusplus
private:
#endif
ARGB Value;
#ifdef __cplusplus
public:
friend class Bitmap;
friend class Graphics;
friend class HatchBrush;
friend class PathGradientBrush;
friend class Pen;
friend class SolidBrush;
static ARGB MakeARGB(BYTE a, BYTE r, BYTE g, BYTE b)
{
return (ARGB) ((((DWORD) a) << 24) | (((DWORD) r) << 16)
| (((DWORD) g) << 8) | ((DWORD) b));
}
static const ARGB AlphaMask = 0xFF000000UL;
static const ARGB AliceBlue = 0xFFF0F8FFUL;
static const ARGB AntiqueWhite = 0xFFFAEBD7UL;
static const ARGB Aqua = 0xFF00FFFFUL;
static const ARGB Aquamarine = 0xFF7FFFD4UL;
static const ARGB Azure = 0xFFF0FFFFUL;
static const ARGB Beige = 0xFFF5F5DCUL;
static const ARGB Bisque = 0xFFFFE4C4UL;
static const ARGB Black = 0xFF000000UL;
static const ARGB BlanchedAlmond = 0xFFFFEBCDUL;
static const ARGB Blue = 0xFF0000FFUL;
static const ARGB BlueViolet = 0xFF8A2BE2UL;
static const ARGB Brown = 0xFFA52A2AUL;
static const ARGB BurlyWood = 0xFFDEB887UL;
static const ARGB CadetBlue = 0xFF5F9EA0UL;
static const ARGB Chartreuse = 0xFF7FFF00UL;
static const ARGB Chocolate = 0xFFD2691EUL;
static const ARGB Coral = 0xFFFF7F50UL;
static const ARGB CornflowerBlue = 0xFF6495EDUL;
static const ARGB Cornsilk = 0xFFFFF8DCUL;
static const ARGB Crimson = 0xFFDC143CUL;
static const ARGB Cyan = 0xFF00FFFFUL;
static const ARGB DarkBlue = 0xFF00008BUL;
static const ARGB DarkCyan = 0xFF008B8BUL;
static const ARGB DarkGoldenrod = 0xFFB8860BUL;
static const ARGB DarkGray = 0xFFA9A9A9UL;
static const ARGB DarkGreen = 0xFF006400UL;
static const ARGB DarkKhaki = 0xFFBDB76BUL;
static const ARGB DarkMagenta = 0xFF8B008BUL;
static const ARGB DarkOliveGreen = 0xFF556B2FUL;
static const ARGB DarkOrange = 0xFFFF8C00UL;
static const ARGB DarkOrchid = 0xFF9932CCUL;
static const ARGB DarkRed = 0xFF8B0000UL;
static const ARGB DarkSalmon = 0xFFE9967AUL;
static const ARGB DarkSeaGreen = 0xFF8FBC8FUL;
static const ARGB DarkSlateBlue = 0xFF483D8BUL;
static const ARGB DarkSlateGray = 0xFF2F4F4FUL;
static const ARGB DarkTurquoise = 0xFF00CED1UL;
static const ARGB DarkViolet = 0xFF9400D3UL;
static const ARGB DeepPink = 0xFFFF1493UL;
static const ARGB DeepSkyBlue = 0xFF00BFFFUL;
static const ARGB DimGray = 0xFF696969UL;
static const ARGB DodgerBlue = 0xFF1E90FFUL;
static const ARGB Firebrick = 0xFFB22222UL;
static const ARGB FloralWhite = 0xFFFFFAF0UL;
static const ARGB ForestGreen = 0xFF228B22UL;
static const ARGB Fuchsia = 0xFFFF00FFUL;
static const ARGB Gainsboro = 0xFFDCDCDCUL;
static const ARGB GhostWhite = 0xFFF8F8FFUL;
static const ARGB Gold = 0xFFFFD700UL;
static const ARGB Goldenrod = 0xFFDAA520UL;
static const ARGB Gray = 0xFF808080UL;
static const ARGB Green = 0xFF008000UL;
static const ARGB GreenYellow = 0xFFADFF2FUL;
static const ARGB Honeydew = 0xFFF0FFF0UL;
static const ARGB HotPink = 0xFFFF69B4UL;
static const ARGB IndianRed = 0xFFCD5C5CUL;
static const ARGB Indigo = 0xFF4B0082UL;
static const ARGB Ivory = 0xFFFFFFF0UL;
static const ARGB Khaki = 0xFFF0E68CUL;
static const ARGB Lavender = 0xFFE6E6FAUL;
static const ARGB LavenderBlush = 0xFFFFF0F5UL;
static const ARGB LawnGreen = 0xFF7CFC00UL;
static const ARGB LemonChiffon = 0xFFFFFACDUL;
static const ARGB LightBlue = 0xFFADD8E6UL;
static const ARGB LightCoral = 0xFFF08080UL;
static const ARGB LightCyan = 0xFFE0FFFFUL;
static const ARGB LightGoldenrodYellow = 0xFFFAFAD2UL;
static const ARGB LightGray = 0xFFD3D3D3UL;
static const ARGB LightGreen = 0xFF90EE90UL;
static const ARGB LightPink = 0xFFFFB6C1UL;
static const ARGB LightSalmon = 0xFFFFA07AUL;
static const ARGB LightSeaGreen = 0xFF20B2AAUL;
static const ARGB LightSkyBlue = 0xFF87CEFAUL;
static const ARGB LightSlateGray = 0xFF778899UL;
static const ARGB LightSteelBlue = 0xFFB0C4DEUL;
static const ARGB LightYellow = 0xFFFFFFE0UL;
static const ARGB Lime = 0xFF00FF00UL;
static const ARGB LimeGreen = 0xFF32CD32UL;
static const ARGB Linen = 0xFFFAF0E6UL;
static const ARGB Magenta = 0xFFFF00FFUL;
static const ARGB Maroon = 0xFF800000UL;
static const ARGB MediumAquamarine = 0xFF66CDAAUL;
static const ARGB MediumBlue = 0xFF0000CDUL;
static const ARGB MediumOrchid = 0xFFBA55D3UL;
static const ARGB MediumPurple = 0xFF9370DBUL;
static const ARGB MediumSeaGreen = 0xFF3CB371UL;
static const ARGB MediumSlateBlue = 0xFF7B68EEUL;
static const ARGB MediumSpringGreen = 0xFF00FA9AUL;
static const ARGB MediumTurquoise = 0xFF48D1CCUL;
static const ARGB MediumVioletRed = 0xFFC71585UL;
static const ARGB MidnightBlue = 0xFF191970UL;
static const ARGB MintCream = 0xFFF5FFFAUL;
static const ARGB MistyRose = 0xFFFFE4E1UL;
static const ARGB Moccasin = 0xFFFFE4B5UL;
static const ARGB NavajoWhite = 0xFFFFDEADUL;
static const ARGB Navy = 0xFF000080UL;
static const ARGB OldLace = 0xFFFDF5E6UL;
static const ARGB Olive = 0xFF808000UL;
static const ARGB OliveDrab = 0xFF6B8E23UL;
static const ARGB Orange = 0xFFFFA500UL;
static const ARGB OrangeRed = 0xFFFF4500UL;
static const ARGB Orchid = 0xFFDA70D6UL;
static const ARGB PaleGoldenrod = 0xFFEEE8AAUL;
static const ARGB PaleGreen = 0xFF98FB98UL;
static const ARGB PaleTurquoise = 0xFFAFEEEEUL;
static const ARGB PaleVioletRed = 0xFFDB7093UL;
static const ARGB PapayaWhip = 0xFFFFEFD5UL;
static const ARGB PeachPuff = 0xFFFFDAB9UL;
static const ARGB Peru = 0xFFCD853FUL;
static const ARGB Pink = 0xFFFFC0CBUL;
static const ARGB Plum = 0xFFDDA0DDUL;
static const ARGB PowderBlue = 0xFFB0E0E6UL;
static const ARGB Purple = 0xFF800080UL;
static const ARGB Red = 0xFFFF0000UL;
static const ARGB RosyBrown = 0xFFBC8F8FUL;
static const ARGB RoyalBlue = 0xFF4169E1UL;
static const ARGB SaddleBrown = 0xFF8B4513UL;
static const ARGB Salmon = 0xFFFA8072UL;
static const ARGB SandyBrown = 0xFFF4A460UL;
static const ARGB SeaGreen = 0xFF2E8B57UL;
static const ARGB SeaShell = 0xFFFFF5EEUL;
static const ARGB Sienna = 0xFFA0522DUL;
static const ARGB Silver = 0xFFC0C0C0UL;
static const ARGB SkyBlue = 0xFF87CEEBUL;
static const ARGB SlateBlue = 0xFF6A5ACDUL;
static const ARGB SlateGray = 0xFF708090UL;
static const ARGB Snow = 0xFFFFFAFAUL;
static const ARGB SpringGreen = 0xFF00FF7FUL;
static const ARGB SteelBlue = 0xFF4682B4UL;
static const ARGB Tan = 0xFFD2B48CUL;
static const ARGB Teal = 0xFF008080UL;
static const ARGB Thistle = 0xFFD8BFD8UL;
static const ARGB Tomato = 0xFFFF6347UL;
static const ARGB Transparent = 0x00FFFFFFUL;
static const ARGB Turquoise = 0xFF40E0D0UL;
static const ARGB Violet = 0xFFEE82EEUL;
static const ARGB Wheat = 0xFFF5DEB3UL;
static const ARGB White = 0xFFFFFFFFUL;
static const ARGB WhiteSmoke = 0xFFF5F5F5UL;
static const ARGB Yellow = 0xFFFFFF00UL;
static const ARGB YellowGreen = 0xFF9ACD32UL;
Color(): Value(0xFF000000) {}
Color(ARGB argb): Value(argb) {}
Color(BYTE r, BYTE g, BYTE b): Value(MakeARGB(0xFF, r, g, b)) {}
Color(BYTE a, BYTE r, BYTE g, BYTE b): Value(MakeARGB(a, r, g, b)) {}
BYTE GetA() const
{
return (BYTE) (Value >> 24);
}
BYTE GetAlpha() const
{
return (BYTE) (Value >> 24);
}
BYTE GetB() const
{
return (BYTE) Value;
}
BYTE GetBlue() const
{
return (BYTE) Value;
}
BYTE GetG() const
{
return (BYTE) (Value >> 8);
}
BYTE GetGreen() const
{
return (BYTE) (Value >> 8);
}
BYTE GetR() const
{
return (BYTE) (Value >> 16);
}
BYTE GetRed() const
{
return (BYTE) (Value >> 16);
}
ARGB GetValue() const
{
return Value;
}
VOID SetFromCOLORREF(COLORREF rgb)
{
BYTE r = (BYTE) rgb;
BYTE g = (BYTE) (rgb >> 8);
BYTE b = (BYTE) (rgb >> 16);
Value = MakeARGB(0xFF, r, g, b);
}
VOID SetValue(ARGB argb)
{
Value = argb;
}
COLORREF ToCOLORREF() const
{
return RGB(GetRed(), GetGreen(), GetBlue());
}
#endif /* __cplusplus */
} Color;
#endif /* __GDIPLUS_COLOR_H */

67
winsup/w32api/include/gdiplus/gdipluscolormatrix.h Executable file
View File

@ -0,0 +1,67 @@
/*
* gdipluscolormatrix.h
*
* GDI+ color mappings
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_COLORMATRIX_H
#define __GDIPLUS_COLORMATRIX_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
typedef enum ColorAdjustType {
ColorAdjustTypeDefault = 0,
ColorAdjustTypeBitmap = 1,
ColorAdjustTypeBrush = 2,
ColorAdjustTypePen = 3,
ColorAdjustTypeText = 4,
ColorAdjustTypeCount = 5,
ColorAdjustTypeAny = 6
} ColorAdjustType;
typedef enum ColorMatrixFlags {
ColorMatrixFlagsDefault = 0,
ColorMatrixFlagsSkipGrays = 1,
ColorMatrixFlagsAltGray = 2
} ColorMatrixFlags;
typedef enum HistogramFormat {
HistogramFormatARGB = 0,
HistogramFormatPARGB = 1,
HistogramFormatRGB = 2,
HistogramFormatGray = 3,
HistogramFormatB = 4,
HistogramFormatG = 5,
HistogramFormatR = 6,
HistogramFormatA = 7
} HistogramFormat;
typedef struct ColorMap {
Color oldColor;
Color newColor;
} ColorMap;
typedef struct ColorMatrix {
REAL m[5][5];
} ColorMatrix;
typedef BYTE ColorChannelLUT[256];
#endif /* __GDIPLUS_COLORMATRIX_H */

116
winsup/w32api/include/gdiplus/gdipluseffects.h Executable file
View File

@ -0,0 +1,116 @@
/*
* gdipluseffects.h
*
* GDI+ filters and effects
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_EFFECTS_H
#define __GDIPLUS_EFFECTS_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
typedef enum CurveAdjustments {
AdjustExposure = 0,
AdjustDensity = 1,
AdjustContrast = 2,
AdjustHighlight = 3,
AdjustShadow = 4,
AdjustMidtone = 5,
AdjustWhiteSaturation = 6,
AdjustBlackSaturation = 7
} CurveAdjustments;
typedef enum CurveChannel {
CurveChannelAll = 0,
CurveChannelRed = 1,
CurveChannelGreen = 2,
CurveChannelBlue = 3
} CurveChannel;
typedef struct BlurParams {
REAL radius;
BOOL expandEdge;
} BlurParams;
typedef struct BrightnessContrastParams {
INT brightnessLevel;
INT contrastLevel;
} BrightnessContrastParams;
typedef struct ColorBalanceParams {
INT cyanRed;
INT magentaGreen;
INT yellowBlue;
} ColorBalanceParams;
typedef struct ColorCurveParams {
CurveAdjustments adjustment;
CurveChannel channel;
INT adjustValue;
} ColorCurveParams;
typedef struct ColorLUTParams {
ColorChannelLUT lutB;
ColorChannelLUT lutG;
ColorChannelLUT lutR;
ColorChannelLUT lutA;
} ColorLUTParams;
typedef struct HueSaturationLightnessParams {
INT hueLevel;
INT saturationLevel;
INT lightnessLevel;
} HueSaturationLightnessParams;
typedef struct LevelsParams {
INT highlight;
INT midtone;
INT shadow;
} LevelsParams;
typedef struct RedEyeCorrectionParams {
UINT numberOfAreas;
RECT *areas;
} RedEyeCorrectionParams;
typedef struct SharpenParams {
REAL radius;
REAL amount;
} SharpenParams;
typedef struct TintParams {
INT hue;
INT amount;
} TintParams;
extern const GUID BlurEffectGuid; /* ? */
extern const GUID BrightnessContrastEffectGuid; /* ? */
extern const GUID ColorBalanceEffectGuid; /* ? */
extern const GUID ColorCurveEffectGuid; /* ? */
extern const GUID ColorLUTEffectGuid; /* ? */
extern const GUID ColorMatrixEffectGuid; /* ? */
extern const GUID HueSaturationLightnessEffectGuid; /* ? */
extern const GUID LevelsEffectGuid; /* ? */
extern const GUID RedEyeCorrectionEffectGuid; /* ? */
extern const GUID SharpenEffectGuid; /* ? */
extern const GUID TintEffectGuid; /* ? */
#endif /* __GDIPLUS_EFFECTS_H */

755
winsup/w32api/include/gdiplus/gdiplusenums.h Executable file
View File

@ -0,0 +1,755 @@
/*
* gdiplusenums.h
*
* GDI+ enumerations
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_ENUMS_H
#define __GDIPLUS_ENUMS_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
typedef enum BrushType {
BrushTypeSolidColor = 0,
BrushTypeHatchFill = 1,
BrushTypeTextureFill = 2,
BrushTypePathGradient = 3,
BrushTypeLinearGradient = 4
} BrushType;
typedef enum CombineMode {
CombineModeReplace = 0,
CombineModeIntersect = 1,
CombineModeUnion = 2,
CombineModeXor = 3,
CombineModeExclude = 4,
CombineModeComplement = 5
} CombineMode;
typedef enum CompositingMode {
CompositingModeSourceOver = 0,
CompositingModeSourceCopy = 1
} CompositingMode;
typedef enum CompositingQuality {
CompositingQualityDefault = 0,
CompositingQualityHighSpeed = 1,
CompositingQualityHighQuality = 2,
CompositingQualityGammaCorrected = 3,
CompositingQualityAssumeLinear = 4
} CompositingQuality;
typedef enum CoordinateSpace {
CoordinateSpaceWorld = 0,
CoordinateSpacePage = 1,
CoordinateSpaceDevice = 2
} CoordinateSpace;
typedef enum CustomLineCapType {
CustomLineCapTypeDefault = 0,
CustomLineCapTypeAdjustableArrow = 1
} CustomLineCapType;
typedef enum DashCap {
DashCapFlat = 0,
DashCapRound = 2,
DashCapTriangle = 3
} DashCap;
typedef enum DashStyle {
DashStyleSolid = 0,
DashStyleDash = 1,
DashStyleDot = 2,
DashStyleDashDot = 3,
DashStyleDashDotDot = 4,
DashStyleCustom = 5
} DashStyle;
typedef enum DitherType {
DitherTypeNone = 0,
DitherTypeSolid = 1,
DitherTypeOrdered4x4 = 2,
DitherTypeOrdered8x8 = 3,
DitherTypeOrdered16x16 = 4,
DitherTypeOrdered91x91 = 5,
DitherTypeSpiral4x4 = 6,
DitherTypeSpiral8x8 = 7,
DitherTypeDualSpiral4x4 = 8,
DitherTypeDualSpiral8x8 = 9,
DitherTypeErrorDiffusion = 10
} DitherType;
typedef enum DriverStringOptions {
DriverStringOptionsCmapLookup = 1,
DriverStringOptionsVertical = 2,
DriverStringOptionsRealizedAdvance = 4,
DriverStringOptionsLimitSubpixel = 8
} DriverStringOptions;
#define GDIP_WMF_RECORD_TO_EMFPLUS(meta) ((meta) | 0x10000)
#define GDIP_EMFPLUS_RECORD_BASE (0x4000)
typedef enum EmfPlusRecordType {
WmfRecordTypeSetBkColor = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETBKCOLOR),
WmfRecordTypeSetBkMode = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETBKMODE),
WmfRecordTypeSetMapMode = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETMAPMODE),
WmfRecordTypeSetROP2 = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETROP2),
WmfRecordTypeSetRelAbs = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETRELABS),
WmfRecordTypeSetPolyFillMode = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETPOLYFILLMODE),
WmfRecordTypeSetStretchBltMode = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETSTRETCHBLTMODE),
WmfRecordTypeSetTextCharExtra = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETTEXTCHAREXTRA),
WmfRecordTypeSetTextColor = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETTEXTCOLOR),
WmfRecordTypeSetTextJustification = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETTEXTJUSTIFICATION),
WmfRecordTypeSetWindowOrg = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETWINDOWORG),
WmfRecordTypeSetWindowExt = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETWINDOWEXT),
WmfRecordTypeSetViewportOrg = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETVIEWPORTORG),
WmfRecordTypeSetViewportExt = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETVIEWPORTEXT),
WmfRecordTypeOffsetWindowOrg = GDIP_WMF_RECORD_TO_EMFPLUS(META_OFFSETWINDOWORG),
WmfRecordTypeScaleWindowExt = GDIP_WMF_RECORD_TO_EMFPLUS(META_SCALEWINDOWEXT),
WmfRecordTypeOffsetViewportOrg = GDIP_WMF_RECORD_TO_EMFPLUS(META_OFFSETVIEWPORTORG),
WmfRecordTypeScaleViewportExt = GDIP_WMF_RECORD_TO_EMFPLUS(META_SCALEVIEWPORTEXT),
WmfRecordTypeLineTo = GDIP_WMF_RECORD_TO_EMFPLUS(META_LINETO),
WmfRecordTypeMoveTo = GDIP_WMF_RECORD_TO_EMFPLUS(META_MOVETO),
WmfRecordTypeExcludeClipRect = GDIP_WMF_RECORD_TO_EMFPLUS(META_EXCLUDECLIPRECT),
WmfRecordTypeIntersectClipRect = GDIP_WMF_RECORD_TO_EMFPLUS(META_INTERSECTCLIPRECT),
WmfRecordTypeArc = GDIP_WMF_RECORD_TO_EMFPLUS(META_ARC),
WmfRecordTypeEllipse = GDIP_WMF_RECORD_TO_EMFPLUS(META_ELLIPSE),
WmfRecordTypeFloodFill = GDIP_WMF_RECORD_TO_EMFPLUS(META_FLOODFILL),
WmfRecordTypePie = GDIP_WMF_RECORD_TO_EMFPLUS(META_PIE),
WmfRecordTypeRectangle = GDIP_WMF_RECORD_TO_EMFPLUS(META_RECTANGLE),
WmfRecordTypeRoundRect = GDIP_WMF_RECORD_TO_EMFPLUS(META_ROUNDRECT),
WmfRecordTypePatBlt = GDIP_WMF_RECORD_TO_EMFPLUS(META_PATBLT),
WmfRecordTypeSaveDC = GDIP_WMF_RECORD_TO_EMFPLUS(META_SAVEDC),
WmfRecordTypeSetPixel = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETPIXEL),
WmfRecordTypeOffsetClipRgn = GDIP_WMF_RECORD_TO_EMFPLUS(META_OFFSETCLIPRGN),
WmfRecordTypeTextOut = GDIP_WMF_RECORD_TO_EMFPLUS(META_TEXTOUT),
WmfRecordTypeBitBlt = GDIP_WMF_RECORD_TO_EMFPLUS(META_BITBLT),
WmfRecordTypeStretchBlt = GDIP_WMF_RECORD_TO_EMFPLUS(META_STRETCHBLT),
WmfRecordTypePolygon = GDIP_WMF_RECORD_TO_EMFPLUS(META_POLYGON),
WmfRecordTypePolyline = GDIP_WMF_RECORD_TO_EMFPLUS(META_POLYLINE),
WmfRecordTypeEscape = GDIP_WMF_RECORD_TO_EMFPLUS(META_ESCAPE),
WmfRecordTypeRestoreDC = GDIP_WMF_RECORD_TO_EMFPLUS(META_RESTOREDC),
WmfRecordTypeFillRegion = GDIP_WMF_RECORD_TO_EMFPLUS(META_FILLREGION),
WmfRecordTypeFrameRegion = GDIP_WMF_RECORD_TO_EMFPLUS(META_FRAMEREGION),
WmfRecordTypeInvertRegion = GDIP_WMF_RECORD_TO_EMFPLUS(META_INVERTREGION),
WmfRecordTypePaintRegion = GDIP_WMF_RECORD_TO_EMFPLUS(META_PAINTREGION),
WmfRecordTypeSelectClipRegion = GDIP_WMF_RECORD_TO_EMFPLUS(META_SELECTCLIPREGION),
WmfRecordTypeSelectObject = GDIP_WMF_RECORD_TO_EMFPLUS(META_SELECTOBJECT),
WmfRecordTypeSetTextAlign = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETTEXTALIGN),
WmfRecordTypeDrawText = GDIP_WMF_RECORD_TO_EMFPLUS(0x062F),
WmfRecordTypeChord = GDIP_WMF_RECORD_TO_EMFPLUS(META_CHORD),
WmfRecordTypeSetMapperFlags = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETMAPPERFLAGS),
WmfRecordTypeExtTextOut = GDIP_WMF_RECORD_TO_EMFPLUS(META_EXTTEXTOUT),
WmfRecordTypeSetDIBToDev = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETDIBTODEV),
WmfRecordTypeSelectPalette = GDIP_WMF_RECORD_TO_EMFPLUS(META_SELECTPALETTE),
WmfRecordTypeRealizePalette = GDIP_WMF_RECORD_TO_EMFPLUS(META_REALIZEPALETTE),
WmfRecordTypeAnimatePalette = GDIP_WMF_RECORD_TO_EMFPLUS(META_ANIMATEPALETTE),
WmfRecordTypeSetPalEntries = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETPALENTRIES),
WmfRecordTypePolyPolygon = GDIP_WMF_RECORD_TO_EMFPLUS(META_POLYPOLYGON),
WmfRecordTypeResizePalette = GDIP_WMF_RECORD_TO_EMFPLUS(META_RESIZEPALETTE),
WmfRecordTypeDIBBitBlt = GDIP_WMF_RECORD_TO_EMFPLUS(META_DIBBITBLT),
WmfRecordTypeDIBStretchBlt = GDIP_WMF_RECORD_TO_EMFPLUS(META_DIBSTRETCHBLT),
WmfRecordTypeDIBCreatePatternBrush = GDIP_WMF_RECORD_TO_EMFPLUS(META_DIBCREATEPATTERNBRUSH),
WmfRecordTypeStretchDIB = GDIP_WMF_RECORD_TO_EMFPLUS(META_STRETCHDIB),
WmfRecordTypeExtFloodFill = GDIP_WMF_RECORD_TO_EMFPLUS(META_EXTFLOODFILL),
WmfRecordTypeSetLayout = GDIP_WMF_RECORD_TO_EMFPLUS(0x0149),
WmfRecordTypeResetDC = GDIP_WMF_RECORD_TO_EMFPLUS(0x014C),
WmfRecordTypeStartDoc = GDIP_WMF_RECORD_TO_EMFPLUS(0x014D),
WmfRecordTypeStartPage = GDIP_WMF_RECORD_TO_EMFPLUS(0x004F),
WmfRecordTypeEndPage = GDIP_WMF_RECORD_TO_EMFPLUS(0x0050),
WmfRecordTypeAbortDoc = GDIP_WMF_RECORD_TO_EMFPLUS(0x0052),
WmfRecordTypeEndDoc = GDIP_WMF_RECORD_TO_EMFPLUS(0x005E),
WmfRecordTypeDeleteObject = GDIP_WMF_RECORD_TO_EMFPLUS(META_DELETEOBJECT),
WmfRecordTypeCreatePalette = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEPALETTE),
WmfRecordTypeCreateBrush = GDIP_WMF_RECORD_TO_EMFPLUS(0x00F8),
WmfRecordTypeCreatePatternBrush = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEPATTERNBRUSH),
WmfRecordTypeCreatePenIndirect = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEPENINDIRECT),
WmfRecordTypeCreateFontIndirect = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEFONTINDIRECT),
WmfRecordTypeCreateBrushIndirect = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEBRUSHINDIRECT),
WmfRecordTypeCreateBitmapIndirect = GDIP_WMF_RECORD_TO_EMFPLUS(0x02FD),
WmfRecordTypeCreateBitmap = GDIP_WMF_RECORD_TO_EMFPLUS(0x06FE),
WmfRecordTypeCreateRegion = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEREGION),
EmfRecordTypeHeader = EMR_HEADER,
EmfRecordTypePolyBezier = EMR_POLYBEZIER,
EmfRecordTypePolygon = EMR_POLYGON,
EmfRecordTypePolyline = EMR_POLYLINE,
EmfRecordTypePolyBezierTo = EMR_POLYBEZIERTO,
EmfRecordTypePolyLineTo = EMR_POLYLINETO,
EmfRecordTypePolyPolyline = EMR_POLYPOLYLINE,
EmfRecordTypePolyPolygon = EMR_POLYPOLYGON,
EmfRecordTypeSetWindowExtEx = EMR_SETWINDOWEXTEX,
EmfRecordTypeSetWindowOrgEx = EMR_SETWINDOWORGEX,
EmfRecordTypeSetViewportExtEx = EMR_SETVIEWPORTEXTEX,
EmfRecordTypeSetViewportOrgEx = EMR_SETVIEWPORTORGEX,
EmfRecordTypeSetBrushOrgEx = EMR_SETBRUSHORGEX,
EmfRecordTypeEOF = EMR_EOF,
EmfRecordTypeSetPixelV = EMR_SETPIXELV,
EmfRecordTypeSetMapperFlags = EMR_SETMAPPERFLAGS,
EmfRecordTypeSetMapMode = EMR_SETMAPMODE,
EmfRecordTypeSetBkMode = EMR_SETBKMODE,
EmfRecordTypeSetPolyFillMode = EMR_SETPOLYFILLMODE,
EmfRecordTypeSetROP2 = EMR_SETROP2,
EmfRecordTypeSetStretchBltMode = EMR_SETSTRETCHBLTMODE,
EmfRecordTypeSetTextAlign = EMR_SETTEXTALIGN,
EmfRecordTypeSetColorAdjustment = EMR_SETCOLORADJUSTMENT,
EmfRecordTypeSetTextColor = EMR_SETTEXTCOLOR,
EmfRecordTypeSetBkColor = EMR_SETBKCOLOR,
EmfRecordTypeOffsetClipRgn = EMR_OFFSETCLIPRGN,
EmfRecordTypeMoveToEx = EMR_MOVETOEX,
EmfRecordTypeSetMetaRgn = EMR_SETMETARGN,
EmfRecordTypeExcludeClipRect = EMR_EXCLUDECLIPRECT,
EmfRecordTypeIntersectClipRect = EMR_INTERSECTCLIPRECT,
EmfRecordTypeScaleViewportExtEx = EMR_SCALEVIEWPORTEXTEX,
EmfRecordTypeScaleWindowExtEx = EMR_SCALEWINDOWEXTEX,
EmfRecordTypeSaveDC = EMR_SAVEDC,
EmfRecordTypeRestoreDC = EMR_RESTOREDC,
EmfRecordTypeSetWorldTransform = EMR_SETWORLDTRANSFORM,
EmfRecordTypeModifyWorldTransform = EMR_MODIFYWORLDTRANSFORM,
EmfRecordTypeSelectObject = EMR_SELECTOBJECT,
EmfRecordTypeCreatePen = EMR_CREATEPEN,
EmfRecordTypeCreateBrushIndirect = EMR_CREATEBRUSHINDIRECT,
EmfRecordTypeDeleteObject = EMR_DELETEOBJECT,
EmfRecordTypeAngleArc = EMR_ANGLEARC,
EmfRecordTypeEllipse = EMR_ELLIPSE,
EmfRecordTypeRectangle = EMR_RECTANGLE,
EmfRecordTypeRoundRect = EMR_ROUNDRECT,
EmfRecordTypeArc = EMR_ARC,
EmfRecordTypeChord = EMR_CHORD,
EmfRecordTypePie = EMR_PIE,
EmfRecordTypeSelectPalette = EMR_SELECTPALETTE,
EmfRecordTypeCreatePalette = EMR_CREATEPALETTE,
EmfRecordTypeSetPaletteEntries = EMR_SETPALETTEENTRIES,
EmfRecordTypeResizePalette = EMR_RESIZEPALETTE,
EmfRecordTypeRealizePalette = EMR_REALIZEPALETTE,
EmfRecordTypeExtFloodFill = EMR_EXTFLOODFILL,
EmfRecordTypeLineTo = EMR_LINETO,
EmfRecordTypeArcTo = EMR_ARCTO,
EmfRecordTypePolyDraw = EMR_POLYDRAW,
EmfRecordTypeSetArcDirection = EMR_SETARCDIRECTION,
EmfRecordTypeSetMiterLimit = EMR_SETMITERLIMIT,
EmfRecordTypeBeginPath = EMR_BEGINPATH,
EmfRecordTypeEndPath = EMR_ENDPATH,
EmfRecordTypeCloseFigure = EMR_CLOSEFIGURE,
EmfRecordTypeFillPath = EMR_FILLPATH,
EmfRecordTypeStrokeAndFillPath = EMR_STROKEANDFILLPATH,
EmfRecordTypeStrokePath = EMR_STROKEPATH,
EmfRecordTypeFlattenPath = EMR_FLATTENPATH,
EmfRecordTypeWidenPath = EMR_WIDENPATH,
EmfRecordTypeSelectClipPath = EMR_SELECTCLIPPATH,
EmfRecordTypeAbortPath = EMR_ABORTPATH,
EmfRecordTypeReserved_069 = 69,
EmfRecordTypeGdiComment = EMR_GDICOMMENT,
EmfRecordTypeFillRgn = EMR_FILLRGN,
EmfRecordTypeFrameRgn = EMR_FRAMERGN,
EmfRecordTypeInvertRgn = EMR_INVERTRGN,
EmfRecordTypePaintRgn = EMR_PAINTRGN,
EmfRecordTypeExtSelectClipRgn = EMR_EXTSELECTCLIPRGN,
EmfRecordTypeBitBlt = EMR_BITBLT,
EmfRecordTypeStretchBlt = EMR_STRETCHBLT,
EmfRecordTypeMaskBlt = EMR_MASKBLT,
EmfRecordTypePlgBlt = EMR_PLGBLT,
EmfRecordTypeSetDIBitsToDevice = EMR_SETDIBITSTODEVICE,
EmfRecordTypeStretchDIBits = EMR_STRETCHDIBITS,
EmfRecordTypeExtCreateFontIndirect = EMR_EXTCREATEFONTINDIRECTW,
EmfRecordTypeExtTextOutA = EMR_EXTTEXTOUTA,
EmfRecordTypeExtTextOutW = EMR_EXTTEXTOUTW,
EmfRecordTypePolyBezier16 = EMR_POLYBEZIER16,
EmfRecordTypePolygon16 = EMR_POLYGON16,
EmfRecordTypePolyline16 = EMR_POLYLINE16,
EmfRecordTypePolyBezierTo16 = EMR_POLYBEZIERTO16,
EmfRecordTypePolylineTo16 = EMR_POLYLINETO16,
EmfRecordTypePolyPolyline16 = EMR_POLYPOLYLINE16,
EmfRecordTypePolyPolygon16 = EMR_POLYPOLYGON16,
EmfRecordTypePolyDraw16 = EMR_POLYDRAW16,
EmfRecordTypeCreateMonoBrush = EMR_CREATEMONOBRUSH,
EmfRecordTypeCreateDIBPatternBrushPt = EMR_CREATEDIBPATTERNBRUSHPT,
EmfRecordTypeExtCreatePen = EMR_EXTCREATEPEN,
EmfRecordTypePolyTextOutA = EMR_POLYTEXTOUTA,
EmfRecordTypePolyTextOutW = EMR_POLYTEXTOUTW,
EmfRecordTypeSetICMMode = 98,
EmfRecordTypeCreateColorSpace = 99,
EmfRecordTypeSetColorSpace = 100,
EmfRecordTypeDeleteColorSpace = 101,
EmfRecordTypeGLSRecord = 102,
EmfRecordTypeGLSBoundedRecord = 103,
EmfRecordTypePixelFormat = 104,
EmfRecordTypeDrawEscape = 105,
EmfRecordTypeExtEscape = 106,
EmfRecordTypeStartDoc = 107,
EmfRecordTypeSmallTextOut = 108,
EmfRecordTypeForceUFIMapping = 109,
EmfRecordTypeNamedEscape = 110,
EmfRecordTypeColorCorrectPalette = 111,
EmfRecordTypeSetICMProfileA = 112,
EmfRecordTypeSetICMProfileW = 113,
EmfRecordTypeAlphaBlend = 114,
EmfRecordTypeSetLayout = 115,
EmfRecordTypeTransparentBlt = 116,
EmfRecordTypeReserved_117 = 117,
EmfRecordTypeGradientFill = 118,
EmfRecordTypeSetLinkedUFIs = 119,
EmfRecordTypeSetTextJustification = 120,
EmfRecordTypeColorMatchToTargetW = 121,
EmfRecordTypeCreateColorSpaceW = 122,
EmfRecordTypeMax = 122,
EmfRecordTypeMin = 1,
EmfPlusRecordTypeInvalid = GDIP_EMFPLUS_RECORD_BASE,
EmfPlusRecordTypeHeader,
EmfPlusRecordTypeEndOfFile,
EmfPlusRecordTypeComment,
EmfPlusRecordTypeGetDC,
EmfPlusRecordTypeMultiFormatStart,
EmfPlusRecordTypeMultiFormatSection,
EmfPlusRecordTypeMultiFormatEnd,
EmfPlusRecordTypeObject,
EmfPlusRecordTypeClear,
EmfPlusRecordTypeFillRects,
EmfPlusRecordTypeDrawRects,
EmfPlusRecordTypeFillPolygon,
EmfPlusRecordTypeDrawLines,
EmfPlusRecordTypeFillEllipse,
EmfPlusRecordTypeDrawEllipse,
EmfPlusRecordTypeFillPie,
EmfPlusRecordTypeDrawPie,
EmfPlusRecordTypeDrawArc,
EmfPlusRecordTypeFillRegion,
EmfPlusRecordTypeFillPath,
EmfPlusRecordTypeDrawPath,
EmfPlusRecordTypeFillClosedCurve,
EmfPlusRecordTypeDrawClosedCurve,
EmfPlusRecordTypeDrawCurve,
EmfPlusRecordTypeDrawBeziers,
EmfPlusRecordTypeDrawImage,
EmfPlusRecordTypeDrawImagePoints,
EmfPlusRecordTypeDrawString,
EmfPlusRecordTypeSetRenderingOrigin,
EmfPlusRecordTypeSetAntiAliasMode,
EmfPlusRecordTypeSetTextRenderingHint,
EmfPlusRecordTypeSetTextContrast,
EmfPlusRecordTypeSetGammaValue,
EmfPlusRecordTypeSetInterpolationMode,
EmfPlusRecordTypeSetPixelOffsetMode,
EmfPlusRecordTypeSetCompositingMode,
EmfPlusRecordTypeSetCompositingQuality,
EmfPlusRecordTypeSave,
EmfPlusRecordTypeRestore,
EmfPlusRecordTypeBeginContainer,
EmfPlusRecordTypeBeginContainerNoParams,
EmfPlusRecordTypeEndContainer,
EmfPlusRecordTypeSetWorldTransform,
EmfPlusRecordTypeResetWorldTransform,
EmfPlusRecordTypeMultiplyWorldTransform,
EmfPlusRecordTypeTranslateWorldTransform,
EmfPlusRecordTypeScaleWorldTransform,
EmfPlusRecordTypeRotateWorldTransform,
EmfPlusRecordTypeSetPageTransform,
EmfPlusRecordTypeResetClip,
EmfPlusRecordTypeSetClipRect,
EmfPlusRecordTypeSetClipPath,
EmfPlusRecordTypeSetClipRegion,
EmfPlusRecordTypeOffsetClip,
EmfPlusRecordTypeDrawDriverString,
EmfPlusRecordTypeStrokeFillPath,
EmfPlusRecordTypeSerializableObject,
EmfPlusRecordTypeSetTSGraphics,
EmfPlusRecordTypeSetTSClip,
EmfPlusRecordTotal,
EmfPlusRecordTypeMax = EmfPlusRecordTotal-1,
EmfPlusRecordTypeMin = EmfPlusRecordTypeHeader
} EmfPlusRecordType;
typedef enum EmfToWmfBitsFlags {
EmfToWmfBitsFlagsDefault = 0,
EmfToWmfBitsFlagsEmbedEmf = 1,
EmfToWmfBitsFlagsIncludePlaceable = 2,
EmfToWmfBitsFlagsNoXORClip = 4
} EmfToWmfBitsFlags;
typedef enum EmfType {
EmfTypeEmfOnly = 3,
EmfTypeEmfPlusOnly = 4,
EmfTypeEmfPlusDual = 5
} EmfType;
typedef enum EncoderParameterValueType {
EncoderParameterValueTypeByte = 1,
EncoderParameterValueTypeASCII = 2,
EncoderParameterValueTypeShort = 3,
EncoderParameterValueTypeLong = 4,
EncoderParameterValueTypeRational = 5,
EncoderParameterValueTypeLongRange = 6,
EncoderParameterValueTypeUndefined = 7,
EncoderParameterValueTypeRationalRange = 8,
EncoderParameterValueTypePointer = 9
} EncoderParameterValueType;
typedef enum EncoderValue {
EncoderValueColorTypeCMYK = 0,
EncoderValueColorTypeYCCK = 1,
EncoderValueCompressionLZW = 2,
EncoderValueCompressionCCITT3 = 3,
EncoderValueCompressionCCITT4 = 4,
EncoderValueCompressionRle = 5,
EncoderValueCompressionNone = 6,
EncoderValueScanMethodInterlaced = 7,
EncoderValueScanMethodNonInterlaced = 8,
EncoderValueVersionGif87 = 9,
EncoderValueVersionGif89 = 10,
EncoderValueRenderProgressive = 11,
EncoderValueRenderNonProgressive = 12,
EncoderValueTransformRotate90 = 13,
EncoderValueTransformRotate180 = 14,
EncoderValueTransformRotate270 = 15,
EncoderValueTransformFlipHorizontal = 16,
EncoderValueTransformFlipVertical = 17,
EncoderValueMultiFrame = 18,
EncoderValueLastFrame = 19,
EncoderValueFlush = 20,
EncoderValueFrameDimensionTime = 21,
EncoderValueFrameDimensionResolution = 22,
EncoderValueFrameDimensionPage = 23
} EncoderValue;
typedef enum FillMode {
FillModeAlternate = 0,
FillModeWinding = 1
} FillMode;
typedef enum FlushIntention {
FlushIntentionFlush = 0,
FlushIntentionSync = 1
} FlushIntention;
typedef enum FontStyle {
FontStyleRegular = 0,
FontStyleBold = 1,
FontStyleItalic = 2,
FontStyleBoldItalic = 3,
FontStyleUnderline = 4,
FontStyleStrikeout = 8
} FontStyle;
typedef enum HatchStyle {
HatchStyleHorizontal = 0,
HatchStyleVertical = 1,
HatchStyleForwardDiagonal = 2,
HatchStyleBackwardDiagonal = 3,
HatchStyleCross = 4,
HatchStyleLargeGrid = 4,
HatchStyleDiagonalCross = 5,
HatchStyle05Percent = 6,
HatchStyle10Percent = 7,
HatchStyle20Percent = 8,
HatchStyle25Percent = 9,
HatchStyle30Percent = 10,
HatchStyle40Percent = 11,
HatchStyle50Percent = 12,
HatchStyle60Percent = 13,
HatchStyle70Percent = 14,
HatchStyle75Percent = 15,
HatchStyle80Percent = 16,
HatchStyle90Percent = 17,
HatchStyleLightDownwardDiagonal = 18,
HatchStyleLightUpwardDiagonal = 19,
HatchStyleDarkDownwardDiagonal = 20,
HatchStyleDarkUpwardDiagonal = 21,
HatchStyleWideDownwardDiagonal = 22,
HatchStyleWideUpwardDiagonal = 23,
HatchStyleLightVertical = 24,
HatchStyleLightHorizontal = 25,
HatchStyleNarrowVertical = 26,
HatchStyleNarrowHorizontal = 27,
HatchStyleDarkVertical = 28,
HatchStyleDarkHorizontal = 29,
HatchStyleDashedDownwardDiagonal = 30,
HatchStyleDashedUpwardDiagonal = 31,
HatchStyleDashedHorizontal = 32,
HatchStyleDashedVertical = 33,
HatchStyleSmallConfetti = 34,
HatchStyleLargeConfetti = 35,
HatchStyleZigZag = 36,
HatchStyleWave = 37,
HatchStyleDiagonalBrick = 38,
HatchStyleHorizontalBrick = 39,
HatchStyleWeave = 40,
HatchStylePlaid = 41,
HatchStyleDivot = 42,
HatchStyleDottedGrid = 43,
HatchStyleDottedDiamond = 44,
HatchStyleShingle = 45,
HatchStyleTrellis = 46,
HatchStyleSphere = 47,
HatchStyleSmallGrid = 48,
HatchStyleSmallCheckerBoard = 49,
HatchStyleLargeCheckerBoard = 50,
HatchStyleOutlinedDiamond = 51,
HatchStyleSolidDiamond = 52,
HatchStyleTotal = 53,
HatchStyleMin = HatchStyleHorizontal,
HatchStyleMax = HatchStyleTotal - 1
} HatchStyle;
typedef enum HotkeyPrefix {
HotkeyPrefixNone = 0,
HotkeyPrefixShow = 1,
HotkeyPrefixHide = 2
} HotkeyPrefix;
typedef enum ImageType {
ImageTypeUnknown = 0,
ImageTypeBitmap = 1,
ImageTypeMetafile = 2
} ImageType;
/* TODO: InterpolationMode */
typedef enum InterpolationMode {
/*InterpolationModeInvalid = QualityModeInvalid,*/
InterpolationModeDefault = 0,
InterpolationModeLowQuality = 1,
InterpolationModeHighQuality = 2,
InterpolationModeBilinear = 3,
InterpolationModeBicubic = 4,
InterpolationModeNearestNeighbor = 5,
InterpolationModeHighQualityBilinear = 6,
InterpolationModeHighQualityBicubic = 7
} InterpolationMode;
typedef enum LinearGradientMode {
LinearGradientModeHorizontal = 0,
LinearGradientModeVertical = 1,
LinearGradientModeForwardDiagonal = 2,
LinearGradientModeBackwardDiagonal = 3
} LinearGradientMode;
typedef enum LineCap {
LineCapFlat = 0,
LineCapSquare = 1,
LineCapRound = 2,
LineCapTriangle = 3,
LineCapNoAnchor = 16,
LineCapSquareAnchor = 17,
LineCapRoundAnchor = 18,
LineCapDiamondAnchor = 19,
LineCapArrowAnchor = 20,
LineCapCustom = 255
} LineCap;
typedef enum LineJoin {
LineJoinMiter = 0,
LineJoinBevel = 1,
LineJoinRound = 2,
LineJoinMiterClipped = 3
} LineJoin;
typedef enum MatrixOrder {
MatrixOrderPrepend = 0,
MatrixOrderAppend = 1
} MatrixOrder;
typedef enum MetafileFrameUnit {
MetafileFrameUnitPixel = 2,
MetafileFrameUnitPoint = 3,
MetafileFrameUnitInch = 4,
MetafileFrameUnitDocument = 5,
MetafileFrameUnitMillimeter = 6,
MetafileFrameUnitGdi = 7
} MetafileFrameUnit;
typedef enum MetafileType {
MetafileTypeInvalid = 0,
MetafileTypeWmf = 1,
MetafileTypeWmfPlaceable = 2,
MetafileTypeEmf = 3,
MetafileTypeEmfPlusOnly = 4,
MetafileTypeEmfPlusDual = 5
} MetafileType;
typedef enum ObjectType {
ObjectTypeInvalid = 0,
ObjectTypeBrush = 1,
ObjectTypePen = 2,
ObjectTypePath = 3,
ObjectTypeRegion = 4,
ObjectTypeFont = 5,
ObjectTypeStringFormat = 6,
ObjectTypeImageAttributes = 7,
ObjectTypeCustomLineCap = 8,
ObjectTypeGraphics = 9,
ObjectTypeMin = ObjectTypeBrush,
ObjectTypeMax = ObjectTypeGraphics
} ObjectType;
typedef enum PathPointType {
PathPointTypeStart = 0x00,
PathPointTypeLine = 0x01,
PathPointTypeBezier = 0x03,
PathPointTypeBezier3 = 0x03,
PathPointTypePathTypeMask = 0x07,
PathPointTypePathDashMode = 0x10,
PathPointTypePathMarker = 0x20,
PathPointTypeCloseSubpath = 0x80
} PathPointType;
typedef enum PenAlignment {
PenAlignmentCenter = 0,
PenAlignmentInset = 1
} PenAlignment;
typedef enum PenType {
PenTypeUnknown = -1,
PenTypeSolidColor = 0,
PenTypeHatchFill = 1,
PenTypeTextureFill = 2,
PenTypePathGradient = 3,
PenTypeLinearGradient = 4
} PenType;
/* TODO: PixelOffsetMode */
typedef enum PixelOffsetMode {
/*PixelOffsetModeInvalid = QualityModeInvalid,*/
PixelOffsetModeDefault = 0,
PixelOffsetModeHighSpeed = 1,
PixelOffsetModeHighQuality = 2,
PixelOffsetModeNone = 3,
PixelOffsetModeHalf = 4
} PixelOffsetMode;
/* TODO: QualityMode */
typedef enum QualityMode {
/*QualityModeInvalid = ?,*/
QualityModeDefault = 0,
QualityModeLow = 1,
QualityModeHigh = 2
} QualityMode;
/* TODO: SmoothingMode */
typedef enum SmoothingMode {
/*SmoothingModeInvalid = QualityModeInvalid,*/
SmoothingModeDefault = 0,
SmoothingModeHighSpeed = 1,
SmoothingModeHighQuality = 2,
SmoothingModeNone = 3,
SmoothingModeAntiAlias8x4 = 4,
SmoothingModeAntiAlias = 4,
SmoothingModeAntiAlias8x8 = 5
} SmoothingMode;
typedef enum StringAlignment {
StringAlignmentNear = 0,
StringAlignmentCenter = 1,
StringAlignmentFar = 2
} StringAlignment;
typedef enum StringDigitSubstitute {
StringDigitSubstituteUser = 0,
StringDigitSubstituteNone = 1,
StringDigitSubstituteNational = 2,
StringDigitSubstituteTraditional = 3
} StringDigitSubstitute;
typedef enum StringFormatFlags {
StringFormatFlagsDirectionRightToLeft = 0x00000001,
StringFormatFlagsDirectionVertical = 0x00000002,
StringFormatFlagsNoFitBlackBox = 0x00000004,
StringFormatFlagsDisplayFormatControl = 0x00000020,
StringFormatFlagsNoFontFallback = 0x00000400,
StringFormatFlagsMeasureTrailingSpaces = 0x00000800,
StringFormatFlagsNoWrap = 0x00001000,
StringFormatFlagsLineLimit = 0x00002000,
StringFormatFlagsNoClip = 0x00004000
} StringFormatFlags;
typedef enum StringTrimming {
StringTrimmingNone = 0,
StringTrimmingCharacter = 1,
StringTrimmingWord = 2,
StringTrimmingEllipsisCharacter = 3,
StringTrimmingEllipsisWord = 4,
StringTrimmingEllipsisPath = 5
} StringTrimming;
typedef enum TextRenderingHint {
TextRenderingHintSystemDefault = 0,
TextRenderingHintSingleBitPerPixelGridFit = 1,
TextRenderingHintSingleBitPerPixel = 2,
TextRenderingHintAntiAliasGridFit = 3,
TextRenderingHintAntiAlias = 4,
TextRenderingHintClearTypeGridFit = 5
} TextRenderingHint;
typedef enum Unit {
UnitWorld = 0,
UnitDisplay = 1,
UnitPixel = 2,
UnitPoint = 3,
UnitInch = 4,
UnitDocument = 5,
UnitMillimeter = 6
} Unit;
typedef enum WarpMode {
WarpModePerspective = 0,
WarpModeBilinear = 1
} WarpMode;
typedef enum WrapMode {
WrapModeTile = 0,
WrapModeTileFlipX = 1,
WrapModeTileFlipY = 2,
WrapModeTileFlipXY = 3,
WrapModeClamp = 4
} WrapMode;
typedef enum GpTestControlEnum {
TestControlForceBilinear = 0,
TestControlForceNoICM = 1,
TestControlGetBuildNumber = 2
} GpTestControlEnum;
/* Opaque handles to information blocks on an internal GDI+ stack. */
typedef DWORD GraphicsContainer;
typedef DWORD GraphicsState;
/* Default flatness for GraphicsPath methods Flatten, Outline, Warp, Widen */
/* FIXME: Is FlatnessDefault = 0.25f correct? */
#ifdef __cplusplus
const REAL FlatnessDefault = 0.25f;
#else
#define FlatnessDefault ((REAL) 0.25f)
#endif
static __inline__ BOOL ObjectTypeIsValid(ObjectType type)
{
switch (type) {
case ObjectTypeBrush:
case ObjectTypePen:
case ObjectTypePath:
case ObjectTypeRegion:
case ObjectTypeFont:
case ObjectTypeStringFormat:
case ObjectTypeImageAttributes:
case ObjectTypeCustomLineCap:
case ObjectTypeGraphics:
return TRUE;
default:
return FALSE;
}
}
#endif /* __GDIPLUS_ENUMS_H */

722
winsup/w32api/include/gdiplus/gdiplusflat.h Executable file
View File

@ -0,0 +1,722 @@
/*
* gdiplusflat.h
*
* GDI+ Flat API
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_FLAT_H
#define __GDIPLUS_FLAT_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#ifdef __cplusplus
namespace DllExports {
extern "C" {
#endif
/* AdjustableArrowCap functions */
GpStatus WINGDIPAPI GdipCreateAdjustableArrowCap(REAL,REAL,BOOL,GpAdjustableArrowCap**);
GpStatus WINGDIPAPI GdipSetAdjustableArrowCapHeight(GpAdjustableArrowCap*,REAL);
GpStatus WINGDIPAPI GdipGetAdjustableArrowCapHeight(GpAdjustableArrowCap*,REAL*);
GpStatus WINGDIPAPI GdipSetAdjustableArrowCapWidth(GpAdjustableArrowCap*,REAL);
GpStatus WINGDIPAPI GdipGetAdjustableArrowCapWidth(GpAdjustableArrowCap*,REAL*);
GpStatus WINGDIPAPI GdipSetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap*,REAL);
GpStatus WINGDIPAPI GdipGetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap*,REAL*);
GpStatus WINGDIPAPI GdipSetAdjustableArrowCapFillState(GpAdjustableArrowCap*,BOOL);
GpStatus WINGDIPAPI GdipGetAdjustableArrowCapFillState(GpAdjustableArrowCap*,BOOL*);
/* Bitmap functions */
GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream*,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR*,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream*,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR*,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT,INT,INT,PixelFormat,BYTE*,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT,INT,GpGraphics*,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateBitmapFromDirectDrawSurface(IDirectDrawSurface7*,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO*,VOID*,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP,HPALETTE,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap*,HBITMAP*,ARGB);
GpStatus WINGDIPAPI GdipCreateBitmapFromHICON(HICON,GpBitmap**);
GpStatus WINGDIPAPI GdipCreateHICONFromBitmap(GpBitmap*,HICON*);
GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE,GDIPCONST WCHAR*,GpBitmap**);
GpStatus WINGDIPAPI GdipCloneBitmapArea(REAL,REAL,REAL,REAL,PixelFormat,GpBitmap*,GpBitmap**);
GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT,INT,INT,INT,PixelFormat,GpBitmap*,GpBitmap**);
GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap*,GDIPCONST GpRect*,UINT,PixelFormat,BitmapData*);
GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap*,BitmapData*);
GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap*,INT,INT,ARGB*);
GpStatus WINGDIPAPI GdipBitmapSetPixel(GpBitmap*,INT,INT,ARGB);
GpStatus WINGDIPAPI GdipBitmapSetResolution(GpBitmap*,REAL,REAL);
GpStatus WINGDIPAPI GdipBitmapConvertFormat(GpBitmap*,PixelFormat,DitherType,PaletteType,ColorPalette*,REAL);
GpStatus WINGDIPAPI GdipInitializePalette(ColorPalette*,PaletteType,INT,BOOL,GpBitmap*);
GpStatus WINGDIPAPI GdipBitmapApplyEffect(GpBitmap*,CGpEffect*,RECT*,BOOL,VOID**,INT*);
GpStatus WINGDIPAPI GdipBitmapCreateApplyEffect(GpBitmap**,INT,CGpEffect*,RECT*,RECT*,GpBitmap**,BOOL,VOID**,INT*);
GpStatus WINGDIPAPI GdipBitmapGetHistogram(GpBitmap*,HistogramFormat,UINT,UINT*,UINT*,UINT*,UINT*);
GpStatus WINGDIPAPI GdipBitmapGetHistogramSize(HistogramFormat,UINT*);
/* Brush functions */
GpStatus WINGDIPAPI GdipCloneBrush(GpBrush*,GpBrush**);
GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush*);
GpStatus WINGDIPAPI GdipGetBrushType(GpBrush*,GpBrushType*);
/* CachedBitmap functions */
GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap*,GpGraphics*,GpCachedBitmap**);
GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap*);
GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics*,GpCachedBitmap*,INT,INT);
/* CustomLineCap functions */
GpStatus WINGDIPAPI GdipCreateCustomLineCap(GpPath*,GpPath*,GpLineCap,REAL,GpCustomLineCap**);
GpStatus WINGDIPAPI GdipDeleteCustomLineCap(GpCustomLineCap*);
GpStatus WINGDIPAPI GdipCloneCustomLineCap(GpCustomLineCap*,GpCustomLineCap**);
GpStatus WINGDIPAPI GdipGetCustomLineCapType(GpCustomLineCap*,CustomLineCapType*);
GpStatus WINGDIPAPI GdipSetCustomLineCapStrokeCaps(GpCustomLineCap*,GpLineCap,GpLineCap);
GpStatus WINGDIPAPI GdipGetCustomLineCapStrokeCaps(GpCustomLineCap*,GpLineCap*,GpLineCap*);
GpStatus WINGDIPAPI GdipSetCustomLineCapStrokeJoin(GpCustomLineCap*,GpLineJoin);
GpStatus WINGDIPAPI GdipGetCustomLineCapStrokeJoin(GpCustomLineCap*,GpLineJoin*);
GpStatus WINGDIPAPI GdipSetCustomLineCapBaseCap(GpCustomLineCap*,GpLineCap);
GpStatus WINGDIPAPI GdipGetCustomLineCapBaseCap(GpCustomLineCap*,GpLineCap*);
GpStatus WINGDIPAPI GdipSetCustomLineCapBaseInset(GpCustomLineCap*,REAL);
GpStatus WINGDIPAPI GdipGetCustomLineCapBaseInset(GpCustomLineCap*,REAL*);
GpStatus WINGDIPAPI GdipSetCustomLineCapWidthScale(GpCustomLineCap*,REAL);
GpStatus WINGDIPAPI GdipGetCustomLineCapWidthScale(GpCustomLineCap*,REAL*);
/* Effect functions */
GpStatus WINGDIPAPI GdipCreateEffect(GDIPCONST GUID,CGpEffect**);
GpStatus WINGDIPAPI GdipDeleteEffect(CGpEffect*);
GpStatus WINGDIPAPI GdipGetEffectParameterSize(CGpEffect*,UINT*);
GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect*,GDIPCONST VOID*,UINT);
GpStatus WINGDIPAPI GdipGetEffectParameters(CGpEffect*,UINT*,VOID*);
/* Font functions */
GpStatus WINGDIPAPI GdipCreateFontFromDC(HDC,GpFont**);
GpStatus WINGDIPAPI GdipCreateFontFromLogfontA(HDC,GDIPCONST LOGFONTA*,GpFont**);
GpStatus WINGDIPAPI GdipCreateFontFromLogfontW(HDC,GDIPCONST LOGFONTW*,GpFont**);
GpStatus WINGDIPAPI GdipCreateFont(GDIPCONST GpFontFamily*,REAL,INT,Unit,GpFont**);
GpStatus WINGDIPAPI GdipCloneFont(GpFont*,GpFont**);
GpStatus WINGDIPAPI GdipDeleteFont(GpFont*);
GpStatus WINGDIPAPI GdipGetFamily(GpFont*,GpFontFamily**);
GpStatus WINGDIPAPI GdipGetFontStyle(GpFont*,INT*);
GpStatus WINGDIPAPI GdipGetFontSize(GpFont*,REAL*);
GpStatus WINGDIPAPI GdipGetFontUnit(GpFont*,Unit*);
GpStatus WINGDIPAPI GdipGetFontHeight(GDIPCONST GpFont*,GDIPCONST GpGraphics*,REAL*);
GpStatus WINGDIPAPI GdipGetFontHeightGivenDPI(GDIPCONST GpFont*,REAL,REAL*);
GpStatus WINGDIPAPI GdipGetLogFontA(GpFont*,GpGraphics*,LOGFONTA*);
GpStatus WINGDIPAPI GdipGetLogFontW(GpFont*,GpGraphics*,LOGFONTW*);
GpStatus WINGDIPAPI GdipNewInstalledFontCollection(GpFontCollection**);
GpStatus WINGDIPAPI GdipNewPrivateFontCollection(GpFontCollection**);
GpStatus WINGDIPAPI GdipDeletePrivateFontCollection(GpFontCollection**);
GpStatus WINGDIPAPI GdipGetFontCollectionFamilyCount(GpFontCollection*,INT*);
GpStatus WINGDIPAPI GdipGetFontCollectionFamilyList(GpFontCollection*,INT,GpFontFamily**,INT*);
GpStatus WINGDIPAPI GdipPrivateAddFontFile(GpFontCollection*,GDIPCONST WCHAR*);
GpStatus WINGDIPAPI GdipPrivateAddMemoryFont(GpFontCollection*,GDIPCONST void*,INT);
/* FontFamily functions */
GpStatus WINGDIPAPI GdipCreateFontFamilyFromName(GDIPCONST WCHAR*,GpFontCollection*,GpFontFamily**);
GpStatus WINGDIPAPI GdipDeleteFontFamily(GpFontFamily*);
GpStatus WINGDIPAPI GdipCloneFontFamily(GpFontFamily*,GpFontFamily**);
GpStatus WINGDIPAPI GdipGetGenericFontFamilySansSerif(GpFontFamily**);
GpStatus WINGDIPAPI GdipGetGenericFontFamilySerif(GpFontFamily**);
GpStatus WINGDIPAPI GdipGetGenericFontFamilyMonospace(GpFontFamily**);
GpStatus WINGDIPAPI GdipGetFamilyName(GDIPCONST GpFontFamily*,WCHAR[LF_FACESIZE],LANGID);
GpStatus WINGDIPAPI GdipIsStyleAvailable(GDIPCONST GpFontFamily*,INT,BOOL*);
GpStatus WINGDIPAPI GdipFontCollectionEnumerable(GpFontCollection*,GpGraphics*,INT*);
GpStatus WINGDIPAPI GdipFontCollectionEnumerate(GpFontCollection*,INT,GpFontFamily**,INT*,GpGraphics*);
GpStatus WINGDIPAPI GdipGetEmHeight(GDIPCONST GpFontFamily*,INT,UINT16*);
GpStatus WINGDIPAPI GdipGetCellAscent(GDIPCONST GpFontFamily*,INT,UINT16*);
GpStatus WINGDIPAPI GdipGetCellDescent(GDIPCONST GpFontFamily*,INT,UINT16*);
GpStatus WINGDIPAPI GdipGetLineSpacing(GDIPCONST GpFontFamily*,INT,UINT16*);
/* Graphics functions */
GpStatus WINGDIPAPI GdipFlush(GpGraphics*,GpFlushIntention);
GpStatus WINGDIPAPI GdipCreateFromHDC(HDC,GpGraphics**);
GpStatus WINGDIPAPI GdipCreateFromHDC2(HDC,HANDLE,GpGraphics**);
GpStatus WINGDIPAPI GdipCreateFromHWND(HWND,GpGraphics**);
GpStatus WINGDIPAPI GdipCreateFromHWNDICM(HWND,GpGraphics**);
GpStatus WINGDIPAPI GdipDeleteGraphics(GpGraphics*);
GpStatus WINGDIPAPI GdipGetDC(GpGraphics*,HDC*);
GpStatus WINGDIPAPI GdipReleaseDC(GpGraphics*,HDC);
GpStatus WINGDIPAPI GdipSetCompositingMode(GpGraphics*,CompositingMode);
GpStatus WINGDIPAPI GdipGetCompositingMode(GpGraphics*,CompositingMode*);
GpStatus WINGDIPAPI GdipSetRenderingOrigin(GpGraphics*,INT,INT);
GpStatus WINGDIPAPI GdipGetRenderingOrigin(GpGraphics*,INT*,INT*);
GpStatus WINGDIPAPI GdipSetCompositingQuality(GpGraphics*,CompositingQuality);
GpStatus WINGDIPAPI GdipGetCompositingQuality(GpGraphics*,CompositingQuality*);
GpStatus WINGDIPAPI GdipSetSmoothingMode(GpGraphics*,SmoothingMode);
GpStatus WINGDIPAPI GdipGetSmoothingMode(GpGraphics*,SmoothingMode*);
GpStatus WINGDIPAPI GdipSetPixelOffsetMode(GpGraphics*,PixelOffsetMode);
GpStatus WINGDIPAPI GdipGetPixelOffsetMode(GpGraphics*,PixelOffsetMode*);
GpStatus WINGDIPAPI GdipSetTextRenderingHint(GpGraphics*,TextRenderingHint);
GpStatus WINGDIPAPI GdipGetTextRenderingHint(GpGraphics*,TextRenderingHint*);
GpStatus WINGDIPAPI GdipSetTextContrast(GpGraphics*,UINT);
GpStatus WINGDIPAPI GdipGetTextContrast(GpGraphics*,UINT*);
GpStatus WINGDIPAPI GdipSetInterpolationMode(GpGraphics*,InterpolationMode);
GpStatus WINGDIPAPI GdipGraphicsSetAbort(GpGraphics*,GdiplusAbort*);
GpStatus WINGDIPAPI GdipGetInterpolationMode(GpGraphics*,InterpolationMode*);
GpStatus WINGDIPAPI GdipSetWorldTransform(GpGraphics*,GpMatrix*);
GpStatus WINGDIPAPI GdipResetWorldTransform(GpGraphics*);
GpStatus WINGDIPAPI GdipMultiplyWorldTransform(GpGraphics*,GDIPCONST GpMatrix*,GpMatrixOrder);
GpStatus WINGDIPAPI GdipTranslateWorldTransform(GpGraphics*,REAL,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipScaleWorldTransform(GpGraphics*,REAL,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipRotateWorldTransform(GpGraphics*,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipGetWorldTransform(GpGraphics*,GpMatrix*);
GpStatus WINGDIPAPI GdipResetPageTransform(GpGraphics*);
GpStatus WINGDIPAPI GdipGetPageUnit(GpGraphics*,GpUnit*);
GpStatus WINGDIPAPI GdipGetPageScale(GpGraphics*,REAL*);
GpStatus WINGDIPAPI GdipSetPageUnit(GpGraphics*,GpUnit);
GpStatus WINGDIPAPI GdipSetPageScale(GpGraphics*,REAL);
GpStatus WINGDIPAPI GdipGetDpiX(GpGraphics*,REAL*);
GpStatus WINGDIPAPI GdipGetDpiY(GpGraphics*,REAL*);
GpStatus WINGDIPAPI GdipTransformPoints(GpGraphics*,GpCoordinateSpace,GpCoordinateSpace,GpPointF*,INT);
GpStatus WINGDIPAPI GdipTransformPointsI(GpGraphics*,GpCoordinateSpace,GpCoordinateSpace,GpPoint*,INT);
GpStatus WINGDIPAPI GdipGetNearestColor(GpGraphics*,ARGB*);
HPALETTE WINGDIPAPI GdipCreateHalftonePalette(void);
GpStatus WINGDIPAPI GdipDrawLine(GpGraphics*,GpPen*,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipDrawLineI(GpGraphics*,GpPen*,INT,INT,INT,INT);
GpStatus WINGDIPAPI GdipDrawLines(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT);
GpStatus WINGDIPAPI GdipDrawLinesI(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT);
GpStatus WINGDIPAPI GdipDrawArc(GpGraphics*,GpPen*,REAL,REAL,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipDrawArcI(GpGraphics*,GpPen*,INT,INT,INT,INT,REAL,REAL);
GpStatus WINGDIPAPI GdipDrawBezier(GpGraphics*,GpPen*,REAL,REAL,REAL,REAL,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipDrawBezierI(GpGraphics*,GpPen*,INT,INT,INT,INT,INT,INT,INT,INT);
GpStatus WINGDIPAPI GdipDrawBeziers(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT);
GpStatus WINGDIPAPI GdipDrawBeziersI(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT);
GpStatus WINGDIPAPI GdipDrawRectangle(GpGraphics*,GpPen*,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipDrawRectangleI(GpGraphics*,GpPen*,INT,INT,INT,INT);
GpStatus WINGDIPAPI GdipDrawRectangles(GpGraphics*,GpPen*,GDIPCONST GpRectF*,INT);
GpStatus WINGDIPAPI GdipDrawRectanglesI(GpGraphics*,GpPen*,GDIPCONST GpRect*,INT);
GpStatus WINGDIPAPI GdipDrawEllipse(GpGraphics*,GpPen*,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipDrawEllipseI(GpGraphics*,GpPen*,INT,INT,INT,INT);
GpStatus WINGDIPAPI GdipDrawPie(GpGraphics*,GpPen*,REAL,REAL,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipDrawPieI(GpGraphics*,GpPen*,INT,INT,INT,INT,REAL,REAL);
GpStatus WINGDIPAPI GdipDrawPolygon(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT);
GpStatus WINGDIPAPI GdipDrawPolygonI(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT);
GpStatus WINGDIPAPI GdipDrawPath(GpGraphics*,GpPen*,GpPath*);
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 GdipDrawClosedCurve(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT);
GpStatus WINGDIPAPI GdipDrawClosedCurveI(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT);
GpStatus WINGDIPAPI GdipDrawClosedCurve2(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT,REAL);
GpStatus WINGDIPAPI GdipDrawClosedCurve2I(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT,REAL);
GpStatus WINGDIPAPI GdipGraphicsClear(GpGraphics*,ARGB);
GpStatus WINGDIPAPI GdipFillRectangle(GpGraphics*,GpBrush*,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipFillRectangleI(GpGraphics*,GpBrush*,INT,INT,INT,INT);
GpStatus WINGDIPAPI GdipFillRectangles(GpGraphics*,GpBrush*,GDIPCONST GpRectF*,INT);
GpStatus WINGDIPAPI GdipFillRectanglesI(GpGraphics*,GpBrush*,GDIPCONST GpRect*,INT);
GpStatus WINGDIPAPI GdipFillPolygon(GpGraphics*,GpBrush*,GDIPCONST GpPointF*,INT,GpFillMode);
GpStatus WINGDIPAPI GdipFillPolygonI(GpGraphics*,GpBrush*,GDIPCONST GpPoint*,INT,GpFillMode);
GpStatus WINGDIPAPI GdipFillPolygon2(GpGraphics*,GpBrush*,GDIPCONST GpPointF*,INT);
GpStatus WINGDIPAPI GdipFillPolygon2I(GpGraphics*,GpBrush*,GDIPCONST GpPoint*,INT);
GpStatus WINGDIPAPI GdipFillEllipse(GpGraphics*,GpBrush*,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipFillEllipseI(GpGraphics*,GpBrush*,INT,INT,INT,INT);
GpStatus WINGDIPAPI GdipFillPie(GpGraphics*,GpBrush*,REAL,REAL,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipFillPieI(GpGraphics*,GpBrush*,INT,INT,INT,INT,REAL,REAL);
GpStatus WINGDIPAPI GdipFillPath(GpGraphics*,GpBrush*,GpPath*);
GpStatus WINGDIPAPI GdipFillClosedCurve(GpGraphics*,GpBrush*,GDIPCONST GpPointF*,INT);
GpStatus WINGDIPAPI GdipFillClosedCurveI(GpGraphics*,GpBrush*,GDIPCONST GpPoint*,INT);
GpStatus WINGDIPAPI GdipFillClosedCurve2(GpGraphics*,GpBrush*,GDIPCONST GpPointF*,INT,REAL,GpFillMode);
GpStatus WINGDIPAPI GdipFillClosedCurve2I(GpGraphics*,GpBrush*,GDIPCONST GpPoint*,INT,REAL,GpFillMode);
GpStatus WINGDIPAPI GdipFillRegion(GpGraphics*,GpBrush*,GpRegion*);
GpStatus WINGDIPAPI GdipDrawImage(GpGraphics*,GpImage*,REAL,REAL);
GpStatus WINGDIPAPI GdipDrawImageI(GpGraphics*,GpImage*,INT,INT);
GpStatus WINGDIPAPI GdipDrawImageRect(GpGraphics*,GpImage*,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipDrawImageRectI(GpGraphics*,GpImage*,INT,INT,INT,INT);
GpStatus WINGDIPAPI GdipDrawImagePoints(GpGraphics*,GpImage*,GDIPCONST GpPointF*,INT);
GpStatus WINGDIPAPI GdipDrawImagePointsI(GpGraphics*,GpImage*,GDIPCONST GpPoint*,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 GdipDrawImageRectRect(GpGraphics*,GpImage*,REAL,REAL,REAL,REAL,REAL,REAL,REAL,REAL,GpUnit,GDIPCONST GpImageAttributes*,DrawImageAbort,VOID*);
GpStatus WINGDIPAPI GdipDrawImageRectRectI(GpGraphics*,GpImage*,INT,INT,INT,INT,INT,INT,INT,INT,GpUnit,GDIPCONST GpImageAttributes*,DrawImageAbort,VOID*);
GpStatus WINGDIPAPI GdipDrawImagePointsRect(GpGraphics*,GpImage*,GDIPCONST GpPointF*,INT,REAL,REAL,REAL,REAL,GpUnit,GDIPCONST GpImageAttributes*,DrawImageAbort,VOID*);
GpStatus WINGDIPAPI GdipDrawImagePointsRectI(GpGraphics*,GpImage*,GDIPCONST GpPoint*,INT,INT,INT,INT,INT,GpUnit,GDIPCONST GpImageAttributes*,DrawImageAbort,VOID*);
GpStatus WINGDIPAPI GdipDrawImageFX(GpGraphics*,GpImage*,GpRectF*,GpMatrix*,CGpEffect*,GpImageAttributes*,GpUnit);
#ifdef __cplusplus
GpStatus WINGDIPAPI GdipEnumerateMetafileDestPoint(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST PointF&,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
GpStatus WINGDIPAPI GdipEnumerateMetafileDestPointI(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST Point&,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
GpStatus WINGDIPAPI GdipEnumerateMetafileDestRect(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST RectF&,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
GpStatus WINGDIPAPI GdipEnumerateMetafileDestRectI(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST Rect&,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
#endif
GpStatus WINGDIPAPI GdipEnumerateMetafileDestPoints(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST PointF*,INT,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
GpStatus WINGDIPAPI GdipEnumerateMetafileDestPointsI(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST Point*,INT,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
#ifdef __cplusplus
GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPoint(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST PointF&,GDIPCONST RectF&,Unit,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPointI(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST Point&,GDIPCONST Rect&,Unit,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestRect(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST RectF&,GDIPCONST RectF&,Unit,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestRectI(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST Rect&,GDIPCONST Rect&,Unit,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPoints(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST PointF*,INT,GDIPCONST RectF&,Unit,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPointsI(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST Point*,INT,GDIPCONST Rect&,Unit,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
#endif
GpStatus WINGDIPAPI GdipSetClipGraphics(GpGraphics*,GpGraphics*,CombineMode);
GpStatus WINGDIPAPI GdipSetClipRect(GpGraphics*,REAL,REAL,REAL,REAL,CombineMode);
GpStatus WINGDIPAPI GdipSetClipRectI(GpGraphics*,INT,INT,INT,INT,CombineMode);
GpStatus WINGDIPAPI GdipSetClipPath(GpGraphics*,GpPath*,CombineMode);
GpStatus WINGDIPAPI GdipSetClipRegion(GpGraphics*,GpRegion*,CombineMode);
GpStatus WINGDIPAPI GdipSetClipHrgn(GpGraphics*,HRGN,CombineMode);
GpStatus WINGDIPAPI GdipResetClip(GpGraphics*);
GpStatus WINGDIPAPI GdipTranslateClip(GpGraphics*,REAL,REAL);
GpStatus WINGDIPAPI GdipTranslateClipI(GpGraphics*,INT,INT);
GpStatus WINGDIPAPI GdipGetClip(GpGraphics*,GpRegion*);
GpStatus WINGDIPAPI GdipGetClipBounds(GpGraphics*,GpRectF*);
GpStatus WINGDIPAPI GdipGetClipBoundsI(GpGraphics*,GpRect*);
GpStatus WINGDIPAPI GdipIsClipEmpty(GpGraphics*,BOOL*);
GpStatus WINGDIPAPI GdipGetVisibleClipBounds(GpGraphics*,GpRectF*);
GpStatus WINGDIPAPI GdipGetVisibleClipBoundsI(GpGraphics*,GpRect*);
GpStatus WINGDIPAPI GdipIsVisibleClipEmpty(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 GdipSaveGraphics(GpGraphics*,GraphicsState*);
GpStatus WINGDIPAPI GdipRestoreGraphics(GpGraphics*,GraphicsState);
GpStatus WINGDIPAPI GdipBeginContainer(GpGraphics*,GDIPCONST GpRectF*,GDIPCONST GpRectF*,GpUnit,GraphicsContainer*);
GpStatus WINGDIPAPI GdipBeginContainerI(GpGraphics*,GDIPCONST GpRect*,GDIPCONST GpRect*,GpUnit,GraphicsContainer*);
GpStatus WINGDIPAPI GdipBeginContainer2(GpGraphics*,GraphicsContainer*);
GpStatus WINGDIPAPI GdipEndContainer(GpGraphics*,GraphicsContainer);
GpStatus WINGDIPAPI GdipComment(GpGraphics*,UINT,GDIPCONST BYTE*);
/* GraphicsPath functions */
GpStatus WINGDIPAPI GdipCreatePath(GpFillMode,GpPath**);
GpStatus WINGDIPAPI GdipCreatePath2(GDIPCONST GpPointF*,GDIPCONST BYTE*,INT,GpFillMode,GpPath**);
GpStatus WINGDIPAPI GdipCreatePath2I(GDIPCONST GpPoint*,GDIPCONST BYTE*,INT,GpFillMode,GpPath**);
GpStatus WINGDIPAPI GdipClonePath(GpPath*,GpPath**);
GpStatus WINGDIPAPI GdipDeletePath(GpPath*);
GpStatus WINGDIPAPI GdipResetPath(GpPath*);
GpStatus WINGDIPAPI GdipGetPointCount(GpPath*,INT*);
GpStatus WINGDIPAPI GdipGetPathTypes(GpPath*,BYTE*,INT);
GpStatus WINGDIPAPI GdipGetPathPoints(GpPath*,GpPointF*,INT);
GpStatus WINGDIPAPI GdipGetPathPointsI(GpPath*,GpPoint*,INT);
GpStatus WINGDIPAPI GdipGetPathFillMode(GpPath*,GpFillMode*);
GpStatus WINGDIPAPI GdipSetPathFillMode(GpPath*,GpFillMode);
GpStatus WINGDIPAPI GdipGetPathData(GpPath*,GpPathData*);
GpStatus WINGDIPAPI GdipStartPathFigure(GpPath*);
GpStatus WINGDIPAPI GdipClosePathFigure(GpPath*);
GpStatus WINGDIPAPI GdipClosePathFigures(GpPath*);
GpStatus WINGDIPAPI GdipSetPathMarker(GpPath*);
GpStatus WINGDIPAPI GdipClearPathMarkers(GpPath*);
GpStatus WINGDIPAPI GdipReversePath(GpPath*);
GpStatus WINGDIPAPI GdipGetPathLastPoint(GpPath*,GpPointF*);
GpStatus WINGDIPAPI GdipAddPathLine(GpPath*,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipAddPathLine2(GpPath*,GDIPCONST GpPointF*,INT);
GpStatus WINGDIPAPI GdipAddPathArc(GpPath*,REAL,REAL,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipAddPathBezier(GpPath*,REAL,REAL,REAL,REAL,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipAddPathBeziers(GpPath*,GDIPCONST GpPointF*,INT);
GpStatus WINGDIPAPI GdipAddPathCurve(GpPath*,GDIPCONST GpPointF*,INT);
GpStatus WINGDIPAPI GdipAddPathCurve2(GpPath*,GDIPCONST GpPointF*,INT,REAL);
GpStatus WINGDIPAPI GdipAddPathCurve3(GpPath*,GDIPCONST GpPointF*,INT,INT,INT,REAL);
GpStatus WINGDIPAPI GdipAddPathClosedCurve(GpPath*,GDIPCONST GpPointF*,INT);
GpStatus WINGDIPAPI GdipAddPathClosedCurve2(GpPath*,GDIPCONST GpPointF*,INT,REAL);
GpStatus WINGDIPAPI GdipAddPathRectangle(GpPath*,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipAddPathRectangles(GpPath*,GDIPCONST GpRectF*,INT);
GpStatus WINGDIPAPI GdipAddPathEllipse(GpPath*,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipAddPathPie(GpPath*,REAL,REAL,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipAddPathPolygon(GpPath*,GDIPCONST GpPointF*,INT);
GpStatus WINGDIPAPI GdipAddPathPath(GpPath*,GDIPCONST GpPath*,BOOL);
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 GdipAddPathLineI(GpPath*,INT,INT,INT,INT);
GpStatus WINGDIPAPI GdipAddPathLine2I(GpPath*,GDIPCONST GpPoint*,INT);
GpStatus WINGDIPAPI GdipAddPathArcI(GpPath*,INT,INT,INT,INT,REAL,REAL);
GpStatus WINGDIPAPI GdipAddPathBezierI(GpPath*,INT,INT,INT,INT,INT,INT,INT,INT);
GpStatus WINGDIPAPI GdipAddPathBeziersI(GpPath*,GDIPCONST GpPoint*,INT);
GpStatus WINGDIPAPI GdipAddPathCurveI(GpPath*,GDIPCONST GpPoint*,INT);
GpStatus WINGDIPAPI GdipAddPathCurve2I(GpPath*,GDIPCONST GpPoint*,INT,REAL);
GpStatus WINGDIPAPI GdipAddPathCurve3I(GpPath*,GDIPCONST GpPoint*,INT,INT,INT,REAL);
GpStatus WINGDIPAPI GdipAddPathClosedCurveI(GpPath*,GDIPCONST GpPoint*,INT);
GpStatus WINGDIPAPI GdipAddPathClosedCurve2I(GpPath*,GDIPCONST GpPoint*,INT,REAL);
GpStatus WINGDIPAPI GdipAddPathRectangleI(GpPath*,INT,INT,INT,INT);
GpStatus WINGDIPAPI GdipAddPathRectanglesI(GpPath*,GDIPCONST GpRect*,INT);
GpStatus WINGDIPAPI GdipAddPathEllipseI(GpPath*,INT,INT,INT,INT);
GpStatus WINGDIPAPI GdipAddPathPieI(GpPath*,INT,INT,INT,INT,REAL,REAL);
GpStatus WINGDIPAPI GdipAddPathPolygonI(GpPath*,GDIPCONST GpPoint*,INT);
GpStatus WINGDIPAPI GdipFlattenPath(GpPath*,GpMatrix*,REAL);
GpStatus WINGDIPAPI GdipWindingModeOutline(GpPath*,GpMatrix*,REAL);
GpStatus WINGDIPAPI GdipWidenPath(GpPath*,GpPen*,GpMatrix*,REAL);
GpStatus WINGDIPAPI GdipWarpPath(GpPath*,GpMatrix*,GDIPCONST GpPointF*,INT,REAL,REAL,REAL,REAL,WarpMode,REAL);
GpStatus WINGDIPAPI GdipTransformPath(GpPath*,GpMatrix*);
GpStatus WINGDIPAPI GdipGetPathWorldBounds(GpPath*,GpRectF*,GDIPCONST GpMatrix*,GDIPCONST GpPen*);
GpStatus WINGDIPAPI GdipGetPathWorldBoundsI(GpPath*,GpRect*,GDIPCONST GpMatrix*,GDIPCONST GpPen*);
GpStatus WINGDIPAPI GdipIsVisiblePathPoint(GpPath*,REAL,REAL,GpGraphics*,BOOL*);
GpStatus WINGDIPAPI GdipIsVisiblePathPointI(GpPath*,INT,INT,GpGraphics*,BOOL*);
GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPoint(GpPath*,REAL,REAL,GpPen*,GpGraphics*,BOOL*);
GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPointI(GpPath*,INT,INT,GpPen*,GpGraphics*,BOOL*);
/* HatchBrush functions */
GpStatus WINGDIPAPI GdipCreateHatchBrush(GpHatchStyle,ARGB,ARGB,GpHatch**);
GpStatus WINGDIPAPI GdipGetHatchStyle(GpHatch*,GpHatchStyle*);
GpStatus WINGDIPAPI GdipGetHatchForegroundColor(GpHatch*,ARGB*);
GpStatus WINGDIPAPI GdipGetHatchBackgroundColor(GpHatch*,ARGB*);
/* Image functions */
GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream*,GpImage**);
GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR*,GpImage**);
GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream*,GpImage**);
GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR*,GpImage**);
GpStatus WINGDIPAPI GdipCloneImage(GpImage*,GpImage**);
GpStatus WINGDIPAPI GdipDisposeImage(GpImage*);
GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage*,GDIPCONST WCHAR*,GDIPCONST CLSID*,GDIPCONST EncoderParameters*);
GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage*,IStream*,GDIPCONST CLSID*,GDIPCONST EncoderParameters*);
GpStatus WINGDIPAPI GdipSaveAdd(GpImage*,GDIPCONST EncoderParameters*);
GpStatus WINGDIPAPI GdipSaveAddImage(GpImage*,GpImage*,GDIPCONST EncoderParameters*);
GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage*,GpGraphics**);
GpStatus WINGDIPAPI GdipGetImageBounds(GpImage*,GpRectF*,GpUnit*);
GpStatus WINGDIPAPI GdipGetImageDimension(GpImage*,REAL*,REAL*);
GpStatus WINGDIPAPI GdipGetImageType(GpImage*,ImageType*);
GpStatus WINGDIPAPI GdipGetImageWidth(GpImage*,UINT*);
GpStatus WINGDIPAPI GdipGetImageHeight(GpImage*,UINT*);
GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage*,REAL*);
GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage*,REAL*);
GpStatus WINGDIPAPI GdipGetImageFlags(GpImage*,UINT*);
GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage*,GUID*);
GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage*,PixelFormat*);
GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage*,UINT,UINT,GpImage**,GetThumbnailImageAbort,VOID*);
GpStatus WINGDIPAPI GdipGetEncoderParameterListSize(GpImage*,GDIPCONST CLSID*,UINT*);
GpStatus WINGDIPAPI GdipGetEncoderParameterList(GpImage*,GDIPCONST CLSID*,UINT,EncoderParameters*);
GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage*,UINT*);
GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage*,GUID*,UINT);
GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage*,GDIPCONST GUID*,UINT*);
GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage*,GDIPCONST GUID*,UINT);
GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage*,RotateFlipType);
GpStatus WINGDIPAPI GdipGetImagePalette(GpImage*,ColorPalette*,INT);
GpStatus WINGDIPAPI GdipSetImagePalette(GpImage*,GDIPCONST ColorPalette*);
GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage*,INT*);
GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage*,UINT*);
GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage*,UINT,PROPID*);
GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage*,PROPID,UINT*);
GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage*,PROPID,UINT,PropertyItem*);
GpStatus WINGDIPAPI GdipGetPropertySize(GpImage*,UINT*,UINT*);
GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage*,UINT,UINT,PropertyItem*);
GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage*,PROPID);
GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage*,GDIPCONST PropertyItem*);
GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage*,ImageItemData*);
GpStatus WINGDIPAPI GdipFindNextImageItem(GpImage*,ImageItemData*);
GpStatus WINGDIPAPI GdipGetImageItemData(GpImage*,ImageItemData*);
GpStatus WINGDIPAPI GdipImageSetAbort(GpImage*,GdiplusAbort*);
GpStatus WINGDIPAPI GdipImageForceValidation(GpImage*);
/* Image codec functions */
GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT*,UINT*);
GpStatus WINGDIPAPI GdipGetImageDecoders(UINT,UINT,ImageCodecInfo*);
GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT*,UINT*);
GpStatus WINGDIPAPI GdipGetImageEncoders(UINT,UINT,ImageCodecInfo*);
/* ImageAttributes functions */
GpStatus WINGDIPAPI GdipCreateImageAttributes(GpImageAttributes**);
GpStatus WINGDIPAPI GdipCloneImageAttributes(GDIPCONST GpImageAttributes*,GpImageAttributes**);
GpStatus WINGDIPAPI GdipDisposeImageAttributes(GpImageAttributes*);
GpStatus WINGDIPAPI GdipSetImageAttributesToIdentity(GpImageAttributes*,ColorAdjustType);
GpStatus WINGDIPAPI GdipResetImageAttributes(GpImageAttributes*,ColorAdjustType);
GpStatus WINGDIPAPI GdipSetImageAttributesColorMatrix(GpImageAttributes*,ColorAdjustType,BOOL,GDIPCONST ColorMatrix*,GDIPCONST ColorMatrix*,ColorMatrixFlags);
GpStatus WINGDIPAPI GdipSetImageAttributesThreshold(GpImageAttributes*,ColorAdjustType,BOOL,REAL);
GpStatus WINGDIPAPI GdipSetImageAttributesGamma(GpImageAttributes*,ColorAdjustType,BOOL,REAL);
GpStatus WINGDIPAPI GdipSetImageAttributesNoOp(GpImageAttributes*,ColorAdjustType,BOOL);
GpStatus WINGDIPAPI GdipSetImageAttributesColorKeys(GpImageAttributes*,ColorAdjustType,BOOL,ARGB,ARGB);
GpStatus WINGDIPAPI GdipSetImageAttributesOutputChannel(GpImageAttributes*,ColorAdjustType,BOOL,ColorChannelFlags);
GpStatus WINGDIPAPI GdipSetImageAttributesOutputChannelColorProfile(GpImageAttributes*,ColorAdjustType,BOOL,GDIPCONST WCHAR*);
GpStatus WINGDIPAPI GdipSetImageAttributesRemapTable(GpImageAttributes*,ColorAdjustType,BOOL,UINT,GDIPCONST ColorMap*);
GpStatus WINGDIPAPI GdipSetImageAttributesWrapMode(GpImageAttributes*,WrapMode,ARGB,BOOL);
GpStatus WINGDIPAPI GdipSetImageAttributesICMMode(GpImageAttributes*,BOOL);
GpStatus WINGDIPAPI GdipGetImageAttributesAdjustedPalette(GpImageAttributes*,ColorPalette*,ColorAdjustType);
GpStatus WINGDIPAPI GdipSetImageAttributesCachedBackground(GpImageAttributes*,BOOL);
/* LinearGradientBrush functions */
GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF*,GDIPCONST GpPointF*,ARGB,ARGB,GpWrapMode,GpLineGradient**);
GpStatus WINGDIPAPI GdipCreateLineBrushI(GDIPCONST GpPoint*,GDIPCONST GpPoint*,ARGB,ARGB,GpWrapMode,GpLineGradient**);
GpStatus WINGDIPAPI GdipCreateLineBrushFromRect(GDIPCONST GpRectF*,ARGB,ARGB,LinearGradientMode,GpWrapMode,GpLineGradient**);
GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI(GDIPCONST GpRect*,ARGB,ARGB,LinearGradientMode,GpWrapMode,GpLineGradient**);
GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngle(GDIPCONST GpRectF*,ARGB,ARGB,REAL,BOOL,GpWrapMode,GpLineGradient**);
GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngleI(GDIPCONST GpRect*,ARGB,ARGB,REAL,BOOL,GpWrapMode,GpLineGradient**);
GpStatus WINGDIPAPI GdipSetLineColors(GpLineGradient*,ARGB,ARGB);
GpStatus WINGDIPAPI GdipGetLineColors(GpLineGradient*,ARGB*);
GpStatus WINGDIPAPI GdipGetLineRect(GpLineGradient*,GpRectF*);
GpStatus WINGDIPAPI GdipGetLineRectI(GpLineGradient*,GpRect*);
GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient*,BOOL);
GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient*,BOOL*);
GpStatus WINGDIPAPI GdipGetLineBlendCount(GpLineGradient*,INT*);
GpStatus WINGDIPAPI GdipGetLineBlend(GpLineGradient*,REAL*,REAL*,INT);
GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient*,GDIPCONST REAL*,GDIPCONST REAL*,INT);
GpStatus WINGDIPAPI GdipGetLinePresetBlendCount(GpLineGradient*,INT*);
GpStatus WINGDIPAPI GdipGetLinePresetBlend(GpLineGradient*,ARGB*,REAL*,INT);
GpStatus WINGDIPAPI GdipSetLinePresetBlend(GpLineGradient*,GDIPCONST ARGB*,GDIPCONST REAL*,INT);
GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient*,REAL,REAL);
GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient*,REAL,REAL);
GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient*,GpWrapMode);
GpStatus WINGDIPAPI GdipGetLineWrapMode(GpLineGradient*,GpWrapMode*);
GpStatus WINGDIPAPI GdipGetLineTransform(GpLineGradient*,GpMatrix*);
GpStatus WINGDIPAPI GdipSetLineTransform(GpLineGradient*,GDIPCONST GpMatrix*);
GpStatus WINGDIPAPI GdipResetLineTransform(GpLineGradient*);
GpStatus WINGDIPAPI GdipMultiplyLineTransform(GpLineGradient*,GDIPCONST GpMatrix*,GpMatrixOrder);
GpStatus WINGDIPAPI GdipTranslateLineTransform(GpLineGradient*,REAL,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipScaleLineTransform(GpLineGradient*,REAL,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipRotateLineTransform(GpLineGradient*,REAL,GpMatrixOrder);
/* Matrix functions */
GpStatus WINGDIPAPI GdipCreateMatrix(GpMatrix**);
GpStatus WINGDIPAPI GdipCreateMatrix2(REAL,REAL,REAL,REAL,REAL,REAL,GpMatrix**);
GpStatus WINGDIPAPI GdipCreateMatrix3(GDIPCONST GpRectF*,GDIPCONST GpPointF*,GpMatrix**);
GpStatus WINGDIPAPI GdipCreateMatrix3I(GDIPCONST GpRect*,GDIPCONST GpPoint*,GpMatrix**);
GpStatus WINGDIPAPI GdipCloneMatrix(GpMatrix*,GpMatrix**);
GpStatus WINGDIPAPI GdipDeleteMatrix(GpMatrix*);
GpStatus WINGDIPAPI GdipSetMatrixElements(GpMatrix*,REAL,REAL,REAL,REAL,REAL,REAL);
GpStatus WINGDIPAPI GdipMultiplyMatrix(GpMatrix*,GpMatrix*,GpMatrixOrder);
GpStatus WINGDIPAPI GdipTranslateMatrix(GpMatrix*,REAL,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipScaleMatrix(GpMatrix*,REAL,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipRotateMatrix(GpMatrix*,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipShearMatrix(GpMatrix*,REAL,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipInvertMatrix(GpMatrix*);
GpStatus WINGDIPAPI GdipTransformMatrixPoints(GpMatrix*,GpPointF*,INT);
GpStatus WINGDIPAPI GdipTransformMatrixPointsI(GpMatrix*,GpPoint*,INT);
GpStatus WINGDIPAPI GdipVectorTransformMatrixPoints(GpMatrix*,GpPointF*,INT);
GpStatus WINGDIPAPI GdipVectorTransformMatrixPointsI(GpMatrix*,GpPoint*,INT);
GpStatus WINGDIPAPI GdipGetMatrixElements(GDIPCONST GpMatrix*,REAL*);
GpStatus WINGDIPAPI GdipIsMatrixInvertible(GDIPCONST GpMatrix*,BOOL*);
GpStatus WINGDIPAPI GdipIsMatrixIdentity(GDIPCONST GpMatrix*,BOOL*);
GpStatus WINGDIPAPI GdipIsMatrixEqual(GDIPCONST GpMatrix*,GDIPCONST GpMatrix*,BOOL*);
/* Metafile functions */
GpStatus WINGDIPAPI GdipGetMetafileHeaderFromEmf(HENHMETAFILE,MetafileHeader*);
GpStatus WINGDIPAPI GdipGetMetafileHeaderFromFile(GDIPCONST WCHAR*,MetafileHeader*);
GpStatus WINGDIPAPI GdipGetMetafileHeaderFromStream(IStream*,MetafileHeader*);
GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile*,MetafileHeader*);
GpStatus WINGDIPAPI GdipGetHemfFromMetafile(GpMetafile*,HENHMETAFILE*);
GpStatus WINGDIPAPI GdipCreateStreamOnFile(GDIPCONST WCHAR*,UINT,IStream**);
GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE,BOOL,GDIPCONST WmfPlaceableFileHeader*,GpMetafile**);
GpStatus WINGDIPAPI GdipCreateMetafileFromEmf(HENHMETAFILE,BOOL,GpMetafile**);
GpStatus WINGDIPAPI GdipCreateMetafileFromFile(GDIPCONST WCHAR*,GpMetafile**);
GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR*,GDIPCONST WmfPlaceableFileHeader*,GpMetafile**);
GpStatus WINGDIPAPI GdipCreateMetafileFromStream(IStream*,GpMetafile**);
GpStatus WINGDIPAPI GdipRecordMetafile(HDC,EmfType,GDIPCONST GpRectF*,MetafileFrameUnit,GDIPCONST WCHAR*,GpMetafile**);
GpStatus WINGDIPAPI GdipRecordMetafileI(HDC,EmfType,GDIPCONST GpRect*,MetafileFrameUnit,GDIPCONST WCHAR*,GpMetafile**);
GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR*,HDC,EmfType,GDIPCONST GpRectF*,MetafileFrameUnit,GDIPCONST WCHAR*,GpMetafile**);
GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR*,HDC,EmfType,GDIPCONST GpRect*,MetafileFrameUnit,GDIPCONST WCHAR*,GpMetafile**);
GpStatus WINGDIPAPI GdipRecordMetafileStream(IStream*,HDC,EmfType,GDIPCONST GpRectF*,MetafileFrameUnit,GDIPCONST WCHAR*,GpMetafile**);
GpStatus WINGDIPAPI GdipRecordMetafileStreamI(IStream*,HDC,EmfType,GDIPCONST GpRect*,MetafileFrameUnit,GDIPCONST WCHAR*,GpMetafile**);
GpStatus WINGDIPAPI GdipPlayMetafileRecord(GDIPCONST GpMetafile*,EmfPlusRecordType,UINT,UINT,GDIPCONST BYTE*);
GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit(GpMetafile*,UINT);
GpStatus WINGDIPAPI GdipGetMetafileDownLevelRasterizationLimit(GDIPCONST GpMetafile*,UINT*);
GpStatus WINGDIPAPI GdipConvertToEmfPlus(GDIPCONST GpGraphics*,GpMetafile*,BOOL*,EmfType,GDIPCONST WCHAR*,GpMetafile**);
GpStatus WINGDIPAPI GdipConvertToEmfPlusToFile(GDIPCONST GpGraphics*,GpMetafile*,BOOL*,GDIPCONST WCHAR*,EmfType,GDIPCONST WCHAR*,GpMetafile**);
GpStatus WINGDIPAPI GdipConvertToEmfPlusToStream(GDIPCONST GpGraphics*,GpMetafile*,BOOL*,IStream*,EmfType,GDIPCONST WCHAR*,GpMetafile**);
UINT WINGDIPAPI GdipEmfToWmfBits(HENHMETAFILE,UINT,LPBYTE,INT,INT);
/* PathGradientBrush functions */
GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF*,INT,GpWrapMode,GpPathGradient**);
GpStatus WINGDIPAPI GdipCreatePathGradientI(GDIPCONST GpPoint*,INT,GpWrapMode,GpPathGradient**);
GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath*,GpPathGradient**);
GpStatus WINGDIPAPI GdipGetPathGradientCenterColor(GpPathGradient*,ARGB*);
GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient*,ARGB);
GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient*,ARGB*,INT*);
GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount(GpPathGradient*,GDIPCONST ARGB*,INT*);
GpStatus WINGDIPAPI GdipGetPathGradientPath(GpPathGradient*,GpPath*);
GpStatus WINGDIPAPI GdipSetPathGradientPath(GpPathGradient*,GDIPCONST GpPath*);
GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient*,GpPointF*);
GpStatus WINGDIPAPI GdipGetPathGradientCenterPointI(GpPathGradient*,GpPoint*);
GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient*,GDIPCONST GpPointF*);
GpStatus WINGDIPAPI GdipSetPathGradientCenterPointI(GpPathGradient*,GDIPCONST GpPoint*);
GpStatus WINGDIPAPI GdipGetPathGradientRect(GpPathGradient*,GpRectF*);
GpStatus WINGDIPAPI GdipGetPathGradientRectI(GpPathGradient*,GpRect*);
GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient*,INT*);
GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorCount(GpPathGradient*,INT*);
GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient*,BOOL);
GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient*,BOOL*);
GpStatus WINGDIPAPI GdipGetPathGradientBlendCount(GpPathGradient*,INT*);
GpStatus WINGDIPAPI GdipGetPathGradientBlend(GpPathGradient*,REAL*,REAL*,INT);
GpStatus WINGDIPAPI GdipSetPathGradientBlend(GpPathGradient*,GDIPCONST REAL*,GDIPCONST REAL*,INT);
GpStatus WINGDIPAPI GdipGetPathGradientPresetBlendCount(GpPathGradient*,INT*);
GpStatus WINGDIPAPI GdipGetPathGradientPresetBlend(GpPathGradient*,ARGB*,REAL*,INT);
GpStatus WINGDIPAPI GdipSetPathGradientPresetBlend(GpPathGradient*,GDIPCONST ARGB*,GDIPCONST REAL*,INT);
GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend(GpPathGradient*,REAL,REAL);
GpStatus WINGDIPAPI GdipSetPathGradientLinearBlend(GpPathGradient*,REAL,REAL);
GpStatus WINGDIPAPI GdipGetPathGradientWrapMode(GpPathGradient*,GpWrapMode*);
GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient*,GpWrapMode);
GpStatus WINGDIPAPI GdipGetPathGradientTransform(GpPathGradient*,GpMatrix*);
GpStatus WINGDIPAPI GdipSetPathGradientTransform(GpPathGradient*,GpMatrix*);
GpStatus WINGDIPAPI GdipResetPathGradientTransform(GpPathGradient*);
GpStatus WINGDIPAPI GdipMultiplyPathGradientTransform(GpPathGradient*,GDIPCONST GpMatrix*,GpMatrixOrder);
GpStatus WINGDIPAPI GdipTranslatePathGradientTransform(GpPathGradient*,REAL,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipScalePathGradientTransform(GpPathGradient*,REAL,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipRotatePathGradientTransform(GpPathGradient*,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient*,REAL*,REAL*);
GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient*,REAL,REAL);
/* PathIterator functions */
GpStatus WINGDIPAPI GdipCreatePathIter(GpPathIterator**,GpPath*);
GpStatus WINGDIPAPI GdipDeletePathIter(GpPathIterator*);
GpStatus WINGDIPAPI GdipPathIterNextSubpath(GpPathIterator*,INT*,INT*,INT*,BOOL*);
GpStatus WINGDIPAPI GdipPathIterNextSubpathPath(GpPathIterator*,INT*,GpPath*,BOOL*);
GpStatus WINGDIPAPI GdipPathIterNextPathType(GpPathIterator*,INT*,BYTE*,INT*,INT*);
GpStatus WINGDIPAPI GdipPathIterNextMarker(GpPathIterator*,INT*,INT*,INT*);
GpStatus WINGDIPAPI GdipPathIterNextMarkerPath(GpPathIterator*,INT*,GpPath*);
GpStatus WINGDIPAPI GdipPathIterGetCount(GpPathIterator*,INT*);
GpStatus WINGDIPAPI GdipPathIterGetSubpathCount(GpPathIterator*,INT*);
GpStatus WINGDIPAPI GdipPathIterIsValid(GpPathIterator*,BOOL*);
GpStatus WINGDIPAPI GdipPathIterHasCurve(GpPathIterator*,BOOL*);
GpStatus WINGDIPAPI GdipPathIterRewind(GpPathIterator*);
GpStatus WINGDIPAPI GdipPathIterEnumerate(GpPathIterator*,INT*,GpPointF*,BYTE*,INT);
GpStatus WINGDIPAPI GdipPathIterCopyData(GpPathIterator*,INT*,GpPointF*,BYTE*,INT,INT);
/* Pen functions */
GpStatus WINGDIPAPI GdipCreatePen1(ARGB,REAL,GpUnit,GpPen**);
GpStatus WINGDIPAPI GdipCreatePen2(GpBrush*,REAL,GpUnit,GpPen**);
GpStatus WINGDIPAPI GdipClonePen(GpPen*,GpPen**);
GpStatus WINGDIPAPI GdipDeletePen(GpPen*);
GpStatus WINGDIPAPI GdipSetPenWidth(GpPen*,REAL);
GpStatus WINGDIPAPI GdipGetPenWidth(GpPen*,REAL*);
GpStatus WINGDIPAPI GdipSetPenUnit(GpPen*,GpUnit);
GpStatus WINGDIPAPI GdipGetPenUnit(GpPen*,GpUnit*);
GpStatus WINGDIPAPI GdipSetPenLineCap197819(GpPen*,GpLineCap,GpLineCap,GpDashCap);
GpStatus WINGDIPAPI GdipSetPenStartCap(GpPen*,GpLineCap);
GpStatus WINGDIPAPI GdipSetPenEndCap(GpPen*,GpLineCap);
GpStatus WINGDIPAPI GdipSetPenDashCap197819(GpPen*,GpDashCap);
GpStatus WINGDIPAPI GdipGetPenStartCap(GpPen*,GpLineCap*);
GpStatus WINGDIPAPI GdipGetPenEndCap(GpPen*,GpLineCap*);
GpStatus WINGDIPAPI GdipGetPenDashCap197819(GpPen*,GpDashCap*);
GpStatus WINGDIPAPI GdipSetPenLineJoin(GpPen*,GpLineJoin);
GpStatus WINGDIPAPI GdipGetPenLineJoin(GpPen*,GpLineJoin*);
GpStatus WINGDIPAPI GdipSetPenCustomStartCap(GpPen*,GpCustomLineCap*);
GpStatus WINGDIPAPI GdipGetPenCustomStartCap(GpPen*,GpCustomLineCap**);
GpStatus WINGDIPAPI GdipSetPenCustomEndCap(GpPen*,GpCustomLineCap*);
GpStatus WINGDIPAPI GdipGetPenCustomEndCap(GpPen*,GpCustomLineCap**);
GpStatus WINGDIPAPI GdipSetPenMiterLimit(GpPen*,REAL);
GpStatus WINGDIPAPI GdipGetPenMiterLimit(GpPen*,REAL*);
GpStatus WINGDIPAPI GdipSetPenMode(GpPen*,GpPenAlignment);
GpStatus WINGDIPAPI GdipGetPenMode(GpPen*,GpPenAlignment*);
GpStatus WINGDIPAPI GdipSetPenTransform(GpPen*,GpMatrix*);
GpStatus WINGDIPAPI GdipGetPenTransform(GpPen*,GpMatrix*);
GpStatus WINGDIPAPI GdipResetPenTransform(GpPen*);
GpStatus WINGDIPAPI GdipMultiplyPenTransform(GpPen*,GDIPCONST GpMatrix*,GpMatrixOrder);
GpStatus WINGDIPAPI GdipTranslatePenTransform(GpPen*,REAL,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipScalePenTransform(GpPen*,REAL,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipRotatePenTransform(GpPen*,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipSetPenColor(GpPen*,ARGB);
GpStatus WINGDIPAPI GdipGetPenColor(GpPen*,ARGB*);
GpStatus WINGDIPAPI GdipSetPenBrushFill(GpPen*,GpBrush*);
GpStatus WINGDIPAPI GdipGetPenBrushFill(GpPen*,GpBrush**);
GpStatus WINGDIPAPI GdipGetPenFillType(GpPen*,GpPenType*);
GpStatus WINGDIPAPI GdipGetPenDashStyle(GpPen*,GpDashStyle*);
GpStatus WINGDIPAPI GdipSetPenDashStyle(GpPen*,GpDashStyle);
GpStatus WINGDIPAPI GdipGetPenDashOffset(GpPen*,REAL*);
GpStatus WINGDIPAPI GdipSetPenDashOffset(GpPen*,REAL);
GpStatus WINGDIPAPI GdipGetPenDashCount(GpPen*,INT*);
GpStatus WINGDIPAPI GdipSetPenDashArray(GpPen*,GDIPCONST REAL*,INT);
GpStatus WINGDIPAPI GdipGetPenDashArray(GpPen*,REAL*,INT);
GpStatus WINGDIPAPI GdipGetPenCompoundCount(GpPen*,INT*);
GpStatus WINGDIPAPI GdipSetPenCompoundArray(GpPen*,GDIPCONST REAL*,INT);
GpStatus WINGDIPAPI GdipGetPenCompoundArray(GpPen*,REAL*,INT);
/* Region functions */
GpStatus WINGDIPAPI GdipCreateRegion(GpRegion**);
GpStatus WINGDIPAPI GdipCreateRegionRect(GDIPCONST GpRectF*,GpRegion**);
GpStatus WINGDIPAPI GdipCreateRegionRectI(GDIPCONST GpRect*,GpRegion**);
GpStatus WINGDIPAPI GdipCreateRegionPath(GpPath*,GpRegion**);
GpStatus WINGDIPAPI GdipCreateRegionRgnData(GDIPCONST BYTE*,INT,GpRegion**);
GpStatus WINGDIPAPI GdipCreateRegionHrgn(HRGN,GpRegion**);
GpStatus WINGDIPAPI GdipCloneRegion(GpRegion*,GpRegion**);
GpStatus WINGDIPAPI GdipDeleteRegion(GpRegion*);
GpStatus WINGDIPAPI GdipSetInfinite(GpRegion*);
GpStatus WINGDIPAPI GdipSetEmpty(GpRegion*);
GpStatus WINGDIPAPI GdipCombineRegionRect(GpRegion*,GDIPCONST GpRectF*,CombineMode);
GpStatus WINGDIPAPI GdipCombineRegionRectI(GpRegion*,GDIPCONST GpRect*,CombineMode);
GpStatus WINGDIPAPI GdipCombineRegionPath(GpRegion*,GpPath*,CombineMode);
GpStatus WINGDIPAPI GdipCombineRegionRegion(GpRegion*,GpRegion*,CombineMode);
GpStatus WINGDIPAPI GdipTranslateRegion(GpRegion*,REAL,REAL);
GpStatus WINGDIPAPI GdipTranslateRegionI(GpRegion*,INT,INT);
GpStatus WINGDIPAPI GdipTransformRegion(GpRegion*,GpMatrix*);
GpStatus WINGDIPAPI GdipGetRegionBounds(GpRegion*,GpGraphics*,GpRectF*);
GpStatus WINGDIPAPI GdipGetRegionBoundsI(GpRegion*,GpGraphics*,GpRect*);
GpStatus WINGDIPAPI GdipGetRegionHRgn(GpRegion*,GpGraphics*,HRGN*);
GpStatus WINGDIPAPI GdipIsEmptyRegion(GpRegion*,GpGraphics*,BOOL*);
GpStatus WINGDIPAPI GdipIsInfiniteRegion(GpRegion*,GpGraphics*,BOOL*);
GpStatus WINGDIPAPI GdipIsEqualRegion(GpRegion*,GpRegion*,GpGraphics*,BOOL*);
GpStatus WINGDIPAPI GdipGetRegionDataSize(GpRegion*,UINT*);
GpStatus WINGDIPAPI GdipGetRegionData(GpRegion*,BYTE*,UINT,UINT*);
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 GdipGetRegionScansCount(GpRegion*,UINT*,GpMatrix*);
GpStatus WINGDIPAPI GdipGetRegionScans(GpRegion*,GpRectF*,INT*,GpMatrix*);
GpStatus WINGDIPAPI GdipGetRegionScansI(GpRegion*,GpRect*,INT*,GpMatrix*);
/* SolidBrush functions */
GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB,GpSolidFill**);
GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill*,ARGB);
GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill*,ARGB*);
/* StringFormat functions */
GpStatus WINGDIPAPI GdipCreateStringFormat(INT,LANGID,GpStringFormat**);
GpStatus WINGDIPAPI GdipStringFormatGetGenericDefault(GpStringFormat**);
GpStatus WINGDIPAPI GdipStringFormatGetGenericTypographic(GpStringFormat**);
GpStatus WINGDIPAPI GdipDeleteStringFormat(GpStringFormat*);
GpStatus WINGDIPAPI GdipCloneStringFormat(GDIPCONST GpStringFormat*,GpStringFormat**);
GpStatus WINGDIPAPI GdipSetStringFormatFlags(GpStringFormat*,INT);
GpStatus WINGDIPAPI GdipGetStringFormatFlags(GDIPCONST GpStringFormat*,INT*);
GpStatus WINGDIPAPI GdipSetStringFormatAlign(GpStringFormat*,StringAlignment);
GpStatus WINGDIPAPI GdipGetStringFormatAlign(GDIPCONST GpStringFormat*,StringAlignment*);
GpStatus WINGDIPAPI GdipSetStringFormatLineAlign(GpStringFormat*,StringAlignment);
GpStatus WINGDIPAPI GdipGetStringFormatLineAlign(GDIPCONST GpStringFormat*,StringAlignment*);
GpStatus WINGDIPAPI GdipSetStringFormatTrimming(GpStringFormat*,StringTrimming);
GpStatus WINGDIPAPI GdipGetStringFormatTrimming(GDIPCONST GpStringFormat*,StringTrimming*);
GpStatus WINGDIPAPI GdipSetStringFormatHotkeyPrefix(GpStringFormat*,INT);
GpStatus WINGDIPAPI GdipGetStringFormatHotkeyPrefix(GDIPCONST GpStringFormat*,INT*);
GpStatus WINGDIPAPI GdipSetStringFormatTabStops(GpStringFormat*,REAL,INT,GDIPCONST REAL*);
GpStatus WINGDIPAPI GdipGetStringFormatTabStops(GDIPCONST GpStringFormat*,INT,REAL*,REAL*);
GpStatus WINGDIPAPI GdipGetStringFormatTabStopCount(GDIPCONST GpStringFormat*,INT*);
GpStatus WINGDIPAPI GdipSetStringFormatDigitSubstitution(GpStringFormat*,LANGID,StringDigitSubstitute);
GpStatus WINGDIPAPI GdipGetStringFormatDigitSubstitution(GDIPCONST GpStringFormat*,LANGID*,StringDigitSubstitute*);
GpStatus WINGDIPAPI GdipGetStringFormatMeasurableCharacterRangeCount(GDIPCONST GpStringFormat*,INT*);
GpStatus WINGDIPAPI GdipSetStringFormatMeasurableCharacterRanges(GpStringFormat*,INT,GDIPCONST CharacterRange*);
/* Text functions */
GpStatus WINGDIPAPI GdipDrawString(GpGraphics*,GDIPCONST WCHAR*,INT,GDIPCONST GpFont*,GDIPCONST RectF*,GDIPCONST GpStringFormat*,GDIPCONST GpBrush*);
GpStatus WINGDIPAPI GdipMeasureString(GpGraphics*,GDIPCONST WCHAR*,INT,GDIPCONST GpFont*,GDIPCONST RectF*,GDIPCONST GpStringFormat*,RectF*,INT*,INT*);
#ifdef __cplusplus
GpStatus WINGDIPAPI GdipMeasureCharacterRanges(GpGraphics*,GDIPCONST WCHAR*,INT,GDIPCONST GpFont*,GDIPCONST RectF&,GDIPCONST GpStringFormat*,INT,GpRegion**);
#endif
GpStatus WINGDIPAPI GdipDrawDriverString(GpGraphics*,GDIPCONST UINT16*,INT,GDIPCONST GpFont*,GDIPCONST GpBrush*,GDIPCONST PointF*,INT,GDIPCONST GpMatrix*);
GpStatus WINGDIPAPI GdipMeasureDriverString(GpGraphics*,GDIPCONST UINT16*,INT,GDIPCONST GpFont*,GDIPCONST PointF*,INT,GDIPCONST GpMatrix*,RectF*);
/* TextureBrush functions */
GpStatus WINGDIPAPI GdipCreateTexture(GpImage*,GpWrapMode,GpTexture**);
GpStatus WINGDIPAPI GdipCreateTexture2(GpImage*,GpWrapMode,REAL,REAL,REAL,REAL,GpTexture**);
GpStatus WINGDIPAPI GdipCreateTexture2I(GpImage*,GpWrapMode,INT,INT,INT,INT,GpTexture**);
GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage*,GDIPCONST GpImageAttributes*,REAL,REAL,REAL,REAL,GpTexture**);
GpStatus WINGDIPAPI GdipCreateTextureIAI(GpImage*,GDIPCONST GpImageAttributes*,INT,INT,INT,INT,GpTexture**);
GpStatus WINGDIPAPI GdipGetTextureTransform(GpTexture*,GpMatrix*);
GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture*,GDIPCONST GpMatrix*);
GpStatus WINGDIPAPI GdipResetTextureTransform(GpTexture*);
GpStatus WINGDIPAPI GdipMultiplyTextureTransform(GpTexture*,GDIPCONST GpMatrix*,GpMatrixOrder);
GpStatus WINGDIPAPI GdipTranslateTextureTransform(GpTexture*,REAL,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipScaleTextureTransform(GpTexture*,REAL,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipRotateTextureTransform(GpTexture*,REAL,GpMatrixOrder);
GpStatus WINGDIPAPI GdipSetTextureWrapMode(GpTexture*,GpWrapMode);
GpStatus WINGDIPAPI GdipGetTextureWrapMode(GpTexture*,GpWrapMode*);
GpStatus WINGDIPAPI GdipGetTextureImage(GpTexture*,GpImage**);
/* uncategorized functions */
GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum,void*);
#ifdef __cplusplus
} /* extern "C" */
} /* namespace DllExports */
#endif
#endif /* __GDIPLUS_FLAT_H */

139
winsup/w32api/include/gdiplus/gdiplusgpstubs.h Executable file
View File

@ -0,0 +1,139 @@
/*
* gdiplusgpstubs.h
*
* GDI+ Gp* type declarations
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_GPSTUBS_H
#define __GDIPLUS_GPSTUBS_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
typedef Point GpPoint;
typedef PointF GpPointF;
typedef Rect GpRect;
typedef RectF GpRectF;
typedef Size GpSize;
typedef SizeF GpSizeF;
typedef enum BrushType GpBrushType;
typedef enum CombineMode GpCombineMode;
typedef enum CompositingMode GpCompositingMode;
typedef enum CompositingQuality GpCompositingQuality;
typedef enum CoordinateSpace GpCoordinateSpace;
typedef enum CustomLineCapType GpCustomLineCapType;
typedef enum DashCap GpDashCap;
typedef enum DashStyle GpDashStyle;
typedef enum DitherType GpDitherType;
typedef enum DriverStringOptions GpDriverStringOptions;
typedef enum EmfPlusRecordType GpEmfPlusRecordType;
typedef enum EmfToWmfBitsFlags GpEmfToWmfBitsFlags;
typedef enum EmfType GpEmfType;
typedef enum EncoderParameterValueType GpEncoderParameterValueType;
typedef enum EncoderValue GpEncoderValue;
typedef enum FillMode GpFillMode;
typedef enum FlushIntention GpFlushIntention;
typedef enum FontStyle GpFontStyle;
typedef enum HatchStyle GpHatchStyle;
typedef enum HotkeyPrefix GpHotkeyPrefix;
typedef enum ImageType GpImageType;
typedef enum InterpolationMode GpInterpolationMode;
typedef enum LinearGradientMode GpLinearGradientMode;
typedef enum LineCap GpLineCap;
typedef enum LineJoin GpLineJoin;
typedef enum MatrixOrder GpMatrixOrder;
typedef enum MetafileFrameUnit GpMetafileFrameUnit;
typedef enum MetafileType GpMetafileType;
typedef enum ObjectType GpObjectType;
typedef enum PathPointType GpPathPointType;
typedef enum PenAlignment GpPenAlignment;
typedef enum PenType GpPenType;
typedef enum PixelOffsetMode GpPixelOffsetMode;
typedef enum QualityMode GpQualityMode;
typedef enum SmoothingMode GpSmoothingMode;
typedef enum StringAlignment GpStringAlignment;
typedef enum StringDigitSubstitute GpStringDigitSubstitute;
typedef enum StringFormatFlags GpStringFormatFlags;
typedef enum StringTrimming GpStringTrimming;
typedef enum TextRenderingHint GpTextRenderingHint;
typedef enum Unit GpUnit;
typedef enum WarpMode GpWarpMode;
typedef enum WrapMode GpWrapMode;
#ifdef __cplusplus
class CGpEffect {};
class GpCustomLineCap {};
class GpImage {};
class GpAdjustableArrowCap: public GpCustomLineCap {};
class GpBitmap: public GpImage {};
class GpBrush {};
class GpCachedBitmap {};
class GpFont {};
class GpFontCollection {};
class GpFontFamily {};
class GpGraphics {};
class GpHatch: public GpBrush {}; /* HatchBrush */
class GpImageAttributes {};
class GpLineGradient: public GpBrush {}; /* LinearGradientBrush */
class GpMatrix {};
class GpMetafile: public GpImage {};
class GpPath {}; /* GraphicsPath */
class GpPathData {};
class GpPathGradient: public GpBrush {}; /* PathGradientBrush */
class GpPathIterator {}; /* GraphicsPathIterator */
class GpPen {};
class GpRegion {};
class GpSolidFill: public GpBrush {}; /* SolidBrush */
class GpStringFormat {};
class GpTexture: public GpBrush {}; /* TextureBrush */
#else /* !__cplusplus */
typedef void CGpEffect;
typedef void GpAdjustableArrowCap;
typedef void GpBitmap;
typedef void GpBrush;
typedef void GpCachedBitmap;
typedef void GpCustomLineCap;
typedef void GpFont;
typedef void GpFontFamily;
typedef void GpFontCollection;
typedef void GpGraphics;
typedef void GpHatch;
typedef void GpImage;
typedef void GpImageAttributes;
typedef void GpLineGradient;
typedef void GpMatrix;
typedef void GpMetafile;
typedef void GpPath;
typedef void GpPathData;
typedef void GpPathGradient;
typedef void GpPathIterator;
typedef void GpPen;
typedef void GpRegion;
typedef void GpSolidFill;
typedef void GpStringFormat;
typedef void GpTexture;
#endif /* !__cplusplus */
#endif /* __GDIPLUS_GPSTUBS_H */

1540
winsup/w32api/include/gdiplus/gdiplusgraphics.h Executable file
View File

File diff suppressed because it is too large Load Diff

581
winsup/w32api/include/gdiplus/gdiplusheaders.h Executable file
View File

@ -0,0 +1,581 @@
/*
* gdiplusheaders.h
*
* GDI+ Bitmap, CachedBitmap, CustomLineCap, Font, FontCollection,
* FontFamily, Image, InstalledFontCollection, PrivateFontCollection,
* Region class definitions.
* Implementation of these classes is in gdiplusimpl.h.
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_HEADERS_H
#define __GDIPLUS_HEADERS_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#ifndef __cplusplus
#error "A C++ compiler is required to include gdiplusheaders.h."
#endif
/*
* Note: Virtual inline functions (dtors, Clone()) are implemented here: If
* these were defined outside class scope, the compiler would always generate
* code for them (and the vtable), even if these classes were never used.
*/
class Bitmap;
class Effect;
class FontCollection;
class FontFamily;
class Graphics;
class GraphicsPath;
class Matrix;
class Pen;
class Image: public GdiplusBase
{
friend class Bitmap;
friend class Metafile;
friend class CachedBitmap;
friend class Graphics;
friend class TextureBrush;
public:
static Image* FromFile(const WCHAR *filename,
BOOL useEmbeddedColorManagement = FALSE);
static Image* FromStream(IStream *stream,
BOOL useEmbeddedColorManagement = FALSE);
Image(const WCHAR *filename, BOOL useEmbeddedColorManagement = FALSE);
Image(IStream *stream, BOOL useEmbeddedColorManagement = FALSE);
virtual ~Image()
{
DllExports::GdipDisposeImage(nativeImage);
}
virtual Image* Clone() const
{
GpImage *cloneImage = NULL;
Status status = updateStatus(DllExports::GdipCloneImage(
nativeImage, &cloneImage));
if (status == Ok) {
Image *result = new Image(cloneImage, lastStatus);
if (!result) {
DllExports::GdipDisposeImage(cloneImage);
lastStatus = OutOfMemory;
}
return result;
} else {
return NULL;
}
}
Status FindFirstItem(ImageItemData *item);
Status FindNextItem(ImageItemData *item);
Status GetAllPropertyItems(UINT totalBufferSize,
UINT numProperties, PropertyItem *allItems);
Status GetBounds(RectF *srcRect, Unit *srcUnit);
Status GetEncoderParameterList(const CLSID *clsidEncoder,
UINT size, EncoderParameters *buffer);
UINT GetEncoderParameterListSize(const CLSID *clsidEncoder);
UINT GetFlags();
UINT GetFrameCount(const GUID *dimensionID);
UINT GetFrameDimensionsCount();
Status GetFrameDimensionsList(GUID *dimensionIDs, UINT count);
UINT GetHeight();
REAL GetHorizontalResolution();
Status GetItemData(ImageItemData *item);
Status GetPalette(ColorPalette *palette, INT size);
INT GetPaletteSize();
Status GetPhysicalDimension(SizeF *size);
PixelFormat GetPixelFormat();
UINT GetPropertyCount();
Status GetPropertyIdList(UINT numOfProperty, PROPID *list);
Status GetPropertyItem(PROPID propId, UINT propSize,
PropertyItem *buffer);
UINT GetPropertyItemSize(PROPID propId);
Status GetPropertySize(UINT *totalBufferSize, UINT *numProperties);
Status GetRawFormat(GUID *format);
Image* GetThumbnailImage(UINT thumbWidth, UINT thumbHeight,
GetThumbnailImageAbort callback, VOID *callbackData);
ImageType GetType() const;
REAL GetVerticalResolution();
UINT GetWidth();
Status RemovePropertyItem(PROPID propId);
Status RotateFlip(RotateFlipType rotateFlipType);
Status Save(IStream *stream, const CLSID *clsidEncoder,
const EncoderParameters *encoderParams);
Status Save(const WCHAR *filename, const CLSID *clsidEncoder,
const EncoderParameters *encoderParams);
Status SaveAdd(const EncoderParameters *encoderParams);
Status SaveAdd(Image *newImage, const EncoderParameters *encoderParams);
Status SelectActiveFrame(const GUID *dimensionID, UINT frameIndex);
Status SetAbort(GdiplusAbort *pIAbort);
Status SetPalette(const ColorPalette *palette);
Status SetPropertyItem(const PropertyItem *item);
Status GetLastStatus() const
{
Status result = lastStatus;
lastStatus = Ok;
return result;
}
private:
Image(GpImage *image, Status status):
nativeImage(image), lastStatus(status) {}
Image(const Image&);
Image& operator=(const Image&);
Status updateStatus(Status newStatus) const
{
if (newStatus != Ok) lastStatus = newStatus;
return newStatus;
}
GpImage *nativeImage;
mutable Status lastStatus;
};
class Bitmap: public Image
{
public:
static Bitmap* FromBITMAPINFO(const BITMAPINFO *gdiBitmapInfo,
VOID *gdiBitmapData);
static Bitmap* FromDirectDrawSurface7(IDirectDrawSurface7 *surface);
static Bitmap* FromFile(const WCHAR *filename,
BOOL useEmbeddedColorManagement = FALSE);
static Bitmap* FromHBITMAP(HBITMAP hbm, HPALETTE hpal);
static Bitmap* FromHICON(HICON icon);
static Bitmap* FromResource(HINSTANCE hInstance,
const WCHAR *bitmapName);
static Bitmap* FromStream(IStream *stream,
BOOL useEmbeddedColorManagement = FALSE);
static Status ApplyEffect(Bitmap **inputs, INT numInputs,
Effect *effect, RECT *ROI,
RECT *outputRect, Bitmap **output);
static Status InitializePalette(ColorPalette *palette,
PaletteType paletteType, INT optimalColors,
BOOL useTransparentColor, Bitmap *bitmap);
Bitmap(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData);
Bitmap(IDirectDrawSurface7 *surface);
Bitmap(const WCHAR *filename, BOOL useEmbeddedColorManagement = FALSE);
Bitmap(HBITMAP hbm, HPALETTE hpal);
Bitmap(HICON hicon);
Bitmap(HINSTANCE hInstance, const WCHAR *bitmapName);
Bitmap(IStream *stream, BOOL useEmbeddedColorManagement = FALSE);
Bitmap(INT width, INT height, Graphics *target);
Bitmap(INT width, INT height, PixelFormat format = PixelFormat32bppARGB);
Bitmap(INT width, INT height, INT stride, PixelFormat format, BYTE *scan0);
virtual ~Bitmap()
{
}
virtual Bitmap* Clone() const
{
GpImage *cloneImage = NULL;
Status status = updateStatus(DllExports::GdipCloneImage(
nativeImage, &cloneImage));
if (status == Ok) {
Bitmap *result = new Bitmap(cloneImage, lastStatus);
if (!result) {
DllExports::GdipDisposeImage(cloneImage);
lastStatus = OutOfMemory;
}
return result;
} else {
return NULL;
}
}
Bitmap* Clone(const RectF& rect, PixelFormat format) const;
Bitmap* Clone(const Rect& rect, PixelFormat format) const;
Bitmap* Clone(REAL x, REAL y, REAL width, REAL height,
PixelFormat format) const;
Bitmap* Clone(INT x, INT y, INT width, INT height,
PixelFormat format) const;
Status ApplyEffect(Effect *effect, RECT *ROI);
Status ConvertFormat(PixelFormat format, DitherType ditherType,
PaletteType paletteType, ColorPalette *palette,
REAL alphaThresholdPercent);
Status GetHBITMAP(const Color& colorBackground, HBITMAP *hbmReturn) const;
Status GetHICON(HICON *icon) const;
Status GetHistogram(HistogramFormat format, UINT numberOfEntries,
UINT *channel0, UINT *channel1,
UINT *channel2, UINT *channel3) const;
Status GetHistogramSize(HistogramFormat format,
UINT *numberOfEntries) const;
Status GetPixel(INT x, INT y, Color *color) const;
Status LockBits(const Rect *rect, UINT flags, PixelFormat format,
BitmapData *lockedBitmapData);
Status SetPixel(INT x, INT y, const Color& color);
Status SetResolution(REAL xdpi, REAL ydpi);
Status UnlockBits(BitmapData *lcokedBitmapData);
private:
Bitmap(GpImage *image, Status status): Image(image, status) {}
Bitmap(const Bitmap&);
Bitmap& operator=(const Bitmap&);
};
class CachedBitmap: public GdiplusBase
{
friend class Graphics;
public:
CachedBitmap(Bitmap *bitmap, Graphics *graphics);
~CachedBitmap();
Status GetLastStatus() const
{
return lastStatus;
}
private:
CachedBitmap(const CachedBitmap&);
CachedBitmap& operator=(const CachedBitmap&);
GpCachedBitmap *nativeCachedBitmap;
Status lastStatus;
};
class CustomLineCap: public GdiplusBase
{
friend class AdjustableArrowCap;
friend class Pen;
public:
CustomLineCap(const GraphicsPath *fillPath,
const GraphicsPath *strokePath,
LineCap baseCap = LineCapFlat,
REAL baseInset = 0.0f);
virtual ~CustomLineCap()
{
DllExports::GdipDeleteCustomLineCap(nativeCustomLineCap);
}
virtual CustomLineCap* Clone() const
{
GpCustomLineCap *cloneCustomLineCap = NULL;
Status status = updateStatus(DllExports::GdipCloneCustomLineCap(
nativeCustomLineCap, &cloneCustomLineCap));
if (status == Ok) {
CustomLineCap *result = new CustomLineCap(
cloneCustomLineCap, lastStatus);
if (!result) {
DllExports::GdipDeleteCustomLineCap(cloneCustomLineCap);
lastStatus = OutOfMemory;
}
return result;
} else {
return NULL;
}
}
LineCap GetBaseCap() const;
REAL GetBaseInset() const;
Status GetStrokeCaps(LineCap *startCap, LineCap *endCap) const;
LineJoin GetStrokeJoin() const;
REAL GetWidthScale() const;
Status SetBaseCap(LineCap baseCap);
Status SetBaseInset(REAL inset);
Status SetStrokeCap(LineCap strokeCap);
Status SetStrokeCaps(LineCap startCap, LineCap endCap);
Status SetStrokeJoin(LineJoin lineJoin);
Status SetWidthScale(REAL widthScale);
Status GetLastStatus() const
{
Status result = lastStatus;
lastStatus = Ok;
return result;
}
private:
CustomLineCap(GpCustomLineCap *customLineCap, Status status):
nativeCustomLineCap(customLineCap), lastStatus(status) {}
CustomLineCap(const CustomLineCap&);
CustomLineCap& operator=(const CustomLineCap&);
Status updateStatus(Status newStatus) const
{
if (newStatus != Ok) lastStatus = newStatus;
return newStatus;
}
GpCustomLineCap *nativeCustomLineCap;
mutable Status lastStatus;
};
class Font: public GdiplusBase
{
friend class Graphics;
public:
Font(const FontFamily *family, REAL emSize,
INT style = FontStyleRegular,
Unit unit = UnitPoint);
Font(HDC hdc, HFONT hfont);
Font(HDC hdc, const LOGFONTA *logfont);
Font(HDC hdc, const LOGFONTW *logfont);
Font(HDC hdc);
Font(const WCHAR *familyName, REAL emSize,
INT style = FontStyleRegular,
Unit unit = UnitPoint,
const FontCollection *fontCollection = NULL);
~Font();
Font* Clone() const;
Status GetFamily(FontFamily *family) const;
REAL GetHeight(const Graphics *graphics) const;
REAL GetHeight(REAL dpi) const;
Status GetLogFontA(const Graphics *graphics, LOGFONTA *logfontA) const;
Status GetLogFontW(const Graphics *graphics, LOGFONTW *logfontW) const;
REAL GetSize() const;
INT GetStyle() const;
Unit GetUnit() const;
Status GetLastStatus() const
{
return lastStatus;
}
BOOL IsAvailable() const
{
return nativeFont != NULL;
}
private:
Font(GpFont *font, Status status):
nativeFont(font), lastStatus(status) {}
Font(const Font&);
Font& operator=(const Font&);
Status updateStatus(Status newStatus) const
{
if (newStatus != Ok) lastStatus = newStatus;
return newStatus;
}
GpFont *nativeFont;
mutable Status lastStatus;
};
class FontCollection: public GdiplusBase
{
friend class InstalledFontCollection;
friend class PrivateFontCollection;
friend class Font;
friend class FontFamily;
public:
FontCollection();
virtual ~FontCollection() {}
Status GetFamilies(INT numSought, FontFamily *families,
INT *numFound) const;
INT GetFamilyCount() const;
Status GetLastStatus() const
{
return lastStatus;
}
private:
FontCollection(const FontCollection&);
FontCollection& operator=(const FontCollection&);
Status updateStatus(Status newStatus) const
{
return lastStatus = newStatus;
}
GpFontCollection *nativeFontCollection;
mutable Status lastStatus;
};
class FontFamily: public GdiplusBase
{
friend class Font;
friend class FontCollection;
friend class GraphicsPath;
public:
static const FontFamily* GenericMonospace();
static const FontFamily* GenericSansSerif();
static const FontFamily* GenericSerif();
FontFamily();
FontFamily(const WCHAR *name,
const FontCollection *fontCollection = NULL);
~FontFamily();
FontFamily* Clone() const;
UINT16 GetCellAscent(INT style) const;
UINT16 GetCellDescent(INT style) const;
UINT16 GetEmHeight(INT style) const;
Status GetFamilyName(WCHAR name[LF_FACESIZE],
LANGID language = LANG_NEUTRAL) const;
UINT16 GetLineSpacing(INT style) const;
BOOL IsStyleAvailable(INT style) const;
Status GetLastStatus() const
{
Status result = lastStatus;
lastStatus = Ok;
return result;
}
BOOL IsAvailable() const
{
return nativeFontFamily != NULL;
}
private:
FontFamily(GpFontFamily *fontFamily, Status status):
nativeFontFamily(fontFamily), lastStatus(status) {}
FontFamily(const FontFamily&);
FontFamily& operator=(const FontFamily&);
Status updateStatus(Status newStatus) const
{
if (newStatus != Ok) lastStatus = newStatus;
return newStatus;
}
GpFontFamily *nativeFontFamily;
mutable Status lastStatus;
};
class InstalledFontCollection: public FontCollection
{
public:
InstalledFontCollection();
virtual ~InstalledFontCollection() {}
};
class PrivateFontCollection: public FontCollection
{
public:
PrivateFontCollection();
virtual ~PrivateFontCollection()
{
DllExports::GdipDeletePrivateFontCollection(&nativeFontCollection);
}
Status AddFontFile(const WCHAR *filename);
Status AddMemoryFont(const VOID *memory, INT length);
};
class Region: public GdiplusBase
{
friend class Graphics;
public:
static Region* FromHRGN(HRGN hrgn);
Region();
Region(const RectF& rect);
Region(const Rect& rect);
Region(const GraphicsPath *path);
Region(const BYTE *regionData, INT size);
Region(HRGN hrgn);
~Region();
Region* Clone() const;
Status Complement(const RectF& rect);
Status Complement(const Rect& rect);
Status Complement(const Region *region);
Status Complement(const GraphicsPath *path);
BOOL Equals(const Region *region, const Graphics *graphics) const;
Status Exclude(const RectF& rect);
Status Exclude(const Rect& rect);
Status Exclude(const Region *region);
Status Exclude(const GraphicsPath *path);
Status GetBounds(RectF *rect, const Graphics *graphics) const;
Status GetBounds(Rect *rect, const Graphics *graphics) const;
Status GetData(BYTE *buffer, UINT bufferSize, UINT *sizeFilled) const;
UINT GetDataSize() const;
HRGN GetHRGN(const Graphics *graphics) const;
Status GetRegionScans(const Matrix *matrix,
RectF *rects, INT *count) const;
Status GetRegionScans(const Matrix *matrix,
Rect *rects, INT *count) const;
UINT GetRegionScansCount(const Matrix *matrix) const;
Status Intersect(const RectF& rect);
Status Intersect(const Rect& rect);
Status Intersect(const Region *region);
Status Intersect(const GraphicsPath *path);
BOOL IsEmpty(const Graphics *graphics) const;
BOOL IsInfinite(const Graphics *graphics) const;
BOOL IsVisible(REAL x, REAL y,
const Graphics *graphics = NULL) const;
BOOL IsVisible(INT x, INT y,
const Graphics *graphics = NULL) const;
BOOL IsVisible(const PointF& point,
const Graphics *graphics = NULL) const;
BOOL IsVisible(const Point& point,
const Graphics *graphics = NULL) const;
BOOL IsVisible(REAL x, REAL y, REAL width, REAL height,
const Graphics *graphics = NULL) const;
BOOL IsVisible(INT x, INT y, INT width, INT height,
const Graphics *graphics = NULL) const;
BOOL IsVisible(const RectF& rect,
const Graphics *graphics = NULL) const;
BOOL IsVisible(const Rect& rect,
const Graphics *graphics = NULL) const;
Status MakeEmpty();
Status MakeInfinite();
Status Transform(const Matrix *matrix);
Status Translate(REAL dx, REAL dy);
Status Translate(INT dx, INT dy);
Status Union(const RectF& rect);
Status Union(const Rect& rect);
Status Union(const Region *region);
Status Union(const GraphicsPath *path);
Status Xor(const RectF& rect);
Status Xor(const Rect& rect);
Status Xor(const Region *region);
Status Xor(const GraphicsPath *path);
Status GetLastStatus() const
{
Status result = lastStatus;
lastStatus = Ok;
return result;
}
private:
Region(GpRegion *region, Status status):
nativeRegion(region), lastStatus(status) {}
Region(const Region&);
Region& operator=(const Region&);
Status updateStatus(Status newStatus) const
{
if (newStatus != Ok) lastStatus = newStatus;
return newStatus;
}
GpRegion *nativeRegion;
mutable Status lastStatus;
};
#endif /* __GDIPLUS_HEADERS_H */

236
winsup/w32api/include/gdiplus/gdiplusimageattributes.h Executable file
View File

@ -0,0 +1,236 @@
/*
* gdiplusimageattributes.h
*
* GDI+ ImageAttributes class
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_IMAGEATTRIBUTES_H
#define __GDIPLUS_IMAGEATTRIBUTES_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#ifndef __cplusplus
#error "A C++ compiler is required to include gdiplusimageattributes.h."
#endif
class ImageAttributes: public GdiplusBase
{
friend class Graphics;
friend class TextureBrush;
public:
ImageAttributes(): nativeImageAttributes(NULL), lastStatus(Ok)
{
lastStatus = DllExports::GdipCreateImageAttributes(
&nativeImageAttributes);
}
~ImageAttributes()
{
DllExports::GdipDisposeImageAttributes(nativeImageAttributes);
}
ImageAttributes* Clone() const
{
GpImageAttributes *cloneImageAttributes = NULL;
Status status = updateStatus(DllExports::GdipCloneImageAttributes(
nativeImageAttributes, &cloneImageAttributes));
if (status == Ok) {
ImageAttributes *result = new ImageAttributes(
cloneImageAttributes, lastStatus);
if (!result) {
DllExports::GdipDisposeImageAttributes(cloneImageAttributes);
lastStatus = OutOfMemory;
}
return result;
} else {
return NULL;
}
}
Status ClearBrushRemapTable()
{
return updateStatus(DllExports::GdipSetImageAttributesRemapTable(
nativeImageAttributes, ColorAdjustTypeBrush,
FALSE, 0, NULL));
}
Status ClearColorKey(ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesColorKeys(
nativeImageAttributes, type, FALSE, 0, 0));
}
Status ClearColorMatrices(ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesColorMatrix(
nativeImageAttributes, type, FALSE,
NULL, NULL, ColorMatrixFlagsDefault));
}
Status ClearColorMatrix(ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesColorMatrix(
nativeImageAttributes, type, FALSE,
NULL, NULL, ColorMatrixFlagsDefault));
}
Status ClearGamma(ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesGamma(
nativeImageAttributes, type, FALSE, 1.0f));
}
Status ClearNoOp(ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesNoOp(
nativeImageAttributes, type, FALSE));
}
Status ClearOutputChannel(ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesOutputChannel(
nativeImageAttributes, type, FALSE,
ColorChannelFlagsC));
}
Status ClearOutputChannelColorProfile(
ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesOutputChannelColorProfile(
nativeImageAttributes, type, FALSE, NULL));
}
Status ClearRemapTable(ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesRemapTable(
nativeImageAttributes, type, FALSE, 0, NULL));
}
Status ClearThreshold(ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesThreshold(
nativeImageAttributes, type, FALSE, 0.0));
}
Status GetAdjustedPalette(ColorPalette *colorPalette,
ColorAdjustType type) const
{
return updateStatus(DllExports::GdipGetImageAttributesAdjustedPalette(
nativeImageAttributes, colorPalette, type));
}
Status GetLastStatus() const
{
Status result = lastStatus;
lastStatus = Ok;
return result;
}
Status Reset(ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipResetImageAttributes(
nativeImageAttributes, type));
}
Status SetBrushRemapTable(UINT mapSize, ColorMap *map)
{
return updateStatus(DllExports::GdipSetImageAttributesRemapTable(
nativeImageAttributes, ColorAdjustTypeBrush,
TRUE, mapSize, map));
}
Status SetColorKey(const Color& colorLow, const Color& colorHigh,
ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesColorKeys(
nativeImageAttributes, type, TRUE,
colorLow.GetValue(), colorHigh.GetValue()));
}
Status SetColorMatrices(const ColorMatrix *colorMatrix,
const ColorMatrix *grayMatrix,
ColorMatrixFlags mode = ColorMatrixFlagsDefault,
ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesColorMatrix(
nativeImageAttributes, type, TRUE,
colorMatrix, grayMatrix, mode));
}
Status SetColorMatrix(const ColorMatrix *colorMatrix,
ColorMatrixFlags mode = ColorMatrixFlagsDefault,
ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesColorMatrix(
nativeImageAttributes, type, TRUE,
colorMatrix, NULL, mode));
}
Status SetGamma(REAL gamma,
ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesGamma(
nativeImageAttributes, type, TRUE, gamma));
}
Status SetNoOp(ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesNoOp(
nativeImageAttributes, type, TRUE));
}
Status SetOutputChannel(ColorChannelFlags channelFlags,
ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesOutputChannel(
nativeImageAttributes, type, TRUE,
channelFlags));
}
Status SetOutputChannelColorProfile(const WCHAR *colorProfileFilename,
ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesOutputChannelColorProfile(
nativeImageAttributes, type, TRUE,
colorProfileFilename));
}
Status SetRemapTable(UINT mapSize, const ColorMap *map,
ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesRemapTable(
nativeImageAttributes, type, TRUE,
mapSize, map));
}
Status SetThreshold(REAL threshold,
ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesThreshold(
nativeImageAttributes, type, TRUE, threshold));
}
Status SetToIdentity(ColorAdjustType type = ColorAdjustTypeDefault)
{
return updateStatus(DllExports::GdipSetImageAttributesToIdentity(
nativeImageAttributes, type));
}
Status SetWrapMode(WrapMode wrap, const Color& color = Color(),
BOOL clamp = FALSE)
{
return updateStatus(DllExports::GdipSetImageAttributesWrapMode(
nativeImageAttributes, wrap,
color.GetValue(), clamp));
}
private:
ImageAttributes(GpImageAttributes *imageAttributes, Status status):
nativeImageAttributes(imageAttributes), lastStatus(status) {}
ImageAttributes(const ImageAttributes&);
ImageAttributes& operator=(const ImageAttributes&);
Status updateStatus(Status newStatus) const
{
if (newStatus != Ok) lastStatus = newStatus;
return newStatus;
}
GpImageAttributes *nativeImageAttributes;
mutable Status lastStatus;
};
#endif /* __GDIPLUS_IMAGEATTRIBUTES_H */

67
winsup/w32api/include/gdiplus/gdiplusimagecodec.h Executable file
View File

@ -0,0 +1,67 @@
/*
* gdiplusimagecodec.h
*
* GDI+ image decoders and encoders
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_IMAGECODEC_H
#define __GDIPLUS_IMAGECODEC_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
static __inline__ GpStatus GetImageDecoders(UINT numDecoders, UINT size,
ImageCodecInfo *decoders)
{
#ifdef __cplusplus
return DllExports::GdipGetImageDecoders(numDecoders, size, decoders);
#else
return GdipGetImageDecoders(numDecoders, size, decoders);
#endif
}
static __inline__ GpStatus GetImageDecodersSize(UINT *numDecoders, UINT *size)
{
#ifdef __cplusplus
return DllExports::GdipGetImageDecodersSize(numDecoders, size);
#else
return GdipGetImageDecodersSize(numDecoders, size);
#endif
}
static __inline__ GpStatus GetImageEncoders(UINT numEncoders, UINT size,
ImageCodecInfo *encoders)
{
#ifdef __cplusplus
return DllExports::GdipGetImageEncoders(numEncoders, size, encoders);
#else
return GdipGetImageEncoders(numEncoders, size, encoders);
#endif
}
static __inline__ GpStatus GetImageEncodersSize(UINT *numEncoders, UINT *size)
{
#ifdef __cplusplus
return DllExports::GdipGetImageEncodersSize(numEncoders, size);
#else
return GdipGetImageEncodersSize(numEncoders, size);
#endif
}
#endif /* __GDIPLUS_IMAGECODEC_H */

411
winsup/w32api/include/gdiplus/gdiplusimaging.h Executable file
View File

@ -0,0 +1,411 @@
/*
* gdiplusimaging.h
*
* GDI+ Imaging and image metadata
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_IMAGING_H
#define __GDIPLUS_IMAGING_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
typedef enum ImageCodecFlags {
ImageCodecFlagsEncoder = 0x00000001,
ImageCodecFlagsDecoder = 0x00000002,
ImageCodecFlagsSupportBitmap = 0x00000004,
ImageCodecFlagsSupportVector = 0x00000008,
ImageCodecFlagsSeekableEncode = 0x00000010,
ImageCodecFlagsBlockingDecode = 0x00000020,
ImageCodecFlagsBuiltin = 0x00010000,
ImageCodecFlagsSystem = 0x00020000,
ImageCodecFlagsUser = 0x00040000
} ImageCodecFlags;
typedef enum ImageFlags {
ImageFlagsNone = 0,
ImageFlagsScalable = 0x00000001,
ImageFlagsHasAlpha = 0x00000002,
ImageFlagsHasTranslucent = 0x00000004,
ImageFlagsPartiallyScalable = 0x00000008,
ImageFlagsColorSpaceRGB = 0x00000010,
ImageFlagsColorSpaceCMYK = 0x00000020,
ImageFlagsColorSpaceGRAY = 0x00000040,
ImageFlagsColorSpaceYCBCR = 0x00000080,
ImageFlagsColorSpaceYCCK = 0x00000100,
ImageFlagsHasRealDPI = 0x00001000,
ImageFlagsHasRealPixelSize = 0x00002000,
ImageFlagsReadOnly = 0x00010000,
ImageFlagsCaching = 0x00020000
} ImageFlags;
typedef enum ImageLockMode {
ImageLockModeRead = 1,
ImageLockModeWrite = 2,
ImageLockModeUserInputBuf = 4
} ImageLockMode;
typedef enum ItemDataPosition {
ItemDataPositionAfterHeader = 0,
ItemDataPositionAfterPalette = 1,
ItemDataPositionAfterBits = 2
} ItemDataPosition;
typedef enum RotateFlipType {
RotateNoneFlipNone = 0,
Rotate90FlipNone = 1,
Rotate180FlipNone = 2,
Rotate270FlipNone = 3,
RotateNoneFlipX = 4,
Rotate90FlipX = 5,
Rotate180FlipX = 6,
Rotate270FlipX = 7,
Rotate180FlipXY = 0,
Rotate270FlipXY = 1,
RotateNoneFlipXY = 2,
Rotate90FlipXY = 3,
Rotate180FlipY = 4,
Rotate270FlipY = 5,
RotateNoneFlipY = 6,
Rotate90FlipY = 7
} RotateFlipType;
typedef struct BitmapData {
UINT Width;
UINT Height;
INT Stride;
INT PixelFormat; /* MSDN: "PixelFormat PixelFormat;" */
VOID *Scan0;
UINT_PTR Reserved;
} BitmapData;
typedef struct EncoderParameter {
GUID Guid;
ULONG NumberOfValues;
ULONG Type;
VOID *Value;
} EncoderParameter;
typedef struct EncoderParameters {
UINT Count;
EncoderParameter Parameter[1];
} EncoderParameters;
typedef struct ImageCodecInfo {
CLSID Clsid;
GUID FormatID;
WCHAR *CodecName;
WCHAR *DllName;
WCHAR *FormatDescription;
WCHAR *FilenameExtension;
WCHAR *MimeType;
DWORD Flags;
DWORD Version;
DWORD SigCount;
DWORD SigSize;
BYTE *SigPattern;
BYTE *SigMask;
} ImageCodecInfo;
/* FIXME: The order of fields is probably wrong. Please don't use this
* structure until this problem is resolved! Can't test because
* ImageItemData is not supported by the redistributable GDI+ 1.0 DLL. */
typedef struct ImageItemData {
UINT Size;
UINT Position;
VOID *Desc;
UINT DescSize;
UINT *Data;
UINT DataSize;
UINT Cookie;
} ImageItemData;
typedef struct PropertyItem {
PROPID id;
ULONG length;
WORD type;
VOID *value;
} PropertyItem;
#define PropertyTagGpsVer ((PROPID) 0x0000)
#define PropertyTagGpsLatitudeRef ((PROPID) 0x0001)
#define PropertyTagGpsLatitude ((PROPID) 0x0002)
#define PropertyTagGpsLongitudeRef ((PROPID) 0x0003)
#define PropertyTagGpsLongitude ((PROPID) 0x0004)
#define PropertyTagGpsAltitudeRef ((PROPID) 0x0005)
#define PropertyTagGpsAltitude ((PROPID) 0x0006)
#define PropertyTagGpsGpsTime ((PROPID) 0x0007)
#define PropertyTagGpsGpsSatellites ((PROPID) 0x0008)
#define PropertyTagGpsGpsStatus ((PROPID) 0x0009)
#define PropertyTagGpsGpsMeasureMode ((PROPID) 0x000A)
#define PropertyTagGpsGpsDop ((PROPID) 0x000B)
#define PropertyTagGpsSpeedRef ((PROPID) 0x000C)
#define PropertyTagGpsSpeed ((PROPID) 0x000D)
#define PropertyTagGpsTrackRef ((PROPID) 0x000E)
#define PropertyTagGpsTrack ((PROPID) 0x000F)
#define PropertyTagGpsImgDirRef ((PROPID) 0x0010)
#define PropertyTagGpsImgDir ((PROPID) 0x0011)
#define PropertyTagGpsMapDatum ((PROPID) 0x0012)
#define PropertyTagGpsDestLatRef ((PROPID) 0x0013)
#define PropertyTagGpsDestLat ((PROPID) 0x0014)
#define PropertyTagGpsDestLongRef ((PROPID) 0x0015)
#define PropertyTagGpsDestLong ((PROPID) 0x0016)
#define PropertyTagGpsDestBearRef ((PROPID) 0x0017)
#define PropertyTagGpsDestBear ((PROPID) 0x0018)
#define PropertyTagGpsDestDistRef ((PROPID) 0x0019)
#define PropertyTagGpsDestDist ((PROPID) 0x001A)
#define PropertyTagNewSubfileType ((PROPID) 0x00FE)
#define PropertyTagSubfileType ((PROPID) 0x00FF)
#define PropertyTagImageWidth ((PROPID) 0x0100)
#define PropertyTagImageHeight ((PROPID) 0x0101)
#define PropertyTagBitsPerSample ((PROPID) 0x0102)
#define PropertyTagCompression ((PROPID) 0x0103)
#define PropertyTagPhotometricInterp ((PROPID) 0x0106)
#define PropertyTagThreshHolding ((PROPID) 0x0107)
#define PropertyTagCellWidth ((PROPID) 0x0108)
#define PropertyTagCellHeight ((PROPID) 0x0109)
#define PropertyTagFillOrder ((PROPID) 0x010A)
#define PropertyTagDocumentName ((PROPID) 0x010D)
#define PropertyTagImageDescription ((PROPID) 0x010E)
#define PropertyTagEquipMake ((PROPID) 0x010F)
#define PropertyTagEquipModel ((PROPID) 0x0110)
#define PropertyTagStripOffsets ((PROPID) 0x0111)
#define PropertyTagOrientation ((PROPID) 0x0112)
#define PropertyTagSamplesPerPixel ((PROPID) 0x0115)
#define PropertyTagRowsPerStrip ((PROPID) 0x0116)
#define PropertyTagStripBytesCount ((PROPID) 0x0117)
#define PropertyTagMinSampleValue ((PROPID) 0x0118)
#define PropertyTagMaxSampleValue ((PROPID) 0x0119)
#define PropertyTagXResolution ((PROPID) 0x011A)
#define PropertyTagYResolution ((PROPID) 0x011B)
#define PropertyTagPlanarConfig ((PROPID) 0x011C)
#define PropertyTagPageName ((PROPID) 0x011D)
#define PropertyTagXPosition ((PROPID) 0x011E)
#define PropertyTagYPosition ((PROPID) 0x011F)
#define PropertyTagFreeOffset ((PROPID) 0x0120)
#define PropertyTagFreeByteCounts ((PROPID) 0x0121)
#define PropertyTagGrayResponseUnit ((PROPID) 0x0122)
#define PropertyTagGrayResponseCurve ((PROPID) 0x0123)
#define PropertyTagT4Option ((PROPID) 0x0124)
#define PropertyTagT6Option ((PROPID) 0x0125)
#define PropertyTagResolutionUnit ((PROPID) 0x0128)
#define PropertyTagPageNumber ((PROPID) 0x0129)
#define PropertyTagTransferFunction ((PROPID) 0x012D)
#define PropertyTagSoftwareUsed ((PROPID) 0x0131)
#define PropertyTagDateTime ((PROPID) 0x0132)
#define PropertyTagArtist ((PROPID) 0x013B)
#define PropertyTagHostComputer ((PROPID) 0x013C)
#define PropertyTagPredictor ((PROPID) 0x013D)
#define PropertyTagWhitePoint ((PROPID) 0x013E)
#define PropertyTagPrimaryChromaticities ((PROPID) 0x013F)
#define PropertyTagColorMap ((PROPID) 0x0140)
#define PropertyTagHalftoneHints ((PROPID) 0x0141)
#define PropertyTagTileWidth ((PROPID) 0x0142)
#define PropertyTagTileLength ((PROPID) 0x0143)
#define PropertyTagTileOffset ((PROPID) 0x0144)
#define PropertyTagTileByteCounts ((PROPID) 0x0145)
#define PropertyTagInkSet ((PROPID) 0x014C)
#define PropertyTagInkNames ((PROPID) 0x014D)
#define PropertyTagNumberOfInks ((PROPID) 0x014E)
#define PropertyTagDotRange ((PROPID) 0x0150)
#define PropertyTagTargetPrinter ((PROPID) 0x0151)
#define PropertyTagExtraSamples ((PROPID) 0x0152)
#define PropertyTagSampleFormat ((PROPID) 0x0153)
#define PropertyTagSMinSampleValue ((PROPID) 0x0154)
#define PropertyTagSMaxSampleValue ((PROPID) 0x0155)
#define PropertyTagTransferRange ((PROPID) 0x0156)
#define PropertyTagJPEGProc ((PROPID) 0x0200)
#define PropertyTagJPEGInterFormat ((PROPID) 0x0201)
#define PropertyTagJPEGInterLength ((PROPID) 0x0202)
#define PropertyTagJPEGRestartInterval ((PROPID) 0x0203)
#define PropertyTagJPEGLosslessPredictors ((PROPID) 0x0205)
#define PropertyTagJPEGPointTransforms ((PROPID) 0x0206)
#define PropertyTagJPEGQTables ((PROPID) 0x0207)
#define PropertyTagJPEGDCTables ((PROPID) 0x0208)
#define PropertyTagJPEGACTables ((PROPID) 0x0209)
#define PropertyTagYCbCrCoefficients ((PROPID) 0x0211)
#define PropertyTagYCbCrSubsampling ((PROPID) 0x0212)
#define PropertyTagYCbCrPositioning ((PROPID) 0x0213)
#define PropertyTagREFBlackWhite ((PROPID) 0x0214)
#define PropertyTagGamma ((PROPID) 0x0301)
#define PropertyTagICCProfileDescriptor ((PROPID) 0x0302)
#define PropertyTagSRGBRenderingIntent ((PROPID) 0x0303)
#define PropertyTagImageTitle ((PROPID) 0x0320)
#define PropertyTagResolutionXUnit ((PROPID) 0x5001)
#define PropertyTagResolutionYUnit ((PROPID) 0x5002)
#define PropertyTagResolutionXLengthUnit ((PROPID) 0x5003)
#define PropertyTagResolutionYLengthUnit ((PROPID) 0x5004)
#define PropertyTagPrintFlags ((PROPID) 0x5005)
#define PropertyTagPrintFlagsVersion ((PROPID) 0x5006)
#define PropertyTagPrintFlagsCrop ((PROPID) 0x5007)
#define PropertyTagPrintFlagsBleedWidth ((PROPID) 0x5008)
#define PropertyTagPrintFlagsBleedWidthScale ((PROPID) 0x5009)
#define PropertyTagHalftoneLPI ((PROPID) 0x500A)
#define PropertyTagHalftoneLPIUnit ((PROPID) 0x500B)
#define PropertyTagHalftoneDegree ((PROPID) 0x500C)
#define PropertyTagHalftoneShape ((PROPID) 0x500D)
#define PropertyTagHalftoneMisc ((PROPID) 0x500E)
#define PropertyTagHalftoneScreen ((PROPID) 0x500F)
#define PropertyTagJPEGQuality ((PROPID) 0x5010)
#define PropertyTagGridSize ((PROPID) 0x5011)
#define PropertyTagThumbnailFormat ((PROPID) 0x5012)
#define PropertyTagThumbnailWidth ((PROPID) 0x5013)
#define PropertyTagThumbnailHeight ((PROPID) 0x5014)
#define PropertyTagThumbnailColorDepth ((PROPID) 0x5015)
#define PropertyTagThumbnailPlanes ((PROPID) 0x5016)
#define PropertyTagThumbnailRawBytes ((PROPID) 0x5017)
#define PropertyTagThumbnailSize ((PROPID) 0x5018)
#define PropertyTagThumbnailCompressedSize ((PROPID) 0x5019)
#define PropertyTagColorTransferFunction ((PROPID) 0x501A)
#define PropertyTagThumbnailData ((PROPID) 0x501B)
#define PropertyTagThumbnailImageWidth ((PROPID) 0x5020)
#define PropertyTagThumbnailImageHeight ((PROPID) 0x5021)
#define PropertyTagThumbnailBitsPerSample ((PROPID) 0x5022)
#define PropertyTagThumbnailCompression ((PROPID) 0x5023)
#define PropertyTagThumbnailPhotometricInterp ((PROPID) 0x5024)
#define PropertyTagThumbnailImageDescription ((PROPID) 0x5025)
#define PropertyTagThumbnailEquipMake ((PROPID) 0x5026)
#define PropertyTagThumbnailEquipModel ((PROPID) 0x5027)
#define PropertyTagThumbnailStripOffsets ((PROPID) 0x5028)
#define PropertyTagThumbnailOrientation ((PROPID) 0x5029)
#define PropertyTagThumbnailSamplesPerPixel ((PROPID) 0x502A)
#define PropertyTagThumbnailRowsPerStrip ((PROPID) 0x502B)
#define PropertyTagThumbnailStripBytesCount ((PROPID) 0x502C)
#define PropertyTagThumbnailResolutionX ((PROPID) 0x502D)
#define PropertyTagThumbnailResolutionY ((PROPID) 0x502E)
#define PropertyTagThumbnailPlanarConfig ((PROPID) 0x502F)
#define PropertyTagThumbnailResolutionUnit ((PROPID) 0x5030)
#define PropertyTagThumbnailTransferFunction ((PROPID) 0x5031)
#define PropertyTagThumbnailSoftwareUsed ((PROPID) 0x5032)
#define PropertyTagThumbnailDateTime ((PROPID) 0x5033)
#define PropertyTagThumbnailArtist ((PROPID) 0x5034)
#define PropertyTagThumbnailWhitePoint ((PROPID) 0x5035)
#define PropertyTagThumbnailPrimaryChromaticities ((PROPID) 0x5036)
#define PropertyTagThumbnailYCbCrCoefficients ((PROPID) 0x5037)
#define PropertyTagThumbnailYCbCrSubsampling ((PROPID) 0x5038)
#define PropertyTagThumbnailYCbCrPositioning ((PROPID) 0x5039)
#define PropertyTagThumbnailRefBlackWhite ((PROPID) 0x503A)
#define PropertyTagThumbnailCopyRight ((PROPID) 0x503B)
#define PropertyTagLuminanceTable ((PROPID) 0x5090)
#define PropertyTagChrominanceTable ((PROPID) 0x5091)
#define PropertyTagFrameDelay ((PROPID) 0x5100)
#define PropertyTagLoopCount ((PROPID) 0x5101)
#define PropertyTagGlobalPalette ((PROPID) 0x5102)
#define PropertyTagIndexBackground ((PROPID) 0x5103)
#define PropertyTagIndexTransparent ((PROPID) 0x5104)
#define PropertyTagPixelUnit ((PROPID) 0x5110)
#define PropertyTagPixelPerUnitX ((PROPID) 0x5111)
#define PropertyTagPixelPerUnitY ((PROPID) 0x5112)
#define PropertyTagPaletteHistogram ((PROPID) 0x5113)
#define PropertyTagCopyright ((PROPID) 0x8298)
#define PropertyTagExifExposureTime ((PROPID) 0x829A)
#define PropertyTagExifFNumber ((PROPID) 0x829D)
#define PropertyTagExifIFD ((PROPID) 0x8769)
#define PropertyTagICCProfile ((PROPID) 0x8773)
#define PropertyTagExifExposureProg ((PROPID) 0x8822)
#define PropertyTagExifSpectralSense ((PROPID) 0x8824)
#define PropertyTagGpsIFD ((PROPID) 0x8825)
#define PropertyTagExifISOSpeed ((PROPID) 0x8827)
#define PropertyTagExifOECF ((PROPID) 0x8828)
#define PropertyTagExifVer ((PROPID) 0x9000)
#define PropertyTagExifDTOrig ((PROPID) 0x9003)
#define PropertyTagExifDTDigitized ((PROPID) 0x9004)
#define PropertyTagExifCompConfig ((PROPID) 0x9101)
#define PropertyTagExifCompBPP ((PROPID) 0x9102)
#define PropertyTagExifShutterSpeed ((PROPID) 0x9201)
#define PropertyTagExifAperture ((PROPID) 0x9202)
#define PropertyTagExifBrightness ((PROPID) 0x9203)
#define PropertyTagExifExposureBias ((PROPID) 0x9204)
#define PropertyTagExifMaxAperture ((PROPID) 0x9205)
#define PropertyTagExifSubjectDist ((PROPID) 0x9206)
#define PropertyTagExifMeteringMode ((PROPID) 0x9207)
#define PropertyTagExifLightSource ((PROPID) 0x9208)
#define PropertyTagExifFlash ((PROPID) 0x9209)
#define PropertyTagExifFocalLength ((PROPID) 0x920A)
#define PropertyTagExifMakerNote ((PROPID) 0x927C)
#define PropertyTagExifUserComment ((PROPID) 0x9286)
#define PropertyTagExifDTSubsec ((PROPID) 0x9290)
#define PropertyTagExifDTOrigSS ((PROPID) 0x9291)
#define PropertyTagExifDTDigSS ((PROPID) 0x9292)
#define PropertyTagExifFPXVer ((PROPID) 0xA000)
#define PropertyTagExifColorSpace ((PROPID) 0xA001)
#define PropertyTagExifPixXDim ((PROPID) 0xA002)
#define PropertyTagExifPixYDim ((PROPID) 0xA003)
#define PropertyTagExifRelatedWav ((PROPID) 0xA004)
#define PropertyTagExifInterop ((PROPID) 0xA005)
#define PropertyTagExifFlashEnergy ((PROPID) 0xA20B)
#define PropertyTagExifSpatialFR ((PROPID) 0xA20C)
#define PropertyTagExifFocalXRes ((PROPID) 0xA20E)
#define PropertyTagExifFocalYRes ((PROPID) 0xA20F)
#define PropertyTagExifFocalResUnit ((PROPID) 0xA210)
#define PropertyTagExifSubjectLoc ((PROPID) 0xA214)
#define PropertyTagExifExposureIndex ((PROPID) 0xA215)
#define PropertyTagExifSensingMethod ((PROPID) 0xA217)
#define PropertyTagExifFileSource ((PROPID) 0xA300)
#define PropertyTagExifSceneType ((PROPID) 0xA301)
#define PropertyTagExifCfaPattern ((PROPID) 0xA302)
#define PropertyTagTypeByte ((WORD) 1)
#define PropertyTagTypeASCII ((WORD) 2)
#define PropertyTagTypeShort ((WORD) 3)
#define PropertyTagTypeLong ((WORD) 4)
#define PropertyTagTypeRational ((WORD) 5)
#define PropertyTagTypeUndefined ((WORD) 7)
#define PropertyTagTypeSLONG ((WORD) 9)
#define PropertyTagTypeSRational ((WORD) 10)
#ifdef __cplusplus
extern "C" {
#endif
extern const GUID EncoderChrominanceTable; /* f2e455dc-09b3-4316-8260-676ada32481c */
extern const GUID EncoderColorDepth; /* 66087055-ad66-4c7c-9a18-38a2310b8337 */
extern const GUID EncoderColorSpace; /* ? */
extern const GUID EncoderCompression; /* e09d739d-ccd4-44ee-8eba-3fbf8be4fc58 */
extern const GUID EncoderImageItems; /* ? */
extern const GUID EncoderLuminanceTable; /* edb33bce-0266-4a77-b904-27216099e717 */
extern const GUID EncoderQuality; /* 1d5be4b5-fa4a-452d-9cdd-5db35105e7eb */
extern const GUID EncoderRenderMethod; /* 6d42c53a-229a-4825-8bb7-5c99e2b9a8b8 */
extern const GUID EncoderSaveAsCMYK; /* ? */
extern const GUID EncoderSaveFlag; /* 292266fc-ac40-47bf-8cfc-a85b89a655de */
extern const GUID EncoderScanMethod; /* 3a4e2661-3109-4e56-8536-42c156e7dcfa */
extern const GUID EncoderTransformation; /* 8d0eb2d1-a58e-4ea8-aa14-108074b7b6f9 */
extern const GUID EncoderVersion; /* 24d18c76-814a-41a4-bf53-1c219cccf797 */
extern const GUID ImageFormatBMP; /* b96b3cab-0728-11d3-9d7b-0000f81ef32e */
extern const GUID ImageFormatEMF; /* b96b3cac-0728-11d3-9d7b-0000f81ef32e */
extern const GUID ImageFormatEXIF; /* ? */
extern const GUID ImageFormatGIF; /* b96b3cb0-0728-11d3-9d7b-0000f81ef32e */
extern const GUID ImageFormatIcon; /* b96b3cb5-0728-11d3-9d7b-0000f81ef32e */
extern const GUID ImageFormatJPEG; /* b96b3cae-0728-11d3-9d7b-0000f81ef32e */
extern const GUID ImageFormatMemoryBMP; /* b96b3caa-0728-11d3-9d7b-0000f81ef32e */
extern const GUID ImageFormatPNG; /* b96b3caf-0728-11d3-9d7b-0000f81ef32e */
extern const GUID ImageFormatTIFF; /* b96b3cb1-0728-11d3-9d7b-0000f81ef32e */
extern const GUID ImageFormatUndefined; /* ? */
extern const GUID ImageFormatWMF; /* b96b3cad-0728-11d3-9d7b-0000f81ef32e */
extern const GUID FrameDimensionPage; /* 7462dc86-6180-4c7e-8e3f-ee7333a7a483 */
extern const GUID FrameDimensionResolution; /* ? */
extern const GUID FrameDimensionTime; /* 6aedbd6d-3fb5-418a-83a6-7f45229dc872 */
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __GDIPLUS_IMAGING_H */

1613
winsup/w32api/include/gdiplus/gdiplusimpl.h Executable file
View File

File diff suppressed because it is too large Load Diff

74
winsup/w32api/include/gdiplus/gdiplusinit.h Executable file
View File

@ -0,0 +1,74 @@
/*
* gdiplusinit.h
*
* GDI+ Initialization
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_INIT_H
#define __GDIPLUS_INIT_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
typedef struct GdiplusStartupInput {
UINT32 GdiplusVersion;
DebugEventProc DebugEventCallback;
BOOL SuppressBackgroundThread;
BOOL SuppressExternalCodecs;
#ifdef __cplusplus
GdiplusStartupInput(DebugEventProc debugEventCallback = NULL,
BOOL suppressBackgroundThread = FALSE,
BOOL suppressExternalCodecs = FALSE):
GdiplusVersion(1),
DebugEventCallback(debugEventCallback),
SuppressBackgroundThread(suppressBackgroundThread),
SuppressExternalCodecs(suppressExternalCodecs) {}
#endif /* __cplusplus */
} GdiplusStartupInput;
typedef GpStatus WINGDIPAPI (*NotificationHookProc)(ULONG_PTR *token);
typedef VOID WINGDIPAPI (*NotificationUnhookProc)(ULONG_PTR token);
typedef struct GdiplusStartupOutput {
NotificationHookProc NotificationHook;
NotificationUnhookProc NotificationUnhook;
#ifdef __cplusplus
GdiplusStartupOutput():
NotificationHook(NULL),
NotificationUnhook(NULL) {}
#endif /* __cplusplus */
} GdiplusStartupOutput;
#ifdef __cplusplus
extern "C" {
#endif
GpStatus WINGDIPAPI GdiplusStartup(ULONG_PTR*,GDIPCONST GdiplusStartupInput*,GdiplusStartupOutput*);
VOID WINGDIPAPI GdiplusShutdown(ULONG_PTR);
GpStatus WINGDIPAPI GdiplusNotificationHook(ULONG_PTR*);
VOID WINGDIPAPI GdiplusNotificationUnhook(ULONG_PTR);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __GDIPLUS_INIT_H */

131
winsup/w32api/include/gdiplus/gdipluslinecaps.h Executable file
View File

@ -0,0 +1,131 @@
/*
* gdipluslinecaps.h
*
* GDI+ AdjustableArrowCap class
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_LINECAPS_H
#define __GDIPLUS_LINECAPS_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#ifndef __cplusplus
#error "A C++ compiler is required to include gdipluslinecaps.h."
#endif
class AdjustableArrowCap: public CustomLineCap
{
public:
AdjustableArrowCap(REAL height, REAL width, BOOL isFilled):
CustomLineCap(NULL, Ok)
{
GpAdjustableArrowCap *nativeAdjustableArrowCap = NULL;
lastStatus = DllExports::GdipCreateAdjustableArrowCap(
height, width, isFilled,
&nativeAdjustableArrowCap);
nativeCustomLineCap = nativeAdjustableArrowCap;
}
virtual ~AdjustableArrowCap()
{
}
virtual AdjustableArrowCap* Clone() const
{
GpCustomLineCap *cloneCustomLineCap = NULL;
Status status = updateStatus(DllExports::GdipCloneCustomLineCap(
nativeCustomLineCap, &cloneCustomLineCap));
if (status == Ok) {
AdjustableArrowCap *result = new AdjustableArrowCap(
cloneCustomLineCap, lastStatus);
if (!result) {
DllExports::GdipDeleteCustomLineCap(
cloneCustomLineCap);
lastStatus = OutOfMemory;
}
return result;
} else {
return NULL;
}
}
REAL GetHeight() const
{
REAL result = 0.0f;
updateStatus(DllExports::GdipGetAdjustableArrowCapHeight(
(GpAdjustableArrowCap*) nativeCustomLineCap,
&result));
return result;
}
REAL GetMiddleInset() const
{
REAL result = 0.0f;
updateStatus(DllExports::GdipGetAdjustableArrowCapMiddleInset(
(GpAdjustableArrowCap*) nativeCustomLineCap,
&result));
return result;
}
REAL GetWidth() const
{
REAL result = 0.0f;
updateStatus(DllExports::GdipGetAdjustableArrowCapWidth(
(GpAdjustableArrowCap*) nativeCustomLineCap,
&result));
return result;
}
BOOL IsFilled() const
{
BOOL result = FALSE;
updateStatus(DllExports::GdipGetAdjustableArrowCapFillState(
(GpAdjustableArrowCap*) nativeCustomLineCap,
&result));
return result;
}
Status SetFillState(BOOL isFilled)
{
return updateStatus(DllExports::GdipSetAdjustableArrowCapFillState(
(GpAdjustableArrowCap*) nativeCustomLineCap,
isFilled));
}
Status SetHeight(REAL height)
{
return updateStatus(DllExports::GdipSetAdjustableArrowCapHeight(
(GpAdjustableArrowCap*) nativeCustomLineCap,
height));
}
Status SetMiddleInset(REAL middleInset)
{
return updateStatus(DllExports::GdipSetAdjustableArrowCapMiddleInset(
(GpAdjustableArrowCap*) nativeCustomLineCap,
middleInset));
}
Status SetWidth(REAL width)
{
return updateStatus(DllExports::GdipSetAdjustableArrowCapWidth(
(GpAdjustableArrowCap*) nativeCustomLineCap,
width));
}
private:
AdjustableArrowCap(GpCustomLineCap *customLineCap, Status status):
CustomLineCap(customLineCap, status) {}
AdjustableArrowCap(const AdjustableArrowCap&);
AdjustableArrowCap& operator=(const AdjustableArrowCap&);
};
#endif /* __GDIPLUS_LINECAPS_H */

240
winsup/w32api/include/gdiplus/gdiplusmatrix.h Executable file
View File

@ -0,0 +1,240 @@
/*
* gdiplusmatrix.h
*
* GDI+ Matrix class
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_MATRIX_H
#define __GDIPLUS_MATRIX_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#ifndef __cplusplus
#error "A C++ compiler is required to include gdiplusmatrix.h."
#endif
#define GDIP_MATRIX_PI \
3.1415926535897932384626433832795028841971693993751058209749445923078164
class Matrix: public GdiplusBase
{
friend class Graphics;
friend class GraphicsPath;
friend class LinearGradientBrush;
friend class PathGradientBrush;
friend class Pen;
friend class Region;
friend class TextureBrush;
public:
Matrix(): nativeMatrix(NULL), lastStatus(Ok)
{
lastStatus = DllExports::GdipCreateMatrix(&nativeMatrix);
}
Matrix(REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy):
nativeMatrix(NULL), lastStatus(Ok)
{
lastStatus = DllExports::GdipCreateMatrix2(
m11, m12, m21, m22, dx, dy,
&nativeMatrix);
}
Matrix(const RectF& rect, const PointF *dstplg):
nativeMatrix(NULL), lastStatus(Ok)
{
lastStatus = DllExports::GdipCreateMatrix3(
&rect, dstplg, &nativeMatrix);
}
Matrix(const Rect& rect, const Point *dstplg):
nativeMatrix(NULL), lastStatus(Ok)
{
lastStatus = DllExports::GdipCreateMatrix3I(
&rect, dstplg, &nativeMatrix);
}
~Matrix()
{
DllExports::GdipDeleteMatrix(nativeMatrix);
}
Matrix* Clone() const
{
GpMatrix *cloneMatrix = NULL;
Status status = updateStatus(DllExports::GdipCloneMatrix(
nativeMatrix, &cloneMatrix));
if (status == Ok) {
Matrix *result = new Matrix(cloneMatrix, lastStatus);
if (!result) {
DllExports::GdipDeleteMatrix(cloneMatrix);
lastStatus = OutOfMemory;
}
return result;
} else {
return NULL;
}
}
BOOL Equals(const Matrix *matrix) const
{
BOOL result;
updateStatus(DllExports::GdipIsMatrixEqual(
nativeMatrix,
matrix ? matrix->nativeMatrix : NULL, &result));
return result;
}
Status GetElements(REAL *m) const
{
return updateStatus(DllExports::GdipGetMatrixElements(
nativeMatrix, m));
}
Status GetLastStatus() const
{
Status result = lastStatus;
lastStatus = Ok;
return result;
}
Status Invert()
{
return updateStatus(DllExports::GdipInvertMatrix(nativeMatrix));
}
BOOL IsIdentity() const
{
BOOL result;
updateStatus(DllExports::GdipIsMatrixIdentity(
nativeMatrix, &result));
return result;
}
BOOL IsInvertible() const
{
BOOL result;
updateStatus(DllExports::GdipIsMatrixInvertible(
nativeMatrix, &result));
return result;
}
Status Multiply(const Matrix *matrix,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipMultiplyMatrix(
nativeMatrix,
matrix ? matrix->nativeMatrix : NULL, order));
}
REAL OffsetX() const
{
REAL m[6];
updateStatus(DllExports::GdipGetMatrixElements(nativeMatrix, m));
return m[4];
}
REAL OffsetY() const
{
REAL m[6];
updateStatus(DllExports::GdipGetMatrixElements(nativeMatrix, m));
return m[5];
}
Status Reset()
{
return updateStatus(DllExports::GdipSetMatrixElements(
nativeMatrix,
1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
}
Status Rotate(REAL angle, MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipRotateMatrix(
nativeMatrix, angle, order));
}
Status RotateAt(REAL angle, const PointF& center,
MatrixOrder order = MatrixOrderPrepend)
{
REAL angleRadian = angle * GDIP_MATRIX_PI / 180.0f;
REAL cosAngle = ::cos(angleRadian);
REAL sinAngle = ::sin(angleRadian);
REAL x = center.X;
REAL y = center.Y;
Matrix matrix2(cosAngle, sinAngle, -sinAngle, cosAngle,
x * (1.0f-cosAngle) + y * sinAngle,
-x * sinAngle + y * (1.0f-cosAngle));
Status status = matrix2.GetLastStatus();
if (status == Ok) {
return Multiply(&matrix2, order);
} else {
return lastStatus = status;
}
}
Status Scale(REAL scaleX, REAL scaleY,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipScaleMatrix(
nativeMatrix, scaleX, scaleY, order));
}
Status SetElements(REAL m11, REAL m12, REAL m21, REAL m22,
REAL dx, REAL dy)
{
return updateStatus(DllExports::GdipSetMatrixElements(
nativeMatrix, m11, m12, m21, m22, dx, dy));
}
Status Shear(REAL shearX, REAL shearY,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipShearMatrix(
nativeMatrix, shearX, shearY, order));
}
Status TransformPoints(PointF *pts, INT count = 1) const
{
return updateStatus(DllExports::GdipTransformMatrixPoints(
nativeMatrix, pts, count));
}
Status TransformPoints(Point *pts, INT count = 1) const
{
return updateStatus(DllExports::GdipTransformMatrixPointsI(
nativeMatrix, pts, count));
}
Status TransformVectors(PointF *pts, INT count = 1) const
{
return updateStatus(DllExports::GdipVectorTransformMatrixPoints(
nativeMatrix, pts, count));
}
Status TransformVectors(Point *pts, INT count = 1) const
{
return updateStatus(DllExports::GdipVectorTransformMatrixPointsI(
nativeMatrix, pts, count));
}
Status Translate(REAL offsetX, REAL offsetY,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipTranslateMatrix(
nativeMatrix, offsetX, offsetY, order));
}
private:
Matrix(GpMatrix *matrix, Status status):
nativeMatrix(matrix), lastStatus(status) {}
Matrix(const Matrix&);
Matrix& operator=(const Matrix&);
Status updateStatus(Status newStatus) const
{
if (newStatus != Ok) lastStatus = newStatus;
return newStatus;
}
GpMatrix *nativeMatrix;
mutable Status lastStatus;
};
#undef GDIP_MATRIX_PI
#endif /* __GDIPLUS_MATRIX_H */

42
winsup/w32api/include/gdiplus/gdiplusmem.h Executable file
View File

@ -0,0 +1,42 @@
/*
* gdiplusmem.h
*
* GDI+ memory allocation
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_MEM_H
#define __GDIPLUS_MEM_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#ifdef __cplusplus
namespace DllExports {
extern "C" {
#endif
VOID* WINGDIPAPI GdipAlloc(size_t);
VOID WINGDIPAPI GdipFree(VOID*);
#ifdef __cplusplus
} /* extern "C" */
} /* namespace DllExports */
#endif
#endif /* __GDIPLUS_MEM_H */

305
winsup/w32api/include/gdiplus/gdiplusmetafile.h Executable file
View File

@ -0,0 +1,305 @@
/*
* gdiplusmetafile.h
*
* GDI+ Metafile class
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_METAFILE_H
#define __GDIPLUS_METAFILE_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#ifndef __cplusplus
#error "A C++ compiler is required to include gdiplusmetafile.h."
#endif
class Metafile: public Image
{
public:
static UINT EmfToWmfBits(HENHMETAFILE hEmf,
UINT cbData16, LPBYTE pData16,
INT iMapMode = MM_ANISOTROPIC,
EmfToWmfBitsFlags eFlags = EmfToWmfBitsFlagsDefault)
{
return DllExports::GdipEmfToWmfBits(hEmf,
cbData16, pData16, iMapMode, eFlags);
}
static Status GetMetafileHeader(const WCHAR *filename,
MetafileHeader *header)
{
return DllExports::GdipGetMetafileHeaderFromFile(
filename, header);
}
static Status GetMetafileHeader(IStream *stream, MetafileHeader *header)
{
return DllExports::GdipGetMetafileHeaderFromStream(
stream, header);
}
////TODO: Metafile::GetMetafileHeader
//static Status GetMetafileHeader(HMETAFILE hWmf,
// const WmfPlaceableFileHeader *wmfPlaceableFileHeader,
// MetafileHeader *header)
//{
// // WTF: No flat API to do this.
// return NotImplemented;
//}
static Status GetMetafileHeader(HENHMETAFILE hEmf,
MetafileHeader *header)
{
return DllExports::GdipGetMetafileHeaderFromEmf(hEmf, header);
}
Metafile(HMETAFILE hWmf,
const WmfPlaceableFileHeader *wmfPlaceableFileHeader,
BOOL deleteWmf = FALSE): Image(NULL, Ok)
{
GpMetafile *nativeMetafile = NULL;
lastStatus = DllExports::GdipCreateMetafileFromWmf(
hWmf, deleteWmf, wmfPlaceableFileHeader,
&nativeMetafile);
nativeImage = nativeMetafile;
}
Metafile(HENHMETAFILE hEmf, BOOL deleteEmf = FALSE): Image(NULL, Ok)
{
GpMetafile *nativeMetafile = NULL;
lastStatus = DllExports::GdipCreateMetafileFromEmf(
hEmf, deleteEmf, &nativeMetafile);
nativeImage = nativeMetafile;
}
Metafile(const WCHAR *filename): Image(NULL, Ok)
{
GpMetafile *nativeMetafile = NULL;
lastStatus = DllExports::GdipCreateMetafileFromFile(
filename, &nativeMetafile);
nativeImage = nativeMetafile;
}
Metafile(const WCHAR *filename,
const WmfPlaceableFileHeader *wmfPlaceableFileHeader):
Image(NULL, Ok)
{
GpMetafile *nativeMetafile = NULL;
lastStatus = DllExports::GdipCreateMetafileFromWmfFile(
filename, wmfPlaceableFileHeader,
&nativeMetafile);
nativeImage = nativeMetafile;
}
Metafile(IStream *stream): Image(NULL, Ok)
{
GpMetafile *nativeMetafile = NULL;
lastStatus = DllExports::GdipCreateMetafileFromStream(
stream, &nativeMetafile);
nativeImage = nativeMetafile;
}
Metafile(HDC referenceHdc, EmfType type = EmfTypeEmfPlusDual,
const WCHAR *description = NULL): Image(NULL, Ok)
{
GpMetafile *nativeMetafile = NULL;
lastStatus = DllExports::GdipRecordMetafile(
referenceHdc, type, NULL, MetafileFrameUnitGdi,
description, &nativeMetafile);
nativeImage = nativeMetafile;
}
Metafile(HDC referenceHdc, const RectF& frameRect,
MetafileFrameUnit frameUnit = MetafileFrameUnitGdi,
EmfType type = EmfTypeEmfPlusDual,
const WCHAR *description = NULL): Image(NULL, Ok)
{
GpMetafile *nativeMetafile = NULL;
lastStatus = DllExports::GdipRecordMetafile(
referenceHdc, type, &frameRect, frameUnit,
description, &nativeMetafile);
nativeImage = nativeMetafile;
}
Metafile(HDC referenceHdc, const Rect& frameRect,
MetafileFrameUnit frameUnit = MetafileFrameUnitGdi,
EmfType type = EmfTypeEmfPlusDual,
const WCHAR *description = NULL): Image(NULL, Ok)
{
GpMetafile *nativeMetafile = NULL;
lastStatus = DllExports::GdipRecordMetafileI(
referenceHdc, type, &frameRect, frameUnit,
description, &nativeMetafile);
nativeImage = nativeMetafile;
}
Metafile(const WCHAR *filename, HDC referenceHdc,
EmfType type = EmfTypeEmfPlusDual,
const WCHAR *description = NULL): Image(NULL, Ok)
{
GpMetafile *nativeMetafile = NULL;
lastStatus = DllExports::GdipRecordMetafileFileName(
filename, referenceHdc, type, NULL,
MetafileFrameUnitGdi, description,
&nativeMetafile);
nativeImage = nativeMetafile;
}
Metafile(const WCHAR *filename, HDC referenceHdc,
const RectF& frameRect,
MetafileFrameUnit frameUnit = MetafileFrameUnitGdi,
EmfType type = EmfTypeEmfPlusDual,
const WCHAR *description = NULL): Image(NULL, Ok)
{
GpMetafile *nativeMetafile = NULL;
lastStatus = DllExports::GdipRecordMetafileFileName(
filename, referenceHdc, type, &frameRect,
frameUnit, description, &nativeMetafile);
nativeImage = nativeMetafile;
}
Metafile(const WCHAR *filename, HDC referenceHdc,
const Rect& frameRect,
MetafileFrameUnit frameUnit = MetafileFrameUnitGdi,
EmfType type = EmfTypeEmfPlusDual,
const WCHAR *description = NULL): Image(NULL, Ok)
{
GpMetafile *nativeMetafile = NULL;
lastStatus = DllExports::GdipRecordMetafileFileNameI(
filename, referenceHdc, type, &frameRect,
frameUnit, description, &nativeMetafile);
nativeImage = nativeMetafile;
}
Metafile(IStream *stream, HDC referenceHdc,
EmfType type = EmfTypeEmfPlusDual,
const WCHAR *description = NULL): Image(NULL, Ok)
{
GpMetafile *nativeMetafile = NULL;
lastStatus = DllExports::GdipRecordMetafileStream(
stream, referenceHdc, type, NULL,
MetafileFrameUnitGdi, description,
&nativeMetafile);
nativeImage = nativeMetafile;
}
Metafile(IStream *stream, HDC referenceHdc, const RectF& frameRect,
MetafileFrameUnit frameUnit = MetafileFrameUnitGdi,
EmfType type = EmfTypeEmfPlusDual,
const WCHAR *description = NULL): Image(NULL, Ok)
{
GpMetafile *nativeMetafile = NULL;
lastStatus = DllExports::GdipRecordMetafileStream(
stream, referenceHdc, type, &frameRect,
frameUnit, description, &nativeMetafile);
nativeImage = nativeMetafile;
}
Metafile(IStream *stream, HDC referenceHdc, const Rect& frameRect,
MetafileFrameUnit frameUnit = MetafileFrameUnitGdi,
EmfType type = EmfTypeEmfPlusDual,
const WCHAR *description = NULL): Image(NULL, Ok)
{
GpMetafile *nativeMetafile = NULL;
lastStatus = DllExports::GdipRecordMetafileStreamI(
stream, referenceHdc, type, &frameRect,
frameUnit, description, &nativeMetafile);
nativeImage = nativeMetafile;
}
virtual ~Metafile()
{
}
virtual Metafile* Clone() const
{
GpImage *cloneImage = NULL;
Status status = updateStatus(DllExports::GdipCloneImage(
nativeImage, &cloneImage));
if (status == Ok) {
Metafile *result = new Metafile(cloneImage, lastStatus);
if (!result) {
DllExports::GdipDisposeImage(cloneImage);
lastStatus = OutOfMemory;
}
return result;
} else {
return NULL;
}
}
////TODO: [GDI+ 1.1] Metafile::ConvertToEmfPlus
//Status ConvertToEmfPlus(const Graphics *refGraphics,
// BOOL *conversionSuccess = NULL,
// EmfType emfType = EmfTypeEmfPlusOnly,
// const WCHAR *description = NULL)
//{
// // FIXME: can't test GdipConvertToEmfPlus because it isn't exported in 1.0
// return updateStatus(DllExports::GdipConvertToEmfPlus(
// refGraphics ? refGraphics->nativeGraphics : NULL,
// (GpMetafile*) nativeImage,
// conversionSuccess, emfType, description, ???));
//}
////TODO: [GDI+ 1.1] Metafile::ConvertToEmfPlus
//Status ConvertToEmfPlus(const Graphics *refGraphics,
// const WCHAR *filename,
// BOOL *conversionSuccess = NULL,
// EmfType emfType = EmfTypeEmfPlusOnly,
// const WCHAR *description = NULL)
//{
// // FIXME: can't test GdipConvertToEmfPlusToFile because it isn't exported in 1.0
// return updateStatus(DllExports::GdipConvertToEmfPlusToFile(
// refGraphics ? refGraphics->nativeGraphics : NULL,
// (GpMetafile*) nativeImage, conversionSuccess,
// filename, emfType, description, ???));
//}
////TODO: [GDI+ 1.1] Metafile::ConvertToEmfPlus
//Status ConvertToEmfPlus(const Graphics *refGraphics,
// IStream *stream,
// BOOL *conversionSuccess = NULL,
// EmfType emfType = EmfTypeEmfPlusOnly,
// const WCHAR *description = NULL)
//{
// // FIXME: can't test GdipConvertToEmfPlusToStream because it isn't exported in 1.0
// return updateStatus(DllExports::GdipConvertToEmfPlusToStream(
// refGraphics ? refGraphics->nativeGraphics : NULL,
// (GpMetafile*) nativeImage, conversionSuccess,
// stream, emfType, description, ???));
//}
UINT GetDownLevelRasterizationLimit() const
{
UINT result = 0;
updateStatus(DllExports::GdipGetMetafileDownLevelRasterizationLimit(
(GpMetafile*) nativeImage, &result));
return result;
}
HENHMETAFILE GetHENHMETAFILE()
{
HENHMETAFILE result = NULL;
updateStatus(DllExports::GdipGetHemfFromMetafile(
(GpMetafile*) nativeImage, &result));
return result;
}
Status GetMetafileHeader(MetafileHeader *header) const
{
return updateStatus(DllExports::GdipGetMetafileHeaderFromMetafile(
(GpMetafile*) nativeImage, header));
}
Status PlayRecord(EmfPlusRecordType recordType, UINT flags,
UINT dataSize, const BYTE *data) const
{
return updateStatus(DllExports::GdipPlayMetafileRecord(
(GpMetafile*) nativeImage,
recordType, flags, dataSize, data));
}
Status SetDownLevelRasterizationLimit(UINT limitDpi)
{
return updateStatus(DllExports::GdipSetMetafileDownLevelRasterizationLimit(
(GpMetafile*) nativeImage, limitDpi));
}
private:
Metafile(GpImage *image, Status status): Image(image, status) {}
Metafile(const Metafile&);
Metafile& operator=(const Metafile&);
};
#endif /* __GDIPLUS_METAFILE_H */

193
winsup/w32api/include/gdiplus/gdiplusmetaheader.h Executable file
View File

@ -0,0 +1,193 @@
/*
* gdiplusmetaheader.h
*
* GDI+ metafile header structure
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_METAHEADER_H
#define __GDIPLUS_METAHEADER_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
/*
* FIXME: is 1 the correct value for GDIP_EMFPLUSFLAGS_DISPLAY? This number
* has been determined by calling Metafile::GetMetafileHeader() on a EMF+
* metafile which was recorded on a display device context (SampleMetafile.emf).
*/
#ifdef __cplusplus
const UINT GDIP_EMFPLUSFLAGS_DISPLAY = 1;
#else
#define GDIP_EMFPLUSFLAGS_DISPLAY ((UINT) 1)
#endif
typedef struct tagENHMETAHEADER3 {
DWORD iType;
DWORD nSize;
RECTL rclBounds;
RECTL rclFrame;
DWORD dSignature;
DWORD nVersion;
DWORD nBytes;
DWORD nRecords;
WORD nHandles;
WORD sReserved;
DWORD nDescription;
DWORD offDescription;
DWORD nPalEntries;
SIZEL szlDevice;
SIZEL szlMillimeters;
} ENHMETAHEADER3,*LPENHMETAHEADER3;
typedef struct PWMFRect16 {
INT16 Left;
INT16 Top;
INT16 Right;
INT16 Bottom;
} PWMFRect16;
typedef struct WmfPlaceableFileHeader {
UINT32 Key;
INT16 Hmf;
PWMFRect16 BoundingBox;
INT16 Inch;
UINT32 Reserved;
INT16 Checksum;
} WmfPlaceableFileHeader;
typedef struct MetafileHeader {
MetafileType Type;
UINT Size;
UINT Version;
UINT EmfPlusFlags;
REAL DpiX;
REAL DpiY;
INT X;
INT Y;
INT Width;
INT Height;
__extension__ union {
METAHEADER WmfHeader;
ENHMETAHEADER3 EmfHeader;
};
INT EmfPlusHeaderSize;
INT LogicalDpiX;
INT LogicalDpiY;
#ifdef __cplusplus
public:
void GetBounds(Rect *rect) const
{
if (rect)
{
rect->X = X;
rect->Y = Y;
rect->Width = Width;
rect->Height = Height;
}
}
REAL GetDpiX() const
{
return DpiX;
}
REAL GetDpiY() const
{
return DpiY;
}
const ENHMETAHEADER3* GetEmfHeader() const
{
if (Type == MetafileTypeEmf
|| Type == MetafileTypeEmfPlusOnly
|| Type == MetafileTypeEmfPlusDual)
{
return &EmfHeader;
}
else
{
return NULL;
}
}
UINT GetEmfPlusFlags() const
{
return EmfPlusFlags;
}
UINT GetMetafileSize() const
{
return Size;
}
MetafileType GetType() const
{
return Type;
}
UINT GetVersion() const
{
return Version;
}
const METAHEADER* GetWmfHeader() const
{
if (Type == MetafileTypeWmf || Type == MetafileTypeWmfPlaceable)
{
return &WmfHeader;
}
else
{
return NULL;
}
}
BOOL IsDisplay() const
{
return EmfPlusFlags == GDIP_EMFPLUSFLAGS_DISPLAY;
}
BOOL IsEmf() const
{
return Type == MetafileTypeEmf;
}
BOOL IsEmfOrEmfPlus() const
{
return Type == MetafileTypeEmf
|| Type == MetafileTypeEmfPlusOnly
|| Type == MetafileTypeEmfPlusDual;
}
BOOL IsEmfPlus() const
{
return Type == MetafileTypeEmfPlusOnly
|| Type == MetafileTypeEmfPlusDual;
}
BOOL IsEmfPlusDual() const
{
return Type == MetafileTypeEmfPlusDual;
}
BOOL IsEmfPlusOnly() const
{
return Type == MetafileTypeEmfPlusOnly;
}
BOOL IsWmf() const
{
return Type == MetafileTypeWmf
|| Type == MetafileTypeWmfPlaceable;
}
BOOL IsWmfPlaceable() const
{
return Type == MetafileTypeWmfPlaceable;
}
#endif
} MetafileHeader;
#endif /* __GDIPLUS_METAHEADER_H */

964
winsup/w32api/include/gdiplus/gdipluspath.h Executable file
View File

@ -0,0 +1,964 @@
/*
* gdipluspath.h
*
* GDI+ GraphicsPath class
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_PATH_H
#define __GDIPLUS_PATH_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#ifndef __cplusplus
#error "A C++ compiler is required to include gdipluspath.h."
#endif
// Note that some methods of GraphicsPath are implemented in gdiplusimpl.h.
// This avoids a cyclic dependency on Graphics and Pen.
class GraphicsPath: public GdiplusBase
{
friend class CustomLineCap;
friend class Graphics;
friend class GraphicsPathIterator;
friend class PathGradientBrush;
friend class Region;
public:
GraphicsPath(FillMode fillMode = FillModeAlternate):
nativePath(NULL), lastStatus(Ok)
{
lastStatus = DllExports::GdipCreatePath(fillMode, &nativePath);
}
GraphicsPath(const PointF *points, const BYTE *types, INT count,
FillMode fillMode = FillModeAlternate):
nativePath(NULL), lastStatus(Ok)
{
lastStatus = DllExports::GdipCreatePath2(
points, types, count, fillMode, &nativePath);
}
GraphicsPath(const Point *points, const BYTE *types, INT count,
FillMode fillMode = FillModeAlternate):
nativePath(NULL), lastStatus(Ok)
{
lastStatus = DllExports::GdipCreatePath2I(
points, types, count, fillMode, &nativePath);
}
~GraphicsPath()
{
DllExports::GdipDeletePath(nativePath);
}
GraphicsPath* Clone() const
{
GpPath *clonePath = NULL;
Status status = updateStatus(DllExports::GdipClonePath(
nativePath, &clonePath));
if (status == Ok) {
GraphicsPath *result = new GraphicsPath(clonePath, lastStatus);
if (!result) {
DllExports::GdipDeletePath(clonePath);
lastStatus = OutOfMemory;
}
return result;
} else {
return NULL;
}
}
Status AddArc(REAL x, REAL y, REAL width, REAL height,
REAL startAngle, REAL sweepAngle)
{
return updateStatus(DllExports::GdipAddPathArc(nativePath,
x, y, width, height, startAngle, sweepAngle));
}
Status AddArc(INT x, INT y, INT width, INT height,
REAL startAngle, REAL sweepAngle)
{
return updateStatus(DllExports::GdipAddPathArcI(nativePath,
x, y, width, height, startAngle, sweepAngle));
}
Status AddArc(const RectF& rect, REAL startAngle, REAL sweepAngle)
{
return updateStatus(DllExports::GdipAddPathArc(nativePath,
rect.X, rect.Y, rect.Width, rect.Height,
startAngle, sweepAngle));
}
Status AddArc(const Rect& rect, REAL startAngle, REAL sweepAngle)
{
return updateStatus(DllExports::GdipAddPathArcI(nativePath,
rect.X, rect.Y, rect.Width, rect.Height,
startAngle, sweepAngle));
}
Status AddBezier(REAL x1, REAL y1, REAL x2, REAL y2,
REAL x3, REAL y3, REAL x4, REAL y4)
{
return updateStatus(DllExports::GdipAddPathBezier(nativePath,
x1, y1, x2, y2, x3, y3, x4, y4));
}
Status AddBezier(INT x1, INT y1, INT x2, INT y2,
INT x3, INT y3, INT x4, INT y4)
{
return updateStatus(DllExports::GdipAddPathBezierI(nativePath,
x1, y1, x2, y2, x3, y3, x4, y4));
}
Status AddBezier(const PointF& pt1, const PointF& pt2,
const PointF& pt3, const PointF& pt4)
{
return updateStatus(DllExports::GdipAddPathBezier(nativePath,
pt1.X, pt1.Y, pt2.X, pt2.Y,
pt3.X, pt3.Y, pt4.X, pt4.Y));
}
Status AddBezier(const Point& pt1, const Point& pt2,
const Point& pt3, const Point& pt4)
{
return updateStatus(DllExports::GdipAddPathBezierI(nativePath,
pt1.X, pt1.Y, pt2.X, pt2.Y,
pt3.X, pt3.Y, pt4.X, pt4.Y));
}
Status AddBeziers(const PointF *points, INT count)
{
return updateStatus(DllExports::GdipAddPathBeziers(
nativePath, points, count));
}
Status AddBeziers(const Point *points, INT count)
{
return updateStatus(DllExports::GdipAddPathBeziersI(
nativePath, points, count));
}
Status AddClosedCurve(const PointF *points, INT count)
{
return updateStatus(DllExports::GdipAddPathClosedCurve(
nativePath, points, count));
}
Status AddClosedCurve(const Point *points, INT count)
{
return updateStatus(DllExports::GdipAddPathClosedCurveI(
nativePath, points, count));
}
Status AddClosedCurve(const PointF *points, INT count, REAL tension)
{
return updateStatus(DllExports::GdipAddPathClosedCurve2(
nativePath, points, count, tension));
}
Status AddClosedCurve(const Point *points, INT count, REAL tension)
{
return updateStatus(DllExports::GdipAddPathClosedCurve2I(
nativePath, points, count, tension));
}
Status AddCurve(const PointF *points, INT count)
{
return updateStatus(DllExports::GdipAddPathCurve(
nativePath, points, count));
}
Status AddCurve(const Point *points, INT count)
{
return updateStatus(DllExports::GdipAddPathCurveI(
nativePath, points, count));
}
Status AddCurve(const PointF *points, INT count, REAL tension)
{
return updateStatus(DllExports::GdipAddPathCurve2(
nativePath, points, count, tension));
}
Status AddCurve(const Point *points, INT count, REAL tension)
{
return updateStatus(DllExports::GdipAddPathCurve2I(
nativePath, points, count, tension));
}
Status AddCurve(const PointF *points, INT count, INT offset,
INT numberOfSegments, REAL tension)
{
return updateStatus(DllExports::GdipAddPathCurve3(
nativePath, points, count,
offset, numberOfSegments, tension));
}
Status AddCurve(const Point *points, INT count, INT offset,
INT numberOfSegments, REAL tension)
{
return updateStatus(DllExports::GdipAddPathCurve3I(
nativePath, points, count,
offset, numberOfSegments, tension));
}
Status AddEllipse(REAL x, REAL y, REAL width, REAL height)
{
return updateStatus(DllExports::GdipAddPathEllipse(nativePath,
x, y, width, height));
}
Status AddEllipse(INT x, INT y, INT width, INT height)
{
return updateStatus(DllExports::GdipAddPathEllipseI(nativePath,
x, y, width, height));
}
Status AddEllipse(const RectF& rect)
{
return updateStatus(DllExports::GdipAddPathEllipse(nativePath,
rect.X, rect.Y, rect.Width, rect.Height));
}
Status AddEllipse(const Rect& rect)
{
return updateStatus(DllExports::GdipAddPathEllipseI(nativePath,
rect.X, rect.Y, rect.Width, rect.Height));
}
Status AddLine(REAL x1, REAL y1, REAL x2, REAL y2)
{
return updateStatus(DllExports::GdipAddPathLine(nativePath,
x1, y1, x2, y2));
}
Status AddLine(INT x1, INT y1, INT x2, INT y2)
{
return updateStatus(DllExports::GdipAddPathLineI(nativePath,
x1, y1, x2, y2));
}
Status AddLine(const PointF& pt1, const PointF& pt2)
{
return updateStatus(DllExports::GdipAddPathLine(nativePath,
pt1.X, pt1.Y, pt2.X, pt2.Y));
}
Status AddLine(const Point& pt1, const Point& pt2)
{
return updateStatus(DllExports::GdipAddPathLineI(nativePath,
pt1.X, pt1.Y, pt2.X, pt2.Y));
}
Status AddLines(const PointF *points, INT count)
{
return updateStatus(DllExports::GdipAddPathLine2(nativePath,
points, count));
}
Status AddLines(const Point *points, INT count)
{
return updateStatus(DllExports::GdipAddPathLine2I(nativePath,
points, count));
}
Status AddPath(const GraphicsPath *addingPath, BOOL connect)
{
return updateStatus(DllExports::GdipAddPathPath(nativePath,
addingPath ? addingPath->nativePath : NULL,
connect));
}
Status AddPie(REAL x, REAL y, REAL width, REAL height,
REAL startAngle, REAL sweepAngle)
{
return updateStatus(DllExports::GdipAddPathPie(nativePath,
x, y, width, height, startAngle, sweepAngle));
}
Status AddPie(INT x, INT y, INT width, INT height,
REAL startAngle, REAL sweepAngle)
{
return updateStatus(DllExports::GdipAddPathPieI(nativePath,
x, y, width, height, startAngle, sweepAngle));
}
Status AddPie(const RectF& rect, REAL startAngle, REAL sweepAngle)
{
return updateStatus(DllExports::GdipAddPathPie(nativePath,
rect.X, rect.Y, rect.Width, rect.Height,
startAngle, sweepAngle));
}
Status AddPie(const Rect& rect, REAL startAngle, REAL sweepAngle)
{
return updateStatus(DllExports::GdipAddPathPieI(nativePath,
rect.X, rect.Y, rect.Width, rect.Height,
startAngle, sweepAngle));
}
Status AddPolygon(const PointF *points, INT count)
{
return updateStatus(DllExports::GdipAddPathPolygon(nativePath,
points, count));
}
Status AddPolygon(const Point *points, INT count)
{
return updateStatus(DllExports::GdipAddPathPolygonI(nativePath,
points, count));
}
Status AddRectangle(const RectF& rect)
{
return updateStatus(DllExports::GdipAddPathRectangle(nativePath,
rect.X, rect.Y, rect.Width, rect.Height));
}
Status AddRectangle(const Rect& rect)
{
return updateStatus(DllExports::GdipAddPathRectangleI(
nativePath,
rect.X, rect.Y, rect.Width, rect.Height));
}
Status AddRectangles(const RectF *rects, INT count)
{
return updateStatus(DllExports::GdipAddPathRectangles(
nativePath, rects, count));
}
Status AddRectangles(const Rect *rects, INT count)
{
return updateStatus(DllExports::GdipAddPathRectanglesI(
nativePath, rects, count));
}
Status AddString(const WCHAR *string, INT length,
const FontFamily *family, INT style, REAL emSize,
const PointF& origin, const StringFormat *format)
{
RectF layoutRect(origin, SizeF(0.0f, 0.0f));
return updateStatus(DllExports::GdipAddPathString(nativePath,
string, length,
family ? family->nativeFontFamily : NULL,
style, emSize, &layoutRect,
format ? format->nativeStringFormat : NULL));
}
Status AddString(const WCHAR *string, INT length,
const FontFamily *family, INT style, REAL emSize,
const Point& origin, const StringFormat *format)
{
Rect layoutRect(origin, Size(0, 0));
return updateStatus(DllExports::GdipAddPathStringI(nativePath,
string, length,
family ? family->nativeFontFamily : NULL,
style, emSize, &layoutRect,
format ? format->nativeStringFormat : NULL));
}
Status AddString(const WCHAR *string, INT length,
const FontFamily *family, INT style, REAL emSize,
const RectF& layoutRect, const StringFormat *format)
{
return updateStatus(DllExports::GdipAddPathString(nativePath,
string, length,
family ? family->nativeFontFamily : NULL,
style, emSize, &layoutRect,
format ? format->nativeStringFormat : NULL));
}
Status AddString(const WCHAR *string, INT length,
const FontFamily *family, INT style, REAL emSize,
const Rect& layoutRect, const StringFormat *format)
{
return updateStatus(DllExports::GdipAddPathStringI(nativePath,
string, length,
family ? family->nativeFontFamily : NULL,
style, emSize, &layoutRect,
format ? format->nativeStringFormat : NULL));
}
Status ClearMarkers()
{
return updateStatus(DllExports::GdipClearPathMarkers(
nativePath));
}
Status CloseAllFigures()
{
return updateStatus(DllExports::GdipClosePathFigures(
nativePath));
}
Status CloseFigure()
{
return updateStatus(DllExports::GdipClosePathFigure(
nativePath));
}
Status Flatten(const Matrix *matrix = NULL,
REAL flatness = FlatnessDefault)
{
return updateStatus(DllExports::GdipFlattenPath(nativePath,
matrix ? matrix->nativeMatrix : NULL,
flatness));
}
Status GetBounds(RectF *bounds, const Matrix *matrix = NULL,
const Pen *pen = NULL) const
{
return updateStatus(DllExports::GdipGetPathWorldBounds(
nativePath, bounds,
matrix ? matrix->nativeMatrix : NULL,
pen ? pen->nativePen : NULL));
}
Status GetBounds(Rect *bounds, const Matrix *matrix = NULL,
const Pen *pen = NULL) const
{
return updateStatus(DllExports::GdipGetPathWorldBoundsI(
nativePath, bounds,
matrix ? matrix->nativeMatrix : NULL,
pen ? pen->nativePen : NULL));
}
FillMode GetFillMode() const
{
FillMode result = FillModeAlternate;
updateStatus(DllExports::GdipGetPathFillMode(nativePath,
&result));
return result;
}
Status GetLastPoint(PointF *lastPoint) const
{
return updateStatus(DllExports::GdipGetPathLastPoint(
nativePath, lastPoint));
}
Status GetLastStatus() const
{
Status result = lastStatus;
lastStatus = Ok;
return result;
}
Status GetPathData(PathData *pathData) const
{
if (!pathData) return lastStatus = InvalidParameter;
Status status;
INT count;
status = updateStatus(DllExports::GdipGetPointCount(
nativePath, &count));
if (status != Ok) return status;
status = updateStatus(pathData->AllocateArrays(count));
if (status != Ok) return status;
return updateStatus(DllExports::GdipGetPathData(
nativePath, (GpPathData*) pathData));
}
Status GetPathPoints(PointF *points, INT count) const
{
return updateStatus(DllExports::GdipGetPathPoints(nativePath,
points, count));
}
Status GetPathPoints(Point *points, INT count) const
{
return updateStatus(DllExports::GdipGetPathPointsI(nativePath,
points, count));
}
Status GetPathTypes(BYTE *types, INT count) const
{
return updateStatus(DllExports::GdipGetPathTypes(nativePath,
types, count));
}
INT GetPointCount() const
{
INT result = 0;
updateStatus(DllExports::GdipGetPointCount(nativePath,
&result));
return result;
}
BOOL IsOutlineVisible(REAL x, REAL y, const Pen *pen,
const Graphics *g = NULL) const;
BOOL IsOutlineVisible(INT x, INT y, const Pen *pen,
const Graphics *g = NULL) const;
BOOL IsOutlineVisible(const PointF& point, const Pen *pen,
const Graphics *g = NULL) const;
BOOL IsOutlineVisible(const Point& point, const Pen *pen,
const Graphics *g = NULL) const;
BOOL IsVisible(REAL x, REAL y, const Graphics *g = NULL) const;
BOOL IsVisible(INT x, INT y, const Graphics *g = NULL) const;
BOOL IsVisible(const PointF& point, const Graphics *g = NULL) const;
BOOL IsVisible(const Point& point, const Graphics *g = NULL) const;
Status Outline(const Matrix *matrix = NULL,
REAL flatness = FlatnessDefault)
{
return updateStatus(DllExports::GdipWindingModeOutline(
nativePath,
matrix ? matrix->nativeMatrix : NULL,
flatness));
}
Status Reset()
{
return updateStatus(DllExports::GdipResetPath(nativePath));
}
Status Reverse()
{
return updateStatus(DllExports::GdipReversePath(nativePath));
}
Status SetFillMode(FillMode fillMode)
{
return updateStatus(DllExports::GdipSetPathFillMode(
nativePath, fillMode));
}
Status SetMarker()
{
return updateStatus(DllExports::GdipSetPathMarker(nativePath));
}
Status StartFigure()
{
return updateStatus(DllExports::GdipStartPathFigure(
nativePath));
}
Status Transform(const Matrix *matrix)
{
return updateStatus(DllExports::GdipTransformPath(
nativePath,
matrix ? matrix->nativeMatrix : NULL));
}
Status Warp(const PointF *destPoints, INT count, const RectF& srcRect,
const Matrix *matrix = NULL,
WarpMode warpMode = WarpModePerspective,
REAL flatness = FlatnessDefault)
{
return updateStatus(DllExports::GdipWarpPath(nativePath,
matrix ? matrix->nativeMatrix : NULL,
destPoints, count,
srcRect.X, srcRect.Y,
srcRect.Width, srcRect.Height,
warpMode, flatness));
}
Status Widen(const Pen *pen, const Matrix *matrix = NULL,
REAL flatness = FlatnessDefault)
{
return updateStatus(DllExports::GdipWidenPath(nativePath,
pen ? pen->nativePen : NULL,
matrix ? matrix->nativeMatrix : NULL,
flatness));
}
private:
GraphicsPath(GpPath *path, Status status):
nativePath(path), lastStatus(status) {}
GraphicsPath(const GraphicsPath&);
GraphicsPath& operator=(const GraphicsPath&);
Status updateStatus(Status newStatus) const
{
if (newStatus != Ok) lastStatus = newStatus;
return newStatus;
}
GpPath *nativePath;
mutable Status lastStatus;
};
class GraphicsPathIterator: public GdiplusBase
{
public:
GraphicsPathIterator(GraphicsPath *path):
nativePathIterator(NULL), lastStatus(Ok)
{
lastStatus = DllExports::GdipCreatePathIter(
&nativePathIterator,
path ? path->nativePath : NULL);
}
~GraphicsPathIterator()
{
DllExports::GdipDeletePathIter(nativePathIterator);
}
INT CopyData(PointF *points, BYTE *types, INT startIndex, INT endIndex)
{
INT result = 0;
updateStatus(DllExports::GdipPathIterCopyData(
nativePathIterator, &result,
points, types, startIndex, endIndex));
return result;
}
INT Enumerate(PointF *points, BYTE *types, INT count)
{
INT result = 0;
updateStatus(DllExports::GdipPathIterEnumerate(
nativePathIterator, &result,
points, types, count));
return result;
}
INT GetCount() const
{
INT result = 0;
updateStatus(DllExports::GdipPathIterGetCount(
nativePathIterator, &result));
return result;
}
Status GetLastStatus() const
{
Status result = lastStatus;
lastStatus = Ok;
return result;
}
INT GetSubpathCount() const
{
INT result = 0;
updateStatus(DllExports::GdipPathIterGetSubpathCount(
nativePathIterator, &result));
return result;
}
BOOL HasCurve() const
{
BOOL result = FALSE;
updateStatus(DllExports::GdipPathIterHasCurve(
nativePathIterator, &result));
return result;
}
INT NextMarker(INT *startIndex, INT *endIndex)
{
INT result = 0;
updateStatus(DllExports::GdipPathIterNextMarker(
nativePathIterator, &result,
startIndex, endIndex));
return result;
}
INT NextMarker(GraphicsPath *path)
{
INT result = 0;
updateStatus(DllExports::GdipPathIterNextMarkerPath(
nativePathIterator, &result,
path ? path->nativePath : NULL));
return result;
}
INT NextPathType(BYTE *pathType, INT *startIndex, INT *endIndex)
{
INT result = 0;
updateStatus(DllExports::GdipPathIterNextPathType(
nativePathIterator, &result,
pathType, startIndex, endIndex));
return result;
}
INT NextSubpath(INT *startIndex, INT *endIndex, BOOL *isClosed)
{
INT result = 0;
updateStatus(DllExports::GdipPathIterNextSubpath(
nativePathIterator, &result,
startIndex, endIndex, isClosed));
return result;
}
INT NextSubpath(GraphicsPath *path, BOOL *isClosed)
{
INT result = 0;
updateStatus(DllExports::GdipPathIterNextSubpathPath(
nativePathIterator, &result,
path ? path->nativePath : NULL, isClosed));
return result;
}
VOID Rewind()
{
updateStatus(DllExports::GdipPathIterRewind(
nativePathIterator));
}
private:
GraphicsPathIterator(GpPathIterator *pathIterator, Status status):
nativePathIterator(pathIterator), lastStatus(status) {}
GraphicsPathIterator(const GraphicsPathIterator&);
GraphicsPathIterator& operator=(const GraphicsPathIterator&);
Status updateStatus(Status newStatus) const
{
if (newStatus != Ok) lastStatus = newStatus;
return newStatus;
}
GpPathIterator *nativePathIterator;
mutable Status lastStatus;
};
class PathGradientBrush: public Brush
{
public:
PathGradientBrush(const PointF *points, INT count,
WrapMode wrapMode = WrapModeClamp)
{
GpPathGradient *nativePathGradient = NULL;
lastStatus = DllExports::GdipCreatePathGradient(
points, count, wrapMode, &nativePathGradient);
nativeBrush = nativePathGradient;
}
PathGradientBrush(const Point *points, INT count,
WrapMode wrapMode = WrapModeClamp)
{
GpPathGradient *nativePathGradient = NULL;
lastStatus = DllExports::GdipCreatePathGradientI(
points, count, wrapMode, &nativePathGradient);
nativeBrush = nativePathGradient;
}
PathGradientBrush(const GraphicsPath *path)
{
GpPathGradient *nativePathGradient = NULL;
lastStatus = DllExports::GdipCreatePathGradientFromPath(
path ? path->nativePath : NULL,
&nativePathGradient);
nativeBrush = nativePathGradient;
}
virtual PathGradientBrush *Clone() const
{
GpBrush *cloneBrush = NULL;
Status status = updateStatus(DllExports::GdipCloneBrush(
nativeBrush, &cloneBrush));
if (status == Ok) {
PathGradientBrush *result =
new PathGradientBrush(cloneBrush, lastStatus);
if (!result) {
DllExports::GdipDeleteBrush(cloneBrush);
updateStatus(OutOfMemory);
}
return result;
} else {
return NULL;
}
}
Status GetBlend(REAL *blendFactors, REAL *blendPositions,
INT count) const
{
return updateStatus(DllExports::GdipGetPathGradientBlend(
(GpPathGradient*) nativeBrush,
blendFactors, blendPositions, count));
}
INT GetBlendCount() const
{
INT result = 0;
updateStatus(DllExports::GdipGetPathGradientBlendCount(
(GpPathGradient*) nativeBrush, &result));
return result;
}
Status GetCenterColor(Color *color) const
{
return updateStatus(DllExports::GdipGetPathGradientCenterColor(
(GpPathGradient*) nativeBrush,
color ? &color->Value : NULL));
}
Status GetCenterPoint(PointF *point) const
{
return updateStatus(DllExports::GdipGetPathGradientCenterPoint(
(GpPathGradient*) nativeBrush, point));
}
Status GetCenterPoint(Point *point) const
{
return updateStatus(DllExports::GdipGetPathGradientCenterPointI(
(GpPathGradient*) nativeBrush, point));
}
Status GetFocusScales(REAL *xScale, REAL *yScale) const
{
return updateStatus(DllExports::GdipGetPathGradientFocusScales(
(GpPathGradient*) nativeBrush, xScale, yScale));
}
BOOL GetGammaCorrection() const
{
BOOL result = FALSE;
updateStatus(DllExports::GdipGetPathGradientGammaCorrection(
(GpPathGradient*) nativeBrush, &result));
return result;
}
//Status GetGraphicsPath(GraphicsPath *path) const
//{
// // TODO: implement PathGradientBrush::GetGraphicsPath
// return updateStatus(NotImplemented);
//}
INT GetInterpolationColorCount() const
{
INT result = 0;
updateStatus(DllExports::GdipGetPathGradientPresetBlendCount(
(GpPathGradient*) nativeBrush, &result));
return result;
}
Status GetInterpolationColors(Color *presetColors,
REAL *blendPositions, INT count) const
{
if (!presetColors || count <= 0)
return lastStatus = InvalidParameter;
ARGB *presetArgb =
(ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB));
if (!presetArgb)
return lastStatus = OutOfMemory;
Status status = updateStatus(DllExports::GdipGetPathGradientPresetBlend(
(GpPathGradient*) nativeBrush,
presetArgb, blendPositions, count));
for (INT i = 0; i < count; ++i) {
presetColors[i].SetValue(presetArgb[i]);
}
DllExports::GdipFree((void*) presetArgb);
return status;
}
INT GetPointCount() const
{
INT result = 0;
updateStatus(DllExports::GdipGetPathGradientPointCount(
(GpPathGradient*) nativeBrush, &result));
return result;
}
Status GetRectangle(RectF *rect) const
{
return updateStatus(DllExports::GdipGetPathGradientRect(
(GpPathGradient*) nativeBrush, rect));
}
Status GetRectangle(Rect *rect) const
{
return updateStatus(DllExports::GdipGetPathGradientRectI(
(GpPathGradient*) nativeBrush, rect));
}
INT GetSurroundColorCount() const
{
INT result = 0;
updateStatus(DllExports::GdipGetPathGradientSurroundColorCount(
(GpPathGradient*) nativeBrush, &result));
return result;
}
Status GetSurroundColors(Color *colors, INT *count)
{
if (!colors || !count || *count <= 0)
return lastStatus = InvalidParameter;
ARGB *colorsArgb =
(ARGB*) DllExports::GdipAlloc(*count * sizeof(ARGB));
if (!colorsArgb)
return lastStatus = OutOfMemory;
Status status = updateStatus(DllExports::GdipGetPathGradientSurroundColorsWithCount(
(GpPathGradient*) nativeBrush,
colorsArgb, count));
for (INT i = 0; i < *count; ++i) {
colors[i].SetValue(colorsArgb[i]);
}
DllExports::GdipFree((void*) colorsArgb);
return status;
}
Status GetTransform(Matrix *matrix) const
{
return updateStatus(DllExports::GdipGetPathGradientTransform(
(GpPathGradient*) nativeBrush,
matrix ? matrix->nativeMatrix : NULL));
}
WrapMode GetWrapMode() const
{
WrapMode result = WrapModeTile;
updateStatus(DllExports::GdipGetPathGradientWrapMode(
(GpPathGradient*) nativeBrush, &result));
return result;
}
Status MultiplyTransform(const Matrix *matrix,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipMultiplyPathGradientTransform(
(GpPathGradient*) nativeBrush,
matrix ? matrix->nativeMatrix : NULL, order));
}
Status ResetTransform()
{
return updateStatus(DllExports::GdipResetPathGradientTransform(
(GpPathGradient*) nativeBrush));
}
Status RotateTransform(REAL angle,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipRotatePathGradientTransform(
(GpPathGradient*) nativeBrush, angle, order));
}
Status ScaleTransform(REAL sx, REAL sy,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipScalePathGradientTransform(
(GpPathGradient*) nativeBrush, sx, sy, order));
}
Status SetBlend(REAL *blendFactors, REAL *blendPositions, INT count)
{
return updateStatus(DllExports::GdipSetPathGradientBlend(
(GpPathGradient*) nativeBrush,
blendFactors, blendPositions, count));
}
Status SetBlendBellShape(REAL focus, REAL scale = 1.0f)
{
return updateStatus(DllExports::GdipSetPathGradientSigmaBlend(
(GpPathGradient*) nativeBrush, focus, scale));
}
Status SetBlendTriangularShape(REAL focus, REAL scale = 1.0f)
{
return updateStatus(DllExports::GdipSetPathGradientLinearBlend(
(GpPathGradient*) nativeBrush, focus, scale));
}
Status SetCenterColor(const Color& color)
{
return updateStatus(DllExports::GdipSetPathGradientCenterColor(
(GpPathGradient*) nativeBrush,
color.GetValue()));
}
Status SetCenterPoint(const PointF& point)
{
return updateStatus(DllExports::GdipSetPathGradientCenterPoint(
(GpPathGradient*) nativeBrush, &point));
}
Status SetCenterPoint(const Point& point)
{
return updateStatus(DllExports::GdipSetPathGradientCenterPointI(
(GpPathGradient*) nativeBrush, &point));
}
Status SetFocusScales(REAL xScale, REAL yScale)
{
return updateStatus(DllExports::GdipSetPathGradientFocusScales(
(GpPathGradient*) nativeBrush, xScale, yScale));
}
Status SetGammaCorrection(BOOL useGammaCorrection)
{
return updateStatus(DllExports::GdipSetPathGradientGammaCorrection(
(GpPathGradient*) nativeBrush,
useGammaCorrection));
}
//Status SetGraphicsPath(const GraphicsPath *path)
//{
// // TODO: implement PathGradientBrush::SetGraphicsPath
// return updateStatus(NotImplemented);
//}
Status SetInterpolationColors(const Color *presetColors,
REAL *blendPositions, INT count)
{
if (!presetColors || count <= 0)
return lastStatus = InvalidParameter;
ARGB *presetArgb =
(ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB));
if (!presetArgb)
return lastStatus = OutOfMemory;
for (INT i = 0; i < count; ++i) {
presetArgb[i] = presetColors[i].GetValue();
}
Status status = updateStatus(DllExports::GdipSetPathGradientPresetBlend(
(GpPathGradient*) nativeBrush,
presetArgb, blendPositions, count));
DllExports::GdipFree((void*) presetArgb);
return status;
}
Status SetSurroundColors(const Color *colors, INT *count)
{
if (!colors || !count || *count <= 0)
return lastStatus = InvalidParameter;
ARGB *colorsArgb =
(ARGB*) DllExports::GdipAlloc(*count * sizeof(ARGB));
if (!colorsArgb)
return lastStatus = OutOfMemory;
for (INT i = 0; i < *count; ++i) {
colorsArgb[i] = colors[i].GetValue();
}
Status status = updateStatus(DllExports::GdipSetPathGradientSurroundColorsWithCount(
(GpPathGradient*) nativeBrush,
colorsArgb, count));
DllExports::GdipFree((void*) colorsArgb);
return status;
}
Status SetTransform(const Matrix *matrix)
{
return updateStatus(DllExports::GdipSetPathGradientTransform(
(GpPathGradient*) nativeBrush,
matrix ? matrix->nativeMatrix : NULL));
}
Status SetWrapMode(WrapMode wrapMode)
{
return updateStatus(DllExports::GdipSetPathGradientWrapMode(
(GpPathGradient*) nativeBrush, wrapMode));
}
Status TranslateTransform(REAL dx, REAL dy,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipTranslatePathGradientTransform(
(GpPathGradient*) nativeBrush, dx, dy, order));
}
private:
PathGradientBrush(GpBrush *brush, Status status): Brush(brush, status) {}
PathGradientBrush(const PathGradientBrush&);
PathGradientBrush& operator=(const PathGradientBrush&);
};
#endif /* __GDIPLUS_PATH_H */

338
winsup/w32api/include/gdiplus/gdipluspen.h Executable file
View File

@ -0,0 +1,338 @@
/*
* gdipluspen.h
*
* GDI+ Pen class
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_PEN_H
#define __GDIPLUS_PEN_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#ifndef __cplusplus
#error "A C++ compiler is required to include gdipluspen.h."
#endif
class Pen: public GdiplusBase
{
friend class Graphics;
friend class GraphicsPath;
public:
Pen(const Color& color, REAL width = 1.0f):
nativePen(NULL), lastStatus(Ok)
{
lastStatus = DllExports::GdipCreatePen1(
color.GetValue(), width, UnitWorld,
&nativePen);
}
Pen(const Brush *brush, REAL width = 1.0f):
nativePen(NULL), lastStatus(Ok)
{
lastStatus = DllExports::GdipCreatePen2(
brush ? brush->nativeBrush : NULL,
width, UnitWorld, &nativePen);
}
~Pen()
{
DllExports::GdipDeletePen(nativePen);
}
Pen* Clone() const
{
GpPen *clonePen = NULL;
Status status = updateStatus(DllExports::GdipClonePen(
nativePen, &clonePen));
if (status == Ok) {
Pen *result = new Pen(clonePen, lastStatus);
if (!result) {
DllExports::GdipDeletePen(clonePen);
lastStatus = OutOfMemory;
}
return result;
} else {
return NULL;
}
}
PenAlignment GetAlignment() const
{
PenAlignment result = PenAlignmentCenter;
updateStatus(DllExports::GdipGetPenMode(nativePen, &result));
return result;
}
// TODO: implement Pen::GetBrush()
//Brush *GetBrush() const
//{
// // where is the pen brush allocated (static,member,new,other)?
// // GdipGetPenBrushFill just returns a GpBrush*
// updateStatus(NotImplemented);
// return NULL;
//}
Status GetColor(Color *color) const
{
return updateStatus(DllExports::GdipGetPenColor(
nativePen, color ? &color->Value : NULL));
}
Status GetCompoundArray(REAL *compoundArray, INT count) const
{
return updateStatus(DllExports::GdipGetPenCompoundArray(
nativePen, compoundArray, count));
}
INT GetCompoundArrayCount() const
{
INT result = 0;
updateStatus(DllExports::GdipGetPenCompoundCount(
nativePen, &result));
return result;
}
Status GetCustomEndCap(CustomLineCap *customCap) const
{
if (!customCap) return lastStatus = InvalidParameter;
// FIXME: do we need to call GdipDeleteCustomLineCap first?
return updateStatus(DllExports::GdipGetPenCustomEndCap(
nativePen, &customCap->nativeCustomLineCap));
}
Status GetCustomStartCap(CustomLineCap *customCap) const
{
if (!customCap) return lastStatus = InvalidParameter;
// FIXME: do we need to call GdipDeleteCustomLineCap first?
return updateStatus(DllExports::GdipGetPenCustomStartCap(
nativePen, &customCap->nativeCustomLineCap));
}
DashCap GetDashCap() const
{
DashCap result = DashCapFlat;
updateStatus(DllExports::GdipGetPenDashCap197819(
nativePen, &result));
return result;
}
REAL GetDashOffset() const
{
REAL result = 0.0f;
updateStatus(DllExports::GdipGetPenDashOffset(
nativePen, &result));
return result;
}
Status GetDashPattern(REAL *dashArray, INT count) const
{
return updateStatus(DllExports::GdipGetPenDashArray(
nativePen, dashArray, count));
}
INT GetDashPatternCount() const
{
INT result = 0;
updateStatus(DllExports::GdipGetPenDashCount(
nativePen, &result));
return result;
}
DashStyle GetDashStyle() const
{
DashStyle result = DashStyleSolid;
updateStatus(DllExports::GdipGetPenDashStyle(
nativePen, &result));
return result;
}
LineCap GetEndCap() const
{
LineCap result = LineCapFlat;
updateStatus(DllExports::GdipGetPenEndCap(nativePen, &result));
return result;
}
Status GetLastStatus() const
{
Status result = lastStatus;
lastStatus = Ok;
return result;
}
LineJoin GetLineJoin() const
{
LineJoin result = LineJoinMiter;
updateStatus(DllExports::GdipGetPenLineJoin(
nativePen, &result));
return result;
}
REAL GetMiterLimit() const
{
REAL result = 10.0f;
updateStatus(DllExports::GdipGetPenMiterLimit(
nativePen, &result));
return result;
}
PenType GetPenType() const
{
PenType result = PenTypeUnknown;
updateStatus(DllExports::GdipGetPenFillType(
nativePen, &result));
return result;
}
LineCap GetStartCap() const
{
LineCap result = LineCapFlat;
updateStatus(DllExports::GdipGetPenStartCap(
nativePen, &result));
return result;
}
Status GetTransform(Matrix *matrix) const
{
return updateStatus(DllExports::GdipGetPenTransform(
nativePen,
matrix ? matrix->nativeMatrix : NULL));
}
REAL GetWidth() const
{
REAL result = 1.0f;
updateStatus(DllExports::GdipGetPenWidth(nativePen, &result));
return result;
}
Status MultiplyTransform(const Matrix *matrix,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipMultiplyPenTransform(
nativePen,
matrix ? matrix->nativeMatrix : NULL, order));
}
Status ResetTransform()
{
return updateStatus(DllExports::GdipResetPenTransform(
nativePen));
}
Status RotateTransform(REAL angle,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipRotatePenTransform(
nativePen, angle, order));
}
Status ScaleTransform(REAL sx, REAL sy,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipScalePenTransform(
nativePen, sx, sy, order));
}
Status SetAlignment(PenAlignment penAlignment)
{
return updateStatus(DllExports::GdipSetPenMode(
nativePen, penAlignment));
}
Status SetBrush(const Brush *brush)
{
return updateStatus(DllExports::GdipSetPenBrushFill(
nativePen, brush ? brush->nativeBrush : NULL));
}
Status SetColor(const Color& color)
{
return updateStatus(DllExports::GdipSetPenColor(
nativePen, color.GetValue()));
}
Status SetCompoundArray(const REAL *compoundArray, INT count)
{
return updateStatus(DllExports::GdipSetPenCompoundArray(
nativePen, compoundArray, count));
}
Status SetCustomEndCap(const CustomLineCap *customCap)
{
return updateStatus(DllExports::GdipSetPenCustomEndCap(
nativePen,
customCap ? customCap->nativeCustomLineCap : NULL));
}
Status SetCustomStartCap(const CustomLineCap *customCap)
{
return updateStatus(DllExports::GdipSetPenCustomStartCap(
nativePen,
customCap ? customCap->nativeCustomLineCap : NULL));
}
Status SetDashCap(DashCap dashCap)
{
return updateStatus(DllExports::GdipSetPenDashCap197819(
nativePen, dashCap));
}
Status SetDashOffset(REAL dashOffset)
{
return updateStatus(DllExports::GdipSetPenDashOffset(
nativePen, dashOffset));
}
Status SetDashPattern(const REAL *dashArray, INT count)
{
return updateStatus(DllExports::GdipSetPenDashArray(
nativePen, dashArray, count));
}
Status SetDashStyle(DashStyle dashStyle)
{
return updateStatus(DllExports::GdipSetPenDashStyle(
nativePen, dashStyle));
}
Status SetEndCap(LineCap endCap)
{
return updateStatus(DllExports::GdipSetPenEndCap(
nativePen, endCap));
}
Status SetLineCap(LineCap startCap, LineCap endCap, DashCap dashCap)
{
return updateStatus(DllExports::GdipSetPenLineCap197819(
nativePen, startCap, endCap, dashCap));
}
Status SetLineJoin(LineJoin lineJoin)
{
return updateStatus(DllExports::GdipSetPenLineJoin(
nativePen, lineJoin));
}
Status SetMiterLimit(REAL miterLimit)
{
return updateStatus(DllExports::GdipSetPenMiterLimit(
nativePen, miterLimit));
}
Status SetStartCap(LineCap startCap)
{
return updateStatus(DllExports::GdipSetPenStartCap(
nativePen, startCap));
}
Status SetTransform(const Matrix *matrix)
{
return updateStatus(DllExports::GdipSetPenTransform(
nativePen,
matrix ? matrix->nativeMatrix : NULL));
}
Status SetWidth(REAL width)
{
return updateStatus(DllExports::GdipSetPenWidth(
nativePen, width));
}
Status TranslateTransform(REAL dx, REAL dy,
MatrixOrder order = MatrixOrderPrepend)
{
return updateStatus(DllExports::GdipTranslatePenTransform(
nativePen, dx, dy, order));
}
private:
Pen(GpPen *pen, Status status): nativePen(pen), lastStatus(status) {}
Pen(const Pen& pen);
Pen& operator=(const Pen&);
Status updateStatus(Status newStatus) const
{
if (newStatus != Ok) lastStatus = newStatus;
return newStatus;
}
GpPen *nativePen;
mutable Status lastStatus;
};
#endif /* __GDIPLUS_PEN_H */

120
winsup/w32api/include/gdiplus/gdipluspixelformats.h Executable file
View File

@ -0,0 +1,120 @@
/*
* gdipluspixelformats.h
*
* GDI+ pixel formats
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_PIXELFORMATS_H
#define __GDIPLUS_PIXELFORMATS_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
typedef DWORD ARGB;
typedef INT PixelFormat;
#define PixelFormatIndexed ((PixelFormat) 0x00010000)
#define PixelFormatGDI ((PixelFormat) 0x00020000)
#define PixelFormatAlpha ((PixelFormat) 0x00040000)
#define PixelFormatPAlpha ((PixelFormat) 0x00080000)
#define PixelFormatExtended ((PixelFormat) 0x00100000)
#define PixelFormatCanonical ((PixelFormat) 0x00200000)
#define PixelFormatUndefined ((PixelFormat) 0)
#define PixelFormatDontCare ((PixelFormat) 0)
#define PixelFormat1bppIndexed ((PixelFormat) \
(1 | (1<<8) | PixelFormatIndexed | PixelFormatGDI))
#define PixelFormat4bppIndexed ((PixelFormat) \
(2 | (4<<8) | PixelFormatIndexed | PixelFormatGDI))
#define PixelFormat8bppIndexed ((PixelFormat) \
(3 | (8<<8) | PixelFormatIndexed | PixelFormatGDI))
#define PixelFormat16bppGrayScale ((PixelFormat) \
(4 | (16<<8) | PixelFormatExtended))
#define PixelFormat16bppRGB555 ((PixelFormat) \
(5 | (16<<8) | PixelFormatGDI))
#define PixelFormat16bppRGB565 ((PixelFormat) \
(6 | (16<<8) | PixelFormatGDI))
#define PixelFormat16bppARGB1555 ((PixelFormat) \
(7 | (16<<8) | PixelFormatAlpha | PixelFormatGDI))
#define PixelFormat24bppRGB ((PixelFormat) \
(8 | (24<<8) | PixelFormatGDI))
#define PixelFormat32bppRGB ((PixelFormat) \
(9 | (32<<8) | PixelFormatGDI))
#define PixelFormat32bppARGB ((PixelFormat) \
(10 | (32<<8) | PixelFormatAlpha | PixelFormatGDI | PixelFormatCanonical))
#define PixelFormat32bppPARGB ((PixelFormat) \
(11 | (32<<8) | PixelFormatAlpha | PixelFormatPAlpha | PixelFormatGDI))
#define PixelFormat48bppRGB ((PixelFormat) \
(12 | (48<<8) | PixelFormatExtended))
#define PixelFormat64bppARGB ((PixelFormat) \
(13 | (64<<8) | PixelFormatAlpha | PixelFormatCanonical | PixelFormatExtended))
#define PixelFormat64bppPARGB ((PixelFormat) \
(14 | (64<<8) | PixelFormatAlpha | PixelFormatPAlpha | PixelFormatExtended))
#define PixelFormatMax ((PixelFormat) 15)
typedef enum PaletteFlags {
PaletteFlagsHasAlpha = 1,
PaletteFlagsGrayScale = 2,
PaletteFlagsHalftone = 4
} PaletteFlags;
typedef enum PaletteType {
PaletteTypeCustom = 0,
PaletteTypeOptimal = 1,
PaletteTypeFixedBW = 2,
PaletteTypeFixedHalftone8 = 3,
PaletteTypeFixedHalftone27 = 4,
PaletteTypeFixedHalftone64 = 5,
PaletteTypeFixedHalftone125 = 6,
PaletteTypeFixedHalftone216 = 7,
PaletteTypeFixedHalftone252 = 8,
PaletteTypeFixedHalftone256 = 9
} PaletteType;
typedef struct ColorPalette {
UINT Flags;
UINT Count;
ARGB Entries[1];
} ColorPalette;
static __inline__ UINT GetPixelFormatSize(PixelFormat pixfmt)
{
return (((UINT) pixfmt) & 0xff00U) >> 8;
}
static __inline__ BOOL IsAlphaPixelFormat(PixelFormat pixfmt)
{
return (pixfmt & PixelFormatAlpha) != 0;
}
static __inline__ BOOL IsCanonicalPixelFormat(PixelFormat pixfmt)
{
return (pixfmt & PixelFormatCanonical) != 0;
}
static __inline__ BOOL IsExtendedPixelFormat(PixelFormat pixfmt)
{
return (pixfmt & PixelFormatExtended) != 0;
}
static __inline__ BOOL IsIndexedPixelFormat(PixelFormat pixfmt)
{
return (pixfmt & PixelFormatIndexed) != 0;
}
#endif /* __GDIPLUS_PIXELFORMATS_H */

251
winsup/w32api/include/gdiplus/gdiplusstringformat.h Executable file
View File

@ -0,0 +1,251 @@
/*
* gdiplusstringformat.h
*
* GDI+ StringFormat class
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_STRINGFORMAT_H
#define __GDIPLUS_STRINGFORMAT_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#ifndef __cplusplus
#error "A C++ compiler is required to include gdiplusstringformat.h."
#endif
class StringFormat: public GdiplusBase
{
friend class Graphics;
friend class GraphicsPath;
public:
static const StringFormat* GenericDefault();
static const StringFormat* GenericTypographic();
StringFormat(INT formatFlags = 0, LANGID language = LANG_NEUTRAL):
nativeStringFormat(NULL), lastStatus(Ok)
{
lastStatus = DllExports::GdipCreateStringFormat(
formatFlags, language, &nativeStringFormat);
}
StringFormat(const StringFormat *format):
nativeStringFormat(NULL), lastStatus(Ok)
{
lastStatus = DllExports::GdipCloneStringFormat(
format ? format->nativeStringFormat : NULL,
&nativeStringFormat);
}
~StringFormat()
{
DllExports::GdipDeleteStringFormat(nativeStringFormat);
}
StringFormat* Clone() const
{
GpStringFormat *cloneStringFormat = NULL;
Status status = updateStatus(DllExports::GdipCloneStringFormat(
nativeStringFormat, &cloneStringFormat));
if (status == Ok) {
StringFormat *result = new StringFormat(
cloneStringFormat, lastStatus);
if (!result) {
DllExports::GdipDeleteStringFormat(cloneStringFormat);
lastStatus = OutOfMemory;
}
return result;
} else {
return NULL;
}
}
StringAlignment GetAlignment() const
{
StringAlignment result = StringAlignmentNear;
updateStatus(DllExports::GdipGetStringFormatAlign(
nativeStringFormat, &result));
return result;
}
LANGID GetDigitSubstitutionLanguage() const
{
LANGID result = 0;
StringDigitSubstitute method;
updateStatus(DllExports::GdipGetStringFormatDigitSubstitution(
nativeStringFormat, &result, &method));
return result;
}
StringDigitSubstitute GetDigitSubstitutionMethod() const
{
LANGID language;
StringDigitSubstitute result = StringDigitSubstituteUser;
updateStatus(DllExports::GdipGetStringFormatDigitSubstitution(
nativeStringFormat, &language, &result));
return result;
}
INT GetFormatFlags() const
{
INT result = 0;
updateStatus(DllExports::GdipGetStringFormatFlags(
nativeStringFormat, &result));
return result;
}
HotkeyPrefix GetHotkeyPrefix() const
{
HotkeyPrefix result = HotkeyPrefixNone;
updateStatus(DllExports::GdipGetStringFormatHotkeyPrefix(
nativeStringFormat, (INT*) &result));
return result;
}
Status GetLastStatus() const
{
Status result = lastStatus;
lastStatus = Ok;
return result;
}
StringAlignment GetLineAlignment() const
{
StringAlignment result = StringAlignmentNear;
updateStatus(DllExports::GdipGetStringFormatLineAlign(
nativeStringFormat, &result));
return result;
}
INT GetMeasurableCharacterRangeCount() const
{
INT result = 0;
updateStatus(DllExports::GdipGetStringFormatMeasurableCharacterRangeCount(
nativeStringFormat, &result));
return result;
}
INT GetTabStopCount() const
{
INT result = 0;
updateStatus(DllExports::GdipGetStringFormatTabStopCount(
nativeStringFormat, &result));
return result;
}
Status GetTabStops(INT count, REAL *firstTabOffset, REAL *tabStops)
{
return updateStatus(DllExports::GdipGetStringFormatTabStops(
nativeStringFormat, count,
firstTabOffset, tabStops));
}
StringTrimming GetTrimming() const
{
StringTrimming result = StringTrimmingNone;
updateStatus(DllExports::GdipGetStringFormatTrimming(
nativeStringFormat, &result));
return result;
}
Status SetAlignment(StringAlignment align)
{
return updateStatus(DllExports::GdipSetStringFormatAlign(
nativeStringFormat, align));
}
Status SetDigitSubstitution(LANGID language,
StringDigitSubstitute substitute)
{
return updateStatus(DllExports::GdipSetStringFormatDigitSubstitution(
nativeStringFormat, language, substitute));
}
Status SetFormatFlags(INT flags)
{
return updateStatus(DllExports::GdipSetStringFormatFlags(
nativeStringFormat, flags));
}
Status SetHotkeyPrefix(HotkeyPrefix hotkeyPrefix)
{
return updateStatus(DllExports::GdipSetStringFormatHotkeyPrefix(
nativeStringFormat, (INT) hotkeyPrefix));
}
Status SetLineAlignment(StringAlignment align)
{
return updateStatus(DllExports::GdipSetStringFormatLineAlign(
nativeStringFormat, align));
}
Status SetMeasurableCharacterRanges(INT rangeCount,
const CharacterRange *ranges)
{
return updateStatus(DllExports::GdipSetStringFormatMeasurableCharacterRanges(
nativeStringFormat, rangeCount, ranges));
}
Status SetTabStops(REAL firstTabOffset, INT count, const REAL *tabStops)
{
return updateStatus(DllExports::GdipSetStringFormatTabStops(
nativeStringFormat, firstTabOffset,
count, tabStops));
}
Status SetTrimming(StringTrimming trimming)
{
return updateStatus(DllExports::GdipSetStringFormatTrimming(
nativeStringFormat, trimming));
}
private:
StringFormat(GpStringFormat *stringFormat, Status status):
nativeStringFormat(stringFormat), lastStatus(status) {}
StringFormat(const StringFormat&);
StringFormat& operator=(const StringFormat&);
Status updateStatus(Status newStatus) const
{
if (newStatus != Ok) lastStatus = newStatus;
return newStatus;
}
GpStringFormat *nativeStringFormat;
mutable Status lastStatus;
};
// FIXME: do StringFormat::GenericDefault() et al. need to be thread safe?
// FIXME: maybe put this in gdiplus.c?
extern "C" void *_GdipStringFormatCachedGenericDefault;
extern "C" void *_GdipStringFormatCachedGenericTypographic;
__inline__ const StringFormat* StringFormat::GenericDefault()
{
if (!_GdipStringFormatCachedGenericDefault) {
GpStringFormat *nativeStringFormat = 0;
Status status = DllExports::GdipStringFormatGetGenericDefault(
&nativeStringFormat);
if (status == Ok && nativeStringFormat) {
_GdipStringFormatCachedGenericDefault = (void*)
new StringFormat(nativeStringFormat, Ok);
}
}
return (StringFormat*) _GdipStringFormatCachedGenericDefault;
}
__inline__ const StringFormat* StringFormat::GenericTypographic()
{
if (!_GdipStringFormatCachedGenericTypographic) {
GpStringFormat *nativeStringFormat = 0;
Status status = DllExports::GdipStringFormatGetGenericTypographic(
&nativeStringFormat);
if (status == Ok && nativeStringFormat) {
_GdipStringFormatCachedGenericTypographic = (void*)
new StringFormat(nativeStringFormat, Ok);
}
}
return (StringFormat*) _GdipStringFormatCachedGenericTypographic;
}
#endif /* __GDIPLUS_STRINGFORMAT_H */

456
winsup/w32api/include/gdiplus/gdiplustypes.h Executable file
View File

@ -0,0 +1,456 @@
/*
* gdiplustypes.h
*
* GDI+ basic type declarations
*
* This file is part of the w32api package.
*
* Contributors:
* Created by Markus Koenig <markus@stber-koenig.de>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#ifndef __GDIPLUS_TYPES_H
#define __GDIPLUS_TYPES_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#define WINGDIPAPI __stdcall
#define GDIPCONST const
typedef enum GpStatus {
Ok = 0,
GenericError = 1,
InvalidParameter = 2,
OutOfMemory = 3,
ObjectBusy = 4,
InsufficientBuffer = 5,
NotImplemented = 6,
Win32Error = 7,
WrongState = 8,
Aborted = 9,
FileNotFound = 10,
ValueOverflow = 11,
AccessDenied = 12,
UnknownImageFormat = 13,
FontFamilyNotFound = 14,
FontStyleNotFound = 15,
NotTrueTypeFont = 16,
UnsupportedGdiplusVersion = 17,
GdiplusNotInitialized = 18,
PropertyNotFound = 19,
PropertyNotSupported = 20,
ProfileNotFound = 21
} GpStatus;
#ifdef __cplusplus
typedef GpStatus Status;
#endif
typedef struct Size {
INT Width;
INT Height;
#ifdef __cplusplus
Size(): Width(0), Height(0) {}
Size(INT width, INT height): Width(width), Height(height) {}
Size(const Size& size): Width(size.Width), Height(size.Height) {}
BOOL Empty() const {
return Width == 0 && Height == 0;
}
BOOL Equals(const Size& size) const {
return Width == size.Width && Height == size.Height;
}
Size operator+(const Size& size) const {
return Size(Width + size.Width, Height + size.Height);
}
Size operator-(const Size& size) const {
return Size(Width - size.Width, Height - size.Height);
}
#endif /* __cplusplus */
} Size;
typedef struct SizeF {
REAL Width;
REAL Height;
#ifdef __cplusplus
SizeF(): Width(0.0f), Height(0.0f) {}
SizeF(REAL width, REAL height): Width(width), Height(height) {}
SizeF(const SizeF& size): Width(size.Width), Height(size.Height) {}
BOOL Empty() const {
return Width == 0.0f && Height == 0.0f;
}
BOOL Equals(const SizeF& size) const {
return Width == size.Width && Height == size.Height;
}
SizeF operator+(const SizeF& size) const {
return SizeF(Width + size.Width, Height + size.Height);
}
SizeF operator-(const SizeF& size) const {
return SizeF(Width - size.Width, Height - size.Height);
}
#endif /* __cplusplus */
} SizeF;
typedef struct Point {
INT X;
INT Y;
#ifdef __cplusplus
Point(): X(0), Y(0) {}
Point(INT x, INT y): X(x), Y(y) {}
Point(const Point& point): X(point.X), Y(point.Y) {}
Point(const Size& size): X(size.Width), Y(size.Height) {}
BOOL Equals(const Point& point) const {
return X == point.X && Y == point.Y;
}
Point operator+(const Point& point) const {
return Point(X + point.X, Y + point.Y);
}
Point operator-(const Point& point) const {
return Point(X - point.X, Y - point.Y);
}
#endif /* __cplusplus */
} Point;
typedef struct PointF {
REAL X;
REAL Y;
#ifdef __cplusplus
PointF(): X(0.0f), Y(0.0f) {}
PointF(REAL x, REAL y): X(x), Y(y) {}
PointF(const PointF& point): X(point.X), Y(point.Y) {}
PointF(const SizeF& size): X(size.Width), Y(size.Height) {}
BOOL Equals(const PointF& point) const {
return X == point.X && Y == point.Y;
}
PointF operator+(const PointF& point) const {
return PointF(X + point.X, Y + point.Y);
}
PointF operator-(const PointF& point) const {
return PointF(X - point.X, Y - point.Y);
}
#endif /* __cplusplus */
} PointF;
typedef struct Rect {
INT X;
INT Y;
INT Width;
INT Height;
#ifdef __cplusplus
Rect(): X(0), Y(0), Width(0), Height(0) {}
Rect(const Point& location, const Size& size):
X(location.X), Y(location.Y),
Width(size.Width), Height(size.Height) {}
Rect(INT x, INT y, INT width, INT height):
X(x), Y(y), Width(width), Height(height) {}
Rect* Clone() const {
return new Rect(X, Y, Width, Height);
}
BOOL Contains(INT x, INT y) const {
return X <= x && Y <= y && x < X+Width && y < Y+Height;
}
BOOL Contains(const Point& point) const {
return Contains(point.X, point.Y);
}
BOOL Contains(const Rect& rect) const {
return X <= rect.X && Y <= rect.Y
&& rect.X+rect.Width <= X+Width
&& rect.Y+rect.Height <= Y+Height;
}
BOOL Equals(const Rect& rect) const {
return X == rect.X && Y == rect.Y
&& Width == rect.Width && Height == rect.Height;
}
INT GetBottom() const {
return Y+Height;
}
VOID GetBounds(Rect *rect) const {
if (rect != NULL) {
rect->X = X;
rect->Y = Y;
rect->Width = Width;
rect->Height = Height;
}
}
INT GetLeft() const {
return X;
}
VOID GetLocation(Point *point) const {
if (point != NULL) {
point->X = X;
point->Y = Y;
}
}
INT GetRight() const {
return X+Width;
}
VOID GetSize(Size *size) const {
if (size != NULL) {
size->Width = Width;
size->Height = Height;
}
}
INT GetTop() const {
return Y;
}
BOOL IsEmptyArea() const {
return Width <= 0 || Height <= 0;
}
VOID Inflate(INT dx, INT dy) {
X -= dx;
Y -= dy;
Width += 2*dx;
Height += 2*dy;
}
VOID Inflate(const Point& point) {
Inflate(point.X, point.Y);
}
static BOOL Intersect(Rect& c, const Rect& a, const Rect& b) {
INT intersectLeft = (a.X < b.X) ? b.X : a.X;
INT intersectTop = (a.Y < b.Y) ? b.Y : a.Y;
INT intersectRight = (a.GetRight() < b.GetRight())
? a.GetRight() : b.GetRight();
INT intersectBottom = (a.GetBottom() < b.GetBottom())
? a.GetBottom() : b.GetBottom();
c.X = intersectLeft;
c.Y = intersectTop;
c.Width = intersectRight - intersectLeft;
c.Height = intersectBottom - intersectTop;
return !c.IsEmptyArea();
}
BOOL Intersect(const Rect& rect) {
return Intersect(*this, *this, rect);
}
BOOL IntersectsWith(const Rect& rc) const {
INT intersectLeft = (X < rc.X) ? rc.X : X;
INT intersectTop = (Y < rc.Y) ? rc.Y : Y;
INT intersectRight = (GetRight() < rc.GetRight())
? GetRight() : rc.GetRight();
INT intersectBottom = (GetBottom() < rc.GetBottom())
? GetBottom() : rc.GetBottom();
return intersectLeft < intersectRight
&& intersectTop < intersectBottom;
}
VOID Offset(INT dx, INT dy) {
X += dx;
Y += dy;
}
VOID Offset(const Point& point) {
Offset(point.X, point.Y);
}
static BOOL Union(Rect& c, const Rect& a, const Rect& b) {
INT unionLeft = (a.X < b.X) ? a.X : b.X;
INT unionTop = (a.Y < b.Y) ? a.Y : b.Y;
INT unionRight = (a.GetRight() < b.GetRight())
? b.GetRight() : a.GetRight();
INT unionBottom = (a.GetBottom() < b.GetBottom())
? b.GetBottom() : a.GetBottom();
c.X = unionLeft;
c.Y = unionTop;
c.Width = unionRight - unionLeft;
c.Height = unionBottom - unionTop;
return !c.IsEmptyArea();
}
#endif /* __cplusplus */
} Rect;
typedef struct RectF {
REAL X;
REAL Y;
REAL Width;
REAL Height;
#ifdef __cplusplus
RectF(): X(0.0f), Y(0.0f), Width(0.0f), Height(0.0f) {}
RectF(const PointF& location, const SizeF& size):
X(location.X), Y(location.Y),
Width(size.Width), Height(size.Height) {}
RectF(REAL x, REAL y, REAL width, REAL height):
X(x), Y(y), Width(width), Height(height) {}
RectF* Clone() const {
return new RectF(X, Y, Width, Height);
}
BOOL Contains(REAL x, REAL y) const {
return X <= x && Y <= y && x < X+Width && y < Y+Height;
}
BOOL Contains(const PointF& point) const {
return Contains(point.X, point.Y);
}
BOOL Contains(const RectF& rect) const {
return X <= rect.X && Y <= rect.Y
&& rect.X+rect.Width <= X+Width
&& rect.Y+rect.Height <= Y+Height;
}
BOOL Equals(const RectF& rect) const {
return X == rect.X && Y == rect.Y
&& Width == rect.Width && Height == rect.Height;
}
REAL GetBottom() const {
return Y+Height;
}
VOID GetBounds(RectF *rect) const {
if (rect != NULL) {
rect->X = X;
rect->Y = Y;
rect->Width = Width;
rect->Height = Height;
}
}
REAL GetLeft() const {
return X;
}
VOID GetLocation(PointF *point) const {
if (point != NULL) {
point->X = X;
point->Y = Y;
}
}
REAL GetRight() const {
return X+Width;
}
VOID GetSize(SizeF *size) const {
if (size != NULL) {
size->Width = Width;
size->Height = Height;
}
}
REAL GetTop() const {
return Y;
}
BOOL IsEmptyArea() const {
return Width <= 0.0f || Height <= 0.0f;
}
VOID Inflate(REAL dx, REAL dy) {
X -= dx;
Y -= dy;
Width += 2*dx;
Height += 2*dy;
}
VOID Inflate(const PointF& point) {
Inflate(point.X, point.Y);
}
static BOOL Intersect(RectF& c, const RectF& a, const RectF& b) {
INT intersectLeft = (a.X < b.X) ? b.X : a.X;
INT intersectTop = (a.Y < b.Y) ? b.Y : a.Y;
INT intersectRight = (a.GetRight() < b.GetRight())
? a.GetRight() : b.GetRight();
INT intersectBottom = (a.GetBottom() < b.GetBottom())
? a.GetBottom() : b.GetBottom();
c.X = intersectLeft;
c.Y = intersectTop;
c.Width = intersectRight - intersectLeft;
c.Height = intersectBottom - intersectTop;
return !c.IsEmptyArea();
}
BOOL Intersect(const RectF& rect) {
return Intersect(*this, *this, rect);
}
BOOL IntersectsWith(const RectF& rc) const {
INT intersectLeft = (X < rc.X) ? rc.X : X;
INT intersectTop = (Y < rc.Y) ? rc.Y : Y;
INT intersectRight = (GetRight() < rc.GetRight())
? GetRight() : rc.GetRight();
INT intersectBottom = (GetBottom() < rc.GetBottom())
? GetBottom() : rc.GetBottom();
return intersectLeft < intersectRight
&& intersectTop < intersectBottom;
}
VOID Offset(REAL dx, REAL dy) {
X += dx;
Y += dy;
}
VOID Offset(const PointF& point) {
Offset(point.X, point.Y);
}
static BOOL Union(RectF& c, const RectF& a, const RectF& b) {
INT unionLeft = (a.X < b.X) ? a.X : b.X;
INT unionTop = (a.Y < b.Y) ? a.Y : b.Y;
INT unionRight = (a.GetRight() < b.GetRight())
? b.GetRight() : a.GetRight();
INT unionBottom = (a.GetBottom() < b.GetBottom())
? b.GetBottom() : a.GetBottom();
c.X = unionLeft;
c.Y = unionTop;
c.Width = unionRight - unionLeft;
c.Height = unionBottom - unionTop;
return !c.IsEmptyArea();
}
#endif /* __cplusplus */
} RectF;
/* FIXME: Are descendants of this class, when compiled with g++,
binary compatible with MSVC++ code (especially GDIPLUS.DLL of course)? */
#ifdef __cplusplus
struct GdiplusAbort {
virtual HRESULT __stdcall Abort(void) {}
};
#else
typedef struct GdiplusAbort GdiplusAbort; /* incomplete type */
#endif
typedef struct CharacterRange {
INT First;
INT Length;
#ifdef __cplusplus
CharacterRange(): First(0), Length(0) {}
CharacterRange(INT first, INT length): First(first), Length(length) {}
CharacterRange& operator=(const CharacterRange& rhs) {
/* This gracefully handles self-assignment */
First = rhs.First;
Length = rhs.Length;
return *this;
}
#endif /* __cplusplus */
} CharacterRange;
typedef struct PathData {
INT Count;
PointF *Points;
BYTE *Types;
#ifdef __cplusplus
friend class GraphicsPath;
PathData(): Count(0), Points(NULL), Types(NULL) {}
~PathData() {
FreeArrays();
}
private:
/* used by GraphicsPath::GetPathData, defined in gdipluspath.h */
Status AllocateArrays(INT capacity);
VOID FreeArrays();
#endif /* __cplusplus */
} PathData;
/* Callback function types */
/* FIXME: need a correct definition for these function pointer types */
typedef void *DebugEventProc;
typedef BOOL CALLBACK (*EnumerateMetafileProc)(EmfPlusRecordType,UINT,UINT,const BYTE*,VOID*);
typedef void *DrawImageAbort;
typedef void *GetThumbnailImageAbort;
#endif /* __GDIPLUS_TYPES_H */

9
winsup/w32api/lib/Makefile.in
View File

@ -112,6 +112,7 @@ FLAGS_TO_PASS = \
HEADERS = $(notdir $(wildcard $(srcdir)/../include/*.h))
GL_HEADERS = $(notdir $(wildcard $(srcdir)/../include/GL/*.h))
GDIPLUS_HEADERS = $(notdir $(wildcard $(srcdir)/../include/gdiplus/*.h))
# libraries
@ -127,7 +128,7 @@ UUID_OBJS = mshtml-uuid.o msxml-uuid.o unknwn-uuid.o \
exdisp-uuid.o mlang-uuid.o objidl-uuid.o cguid-uuid.o \
olectlid-uuid.o ativscp-uuid.o urlmon-uuid.o hlink-uuid.o \
hlguids-uuid.o extras-uuid.o devguid.o power-uuid.o
EXTRA_OBJS = shell32.o scrnsave.o scrnsavw.o largeint.o \
EXTRA_OBJS = shell32.o scrnsave.o scrnsavw.o largeint.o gdiplus.o \
$(UUID_OBJS) ws2_32.o
UUID_SOURCES = mshtml-uuid.c msxml-uuid.c unknwn-uuid.c \
servprov-uuid.c oleidl-uuid.c oleacc-uuid.c ocidl-uuid.c \
@ -135,7 +136,7 @@ UUID_SOURCES = mshtml-uuid.c msxml-uuid.c unknwn-uuid.c \
exdisp-uuid.c mlang-uuid.c objidl-uuid.c cguid-uuid.c \
olectlid-uuid.c ativscp-uuid.c urlmon-uuid.c hlink-uuid.c \
hlguids-uuid.c extras-uuid.c devguid.c power-uuid.c
SOURCES = scrnsave.c shell32.c largeint.c $(UUID_SOURCES)\
SOURCES = scrnsave.c shell32.c largeint.c gdiplus.c $(UUID_SOURCES) \
res.rc test.c ws2_32.c
DISTFILES = Makefile.in $(DEF_FILES) $(MRI_FILES) $(SOURCES)
@ -239,6 +240,10 @@ install-headers: $(need-DESTDIR-compatibility)
for i in $(GL_HEADERS); do \
$(INSTALL_DATA) $(srcdir)/../include/GL/$$i $(DESTDIR)$(inst_includedir)/GL/$$i ; \
done
$(mkinstalldirs) $(DESTDIR)$(inst_includedir)/gdiplus
for i in $(GDIPLUS_HEADERS); do \
$(INSTALL_DATA) $(srcdir)/../include/gdiplus/$$i $(DESTDIR)$(inst_includedir)/gdiplus/$$i ; \
done
install-ddk: install-libraries install-headers
cd ddk && $(MAKE) install $(FLAGS_TO_PASS)

67
winsup/w32api/lib/gdiplus.c Executable file
View File

@ -0,0 +1,67 @@
/*
* Generate GUIDs for GDI+
*
* The Image Format GUIDs were generated by loading example images of
* various types with GdipLoadImageFromFile and then extracting the
* image format with GdipGetImageRawFormat.
*
* The Encoder Parameter GUIDs were taken from this .NET MSDN page:
* http://msdn.microsoft.com/en-us/library/system.drawing.imaging.encoder.quality.aspx
*
* The Frame Dimension GUIDs were generated by loading example multi-frame
* images (multi-page TIFF; animated GIF) and querying the frame dimension list
* using GdipImageGetFrameDimensionsList.
*/
/* TODO: find the remaining GUIDs */
#define INITGUID
#include <basetyps.h>
void *_GdipFontFamilyCachedGenericMonospace = 0;
void *_GdipFontFamilyCachedGenericSansSerif = 0;
void *_GdipFontFamilyCachedGenericSerif = 0;
void *_GdipStringFormatCachedGenericDefault = 0;
void *_GdipStringFormatCachedGenericTypographic = 0;
DEFINE_GUID(EncoderChrominanceTable,0xF2E455DC,0x09B3,0x4316,0x82,0x60,0x67,0x6A,0xDA,0x32,0x48,0x1C);
DEFINE_GUID(EncoderColorDepth,0x66087055,0xAD66,0x4C7C,0x9A,0x18,0x38,0xA2,0x31,0x0B,0x83,0x37);
/* EncoderColorSpace missing */
DEFINE_GUID(EncoderCompression,0xE09D739D,0xCCD4,0x44EE,0x8E,0xBA,0x3F,0xBF,0x8B,0xE4,0xFC,0x58);
/* EncoderImageItems missing */
DEFINE_GUID(EncoderLuminanceTable,0xEDB33BCE,0x0266,0x4A77,0xB9,0x04,0x27,0x21,0x60,0x99,0xE7,0x17);
DEFINE_GUID(EncoderQuality,0x1D5BE4B5,0xFA4A,0x452D,0x9C,0xDD,0x5D,0xB3,0x51,0x05,0xE7,0xEB);
DEFINE_GUID(EncoderRenderMethod,0x6D42C53A,0x229A,0x4825,0x8B,0xB7,0x5C,0x99,0xE2,0xB9,0xA8,0xB8);
/* EncoderSaveAsCMYK missing */
DEFINE_GUID(EncoderSaveFlag,0x292266FC,0xAC40,0x47BF,0x8C,0xFC,0xA8,0x5B,0x89,0xA6,0x55,0xDE);
DEFINE_GUID(EncoderScanMethod,0x3A4E2661,0x3109,0x4E56,0x85,0x36,0x42,0xC1,0x56,0xE7,0xDC,0xFA);
DEFINE_GUID(EncoderTransformation,0x8D0EB2D1,0xA58E,0x4EA8,0xAA,0x14,0x10,0x80,0x74,0xB7,0xB6,0xF9);
DEFINE_GUID(EncoderVersion,0x24D18C76,0x814A,0x41A4,0xBF,0x53,0x1C,0x21,0x9C,0xCC,0xF7,0x97);
DEFINE_GUID(ImageFormatBMP,0xB96B3CAB,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
DEFINE_GUID(ImageFormatEMF,0xB96B3CAC,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
/* ImageFormatEXIF missing */
DEFINE_GUID(ImageFormatGIF,0xB96B3CB0,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
DEFINE_GUID(ImageFormatIcon,0xB96B3CB5,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
DEFINE_GUID(ImageFormatJPEG,0xB96B3CAE,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
DEFINE_GUID(ImageFormatMemoryBMP,0xB96B3CAA,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
DEFINE_GUID(ImageFormatPNG,0xB96B3CAF,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
DEFINE_GUID(ImageFormatTIFF,0xB96B3CB1,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
/* ImageFormatUndefined missing */
DEFINE_GUID(ImageFormatWMF,0xB96B3CAD,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
DEFINE_GUID(FrameDimensionPage,0x7462DC86,0x6180,0x4C7E,0x8E,0x3F,0xEE,0x73,0x33,0xA7,0xA4,0x83);
/* FrameDimensionResolution missing */
DEFINE_GUID(FrameDimensionTime,0x6AEDBD6D,0x3FB5,0x418A,0x83,0xA6,0x7F,0x45,0x22,0x9D,0xC8,0x72);
/* BlurEffectGuid missing */
/* BrightnessContrastEffectGuid missing */
/* ColorBalanceEffectGuid missing */
/* ColorCurveEffectGuid missing */
/* ColorLUTEffectGuid missing */
/* ColorMatrixEffectGuid missing */
/* HueSaturationLightnessEffectGuid missing */
/* LevelsEffectGuid missing */
/* RedEyeCorrectionEffectGuid missing */
/* SharpenEffectGuid missing */
/* TintEffectGuid missing */

633
winsup/w32api/lib/gdiplus.def Executable file
View File

@ -0,0 +1,633 @@
LIBRARY GDIPLUS.DLL
EXPORTS
GdipAddPathArc@28
GdipAddPathArcI@28
GdipAddPathBezier@36
GdipAddPathBezierI@36
GdipAddPathBeziers@12
GdipAddPathBeziersI@12
GdipAddPathClosedCurve@12
GdipAddPathClosedCurve2@16
GdipAddPathClosedCurve2I@16
GdipAddPathClosedCurveI@12
GdipAddPathCurve@12
GdipAddPathCurve2@16
GdipAddPathCurve2I@16
GdipAddPathCurve3@24
GdipAddPathCurve3I@24
GdipAddPathCurveI@12
GdipAddPathEllipse@20
GdipAddPathEllipseI@20
GdipAddPathLine@20
GdipAddPathLine2@12
GdipAddPathLine2I@12
GdipAddPathLineI@20
GdipAddPathPath@12
GdipAddPathPie@28
GdipAddPathPieI@28
GdipAddPathPolygon@12
GdipAddPathPolygonI@12
GdipAddPathRectangle@20
GdipAddPathRectangleI@20
GdipAddPathRectangles@12
GdipAddPathRectanglesI@12
GdipAddPathString@32
GdipAddPathStringI@32
GdipAlloc@4
GdipBeginContainer@20
GdipBeginContainer2@8
GdipBeginContainerI@20
GdipBitmapApplyEffect@24
GdipBitmapConvertFormat@24
GdipBitmapCreateApplyEffect@36
GdipBitmapGetHistogram@28
GdipBitmapGetHistogramSize@8
GdipBitmapGetPixel@16
GdipBitmapLockBits@20
GdipBitmapSetPixel@16
GdipBitmapSetResolution@12
GdipBitmapUnlockBits@8
GdipClearPathMarkers@4
GdipCloneBitmapArea@28
GdipCloneBitmapAreaI@28
GdipCloneBrush@8
GdipCloneCustomLineCap@8
GdipCloneFont@8
GdipCloneFontFamily@8
GdipCloneImage@8
GdipCloneImageAttributes@8
GdipCloneMatrix@8
GdipClonePath@8
GdipClonePen@8
GdipCloneRegion@8
GdipCloneStringFormat@8
GdipClosePathFigure@4
GdipClosePathFigures@4
GdipCombineRegionPath@12
GdipCombineRegionRect@12
GdipCombineRegionRectI@12
GdipCombineRegionRegion@12
GdipComment@12
GdipConvertToEmfPlus@24
GdipConvertToEmfPlusToFile@28
GdipConvertToEmfPlusToStream@28
GdipCreateAdjustableArrowCap@16
GdipCreateBitmapFromDirectDrawSurface@8
GdipCreateBitmapFromFile@8
GdipCreateBitmapFromFileICM@8
GdipCreateBitmapFromGdiDib@12
GdipCreateBitmapFromGraphics@16
GdipCreateBitmapFromHBITMAP@12
GdipCreateBitmapFromHICON@8
GdipCreateBitmapFromResource@12
GdipCreateBitmapFromScan0@24
GdipCreateBitmapFromStream@8
GdipCreateBitmapFromStreamICM@8
GdipCreateCachedBitmap@12
GdipCreateCustomLineCap@20
GdipCreateEffect@20
GdipCreateFont@20
GdipCreateFontFamilyFromName@12
GdipCreateFontFromDC@8
GdipCreateFontFromLogfontA@12
GdipCreateFontFromLogfontW@12
GdipCreateFromHDC@8
GdipCreateFromHDC2@12
GdipCreateFromHWND@8
GdipCreateFromHWNDICM@8
GdipCreateHBITMAPFromBitmap@12
GdipCreateHICONFromBitmap@8
GdipCreateHalftonePalette@
GdipCreateHatchBrush@16
GdipCreateImageAttributes@4
GdipCreateLineBrush@24
GdipCreateLineBrushFromRect@24
GdipCreateLineBrushFromRectI@24
GdipCreateLineBrushFromRectWithAngle@28
GdipCreateLineBrushFromRectWithAngleI@28
GdipCreateLineBrushI@24
GdipCreateMatrix@4
GdipCreateMatrix2@28
GdipCreateMatrix3@12
GdipCreateMatrix3I@12
GdipCreateMetafileFromEmf@12
GdipCreateMetafileFromFile@8
GdipCreateMetafileFromStream@8
GdipCreateMetafileFromWmf@16
GdipCreateMetafileFromWmfFile@12
GdipCreatePath@8
GdipCreatePath2@20
GdipCreatePath2I@20
GdipCreatePathGradient@16
GdipCreatePathGradientFromPath@8
GdipCreatePathGradientI@16
GdipCreatePathIter@8
GdipCreatePen1@16
GdipCreatePen2@16
GdipCreateRegion@4
GdipCreateRegionHrgn@8
GdipCreateRegionPath@8
GdipCreateRegionRect@8
GdipCreateRegionRectI@8
GdipCreateRegionRgnData@12
GdipCreateSolidFill@8
GdipCreateStreamOnFile@12
GdipCreateStringFormat@12
GdipCreateTexture@12
GdipCreateTexture2@28
GdipCreateTexture2I@28
GdipCreateTextureIA@28
GdipCreateTextureIAI@28
GdipDeleteBrush@4
GdipDeleteCachedBitmap@4
GdipDeleteCustomLineCap@4
GdipDeleteEffect@4
GdipDeleteFont@4
GdipDeleteFontFamily@4
GdipDeleteGraphics@4
GdipDeleteMatrix@4
GdipDeletePath@4
GdipDeletePathIter@4
GdipDeletePen@4
GdipDeletePrivateFontCollection@4
GdipDeleteRegion@4
GdipDeleteStringFormat@4
GdipDisposeImage@4
GdipDisposeImageAttributes@4
GdipDrawArc@32
GdipDrawArcI@32
GdipDrawBezier@40
GdipDrawBezierI@40
GdipDrawBeziers@16
GdipDrawBeziersI@16
GdipDrawCachedBitmap@16
GdipDrawClosedCurve@16
GdipDrawClosedCurve2@20
GdipDrawClosedCurve2I@20
GdipDrawClosedCurveI@16
GdipDrawCurve@16
GdipDrawCurve2@20
GdipDrawCurve2I@20
GdipDrawCurve3@28
GdipDrawCurve3I@28
GdipDrawCurveI@16
GdipDrawDriverString@32
GdipDrawEllipse@24
GdipDrawEllipseI@24
GdipDrawImage@16
GdipDrawImageFX@28
GdipDrawImageI@16
GdipDrawImagePointRect@36
GdipDrawImagePointRectI@36
GdipDrawImagePoints@16
GdipDrawImagePointsI@16
GdipDrawImagePointsRect@48
GdipDrawImagePointsRectI@48
GdipDrawImageRect@24
GdipDrawImageRectI@24
GdipDrawImageRectRect@56
GdipDrawImageRectRectI@56
GdipDrawLine@24
GdipDrawLineI@24
GdipDrawLines@16
GdipDrawLinesI@16
GdipDrawPath@12
GdipDrawPie@32
GdipDrawPieI@32
GdipDrawPolygon@16
GdipDrawPolygonI@16
GdipDrawRectangle@24
GdipDrawRectangleI@24
GdipDrawRectangles@16
GdipDrawRectanglesI@16
GdipDrawString@28
GdipEmfToWmfBits@20
GdipEndContainer@8
GdipEnumerateMetafileDestPoint@24
GdipEnumerateMetafileDestPointI@24
GdipEnumerateMetafileDestPoints@28
GdipEnumerateMetafileDestPointsI@28
GdipEnumerateMetafileDestRect@24
GdipEnumerateMetafileDestRectI@24
GdipEnumerateMetafileSrcRectDestPoint@32
GdipEnumerateMetafileSrcRectDestPointI@32
GdipEnumerateMetafileSrcRectDestPoints@36
GdipEnumerateMetafileSrcRectDestPointsI@36
GdipEnumerateMetafileSrcRectDestRect@32
GdipEnumerateMetafileSrcRectDestRectI@32
GdipFillClosedCurve@16
GdipFillClosedCurve2@24
GdipFillClosedCurve2I@24
GdipFillClosedCurveI@16
GdipFillEllipse@24
GdipFillEllipseI@24
GdipFillPath@12
GdipFillPie@32
GdipFillPieI@32
GdipFillPolygon@20
GdipFillPolygon2@16
GdipFillPolygon2I@16
GdipFillPolygonI@20
GdipFillRectangle@24
GdipFillRectangleI@24
GdipFillRectangles@16
GdipFillRectanglesI@16
GdipFillRegion@12
GdipFindFirstImageItem@8
GdipFindNextImageItem@8
GdipFlattenPath@12
GdipFlush@8
GdipFontCollectionEnumerable@12
GdipFontCollectionEnumerate@20
GdipFree@4
GdipGetAdjustableArrowCapFillState@8
GdipGetAdjustableArrowCapHeight@8
GdipGetAdjustableArrowCapMiddleInset@8
GdipGetAdjustableArrowCapWidth@8
GdipGetAllPropertyItems@16
GdipGetBrushType@8
GdipGetCellAscent@12
GdipGetCellDescent@12
GdipGetClip@8
GdipGetClipBounds@8
GdipGetClipBoundsI@8
GdipGetCompositingMode@8
GdipGetCompositingQuality@8
GdipGetCustomLineCapBaseCap@8
GdipGetCustomLineCapBaseInset@8
GdipGetCustomLineCapStrokeCaps@12
GdipGetCustomLineCapStrokeJoin@8
GdipGetCustomLineCapType@8
GdipGetCustomLineCapWidthScale@8
GdipGetDC@8
GdipGetDpiX@8
GdipGetDpiY@8
GdipGetEffectParameterSize@8
GdipGetEffectParameters@12
GdipGetEmHeight@12
GdipGetEncoderParameterList@16
GdipGetEncoderParameterListSize@12
GdipGetFamily@8
GdipGetFamilyName@12
GdipGetFontCollectionFamilyCount@8
GdipGetFontCollectionFamilyList@16
GdipGetFontHeight@12
GdipGetFontHeightGivenDPI@12
GdipGetFontSize@8
GdipGetFontStyle@8
GdipGetFontUnit@8
GdipGetGenericFontFamilyMonospace@4
GdipGetGenericFontFamilySansSerif@4
GdipGetGenericFontFamilySerif@4
GdipGetHatchBackgroundColor@8
GdipGetHatchForegroundColor@8
GdipGetHatchStyle@8
GdipGetHemfFromMetafile@8
GdipGetImageAttributesAdjustedPalette@12
GdipGetImageBounds@12
GdipGetImageDecoders@12
GdipGetImageDecodersSize@8
GdipGetImageDimension@12
GdipGetImageEncoders@12
GdipGetImageEncodersSize@8
GdipGetImageFlags@8
GdipGetImageGraphicsContext@8
GdipGetImageHeight@8
GdipGetImageHorizontalResolution@8
GdipGetImageItemData@8
GdipGetImagePalette@12
GdipGetImagePaletteSize@8
GdipGetImagePixelFormat@8
GdipGetImageRawFormat@8
GdipGetImageThumbnail@24
GdipGetImageType@8
GdipGetImageVerticalResolution@8
GdipGetImageWidth@8
GdipGetInterpolationMode@8
GdipGetLineBlend@16
GdipGetLineBlendCount@8
GdipGetLineColors@8
GdipGetLineGammaCorrection@8
GdipGetLinePresetBlend@16
GdipGetLinePresetBlendCount@8
GdipGetLineRect@8
GdipGetLineRectI@8
GdipGetLineSpacing@12
GdipGetLineTransform@8
GdipGetLineWrapMode@8
GdipGetLogFontA@12
GdipGetLogFontW@12
GdipGetMatrixElements@8
GdipGetMetafileDownLevelRasterizationLimit@8
GdipGetMetafileHeaderFromEmf@8
GdipGetMetafileHeaderFromFile@8
GdipGetMetafileHeaderFromMetafile@8
GdipGetMetafileHeaderFromStream@8
GdipGetNearestColor@8
GdipGetPageScale@8
GdipGetPageUnit@8
GdipGetPathData@8
GdipGetPathFillMode@8
GdipGetPathGradientBlend@16
GdipGetPathGradientBlendCount@8
GdipGetPathGradientCenterColor@8
GdipGetPathGradientCenterPoint@8
GdipGetPathGradientCenterPointI@8
GdipGetPathGradientFocusScales@12
GdipGetPathGradientGammaCorrection@8
GdipGetPathGradientPath@8
GdipGetPathGradientPointCount@8
GdipGetPathGradientPresetBlend@16
GdipGetPathGradientPresetBlendCount@8
GdipGetPathGradientRect@8
GdipGetPathGradientRectI@8
GdipGetPathGradientSurroundColorCount@8
GdipGetPathGradientSurroundColorsWithCount@12
GdipGetPathGradientTransform@8
GdipGetPathGradientWrapMode@8
GdipGetPathLastPoint@8
GdipGetPathPoints@12
GdipGetPathPointsI@12
GdipGetPathTypes@12
GdipGetPathWorldBounds@16
GdipGetPathWorldBoundsI@16
GdipGetPenBrushFill@8
GdipGetPenColor@8
GdipGetPenCompoundArray@12
GdipGetPenCompoundCount@8
GdipGetPenCustomEndCap@8
GdipGetPenCustomStartCap@8
GdipGetPenDashArray@12
GdipGetPenDashCap197819@8
GdipGetPenDashCount@8
GdipGetPenDashOffset@8
GdipGetPenDashStyle@8
GdipGetPenEndCap@8
GdipGetPenFillType@8
GdipGetPenLineJoin@8
GdipGetPenMiterLimit@8
GdipGetPenMode@8
GdipGetPenStartCap@8
GdipGetPenTransform@8
GdipGetPenUnit@8
GdipGetPenWidth@8
GdipGetPixelOffsetMode@8
GdipGetPointCount@8
GdipGetPropertyCount@8
GdipGetPropertyIdList@12
GdipGetPropertyItem@16
GdipGetPropertyItemSize@12
GdipGetPropertySize@12
GdipGetRegionBounds@12
GdipGetRegionBoundsI@12
GdipGetRegionData@16
GdipGetRegionDataSize@8
GdipGetRegionHRgn@12
GdipGetRegionScans@16
GdipGetRegionScansCount@12
GdipGetRegionScansI@16
GdipGetRenderingOrigin@12
GdipGetSmoothingMode@8
GdipGetSolidFillColor@8
GdipGetStringFormatAlign@8
GdipGetStringFormatDigitSubstitution@12
GdipGetStringFormatFlags@8
GdipGetStringFormatHotkeyPrefix@8
GdipGetStringFormatLineAlign@8
GdipGetStringFormatMeasurableCharacterRangeCount@8
GdipGetStringFormatTabStopCount@8
GdipGetStringFormatTabStops@16
GdipGetStringFormatTrimming@8
GdipGetTextContrast@8
GdipGetTextRenderingHint@8
GdipGetTextureImage@8
GdipGetTextureTransform@8
GdipGetTextureWrapMode@8
GdipGetVisibleClipBounds@8
GdipGetVisibleClipBoundsI@8
GdipGetWorldTransform@8
GdipGraphicsClear@8
GdipGraphicsSetAbort@8
GdipImageForceValidation@4
GdipImageGetFrameCount@12
GdipImageGetFrameDimensionsCount@8
GdipImageGetFrameDimensionsList@12
GdipImageRotateFlip@8
GdipImageSelectActiveFrame@12
GdipImageSetAbort@8
GdipInitializePalette@20
GdipInvertMatrix@4
GdipIsClipEmpty@8
GdipIsEmptyRegion@12
GdipIsEqualRegion@16
GdipIsInfiniteRegion@12
GdipIsMatrixEqual@12
GdipIsMatrixIdentity@8
GdipIsMatrixInvertible@8
GdipIsOutlineVisiblePathPoint@24
GdipIsOutlineVisiblePathPointI@24
GdipIsStyleAvailable@12
GdipIsVisibleClipEmpty@8
GdipIsVisiblePathPoint@20
GdipIsVisiblePathPointI@20
GdipIsVisiblePoint@16
GdipIsVisiblePointI@16
GdipIsVisibleRect@24
GdipIsVisibleRectI@24
GdipIsVisibleRegionPoint@20
GdipIsVisibleRegionPointI@20
GdipIsVisibleRegionRect@28
GdipIsVisibleRegionRectI@28
GdipLoadImageFromFile@8
GdipLoadImageFromFileICM@8
GdipLoadImageFromStream@8
GdipLoadImageFromStreamICM@8
GdipMeasureCharacterRanges@32
GdipMeasureDriverString@32
GdipMeasureString@36
GdipMultiplyLineTransform@12
GdipMultiplyMatrix@12
GdipMultiplyPathGradientTransform@12
GdipMultiplyPenTransform@12
GdipMultiplyTextureTransform@12
GdipMultiplyWorldTransform@12
GdipNewInstalledFontCollection@4
GdipNewPrivateFontCollection@4
GdipPathIterCopyData@24
GdipPathIterEnumerate@20
GdipPathIterGetCount@8
GdipPathIterGetSubpathCount@8
GdipPathIterHasCurve@8
GdipPathIterIsValid@8
GdipPathIterNextMarker@16
GdipPathIterNextMarkerPath@12
GdipPathIterNextPathType@20
GdipPathIterNextSubpath@20
GdipPathIterNextSubpathPath@16
GdipPathIterRewind@4
GdipPlayMetafileRecord@20
GdipPrivateAddFontFile@8
GdipPrivateAddMemoryFont@12
GdipRecordMetafile@24
GdipRecordMetafileFileName@28
GdipRecordMetafileFileNameI@28
GdipRecordMetafileI@24
GdipRecordMetafileStream@28
GdipRecordMetafileStreamI@28
GdipReleaseDC@8
GdipRemovePropertyItem@8
GdipResetClip@4
GdipResetImageAttributes@8
GdipResetLineTransform@4
GdipResetPageTransform@4
GdipResetPath@4
GdipResetPathGradientTransform@4
GdipResetPenTransform@4
GdipResetTextureTransform@4
GdipResetWorldTransform@4
GdipRestoreGraphics@8
GdipReversePath@4
GdipRotateLineTransform@12
GdipRotateMatrix@12
GdipRotatePathGradientTransform@12
GdipRotatePenTransform@12
GdipRotateTextureTransform@12
GdipRotateWorldTransform@12
GdipSaveAdd@8
GdipSaveAddImage@12
GdipSaveGraphics@8
GdipSaveImageToFile@16
GdipSaveImageToStream@16
GdipScaleLineTransform@16
GdipScaleMatrix@16
GdipScalePathGradientTransform@16
GdipScalePenTransform@16
GdipScaleTextureTransform@16
GdipScaleWorldTransform@16
GdipSetAdjustableArrowCapFillState@8
GdipSetAdjustableArrowCapHeight@8
GdipSetAdjustableArrowCapMiddleInset@8
GdipSetAdjustableArrowCapWidth@8
GdipSetClipGraphics@12
GdipSetClipHrgn@12
GdipSetClipPath@12
GdipSetClipRect@24
GdipSetClipRectI@24
GdipSetClipRegion@12
GdipSetCompositingMode@8
GdipSetCompositingQuality@8
GdipSetCustomLineCapBaseCap@8
GdipSetCustomLineCapBaseInset@8
GdipSetCustomLineCapStrokeCaps@12
GdipSetCustomLineCapStrokeJoin@8
GdipSetCustomLineCapWidthScale@8
GdipSetEffectParameters@12
GdipSetEmpty@4
GdipSetImageAttributesCachedBackground@8
GdipSetImageAttributesColorKeys@20
GdipSetImageAttributesColorMatrix@24
GdipSetImageAttributesGamma@16
GdipSetImageAttributesICMMode@8
GdipSetImageAttributesNoOp@12
GdipSetImageAttributesOutputChannel@16
GdipSetImageAttributesOutputChannelColorProfile@16
GdipSetImageAttributesRemapTable@20
GdipSetImageAttributesThreshold@16
GdipSetImageAttributesToIdentity@8
GdipSetImageAttributesWrapMode@16
GdipSetImagePalette@8
GdipSetInfinite@4
GdipSetInterpolationMode@8
GdipSetLineBlend@16
GdipSetLineColors@12
GdipSetLineGammaCorrection@8
GdipSetLineLinearBlend@12
GdipSetLinePresetBlend@16
GdipSetLineSigmaBlend@12
GdipSetLineTransform@8
GdipSetLineWrapMode@8
GdipSetMatrixElements@28
GdipSetMetafileDownLevelRasterizationLimit@8
GdipSetPageScale@8
GdipSetPageUnit@8
GdipSetPathFillMode@8
GdipSetPathGradientBlend@16
GdipSetPathGradientCenterColor@8
GdipSetPathGradientCenterPoint@8
GdipSetPathGradientCenterPointI@8
GdipSetPathGradientFocusScales@12
GdipSetPathGradientGammaCorrection@8
GdipSetPathGradientLinearBlend@12
GdipSetPathGradientPath@8
GdipSetPathGradientPresetBlend@16
GdipSetPathGradientSigmaBlend@12
GdipSetPathGradientSurroundColorsWithCount@12
GdipSetPathGradientTransform@8
GdipSetPathGradientWrapMode@8
GdipSetPathMarker@4
GdipSetPenBrushFill@8
GdipSetPenColor@8
GdipSetPenCompoundArray@12
GdipSetPenCustomEndCap@8
GdipSetPenCustomStartCap@8
GdipSetPenDashArray@12
GdipSetPenDashCap197819@8
GdipSetPenDashOffset@8
GdipSetPenDashStyle@8
GdipSetPenEndCap@8
GdipSetPenLineCap197819@16
GdipSetPenLineJoin@8
GdipSetPenMiterLimit@8
GdipSetPenMode@8
GdipSetPenStartCap@8
GdipSetPenTransform@8
GdipSetPenUnit@8
GdipSetPenWidth@8
GdipSetPixelOffsetMode@8
GdipSetPropertyItem@8
GdipSetRenderingOrigin@12
GdipSetSmoothingMode@8
GdipSetSolidFillColor@8
GdipSetStringFormatAlign@8
GdipSetStringFormatDigitSubstitution@12
GdipSetStringFormatFlags@8
GdipSetStringFormatHotkeyPrefix@8
GdipSetStringFormatLineAlign@8
GdipSetStringFormatMeasurableCharacterRanges@12
GdipSetStringFormatTabStops@16
GdipSetStringFormatTrimming@8
GdipSetTextContrast@8
GdipSetTextRenderingHint@8
GdipSetTextureTransform@8
GdipSetTextureWrapMode@8
GdipSetWorldTransform@8
GdipShearMatrix@16
GdipStartPathFigure@4
GdipStringFormatGetGenericDefault@4
GdipStringFormatGetGenericTypographic@4
GdipTestControl@8
GdipTransformMatrixPoints@12
GdipTransformMatrixPointsI@12
GdipTransformPath@8
GdipTransformPoints@20
GdipTransformPointsI@20
GdipTransformRegion@8
GdipTranslateClip@12
GdipTranslateClipI@12
GdipTranslateLineTransform@16
GdipTranslateMatrix@16
GdipTranslatePathGradientTransform@16
GdipTranslatePenTransform@16
GdipTranslateRegion@12
GdipTranslateRegionI@12
GdipTranslateTextureTransform@16
GdipTranslateWorldTransform@16
GdipVectorTransformMatrixPoints@12
GdipVectorTransformMatrixPointsI@12
GdipWarpPath@40
GdipWidenPath@16
GdipWindingModeOutline@12
GdiplusNotificationHook@4
GdiplusNotificationUnhook@4
GdiplusShutdown@4
GdiplusStartup@12

1
winsup/w32api/lib/test.c
View File

@ -28,6 +28,7 @@
#include <mapi.h>
#include <dbt.h>
#include <gdiplus.h>
#include <httpext.h>
#include <icm.h>
#include <imagehlp.h>