diff --git a/winsup/w32api/ChangeLog b/winsup/w32api/ChangeLog index 2145e3c36..31f456468 100644 --- a/winsup/w32api/ChangeLog +++ b/winsup/w32api/ChangeLog @@ -1,3 +1,39 @@ +2010-07-08 Markus Koenig + + * 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 * include/psapi.h (PROCESS_MEMORY_COUNTERS_EX, PERFORMANCE_INFORMATION, diff --git a/winsup/w32api/include/gdiplus.h b/winsup/w32api/include/gdiplus.h new file mode 100755 index 000000000..4b86cfd98 --- /dev/null +++ b/winsup/w32api/include/gdiplus.h @@ -0,0 +1 @@ +#include "gdiplus/gdiplus.h" diff --git a/winsup/w32api/include/gdiplus/gdiplus.h b/winsup/w32api/include/gdiplus/gdiplus.h new file mode 100755 index 000000000..9968e0eee --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplus.h @@ -0,0 +1,81 @@ +/* + * gdiplus.h + * + * GDI+ main header + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 +#include +#include +#include + +#include +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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusbase.h b/winsup/w32api/include/gdiplus/gdiplusbase.h new file mode 100755 index 000000000..71720c531 --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusbase.h @@ -0,0 +1,54 @@ +/* + * gdiplusbase.h + * + * GDI+ base class + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusbrush.h b/winsup/w32api/include/gdiplus/gdiplusbrush.h new file mode 100755 index 000000000..0e0be42e8 --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusbrush.h @@ -0,0 +1,606 @@ +/* + * gdiplusbrush.h + * + * GDI+ brush classes + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdipluscolor.h b/winsup/w32api/include/gdiplus/gdipluscolor.h new file mode 100755 index 000000000..178f3363a --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdipluscolor.h @@ -0,0 +1,262 @@ +/* + * gdipluscolor.h + * + * GDI+ color + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdipluscolormatrix.h b/winsup/w32api/include/gdiplus/gdipluscolormatrix.h new file mode 100755 index 000000000..ef19e2286 --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdipluscolormatrix.h @@ -0,0 +1,67 @@ +/* + * gdipluscolormatrix.h + * + * GDI+ color mappings + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdipluseffects.h b/winsup/w32api/include/gdiplus/gdipluseffects.h new file mode 100755 index 000000000..ddfb9b7f1 --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdipluseffects.h @@ -0,0 +1,116 @@ +/* + * gdipluseffects.h + * + * GDI+ filters and effects + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusenums.h b/winsup/w32api/include/gdiplus/gdiplusenums.h new file mode 100755 index 000000000..d64bba68c --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusenums.h @@ -0,0 +1,755 @@ +/* + * gdiplusenums.h + * + * GDI+ enumerations + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusflat.h b/winsup/w32api/include/gdiplus/gdiplusflat.h new file mode 100755 index 000000000..cda030197 --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusflat.h @@ -0,0 +1,722 @@ +/* + * gdiplusflat.h + * + * GDI+ Flat API + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusgpstubs.h b/winsup/w32api/include/gdiplus/gdiplusgpstubs.h new file mode 100755 index 000000000..0fa3e50bf --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusgpstubs.h @@ -0,0 +1,139 @@ +/* + * gdiplusgpstubs.h + * + * GDI+ Gp* type declarations + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusgraphics.h b/winsup/w32api/include/gdiplus/gdiplusgraphics.h new file mode 100755 index 000000000..5e5b771a1 --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusgraphics.h @@ -0,0 +1,1540 @@ +/* + * gdiplusgraphics.h + * + * GDI+ Graphics class + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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_GRAPHICS_H +#define __GDIPLUS_GRAPHICS_H +#if __GNUC__ >=3 +#pragma GCC system_header +#endif + +#ifndef __cplusplus +#error "A C++ compiler is required to include gdiplusgraphics.h." +#endif + +class Graphics: public GdiplusBase +{ + friend class Bitmap; + friend class CachedBitmap; + friend class Font; + friend class GraphicsPath; + friend class Metafile; + friend class Region; + +public: + static Graphics* FromHDC(HDC hdc) + { + return new Graphics(hdc); + } + static Graphics* FromHDC(HDC hdc, HANDLE hdevice) + { + return new Graphics(hdc, hdevice); + } + static Graphics* FromHWND(HWND hwnd, BOOL icm = FALSE) + { + return new Graphics(hwnd, icm); + } + static Graphics* FromImage(Image *image) + { + return new Graphics(image); + } + static HPALETTE GetHalftonePalette() + { + return DllExports::GdipCreateHalftonePalette(); + } + + Graphics(Image *image): nativeGraphics(NULL), lastStatus(Ok) + { + lastStatus = DllExports::GdipGetImageGraphicsContext( + image ? image->nativeImage : NULL, + &nativeGraphics); + } + Graphics(HDC hdc): nativeGraphics(NULL), lastStatus(Ok) + { + lastStatus = DllExports::GdipCreateFromHDC( + hdc, &nativeGraphics); + } + Graphics(HDC hdc, HANDLE hdevice): nativeGraphics(NULL), lastStatus(Ok) + { + lastStatus = DllExports::GdipCreateFromHDC2( + hdc, hdevice, &nativeGraphics); + } + Graphics(HWND hwnd, BOOL icm = FALSE): + nativeGraphics(NULL), lastStatus(Ok) + { + if (icm) { + lastStatus = DllExports::GdipCreateFromHWNDICM( + hwnd, &nativeGraphics); + } else { + lastStatus = DllExports::GdipCreateFromHWND( + hwnd, &nativeGraphics); + } + } + ~Graphics() + { + DllExports::GdipDeleteGraphics(nativeGraphics); + } + + Status AddMetafileComment(const BYTE *data, UINT sizeData) + { + return updateStatus(DllExports::GdipComment( + nativeGraphics, sizeData, data)); + } + GraphicsContainer BeginContainer() + { + GraphicsContainer result = 0; + updateStatus(DllExports::GdipBeginContainer2( + nativeGraphics, &result)); + return result; + } + GraphicsContainer BeginContainer(const RectF& dstrect, + const RectF& srcrect, Unit unit) + { + GraphicsContainer result = 0; + updateStatus(DllExports::GdipBeginContainer( + nativeGraphics, &dstrect, &srcrect, unit, + &result)); + return result; + } + GraphicsContainer BeginContainer(const Rect& dstrect, + const Rect& srcrect, Unit unit) + { + GraphicsContainer result = 0; + updateStatus(DllExports::GdipBeginContainerI( + nativeGraphics, &dstrect, &srcrect, unit, + &result)); + return result; + } + Status Clear(const Color& color) + { + return updateStatus(DllExports::GdipGraphicsClear( + nativeGraphics, color.GetValue())); + } + Status DrawArc(const Pen *pen, REAL x, REAL y, REAL width, REAL height, + REAL startAngle, REAL sweepAngle) + { + return updateStatus(DllExports::GdipDrawArc( + nativeGraphics, pen ? pen->nativePen : NULL, + x, y, width, height, startAngle, sweepAngle)); + } + Status DrawArc(const Pen *pen, INT x, INT y, INT width, INT height, + REAL startAngle, REAL sweepAngle) + { + return updateStatus(DllExports::GdipDrawArcI( + nativeGraphics, pen ? pen->nativePen : NULL, + x, y, width, height, startAngle, sweepAngle)); + } + Status DrawArc(const Pen *pen, const RectF& rect, + REAL startAngle, REAL sweepAngle) + { + return updateStatus(DllExports::GdipDrawArc( + nativeGraphics, pen ? pen->nativePen : NULL, + rect.X, rect.Y, rect.Width, rect.Height, + startAngle, sweepAngle)); + } + Status DrawArc(const Pen *pen, const Rect& rect, + REAL startAngle, REAL sweepAngle) + { + return updateStatus(DllExports::GdipDrawArcI( + nativeGraphics, pen ? pen->nativePen : NULL, + rect.X, rect.Y, rect.Width, rect.Height, + startAngle, sweepAngle)); + } + Status DrawBezier(const Pen *pen, + REAL x1, REAL y1, REAL x2, REAL y2, + REAL x3, REAL y3, REAL x4, REAL y4) + { + return updateStatus(DllExports::GdipDrawBezier( + nativeGraphics, pen ? pen->nativePen : NULL, + x1, y1, x2, y2, x3, y3, x4, y4)); + } + Status DrawBezier(const Pen *pen, + INT x1, INT y1, INT x2, INT y2, + INT x3, INT y3, INT x4, INT y4) + { + return updateStatus(DllExports::GdipDrawBezierI( + nativeGraphics, pen ? pen->nativePen : NULL, + x1, y1, x2, y2, x3, y3, x4, y4)); + } + Status DrawBezier(const Pen *pen, + const PointF& pt1, const PointF& pt2, + const PointF& pt3, const PointF& pt4) + { + return updateStatus(DllExports::GdipDrawBezier( + nativeGraphics, pen ? pen->nativePen : NULL, + pt1.X, pt1.Y, pt2.X, pt2.Y, + pt3.X, pt3.Y, pt4.X, pt4.Y)); + } + Status DrawBezier(const Pen *pen, + const Point& pt1, const Point& pt2, + const Point& pt3, const Point& pt4) + { + return updateStatus(DllExports::GdipDrawBezierI( + nativeGraphics, pen ? pen->nativePen : NULL, + pt1.X, pt1.Y, pt2.X, pt2.Y, + pt3.X, pt3.Y, pt4.X, pt4.Y)); + } + Status DrawBeziers(const Pen *pen, const PointF *points, INT count) + { + return updateStatus(DllExports::GdipDrawBeziers( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count)); + } + Status DrawBeziers(const Pen *pen, const Point *points, INT count) + { + return updateStatus(DllExports::GdipDrawBeziersI( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count)); + } + Status DrawCachedBitmap(CachedBitmap *cb, INT x, INT y) + { + return updateStatus(DllExports::GdipDrawCachedBitmap( + nativeGraphics, + cb ? cb->nativeCachedBitmap : NULL, + x, y)); + } + Status DrawClosedCurve(const Pen *pen, const PointF *points, INT count) + { + return updateStatus(DllExports::GdipDrawClosedCurve( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count)); + } + Status DrawClosedCurve(const Pen *pen, const Point *points, INT count) + { + return updateStatus(DllExports::GdipDrawClosedCurveI( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count)); + } + Status DrawClosedCurve(const Pen *pen, const PointF *points, INT count, + REAL tension) + { + return updateStatus(DllExports::GdipDrawClosedCurve2( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count, tension)); + } + Status DrawClosedCurve(const Pen *pen, const Point *points, INT count, + REAL tension) + { + return updateStatus(DllExports::GdipDrawClosedCurve2I( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count, tension)); + } + Status DrawCurve(const Pen *pen, const PointF *points, INT count) + { + return updateStatus(DllExports::GdipDrawCurve( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count)); + } + Status DrawCurve(const Pen *pen, const Point *points, INT count) + { + return updateStatus(DllExports::GdipDrawCurveI( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count)); + } + Status DrawCurve(const Pen *pen, const PointF *points, INT count, + REAL tension) + { + return updateStatus(DllExports::GdipDrawCurve2( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count, tension)); + } + Status DrawCurve(const Pen *pen, const Point *points, INT count, + REAL tension) + { + return updateStatus(DllExports::GdipDrawCurve2I( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count, tension)); + } + Status DrawCurve(const Pen *pen, const PointF *points, INT count, + INT offset, INT numberOfSegments, REAL tension) + { + return updateStatus(DllExports::GdipDrawCurve3( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count, offset, + numberOfSegments, tension)); + } + Status DrawCurve(const Pen *pen, const Point *points, INT count, + INT offset, INT numberOfSegments, REAL tension) + { + return updateStatus(DllExports::GdipDrawCurve3I( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count, offset, + numberOfSegments, tension)); + } + Status DrawDriverString(const UINT16 *text, INT length, + const Font *font, const Brush *brush, + const PointF *positions, INT flags, + const Matrix *matrix) + { + return updateStatus(DllExports::GdipDrawDriverString( + nativeGraphics, text, length, + font ? font->nativeFont : NULL, + brush ? brush->nativeBrush : NULL, + positions, flags, + matrix ? matrix->nativeMatrix : NULL)); + } + Status DrawEllipse(const Pen *pen, + REAL x, REAL y, REAL width, REAL height) + { + return updateStatus(DllExports::GdipDrawEllipse( + nativeGraphics, pen ? pen->nativePen : NULL, + x, y, width, height)); + } + Status DrawEllipse(const Pen *pen, INT x, INT y, INT width, INT height) + { + return updateStatus(DllExports::GdipDrawEllipseI( + nativeGraphics, pen ? pen->nativePen : NULL, + x, y, width, height)); + } + Status DrawEllipse(const Pen *pen, const RectF& rect) + { + return updateStatus(DllExports::GdipDrawEllipse( + nativeGraphics, pen ? pen->nativePen : NULL, + rect.X, rect.Y, rect.Width, rect.Height)); + } + Status DrawEllipse(const Pen *pen, const Rect& rect) + { + return updateStatus(DllExports::GdipDrawEllipseI( + nativeGraphics, pen ? pen->nativePen : NULL, + rect.X, rect.Y, rect.Width, rect.Height)); + } + Status DrawImage(Image *image, REAL x, REAL y) + { + return updateStatus(DllExports::GdipDrawImage( + nativeGraphics, + image ? image->nativeImage : NULL, + x, y)); + } + Status DrawImage(Image *image, INT x, INT y) + { + return updateStatus(DllExports::GdipDrawImageI( + nativeGraphics, + image ? image->nativeImage : NULL, + x, y)); + } + Status DrawImage(Image *image, const PointF& point) + { + return updateStatus(DllExports::GdipDrawImage( + nativeGraphics, + image ? image->nativeImage : NULL, + point.X, point.Y)); + } + Status DrawImage(Image *image, const Point& point) + { + return updateStatus(DllExports::GdipDrawImageI( + nativeGraphics, + image ? image->nativeImage : NULL, + point.X, point.Y)); + } + Status DrawImage(Image *image, REAL x, REAL y, REAL width, REAL height) + { + return updateStatus(DllExports::GdipDrawImageRect( + nativeGraphics, + image ? image->nativeImage : NULL, + x, y, width, height)); + } + Status DrawImage(Image *image, INT x, INT y, INT width, INT height) + { + return updateStatus(DllExports::GdipDrawImageRectI( + nativeGraphics, + image ? image->nativeImage : NULL, + x, y, width, height)); + } + Status DrawImage(Image *image, const RectF& rect) + { + return updateStatus(DllExports::GdipDrawImageRect( + nativeGraphics, + image ? image->nativeImage : NULL, + rect.X, rect.Y, rect.Width, rect.Height)); + } + Status DrawImage(Image *image, const Rect& rect) + { + return updateStatus(DllExports::GdipDrawImageRectI( + nativeGraphics, + image ? image->nativeImage : NULL, + rect.X, rect.Y, rect.Width, rect.Height)); + } + Status DrawImage(Image *image, const PointF *destPoints, INT count) + { + return updateStatus(DllExports::GdipDrawImagePoints( + nativeGraphics, + image ? image->nativeImage : NULL, + destPoints, count)); + } + Status DrawImage(Image *image, const Point *destPoints, INT count) + { + return updateStatus(DllExports::GdipDrawImagePointsI( + nativeGraphics, + image ? image->nativeImage : NULL, + destPoints, count)); + } + Status DrawImage(Image *image, REAL x, REAL y, REAL srcx, REAL srcy, + REAL srcwidth, REAL srcheight, Unit srcUnit) + { + return updateStatus(DllExports::GdipDrawImagePointRect( + nativeGraphics, + image ? image->nativeImage : NULL, + x, y, srcx, srcy, srcwidth, srcheight, + srcUnit)); + } + Status DrawImage(Image *image, INT x, INT y, INT srcx, INT srcy, + INT srcwidth, INT srcheight, Unit srcUnit) + { + return updateStatus(DllExports::GdipDrawImagePointRectI( + nativeGraphics, + image ? image->nativeImage : NULL, + x, y, srcx, srcy, srcwidth, srcheight, + srcUnit)); + } + Status DrawImage(Image *image, const RectF& destRect, + REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight, + Unit srcUnit, + const ImageAttributes *imageAttributes = NULL, + DrawImageAbort callback = NULL, + VOID *callbackData = NULL) + { + return updateStatus(DllExports::GdipDrawImageRectRect( + nativeGraphics, + image ? image->nativeImage : NULL, + destRect.X, destRect.Y, + destRect.Width, destRect.Height, + srcx, srcy, srcwidth, srcheight, srcUnit, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL, + callback, callbackData)); + } + Status DrawImage(Image *image, const Rect& destRect, + INT srcx, INT srcy, INT srcwidth, INT srcheight, + Unit srcUnit, + const ImageAttributes *imageAttributes = NULL, + DrawImageAbort callback = NULL, + VOID *callbackData = NULL) + { + return updateStatus(DllExports::GdipDrawImageRectRectI( + nativeGraphics, + image ? image->nativeImage : NULL, + destRect.X, destRect.Y, + destRect.Width, destRect.Height, + srcx, srcy, srcwidth, srcheight, srcUnit, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL, + callback, callbackData)); + } + Status DrawImage(Image *image, const RectF& destRect, + const RectF& sourceRect, Unit srcUnit, + const ImageAttributes *imageAttributes = NULL) + { + return updateStatus(DllExports::GdipDrawImageRectRectI( + nativeGraphics, + image ? image->nativeImage : NULL, + destRect.X, destRect.Y, + destRect.Width, destRect.Height, + sourceRect.X, sourceRect.Y, + sourceRect.Width, sourceRect.Height, srcUnit, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL, + NULL, NULL)); + } + Status DrawImage(Image *image, const PointF *destPoints, INT count, + REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight, + Unit srcUnit, + const ImageAttributes *imageAttributes = NULL, + DrawImageAbort callback = NULL, + VOID *callbackData = NULL) + { + return updateStatus(DllExports::GdipDrawImagePointsRect( + nativeGraphics, + image ? image->nativeImage : NULL, + destPoints, count, + srcx, srcy, srcwidth, srcheight, srcUnit, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL, + callback, callbackData)); + } + Status DrawImage(Image *image, const Point *destPoints, INT count, + INT srcx, INT srcy, INT srcwidth, INT srcheight, + Unit srcUnit, + const ImageAttributes *imageAttributes = NULL, + DrawImageAbort callback = NULL, + VOID *callbackData = NULL) + { + return updateStatus(DllExports::GdipDrawImagePointsRectI( + nativeGraphics, + image ? image->nativeImage : NULL, + destPoints, count, + srcx, srcy, srcwidth, srcheight, srcUnit, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL, + callback, callbackData)); + } + // TODO: [GDI+ 1.1] Graphics::DrawImage(..Effect..) + //Status DrawImage(Image *image, RectF *sourceRect, Matrix *matrix, + // Effect *effect, ImageAttributes *imageAttributes, + // Unit srcUnit) + //{ + // return updateStatus(DllExports::GdipDrawImageFX( + // nativeGraphics, + // image ? image->nativeImage : NULL, + // sourceRect, + // matrix ? matrix->nativeMatrix : NULL, + // effect ? effect->nativeEffect : NULL, + // imageAttributes ? imageAttributes->nativeImageAttributes : NULL, + // srcUnit)); + //} + Status DrawLine(const Pen *pen, REAL x1, REAL y1, REAL x2, REAL y2) + { + return updateStatus(DllExports::GdipDrawLine( + nativeGraphics, pen ? pen->nativePen : NULL, + x1, y1, x2, y2)); + } + Status DrawLine(const Pen *pen, INT x1, INT y1, INT x2, INT y2) + { + return updateStatus(DllExports::GdipDrawLineI( + nativeGraphics, pen ? pen->nativePen : NULL, + x1, y1, x2, y2)); + } + Status DrawLine(const Pen *pen, const PointF& pt1, const PointF& pt2) + { + return updateStatus(DllExports::GdipDrawLine( + nativeGraphics, pen ? pen->nativePen : NULL, + pt1.X, pt1.Y, pt2.X, pt2.Y)); + } + Status DrawLine(const Pen *pen, const Point& pt1, const Point& pt2) + { + return updateStatus(DllExports::GdipDrawLineI( + nativeGraphics, pen ? pen->nativePen : NULL, + pt1.X, pt1.Y, pt2.X, pt2.Y)); + } + Status DrawLines(const Pen *pen, const PointF *points, INT count) + { + return updateStatus(DllExports::GdipDrawLines( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count)); + } + Status DrawLines(const Pen *pen, const Point *points, INT count) + { + return updateStatus(DllExports::GdipDrawLinesI( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count)); + } + Status DrawPath(const Pen *pen, const GraphicsPath *path) + { + return updateStatus(DllExports::GdipDrawPath( + nativeGraphics, pen ? pen->nativePen : NULL, + path ? path->nativePath : NULL)); + } + Status DrawPie(const Pen *pen, REAL x, REAL y, REAL width, REAL height, + REAL startAngle, REAL sweepAngle) + { + return updateStatus(DllExports::GdipDrawPie( + nativeGraphics, pen ? pen->nativePen : NULL, + x, y, width, height, startAngle, sweepAngle)); + } + Status DrawPie(const Pen *pen, INT x, INT y, INT width, INT height, + REAL startAngle, REAL sweepAngle) + { + return updateStatus(DllExports::GdipDrawPieI( + nativeGraphics, pen ? pen->nativePen : NULL, + x, y, width, height, startAngle, sweepAngle)); + } + Status DrawPie(const Pen *pen, const RectF& rect, + REAL startAngle, REAL sweepAngle) + { + return updateStatus(DllExports::GdipDrawPie( + nativeGraphics, pen ? pen->nativePen : NULL, + rect.X, rect.Y, rect.Width, rect.Height, + startAngle, sweepAngle)); + } + Status DrawPie(const Pen *pen, const Rect& rect, + REAL startAngle, REAL sweepAngle) + { + return updateStatus(DllExports::GdipDrawPieI( + nativeGraphics, pen ? pen->nativePen : NULL, + rect.X, rect.Y, rect.Width, rect.Height, + startAngle, sweepAngle)); + } + Status DrawPolygon(const Pen *pen, const PointF *points, INT count) + { + return updateStatus(DllExports::GdipDrawPolygon( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count)); + } + Status DrawPolygon(const Pen *pen, const Point *points, INT count) + { + return updateStatus(DllExports::GdipDrawPolygonI( + nativeGraphics, pen ? pen->nativePen : NULL, + points, count)); + } + Status DrawRectangle(const Pen *pen, + REAL x, REAL y, REAL width, REAL height) + { + return updateStatus(DllExports::GdipDrawRectangle( + nativeGraphics, pen ? pen->nativePen : NULL, + x, y, width, height)); + } + Status DrawRectangle(const Pen *pen, + INT x, INT y, INT width, INT height) + { + return updateStatus(DllExports::GdipDrawRectangleI( + nativeGraphics, pen ? pen->nativePen : NULL, + x, y, width, height)); + } + Status DrawRectangle(const Pen *pen, const RectF& rect) + { + return updateStatus(DllExports::GdipDrawRectangle( + nativeGraphics, pen ? pen->nativePen : NULL, + rect.X, rect.Y, rect.Width, rect.Height)); + } + Status DrawRectangle(const Pen *pen, const Rect& rect) + { + return updateStatus(DllExports::GdipDrawRectangleI( + nativeGraphics, pen ? pen->nativePen : NULL, + rect.X, rect.Y, rect.Width, rect.Height)); + } + Status DrawRectangles(const Pen *pen, const RectF *rects, INT count) + { + return updateStatus(DllExports::GdipDrawRectangles( + nativeGraphics, pen ? pen->nativePen : NULL, + rects, count)); + } + Status DrawRectangles(const Pen *pen, const Rect *rects, INT count) + { + return updateStatus(DllExports::GdipDrawRectanglesI( + nativeGraphics, pen ? pen->nativePen : NULL, + rects, count)); + } + Status DrawString(const WCHAR *string, INT length, const Font *font, + const PointF& origin, const Brush *brush) + { + RectF layoutRect(origin.X, origin.Y, 0.0f, 0.0f); + return updateStatus(DllExports::GdipDrawString( + nativeGraphics, string, length, + font ? font->nativeFont : NULL, + &layoutRect, NULL, + brush ? brush->nativeBrush : NULL)); + } + Status DrawString(const WCHAR *string, INT length, + const Font *font, const PointF& origin, + const StringFormat *stringFormat, const Brush *brush) + { + RectF layoutRect(origin.X, origin.Y, 0.0f, 0.0f); + return updateStatus(DllExports::GdipDrawString( + nativeGraphics, string, length, + font ? font->nativeFont : NULL, + &layoutRect, + stringFormat ? stringFormat->nativeStringFormat : NULL, + brush ? brush->nativeBrush : NULL)); + } + Status DrawString(const WCHAR *string, INT length, + const Font *font, const RectF& layoutRect, + const StringFormat *stringFormat, const Brush *brush) + { + return updateStatus(DllExports::GdipDrawString( + nativeGraphics, string, length, + font ? font->nativeFont : NULL, + &layoutRect, + stringFormat ? stringFormat->nativeStringFormat : NULL, + brush ? brush->nativeBrush : NULL)); + } + Status EndContainer(GraphicsContainer state) + { + return updateStatus(DllExports::GdipEndContainer( + nativeGraphics, state)); + } + Status EnumerateMetafile(const Metafile *metafile, + const PointF& destPoint, + EnumerateMetafileProc callback, + VOID *callbackData = NULL, + ImageAttributes *imageAttributes = NULL) + { + return updateStatus(DllExports::GdipEnumerateMetafileDestPoint( + nativeGraphics, + metafile ? ((GpMetafile*) metafile->nativeImage) : NULL, + destPoint, callback, callbackData, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL)); + } + Status EnumerateMetafile(const Metafile *metafile, + const Point& destPoint, + EnumerateMetafileProc callback, + VOID *callbackData = NULL, + ImageAttributes *imageAttributes = NULL) + { + return updateStatus(DllExports::GdipEnumerateMetafileDestPointI( + nativeGraphics, + metafile ? ((GpMetafile*) metafile->nativeImage) : NULL, + destPoint, callback, callbackData, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL)); + } + Status EnumerateMetafile(const Metafile *metafile, + const RectF& destRect, + EnumerateMetafileProc callback, + VOID *callbackData = NULL, + ImageAttributes *imageAttributes = NULL) + { + return updateStatus(DllExports::GdipEnumerateMetafileDestRect( + nativeGraphics, + metafile ? ((GpMetafile*) metafile->nativeImage) : NULL, + destRect, callback, callbackData, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL)); + } + Status EnumerateMetafile(const Metafile *metafile, + const Rect& destRect, + EnumerateMetafileProc callback, + VOID *callbackData = NULL, + ImageAttributes *imageAttributes = NULL) + { + return updateStatus(DllExports::GdipEnumerateMetafileDestRectI( + nativeGraphics, + metafile ? ((GpMetafile*) metafile->nativeImage) : NULL, + destRect, callback, callbackData, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL)); + } + Status EnumerateMetafile(const Metafile *metafile, + const PointF *destPoints, INT count, + EnumerateMetafileProc callback, + VOID *callbackData = NULL, + ImageAttributes *imageAttributes = NULL) + { + return updateStatus(DllExports::GdipEnumerateMetafileDestPoints( + nativeGraphics, + metafile ? ((GpMetafile*) metafile->nativeImage) : NULL, + destPoints, count, callback, callbackData, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL)); + } + Status EnumerateMetafile(const Metafile *metafile, + const Point *destPoints, INT count, + EnumerateMetafileProc callback, + VOID *callbackData = NULL, + ImageAttributes *imageAttributes = NULL) + { + return updateStatus(DllExports::GdipEnumerateMetafileDestPointsI( + nativeGraphics, + metafile ? ((GpMetafile*) metafile->nativeImage) : NULL, + destPoints, count, callback, callbackData, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL)); + } + Status EnumerateMetafile(const Metafile *metafile, + const PointF& destPoint, + const RectF& srcRect, Unit srcUnit, + EnumerateMetafileProc callback, + VOID *callbackData = NULL, + ImageAttributes *imageAttributes = NULL) + { + return updateStatus(DllExports::GdipEnumerateMetafileSrcRectDestPoint( + nativeGraphics, + metafile ? ((GpMetafile*) metafile->nativeImage) : NULL, + destPoint, srcRect, srcUnit, + callback, callbackData, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL)); + } + Status EnumerateMetafile(const Metafile *metafile, + const Point& destPoint, + const Rect& srcRect, Unit srcUnit, + EnumerateMetafileProc callback, + VOID *callbackData = NULL, + ImageAttributes *imageAttributes = NULL) + { + return updateStatus(DllExports::GdipEnumerateMetafileSrcRectDestPointI( + nativeGraphics, + metafile ? ((GpMetafile*) metafile->nativeImage) : NULL, + destPoint, srcRect, srcUnit, + callback, callbackData, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL)); + } + Status EnumerateMetafile(const Metafile *metafile, + const RectF& destRect, + const RectF& srcRect, Unit srcUnit, + EnumerateMetafileProc callback, + VOID *callbackData = NULL, + ImageAttributes *imageAttributes = NULL) + { + return updateStatus(DllExports::GdipEnumerateMetafileSrcRectDestRect( + nativeGraphics, + metafile ? ((GpMetafile*) metafile->nativeImage) : NULL, + destRect, srcRect, srcUnit, + callback, callbackData, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL)); + } + Status EnumerateMetafile(const Metafile *metafile, + const Rect& destRect, + const Rect& srcRect, Unit srcUnit, + EnumerateMetafileProc callback, + VOID *callbackData = NULL, + ImageAttributes *imageAttributes = NULL) + { + return updateStatus(DllExports::GdipEnumerateMetafileSrcRectDestRectI( + nativeGraphics, + metafile ? ((GpMetafile*) metafile->nativeImage) : NULL, + destRect, srcRect, srcUnit, + callback, callbackData, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL)); + } + Status EnumerateMetafile(const Metafile *metafile, + const PointF* destPoints, INT count, + const RectF& srcRect, Unit srcUnit, + EnumerateMetafileProc callback, + VOID *callbackData = NULL, + ImageAttributes *imageAttributes = NULL) + { + return updateStatus(DllExports::GdipEnumerateMetafileSrcRectDestPoints( + nativeGraphics, + metafile ? ((GpMetafile*) metafile->nativeImage) : NULL, + destPoints, count, srcRect, srcUnit, + callback, callbackData, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL)); + } + Status EnumerateMetafile(const Metafile *metafile, + const Point* destPoints, INT count, + const Rect& srcRect, Unit srcUnit, + EnumerateMetafileProc callback, + VOID *callbackData = NULL, + ImageAttributes *imageAttributes = NULL) + { + return updateStatus(DllExports::GdipEnumerateMetafileSrcRectDestPointsI( + nativeGraphics, + metafile ? ((GpMetafile*) metafile->nativeImage) : NULL, + destPoints, count, srcRect, srcUnit, + callback, callbackData, + imageAttributes ? imageAttributes->nativeImageAttributes : NULL)); + } + Status ExcludeClip(const RectF& rect) + { + return updateStatus(DllExports::GdipSetClipRect( + nativeGraphics, + rect.X, rect.Y, rect.Width, rect.Height, + CombineModeExclude)); + } + Status ExcludeClip(const Rect& rect) + { + return updateStatus(DllExports::GdipSetClipRectI( + nativeGraphics, + rect.X, rect.Y, rect.Width, rect.Height, + CombineModeExclude)); + } + Status ExcludeClip(const Region *region) + { + return updateStatus(DllExports::GdipSetClipRegion( + nativeGraphics, + region ? region->nativeRegion : NULL, + CombineModeExclude)); + } + Status FillClosedCurve(const Brush *brush, + const PointF *points, INT count) + { + return updateStatus(DllExports::GdipFillClosedCurve( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + points, count)); + } + Status FillClosedCurve(const Brush *brush, + const Point *points, INT count) + { + return updateStatus(DllExports::GdipFillClosedCurveI( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + points, count)); + } + Status FillClosedCurve(const Brush *brush, + const PointF *points, INT count, + FillMode fillMode, REAL tension = 0.5f) + { + return updateStatus(DllExports::GdipFillClosedCurve2( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + points, count, tension, fillMode)); + } + Status FillClosedCurve(const Brush *brush, + const Point *points, INT count, + FillMode fillMode, REAL tension = 0.5f) + { + return updateStatus(DllExports::GdipFillClosedCurve2I( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + points, count, tension, fillMode)); + } + Status FillEllipse(const Brush *brush, + REAL x, REAL y, REAL width, REAL height) + { + return updateStatus(DllExports::GdipFillEllipse( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + x, y, width, height)); + } + Status FillEllipse(const Brush *brush, + INT x, INT y, INT width, INT height) + { + return updateStatus(DllExports::GdipFillEllipseI( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + x, y, width, height)); + } + Status FillEllipse(const Brush *brush, const RectF& rect) + { + return updateStatus(DllExports::GdipFillEllipse( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + rect.X, rect.Y, rect.Width, rect.Height)); + } + Status FillEllipse(const Brush *brush, const Rect& rect) + { + return updateStatus(DllExports::GdipFillEllipseI( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + rect.X, rect.Y, rect.Width, rect.Height)); + } + Status FillPath(const Brush *brush, const GraphicsPath *path) + { + return updateStatus(DllExports::GdipFillPath( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + path ? path->nativePath : NULL)); + } + Status FillPie(const Brush *brush, + REAL x, REAL y, REAL width, REAL height, + REAL startAngle, REAL sweepAngle) + { + return updateStatus(DllExports::GdipFillPie( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + x, y, width, height, startAngle, sweepAngle)); + } + Status FillPie(const Brush *brush, INT x, INT y, INT width, INT height, + REAL startAngle, REAL sweepAngle) + { + return updateStatus(DllExports::GdipFillPieI( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + x, y, width, height, startAngle, sweepAngle)); + } + Status FillPie(const Brush *brush, const RectF& rect, + REAL startAngle, REAL sweepAngle) + { + return updateStatus(DllExports::GdipFillPie( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + rect.X, rect.Y, rect.Width, rect.Height, + startAngle, sweepAngle)); + } + Status FillPie(const Brush *brush, const Rect& rect, + REAL startAngle, REAL sweepAngle) + { + return updateStatus(DllExports::GdipFillPieI( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + rect.X, rect.Y, rect.Width, rect.Height, + startAngle, sweepAngle)); + } + Status FillPolygon(const Brush *brush, const PointF *points, INT count) + { + return updateStatus(DllExports::GdipFillPolygon( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + points, count, FillModeAlternate)); + } + Status FillPolygon(const Brush *brush, const Point *points, INT count) + { + return updateStatus(DllExports::GdipFillPolygonI( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + points, count, FillModeAlternate)); + } + Status FillPolygon(const Brush *brush, const PointF *points, INT count, + FillMode fillMode) + { + return updateStatus(DllExports::GdipFillPolygon( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + points, count, fillMode)); + } + Status FillPolygon(const Brush *brush, const Point *points, INT count, + FillMode fillMode) + { + return updateStatus(DllExports::GdipFillPolygonI( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + points, count, fillMode)); + } + Status FillRectangle(const Brush *brush, + REAL x, REAL y, REAL width, REAL height) + { + return updateStatus(DllExports::GdipFillRectangle( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + x, y, width, height)); + } + Status FillRectangle(const Brush *brush, + INT x, INT y, INT width, INT height) + { + return updateStatus(DllExports::GdipFillRectangleI( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + x, y, width, height)); + } + Status FillRectangle(const Brush *brush, const RectF& rect) + { + return updateStatus(DllExports::GdipFillRectangle( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + rect.X, rect.Y, rect.Width, rect.Height)); + } + Status FillRectangle(const Brush *brush, const Rect& rect) + { + return updateStatus(DllExports::GdipFillRectangleI( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + rect.X, rect.Y, rect.Width, rect.Height)); + } + Status FillRectangles(const Brush *brush, const RectF *rects, INT count) + { + return updateStatus(DllExports::GdipFillRectangles( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + rects, count)); + } + Status FillRectangles(const Brush *brush, const Rect *rects, INT count) + { + return updateStatus(DllExports::GdipFillRectanglesI( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + rects, count)); + } + Status FillRegion(const Brush *brush, const Region *region) + { + return updateStatus(DllExports::GdipFillRegion( + nativeGraphics, + brush ? brush->nativeBrush : NULL, + region ? region->nativeRegion : NULL)); + } + VOID Flush(FlushIntention intention = FlushIntentionFlush) + { + updateStatus(DllExports::GdipFlush(nativeGraphics, intention)); + } + Status GetClip(Region *region) const + { + return updateStatus(DllExports::GdipGetClip( + nativeGraphics, + region ? region->nativeRegion : NULL)); + } + Status GetClipBounds(RectF *rect) const + { + return updateStatus(DllExports::GdipGetClipBounds( + nativeGraphics, rect)); + } + Status GetClipBounds(Rect *rect) const + { + return updateStatus(DllExports::GdipGetClipBoundsI( + nativeGraphics, rect)); + } + CompositingMode GetCompositingMode() const + { + CompositingMode result = CompositingModeSourceOver; + updateStatus(DllExports::GdipGetCompositingMode( + nativeGraphics, &result)); + return result; + } + CompositingQuality GetCompositingQuality() const + { + CompositingQuality result = CompositingQualityDefault; + updateStatus(DllExports::GdipGetCompositingQuality( + nativeGraphics, &result)); + return result; + } + REAL GetDpiX() const + { + REAL result = 0.0f; + updateStatus(DllExports::GdipGetDpiX(nativeGraphics, &result)); + return result; + } + REAL GetDpiY() const + { + REAL result = 0.0f; + updateStatus(DllExports::GdipGetDpiY(nativeGraphics, &result)); + return result; + } + HDC GetHDC() + { + HDC result = NULL; + updateStatus(DllExports::GdipGetDC(nativeGraphics, &result)); + return result; + } + InterpolationMode GetInterpolationMode() const + { + InterpolationMode result = InterpolationModeDefault; + updateStatus(DllExports::GdipGetInterpolationMode( + nativeGraphics, &result)); + return result; + } + Status GetLastStatus() const + { + Status result = lastStatus; + lastStatus = Ok; + return result; + } + Status GetNearestColor(Color *color) const + { + return updateStatus(DllExports::GdipGetNearestColor( + nativeGraphics, color ? &color->Value : NULL)); + } + REAL GetPageScale() const + { + REAL result = 0.0f; + updateStatus(DllExports::GdipGetPageScale( + nativeGraphics, &result)); + return result; + } + Unit GetPageUnit() const + { + Unit result = UnitWorld; + updateStatus(DllExports::GdipGetPageUnit( + nativeGraphics, &result)); + return result; + } + PixelOffsetMode GetPixelOffsetMode() const + { + PixelOffsetMode result = PixelOffsetModeDefault; + updateStatus(DllExports::GdipGetPixelOffsetMode( + nativeGraphics, &result)); + return result; + } + Status GetRenderingOrigin(INT *x, INT *y) const + { + return updateStatus(DllExports::GdipGetRenderingOrigin( + nativeGraphics, x, y)); + } + SmoothingMode GetSmoothingMode() const + { + SmoothingMode result = SmoothingModeDefault; + updateStatus(DllExports::GdipGetSmoothingMode( + nativeGraphics, &result)); + return result; + } + UINT GetTextContrast() const + { + UINT result = 0; + updateStatus(DllExports::GdipGetTextContrast( + nativeGraphics, &result)); + return result; + } + TextRenderingHint GetTextRenderingHint() const + { + TextRenderingHint result = TextRenderingHintSystemDefault; + updateStatus(DllExports::GdipGetTextRenderingHint( + nativeGraphics, &result)); + return result; + } + Status GetTransform(Matrix *matrix) const + { + return updateStatus(DllExports::GdipGetWorldTransform( + nativeGraphics, + matrix ? matrix->nativeMatrix : NULL)); + } + Status GetVisibleClipBounds(RectF *rect) const + { + return updateStatus(DllExports::GdipGetVisibleClipBounds( + nativeGraphics, rect)); + } + Status GetVisibleClipBounds(Rect *rect) const + { + return updateStatus(DllExports::GdipGetVisibleClipBoundsI( + nativeGraphics, rect)); + } + Status IntersectClip(const RectF& rect) + { + return updateStatus(DllExports::GdipSetClipRect( + nativeGraphics, + rect.X, rect.Y, rect.Width, rect.Height, + CombineModeIntersect)); + } + Status IntersectClip(const Rect& rect) + { + return updateStatus(DllExports::GdipSetClipRectI( + nativeGraphics, + rect.X, rect.Y, rect.Width, rect.Height, + CombineModeIntersect)); + } + Status IntersectClip(const Region *region) + { + return updateStatus(DllExports::GdipSetClipRegion( + nativeGraphics, + region ? region->nativeRegion : NULL, + CombineModeIntersect)); + } + BOOL IsClipEmpty() const + { + BOOL result = FALSE; + updateStatus(DllExports::GdipIsClipEmpty( + nativeGraphics, &result)); + return result; + } + BOOL IsVisible(REAL x, REAL y) const + { + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisiblePoint( + nativeGraphics, x, y, &result)); + return result; + } + BOOL IsVisible(INT x, INT y) const + { + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisiblePointI( + nativeGraphics, x, y, &result)); + return result; + } + BOOL IsVisible(const PointF& point) const + { + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisiblePoint( + nativeGraphics, point.X, point.Y, &result)); + return result; + } + BOOL IsVisible(const Point& point) const + { + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisiblePointI( + nativeGraphics, point.X, point.Y, &result)); + return result; + } + BOOL IsVisible(REAL x, REAL y, REAL width, REAL height) const + { + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisibleRect( + nativeGraphics, x, y, width, height, &result)); + return result; + } + BOOL IsVisible(INT x, INT y, INT width, INT height) const + { + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisibleRectI( + nativeGraphics, x, y, width, height, &result)); + return result; + } + BOOL IsVisible(const RectF& rect) const + { + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisibleRect( + nativeGraphics, rect.X, rect.Y, + rect.Width, rect.Height, &result)); + return result; + } + BOOL IsVisible(const Rect& rect) const + { + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisibleRectI( + nativeGraphics, rect.X, rect.Y, + rect.Width, rect.Height, &result)); + return result; + } + BOOL IsVisibleClipEmpty() const + { + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisibleClipEmpty( + nativeGraphics, &result)); + return result; + } + Status MeasureCharacterRanges(const WCHAR *string, INT length, + const Font *font, const RectF& layoutRect, + const StringFormat *stringFormat, + INT regionCount, Region *regions) const + { + if (regionCount <= 0 || !regions) + return lastStatus = InvalidParameter; + + GpRegion **nativeRegionArray = (GpRegion**) + DllExports::GdipAlloc(regionCount * sizeof(GpRegion*)); + if (!nativeRegionArray) + return lastStatus = OutOfMemory; + for (int i = 0; i < regionCount; ++i) { + nativeRegionArray[i] = regions[i].nativeRegion; + } + Status status = updateStatus(DllExports::GdipMeasureCharacterRanges( + nativeGraphics, string, length, + font ? font->nativeFont : NULL, + layoutRect, + stringFormat ? stringFormat->nativeStringFormat : NULL, + regionCount, nativeRegionArray)); + DllExports::GdipFree(nativeRegionArray); + return status; + } + Status MeasureDriverString(const UINT16 *text, INT length, + const Font *font, const PointF *positions, INT flags, + const Matrix *matrix, RectF *boundingBox) const + { + return updateStatus(DllExports::GdipMeasureDriverString( + nativeGraphics, text, length, + font ? font->nativeFont : NULL, + positions, flags, + matrix ? matrix->nativeMatrix : NULL, + boundingBox)); + } + Status MeasureString(const WCHAR *string, INT length, + const Font *font, const RectF& layoutRect, + RectF *boundingBox) const + { + return updateStatus(DllExports::GdipMeasureString( + nativeGraphics, string, length, + font ? font->nativeFont : NULL, + &layoutRect, NULL, boundingBox, NULL, NULL)); + } + Status MeasureString(const WCHAR *string, INT length, + const Font *font, const RectF& layoutRect, + const StringFormat *stringFormat, RectF *boundingBox, + INT *codepointsFitted = NULL, + INT *linesFitted = NULL) const + { + return updateStatus(DllExports::GdipMeasureString( + nativeGraphics, string, length, + font ? font->nativeFont : NULL, + &layoutRect, + stringFormat ? stringFormat->nativeStringFormat : NULL, + boundingBox, codepointsFitted, linesFitted)); + } + Status MeasureString(const WCHAR *string, INT length, + const Font *font, const SizeF& layoutRectSize, + const StringFormat *stringFormat, SizeF *size, + INT *codepointsFitted = NULL, + INT *linesFitted = NULL) const + { + if (!size) return lastStatus = InvalidParameter; + RectF layoutRect(PointF(0.0f, 0.0f), layoutRectSize); + RectF boundingBox; + Status status = updateStatus(DllExports::GdipMeasureString( + nativeGraphics, string, length, + font ? font->nativeFont : NULL, + &layoutRect, + stringFormat ? stringFormat->nativeStringFormat : NULL, + &boundingBox, codepointsFitted, linesFitted)); + boundingBox.GetSize(size); + return status; + } + Status MeasureString(const WCHAR *string, INT length, + const Font *font, const PointF& origin, + RectF *boundingBox) const + { + RectF layoutRect(origin, SizeF(0.0f, 0.0f)); + return updateStatus(DllExports::GdipMeasureString( + nativeGraphics, string, length, + font ? font->nativeFont : NULL, + &layoutRect, NULL, boundingBox, NULL, NULL)); + } + Status MeasureString(const WCHAR *string, INT length, + const Font *font, const PointF& origin, + const StringFormat *stringFormat, + RectF *boundingBox) const + { + RectF layoutRect(origin, SizeF(0.0f, 0.0f)); + return updateStatus(DllExports::GdipMeasureString( + nativeGraphics, string, length, + font ? font->nativeFont : NULL, + &layoutRect, + stringFormat ? stringFormat->nativeStringFormat : NULL, + boundingBox, NULL, NULL)); + } + Status MultiplyTransform(const Matrix *matrix, + MatrixOrder order = MatrixOrderPrepend) + { + return updateStatus(DllExports::GdipMultiplyWorldTransform( + nativeGraphics, + matrix ? matrix->nativeMatrix : NULL, order)); + } + VOID ReleaseHDC(HDC hdc) + { + updateStatus(DllExports::GdipReleaseDC(nativeGraphics, hdc)); + } + Status ResetClip() + { + return updateStatus(DllExports::GdipResetClip(nativeGraphics)); + } + Status ResetTransform() + { + return updateStatus(DllExports::GdipResetWorldTransform( + nativeGraphics)); + } + Status Restore(GraphicsState state) + { + return updateStatus(DllExports::GdipRestoreGraphics( + nativeGraphics, state)); + } + Status RotateTransform(REAL angle, + MatrixOrder order = MatrixOrderPrepend) + { + return updateStatus(DllExports::GdipRotateWorldTransform( + nativeGraphics, angle, order)); + } + GraphicsState Save() const + { + GraphicsState result = 0; + updateStatus(DllExports::GdipSaveGraphics( + nativeGraphics, &result)); + return result; + } + Status ScaleTransform(REAL sx, REAL sy, + MatrixOrder order = MatrixOrderPrepend) + { + return updateStatus(DllExports::GdipScaleWorldTransform( + nativeGraphics, sx, sy, order)); + } + VOID SetAbort() + { + updateStatus(NotImplemented); + } + Status SetClip(const Graphics *g, + CombineMode combineMode = CombineModeReplace) + { + return updateStatus(DllExports::GdipSetClipGraphics( + nativeGraphics, g ? g->nativeGraphics : NULL, + combineMode)); + } + Status SetClip(const RectF& rect, + CombineMode combineMode = CombineModeReplace) + { + return updateStatus(DllExports::GdipSetClipRect( + nativeGraphics, + rect.X, rect.Y, rect.Width, rect.Height, + combineMode)); + } + Status SetClip(const Rect& rect, + CombineMode combineMode = CombineModeReplace) + { + return updateStatus(DllExports::GdipSetClipRectI( + nativeGraphics, + rect.X, rect.Y, rect.Width, rect.Height, + combineMode)); + } + Status SetClip(const GraphicsPath *path, + CombineMode combineMode = CombineModeReplace) + { + return updateStatus(DllExports::GdipSetClipPath( + nativeGraphics, + path ? path->nativePath : NULL, + combineMode)); + } + Status SetClip(const Region *region, + CombineMode combineMode = CombineModeReplace) + { + return updateStatus(DllExports::GdipSetClipRegion( + nativeGraphics, + region ? region->nativeRegion : NULL, + combineMode)); + } + Status SetClip(HRGN hRgn, CombineMode combineMode = CombineModeReplace) + { + return updateStatus(DllExports::GdipSetClipHrgn( + nativeGraphics, hRgn, combineMode)); + } + Status SetCompositingMode(CompositingMode compositingMode) + { + return updateStatus(DllExports::GdipSetCompositingMode( + nativeGraphics, compositingMode)); + } + Status SetCompositingQuality(CompositingQuality compositingQuality) + { + return updateStatus(DllExports::GdipSetCompositingQuality( + nativeGraphics, compositingQuality)); + } + Status SetInterpolationMode(InterpolationMode interpolationMode) + { + return updateStatus(DllExports::GdipSetInterpolationMode( + nativeGraphics, interpolationMode)); + } + Status SetPageScale(REAL scale) + { + return updateStatus(DllExports::GdipSetPageScale( + nativeGraphics, scale)); + } + Status SetPageUnit(Unit unit) + { + return updateStatus(DllExports::GdipSetPageUnit( + nativeGraphics, unit)); + } + Status SetPixelOffsetMode(PixelOffsetMode pixelOffsetMode) + { + return updateStatus(DllExports::GdipSetPixelOffsetMode( + nativeGraphics, pixelOffsetMode)); + } + Status SetRenderingOrigin(INT x, INT y) + { + return updateStatus(DllExports::GdipSetRenderingOrigin( + nativeGraphics, x, y)); + } + Status SetSmoothingMode(SmoothingMode smoothingMode) + { + return updateStatus(DllExports::GdipSetSmoothingMode( + nativeGraphics, smoothingMode)); + } + Status SetTextContrast(UINT contrast) + { + return updateStatus(DllExports::GdipSetTextContrast( + nativeGraphics, contrast)); + } + Status SetTextRenderingHint(TextRenderingHint textRenderingHint) + { + return updateStatus(DllExports::GdipSetTextRenderingHint( + nativeGraphics, textRenderingHint)); + } + Status SetTransform(const Matrix *matrix) + { + return updateStatus(DllExports::GdipSetWorldTransform( + nativeGraphics, + matrix ? matrix->nativeMatrix : NULL)); + } + Status TransformPoints(CoordinateSpace destSpace, + CoordinateSpace srcSpace, + PointF *pts, INT count) const + { + return updateStatus(DllExports::GdipTransformPoints( + nativeGraphics, destSpace, srcSpace, + pts, count)); + } + Status TransformPoints(CoordinateSpace destSpace, + CoordinateSpace srcSpace, + Point *pts, INT count) const + { + return updateStatus(DllExports::GdipTransformPointsI( + nativeGraphics, destSpace, srcSpace, + pts, count)); + } + Status TranslateClip(REAL dx, REAL dy) + { + return updateStatus(DllExports::GdipTranslateClip( + nativeGraphics, dx, dy)); + } + Status TranslateClip(INT dx, INT dy) + { + return updateStatus(DllExports::GdipTranslateClipI( + nativeGraphics, dx, dy)); + } + Status TranslateTransform(REAL dx, REAL dy, + MatrixOrder order = MatrixOrderPrepend) + { + return updateStatus(DllExports::GdipTranslateWorldTransform( + nativeGraphics, dx, dy, order)); + } + +private: + Graphics(const Graphics&); + Graphics& operator=(const Graphics&); + + Status updateStatus(Status newStatus) const + { + if (newStatus != Ok) lastStatus = newStatus; + return newStatus; + } + + GpGraphics *nativeGraphics; + mutable Status lastStatus; +}; + +#endif /* __GDIPLUS_GRAPHICS_H */ diff --git a/winsup/w32api/include/gdiplus/gdiplusheaders.h b/winsup/w32api/include/gdiplus/gdiplusheaders.h new file mode 100755 index 000000000..92de81ae4 --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusheaders.h @@ -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 + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusimageattributes.h b/winsup/w32api/include/gdiplus/gdiplusimageattributes.h new file mode 100755 index 000000000..0f7db98b2 --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusimageattributes.h @@ -0,0 +1,236 @@ +/* + * gdiplusimageattributes.h + * + * GDI+ ImageAttributes class + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusimagecodec.h b/winsup/w32api/include/gdiplus/gdiplusimagecodec.h new file mode 100755 index 000000000..6c76956ee --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusimagecodec.h @@ -0,0 +1,67 @@ +/* + * gdiplusimagecodec.h + * + * GDI+ image decoders and encoders + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusimaging.h b/winsup/w32api/include/gdiplus/gdiplusimaging.h new file mode 100755 index 000000000..d5e98ec0c --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusimaging.h @@ -0,0 +1,411 @@ +/* + * gdiplusimaging.h + * + * GDI+ Imaging and image metadata + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusimpl.h b/winsup/w32api/include/gdiplus/gdiplusimpl.h new file mode 100755 index 000000000..5365e865d --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusimpl.h @@ -0,0 +1,1613 @@ +/* + * gdiplusimpl.h + * + * GDI+ Bitmap, CachedBitmap, CustomLineCap, Font, FontCollection, FontFamily, + * Image, InstalledFontCollection, PrivateFontCollection, Region + * implementation. Definitions of these classes are in gdiplusheaders.h. + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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_IMPL_H +#define __GDIPLUS_IMPL_H +#if __GNUC__ >=3 +#pragma GCC system_header +#endif + +#ifndef __cplusplus +#error "A C++ compiler is required to include gdiplusimpl.h." +#endif + +/* + * FIXME: I called this file gdiplusimpl.h, but what should it really be called? + * Or did Microsoft create separate files for each class implemented here? + */ + + +// Image + +__inline__ Image* Image::FromFile(const WCHAR *filename, + BOOL useEmbeddedColorManagement) +{ + return new Image(filename, useEmbeddedColorManagement); +} + +__inline__ Image* Image::FromStream(IStream *stream, + BOOL useEmbeddedColorManagement) +{ + return new Image(stream, useEmbeddedColorManagement); +} + +__inline__ Image::Image(const WCHAR *filename, BOOL useEmbeddedColorManagement): + nativeImage(NULL), lastStatus(Ok) +{ + if (useEmbeddedColorManagement) { + lastStatus = DllExports::GdipLoadImageFromFileICM( + filename, &nativeImage); + } else { + lastStatus = DllExports::GdipLoadImageFromFile( + filename, &nativeImage); + } +} + +__inline__ Image::Image(IStream *stream, BOOL useEmbeddedColorManagement): + nativeImage(NULL), lastStatus(Ok) +{ + if (useEmbeddedColorManagement) { + lastStatus = DllExports::GdipLoadImageFromStreamICM( + stream, &nativeImage); + } else { + lastStatus = DllExports::GdipLoadImageFromStream( + stream, &nativeImage); + } +} + +__inline__ Status Image::FindFirstItem(ImageItemData *item) +{ + // FIXME: can't test GdipFindFirstImageItem b/c it isn't exported in 1.0 + return updateStatus(DllExports::GdipFindFirstImageItem( + nativeImage, item)); +} + +__inline__ Status Image::FindNextItem(ImageItemData *item) +{ + // FIXME: can't test GdipFindFirstImageItem b/c it isn't exported in 1.0 + return updateStatus(DllExports::GdipFindNextImageItem( + nativeImage, item)); +} + +__inline__ Status Image::GetAllPropertyItems(UINT totalBufferSize, + UINT numProperties, PropertyItem *allItems) +{ + return updateStatus(DllExports::GdipGetAllPropertyItems( + nativeImage, totalBufferSize, numProperties, allItems)); +} + +__inline__ Status Image::GetBounds(RectF *srcRect, Unit *srcUnit) +{ + return updateStatus(DllExports::GdipGetImageBounds( + nativeImage, srcRect, srcUnit)); +} + +__inline__ Status Image::GetEncoderParameterList(const CLSID *clsidEncoder, + UINT size, EncoderParameters *buffer) +{ + return updateStatus(DllExports::GdipGetEncoderParameterList( + nativeImage, clsidEncoder, size, buffer)); +} + +__inline__ UINT Image::GetEncoderParameterListSize(const CLSID *clsidEncoder) +{ + UINT result = 0; + updateStatus(DllExports::GdipGetEncoderParameterListSize( + nativeImage, clsidEncoder, &result)); + return result; +} + +__inline__ UINT Image::GetFlags() +{ + UINT result = 0; + updateStatus(DllExports::GdipGetImageFlags(nativeImage, &result)); + return result; +} + +__inline__ UINT Image::GetFrameCount(const GUID *dimensionID) +{ + UINT result = 0; + updateStatus(DllExports::GdipImageGetFrameCount( + nativeImage, dimensionID, &result)); + return result; +} + +__inline__ UINT Image::GetFrameDimensionsCount() +{ + UINT result = 0; + updateStatus(DllExports::GdipImageGetFrameDimensionsCount( + nativeImage, &result)); + return result; +} + +__inline__ Status Image::GetFrameDimensionsList(GUID *dimensionIDs, UINT count) +{ + return updateStatus(DllExports::GdipImageGetFrameDimensionsList( + nativeImage, dimensionIDs, count)); +} + +__inline__ UINT Image::GetHeight() +{ + UINT result = 0; + updateStatus(DllExports::GdipGetImageHeight(nativeImage, &result)); + return result; +} + +__inline__ REAL Image::GetHorizontalResolution() +{ + REAL result = 0.0f; + updateStatus(DllExports::GdipGetImageHorizontalResolution( + nativeImage, &result)); + return result; +} + +__inline__ Status Image::GetItemData(ImageItemData *item) +{ + // FIXME: can't test GdipGetImageItemData b/c it isn't exported in 1.0 + return updateStatus(DllExports::GdipGetImageItemData( + nativeImage, item)); +} + +__inline__ Status Image::GetPalette(ColorPalette *palette, INT size) +{ + return updateStatus(DllExports::GdipGetImagePalette( + nativeImage, palette, size)); +} + +__inline__ INT Image::GetPaletteSize() +{ + INT result = 0; + updateStatus(DllExports::GdipGetImagePaletteSize(nativeImage, &result)); + return result; +} + +__inline__ Status Image::GetPhysicalDimension(SizeF *size) +{ + if (!size) return lastStatus = InvalidParameter; + return updateStatus(DllExports::GdipGetImageDimension( + nativeImage, &size->Width, &size->Height)); +} + +__inline__ PixelFormat Image::GetPixelFormat() +{ + PixelFormat result = (PixelFormat) 0; + updateStatus(DllExports::GdipGetImagePixelFormat(nativeImage, &result)); + return result; +} + +__inline__ UINT Image::GetPropertyCount() +{ + UINT result = 0; + updateStatus(DllExports::GdipGetPropertyCount(nativeImage, &result)); + return result; +} + +__inline__ Status Image::GetPropertyIdList(UINT numOfProperty, PROPID *list) +{ + return updateStatus(DllExports::GdipGetPropertyIdList( + nativeImage, numOfProperty, list)); +} + +__inline__ Status Image::GetPropertyItem(PROPID propId, UINT propSize, + PropertyItem *buffer) +{ + return updateStatus(DllExports::GdipGetPropertyItem( + nativeImage, propId, propSize, buffer)); +} + +__inline__ UINT Image::GetPropertyItemSize(PROPID propId) +{ + UINT result = 0; + updateStatus(DllExports::GdipGetPropertyItemSize( + nativeImage, propId, &result)); + return result; +} + +__inline__ Status Image::GetPropertySize( + UINT *totalBufferSize, UINT *numProperties) +{ + return updateStatus(DllExports::GdipGetPropertySize( + nativeImage, totalBufferSize, numProperties)); +} + +__inline__ Status Image::GetRawFormat(GUID *format) +{ + return updateStatus(DllExports::GdipGetImageRawFormat( + nativeImage, format)); +} + +__inline__ Image* Image::GetThumbnailImage(UINT thumbWidth, UINT thumbHeight, + GetThumbnailImageAbort callback, VOID *callbackData) +{ + GpImage *thumbImage = NULL; + Status status = updateStatus(DllExports::GdipGetImageThumbnail( + nativeImage, thumbWidth, thumbHeight, &thumbImage, + callback, callbackData)); + + if (status == Ok) { + Image *result = new Image(thumbImage, Ok); + if (!result) { + DllExports::GdipDisposeImage(thumbImage); + lastStatus = OutOfMemory; + } + return result; + } else { + return NULL; + } +} + +__inline__ ImageType Image::GetType() const +{ + ImageType result = ImageTypeUnknown; + updateStatus(DllExports::GdipGetImageType(nativeImage, &result)); + return result; +} + +__inline__ REAL Image::GetVerticalResolution() +{ + REAL result = 0.0f; + updateStatus(DllExports::GdipGetImageVerticalResolution( + nativeImage, &result)); + return result; +} + +__inline__ UINT Image::GetWidth() +{ + UINT result = 0; + updateStatus(DllExports::GdipGetImageWidth(nativeImage, &result)); + return result; +} + +__inline__ Status Image::RemovePropertyItem(PROPID propId) +{ + return updateStatus(DllExports::GdipRemovePropertyItem( + nativeImage, propId)); +} + +__inline__ Status Image::RotateFlip(RotateFlipType rotateFlipType) +{ + return updateStatus(DllExports::GdipImageRotateFlip( + nativeImage, rotateFlipType)); +} + +__inline__ Status Image::Save(const WCHAR *filename, const CLSID *clsidEncoder, + const EncoderParameters *encoderParams) +{ + return updateStatus(DllExports::GdipSaveImageToFile( + nativeImage, filename, clsidEncoder, encoderParams)); +} + +__inline__ Status Image::Save(IStream *stream, const CLSID *clsidEncoder, + const EncoderParameters *encoderParams) +{ + return updateStatus(DllExports::GdipSaveImageToStream( + nativeImage, stream, clsidEncoder, encoderParams)); +} + +__inline__ Status Image::SaveAdd(const EncoderParameters *encoderParams) +{ + return updateStatus(DllExports::GdipSaveAdd( + nativeImage, encoderParams)); +} + +__inline__ Status Image::SaveAdd(Image *newImage, + const EncoderParameters *encoderParams) +{ + return updateStatus(DllExports::GdipSaveAddImage( + nativeImage, + newImage ? newImage->nativeImage : NULL, + encoderParams)); +} + +__inline__ Status Image::SelectActiveFrame( + const GUID *dimensionID, UINT frameIndex) +{ + return updateStatus(DllExports::GdipImageSelectActiveFrame( + nativeImage, dimensionID, frameIndex)); +} + +__inline__ Status Image::SetAbort(GdiplusAbort *pIAbort) +{ + // FIXME: can't test GdipImageSetAbort because it isn't exported in 1.0 + return updateStatus(DllExports::GdipImageSetAbort( + nativeImage, pIAbort)); +} + +__inline__ Status Image::SetPalette(const ColorPalette *palette) +{ + return updateStatus(DllExports::GdipSetImagePalette( + nativeImage, palette)); +} + +__inline__ Status Image::SetPropertyItem(const PropertyItem *item) +{ + return updateStatus(DllExports::GdipSetPropertyItem(nativeImage, item)); +} + + +// Bitmap + +__inline__ Bitmap* Bitmap::FromBITMAPINFO(const BITMAPINFO *gdiBitmapInfo, + VOID *gdiBitmapData) +{ + return new Bitmap(gdiBitmapInfo, gdiBitmapData); +} + +__inline__ Bitmap* Bitmap::FromDirectDrawSurface7(IDirectDrawSurface7 *surface) +{ + return new Bitmap(surface); +} + +__inline__ Bitmap* Bitmap::FromFile(const WCHAR *filename, + BOOL useEmbeddedColorManagement) +{ + return new Bitmap(filename, useEmbeddedColorManagement); +} + +__inline__ Bitmap* Bitmap::FromHBITMAP(HBITMAP hbm, HPALETTE hpal) +{ + return new Bitmap(hbm, hpal); +} + +__inline__ Bitmap* Bitmap::FromHICON(HICON icon) +{ + return new Bitmap(icon); +} + +__inline__ Bitmap* Bitmap::FromResource( + HINSTANCE hInstance, const WCHAR *bitmapName) +{ + return new Bitmap(hInstance, bitmapName); +} + +__inline__ Bitmap* Bitmap::FromStream(IStream *stream, + BOOL useEmbeddedColorManagement) +{ + return new Bitmap(stream, useEmbeddedColorManagement); +} + +//TODO: [GDI+ 1.1] Bitmap::ApplyEffect +//__inline__ Status Bitmap::ApplyEffect(Bitmap **inputs, INT numInputs, +// Effect *effect, RECT *ROI, RECT *outputRect, Bitmap **output) +//{ +// return NotImplemented; +//} + +__inline__ Status Bitmap::InitializePalette(ColorPalette *palette, + PaletteType paletteType, INT optimalColors, + BOOL useTransparentColor, Bitmap *bitmap) +{ + // FIXME: can't test GdipInitializePalette b/c it isn't exported in 1.0 + return DllExports::GdipInitializePalette(palette, paletteType, + optimalColors, useTransparentColor, + bitmap ? (GpBitmap*) bitmap->nativeImage : NULL); +} + +__inline__ Bitmap::Bitmap(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData): + Image(NULL, Ok) +{ + GpBitmap *nativeBitmap = NULL; + lastStatus = DllExports::GdipCreateBitmapFromGdiDib( + gdiBitmapInfo, gdiBitmapData, &nativeBitmap); + nativeImage = nativeBitmap; +} + +__inline__ Bitmap::Bitmap(IDirectDrawSurface7 *surface): Image(NULL, Ok) +{ + GpBitmap *nativeBitmap = NULL; + lastStatus = DllExports::GdipCreateBitmapFromDirectDrawSurface( + surface, &nativeBitmap); + nativeImage = nativeBitmap; +} + +__inline__ Bitmap::Bitmap(const WCHAR *filename, + BOOL useEmbeddedColorManagement): Image(NULL, Ok) +{ + GpBitmap *nativeBitmap = NULL; + if (useEmbeddedColorManagement) { + lastStatus = DllExports::GdipCreateBitmapFromFileICM( + filename, &nativeBitmap); + } else { + lastStatus = DllExports::GdipCreateBitmapFromFile( + filename, &nativeBitmap); + } + nativeImage = nativeBitmap; +} + +__inline__ Bitmap::Bitmap(HBITMAP hbm, HPALETTE hpal): + Image(NULL, Ok) +{ + GpBitmap *nativeBitmap = NULL; + lastStatus = DllExports::GdipCreateBitmapFromHBITMAP( + hbm, hpal, &nativeBitmap); + nativeImage = nativeBitmap; +} + +__inline__ Bitmap::Bitmap(HICON hicon): + Image(NULL, Ok) +{ + GpBitmap *nativeBitmap = NULL; + lastStatus = DllExports::GdipCreateBitmapFromHICON(hicon, &nativeBitmap); + nativeImage = nativeBitmap; +} + +__inline__ Bitmap::Bitmap(HINSTANCE hInstance, const WCHAR *bitmapName): + Image(NULL, Ok) +{ + GpBitmap *nativeBitmap = NULL; + lastStatus = DllExports::GdipCreateBitmapFromResource( + hInstance, bitmapName, &nativeBitmap); + nativeImage = nativeBitmap; +} + +__inline__ Bitmap::Bitmap(IStream *stream, BOOL useEmbeddedColorManagement): + Image(NULL, Ok) +{ + GpBitmap *nativeBitmap = NULL; + if (useEmbeddedColorManagement) { + lastStatus = DllExports::GdipCreateBitmapFromStreamICM( + stream, &nativeBitmap); + } else { + lastStatus = DllExports::GdipCreateBitmapFromStream( + stream, &nativeBitmap); + } + nativeImage = nativeBitmap; +} + +__inline__ Bitmap::Bitmap(INT width, INT height, Graphics *target): + Image(NULL, Ok) +{ + GpBitmap *nativeBitmap = NULL; + lastStatus = DllExports::GdipCreateBitmapFromGraphics( + width, height, target ? target->nativeGraphics : NULL, + &nativeBitmap); + nativeImage = nativeBitmap; +} + +__inline__ Bitmap::Bitmap(INT width, INT height, PixelFormat format): + Image(NULL, Ok) +{ + GpBitmap *nativeBitmap = NULL; + lastStatus = DllExports::GdipCreateBitmapFromScan0( + width, height, 0, format, NULL, &nativeBitmap); + nativeImage = nativeBitmap; +} + +__inline__ Bitmap::Bitmap(INT width, INT height, INT stride, + PixelFormat format, BYTE *scan0): Image(NULL, Ok) +{ + GpBitmap *nativeBitmap = NULL; + lastStatus = DllExports::GdipCreateBitmapFromScan0( + width, height, stride, format, scan0, &nativeBitmap); + nativeImage = nativeBitmap; +} + +__inline__ Bitmap* Bitmap::Clone(const RectF& rect, PixelFormat format) const +{ + return Clone(rect.X, rect.Y, rect.Width, rect.Height, format); +} + +__inline__ Bitmap* Bitmap::Clone(const Rect& rect, PixelFormat format) const +{ + return Clone(rect.X, rect.Y, rect.Width, rect.Height, format); +} + +__inline__ Bitmap* Bitmap::Clone(REAL x, REAL y, REAL width, REAL height, + PixelFormat format) const +{ + GpBitmap *cloneBitmap = NULL; + Status status = updateStatus(DllExports::GdipCloneBitmapArea( + x, y, width, height, format, + (GpBitmap*) nativeImage, &cloneBitmap)); + if (status == Ok) { + Bitmap *result = new Bitmap(cloneBitmap, lastStatus); + if (!result) { + DllExports::GdipDisposeImage(cloneBitmap); + lastStatus = OutOfMemory; + } + return result; + } else { + return NULL; + } +} + +__inline__ Bitmap* Bitmap::Clone(INT x, INT y, INT width, INT height, + PixelFormat format) const +{ + GpBitmap *cloneBitmap = NULL; + Status status = updateStatus(DllExports::GdipCloneBitmapAreaI( + x, y, width, height, format, + (GpBitmap*) nativeImage, &cloneBitmap)); + if (status == Ok) { + Bitmap *result = new Bitmap(cloneBitmap, lastStatus); + if (!result) { + DllExports::GdipDisposeImage(cloneBitmap); + lastStatus = OutOfMemory; + } + return result; + } else { + return NULL; + } +} + +//TODO: [GDI+ 1.1] Bitmap::ApplyEffect +//__inline__ Status Bitmap::ApplyEffect(Effect *effect, RECT *ROI) +//{ +// return NotImplemented; +//} + +__inline__ Status Bitmap::ConvertFormat(PixelFormat format, + DitherType ditherType, PaletteType paletteType, + ColorPalette *palette, REAL alphaThresholdPercent) +{ + // FIXME: can't test GdipBitmapConvertFormat b/c it isn't exported in 1.0 + return updateStatus(DllExports::GdipBitmapConvertFormat( + (GpBitmap*) nativeImage, format, ditherType, + paletteType, palette, alphaThresholdPercent)); +} + +__inline__ Status Bitmap::GetHBITMAP( + const Color& colorBackground, HBITMAP *hbmReturn) const +{ + return updateStatus(DllExports::GdipCreateHBITMAPFromBitmap( + (GpBitmap*) nativeImage, hbmReturn, + colorBackground.GetValue())); +} + +__inline__ Status Bitmap::GetHICON(HICON *icon) const +{ + return updateStatus(DllExports::GdipCreateHICONFromBitmap( + (GpBitmap*) nativeImage, icon)); +} + +__inline__ Status Bitmap::GetHistogram(HistogramFormat format, + UINT numberOfEntries, + UINT *channel0, UINT *channel1, + UINT *channel2, UINT *channel3) const +{ + return updateStatus(DllExports::GdipBitmapGetHistogram( + (GpBitmap*) nativeImage, format, numberOfEntries, + channel0, channel1, channel2, channel3)); +} + +__inline__ Status Bitmap::GetHistogramSize(HistogramFormat format, + UINT *numberOfEntries) const +{ + return updateStatus(DllExports::GdipBitmapGetHistogramSize( + format, numberOfEntries)); +} + +__inline__ Status Bitmap::GetPixel(INT x, INT y, Color *color) const +{ + return updateStatus(DllExports::GdipBitmapGetPixel( + (GpBitmap*) nativeImage, x, y, + color ? &color->Value : NULL)); +} + +__inline__ Status Bitmap::LockBits(const Rect *rect, UINT flags, + PixelFormat format, BitmapData *lockedBitmapData) +{ + return updateStatus(DllExports::GdipBitmapLockBits( + (GpBitmap*) nativeImage, rect, flags, format, + lockedBitmapData)); +} + +__inline__ Status Bitmap::SetPixel(INT x, INT y, const Color& color) +{ + return updateStatus(DllExports::GdipBitmapSetPixel( + (GpBitmap*) nativeImage, x, y, color.GetValue())); +} + +__inline__ Status Bitmap::SetResolution(REAL xdpi, REAL ydpi) +{ + return updateStatus(DllExports::GdipBitmapSetResolution( + (GpBitmap*) nativeImage, xdpi, ydpi)); +} + +__inline__ Status Bitmap::UnlockBits(BitmapData *lockedBitmapData) +{ + return updateStatus(DllExports::GdipBitmapUnlockBits( + (GpBitmap*) nativeImage, lockedBitmapData)); +} + + +// CachedBitmap + +__inline__ CachedBitmap::CachedBitmap(Bitmap *bitmap, Graphics *graphics): + nativeCachedBitmap(NULL), lastStatus(Ok) +{ + lastStatus = DllExports::GdipCreateCachedBitmap( + bitmap ? ((GpBitmap*) bitmap->nativeImage) : NULL, + graphics ? graphics->nativeGraphics : NULL, + &nativeCachedBitmap); +} + +__inline__ CachedBitmap::~CachedBitmap() +{ + DllExports::GdipDeleteCachedBitmap(nativeCachedBitmap); +} + + +// CustomLineCap + +__inline__ CustomLineCap::CustomLineCap( + const GraphicsPath *fillPath, + const GraphicsPath *strokePath, + LineCap baseCap, REAL baseInset): + nativeCustomLineCap(NULL), lastStatus(Ok) +{ + lastStatus = DllExports::GdipCreateCustomLineCap( + fillPath ? fillPath->nativePath : NULL, + strokePath ? strokePath->nativePath : NULL, + baseCap, baseInset, &nativeCustomLineCap); +} + +__inline__ LineCap CustomLineCap::GetBaseCap() const +{ + LineCap result = LineCapFlat; + updateStatus(DllExports::GdipGetCustomLineCapBaseCap( + nativeCustomLineCap, &result)); + return result; +} + +__inline__ REAL CustomLineCap::GetBaseInset() const +{ + REAL result = 0.0f; + updateStatus(DllExports::GdipGetCustomLineCapBaseInset( + nativeCustomLineCap, &result)); + return result; +} + +__inline__ Status CustomLineCap::GetStrokeCaps(LineCap *startCap, + LineCap *endCap) const +{ + return updateStatus(DllExports::GdipGetCustomLineCapStrokeCaps( + nativeCustomLineCap, startCap, endCap)); +} + +__inline__ LineJoin CustomLineCap::GetStrokeJoin() const +{ + LineJoin result = LineJoinMiter; + updateStatus(DllExports::GdipGetCustomLineCapStrokeJoin( + nativeCustomLineCap, &result)); + return result; +} + +__inline__ REAL CustomLineCap::GetWidthScale() const +{ + REAL result = 0.0f; + updateStatus(DllExports::GdipGetCustomLineCapWidthScale( + nativeCustomLineCap, &result)); + return result; +} + +__inline__ Status CustomLineCap::SetBaseCap(LineCap baseCap) +{ + return updateStatus(DllExports::GdipSetCustomLineCapBaseCap( + nativeCustomLineCap, baseCap)); +} + +__inline__ Status CustomLineCap::SetBaseInset(REAL inset) +{ + return updateStatus(DllExports::GdipSetCustomLineCapBaseInset( + nativeCustomLineCap, inset)); +} + +__inline__ Status CustomLineCap::SetStrokeCap(LineCap strokeCap) +{ + return updateStatus(DllExports::GdipSetCustomLineCapStrokeCaps( + nativeCustomLineCap, strokeCap, strokeCap)); +} + +__inline__ Status CustomLineCap::SetStrokeCaps(LineCap startCap, LineCap endCap) +{ + return updateStatus(DllExports::GdipSetCustomLineCapStrokeCaps( + nativeCustomLineCap, startCap, endCap)); +} + +__inline__ Status CustomLineCap::SetStrokeJoin(LineJoin lineJoin) +{ + return updateStatus(DllExports::GdipSetCustomLineCapStrokeJoin( + nativeCustomLineCap, lineJoin)); +} + +__inline__ Status CustomLineCap::SetWidthScale(REAL widthScale) +{ + return updateStatus(DllExports::GdipSetCustomLineCapWidthScale( + nativeCustomLineCap, widthScale)); +} + + +// Font + +__inline__ Font::Font(const FontFamily *family, + REAL emSize, INT style, Unit unit): + nativeFont(NULL), lastStatus(Ok) +{ + lastStatus = DllExports::GdipCreateFont( + family ? family->nativeFontFamily : NULL, + emSize, style, unit, &nativeFont); +} + +__inline__ Font::Font(HDC hdc, HFONT hfont): + nativeFont(NULL), lastStatus(Ok) +{ + LOGFONTW logfont; + if (GetObject(hfont, sizeof logfont, &logfont)) { + lastStatus = DllExports::GdipCreateFontFromLogfontW( + hdc, &logfont, &nativeFont); + } else { + lastStatus = DllExports::GdipCreateFontFromDC( + hdc, &nativeFont); + } +} + +__inline__ Font::Font(HDC hdc, const LOGFONTA *logfont): + nativeFont(NULL), lastStatus(Ok) +{ + lastStatus = DllExports::GdipCreateFontFromLogfontA( + hdc, logfont, &nativeFont); +} + +__inline__ Font::Font(HDC hdc, const LOGFONTW *logfont): + nativeFont(NULL), lastStatus(Ok) +{ + lastStatus = DllExports::GdipCreateFontFromLogfontW( + hdc, logfont, &nativeFont); +} + +__inline__ Font::Font(HDC hdc): + nativeFont(NULL), lastStatus(Ok) +{ + lastStatus = DllExports::GdipCreateFontFromDC(hdc, &nativeFont); +} + +__inline__ Font::Font(const WCHAR *familyName, REAL emSize, INT style, + Unit unit, const FontCollection *fontCollection): + nativeFont(NULL), lastStatus(Ok) +{ + GpFontFamily *nativeFamily = NULL; + lastStatus = DllExports::GdipCreateFontFamilyFromName( + familyName, + fontCollection ? fontCollection->nativeFontCollection : NULL, + &nativeFamily); + + if (nativeFamily) { + lastStatus = DllExports::GdipCreateFont( + nativeFamily, emSize, style, unit, &nativeFont); + DllExports::GdipDeleteFontFamily(nativeFamily); + } +} + +__inline__ Font::~Font() +{ + DllExports::GdipDeleteFont(nativeFont); +} + +__inline__ Font* Font::Clone() const +{ + GpFont *cloneFont = NULL; + Status status = updateStatus(DllExports::GdipCloneFont( + nativeFont, &cloneFont)); + if (status == Ok) { + Font *result = new Font(cloneFont, lastStatus); + if (!result) { + DllExports::GdipDeleteFont(cloneFont); + lastStatus = OutOfMemory; + } + return result; + } else { + return NULL; + } +} + +__inline__ Status Font::GetFamily(FontFamily *family) const +{ + if (!family) return lastStatus = InvalidParameter; + // FIXME: do we need to call GdipDeleteFontFamily first? + return family->lastStatus = updateStatus(DllExports::GdipGetFamily( + nativeFont, &family->nativeFontFamily)); +} + +__inline__ REAL Font::GetHeight(const Graphics *graphics) const +{ + REAL result = 0.0f; + updateStatus(DllExports::GdipGetFontHeight( + nativeFont, graphics ? graphics->nativeGraphics : NULL, + &result)); + return result; +} + +__inline__ REAL Font::GetHeight(REAL dpi) const +{ + REAL result = 0.0f; + updateStatus(DllExports::GdipGetFontHeightGivenDPI( + nativeFont, dpi, &result)); + return result; +} + +__inline__ Status Font::GetLogFontA(const Graphics *graphics, LOGFONTA *logfontA) +const +{ + return updateStatus(DllExports::GdipGetLogFontA( + nativeFont, graphics ? graphics->nativeGraphics : NULL, + logfontA)); +} + +__inline__ Status Font::GetLogFontW(const Graphics *graphics, LOGFONTW *logfontW) +const +{ + return updateStatus(DllExports::GdipGetLogFontW( + nativeFont, graphics ? graphics->nativeGraphics : NULL, + logfontW)); +} + +__inline__ REAL Font::GetSize() const +{ + REAL result = 0.0; + updateStatus(DllExports::GdipGetFontSize(nativeFont, &result)); + return result; +} + +__inline__ INT Font::GetStyle() const +{ + INT result = FontStyleRegular; + updateStatus(DllExports::GdipGetFontStyle(nativeFont, &result)); + return result; +} + +__inline__ Unit Font::GetUnit() const +{ + Unit result = UnitPoint; + updateStatus(DllExports::GdipGetFontUnit(nativeFont, &result)); + return result; +} + + +// FontCollection + +__inline__ FontCollection::FontCollection(): + nativeFontCollection(NULL), lastStatus(Ok) +{ +} + +__inline__ Status FontCollection::GetFamilies(INT numSought, + FontFamily *families, INT *numFound) const +{ + if (numSought <= 0 || !families || !numFound) + return lastStatus = InvalidParameter; + + for (int i = 0; i < numSought; ++i) { + families[i].nativeFontFamily = NULL; + families[i].lastStatus = FontFamilyNotFound; + } + *numFound = 0; + + GpFontFamily **nativeFamilyArray = (GpFontFamily**) + DllExports::GdipAlloc(numSought * sizeof (GpFontFamily*)); + if (!nativeFamilyArray) + return lastStatus = OutOfMemory; + + Status status = updateStatus(DllExports::GdipGetFontCollectionFamilyList( + nativeFontCollection, numSought, nativeFamilyArray, + numFound)); + + // FIXME: must the native GpFontFamily objects be cloned? Seems so. + // (if this is not done, the "Creating a Private Font Collection" + // example crashes on "delete[] pFontFamily") + + if (status == Ok) { + for (int i = 0; i < *numFound; ++i) { + families[i].lastStatus = + updateStatus(DllExports::GdipCloneFontFamily( + nativeFamilyArray[i], + &families[i].nativeFontFamily)); + } + } + + DllExports::GdipFree(nativeFamilyArray); + return status; +} + +__inline__ INT FontCollection::GetFamilyCount() const +{ + INT result = 0; + updateStatus(DllExports::GdipGetFontCollectionFamilyCount( + nativeFontCollection, &result)); + return result; +} + + +// FontFamily + +// FIXME: do FontFamily::GenericMonospace() et al. need to be thread safe? +// FIXME: maybe put parts of this in gdiplus.c + +extern "C" void *_GdipFontFamilyCachedGenericMonospace; +extern "C" void *_GdipFontFamilyCachedGenericSansSerif; +extern "C" void *_GdipFontFamilyCachedGenericSerif; + +__inline__ const FontFamily* FontFamily::GenericMonospace() +{ + if (!_GdipFontFamilyCachedGenericMonospace) { + GpFontFamily *nativeFontFamily = 0; + Status status = DllExports::GdipGetGenericFontFamilyMonospace( + &nativeFontFamily); + if (status == Ok && nativeFontFamily) { + _GdipFontFamilyCachedGenericMonospace = (void*) + new FontFamily(nativeFontFamily, Ok); + } + } + return (FontFamily*) _GdipFontFamilyCachedGenericMonospace; +} + +__inline__ const FontFamily* FontFamily::GenericSansSerif() +{ + if (!_GdipFontFamilyCachedGenericSansSerif) { + GpFontFamily *nativeFontFamily = 0; + Status status = DllExports::GdipGetGenericFontFamilySansSerif( + &nativeFontFamily); + if (status == Ok && nativeFontFamily) { + _GdipFontFamilyCachedGenericSansSerif = (void*) + new FontFamily(nativeFontFamily, Ok); + } + } + return (FontFamily*) _GdipFontFamilyCachedGenericSansSerif; +} + +__inline__ const FontFamily* FontFamily::GenericSerif() +{ + if (!_GdipFontFamilyCachedGenericSerif) { + GpFontFamily *nativeFontFamily = 0; + Status status = DllExports::GdipGetGenericFontFamilySerif( + &nativeFontFamily); + if (status == Ok && nativeFontFamily) { + _GdipFontFamilyCachedGenericSerif = (void*) + new FontFamily(nativeFontFamily, Ok); + } + } + return (FontFamily*) _GdipFontFamilyCachedGenericSerif; +} + +__inline__ FontFamily::FontFamily(): + nativeFontFamily(NULL), lastStatus(Ok) +{ +} + +__inline__ FontFamily::FontFamily(const WCHAR *name, + const FontCollection *fontCollection): + nativeFontFamily(NULL), lastStatus(Ok) +{ + lastStatus = DllExports::GdipCreateFontFamilyFromName(name, + fontCollection ? fontCollection->nativeFontCollection : NULL, + &nativeFontFamily); +} + +__inline__ FontFamily::~FontFamily() +{ + DllExports::GdipDeleteFontFamily(nativeFontFamily); +} + +__inline__ FontFamily* FontFamily::Clone() const +{ + GpFontFamily *cloneFontFamily = NULL; + Status status = updateStatus(DllExports::GdipCloneFontFamily( + nativeFontFamily, &cloneFontFamily)); + if (status == Ok) { + FontFamily *result = new FontFamily(cloneFontFamily, lastStatus); + if (!result) { + DllExports::GdipDeleteFontFamily(cloneFontFamily); + lastStatus = OutOfMemory; + } + return result; + } else { + return NULL; + } +} + +__inline__ UINT16 FontFamily::GetCellAscent(INT style) const +{ + UINT16 result = 0; + updateStatus(DllExports::GdipGetCellAscent( + nativeFontFamily, style, &result)); + return result; +} + +__inline__ UINT16 FontFamily::GetCellDescent(INT style) const +{ + UINT16 result = 0; + updateStatus(DllExports::GdipGetCellDescent( + nativeFontFamily, style, &result)); + return result; +} + +__inline__ UINT16 FontFamily::GetEmHeight(INT style) const +{ + UINT16 result = 0; + updateStatus(DllExports::GdipGetEmHeight( + nativeFontFamily, style, &result)); + return result; +} + +__inline__ Status FontFamily::GetFamilyName(WCHAR name[LF_FACESIZE], + LANGID language) const +{ + return updateStatus(DllExports::GdipGetFamilyName( + nativeFontFamily, name, language)); +} + +__inline__ UINT16 FontFamily::GetLineSpacing(INT style) const +{ + UINT16 result = 0; + updateStatus(DllExports::GdipGetLineSpacing( + nativeFontFamily, style, &result)); + return result; +} + +__inline__ BOOL FontFamily::IsStyleAvailable(INT style) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsStyleAvailable( + nativeFontFamily, style, &result)); + return result; +} + + +// InstalledFontCollection + +__inline__ InstalledFontCollection::InstalledFontCollection() +{ + lastStatus = DllExports::GdipNewInstalledFontCollection( + &nativeFontCollection); +} + + +// PrivateFontCollection + +__inline__ PrivateFontCollection::PrivateFontCollection() +{ + lastStatus = DllExports::GdipNewPrivateFontCollection( + &nativeFontCollection); +} + +__inline__ Status PrivateFontCollection::AddFontFile(const WCHAR *filename) +{ + return updateStatus(DllExports::GdipPrivateAddFontFile( + nativeFontCollection, filename)); +} + +__inline__ Status PrivateFontCollection::AddMemoryFont( + const VOID *memory, INT length) +{ + return updateStatus(DllExports::GdipPrivateAddMemoryFont( + nativeFontCollection, memory, length)); +} + + +// Region + +__inline__ Region* Region::FromHRGN(HRGN hrgn) +{ + return new Region(hrgn); +} + +__inline__ Region::Region(): nativeRegion(NULL), lastStatus(Ok) +{ + lastStatus = DllExports::GdipCreateRegion(&nativeRegion); +} + +__inline__ Region::Region(const RectF& rect): nativeRegion(NULL), lastStatus(Ok) +{ + lastStatus = DllExports::GdipCreateRegionRect(&rect, &nativeRegion); +} + +__inline__ Region::Region(const Rect& rect): nativeRegion(NULL), lastStatus(Ok) +{ + lastStatus = DllExports::GdipCreateRegionRectI(&rect, &nativeRegion); +} + +__inline__ Region::Region(const GraphicsPath *path): + nativeRegion(NULL), lastStatus(Ok) +{ + lastStatus = DllExports::GdipCreateRegionPath( + path ? path->nativePath : NULL, &nativeRegion); +} + +__inline__ Region::Region(const BYTE *regionData, INT size): + nativeRegion(NULL), lastStatus(Ok) +{ + lastStatus = DllExports::GdipCreateRegionRgnData( + regionData, size, &nativeRegion); +} + +__inline__ Region::Region(HRGN hrgn): nativeRegion(NULL), lastStatus(Ok) +{ + lastStatus = DllExports::GdipCreateRegionHrgn(hrgn, &nativeRegion); +} + +__inline__ Region::~Region() +{ + DllExports::GdipDeleteRegion(nativeRegion); +} + +__inline__ Region* Region::Clone() const +{ + GpRegion *cloneRegion = NULL; + Status status = updateStatus(DllExports::GdipCloneRegion( + nativeRegion, &cloneRegion)); + if (status == Ok) { + Region *result = new Region(cloneRegion, lastStatus); + if (!result) { + DllExports::GdipDeleteRegion(cloneRegion); + lastStatus = OutOfMemory; + } + return result; + } else { + return NULL; + } +} + +__inline__ Status Region::Complement(const RectF& rect) +{ + return updateStatus(DllExports::GdipCombineRegionRect( + nativeRegion, &rect, CombineModeComplement)); +} + +__inline__ Status Region::Complement(const Rect& rect) +{ + return updateStatus(DllExports::GdipCombineRegionRectI( + nativeRegion, &rect, CombineModeComplement)); +} + +__inline__ Status Region::Complement(const Region *region) +{ + return updateStatus(DllExports::GdipCombineRegionRegion( + nativeRegion, region ? region->nativeRegion : NULL, + CombineModeComplement)); +} + +__inline__ Status Region::Complement(const GraphicsPath *path) +{ + return updateStatus(DllExports::GdipCombineRegionPath( + nativeRegion, path ? path->nativePath : NULL, + CombineModeComplement)); +} + +__inline__ BOOL Region::Equals(const Region *region, const Graphics *graphics) +const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsEqualRegion( + nativeRegion, region ? region->nativeRegion : NULL, + graphics ? graphics->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ Status Region::Exclude(const RectF& rect) +{ + return updateStatus(DllExports::GdipCombineRegionRect( + nativeRegion, &rect, CombineModeExclude)); +} + +__inline__ Status Region::Exclude(const Rect& rect) +{ + return updateStatus(DllExports::GdipCombineRegionRectI( + nativeRegion, &rect, CombineModeExclude)); +} + +__inline__ Status Region::Exclude(const Region *region) +{ + return updateStatus(DllExports::GdipCombineRegionRegion( + nativeRegion, region ? region->nativeRegion : NULL, + CombineModeExclude)); +} + +__inline__ Status Region::Exclude(const GraphicsPath *path) +{ + return updateStatus(DllExports::GdipCombineRegionPath( + nativeRegion, path ? path->nativePath : NULL, + CombineModeExclude)); +} + +__inline__ Status Region::GetBounds(RectF *rect, const Graphics *graphics) const +{ + return updateStatus(DllExports::GdipGetRegionBounds(nativeRegion, + graphics ? graphics->nativeGraphics : NULL, rect)); +} + +__inline__ Status Region::GetBounds(Rect *rect, const Graphics *graphics) const +{ + return updateStatus(DllExports::GdipGetRegionBoundsI(nativeRegion, + graphics ? graphics->nativeGraphics : NULL, rect)); +} + +__inline__ Status Region::GetData(BYTE *buffer, UINT bufferSize, + UINT *sizeFilled) const +{ + return updateStatus(DllExports::GdipGetRegionData( + nativeRegion, buffer, bufferSize, sizeFilled)); +} + +__inline__ UINT Region::GetDataSize() const +{ + UINT result = 0; + updateStatus(DllExports::GdipGetRegionDataSize(nativeRegion, &result)); + return result; +} + +__inline__ HRGN Region::GetHRGN(const Graphics *graphics) const +{ + HRGN result = NULL; + updateStatus(DllExports::GdipGetRegionHRgn(nativeRegion, + graphics ? graphics->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ Status Region::GetRegionScans(const Matrix *matrix, + RectF *rects, INT *count) const +{ + return updateStatus(DllExports::GdipGetRegionScans( + nativeRegion, rects, count, + matrix ? matrix->nativeMatrix : NULL)); +} + +__inline__ Status Region::GetRegionScans(const Matrix *matrix, + Rect *rects, INT *count) const +{ + return updateStatus(DllExports::GdipGetRegionScansI( + nativeRegion, rects, count, + matrix ? matrix->nativeMatrix : NULL)); +} + +__inline__ UINT Region::GetRegionScansCount(const Matrix *matrix) const +{ + UINT result = 0; + updateStatus(DllExports::GdipGetRegionScansCount( + nativeRegion, &result, + matrix ? matrix->nativeMatrix : NULL)); + return result; +} + +__inline__ Status Region::Intersect(const RectF& rect) +{ + return updateStatus(DllExports::GdipCombineRegionRect( + nativeRegion, &rect, CombineModeIntersect)); +} + +__inline__ Status Region::Intersect(const Rect& rect) +{ + return updateStatus(DllExports::GdipCombineRegionRectI( + nativeRegion, &rect, CombineModeIntersect)); +} + +__inline__ Status Region::Intersect(const Region *region) +{ + return updateStatus(DllExports::GdipCombineRegionRegion( + nativeRegion, region ? region->nativeRegion : NULL, + CombineModeIntersect)); +} + +__inline__ Status Region::Intersect(const GraphicsPath *path) +{ + return updateStatus(DllExports::GdipCombineRegionPath( + nativeRegion, path ? path->nativePath : NULL, + CombineModeIntersect)); +} + +__inline__ BOOL Region::IsEmpty(const Graphics *graphics) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsEmptyRegion(nativeRegion, + graphics ? graphics->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL Region::IsInfinite(const Graphics *graphics) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsInfiniteRegion(nativeRegion, + graphics ? graphics->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL Region::IsVisible(REAL x, REAL y, + const Graphics *graphics) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisibleRegionPoint( + nativeRegion, x, y, + graphics ? graphics->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL Region::IsVisible(INT x, INT y, + const Graphics *graphics) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisibleRegionPointI( + nativeRegion, x, y, + graphics ? graphics->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL Region::IsVisible(const PointF& point, + const Graphics *graphics) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisibleRegionPoint( + nativeRegion, point.X, point.Y, + graphics ? graphics->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL Region::IsVisible(const Point& point, + const Graphics *graphics) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisibleRegionPointI( + nativeRegion, point.X, point.Y, + graphics ? graphics->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL Region::IsVisible(REAL x, REAL y, REAL width, REAL height, + const Graphics *graphics) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisibleRegionRect( + nativeRegion, x, y, width, height, + graphics ? graphics->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL Region::IsVisible(INT x, INT y, INT width, INT height, + const Graphics *graphics) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisibleRegionRectI( + nativeRegion, x, y, width, height, + graphics ? graphics->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL Region::IsVisible(const RectF& rect, + const Graphics *graphics) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisibleRegionRect( + nativeRegion, rect.X, rect.Y, rect.Width, rect.Height, + graphics ? graphics->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL Region::IsVisible(const Rect& rect, + const Graphics *graphics) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisibleRegionRectI( + nativeRegion, rect.X, rect.Y, rect.Width, rect.Height, + graphics ? graphics->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ Status Region::MakeEmpty() +{ + return updateStatus(DllExports::GdipSetEmpty(nativeRegion)); +} + +__inline__ Status Region::MakeInfinite() +{ + return updateStatus(DllExports::GdipSetInfinite(nativeRegion)); +} + +__inline__ Status Region::Transform(const Matrix *matrix) +{ + return updateStatus(DllExports::GdipTransformRegion( + nativeRegion, matrix ? matrix->nativeMatrix : NULL)); +} + +__inline__ Status Region::Translate(REAL dx, REAL dy) +{ + return updateStatus(DllExports::GdipTranslateRegion( + nativeRegion, dx, dy)); +} + +__inline__ Status Region::Translate(INT dx, INT dy) +{ + return updateStatus(DllExports::GdipTranslateRegionI( + nativeRegion, dx, dy)); +} + +__inline__ Status Region::Union(const RectF& rect) +{ + return updateStatus(DllExports::GdipCombineRegionRect( + nativeRegion, &rect, CombineModeUnion)); +} + +__inline__ Status Region::Union(const Rect& rect) +{ + return updateStatus(DllExports::GdipCombineRegionRectI( + nativeRegion, &rect, CombineModeUnion)); +} + +__inline__ Status Region::Union(const Region *region) +{ + return updateStatus(DllExports::GdipCombineRegionRegion( + nativeRegion, region ? region->nativeRegion : NULL, + CombineModeUnion)); +} + +__inline__ Status Region::Union(const GraphicsPath *path) +{ + return updateStatus(DllExports::GdipCombineRegionPath( + nativeRegion, path ? path->nativePath : NULL, + CombineModeUnion)); +} + +__inline__ Status Region::Xor(const RectF& rect) +{ + return updateStatus(DllExports::GdipCombineRegionRect( + nativeRegion, &rect, CombineModeXor)); +} + +__inline__ Status Region::Xor(const Rect& rect) +{ + return updateStatus(DllExports::GdipCombineRegionRectI( + nativeRegion, &rect, CombineModeXor)); +} + +__inline__ Status Region::Xor(const Region *region) +{ + return updateStatus(DllExports::GdipCombineRegionRegion( + nativeRegion, region ? region->nativeRegion : NULL, + CombineModeXor)); +} + +__inline__ Status Region::Xor(const GraphicsPath *path) +{ + return updateStatus(DllExports::GdipCombineRegionPath( + nativeRegion, path ? path->nativePath : NULL, + CombineModeXor)); +} + + +// GraphicsPath + +__inline__ BOOL GraphicsPath::IsOutlineVisible(REAL x, REAL y, const Pen *pen, + const Graphics *g) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsOutlineVisiblePathPoint( + nativePath, x, y, pen ? pen->nativePen : NULL, + g ? g->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL GraphicsPath::IsOutlineVisible(INT x, INT y, const Pen *pen, + const Graphics *g) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsOutlineVisiblePathPointI( + nativePath, x, y, pen ? pen->nativePen : NULL, + g ? g->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL GraphicsPath::IsOutlineVisible(const PointF& point, const Pen *pen, + const Graphics *g) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsOutlineVisiblePathPoint( + nativePath, point.X, point.Y, + pen ? pen->nativePen : NULL, + g ? g->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL GraphicsPath::IsOutlineVisible(const Point& point, const Pen *pen, + const Graphics *g) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsOutlineVisiblePathPointI( + nativePath, point.X, point.Y, + pen ? pen->nativePen : NULL, + g ? g->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL GraphicsPath::IsVisible(REAL x, REAL y, const Graphics *g) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisiblePathPoint( + nativePath, x, y, + g ? g->nativeGraphics : NULL, &result)); + return result; +} +__inline__ BOOL GraphicsPath::IsVisible(INT x, INT y, const Graphics *g) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisiblePathPointI( + nativePath, x, y, + g ? g->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL GraphicsPath::IsVisible(const PointF& point, + const Graphics *g) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisiblePathPoint( + nativePath, point.X, point.Y, + g ? g->nativeGraphics : NULL, &result)); + return result; +} + +__inline__ BOOL GraphicsPath::IsVisible(const Point& point, const Graphics *g) const +{ + BOOL result = FALSE; + updateStatus(DllExports::GdipIsVisiblePathPointI( + nativePath, point.X, point.Y, + g ? g->nativeGraphics : NULL, &result)); + return result; +} + + +// PathData + +__inline__ Status PathData::AllocateArrays(INT capacity) +{ + if (capacity < 0) { + return InvalidParameter; + } else if (Count < capacity) { + FreeArrays(); + + PointF *pointArray = (PointF*) + DllExports::GdipAlloc(capacity * sizeof(PointF)); + if (!pointArray) + return OutOfMemory; + + BYTE *typeArray = (BYTE*) + DllExports::GdipAlloc(capacity * sizeof(BYTE)); + if (!typeArray) { + DllExports::GdipFree(pointArray); + return OutOfMemory; + } + + Count = capacity; + Points = pointArray; + Types = typeArray; + } + return Ok; +} + +__inline__ VOID PathData::FreeArrays() +{ + if (Points) DllExports::GdipFree(Points); + if (Types) DllExports::GdipFree(Types); + Count = 0; + Points = NULL; + Types = NULL; +} + +#endif /* __GDIPLUS_IMPL_H */ diff --git a/winsup/w32api/include/gdiplus/gdiplusinit.h b/winsup/w32api/include/gdiplus/gdiplusinit.h new file mode 100755 index 000000000..768e16f27 --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusinit.h @@ -0,0 +1,74 @@ +/* + * gdiplusinit.h + * + * GDI+ Initialization + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdipluslinecaps.h b/winsup/w32api/include/gdiplus/gdipluslinecaps.h new file mode 100755 index 000000000..dd1b3270b --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdipluslinecaps.h @@ -0,0 +1,131 @@ +/* + * gdipluslinecaps.h + * + * GDI+ AdjustableArrowCap class + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusmatrix.h b/winsup/w32api/include/gdiplus/gdiplusmatrix.h new file mode 100755 index 000000000..626e0dab1 --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusmatrix.h @@ -0,0 +1,240 @@ +/* + * gdiplusmatrix.h + * + * GDI+ Matrix class + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusmem.h b/winsup/w32api/include/gdiplus/gdiplusmem.h new file mode 100755 index 000000000..4f18c43bb --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusmem.h @@ -0,0 +1,42 @@ +/* + * gdiplusmem.h + * + * GDI+ memory allocation + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusmetafile.h b/winsup/w32api/include/gdiplus/gdiplusmetafile.h new file mode 100755 index 000000000..eccb99b0c --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusmetafile.h @@ -0,0 +1,305 @@ +/* + * gdiplusmetafile.h + * + * GDI+ Metafile class + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusmetaheader.h b/winsup/w32api/include/gdiplus/gdiplusmetaheader.h new file mode 100755 index 000000000..84cdd3272 --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusmetaheader.h @@ -0,0 +1,193 @@ +/* + * gdiplusmetaheader.h + * + * GDI+ metafile header structure + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdipluspath.h b/winsup/w32api/include/gdiplus/gdipluspath.h new file mode 100755 index 000000000..aad8a249e --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdipluspath.h @@ -0,0 +1,964 @@ +/* + * gdipluspath.h + * + * GDI+ GraphicsPath class + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdipluspen.h b/winsup/w32api/include/gdiplus/gdipluspen.h new file mode 100755 index 000000000..d47f7afba --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdipluspen.h @@ -0,0 +1,338 @@ +/* + * gdipluspen.h + * + * GDI+ Pen class + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdipluspixelformats.h b/winsup/w32api/include/gdiplus/gdipluspixelformats.h new file mode 100755 index 000000000..d5d806cb8 --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdipluspixelformats.h @@ -0,0 +1,120 @@ +/* + * gdipluspixelformats.h + * + * GDI+ pixel formats + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplusstringformat.h b/winsup/w32api/include/gdiplus/gdiplusstringformat.h new file mode 100755 index 000000000..310ad95de --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplusstringformat.h @@ -0,0 +1,251 @@ +/* + * gdiplusstringformat.h + * + * GDI+ StringFormat class + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/include/gdiplus/gdiplustypes.h b/winsup/w32api/include/gdiplus/gdiplustypes.h new file mode 100755 index 000000000..9ac8de5b5 --- /dev/null +++ b/winsup/w32api/include/gdiplus/gdiplustypes.h @@ -0,0 +1,456 @@ +/* + * gdiplustypes.h + * + * GDI+ basic type declarations + * + * This file is part of the w32api package. + * + * Contributors: + * Created by Markus Koenig + * + * 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 */ diff --git a/winsup/w32api/lib/Makefile.in b/winsup/w32api/lib/Makefile.in index 9439627c3..e524ec59f 100644 --- a/winsup/w32api/lib/Makefile.in +++ b/winsup/w32api/lib/Makefile.in @@ -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) diff --git a/winsup/w32api/lib/gdiplus.c b/winsup/w32api/lib/gdiplus.c new file mode 100755 index 000000000..bd1234d26 --- /dev/null +++ b/winsup/w32api/lib/gdiplus.c @@ -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 + +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 */ diff --git a/winsup/w32api/lib/gdiplus.def b/winsup/w32api/lib/gdiplus.def new file mode 100755 index 000000000..42e139ac6 --- /dev/null +++ b/winsup/w32api/lib/gdiplus.def @@ -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 diff --git a/winsup/w32api/lib/test.c b/winsup/w32api/lib/test.c index 2db731ba0..ff44cb75f 100644 --- a/winsup/w32api/lib/test.c +++ b/winsup/w32api/lib/test.c @@ -28,6 +28,7 @@ #include #include +#include #include #include #include