diff options
| author | Chris Sutcliffe <ir0nh34d@users.sourceforge.net> | 2010-07-09 03:14:54 +0400 |
|---|---|---|
| committer | Chris Sutcliffe <ir0nh34d@users.sourceforge.net> | 2010-07-09 03:14:54 +0400 |
| commit | cc077128d30dd6c488d8c420606ecd36ea18b3de (patch) | |
| tree | a68981b5a407265adfd34d6541a5472648a89877 /winsup/w32api | |
| parent | 975a85f42c985b87533fd7cbfcdfe65ca243a94e (diff) | |
2010-07-08 Markus Koenig <basilo@users.sourceforge.net>
* include/gdiplus.h: New file.
* include/gdiplus/gdiplus.h: New file.
* include/gdiplus/gdiplusbase.h: New file.
* include/gdiplus/gdiplusbrush.h: New file.
* include/gdiplus/gdipluscolor.h: New file.
* include/gdiplus/gdipluscolormatrix.h: New file.
* include/gdiplus/gdipluseffects.h: New file.
* include/gdiplus/gdiplusenums.h: New file.
* include/gdiplus/gdiplusflat.h: New file.
* include/gdiplus/gdiplusgpstubs.h: New file.
* include/gdiplus/gdiplusgraphics.h: New file.
* include/gdiplus/gdiplusheaders.h: New file.
* include/gdiplus/gdiplusimageattributes.h: New file.
* include/gdiplus/gdiplusimagecodec.h: New file.
* include/gdiplus/gdiplusimaging.h: New file.
* include/gdiplus/gdiplusimpl.h: New file.
* include/gdiplus/gdiplusinit.h: New file.
* include/gdiplus/gdipluslinecaps.h: New file.
* include/gdiplus/gdiplusmatrix.h: New file.
* include/gdiplus/gdiplusmem.h: New file.
* include/gdiplus/gdiplusmetafile.h: New file.
* include/gdiplus/gdiplusmetaheader.h: New file.
* include/gdiplus/gdipluspath.h: New file.
* include/gdiplus/gdipluspen.h: New file.
* include/gdiplus/gdipluspixelformats.h: New file.
* include/gdiplus/gdiplusstringformat.h: New file.
* include/gdiplus/gdiplustypes.h: New file.
* lib/gdiplus.c: New file containing GDI+ variable definitions
and GUIDs.
* lib/gdiplus.def: New file.
* lib/Makefile.in: Add gdiplus.o to EXTRA_OBJS,
add gdiplus.c to SOURCES.
* lib/test.c: Include gdiplus.h.
Diffstat (limited to 'winsup/w32api')
32 files changed, 11109 insertions, 2 deletions
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 <basilo@users.sourceforge.net> + + * include/gdiplus.h: New file. + * include/gdiplus/gdiplus.h: New file. + * include/gdiplus/gdiplusbase.h: New file. + * include/gdiplus/gdiplusbrush.h: New file. + * include/gdiplus/gdipluscolor.h: New file. + * include/gdiplus/gdipluscolormatrix.h: New file. + * include/gdiplus/gdipluseffects.h: New file. + * include/gdiplus/gdiplusenums.h: New file. + * include/gdiplus/gdiplusflat.h: New file. + * include/gdiplus/gdiplusgpstubs.h: New file. + * include/gdiplus/gdiplusgraphics.h: New file. + * include/gdiplus/gdiplusheaders.h: New file. + * include/gdiplus/gdiplusimageattributes.h: New file. + * include/gdiplus/gdiplusimagecodec.h: New file. + * include/gdiplus/gdiplusimaging.h: New file. + * include/gdiplus/gdiplusimpl.h: New file. + * include/gdiplus/gdiplusinit.h: New file. + * include/gdiplus/gdipluslinecaps.h: New file. + * include/gdiplus/gdiplusmatrix.h: New file. + * include/gdiplus/gdiplusmem.h: New file. + * include/gdiplus/gdiplusmetafile.h: New file. + * include/gdiplus/gdiplusmetaheader.h: New file. + * include/gdiplus/gdipluspath.h: New file. + * include/gdiplus/gdipluspen.h: New file. + * include/gdiplus/gdipluspixelformats.h: New file. + * include/gdiplus/gdiplusstringformat.h: New file. + * include/gdiplus/gdiplustypes.h: New file. + * lib/gdiplus.c: New file containing GDI+ variable definitions + and GUIDs. + * lib/gdiplus.def: New file. + * lib/Makefile.in: Add gdiplus.o to EXTRA_OBJS, + add gdiplus.c to SOURCES. + * lib/test.c: Include gdiplus.h. + 2010-06-28 Rick Rankin <rrankin1424-mingw@yahoo.com> * include/psapi.h (PROCESS_MEMORY_COUNTERS_EX, PERFORMANCE_INFORMATION, 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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_H
+#define __GDIPLUS_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifndef RC_INVOKED
+
+#include <stddef.h>
+#include <math.h>
+#include <windef.h>
+#include <wingdi.h>
+
+#include <basetyps.h>
+typedef _COM_interface IStream IStream;
+typedef _COM_interface IDirectDrawSurface7 IDirectDrawSurface7;
+
+#ifdef __cplusplus
+namespace Gdiplus {
+#endif
+
+typedef float REAL;
+typedef SHORT INT16;
+typedef WORD UINT16;
+
+#include "gdiplusenums.h"
+#include "gdiplustypes.h"
+#include "gdiplusgpstubs.h"
+#include "gdiplusimaging.h"
+#include "gdiplusinit.h"
+#include "gdiplusmem.h"
+#include "gdiplusmetaheader.h"
+#include "gdipluspixelformats.h"
+#include "gdipluscolor.h"
+#include "gdipluscolormatrix.h"
+#include "gdiplusflat.h"
+#include "gdipluseffects.h"
+#include "gdiplusimagecodec.h"
+
+#ifdef __cplusplus
+#include "gdiplusbase.h"
+#include "gdiplusheaders.h"
+#include "gdiplusimageattributes.h"
+#include "gdiplusmatrix.h"
+#include "gdiplusbrush.h"
+#include "gdiplusmetafile.h"
+#include "gdipluspen.h"
+#include "gdiplusstringformat.h"
+#include "gdipluspath.h"
+#include "gdiplusgraphics.h"
+#include "gdipluslinecaps.h"
+#include "gdiplusimpl.h"
+
+} /* namespace Gdiplus */
+#endif /* __cplusplus */
+
+#endif /* !RC_INVOKED */
+
+#endif /* __GDIPLUS_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_BASE_H
+#define __GDIPLUS_BASE_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifndef __cplusplus
+#error "A C++ compiler is required to include gdiplusbase.h."
+#endif
+
+class GdiplusBase
+{
+public:
+ static void* operator new(size_t in_size)
+ {
+ return DllExports::GdipAlloc(in_size);
+ }
+ static void* operator new[](size_t in_size)
+ {
+ return DllExports::GdipAlloc(in_size);
+ }
+ static void operator delete(void *in_pVoid)
+ {
+ DllExports::GdipFree(in_pVoid);
+ }
+ static void operator delete[](void *in_pVoid)
+ {
+ DllExports::GdipFree(in_pVoid);
+ }
+};
+
+#endif /* __GDIPLUS_BASE_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_BRUSH_H
+#define __GDIPLUS_BRUSH_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifndef __cplusplus
+#error "A C++ compiler is required to include gdiplusbrush.h."
+#endif
+
+class Brush: public GdiplusBase
+{
+ friend class HatchBrush;
+ friend class LinearGradientBrush;
+ friend class PathGradientBrush;
+ friend class SolidBrush;
+ friend class TextureBrush;
+ friend class Graphics;
+ friend class Pen;
+
+public:
+ virtual ~Brush()
+ {
+ DllExports::GdipDeleteBrush(nativeBrush);
+ }
+ virtual Brush* Clone() const // each subclass must implement this
+ {
+ lastStatus = NotImplemented;
+ return NULL;
+ }
+
+ Status GetLastStatus() const
+ {
+ Status result = lastStatus;
+ lastStatus = Ok;
+ return result;
+ }
+ BrushType GetType() const
+ {
+ BrushType result = BrushTypeSolidColor;
+ updateStatus(DllExports::GdipGetBrushType(nativeBrush, &result));
+ return result;
+ }
+
+private:
+ Brush(): nativeBrush(NULL), lastStatus(Ok) {}
+ Brush(GpBrush *brush, Status status):
+ nativeBrush(brush), lastStatus(status) {}
+ Brush(const Brush& brush);
+ Brush& operator=(const Brush&);
+
+ Status updateStatus(Status newStatus) const
+ {
+ if (newStatus != Ok) lastStatus = newStatus;
+ return newStatus;
+ }
+
+ GpBrush *nativeBrush;
+ mutable Status lastStatus;
+};
+
+class HatchBrush: public Brush
+{
+public:
+ HatchBrush(HatchStyle hatchStyle,
+ const Color& foreColor,
+ const Color& backColor = Color())
+ {
+ GpHatch *nativeHatch = NULL;
+ lastStatus = DllExports::GdipCreateHatchBrush(hatchStyle,
+ foreColor.GetValue(), backColor.GetValue(),
+ &nativeHatch);
+ nativeBrush = nativeHatch;
+ }
+ virtual HatchBrush* Clone() const
+ {
+ GpBrush *cloneBrush = NULL;
+ Status status = updateStatus(DllExports::GdipCloneBrush(
+ nativeBrush, &cloneBrush));
+ if (status == Ok) {
+ HatchBrush *result =
+ new HatchBrush(cloneBrush, lastStatus);
+ if (!result) {
+ DllExports::GdipDeleteBrush(cloneBrush);
+ updateStatus(OutOfMemory);
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ Status GetBackgroundColor(Color *color) const
+ {
+ return updateStatus(DllExports::GdipGetHatchBackgroundColor(
+ (GpHatch*) nativeBrush,
+ color ? &color->Value : NULL));
+ }
+ Status GetForegroundColor(Color *color) const
+ {
+ return updateStatus(DllExports::GdipGetHatchForegroundColor(
+ (GpHatch*) nativeBrush,
+ color ? &color->Value : NULL));
+ }
+ HatchStyle GetHatchStyle() const
+ {
+ HatchStyle result;
+ updateStatus(DllExports::GdipGetHatchStyle(
+ (GpHatch*) nativeBrush, &result));
+ return result;
+ }
+
+private:
+ HatchBrush(GpBrush *brush, Status status): Brush(brush, status) {}
+ HatchBrush(const HatchBrush& brush);
+ HatchBrush& operator=(const HatchBrush&);
+};
+
+class LinearGradientBrush: public Brush
+{
+public:
+ LinearGradientBrush(const PointF& point1, const PointF& point2,
+ const Color& color1, const Color& color2)
+ {
+ GpLineGradient *nativeLineGradient = NULL;
+ lastStatus = DllExports::GdipCreateLineBrush(
+ &point1, &point2,
+ color1.GetValue(), color2.GetValue(),
+ WrapModeTile, &nativeLineGradient);
+ nativeBrush = nativeLineGradient;
+ }
+ LinearGradientBrush(const Point& point1, const Point& point2,
+ const Color& color1, const Color& color2)
+ {
+ GpLineGradient *nativeLineGradient = NULL;
+ lastStatus = DllExports::GdipCreateLineBrushI(
+ &point1, &point2,
+ color1.GetValue(), color2.GetValue(),
+ WrapModeTile, &nativeLineGradient);
+ nativeBrush = nativeLineGradient;
+ }
+ LinearGradientBrush(const RectF& rect, const Color& color1,
+ const Color& color2, LinearGradientMode mode)
+ {
+ GpLineGradient *nativeLineGradient = NULL;
+ lastStatus = DllExports::GdipCreateLineBrushFromRect(
+ &rect, color1.GetValue(), color2.GetValue(),
+ mode, WrapModeTile, &nativeLineGradient);
+ nativeBrush = nativeLineGradient;
+ }
+ LinearGradientBrush(const Rect& rect, const Color& color1,
+ const Color& color2, LinearGradientMode mode)
+ {
+ GpLineGradient *nativeLineGradient = NULL;
+ lastStatus = DllExports::GdipCreateLineBrushFromRectI(
+ &rect, color1.GetValue(), color2.GetValue(),
+ mode, WrapModeTile, &nativeLineGradient);
+ nativeBrush = nativeLineGradient;
+ }
+ LinearGradientBrush(const RectF& rect, const Color& color1,
+ const Color& color2, REAL angle,
+ BOOL isAngleScalable = FALSE)
+ {
+ GpLineGradient *nativeLineGradient = NULL;
+ lastStatus = DllExports::GdipCreateLineBrushFromRectWithAngle(
+ &rect, color1.GetValue(), color2.GetValue(),
+ angle, isAngleScalable, WrapModeTile,
+ &nativeLineGradient);
+ nativeBrush = nativeLineGradient;
+ }
+ LinearGradientBrush(const Rect& rect, const Color& color1,
+ const Color& color2, REAL angle,
+ BOOL isAngleScalable = FALSE)
+ {
+ GpLineGradient *nativeLineGradient = NULL;
+ lastStatus = DllExports::GdipCreateLineBrushFromRectWithAngleI(
+ &rect, color1.GetValue(), color2.GetValue(),
+ angle, isAngleScalable, WrapModeTile,
+ &nativeLineGradient);
+ nativeBrush = nativeLineGradient;
+ }
+ virtual LinearGradientBrush* Clone() const
+ {
+ GpBrush *cloneBrush = NULL;
+ Status status = updateStatus(DllExports::GdipCloneBrush(
+ nativeBrush, &cloneBrush));
+ if (status == Ok) {
+ LinearGradientBrush *result =
+ new LinearGradientBrush(cloneBrush, lastStatus);
+ if (!result) {
+ DllExports::GdipDeleteBrush(cloneBrush);
+ updateStatus(OutOfMemory);
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ Status GetBlend(REAL *blendFactors, REAL *blendPositions,
+ INT count) const
+ {
+ return updateStatus(DllExports::GdipGetLineBlend(
+ (GpLineGradient*) nativeBrush,
+ blendFactors, blendPositions, count));
+ }
+ INT GetBlendCount() const
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipGetLineBlendCount(
+ (GpLineGradient*) nativeBrush, &result));
+ return result;
+ }
+ BOOL GetGammaCorrection() const
+ {
+ BOOL result = FALSE;
+ updateStatus(DllExports::GdipGetLineGammaCorrection(
+ (GpLineGradient*) nativeBrush, &result));
+ return result;
+ }
+ INT GetInterpolationColorCount() const
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipGetLinePresetBlendCount(
+ (GpLineGradient*) nativeBrush, &result));
+ return result;
+ }
+ Status GetInterpolationColors(Color *presetColors,
+ REAL *blendPositions, INT count) const
+ {
+ if (!presetColors || count <= 0)
+ return lastStatus = InvalidParameter;
+
+ ARGB *presetArgb =
+ (ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB));
+ if (!presetArgb)
+ return lastStatus = OutOfMemory;
+
+ Status status = updateStatus(DllExports::GdipGetLinePresetBlend(
+ (GpLineGradient*) nativeBrush, presetArgb,
+ blendPositions, count));
+ for (INT i = 0; i < count; ++i) {
+ presetColors[i].SetValue(presetArgb[i]);
+ }
+ DllExports::GdipFree((void*) presetArgb);
+ return status;
+ }
+ Status GetLinearColors(Color *colors) const
+ {
+ if (!colors) return lastStatus = InvalidParameter;
+
+ ARGB colorsArgb[2];
+ Status status = updateStatus(DllExports::GdipGetLineColors(
+ (GpLineGradient*) nativeBrush, colorsArgb));
+ colors[0].SetValue(colorsArgb[0]);
+ colors[1].SetValue(colorsArgb[1]);
+ return status;
+ }
+ Status GetRectangle(RectF *rect) const
+ {
+ return updateStatus(DllExports::GdipGetLineRect(
+ (GpLineGradient*) nativeBrush, rect));
+ }
+ Status GetRectangle(Rect *rect) const
+ {
+ return updateStatus(DllExports::GdipGetLineRectI(
+ (GpLineGradient*) nativeBrush, rect));
+ }
+ Status GetTransform(Matrix *matrix) const
+ {
+ return updateStatus(DllExports::GdipGetLineTransform(
+ (GpLineGradient*) nativeBrush,
+ matrix ? matrix->nativeMatrix : NULL));
+ }
+ WrapMode GetWrapMode() const
+ {
+ WrapMode wrapMode = WrapModeTile;
+ updateStatus(DllExports::GdipGetLineWrapMode(
+ (GpLineGradient*) nativeBrush, &wrapMode));
+ return wrapMode;
+ }
+ Status MultiplyTransform(const Matrix *matrix,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipMultiplyLineTransform(
+ (GpLineGradient*) nativeBrush,
+ matrix ? matrix->nativeMatrix : NULL, order));
+ }
+ Status ResetTransform()
+ {
+ return updateStatus(DllExports::GdipResetLineTransform(
+ (GpLineGradient*) nativeBrush));
+ }
+ Status RotateTranform(REAL angle, MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipRotateLineTransform(
+ (GpLineGradient*) nativeBrush, angle, order));
+ }
+ Status ScaleTransform(REAL sx, REAL sy,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipScaleLineTransform(
+ (GpLineGradient*) nativeBrush, sx, sy, order));
+ }
+ Status SetBlend(const REAL *blendFactors,
+ const REAL *blendPositions, INT count)
+ {
+ return updateStatus(DllExports::GdipSetLineBlend(
+ (GpLineGradient*) nativeBrush,
+ blendFactors, blendPositions, count));
+ }
+ Status SetBlendBellShape(REAL focus, REAL scale = 1.0f)
+ {
+ return updateStatus(DllExports::GdipSetLineSigmaBlend(
+ (GpLineGradient*) nativeBrush,
+ focus, scale));
+ }
+ Status SetBlendTriangularShape(REAL focus, REAL scale = 1.0f)
+ {
+ return updateStatus(DllExports::GdipSetLineLinearBlend(
+ (GpLineGradient*) nativeBrush,
+ focus, scale));
+ }
+ Status SetGammaCorrection(BOOL useGammaCorrection)
+ {
+ return updateStatus(DllExports::GdipSetLineGammaCorrection(
+ (GpLineGradient*) nativeBrush,
+ useGammaCorrection));
+ }
+ Status SetInterpolationColors(const Color *presetColors,
+ const REAL *blendPositions, INT count)
+ {
+ if (!presetColors || count < 0)
+ return lastStatus = InvalidParameter;
+
+ ARGB *presetArgb =
+ (ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB));
+ if (!presetArgb)
+ return lastStatus = OutOfMemory;
+ for (INT i = 0; i < count; ++i) {
+ presetArgb[i] = presetColors[i].GetValue();
+ }
+
+ Status status = updateStatus(DllExports::GdipSetLinePresetBlend(
+ (GpLineGradient*) nativeBrush,
+ presetArgb, blendPositions, count));
+ DllExports::GdipFree((void*) presetArgb);
+ return status;
+ }
+ Status SetLinearColors(const Color& color1, const Color& color2)
+ {
+ return updateStatus(DllExports::GdipSetLineColors(
+ (GpLineGradient*) nativeBrush,
+ color1.GetValue(), color2.GetValue()));
+ }
+ Status SetTransform(const Matrix *matrix)
+ {
+ return updateStatus(DllExports::GdipSetLineTransform(
+ (GpLineGradient*) nativeBrush,
+ matrix ? matrix->nativeMatrix : NULL));
+ }
+ Status SetWrapMode(WrapMode wrapMode)
+ {
+ return updateStatus(DllExports::GdipSetLineWrapMode(
+ (GpLineGradient*) nativeBrush, wrapMode));
+ }
+ Status TranslateTransform(REAL dx, REAL dy,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipTranslateLineTransform(
+ (GpLineGradient*) nativeBrush, dx, dy, order));
+ }
+
+private:
+ LinearGradientBrush(GpBrush *brush, Status status): Brush(brush, status) {}
+ LinearGradientBrush(const LinearGradientBrush& brush);
+ LinearGradientBrush& operator=(const LinearGradientBrush&);
+};
+
+class SolidBrush: public Brush
+{
+public:
+ SolidBrush(const Color& color)
+ {
+ GpSolidFill *nativeSolidFill = NULL;
+ lastStatus = DllExports::GdipCreateSolidFill(
+ color.GetValue(), &nativeSolidFill);
+ nativeBrush = nativeSolidFill;
+ }
+ virtual SolidBrush* Clone() const
+ {
+ GpBrush *cloneBrush = NULL;
+ Status status = updateStatus(DllExports::GdipCloneBrush(
+ nativeBrush, &cloneBrush));
+ if (status == Ok) {
+ SolidBrush *result =
+ new SolidBrush(cloneBrush, lastStatus);
+ if (!result) {
+ DllExports::GdipDeleteBrush(cloneBrush);
+ updateStatus(OutOfMemory);
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ Status GetColor(Color *color) const
+ {
+ return updateStatus(DllExports::GdipGetSolidFillColor(
+ (GpSolidFill*) nativeBrush,
+ color ? &color->Value : NULL));
+ }
+ Status SetColor(const Color& color)
+ {
+ return updateStatus(DllExports::GdipSetSolidFillColor(
+ (GpSolidFill*) nativeBrush, color.GetValue()));
+ }
+
+private:
+ SolidBrush(GpBrush *brush, Status status): Brush(brush, status) {}
+ SolidBrush(const SolidBrush&);
+ SolidBrush& operator=(const SolidBrush&);
+};
+
+class TextureBrush: public Brush
+{
+public:
+ TextureBrush(Image *image, WrapMode wrapMode = WrapModeTile)
+ {
+ GpTexture *nativeTexture = NULL;
+ lastStatus = DllExports::GdipCreateTexture(
+ image ? image->nativeImage : NULL,
+ wrapMode, &nativeTexture);
+ nativeBrush = nativeTexture;
+ }
+ TextureBrush(Image *image, WrapMode wrapMode,
+ REAL dstX, REAL dstY, REAL dstWidth, REAL dstHeight)
+ {
+ GpTexture *nativeTexture = NULL;
+ lastStatus = DllExports::GdipCreateTexture2(
+ image ? image->nativeImage : NULL,
+ wrapMode, dstX, dstY, dstWidth, dstHeight,
+ &nativeTexture);
+ nativeBrush = nativeTexture;
+ }
+ TextureBrush(Image *image, WrapMode wrapMode,
+ INT dstX, INT dstY, INT dstWidth, INT dstHeight)
+ {
+ GpTexture *nativeTexture = NULL;
+ lastStatus = DllExports::GdipCreateTexture2I(
+ image ? image->nativeImage : NULL,
+ wrapMode, dstX, dstY, dstWidth, dstHeight,
+ &nativeTexture);
+ nativeBrush = nativeTexture;
+ }
+ TextureBrush(Image *image, WrapMode wrapMode, const RectF& dstRect)
+ {
+ GpTexture *nativeTexture = NULL;
+ lastStatus = DllExports::GdipCreateTexture2(
+ image ? image->nativeImage : NULL, wrapMode,
+ dstRect.X, dstRect.Y,
+ dstRect.Width, dstRect.Height, &nativeTexture);
+ nativeBrush = nativeTexture;
+ }
+ TextureBrush(Image *image, WrapMode wrapMode, const Rect& dstRect)
+ {
+ GpTexture *nativeTexture = NULL;
+ lastStatus = DllExports::GdipCreateTexture2I(
+ image ? image->nativeImage : NULL, wrapMode,
+ dstRect.X, dstRect.Y,
+ dstRect.Width, dstRect.Height, &nativeTexture);
+ nativeBrush = nativeTexture;
+ }
+ TextureBrush(Image *image, const RectF& dstRect,
+ ImageAttributes *imageAttributes = NULL)
+ {
+ GpTexture *nativeTexture = NULL;
+ lastStatus = DllExports::GdipCreateTextureIA(
+ image ? image->nativeImage : NULL,
+ imageAttributes ? imageAttributes->nativeImageAttributes : NULL,
+ dstRect.X, dstRect.Y,
+ dstRect.Width, dstRect.Height, &nativeTexture);
+ nativeBrush = nativeTexture;
+ }
+ TextureBrush(Image *image, const Rect& dstRect,
+ ImageAttributes *imageAttributes = NULL)
+ {
+ GpTexture *nativeTexture = NULL;
+ lastStatus = DllExports::GdipCreateTextureIAI(
+ image ? image->nativeImage : NULL,
+ imageAttributes ? imageAttributes->nativeImageAttributes : NULL,
+ dstRect.X, dstRect.Y,
+ dstRect.Width, dstRect.Height, &nativeTexture);
+ nativeBrush = nativeTexture;
+ }
+ virtual TextureBrush* Clone() const
+ {
+ GpBrush *cloneBrush = NULL;
+ Status status = updateStatus(DllExports::GdipCloneBrush(
+ nativeBrush, &cloneBrush));
+ if (status == Ok) {
+ TextureBrush *result =
+ new TextureBrush(cloneBrush, lastStatus);
+ if (!result) {
+ DllExports::GdipDeleteBrush(cloneBrush);
+ updateStatus(OutOfMemory);
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ //TODO: implement TextureBrush::GetImage()
+ //Image *GetImage() const
+ //{
+ // // where is the Image allocated (static,member,new,other)?
+ // // GdipGetTextureImage just returns a GpImage*
+ // updateStatus(NotImplemented);
+ // return NULL;
+ //}
+ Status GetTransfrom(Matrix *matrix) const
+ {
+ return updateStatus(DllExports::GdipGetTextureTransform(
+ (GpTexture*) nativeBrush,
+ matrix ? matrix->nativeMatrix : NULL));
+ }
+ WrapMode GetWrapMode() const
+ {
+ WrapMode result = WrapModeTile;
+ updateStatus(DllExports::GdipGetTextureWrapMode(
+ (GpTexture*) nativeBrush, &result));
+ return result;
+ }
+ Status MultiplyTransform(const Matrix *matrix,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipMultiplyTextureTransform(
+ (GpTexture*) nativeBrush,
+ matrix ? matrix->nativeMatrix : NULL, order));
+ }
+ Status ResetTransform()
+ {
+ return updateStatus(DllExports::GdipResetTextureTransform(
+ (GpTexture*) nativeBrush));
+ }
+ Status RotateTransform(REAL angle,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipRotateTextureTransform(
+ (GpTexture*) nativeBrush, angle, order));
+ }
+ Status ScaleTransform(REAL sx, REAL sy,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipScaleTextureTransform(
+ (GpTexture*) nativeBrush, sx, sy, order));
+ }
+ Status SetTransform(const Matrix *matrix)
+ {
+ return updateStatus(DllExports::GdipSetTextureTransform(
+ (GpTexture*) nativeBrush,
+ matrix ? matrix->nativeMatrix : NULL));
+ }
+ Status SetWrapMode(WrapMode wrapMode)
+ {
+ return updateStatus(DllExports::GdipSetTextureWrapMode(
+ (GpTexture*) nativeBrush, wrapMode));
+ }
+ Status TranslateTransform(REAL dx, REAL dy,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipTranslateTextureTransform(
+ (GpTexture*) nativeBrush, dx, dy, order));
+ }
+
+private:
+ TextureBrush(GpBrush *brush, Status status): Brush(brush, status) {}
+ TextureBrush(const TextureBrush&);
+ TextureBrush& operator=(const TextureBrush&);
+};
+
+#endif /* __GDIPLUS_BRUSH_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_COLOR_H
+#define __GDIPLUS_COLOR_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+typedef enum ColorChannelFlags {
+ ColorChannelFlagsC = 0,
+ ColorChannelFlagsM = 1,
+ ColorChannelFlagsY = 2,
+ ColorChannelFlagsK = 3,
+ ColorChannelFlagsLast = 4
+} ColorChannelFlags;
+
+typedef struct Color
+{
+ #ifdef __cplusplus
+ private:
+ #endif
+ ARGB Value;
+
+ #ifdef __cplusplus
+ public:
+ friend class Bitmap;
+ friend class Graphics;
+ friend class HatchBrush;
+ friend class PathGradientBrush;
+ friend class Pen;
+ friend class SolidBrush;
+
+ static ARGB MakeARGB(BYTE a, BYTE r, BYTE g, BYTE b)
+ {
+ return (ARGB) ((((DWORD) a) << 24) | (((DWORD) r) << 16)
+ | (((DWORD) g) << 8) | ((DWORD) b));
+ }
+
+ static const ARGB AlphaMask = 0xFF000000UL;
+
+ static const ARGB AliceBlue = 0xFFF0F8FFUL;
+ static const ARGB AntiqueWhite = 0xFFFAEBD7UL;
+ static const ARGB Aqua = 0xFF00FFFFUL;
+ static const ARGB Aquamarine = 0xFF7FFFD4UL;
+ static const ARGB Azure = 0xFFF0FFFFUL;
+ static const ARGB Beige = 0xFFF5F5DCUL;
+ static const ARGB Bisque = 0xFFFFE4C4UL;
+ static const ARGB Black = 0xFF000000UL;
+ static const ARGB BlanchedAlmond = 0xFFFFEBCDUL;
+ static const ARGB Blue = 0xFF0000FFUL;
+ static const ARGB BlueViolet = 0xFF8A2BE2UL;
+ static const ARGB Brown = 0xFFA52A2AUL;
+ static const ARGB BurlyWood = 0xFFDEB887UL;
+ static const ARGB CadetBlue = 0xFF5F9EA0UL;
+ static const ARGB Chartreuse = 0xFF7FFF00UL;
+ static const ARGB Chocolate = 0xFFD2691EUL;
+ static const ARGB Coral = 0xFFFF7F50UL;
+ static const ARGB CornflowerBlue = 0xFF6495EDUL;
+ static const ARGB Cornsilk = 0xFFFFF8DCUL;
+ static const ARGB Crimson = 0xFFDC143CUL;
+ static const ARGB Cyan = 0xFF00FFFFUL;
+ static const ARGB DarkBlue = 0xFF00008BUL;
+ static const ARGB DarkCyan = 0xFF008B8BUL;
+ static const ARGB DarkGoldenrod = 0xFFB8860BUL;
+ static const ARGB DarkGray = 0xFFA9A9A9UL;
+ static const ARGB DarkGreen = 0xFF006400UL;
+ static const ARGB DarkKhaki = 0xFFBDB76BUL;
+ static const ARGB DarkMagenta = 0xFF8B008BUL;
+ static const ARGB DarkOliveGreen = 0xFF556B2FUL;
+ static const ARGB DarkOrange = 0xFFFF8C00UL;
+ static const ARGB DarkOrchid = 0xFF9932CCUL;
+ static const ARGB DarkRed = 0xFF8B0000UL;
+ static const ARGB DarkSalmon = 0xFFE9967AUL;
+ static const ARGB DarkSeaGreen = 0xFF8FBC8FUL;
+ static const ARGB DarkSlateBlue = 0xFF483D8BUL;
+ static const ARGB DarkSlateGray = 0xFF2F4F4FUL;
+ static const ARGB DarkTurquoise = 0xFF00CED1UL;
+ static const ARGB DarkViolet = 0xFF9400D3UL;
+ static const ARGB DeepPink = 0xFFFF1493UL;
+ static const ARGB DeepSkyBlue = 0xFF00BFFFUL;
+ static const ARGB DimGray = 0xFF696969UL;
+ static const ARGB DodgerBlue = 0xFF1E90FFUL;
+ static const ARGB Firebrick = 0xFFB22222UL;
+ static const ARGB FloralWhite = 0xFFFFFAF0UL;
+ static const ARGB ForestGreen = 0xFF228B22UL;
+ static const ARGB Fuchsia = 0xFFFF00FFUL;
+ static const ARGB Gainsboro = 0xFFDCDCDCUL;
+ static const ARGB GhostWhite = 0xFFF8F8FFUL;
+ static const ARGB Gold = 0xFFFFD700UL;
+ static const ARGB Goldenrod = 0xFFDAA520UL;
+ static const ARGB Gray = 0xFF808080UL;
+ static const ARGB Green = 0xFF008000UL;
+ static const ARGB GreenYellow = 0xFFADFF2FUL;
+ static const ARGB Honeydew = 0xFFF0FFF0UL;
+ static const ARGB HotPink = 0xFFFF69B4UL;
+ static const ARGB IndianRed = 0xFFCD5C5CUL;
+ static const ARGB Indigo = 0xFF4B0082UL;
+ static const ARGB Ivory = 0xFFFFFFF0UL;
+ static const ARGB Khaki = 0xFFF0E68CUL;
+ static const ARGB Lavender = 0xFFE6E6FAUL;
+ static const ARGB LavenderBlush = 0xFFFFF0F5UL;
+ static const ARGB LawnGreen = 0xFF7CFC00UL;
+ static const ARGB LemonChiffon = 0xFFFFFACDUL;
+ static const ARGB LightBlue = 0xFFADD8E6UL;
+ static const ARGB LightCoral = 0xFFF08080UL;
+ static const ARGB LightCyan = 0xFFE0FFFFUL;
+ static const ARGB LightGoldenrodYellow = 0xFFFAFAD2UL;
+ static const ARGB LightGray = 0xFFD3D3D3UL;
+ static const ARGB LightGreen = 0xFF90EE90UL;
+ static const ARGB LightPink = 0xFFFFB6C1UL;
+ static const ARGB LightSalmon = 0xFFFFA07AUL;
+ static const ARGB LightSeaGreen = 0xFF20B2AAUL;
+ static const ARGB LightSkyBlue = 0xFF87CEFAUL;
+ static const ARGB LightSlateGray = 0xFF778899UL;
+ static const ARGB LightSteelBlue = 0xFFB0C4DEUL;
+ static const ARGB LightYellow = 0xFFFFFFE0UL;
+ static const ARGB Lime = 0xFF00FF00UL;
+ static const ARGB LimeGreen = 0xFF32CD32UL;
+ static const ARGB Linen = 0xFFFAF0E6UL;
+ static const ARGB Magenta = 0xFFFF00FFUL;
+ static const ARGB Maroon = 0xFF800000UL;
+ static const ARGB MediumAquamarine = 0xFF66CDAAUL;
+ static const ARGB MediumBlue = 0xFF0000CDUL;
+ static const ARGB MediumOrchid = 0xFFBA55D3UL;
+ static const ARGB MediumPurple = 0xFF9370DBUL;
+ static const ARGB MediumSeaGreen = 0xFF3CB371UL;
+ static const ARGB MediumSlateBlue = 0xFF7B68EEUL;
+ static const ARGB MediumSpringGreen = 0xFF00FA9AUL;
+ static const ARGB MediumTurquoise = 0xFF48D1CCUL;
+ static const ARGB MediumVioletRed = 0xFFC71585UL;
+ static const ARGB MidnightBlue = 0xFF191970UL;
+ static const ARGB MintCream = 0xFFF5FFFAUL;
+ static const ARGB MistyRose = 0xFFFFE4E1UL;
+ static const ARGB Moccasin = 0xFFFFE4B5UL;
+ static const ARGB NavajoWhite = 0xFFFFDEADUL;
+ static const ARGB Navy = 0xFF000080UL;
+ static const ARGB OldLace = 0xFFFDF5E6UL;
+ static const ARGB Olive = 0xFF808000UL;
+ static const ARGB OliveDrab = 0xFF6B8E23UL;
+ static const ARGB Orange = 0xFFFFA500UL;
+ static const ARGB OrangeRed = 0xFFFF4500UL;
+ static const ARGB Orchid = 0xFFDA70D6UL;
+ static const ARGB PaleGoldenrod = 0xFFEEE8AAUL;
+ static const ARGB PaleGreen = 0xFF98FB98UL;
+ static const ARGB PaleTurquoise = 0xFFAFEEEEUL;
+ static const ARGB PaleVioletRed = 0xFFDB7093UL;
+ static const ARGB PapayaWhip = 0xFFFFEFD5UL;
+ static const ARGB PeachPuff = 0xFFFFDAB9UL;
+ static const ARGB Peru = 0xFFCD853FUL;
+ static const ARGB Pink = 0xFFFFC0CBUL;
+ static const ARGB Plum = 0xFFDDA0DDUL;
+ static const ARGB PowderBlue = 0xFFB0E0E6UL;
+ static const ARGB Purple = 0xFF800080UL;
+ static const ARGB Red = 0xFFFF0000UL;
+ static const ARGB RosyBrown = 0xFFBC8F8FUL;
+ static const ARGB RoyalBlue = 0xFF4169E1UL;
+ static const ARGB SaddleBrown = 0xFF8B4513UL;
+ static const ARGB Salmon = 0xFFFA8072UL;
+ static const ARGB SandyBrown = 0xFFF4A460UL;
+ static const ARGB SeaGreen = 0xFF2E8B57UL;
+ static const ARGB SeaShell = 0xFFFFF5EEUL;
+ static const ARGB Sienna = 0xFFA0522DUL;
+ static const ARGB Silver = 0xFFC0C0C0UL;
+ static const ARGB SkyBlue = 0xFF87CEEBUL;
+ static const ARGB SlateBlue = 0xFF6A5ACDUL;
+ static const ARGB SlateGray = 0xFF708090UL;
+ static const ARGB Snow = 0xFFFFFAFAUL;
+ static const ARGB SpringGreen = 0xFF00FF7FUL;
+ static const ARGB SteelBlue = 0xFF4682B4UL;
+ static const ARGB Tan = 0xFFD2B48CUL;
+ static const ARGB Teal = 0xFF008080UL;
+ static const ARGB Thistle = 0xFFD8BFD8UL;
+ static const ARGB Tomato = 0xFFFF6347UL;
+ static const ARGB Transparent = 0x00FFFFFFUL;
+ static const ARGB Turquoise = 0xFF40E0D0UL;
+ static const ARGB Violet = 0xFFEE82EEUL;
+ static const ARGB Wheat = 0xFFF5DEB3UL;
+ static const ARGB White = 0xFFFFFFFFUL;
+ static const ARGB WhiteSmoke = 0xFFF5F5F5UL;
+ static const ARGB Yellow = 0xFFFFFF00UL;
+ static const ARGB YellowGreen = 0xFF9ACD32UL;
+
+ Color(): Value(0xFF000000) {}
+ Color(ARGB argb): Value(argb) {}
+ Color(BYTE r, BYTE g, BYTE b): Value(MakeARGB(0xFF, r, g, b)) {}
+ Color(BYTE a, BYTE r, BYTE g, BYTE b): Value(MakeARGB(a, r, g, b)) {}
+
+ BYTE GetA() const
+ {
+ return (BYTE) (Value >> 24);
+ }
+ BYTE GetAlpha() const
+ {
+ return (BYTE) (Value >> 24);
+ }
+ BYTE GetB() const
+ {
+ return (BYTE) Value;
+ }
+ BYTE GetBlue() const
+ {
+ return (BYTE) Value;
+ }
+ BYTE GetG() const
+ {
+ return (BYTE) (Value >> 8);
+ }
+ BYTE GetGreen() const
+ {
+ return (BYTE) (Value >> 8);
+ }
+ BYTE GetR() const
+ {
+ return (BYTE) (Value >> 16);
+ }
+ BYTE GetRed() const
+ {
+ return (BYTE) (Value >> 16);
+ }
+ ARGB GetValue() const
+ {
+ return Value;
+ }
+ VOID SetFromCOLORREF(COLORREF rgb)
+ {
+ BYTE r = (BYTE) rgb;
+ BYTE g = (BYTE) (rgb >> 8);
+ BYTE b = (BYTE) (rgb >> 16);
+ Value = MakeARGB(0xFF, r, g, b);
+ }
+ VOID SetValue(ARGB argb)
+ {
+ Value = argb;
+ }
+ COLORREF ToCOLORREF() const
+ {
+ return RGB(GetRed(), GetGreen(), GetBlue());
+ }
+ #endif /* __cplusplus */
+} Color;
+
+#endif /* __GDIPLUS_COLOR_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_COLORMATRIX_H
+#define __GDIPLUS_COLORMATRIX_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+typedef enum ColorAdjustType {
+ ColorAdjustTypeDefault = 0,
+ ColorAdjustTypeBitmap = 1,
+ ColorAdjustTypeBrush = 2,
+ ColorAdjustTypePen = 3,
+ ColorAdjustTypeText = 4,
+ ColorAdjustTypeCount = 5,
+ ColorAdjustTypeAny = 6
+} ColorAdjustType;
+
+typedef enum ColorMatrixFlags {
+ ColorMatrixFlagsDefault = 0,
+ ColorMatrixFlagsSkipGrays = 1,
+ ColorMatrixFlagsAltGray = 2
+} ColorMatrixFlags;
+
+typedef enum HistogramFormat {
+ HistogramFormatARGB = 0,
+ HistogramFormatPARGB = 1,
+ HistogramFormatRGB = 2,
+ HistogramFormatGray = 3,
+ HistogramFormatB = 4,
+ HistogramFormatG = 5,
+ HistogramFormatR = 6,
+ HistogramFormatA = 7
+} HistogramFormat;
+
+typedef struct ColorMap {
+ Color oldColor;
+ Color newColor;
+} ColorMap;
+
+typedef struct ColorMatrix {
+ REAL m[5][5];
+} ColorMatrix;
+
+typedef BYTE ColorChannelLUT[256];
+
+#endif /* __GDIPLUS_COLORMATRIX_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_EFFECTS_H
+#define __GDIPLUS_EFFECTS_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+typedef enum CurveAdjustments {
+ AdjustExposure = 0,
+ AdjustDensity = 1,
+ AdjustContrast = 2,
+ AdjustHighlight = 3,
+ AdjustShadow = 4,
+ AdjustMidtone = 5,
+ AdjustWhiteSaturation = 6,
+ AdjustBlackSaturation = 7
+} CurveAdjustments;
+
+typedef enum CurveChannel {
+ CurveChannelAll = 0,
+ CurveChannelRed = 1,
+ CurveChannelGreen = 2,
+ CurveChannelBlue = 3
+} CurveChannel;
+
+typedef struct BlurParams {
+ REAL radius;
+ BOOL expandEdge;
+} BlurParams;
+
+typedef struct BrightnessContrastParams {
+ INT brightnessLevel;
+ INT contrastLevel;
+} BrightnessContrastParams;
+
+typedef struct ColorBalanceParams {
+ INT cyanRed;
+ INT magentaGreen;
+ INT yellowBlue;
+} ColorBalanceParams;
+
+typedef struct ColorCurveParams {
+ CurveAdjustments adjustment;
+ CurveChannel channel;
+ INT adjustValue;
+} ColorCurveParams;
+
+typedef struct ColorLUTParams {
+ ColorChannelLUT lutB;
+ ColorChannelLUT lutG;
+ ColorChannelLUT lutR;
+ ColorChannelLUT lutA;
+} ColorLUTParams;
+
+typedef struct HueSaturationLightnessParams {
+ INT hueLevel;
+ INT saturationLevel;
+ INT lightnessLevel;
+} HueSaturationLightnessParams;
+
+typedef struct LevelsParams {
+ INT highlight;
+ INT midtone;
+ INT shadow;
+} LevelsParams;
+
+typedef struct RedEyeCorrectionParams {
+ UINT numberOfAreas;
+ RECT *areas;
+} RedEyeCorrectionParams;
+
+typedef struct SharpenParams {
+ REAL radius;
+ REAL amount;
+} SharpenParams;
+
+typedef struct TintParams {
+ INT hue;
+ INT amount;
+} TintParams;
+
+extern const GUID BlurEffectGuid; /* ? */
+extern const GUID BrightnessContrastEffectGuid; /* ? */
+extern const GUID ColorBalanceEffectGuid; /* ? */
+extern const GUID ColorCurveEffectGuid; /* ? */
+extern const GUID ColorLUTEffectGuid; /* ? */
+extern const GUID ColorMatrixEffectGuid; /* ? */
+extern const GUID HueSaturationLightnessEffectGuid; /* ? */
+extern const GUID LevelsEffectGuid; /* ? */
+extern const GUID RedEyeCorrectionEffectGuid; /* ? */
+extern const GUID SharpenEffectGuid; /* ? */
+extern const GUID TintEffectGuid; /* ? */
+
+
+#endif /* __GDIPLUS_EFFECTS_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_ENUMS_H
+#define __GDIPLUS_ENUMS_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+typedef enum BrushType {
+ BrushTypeSolidColor = 0,
+ BrushTypeHatchFill = 1,
+ BrushTypeTextureFill = 2,
+ BrushTypePathGradient = 3,
+ BrushTypeLinearGradient = 4
+} BrushType;
+
+typedef enum CombineMode {
+ CombineModeReplace = 0,
+ CombineModeIntersect = 1,
+ CombineModeUnion = 2,
+ CombineModeXor = 3,
+ CombineModeExclude = 4,
+ CombineModeComplement = 5
+} CombineMode;
+
+typedef enum CompositingMode {
+ CompositingModeSourceOver = 0,
+ CompositingModeSourceCopy = 1
+} CompositingMode;
+
+typedef enum CompositingQuality {
+ CompositingQualityDefault = 0,
+ CompositingQualityHighSpeed = 1,
+ CompositingQualityHighQuality = 2,
+ CompositingQualityGammaCorrected = 3,
+ CompositingQualityAssumeLinear = 4
+} CompositingQuality;
+
+typedef enum CoordinateSpace {
+ CoordinateSpaceWorld = 0,
+ CoordinateSpacePage = 1,
+ CoordinateSpaceDevice = 2
+} CoordinateSpace;
+
+typedef enum CustomLineCapType {
+ CustomLineCapTypeDefault = 0,
+ CustomLineCapTypeAdjustableArrow = 1
+} CustomLineCapType;
+
+typedef enum DashCap {
+ DashCapFlat = 0,
+ DashCapRound = 2,
+ DashCapTriangle = 3
+} DashCap;
+
+typedef enum DashStyle {
+ DashStyleSolid = 0,
+ DashStyleDash = 1,
+ DashStyleDot = 2,
+ DashStyleDashDot = 3,
+ DashStyleDashDotDot = 4,
+ DashStyleCustom = 5
+} DashStyle;
+
+typedef enum DitherType {
+ DitherTypeNone = 0,
+ DitherTypeSolid = 1,
+ DitherTypeOrdered4x4 = 2,
+ DitherTypeOrdered8x8 = 3,
+ DitherTypeOrdered16x16 = 4,
+ DitherTypeOrdered91x91 = 5,
+ DitherTypeSpiral4x4 = 6,
+ DitherTypeSpiral8x8 = 7,
+ DitherTypeDualSpiral4x4 = 8,
+ DitherTypeDualSpiral8x8 = 9,
+ DitherTypeErrorDiffusion = 10
+} DitherType;
+
+typedef enum DriverStringOptions {
+ DriverStringOptionsCmapLookup = 1,
+ DriverStringOptionsVertical = 2,
+ DriverStringOptionsRealizedAdvance = 4,
+ DriverStringOptionsLimitSubpixel = 8
+} DriverStringOptions;
+
+#define GDIP_WMF_RECORD_TO_EMFPLUS(meta) ((meta) | 0x10000)
+#define GDIP_EMFPLUS_RECORD_BASE (0x4000)
+typedef enum EmfPlusRecordType {
+ WmfRecordTypeSetBkColor = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETBKCOLOR),
+ WmfRecordTypeSetBkMode = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETBKMODE),
+ WmfRecordTypeSetMapMode = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETMAPMODE),
+ WmfRecordTypeSetROP2 = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETROP2),
+ WmfRecordTypeSetRelAbs = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETRELABS),
+ WmfRecordTypeSetPolyFillMode = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETPOLYFILLMODE),
+ WmfRecordTypeSetStretchBltMode = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETSTRETCHBLTMODE),
+ WmfRecordTypeSetTextCharExtra = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETTEXTCHAREXTRA),
+ WmfRecordTypeSetTextColor = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETTEXTCOLOR),
+ WmfRecordTypeSetTextJustification = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETTEXTJUSTIFICATION),
+ WmfRecordTypeSetWindowOrg = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETWINDOWORG),
+ WmfRecordTypeSetWindowExt = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETWINDOWEXT),
+ WmfRecordTypeSetViewportOrg = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETVIEWPORTORG),
+ WmfRecordTypeSetViewportExt = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETVIEWPORTEXT),
+ WmfRecordTypeOffsetWindowOrg = GDIP_WMF_RECORD_TO_EMFPLUS(META_OFFSETWINDOWORG),
+ WmfRecordTypeScaleWindowExt = GDIP_WMF_RECORD_TO_EMFPLUS(META_SCALEWINDOWEXT),
+ WmfRecordTypeOffsetViewportOrg = GDIP_WMF_RECORD_TO_EMFPLUS(META_OFFSETVIEWPORTORG),
+ WmfRecordTypeScaleViewportExt = GDIP_WMF_RECORD_TO_EMFPLUS(META_SCALEVIEWPORTEXT),
+ WmfRecordTypeLineTo = GDIP_WMF_RECORD_TO_EMFPLUS(META_LINETO),
+ WmfRecordTypeMoveTo = GDIP_WMF_RECORD_TO_EMFPLUS(META_MOVETO),
+ WmfRecordTypeExcludeClipRect = GDIP_WMF_RECORD_TO_EMFPLUS(META_EXCLUDECLIPRECT),
+ WmfRecordTypeIntersectClipRect = GDIP_WMF_RECORD_TO_EMFPLUS(META_INTERSECTCLIPRECT),
+ WmfRecordTypeArc = GDIP_WMF_RECORD_TO_EMFPLUS(META_ARC),
+ WmfRecordTypeEllipse = GDIP_WMF_RECORD_TO_EMFPLUS(META_ELLIPSE),
+ WmfRecordTypeFloodFill = GDIP_WMF_RECORD_TO_EMFPLUS(META_FLOODFILL),
+ WmfRecordTypePie = GDIP_WMF_RECORD_TO_EMFPLUS(META_PIE),
+ WmfRecordTypeRectangle = GDIP_WMF_RECORD_TO_EMFPLUS(META_RECTANGLE),
+ WmfRecordTypeRoundRect = GDIP_WMF_RECORD_TO_EMFPLUS(META_ROUNDRECT),
+ WmfRecordTypePatBlt = GDIP_WMF_RECORD_TO_EMFPLUS(META_PATBLT),
+ WmfRecordTypeSaveDC = GDIP_WMF_RECORD_TO_EMFPLUS(META_SAVEDC),
+ WmfRecordTypeSetPixel = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETPIXEL),
+ WmfRecordTypeOffsetClipRgn = GDIP_WMF_RECORD_TO_EMFPLUS(META_OFFSETCLIPRGN),
+ WmfRecordTypeTextOut = GDIP_WMF_RECORD_TO_EMFPLUS(META_TEXTOUT),
+ WmfRecordTypeBitBlt = GDIP_WMF_RECORD_TO_EMFPLUS(META_BITBLT),
+ WmfRecordTypeStretchBlt = GDIP_WMF_RECORD_TO_EMFPLUS(META_STRETCHBLT),
+ WmfRecordTypePolygon = GDIP_WMF_RECORD_TO_EMFPLUS(META_POLYGON),
+ WmfRecordTypePolyline = GDIP_WMF_RECORD_TO_EMFPLUS(META_POLYLINE),
+ WmfRecordTypeEscape = GDIP_WMF_RECORD_TO_EMFPLUS(META_ESCAPE),
+ WmfRecordTypeRestoreDC = GDIP_WMF_RECORD_TO_EMFPLUS(META_RESTOREDC),
+ WmfRecordTypeFillRegion = GDIP_WMF_RECORD_TO_EMFPLUS(META_FILLREGION),
+ WmfRecordTypeFrameRegion = GDIP_WMF_RECORD_TO_EMFPLUS(META_FRAMEREGION),
+ WmfRecordTypeInvertRegion = GDIP_WMF_RECORD_TO_EMFPLUS(META_INVERTREGION),
+ WmfRecordTypePaintRegion = GDIP_WMF_RECORD_TO_EMFPLUS(META_PAINTREGION),
+ WmfRecordTypeSelectClipRegion = GDIP_WMF_RECORD_TO_EMFPLUS(META_SELECTCLIPREGION),
+ WmfRecordTypeSelectObject = GDIP_WMF_RECORD_TO_EMFPLUS(META_SELECTOBJECT),
+ WmfRecordTypeSetTextAlign = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETTEXTALIGN),
+ WmfRecordTypeDrawText = GDIP_WMF_RECORD_TO_EMFPLUS(0x062F),
+ WmfRecordTypeChord = GDIP_WMF_RECORD_TO_EMFPLUS(META_CHORD),
+ WmfRecordTypeSetMapperFlags = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETMAPPERFLAGS),
+ WmfRecordTypeExtTextOut = GDIP_WMF_RECORD_TO_EMFPLUS(META_EXTTEXTOUT),
+ WmfRecordTypeSetDIBToDev = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETDIBTODEV),
+ WmfRecordTypeSelectPalette = GDIP_WMF_RECORD_TO_EMFPLUS(META_SELECTPALETTE),
+ WmfRecordTypeRealizePalette = GDIP_WMF_RECORD_TO_EMFPLUS(META_REALIZEPALETTE),
+ WmfRecordTypeAnimatePalette = GDIP_WMF_RECORD_TO_EMFPLUS(META_ANIMATEPALETTE),
+ WmfRecordTypeSetPalEntries = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETPALENTRIES),
+ WmfRecordTypePolyPolygon = GDIP_WMF_RECORD_TO_EMFPLUS(META_POLYPOLYGON),
+ WmfRecordTypeResizePalette = GDIP_WMF_RECORD_TO_EMFPLUS(META_RESIZEPALETTE),
+ WmfRecordTypeDIBBitBlt = GDIP_WMF_RECORD_TO_EMFPLUS(META_DIBBITBLT),
+ WmfRecordTypeDIBStretchBlt = GDIP_WMF_RECORD_TO_EMFPLUS(META_DIBSTRETCHBLT),
+ WmfRecordTypeDIBCreatePatternBrush = GDIP_WMF_RECORD_TO_EMFPLUS(META_DIBCREATEPATTERNBRUSH),
+ WmfRecordTypeStretchDIB = GDIP_WMF_RECORD_TO_EMFPLUS(META_STRETCHDIB),
+ WmfRecordTypeExtFloodFill = GDIP_WMF_RECORD_TO_EMFPLUS(META_EXTFLOODFILL),
+ WmfRecordTypeSetLayout = GDIP_WMF_RECORD_TO_EMFPLUS(0x0149),
+ WmfRecordTypeResetDC = GDIP_WMF_RECORD_TO_EMFPLUS(0x014C),
+ WmfRecordTypeStartDoc = GDIP_WMF_RECORD_TO_EMFPLUS(0x014D),
+ WmfRecordTypeStartPage = GDIP_WMF_RECORD_TO_EMFPLUS(0x004F),
+ WmfRecordTypeEndPage = GDIP_WMF_RECORD_TO_EMFPLUS(0x0050),
+ WmfRecordTypeAbortDoc = GDIP_WMF_RECORD_TO_EMFPLUS(0x0052),
+ WmfRecordTypeEndDoc = GDIP_WMF_RECORD_TO_EMFPLUS(0x005E),
+ WmfRecordTypeDeleteObject = GDIP_WMF_RECORD_TO_EMFPLUS(META_DELETEOBJECT),
+ WmfRecordTypeCreatePalette = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEPALETTE),
+ WmfRecordTypeCreateBrush = GDIP_WMF_RECORD_TO_EMFPLUS(0x00F8),
+ WmfRecordTypeCreatePatternBrush = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEPATTERNBRUSH),
+ WmfRecordTypeCreatePenIndirect = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEPENINDIRECT),
+ WmfRecordTypeCreateFontIndirect = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEFONTINDIRECT),
+ WmfRecordTypeCreateBrushIndirect = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEBRUSHINDIRECT),
+ WmfRecordTypeCreateBitmapIndirect = GDIP_WMF_RECORD_TO_EMFPLUS(0x02FD),
+ WmfRecordTypeCreateBitmap = GDIP_WMF_RECORD_TO_EMFPLUS(0x06FE),
+ WmfRecordTypeCreateRegion = GDIP_WMF_RECORD_TO_EMFPLUS(META_CREATEREGION),
+ EmfRecordTypeHeader = EMR_HEADER,
+ EmfRecordTypePolyBezier = EMR_POLYBEZIER,
+ EmfRecordTypePolygon = EMR_POLYGON,
+ EmfRecordTypePolyline = EMR_POLYLINE,
+ EmfRecordTypePolyBezierTo = EMR_POLYBEZIERTO,
+ EmfRecordTypePolyLineTo = EMR_POLYLINETO,
+ EmfRecordTypePolyPolyline = EMR_POLYPOLYLINE,
+ EmfRecordTypePolyPolygon = EMR_POLYPOLYGON,
+ EmfRecordTypeSetWindowExtEx = EMR_SETWINDOWEXTEX,
+ EmfRecordTypeSetWindowOrgEx = EMR_SETWINDOWORGEX,
+ EmfRecordTypeSetViewportExtEx = EMR_SETVIEWPORTEXTEX,
+ EmfRecordTypeSetViewportOrgEx = EMR_SETVIEWPORTORGEX,
+ EmfRecordTypeSetBrushOrgEx = EMR_SETBRUSHORGEX,
+ EmfRecordTypeEOF = EMR_EOF,
+ EmfRecordTypeSetPixelV = EMR_SETPIXELV,
+ EmfRecordTypeSetMapperFlags = EMR_SETMAPPERFLAGS,
+ EmfRecordTypeSetMapMode = EMR_SETMAPMODE,
+ EmfRecordTypeSetBkMode = EMR_SETBKMODE,
+ EmfRecordTypeSetPolyFillMode = EMR_SETPOLYFILLMODE,
+ EmfRecordTypeSetROP2 = EMR_SETROP2,
+ EmfRecordTypeSetStretchBltMode = EMR_SETSTRETCHBLTMODE,
+ EmfRecordTypeSetTextAlign = EMR_SETTEXTALIGN,
+ EmfRecordTypeSetColorAdjustment = EMR_SETCOLORADJUSTMENT,
+ EmfRecordTypeSetTextColor = EMR_SETTEXTCOLOR,
+ EmfRecordTypeSetBkColor = EMR_SETBKCOLOR,
+ EmfRecordTypeOffsetClipRgn = EMR_OFFSETCLIPRGN,
+ EmfRecordTypeMoveToEx = EMR_MOVETOEX,
+ EmfRecordTypeSetMetaRgn = EMR_SETMETARGN,
+ EmfRecordTypeExcludeClipRect = EMR_EXCLUDECLIPRECT,
+ EmfRecordTypeIntersectClipRect = EMR_INTERSECTCLIPRECT,
+ EmfRecordTypeScaleViewportExtEx = EMR_SCALEVIEWPORTEXTEX,
+ EmfRecordTypeScaleWindowExtEx = EMR_SCALEWINDOWEXTEX,
+ EmfRecordTypeSaveDC = EMR_SAVEDC,
+ EmfRecordTypeRestoreDC = EMR_RESTOREDC,
+ EmfRecordTypeSetWorldTransform = EMR_SETWORLDTRANSFORM,
+ EmfRecordTypeModifyWorldTransform = EMR_MODIFYWORLDTRANSFORM,
+ EmfRecordTypeSelectObject = EMR_SELECTOBJECT,
+ EmfRecordTypeCreatePen = EMR_CREATEPEN,
+ EmfRecordTypeCreateBrushIndirect = EMR_CREATEBRUSHINDIRECT,
+ EmfRecordTypeDeleteObject = EMR_DELETEOBJECT,
+ EmfRecordTypeAngleArc = EMR_ANGLEARC,
+ EmfRecordTypeEllipse = EMR_ELLIPSE,
+ EmfRecordTypeRectangle = EMR_RECTANGLE,
+ EmfRecordTypeRoundRect = EMR_ROUNDRECT,
+ EmfRecordTypeArc = EMR_ARC,
+ EmfRecordTypeChord = EMR_CHORD,
+ EmfRecordTypePie = EMR_PIE,
+ EmfRecordTypeSelectPalette = EMR_SELECTPALETTE,
+ EmfRecordTypeCreatePalette = EMR_CREATEPALETTE,
+ EmfRecordTypeSetPaletteEntries = EMR_SETPALETTEENTRIES,
+ EmfRecordTypeResizePalette = EMR_RESIZEPALETTE,
+ EmfRecordTypeRealizePalette = EMR_REALIZEPALETTE,
+ EmfRecordTypeExtFloodFill = EMR_EXTFLOODFILL,
+ EmfRecordTypeLineTo = EMR_LINETO,
+ EmfRecordTypeArcTo = EMR_ARCTO,
+ EmfRecordTypePolyDraw = EMR_POLYDRAW,
+ EmfRecordTypeSetArcDirection = EMR_SETARCDIRECTION,
+ EmfRecordTypeSetMiterLimit = EMR_SETMITERLIMIT,
+ EmfRecordTypeBeginPath = EMR_BEGINPATH,
+ EmfRecordTypeEndPath = EMR_ENDPATH,
+ EmfRecordTypeCloseFigure = EMR_CLOSEFIGURE,
+ EmfRecordTypeFillPath = EMR_FILLPATH,
+ EmfRecordTypeStrokeAndFillPath = EMR_STROKEANDFILLPATH,
+ EmfRecordTypeStrokePath = EMR_STROKEPATH,
+ EmfRecordTypeFlattenPath = EMR_FLATTENPATH,
+ EmfRecordTypeWidenPath = EMR_WIDENPATH,
+ EmfRecordTypeSelectClipPath = EMR_SELECTCLIPPATH,
+ EmfRecordTypeAbortPath = EMR_ABORTPATH,
+ EmfRecordTypeReserved_069 = 69,
+ EmfRecordTypeGdiComment = EMR_GDICOMMENT,
+ EmfRecordTypeFillRgn = EMR_FILLRGN,
+ EmfRecordTypeFrameRgn = EMR_FRAMERGN,
+ EmfRecordTypeInvertRgn = EMR_INVERTRGN,
+ EmfRecordTypePaintRgn = EMR_PAINTRGN,
+ EmfRecordTypeExtSelectClipRgn = EMR_EXTSELECTCLIPRGN,
+ EmfRecordTypeBitBlt = EMR_BITBLT,
+ EmfRecordTypeStretchBlt = EMR_STRETCHBLT,
+ EmfRecordTypeMaskBlt = EMR_MASKBLT,
+ EmfRecordTypePlgBlt = EMR_PLGBLT,
+ EmfRecordTypeSetDIBitsToDevice = EMR_SETDIBITSTODEVICE,
+ EmfRecordTypeStretchDIBits = EMR_STRETCHDIBITS,
+ EmfRecordTypeExtCreateFontIndirect = EMR_EXTCREATEFONTINDIRECTW,
+ EmfRecordTypeExtTextOutA = EMR_EXTTEXTOUTA,
+ EmfRecordTypeExtTextOutW = EMR_EXTTEXTOUTW,
+ EmfRecordTypePolyBezier16 = EMR_POLYBEZIER16,
+ EmfRecordTypePolygon16 = EMR_POLYGON16,
+ EmfRecordTypePolyline16 = EMR_POLYLINE16,
+ EmfRecordTypePolyBezierTo16 = EMR_POLYBEZIERTO16,
+ EmfRecordTypePolylineTo16 = EMR_POLYLINETO16,
+ EmfRecordTypePolyPolyline16 = EMR_POLYPOLYLINE16,
+ EmfRecordTypePolyPolygon16 = EMR_POLYPOLYGON16,
+ EmfRecordTypePolyDraw16 = EMR_POLYDRAW16,
+ EmfRecordTypeCreateMonoBrush = EMR_CREATEMONOBRUSH,
+ EmfRecordTypeCreateDIBPatternBrushPt = EMR_CREATEDIBPATTERNBRUSHPT,
+ EmfRecordTypeExtCreatePen = EMR_EXTCREATEPEN,
+ EmfRecordTypePolyTextOutA = EMR_POLYTEXTOUTA,
+ EmfRecordTypePolyTextOutW = EMR_POLYTEXTOUTW,
+ EmfRecordTypeSetICMMode = 98,
+ EmfRecordTypeCreateColorSpace = 99,
+ EmfRecordTypeSetColorSpace = 100,
+ EmfRecordTypeDeleteColorSpace = 101,
+ EmfRecordTypeGLSRecord = 102,
+ EmfRecordTypeGLSBoundedRecord = 103,
+ EmfRecordTypePixelFormat = 104,
+ EmfRecordTypeDrawEscape = 105,
+ EmfRecordTypeExtEscape = 106,
+ EmfRecordTypeStartDoc = 107,
+ EmfRecordTypeSmallTextOut = 108,
+ EmfRecordTypeForceUFIMapping = 109,
+ EmfRecordTypeNamedEscape = 110,
+ EmfRecordTypeColorCorrectPalette = 111,
+ EmfRecordTypeSetICMProfileA = 112,
+ EmfRecordTypeSetICMProfileW = 113,
+ EmfRecordTypeAlphaBlend = 114,
+ EmfRecordTypeSetLayout = 115,
+ EmfRecordTypeTransparentBlt = 116,
+ EmfRecordTypeReserved_117 = 117,
+ EmfRecordTypeGradientFill = 118,
+ EmfRecordTypeSetLinkedUFIs = 119,
+ EmfRecordTypeSetTextJustification = 120,
+ EmfRecordTypeColorMatchToTargetW = 121,
+ EmfRecordTypeCreateColorSpaceW = 122,
+ EmfRecordTypeMax = 122,
+ EmfRecordTypeMin = 1,
+ EmfPlusRecordTypeInvalid = GDIP_EMFPLUS_RECORD_BASE,
+ EmfPlusRecordTypeHeader,
+ EmfPlusRecordTypeEndOfFile,
+ EmfPlusRecordTypeComment,
+ EmfPlusRecordTypeGetDC,
+ EmfPlusRecordTypeMultiFormatStart,
+ EmfPlusRecordTypeMultiFormatSection,
+ EmfPlusRecordTypeMultiFormatEnd,
+ EmfPlusRecordTypeObject,
+ EmfPlusRecordTypeClear,
+ EmfPlusRecordTypeFillRects,
+ EmfPlusRecordTypeDrawRects,
+ EmfPlusRecordTypeFillPolygon,
+ EmfPlusRecordTypeDrawLines,
+ EmfPlusRecordTypeFillEllipse,
+ EmfPlusRecordTypeDrawEllipse,
+ EmfPlusRecordTypeFillPie,
+ EmfPlusRecordTypeDrawPie,
+ EmfPlusRecordTypeDrawArc,
+ EmfPlusRecordTypeFillRegion,
+ EmfPlusRecordTypeFillPath,
+ EmfPlusRecordTypeDrawPath,
+ EmfPlusRecordTypeFillClosedCurve,
+ EmfPlusRecordTypeDrawClosedCurve,
+ EmfPlusRecordTypeDrawCurve,
+ EmfPlusRecordTypeDrawBeziers,
+ EmfPlusRecordTypeDrawImage,
+ EmfPlusRecordTypeDrawImagePoints,
+ EmfPlusRecordTypeDrawString,
+ EmfPlusRecordTypeSetRenderingOrigin,
+ EmfPlusRecordTypeSetAntiAliasMode,
+ EmfPlusRecordTypeSetTextRenderingHint,
+ EmfPlusRecordTypeSetTextContrast,
+ EmfPlusRecordTypeSetGammaValue,
+ EmfPlusRecordTypeSetInterpolationMode,
+ EmfPlusRecordTypeSetPixelOffsetMode,
+ EmfPlusRecordTypeSetCompositingMode,
+ EmfPlusRecordTypeSetCompositingQuality,
+ EmfPlusRecordTypeSave,
+ EmfPlusRecordTypeRestore,
+ EmfPlusRecordTypeBeginContainer,
+ EmfPlusRecordTypeBeginContainerNoParams,
+ EmfPlusRecordTypeEndContainer,
+ EmfPlusRecordTypeSetWorldTransform,
+ EmfPlusRecordTypeResetWorldTransform,
+ EmfPlusRecordTypeMultiplyWorldTransform,
+ EmfPlusRecordTypeTranslateWorldTransform,
+ EmfPlusRecordTypeScaleWorldTransform,
+ EmfPlusRecordTypeRotateWorldTransform,
+ EmfPlusRecordTypeSetPageTransform,
+ EmfPlusRecordTypeResetClip,
+ EmfPlusRecordTypeSetClipRect,
+ EmfPlusRecordTypeSetClipPath,
+ EmfPlusRecordTypeSetClipRegion,
+ EmfPlusRecordTypeOffsetClip,
+ EmfPlusRecordTypeDrawDriverString,
+ EmfPlusRecordTypeStrokeFillPath,
+ EmfPlusRecordTypeSerializableObject,
+ EmfPlusRecordTypeSetTSGraphics,
+ EmfPlusRecordTypeSetTSClip,
+ EmfPlusRecordTotal,
+ EmfPlusRecordTypeMax = EmfPlusRecordTotal-1,
+ EmfPlusRecordTypeMin = EmfPlusRecordTypeHeader
+} EmfPlusRecordType;
+
+typedef enum EmfToWmfBitsFlags {
+ EmfToWmfBitsFlagsDefault = 0,
+ EmfToWmfBitsFlagsEmbedEmf = 1,
+ EmfToWmfBitsFlagsIncludePlaceable = 2,
+ EmfToWmfBitsFlagsNoXORClip = 4
+} EmfToWmfBitsFlags;
+
+typedef enum EmfType {
+ EmfTypeEmfOnly = 3,
+ EmfTypeEmfPlusOnly = 4,
+ EmfTypeEmfPlusDual = 5
+} EmfType;
+
+typedef enum EncoderParameterValueType {
+ EncoderParameterValueTypeByte = 1,
+ EncoderParameterValueTypeASCII = 2,
+ EncoderParameterValueTypeShort = 3,
+ EncoderParameterValueTypeLong = 4,
+ EncoderParameterValueTypeRational = 5,
+ EncoderParameterValueTypeLongRange = 6,
+ EncoderParameterValueTypeUndefined = 7,
+ EncoderParameterValueTypeRationalRange = 8,
+ EncoderParameterValueTypePointer = 9
+} EncoderParameterValueType;
+
+typedef enum EncoderValue {
+ EncoderValueColorTypeCMYK = 0,
+ EncoderValueColorTypeYCCK = 1,
+ EncoderValueCompressionLZW = 2,
+ EncoderValueCompressionCCITT3 = 3,
+ EncoderValueCompressionCCITT4 = 4,
+ EncoderValueCompressionRle = 5,
+ EncoderValueCompressionNone = 6,
+ EncoderValueScanMethodInterlaced = 7,
+ EncoderValueScanMethodNonInterlaced = 8,
+ EncoderValueVersionGif87 = 9,
+ EncoderValueVersionGif89 = 10,
+ EncoderValueRenderProgressive = 11,
+ EncoderValueRenderNonProgressive = 12,
+ EncoderValueTransformRotate90 = 13,
+ EncoderValueTransformRotate180 = 14,
+ EncoderValueTransformRotate270 = 15,
+ EncoderValueTransformFlipHorizontal = 16,
+ EncoderValueTransformFlipVertical = 17,
+ EncoderValueMultiFrame = 18,
+ EncoderValueLastFrame = 19,
+ EncoderValueFlush = 20,
+ EncoderValueFrameDimensionTime = 21,
+ EncoderValueFrameDimensionResolution = 22,
+ EncoderValueFrameDimensionPage = 23
+} EncoderValue;
+
+typedef enum FillMode {
+ FillModeAlternate = 0,
+ FillModeWinding = 1
+} FillMode;
+
+typedef enum FlushIntention {
+ FlushIntentionFlush = 0,
+ FlushIntentionSync = 1
+} FlushIntention;
+
+typedef enum FontStyle {
+ FontStyleRegular = 0,
+ FontStyleBold = 1,
+ FontStyleItalic = 2,
+ FontStyleBoldItalic = 3,
+ FontStyleUnderline = 4,
+ FontStyleStrikeout = 8
+} FontStyle;
+
+typedef enum HatchStyle {
+ HatchStyleHorizontal = 0,
+ HatchStyleVertical = 1,
+ HatchStyleForwardDiagonal = 2,
+ HatchStyleBackwardDiagonal = 3,
+ HatchStyleCross = 4,
+ HatchStyleLargeGrid = 4,
+ HatchStyleDiagonalCross = 5,
+ HatchStyle05Percent = 6,
+ HatchStyle10Percent = 7,
+ HatchStyle20Percent = 8,
+ HatchStyle25Percent = 9,
+ HatchStyle30Percent = 10,
+ HatchStyle40Percent = 11,
+ HatchStyle50Percent = 12,
+ HatchStyle60Percent = 13,
+ HatchStyle70Percent = 14,
+ HatchStyle75Percent = 15,
+ HatchStyle80Percent = 16,
+ HatchStyle90Percent = 17,
+ HatchStyleLightDownwardDiagonal = 18,
+ HatchStyleLightUpwardDiagonal = 19,
+ HatchStyleDarkDownwardDiagonal = 20,
+ HatchStyleDarkUpwardDiagonal = 21,
+ HatchStyleWideDownwardDiagonal = 22,
+ HatchStyleWideUpwardDiagonal = 23,
+ HatchStyleLightVertical = 24,
+ HatchStyleLightHorizontal = 25,
+ HatchStyleNarrowVertical = 26,
+ HatchStyleNarrowHorizontal = 27,
+ HatchStyleDarkVertical = 28,
+ HatchStyleDarkHorizontal = 29,
+ HatchStyleDashedDownwardDiagonal = 30,
+ HatchStyleDashedUpwardDiagonal = 31,
+ HatchStyleDashedHorizontal = 32,
+ HatchStyleDashedVertical = 33,
+ HatchStyleSmallConfetti = 34,
+ HatchStyleLargeConfetti = 35,
+ HatchStyleZigZag = 36,
+ HatchStyleWave = 37,
+ HatchStyleDiagonalBrick = 38,
+ HatchStyleHorizontalBrick = 39,
+ HatchStyleWeave = 40,
+ HatchStylePlaid = 41,
+ HatchStyleDivot = 42,
+ HatchStyleDottedGrid = 43,
+ HatchStyleDottedDiamond = 44,
+ HatchStyleShingle = 45,
+ HatchStyleTrellis = 46,
+ HatchStyleSphere = 47,
+ HatchStyleSmallGrid = 48,
+ HatchStyleSmallCheckerBoard = 49,
+ HatchStyleLargeCheckerBoard = 50,
+ HatchStyleOutlinedDiamond = 51,
+ HatchStyleSolidDiamond = 52,
+ HatchStyleTotal = 53,
+ HatchStyleMin = HatchStyleHorizontal,
+ HatchStyleMax = HatchStyleTotal - 1
+} HatchStyle;
+
+typedef enum HotkeyPrefix {
+ HotkeyPrefixNone = 0,
+ HotkeyPrefixShow = 1,
+ HotkeyPrefixHide = 2
+} HotkeyPrefix;
+
+typedef enum ImageType {
+ ImageTypeUnknown = 0,
+ ImageTypeBitmap = 1,
+ ImageTypeMetafile = 2
+} ImageType;
+
+/* TODO: InterpolationMode */
+typedef enum InterpolationMode {
+ /*InterpolationModeInvalid = QualityModeInvalid,*/
+ InterpolationModeDefault = 0,
+ InterpolationModeLowQuality = 1,
+ InterpolationModeHighQuality = 2,
+ InterpolationModeBilinear = 3,
+ InterpolationModeBicubic = 4,
+ InterpolationModeNearestNeighbor = 5,
+ InterpolationModeHighQualityBilinear = 6,
+ InterpolationModeHighQualityBicubic = 7
+} InterpolationMode;
+
+typedef enum LinearGradientMode {
+ LinearGradientModeHorizontal = 0,
+ LinearGradientModeVertical = 1,
+ LinearGradientModeForwardDiagonal = 2,
+ LinearGradientModeBackwardDiagonal = 3
+} LinearGradientMode;
+
+typedef enum LineCap {
+ LineCapFlat = 0,
+ LineCapSquare = 1,
+ LineCapRound = 2,
+ LineCapTriangle = 3,
+ LineCapNoAnchor = 16,
+ LineCapSquareAnchor = 17,
+ LineCapRoundAnchor = 18,
+ LineCapDiamondAnchor = 19,
+ LineCapArrowAnchor = 20,
+ LineCapCustom = 255
+} LineCap;
+
+typedef enum LineJoin {
+ LineJoinMiter = 0,
+ LineJoinBevel = 1,
+ LineJoinRound = 2,
+ LineJoinMiterClipped = 3
+} LineJoin;
+
+typedef enum MatrixOrder {
+ MatrixOrderPrepend = 0,
+ MatrixOrderAppend = 1
+} MatrixOrder;
+
+typedef enum MetafileFrameUnit {
+ MetafileFrameUnitPixel = 2,
+ MetafileFrameUnitPoint = 3,
+ MetafileFrameUnitInch = 4,
+ MetafileFrameUnitDocument = 5,
+ MetafileFrameUnitMillimeter = 6,
+ MetafileFrameUnitGdi = 7
+} MetafileFrameUnit;
+
+typedef enum MetafileType {
+ MetafileTypeInvalid = 0,
+ MetafileTypeWmf = 1,
+ MetafileTypeWmfPlaceable = 2,
+ MetafileTypeEmf = 3,
+ MetafileTypeEmfPlusOnly = 4,
+ MetafileTypeEmfPlusDual = 5
+} MetafileType;
+
+typedef enum ObjectType {
+ ObjectTypeInvalid = 0,
+ ObjectTypeBrush = 1,
+ ObjectTypePen = 2,
+ ObjectTypePath = 3,
+ ObjectTypeRegion = 4,
+ ObjectTypeFont = 5,
+ ObjectTypeStringFormat = 6,
+ ObjectTypeImageAttributes = 7,
+ ObjectTypeCustomLineCap = 8,
+ ObjectTypeGraphics = 9,
+ ObjectTypeMin = ObjectTypeBrush,
+ ObjectTypeMax = ObjectTypeGraphics
+} ObjectType;
+
+typedef enum PathPointType {
+ PathPointTypeStart = 0x00,
+ PathPointTypeLine = 0x01,
+ PathPointTypeBezier = 0x03,
+ PathPointTypeBezier3 = 0x03,
+ PathPointTypePathTypeMask = 0x07,
+ PathPointTypePathDashMode = 0x10,
+ PathPointTypePathMarker = 0x20,
+ PathPointTypeCloseSubpath = 0x80
+} PathPointType;
+
+typedef enum PenAlignment {
+ PenAlignmentCenter = 0,
+ PenAlignmentInset = 1
+} PenAlignment;
+
+typedef enum PenType {
+ PenTypeUnknown = -1,
+ PenTypeSolidColor = 0,
+ PenTypeHatchFill = 1,
+ PenTypeTextureFill = 2,
+ PenTypePathGradient = 3,
+ PenTypeLinearGradient = 4
+} PenType;
+
+/* TODO: PixelOffsetMode */
+typedef enum PixelOffsetMode {
+ /*PixelOffsetModeInvalid = QualityModeInvalid,*/
+ PixelOffsetModeDefault = 0,
+ PixelOffsetModeHighSpeed = 1,
+ PixelOffsetModeHighQuality = 2,
+ PixelOffsetModeNone = 3,
+ PixelOffsetModeHalf = 4
+} PixelOffsetMode;
+
+/* TODO: QualityMode */
+typedef enum QualityMode {
+ /*QualityModeInvalid = ?,*/
+ QualityModeDefault = 0,
+ QualityModeLow = 1,
+ QualityModeHigh = 2
+} QualityMode;
+
+/* TODO: SmoothingMode */
+typedef enum SmoothingMode {
+ /*SmoothingModeInvalid = QualityModeInvalid,*/
+ SmoothingModeDefault = 0,
+ SmoothingModeHighSpeed = 1,
+ SmoothingModeHighQuality = 2,
+ SmoothingModeNone = 3,
+ SmoothingModeAntiAlias8x4 = 4,
+ SmoothingModeAntiAlias = 4,
+ SmoothingModeAntiAlias8x8 = 5
+} SmoothingMode;
+
+typedef enum StringAlignment {
+ StringAlignmentNear = 0,
+ StringAlignmentCenter = 1,
+ StringAlignmentFar = 2
+} StringAlignment;
+
+typedef enum StringDigitSubstitute {
+ StringDigitSubstituteUser = 0,
+ StringDigitSubstituteNone = 1,
+ StringDigitSubstituteNational = 2,
+ StringDigitSubstituteTraditional = 3
+} StringDigitSubstitute;
+
+typedef enum StringFormatFlags {
+ StringFormatFlagsDirectionRightToLeft = 0x00000001,
+ StringFormatFlagsDirectionVertical = 0x00000002,
+ StringFormatFlagsNoFitBlackBox = 0x00000004,
+ StringFormatFlagsDisplayFormatControl = 0x00000020,
+ StringFormatFlagsNoFontFallback = 0x00000400,
+ StringFormatFlagsMeasureTrailingSpaces = 0x00000800,
+ StringFormatFlagsNoWrap = 0x00001000,
+ StringFormatFlagsLineLimit = 0x00002000,
+ StringFormatFlagsNoClip = 0x00004000
+} StringFormatFlags;
+
+typedef enum StringTrimming {
+ StringTrimmingNone = 0,
+ StringTrimmingCharacter = 1,
+ StringTrimmingWord = 2,
+ StringTrimmingEllipsisCharacter = 3,
+ StringTrimmingEllipsisWord = 4,
+ StringTrimmingEllipsisPath = 5
+} StringTrimming;
+
+typedef enum TextRenderingHint {
+ TextRenderingHintSystemDefault = 0,
+ TextRenderingHintSingleBitPerPixelGridFit = 1,
+ TextRenderingHintSingleBitPerPixel = 2,
+ TextRenderingHintAntiAliasGridFit = 3,
+ TextRenderingHintAntiAlias = 4,
+ TextRenderingHintClearTypeGridFit = 5
+} TextRenderingHint;
+
+typedef enum Unit {
+ UnitWorld = 0,
+ UnitDisplay = 1,
+ UnitPixel = 2,
+ UnitPoint = 3,
+ UnitInch = 4,
+ UnitDocument = 5,
+ UnitMillimeter = 6
+} Unit;
+
+typedef enum WarpMode {
+ WarpModePerspective = 0,
+ WarpModeBilinear = 1
+} WarpMode;
+
+typedef enum WrapMode {
+ WrapModeTile = 0,
+ WrapModeTileFlipX = 1,
+ WrapModeTileFlipY = 2,
+ WrapModeTileFlipXY = 3,
+ WrapModeClamp = 4
+} WrapMode;
+
+typedef enum GpTestControlEnum {
+ TestControlForceBilinear = 0,
+ TestControlForceNoICM = 1,
+ TestControlGetBuildNumber = 2
+} GpTestControlEnum;
+
+/* Opaque handles to information blocks on an internal GDI+ stack. */
+typedef DWORD GraphicsContainer;
+typedef DWORD GraphicsState;
+
+/* Default flatness for GraphicsPath methods Flatten, Outline, Warp, Widen */
+/* FIXME: Is FlatnessDefault = 0.25f correct? */
+#ifdef __cplusplus
+const REAL FlatnessDefault = 0.25f;
+#else
+#define FlatnessDefault ((REAL) 0.25f)
+#endif
+
+static __inline__ BOOL ObjectTypeIsValid(ObjectType type)
+{
+ switch (type) {
+ case ObjectTypeBrush:
+ case ObjectTypePen:
+ case ObjectTypePath:
+ case ObjectTypeRegion:
+ case ObjectTypeFont:
+ case ObjectTypeStringFormat:
+ case ObjectTypeImageAttributes:
+ case ObjectTypeCustomLineCap:
+ case ObjectTypeGraphics:
+ return TRUE;
+ default:
+ return FALSE;
+ }
+}
+
+#endif /* __GDIPLUS_ENUMS_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_FLAT_H
+#define __GDIPLUS_FLAT_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifdef __cplusplus
+namespace DllExports {
+extern "C" {
+#endif
+
+/* AdjustableArrowCap functions */
+GpStatus WINGDIPAPI GdipCreateAdjustableArrowCap(REAL,REAL,BOOL,GpAdjustableArrowCap**);
+GpStatus WINGDIPAPI GdipSetAdjustableArrowCapHeight(GpAdjustableArrowCap*,REAL);
+GpStatus WINGDIPAPI GdipGetAdjustableArrowCapHeight(GpAdjustableArrowCap*,REAL*);
+GpStatus WINGDIPAPI GdipSetAdjustableArrowCapWidth(GpAdjustableArrowCap*,REAL);
+GpStatus WINGDIPAPI GdipGetAdjustableArrowCapWidth(GpAdjustableArrowCap*,REAL*);
+GpStatus WINGDIPAPI GdipSetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap*,REAL);
+GpStatus WINGDIPAPI GdipGetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap*,REAL*);
+GpStatus WINGDIPAPI GdipSetAdjustableArrowCapFillState(GpAdjustableArrowCap*,BOOL);
+GpStatus WINGDIPAPI GdipGetAdjustableArrowCapFillState(GpAdjustableArrowCap*,BOOL*);
+
+/* Bitmap functions */
+GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream*,GpBitmap**);
+GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR*,GpBitmap**);
+GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream*,GpBitmap**);
+GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR*,GpBitmap**);
+GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT,INT,INT,PixelFormat,BYTE*,GpBitmap**);
+GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT,INT,GpGraphics*,GpBitmap**);
+GpStatus WINGDIPAPI GdipCreateBitmapFromDirectDrawSurface(IDirectDrawSurface7*,GpBitmap**);
+GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO*,VOID*,GpBitmap**);
+GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP,HPALETTE,GpBitmap**);
+GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap*,HBITMAP*,ARGB);
+GpStatus WINGDIPAPI GdipCreateBitmapFromHICON(HICON,GpBitmap**);
+GpStatus WINGDIPAPI GdipCreateHICONFromBitmap(GpBitmap*,HICON*);
+GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE,GDIPCONST WCHAR*,GpBitmap**);
+GpStatus WINGDIPAPI GdipCloneBitmapArea(REAL,REAL,REAL,REAL,PixelFormat,GpBitmap*,GpBitmap**);
+GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT,INT,INT,INT,PixelFormat,GpBitmap*,GpBitmap**);
+GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap*,GDIPCONST GpRect*,UINT,PixelFormat,BitmapData*);
+GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap*,BitmapData*);
+GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap*,INT,INT,ARGB*);
+GpStatus WINGDIPAPI GdipBitmapSetPixel(GpBitmap*,INT,INT,ARGB);
+GpStatus WINGDIPAPI GdipBitmapSetResolution(GpBitmap*,REAL,REAL);
+GpStatus WINGDIPAPI GdipBitmapConvertFormat(GpBitmap*,PixelFormat,DitherType,PaletteType,ColorPalette*,REAL);
+GpStatus WINGDIPAPI GdipInitializePalette(ColorPalette*,PaletteType,INT,BOOL,GpBitmap*);
+GpStatus WINGDIPAPI GdipBitmapApplyEffect(GpBitmap*,CGpEffect*,RECT*,BOOL,VOID**,INT*);
+GpStatus WINGDIPAPI GdipBitmapCreateApplyEffect(GpBitmap**,INT,CGpEffect*,RECT*,RECT*,GpBitmap**,BOOL,VOID**,INT*);
+GpStatus WINGDIPAPI GdipBitmapGetHistogram(GpBitmap*,HistogramFormat,UINT,UINT*,UINT*,UINT*,UINT*);
+GpStatus WINGDIPAPI GdipBitmapGetHistogramSize(HistogramFormat,UINT*);
+
+/* Brush functions */
+GpStatus WINGDIPAPI GdipCloneBrush(GpBrush*,GpBrush**);
+GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush*);
+GpStatus WINGDIPAPI GdipGetBrushType(GpBrush*,GpBrushType*);
+
+/* CachedBitmap functions */
+GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap*,GpGraphics*,GpCachedBitmap**);
+GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap*);
+GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics*,GpCachedBitmap*,INT,INT);
+
+/* CustomLineCap functions */
+GpStatus WINGDIPAPI GdipCreateCustomLineCap(GpPath*,GpPath*,GpLineCap,REAL,GpCustomLineCap**);
+GpStatus WINGDIPAPI GdipDeleteCustomLineCap(GpCustomLineCap*);
+GpStatus WINGDIPAPI GdipCloneCustomLineCap(GpCustomLineCap*,GpCustomLineCap**);
+GpStatus WINGDIPAPI GdipGetCustomLineCapType(GpCustomLineCap*,CustomLineCapType*);
+GpStatus WINGDIPAPI GdipSetCustomLineCapStrokeCaps(GpCustomLineCap*,GpLineCap,GpLineCap);
+GpStatus WINGDIPAPI GdipGetCustomLineCapStrokeCaps(GpCustomLineCap*,GpLineCap*,GpLineCap*);
+GpStatus WINGDIPAPI GdipSetCustomLineCapStrokeJoin(GpCustomLineCap*,GpLineJoin);
+GpStatus WINGDIPAPI GdipGetCustomLineCapStrokeJoin(GpCustomLineCap*,GpLineJoin*);
+GpStatus WINGDIPAPI GdipSetCustomLineCapBaseCap(GpCustomLineCap*,GpLineCap);
+GpStatus WINGDIPAPI GdipGetCustomLineCapBaseCap(GpCustomLineCap*,GpLineCap*);
+GpStatus WINGDIPAPI GdipSetCustomLineCapBaseInset(GpCustomLineCap*,REAL);
+GpStatus WINGDIPAPI GdipGetCustomLineCapBaseInset(GpCustomLineCap*,REAL*);
+GpStatus WINGDIPAPI GdipSetCustomLineCapWidthScale(GpCustomLineCap*,REAL);
+GpStatus WINGDIPAPI GdipGetCustomLineCapWidthScale(GpCustomLineCap*,REAL*);
+
+/* Effect functions */
+GpStatus WINGDIPAPI GdipCreateEffect(GDIPCONST GUID,CGpEffect**);
+GpStatus WINGDIPAPI GdipDeleteEffect(CGpEffect*);
+GpStatus WINGDIPAPI GdipGetEffectParameterSize(CGpEffect*,UINT*);
+GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect*,GDIPCONST VOID*,UINT);
+GpStatus WINGDIPAPI GdipGetEffectParameters(CGpEffect*,UINT*,VOID*);
+
+/* Font functions */
+GpStatus WINGDIPAPI GdipCreateFontFromDC(HDC,GpFont**);
+GpStatus WINGDIPAPI GdipCreateFontFromLogfontA(HDC,GDIPCONST LOGFONTA*,GpFont**);
+GpStatus WINGDIPAPI GdipCreateFontFromLogfontW(HDC,GDIPCONST LOGFONTW*,GpFont**);
+GpStatus WINGDIPAPI GdipCreateFont(GDIPCONST GpFontFamily*,REAL,INT,Unit,GpFont**);
+GpStatus WINGDIPAPI GdipCloneFont(GpFont*,GpFont**);
+GpStatus WINGDIPAPI GdipDeleteFont(GpFont*);
+GpStatus WINGDIPAPI GdipGetFamily(GpFont*,GpFontFamily**);
+GpStatus WINGDIPAPI GdipGetFontStyle(GpFont*,INT*);
+GpStatus WINGDIPAPI GdipGetFontSize(GpFont*,REAL*);
+GpStatus WINGDIPAPI GdipGetFontUnit(GpFont*,Unit*);
+GpStatus WINGDIPAPI GdipGetFontHeight(GDIPCONST GpFont*,GDIPCONST GpGraphics*,REAL*);
+GpStatus WINGDIPAPI GdipGetFontHeightGivenDPI(GDIPCONST GpFont*,REAL,REAL*);
+GpStatus WINGDIPAPI GdipGetLogFontA(GpFont*,GpGraphics*,LOGFONTA*);
+GpStatus WINGDIPAPI GdipGetLogFontW(GpFont*,GpGraphics*,LOGFONTW*);
+GpStatus WINGDIPAPI GdipNewInstalledFontCollection(GpFontCollection**);
+GpStatus WINGDIPAPI GdipNewPrivateFontCollection(GpFontCollection**);
+GpStatus WINGDIPAPI GdipDeletePrivateFontCollection(GpFontCollection**);
+GpStatus WINGDIPAPI GdipGetFontCollectionFamilyCount(GpFontCollection*,INT*);
+GpStatus WINGDIPAPI GdipGetFontCollectionFamilyList(GpFontCollection*,INT,GpFontFamily**,INT*);
+GpStatus WINGDIPAPI GdipPrivateAddFontFile(GpFontCollection*,GDIPCONST WCHAR*);
+GpStatus WINGDIPAPI GdipPrivateAddMemoryFont(GpFontCollection*,GDIPCONST void*,INT);
+
+/* FontFamily functions */
+GpStatus WINGDIPAPI GdipCreateFontFamilyFromName(GDIPCONST WCHAR*,GpFontCollection*,GpFontFamily**);
+GpStatus WINGDIPAPI GdipDeleteFontFamily(GpFontFamily*);
+GpStatus WINGDIPAPI GdipCloneFontFamily(GpFontFamily*,GpFontFamily**);
+GpStatus WINGDIPAPI GdipGetGenericFontFamilySansSerif(GpFontFamily**);
+GpStatus WINGDIPAPI GdipGetGenericFontFamilySerif(GpFontFamily**);
+GpStatus WINGDIPAPI GdipGetGenericFontFamilyMonospace(GpFontFamily**);
+GpStatus WINGDIPAPI GdipGetFamilyName(GDIPCONST GpFontFamily*,WCHAR[LF_FACESIZE],LANGID);
+GpStatus WINGDIPAPI GdipIsStyleAvailable(GDIPCONST GpFontFamily*,INT,BOOL*);
+GpStatus WINGDIPAPI GdipFontCollectionEnumerable(GpFontCollection*,GpGraphics*,INT*);
+GpStatus WINGDIPAPI GdipFontCollectionEnumerate(GpFontCollection*,INT,GpFontFamily**,INT*,GpGraphics*);
+GpStatus WINGDIPAPI GdipGetEmHeight(GDIPCONST GpFontFamily*,INT,UINT16*);
+GpStatus WINGDIPAPI GdipGetCellAscent(GDIPCONST GpFontFamily*,INT,UINT16*);
+GpStatus WINGDIPAPI GdipGetCellDescent(GDIPCONST GpFontFamily*,INT,UINT16*);
+GpStatus WINGDIPAPI GdipGetLineSpacing(GDIPCONST GpFontFamily*,INT,UINT16*);
+
+/* Graphics functions */
+GpStatus WINGDIPAPI GdipFlush(GpGraphics*,GpFlushIntention);
+GpStatus WINGDIPAPI GdipCreateFromHDC(HDC,GpGraphics**);
+GpStatus WINGDIPAPI GdipCreateFromHDC2(HDC,HANDLE,GpGraphics**);
+GpStatus WINGDIPAPI GdipCreateFromHWND(HWND,GpGraphics**);
+GpStatus WINGDIPAPI GdipCreateFromHWNDICM(HWND,GpGraphics**);
+GpStatus WINGDIPAPI GdipDeleteGraphics(GpGraphics*);
+GpStatus WINGDIPAPI GdipGetDC(GpGraphics*,HDC*);
+GpStatus WINGDIPAPI GdipReleaseDC(GpGraphics*,HDC);
+GpStatus WINGDIPAPI GdipSetCompositingMode(GpGraphics*,CompositingMode);
+GpStatus WINGDIPAPI GdipGetCompositingMode(GpGraphics*,CompositingMode*);
+GpStatus WINGDIPAPI GdipSetRenderingOrigin(GpGraphics*,INT,INT);
+GpStatus WINGDIPAPI GdipGetRenderingOrigin(GpGraphics*,INT*,INT*);
+GpStatus WINGDIPAPI GdipSetCompositingQuality(GpGraphics*,CompositingQuality);
+GpStatus WINGDIPAPI GdipGetCompositingQuality(GpGraphics*,CompositingQuality*);
+GpStatus WINGDIPAPI GdipSetSmoothingMode(GpGraphics*,SmoothingMode);
+GpStatus WINGDIPAPI GdipGetSmoothingMode(GpGraphics*,SmoothingMode*);
+GpStatus WINGDIPAPI GdipSetPixelOffsetMode(GpGraphics*,PixelOffsetMode);
+GpStatus WINGDIPAPI GdipGetPixelOffsetMode(GpGraphics*,PixelOffsetMode*);
+GpStatus WINGDIPAPI GdipSetTextRenderingHint(GpGraphics*,TextRenderingHint);
+GpStatus WINGDIPAPI GdipGetTextRenderingHint(GpGraphics*,TextRenderingHint*);
+GpStatus WINGDIPAPI GdipSetTextContrast(GpGraphics*,UINT);
+GpStatus WINGDIPAPI GdipGetTextContrast(GpGraphics*,UINT*);
+GpStatus WINGDIPAPI GdipSetInterpolationMode(GpGraphics*,InterpolationMode);
+GpStatus WINGDIPAPI GdipGraphicsSetAbort(GpGraphics*,GdiplusAbort*);
+GpStatus WINGDIPAPI GdipGetInterpolationMode(GpGraphics*,InterpolationMode*);
+GpStatus WINGDIPAPI GdipSetWorldTransform(GpGraphics*,GpMatrix*);
+GpStatus WINGDIPAPI GdipResetWorldTransform(GpGraphics*);
+GpStatus WINGDIPAPI GdipMultiplyWorldTransform(GpGraphics*,GDIPCONST GpMatrix*,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipTranslateWorldTransform(GpGraphics*,REAL,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipScaleWorldTransform(GpGraphics*,REAL,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipRotateWorldTransform(GpGraphics*,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipGetWorldTransform(GpGraphics*,GpMatrix*);
+GpStatus WINGDIPAPI GdipResetPageTransform(GpGraphics*);
+GpStatus WINGDIPAPI GdipGetPageUnit(GpGraphics*,GpUnit*);
+GpStatus WINGDIPAPI GdipGetPageScale(GpGraphics*,REAL*);
+GpStatus WINGDIPAPI GdipSetPageUnit(GpGraphics*,GpUnit);
+GpStatus WINGDIPAPI GdipSetPageScale(GpGraphics*,REAL);
+GpStatus WINGDIPAPI GdipGetDpiX(GpGraphics*,REAL*);
+GpStatus WINGDIPAPI GdipGetDpiY(GpGraphics*,REAL*);
+GpStatus WINGDIPAPI GdipTransformPoints(GpGraphics*,GpCoordinateSpace,GpCoordinateSpace,GpPointF*,INT);
+GpStatus WINGDIPAPI GdipTransformPointsI(GpGraphics*,GpCoordinateSpace,GpCoordinateSpace,GpPoint*,INT);
+GpStatus WINGDIPAPI GdipGetNearestColor(GpGraphics*,ARGB*);
+HPALETTE WINGDIPAPI GdipCreateHalftonePalette(void);
+GpStatus WINGDIPAPI GdipDrawLine(GpGraphics*,GpPen*,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipDrawLineI(GpGraphics*,GpPen*,INT,INT,INT,INT);
+GpStatus WINGDIPAPI GdipDrawLines(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT);
+GpStatus WINGDIPAPI GdipDrawLinesI(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT);
+GpStatus WINGDIPAPI GdipDrawArc(GpGraphics*,GpPen*,REAL,REAL,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipDrawArcI(GpGraphics*,GpPen*,INT,INT,INT,INT,REAL,REAL);
+GpStatus WINGDIPAPI GdipDrawBezier(GpGraphics*,GpPen*,REAL,REAL,REAL,REAL,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipDrawBezierI(GpGraphics*,GpPen*,INT,INT,INT,INT,INT,INT,INT,INT);
+GpStatus WINGDIPAPI GdipDrawBeziers(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT);
+GpStatus WINGDIPAPI GdipDrawBeziersI(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT);
+GpStatus WINGDIPAPI GdipDrawRectangle(GpGraphics*,GpPen*,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipDrawRectangleI(GpGraphics*,GpPen*,INT,INT,INT,INT);
+GpStatus WINGDIPAPI GdipDrawRectangles(GpGraphics*,GpPen*,GDIPCONST GpRectF*,INT);
+GpStatus WINGDIPAPI GdipDrawRectanglesI(GpGraphics*,GpPen*,GDIPCONST GpRect*,INT);
+GpStatus WINGDIPAPI GdipDrawEllipse(GpGraphics*,GpPen*,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipDrawEllipseI(GpGraphics*,GpPen*,INT,INT,INT,INT);
+GpStatus WINGDIPAPI GdipDrawPie(GpGraphics*,GpPen*,REAL,REAL,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipDrawPieI(GpGraphics*,GpPen*,INT,INT,INT,INT,REAL,REAL);
+GpStatus WINGDIPAPI GdipDrawPolygon(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT);
+GpStatus WINGDIPAPI GdipDrawPolygonI(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT);
+GpStatus WINGDIPAPI GdipDrawPath(GpGraphics*,GpPen*,GpPath*);
+GpStatus WINGDIPAPI GdipDrawCurve(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT);
+GpStatus WINGDIPAPI GdipDrawCurveI(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT);
+GpStatus WINGDIPAPI GdipDrawCurve2(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT,REAL);
+GpStatus WINGDIPAPI GdipDrawCurve2I(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT,REAL);
+GpStatus WINGDIPAPI GdipDrawCurve3(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT,INT,INT,REAL);
+GpStatus WINGDIPAPI GdipDrawCurve3I(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT,INT,INT,REAL);
+GpStatus WINGDIPAPI GdipDrawClosedCurve(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT);
+GpStatus WINGDIPAPI GdipDrawClosedCurveI(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT);
+GpStatus WINGDIPAPI GdipDrawClosedCurve2(GpGraphics*,GpPen*,GDIPCONST GpPointF*,INT,REAL);
+GpStatus WINGDIPAPI GdipDrawClosedCurve2I(GpGraphics*,GpPen*,GDIPCONST GpPoint*,INT,REAL);
+GpStatus WINGDIPAPI GdipGraphicsClear(GpGraphics*,ARGB);
+GpStatus WINGDIPAPI GdipFillRectangle(GpGraphics*,GpBrush*,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipFillRectangleI(GpGraphics*,GpBrush*,INT,INT,INT,INT);
+GpStatus WINGDIPAPI GdipFillRectangles(GpGraphics*,GpBrush*,GDIPCONST GpRectF*,INT);
+GpStatus WINGDIPAPI GdipFillRectanglesI(GpGraphics*,GpBrush*,GDIPCONST GpRect*,INT);
+GpStatus WINGDIPAPI GdipFillPolygon(GpGraphics*,GpBrush*,GDIPCONST GpPointF*,INT,GpFillMode);
+GpStatus WINGDIPAPI GdipFillPolygonI(GpGraphics*,GpBrush*,GDIPCONST GpPoint*,INT,GpFillMode);
+GpStatus WINGDIPAPI GdipFillPolygon2(GpGraphics*,GpBrush*,GDIPCONST GpPointF*,INT);
+GpStatus WINGDIPAPI GdipFillPolygon2I(GpGraphics*,GpBrush*,GDIPCONST GpPoint*,INT);
+GpStatus WINGDIPAPI GdipFillEllipse(GpGraphics*,GpBrush*,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipFillEllipseI(GpGraphics*,GpBrush*,INT,INT,INT,INT);
+GpStatus WINGDIPAPI GdipFillPie(GpGraphics*,GpBrush*,REAL,REAL,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipFillPieI(GpGraphics*,GpBrush*,INT,INT,INT,INT,REAL,REAL);
+GpStatus WINGDIPAPI GdipFillPath(GpGraphics*,GpBrush*,GpPath*);
+GpStatus WINGDIPAPI GdipFillClosedCurve(GpGraphics*,GpBrush*,GDIPCONST GpPointF*,INT);
+GpStatus WINGDIPAPI GdipFillClosedCurveI(GpGraphics*,GpBrush*,GDIPCONST GpPoint*,INT);
+GpStatus WINGDIPAPI GdipFillClosedCurve2(GpGraphics*,GpBrush*,GDIPCONST GpPointF*,INT,REAL,GpFillMode);
+GpStatus WINGDIPAPI GdipFillClosedCurve2I(GpGraphics*,GpBrush*,GDIPCONST GpPoint*,INT,REAL,GpFillMode);
+GpStatus WINGDIPAPI GdipFillRegion(GpGraphics*,GpBrush*,GpRegion*);
+GpStatus WINGDIPAPI GdipDrawImage(GpGraphics*,GpImage*,REAL,REAL);
+GpStatus WINGDIPAPI GdipDrawImageI(GpGraphics*,GpImage*,INT,INT);
+GpStatus WINGDIPAPI GdipDrawImageRect(GpGraphics*,GpImage*,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipDrawImageRectI(GpGraphics*,GpImage*,INT,INT,INT,INT);
+GpStatus WINGDIPAPI GdipDrawImagePoints(GpGraphics*,GpImage*,GDIPCONST GpPointF*,INT);
+GpStatus WINGDIPAPI GdipDrawImagePointsI(GpGraphics*,GpImage*,GDIPCONST GpPoint*,INT);
+GpStatus WINGDIPAPI GdipDrawImagePointRect(GpGraphics*,GpImage*,REAL,REAL,REAL,REAL,REAL,REAL,GpUnit);
+GpStatus WINGDIPAPI GdipDrawImagePointRectI(GpGraphics*,GpImage*,INT,INT,INT,INT,INT,INT,GpUnit);
+GpStatus WINGDIPAPI GdipDrawImageRectRect(GpGraphics*,GpImage*,REAL,REAL,REAL,REAL,REAL,REAL,REAL,REAL,GpUnit,GDIPCONST GpImageAttributes*,DrawImageAbort,VOID*);
+GpStatus WINGDIPAPI GdipDrawImageRectRectI(GpGraphics*,GpImage*,INT,INT,INT,INT,INT,INT,INT,INT,GpUnit,GDIPCONST GpImageAttributes*,DrawImageAbort,VOID*);
+GpStatus WINGDIPAPI GdipDrawImagePointsRect(GpGraphics*,GpImage*,GDIPCONST GpPointF*,INT,REAL,REAL,REAL,REAL,GpUnit,GDIPCONST GpImageAttributes*,DrawImageAbort,VOID*);
+GpStatus WINGDIPAPI GdipDrawImagePointsRectI(GpGraphics*,GpImage*,GDIPCONST GpPoint*,INT,INT,INT,INT,INT,GpUnit,GDIPCONST GpImageAttributes*,DrawImageAbort,VOID*);
+GpStatus WINGDIPAPI GdipDrawImageFX(GpGraphics*,GpImage*,GpRectF*,GpMatrix*,CGpEffect*,GpImageAttributes*,GpUnit);
+#ifdef __cplusplus
+GpStatus WINGDIPAPI GdipEnumerateMetafileDestPoint(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST PointF&,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
+GpStatus WINGDIPAPI GdipEnumerateMetafileDestPointI(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST Point&,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
+GpStatus WINGDIPAPI GdipEnumerateMetafileDestRect(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST RectF&,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
+GpStatus WINGDIPAPI GdipEnumerateMetafileDestRectI(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST Rect&,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
+#endif
+GpStatus WINGDIPAPI GdipEnumerateMetafileDestPoints(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST PointF*,INT,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
+GpStatus WINGDIPAPI GdipEnumerateMetafileDestPointsI(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST Point*,INT,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
+#ifdef __cplusplus
+GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPoint(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST PointF&,GDIPCONST RectF&,Unit,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
+GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPointI(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST Point&,GDIPCONST Rect&,Unit,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
+GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestRect(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST RectF&,GDIPCONST RectF&,Unit,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
+GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestRectI(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST Rect&,GDIPCONST Rect&,Unit,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
+GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPoints(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST PointF*,INT,GDIPCONST RectF&,Unit,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
+GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPointsI(GpGraphics*,GDIPCONST GpMetafile*,GDIPCONST Point*,INT,GDIPCONST Rect&,Unit,EnumerateMetafileProc,VOID*,GDIPCONST GpImageAttributes*);
+#endif
+GpStatus WINGDIPAPI GdipSetClipGraphics(GpGraphics*,GpGraphics*,CombineMode);
+GpStatus WINGDIPAPI GdipSetClipRect(GpGraphics*,REAL,REAL,REAL,REAL,CombineMode);
+GpStatus WINGDIPAPI GdipSetClipRectI(GpGraphics*,INT,INT,INT,INT,CombineMode);
+GpStatus WINGDIPAPI GdipSetClipPath(GpGraphics*,GpPath*,CombineMode);
+GpStatus WINGDIPAPI GdipSetClipRegion(GpGraphics*,GpRegion*,CombineMode);
+GpStatus WINGDIPAPI GdipSetClipHrgn(GpGraphics*,HRGN,CombineMode);
+GpStatus WINGDIPAPI GdipResetClip(GpGraphics*);
+GpStatus WINGDIPAPI GdipTranslateClip(GpGraphics*,REAL,REAL);
+GpStatus WINGDIPAPI GdipTranslateClipI(GpGraphics*,INT,INT);
+GpStatus WINGDIPAPI GdipGetClip(GpGraphics*,GpRegion*);
+GpStatus WINGDIPAPI GdipGetClipBounds(GpGraphics*,GpRectF*);
+GpStatus WINGDIPAPI GdipGetClipBoundsI(GpGraphics*,GpRect*);
+GpStatus WINGDIPAPI GdipIsClipEmpty(GpGraphics*,BOOL*);
+GpStatus WINGDIPAPI GdipGetVisibleClipBounds(GpGraphics*,GpRectF*);
+GpStatus WINGDIPAPI GdipGetVisibleClipBoundsI(GpGraphics*,GpRect*);
+GpStatus WINGDIPAPI GdipIsVisibleClipEmpty(GpGraphics*,BOOL*);
+GpStatus WINGDIPAPI GdipIsVisiblePoint(GpGraphics*,REAL,REAL,BOOL*);
+GpStatus WINGDIPAPI GdipIsVisiblePointI(GpGraphics*,INT,INT,BOOL*);
+GpStatus WINGDIPAPI GdipIsVisibleRect(GpGraphics*,REAL,REAL,REAL,REAL,BOOL*);
+GpStatus WINGDIPAPI GdipIsVisibleRectI(GpGraphics*,INT,INT,INT,INT,BOOL*);
+GpStatus WINGDIPAPI GdipSaveGraphics(GpGraphics*,GraphicsState*);
+GpStatus WINGDIPAPI GdipRestoreGraphics(GpGraphics*,GraphicsState);
+GpStatus WINGDIPAPI GdipBeginContainer(GpGraphics*,GDIPCONST GpRectF*,GDIPCONST GpRectF*,GpUnit,GraphicsContainer*);
+GpStatus WINGDIPAPI GdipBeginContainerI(GpGraphics*,GDIPCONST GpRect*,GDIPCONST GpRect*,GpUnit,GraphicsContainer*);
+GpStatus WINGDIPAPI GdipBeginContainer2(GpGraphics*,GraphicsContainer*);
+GpStatus WINGDIPAPI GdipEndContainer(GpGraphics*,GraphicsContainer);
+GpStatus WINGDIPAPI GdipComment(GpGraphics*,UINT,GDIPCONST BYTE*);
+
+/* GraphicsPath functions */
+GpStatus WINGDIPAPI GdipCreatePath(GpFillMode,GpPath**);
+GpStatus WINGDIPAPI GdipCreatePath2(GDIPCONST GpPointF*,GDIPCONST BYTE*,INT,GpFillMode,GpPath**);
+GpStatus WINGDIPAPI GdipCreatePath2I(GDIPCONST GpPoint*,GDIPCONST BYTE*,INT,GpFillMode,GpPath**);
+GpStatus WINGDIPAPI GdipClonePath(GpPath*,GpPath**);
+GpStatus WINGDIPAPI GdipDeletePath(GpPath*);
+GpStatus WINGDIPAPI GdipResetPath(GpPath*);
+GpStatus WINGDIPAPI GdipGetPointCount(GpPath*,INT*);
+GpStatus WINGDIPAPI GdipGetPathTypes(GpPath*,BYTE*,INT);
+GpStatus WINGDIPAPI GdipGetPathPoints(GpPath*,GpPointF*,INT);
+GpStatus WINGDIPAPI GdipGetPathPointsI(GpPath*,GpPoint*,INT);
+GpStatus WINGDIPAPI GdipGetPathFillMode(GpPath*,GpFillMode*);
+GpStatus WINGDIPAPI GdipSetPathFillMode(GpPath*,GpFillMode);
+GpStatus WINGDIPAPI GdipGetPathData(GpPath*,GpPathData*);
+GpStatus WINGDIPAPI GdipStartPathFigure(GpPath*);
+GpStatus WINGDIPAPI GdipClosePathFigure(GpPath*);
+GpStatus WINGDIPAPI GdipClosePathFigures(GpPath*);
+GpStatus WINGDIPAPI GdipSetPathMarker(GpPath*);
+GpStatus WINGDIPAPI GdipClearPathMarkers(GpPath*);
+GpStatus WINGDIPAPI GdipReversePath(GpPath*);
+GpStatus WINGDIPAPI GdipGetPathLastPoint(GpPath*,GpPointF*);
+GpStatus WINGDIPAPI GdipAddPathLine(GpPath*,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipAddPathLine2(GpPath*,GDIPCONST GpPointF*,INT);
+GpStatus WINGDIPAPI GdipAddPathArc(GpPath*,REAL,REAL,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipAddPathBezier(GpPath*,REAL,REAL,REAL,REAL,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipAddPathBeziers(GpPath*,GDIPCONST GpPointF*,INT);
+GpStatus WINGDIPAPI GdipAddPathCurve(GpPath*,GDIPCONST GpPointF*,INT);
+GpStatus WINGDIPAPI GdipAddPathCurve2(GpPath*,GDIPCONST GpPointF*,INT,REAL);
+GpStatus WINGDIPAPI GdipAddPathCurve3(GpPath*,GDIPCONST GpPointF*,INT,INT,INT,REAL);
+GpStatus WINGDIPAPI GdipAddPathClosedCurve(GpPath*,GDIPCONST GpPointF*,INT);
+GpStatus WINGDIPAPI GdipAddPathClosedCurve2(GpPath*,GDIPCONST GpPointF*,INT,REAL);
+GpStatus WINGDIPAPI GdipAddPathRectangle(GpPath*,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipAddPathRectangles(GpPath*,GDIPCONST GpRectF*,INT);
+GpStatus WINGDIPAPI GdipAddPathEllipse(GpPath*,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipAddPathPie(GpPath*,REAL,REAL,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipAddPathPolygon(GpPath*,GDIPCONST GpPointF*,INT);
+GpStatus WINGDIPAPI GdipAddPathPath(GpPath*,GDIPCONST GpPath*,BOOL);
+GpStatus WINGDIPAPI GdipAddPathString(GpPath*,GDIPCONST WCHAR*,INT,GDIPCONST GpFontFamily*,INT,REAL,GDIPCONST RectF*,GDIPCONST GpStringFormat*);
+GpStatus WINGDIPAPI GdipAddPathStringI(GpPath*,GDIPCONST WCHAR*,INT,GDIPCONST GpFontFamily*,INT,REAL,GDIPCONST Rect*,GDIPCONST GpStringFormat*);
+GpStatus WINGDIPAPI GdipAddPathLineI(GpPath*,INT,INT,INT,INT);
+GpStatus WINGDIPAPI GdipAddPathLine2I(GpPath*,GDIPCONST GpPoint*,INT);
+GpStatus WINGDIPAPI GdipAddPathArcI(GpPath*,INT,INT,INT,INT,REAL,REAL);
+GpStatus WINGDIPAPI GdipAddPathBezierI(GpPath*,INT,INT,INT,INT,INT,INT,INT,INT);
+GpStatus WINGDIPAPI GdipAddPathBeziersI(GpPath*,GDIPCONST GpPoint*,INT);
+GpStatus WINGDIPAPI GdipAddPathCurveI(GpPath*,GDIPCONST GpPoint*,INT);
+GpStatus WINGDIPAPI GdipAddPathCurve2I(GpPath*,GDIPCONST GpPoint*,INT,REAL);
+GpStatus WINGDIPAPI GdipAddPathCurve3I(GpPath*,GDIPCONST GpPoint*,INT,INT,INT,REAL);
+GpStatus WINGDIPAPI GdipAddPathClosedCurveI(GpPath*,GDIPCONST GpPoint*,INT);
+GpStatus WINGDIPAPI GdipAddPathClosedCurve2I(GpPath*,GDIPCONST GpPoint*,INT,REAL);
+GpStatus WINGDIPAPI GdipAddPathRectangleI(GpPath*,INT,INT,INT,INT);
+GpStatus WINGDIPAPI GdipAddPathRectanglesI(GpPath*,GDIPCONST GpRect*,INT);
+GpStatus WINGDIPAPI GdipAddPathEllipseI(GpPath*,INT,INT,INT,INT);
+GpStatus WINGDIPAPI GdipAddPathPieI(GpPath*,INT,INT,INT,INT,REAL,REAL);
+GpStatus WINGDIPAPI GdipAddPathPolygonI(GpPath*,GDIPCONST GpPoint*,INT);
+GpStatus WINGDIPAPI GdipFlattenPath(GpPath*,GpMatrix*,REAL);
+GpStatus WINGDIPAPI GdipWindingModeOutline(GpPath*,GpMatrix*,REAL);
+GpStatus WINGDIPAPI GdipWidenPath(GpPath*,GpPen*,GpMatrix*,REAL);
+GpStatus WINGDIPAPI GdipWarpPath(GpPath*,GpMatrix*,GDIPCONST GpPointF*,INT,REAL,REAL,REAL,REAL,WarpMode,REAL);
+GpStatus WINGDIPAPI GdipTransformPath(GpPath*,GpMatrix*);
+GpStatus WINGDIPAPI GdipGetPathWorldBounds(GpPath*,GpRectF*,GDIPCONST GpMatrix*,GDIPCONST GpPen*);
+GpStatus WINGDIPAPI GdipGetPathWorldBoundsI(GpPath*,GpRect*,GDIPCONST GpMatrix*,GDIPCONST GpPen*);
+GpStatus WINGDIPAPI GdipIsVisiblePathPoint(GpPath*,REAL,REAL,GpGraphics*,BOOL*);
+GpStatus WINGDIPAPI GdipIsVisiblePathPointI(GpPath*,INT,INT,GpGraphics*,BOOL*);
+GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPoint(GpPath*,REAL,REAL,GpPen*,GpGraphics*,BOOL*);
+GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPointI(GpPath*,INT,INT,GpPen*,GpGraphics*,BOOL*);
+
+/* HatchBrush functions */
+GpStatus WINGDIPAPI GdipCreateHatchBrush(GpHatchStyle,ARGB,ARGB,GpHatch**);
+GpStatus WINGDIPAPI GdipGetHatchStyle(GpHatch*,GpHatchStyle*);
+GpStatus WINGDIPAPI GdipGetHatchForegroundColor(GpHatch*,ARGB*);
+GpStatus WINGDIPAPI GdipGetHatchBackgroundColor(GpHatch*,ARGB*);
+
+/* Image functions */
+GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream*,GpImage**);
+GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR*,GpImage**);
+GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream*,GpImage**);
+GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR*,GpImage**);
+GpStatus WINGDIPAPI GdipCloneImage(GpImage*,GpImage**);
+GpStatus WINGDIPAPI GdipDisposeImage(GpImage*);
+GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage*,GDIPCONST WCHAR*,GDIPCONST CLSID*,GDIPCONST EncoderParameters*);
+GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage*,IStream*,GDIPCONST CLSID*,GDIPCONST EncoderParameters*);
+GpStatus WINGDIPAPI GdipSaveAdd(GpImage*,GDIPCONST EncoderParameters*);
+GpStatus WINGDIPAPI GdipSaveAddImage(GpImage*,GpImage*,GDIPCONST EncoderParameters*);
+GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage*,GpGraphics**);
+GpStatus WINGDIPAPI GdipGetImageBounds(GpImage*,GpRectF*,GpUnit*);
+GpStatus WINGDIPAPI GdipGetImageDimension(GpImage*,REAL*,REAL*);
+GpStatus WINGDIPAPI GdipGetImageType(GpImage*,ImageType*);
+GpStatus WINGDIPAPI GdipGetImageWidth(GpImage*,UINT*);
+GpStatus WINGDIPAPI GdipGetImageHeight(GpImage*,UINT*);
+GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage*,REAL*);
+GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage*,REAL*);
+GpStatus WINGDIPAPI GdipGetImageFlags(GpImage*,UINT*);
+GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage*,GUID*);
+GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage*,PixelFormat*);
+GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage*,UINT,UINT,GpImage**,GetThumbnailImageAbort,VOID*);
+GpStatus WINGDIPAPI GdipGetEncoderParameterListSize(GpImage*,GDIPCONST CLSID*,UINT*);
+GpStatus WINGDIPAPI GdipGetEncoderParameterList(GpImage*,GDIPCONST CLSID*,UINT,EncoderParameters*);
+GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage*,UINT*);
+GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage*,GUID*,UINT);
+GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage*,GDIPCONST GUID*,UINT*);
+GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage*,GDIPCONST GUID*,UINT);
+GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage*,RotateFlipType);
+GpStatus WINGDIPAPI GdipGetImagePalette(GpImage*,ColorPalette*,INT);
+GpStatus WINGDIPAPI GdipSetImagePalette(GpImage*,GDIPCONST ColorPalette*);
+GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage*,INT*);
+GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage*,UINT*);
+GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage*,UINT,PROPID*);
+GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage*,PROPID,UINT*);
+GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage*,PROPID,UINT,PropertyItem*);
+GpStatus WINGDIPAPI GdipGetPropertySize(GpImage*,UINT*,UINT*);
+GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage*,UINT,UINT,PropertyItem*);
+GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage*,PROPID);
+GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage*,GDIPCONST PropertyItem*);
+GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage*,ImageItemData*);
+GpStatus WINGDIPAPI GdipFindNextImageItem(GpImage*,ImageItemData*);
+GpStatus WINGDIPAPI GdipGetImageItemData(GpImage*,ImageItemData*);
+GpStatus WINGDIPAPI GdipImageSetAbort(GpImage*,GdiplusAbort*);
+GpStatus WINGDIPAPI GdipImageForceValidation(GpImage*);
+
+/* Image codec functions */
+GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT*,UINT*);
+GpStatus WINGDIPAPI GdipGetImageDecoders(UINT,UINT,ImageCodecInfo*);
+GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT*,UINT*);
+GpStatus WINGDIPAPI GdipGetImageEncoders(UINT,UINT,ImageCodecInfo*);
+
+/* ImageAttributes functions */
+GpStatus WINGDIPAPI GdipCreateImageAttributes(GpImageAttributes**);
+GpStatus WINGDIPAPI GdipCloneImageAttributes(GDIPCONST GpImageAttributes*,GpImageAttributes**);
+GpStatus WINGDIPAPI GdipDisposeImageAttributes(GpImageAttributes*);
+GpStatus WINGDIPAPI GdipSetImageAttributesToIdentity(GpImageAttributes*,ColorAdjustType);
+GpStatus WINGDIPAPI GdipResetImageAttributes(GpImageAttributes*,ColorAdjustType);
+GpStatus WINGDIPAPI GdipSetImageAttributesColorMatrix(GpImageAttributes*,ColorAdjustType,BOOL,GDIPCONST ColorMatrix*,GDIPCONST ColorMatrix*,ColorMatrixFlags);
+GpStatus WINGDIPAPI GdipSetImageAttributesThreshold(GpImageAttributes*,ColorAdjustType,BOOL,REAL);
+GpStatus WINGDIPAPI GdipSetImageAttributesGamma(GpImageAttributes*,ColorAdjustType,BOOL,REAL);
+GpStatus WINGDIPAPI GdipSetImageAttributesNoOp(GpImageAttributes*,ColorAdjustType,BOOL);
+GpStatus WINGDIPAPI GdipSetImageAttributesColorKeys(GpImageAttributes*,ColorAdjustType,BOOL,ARGB,ARGB);
+GpStatus WINGDIPAPI GdipSetImageAttributesOutputChannel(GpImageAttributes*,ColorAdjustType,BOOL,ColorChannelFlags);
+GpStatus WINGDIPAPI GdipSetImageAttributesOutputChannelColorProfile(GpImageAttributes*,ColorAdjustType,BOOL,GDIPCONST WCHAR*);
+GpStatus WINGDIPAPI GdipSetImageAttributesRemapTable(GpImageAttributes*,ColorAdjustType,BOOL,UINT,GDIPCONST ColorMap*);
+GpStatus WINGDIPAPI GdipSetImageAttributesWrapMode(GpImageAttributes*,WrapMode,ARGB,BOOL);
+GpStatus WINGDIPAPI GdipSetImageAttributesICMMode(GpImageAttributes*,BOOL);
+GpStatus WINGDIPAPI GdipGetImageAttributesAdjustedPalette(GpImageAttributes*,ColorPalette*,ColorAdjustType);
+GpStatus WINGDIPAPI GdipSetImageAttributesCachedBackground(GpImageAttributes*,BOOL);
+
+/* LinearGradientBrush functions */
+GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF*,GDIPCONST GpPointF*,ARGB,ARGB,GpWrapMode,GpLineGradient**);
+GpStatus WINGDIPAPI GdipCreateLineBrushI(GDIPCONST GpPoint*,GDIPCONST GpPoint*,ARGB,ARGB,GpWrapMode,GpLineGradient**);
+GpStatus WINGDIPAPI GdipCreateLineBrushFromRect(GDIPCONST GpRectF*,ARGB,ARGB,LinearGradientMode,GpWrapMode,GpLineGradient**);
+GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI(GDIPCONST GpRect*,ARGB,ARGB,LinearGradientMode,GpWrapMode,GpLineGradient**);
+GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngle(GDIPCONST GpRectF*,ARGB,ARGB,REAL,BOOL,GpWrapMode,GpLineGradient**);
+GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngleI(GDIPCONST GpRect*,ARGB,ARGB,REAL,BOOL,GpWrapMode,GpLineGradient**);
+GpStatus WINGDIPAPI GdipSetLineColors(GpLineGradient*,ARGB,ARGB);
+GpStatus WINGDIPAPI GdipGetLineColors(GpLineGradient*,ARGB*);
+GpStatus WINGDIPAPI GdipGetLineRect(GpLineGradient*,GpRectF*);
+GpStatus WINGDIPAPI GdipGetLineRectI(GpLineGradient*,GpRect*);
+GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient*,BOOL);
+GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient*,BOOL*);
+GpStatus WINGDIPAPI GdipGetLineBlendCount(GpLineGradient*,INT*);
+GpStatus WINGDIPAPI GdipGetLineBlend(GpLineGradient*,REAL*,REAL*,INT);
+GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient*,GDIPCONST REAL*,GDIPCONST REAL*,INT);
+GpStatus WINGDIPAPI GdipGetLinePresetBlendCount(GpLineGradient*,INT*);
+GpStatus WINGDIPAPI GdipGetLinePresetBlend(GpLineGradient*,ARGB*,REAL*,INT);
+GpStatus WINGDIPAPI GdipSetLinePresetBlend(GpLineGradient*,GDIPCONST ARGB*,GDIPCONST REAL*,INT);
+GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient*,REAL,REAL);
+GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient*,REAL,REAL);
+GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient*,GpWrapMode);
+GpStatus WINGDIPAPI GdipGetLineWrapMode(GpLineGradient*,GpWrapMode*);
+GpStatus WINGDIPAPI GdipGetLineTransform(GpLineGradient*,GpMatrix*);
+GpStatus WINGDIPAPI GdipSetLineTransform(GpLineGradient*,GDIPCONST GpMatrix*);
+GpStatus WINGDIPAPI GdipResetLineTransform(GpLineGradient*);
+GpStatus WINGDIPAPI GdipMultiplyLineTransform(GpLineGradient*,GDIPCONST GpMatrix*,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipTranslateLineTransform(GpLineGradient*,REAL,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipScaleLineTransform(GpLineGradient*,REAL,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipRotateLineTransform(GpLineGradient*,REAL,GpMatrixOrder);
+
+/* Matrix functions */
+GpStatus WINGDIPAPI GdipCreateMatrix(GpMatrix**);
+GpStatus WINGDIPAPI GdipCreateMatrix2(REAL,REAL,REAL,REAL,REAL,REAL,GpMatrix**);
+GpStatus WINGDIPAPI GdipCreateMatrix3(GDIPCONST GpRectF*,GDIPCONST GpPointF*,GpMatrix**);
+GpStatus WINGDIPAPI GdipCreateMatrix3I(GDIPCONST GpRect*,GDIPCONST GpPoint*,GpMatrix**);
+GpStatus WINGDIPAPI GdipCloneMatrix(GpMatrix*,GpMatrix**);
+GpStatus WINGDIPAPI GdipDeleteMatrix(GpMatrix*);
+GpStatus WINGDIPAPI GdipSetMatrixElements(GpMatrix*,REAL,REAL,REAL,REAL,REAL,REAL);
+GpStatus WINGDIPAPI GdipMultiplyMatrix(GpMatrix*,GpMatrix*,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipTranslateMatrix(GpMatrix*,REAL,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipScaleMatrix(GpMatrix*,REAL,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipRotateMatrix(GpMatrix*,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipShearMatrix(GpMatrix*,REAL,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipInvertMatrix(GpMatrix*);
+GpStatus WINGDIPAPI GdipTransformMatrixPoints(GpMatrix*,GpPointF*,INT);
+GpStatus WINGDIPAPI GdipTransformMatrixPointsI(GpMatrix*,GpPoint*,INT);
+GpStatus WINGDIPAPI GdipVectorTransformMatrixPoints(GpMatrix*,GpPointF*,INT);
+GpStatus WINGDIPAPI GdipVectorTransformMatrixPointsI(GpMatrix*,GpPoint*,INT);
+GpStatus WINGDIPAPI GdipGetMatrixElements(GDIPCONST GpMatrix*,REAL*);
+GpStatus WINGDIPAPI GdipIsMatrixInvertible(GDIPCONST GpMatrix*,BOOL*);
+GpStatus WINGDIPAPI GdipIsMatrixIdentity(GDIPCONST GpMatrix*,BOOL*);
+GpStatus WINGDIPAPI GdipIsMatrixEqual(GDIPCONST GpMatrix*,GDIPCONST GpMatrix*,BOOL*);
+
+/* Metafile functions */
+GpStatus WINGDIPAPI GdipGetMetafileHeaderFromEmf(HENHMETAFILE,MetafileHeader*);
+GpStatus WINGDIPAPI GdipGetMetafileHeaderFromFile(GDIPCONST WCHAR*,MetafileHeader*);
+GpStatus WINGDIPAPI GdipGetMetafileHeaderFromStream(IStream*,MetafileHeader*);
+GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile*,MetafileHeader*);
+GpStatus WINGDIPAPI GdipGetHemfFromMetafile(GpMetafile*,HENHMETAFILE*);
+GpStatus WINGDIPAPI GdipCreateStreamOnFile(GDIPCONST WCHAR*,UINT,IStream**);
+GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE,BOOL,GDIPCONST WmfPlaceableFileHeader*,GpMetafile**);
+GpStatus WINGDIPAPI GdipCreateMetafileFromEmf(HENHMETAFILE,BOOL,GpMetafile**);
+GpStatus WINGDIPAPI GdipCreateMetafileFromFile(GDIPCONST WCHAR*,GpMetafile**);
+GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR*,GDIPCONST WmfPlaceableFileHeader*,GpMetafile**);
+GpStatus WINGDIPAPI GdipCreateMetafileFromStream(IStream*,GpMetafile**);
+GpStatus WINGDIPAPI GdipRecordMetafile(HDC,EmfType,GDIPCONST GpRectF*,MetafileFrameUnit,GDIPCONST WCHAR*,GpMetafile**);
+GpStatus WINGDIPAPI GdipRecordMetafileI(HDC,EmfType,GDIPCONST GpRect*,MetafileFrameUnit,GDIPCONST WCHAR*,GpMetafile**);
+GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR*,HDC,EmfType,GDIPCONST GpRectF*,MetafileFrameUnit,GDIPCONST WCHAR*,GpMetafile**);
+GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR*,HDC,EmfType,GDIPCONST GpRect*,MetafileFrameUnit,GDIPCONST WCHAR*,GpMetafile**);
+GpStatus WINGDIPAPI GdipRecordMetafileStream(IStream*,HDC,EmfType,GDIPCONST GpRectF*,MetafileFrameUnit,GDIPCONST WCHAR*,GpMetafile**);
+GpStatus WINGDIPAPI GdipRecordMetafileStreamI(IStream*,HDC,EmfType,GDIPCONST GpRect*,MetafileFrameUnit,GDIPCONST WCHAR*,GpMetafile**);
+GpStatus WINGDIPAPI GdipPlayMetafileRecord(GDIPCONST GpMetafile*,EmfPlusRecordType,UINT,UINT,GDIPCONST BYTE*);
+GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit(GpMetafile*,UINT);
+GpStatus WINGDIPAPI GdipGetMetafileDownLevelRasterizationLimit(GDIPCONST GpMetafile*,UINT*);
+GpStatus WINGDIPAPI GdipConvertToEmfPlus(GDIPCONST GpGraphics*,GpMetafile*,BOOL*,EmfType,GDIPCONST WCHAR*,GpMetafile**);
+GpStatus WINGDIPAPI GdipConvertToEmfPlusToFile(GDIPCONST GpGraphics*,GpMetafile*,BOOL*,GDIPCONST WCHAR*,EmfType,GDIPCONST WCHAR*,GpMetafile**);
+GpStatus WINGDIPAPI GdipConvertToEmfPlusToStream(GDIPCONST GpGraphics*,GpMetafile*,BOOL*,IStream*,EmfType,GDIPCONST WCHAR*,GpMetafile**);
+UINT WINGDIPAPI GdipEmfToWmfBits(HENHMETAFILE,UINT,LPBYTE,INT,INT);
+
+/* PathGradientBrush functions */
+GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF*,INT,GpWrapMode,GpPathGradient**);
+GpStatus WINGDIPAPI GdipCreatePathGradientI(GDIPCONST GpPoint*,INT,GpWrapMode,GpPathGradient**);
+GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath*,GpPathGradient**);
+GpStatus WINGDIPAPI GdipGetPathGradientCenterColor(GpPathGradient*,ARGB*);
+GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient*,ARGB);
+GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient*,ARGB*,INT*);
+GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount(GpPathGradient*,GDIPCONST ARGB*,INT*);
+GpStatus WINGDIPAPI GdipGetPathGradientPath(GpPathGradient*,GpPath*);
+GpStatus WINGDIPAPI GdipSetPathGradientPath(GpPathGradient*,GDIPCONST GpPath*);
+GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient*,GpPointF*);
+GpStatus WINGDIPAPI GdipGetPathGradientCenterPointI(GpPathGradient*,GpPoint*);
+GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient*,GDIPCONST GpPointF*);
+GpStatus WINGDIPAPI GdipSetPathGradientCenterPointI(GpPathGradient*,GDIPCONST GpPoint*);
+GpStatus WINGDIPAPI GdipGetPathGradientRect(GpPathGradient*,GpRectF*);
+GpStatus WINGDIPAPI GdipGetPathGradientRectI(GpPathGradient*,GpRect*);
+GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient*,INT*);
+GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorCount(GpPathGradient*,INT*);
+GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient*,BOOL);
+GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient*,BOOL*);
+GpStatus WINGDIPAPI GdipGetPathGradientBlendCount(GpPathGradient*,INT*);
+GpStatus WINGDIPAPI GdipGetPathGradientBlend(GpPathGradient*,REAL*,REAL*,INT);
+GpStatus WINGDIPAPI GdipSetPathGradientBlend(GpPathGradient*,GDIPCONST REAL*,GDIPCONST REAL*,INT);
+GpStatus WINGDIPAPI GdipGetPathGradientPresetBlendCount(GpPathGradient*,INT*);
+GpStatus WINGDIPAPI GdipGetPathGradientPresetBlend(GpPathGradient*,ARGB*,REAL*,INT);
+GpStatus WINGDIPAPI GdipSetPathGradientPresetBlend(GpPathGradient*,GDIPCONST ARGB*,GDIPCONST REAL*,INT);
+GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend(GpPathGradient*,REAL,REAL);
+GpStatus WINGDIPAPI GdipSetPathGradientLinearBlend(GpPathGradient*,REAL,REAL);
+GpStatus WINGDIPAPI GdipGetPathGradientWrapMode(GpPathGradient*,GpWrapMode*);
+GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient*,GpWrapMode);
+GpStatus WINGDIPAPI GdipGetPathGradientTransform(GpPathGradient*,GpMatrix*);
+GpStatus WINGDIPAPI GdipSetPathGradientTransform(GpPathGradient*,GpMatrix*);
+GpStatus WINGDIPAPI GdipResetPathGradientTransform(GpPathGradient*);
+GpStatus WINGDIPAPI GdipMultiplyPathGradientTransform(GpPathGradient*,GDIPCONST GpMatrix*,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipTranslatePathGradientTransform(GpPathGradient*,REAL,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipScalePathGradientTransform(GpPathGradient*,REAL,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipRotatePathGradientTransform(GpPathGradient*,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient*,REAL*,REAL*);
+GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient*,REAL,REAL);
+
+/* PathIterator functions */
+GpStatus WINGDIPAPI GdipCreatePathIter(GpPathIterator**,GpPath*);
+GpStatus WINGDIPAPI GdipDeletePathIter(GpPathIterator*);
+GpStatus WINGDIPAPI GdipPathIterNextSubpath(GpPathIterator*,INT*,INT*,INT*,BOOL*);
+GpStatus WINGDIPAPI GdipPathIterNextSubpathPath(GpPathIterator*,INT*,GpPath*,BOOL*);
+GpStatus WINGDIPAPI GdipPathIterNextPathType(GpPathIterator*,INT*,BYTE*,INT*,INT*);
+GpStatus WINGDIPAPI GdipPathIterNextMarker(GpPathIterator*,INT*,INT*,INT*);
+GpStatus WINGDIPAPI GdipPathIterNextMarkerPath(GpPathIterator*,INT*,GpPath*);
+GpStatus WINGDIPAPI GdipPathIterGetCount(GpPathIterator*,INT*);
+GpStatus WINGDIPAPI GdipPathIterGetSubpathCount(GpPathIterator*,INT*);
+GpStatus WINGDIPAPI GdipPathIterIsValid(GpPathIterator*,BOOL*);
+GpStatus WINGDIPAPI GdipPathIterHasCurve(GpPathIterator*,BOOL*);
+GpStatus WINGDIPAPI GdipPathIterRewind(GpPathIterator*);
+GpStatus WINGDIPAPI GdipPathIterEnumerate(GpPathIterator*,INT*,GpPointF*,BYTE*,INT);
+GpStatus WINGDIPAPI GdipPathIterCopyData(GpPathIterator*,INT*,GpPointF*,BYTE*,INT,INT);
+
+/* Pen functions */
+GpStatus WINGDIPAPI GdipCreatePen1(ARGB,REAL,GpUnit,GpPen**);
+GpStatus WINGDIPAPI GdipCreatePen2(GpBrush*,REAL,GpUnit,GpPen**);
+GpStatus WINGDIPAPI GdipClonePen(GpPen*,GpPen**);
+GpStatus WINGDIPAPI GdipDeletePen(GpPen*);
+GpStatus WINGDIPAPI GdipSetPenWidth(GpPen*,REAL);
+GpStatus WINGDIPAPI GdipGetPenWidth(GpPen*,REAL*);
+GpStatus WINGDIPAPI GdipSetPenUnit(GpPen*,GpUnit);
+GpStatus WINGDIPAPI GdipGetPenUnit(GpPen*,GpUnit*);
+GpStatus WINGDIPAPI GdipSetPenLineCap197819(GpPen*,GpLineCap,GpLineCap,GpDashCap);
+GpStatus WINGDIPAPI GdipSetPenStartCap(GpPen*,GpLineCap);
+GpStatus WINGDIPAPI GdipSetPenEndCap(GpPen*,GpLineCap);
+GpStatus WINGDIPAPI GdipSetPenDashCap197819(GpPen*,GpDashCap);
+GpStatus WINGDIPAPI GdipGetPenStartCap(GpPen*,GpLineCap*);
+GpStatus WINGDIPAPI GdipGetPenEndCap(GpPen*,GpLineCap*);
+GpStatus WINGDIPAPI GdipGetPenDashCap197819(GpPen*,GpDashCap*);
+GpStatus WINGDIPAPI GdipSetPenLineJoin(GpPen*,GpLineJoin);
+GpStatus WINGDIPAPI GdipGetPenLineJoin(GpPen*,GpLineJoin*);
+GpStatus WINGDIPAPI GdipSetPenCustomStartCap(GpPen*,GpCustomLineCap*);
+GpStatus WINGDIPAPI GdipGetPenCustomStartCap(GpPen*,GpCustomLineCap**);
+GpStatus WINGDIPAPI GdipSetPenCustomEndCap(GpPen*,GpCustomLineCap*);
+GpStatus WINGDIPAPI GdipGetPenCustomEndCap(GpPen*,GpCustomLineCap**);
+GpStatus WINGDIPAPI GdipSetPenMiterLimit(GpPen*,REAL);
+GpStatus WINGDIPAPI GdipGetPenMiterLimit(GpPen*,REAL*);
+GpStatus WINGDIPAPI GdipSetPenMode(GpPen*,GpPenAlignment);
+GpStatus WINGDIPAPI GdipGetPenMode(GpPen*,GpPenAlignment*);
+GpStatus WINGDIPAPI GdipSetPenTransform(GpPen*,GpMatrix*);
+GpStatus WINGDIPAPI GdipGetPenTransform(GpPen*,GpMatrix*);
+GpStatus WINGDIPAPI GdipResetPenTransform(GpPen*);
+GpStatus WINGDIPAPI GdipMultiplyPenTransform(GpPen*,GDIPCONST GpMatrix*,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipTranslatePenTransform(GpPen*,REAL,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipScalePenTransform(GpPen*,REAL,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipRotatePenTransform(GpPen*,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipSetPenColor(GpPen*,ARGB);
+GpStatus WINGDIPAPI GdipGetPenColor(GpPen*,ARGB*);
+GpStatus WINGDIPAPI GdipSetPenBrushFill(GpPen*,GpBrush*);
+GpStatus WINGDIPAPI GdipGetPenBrushFill(GpPen*,GpBrush**);
+GpStatus WINGDIPAPI GdipGetPenFillType(GpPen*,GpPenType*);
+GpStatus WINGDIPAPI GdipGetPenDashStyle(GpPen*,GpDashStyle*);
+GpStatus WINGDIPAPI GdipSetPenDashStyle(GpPen*,GpDashStyle);
+GpStatus WINGDIPAPI GdipGetPenDashOffset(GpPen*,REAL*);
+GpStatus WINGDIPAPI GdipSetPenDashOffset(GpPen*,REAL);
+GpStatus WINGDIPAPI GdipGetPenDashCount(GpPen*,INT*);
+GpStatus WINGDIPAPI GdipSetPenDashArray(GpPen*,GDIPCONST REAL*,INT);
+GpStatus WINGDIPAPI GdipGetPenDashArray(GpPen*,REAL*,INT);
+GpStatus WINGDIPAPI GdipGetPenCompoundCount(GpPen*,INT*);
+GpStatus WINGDIPAPI GdipSetPenCompoundArray(GpPen*,GDIPCONST REAL*,INT);
+GpStatus WINGDIPAPI GdipGetPenCompoundArray(GpPen*,REAL*,INT);
+
+/* Region functions */
+GpStatus WINGDIPAPI GdipCreateRegion(GpRegion**);
+GpStatus WINGDIPAPI GdipCreateRegionRect(GDIPCONST GpRectF*,GpRegion**);
+GpStatus WINGDIPAPI GdipCreateRegionRectI(GDIPCONST GpRect*,GpRegion**);
+GpStatus WINGDIPAPI GdipCreateRegionPath(GpPath*,GpRegion**);
+GpStatus WINGDIPAPI GdipCreateRegionRgnData(GDIPCONST BYTE*,INT,GpRegion**);
+GpStatus WINGDIPAPI GdipCreateRegionHrgn(HRGN,GpRegion**);
+GpStatus WINGDIPAPI GdipCloneRegion(GpRegion*,GpRegion**);
+GpStatus WINGDIPAPI GdipDeleteRegion(GpRegion*);
+GpStatus WINGDIPAPI GdipSetInfinite(GpRegion*);
+GpStatus WINGDIPAPI GdipSetEmpty(GpRegion*);
+GpStatus WINGDIPAPI GdipCombineRegionRect(GpRegion*,GDIPCONST GpRectF*,CombineMode);
+GpStatus WINGDIPAPI GdipCombineRegionRectI(GpRegion*,GDIPCONST GpRect*,CombineMode);
+GpStatus WINGDIPAPI GdipCombineRegionPath(GpRegion*,GpPath*,CombineMode);
+GpStatus WINGDIPAPI GdipCombineRegionRegion(GpRegion*,GpRegion*,CombineMode);
+GpStatus WINGDIPAPI GdipTranslateRegion(GpRegion*,REAL,REAL);
+GpStatus WINGDIPAPI GdipTranslateRegionI(GpRegion*,INT,INT);
+GpStatus WINGDIPAPI GdipTransformRegion(GpRegion*,GpMatrix*);
+GpStatus WINGDIPAPI GdipGetRegionBounds(GpRegion*,GpGraphics*,GpRectF*);
+GpStatus WINGDIPAPI GdipGetRegionBoundsI(GpRegion*,GpGraphics*,GpRect*);
+GpStatus WINGDIPAPI GdipGetRegionHRgn(GpRegion*,GpGraphics*,HRGN*);
+GpStatus WINGDIPAPI GdipIsEmptyRegion(GpRegion*,GpGraphics*,BOOL*);
+GpStatus WINGDIPAPI GdipIsInfiniteRegion(GpRegion*,GpGraphics*,BOOL*);
+GpStatus WINGDIPAPI GdipIsEqualRegion(GpRegion*,GpRegion*,GpGraphics*,BOOL*);
+GpStatus WINGDIPAPI GdipGetRegionDataSize(GpRegion*,UINT*);
+GpStatus WINGDIPAPI GdipGetRegionData(GpRegion*,BYTE*,UINT,UINT*);
+GpStatus WINGDIPAPI GdipIsVisibleRegionPoint(GpRegion*,REAL,REAL,GpGraphics*,BOOL*);
+GpStatus WINGDIPAPI GdipIsVisibleRegionPointI(GpRegion*,INT,INT,GpGraphics*,BOOL*);
+GpStatus WINGDIPAPI GdipIsVisibleRegionRect(GpRegion*,REAL,REAL,REAL,REAL,GpGraphics*,BOOL*);
+GpStatus WINGDIPAPI GdipIsVisibleRegionRectI(GpRegion*,INT,INT,INT,INT,GpGraphics*,BOOL*);
+GpStatus WINGDIPAPI GdipGetRegionScansCount(GpRegion*,UINT*,GpMatrix*);
+GpStatus WINGDIPAPI GdipGetRegionScans(GpRegion*,GpRectF*,INT*,GpMatrix*);
+GpStatus WINGDIPAPI GdipGetRegionScansI(GpRegion*,GpRect*,INT*,GpMatrix*);
+
+/* SolidBrush functions */
+GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB,GpSolidFill**);
+GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill*,ARGB);
+GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill*,ARGB*);
+
+/* StringFormat functions */
+GpStatus WINGDIPAPI GdipCreateStringFormat(INT,LANGID,GpStringFormat**);
+GpStatus WINGDIPAPI GdipStringFormatGetGenericDefault(GpStringFormat**);
+GpStatus WINGDIPAPI GdipStringFormatGetGenericTypographic(GpStringFormat**);
+GpStatus WINGDIPAPI GdipDeleteStringFormat(GpStringFormat*);
+GpStatus WINGDIPAPI GdipCloneStringFormat(GDIPCONST GpStringFormat*,GpStringFormat**);
+GpStatus WINGDIPAPI GdipSetStringFormatFlags(GpStringFormat*,INT);
+GpStatus WINGDIPAPI GdipGetStringFormatFlags(GDIPCONST GpStringFormat*,INT*);
+GpStatus WINGDIPAPI GdipSetStringFormatAlign(GpStringFormat*,StringAlignment);
+GpStatus WINGDIPAPI GdipGetStringFormatAlign(GDIPCONST GpStringFormat*,StringAlignment*);
+GpStatus WINGDIPAPI GdipSetStringFormatLineAlign(GpStringFormat*,StringAlignment);
+GpStatus WINGDIPAPI GdipGetStringFormatLineAlign(GDIPCONST GpStringFormat*,StringAlignment*);
+GpStatus WINGDIPAPI GdipSetStringFormatTrimming(GpStringFormat*,StringTrimming);
+GpStatus WINGDIPAPI GdipGetStringFormatTrimming(GDIPCONST GpStringFormat*,StringTrimming*);
+GpStatus WINGDIPAPI GdipSetStringFormatHotkeyPrefix(GpStringFormat*,INT);
+GpStatus WINGDIPAPI GdipGetStringFormatHotkeyPrefix(GDIPCONST GpStringFormat*,INT*);
+GpStatus WINGDIPAPI GdipSetStringFormatTabStops(GpStringFormat*,REAL,INT,GDIPCONST REAL*);
+GpStatus WINGDIPAPI GdipGetStringFormatTabStops(GDIPCONST GpStringFormat*,INT,REAL*,REAL*);
+GpStatus WINGDIPAPI GdipGetStringFormatTabStopCount(GDIPCONST GpStringFormat*,INT*);
+GpStatus WINGDIPAPI GdipSetStringFormatDigitSubstitution(GpStringFormat*,LANGID,StringDigitSubstitute);
+GpStatus WINGDIPAPI GdipGetStringFormatDigitSubstitution(GDIPCONST GpStringFormat*,LANGID*,StringDigitSubstitute*);
+GpStatus WINGDIPAPI GdipGetStringFormatMeasurableCharacterRangeCount(GDIPCONST GpStringFormat*,INT*);
+GpStatus WINGDIPAPI GdipSetStringFormatMeasurableCharacterRanges(GpStringFormat*,INT,GDIPCONST CharacterRange*);
+
+/* Text functions */
+GpStatus WINGDIPAPI GdipDrawString(GpGraphics*,GDIPCONST WCHAR*,INT,GDIPCONST GpFont*,GDIPCONST RectF*,GDIPCONST GpStringFormat*,GDIPCONST GpBrush*);
+GpStatus WINGDIPAPI GdipMeasureString(GpGraphics*,GDIPCONST WCHAR*,INT,GDIPCONST GpFont*,GDIPCONST RectF*,GDIPCONST GpStringFormat*,RectF*,INT*,INT*);
+#ifdef __cplusplus
+GpStatus WINGDIPAPI GdipMeasureCharacterRanges(GpGraphics*,GDIPCONST WCHAR*,INT,GDIPCONST GpFont*,GDIPCONST RectF&,GDIPCONST GpStringFormat*,INT,GpRegion**);
+#endif
+GpStatus WINGDIPAPI GdipDrawDriverString(GpGraphics*,GDIPCONST UINT16*,INT,GDIPCONST GpFont*,GDIPCONST GpBrush*,GDIPCONST PointF*,INT,GDIPCONST GpMatrix*);
+GpStatus WINGDIPAPI GdipMeasureDriverString(GpGraphics*,GDIPCONST UINT16*,INT,GDIPCONST GpFont*,GDIPCONST PointF*,INT,GDIPCONST GpMatrix*,RectF*);
+
+/* TextureBrush functions */
+GpStatus WINGDIPAPI GdipCreateTexture(GpImage*,GpWrapMode,GpTexture**);
+GpStatus WINGDIPAPI GdipCreateTexture2(GpImage*,GpWrapMode,REAL,REAL,REAL,REAL,GpTexture**);
+GpStatus WINGDIPAPI GdipCreateTexture2I(GpImage*,GpWrapMode,INT,INT,INT,INT,GpTexture**);
+GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage*,GDIPCONST GpImageAttributes*,REAL,REAL,REAL,REAL,GpTexture**);
+GpStatus WINGDIPAPI GdipCreateTextureIAI(GpImage*,GDIPCONST GpImageAttributes*,INT,INT,INT,INT,GpTexture**);
+GpStatus WINGDIPAPI GdipGetTextureTransform(GpTexture*,GpMatrix*);
+GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture*,GDIPCONST GpMatrix*);
+GpStatus WINGDIPAPI GdipResetTextureTransform(GpTexture*);
+GpStatus WINGDIPAPI GdipMultiplyTextureTransform(GpTexture*,GDIPCONST GpMatrix*,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipTranslateTextureTransform(GpTexture*,REAL,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipScaleTextureTransform(GpTexture*,REAL,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipRotateTextureTransform(GpTexture*,REAL,GpMatrixOrder);
+GpStatus WINGDIPAPI GdipSetTextureWrapMode(GpTexture*,GpWrapMode);
+GpStatus WINGDIPAPI GdipGetTextureWrapMode(GpTexture*,GpWrapMode*);
+GpStatus WINGDIPAPI GdipGetTextureImage(GpTexture*,GpImage**);
+
+/* uncategorized functions */
+GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum,void*);
+
+#ifdef __cplusplus
+} /* extern "C" */
+} /* namespace DllExports */
+#endif
+
+#endif /* __GDIPLUS_FLAT_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_GPSTUBS_H
+#define __GDIPLUS_GPSTUBS_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+typedef Point GpPoint;
+typedef PointF GpPointF;
+typedef Rect GpRect;
+typedef RectF GpRectF;
+typedef Size GpSize;
+typedef SizeF GpSizeF;
+
+typedef enum BrushType GpBrushType;
+typedef enum CombineMode GpCombineMode;
+typedef enum CompositingMode GpCompositingMode;
+typedef enum CompositingQuality GpCompositingQuality;
+typedef enum CoordinateSpace GpCoordinateSpace;
+typedef enum CustomLineCapType GpCustomLineCapType;
+typedef enum DashCap GpDashCap;
+typedef enum DashStyle GpDashStyle;
+typedef enum DitherType GpDitherType;
+typedef enum DriverStringOptions GpDriverStringOptions;
+typedef enum EmfPlusRecordType GpEmfPlusRecordType;
+typedef enum EmfToWmfBitsFlags GpEmfToWmfBitsFlags;
+typedef enum EmfType GpEmfType;
+typedef enum EncoderParameterValueType GpEncoderParameterValueType;
+typedef enum EncoderValue GpEncoderValue;
+typedef enum FillMode GpFillMode;
+typedef enum FlushIntention GpFlushIntention;
+typedef enum FontStyle GpFontStyle;
+typedef enum HatchStyle GpHatchStyle;
+typedef enum HotkeyPrefix GpHotkeyPrefix;
+typedef enum ImageType GpImageType;
+typedef enum InterpolationMode GpInterpolationMode;
+typedef enum LinearGradientMode GpLinearGradientMode;
+typedef enum LineCap GpLineCap;
+typedef enum LineJoin GpLineJoin;
+typedef enum MatrixOrder GpMatrixOrder;
+typedef enum MetafileFrameUnit GpMetafileFrameUnit;
+typedef enum MetafileType GpMetafileType;
+typedef enum ObjectType GpObjectType;
+typedef enum PathPointType GpPathPointType;
+typedef enum PenAlignment GpPenAlignment;
+typedef enum PenType GpPenType;
+typedef enum PixelOffsetMode GpPixelOffsetMode;
+typedef enum QualityMode GpQualityMode;
+typedef enum SmoothingMode GpSmoothingMode;
+typedef enum StringAlignment GpStringAlignment;
+typedef enum StringDigitSubstitute GpStringDigitSubstitute;
+typedef enum StringFormatFlags GpStringFormatFlags;
+typedef enum StringTrimming GpStringTrimming;
+typedef enum TextRenderingHint GpTextRenderingHint;
+typedef enum Unit GpUnit;
+typedef enum WarpMode GpWarpMode;
+typedef enum WrapMode GpWrapMode;
+
+#ifdef __cplusplus
+
+class CGpEffect {};
+class GpCustomLineCap {};
+class GpImage {};
+
+class GpAdjustableArrowCap: public GpCustomLineCap {};
+class GpBitmap: public GpImage {};
+class GpBrush {};
+class GpCachedBitmap {};
+class GpFont {};
+class GpFontCollection {};
+class GpFontFamily {};
+class GpGraphics {};
+class GpHatch: public GpBrush {}; /* HatchBrush */
+class GpImageAttributes {};
+class GpLineGradient: public GpBrush {}; /* LinearGradientBrush */
+class GpMatrix {};
+class GpMetafile: public GpImage {};
+class GpPath {}; /* GraphicsPath */
+class GpPathData {};
+class GpPathGradient: public GpBrush {}; /* PathGradientBrush */
+class GpPathIterator {}; /* GraphicsPathIterator */
+class GpPen {};
+class GpRegion {};
+class GpSolidFill: public GpBrush {}; /* SolidBrush */
+class GpStringFormat {};
+class GpTexture: public GpBrush {}; /* TextureBrush */
+
+#else /* !__cplusplus */
+
+typedef void CGpEffect;
+typedef void GpAdjustableArrowCap;
+typedef void GpBitmap;
+typedef void GpBrush;
+typedef void GpCachedBitmap;
+typedef void GpCustomLineCap;
+typedef void GpFont;
+typedef void GpFontFamily;
+typedef void GpFontCollection;
+typedef void GpGraphics;
+typedef void GpHatch;
+typedef void GpImage;
+typedef void GpImageAttributes;
+typedef void GpLineGradient;
+typedef void GpMatrix;
+typedef void GpMetafile;
+typedef void GpPath;
+typedef void GpPathData;
+typedef void GpPathGradient;
+typedef void GpPathIterator;
+typedef void GpPen;
+typedef void GpRegion;
+typedef void GpSolidFill;
+typedef void GpStringFormat;
+typedef void GpTexture;
+
+#endif /* !__cplusplus */
+
+#endif /* __GDIPLUS_GPSTUBS_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_HEADERS_H
+#define __GDIPLUS_HEADERS_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifndef __cplusplus
+#error "A C++ compiler is required to include gdiplusheaders.h."
+#endif
+
+/*
+ * Note: Virtual inline functions (dtors, Clone()) are implemented here: If
+ * these were defined outside class scope, the compiler would always generate
+ * code for them (and the vtable), even if these classes were never used.
+ */
+
+class Bitmap;
+class Effect;
+class FontCollection;
+class FontFamily;
+class Graphics;
+class GraphicsPath;
+class Matrix;
+class Pen;
+
+class Image: public GdiplusBase
+{
+ friend class Bitmap;
+ friend class Metafile;
+ friend class CachedBitmap;
+ friend class Graphics;
+ friend class TextureBrush;
+
+public:
+ static Image* FromFile(const WCHAR *filename,
+ BOOL useEmbeddedColorManagement = FALSE);
+ static Image* FromStream(IStream *stream,
+ BOOL useEmbeddedColorManagement = FALSE);
+
+ Image(const WCHAR *filename, BOOL useEmbeddedColorManagement = FALSE);
+ Image(IStream *stream, BOOL useEmbeddedColorManagement = FALSE);
+
+ virtual ~Image()
+ {
+ DllExports::GdipDisposeImage(nativeImage);
+ }
+ virtual Image* Clone() const
+ {
+ GpImage *cloneImage = NULL;
+ Status status = updateStatus(DllExports::GdipCloneImage(
+ nativeImage, &cloneImage));
+ if (status == Ok) {
+ Image *result = new Image(cloneImage, lastStatus);
+ if (!result) {
+ DllExports::GdipDisposeImage(cloneImage);
+ lastStatus = OutOfMemory;
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ Status FindFirstItem(ImageItemData *item);
+ Status FindNextItem(ImageItemData *item);
+ Status GetAllPropertyItems(UINT totalBufferSize,
+ UINT numProperties, PropertyItem *allItems);
+ Status GetBounds(RectF *srcRect, Unit *srcUnit);
+ Status GetEncoderParameterList(const CLSID *clsidEncoder,
+ UINT size, EncoderParameters *buffer);
+ UINT GetEncoderParameterListSize(const CLSID *clsidEncoder);
+ UINT GetFlags();
+ UINT GetFrameCount(const GUID *dimensionID);
+ UINT GetFrameDimensionsCount();
+ Status GetFrameDimensionsList(GUID *dimensionIDs, UINT count);
+ UINT GetHeight();
+ REAL GetHorizontalResolution();
+ Status GetItemData(ImageItemData *item);
+ Status GetPalette(ColorPalette *palette, INT size);
+ INT GetPaletteSize();
+ Status GetPhysicalDimension(SizeF *size);
+ PixelFormat GetPixelFormat();
+ UINT GetPropertyCount();
+ Status GetPropertyIdList(UINT numOfProperty, PROPID *list);
+ Status GetPropertyItem(PROPID propId, UINT propSize,
+ PropertyItem *buffer);
+ UINT GetPropertyItemSize(PROPID propId);
+ Status GetPropertySize(UINT *totalBufferSize, UINT *numProperties);
+ Status GetRawFormat(GUID *format);
+ Image* GetThumbnailImage(UINT thumbWidth, UINT thumbHeight,
+ GetThumbnailImageAbort callback, VOID *callbackData);
+ ImageType GetType() const;
+ REAL GetVerticalResolution();
+ UINT GetWidth();
+ Status RemovePropertyItem(PROPID propId);
+ Status RotateFlip(RotateFlipType rotateFlipType);
+ Status Save(IStream *stream, const CLSID *clsidEncoder,
+ const EncoderParameters *encoderParams);
+ Status Save(const WCHAR *filename, const CLSID *clsidEncoder,
+ const EncoderParameters *encoderParams);
+ Status SaveAdd(const EncoderParameters *encoderParams);
+ Status SaveAdd(Image *newImage, const EncoderParameters *encoderParams);
+ Status SelectActiveFrame(const GUID *dimensionID, UINT frameIndex);
+ Status SetAbort(GdiplusAbort *pIAbort);
+ Status SetPalette(const ColorPalette *palette);
+ Status SetPropertyItem(const PropertyItem *item);
+
+ Status GetLastStatus() const
+ {
+ Status result = lastStatus;
+ lastStatus = Ok;
+ return result;
+ }
+
+private:
+ Image(GpImage *image, Status status):
+ nativeImage(image), lastStatus(status) {}
+ Image(const Image&);
+ Image& operator=(const Image&);
+
+ Status updateStatus(Status newStatus) const
+ {
+ if (newStatus != Ok) lastStatus = newStatus;
+ return newStatus;
+ }
+
+ GpImage *nativeImage;
+ mutable Status lastStatus;
+};
+
+class Bitmap: public Image
+{
+public:
+ static Bitmap* FromBITMAPINFO(const BITMAPINFO *gdiBitmapInfo,
+ VOID *gdiBitmapData);
+ static Bitmap* FromDirectDrawSurface7(IDirectDrawSurface7 *surface);
+ static Bitmap* FromFile(const WCHAR *filename,
+ BOOL useEmbeddedColorManagement = FALSE);
+ static Bitmap* FromHBITMAP(HBITMAP hbm, HPALETTE hpal);
+ static Bitmap* FromHICON(HICON icon);
+ static Bitmap* FromResource(HINSTANCE hInstance,
+ const WCHAR *bitmapName);
+ static Bitmap* FromStream(IStream *stream,
+ BOOL useEmbeddedColorManagement = FALSE);
+ static Status ApplyEffect(Bitmap **inputs, INT numInputs,
+ Effect *effect, RECT *ROI,
+ RECT *outputRect, Bitmap **output);
+ static Status InitializePalette(ColorPalette *palette,
+ PaletteType paletteType, INT optimalColors,
+ BOOL useTransparentColor, Bitmap *bitmap);
+
+ Bitmap(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData);
+ Bitmap(IDirectDrawSurface7 *surface);
+ Bitmap(const WCHAR *filename, BOOL useEmbeddedColorManagement = FALSE);
+ Bitmap(HBITMAP hbm, HPALETTE hpal);
+ Bitmap(HICON hicon);
+ Bitmap(HINSTANCE hInstance, const WCHAR *bitmapName);
+ Bitmap(IStream *stream, BOOL useEmbeddedColorManagement = FALSE);
+ Bitmap(INT width, INT height, Graphics *target);
+ Bitmap(INT width, INT height, PixelFormat format = PixelFormat32bppARGB);
+ Bitmap(INT width, INT height, INT stride, PixelFormat format, BYTE *scan0);
+
+ virtual ~Bitmap()
+ {
+ }
+ virtual Bitmap* Clone() const
+ {
+ GpImage *cloneImage = NULL;
+ Status status = updateStatus(DllExports::GdipCloneImage(
+ nativeImage, &cloneImage));
+ if (status == Ok) {
+ Bitmap *result = new Bitmap(cloneImage, lastStatus);
+ if (!result) {
+ DllExports::GdipDisposeImage(cloneImage);
+ lastStatus = OutOfMemory;
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ Bitmap* Clone(const RectF& rect, PixelFormat format) const;
+ Bitmap* Clone(const Rect& rect, PixelFormat format) const;
+ Bitmap* Clone(REAL x, REAL y, REAL width, REAL height,
+ PixelFormat format) const;
+ Bitmap* Clone(INT x, INT y, INT width, INT height,
+ PixelFormat format) const;
+
+ Status ApplyEffect(Effect *effect, RECT *ROI);
+ Status ConvertFormat(PixelFormat format, DitherType ditherType,
+ PaletteType paletteType, ColorPalette *palette,
+ REAL alphaThresholdPercent);
+ Status GetHBITMAP(const Color& colorBackground, HBITMAP *hbmReturn) const;
+ Status GetHICON(HICON *icon) const;
+ Status GetHistogram(HistogramFormat format, UINT numberOfEntries,
+ UINT *channel0, UINT *channel1,
+ UINT *channel2, UINT *channel3) const;
+ Status GetHistogramSize(HistogramFormat format,
+ UINT *numberOfEntries) const;
+ Status GetPixel(INT x, INT y, Color *color) const;
+ Status LockBits(const Rect *rect, UINT flags, PixelFormat format,
+ BitmapData *lockedBitmapData);
+ Status SetPixel(INT x, INT y, const Color& color);
+ Status SetResolution(REAL xdpi, REAL ydpi);
+ Status UnlockBits(BitmapData *lcokedBitmapData);
+
+private:
+ Bitmap(GpImage *image, Status status): Image(image, status) {}
+ Bitmap(const Bitmap&);
+ Bitmap& operator=(const Bitmap&);
+};
+
+class CachedBitmap: public GdiplusBase
+{
+ friend class Graphics;
+
+public:
+ CachedBitmap(Bitmap *bitmap, Graphics *graphics);
+ ~CachedBitmap();
+
+ Status GetLastStatus() const
+ {
+ return lastStatus;
+ }
+
+private:
+ CachedBitmap(const CachedBitmap&);
+ CachedBitmap& operator=(const CachedBitmap&);
+
+ GpCachedBitmap *nativeCachedBitmap;
+ Status lastStatus;
+};
+
+class CustomLineCap: public GdiplusBase
+{
+ friend class AdjustableArrowCap;
+ friend class Pen;
+
+public:
+ CustomLineCap(const GraphicsPath *fillPath,
+ const GraphicsPath *strokePath,
+ LineCap baseCap = LineCapFlat,
+ REAL baseInset = 0.0f);
+
+ virtual ~CustomLineCap()
+ {
+ DllExports::GdipDeleteCustomLineCap(nativeCustomLineCap);
+ }
+ virtual CustomLineCap* Clone() const
+ {
+ GpCustomLineCap *cloneCustomLineCap = NULL;
+ Status status = updateStatus(DllExports::GdipCloneCustomLineCap(
+ nativeCustomLineCap, &cloneCustomLineCap));
+ if (status == Ok) {
+ CustomLineCap *result = new CustomLineCap(
+ cloneCustomLineCap, lastStatus);
+ if (!result) {
+ DllExports::GdipDeleteCustomLineCap(cloneCustomLineCap);
+ lastStatus = OutOfMemory;
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ LineCap GetBaseCap() const;
+ REAL GetBaseInset() const;
+ Status GetStrokeCaps(LineCap *startCap, LineCap *endCap) const;
+ LineJoin GetStrokeJoin() const;
+ REAL GetWidthScale() const;
+ Status SetBaseCap(LineCap baseCap);
+ Status SetBaseInset(REAL inset);
+ Status SetStrokeCap(LineCap strokeCap);
+ Status SetStrokeCaps(LineCap startCap, LineCap endCap);
+ Status SetStrokeJoin(LineJoin lineJoin);
+ Status SetWidthScale(REAL widthScale);
+
+ Status GetLastStatus() const
+ {
+ Status result = lastStatus;
+ lastStatus = Ok;
+ return result;
+ }
+
+private:
+ CustomLineCap(GpCustomLineCap *customLineCap, Status status):
+ nativeCustomLineCap(customLineCap), lastStatus(status) {}
+ CustomLineCap(const CustomLineCap&);
+ CustomLineCap& operator=(const CustomLineCap&);
+
+ Status updateStatus(Status newStatus) const
+ {
+ if (newStatus != Ok) lastStatus = newStatus;
+ return newStatus;
+ }
+
+ GpCustomLineCap *nativeCustomLineCap;
+ mutable Status lastStatus;
+};
+
+class Font: public GdiplusBase
+{
+ friend class Graphics;
+
+public:
+ Font(const FontFamily *family, REAL emSize,
+ INT style = FontStyleRegular,
+ Unit unit = UnitPoint);
+ Font(HDC hdc, HFONT hfont);
+ Font(HDC hdc, const LOGFONTA *logfont);
+ Font(HDC hdc, const LOGFONTW *logfont);
+ Font(HDC hdc);
+ Font(const WCHAR *familyName, REAL emSize,
+ INT style = FontStyleRegular,
+ Unit unit = UnitPoint,
+ const FontCollection *fontCollection = NULL);
+ ~Font();
+ Font* Clone() const;
+
+ Status GetFamily(FontFamily *family) const;
+ REAL GetHeight(const Graphics *graphics) const;
+ REAL GetHeight(REAL dpi) const;
+ Status GetLogFontA(const Graphics *graphics, LOGFONTA *logfontA) const;
+ Status GetLogFontW(const Graphics *graphics, LOGFONTW *logfontW) const;
+ REAL GetSize() const;
+ INT GetStyle() const;
+ Unit GetUnit() const;
+
+ Status GetLastStatus() const
+ {
+ return lastStatus;
+ }
+ BOOL IsAvailable() const
+ {
+ return nativeFont != NULL;
+ }
+
+private:
+ Font(GpFont *font, Status status):
+ nativeFont(font), lastStatus(status) {}
+ Font(const Font&);
+ Font& operator=(const Font&);
+
+ Status updateStatus(Status newStatus) const
+ {
+ if (newStatus != Ok) lastStatus = newStatus;
+ return newStatus;
+ }
+
+ GpFont *nativeFont;
+ mutable Status lastStatus;
+};
+
+class FontCollection: public GdiplusBase
+{
+ friend class InstalledFontCollection;
+ friend class PrivateFontCollection;
+ friend class Font;
+ friend class FontFamily;
+
+public:
+ FontCollection();
+ virtual ~FontCollection() {}
+
+ Status GetFamilies(INT numSought, FontFamily *families,
+ INT *numFound) const;
+ INT GetFamilyCount() const;
+
+ Status GetLastStatus() const
+ {
+ return lastStatus;
+ }
+
+private:
+ FontCollection(const FontCollection&);
+ FontCollection& operator=(const FontCollection&);
+
+ Status updateStatus(Status newStatus) const
+ {
+ return lastStatus = newStatus;
+ }
+
+ GpFontCollection *nativeFontCollection;
+ mutable Status lastStatus;
+};
+
+class FontFamily: public GdiplusBase
+{
+ friend class Font;
+ friend class FontCollection;
+ friend class GraphicsPath;
+
+public:
+ static const FontFamily* GenericMonospace();
+ static const FontFamily* GenericSansSerif();
+ static const FontFamily* GenericSerif();
+
+ FontFamily();
+ FontFamily(const WCHAR *name,
+ const FontCollection *fontCollection = NULL);
+ ~FontFamily();
+ FontFamily* Clone() const;
+
+ UINT16 GetCellAscent(INT style) const;
+ UINT16 GetCellDescent(INT style) const;
+ UINT16 GetEmHeight(INT style) const;
+ Status GetFamilyName(WCHAR name[LF_FACESIZE],
+ LANGID language = LANG_NEUTRAL) const;
+ UINT16 GetLineSpacing(INT style) const;
+ BOOL IsStyleAvailable(INT style) const;
+
+ Status GetLastStatus() const
+ {
+ Status result = lastStatus;
+ lastStatus = Ok;
+ return result;
+ }
+ BOOL IsAvailable() const
+ {
+ return nativeFontFamily != NULL;
+ }
+
+private:
+ FontFamily(GpFontFamily *fontFamily, Status status):
+ nativeFontFamily(fontFamily), lastStatus(status) {}
+ FontFamily(const FontFamily&);
+ FontFamily& operator=(const FontFamily&);
+
+ Status updateStatus(Status newStatus) const
+ {
+ if (newStatus != Ok) lastStatus = newStatus;
+ return newStatus;
+ }
+
+ GpFontFamily *nativeFontFamily;
+ mutable Status lastStatus;
+};
+
+class InstalledFontCollection: public FontCollection
+{
+public:
+ InstalledFontCollection();
+ virtual ~InstalledFontCollection() {}
+};
+
+class PrivateFontCollection: public FontCollection
+{
+public:
+ PrivateFontCollection();
+
+ virtual ~PrivateFontCollection()
+ {
+ DllExports::GdipDeletePrivateFontCollection(&nativeFontCollection);
+ }
+
+ Status AddFontFile(const WCHAR *filename);
+ Status AddMemoryFont(const VOID *memory, INT length);
+};
+
+class Region: public GdiplusBase
+{
+ friend class Graphics;
+
+public:
+ static Region* FromHRGN(HRGN hrgn);
+
+ Region();
+ Region(const RectF& rect);
+ Region(const Rect& rect);
+ Region(const GraphicsPath *path);
+ Region(const BYTE *regionData, INT size);
+ Region(HRGN hrgn);
+ ~Region();
+ Region* Clone() const;
+
+ Status Complement(const RectF& rect);
+ Status Complement(const Rect& rect);
+ Status Complement(const Region *region);
+ Status Complement(const GraphicsPath *path);
+ BOOL Equals(const Region *region, const Graphics *graphics) const;
+ Status Exclude(const RectF& rect);
+ Status Exclude(const Rect& rect);
+ Status Exclude(const Region *region);
+ Status Exclude(const GraphicsPath *path);
+ Status GetBounds(RectF *rect, const Graphics *graphics) const;
+ Status GetBounds(Rect *rect, const Graphics *graphics) const;
+ Status GetData(BYTE *buffer, UINT bufferSize, UINT *sizeFilled) const;
+ UINT GetDataSize() const;
+ HRGN GetHRGN(const Graphics *graphics) const;
+ Status GetRegionScans(const Matrix *matrix,
+ RectF *rects, INT *count) const;
+ Status GetRegionScans(const Matrix *matrix,
+ Rect *rects, INT *count) const;
+ UINT GetRegionScansCount(const Matrix *matrix) const;
+ Status Intersect(const RectF& rect);
+ Status Intersect(const Rect& rect);
+ Status Intersect(const Region *region);
+ Status Intersect(const GraphicsPath *path);
+ BOOL IsEmpty(const Graphics *graphics) const;
+ BOOL IsInfinite(const Graphics *graphics) const;
+ BOOL IsVisible(REAL x, REAL y,
+ const Graphics *graphics = NULL) const;
+ BOOL IsVisible(INT x, INT y,
+ const Graphics *graphics = NULL) const;
+ BOOL IsVisible(const PointF& point,
+ const Graphics *graphics = NULL) const;
+ BOOL IsVisible(const Point& point,
+ const Graphics *graphics = NULL) const;
+ BOOL IsVisible(REAL x, REAL y, REAL width, REAL height,
+ const Graphics *graphics = NULL) const;
+ BOOL IsVisible(INT x, INT y, INT width, INT height,
+ const Graphics *graphics = NULL) const;
+ BOOL IsVisible(const RectF& rect,
+ const Graphics *graphics = NULL) const;
+ BOOL IsVisible(const Rect& rect,
+ const Graphics *graphics = NULL) const;
+ Status MakeEmpty();
+ Status MakeInfinite();
+ Status Transform(const Matrix *matrix);
+ Status Translate(REAL dx, REAL dy);
+ Status Translate(INT dx, INT dy);
+ Status Union(const RectF& rect);
+ Status Union(const Rect& rect);
+ Status Union(const Region *region);
+ Status Union(const GraphicsPath *path);
+ Status Xor(const RectF& rect);
+ Status Xor(const Rect& rect);
+ Status Xor(const Region *region);
+ Status Xor(const GraphicsPath *path);
+
+ Status GetLastStatus() const
+ {
+ Status result = lastStatus;
+ lastStatus = Ok;
+ return result;
+ }
+
+private:
+ Region(GpRegion *region, Status status):
+ nativeRegion(region), lastStatus(status) {}
+ Region(const Region&);
+ Region& operator=(const Region&);
+
+ Status updateStatus(Status newStatus) const
+ {
+ if (newStatus != Ok) lastStatus = newStatus;
+ return newStatus;
+ }
+
+ GpRegion *nativeRegion;
+ mutable Status lastStatus;
+};
+
+#endif /* __GDIPLUS_HEADERS_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_IMAGEATTRIBUTES_H
+#define __GDIPLUS_IMAGEATTRIBUTES_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifndef __cplusplus
+#error "A C++ compiler is required to include gdiplusimageattributes.h."
+#endif
+
+class ImageAttributes: public GdiplusBase
+{
+ friend class Graphics;
+ friend class TextureBrush;
+
+public:
+ ImageAttributes(): nativeImageAttributes(NULL), lastStatus(Ok)
+ {
+ lastStatus = DllExports::GdipCreateImageAttributes(
+ &nativeImageAttributes);
+ }
+ ~ImageAttributes()
+ {
+ DllExports::GdipDisposeImageAttributes(nativeImageAttributes);
+ }
+ ImageAttributes* Clone() const
+ {
+ GpImageAttributes *cloneImageAttributes = NULL;
+ Status status = updateStatus(DllExports::GdipCloneImageAttributes(
+ nativeImageAttributes, &cloneImageAttributes));
+ if (status == Ok) {
+ ImageAttributes *result = new ImageAttributes(
+ cloneImageAttributes, lastStatus);
+ if (!result) {
+ DllExports::GdipDisposeImageAttributes(cloneImageAttributes);
+ lastStatus = OutOfMemory;
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ Status ClearBrushRemapTable()
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesRemapTable(
+ nativeImageAttributes, ColorAdjustTypeBrush,
+ FALSE, 0, NULL));
+ }
+ Status ClearColorKey(ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesColorKeys(
+ nativeImageAttributes, type, FALSE, 0, 0));
+ }
+ Status ClearColorMatrices(ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesColorMatrix(
+ nativeImageAttributes, type, FALSE,
+ NULL, NULL, ColorMatrixFlagsDefault));
+ }
+ Status ClearColorMatrix(ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesColorMatrix(
+ nativeImageAttributes, type, FALSE,
+ NULL, NULL, ColorMatrixFlagsDefault));
+ }
+ Status ClearGamma(ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesGamma(
+ nativeImageAttributes, type, FALSE, 1.0f));
+ }
+ Status ClearNoOp(ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesNoOp(
+ nativeImageAttributes, type, FALSE));
+ }
+ Status ClearOutputChannel(ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesOutputChannel(
+ nativeImageAttributes, type, FALSE,
+ ColorChannelFlagsC));
+ }
+ Status ClearOutputChannelColorProfile(
+ ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesOutputChannelColorProfile(
+ nativeImageAttributes, type, FALSE, NULL));
+ }
+ Status ClearRemapTable(ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesRemapTable(
+ nativeImageAttributes, type, FALSE, 0, NULL));
+ }
+ Status ClearThreshold(ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesThreshold(
+ nativeImageAttributes, type, FALSE, 0.0));
+ }
+ Status GetAdjustedPalette(ColorPalette *colorPalette,
+ ColorAdjustType type) const
+ {
+ return updateStatus(DllExports::GdipGetImageAttributesAdjustedPalette(
+ nativeImageAttributes, colorPalette, type));
+ }
+ Status GetLastStatus() const
+ {
+ Status result = lastStatus;
+ lastStatus = Ok;
+ return result;
+ }
+ Status Reset(ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipResetImageAttributes(
+ nativeImageAttributes, type));
+ }
+ Status SetBrushRemapTable(UINT mapSize, ColorMap *map)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesRemapTable(
+ nativeImageAttributes, ColorAdjustTypeBrush,
+ TRUE, mapSize, map));
+ }
+ Status SetColorKey(const Color& colorLow, const Color& colorHigh,
+ ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesColorKeys(
+ nativeImageAttributes, type, TRUE,
+ colorLow.GetValue(), colorHigh.GetValue()));
+ }
+ Status SetColorMatrices(const ColorMatrix *colorMatrix,
+ const ColorMatrix *grayMatrix,
+ ColorMatrixFlags mode = ColorMatrixFlagsDefault,
+ ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesColorMatrix(
+ nativeImageAttributes, type, TRUE,
+ colorMatrix, grayMatrix, mode));
+ }
+ Status SetColorMatrix(const ColorMatrix *colorMatrix,
+ ColorMatrixFlags mode = ColorMatrixFlagsDefault,
+ ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesColorMatrix(
+ nativeImageAttributes, type, TRUE,
+ colorMatrix, NULL, mode));
+ }
+ Status SetGamma(REAL gamma,
+ ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesGamma(
+ nativeImageAttributes, type, TRUE, gamma));
+ }
+ Status SetNoOp(ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesNoOp(
+ nativeImageAttributes, type, TRUE));
+ }
+ Status SetOutputChannel(ColorChannelFlags channelFlags,
+ ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesOutputChannel(
+ nativeImageAttributes, type, TRUE,
+ channelFlags));
+ }
+ Status SetOutputChannelColorProfile(const WCHAR *colorProfileFilename,
+ ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesOutputChannelColorProfile(
+ nativeImageAttributes, type, TRUE,
+ colorProfileFilename));
+ }
+ Status SetRemapTable(UINT mapSize, const ColorMap *map,
+ ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesRemapTable(
+ nativeImageAttributes, type, TRUE,
+ mapSize, map));
+ }
+ Status SetThreshold(REAL threshold,
+ ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesThreshold(
+ nativeImageAttributes, type, TRUE, threshold));
+ }
+ Status SetToIdentity(ColorAdjustType type = ColorAdjustTypeDefault)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesToIdentity(
+ nativeImageAttributes, type));
+ }
+ Status SetWrapMode(WrapMode wrap, const Color& color = Color(),
+ BOOL clamp = FALSE)
+ {
+ return updateStatus(DllExports::GdipSetImageAttributesWrapMode(
+ nativeImageAttributes, wrap,
+ color.GetValue(), clamp));
+ }
+
+private:
+ ImageAttributes(GpImageAttributes *imageAttributes, Status status):
+ nativeImageAttributes(imageAttributes), lastStatus(status) {}
+ ImageAttributes(const ImageAttributes&);
+ ImageAttributes& operator=(const ImageAttributes&);
+
+ Status updateStatus(Status newStatus) const
+ {
+ if (newStatus != Ok) lastStatus = newStatus;
+ return newStatus;
+ }
+
+ GpImageAttributes *nativeImageAttributes;
+ mutable Status lastStatus;
+};
+
+
+#endif /* __GDIPLUS_IMAGEATTRIBUTES_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_IMAGECODEC_H
+#define __GDIPLUS_IMAGECODEC_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+static __inline__ GpStatus GetImageDecoders(UINT numDecoders, UINT size,
+ ImageCodecInfo *decoders)
+{
+ #ifdef __cplusplus
+ return DllExports::GdipGetImageDecoders(numDecoders, size, decoders);
+ #else
+ return GdipGetImageDecoders(numDecoders, size, decoders);
+ #endif
+}
+
+static __inline__ GpStatus GetImageDecodersSize(UINT *numDecoders, UINT *size)
+{
+ #ifdef __cplusplus
+ return DllExports::GdipGetImageDecodersSize(numDecoders, size);
+ #else
+ return GdipGetImageDecodersSize(numDecoders, size);
+ #endif
+}
+
+static __inline__ GpStatus GetImageEncoders(UINT numEncoders, UINT size,
+ ImageCodecInfo *encoders)
+{
+ #ifdef __cplusplus
+ return DllExports::GdipGetImageEncoders(numEncoders, size, encoders);
+ #else
+ return GdipGetImageEncoders(numEncoders, size, encoders);
+ #endif
+}
+
+static __inline__ GpStatus GetImageEncodersSize(UINT *numEncoders, UINT *size)
+{
+ #ifdef __cplusplus
+ return DllExports::GdipGetImageEncodersSize(numEncoders, size);
+ #else
+ return GdipGetImageEncodersSize(numEncoders, size);
+ #endif
+}
+
+#endif /* __GDIPLUS_IMAGECODEC_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_IMAGING_H
+#define __GDIPLUS_IMAGING_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+typedef enum ImageCodecFlags {
+ ImageCodecFlagsEncoder = 0x00000001,
+ ImageCodecFlagsDecoder = 0x00000002,
+ ImageCodecFlagsSupportBitmap = 0x00000004,
+ ImageCodecFlagsSupportVector = 0x00000008,
+ ImageCodecFlagsSeekableEncode = 0x00000010,
+ ImageCodecFlagsBlockingDecode = 0x00000020,
+ ImageCodecFlagsBuiltin = 0x00010000,
+ ImageCodecFlagsSystem = 0x00020000,
+ ImageCodecFlagsUser = 0x00040000
+} ImageCodecFlags;
+
+typedef enum ImageFlags {
+ ImageFlagsNone = 0,
+ ImageFlagsScalable = 0x00000001,
+ ImageFlagsHasAlpha = 0x00000002,
+ ImageFlagsHasTranslucent = 0x00000004,
+ ImageFlagsPartiallyScalable = 0x00000008,
+ ImageFlagsColorSpaceRGB = 0x00000010,
+ ImageFlagsColorSpaceCMYK = 0x00000020,
+ ImageFlagsColorSpaceGRAY = 0x00000040,
+ ImageFlagsColorSpaceYCBCR = 0x00000080,
+ ImageFlagsColorSpaceYCCK = 0x00000100,
+ ImageFlagsHasRealDPI = 0x00001000,
+ ImageFlagsHasRealPixelSize = 0x00002000,
+ ImageFlagsReadOnly = 0x00010000,
+ ImageFlagsCaching = 0x00020000
+} ImageFlags;
+
+typedef enum ImageLockMode {
+ ImageLockModeRead = 1,
+ ImageLockModeWrite = 2,
+ ImageLockModeUserInputBuf = 4
+} ImageLockMode;
+
+typedef enum ItemDataPosition {
+ ItemDataPositionAfterHeader = 0,
+ ItemDataPositionAfterPalette = 1,
+ ItemDataPositionAfterBits = 2
+} ItemDataPosition;
+
+typedef enum RotateFlipType {
+ RotateNoneFlipNone = 0,
+ Rotate90FlipNone = 1,
+ Rotate180FlipNone = 2,
+ Rotate270FlipNone = 3,
+ RotateNoneFlipX = 4,
+ Rotate90FlipX = 5,
+ Rotate180FlipX = 6,
+ Rotate270FlipX = 7,
+ Rotate180FlipXY = 0,
+ Rotate270FlipXY = 1,
+ RotateNoneFlipXY = 2,
+ Rotate90FlipXY = 3,
+ Rotate180FlipY = 4,
+ Rotate270FlipY = 5,
+ RotateNoneFlipY = 6,
+ Rotate90FlipY = 7
+} RotateFlipType;
+
+typedef struct BitmapData {
+ UINT Width;
+ UINT Height;
+ INT Stride;
+ INT PixelFormat; /* MSDN: "PixelFormat PixelFormat;" */
+ VOID *Scan0;
+ UINT_PTR Reserved;
+} BitmapData;
+
+typedef struct EncoderParameter {
+ GUID Guid;
+ ULONG NumberOfValues;
+ ULONG Type;
+ VOID *Value;
+} EncoderParameter;
+
+typedef struct EncoderParameters {
+ UINT Count;
+ EncoderParameter Parameter[1];
+} EncoderParameters;
+
+typedef struct ImageCodecInfo {
+ CLSID Clsid;
+ GUID FormatID;
+ WCHAR *CodecName;
+ WCHAR *DllName;
+ WCHAR *FormatDescription;
+ WCHAR *FilenameExtension;
+ WCHAR *MimeType;
+ DWORD Flags;
+ DWORD Version;
+ DWORD SigCount;
+ DWORD SigSize;
+ BYTE *SigPattern;
+ BYTE *SigMask;
+} ImageCodecInfo;
+
+/* FIXME: The order of fields is probably wrong. Please don't use this
+ * structure until this problem is resolved! Can't test because
+ * ImageItemData is not supported by the redistributable GDI+ 1.0 DLL. */
+typedef struct ImageItemData {
+ UINT Size;
+ UINT Position;
+ VOID *Desc;
+ UINT DescSize;
+ UINT *Data;
+ UINT DataSize;
+ UINT Cookie;
+} ImageItemData;
+
+typedef struct PropertyItem {
+ PROPID id;
+ ULONG length;
+ WORD type;
+ VOID *value;
+} PropertyItem;
+
+#define PropertyTagGpsVer ((PROPID) 0x0000)
+#define PropertyTagGpsLatitudeRef ((PROPID) 0x0001)
+#define PropertyTagGpsLatitude ((PROPID) 0x0002)
+#define PropertyTagGpsLongitudeRef ((PROPID) 0x0003)
+#define PropertyTagGpsLongitude ((PROPID) 0x0004)
+#define PropertyTagGpsAltitudeRef ((PROPID) 0x0005)
+#define PropertyTagGpsAltitude ((PROPID) 0x0006)
+#define PropertyTagGpsGpsTime ((PROPID) 0x0007)
+#define PropertyTagGpsGpsSatellites ((PROPID) 0x0008)
+#define PropertyTagGpsGpsStatus ((PROPID) 0x0009)
+#define PropertyTagGpsGpsMeasureMode ((PROPID) 0x000A)
+#define PropertyTagGpsGpsDop ((PROPID) 0x000B)
+#define PropertyTagGpsSpeedRef ((PROPID) 0x000C)
+#define PropertyTagGpsSpeed ((PROPID) 0x000D)
+#define PropertyTagGpsTrackRef ((PROPID) 0x000E)
+#define PropertyTagGpsTrack ((PROPID) 0x000F)
+#define PropertyTagGpsImgDirRef ((PROPID) 0x0010)
+#define PropertyTagGpsImgDir ((PROPID) 0x0011)
+#define PropertyTagGpsMapDatum ((PROPID) 0x0012)
+#define PropertyTagGpsDestLatRef ((PROPID) 0x0013)
+#define PropertyTagGpsDestLat ((PROPID) 0x0014)
+#define PropertyTagGpsDestLongRef ((PROPID) 0x0015)
+#define PropertyTagGpsDestLong ((PROPID) 0x0016)
+#define PropertyTagGpsDestBearRef ((PROPID) 0x0017)
+#define PropertyTagGpsDestBear ((PROPID) 0x0018)
+#define PropertyTagGpsDestDistRef ((PROPID) 0x0019)
+#define PropertyTagGpsDestDist ((PROPID) 0x001A)
+#define PropertyTagNewSubfileType ((PROPID) 0x00FE)
+#define PropertyTagSubfileType ((PROPID) 0x00FF)
+#define PropertyTagImageWidth ((PROPID) 0x0100)
+#define PropertyTagImageHeight ((PROPID) 0x0101)
+#define PropertyTagBitsPerSample ((PROPID) 0x0102)
+#define PropertyTagCompression ((PROPID) 0x0103)
+#define PropertyTagPhotometricInterp ((PROPID) 0x0106)
+#define PropertyTagThreshHolding ((PROPID) 0x0107)
+#define PropertyTagCellWidth ((PROPID) 0x0108)
+#define PropertyTagCellHeight ((PROPID) 0x0109)
+#define PropertyTagFillOrder ((PROPID) 0x010A)
+#define PropertyTagDocumentName ((PROPID) 0x010D)
+#define PropertyTagImageDescription ((PROPID) 0x010E)
+#define PropertyTagEquipMake ((PROPID) 0x010F)
+#define PropertyTagEquipModel ((PROPID) 0x0110)
+#define PropertyTagStripOffsets ((PROPID) 0x0111)
+#define PropertyTagOrientation ((PROPID) 0x0112)
+#define PropertyTagSamplesPerPixel ((PROPID) 0x0115)
+#define PropertyTagRowsPerStrip ((PROPID) 0x0116)
+#define PropertyTagStripBytesCount ((PROPID) 0x0117)
+#define PropertyTagMinSampleValue ((PROPID) 0x0118)
+#define PropertyTagMaxSampleValue ((PROPID) 0x0119)
+#define PropertyTagXResolution ((PROPID) 0x011A)
+#define PropertyTagYResolution ((PROPID) 0x011B)
+#define PropertyTagPlanarConfig ((PROPID) 0x011C)
+#define PropertyTagPageName ((PROPID) 0x011D)
+#define PropertyTagXPosition ((PROPID) 0x011E)
+#define PropertyTagYPosition ((PROPID) 0x011F)
+#define PropertyTagFreeOffset ((PROPID) 0x0120)
+#define PropertyTagFreeByteCounts ((PROPID) 0x0121)
+#define PropertyTagGrayResponseUnit ((PROPID) 0x0122)
+#define PropertyTagGrayResponseCurve ((PROPID) 0x0123)
+#define PropertyTagT4Option ((PROPID) 0x0124)
+#define PropertyTagT6Option ((PROPID) 0x0125)
+#define PropertyTagResolutionUnit ((PROPID) 0x0128)
+#define PropertyTagPageNumber ((PROPID) 0x0129)
+#define PropertyTagTransferFunction ((PROPID) 0x012D)
+#define PropertyTagSoftwareUsed ((PROPID) 0x0131)
+#define PropertyTagDateTime ((PROPID) 0x0132)
+#define PropertyTagArtist ((PROPID) 0x013B)
+#define PropertyTagHostComputer ((PROPID) 0x013C)
+#define PropertyTagPredictor ((PROPID) 0x013D)
+#define PropertyTagWhitePoint ((PROPID) 0x013E)
+#define PropertyTagPrimaryChromaticities ((PROPID) 0x013F)
+#define PropertyTagColorMap ((PROPID) 0x0140)
+#define PropertyTagHalftoneHints ((PROPID) 0x0141)
+#define PropertyTagTileWidth ((PROPID) 0x0142)
+#define PropertyTagTileLength ((PROPID) 0x0143)
+#define PropertyTagTileOffset ((PROPID) 0x0144)
+#define PropertyTagTileByteCounts ((PROPID) 0x0145)
+#define PropertyTagInkSet ((PROPID) 0x014C)
+#define PropertyTagInkNames ((PROPID) 0x014D)
+#define PropertyTagNumberOfInks ((PROPID) 0x014E)
+#define PropertyTagDotRange ((PROPID) 0x0150)
+#define PropertyTagTargetPrinter ((PROPID) 0x0151)
+#define PropertyTagExtraSamples ((PROPID) 0x0152)
+#define PropertyTagSampleFormat ((PROPID) 0x0153)
+#define PropertyTagSMinSampleValue ((PROPID) 0x0154)
+#define PropertyTagSMaxSampleValue ((PROPID) 0x0155)
+#define PropertyTagTransferRange ((PROPID) 0x0156)
+#define PropertyTagJPEGProc ((PROPID) 0x0200)
+#define PropertyTagJPEGInterFormat ((PROPID) 0x0201)
+#define PropertyTagJPEGInterLength ((PROPID) 0x0202)
+#define PropertyTagJPEGRestartInterval ((PROPID) 0x0203)
+#define PropertyTagJPEGLosslessPredictors ((PROPID) 0x0205)
+#define PropertyTagJPEGPointTransforms ((PROPID) 0x0206)
+#define PropertyTagJPEGQTables ((PROPID) 0x0207)
+#define PropertyTagJPEGDCTables ((PROPID) 0x0208)
+#define PropertyTagJPEGACTables ((PROPID) 0x0209)
+#define PropertyTagYCbCrCoefficients ((PROPID) 0x0211)
+#define PropertyTagYCbCrSubsampling ((PROPID) 0x0212)
+#define PropertyTagYCbCrPositioning ((PROPID) 0x0213)
+#define PropertyTagREFBlackWhite ((PROPID) 0x0214)
+#define PropertyTagGamma ((PROPID) 0x0301)
+#define PropertyTagICCProfileDescriptor ((PROPID) 0x0302)
+#define PropertyTagSRGBRenderingIntent ((PROPID) 0x0303)
+#define PropertyTagImageTitle ((PROPID) 0x0320)
+#define PropertyTagResolutionXUnit ((PROPID) 0x5001)
+#define PropertyTagResolutionYUnit ((PROPID) 0x5002)
+#define PropertyTagResolutionXLengthUnit ((PROPID) 0x5003)
+#define PropertyTagResolutionYLengthUnit ((PROPID) 0x5004)
+#define PropertyTagPrintFlags ((PROPID) 0x5005)
+#define PropertyTagPrintFlagsVersion ((PROPID) 0x5006)
+#define PropertyTagPrintFlagsCrop ((PROPID) 0x5007)
+#define PropertyTagPrintFlagsBleedWidth ((PROPID) 0x5008)
+#define PropertyTagPrintFlagsBleedWidthScale ((PROPID) 0x5009)
+#define PropertyTagHalftoneLPI ((PROPID) 0x500A)
+#define PropertyTagHalftoneLPIUnit ((PROPID) 0x500B)
+#define PropertyTagHalftoneDegree ((PROPID) 0x500C)
+#define PropertyTagHalftoneShape ((PROPID) 0x500D)
+#define PropertyTagHalftoneMisc ((PROPID) 0x500E)
+#define PropertyTagHalftoneScreen ((PROPID) 0x500F)
+#define PropertyTagJPEGQuality ((PROPID) 0x5010)
+#define PropertyTagGridSize ((PROPID) 0x5011)
+#define PropertyTagThumbnailFormat ((PROPID) 0x5012)
+#define PropertyTagThumbnailWidth ((PROPID) 0x5013)
+#define PropertyTagThumbnailHeight ((PROPID) 0x5014)
+#define PropertyTagThumbnailColorDepth ((PROPID) 0x5015)
+#define PropertyTagThumbnailPlanes ((PROPID) 0x5016)
+#define PropertyTagThumbnailRawBytes ((PROPID) 0x5017)
+#define PropertyTagThumbnailSize ((PROPID) 0x5018)
+#define PropertyTagThumbnailCompressedSize ((PROPID) 0x5019)
+#define PropertyTagColorTransferFunction ((PROPID) 0x501A)
+#define PropertyTagThumbnailData ((PROPID) 0x501B)
+#define PropertyTagThumbnailImageWidth ((PROPID) 0x5020)
+#define PropertyTagThumbnailImageHeight ((PROPID) 0x5021)
+#define PropertyTagThumbnailBitsPerSample ((PROPID) 0x5022)
+#define PropertyTagThumbnailCompression ((PROPID) 0x5023)
+#define PropertyTagThumbnailPhotometricInterp ((PROPID) 0x5024)
+#define PropertyTagThumbnailImageDescription ((PROPID) 0x5025)
+#define PropertyTagThumbnailEquipMake ((PROPID) 0x5026)
+#define PropertyTagThumbnailEquipModel ((PROPID) 0x5027)
+#define PropertyTagThumbnailStripOffsets ((PROPID) 0x5028)
+#define PropertyTagThumbnailOrientation ((PROPID) 0x5029)
+#define PropertyTagThumbnailSamplesPerPixel ((PROPID) 0x502A)
+#define PropertyTagThumbnailRowsPerStrip ((PROPID) 0x502B)
+#define PropertyTagThumbnailStripBytesCount ((PROPID) 0x502C)
+#define PropertyTagThumbnailResolutionX ((PROPID) 0x502D)
+#define PropertyTagThumbnailResolutionY ((PROPID) 0x502E)
+#define PropertyTagThumbnailPlanarConfig ((PROPID) 0x502F)
+#define PropertyTagThumbnailResolutionUnit ((PROPID) 0x5030)
+#define PropertyTagThumbnailTransferFunction ((PROPID) 0x5031)
+#define PropertyTagThumbnailSoftwareUsed ((PROPID) 0x5032)
+#define PropertyTagThumbnailDateTime ((PROPID) 0x5033)
+#define PropertyTagThumbnailArtist ((PROPID) 0x5034)
+#define PropertyTagThumbnailWhitePoint ((PROPID) 0x5035)
+#define PropertyTagThumbnailPrimaryChromaticities ((PROPID) 0x5036)
+#define PropertyTagThumbnailYCbCrCoefficients ((PROPID) 0x5037)
+#define PropertyTagThumbnailYCbCrSubsampling ((PROPID) 0x5038)
+#define PropertyTagThumbnailYCbCrPositioning ((PROPID) 0x5039)
+#define PropertyTagThumbnailRefBlackWhite ((PROPID) 0x503A)
+#define PropertyTagThumbnailCopyRight ((PROPID) 0x503B)
+#define PropertyTagLuminanceTable ((PROPID) 0x5090)
+#define PropertyTagChrominanceTable ((PROPID) 0x5091)
+#define PropertyTagFrameDelay ((PROPID) 0x5100)
+#define PropertyTagLoopCount ((PROPID) 0x5101)
+#define PropertyTagGlobalPalette ((PROPID) 0x5102)
+#define PropertyTagIndexBackground ((PROPID) 0x5103)
+#define PropertyTagIndexTransparent ((PROPID) 0x5104)
+#define PropertyTagPixelUnit ((PROPID) 0x5110)
+#define PropertyTagPixelPerUnitX ((PROPID) 0x5111)
+#define PropertyTagPixelPerUnitY ((PROPID) 0x5112)
+#define PropertyTagPaletteHistogram ((PROPID) 0x5113)
+#define PropertyTagCopyright ((PROPID) 0x8298)
+#define PropertyTagExifExposureTime ((PROPID) 0x829A)
+#define PropertyTagExifFNumber ((PROPID) 0x829D)
+#define PropertyTagExifIFD ((PROPID) 0x8769)
+#define PropertyTagICCProfile ((PROPID) 0x8773)
+#define PropertyTagExifExposureProg ((PROPID) 0x8822)
+#define PropertyTagExifSpectralSense ((PROPID) 0x8824)
+#define PropertyTagGpsIFD ((PROPID) 0x8825)
+#define PropertyTagExifISOSpeed ((PROPID) 0x8827)
+#define PropertyTagExifOECF ((PROPID) 0x8828)
+#define PropertyTagExifVer ((PROPID) 0x9000)
+#define PropertyTagExifDTOrig ((PROPID) 0x9003)
+#define PropertyTagExifDTDigitized ((PROPID) 0x9004)
+#define PropertyTagExifCompConfig ((PROPID) 0x9101)
+#define PropertyTagExifCompBPP ((PROPID) 0x9102)
+#define PropertyTagExifShutterSpeed ((PROPID) 0x9201)
+#define PropertyTagExifAperture ((PROPID) 0x9202)
+#define PropertyTagExifBrightness ((PROPID) 0x9203)
+#define PropertyTagExifExposureBias ((PROPID) 0x9204)
+#define PropertyTagExifMaxAperture ((PROPID) 0x9205)
+#define PropertyTagExifSubjectDist ((PROPID) 0x9206)
+#define PropertyTagExifMeteringMode ((PROPID) 0x9207)
+#define PropertyTagExifLightSource ((PROPID) 0x9208)
+#define PropertyTagExifFlash ((PROPID) 0x9209)
+#define PropertyTagExifFocalLength ((PROPID) 0x920A)
+#define PropertyTagExifMakerNote ((PROPID) 0x927C)
+#define PropertyTagExifUserComment ((PROPID) 0x9286)
+#define PropertyTagExifDTSubsec ((PROPID) 0x9290)
+#define PropertyTagExifDTOrigSS ((PROPID) 0x9291)
+#define PropertyTagExifDTDigSS ((PROPID) 0x9292)
+#define PropertyTagExifFPXVer ((PROPID) 0xA000)
+#define PropertyTagExifColorSpace ((PROPID) 0xA001)
+#define PropertyTagExifPixXDim ((PROPID) 0xA002)
+#define PropertyTagExifPixYDim ((PROPID) 0xA003)
+#define PropertyTagExifRelatedWav ((PROPID) 0xA004)
+#define PropertyTagExifInterop ((PROPID) 0xA005)
+#define PropertyTagExifFlashEnergy ((PROPID) 0xA20B)
+#define PropertyTagExifSpatialFR ((PROPID) 0xA20C)
+#define PropertyTagExifFocalXRes ((PROPID) 0xA20E)
+#define PropertyTagExifFocalYRes ((PROPID) 0xA20F)
+#define PropertyTagExifFocalResUnit ((PROPID) 0xA210)
+#define PropertyTagExifSubjectLoc ((PROPID) 0xA214)
+#define PropertyTagExifExposureIndex ((PROPID) 0xA215)
+#define PropertyTagExifSensingMethod ((PROPID) 0xA217)
+#define PropertyTagExifFileSource ((PROPID) 0xA300)
+#define PropertyTagExifSceneType ((PROPID) 0xA301)
+#define PropertyTagExifCfaPattern ((PROPID) 0xA302)
+
+#define PropertyTagTypeByte ((WORD) 1)
+#define PropertyTagTypeASCII ((WORD) 2)
+#define PropertyTagTypeShort ((WORD) 3)
+#define PropertyTagTypeLong ((WORD) 4)
+#define PropertyTagTypeRational ((WORD) 5)
+#define PropertyTagTypeUndefined ((WORD) 7)
+#define PropertyTagTypeSLONG ((WORD) 9)
+#define PropertyTagTypeSRational ((WORD) 10)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern const GUID EncoderChrominanceTable; /* f2e455dc-09b3-4316-8260-676ada32481c */
+extern const GUID EncoderColorDepth; /* 66087055-ad66-4c7c-9a18-38a2310b8337 */
+extern const GUID EncoderColorSpace; /* ? */
+extern const GUID EncoderCompression; /* e09d739d-ccd4-44ee-8eba-3fbf8be4fc58 */
+extern const GUID EncoderImageItems; /* ? */
+extern const GUID EncoderLuminanceTable; /* edb33bce-0266-4a77-b904-27216099e717 */
+extern const GUID EncoderQuality; /* 1d5be4b5-fa4a-452d-9cdd-5db35105e7eb */
+extern const GUID EncoderRenderMethod; /* 6d42c53a-229a-4825-8bb7-5c99e2b9a8b8 */
+extern const GUID EncoderSaveAsCMYK; /* ? */
+extern const GUID EncoderSaveFlag; /* 292266fc-ac40-47bf-8cfc-a85b89a655de */
+extern const GUID EncoderScanMethod; /* 3a4e2661-3109-4e56-8536-42c156e7dcfa */
+extern const GUID EncoderTransformation; /* 8d0eb2d1-a58e-4ea8-aa14-108074b7b6f9 */
+extern const GUID EncoderVersion; /* 24d18c76-814a-41a4-bf53-1c219cccf797 */
+
+extern const GUID ImageFormatBMP; /* b96b3cab-0728-11d3-9d7b-0000f81ef32e */
+extern const GUID ImageFormatEMF; /* b96b3cac-0728-11d3-9d7b-0000f81ef32e */
+extern const GUID ImageFormatEXIF; /* ? */
+extern const GUID ImageFormatGIF; /* b96b3cb0-0728-11d3-9d7b-0000f81ef32e */
+extern const GUID ImageFormatIcon; /* b96b3cb5-0728-11d3-9d7b-0000f81ef32e */
+extern const GUID ImageFormatJPEG; /* b96b3cae-0728-11d3-9d7b-0000f81ef32e */
+extern const GUID ImageFormatMemoryBMP; /* b96b3caa-0728-11d3-9d7b-0000f81ef32e */
+extern const GUID ImageFormatPNG; /* b96b3caf-0728-11d3-9d7b-0000f81ef32e */
+extern const GUID ImageFormatTIFF; /* b96b3cb1-0728-11d3-9d7b-0000f81ef32e */
+extern const GUID ImageFormatUndefined; /* ? */
+extern const GUID ImageFormatWMF; /* b96b3cad-0728-11d3-9d7b-0000f81ef32e */
+
+extern const GUID FrameDimensionPage; /* 7462dc86-6180-4c7e-8e3f-ee7333a7a483 */
+extern const GUID FrameDimensionResolution; /* ? */
+extern const GUID FrameDimensionTime; /* 6aedbd6d-3fb5-418a-83a6-7f45229dc872 */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* __GDIPLUS_IMAGING_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_INIT_H
+#define __GDIPLUS_INIT_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+typedef struct GdiplusStartupInput {
+ UINT32 GdiplusVersion;
+ DebugEventProc DebugEventCallback;
+ BOOL SuppressBackgroundThread;
+ BOOL SuppressExternalCodecs;
+
+ #ifdef __cplusplus
+ GdiplusStartupInput(DebugEventProc debugEventCallback = NULL,
+ BOOL suppressBackgroundThread = FALSE,
+ BOOL suppressExternalCodecs = FALSE):
+ GdiplusVersion(1),
+ DebugEventCallback(debugEventCallback),
+ SuppressBackgroundThread(suppressBackgroundThread),
+ SuppressExternalCodecs(suppressExternalCodecs) {}
+ #endif /* __cplusplus */
+} GdiplusStartupInput;
+
+typedef GpStatus WINGDIPAPI (*NotificationHookProc)(ULONG_PTR *token);
+typedef VOID WINGDIPAPI (*NotificationUnhookProc)(ULONG_PTR token);
+
+typedef struct GdiplusStartupOutput {
+ NotificationHookProc NotificationHook;
+ NotificationUnhookProc NotificationUnhook;
+
+ #ifdef __cplusplus
+ GdiplusStartupOutput():
+ NotificationHook(NULL),
+ NotificationUnhook(NULL) {}
+ #endif /* __cplusplus */
+} GdiplusStartupOutput;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+GpStatus WINGDIPAPI GdiplusStartup(ULONG_PTR*,GDIPCONST GdiplusStartupInput*,GdiplusStartupOutput*);
+VOID WINGDIPAPI GdiplusShutdown(ULONG_PTR);
+GpStatus WINGDIPAPI GdiplusNotificationHook(ULONG_PTR*);
+VOID WINGDIPAPI GdiplusNotificationUnhook(ULONG_PTR);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* __GDIPLUS_INIT_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_LINECAPS_H
+#define __GDIPLUS_LINECAPS_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifndef __cplusplus
+#error "A C++ compiler is required to include gdipluslinecaps.h."
+#endif
+
+class AdjustableArrowCap: public CustomLineCap
+{
+public:
+ AdjustableArrowCap(REAL height, REAL width, BOOL isFilled):
+ CustomLineCap(NULL, Ok)
+ {
+ GpAdjustableArrowCap *nativeAdjustableArrowCap = NULL;
+ lastStatus = DllExports::GdipCreateAdjustableArrowCap(
+ height, width, isFilled,
+ &nativeAdjustableArrowCap);
+ nativeCustomLineCap = nativeAdjustableArrowCap;
+ }
+ virtual ~AdjustableArrowCap()
+ {
+ }
+ virtual AdjustableArrowCap* Clone() const
+ {
+ GpCustomLineCap *cloneCustomLineCap = NULL;
+ Status status = updateStatus(DllExports::GdipCloneCustomLineCap(
+ nativeCustomLineCap, &cloneCustomLineCap));
+ if (status == Ok) {
+ AdjustableArrowCap *result = new AdjustableArrowCap(
+ cloneCustomLineCap, lastStatus);
+ if (!result) {
+ DllExports::GdipDeleteCustomLineCap(
+ cloneCustomLineCap);
+ lastStatus = OutOfMemory;
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ REAL GetHeight() const
+ {
+ REAL result = 0.0f;
+ updateStatus(DllExports::GdipGetAdjustableArrowCapHeight(
+ (GpAdjustableArrowCap*) nativeCustomLineCap,
+ &result));
+ return result;
+ }
+ REAL GetMiddleInset() const
+ {
+ REAL result = 0.0f;
+ updateStatus(DllExports::GdipGetAdjustableArrowCapMiddleInset(
+ (GpAdjustableArrowCap*) nativeCustomLineCap,
+ &result));
+ return result;
+ }
+ REAL GetWidth() const
+ {
+ REAL result = 0.0f;
+ updateStatus(DllExports::GdipGetAdjustableArrowCapWidth(
+ (GpAdjustableArrowCap*) nativeCustomLineCap,
+ &result));
+ return result;
+ }
+ BOOL IsFilled() const
+ {
+ BOOL result = FALSE;
+ updateStatus(DllExports::GdipGetAdjustableArrowCapFillState(
+ (GpAdjustableArrowCap*) nativeCustomLineCap,
+ &result));
+ return result;
+ }
+ Status SetFillState(BOOL isFilled)
+ {
+ return updateStatus(DllExports::GdipSetAdjustableArrowCapFillState(
+ (GpAdjustableArrowCap*) nativeCustomLineCap,
+ isFilled));
+ }
+ Status SetHeight(REAL height)
+ {
+ return updateStatus(DllExports::GdipSetAdjustableArrowCapHeight(
+ (GpAdjustableArrowCap*) nativeCustomLineCap,
+ height));
+ }
+ Status SetMiddleInset(REAL middleInset)
+ {
+ return updateStatus(DllExports::GdipSetAdjustableArrowCapMiddleInset(
+ (GpAdjustableArrowCap*) nativeCustomLineCap,
+ middleInset));
+ }
+ Status SetWidth(REAL width)
+ {
+ return updateStatus(DllExports::GdipSetAdjustableArrowCapWidth(
+ (GpAdjustableArrowCap*) nativeCustomLineCap,
+ width));
+ }
+
+private:
+ AdjustableArrowCap(GpCustomLineCap *customLineCap, Status status):
+ CustomLineCap(customLineCap, status) {}
+ AdjustableArrowCap(const AdjustableArrowCap&);
+ AdjustableArrowCap& operator=(const AdjustableArrowCap&);
+};
+
+#endif /* __GDIPLUS_LINECAPS_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_MATRIX_H
+#define __GDIPLUS_MATRIX_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifndef __cplusplus
+#error "A C++ compiler is required to include gdiplusmatrix.h."
+#endif
+
+#define GDIP_MATRIX_PI \
+ 3.1415926535897932384626433832795028841971693993751058209749445923078164
+
+class Matrix: public GdiplusBase
+{
+ friend class Graphics;
+ friend class GraphicsPath;
+ friend class LinearGradientBrush;
+ friend class PathGradientBrush;
+ friend class Pen;
+ friend class Region;
+ friend class TextureBrush;
+
+public:
+ Matrix(): nativeMatrix(NULL), lastStatus(Ok)
+ {
+ lastStatus = DllExports::GdipCreateMatrix(&nativeMatrix);
+ }
+ Matrix(REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy):
+ nativeMatrix(NULL), lastStatus(Ok)
+ {
+ lastStatus = DllExports::GdipCreateMatrix2(
+ m11, m12, m21, m22, dx, dy,
+ &nativeMatrix);
+ }
+ Matrix(const RectF& rect, const PointF *dstplg):
+ nativeMatrix(NULL), lastStatus(Ok)
+ {
+ lastStatus = DllExports::GdipCreateMatrix3(
+ &rect, dstplg, &nativeMatrix);
+ }
+ Matrix(const Rect& rect, const Point *dstplg):
+ nativeMatrix(NULL), lastStatus(Ok)
+ {
+ lastStatus = DllExports::GdipCreateMatrix3I(
+ &rect, dstplg, &nativeMatrix);
+ }
+ ~Matrix()
+ {
+ DllExports::GdipDeleteMatrix(nativeMatrix);
+ }
+ Matrix* Clone() const
+ {
+ GpMatrix *cloneMatrix = NULL;
+ Status status = updateStatus(DllExports::GdipCloneMatrix(
+ nativeMatrix, &cloneMatrix));
+ if (status == Ok) {
+ Matrix *result = new Matrix(cloneMatrix, lastStatus);
+ if (!result) {
+ DllExports::GdipDeleteMatrix(cloneMatrix);
+ lastStatus = OutOfMemory;
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ BOOL Equals(const Matrix *matrix) const
+ {
+ BOOL result;
+ updateStatus(DllExports::GdipIsMatrixEqual(
+ nativeMatrix,
+ matrix ? matrix->nativeMatrix : NULL, &result));
+ return result;
+ }
+ Status GetElements(REAL *m) const
+ {
+ return updateStatus(DllExports::GdipGetMatrixElements(
+ nativeMatrix, m));
+ }
+ Status GetLastStatus() const
+ {
+ Status result = lastStatus;
+ lastStatus = Ok;
+ return result;
+ }
+ Status Invert()
+ {
+ return updateStatus(DllExports::GdipInvertMatrix(nativeMatrix));
+ }
+ BOOL IsIdentity() const
+ {
+ BOOL result;
+ updateStatus(DllExports::GdipIsMatrixIdentity(
+ nativeMatrix, &result));
+ return result;
+ }
+ BOOL IsInvertible() const
+ {
+ BOOL result;
+ updateStatus(DllExports::GdipIsMatrixInvertible(
+ nativeMatrix, &result));
+ return result;
+ }
+ Status Multiply(const Matrix *matrix,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipMultiplyMatrix(
+ nativeMatrix,
+ matrix ? matrix->nativeMatrix : NULL, order));
+ }
+ REAL OffsetX() const
+ {
+ REAL m[6];
+ updateStatus(DllExports::GdipGetMatrixElements(nativeMatrix, m));
+ return m[4];
+ }
+ REAL OffsetY() const
+ {
+ REAL m[6];
+ updateStatus(DllExports::GdipGetMatrixElements(nativeMatrix, m));
+ return m[5];
+ }
+ Status Reset()
+ {
+ return updateStatus(DllExports::GdipSetMatrixElements(
+ nativeMatrix,
+ 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
+ }
+ Status Rotate(REAL angle, MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipRotateMatrix(
+ nativeMatrix, angle, order));
+ }
+ Status RotateAt(REAL angle, const PointF& center,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ REAL angleRadian = angle * GDIP_MATRIX_PI / 180.0f;
+ REAL cosAngle = ::cos(angleRadian);
+ REAL sinAngle = ::sin(angleRadian);
+ REAL x = center.X;
+ REAL y = center.Y;
+
+ Matrix matrix2(cosAngle, sinAngle, -sinAngle, cosAngle,
+ x * (1.0f-cosAngle) + y * sinAngle,
+ -x * sinAngle + y * (1.0f-cosAngle));
+ Status status = matrix2.GetLastStatus();
+ if (status == Ok) {
+ return Multiply(&matrix2, order);
+ } else {
+ return lastStatus = status;
+ }
+ }
+ Status Scale(REAL scaleX, REAL scaleY,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipScaleMatrix(
+ nativeMatrix, scaleX, scaleY, order));
+ }
+ Status SetElements(REAL m11, REAL m12, REAL m21, REAL m22,
+ REAL dx, REAL dy)
+ {
+ return updateStatus(DllExports::GdipSetMatrixElements(
+ nativeMatrix, m11, m12, m21, m22, dx, dy));
+ }
+ Status Shear(REAL shearX, REAL shearY,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipShearMatrix(
+ nativeMatrix, shearX, shearY, order));
+ }
+ Status TransformPoints(PointF *pts, INT count = 1) const
+ {
+ return updateStatus(DllExports::GdipTransformMatrixPoints(
+ nativeMatrix, pts, count));
+ }
+ Status TransformPoints(Point *pts, INT count = 1) const
+ {
+ return updateStatus(DllExports::GdipTransformMatrixPointsI(
+ nativeMatrix, pts, count));
+ }
+ Status TransformVectors(PointF *pts, INT count = 1) const
+ {
+ return updateStatus(DllExports::GdipVectorTransformMatrixPoints(
+ nativeMatrix, pts, count));
+ }
+ Status TransformVectors(Point *pts, INT count = 1) const
+ {
+ return updateStatus(DllExports::GdipVectorTransformMatrixPointsI(
+ nativeMatrix, pts, count));
+ }
+ Status Translate(REAL offsetX, REAL offsetY,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipTranslateMatrix(
+ nativeMatrix, offsetX, offsetY, order));
+ }
+
+private:
+ Matrix(GpMatrix *matrix, Status status):
+ nativeMatrix(matrix), lastStatus(status) {}
+ Matrix(const Matrix&);
+ Matrix& operator=(const Matrix&);
+
+ Status updateStatus(Status newStatus) const
+ {
+ if (newStatus != Ok) lastStatus = newStatus;
+ return newStatus;
+ }
+
+ GpMatrix *nativeMatrix;
+ mutable Status lastStatus;
+};
+
+#undef GDIP_MATRIX_PI
+
+#endif /* __GDIPLUS_MATRIX_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_MEM_H
+#define __GDIPLUS_MEM_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifdef __cplusplus
+namespace DllExports {
+extern "C" {
+#endif
+
+VOID* WINGDIPAPI GdipAlloc(size_t);
+VOID WINGDIPAPI GdipFree(VOID*);
+
+#ifdef __cplusplus
+} /* extern "C" */
+} /* namespace DllExports */
+#endif
+
+#endif /* __GDIPLUS_MEM_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_METAFILE_H
+#define __GDIPLUS_METAFILE_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifndef __cplusplus
+#error "A C++ compiler is required to include gdiplusmetafile.h."
+#endif
+
+class Metafile: public Image
+{
+public:
+ static UINT EmfToWmfBits(HENHMETAFILE hEmf,
+ UINT cbData16, LPBYTE pData16,
+ INT iMapMode = MM_ANISOTROPIC,
+ EmfToWmfBitsFlags eFlags = EmfToWmfBitsFlagsDefault)
+ {
+ return DllExports::GdipEmfToWmfBits(hEmf,
+ cbData16, pData16, iMapMode, eFlags);
+ }
+ static Status GetMetafileHeader(const WCHAR *filename,
+ MetafileHeader *header)
+ {
+ return DllExports::GdipGetMetafileHeaderFromFile(
+ filename, header);
+ }
+ static Status GetMetafileHeader(IStream *stream, MetafileHeader *header)
+ {
+ return DllExports::GdipGetMetafileHeaderFromStream(
+ stream, header);
+ }
+ ////TODO: Metafile::GetMetafileHeader
+ //static Status GetMetafileHeader(HMETAFILE hWmf,
+ // const WmfPlaceableFileHeader *wmfPlaceableFileHeader,
+ // MetafileHeader *header)
+ //{
+ // // WTF: No flat API to do this.
+ // return NotImplemented;
+ //}
+ static Status GetMetafileHeader(HENHMETAFILE hEmf,
+ MetafileHeader *header)
+ {
+ return DllExports::GdipGetMetafileHeaderFromEmf(hEmf, header);
+ }
+
+ Metafile(HMETAFILE hWmf,
+ const WmfPlaceableFileHeader *wmfPlaceableFileHeader,
+ BOOL deleteWmf = FALSE): Image(NULL, Ok)
+ {
+ GpMetafile *nativeMetafile = NULL;
+ lastStatus = DllExports::GdipCreateMetafileFromWmf(
+ hWmf, deleteWmf, wmfPlaceableFileHeader,
+ &nativeMetafile);
+ nativeImage = nativeMetafile;
+ }
+ Metafile(HENHMETAFILE hEmf, BOOL deleteEmf = FALSE): Image(NULL, Ok)
+ {
+ GpMetafile *nativeMetafile = NULL;
+ lastStatus = DllExports::GdipCreateMetafileFromEmf(
+ hEmf, deleteEmf, &nativeMetafile);
+ nativeImage = nativeMetafile;
+ }
+ Metafile(const WCHAR *filename): Image(NULL, Ok)
+ {
+ GpMetafile *nativeMetafile = NULL;
+ lastStatus = DllExports::GdipCreateMetafileFromFile(
+ filename, &nativeMetafile);
+ nativeImage = nativeMetafile;
+ }
+ Metafile(const WCHAR *filename,
+ const WmfPlaceableFileHeader *wmfPlaceableFileHeader):
+ Image(NULL, Ok)
+ {
+ GpMetafile *nativeMetafile = NULL;
+ lastStatus = DllExports::GdipCreateMetafileFromWmfFile(
+ filename, wmfPlaceableFileHeader,
+ &nativeMetafile);
+ nativeImage = nativeMetafile;
+ }
+ Metafile(IStream *stream): Image(NULL, Ok)
+ {
+ GpMetafile *nativeMetafile = NULL;
+ lastStatus = DllExports::GdipCreateMetafileFromStream(
+ stream, &nativeMetafile);
+ nativeImage = nativeMetafile;
+ }
+ Metafile(HDC referenceHdc, EmfType type = EmfTypeEmfPlusDual,
+ const WCHAR *description = NULL): Image(NULL, Ok)
+ {
+ GpMetafile *nativeMetafile = NULL;
+ lastStatus = DllExports::GdipRecordMetafile(
+ referenceHdc, type, NULL, MetafileFrameUnitGdi,
+ description, &nativeMetafile);
+ nativeImage = nativeMetafile;
+ }
+ Metafile(HDC referenceHdc, const RectF& frameRect,
+ MetafileFrameUnit frameUnit = MetafileFrameUnitGdi,
+ EmfType type = EmfTypeEmfPlusDual,
+ const WCHAR *description = NULL): Image(NULL, Ok)
+ {
+ GpMetafile *nativeMetafile = NULL;
+ lastStatus = DllExports::GdipRecordMetafile(
+ referenceHdc, type, &frameRect, frameUnit,
+ description, &nativeMetafile);
+ nativeImage = nativeMetafile;
+ }
+ Metafile(HDC referenceHdc, const Rect& frameRect,
+ MetafileFrameUnit frameUnit = MetafileFrameUnitGdi,
+ EmfType type = EmfTypeEmfPlusDual,
+ const WCHAR *description = NULL): Image(NULL, Ok)
+ {
+ GpMetafile *nativeMetafile = NULL;
+ lastStatus = DllExports::GdipRecordMetafileI(
+ referenceHdc, type, &frameRect, frameUnit,
+ description, &nativeMetafile);
+ nativeImage = nativeMetafile;
+ }
+ Metafile(const WCHAR *filename, HDC referenceHdc,
+ EmfType type = EmfTypeEmfPlusDual,
+ const WCHAR *description = NULL): Image(NULL, Ok)
+ {
+ GpMetafile *nativeMetafile = NULL;
+ lastStatus = DllExports::GdipRecordMetafileFileName(
+ filename, referenceHdc, type, NULL,
+ MetafileFrameUnitGdi, description,
+ &nativeMetafile);
+ nativeImage = nativeMetafile;
+ }
+ Metafile(const WCHAR *filename, HDC referenceHdc,
+ const RectF& frameRect,
+ MetafileFrameUnit frameUnit = MetafileFrameUnitGdi,
+ EmfType type = EmfTypeEmfPlusDual,
+ const WCHAR *description = NULL): Image(NULL, Ok)
+ {
+ GpMetafile *nativeMetafile = NULL;
+ lastStatus = DllExports::GdipRecordMetafileFileName(
+ filename, referenceHdc, type, &frameRect,
+ frameUnit, description, &nativeMetafile);
+ nativeImage = nativeMetafile;
+ }
+ Metafile(const WCHAR *filename, HDC referenceHdc,
+ const Rect& frameRect,
+ MetafileFrameUnit frameUnit = MetafileFrameUnitGdi,
+ EmfType type = EmfTypeEmfPlusDual,
+ const WCHAR *description = NULL): Image(NULL, Ok)
+ {
+ GpMetafile *nativeMetafile = NULL;
+ lastStatus = DllExports::GdipRecordMetafileFileNameI(
+ filename, referenceHdc, type, &frameRect,
+ frameUnit, description, &nativeMetafile);
+ nativeImage = nativeMetafile;
+ }
+ Metafile(IStream *stream, HDC referenceHdc,
+ EmfType type = EmfTypeEmfPlusDual,
+ const WCHAR *description = NULL): Image(NULL, Ok)
+ {
+ GpMetafile *nativeMetafile = NULL;
+ lastStatus = DllExports::GdipRecordMetafileStream(
+ stream, referenceHdc, type, NULL,
+ MetafileFrameUnitGdi, description,
+ &nativeMetafile);
+ nativeImage = nativeMetafile;
+ }
+ Metafile(IStream *stream, HDC referenceHdc, const RectF& frameRect,
+ MetafileFrameUnit frameUnit = MetafileFrameUnitGdi,
+ EmfType type = EmfTypeEmfPlusDual,
+ const WCHAR *description = NULL): Image(NULL, Ok)
+ {
+ GpMetafile *nativeMetafile = NULL;
+ lastStatus = DllExports::GdipRecordMetafileStream(
+ stream, referenceHdc, type, &frameRect,
+ frameUnit, description, &nativeMetafile);
+ nativeImage = nativeMetafile;
+ }
+ Metafile(IStream *stream, HDC referenceHdc, const Rect& frameRect,
+ MetafileFrameUnit frameUnit = MetafileFrameUnitGdi,
+ EmfType type = EmfTypeEmfPlusDual,
+ const WCHAR *description = NULL): Image(NULL, Ok)
+ {
+ GpMetafile *nativeMetafile = NULL;
+ lastStatus = DllExports::GdipRecordMetafileStreamI(
+ stream, referenceHdc, type, &frameRect,
+ frameUnit, description, &nativeMetafile);
+ nativeImage = nativeMetafile;
+ }
+ virtual ~Metafile()
+ {
+ }
+ virtual Metafile* Clone() const
+ {
+ GpImage *cloneImage = NULL;
+ Status status = updateStatus(DllExports::GdipCloneImage(
+ nativeImage, &cloneImage));
+ if (status == Ok) {
+ Metafile *result = new Metafile(cloneImage, lastStatus);
+ if (!result) {
+ DllExports::GdipDisposeImage(cloneImage);
+ lastStatus = OutOfMemory;
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ ////TODO: [GDI+ 1.1] Metafile::ConvertToEmfPlus
+ //Status ConvertToEmfPlus(const Graphics *refGraphics,
+ // BOOL *conversionSuccess = NULL,
+ // EmfType emfType = EmfTypeEmfPlusOnly,
+ // const WCHAR *description = NULL)
+ //{
+ // // FIXME: can't test GdipConvertToEmfPlus because it isn't exported in 1.0
+ // return updateStatus(DllExports::GdipConvertToEmfPlus(
+ // refGraphics ? refGraphics->nativeGraphics : NULL,
+ // (GpMetafile*) nativeImage,
+ // conversionSuccess, emfType, description, ???));
+ //}
+ ////TODO: [GDI+ 1.1] Metafile::ConvertToEmfPlus
+ //Status ConvertToEmfPlus(const Graphics *refGraphics,
+ // const WCHAR *filename,
+ // BOOL *conversionSuccess = NULL,
+ // EmfType emfType = EmfTypeEmfPlusOnly,
+ // const WCHAR *description = NULL)
+ //{
+ // // FIXME: can't test GdipConvertToEmfPlusToFile because it isn't exported in 1.0
+ // return updateStatus(DllExports::GdipConvertToEmfPlusToFile(
+ // refGraphics ? refGraphics->nativeGraphics : NULL,
+ // (GpMetafile*) nativeImage, conversionSuccess,
+ // filename, emfType, description, ???));
+ //}
+ ////TODO: [GDI+ 1.1] Metafile::ConvertToEmfPlus
+ //Status ConvertToEmfPlus(const Graphics *refGraphics,
+ // IStream *stream,
+ // BOOL *conversionSuccess = NULL,
+ // EmfType emfType = EmfTypeEmfPlusOnly,
+ // const WCHAR *description = NULL)
+ //{
+ // // FIXME: can't test GdipConvertToEmfPlusToStream because it isn't exported in 1.0
+ // return updateStatus(DllExports::GdipConvertToEmfPlusToStream(
+ // refGraphics ? refGraphics->nativeGraphics : NULL,
+ // (GpMetafile*) nativeImage, conversionSuccess,
+ // stream, emfType, description, ???));
+ //}
+ UINT GetDownLevelRasterizationLimit() const
+ {
+ UINT result = 0;
+ updateStatus(DllExports::GdipGetMetafileDownLevelRasterizationLimit(
+ (GpMetafile*) nativeImage, &result));
+ return result;
+ }
+ HENHMETAFILE GetHENHMETAFILE()
+ {
+ HENHMETAFILE result = NULL;
+ updateStatus(DllExports::GdipGetHemfFromMetafile(
+ (GpMetafile*) nativeImage, &result));
+ return result;
+ }
+ Status GetMetafileHeader(MetafileHeader *header) const
+ {
+ return updateStatus(DllExports::GdipGetMetafileHeaderFromMetafile(
+ (GpMetafile*) nativeImage, header));
+ }
+ Status PlayRecord(EmfPlusRecordType recordType, UINT flags,
+ UINT dataSize, const BYTE *data) const
+ {
+ return updateStatus(DllExports::GdipPlayMetafileRecord(
+ (GpMetafile*) nativeImage,
+ recordType, flags, dataSize, data));
+ }
+ Status SetDownLevelRasterizationLimit(UINT limitDpi)
+ {
+ return updateStatus(DllExports::GdipSetMetafileDownLevelRasterizationLimit(
+ (GpMetafile*) nativeImage, limitDpi));
+ }
+
+private:
+ Metafile(GpImage *image, Status status): Image(image, status) {}
+ Metafile(const Metafile&);
+ Metafile& operator=(const Metafile&);
+};
+
+#endif /* __GDIPLUS_METAFILE_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_METAHEADER_H
+#define __GDIPLUS_METAHEADER_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+
+/*
+ * FIXME: is 1 the correct value for GDIP_EMFPLUSFLAGS_DISPLAY? This number
+ * has been determined by calling Metafile::GetMetafileHeader() on a EMF+
+ * metafile which was recorded on a display device context (SampleMetafile.emf).
+ */
+#ifdef __cplusplus
+const UINT GDIP_EMFPLUSFLAGS_DISPLAY = 1;
+#else
+#define GDIP_EMFPLUSFLAGS_DISPLAY ((UINT) 1)
+#endif
+
+typedef struct tagENHMETAHEADER3 {
+ DWORD iType;
+ DWORD nSize;
+ RECTL rclBounds;
+ RECTL rclFrame;
+ DWORD dSignature;
+ DWORD nVersion;
+ DWORD nBytes;
+ DWORD nRecords;
+ WORD nHandles;
+ WORD sReserved;
+ DWORD nDescription;
+ DWORD offDescription;
+ DWORD nPalEntries;
+ SIZEL szlDevice;
+ SIZEL szlMillimeters;
+} ENHMETAHEADER3,*LPENHMETAHEADER3;
+
+typedef struct PWMFRect16 {
+ INT16 Left;
+ INT16 Top;
+ INT16 Right;
+ INT16 Bottom;
+} PWMFRect16;
+
+typedef struct WmfPlaceableFileHeader {
+ UINT32 Key;
+ INT16 Hmf;
+ PWMFRect16 BoundingBox;
+ INT16 Inch;
+ UINT32 Reserved;
+ INT16 Checksum;
+} WmfPlaceableFileHeader;
+
+typedef struct MetafileHeader {
+ MetafileType Type;
+ UINT Size;
+ UINT Version;
+ UINT EmfPlusFlags;
+ REAL DpiX;
+ REAL DpiY;
+ INT X;
+ INT Y;
+ INT Width;
+ INT Height;
+ __extension__ union {
+ METAHEADER WmfHeader;
+ ENHMETAHEADER3 EmfHeader;
+ };
+ INT EmfPlusHeaderSize;
+ INT LogicalDpiX;
+ INT LogicalDpiY;
+
+ #ifdef __cplusplus
+ public:
+ void GetBounds(Rect *rect) const
+ {
+ if (rect)
+ {
+ rect->X = X;
+ rect->Y = Y;
+ rect->Width = Width;
+ rect->Height = Height;
+ }
+ }
+ REAL GetDpiX() const
+ {
+ return DpiX;
+ }
+ REAL GetDpiY() const
+ {
+ return DpiY;
+ }
+ const ENHMETAHEADER3* GetEmfHeader() const
+ {
+ if (Type == MetafileTypeEmf
+ || Type == MetafileTypeEmfPlusOnly
+ || Type == MetafileTypeEmfPlusDual)
+ {
+ return &EmfHeader;
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+ UINT GetEmfPlusFlags() const
+ {
+ return EmfPlusFlags;
+ }
+ UINT GetMetafileSize() const
+ {
+ return Size;
+ }
+ MetafileType GetType() const
+ {
+ return Type;
+ }
+ UINT GetVersion() const
+ {
+ return Version;
+ }
+ const METAHEADER* GetWmfHeader() const
+ {
+ if (Type == MetafileTypeWmf || Type == MetafileTypeWmfPlaceable)
+ {
+ return &WmfHeader;
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+ BOOL IsDisplay() const
+ {
+ return EmfPlusFlags == GDIP_EMFPLUSFLAGS_DISPLAY;
+ }
+ BOOL IsEmf() const
+ {
+ return Type == MetafileTypeEmf;
+ }
+ BOOL IsEmfOrEmfPlus() const
+ {
+ return Type == MetafileTypeEmf
+ || Type == MetafileTypeEmfPlusOnly
+ || Type == MetafileTypeEmfPlusDual;
+ }
+ BOOL IsEmfPlus() const
+ {
+ return Type == MetafileTypeEmfPlusOnly
+ || Type == MetafileTypeEmfPlusDual;
+ }
+ BOOL IsEmfPlusDual() const
+ {
+ return Type == MetafileTypeEmfPlusDual;
+ }
+ BOOL IsEmfPlusOnly() const
+ {
+ return Type == MetafileTypeEmfPlusOnly;
+ }
+ BOOL IsWmf() const
+ {
+ return Type == MetafileTypeWmf
+ || Type == MetafileTypeWmfPlaceable;
+ }
+ BOOL IsWmfPlaceable() const
+ {
+ return Type == MetafileTypeWmfPlaceable;
+ }
+ #endif
+} MetafileHeader;
+
+#endif /* __GDIPLUS_METAHEADER_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_PATH_H
+#define __GDIPLUS_PATH_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifndef __cplusplus
+#error "A C++ compiler is required to include gdipluspath.h."
+#endif
+
+// Note that some methods of GraphicsPath are implemented in gdiplusimpl.h.
+// This avoids a cyclic dependency on Graphics and Pen.
+
+class GraphicsPath: public GdiplusBase
+{
+ friend class CustomLineCap;
+ friend class Graphics;
+ friend class GraphicsPathIterator;
+ friend class PathGradientBrush;
+ friend class Region;
+
+public:
+ GraphicsPath(FillMode fillMode = FillModeAlternate):
+ nativePath(NULL), lastStatus(Ok)
+ {
+ lastStatus = DllExports::GdipCreatePath(fillMode, &nativePath);
+ }
+ GraphicsPath(const PointF *points, const BYTE *types, INT count,
+ FillMode fillMode = FillModeAlternate):
+ nativePath(NULL), lastStatus(Ok)
+ {
+ lastStatus = DllExports::GdipCreatePath2(
+ points, types, count, fillMode, &nativePath);
+ }
+ GraphicsPath(const Point *points, const BYTE *types, INT count,
+ FillMode fillMode = FillModeAlternate):
+ nativePath(NULL), lastStatus(Ok)
+ {
+ lastStatus = DllExports::GdipCreatePath2I(
+ points, types, count, fillMode, &nativePath);
+ }
+ ~GraphicsPath()
+ {
+ DllExports::GdipDeletePath(nativePath);
+ }
+ GraphicsPath* Clone() const
+ {
+ GpPath *clonePath = NULL;
+ Status status = updateStatus(DllExports::GdipClonePath(
+ nativePath, &clonePath));
+ if (status == Ok) {
+ GraphicsPath *result = new GraphicsPath(clonePath, lastStatus);
+ if (!result) {
+ DllExports::GdipDeletePath(clonePath);
+ lastStatus = OutOfMemory;
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ Status AddArc(REAL x, REAL y, REAL width, REAL height,
+ REAL startAngle, REAL sweepAngle)
+ {
+ return updateStatus(DllExports::GdipAddPathArc(nativePath,
+ x, y, width, height, startAngle, sweepAngle));
+ }
+ Status AddArc(INT x, INT y, INT width, INT height,
+ REAL startAngle, REAL sweepAngle)
+ {
+ return updateStatus(DllExports::GdipAddPathArcI(nativePath,
+ x, y, width, height, startAngle, sweepAngle));
+ }
+ Status AddArc(const RectF& rect, REAL startAngle, REAL sweepAngle)
+ {
+ return updateStatus(DllExports::GdipAddPathArc(nativePath,
+ rect.X, rect.Y, rect.Width, rect.Height,
+ startAngle, sweepAngle));
+ }
+ Status AddArc(const Rect& rect, REAL startAngle, REAL sweepAngle)
+ {
+ return updateStatus(DllExports::GdipAddPathArcI(nativePath,
+ rect.X, rect.Y, rect.Width, rect.Height,
+ startAngle, sweepAngle));
+ }
+ Status AddBezier(REAL x1, REAL y1, REAL x2, REAL y2,
+ REAL x3, REAL y3, REAL x4, REAL y4)
+ {
+ return updateStatus(DllExports::GdipAddPathBezier(nativePath,
+ x1, y1, x2, y2, x3, y3, x4, y4));
+ }
+ Status AddBezier(INT x1, INT y1, INT x2, INT y2,
+ INT x3, INT y3, INT x4, INT y4)
+ {
+ return updateStatus(DllExports::GdipAddPathBezierI(nativePath,
+ x1, y1, x2, y2, x3, y3, x4, y4));
+ }
+ Status AddBezier(const PointF& pt1, const PointF& pt2,
+ const PointF& pt3, const PointF& pt4)
+ {
+ return updateStatus(DllExports::GdipAddPathBezier(nativePath,
+ pt1.X, pt1.Y, pt2.X, pt2.Y,
+ pt3.X, pt3.Y, pt4.X, pt4.Y));
+ }
+ Status AddBezier(const Point& pt1, const Point& pt2,
+ const Point& pt3, const Point& pt4)
+ {
+ return updateStatus(DllExports::GdipAddPathBezierI(nativePath,
+ pt1.X, pt1.Y, pt2.X, pt2.Y,
+ pt3.X, pt3.Y, pt4.X, pt4.Y));
+ }
+ Status AddBeziers(const PointF *points, INT count)
+ {
+ return updateStatus(DllExports::GdipAddPathBeziers(
+ nativePath, points, count));
+ }
+ Status AddBeziers(const Point *points, INT count)
+ {
+ return updateStatus(DllExports::GdipAddPathBeziersI(
+ nativePath, points, count));
+ }
+ Status AddClosedCurve(const PointF *points, INT count)
+ {
+ return updateStatus(DllExports::GdipAddPathClosedCurve(
+ nativePath, points, count));
+ }
+ Status AddClosedCurve(const Point *points, INT count)
+ {
+ return updateStatus(DllExports::GdipAddPathClosedCurveI(
+ nativePath, points, count));
+ }
+ Status AddClosedCurve(const PointF *points, INT count, REAL tension)
+ {
+ return updateStatus(DllExports::GdipAddPathClosedCurve2(
+ nativePath, points, count, tension));
+ }
+ Status AddClosedCurve(const Point *points, INT count, REAL tension)
+ {
+ return updateStatus(DllExports::GdipAddPathClosedCurve2I(
+ nativePath, points, count, tension));
+ }
+ Status AddCurve(const PointF *points, INT count)
+ {
+ return updateStatus(DllExports::GdipAddPathCurve(
+ nativePath, points, count));
+ }
+ Status AddCurve(const Point *points, INT count)
+ {
+ return updateStatus(DllExports::GdipAddPathCurveI(
+ nativePath, points, count));
+ }
+ Status AddCurve(const PointF *points, INT count, REAL tension)
+ {
+ return updateStatus(DllExports::GdipAddPathCurve2(
+ nativePath, points, count, tension));
+ }
+ Status AddCurve(const Point *points, INT count, REAL tension)
+ {
+ return updateStatus(DllExports::GdipAddPathCurve2I(
+ nativePath, points, count, tension));
+ }
+ Status AddCurve(const PointF *points, INT count, INT offset,
+ INT numberOfSegments, REAL tension)
+ {
+ return updateStatus(DllExports::GdipAddPathCurve3(
+ nativePath, points, count,
+ offset, numberOfSegments, tension));
+ }
+ Status AddCurve(const Point *points, INT count, INT offset,
+ INT numberOfSegments, REAL tension)
+ {
+ return updateStatus(DllExports::GdipAddPathCurve3I(
+ nativePath, points, count,
+ offset, numberOfSegments, tension));
+ }
+ Status AddEllipse(REAL x, REAL y, REAL width, REAL height)
+ {
+ return updateStatus(DllExports::GdipAddPathEllipse(nativePath,
+ x, y, width, height));
+ }
+ Status AddEllipse(INT x, INT y, INT width, INT height)
+ {
+ return updateStatus(DllExports::GdipAddPathEllipseI(nativePath,
+ x, y, width, height));
+ }
+ Status AddEllipse(const RectF& rect)
+ {
+ return updateStatus(DllExports::GdipAddPathEllipse(nativePath,
+ rect.X, rect.Y, rect.Width, rect.Height));
+ }
+ Status AddEllipse(const Rect& rect)
+ {
+ return updateStatus(DllExports::GdipAddPathEllipseI(nativePath,
+ rect.X, rect.Y, rect.Width, rect.Height));
+ }
+ Status AddLine(REAL x1, REAL y1, REAL x2, REAL y2)
+ {
+ return updateStatus(DllExports::GdipAddPathLine(nativePath,
+ x1, y1, x2, y2));
+ }
+ Status AddLine(INT x1, INT y1, INT x2, INT y2)
+ {
+ return updateStatus(DllExports::GdipAddPathLineI(nativePath,
+ x1, y1, x2, y2));
+ }
+ Status AddLine(const PointF& pt1, const PointF& pt2)
+ {
+ return updateStatus(DllExports::GdipAddPathLine(nativePath,
+ pt1.X, pt1.Y, pt2.X, pt2.Y));
+ }
+ Status AddLine(const Point& pt1, const Point& pt2)
+ {
+ return updateStatus(DllExports::GdipAddPathLineI(nativePath,
+ pt1.X, pt1.Y, pt2.X, pt2.Y));
+ }
+ Status AddLines(const PointF *points, INT count)
+ {
+ return updateStatus(DllExports::GdipAddPathLine2(nativePath,
+ points, count));
+ }
+ Status AddLines(const Point *points, INT count)
+ {
+ return updateStatus(DllExports::GdipAddPathLine2I(nativePath,
+ points, count));
+ }
+ Status AddPath(const GraphicsPath *addingPath, BOOL connect)
+ {
+ return updateStatus(DllExports::GdipAddPathPath(nativePath,
+ addingPath ? addingPath->nativePath : NULL,
+ connect));
+ }
+ Status AddPie(REAL x, REAL y, REAL width, REAL height,
+ REAL startAngle, REAL sweepAngle)
+ {
+ return updateStatus(DllExports::GdipAddPathPie(nativePath,
+ x, y, width, height, startAngle, sweepAngle));
+ }
+ Status AddPie(INT x, INT y, INT width, INT height,
+ REAL startAngle, REAL sweepAngle)
+ {
+ return updateStatus(DllExports::GdipAddPathPieI(nativePath,
+ x, y, width, height, startAngle, sweepAngle));
+ }
+ Status AddPie(const RectF& rect, REAL startAngle, REAL sweepAngle)
+ {
+ return updateStatus(DllExports::GdipAddPathPie(nativePath,
+ rect.X, rect.Y, rect.Width, rect.Height,
+ startAngle, sweepAngle));
+ }
+ Status AddPie(const Rect& rect, REAL startAngle, REAL sweepAngle)
+ {
+ return updateStatus(DllExports::GdipAddPathPieI(nativePath,
+ rect.X, rect.Y, rect.Width, rect.Height,
+ startAngle, sweepAngle));
+ }
+ Status AddPolygon(const PointF *points, INT count)
+ {
+ return updateStatus(DllExports::GdipAddPathPolygon(nativePath,
+ points, count));
+ }
+ Status AddPolygon(const Point *points, INT count)
+ {
+ return updateStatus(DllExports::GdipAddPathPolygonI(nativePath,
+ points, count));
+ }
+ Status AddRectangle(const RectF& rect)
+ {
+ return updateStatus(DllExports::GdipAddPathRectangle(nativePath,
+ rect.X, rect.Y, rect.Width, rect.Height));
+ }
+ Status AddRectangle(const Rect& rect)
+ {
+ return updateStatus(DllExports::GdipAddPathRectangleI(
+ nativePath,
+ rect.X, rect.Y, rect.Width, rect.Height));
+ }
+ Status AddRectangles(const RectF *rects, INT count)
+ {
+ return updateStatus(DllExports::GdipAddPathRectangles(
+ nativePath, rects, count));
+ }
+ Status AddRectangles(const Rect *rects, INT count)
+ {
+ return updateStatus(DllExports::GdipAddPathRectanglesI(
+ nativePath, rects, count));
+ }
+ Status AddString(const WCHAR *string, INT length,
+ const FontFamily *family, INT style, REAL emSize,
+ const PointF& origin, const StringFormat *format)
+ {
+ RectF layoutRect(origin, SizeF(0.0f, 0.0f));
+ return updateStatus(DllExports::GdipAddPathString(nativePath,
+ string, length,
+ family ? family->nativeFontFamily : NULL,
+ style, emSize, &layoutRect,
+ format ? format->nativeStringFormat : NULL));
+ }
+ Status AddString(const WCHAR *string, INT length,
+ const FontFamily *family, INT style, REAL emSize,
+ const Point& origin, const StringFormat *format)
+ {
+ Rect layoutRect(origin, Size(0, 0));
+ return updateStatus(DllExports::GdipAddPathStringI(nativePath,
+ string, length,
+ family ? family->nativeFontFamily : NULL,
+ style, emSize, &layoutRect,
+ format ? format->nativeStringFormat : NULL));
+ }
+ Status AddString(const WCHAR *string, INT length,
+ const FontFamily *family, INT style, REAL emSize,
+ const RectF& layoutRect, const StringFormat *format)
+ {
+ return updateStatus(DllExports::GdipAddPathString(nativePath,
+ string, length,
+ family ? family->nativeFontFamily : NULL,
+ style, emSize, &layoutRect,
+ format ? format->nativeStringFormat : NULL));
+ }
+ Status AddString(const WCHAR *string, INT length,
+ const FontFamily *family, INT style, REAL emSize,
+ const Rect& layoutRect, const StringFormat *format)
+ {
+ return updateStatus(DllExports::GdipAddPathStringI(nativePath,
+ string, length,
+ family ? family->nativeFontFamily : NULL,
+ style, emSize, &layoutRect,
+ format ? format->nativeStringFormat : NULL));
+ }
+ Status ClearMarkers()
+ {
+ return updateStatus(DllExports::GdipClearPathMarkers(
+ nativePath));
+ }
+ Status CloseAllFigures()
+ {
+ return updateStatus(DllExports::GdipClosePathFigures(
+ nativePath));
+ }
+ Status CloseFigure()
+ {
+ return updateStatus(DllExports::GdipClosePathFigure(
+ nativePath));
+ }
+ Status Flatten(const Matrix *matrix = NULL,
+ REAL flatness = FlatnessDefault)
+ {
+ return updateStatus(DllExports::GdipFlattenPath(nativePath,
+ matrix ? matrix->nativeMatrix : NULL,
+ flatness));
+ }
+ Status GetBounds(RectF *bounds, const Matrix *matrix = NULL,
+ const Pen *pen = NULL) const
+ {
+ return updateStatus(DllExports::GdipGetPathWorldBounds(
+ nativePath, bounds,
+ matrix ? matrix->nativeMatrix : NULL,
+ pen ? pen->nativePen : NULL));
+ }
+ Status GetBounds(Rect *bounds, const Matrix *matrix = NULL,
+ const Pen *pen = NULL) const
+ {
+ return updateStatus(DllExports::GdipGetPathWorldBoundsI(
+ nativePath, bounds,
+ matrix ? matrix->nativeMatrix : NULL,
+ pen ? pen->nativePen : NULL));
+ }
+ FillMode GetFillMode() const
+ {
+ FillMode result = FillModeAlternate;
+ updateStatus(DllExports::GdipGetPathFillMode(nativePath,
+ &result));
+ return result;
+ }
+ Status GetLastPoint(PointF *lastPoint) const
+ {
+ return updateStatus(DllExports::GdipGetPathLastPoint(
+ nativePath, lastPoint));
+ }
+ Status GetLastStatus() const
+ {
+ Status result = lastStatus;
+ lastStatus = Ok;
+ return result;
+ }
+ Status GetPathData(PathData *pathData) const
+ {
+ if (!pathData) return lastStatus = InvalidParameter;
+
+ Status status;
+ INT count;
+
+ status = updateStatus(DllExports::GdipGetPointCount(
+ nativePath, &count));
+ if (status != Ok) return status;
+
+ status = updateStatus(pathData->AllocateArrays(count));
+ if (status != Ok) return status;
+
+ return updateStatus(DllExports::GdipGetPathData(
+ nativePath, (GpPathData*) pathData));
+ }
+ Status GetPathPoints(PointF *points, INT count) const
+ {
+ return updateStatus(DllExports::GdipGetPathPoints(nativePath,
+ points, count));
+ }
+ Status GetPathPoints(Point *points, INT count) const
+ {
+ return updateStatus(DllExports::GdipGetPathPointsI(nativePath,
+ points, count));
+ }
+ Status GetPathTypes(BYTE *types, INT count) const
+ {
+ return updateStatus(DllExports::GdipGetPathTypes(nativePath,
+ types, count));
+ }
+ INT GetPointCount() const
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipGetPointCount(nativePath,
+ &result));
+ return result;
+ }
+ BOOL IsOutlineVisible(REAL x, REAL y, const Pen *pen,
+ const Graphics *g = NULL) const;
+ BOOL IsOutlineVisible(INT x, INT y, const Pen *pen,
+ const Graphics *g = NULL) const;
+ BOOL IsOutlineVisible(const PointF& point, const Pen *pen,
+ const Graphics *g = NULL) const;
+ BOOL IsOutlineVisible(const Point& point, const Pen *pen,
+ const Graphics *g = NULL) const;
+ BOOL IsVisible(REAL x, REAL y, const Graphics *g = NULL) const;
+ BOOL IsVisible(INT x, INT y, const Graphics *g = NULL) const;
+ BOOL IsVisible(const PointF& point, const Graphics *g = NULL) const;
+ BOOL IsVisible(const Point& point, const Graphics *g = NULL) const;
+ Status Outline(const Matrix *matrix = NULL,
+ REAL flatness = FlatnessDefault)
+ {
+ return updateStatus(DllExports::GdipWindingModeOutline(
+ nativePath,
+ matrix ? matrix->nativeMatrix : NULL,
+ flatness));
+ }
+ Status Reset()
+ {
+ return updateStatus(DllExports::GdipResetPath(nativePath));
+ }
+ Status Reverse()
+ {
+ return updateStatus(DllExports::GdipReversePath(nativePath));
+ }
+ Status SetFillMode(FillMode fillMode)
+ {
+ return updateStatus(DllExports::GdipSetPathFillMode(
+ nativePath, fillMode));
+ }
+ Status SetMarker()
+ {
+ return updateStatus(DllExports::GdipSetPathMarker(nativePath));
+ }
+ Status StartFigure()
+ {
+ return updateStatus(DllExports::GdipStartPathFigure(
+ nativePath));
+ }
+ Status Transform(const Matrix *matrix)
+ {
+ return updateStatus(DllExports::GdipTransformPath(
+ nativePath,
+ matrix ? matrix->nativeMatrix : NULL));
+ }
+ Status Warp(const PointF *destPoints, INT count, const RectF& srcRect,
+ const Matrix *matrix = NULL,
+ WarpMode warpMode = WarpModePerspective,
+ REAL flatness = FlatnessDefault)
+ {
+ return updateStatus(DllExports::GdipWarpPath(nativePath,
+ matrix ? matrix->nativeMatrix : NULL,
+ destPoints, count,
+ srcRect.X, srcRect.Y,
+ srcRect.Width, srcRect.Height,
+ warpMode, flatness));
+ }
+ Status Widen(const Pen *pen, const Matrix *matrix = NULL,
+ REAL flatness = FlatnessDefault)
+ {
+ return updateStatus(DllExports::GdipWidenPath(nativePath,
+ pen ? pen->nativePen : NULL,
+ matrix ? matrix->nativeMatrix : NULL,
+ flatness));
+ }
+
+private:
+ GraphicsPath(GpPath *path, Status status):
+ nativePath(path), lastStatus(status) {}
+ GraphicsPath(const GraphicsPath&);
+ GraphicsPath& operator=(const GraphicsPath&);
+
+ Status updateStatus(Status newStatus) const
+ {
+ if (newStatus != Ok) lastStatus = newStatus;
+ return newStatus;
+ }
+
+ GpPath *nativePath;
+ mutable Status lastStatus;
+};
+
+class GraphicsPathIterator: public GdiplusBase
+{
+public:
+ GraphicsPathIterator(GraphicsPath *path):
+ nativePathIterator(NULL), lastStatus(Ok)
+ {
+ lastStatus = DllExports::GdipCreatePathIter(
+ &nativePathIterator,
+ path ? path->nativePath : NULL);
+ }
+ ~GraphicsPathIterator()
+ {
+ DllExports::GdipDeletePathIter(nativePathIterator);
+ }
+
+ INT CopyData(PointF *points, BYTE *types, INT startIndex, INT endIndex)
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipPathIterCopyData(
+ nativePathIterator, &result,
+ points, types, startIndex, endIndex));
+ return result;
+ }
+ INT Enumerate(PointF *points, BYTE *types, INT count)
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipPathIterEnumerate(
+ nativePathIterator, &result,
+ points, types, count));
+ return result;
+ }
+ INT GetCount() const
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipPathIterGetCount(
+ nativePathIterator, &result));
+ return result;
+ }
+ Status GetLastStatus() const
+ {
+ Status result = lastStatus;
+ lastStatus = Ok;
+ return result;
+ }
+ INT GetSubpathCount() const
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipPathIterGetSubpathCount(
+ nativePathIterator, &result));
+ return result;
+ }
+ BOOL HasCurve() const
+ {
+ BOOL result = FALSE;
+ updateStatus(DllExports::GdipPathIterHasCurve(
+ nativePathIterator, &result));
+ return result;
+ }
+ INT NextMarker(INT *startIndex, INT *endIndex)
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipPathIterNextMarker(
+ nativePathIterator, &result,
+ startIndex, endIndex));
+ return result;
+ }
+ INT NextMarker(GraphicsPath *path)
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipPathIterNextMarkerPath(
+ nativePathIterator, &result,
+ path ? path->nativePath : NULL));
+ return result;
+ }
+ INT NextPathType(BYTE *pathType, INT *startIndex, INT *endIndex)
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipPathIterNextPathType(
+ nativePathIterator, &result,
+ pathType, startIndex, endIndex));
+ return result;
+ }
+ INT NextSubpath(INT *startIndex, INT *endIndex, BOOL *isClosed)
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipPathIterNextSubpath(
+ nativePathIterator, &result,
+ startIndex, endIndex, isClosed));
+ return result;
+ }
+ INT NextSubpath(GraphicsPath *path, BOOL *isClosed)
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipPathIterNextSubpathPath(
+ nativePathIterator, &result,
+ path ? path->nativePath : NULL, isClosed));
+ return result;
+ }
+ VOID Rewind()
+ {
+ updateStatus(DllExports::GdipPathIterRewind(
+ nativePathIterator));
+ }
+
+private:
+ GraphicsPathIterator(GpPathIterator *pathIterator, Status status):
+ nativePathIterator(pathIterator), lastStatus(status) {}
+ GraphicsPathIterator(const GraphicsPathIterator&);
+ GraphicsPathIterator& operator=(const GraphicsPathIterator&);
+
+ Status updateStatus(Status newStatus) const
+ {
+ if (newStatus != Ok) lastStatus = newStatus;
+ return newStatus;
+ }
+
+ GpPathIterator *nativePathIterator;
+ mutable Status lastStatus;
+};
+
+class PathGradientBrush: public Brush
+{
+public:
+ PathGradientBrush(const PointF *points, INT count,
+ WrapMode wrapMode = WrapModeClamp)
+ {
+ GpPathGradient *nativePathGradient = NULL;
+ lastStatus = DllExports::GdipCreatePathGradient(
+ points, count, wrapMode, &nativePathGradient);
+ nativeBrush = nativePathGradient;
+ }
+ PathGradientBrush(const Point *points, INT count,
+ WrapMode wrapMode = WrapModeClamp)
+ {
+ GpPathGradient *nativePathGradient = NULL;
+ lastStatus = DllExports::GdipCreatePathGradientI(
+ points, count, wrapMode, &nativePathGradient);
+ nativeBrush = nativePathGradient;
+ }
+ PathGradientBrush(const GraphicsPath *path)
+ {
+ GpPathGradient *nativePathGradient = NULL;
+ lastStatus = DllExports::GdipCreatePathGradientFromPath(
+ path ? path->nativePath : NULL,
+ &nativePathGradient);
+ nativeBrush = nativePathGradient;
+ }
+ virtual PathGradientBrush *Clone() const
+ {
+ GpBrush *cloneBrush = NULL;
+ Status status = updateStatus(DllExports::GdipCloneBrush(
+ nativeBrush, &cloneBrush));
+ if (status == Ok) {
+ PathGradientBrush *result =
+ new PathGradientBrush(cloneBrush, lastStatus);
+ if (!result) {
+ DllExports::GdipDeleteBrush(cloneBrush);
+ updateStatus(OutOfMemory);
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ Status GetBlend(REAL *blendFactors, REAL *blendPositions,
+ INT count) const
+ {
+ return updateStatus(DllExports::GdipGetPathGradientBlend(
+ (GpPathGradient*) nativeBrush,
+ blendFactors, blendPositions, count));
+ }
+ INT GetBlendCount() const
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipGetPathGradientBlendCount(
+ (GpPathGradient*) nativeBrush, &result));
+ return result;
+ }
+ Status GetCenterColor(Color *color) const
+ {
+ return updateStatus(DllExports::GdipGetPathGradientCenterColor(
+ (GpPathGradient*) nativeBrush,
+ color ? &color->Value : NULL));
+ }
+ Status GetCenterPoint(PointF *point) const
+ {
+ return updateStatus(DllExports::GdipGetPathGradientCenterPoint(
+ (GpPathGradient*) nativeBrush, point));
+ }
+ Status GetCenterPoint(Point *point) const
+ {
+ return updateStatus(DllExports::GdipGetPathGradientCenterPointI(
+ (GpPathGradient*) nativeBrush, point));
+ }
+ Status GetFocusScales(REAL *xScale, REAL *yScale) const
+ {
+ return updateStatus(DllExports::GdipGetPathGradientFocusScales(
+ (GpPathGradient*) nativeBrush, xScale, yScale));
+ }
+ BOOL GetGammaCorrection() const
+ {
+ BOOL result = FALSE;
+ updateStatus(DllExports::GdipGetPathGradientGammaCorrection(
+ (GpPathGradient*) nativeBrush, &result));
+ return result;
+ }
+ //Status GetGraphicsPath(GraphicsPath *path) const
+ //{
+ // // TODO: implement PathGradientBrush::GetGraphicsPath
+ // return updateStatus(NotImplemented);
+ //}
+ INT GetInterpolationColorCount() const
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipGetPathGradientPresetBlendCount(
+ (GpPathGradient*) nativeBrush, &result));
+ return result;
+ }
+ Status GetInterpolationColors(Color *presetColors,
+ REAL *blendPositions, INT count) const
+ {
+ if (!presetColors || count <= 0)
+ return lastStatus = InvalidParameter;
+
+ ARGB *presetArgb =
+ (ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB));
+ if (!presetArgb)
+ return lastStatus = OutOfMemory;
+
+ Status status = updateStatus(DllExports::GdipGetPathGradientPresetBlend(
+ (GpPathGradient*) nativeBrush,
+ presetArgb, blendPositions, count));
+ for (INT i = 0; i < count; ++i) {
+ presetColors[i].SetValue(presetArgb[i]);
+ }
+ DllExports::GdipFree((void*) presetArgb);
+ return status;
+ }
+ INT GetPointCount() const
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipGetPathGradientPointCount(
+ (GpPathGradient*) nativeBrush, &result));
+ return result;
+ }
+ Status GetRectangle(RectF *rect) const
+ {
+ return updateStatus(DllExports::GdipGetPathGradientRect(
+ (GpPathGradient*) nativeBrush, rect));
+ }
+ Status GetRectangle(Rect *rect) const
+ {
+ return updateStatus(DllExports::GdipGetPathGradientRectI(
+ (GpPathGradient*) nativeBrush, rect));
+ }
+ INT GetSurroundColorCount() const
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipGetPathGradientSurroundColorCount(
+ (GpPathGradient*) nativeBrush, &result));
+ return result;
+ }
+ Status GetSurroundColors(Color *colors, INT *count)
+ {
+ if (!colors || !count || *count <= 0)
+ return lastStatus = InvalidParameter;
+
+ ARGB *colorsArgb =
+ (ARGB*) DllExports::GdipAlloc(*count * sizeof(ARGB));
+ if (!colorsArgb)
+ return lastStatus = OutOfMemory;
+
+ Status status = updateStatus(DllExports::GdipGetPathGradientSurroundColorsWithCount(
+ (GpPathGradient*) nativeBrush,
+ colorsArgb, count));
+ for (INT i = 0; i < *count; ++i) {
+ colors[i].SetValue(colorsArgb[i]);
+ }
+ DllExports::GdipFree((void*) colorsArgb);
+ return status;
+ }
+ Status GetTransform(Matrix *matrix) const
+ {
+ return updateStatus(DllExports::GdipGetPathGradientTransform(
+ (GpPathGradient*) nativeBrush,
+ matrix ? matrix->nativeMatrix : NULL));
+ }
+ WrapMode GetWrapMode() const
+ {
+ WrapMode result = WrapModeTile;
+ updateStatus(DllExports::GdipGetPathGradientWrapMode(
+ (GpPathGradient*) nativeBrush, &result));
+ return result;
+ }
+ Status MultiplyTransform(const Matrix *matrix,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipMultiplyPathGradientTransform(
+ (GpPathGradient*) nativeBrush,
+ matrix ? matrix->nativeMatrix : NULL, order));
+ }
+ Status ResetTransform()
+ {
+ return updateStatus(DllExports::GdipResetPathGradientTransform(
+ (GpPathGradient*) nativeBrush));
+ }
+ Status RotateTransform(REAL angle,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipRotatePathGradientTransform(
+ (GpPathGradient*) nativeBrush, angle, order));
+ }
+ Status ScaleTransform(REAL sx, REAL sy,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipScalePathGradientTransform(
+ (GpPathGradient*) nativeBrush, sx, sy, order));
+ }
+ Status SetBlend(REAL *blendFactors, REAL *blendPositions, INT count)
+ {
+ return updateStatus(DllExports::GdipSetPathGradientBlend(
+ (GpPathGradient*) nativeBrush,
+ blendFactors, blendPositions, count));
+ }
+ Status SetBlendBellShape(REAL focus, REAL scale = 1.0f)
+ {
+ return updateStatus(DllExports::GdipSetPathGradientSigmaBlend(
+ (GpPathGradient*) nativeBrush, focus, scale));
+ }
+ Status SetBlendTriangularShape(REAL focus, REAL scale = 1.0f)
+ {
+ return updateStatus(DllExports::GdipSetPathGradientLinearBlend(
+ (GpPathGradient*) nativeBrush, focus, scale));
+ }
+ Status SetCenterColor(const Color& color)
+ {
+ return updateStatus(DllExports::GdipSetPathGradientCenterColor(
+ (GpPathGradient*) nativeBrush,
+ color.GetValue()));
+ }
+ Status SetCenterPoint(const PointF& point)
+ {
+ return updateStatus(DllExports::GdipSetPathGradientCenterPoint(
+ (GpPathGradient*) nativeBrush, &point));
+ }
+ Status SetCenterPoint(const Point& point)
+ {
+ return updateStatus(DllExports::GdipSetPathGradientCenterPointI(
+ (GpPathGradient*) nativeBrush, &point));
+ }
+ Status SetFocusScales(REAL xScale, REAL yScale)
+ {
+ return updateStatus(DllExports::GdipSetPathGradientFocusScales(
+ (GpPathGradient*) nativeBrush, xScale, yScale));
+ }
+ Status SetGammaCorrection(BOOL useGammaCorrection)
+ {
+ return updateStatus(DllExports::GdipSetPathGradientGammaCorrection(
+ (GpPathGradient*) nativeBrush,
+ useGammaCorrection));
+ }
+ //Status SetGraphicsPath(const GraphicsPath *path)
+ //{
+ // // TODO: implement PathGradientBrush::SetGraphicsPath
+ // return updateStatus(NotImplemented);
+ //}
+ Status SetInterpolationColors(const Color *presetColors,
+ REAL *blendPositions, INT count)
+ {
+ if (!presetColors || count <= 0)
+ return lastStatus = InvalidParameter;
+
+ ARGB *presetArgb =
+ (ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB));
+ if (!presetArgb)
+ return lastStatus = OutOfMemory;
+ for (INT i = 0; i < count; ++i) {
+ presetArgb[i] = presetColors[i].GetValue();
+ }
+
+ Status status = updateStatus(DllExports::GdipSetPathGradientPresetBlend(
+ (GpPathGradient*) nativeBrush,
+ presetArgb, blendPositions, count));
+ DllExports::GdipFree((void*) presetArgb);
+ return status;
+ }
+ Status SetSurroundColors(const Color *colors, INT *count)
+ {
+ if (!colors || !count || *count <= 0)
+ return lastStatus = InvalidParameter;
+
+ ARGB *colorsArgb =
+ (ARGB*) DllExports::GdipAlloc(*count * sizeof(ARGB));
+ if (!colorsArgb)
+ return lastStatus = OutOfMemory;
+ for (INT i = 0; i < *count; ++i) {
+ colorsArgb[i] = colors[i].GetValue();
+ }
+
+ Status status = updateStatus(DllExports::GdipSetPathGradientSurroundColorsWithCount(
+ (GpPathGradient*) nativeBrush,
+ colorsArgb, count));
+ DllExports::GdipFree((void*) colorsArgb);
+ return status;
+ }
+ Status SetTransform(const Matrix *matrix)
+ {
+ return updateStatus(DllExports::GdipSetPathGradientTransform(
+ (GpPathGradient*) nativeBrush,
+ matrix ? matrix->nativeMatrix : NULL));
+ }
+ Status SetWrapMode(WrapMode wrapMode)
+ {
+ return updateStatus(DllExports::GdipSetPathGradientWrapMode(
+ (GpPathGradient*) nativeBrush, wrapMode));
+ }
+ Status TranslateTransform(REAL dx, REAL dy,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipTranslatePathGradientTransform(
+ (GpPathGradient*) nativeBrush, dx, dy, order));
+ }
+
+private:
+ PathGradientBrush(GpBrush *brush, Status status): Brush(brush, status) {}
+ PathGradientBrush(const PathGradientBrush&);
+ PathGradientBrush& operator=(const PathGradientBrush&);
+};
+
+
+
+#endif /* __GDIPLUS_PATH_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_PEN_H
+#define __GDIPLUS_PEN_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifndef __cplusplus
+#error "A C++ compiler is required to include gdipluspen.h."
+#endif
+
+class Pen: public GdiplusBase
+{
+ friend class Graphics;
+ friend class GraphicsPath;
+
+public:
+ Pen(const Color& color, REAL width = 1.0f):
+ nativePen(NULL), lastStatus(Ok)
+ {
+ lastStatus = DllExports::GdipCreatePen1(
+ color.GetValue(), width, UnitWorld,
+ &nativePen);
+ }
+ Pen(const Brush *brush, REAL width = 1.0f):
+ nativePen(NULL), lastStatus(Ok)
+ {
+ lastStatus = DllExports::GdipCreatePen2(
+ brush ? brush->nativeBrush : NULL,
+ width, UnitWorld, &nativePen);
+ }
+ ~Pen()
+ {
+ DllExports::GdipDeletePen(nativePen);
+ }
+ Pen* Clone() const
+ {
+ GpPen *clonePen = NULL;
+ Status status = updateStatus(DllExports::GdipClonePen(
+ nativePen, &clonePen));
+ if (status == Ok) {
+ Pen *result = new Pen(clonePen, lastStatus);
+ if (!result) {
+ DllExports::GdipDeletePen(clonePen);
+ lastStatus = OutOfMemory;
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ PenAlignment GetAlignment() const
+ {
+ PenAlignment result = PenAlignmentCenter;
+ updateStatus(DllExports::GdipGetPenMode(nativePen, &result));
+ return result;
+ }
+ // TODO: implement Pen::GetBrush()
+ //Brush *GetBrush() const
+ //{
+ // // where is the pen brush allocated (static,member,new,other)?
+ // // GdipGetPenBrushFill just returns a GpBrush*
+ // updateStatus(NotImplemented);
+ // return NULL;
+ //}
+ Status GetColor(Color *color) const
+ {
+ return updateStatus(DllExports::GdipGetPenColor(
+ nativePen, color ? &color->Value : NULL));
+ }
+ Status GetCompoundArray(REAL *compoundArray, INT count) const
+ {
+ return updateStatus(DllExports::GdipGetPenCompoundArray(
+ nativePen, compoundArray, count));
+ }
+ INT GetCompoundArrayCount() const
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipGetPenCompoundCount(
+ nativePen, &result));
+ return result;
+ }
+ Status GetCustomEndCap(CustomLineCap *customCap) const
+ {
+ if (!customCap) return lastStatus = InvalidParameter;
+ // FIXME: do we need to call GdipDeleteCustomLineCap first?
+ return updateStatus(DllExports::GdipGetPenCustomEndCap(
+ nativePen, &customCap->nativeCustomLineCap));
+ }
+ Status GetCustomStartCap(CustomLineCap *customCap) const
+ {
+ if (!customCap) return lastStatus = InvalidParameter;
+ // FIXME: do we need to call GdipDeleteCustomLineCap first?
+ return updateStatus(DllExports::GdipGetPenCustomStartCap(
+ nativePen, &customCap->nativeCustomLineCap));
+ }
+ DashCap GetDashCap() const
+ {
+ DashCap result = DashCapFlat;
+ updateStatus(DllExports::GdipGetPenDashCap197819(
+ nativePen, &result));
+ return result;
+ }
+ REAL GetDashOffset() const
+ {
+ REAL result = 0.0f;
+ updateStatus(DllExports::GdipGetPenDashOffset(
+ nativePen, &result));
+ return result;
+ }
+ Status GetDashPattern(REAL *dashArray, INT count) const
+ {
+ return updateStatus(DllExports::GdipGetPenDashArray(
+ nativePen, dashArray, count));
+ }
+ INT GetDashPatternCount() const
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipGetPenDashCount(
+ nativePen, &result));
+ return result;
+ }
+ DashStyle GetDashStyle() const
+ {
+ DashStyle result = DashStyleSolid;
+ updateStatus(DllExports::GdipGetPenDashStyle(
+ nativePen, &result));
+ return result;
+ }
+ LineCap GetEndCap() const
+ {
+ LineCap result = LineCapFlat;
+ updateStatus(DllExports::GdipGetPenEndCap(nativePen, &result));
+ return result;
+ }
+ Status GetLastStatus() const
+ {
+ Status result = lastStatus;
+ lastStatus = Ok;
+ return result;
+ }
+ LineJoin GetLineJoin() const
+ {
+ LineJoin result = LineJoinMiter;
+ updateStatus(DllExports::GdipGetPenLineJoin(
+ nativePen, &result));
+ return result;
+ }
+ REAL GetMiterLimit() const
+ {
+ REAL result = 10.0f;
+ updateStatus(DllExports::GdipGetPenMiterLimit(
+ nativePen, &result));
+ return result;
+ }
+ PenType GetPenType() const
+ {
+ PenType result = PenTypeUnknown;
+ updateStatus(DllExports::GdipGetPenFillType(
+ nativePen, &result));
+ return result;
+ }
+ LineCap GetStartCap() const
+ {
+ LineCap result = LineCapFlat;
+ updateStatus(DllExports::GdipGetPenStartCap(
+ nativePen, &result));
+ return result;
+ }
+ Status GetTransform(Matrix *matrix) const
+ {
+ return updateStatus(DllExports::GdipGetPenTransform(
+ nativePen,
+ matrix ? matrix->nativeMatrix : NULL));
+ }
+ REAL GetWidth() const
+ {
+ REAL result = 1.0f;
+ updateStatus(DllExports::GdipGetPenWidth(nativePen, &result));
+ return result;
+ }
+ Status MultiplyTransform(const Matrix *matrix,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipMultiplyPenTransform(
+ nativePen,
+ matrix ? matrix->nativeMatrix : NULL, order));
+ }
+ Status ResetTransform()
+ {
+ return updateStatus(DllExports::GdipResetPenTransform(
+ nativePen));
+ }
+ Status RotateTransform(REAL angle,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipRotatePenTransform(
+ nativePen, angle, order));
+ }
+ Status ScaleTransform(REAL sx, REAL sy,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipScalePenTransform(
+ nativePen, sx, sy, order));
+ }
+ Status SetAlignment(PenAlignment penAlignment)
+ {
+ return updateStatus(DllExports::GdipSetPenMode(
+ nativePen, penAlignment));
+ }
+ Status SetBrush(const Brush *brush)
+ {
+ return updateStatus(DllExports::GdipSetPenBrushFill(
+ nativePen, brush ? brush->nativeBrush : NULL));
+ }
+ Status SetColor(const Color& color)
+ {
+ return updateStatus(DllExports::GdipSetPenColor(
+ nativePen, color.GetValue()));
+ }
+ Status SetCompoundArray(const REAL *compoundArray, INT count)
+ {
+ return updateStatus(DllExports::GdipSetPenCompoundArray(
+ nativePen, compoundArray, count));
+ }
+ Status SetCustomEndCap(const CustomLineCap *customCap)
+ {
+ return updateStatus(DllExports::GdipSetPenCustomEndCap(
+ nativePen,
+ customCap ? customCap->nativeCustomLineCap : NULL));
+ }
+ Status SetCustomStartCap(const CustomLineCap *customCap)
+ {
+ return updateStatus(DllExports::GdipSetPenCustomStartCap(
+ nativePen,
+ customCap ? customCap->nativeCustomLineCap : NULL));
+ }
+ Status SetDashCap(DashCap dashCap)
+ {
+ return updateStatus(DllExports::GdipSetPenDashCap197819(
+ nativePen, dashCap));
+ }
+ Status SetDashOffset(REAL dashOffset)
+ {
+ return updateStatus(DllExports::GdipSetPenDashOffset(
+ nativePen, dashOffset));
+ }
+ Status SetDashPattern(const REAL *dashArray, INT count)
+ {
+ return updateStatus(DllExports::GdipSetPenDashArray(
+ nativePen, dashArray, count));
+ }
+ Status SetDashStyle(DashStyle dashStyle)
+ {
+ return updateStatus(DllExports::GdipSetPenDashStyle(
+ nativePen, dashStyle));
+ }
+ Status SetEndCap(LineCap endCap)
+ {
+ return updateStatus(DllExports::GdipSetPenEndCap(
+ nativePen, endCap));
+ }
+ Status SetLineCap(LineCap startCap, LineCap endCap, DashCap dashCap)
+ {
+ return updateStatus(DllExports::GdipSetPenLineCap197819(
+ nativePen, startCap, endCap, dashCap));
+ }
+ Status SetLineJoin(LineJoin lineJoin)
+ {
+ return updateStatus(DllExports::GdipSetPenLineJoin(
+ nativePen, lineJoin));
+ }
+ Status SetMiterLimit(REAL miterLimit)
+ {
+ return updateStatus(DllExports::GdipSetPenMiterLimit(
+ nativePen, miterLimit));
+ }
+ Status SetStartCap(LineCap startCap)
+ {
+ return updateStatus(DllExports::GdipSetPenStartCap(
+ nativePen, startCap));
+ }
+ Status SetTransform(const Matrix *matrix)
+ {
+ return updateStatus(DllExports::GdipSetPenTransform(
+ nativePen,
+ matrix ? matrix->nativeMatrix : NULL));
+ }
+ Status SetWidth(REAL width)
+ {
+ return updateStatus(DllExports::GdipSetPenWidth(
+ nativePen, width));
+ }
+ Status TranslateTransform(REAL dx, REAL dy,
+ MatrixOrder order = MatrixOrderPrepend)
+ {
+ return updateStatus(DllExports::GdipTranslatePenTransform(
+ nativePen, dx, dy, order));
+ }
+
+private:
+ Pen(GpPen *pen, Status status): nativePen(pen), lastStatus(status) {}
+ Pen(const Pen& pen);
+ Pen& operator=(const Pen&);
+
+ Status updateStatus(Status newStatus) const
+ {
+ if (newStatus != Ok) lastStatus = newStatus;
+ return newStatus;
+ }
+
+ GpPen *nativePen;
+ mutable Status lastStatus;
+};
+
+#endif /* __GDIPLUS_PEN_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_PIXELFORMATS_H
+#define __GDIPLUS_PIXELFORMATS_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+typedef DWORD ARGB;
+typedef INT PixelFormat;
+
+#define PixelFormatIndexed ((PixelFormat) 0x00010000)
+#define PixelFormatGDI ((PixelFormat) 0x00020000)
+#define PixelFormatAlpha ((PixelFormat) 0x00040000)
+#define PixelFormatPAlpha ((PixelFormat) 0x00080000)
+#define PixelFormatExtended ((PixelFormat) 0x00100000)
+#define PixelFormatCanonical ((PixelFormat) 0x00200000)
+#define PixelFormatUndefined ((PixelFormat) 0)
+#define PixelFormatDontCare ((PixelFormat) 0)
+#define PixelFormat1bppIndexed ((PixelFormat) \
+ (1 | (1<<8) | PixelFormatIndexed | PixelFormatGDI))
+#define PixelFormat4bppIndexed ((PixelFormat) \
+ (2 | (4<<8) | PixelFormatIndexed | PixelFormatGDI))
+#define PixelFormat8bppIndexed ((PixelFormat) \
+ (3 | (8<<8) | PixelFormatIndexed | PixelFormatGDI))
+#define PixelFormat16bppGrayScale ((PixelFormat) \
+ (4 | (16<<8) | PixelFormatExtended))
+#define PixelFormat16bppRGB555 ((PixelFormat) \
+ (5 | (16<<8) | PixelFormatGDI))
+#define PixelFormat16bppRGB565 ((PixelFormat) \
+ (6 | (16<<8) | PixelFormatGDI))
+#define PixelFormat16bppARGB1555 ((PixelFormat) \
+ (7 | (16<<8) | PixelFormatAlpha | PixelFormatGDI))
+#define PixelFormat24bppRGB ((PixelFormat) \
+ (8 | (24<<8) | PixelFormatGDI))
+#define PixelFormat32bppRGB ((PixelFormat) \
+ (9 | (32<<8) | PixelFormatGDI))
+#define PixelFormat32bppARGB ((PixelFormat) \
+ (10 | (32<<8) | PixelFormatAlpha | PixelFormatGDI | PixelFormatCanonical))
+#define PixelFormat32bppPARGB ((PixelFormat) \
+ (11 | (32<<8) | PixelFormatAlpha | PixelFormatPAlpha | PixelFormatGDI))
+#define PixelFormat48bppRGB ((PixelFormat) \
+ (12 | (48<<8) | PixelFormatExtended))
+#define PixelFormat64bppARGB ((PixelFormat) \
+ (13 | (64<<8) | PixelFormatAlpha | PixelFormatCanonical | PixelFormatExtended))
+#define PixelFormat64bppPARGB ((PixelFormat) \
+ (14 | (64<<8) | PixelFormatAlpha | PixelFormatPAlpha | PixelFormatExtended))
+#define PixelFormatMax ((PixelFormat) 15)
+
+typedef enum PaletteFlags {
+ PaletteFlagsHasAlpha = 1,
+ PaletteFlagsGrayScale = 2,
+ PaletteFlagsHalftone = 4
+} PaletteFlags;
+
+typedef enum PaletteType {
+ PaletteTypeCustom = 0,
+ PaletteTypeOptimal = 1,
+ PaletteTypeFixedBW = 2,
+ PaletteTypeFixedHalftone8 = 3,
+ PaletteTypeFixedHalftone27 = 4,
+ PaletteTypeFixedHalftone64 = 5,
+ PaletteTypeFixedHalftone125 = 6,
+ PaletteTypeFixedHalftone216 = 7,
+ PaletteTypeFixedHalftone252 = 8,
+ PaletteTypeFixedHalftone256 = 9
+} PaletteType;
+
+typedef struct ColorPalette {
+ UINT Flags;
+ UINT Count;
+ ARGB Entries[1];
+} ColorPalette;
+
+static __inline__ UINT GetPixelFormatSize(PixelFormat pixfmt)
+{
+ return (((UINT) pixfmt) & 0xff00U) >> 8;
+}
+
+static __inline__ BOOL IsAlphaPixelFormat(PixelFormat pixfmt)
+{
+ return (pixfmt & PixelFormatAlpha) != 0;
+}
+
+static __inline__ BOOL IsCanonicalPixelFormat(PixelFormat pixfmt)
+{
+ return (pixfmt & PixelFormatCanonical) != 0;
+}
+
+static __inline__ BOOL IsExtendedPixelFormat(PixelFormat pixfmt)
+{
+ return (pixfmt & PixelFormatExtended) != 0;
+}
+
+static __inline__ BOOL IsIndexedPixelFormat(PixelFormat pixfmt)
+{
+ return (pixfmt & PixelFormatIndexed) != 0;
+}
+
+#endif /* __GDIPLUS_PIXELFORMATS_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_STRINGFORMAT_H
+#define __GDIPLUS_STRINGFORMAT_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifndef __cplusplus
+#error "A C++ compiler is required to include gdiplusstringformat.h."
+#endif
+
+class StringFormat: public GdiplusBase
+{
+ friend class Graphics;
+ friend class GraphicsPath;
+
+public:
+ static const StringFormat* GenericDefault();
+ static const StringFormat* GenericTypographic();
+
+ StringFormat(INT formatFlags = 0, LANGID language = LANG_NEUTRAL):
+ nativeStringFormat(NULL), lastStatus(Ok)
+ {
+ lastStatus = DllExports::GdipCreateStringFormat(
+ formatFlags, language, &nativeStringFormat);
+ }
+ StringFormat(const StringFormat *format):
+ nativeStringFormat(NULL), lastStatus(Ok)
+ {
+ lastStatus = DllExports::GdipCloneStringFormat(
+ format ? format->nativeStringFormat : NULL,
+ &nativeStringFormat);
+ }
+ ~StringFormat()
+ {
+ DllExports::GdipDeleteStringFormat(nativeStringFormat);
+ }
+ StringFormat* Clone() const
+ {
+ GpStringFormat *cloneStringFormat = NULL;
+ Status status = updateStatus(DllExports::GdipCloneStringFormat(
+ nativeStringFormat, &cloneStringFormat));
+ if (status == Ok) {
+ StringFormat *result = new StringFormat(
+ cloneStringFormat, lastStatus);
+ if (!result) {
+ DllExports::GdipDeleteStringFormat(cloneStringFormat);
+ lastStatus = OutOfMemory;
+ }
+ return result;
+ } else {
+ return NULL;
+ }
+ }
+
+ StringAlignment GetAlignment() const
+ {
+ StringAlignment result = StringAlignmentNear;
+ updateStatus(DllExports::GdipGetStringFormatAlign(
+ nativeStringFormat, &result));
+ return result;
+ }
+ LANGID GetDigitSubstitutionLanguage() const
+ {
+ LANGID result = 0;
+ StringDigitSubstitute method;
+ updateStatus(DllExports::GdipGetStringFormatDigitSubstitution(
+ nativeStringFormat, &result, &method));
+ return result;
+ }
+ StringDigitSubstitute GetDigitSubstitutionMethod() const
+ {
+ LANGID language;
+ StringDigitSubstitute result = StringDigitSubstituteUser;
+ updateStatus(DllExports::GdipGetStringFormatDigitSubstitution(
+ nativeStringFormat, &language, &result));
+ return result;
+ }
+ INT GetFormatFlags() const
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipGetStringFormatFlags(
+ nativeStringFormat, &result));
+ return result;
+ }
+ HotkeyPrefix GetHotkeyPrefix() const
+ {
+ HotkeyPrefix result = HotkeyPrefixNone;
+ updateStatus(DllExports::GdipGetStringFormatHotkeyPrefix(
+ nativeStringFormat, (INT*) &result));
+ return result;
+ }
+ Status GetLastStatus() const
+ {
+ Status result = lastStatus;
+ lastStatus = Ok;
+ return result;
+ }
+ StringAlignment GetLineAlignment() const
+ {
+ StringAlignment result = StringAlignmentNear;
+ updateStatus(DllExports::GdipGetStringFormatLineAlign(
+ nativeStringFormat, &result));
+ return result;
+ }
+ INT GetMeasurableCharacterRangeCount() const
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipGetStringFormatMeasurableCharacterRangeCount(
+ nativeStringFormat, &result));
+ return result;
+ }
+ INT GetTabStopCount() const
+ {
+ INT result = 0;
+ updateStatus(DllExports::GdipGetStringFormatTabStopCount(
+ nativeStringFormat, &result));
+ return result;
+ }
+ Status GetTabStops(INT count, REAL *firstTabOffset, REAL *tabStops)
+ {
+ return updateStatus(DllExports::GdipGetStringFormatTabStops(
+ nativeStringFormat, count,
+ firstTabOffset, tabStops));
+ }
+ StringTrimming GetTrimming() const
+ {
+ StringTrimming result = StringTrimmingNone;
+ updateStatus(DllExports::GdipGetStringFormatTrimming(
+ nativeStringFormat, &result));
+ return result;
+ }
+ Status SetAlignment(StringAlignment align)
+ {
+ return updateStatus(DllExports::GdipSetStringFormatAlign(
+ nativeStringFormat, align));
+ }
+ Status SetDigitSubstitution(LANGID language,
+ StringDigitSubstitute substitute)
+ {
+ return updateStatus(DllExports::GdipSetStringFormatDigitSubstitution(
+ nativeStringFormat, language, substitute));
+ }
+ Status SetFormatFlags(INT flags)
+ {
+ return updateStatus(DllExports::GdipSetStringFormatFlags(
+ nativeStringFormat, flags));
+ }
+ Status SetHotkeyPrefix(HotkeyPrefix hotkeyPrefix)
+ {
+ return updateStatus(DllExports::GdipSetStringFormatHotkeyPrefix(
+ nativeStringFormat, (INT) hotkeyPrefix));
+ }
+ Status SetLineAlignment(StringAlignment align)
+ {
+ return updateStatus(DllExports::GdipSetStringFormatLineAlign(
+ nativeStringFormat, align));
+ }
+ Status SetMeasurableCharacterRanges(INT rangeCount,
+ const CharacterRange *ranges)
+ {
+ return updateStatus(DllExports::GdipSetStringFormatMeasurableCharacterRanges(
+ nativeStringFormat, rangeCount, ranges));
+ }
+ Status SetTabStops(REAL firstTabOffset, INT count, const REAL *tabStops)
+ {
+ return updateStatus(DllExports::GdipSetStringFormatTabStops(
+ nativeStringFormat, firstTabOffset,
+ count, tabStops));
+ }
+ Status SetTrimming(StringTrimming trimming)
+ {
+ return updateStatus(DllExports::GdipSetStringFormatTrimming(
+ nativeStringFormat, trimming));
+ }
+
+private:
+ StringFormat(GpStringFormat *stringFormat, Status status):
+ nativeStringFormat(stringFormat), lastStatus(status) {}
+ StringFormat(const StringFormat&);
+ StringFormat& operator=(const StringFormat&);
+
+ Status updateStatus(Status newStatus) const
+ {
+ if (newStatus != Ok) lastStatus = newStatus;
+ return newStatus;
+ }
+
+ GpStringFormat *nativeStringFormat;
+ mutable Status lastStatus;
+};
+
+
+// FIXME: do StringFormat::GenericDefault() et al. need to be thread safe?
+// FIXME: maybe put this in gdiplus.c?
+
+extern "C" void *_GdipStringFormatCachedGenericDefault;
+extern "C" void *_GdipStringFormatCachedGenericTypographic;
+
+__inline__ const StringFormat* StringFormat::GenericDefault()
+{
+ if (!_GdipStringFormatCachedGenericDefault) {
+ GpStringFormat *nativeStringFormat = 0;
+ Status status = DllExports::GdipStringFormatGetGenericDefault(
+ &nativeStringFormat);
+ if (status == Ok && nativeStringFormat) {
+ _GdipStringFormatCachedGenericDefault = (void*)
+ new StringFormat(nativeStringFormat, Ok);
+ }
+ }
+ return (StringFormat*) _GdipStringFormatCachedGenericDefault;
+}
+
+__inline__ const StringFormat* StringFormat::GenericTypographic()
+{
+ if (!_GdipStringFormatCachedGenericTypographic) {
+ GpStringFormat *nativeStringFormat = 0;
+ Status status = DllExports::GdipStringFormatGetGenericTypographic(
+ &nativeStringFormat);
+ if (status == Ok && nativeStringFormat) {
+ _GdipStringFormatCachedGenericTypographic = (void*)
+ new StringFormat(nativeStringFormat, Ok);
+ }
+ }
+ return (StringFormat*) _GdipStringFormatCachedGenericTypographic;
+}
+
+
+
+#endif /* __GDIPLUS_STRINGFORMAT_H */
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 <markus@stber-koenig.de>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAIMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef __GDIPLUS_TYPES_H
+#define __GDIPLUS_TYPES_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#define WINGDIPAPI __stdcall
+#define GDIPCONST const
+
+typedef enum GpStatus {
+ Ok = 0,
+ GenericError = 1,
+ InvalidParameter = 2,
+ OutOfMemory = 3,
+ ObjectBusy = 4,
+ InsufficientBuffer = 5,
+ NotImplemented = 6,
+ Win32Error = 7,
+ WrongState = 8,
+ Aborted = 9,
+ FileNotFound = 10,
+ ValueOverflow = 11,
+ AccessDenied = 12,
+ UnknownImageFormat = 13,
+ FontFamilyNotFound = 14,
+ FontStyleNotFound = 15,
+ NotTrueTypeFont = 16,
+ UnsupportedGdiplusVersion = 17,
+ GdiplusNotInitialized = 18,
+ PropertyNotFound = 19,
+ PropertyNotSupported = 20,
+ ProfileNotFound = 21
+} GpStatus;
+
+#ifdef __cplusplus
+typedef GpStatus Status;
+#endif
+
+typedef struct Size {
+ INT Width;
+ INT Height;
+
+ #ifdef __cplusplus
+ Size(): Width(0), Height(0) {}
+ Size(INT width, INT height): Width(width), Height(height) {}
+ Size(const Size& size): Width(size.Width), Height(size.Height) {}
+
+ BOOL Empty() const {
+ return Width == 0 && Height == 0;
+ }
+ BOOL Equals(const Size& size) const {
+ return Width == size.Width && Height == size.Height;
+ }
+ Size operator+(const Size& size) const {
+ return Size(Width + size.Width, Height + size.Height);
+ }
+ Size operator-(const Size& size) const {
+ return Size(Width - size.Width, Height - size.Height);
+ }
+ #endif /* __cplusplus */
+} Size;
+
+typedef struct SizeF {
+ REAL Width;
+ REAL Height;
+
+ #ifdef __cplusplus
+ SizeF(): Width(0.0f), Height(0.0f) {}
+ SizeF(REAL width, REAL height): Width(width), Height(height) {}
+ SizeF(const SizeF& size): Width(size.Width), Height(size.Height) {}
+
+ BOOL Empty() const {
+ return Width == 0.0f && Height == 0.0f;
+ }
+ BOOL Equals(const SizeF& size) const {
+ return Width == size.Width && Height == size.Height;
+ }
+ SizeF operator+(const SizeF& size) const {
+ return SizeF(Width + size.Width, Height + size.Height);
+ }
+ SizeF operator-(const SizeF& size) const {
+ return SizeF(Width - size.Width, Height - size.Height);
+ }
+ #endif /* __cplusplus */
+} SizeF;
+
+typedef struct Point {
+ INT X;
+ INT Y;
+
+ #ifdef __cplusplus
+ Point(): X(0), Y(0) {}
+ Point(INT x, INT y): X(x), Y(y) {}
+ Point(const Point& point): X(point.X), Y(point.Y) {}
+ Point(const Size& size): X(size.Width), Y(size.Height) {}
+
+ BOOL Equals(const Point& point) const {
+ return X == point.X && Y == point.Y;
+ }
+ Point operator+(const Point& point) const {
+ return Point(X + point.X, Y + point.Y);
+ }
+ Point operator-(const Point& point) const {
+ return Point(X - point.X, Y - point.Y);
+ }
+ #endif /* __cplusplus */
+} Point;
+
+typedef struct PointF {
+ REAL X;
+ REAL Y;
+
+ #ifdef __cplusplus
+ PointF(): X(0.0f), Y(0.0f) {}
+ PointF(REAL x, REAL y): X(x), Y(y) {}
+ PointF(const PointF& point): X(point.X), Y(point.Y) {}
+ PointF(const SizeF& size): X(size.Width), Y(size.Height) {}
+
+ BOOL Equals(const PointF& point) const {
+ return X == point.X && Y == point.Y;
+ }
+ PointF operator+(const PointF& point) const {
+ return PointF(X + point.X, Y + point.Y);
+ }
+ PointF operator-(const PointF& point) const {
+ return PointF(X - point.X, Y - point.Y);
+ }
+ #endif /* __cplusplus */
+} PointF;
+
+typedef struct Rect {
+ INT X;
+ INT Y;
+ INT Width;
+ INT Height;
+
+ #ifdef __cplusplus
+ Rect(): X(0), Y(0), Width(0), Height(0) {}
+ Rect(const Point& location, const Size& size):
+ X(location.X), Y(location.Y),
+ Width(size.Width), Height(size.Height) {}
+ Rect(INT x, INT y, INT width, INT height):
+ X(x), Y(y), Width(width), Height(height) {}
+
+ Rect* Clone() const {
+ return new Rect(X, Y, Width, Height);
+ }
+ BOOL Contains(INT x, INT y) const {
+ return X <= x && Y <= y && x < X+Width && y < Y+Height;
+ }
+ BOOL Contains(const Point& point) const {
+ return Contains(point.X, point.Y);
+ }
+ BOOL Contains(const Rect& rect) const {
+ return X <= rect.X && Y <= rect.Y
+ && rect.X+rect.Width <= X+Width
+ && rect.Y+rect.Height <= Y+Height;
+ }
+ BOOL Equals(const Rect& rect) const {
+ return X == rect.X && Y == rect.Y
+ && Width == rect.Width && Height == rect.Height;
+ }
+ INT GetBottom() const {
+ return Y+Height;
+ }
+ VOID GetBounds(Rect *rect) const {
+ if (rect != NULL) {
+ rect->X = X;
+ rect->Y = Y;
+ rect->Width = Width;
+ rect->Height = Height;
+ }
+ }
+ INT GetLeft() const {
+ return X;
+ }
+ VOID GetLocation(Point *point) const {
+ if (point != NULL) {
+ point->X = X;
+ point->Y = Y;
+ }
+ }
+ INT GetRight() const {
+ return X+Width;
+ }
+ VOID GetSize(Size *size) const {
+ if (size != NULL) {
+ size->Width = Width;
+ size->Height = Height;
+ }
+ }
+ INT GetTop() const {
+ return Y;
+ }
+ BOOL IsEmptyArea() const {
+ return Width <= 0 || Height <= 0;
+ }
+ VOID Inflate(INT dx, INT dy) {
+ X -= dx;
+ Y -= dy;
+ Width += 2*dx;
+ Height += 2*dy;
+ }
+ VOID Inflate(const Point& point) {
+ Inflate(point.X, point.Y);
+ }
+ static BOOL Intersect(Rect& c, const Rect& a, const Rect& b) {
+ INT intersectLeft = (a.X < b.X) ? b.X : a.X;
+ INT intersectTop = (a.Y < b.Y) ? b.Y : a.Y;
+ INT intersectRight = (a.GetRight() < b.GetRight())
+ ? a.GetRight() : b.GetRight();
+ INT intersectBottom = (a.GetBottom() < b.GetBottom())
+ ? a.GetBottom() : b.GetBottom();
+ c.X = intersectLeft;
+ c.Y = intersectTop;
+ c.Width = intersectRight - intersectLeft;
+ c.Height = intersectBottom - intersectTop;
+ return !c.IsEmptyArea();
+ }
+ BOOL Intersect(const Rect& rect) {
+ return Intersect(*this, *this, rect);
+ }
+ BOOL IntersectsWith(const Rect& rc) const {
+ INT intersectLeft = (X < rc.X) ? rc.X : X;
+ INT intersectTop = (Y < rc.Y) ? rc.Y : Y;
+ INT intersectRight = (GetRight() < rc.GetRight())
+ ? GetRight() : rc.GetRight();
+ INT intersectBottom = (GetBottom() < rc.GetBottom())
+ ? GetBottom() : rc.GetBottom();
+ return intersectLeft < intersectRight
+ && intersectTop < intersectBottom;
+ }
+ VOID Offset(INT dx, INT dy) {
+ X += dx;
+ Y += dy;
+ }
+ VOID Offset(const Point& point) {
+ Offset(point.X, point.Y);
+ }
+ static BOOL Union(Rect& c, const Rect& a, const Rect& b) {
+ INT unionLeft = (a.X < b.X) ? a.X : b.X;
+ INT unionTop = (a.Y < b.Y) ? a.Y : b.Y;
+ INT unionRight = (a.GetRight() < b.GetRight())
+ ? b.GetRight() : a.GetRight();
+ INT unionBottom = (a.GetBottom() < b.GetBottom())
+ ? b.GetBottom() : a.GetBottom();
+ c.X = unionLeft;
+ c.Y = unionTop;
+ c.Width = unionRight - unionLeft;
+ c.Height = unionBottom - unionTop;
+ return !c.IsEmptyArea();
+ }
+ #endif /* __cplusplus */
+} Rect;
+
+typedef struct RectF {
+ REAL X;
+ REAL Y;
+ REAL Width;
+ REAL Height;
+
+ #ifdef __cplusplus
+ RectF(): X(0.0f), Y(0.0f), Width(0.0f), Height(0.0f) {}
+ RectF(const PointF& location, const SizeF& size):
+ X(location.X), Y(location.Y),
+ Width(size.Width), Height(size.Height) {}
+ RectF(REAL x, REAL y, REAL width, REAL height):
+ X(x), Y(y), Width(width), Height(height) {}
+
+ RectF* Clone() const {
+ return new RectF(X, Y, Width, Height);
+ }
+ BOOL Contains(REAL x, REAL y) const {
+ return X <= x && Y <= y && x < X+Width && y < Y+Height;
+ }
+ BOOL Contains(const PointF& point) const {
+ return Contains(point.X, point.Y);
+ }
+ BOOL Contains(const RectF& rect) const {
+ return X <= rect.X && Y <= rect.Y
+ && rect.X+rect.Width <= X+Width
+ && rect.Y+rect.Height <= Y+Height;
+ }
+ BOOL Equals(const RectF& rect) const {
+ return X == rect.X && Y == rect.Y
+ && Width == rect.Width && Height == rect.Height;
+ }
+ REAL GetBottom() const {
+ return Y+Height;
+ }
+ VOID GetBounds(RectF *rect) const {
+ if (rect != NULL) {
+ rect->X = X;
+ rect->Y = Y;
+ rect->Width = Width;
+ rect->Height = Height;
+ }
+ }
+ REAL GetLeft() const {
+ return X;
+ }
+ VOID GetLocation(PointF *point) const {
+ if (point != NULL) {
+ point->X = X;
+ point->Y = Y;
+ }
+ }
+ REAL GetRight() const {
+ return X+Width;
+ }
+ VOID GetSize(SizeF *size) const {
+ if (size != NULL) {
+ size->Width = Width;
+ size->Height = Height;
+ }
+ }
+ REAL GetTop() const {
+ return Y;
+ }
+ BOOL IsEmptyArea() const {
+ return Width <= 0.0f || Height <= 0.0f;
+ }
+ VOID Inflate(REAL dx, REAL dy) {
+ X -= dx;
+ Y -= dy;
+ Width += 2*dx;
+ Height += 2*dy;
+ }
+ VOID Inflate(const PointF& point) {
+ Inflate(point.X, point.Y);
+ }
+ static BOOL Intersect(RectF& c, const RectF& a, const RectF& b) {
+ INT intersectLeft = (a.X < b.X) ? b.X : a.X;
+ INT intersectTop = (a.Y < b.Y) ? b.Y : a.Y;
+ INT intersectRight = (a.GetRight() < b.GetRight())
+ ? a.GetRight() : b.GetRight();
+ INT intersectBottom = (a.GetBottom() < b.GetBottom())
+ ? a.GetBottom() : b.GetBottom();
+ c.X = intersectLeft;
+ c.Y = intersectTop;
+ c.Width = intersectRight - intersectLeft;
+ c.Height = intersectBottom - intersectTop;
+ return !c.IsEmptyArea();
+ }
+ BOOL Intersect(const RectF& rect) {
+ return Intersect(*this, *this, rect);
+ }
+ BOOL IntersectsWith(const RectF& rc) const {
+ INT intersectLeft = (X < rc.X) ? rc.X : X;
+ INT intersectTop = (Y < rc.Y) ? rc.Y : Y;
+ INT intersectRight = (GetRight() < rc.GetRight())
+ ? GetRight() : rc.GetRight();
+ INT intersectBottom = (GetBottom() < rc.GetBottom())
+ ? GetBottom() : rc.GetBottom();
+ return intersectLeft < intersectRight
+ && intersectTop < intersectBottom;
+ }
+ VOID Offset(REAL dx, REAL dy) {
+ X += dx;
+ Y += dy;
+ }
+ VOID Offset(const PointF& point) {
+ Offset(point.X, point.Y);
+ }
+ static BOOL Union(RectF& c, const RectF& a, const RectF& b) {
+ INT unionLeft = (a.X < b.X) ? a.X : b.X;
+ INT unionTop = (a.Y < b.Y) ? a.Y : b.Y;
+ INT unionRight = (a.GetRight() < b.GetRight())
+ ? b.GetRight() : a.GetRight();
+ INT unionBottom = (a.GetBottom() < b.GetBottom())
+ ? b.GetBottom() : a.GetBottom();
+ c.X = unionLeft;
+ c.Y = unionTop;
+ c.Width = unionRight - unionLeft;
+ c.Height = unionBottom - unionTop;
+ return !c.IsEmptyArea();
+ }
+ #endif /* __cplusplus */
+} RectF;
+
+/* FIXME: Are descendants of this class, when compiled with g++,
+ binary compatible with MSVC++ code (especially GDIPLUS.DLL of course)? */
+#ifdef __cplusplus
+struct GdiplusAbort {
+ virtual HRESULT __stdcall Abort(void) {}
+};
+#else
+typedef struct GdiplusAbort GdiplusAbort; /* incomplete type */
+#endif
+
+typedef struct CharacterRange {
+ INT First;
+ INT Length;
+
+ #ifdef __cplusplus
+ CharacterRange(): First(0), Length(0) {}
+ CharacterRange(INT first, INT length): First(first), Length(length) {}
+ CharacterRange& operator=(const CharacterRange& rhs) {
+ /* This gracefully handles self-assignment */
+ First = rhs.First;
+ Length = rhs.Length;
+ return *this;
+ }
+ #endif /* __cplusplus */
+} CharacterRange;
+
+typedef struct PathData {
+ INT Count;
+ PointF *Points;
+ BYTE *Types;
+
+ #ifdef __cplusplus
+ friend class GraphicsPath;
+
+ PathData(): Count(0), Points(NULL), Types(NULL) {}
+ ~PathData() {
+ FreeArrays();
+ }
+private:
+ /* used by GraphicsPath::GetPathData, defined in gdipluspath.h */
+ Status AllocateArrays(INT capacity);
+ VOID FreeArrays();
+ #endif /* __cplusplus */
+} PathData;
+
+/* Callback function types */
+/* FIXME: need a correct definition for these function pointer types */
+typedef void *DebugEventProc;
+typedef BOOL CALLBACK (*EnumerateMetafileProc)(EmfPlusRecordType,UINT,UINT,const BYTE*,VOID*);
+typedef void *DrawImageAbort;
+typedef void *GetThumbnailImageAbort;
+
+
+#endif /* __GDIPLUS_TYPES_H */
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 <basetyps.h>
+
+void *_GdipFontFamilyCachedGenericMonospace = 0;
+void *_GdipFontFamilyCachedGenericSansSerif = 0;
+void *_GdipFontFamilyCachedGenericSerif = 0;
+void *_GdipStringFormatCachedGenericDefault = 0;
+void *_GdipStringFormatCachedGenericTypographic = 0;
+
+DEFINE_GUID(EncoderChrominanceTable,0xF2E455DC,0x09B3,0x4316,0x82,0x60,0x67,0x6A,0xDA,0x32,0x48,0x1C);
+DEFINE_GUID(EncoderColorDepth,0x66087055,0xAD66,0x4C7C,0x9A,0x18,0x38,0xA2,0x31,0x0B,0x83,0x37);
+/* EncoderColorSpace missing */
+DEFINE_GUID(EncoderCompression,0xE09D739D,0xCCD4,0x44EE,0x8E,0xBA,0x3F,0xBF,0x8B,0xE4,0xFC,0x58);
+/* EncoderImageItems missing */
+DEFINE_GUID(EncoderLuminanceTable,0xEDB33BCE,0x0266,0x4A77,0xB9,0x04,0x27,0x21,0x60,0x99,0xE7,0x17);
+DEFINE_GUID(EncoderQuality,0x1D5BE4B5,0xFA4A,0x452D,0x9C,0xDD,0x5D,0xB3,0x51,0x05,0xE7,0xEB);
+DEFINE_GUID(EncoderRenderMethod,0x6D42C53A,0x229A,0x4825,0x8B,0xB7,0x5C,0x99,0xE2,0xB9,0xA8,0xB8);
+/* EncoderSaveAsCMYK missing */
+DEFINE_GUID(EncoderSaveFlag,0x292266FC,0xAC40,0x47BF,0x8C,0xFC,0xA8,0x5B,0x89,0xA6,0x55,0xDE);
+DEFINE_GUID(EncoderScanMethod,0x3A4E2661,0x3109,0x4E56,0x85,0x36,0x42,0xC1,0x56,0xE7,0xDC,0xFA);
+DEFINE_GUID(EncoderTransformation,0x8D0EB2D1,0xA58E,0x4EA8,0xAA,0x14,0x10,0x80,0x74,0xB7,0xB6,0xF9);
+DEFINE_GUID(EncoderVersion,0x24D18C76,0x814A,0x41A4,0xBF,0x53,0x1C,0x21,0x9C,0xCC,0xF7,0x97);
+
+DEFINE_GUID(ImageFormatBMP,0xB96B3CAB,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
+DEFINE_GUID(ImageFormatEMF,0xB96B3CAC,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
+/* ImageFormatEXIF missing */
+DEFINE_GUID(ImageFormatGIF,0xB96B3CB0,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
+DEFINE_GUID(ImageFormatIcon,0xB96B3CB5,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
+DEFINE_GUID(ImageFormatJPEG,0xB96B3CAE,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
+DEFINE_GUID(ImageFormatMemoryBMP,0xB96B3CAA,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
+DEFINE_GUID(ImageFormatPNG,0xB96B3CAF,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
+DEFINE_GUID(ImageFormatTIFF,0xB96B3CB1,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
+/* ImageFormatUndefined missing */
+DEFINE_GUID(ImageFormatWMF,0xB96B3CAD,0x0728,0x11D3,0x9D,0x7B,0x00,0x00,0xF8,0x1E,0xF3,0x2E);
+
+DEFINE_GUID(FrameDimensionPage,0x7462DC86,0x6180,0x4C7E,0x8E,0x3F,0xEE,0x73,0x33,0xA7,0xA4,0x83);
+/* FrameDimensionResolution missing */
+DEFINE_GUID(FrameDimensionTime,0x6AEDBD6D,0x3FB5,0x418A,0x83,0xA6,0x7F,0x45,0x22,0x9D,0xC8,0x72);
+
+/* BlurEffectGuid missing */
+/* BrightnessContrastEffectGuid missing */
+/* ColorBalanceEffectGuid missing */
+/* ColorCurveEffectGuid missing */
+/* ColorLUTEffectGuid missing */
+/* ColorMatrixEffectGuid missing */
+/* HueSaturationLightnessEffectGuid missing */
+/* LevelsEffectGuid missing */
+/* RedEyeCorrectionEffectGuid missing */
+/* SharpenEffectGuid missing */
+/* TintEffectGuid missing */
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 <mapi.h> #include <dbt.h> +#include <gdiplus.h> #include <httpext.h> #include <icm.h> #include <imagehlp.h> |