2004-07-21 Casper S. Hornstrup <[email protected]>

* w32api/include/(GdiPlus.h, GdiPlusBase.h, GdiPlusBrush.h, GdiPlusColor.h,
	GdiPlusColorMatrix.h, GdiPlusEffects.h, GdiPlusEnums.h, GdiPlusFlat.h,
	GdiPlusGpStubs.h, GdiPlusGraphics.h, GdiPlusHeaders.h,
	GdiPlusImageAttributes.h, GdiPlusImaging.h GdiPlusInit.h,
	GdiPlusLineCaps.h, GdiPlusMatrix.h, GdiPlusMem.h, GdiPlusMetaFile.h,
	GdiPlusMetaHeader.h, GdiPlusPath.h, GdiPlusPen.h, GdiPlusPixelFormats.h,
	GdiPlusStringFormat.h, GdiPlusTypes.h): New files.

svn path=/trunk/; revision=10241

reactos/ChangeLog

@@ -1,3 +1,13 @@
+2004-07-21  Casper S. Hornstrup  <[email protected]>
+
+	* w32api/include/(GdiPlus.h, GdiPlusBase.h, GdiPlusBrush.h, GdiPlusColor.h,
+	GdiPlusColorMatrix.h, GdiPlusEffects.h, GdiPlusEnums.h, GdiPlusFlat.h,
+	GdiPlusGpStubs.h, GdiPlusGraphics.h, GdiPlusHeaders.h,
+	GdiPlusImageAttributes.h, GdiPlusImaging.h GdiPlusInit.h,
+	GdiPlusLineCaps.h, GdiPlusMatrix.h, GdiPlusMem.h, GdiPlusMetaFile.h,
+	GdiPlusMetaHeader.h, GdiPlusPath.h, GdiPlusPen.h, GdiPlusPixelFormats.h,
+	GdiPlusStringFormat.h, GdiPlusTypes.h): New files.
+
 2004-07-21  Casper S. Hornstrup  <[email protected]>
 
 	* rules.mak, iface/addsys/makefile, iface/native/makefile,

reactos/w32api/include/GdiPlus.h

@@ -0,0 +1,78 @@
+/*
+ * GdiPlus.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 __cplusplus
+#error In order to use GDI+ headers use must use a C++ compiler
+#else
+
+struct IDirectDrawSurface7;
+
+typedef signed short INT16;
+typedef unsigned short UINT16;
+
+#include <pshpack8.h>
+
+namespace Gdiplus
+{
+  namespace DllExports
+  {
+    #include "GdiplusMem.h"
+  };
+
+  #include "GdiplusBase.h"
+  
+  #include "GdiplusEnums.h"
+  #include "GdiplusTypes.h"
+  #include "GdiplusInit.h"
+  #include "GdiplusPixelFormats.h"
+  #include "GdiplusColor.h"
+  #include "GdiplusMetaHeader.h"
+  #include "GdiplusImaging.h"
+  #include "GdiplusColorMatrix.h"
+  #include "GdiplusGpStubs.h"
+  #include "GdiplusHeaders.h"
+
+  namespace DllExports
+  {
+    #include "GdiPlusFlat.h"
+  };
+
+  #include "GdiplusImageAttributes.h"
+  #include "GdiplusMatrix.h"
+  #include "GdiplusBrush.h"
+  #include "GdiplusPen.h"
+  #include "GdiplusStringFormat.h"
+  #include "GdiplusPath.h"
+  #include "GdiplusLineCaps.h"
+  #include "GdiplusMetaFile.h"
+  #include "GdiplusGraphics.h"
+  #include "GdiplusEffects.h"
+}
+
+#include <poppack.h>
+
+#endif
+
+#endif /* _GDIPLUS_H */

reactos/w32api/include/GdiPlusBase.h

@@ -0,0 +1,49 @@
+/*
+ * GdiPlusBase.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSBASE_H
+#define _GDIPLUSBASE_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+class GdiplusBase {
+public:
+  void operator delete(void *in_pVoid)
+  {
+    DllExports::GdipFree(in_pVoid);
+  }
+
+  void operator delete[](void *in_pVoid)
+  {
+    DllExports::GdipFree(in_pVoid);
+  }
+
+  void *operator new(size_t in_size)
+  {
+    return DllExports::GdipAlloc(in_size);
+  }
+
+  void *operator new[](size_t in_size)
+  {
+    return DllExports::GdipAlloc(in_size);
+  }
+};
+
+#endif /* _GDIPLUSBASE_H */

reactos/w32api/include/GdiPlusBrush.h

@@ -0,0 +1,315 @@
+/*
+ * GdiPlusBrush.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSBRUSH_H
+#define _GDIPLUSBRUSH_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+class Brush : public GdiplusBase
+{
+public:
+  Brush *Clone(VOID) const
+  {
+    return NULL;
+  }
+
+  Status GetLastStatus(VOID)
+  {
+    return NotImplemented;
+  }
+
+  BrushType GetType(VOID)
+  {
+    return BrushTypeSolidColor;
+  }
+};
+
+
+class HatchBrush : public Brush
+{
+public:
+  HatchBrush(HatchStyle hatchStyle, const Color &foreColor, const Color &backColor)
+  {
+  }
+
+  Status GetBackgroundColor(Color *color) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetForegroundColor(Color *color) const
+  {
+    return NotImplemented;
+  }
+
+  HatchStyle GetHatchStyle(VOID) const
+  {
+    return HatchStyleHorizontal;
+  }
+};
+
+
+class LinearGradientBrush : public Brush
+{
+public:
+  LinearGradientBrush(const PointF &point1, const PointF &point2, const Color &color1, const Color &color2)
+  {
+  }
+
+  LinearGradientBrush(const Rect &rect, const Color &color1, const Color &color2, REAL angle, BOOL isAngleScalable)
+  {
+  }
+
+  LinearGradientBrush(const Rect &rect, const Color &color1, const Color &color2, LinearGradientMode mode)
+  {
+  }
+
+  LinearGradientBrush(const Point &point1, const Point &point2, const Color &color1, const Color &color2)
+  {
+  }
+
+  LinearGradientBrush(const RectF &rect, const Color &color1, const Color &color2, REAL angle, BOOL isAngleScalable)
+  {
+  }
+
+  LinearGradientBrush(const RectF &rect, const Color &color1, const Color &color2, LinearGradientMode mode)
+  {
+  }
+
+  Status GetBlend(REAL *blendFactors, REAL *blendPositions, INT count)
+  {
+    return NotImplemented;
+  }
+
+  INT GetBlendCount(VOID) const
+  {
+    return 0;
+  }
+
+  BOOL GetGammaCorrection(VOID) const
+  {
+    return FALSE;
+  }
+
+  INT GetInterpolationColorCount(VOID) const
+  {
+    return 0;
+  }
+
+  Status GetInterpolationColors(Color *presetColors, REAL *blendPositions, INT count) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetLinearColors(Color* colors) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetRectangle(Rect *rect) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetRectangle(RectF* rect) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetTransform(Matrix* matrix) const
+  {
+    return NotImplemented;
+  }
+
+  WrapMode GetWrapMode(VOID) const
+  {
+    return WrapModeTile;
+  }
+
+  Status MultiplyTransform(const Matrix *matrix, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status ResetTransform(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status RotateTransform(REAL angle, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status SetBlend(const REAL *blendFactors, const REAL *blendPositions, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status SetBlendBellShape(REAL focus, REAL scale)
+  {
+    return NotImplemented;
+  }
+
+  Status SetBlendTriangularShape(REAL focus, REAL scale)
+  {
+    return NotImplemented;
+  }
+
+  Status SetGammaCorrection(BOOL useGammaCorrection)
+  {
+    return NotImplemented;
+  }
+
+  Status SetInterpolationColors(const Color *presetColors, const REAL *blendPositions, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status SetLinearColors(const Color& color1, const Color& color2)
+  {
+    return NotImplemented;
+  }
+
+  Status SetTransform(const Matrix* matrix)
+  {
+    return NotImplemented;
+  }
+
+  Status SetWrapMode(WrapMode wrapMode)
+  {
+    return NotImplemented;
+  }
+
+  Status TranslateTransform(REAL dx, REAL dy, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class SolidBrush : Brush
+{
+public:
+  SolidBrush(const Color &color)
+  {
+  }
+
+  Status GetColor(Color *color) const
+  {
+    return NotImplemented;
+  }
+
+  Status SetColor(const Color &color)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class TextureBrush : Brush
+{
+public:
+  TextureBrush(Image *image, WrapMode wrapMode, const RectF &dstRect)
+  {
+  }
+
+  TextureBrush(Image *image, Rect &dstRect, ImageAttributes *imageAttributes)
+  {
+  }
+
+  TextureBrush(Image *image, WrapMode wrapMode, INT dstX, INT dstY, INT dstWidth, INT dstHeight)
+  {
+  }
+
+  TextureBrush(Image *image, WrapMode wrapMode, REAL dstX, REAL dstY, REAL dstWidth, REAL dstHeight)
+  {
+  }
+
+  TextureBrush(Image *image, RectF &dstRect, ImageAttributes *imageAttributes)
+  {
+  }
+
+  TextureBrush(Image *image, WrapMode wrapMode)
+  {
+  }
+
+  TextureBrush(Image *image, WrapMode wrapMode, const Rect &dstRect)
+  {
+  }
+
+  Image *GetImage(VOID) const
+  {
+    return NULL;
+  }
+
+  Status GetTransform(Matrix *matrix) const
+  {
+    return NotImplemented;
+  }
+
+  WrapMode GetWrapMode(VOID) const
+  {
+    return WrapModeTile;
+  }
+
+  Status MultiplyTransform(Matrix *matrix, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status ResetTransform(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status RotateTransform(REAL angle, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status SetTransform(const Matrix *matrix)
+  {
+    return NotImplemented;
+  }
+
+  Status SetWrapMode(WrapMode wrapMode)
+  {
+    return NotImplemented;
+  }
+
+  Status TranslateTransform(REAL dx, REAL dy, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+};
+
+#endif /* _GDIPLUSBRUSH_H */

reactos/w32api/include/GdiPlusColor.h

@@ -0,0 +1,279 @@
+/*
+ * GdiPlusColor.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSCOLOR_H
+#define _GDIPLUSCOLOR_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+typedef enum {
+  ColorChannelFlagsC = 0,
+  ColorChannelFlagsM = 1,
+  ColorChannelFlagsY = 2,
+  ColorChannelFlagsK = 3,
+  ColorChannelFlagsLast = 4
+} ColorChannelFlags;
+
+
+class Color
+{
+public:
+  Color(BYTE a, BYTE r, BYTE g, BYTE b)
+  {
+    color = MakeARGB(a, r, g, b);
+  }
+
+  Color(VOID)
+  {
+  }
+
+  Color(BYTE r, BYTE g, BYTE b)
+  {
+  }
+
+  Color(ARGB argb)
+  {
+  }
+
+  BYTE GetA(VOID)
+  {
+    return 0;
+  }
+
+  BYTE GetAlpha(VOID)
+  {
+    return 0;
+  }
+
+  BYTE GetB(VOID)
+  {
+    return 0;
+  }
+
+  BYTE GetBlue(VOID)
+  {
+    return 0;
+  }
+
+  BYTE GetG(VOID)
+  {
+    return 0;
+  }
+
+  BYTE GetGreen(VOID)
+  {
+    return 0;
+  }
+
+  BYTE GetR(VOID)
+  {
+    return 0;
+  }
+
+  BYTE GetRed(VOID)
+  {
+    return 0;
+  }
+
+  ARGB GetValue(VOID) const
+  {
+    return color;
+  }
+
+  enum
+  {
+    AlphaShift = 24,
+    RedShift = 16,
+    GreenShift = 8,
+    BlueShift = 0
+  };
+
+  static ARGB MakeARGB(BYTE a, BYTE r, BYTE g, BYTE b)
+  {
+    return (((ARGB)(b) << BlueShift) |
+      ((ARGB)(g) << GreenShift) |
+      ((ARGB)(r) << RedShift) |
+      ((ARGB)(a) << AlphaShift));
+  }
+
+  VOID SetFromCOLORREF(COLORREF rgb)
+  {
+  }
+
+  VOID SetValue(ARGB argb)
+  {
+  }
+
+  COLORREF ToCOLORREF(VOID)
+  {
+    return 0;
+  }
+
+
+  enum
+  {
+    AliceBlue = 0xFFF0F8FF,
+    AntiqueWhite = 0xFFFAEBD7,
+    Aqua = 0xFF00FFFF,
+    Aquamarine = 0xFF7FFFD4,
+    Azure = 0xFFF0FFFF,
+    Beige = 0xFFF5F5DC,
+    Bisque = 0xFFFFE4C4,
+    Black = 0xFF000000,
+    BlanchedAlmond = 0xFFFFEBCD,
+    Blue = 0xFF0000FF,
+    BlueViolet = 0xFF8A2BE2,
+    Brown = 0xFFA52A2A,
+    BurlyWood = 0xFFDEB887,
+    CadetBlue = 0xFF5F9EA0,
+    Chartreuse = 0xFF7FFF00,
+    Chocolate = 0xFFD2691E,
+    Coral = 0xFFFF7F50,
+    CornflowerBlue = 0xFF6495ED,
+    Cornsilk = 0xFFFFF8DC,
+    Crimson = 0xFFDC143C,
+    Cyan = 0xFF00FFFF,
+    DarkBlue = 0xFF00008B,
+    DarkCyan = 0xFF008B8B,
+    DarkGoldenrod = 0xFFB8860B,
+    DarkGray = 0xFFA9A9A9,
+    DarkGreen = 0xFF006400,
+    DarkKhaki = 0xFFBDB76B,
+    DarkMagenta = 0xFF8B008B,
+    DarkOliveGreen = 0xFF556B2F,
+    DarkOrange = 0xFFFF8C00,
+    DarkOrchid = 0xFF9932CC,
+    DarkRed = 0xFF8B0000,
+    DarkSalmon = 0xFFE9967A,
+    DarkSeaGreen = 0xFF8FBC8B,
+    DarkSlateBlue = 0xFF483D8B,
+    DarkSlateGray = 0xFF2F4F4F,
+    DarkTurquoise = 0xFF00CED1,
+    DarkViolet = 0xFF9400D3,
+    DeepPink = 0xFFFF1493,
+    DeepSkyBlue = 0xFF00BFFF,
+    DimGray = 0xFF696969,
+    DodgerBlue = 0xFF1E90FF,
+    Firebrick = 0xFFB22222,
+    FloralWhite = 0xFFFFFAF0,
+    ForestGreen = 0xFF228B22,
+    Fuchsia = 0xFFFF00FF,
+    Gainsboro = 0xFFDCDCDC,
+    GhostWhite = 0xFFF8F8FF,
+    Gold = 0xFFFFD700,
+    Goldenrod = 0xFFDAA520,
+    Gray = 0xFF808080,
+    Green = 0xFF008000,
+    GreenYellow = 0xFFADFF2F,
+    Honeydew = 0xFFF0FFF0,
+    HotPink = 0xFFFF69B4,
+    IndianRed = 0xFFCD5C5C,
+    Indigo = 0xFF4B0082,
+    Ivory = 0xFFFFFFF0,
+    Khaki = 0xFFF0E68C,
+    Lavender = 0xFFE6E6FA,
+    LavenderBlush = 0xFFFFF0F5,
+    LawnGreen = 0xFF7CFC00,
+    LemonChiffon = 0xFFFFFACD,
+    LightBlue = 0xFFADD8E6,
+    LightCoral = 0xFFF08080,
+    LightCyan = 0xFFE0FFFF,
+    LightGoldenrodYellow = 0xFFFAFAD2,
+    LightGray = 0xFFD3D3D3,
+    LightGreen = 0xFF90EE90,
+    LightPink = 0xFFFFB6C1,
+    LightSalmon = 0xFFFFA07A,
+    LightSeaGreen = 0xFF20B2AA,
+    LightSkyBlue = 0xFF87CEFA,
+    LightSlateGray = 0xFF778899,
+    LightSteelBlue = 0xFFB0C4DE,
+    LightYellow = 0xFFFFFFE0,
+    Lime = 0xFF00FF00,
+    LimeGreen = 0xFF32CD32,
+    Linen = 0xFFFAF0E6,
+    Magenta = 0xFFFF00FF,
+    Maroon = 0xFF800000,
+    MediumAquamarine = 0xFF66CDAA,
+    MediumBlue = 0xFF0000CD,
+    MediumOrchid = 0xFFBA55D3,
+    MediumPurple = 0xFF9370DB,
+    MediumSeaGreen = 0xFF3CB371,
+    MediumSlateBlue = 0xFF7B68EE,
+    MediumSpringGreen = 0xFF00FA9A,
+    MediumTurquoise = 0xFF48D1CC,
+    MediumVioletRed = 0xFFC71585,
+    MidnightBlue = 0xFF191970,
+    MintCream = 0xFFF5FFFA,
+    MistyRose = 0xFFFFE4E1,
+    Moccasin = 0xFFFFE4B5,
+    NavajoWhite = 0xFFFFDEAD,
+    Navy = 0xFF000080,
+    OldLace = 0xFFFDF5E6,
+    Olive = 0xFF808000,
+    OliveDrab = 0xFF6B8E23,
+    Orange = 0xFFFFA500,
+    OrangeRed = 0xFFFF4500,
+    Orchid = 0xFFDA70D6,
+    PaleGoldenrod = 0xFFEEE8AA,
+    PaleGreen = 0xFF98FB98,
+    PaleTurquoise = 0xFFAFEEEE,
+    PaleVioletRed = 0xFFDB7093,
+    PapayaWhip = 0xFFFFEFD5,
+    PeachPuff = 0xFFFFDAB9,
+    Peru = 0xFFCD853F,
+    Pink = 0xFFFFC0CB,
+    Plum = 0xFFDDA0DD,
+    PowderBlue = 0xFFB0E0E6,
+    Purple = 0xFF800080,
+    Red = 0xFFFF0000,
+    RosyBrown = 0xFFBC8F8F,
+    RoyalBlue = 0xFF4169E1,
+    SaddleBrown = 0xFF8B4513,
+    Salmon = 0xFFFA8072,
+    SandyBrown = 0xFFF4A460,
+    SeaGreen = 0xFF2E8B57,
+    SeaShell = 0xFFFFF5EE,
+    Sienna = 0xFFA0522D,
+    Silver = 0xFFC0C0C0,
+    SkyBlue = 0xFF87CEEB,
+    SlateBlue = 0xFF6A5ACD,
+    SlateGray = 0xFF708090,
+    Snow = 0xFFFFFAFA,
+    SpringGreen = 0xFF00FF7F,
+    SteelBlue = 0xFF4682B4,
+    Tan = 0xFFD2B48C,
+    Teal = 0xFF008080,
+    Thistle = 0xFFD8BFD8,
+    Tomato = 0xFFFF6347,
+    Transparent = 0x00FFFFFF,
+    Turquoise = 0xFF40E0D0,
+    Violet = 0xFFEE82EE,
+    Wheat = 0xFFF5DEB3,
+    White = 0xFFFFFFFF,
+    WhiteSmoke = 0xFFF5F5F5,
+    Yellow = 0xFFFFFF00,
+    YellowGreen = 0xFF9ACD32,
+  };
+
+private:
+  ARGB color;
+};
+
+#endif /* _GDIPLUSCOLOR_H */

reactos/w32api/include/GdiPlusColorMatrix.h

@@ -0,0 +1,51 @@
+/*
+ * GdiPlusColorMatrix.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSCOLORMATRIX_H
+#define _GDIPLUSCOLORMATRIX_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+typedef struct {
+  Color oldColor;
+  Color newColor;
+} ColorMap;
+
+struct ColorMatrix {
+  REAL m[5][5];
+};
+
+typedef enum {
+  ColorAdjustTypeDefault = 0,
+  ColorAdjustTypeBitmap = 1,
+  ColorAdjustTypeBrush = 2,
+  ColorAdjustTypePen = 3,
+  ColorAdjustTypeText = 4,
+  ColorAdjustTypeCount = 5,
+  ColorAdjustTypeAny = 6
+} ColorAdjustType;
+
+typedef enum {
+  ColorMatrixFlagsDefault = 0,
+  ColorMatrixFlagsSkipGrays = 1,
+  ColorMatrixFlagsAltGray = 2
+} ColorMatrixFlags;
+
+#endif /* _GDIPLUSCOLORMATRIX_H */

reactos/w32api/include/GdiPlusEffects.h

@@ -0,0 +1,292 @@
+/*
+ * GdiPlusEffects.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSEFFECTS_H
+#define _GDIPLUSEFFECTS_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+typedef struct {
+  float radius;
+  BOOL expandEdge;
+} BlurParams;
+
+typedef struct {
+  INT brightnessLevel;
+  INT contrastLevel;
+} BrightnessContrastParams;
+
+typedef struct {
+  INT cyanRed;
+  INT magentaGreen;
+  INT yellowBlue;
+} ColorBalanceParams;
+
+typedef struct {
+  CurveAdjustments adjustment;
+  CurveChannel channel;
+  INT adjustValue;
+} ColorCurveParams;
+
+typedef struct {
+  INT hueLevel;
+  INT saturationLevel;
+  INT lightnessLevel;
+} HueSaturationLightnessParams;
+
+typedef struct {
+  INT highlight;
+  INT midtone;
+  INT shadow;
+} LevelsParams;
+
+typedef struct {
+  UINT numberOfAreas;
+  RECT *areas;
+} RedEyeCorrectionParams;
+
+typedef struct {
+  REAL radius;
+  REAL amount;
+} SharpenParams;
+
+typedef struct {
+  INT hue;
+  INT amount;
+} TintParams;
+
+
+class Effect
+{
+public:
+  Effect(VOID)
+  {
+  }
+
+  VOID *GetAuxData(VOID) const
+  {
+    return NULL;
+  }
+
+  INT GetAuxDataSize(VOID)
+  {
+    return 0;
+  }
+
+  Status GetParameterSize(UINT *size)
+  {
+    return NotImplemented;
+  }
+
+  VOID UseAuxData(const BOOL useAuxDataFlag)
+  {
+  }
+};
+
+
+class Blur : public Effect
+{
+public:
+  Blur(VOID)
+  {
+  }
+
+  Status GetParameters(UINT *size, BlurParams *parameters)
+  {
+    return NotImplemented;
+  }
+
+  Status SetParameters(const BlurParams *parameters)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class BrightnessContrast : public Effect
+{
+public:
+  BrightnessContrast(VOID)
+  {
+  }
+
+  Status GetParameters(UINT *size, BrightnessContrastParams *parameters)
+  {
+    return NotImplemented;
+  }
+
+  Status SetParameters(const BrightnessContrastParams *parameters)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class ColorBalance : public Effect
+{
+public:
+  ColorBalance(VOID)
+  {
+  }
+
+  Status GetParameters(UINT *size, ColorBalanceParams *parameters)
+  {
+    return NotImplemented;
+  }
+
+  Status SetParameters(ColorBalanceParams *parameters)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class ColorCurve : public Effect
+{
+public:
+  ColorCurve(VOID)
+  {
+  }
+
+  Status GetParameters(UINT *size, ColorCurveParams *parameters)
+  {
+    return NotImplemented;
+  }
+
+  Status SetParameters(const ColorCurveParams *parameters)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class ColorMatrixEffect : public Effect
+{
+public:
+  ColorMatrixEffect(VOID)
+  {
+  }
+
+  Status GetParameters(UINT *size, ColorMatrix *matrix)
+  {
+    return NotImplemented;
+  }
+
+  Status SetParameters(const ColorMatrix *matrix)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class HueSaturationLightness : public Effect
+{
+public:
+  HueSaturationLightness(VOID)
+  {
+  }
+
+  Status GetParameters(UINT *size, HueSaturationLightnessParams *parameters)
+  {
+    return NotImplemented;
+  }
+
+  Status SetParameters(const HueSaturationLightnessParams *parameters)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class Levels : public Effect
+{
+public:
+  Levels(VOID)
+  {
+  }
+
+  Status GetParameters(UINT *size, LevelsParams *parameters)
+  {
+    return NotImplemented;
+  }
+
+  Status SetParameters(const LevelsParams *parameters)
+  {
+    return NotImplemented;
+  }
+};
+
+class RedEyeCorrection : public Effect
+{
+public:
+  RedEyeCorrection(VOID)
+  {
+  }
+
+  Status GetParameters(UINT *size, RedEyeCorrectionParams *parameters)
+  {
+    return NotImplemented;
+  }
+
+  Status SetParameters(const RedEyeCorrectionParams *parameters)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class Sharpen
+{
+public:
+  Sharpen(VOID)
+  {
+  }
+
+  Status GetParameters(UINT *size, SharpenParams *parameters)
+  {
+    return NotImplemented;
+  }
+
+  Status SetParameters(const SharpenParams *parameters)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class Tint : Effect
+{
+public:
+  Tint(VOID)
+  {
+  }
+
+  Status GetParameters(UINT *size, TintParams *parameters)
+  {
+    return NotImplemented;
+  }
+
+  Status SetParameters(const TintParams *parameters)
+  {
+    return NotImplemented;
+  }
+};
+
+#endif /* _GDIPLUSEFFECTS_H */

reactos/w32api/include/GdiPlusEnums.h

@@ -0,0 +1,834 @@
+/*
+ * GdiPlusEnums.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSENUMS_H
+#define _GDIPLUSENUMS_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+typedef UINT GraphicsState;
+typedef UINT GraphicsContainer;
+
+typedef enum {
+  BrushTypeSolidColor = 0,
+  BrushTypeHatchFill = 1,
+  BrushTypeTextureFill = 2,
+  BrushTypePathGradient = 3,
+  BrushTypeLinearGradient = 4
+} BrushType;
+
+typedef enum {
+  CombineModeReplace,
+  CombineModeIntersect,
+  CombineModeUnion,
+  CombineModeXor,
+  CombineModeExclude,
+  CombineModeComplement
+} CombineMode;
+
+typedef enum {
+  CompositingModeSourceOver,
+  CompositingModeSourceCopy
+} CompositingMode;
+
+enum QualityMode
+{
+  QualityModeInvalid = -1,
+  QualityModeDefault = 0,
+  QualityModeLow = 1,
+  QualityModeHigh = 2
+};
+
+typedef enum {
+  CompositingQualityDefault = QualityModeDefault,
+  CompositingQualityHighSpeed = QualityModeLow,
+  CompositingQualityHighQuality = QualityModeHigh,
+  CompositingQualityGammaCorrected,
+  CompositingQualityAssumeLinear
+} CompositingQuality;
+
+typedef enum {
+  CoordinateSpaceWorld,
+  CoordinateSpacePage,
+  CoordinateSpaceDevice
+} CoordinateSpace;
+
+typedef enum {
+  AdjustExposure = 0,
+  AdjustDensity = 1,
+  AdjustContrast = 2,
+  AdjustHighlight = 3,
+  AdjustShadow = 4,
+  AdjustMidtone = 5,
+  AdjustWhiteSaturation = 6,
+  AdjustBlackSaturation = 7
+} CurveAdjustments;
+
+typedef enum {
+  CurveChannelAll = 0,
+  CurveChannelRed = 1,
+  CurveChannelGreen = 2,
+  CurveChannelBlue = 3
+} CurveChannel;
+
+typedef enum {
+  DashCapFlat = 0,
+  DashCapRound = 2,
+  DashCapTriangle = 3
+} DashCap;
+
+typedef enum {
+  DashStyleSolid = 0,
+  DashStyleDash = 1,
+  DashStyleDot = 2,
+  DashStyleDashDot = 3,
+  DashStyleDashDotDot = 4,
+  DashStyleCustom = 5
+} DashStyle;
+
+typedef enum {
+  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 {
+  DriverStringOptionsCmapLookup = 1,
+  DriverStringOptionsVertical = 2,
+  DriverStringOptionsRealizedAdvance = 4,
+  DriverStringOptionsLimitSubpixel = 8
+} DriverStringOptions;
+
+#define GDIP_EMFPLUS_RECORD_BASE 0x00004000
+#define GDIP_WMF_RECORD_BASE 0x00010000
+#define GDIP_WMF_RECORD_TO_EMFPLUS(n) ((n) | GDIP_WMF_RECORD_BASE)
+#define GDIP_EMFPLUS_RECORD_TO_WMF(n) ((n) & (~GDIP_WMF_RECORD_BASE))
+#define GDIP_IS_WMF_RECORDTYPE(n) (((n) & GDIP_WMF_RECORD_BASE) != 0)
+
+typedef enum {
+  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 {
+  EmfToWmfBitsFlagsDefault = 0x00000000,
+  EmfToWmfBitsFlagsEmbedEmf = 0x00000001,
+  EmfToWmfBitsFlagsIncludePlaceable = 0x00000002,
+  EmfToWmfBitsFlagsNoXORClip = 0x00000004
+} EmfToWmfBitsFlags;
+
+typedef enum {
+  MetafileTypeInvalid = 0,
+  MetafileTypeWmf = 1,
+  MetafileTypeWmfPlaceable = 2,
+  MetafileTypeEmf = 3,
+  MetafileTypeEmfPlusOnly = 4,
+  MetafileTypeEmfPlusDual = 5
+} MetafileType;
+
+typedef enum {
+  EmfTypeEmfOnly = MetafileTypeEmf,
+  EmfTypeEmfPlusOnly = MetafileTypeEmfPlusOnly,
+  EmfTypeEmfPlusDual = MetafileTypeEmfPlusDual
+} EmfType;
+
+typedef enum {
+  EncoderParameterValueTypeByte = 1,
+  EncoderParameterValueTypeASCII = 2,
+  EncoderParameterValueTypeShort = 3,
+  EncoderParameterValueTypeLong = 4,
+  EncoderParameterValueTypeRational = 5,
+  EncoderParameterValueTypeLongRange = 6,
+  EncoderParameterValueTypeUndefined = 7,
+  EncoderParameterValueTypeRationalRange = 8,
+  EncoderParameterValueTypePointer = 9
+} EncoderParameterValueType;
+
+typedef enum {
+  EncoderValueColorTypeCMYK,
+  EncoderValueColorTypeYCCK,
+  EncoderValueCompressionLZW,
+  EncoderValueCompressionCCITT3,
+  EncoderValueCompressionCCITT4,
+  EncoderValueCompressionRle,
+  EncoderValueCompressionNone,
+  EncoderValueScanMethodInterlaced,
+  EncoderValueScanMethodNonInterlaced,
+  EncoderValueVersionGif87,
+  EncoderValueVersionGif89,
+  EncoderValueRenderProgressive,
+  EncoderValueRenderNonProgressive,
+  EncoderValueTransformRotate90,
+  EncoderValueTransformRotate180,
+  EncoderValueTransformRotate270,
+  EncoderValueTransformFlipHorizontal,
+  EncoderValueTransformFlipVertical,
+  EncoderValueMultiFrame,
+  EncoderValueLastFrame,
+  EncoderValueFlush,
+  EncoderValueFrameDimensionTime,
+  EncoderValueFrameDimensionResolution,
+  EncoderValueFrameDimensionPage
+} EncoderValue;
+
+typedef enum {
+  FillModeAlternate,
+  FillModeWinding
+} FillMode;
+
+typedef enum {
+  FlushIntentionFlush = 0,
+  FlushIntentionSync = 1
+} FlushIntention;
+
+typedef enum {
+  FontStyleRegular = 0,
+  FontStyleBold = 1,
+  FontStyleItalic = 2,
+  FontStyleBoldItalic = 3,
+  FontStyleUnderline = 4,
+  FontStyleStrikeout = 8
+} FontStyle;
+
+typedef enum {
+  HatchStyleHorizontal = 0,
+  HatchStyleVertical = 1,
+  HatchStyleForwardDiagonal = 2,
+  HatchStyleBackwardDiagonal = 3,
+  HatchStyleCross = 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 = 311,
+  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,
+  HatchStyleLargeGrid = HatchStyleCross,
+  HatchStyleMin = HatchStyleHorizontal,
+  HatchStyleMax = HatchStyleTotal - 1
+} HatchStyle;
+
+typedef enum {
+  HistogramFormatARGB,
+  HistogramFormatPARGB,
+  HistogramFormatRGB,
+  HistogramFormatGray,
+  HistogramFormatB,
+  HistogramFormatG,
+  HistogramFormatR,
+  HistogramFormatA
+} HistogramFormat;
+
+typedef enum {
+  HotkeyPrefixNone = 0,
+  HotkeyPrefixShow = 1,
+  HotkeyPrefixHide = 2
+} HotkeyPrefix;
+
+typedef enum {
+  ImageCodecFlagsEncoder = 0x00000001,
+  ImageCodecFlagsDecoder = 0x00000002,
+  ImageCodecFlagsSupportBitmap = 0x00000004,
+  ImageCodecFlagsSupportVector = 0x00000008,
+  ImageCodecFlagsSeekableEncode = 0x00000010,
+  ImageCodecFlagsBlockingDecode = 0x00000020,
+  ImageCodecFlagsBuiltin = 0x00010000,
+  ImageCodecFlagsSystem = 0x00020000,
+  ImageCodecFlagsUser = 0x00040000
+} ImageCodecFlags;
+
+typedef enum {
+  ImageFlagsNone = 0,
+  ImageFlagsScalable = 0x0001,
+  ImageFlagsHasAlpha = 0x0002,
+  ImageFlagsHasTranslucent = 0x0004,
+  ImageFlagsPartiallyScalable = 0x0008,
+  ImageFlagsColorSpaceRGB = 0x0010,
+  ImageFlagsColorSpaceCMYK = 0x0020,
+  ImageFlagsColorSpaceGRAY = 0x0040,
+  ImageFlagsColorSpaceYCBCR = 0x0080,
+  ImageFlagsColorSpaceYCCK = 0x0100,
+  ImageFlagsHasRealDPI = 0x1000,
+  ImageFlagsHasRealPixelSize = 0x2000,
+  ImageFlagsReadOnly = 0x00010000,
+  ImageFlagsCaching = 0x00020000
+} ImageFlags;
+
+typedef enum {
+  ImageLockModeRead = 0x0001,
+  ImageLockModeWrite = 0x0002,
+  ImageLockModeUserInputBuf = 0x0004
+} ImageLockMode;
+
+typedef enum {
+  ImageTypeUnknown = 0,
+  ImageTypeBitmap = 1,
+  ImageTypeMetafile = 2
+} ImageType;
+
+typedef enum {
+  InterpolationModeInvalid = QualityModeInvalid,
+  InterpolationModeDefault = QualityModeDefault,
+  InterpolationModeLowQuality = QualityModeLow,
+  InterpolationModeHighQuality = QualityModeHigh,
+  InterpolationModeBilinear = QualityModeHigh + 1,
+  InterpolationModeBicubic = QualityModeHigh + 2,
+  InterpolationModeNearestNeighbor = QualityModeHigh + 3,
+  InterpolationModeHighQualityBilinear = QualityModeHigh + 4,
+  InterpolationModeHighQualityBicubic = QualityModeHigh + 5
+} InterpolationMode;
+
+typedef enum {
+  ItemDataPositionAfterHeader = 0x0,
+  ItemDataPositionAfterPalette = 0x1,
+  ItemDataPositionAfterBits = 0x2
+} ItemDataPosition;
+
+typedef enum {
+  LinearGradientModeHorizontal = 0,
+  LinearGradientModeVertical = 1,
+  LinearGradientModeForwardDiagonal = 2,
+  LinearGradientModeBackwardDiagonal = 3
+} LinearGradientMode;
+
+typedef enum {
+  LineCapFlat = 0,
+  LineCapSquare = 1,
+  LineCapRound = 2,
+  LineCapTriangle = 3,
+  LineCapNoAnchor = 0x10,
+  LineCapSquareAnchor = 0x11,
+  LineCapRoundAnchor = 0x12,
+  LineCapDiamondAnchor = 0x13,
+  LineCapArrowAnchor = 0x14,
+  LineCapCustom = 0xff
+} LineCap;
+
+typedef enum {
+  LineJoinMiter = 0,
+  LineJoinBevel = 1,
+  LineJoinRound = 2,
+  LineJoinMiterClipped = 3
+} LineJoin;
+
+typedef enum {
+  MatrixOrderPrepend = 0,
+  MatrixOrderAppend = 1
+} MatrixOrder;
+
+typedef enum {
+  UnitWorld = 0,
+  UnitDisplay = 1,
+  UnitPixel = 2,
+  UnitPoint = 3,
+  UnitInch = 4,
+  UnitDocument = 5,
+  UnitMillimeter = 6
+} Unit;
+
+typedef enum {
+  MetafileFrameUnitPixel = UnitPixel,
+  MetafileFrameUnitPoint = UnitPoint,
+  MetafileFrameUnitInch = UnitInch,
+  MetafileFrameUnitDocument = UnitDocument,
+  MetafileFrameUnitMillimeter = UnitDocument + 1,
+  MetafileFrameUnitGdi = UnitDocument + 2
+} MetafileFrameUnit;
+
+typedef enum {
+  ObjectTypeInvalid,
+  ObjectTypeBrush,
+  ObjectTypePen,
+  ObjectTypePath,
+  ObjectTypeRegion,
+  ObjectTypeFont,
+  ObjectTypeStringFormat,
+  ObjectTypeImageAttributes,
+  ObjectTypeCustomLineCap,
+  ObjectTypeGraphics,
+  ObjectTypeMax = ObjectTypeGraphics,
+  ObjectTypeMin = ObjectTypeBrush
+} ObjectType;
+
+typedef enum {
+  PaletteFlagsHasAlpha = 0x0001,
+  PaletteFlagsGrayScale = 0x0002,
+  PaletteFlagsHalftone = 0x0004
+} PaletteFlags;
+
+typedef enum {
+  PaletteTypeCustom = 0,
+  PaletteTypeOptimal = 1,
+  PaletteTypeFixedBW = 2,
+  PaletteTypeFixedHalftone8 = 3,
+  PaletteTypeFixedHalftone27 = 4,
+  PaletteTypeFixedHalftone64 = 5,
+  PaletteTypeFixedHalftone125 = 6,
+  PaletteTypeFixedHalftone216 = 7,
+  PaletteTypeFixedHalftone252 = 8,
+  PaletteTypeFixedHalftone256 = 9
+} PaletteType;
+
+typedef enum {
+  PathPointTypeStart = 0,
+  PathPointTypeLine = 1,
+  PathPointTypeBezier = 3,
+  PathPointTypePathTypeMask = 0x7,
+  PathPointTypePathDashMode = 0x10,
+  PathPointTypePathMarker = 0x20,
+  PathPointTypeCloseSubpath = 0x80,
+  PathPointTypeBezier3 = 3
+} PathPointType;
+
+typedef enum {
+  PenAlignmentCenter = 0,
+  PenAlignmentInset = 1
+} PenAlignment;
+
+typedef enum {
+  PenTypeSolidColor = BrushTypeSolidColor,
+  PenTypeHatchFill = BrushTypeHatchFill,
+  PenTypeTextureFill = BrushTypeTextureFill,
+  PenTypePathGradient = BrushTypePathGradient,
+  PenTypeLinearGradient = BrushTypeLinearGradient,
+  PenTypeUnknown = -1
+} PenType;
+
+typedef enum {
+  PixelOffsetModeInvalid = QualityModeInvalid,
+  PixelOffsetModeDefault = QualityModeDefault,
+  PixelOffsetModeHighSpeed = QualityModeLow,
+  PixelOffsetModeHighQuality = QualityModeHigh,
+  PixelOffsetModeNone = QualityModeHigh + 1,
+  PixelOffsetModeHalf = QualityModeHigh + 2
+} PixelOffsetMode;
+
+typedef enum {
+  RotateNoneFlipNone = 0,
+  Rotate90FlipNone = 1,
+  Rotate180FlipNone = 2,
+  Rotate270FlipNone = 3,
+  RotateNoneFlipX = 4,
+  Rotate90FlipX = 5,
+  Rotate180FlipX = 6,
+  Rotate270FlipX = 7,
+  RotateNoneFlipY = Rotate180FlipX,
+  Rotate90FlipY = Rotate270FlipX,
+  Rotate180FlipY = RotateNoneFlipX,
+  Rotate270FlipY = Rotate90FlipX,
+  RotateNoneFlipXY = Rotate180FlipNone,
+  Rotate90FlipXY = Rotate270FlipNone,
+  Rotate180FlipXY = RotateNoneFlipNone,
+  Rotate270FlipXY = Rotate90FlipNone
+} RotateFlipType;
+
+typedef enum {
+  SmoothingModeInvalid = QualityModeInvalid,
+  SmoothingModeDefault = QualityModeDefault,
+  SmoothingModeHighSpeed = QualityModeLow,
+  SmoothingModeHighQuality = QualityModeHigh,
+  SmoothingModeNone,
+  SmoothingModeAntiAlias8x4,
+  SmoothingModeAntiAlias = SmoothingModeAntiAlias8x4,
+  SmoothingModeAntiAlias8x8
+} SmoothingMode;
+
+typedef enum {
+  StringAlignmentNear = 0,
+  StringAlignmentCenter = 1,
+  StringAlignmentFar = 2
+} StringAlignment;
+
+typedef enum {
+  StringDigitSubstituteUser = 0,
+  StringDigitSubstituteNone = 1,
+  StringDigitSubstituteNational = 2,
+  StringDigitSubstituteTraditional = 3
+} StringDigitSubstitute;
+
+typedef enum {
+  StringFormatFlagsDirectionRightToLeft = 0x00000001,
+  StringFormatFlagsDirectionVertical = 0x00000002,
+  StringFormatFlagsNoFitBlackBox = 0x00000004,
+  StringFormatFlagsDisplayFormatControl = 0x00000020,
+  StringFormatFlagsNoFontFallback = 0x00000400,
+  StringFormatFlagsMeasureTrailingSpaces = 0x00000800,
+  StringFormatFlagsNoWrap = 0x00001000,
+  StringFormatFlagsLineLimit = 0x00002000,
+  StringFormatFlagsNoClip = 0x00004000
+} StringFormatFlags;
+
+typedef enum {
+  StringTrimmingNone = 0,
+  StringTrimmingCharacter = 1,
+  StringTrimmingWord = 2,
+  StringTrimmingEllipsisCharacter = 3,
+  StringTrimmingEllipsisWord = 4,
+  StringTrimmingEllipsisPath = 5
+} StringTrimming;
+
+typedef enum {
+  TextRenderingHintSystemDefault = 0,
+  TextRenderingHintSingleBitPerPixelGridFit = 1,
+  TextRenderingHintSingleBitPerPixel = 2,
+  TextRenderingHintAntiAliasGridFit = 3,
+  TextRenderingHintAntiAlias = 4,
+  TextRenderingHintClearTypeGridFit = 5
+} TextRenderingHint;
+
+typedef enum {
+  WarpModePerspective = 0,
+  WarpModeBilinear = 1
+} WarpMode;
+
+typedef enum {
+  WrapModeTile = 0,
+  WrapModeTileFlipX = 1,
+  WrapModeTileFlipY = 2,
+  WrapModeTileFlipXY = 3,
+  WrapModeClamp = 4
+} WrapMode;
+
+enum GpTestControlEnum {
+  TestControlForceBilinear = 0,
+  TestControlNoICM = 1,
+  TestControlGetBuildNumber = 2
+};
+
+enum CustomLineCapType {
+  CustomLineCapTypeDefault = 0,
+  CustomLineCapTypeAdjustableArrow = 1
+};
+
+#endif /* _GDIPLUSENUMS_H */

reactos/w32api/include/GdiPlusFlat.h

@@ -0,0 +1,683 @@
+/*
+ * GdiPlusFlat.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSFLAT_H
+#define _GDIPLUSFLAT_H
+
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WINGDIPAPI __stdcall
+#define GDIPCONST const
+
+GpStatus WINGDIPAPI GdipCreateAdjustableArrowCap(REAL height, REAL width, BOOL isFilled, GpAdjustableArrowCap **cap);
+GpStatus WINGDIPAPI GdipSetAdjustableArrowCapHeight(GpAdjustableArrowCap* cap, REAL height);
+GpStatus WINGDIPAPI GdipGetAdjustableArrowCapHeight(GpAdjustableArrowCap* cap, REAL* height);
+GpStatus WINGDIPAPI GdipSetAdjustableArrowCapWidth(GpAdjustableArrowCap* cap, REAL width);
+GpStatus WINGDIPAPI GdipGetAdjustableArrowCapWidth(GpAdjustableArrowCap* cap, REAL* width);
+GpStatus WINGDIPAPI GdipSetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap* cap, REAL middleInset);
+GpStatus WINGDIPAPI GdipGetAdjustableArrowCapMiddleInset(GpAdjustableArrowCap* cap, REAL* middleInset);
+GpStatus WINGDIPAPI GdipSetAdjustableArrowCapFillState(GpAdjustableArrowCap* cap, BOOL fillState);
+GpStatus WINGDIPAPI GdipGetAdjustableArrowCapFillState(GpAdjustableArrowCap* cap, BOOL* fillState);
+
+GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream, GpBitmap **bitmap);
+GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename, GpBitmap **bitmap);
+GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream, GpBitmap **bitmap);
+GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename, GpBitmap **bitmap);
+GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride, PixelFormat format, BYTE* scan0, GpBitmap** bitmap);
+GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height, GpGraphics* target, GpBitmap** bitmap);
+GpStatus WINGDIPAPI GdipCreateBitmapFromDirectDrawSurface(IDirectDrawSurface7* surface, GpBitmap** bitmap);
+GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* gdiBitmapInfo, VOID* gdiBitmapData, GpBitmap** bitmap);
+GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap);
+GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap, HBITMAP* hbmReturn, ARGB background);
+GpStatus WINGDIPAPI GdipCreateBitmapFromHICON(HICON hicon, GpBitmap** bitmap);
+GpStatus WINGDIPAPI GdipCreateHICONFromBitmap(GpBitmap* bitmap, HICON* hbmReturn);
+GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE hInstance, GDIPCONST WCHAR* lpBitmapName, GpBitmap** bitmap);
+GpStatus WINGDIPAPI GdipCloneBitmapArea(REAL x, REAL y, REAL width, REAL height, PixelFormat format, GpBitmap *srcBitmap, GpBitmap **dstBitmap);
+GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT x, INT y, INT width, INT height, PixelFormat format, GpBitmap *srcBitmap, GpBitmap **dstBitmap);
+GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect, UINT flags, PixelFormat format, BitmapData* lockedBitmapData);
+GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap, BitmapData* lockedBitmapData);
+GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y, ARGB *color);
+GpStatus WINGDIPAPI GdipBitmapSetPixel(GpBitmap* bitmap, INT x, INT y, ARGB color);
+GpStatus WINGDIPAPI GdipBitmapSetResolution(GpBitmap* bitmap, REAL xdpi, REAL ydpi);
+GpStatus WINGDIPAPI GdipBitmapConvertFormat(IN GpBitmap *pInputBitmap, PixelFormat format, DitherType dithertype, PaletteType palettetype, ColorPalette *palette, REAL alphaThresholdPercent);
+GpStatus WINGDIPAPI GdipInitializePalette(OUT ColorPalette *palette, PaletteType palettetype, INT optimalColors, BOOL useTransparentColor, GpBitmap *bitmap);
+GpStatus WINGDIPAPI GdipBitmapApplyEffect(GpBitmap* bitmap, CGpEffect *effect, RECT *roi, BOOL useAuxData, VOID **auxData, INT *auxDataSize);
+GpStatus WINGDIPAPI GdipBitmapCreateApplyEffect(GpBitmap **inputBitmaps, INT numInputs, CGpEffect *effect, RECT *roi, RECT *outputRect, GpBitmap **outputBitmap, BOOL useAuxData, VOID **auxData, INT *auxDataSize);
+GpStatus WINGDIPAPI GdipBitmapGetHistogram(GpBitmap* bitmap, IN HistogramFormat format, IN UINT NumberOfEntries, OUT UINT *channel0, OUT UINT *channel1, OUT UINT *channel2, OUT UINT *channel3);
+GpStatus WINGDIPAPI GdipBitmapGetHistogramSize(IN HistogramFormat format, OUT UINT *NumberOfEntries);
+Status __stdcall GdipCreateEffect(const GUID guid, CGpEffect **effect);
+Status __stdcall GdipDeleteEffect(CGpEffect *effect);
+Status __stdcall GdipGetEffectParameterSize(CGpEffect *effect, UINT *size);
+Status __stdcall GdipSetEffectParameters(CGpEffect *effect, const VOID *params, const UINT size);
+Status __stdcall GdipGetEffectParameters(CGpEffect *effect, UINT *size, VOID *params);
+GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void * param);
+
+GpStatus WINGDIPAPI GdipCloneBrush(GpBrush *brush, GpBrush **cloneBrush);
+GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush);
+GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type);
+
+GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap *bitmap, GpGraphics *graphics, GpCachedBitmap **cachedBitmap);
+GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedBitmap);
+GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics *graphics, GpCachedBitmap *cachedBitmap, INT x, INT y);
+UINT WINGDIPAPI GdipEmfToWmfBits(HENHMETAFILE hemf, UINT cbData16, LPBYTE pData16, INT iMapMode, INT eFlags);
+
+GpStatus WINGDIPAPI GdipCreateCustomLineCap(GpPath* fillPath, GpPath* strokePath, GpLineCap baseCap, REAL baseInset, GpCustomLineCap **customCap);
+GpStatus WINGDIPAPI GdipDeleteCustomLineCap(GpCustomLineCap* customCap);
+GpStatus WINGDIPAPI GdipCloneCustomLineCap(GpCustomLineCap* customCap, GpCustomLineCap** clonedCap);
+GpStatus WINGDIPAPI GdipGetCustomLineCapType(GpCustomLineCap* customCap, CustomLineCapType* capType);
+GpStatus WINGDIPAPI GdipSetCustomLineCapStrokeCaps(GpCustomLineCap* customCap, GpLineCap startCap, GpLineCap endCap);
+GpStatus WINGDIPAPI GdipGetCustomLineCapStrokeCaps(GpCustomLineCap* customCap, GpLineCap* startCap, GpLineCap* endCap);
+GpStatus WINGDIPAPI GdipSetCustomLineCapStrokeJoin(GpCustomLineCap* customCap, GpLineJoin lineJoin);
+GpStatus WINGDIPAPI GdipGetCustomLineCapStrokeJoin(GpCustomLineCap* customCap, GpLineJoin* lineJoin);
+GpStatus WINGDIPAPI GdipSetCustomLineCapBaseCap(GpCustomLineCap* customCap, GpLineCap baseCap);
+GpStatus WINGDIPAPI GdipGetCustomLineCapBaseCap(GpCustomLineCap* customCap, GpLineCap* baseCap);
+GpStatus WINGDIPAPI GdipSetCustomLineCapBaseInset(GpCustomLineCap* customCap, REAL inset);
+GpStatus WINGDIPAPI GdipGetCustomLineCapBaseInset(GpCustomLineCap* customCap, REAL* inset);
+GpStatus WINGDIPAPI GdipSetCustomLineCapWidthScale(GpCustomLineCap* customCap, REAL widthScale);
+GpStatus WINGDIPAPI GdipGetCustomLineCapWidthScale(GpCustomLineCap* customCap, REAL* widthScale);
+
+GpStatus WINGDIPAPI GdipCreateFontFromDC(HDC hdc, GpFont **font);
+GpStatus WINGDIPAPI GdipCreateFontFromLogfontA(HDC hdc, GDIPCONST LOGFONTA *logfont, GpFont **font);
+GpStatus WINGDIPAPI GdipCreateFontFromLogfontW(HDC hdc, GDIPCONST LOGFONTW *logfont, GpFont **font);
+GpStatus WINGDIPAPI GdipCreateFont(GDIPCONST GpFontFamily *fontFamily, REAL emSize, INT style, Unit unit, GpFont **font);
+GpStatus WINGDIPAPI GdipCloneFont(GpFont* font, GpFont** cloneFont);
+GpStatus WINGDIPAPI GdipDeleteFont(GpFont* font);
+GpStatus WINGDIPAPI GdipGetFamily(GpFont *font, GpFontFamily **family);
+GpStatus WINGDIPAPI GdipGetFontStyle(GpFont *font, INT *style);
+GpStatus WINGDIPAPI GdipGetFontSize(GpFont *font, REAL *size);
+GpStatus WINGDIPAPI GdipGetFontUnit(GpFont *font, Unit *unit);
+GpStatus WINGDIPAPI GdipGetFontHeight(GDIPCONST GpFont *font, GDIPCONST GpGraphics *graphics, REAL *height);
+GpStatus WINGDIPAPI GdipGetFontHeightGivenDPI(GDIPCONST GpFont *font, REAL dpi, REAL *height);
+GpStatus WINGDIPAPI GdipGetLogFontA(GpFont * font, GpGraphics *graphics, LOGFONTA * logfontA);
+GpStatus WINGDIPAPI GdipGetLogFontW(GpFont * font, GpGraphics *graphics, LOGFONTW * logfontW);
+GpStatus WINGDIPAPI GdipNewInstalledFontCollection(GpFontCollection** fontCollection);
+GpStatus WINGDIPAPI GdipNewPrivateFontCollection(GpFontCollection** fontCollection);
+GpStatus WINGDIPAPI GdipDeletePrivateFontCollection(GpFontCollection** fontCollection);
+GpStatus WINGDIPAPI GdipGetFontCollectionFamilyCount(GpFontCollection* fontCollection, INT * numFound);
+GpStatus WINGDIPAPI GdipGetFontCollectionFamilyList(GpFontCollection* fontCollection, INT numSought, GpFontFamily* gpfamilies[], INT* numFound);
+GpStatus WINGDIPAPI GdipPrivateAddFontFile(GpFontCollection* fontCollection, GDIPCONST WCHAR* filename);
+GpStatus WINGDIPAPI GdipPrivateAddMemoryFont(GpFontCollection* fontCollection, GDIPCONST void* memory, INT length);
+
+GpStatus WINGDIPAPI GdipCreateFontFamilyFromName(GDIPCONST WCHAR *name, GpFontCollection *fontCollection, GpFontFamily **FontFamily);
+GpStatus WINGDIPAPI GdipDeleteFontFamily(GpFontFamily *FontFamily);
+GpStatus WINGDIPAPI GdipCloneFontFamily(GpFontFamily *FontFamily, GpFontFamily **clonedFontFamily);
+GpStatus WINGDIPAPI GdipGetGenericFontFamilySansSerif(GpFontFamily **nativeFamily);
+GpStatus WINGDIPAPI GdipGetGenericFontFamilySerif(GpFontFamily **nativeFamily);
+GpStatus WINGDIPAPI GdipGetGenericFontFamilyMonospace(GpFontFamily **nativeFamily);
+GpStatus WINGDIPAPI GdipGetFamilyName(GDIPCONST GpFontFamily *family, WCHAR name[LF_FACESIZE], LANGID language);
+GpStatus WINGDIPAPI GdipIsStyleAvailable(GDIPCONST GpFontFamily *family, INT style, BOOL * IsStyleAvailable);
+GpStatus WINGDIPAPI GdipFontCollectionEnumerable(GpFontCollection* fontCollection, GpGraphics* graphics, INT * numFound);
+GpStatus WINGDIPAPI GdipFontCollectionEnumerate(GpFontCollection* fontCollection, INT numSought, GpFontFamily* gpfamilies[], INT* numFound, GpGraphics* graphics);
+GpStatus WINGDIPAPI GdipGetEmHeight(GDIPCONST GpFontFamily *family, INT style, UINT16 * EmHeight);
+GpStatus WINGDIPAPI GdipGetCellAscent(GDIPCONST GpFontFamily *family, INT style, UINT16 * CellAscent);
+GpStatus WINGDIPAPI GdipGetCellDescent(GDIPCONST GpFontFamily *family, INT style, UINT16 * CellDescent);
+GpStatus WINGDIPAPI GdipGetLineSpacing(GDIPCONST GpFontFamily *family, INT style, UINT16 * LineSpacing);
+
+GpStatus WINGDIPAPI GdipFlush(GpGraphics *graphics, GpFlushIntention intention);
+GpStatus WINGDIPAPI GdipCreateFromHDC(HDC hdc, GpGraphics **graphics);
+GpStatus WINGDIPAPI GdipCreateFromHDC2(HDC hdc, HANDLE hDevice, GpGraphics **graphics);
+GpStatus WINGDIPAPI GdipCreateFromHWND(HWND hwnd, GpGraphics **graphics);
+GpStatus WINGDIPAPI GdipCreateFromHWNDICM(HWND hwnd, GpGraphics **graphics);
+GpStatus WINGDIPAPI GdipDeleteGraphics(GpGraphics *graphics);
+GpStatus WINGDIPAPI GdipGetDC(GpGraphics* graphics, HDC * hdc);
+GpStatus WINGDIPAPI GdipReleaseDC(GpGraphics* graphics, HDC hdc);
+GpStatus WINGDIPAPI GdipSetCompositingMode(GpGraphics *graphics, CompositingMode compositingMode);
+GpStatus WINGDIPAPI GdipGetCompositingMode(GpGraphics *graphics, CompositingMode *compositingMode);
+GpStatus WINGDIPAPI GdipSetRenderingOrigin(GpGraphics *graphics, INT x, INT y);
+GpStatus WINGDIPAPI GdipGetRenderingOrigin(GpGraphics *graphics, INT *x, INT *y);
+GpStatus WINGDIPAPI GdipSetCompositingQuality(GpGraphics *graphics, CompositingQuality compositingQuality);
+GpStatus WINGDIPAPI GdipGetCompositingQuality(GpGraphics *graphics, CompositingQuality *compositingQuality);
+GpStatus WINGDIPAPI GdipSetSmoothingMode(GpGraphics *graphics, SmoothingMode smoothingMode);
+GpStatus WINGDIPAPI GdipGetSmoothingMode(GpGraphics *graphics, SmoothingMode *smoothingMode);
+GpStatus WINGDIPAPI GdipSetPixelOffsetMode(GpGraphics* graphics, PixelOffsetMode pixelOffsetMode);
+GpStatus WINGDIPAPI GdipGetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode *pixelOffsetMode);
+GpStatus WINGDIPAPI GdipSetTextRenderingHint(GpGraphics *graphics, TextRenderingHint mode);
+GpStatus WINGDIPAPI GdipGetTextRenderingHint(GpGraphics *graphics, TextRenderingHint *mode);
+GpStatus WINGDIPAPI GdipSetTextContrast(GpGraphics *graphics, UINT contrast);
+GpStatus WINGDIPAPI GdipGetTextContrast(GpGraphics *graphics, UINT * contrast);
+GpStatus WINGDIPAPI GdipSetInterpolationMode(GpGraphics *graphics, InterpolationMode interpolationMode);
+GpStatus WINGDIPAPI GdipGetInterpolationMode(GpGraphics *graphics, InterpolationMode *interpolationMode);
+GpStatus WINGDIPAPI GdipSetWorldTransform(GpGraphics *graphics, GpMatrix *matrix);
+GpStatus WINGDIPAPI GdipResetWorldTransform(GpGraphics *graphics);
+GpStatus WINGDIPAPI GdipMultiplyWorldTransform(GpGraphics *graphics, GDIPCONST GpMatrix *matrix, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipTranslateWorldTransform(GpGraphics *graphics, REAL dx, REAL dy, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipScaleWorldTransform(GpGraphics *graphics, REAL sx, REAL sy, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipRotateWorldTransform(GpGraphics *graphics, REAL angle, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipGetWorldTransform(GpGraphics *graphics, GpMatrix *matrix);
+GpStatus WINGDIPAPI GdipResetPageTransform(GpGraphics *graphics);
+GpStatus WINGDIPAPI GdipGetPageUnit(GpGraphics *graphics, GpUnit *unit);
+GpStatus WINGDIPAPI GdipGetPageScale(GpGraphics *graphics, REAL *scale);
+GpStatus WINGDIPAPI GdipSetPageUnit(GpGraphics *graphics, GpUnit unit);
+GpStatus WINGDIPAPI GdipSetPageScale(GpGraphics *graphics, REAL scale);
+GpStatus WINGDIPAPI GdipGetDpiX(GpGraphics *graphics, REAL* dpi);
+GpStatus WINGDIPAPI GdipGetDpiY(GpGraphics *graphics, REAL* dpi);
+GpStatus WINGDIPAPI GdipTransformPoints(GpGraphics *graphics, GpCoordinateSpace destSpace, GpCoordinateSpace srcSpace, GpPointF *points, INT count);
+GpStatus WINGDIPAPI GdipTransformPointsI(GpGraphics *graphics, GpCoordinateSpace destSpace, GpCoordinateSpace srcSpace, GpPoint *points, INT count);
+GpStatus WINGDIPAPI GdipGetNearestColor(GpGraphics *graphics, ARGB* argb);
+HPALETTE WINGDIPAPI GdipCreateHalftonePalette();
+GpStatus WINGDIPAPI GdipDrawLine(GpGraphics *graphics, GpPen *pen, REAL x1, REAL y1, REAL x2, REAL y2);
+GpStatus WINGDIPAPI GdipDrawLineI(GpGraphics *graphics, GpPen *pen, INT x1, INT y1, INT x2, INT y2);
+GpStatus WINGDIPAPI GdipDrawLines(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF *points, INT count);
+GpStatus WINGDIPAPI GdipDrawLinesI(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPoint *points, INT count);
+GpStatus WINGDIPAPI GdipDrawArc(GpGraphics *graphics, GpPen *pen, REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle);
+GpStatus WINGDIPAPI GdipDrawArcI(GpGraphics *graphics, GpPen *pen, INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle);
+GpStatus WINGDIPAPI GdipDrawBezier(GpGraphics *graphics, GpPen *pen, REAL x1, REAL y1, REAL x2, REAL y2, REAL x3, REAL y3, REAL x4, REAL y4);
+GpStatus WINGDIPAPI GdipDrawBezierI(GpGraphics *graphics, GpPen *pen, INT x1, INT y1, INT x2, INT y2, INT x3, INT y3, INT x4, INT y4);
+GpStatus WINGDIPAPI GdipDrawBeziers(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF *points, INT count);
+GpStatus WINGDIPAPI GdipDrawBeziersI(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPoint *points, INT count);
+GpStatus WINGDIPAPI GdipDrawRectangle(GpGraphics *graphics, GpPen *pen, REAL x, REAL y, REAL width, REAL height);
+GpStatus WINGDIPAPI GdipDrawRectangleI(GpGraphics *graphics, GpPen *pen, INT x, INT y, INT width, INT height);
+GpStatus WINGDIPAPI GdipDrawRectangles(GpGraphics *graphics, GpPen *pen, GDIPCONST GpRectF *rects, INT count);
+GpStatus WINGDIPAPI GdipDrawRectanglesI(GpGraphics *graphics, GpPen *pen, GDIPCONST GpRect *rects, INT count);
+GpStatus WINGDIPAPI GdipDrawEllipse(GpGraphics *graphics, GpPen *pen, REAL x, REAL y, REAL width, REAL height);
+GpStatus WINGDIPAPI GdipDrawEllipseI(GpGraphics *graphics, GpPen *pen, INT x, INT y, INT width, INT height);
+GpStatus WINGDIPAPI GdipDrawPie(GpGraphics *graphics, GpPen *pen, REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle);
+GpStatus WINGDIPAPI GdipDrawPieI(GpGraphics *graphics, GpPen *pen, INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle);
+GpStatus WINGDIPAPI GdipDrawPolygon(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF *points, INT count);
+GpStatus WINGDIPAPI GdipDrawPolygonI(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPoint *points, INT count);
+GpStatus WINGDIPAPI GdipDrawPath(GpGraphics *graphics, GpPen *pen, GpPath *path);
+GpStatus WINGDIPAPI GdipDrawCurve(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF *points, INT count);
+GpStatus WINGDIPAPI GdipDrawCurveI(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPoint *points, INT count);
+GpStatus WINGDIPAPI GdipDrawCurve2(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF *points, INT count, REAL tension);
+GpStatus WINGDIPAPI GdipDrawCurve2I(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPoint *points, INT count, REAL tension);
+GpStatus WINGDIPAPI GdipDrawCurve3(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF *points, INT count, INT offset, INT numberOfSegments, REAL tension);
+GpStatus WINGDIPAPI GdipDrawCurve3I(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPoint *points, INT count, INT offset, INT numberOfSegments, REAL tension);
+GpStatus WINGDIPAPI GdipDrawClosedCurve(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF *points, INT count);
+GpStatus WINGDIPAPI GdipDrawClosedCurveI(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPoint *points, INT count);
+GpStatus WINGDIPAPI GdipDrawClosedCurve2(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF *points, INT count, REAL tension);
+GpStatus WINGDIPAPI GdipDrawClosedCurve2I(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPoint *points, INT count, REAL tension);
+GpStatus WINGDIPAPI GdipGraphicsClear(GpGraphics *graphics, ARGB color);
+GpStatus WINGDIPAPI GdipFillRectangle(GpGraphics *graphics, GpBrush *brush, REAL x, REAL y, REAL width, REAL height);
+GpStatus WINGDIPAPI GdipFillRectangleI(GpGraphics *graphics, GpBrush *brush, INT x, INT y, INT width, INT height);
+GpStatus WINGDIPAPI GdipFillRectangles(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRectF *rects, INT count);
+GpStatus WINGDIPAPI GdipFillRectanglesI(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRect *rects, INT count);
+GpStatus WINGDIPAPI GdipFillPolygon(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpPointF *points, INT count, GpFillMode fillMode);
+GpStatus WINGDIPAPI GdipFillPolygonI(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpPoint *points, INT count, GpFillMode fillMode);
+GpStatus WINGDIPAPI GdipFillPolygon2(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpPointF *points, INT count);
+GpStatus WINGDIPAPI GdipFillPolygon2I(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpPoint *points, INT count);
+GpStatus WINGDIPAPI GdipFillEllipse(GpGraphics *graphics, GpBrush *brush, REAL x, REAL y, REAL width, REAL height);
+GpStatus WINGDIPAPI GdipFillEllipseI(GpGraphics *graphics, GpBrush *brush, INT x, INT y, INT width, INT height);
+GpStatus WINGDIPAPI GdipFillPie(GpGraphics *graphics, GpBrush *brush, REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle);
+GpStatus WINGDIPAPI GdipFillPieI(GpGraphics *graphics, GpBrush *brush, INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle);
+GpStatus WINGDIPAPI GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path);
+GpStatus WINGDIPAPI GdipFillClosedCurve(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpPointF *points, INT count);
+GpStatus WINGDIPAPI GdipFillClosedCurveI(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpPoint *points, INT count);
+GpStatus WINGDIPAPI GdipFillClosedCurve2I(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpPoint *points, INT count, REAL tension, GpFillMode fillMode);
+GpStatus WINGDIPAPI GdipFillRegion(GpGraphics *graphics, GpBrush *brush, GpRegion *region);
+GpStatus WINGDIPAPI GdipDrawImage(GpGraphics *graphics, GpImage *image, REAL x, REAL y);
+GpStatus WINGDIPAPI GdipDrawImageI(GpGraphics *graphics, GpImage *image, INT x, INT y);
+GpStatus WINGDIPAPI GdipDrawImageRect(GpGraphics *graphics, GpImage *image, REAL x, REAL y, REAL width, REAL height);
+GpStatus WINGDIPAPI GdipDrawImageRectI(GpGraphics *graphics, GpImage *image, INT x, INT y, INT width, INT height);
+GpStatus WINGDIPAPI GdipDrawImagePoints(GpGraphics *graphics, GpImage *image, GDIPCONST GpPointF *dstpoints, INT count);
+GpStatus WINGDIPAPI GdipDrawImagePointsI(GpGraphics *graphics, GpImage *image, GDIPCONST GpPoint *dstpoints, INT count);
+GpStatus WINGDIPAPI GdipDrawImagePointRect(GpGraphics *graphics, GpImage *image, REAL x, REAL y, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight, GpUnit srcUnit);
+GpStatus WINGDIPAPI GdipDrawImagePointRectI(GpGraphics *graphics, GpImage *image, INT x, INT y, INT srcx, INT srcy, INT srcwidth, INT srcheight, GpUnit srcUnit);
+GpStatus WINGDIPAPI GdipDrawImageRectRect(GpGraphics *graphics, GpImage *image, REAL dstx, REAL dsty, REAL dstwidth, REAL dstheight, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes, DrawImageAbort callback, VOID * callbackData);
+GpStatus WINGDIPAPI GdipDrawImageRectRectI(GpGraphics *graphics, GpImage *image, INT dstx, INT dsty, INT dstwidth, INT dstheight, INT srcx, INT srcy, INT srcwidth, INT srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes, DrawImageAbort callback, VOID * callbackData);
+GpStatus WINGDIPAPI GdipDrawImagePointsRect(GpGraphics *graphics, GpImage *image, GDIPCONST GpPointF *points, INT count, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes, DrawImageAbort callback, VOID * callbackData);
+GpStatus WINGDIPAPI GdipDrawImagePointsRectI(GpGraphics *graphics, GpImage *image, GDIPCONST GpPoint *points, INT count, INT srcx, INT srcy, INT srcwidth, INT srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes, DrawImageAbort callback, VOID * callbackData);
+GpStatus WINGDIPAPI GdipDrawImageFX(GpGraphics *graphics, GpImage *image, GpRectF *source, GpMatrix *xForm, CGpEffect *effect, GpImageAttributes *imageAttributes, GpUnit srcUnit);
+GpStatus WINGDIPAPI GdipEnumerateMetafileDestPoint(GpGraphics * graphics, GDIPCONST GpMetafile * metafile, GDIPCONST PointF & destPoint, EnumerateMetafileProc callback, VOID * callbackData, GDIPCONST GpImageAttributes * imageAttributes);
+GpStatus WINGDIPAPI GdipEnumerateMetafileDestPointI(GpGraphics * graphics, GDIPCONST GpMetafile * metafile, GDIPCONST Point & destPoint, EnumerateMetafileProc callback, VOID * callbackData, GDIPCONST GpImageAttributes * imageAttributes);
+GpStatus WINGDIPAPI GdipEnumerateMetafileDestRect(GpGraphics * graphics, GDIPCONST GpMetafile * metafile, GDIPCONST RectF & destRect, EnumerateMetafileProc callback, VOID * callbackData, GDIPCONST GpImageAttributes * imageAttributes);
+GpStatus WINGDIPAPI GdipEnumerateMetafileDestRectI(GpGraphics * graphics, GDIPCONST GpMetafile * metafile, GDIPCONST Rect & destRect, EnumerateMetafileProc callback, VOID * callbackData, GDIPCONST GpImageAttributes * imageAttributes);
+GpStatus WINGDIPAPI GdipEnumerateMetafileDestPoints(GpGraphics * graphics, GDIPCONST GpMetafile * metafile, GDIPCONST PointF * destPoints, INT count, EnumerateMetafileProc callback, VOID * callbackData, GDIPCONST GpImageAttributes * imageAttributes);
+GpStatus WINGDIPAPI GdipEnumerateMetafileDestPointsI(GpGraphics * graphics, GDIPCONST GpMetafile * metafile, GDIPCONST Point * destPoints, INT count, EnumerateMetafileProc callback, VOID * callbackData, GDIPCONST GpImageAttributes * imageAttributes);
+GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPoint(GpGraphics * graphics, GDIPCONST GpMetafile * metafile, GDIPCONST PointF & destPoint, GDIPCONST RectF & srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID * callbackData, GDIPCONST GpImageAttributes * imageAttributes);
+GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPointI(GpGraphics * graphics, GDIPCONST GpMetafile * metafile, GDIPCONST Point & destPoint, GDIPCONST Rect & srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID * callbackData, GDIPCONST GpImageAttributes * imageAttributes);
+GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestRect(GpGraphics * graphics, GDIPCONST GpMetafile * metafile, GDIPCONST RectF & destRect, GDIPCONST RectF & srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID * callbackData, GDIPCONST GpImageAttributes * imageAttributes);
+GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestRectI(GpGraphics * graphics, GDIPCONST GpMetafile * metafile, GDIPCONST Rect & destRect, GDIPCONST Rect & srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID * callbackData, GDIPCONST GpImageAttributes * imageAttributes);
+GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPoints(GpGraphics * graphics, GDIPCONST GpMetafile * metafile, GDIPCONST PointF * destPoints, INT count, GDIPCONST RectF & srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID * callbackData, GDIPCONST GpImageAttributes * imageAttributes);
+GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPointsI(GpGraphics * graphics, GDIPCONST GpMetafile * metafile, GDIPCONST Point * destPoints, INT count, GDIPCONST Rect & srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID * callbackData, GDIPCONST GpImageAttributes * imageAttributes);
+GpStatus WINGDIPAPI GdipPlayMetafileRecord(GDIPCONST GpMetafile * metafile, EmfPlusRecordType recordType, UINT flags, UINT dataSize, GDIPCONST BYTE * data);
+GpStatus WINGDIPAPI GdipSetClipGraphics(GpGraphics *graphics, GpGraphics *srcgraphics, CombineMode combineMode);
+GpStatus WINGDIPAPI GdipSetClipRect(GpGraphics *graphics, REAL x, REAL y, REAL width, REAL height, CombineMode combineMode);
+GpStatus WINGDIPAPI GdipSetClipRectI(GpGraphics *graphics, INT x, INT y, INT width, INT height, CombineMode combineMode);
+GpStatus WINGDIPAPI GdipSetClipPath(GpGraphics *graphics, GpPath *path, CombineMode combineMode);
+GpStatus WINGDIPAPI GdipSetClipRegion(GpGraphics *graphics, GpRegion *region, CombineMode combineMode);
+GpStatus WINGDIPAPI GdipSetClipHrgn(GpGraphics *graphics, HRGN hRgn, CombineMode combineMode);
+GpStatus WINGDIPAPI GdipResetClip(GpGraphics *graphics);
+GpStatus WINGDIPAPI GdipTranslateClip(GpGraphics *graphics, REAL dx, REAL dy);
+GpStatus WINGDIPAPI GdipTranslateClipI(GpGraphics *graphics, INT dx, INT dy);
+GpStatus WINGDIPAPI GdipGetClip(GpGraphics *graphics, GpRegion *region);
+GpStatus WINGDIPAPI GdipGetClipBounds(GpGraphics *graphics, GpRectF *rect);
+GpStatus WINGDIPAPI GdipGetClipBoundsI(GpGraphics *graphics, GpRect *rect);
+GpStatus WINGDIPAPI GdipIsClipEmpty(GpGraphics *graphics, BOOL *result);
+GpStatus WINGDIPAPI GdipGetVisibleClipBounds(GpGraphics *graphics, GpRectF *rect);
+GpStatus WINGDIPAPI GdipGetVisibleClipBoundsI(GpGraphics *graphics, GpRect *rect);
+GpStatus WINGDIPAPI GdipIsVisibleClipEmpty(GpGraphics *graphics, BOOL *result);
+GpStatus WINGDIPAPI GdipIsVisiblePoint(GpGraphics *graphics, REAL x, REAL y, BOOL *result);
+GpStatus WINGDIPAPI GdipIsVisiblePointI(GpGraphics *graphics, INT x, INT y, BOOL *result);
+GpStatus WINGDIPAPI GdipIsVisibleRect(GpGraphics *graphics, REAL x, REAL y, REAL width, REAL height, BOOL *result);
+GpStatus WINGDIPAPI GdipIsVisibleRectI(GpGraphics *graphics, INT x, INT y, INT width, INT height, BOOL *result);
+GpStatus WINGDIPAPI GdipSaveGraphics(GpGraphics *graphics, GraphicsState *state);
+GpStatus WINGDIPAPI GdipRestoreGraphics(GpGraphics *graphics, GraphicsState state);
+GpStatus WINGDIPAPI GdipBeginContainer(GpGraphics *graphics, GDIPCONST GpRectF* dstrect, GDIPCONST GpRectF *srcrect, GpUnit unit, GraphicsContainer *state);
+GpStatus WINGDIPAPI GdipBeginContainerI(GpGraphics *graphics, GDIPCONST GpRect* dstrect, GDIPCONST GpRect *srcrect, GpUnit unit, GraphicsContainer *state);
+GpStatus WINGDIPAPI GdipBeginContainer2(GpGraphics *graphics, GraphicsContainer* state);
+GpStatus WINGDIPAPI GdipEndContainer(GpGraphics *graphics, GraphicsContainer state);
+GpStatus WINGDIPAPI GdipGetMetafileHeaderFromEmf(HENHMETAFILE hEmf, MetafileHeader * header);
+GpStatus WINGDIPAPI GdipGetMetafileHeaderFromFile(GDIPCONST WCHAR* filename, MetafileHeader * header);
+GpStatus WINGDIPAPI GdipGetMetafileHeaderFromStream(IStream * stream, MetafileHeader * header);
+GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile, MetafileHeader * header);
+GpStatus WINGDIPAPI GdipGetHemfFromMetafile(GpMetafile * metafile, HENHMETAFILE * hEmf);
+GpStatus WINGDIPAPI GdipCreateStreamOnFile(GDIPCONST WCHAR * filename, UINT access, IStream **stream);
+GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE hWmf, BOOL deleteWmf, GDIPCONST WmfPlaceableFileHeader * wmfPlaceableFileHeader, GpMetafile **metafile);
+GpStatus WINGDIPAPI GdipCreateMetafileFromEmf(HENHMETAFILE hEmf, BOOL deleteEmf, GpMetafile **metafile);
+GpStatus WINGDIPAPI GdipCreateMetafileFromFile(GDIPCONST WCHAR* file, GpMetafile **metafile);
+GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR* file, GDIPCONST WmfPlaceableFileHeader * wmfPlaceableFileHeader, GpMetafile **metafile);
+GpStatus WINGDIPAPI GdipCreateMetafileFromStream(IStream * stream, GpMetafile **metafile);
+GpStatus WINGDIPAPI GdipRecordMetafile(HDC referenceHdc, EmfType type, GDIPCONST GpRectF * frameRect, MetafileFrameUnit frameUnit, GDIPCONST WCHAR * description, GpMetafile ** metafile);
+GpStatus WINGDIPAPI GdipRecordMetafileI(HDC referenceHdc, EmfType type, GDIPCONST GpRect * frameRect, MetafileFrameUnit frameUnit, GDIPCONST WCHAR * description, GpMetafile ** metafile);
+GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName, HDC referenceHdc, EmfType type, GDIPCONST GpRectF * frameRect, MetafileFrameUnit frameUnit, GDIPCONST WCHAR * description, GpMetafile ** metafile);
+GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC referenceHdc, EmfType type, GDIPCONST GpRect * frameRect, MetafileFrameUnit frameUnit, GDIPCONST WCHAR * description, GpMetafile ** metafile);
+GpStatus WINGDIPAPI GdipRecordMetafileStream(IStream * stream, HDC referenceHdc, EmfType type, GDIPCONST GpRectF * frameRect, MetafileFrameUnit frameUnit, GDIPCONST WCHAR * description, GpMetafile ** metafile);
+GpStatus WINGDIPAPI GdipRecordMetafileStreamI(IStream * stream, HDC referenceHdc, EmfType type, GDIPCONST GpRect * frameRect, MetafileFrameUnit frameUnit, GDIPCONST WCHAR * description, GpMetafile ** metafile);
+GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit(GpMetafile * metafile, UINT metafileRasterizationLimitDpi);
+GpStatus WINGDIPAPI GdipGetMetafileDownLevelRasterizationLimit(GDIPCONST GpMetafile * metafile, UINT * metafileRasterizationLimitDpi);
+GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size);
+GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders);
+GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size);
+GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders);
+GpStatus WINGDIPAPI GdipComment(GpGraphics* graphics, UINT sizeData, GDIPCONST BYTE * data);
+
+GpStatus WINGDIPAPI GdipComment(GpGraphics* graphics, UINT sizeData, GDIPCONST BYTE * data);
+GpStatus WINGDIPAPI GdipCreatePath2(GDIPCONST GpPointF* points, GDIPCONST BYTE* types, INT count, GpFillMode fillMode, GpPath **path);
+GpStatus WINGDIPAPI GdipCreatePath2I(GDIPCONST GpPoint* points, GDIPCONST BYTE* types, INT count, GpFillMode fillMode, GpPath **path);
+GpStatus WINGDIPAPI GdipClonePath(GpPath* path, GpPath **clonePath);
+GpStatus WINGDIPAPI GdipDeletePath(GpPath* path);
+GpStatus WINGDIPAPI GdipResetPath(GpPath* path);
+GpStatus WINGDIPAPI GdipGetPointCount(GpPath* path, INT* count);
+GpStatus WINGDIPAPI GdipGetPathTypes(GpPath* path, BYTE* types, INT count);
+GpStatus WINGDIPAPI GdipGetPathPoints(GpPath* path, GpPointF* points, INT count);
+GpStatus WINGDIPAPI GdipGetPathPointsI(GpPath* path, GpPoint* points, INT count);
+GpStatus WINGDIPAPI GdipGetPathFillMode(GpPath *path, GpFillMode *fillmode);
+GpStatus WINGDIPAPI GdipSetPathFillMode(GpPath *path, GpFillMode fillmode);
+GpStatus WINGDIPAPI GdipGetPathData(GpPath *path, GpPathData* pathData);
+GpStatus WINGDIPAPI GdipStartPathFigure(GpPath *path);
+GpStatus WINGDIPAPI GdipClosePathFigure(GpPath *path);
+GpStatus WINGDIPAPI GdipClosePathFigures(GpPath *path);
+GpStatus WINGDIPAPI GdipSetPathMarker(GpPath* path);
+GpStatus WINGDIPAPI GdipClearPathMarkers(GpPath* path);
+GpStatus WINGDIPAPI GdipReversePath(GpPath* path);
+GpStatus WINGDIPAPI GdipGetPathLastPoint(GpPath* path, GpPointF* lastPoint);
+GpStatus WINGDIPAPI GdipAddPathLine(GpPath *path, REAL x1, REAL y1, REAL x2, REAL y2);
+GpStatus WINGDIPAPI GdipAddPathLine2(GpPath *path, GDIPCONST GpPointF *points, INT count);
+GpStatus WINGDIPAPI GdipAddPathArc(GpPath *path, REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle);
+GpStatus WINGDIPAPI GdipAddPathBezier(GpPath *path, REAL x1, REAL y1, REAL x2, REAL y2, REAL x3, REAL y3, REAL x4, REAL y4);
+GpStatus WINGDIPAPI GdipAddPathBeziers(GpPath *path, GDIPCONST GpPointF *points, INT count);
+GpStatus WINGDIPAPI GdipAddPathCurve(GpPath *path, GDIPCONST GpPointF *points, INT count);
+GpStatus WINGDIPAPI GdipAddPathCurve2(GpPath *path, GDIPCONST GpPointF *points, INT count, REAL tension);
+GpStatus WINGDIPAPI GdipAddPathCurve3(GpPath *path, GDIPCONST GpPointF *points, INT count, INT offset, INT numberOfSegments, REAL tension);
+GpStatus WINGDIPAPI GdipAddPathClosedCurve(GpPath *path, GDIPCONST GpPointF *points, INT count);
+GpStatus WINGDIPAPI GdipAddPathClosedCurve2(GpPath *path, GDIPCONST GpPointF *points, INT count, REAL tension);
+GpStatus WINGDIPAPI GdipAddPathRectangle(GpPath *path, REAL x, REAL y, REAL width, REAL height);
+GpStatus WINGDIPAPI GdipAddPathRectangles(GpPath *path, GDIPCONST GpRectF *rects, INT count);
+GpStatus WINGDIPAPI GdipAddPathEllipse(GpPath *path, REAL x, REAL y, REAL width, REAL height);
+GpStatus WINGDIPAPI GdipAddPathPie(GpPath *path, REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle);
+GpStatus WINGDIPAPI GdipAddPathPolygon(GpPath *path, GDIPCONST GpPointF *points, INT count);
+GpStatus WINGDIPAPI GdipAddPathPath(GpPath *path, GDIPCONST GpPath* addingPath, BOOL connect);
+GpStatus WINGDIPAPI GdipAddPathString(GpPath *path, GDIPCONST WCHAR *string, INT length, GDIPCONST GpFontFamily *family, INT style, REAL emSize, GDIPCONST RectF *layoutRect, GDIPCONST GpStringFormat *format);
+GpStatus WINGDIPAPI GdipAddPathStringI(GpPath *path, GDIPCONST WCHAR *string, INT length, GDIPCONST GpFontFamily *family, INT style, REAL emSize, GDIPCONST Rect *layoutRect, GDIPCONST GpStringFormat *format);
+GpStatus WINGDIPAPI GdipAddPathLineI(GpPath *path, INT x1, INT y1, INT x2, INT y2);
+GpStatus WINGDIPAPI GdipAddPathLine2I(GpPath *path, GDIPCONST GpPoint *points, INT count);
+GpStatus WINGDIPAPI GdipAddPathArcI(GpPath *path, INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle);
+GpStatus WINGDIPAPI GdipAddPathBezierI(GpPath *path, INT x1, INT y1, INT x2, INT y2, INT x3, INT y3, INT x4, INT y4);
+GpStatus WINGDIPAPI GdipAddPathBeziersI(GpPath *path, GDIPCONST GpPoint *points, INT count);
+GpStatus WINGDIPAPI GdipAddPathCurveI(GpPath *path, GDIPCONST GpPoint *points, INT count);
+GpStatus WINGDIPAPI GdipAddPathCurve2I(GpPath *path, GDIPCONST GpPoint *points, INT count, REAL tension);
+GpStatus WINGDIPAPI GdipAddPathCurve3I(GpPath *path, GDIPCONST GpPoint *points, INT count, INT offset, INT numberOfSegments, REAL tension);
+GpStatus WINGDIPAPI GdipAddPathClosedCurveI(GpPath *path, GDIPCONST GpPoint *points, INT count);
+GpStatus WINGDIPAPI GdipAddPathClosedCurve2I(GpPath *path, GDIPCONST GpPoint *points, INT count, REAL tension);
+GpStatus WINGDIPAPI GdipAddPathRectangleI(GpPath *path, INT x, INT y, INT width, INT height);
+GpStatus WINGDIPAPI GdipAddPathRectanglesI(GpPath *path, GDIPCONST GpRect *rects, INT count);
+GpStatus WINGDIPAPI GdipAddPathEllipseI(GpPath *path, INT x, INT y, INT width, INT height);
+GpStatus WINGDIPAPI GdipAddPathPieI(GpPath *path, INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle);
+GpStatus WINGDIPAPI GdipAddPathPolygonI(GpPath *path, GDIPCONST GpPoint *points, INT count);
+GpStatus WINGDIPAPI GdipFlattenPath(GpPath *path, GpMatrix* matrix, REAL flatness);
+GpStatus WINGDIPAPI GdipWindingModeOutline(GpPath *path, GpMatrix *matrix, REAL flatness);
+GpStatus WINGDIPAPI GdipWidenPath(GpPath *nativePath, GpPen *pen, GpMatrix *matrix, REAL flatness);
+GpStatus WINGDIPAPI GdipWarpPath(GpPath *path, GpMatrix* matrix, GDIPCONST GpPointF *points, INT count, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight, WarpMode warpMode, REAL flatness);
+GpStatus WINGDIPAPI GdipTransformPath(GpPath* path, GpMatrix* matrix);
+GpStatus WINGDIPAPI GdipGetPathWorldBounds(GpPath* path, GpRectF* bounds, GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen);
+GpStatus WINGDIPAPI GdipGetPathWorldBoundsI(GpPath* path, GpRect* bounds, GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen);
+GpStatus WINGDIPAPI GdipIsVisiblePathPoint(GpPath* path, REAL x, REAL y, GpGraphics *graphics, BOOL *result);
+GpStatus WINGDIPAPI GdipIsVisiblePathPointI(GpPath* path, INT x, INT y, GpGraphics *graphics, BOOL *result);
+GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPoint(GpPath* path, REAL x, REAL y, GpPen *pen, GpGraphics *graphics, BOOL *result);
+GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPointI(GpPath* path, INT x, INT y, GpPen *pen, GpGraphics *graphics, BOOL *result);
+
+GpStatus WINGDIPAPI GdipCreateHatchBrush(GpHatchStyle hatchstyle, ARGB forecol, ARGB backcol, GpHatch **brush);
+GpStatus WINGDIPAPI GdipGetHatchStyle(GpHatch *brush, GpHatchStyle *hatchstyle);
+GpStatus WINGDIPAPI GdipGetHatchForegroundColor(GpHatch *brush, ARGB* forecol);
+GpStatus WINGDIPAPI GdipGetHatchBackgroundColor(GpHatch *brush, ARGB* backcol);
+
+GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream* stream, GpImage **image);
+GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename, GpImage **image);
+GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image);
+GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename, GpImage **image);
+GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage);
+GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image);
+GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename, GDIPCONST CLSID* clsidEncoder, GDIPCONST EncoderParameters* encoderParams);
+GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream, GDIPCONST CLSID* clsidEncoder, GDIPCONST EncoderParameters* encoderParams);
+GpStatus WINGDIPAPI GdipSaveAdd(GpImage *image, GDIPCONST EncoderParameters* encoderParams);
+GpStatus WINGDIPAPI GdipSaveAddImage(GpImage *image, GpImage* newImage, GDIPCONST EncoderParameters* encoderParams);
+GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image, GpGraphics **graphics);
+GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect, GpUnit *srcUnit);
+GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width, REAL *height);
+GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type);
+GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width);
+GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height);
+GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *resolution);
+GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *resolution);
+GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags);
+GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format);
+GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format);
+GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage *image, UINT thumbWidth, UINT thumbHeight, GpImage **thumbImage, GetThumbnailImageAbort callback, VOID * callbackData);
+GpStatus WINGDIPAPI GdipGetEncoderParameterListSize(GpImage *image, GDIPCONST CLSID* clsidEncoder, UINT* size);
+GpStatus WINGDIPAPI GdipGetEncoderParameterList(GpImage *image, GDIPCONST CLSID* clsidEncoder, UINT size, EncoderParameters* buffer);
+GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage* image, UINT* count);
+GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image, GUID* dimensionIDs, UINT count);
+GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image, GDIPCONST GUID* dimensionID, UINT* count);
+GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image, GDIPCONST GUID* dimensionID, UINT frameIndex);
+GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage *image, RotateFlipType rfType);
+GpStatus WINGDIPAPI GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size);
+GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image, GDIPCONST ColorPalette *palette);
+GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size);
+GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT* numOfProperty);
+GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT numOfProperty, PROPID* list);
+GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID propId, UINT* size);
+GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID propId,UINT propSize, PropertyItem* buffer);
+GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT* totalBufferSize, UINT* numProperties);
+GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT totalBufferSize, UINT numProperties, PropertyItem* allItems);
+GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId);
+GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item);
+GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item);
+GpStatus WINGDIPAPI GdipFindNextImageItem(GpImage *image, ImageItemData* item);
+GpStatus WINGDIPAPI GdipGetImageItemData(GpImage *image, ImageItemData* item);
+GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* refGraphics, GpMetafile* metafile, BOOL* conversionSuccess, EmfType emfType, const WCHAR* description, GpMetafile** out_metafile);
+GpStatus WINGDIPAPI GdipConvertToEmfPlusToFile(const GpGraphics* refGraphics, GpMetafile* metafile, BOOL* conversionSuccess, const WCHAR* filename, EmfType emfType, const WCHAR* description, GpMetafile** out_metafile);
+GpStatus WINGDIPAPI GdipConvertToEmfPlusToStream(const GpGraphics* refGraphics, GpMetafile* metafile, BOOL* conversionSuccess, IStream* stream, EmfType emfType, const WCHAR* description, GpMetafile** out_metafile);
+GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image);
+
+GpStatus WINGDIPAPI GdipCreateImageAttributes(GpImageAttributes **imageattr);
+GpStatus WINGDIPAPI GdipCloneImageAttributes(GDIPCONST GpImageAttributes *imageattr, GpImageAttributes **cloneImageattr);
+GpStatus WINGDIPAPI GdipDisposeImageAttributes(GpImageAttributes *imageattr);
+GpStatus WINGDIPAPI GdipSetImageAttributesToIdentity(GpImageAttributes *imageattr, ColorAdjustType type);
+GpStatus WINGDIPAPI GdipResetImageAttributes(GpImageAttributes *imageattr, ColorAdjustType type);
+GpStatus WINGDIPAPI GdipSetImageAttributesColorMatrix(GpImageAttributes *imageattr, ColorAdjustType type, BOOL enableFlag, GDIPCONST ColorMatrix* colorMatrix, GDIPCONST ColorMatrix* grayMatrix, ColorMatrixFlags flags);
+GpStatus WINGDIPAPI GdipSetImageAttributesThreshold(GpImageAttributes *imageattr, ColorAdjustType type, BOOL enableFlag, REAL threshold);
+GpStatus WINGDIPAPI GdipSetImageAttributesGamma(GpImageAttributes *imageattr, ColorAdjustType type, BOOL enableFlag, REAL gamma);
+GpStatus WINGDIPAPI GdipSetImageAttributesNoOp(GpImageAttributes *imageattr, ColorAdjustType type, BOOL enableFlag);
+GpStatus WINGDIPAPI GdipSetImageAttributesColorKeys(GpImageAttributes *imageattr, ColorAdjustType type, BOOL enableFlag, ARGB colorLow, ARGB colorHigh);
+GpStatus WINGDIPAPI GdipSetImageAttributesOutputChannel(GpImageAttributes *imageattr, ColorAdjustType type, BOOL enableFlag, ColorChannelFlags channelFlags);
+GpStatus WINGDIPAPI GdipSetImageAttributesOutputChannelColorProfile(GpImageAttributes *imageattr, ColorAdjustType type, BOOL enableFlag, GDIPCONST WCHAR *colorProfileFilename);
+GpStatus WINGDIPAPI GdipSetImageAttributesRemapTable(GpImageAttributes *imageattr, ColorAdjustType type, BOOL enableFlag, UINT mapSize, GDIPCONST ColorMap *map);
+GpStatus WINGDIPAPI GdipSetImageAttributesWrapMode(GpImageAttributes *imageAttr, WrapMode wrap, ARGB argb, BOOL clamp);
+GpStatus WINGDIPAPI GdipSetImageAttributesICMMode(GpImageAttributes *imageAttr, BOOL on);
+GpStatus WINGDIPAPI GdipGetImageAttributesAdjustedPalette(GpImageAttributes *imageAttr, ColorPalette * colorPalette, ColorAdjustType colorAdjustType);
+GpStatus WINGDIPAPI GdipSetImageAttributesCachedBackground(GpImageAttributes *imageattr, BOOL enableFlag);
+
+GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF* point1, GDIPCONST GpPointF* point2, ARGB color1, ARGB color2, GpWrapMode wrapMode, GpLineGradient **lineGradient);
+GpStatus WINGDIPAPI GdipCreateLineBrushI(GDIPCONST GpPoint* point1, GDIPCONST GpPoint* point2, ARGB color1, ARGB color2, GpWrapMode wrapMode, GpLineGradient **lineGradient);
+GpStatus WINGDIPAPI GdipCreateLineBrushFromRect(GDIPCONST GpRectF* rect, ARGB color1, ARGB color2, LinearGradientMode mode, GpWrapMode wrapMode, GpLineGradient **lineGradient);
+GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI(GDIPCONST GpRect* rect, ARGB color1, ARGB color2, LinearGradientMode mode, GpWrapMode wrapMode, GpLineGradient **lineGradient);
+GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngle(GDIPCONST GpRectF* rect, ARGB color1, ARGB color2, REAL angle, BOOL isAngleScalable, GpWrapMode wrapMode, GpLineGradient **lineGradient);
+GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngleI(GDIPCONST GpRect* rect, ARGB color1, ARGB color2, REAL angle, BOOL isAngleScalable, GpWrapMode wrapMode, GpLineGradient **lineGradient);
+GpStatus WINGDIPAPI GdipSetLineColors(GpLineGradient *brush, ARGB color1, ARGB color2);
+GpStatus WINGDIPAPI GdipGetLineColors(GpLineGradient *brush, ARGB* colors);
+GpStatus WINGDIPAPI GdipGetLineRect(GpLineGradient *brush, GpRectF *rect);
+GpStatus WINGDIPAPI GdipGetLineRectI(GpLineGradient *brush, GpRect *rect);
+GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient *brush, BOOL useGammaCorrection);
+GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient *brush, BOOL *useGammaCorrection);
+GpStatus WINGDIPAPI GdipGetLineBlendCount(GpLineGradient *brush, INT *count);
+GpStatus WINGDIPAPI GdipGetLineBlend(GpLineGradient *brush, REAL *blend, REAL* positions, INT count);
+GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient *brush, GDIPCONST REAL *blend, GDIPCONST REAL* positions, INT count);
+GpStatus WINGDIPAPI GdipGetLinePresetBlendCount(GpLineGradient *brush, INT *count);
+GpStatus WINGDIPAPI GdipGetLinePresetBlend(GpLineGradient *brush, ARGB *blend, REAL* positions, INT count);
+GpStatus WINGDIPAPI GdipSetLinePresetBlend(GpLineGradient *brush, GDIPCONST ARGB *blend, GDIPCONST REAL* positions, INT count);
+GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient *brush, REAL focus, REAL scale);
+GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient *brush, REAL focus, REAL scale);
+GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient *brush, GpWrapMode wrapmode);
+GpStatus WINGDIPAPI GdipGetLineWrapMode(GpLineGradient *brush, GpWrapMode *wrapmode);
+GpStatus WINGDIPAPI GdipGetLineTransform(GpLineGradient *brush, GpMatrix *matrix);
+GpStatus WINGDIPAPI GdipSetLineTransform(GpLineGradient *brush, GDIPCONST GpMatrix *matrix);
+GpStatus WINGDIPAPI GdipResetLineTransform(GpLineGradient* brush);
+GpStatus WINGDIPAPI GdipMultiplyLineTransform(GpLineGradient* brush, GDIPCONST GpMatrix *matrix, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipTranslateLineTransform(GpLineGradient* brush, REAL dx, REAL dy, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipScaleLineTransform(GpLineGradient* brush, REAL sx, REAL sy, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipRotateLineTransform(GpLineGradient* brush, REAL angle, GpMatrixOrder order);
+
+GpStatus WINGDIPAPI GdipCreateMatrix(GpMatrix **matrix);
+GpStatus WINGDIPAPI GdipCreateMatrix2(REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy, GpMatrix **matrix);
+GpStatus WINGDIPAPI GdipCreateMatrix3(GDIPCONST GpRectF *rect, GDIPCONST GpPointF *dstplg, GpMatrix **matrix);
+GpStatus WINGDIPAPI GdipCreateMatrix3I(GDIPCONST GpRect *rect, GDIPCONST GpPoint *dstplg, GpMatrix **matrix);
+GpStatus WINGDIPAPI GdipCloneMatrix(GpMatrix *matrix, GpMatrix **cloneMatrix);
+GpStatus WINGDIPAPI GdipDeleteMatrix(GpMatrix *matrix);
+GpStatus WINGDIPAPI GdipSetMatrixElements(GpMatrix *matrix, REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy);
+GpStatus WINGDIPAPI GdipMultiplyMatrix(GpMatrix *matrix, GpMatrix* matrix2, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipTranslateMatrix(GpMatrix *matrix, REAL offsetX, REAL offsetY, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipScaleMatrix(GpMatrix *matrix, REAL scaleX, REAL scaleY, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipRotateMatrix(GpMatrix *matrix, REAL angle, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipShearMatrix(GpMatrix *matrix, REAL shearX, REAL shearY, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipInvertMatrix(GpMatrix *matrix);
+GpStatus WINGDIPAPI GdipTransformMatrixPoints(GpMatrix *matrix, GpPointF *pts, INT count);
+GpStatus WINGDIPAPI GdipTransformMatrixPointsI(GpMatrix *matrix, GpPoint *pts, INT count);
+GpStatus WINGDIPAPI GdipVectorTransformMatrixPoints(GpMatrix *matrix, GpPointF *pts, INT count);
+GpStatus WINGDIPAPI GdipVectorTransformMatrixPointsI(GpMatrix *matrix, GpPoint *pts, INT count);
+GpStatus WINGDIPAPI GdipGetMatrixElements(GDIPCONST GpMatrix *matrix, REAL *matrixOut);
+GpStatus WINGDIPAPI GdipIsMatrixInvertible(GDIPCONST GpMatrix *matrix, BOOL *result);
+GpStatus WINGDIPAPI GdipIsMatrixIdentity(GDIPCONST GpMatrix *matrix, BOOL *result);
+GpStatus WINGDIPAPI GdipIsMatrixEqual(GDIPCONST GpMatrix *matrix, GDIPCONST GpMatrix *matrix2, BOOL *result);
+
+GpStatus WINGDIPAPI GdiplusNotificationHook(OUT ULONG_PTR *token);
+VOID WINGDIPAPI GdiplusNotificationUnhook(ULONG_PTR token);
+
+GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF* points, INT count, GpWrapMode wrapMode, GpPathGradient **polyGradient);
+GpStatus WINGDIPAPI GdipCreatePathGradientI(GDIPCONST GpPoint* points, INT count, GpWrapMode wrapMode, GpPathGradient **polyGradient);
+GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath* path, GpPathGradient **polyGradient);
+GpStatus WINGDIPAPI GdipGetPathGradientCenterColor(GpPathGradient *brush, ARGB* colors);
+GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient *brush, ARGB colors);
+GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient *brush, ARGB* color, INT* count);
+GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount(GpPathGradient *brush, GDIPCONST ARGB* color, INT* count);
+GpStatus WINGDIPAPI GdipGetPathGradientPath(GpPathGradient *brush, GpPath *path);
+GpStatus WINGDIPAPI GdipSetPathGradientPath(GpPathGradient *brush, GDIPCONST GpPath *path);
+GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient *brush, GpPointF* points);
+GpStatus WINGDIPAPI GdipGetPathGradientCenterPointI(GpPathGradient *brush, GpPoint* points);
+GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient *brush, GDIPCONST GpPointF* points);
+GpStatus WINGDIPAPI GdipSetPathGradientCenterPointI(GpPathGradient *brush, GDIPCONST GpPoint* points);
+GpStatus WINGDIPAPI GdipGetPathGradientRect(GpPathGradient *brush, GpRectF *rect);
+GpStatus WINGDIPAPI GdipGetPathGradientRectI(GpPathGradient *brush, GpRect *rect);
+GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient *brush, INT* count);
+GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorCount(GpPathGradient *brush, INT* count);
+GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient *brush, BOOL useGammaCorrection);
+GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient *brush, BOOL *useGammaCorrection);
+GpStatus WINGDIPAPI GdipGetPathGradientBlendCount(GpPathGradient *brush, INT *count);
+GpStatus WINGDIPAPI GdipGetPathGradientBlend(GpPathGradient *brush, REAL *blend, REAL *positions, INT count);
+GpStatus WINGDIPAPI GdipSetPathGradientBlend(GpPathGradient *brush, GDIPCONST REAL *blend, GDIPCONST REAL *positions, INT count);
+GpStatus WINGDIPAPI GdipGetPathGradientPresetBlendCount(GpPathGradient *brush, INT *count);
+GpStatus WINGDIPAPI GdipGetPathGradientPresetBlend(GpPathGradient *brush, ARGB *blend, REAL* positions, INT count);
+GpStatus WINGDIPAPI GdipSetPathGradientPresetBlend(GpPathGradient *brush, GDIPCONST ARGB *blend, GDIPCONST REAL* positions, INT count);
+GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend(GpPathGradient *brush, REAL focus, REAL scale);
+GpStatus WINGDIPAPI GdipGetPathGradientWrapMode(GpPathGradient *brush, GpWrapMode *wrapmode);
+GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient *brush, GpWrapMode wrapmode);
+GpStatus WINGDIPAPI GdipGetPathGradientTransform(GpPathGradient *brush, GpMatrix *matrix);
+GpStatus WINGDIPAPI GdipSetPathGradientTransform(GpPathGradient *brush, GpMatrix *matrix);
+GpStatus WINGDIPAPI GdipResetPathGradientTransform(GpPathGradient* brush);
+GpStatus WINGDIPAPI GdipMultiplyPathGradientTransform(GpPathGradient* brush, GDIPCONST GpMatrix *matrix, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipTranslatePathGradientTransform(GpPathGradient* brush, REAL dx, REAL dy, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipScalePathGradientTransform(GpPathGradient* brush, REAL sx, REAL sy, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipRotatePathGradientTransform(GpPathGradient* brush, REAL angle, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient *brush, REAL* xScale, REAL* yScale);
+GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient *brush, REAL xScale, REAL yScale);
+
+GpStatus WINGDIPAPI GdipCreatePathIter(GpPathIterator **iterator, GpPath* path);
+GpStatus WINGDIPAPI GdipDeletePathIter(GpPathIterator *iterator);
+GpStatus WINGDIPAPI GdipPathIterNextSubpath(GpPathIterator* iterator, INT *resultCount, INT* startIndex, INT* endIndex, BOOL* isClosed);
+GpStatus WINGDIPAPI GdipPathIterNextSubpathPath(GpPathIterator* iterator, INT* resultCount, GpPath* path, BOOL* isClosed);
+GpStatus WINGDIPAPI GdipPathIterNextPathType(GpPathIterator* iterator, INT* resultCount, BYTE* pathType, INT* startIndex, INT* endIndex);
+GpStatus WINGDIPAPI GdipPathIterNextMarker(GpPathIterator* iterator, INT *resultCount, INT* startIndex, INT* endIndex);
+GpStatus WINGDIPAPI GdipPathIterNextMarkerPath(GpPathIterator* iterator, INT* resultCount, GpPath* path);
+GpStatus WINGDIPAPI GdipPathIterGetCount(GpPathIterator* iterator, INT* count);
+GpStatus WINGDIPAPI GdipPathIterGetSubpathCount(GpPathIterator* iterator, INT* count);
+GpStatus WINGDIPAPI GdipPathIterIsValid(GpPathIterator* iterator, BOOL* valid);
+GpStatus WINGDIPAPI GdipPathIterHasCurve(GpPathIterator* iterator, BOOL* hasCurve);
+GpStatus WINGDIPAPI GdipPathIterRewind(GpPathIterator* iterator);
+GpStatus WINGDIPAPI GdipPathIterEnumerate(GpPathIterator* iterator, INT* resultCount, GpPointF *points, BYTE *types, INT count);
+GpStatus WINGDIPAPI GdipPathIterCopyData(GpPathIterator* iterator, INT* resultCount, GpPointF* points, BYTE* types, INT startIndex, INT endIndex);
+
+GpStatus WINGDIPAPI GdipCreatePen1(ARGB color, REAL width, GpUnit unit, GpPen **pen);
+GpStatus WINGDIPAPI GdipCreatePen2(GpBrush *brush, REAL width, GpUnit unit, GpPen **pen);
+GpStatus WINGDIPAPI GdipClonePen(GpPen *pen, GpPen **clonepen);
+GpStatus WINGDIPAPI GdipDeletePen(GpPen *pen);
+GpStatus WINGDIPAPI GdipSetPenWidth(GpPen *pen, REAL width);
+GpStatus WINGDIPAPI GdipGetPenWidth(GpPen *pen, REAL *width);
+GpStatus WINGDIPAPI GdipSetPenUnit(GpPen *pen, GpUnit unit);
+GpStatus WINGDIPAPI GdipGetPenUnit(GpPen *pen, GpUnit *unit);
+GpStatus WINGDIPAPI GdipSetPenLineCap197819(GpPen *pen, GpLineCap startCap, GpLineCap endCap, GpDashCap dashCap);
+GpStatus WINGDIPAPI GdipSetPenStartCap(GpPen *pen, GpLineCap startCap);
+GpStatus WINGDIPAPI GdipSetPenEndCap(GpPen *pen, GpLineCap endCap);
+GpStatus WINGDIPAPI GdipSetPenDashCap197819(GpPen *pen, GpDashCap dashCap);
+GpStatus WINGDIPAPI GdipGetPenStartCap(GpPen *pen, GpLineCap *startCap);
+GpStatus WINGDIPAPI GdipGetPenEndCap(GpPen *pen, GpLineCap *endCap);
+GpStatus WINGDIPAPI GdipGetPenDashCap197819(GpPen *pen, GpDashCap *dashCap);
+GpStatus WINGDIPAPI GdipSetPenLineJoin(GpPen *pen, GpLineJoin lineJoin);
+GpStatus WINGDIPAPI GdipGetPenLineJoin(GpPen *pen, GpLineJoin *lineJoin);
+GpStatus WINGDIPAPI GdipSetPenCustomStartCap(GpPen *pen, GpCustomLineCap* customCap);
+GpStatus WINGDIPAPI GdipGetPenCustomStartCap(GpPen *pen, GpCustomLineCap** customCap);
+GpStatus WINGDIPAPI GdipSetPenCustomEndCap(GpPen *pen, GpCustomLineCap* customCap);
+GpStatus WINGDIPAPI GdipGetPenCustomEndCap(GpPen *pen, GpCustomLineCap** customCap);
+GpStatus WINGDIPAPI GdipSetPenMiterLimit(GpPen *pen, REAL miterLimit);
+GpStatus WINGDIPAPI GdipGetPenMiterLimit(GpPen *pen, REAL *miterLimit);
+GpStatus WINGDIPAPI GdipSetPenMode(GpPen *pen, GpPenAlignment penMode);
+GpStatus WINGDIPAPI GdipGetPenMode(GpPen *pen, GpPenAlignment *penMode);
+GpStatus WINGDIPAPI GdipSetPenTransform(GpPen *pen, GpMatrix *matrix);
+GpStatus WINGDIPAPI GdipGetPenTransform(GpPen *pen, GpMatrix *matrix);
+GpStatus WINGDIPAPI GdipResetPenTransform(GpPen *pen);
+GpStatus WINGDIPAPI GdipMultiplyPenTransform(GpPen *pen, GDIPCONST GpMatrix *matrix, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipTranslatePenTransform(GpPen *pen, REAL dx, REAL dy, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipScalePenTransform(GpPen *pen, REAL sx, REAL sy, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipRotatePenTransform(GpPen *pen, REAL angle, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipSetPenColor(GpPen *pen, ARGB argb);
+GpStatus WINGDIPAPI GdipGetPenColor(GpPen *pen, ARGB *argb);
+GpStatus WINGDIPAPI GdipSetPenBrushFill(GpPen *pen, GpBrush *brush);
+GpStatus WINGDIPAPI GdipGetPenBrushFill(GpPen *pen, GpBrush **brush);
+GpStatus WINGDIPAPI GdipGetPenFillType(GpPen *pen, GpPenType* type);
+GpStatus WINGDIPAPI GdipGetPenDashStyle(GpPen *pen, GpDashStyle *dashstyle);
+GpStatus WINGDIPAPI GdipSetPenDashStyle(GpPen *pen, GpDashStyle dashstyle);
+GpStatus WINGDIPAPI GdipGetPenDashOffset(GpPen *pen, REAL *offset);
+GpStatus WINGDIPAPI GdipSetPenDashOffset(GpPen *pen, REAL offset);
+GpStatus WINGDIPAPI GdipGetPenDashCount(GpPen *pen, INT *count);
+GpStatus WINGDIPAPI GdipSetPenDashArray(GpPen *pen, GDIPCONST REAL *dash, INT count);
+GpStatus WINGDIPAPI GdipGetPenDashArray(GpPen *pen, REAL *dash, INT count);
+GpStatus WINGDIPAPI GdipGetPenCompoundCount(GpPen *pen, INT *count);
+GpStatus WINGDIPAPI GdipSetPenCompoundArray(GpPen *pen, GDIPCONST REAL *dash, INT count);
+GpStatus WINGDIPAPI GdipGetPenCompoundArray(GpPen *pen, REAL *dash, INT count);
+
+GpStatus WINGDIPAPI GdipCreateRegion(GpRegion **region);
+GpStatus WINGDIPAPI GdipCreateRegionRect(GDIPCONST GpRectF *rect, GpRegion **region);
+GpStatus WINGDIPAPI GdipCreateRegionRectI(GDIPCONST GpRect *rect, GpRegion **region);
+GpStatus WINGDIPAPI GdipCreateRegionPath(GpPath *path, GpRegion **region);
+GpStatus WINGDIPAPI GdipCreateRegionRgnData(GDIPCONST BYTE *regionData, INT size, GpRegion **region);
+GpStatus WINGDIPAPI GdipCreateRegionHrgn(HRGN hRgn, GpRegion **region);
+GpStatus WINGDIPAPI GdipCloneRegion(GpRegion *region, GpRegion **cloneRegion);
+GpStatus WINGDIPAPI GdipDeleteRegion(GpRegion *region);
+GpStatus WINGDIPAPI GdipSetInfinite(GpRegion *region);
+GpStatus WINGDIPAPI GdipSetEmpty(GpRegion *region);
+GpStatus WINGDIPAPI GdipCombineRegionRect(GpRegion *region, GDIPCONST GpRectF *rect, CombineMode combineMode);
+GpStatus WINGDIPAPI GdipCombineRegionRectI(GpRegion *region, GDIPCONST GpRect *rect, CombineMode combineMode);
+GpStatus WINGDIPAPI GdipCombineRegionPath(GpRegion *region, GpPath *path, CombineMode combineMode);
+GpStatus WINGDIPAPI GdipCombineRegionRegion(GpRegion *region, GpRegion *region2, CombineMode combineMode);
+GpStatus WINGDIPAPI GdipTranslateRegion(GpRegion *region, REAL dx, REAL dy);
+GpStatus WINGDIPAPI GdipTranslateRegionI(GpRegion *region, INT dx, INT dy);
+GpStatus WINGDIPAPI GdipTransformRegion(GpRegion *region, GpMatrix *matrix);
+GpStatus WINGDIPAPI GdipGetRegionBounds(GpRegion *region, GpGraphics *graphics, GpRectF *rect);
+GpStatus WINGDIPAPI GdipGetRegionBoundsI(GpRegion *region, GpGraphics *graphics, GpRect *rect);
+GpStatus WINGDIPAPI GdipGetRegionHRgn(GpRegion *region, GpGraphics *graphics, HRGN *hRgn);
+GpStatus WINGDIPAPI GdipIsEmptyRegion(GpRegion *region, GpGraphics *graphics, BOOL *result);
+GpStatus WINGDIPAPI GdipIsInfiniteRegion(GpRegion *region, GpGraphics *graphics, BOOL *result);
+GpStatus WINGDIPAPI GdipIsEqualRegion(GpRegion *region, GpRegion *region2, GpGraphics *graphics, BOOL *result);
+GpStatus WINGDIPAPI GdipGetRegionDataSize(GpRegion *region, UINT * bufferSize);
+GpStatus WINGDIPAPI GdipGetRegionData(GpRegion *region, BYTE * buffer, UINT bufferSize, UINT * sizeFilled);
+GpStatus WINGDIPAPI GdipIsVisibleRegionPoint(GpRegion *region, REAL x, REAL y, GpGraphics *graphics, BOOL *result);
+GpStatus WINGDIPAPI GdipIsVisibleRegionPointI(GpRegion *region, INT x, INT y, GpGraphics *graphics, BOOL *result);
+GpStatus WINGDIPAPI GdipIsVisibleRegionRect(GpRegion *region, REAL x, REAL y, REAL width, REAL height, GpGraphics *graphics, BOOL *result);
+GpStatus WINGDIPAPI GdipIsVisibleRegionRectI(GpRegion *region, INT x, INT y, INT width, INT height, GpGraphics *graphics, BOOL *result);
+GpStatus WINGDIPAPI GdipGetRegionScansCount(GpRegion *region, UINT* count, GpMatrix* matrix);
+GpStatus WINGDIPAPI GdipGetRegionScans(GpRegion *region, GpRectF* rects, INT* count, GpMatrix* matrix);
+GpStatus WINGDIPAPI GdipGetRegionScansI(GpRegion *region, GpRect* rects, INT* count, GpMatrix* matrix);
+
+GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **brush);
+GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *brush, ARGB color);
+GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *brush, ARGB *color);
+
+GpStatus WINGDIPAPI GdipCreateStringFormat(INT formatAttributes, LANGID language, GpStringFormat **format);
+GpStatus WINGDIPAPI GdipStringFormatGetGenericDefault(GpStringFormat **format);
+GpStatus WINGDIPAPI GdipStringFormatGetGenericTypographic(GpStringFormat **format);
+GpStatus WINGDIPAPI GdipDeleteStringFormat(GpStringFormat *format);
+GpStatus WINGDIPAPI GdipCloneStringFormat(GDIPCONST GpStringFormat *format, GpStringFormat **newFormat);
+GpStatus WINGDIPAPI GdipSetStringFormatFlags(GpStringFormat *format, INT flags);
+GpStatus WINGDIPAPI GdipGetStringFormatFlags(GDIPCONST GpStringFormat *format, INT *flags);
+GpStatus WINGDIPAPI GdipSetStringFormatAlign(GpStringFormat *format, StringAlignment align);
+GpStatus WINGDIPAPI GdipGetStringFormatAlign(GDIPCONST GpStringFormat *format, StringAlignment *align);
+GpStatus WINGDIPAPI GdipSetStringFormatLineAlign(GpStringFormat *format, StringAlignment align);
+GpStatus WINGDIPAPI GdipGetStringFormatLineAlign(GDIPCONST GpStringFormat *format, StringAlignment *align);
+GpStatus WINGDIPAPI GdipSetStringFormatTrimming(GpStringFormat *format, StringTrimming trimming);
+GpStatus WINGDIPAPI GdipGetStringFormatTrimming(GDIPCONST GpStringFormat *format, StringTrimming *trimming);
+GpStatus WINGDIPAPI GdipSetStringFormatHotkeyPrefix(GpStringFormat *format, INT hotkeyPrefix);
+GpStatus WINGDIPAPI GdipGetStringFormatHotkeyPrefix(GDIPCONST GpStringFormat *format, INT *hotkeyPrefix);
+GpStatus WINGDIPAPI GdipSetStringFormatTabStops(GpStringFormat *format, REAL firstTabOffset, INT count, GDIPCONST REAL *tabStops);
+GpStatus WINGDIPAPI GdipGetStringFormatTabStops(GDIPCONST GpStringFormat *format, INT count, REAL *firstTabOffset, REAL *tabStops);
+GpStatus WINGDIPAPI GdipGetStringFormatTabStopCount(GDIPCONST GpStringFormat *format, INT * count);
+GpStatus WINGDIPAPI GdipSetStringFormatDigitSubstitution(GpStringFormat *format, LANGID language, StringDigitSubstitute substitute);
+GpStatus WINGDIPAPI GdipGetStringFormatDigitSubstitution(GDIPCONST GpStringFormat *format, LANGID *language, StringDigitSubstitute *substitute);
+GpStatus WINGDIPAPI GdipGetStringFormatMeasurableCharacterRangeCount(GDIPCONST GpStringFormat *format, INT *count);
+GpStatus WINGDIPAPI GdipSetStringFormatMeasurableCharacterRanges(GpStringFormat *format, INT rangeCount, GDIPCONST CharacterRange *ranges);
+
+GpStatus WINGDIPAPI GdipDrawString(GpGraphics *graphics, GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font, GDIPCONST RectF *layoutRect, GDIPCONST GpStringFormat *stringFormat, GDIPCONST GpBrush *brush);
+GpStatus WINGDIPAPI GdipMeasureString(GpGraphics *graphics, GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font, GDIPCONST RectF *layoutRect, GDIPCONST GpStringFormat *stringFormat, RectF *boundingBox, INT *codepointsFitted, INT *linesFilled);
+GpStatus WINGDIPAPI GdipMeasureCharacterRanges(GpGraphics *graphics, GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font, GDIPCONST RectF &layoutRect, GDIPCONST GpStringFormat *stringFormat, INT regionCount, GpRegion **regions);
+GpStatus WINGDIPAPI GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length, GDIPCONST GpFont *font, GDIPCONST GpBrush *brush, GDIPCONST PointF *positions, INT flags, GDIPCONST GpMatrix *matrix);
+GpStatus WINGDIPAPI GdipMeasureDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length, GDIPCONST GpFont *font, GDIPCONST PointF *positions, INT flags, GDIPCONST GpMatrix *matrix, RectF *boundingBox);
+
+GpStatus WINGDIPAPI GdipCreateTexture(GpImage *image, GpWrapMode wrapmode, GpTexture **texture);
+GpStatus WINGDIPAPI GdipCreateTexture2(GpImage *image, GpWrapMode wrapmode, REAL x, REAL y, REAL width, REAL height, GpTexture **texture);
+GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage *image, GDIPCONST GpImageAttributes *imageAttributes, REAL x, REAL y, REAL width, REAL height, GpTexture **texture);
+GpStatus WINGDIPAPI GdipCreateTexture2I(GpImage *image, GpWrapMode wrapmode, INT x, INT y, INT width, INT height, GpTexture **texture);
+GpStatus WINGDIPAPI GdipCreateTextureIAI(GpImage *image, GDIPCONST GpImageAttributes *imageAttributes, INT x, INT y, INT width, INT height, GpTexture **texture);
+GpStatus WINGDIPAPI GdipGetTextureTransform(GpTexture *brush, GpMatrix *matrix);
+GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture *brush, GDIPCONST GpMatrix *matrix);
+GpStatus WINGDIPAPI GdipResetTextureTransform(GpTexture* brush);
+GpStatus WINGDIPAPI GdipMultiplyTextureTransform(GpTexture* brush, GDIPCONST GpMatrix *matrix, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipTranslateTextureTransform(GpTexture* brush, REAL dx, REAL dy, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipScaleTextureTransform(GpTexture* brush, REAL sx, REAL sy, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipRotateTextureTransform(GpTexture* brush, REAL angle, GpMatrixOrder order);
+GpStatus WINGDIPAPI GdipSetTextureWrapMode(GpTexture *brush, GpWrapMode wrapmode);
+GpStatus WINGDIPAPI GdipGetTextureWrapMode(GpTexture *brush, GpWrapMode *wrapmode);
+GpStatus WINGDIPAPI GdipGetTextureImage(GpTexture *brush, GpImage **image);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _GDIPLUSFLAT_H */

reactos/w32api/include/GdiPlusGpStubs.h

@@ -0,0 +1,74 @@
+/*
+ * GdiPlusGpStubs.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSGPSTUBS_H
+#define _GDIPLUSGPSTUBS_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+class Matrix;
+
+class GpCustomLineCap {};
+class GpAdjustableArrowCap : public GpCustomLineCap {};
+class GpImage {};
+class GpBitmap : public GpImage {};
+class GpGraphics {};
+class CGpEffect {};
+class GpBrush {};
+class GpPath {};
+class GpCachedBitmap;
+class GpFont {};
+class GpFontFamily {};
+class GpFontCollection {};
+class GpPen {};
+class GpRegion {};
+class GpImageAttributes {};
+class GpMetafile : public GpImage {};
+class GpStringFormat {};
+class GpHatch : public GpBrush {};
+class GpLineGradient : public GpBrush {};
+class GpPathGradient : public GpBrush {};
+class GpPathIterator {};
+class GpSolidFill : public GpBrush {};
+class GpTexture : public GpBrush {};
+
+typedef Status GpStatus;
+typedef Rect GpRect;
+typedef PathData GpPathData;
+typedef BrushType GpBrushType;
+typedef LineCap GpLineCap;
+typedef LineJoin GpLineJoin;
+typedef FlushIntention GpFlushIntention;
+typedef Matrix GpMatrix;
+typedef MatrixOrder GpMatrixOrder;
+typedef Unit GpUnit;
+typedef CoordinateSpace GpCoordinateSpace;
+typedef PointF GpPointF;
+typedef Point GpPoint;
+typedef RectF GpRectF;
+typedef FillMode GpFillMode;
+typedef HatchStyle GpHatchStyle;
+typedef WrapMode GpWrapMode;
+typedef DashCap GpDashCap;
+typedef PenAlignment GpPenAlignment;
+typedef PenType GpPenType;
+typedef DashStyle GpDashStyle;
+
+#endif /* _GDIPLUSGPSTUBS_H */

reactos/w32api/include/GdiPlusGraphics.h

@@ -0,0 +1,995 @@
+/*
+ * GdiPlusGraphics.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSGRAPHICS_H
+#define _GDIPLUSGRAPHICS_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+class Graphics : public GdiplusBase
+{
+public:
+  Graphics(Image *image)
+  {
+  }
+
+  Graphics(HDC hdc)
+  {
+    GpGraphics *graphics = NULL;
+    status = DllExports::GdipCreateFromHDC(hdc, &graphics);
+    SetGraphics(graphics);
+  }
+
+  Graphics(HDC hdc, HANDLE hdevice)
+  {
+  }
+
+  Graphics(HWND hwnd, BOOL icm)
+  {
+  }
+
+  Status AddMetafileComment(const BYTE *data, UINT sizeData)
+  {
+    return NotImplemented;
+  }
+
+  GraphicsContainer BeginContainer(VOID)
+  {
+    return GraphicsContainer();
+  }
+
+  GraphicsContainer BeginContainer(const RectF &dstrect, const RectF &srcrect, Unit unit)
+  {
+    return GraphicsContainer();
+  }
+
+  GraphicsContainer BeginContainer(const Rect &dstrect, const Rect &srcrect, Unit unit)
+  {
+    return GraphicsContainer();
+  }
+
+  Status Clear(const Color &color)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawArc(const Pen *pen, const Rect &rect, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawArc(const Pen *pen, const RectF &rect, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawArc(const Pen *pen, REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawArc(const Pen *pen, INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawBezier(const Pen *pen, const Point &pt1, const Point &pt2, const Point &pt3, const Point &pt4)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawBezier(const Pen *pen, const PointF &pt1, const PointF &pt2, const PointF &pt3, const PointF &pt4)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawBezier(const Pen *pen, REAL x1, REAL y1, REAL x2, REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawBezier(const Pen *pen, INT x1, INT y1, INT x2, INT y2, INT x3, INT y3, INT x4, INT y4)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawBeziers(const Pen *pen, const Point *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawBeziers(const Pen *pen, const PointF *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawCachedBitmap(CachedBitmap *cb, INT x, INT y)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawClosedCurve(const Pen *pen, const Point *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawClosedCurve(const Pen *pen, const PointF *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawClosedCurve(const Pen *pen, const PointF *points, INT count, REAL tension)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawClosedCurve(const Pen *pen, const Point *points, INT count, REAL tension)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawCurve(const Pen *pen, const Point *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawCurve(const Pen *pen, const PointF *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawCurve(const Pen *pen, const PointF *points, INT count, REAL tension)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawCurve(const Pen *pen, const Point *points, INT count, INT offset, INT numberOfSegments, REAL tension)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawCurve(const Pen *pen, const PointF *points, INT count, INT offset, INT numberOfSegments, REAL tension)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawCurve(const Pen *pen, const Point *points, INT count, REAL tension)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawDriverString(const UINT16 *text, INT length, const Font *font, const Brush *brush, const PointF *positions, INT flags, const Matrix *matrix)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawEllipse(const Pen *pen, const Rect &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawEllipse(const Pen *pen, REAL x, REAL y, REAL width, REAL height)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawEllipse(const Pen *pen, const RectF &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawEllipse(const Pen *pen, INT x, INT y, INT width, INT height)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, const Point *destPoints, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, INT x, INT y)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, const Point &point)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, REAL x, REAL y)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, const PointF &point)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, const PointF *destPoints, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, REAL x, REAL y, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight, Unit srcUnit)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, const RectF &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, INT x, INT y, INT width, INT height)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, const PointF *destPoints, INT count, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight, Unit srcUnit, ImageAttributes *imageAttributes, DrawImageAbort callback, VOID *callbackData)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, const Rect &destRect, INT srcx, INT srcy, INT srcwidth, INT srcheight, Unit srcUnit, ImageAttributes *imageAttributes, DrawImageAbort callback, VOID *callbackData)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, const Point *destPoints, INT count, INT srcx, INT srcy, INT srcwidth, INT srcheight, Unit srcUnit, ImageAttributes *imageAttributes, DrawImageAbort callback, VOID *callbackData)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, REAL x, REAL y, REAL width, REAL height)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, const Rect &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, INT x, INT y, INT srcx, INT srcy, INT srcwidth, INT srcheight, Unit srcUnit)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawImage(Image *image, const RectF &destRect, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight, Unit srcUnit, ImageAttributes *imageAttributes, DrawImageAbort callback, VOID *callbackData)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawLine(const Pen *pen, const Point &pt1, const Point &pt2)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawLine(const Pen *pen, const PointF &pt1, const Point &pt2)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawLine(const Pen *pen, REAL x1, REAL y1, REAL x2, REAL y2)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawLine(const Pen *pen, INT x1, INT y1, INT x2, INT y2)
+  {
+    return SetStatus(DllExports::GdipDrawLine(graphics,
+      pen->pen,
+      x1,
+      y1,
+      x2,
+      y2));
+  }
+
+  Status DrawLines(const Pen *pen, const Point *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawLines(const Pen *pen, const PointF *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawPath(const Pen *pen, const GraphicsPath *path)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawPie(const Pen *pen, const Rect &rect, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawPie(const Pen *pen, INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawPie(const Pen *pen, REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawPie(const Pen *pen, const RectF &rect, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawPolygon(const Pen *pen, const Point *points, INT *count)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawPolygon(const Pen *pen, const PointF *points, INT *count)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawRectangle(const Pen *pen, const Rect &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawRectangle(const Pen *pen, INT x, INT y, INT width, INT height)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawRectangle(const Pen *pen, REAL x, REAL y, REAL width, REAL height)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawRectangle(const Pen *pen, const RectF &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawRectangles(const Pen *pen, const Rect *rects, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawRectangles(const Pen *pen, const RectF *rects, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawString(const WCHAR *string, INT length, const Font *font, const RectF &layoutRect, const StringFormat *stringFormat, const Brush *brush)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawString(const WCHAR *string, INT length, const Font *font, const PointF &origin, const Brush *brush)
+  {
+    return NotImplemented;
+  }
+
+  Status DrawString(const WCHAR *string, INT length, const Font *font, const PointF &origin, const StringFormat *stringFormat, const Brush *brush)
+  {
+    return NotImplemented;
+  }
+
+  Status EndContainer(GraphicsContainer state)
+  {
+    return NotImplemented;
+  }
+
+  Status EnumerateMetafile(const Metafile *metafile, const Metafile &destPoint, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
+  {
+    return NotImplemented;
+  }
+
+  Status EnumerateMetafile(const Metafile *metafile, const Point *destPoints, INT count, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
+  {
+    return NotImplemented;
+  }
+
+  Status EnumerateMetafile(const Metafile *metafile, const Point &destPoint, const Rect &srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
+  {
+    return NotImplemented;
+  }
+
+  Status EnumerateMetafile(const Metafile *metafile, const PointF *destPoints, INT count, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
+  {
+    return NotImplemented;
+  }
+
+  Status EnumerateMetafile(const Metafile *metafile, const Rect &destRect, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
+  {
+    return NotImplemented;
+  }
+
+  Status EnumerateMetafile(const Metafile *metafile, const RectF &destRect, const RectF &srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
+  {
+    return NotImplemented;
+  }
+
+  Status EnumerateMetafile(const Metafile *metafile, const RectF &destRect, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
+  {
+    return NotImplemented;
+  }
+
+  Status EnumerateMetafile(const Metafile *metafile, const PointF &destPoint, const Rect &srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
+  {
+    return NotImplemented;
+  }
+
+  Status EnumerateMetafile(const Metafile *metafile, const Point *destPoints, INT count, const Rect &srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
+  {
+    return NotImplemented;
+  }
+
+  Status EnumerateMetafile(const Metafile *metafile, const Rect &destRect, const Rect &srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
+  {
+    return NotImplemented;
+  }
+
+  Status EnumerateMetafile(const Metafile *metafile, const Point *destPoints, INT count, const RectF &srcRect, Unit srcUnit, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
+  {
+    return NotImplemented;
+  }
+
+  Status EnumerateMetafile(const Metafile *metafile, const PointF &destPoint, EnumerateMetafileProc callback, VOID *callbackData, ImageAttributes *imageAttributes)
+  {
+    return NotImplemented;
+  }
+
+  Status ExcludeClip(const Rect& rect)
+  {
+    return NotImplemented;
+  }
+
+  Status ExcludeClip(const RectF &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status ExcludeClip(const Region *region)
+  {
+    return NotImplemented;
+  }
+
+  Status FillClosedCurve(const Brush *brush, const Point *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status FillClosedCurve(const Brush *brush, const Point *points, INT count, FillMode fillMode, REAL tension)
+  {
+    return NotImplemented;
+  }
+
+  Status FillClosedCurve(const Brush *brush, const PointF *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status FillClosedCurve(const Brush *brush, const PointF *points, INT count, FillMode fillMode, REAL tension)
+  {
+    return NotImplemented;
+  }
+
+  Status FillEllipse(const Brush *brush, const Rect &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status FillEllipse(const Brush *brush, REAL x, REAL y, REAL width, REAL height)
+  {
+    return NotImplemented;
+  }
+
+  Status FillEllipse(const Brush *brush, const RectF &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status FillEllipse(const Brush *brush, INT x, INT y, INT width, INT height)
+  {
+    return NotImplemented;
+  }
+
+  Status FillPath(const Brush *brush, const GraphicsPath *path)
+  {
+    return NotImplemented;
+  }
+
+  Status FillPie(const Brush *brush, const Rect &rect, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status FillPie(const Brush *brush, INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status FillPie(const Brush *brush, REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status FillPie(const Brush *brush, RectF &rect, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status FillPolygon(const Brush *brush, const Point *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status FillPolygon(const Brush *brush, const PointF *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status FillPolygon(const Brush *brush, const Point *points, INT count, FillMode fillMode)
+  {
+    return NotImplemented;
+  }
+
+  Status FillPolygon(const Brush *brush, const PointF *points, INT count, FillMode fillMode)
+  {
+    return NotImplemented;
+  }
+
+  Status FillRectangle(const Brush *brush, const Rect &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status FillRectangle(const Brush *brush, const RectF &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status FillRectangle(const Brush *brush, REAL x, REAL y, REAL width, REAL height)
+  {
+    return NotImplemented;
+  }
+
+  Status FillRectangle(const Brush *brush, INT x, INT y, INT width, INT height)
+  {
+    return NotImplemented;
+  }
+
+  Status FillRectangles(const Brush *brush, const Rect *rects, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status FillRectangles(const Brush *brush, const RectF *rects, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status FillRegion(const Brush *brush, const Region *region)
+  {
+    return NotImplemented;
+  }
+
+  VOID Flush(FlushIntention intention)
+  {
+  }
+
+  static Graphics *FromHDC(HDC hdc)
+  {
+    return NULL;
+  }
+
+  static Graphics *FromHDC(HDC hdc, HANDLE hDevice)
+  {
+    return NULL;
+  }
+
+  static Graphics *FromHWND(HWND hWnd, BOOL icm)
+  {
+    return NULL;
+  }
+
+  static Graphics *FromImage(Image *image)
+  {
+    return NULL;
+  }
+
+  Status GetClip(Region *region) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetClipBounds(Rect* rect) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetClipBounds(RectF* rect) const
+  {
+    return NotImplemented;
+  }
+
+  CompositingMode GetCompositingMode(VOID)
+  {
+    return CompositingModeSourceOver;
+  }
+
+  CompositingQuality GetCompositingQuality(VOID)
+  {
+    return CompositingQualityDefault;
+  }
+
+  REAL GetDpiX(VOID)
+  {
+    return 0;
+  }
+
+  REAL GetDpiY(VOID)
+  {
+    return 0;
+  }
+
+  static HPALETTE GetHalftonePalette(VOID)
+  {
+    return NULL;
+  }
+
+  HDC GetHDC(VOID)
+  {
+    return NULL;
+  }
+
+  InterpolationMode GetInterpolationMode(VOID)
+  {
+    return InterpolationModeInvalid;
+  }
+
+  Status GetLastStatus(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status GetNearestColor(Color* color) const
+  {
+    return NotImplemented;
+  }
+
+  REAL GetPageScale(VOID)
+  {
+    return 0;
+  }
+
+  Unit GetPageUnit(VOID)
+  {
+    return UnitWorld;
+  }
+
+  PixelOffsetMode GetPixelOffsetMode(VOID)
+  {
+    return PixelOffsetModeInvalid;
+  }
+
+  Status GetRenderingOrigin(INT *x, INT *y)
+  {
+    return NotImplemented;
+  }
+
+  SmoothingMode GetSmoothingMode(VOID) const
+  {
+    return SmoothingModeInvalid;
+  }
+
+  UINT GetTextContrast(VOID) const
+  {
+    return 0;
+  }
+
+  TextRenderingHint GetTextRenderingHint(VOID) const
+  {
+    return TextRenderingHintSystemDefault;
+  }
+
+  Status GetTransform(Matrix* matrix)
+  {
+    return NotImplemented;
+  }
+
+  Status GetVisibleClipBounds(Rect* rect) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetVisibleClipBounds(RectF* rect) const
+  {
+    return NotImplemented;
+  }
+
+  Status IntersectClip(const Rect& rect)
+  {
+    return NotImplemented;
+  }
+
+  Status IntersectClip(const Region* region)
+  {
+    return NotImplemented;
+  }
+
+  Status IntersectClip(const RectF& rect)
+  {
+    return NotImplemented;
+  }
+
+  BOOL IsClipEmpty(VOID) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(const Point& point) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(const Rect& rect) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(REAL x, REAL y) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(const RectF& rect) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(INT x, INT y, INT width, INT height) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(INT x, INT y) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(const PointF& point) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(REAL x, REAL y, REAL width, REAL height) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisibleClipEmpty(VOID) const
+  {
+    return FALSE;
+  }
+
+  Status MeasureCharacterRanges(const WCHAR *string, INT length, const Font *font, const RectF &layoutRect, const StringFormat *stringFormat, INT regionCount, Region *regions) const
+  {
+    return NotImplemented;
+  }
+
+  Status MeasureDriverString(const UINT16 *text, INT length, const Font *font, const PointF *positions, INT flags, const Matrix *matrix, RectF *boundingBox) const
+  {
+    return NotImplemented;
+  }
+
+  Status MeasureString(const WCHAR *string, INT length, const Font *font, const RectF &layoutRect, RectF *boundingBox) const
+  {
+    return NotImplemented;
+  }
+
+  Status MeasureString(const WCHAR *string, INT length, const Font *font, const PointF &origin, const StringFormat *stringFormat, RectF *boundingBox) const
+  {
+    return NotImplemented;
+  }
+
+  Status MeasureString(const WCHAR *string, INT length, const Font *font, const RectF &layoutRect, const StringFormat *stringFormat, RectF *boundingBox, INT *codepointsFitted, INT *linesFilled) const
+  {
+    return NotImplemented;
+  }
+
+  Status MeasureString(const WCHAR *string, INT length, const Font *font, const SizeF &layoutRectSize, const StringFormat *stringFormat, SizeF *size, INT *codepointsFitted, INT *linesFilled) const
+  {
+    return NotImplemented;
+  }
+
+  Status MeasureString(const WCHAR *string, INT length, const Font *font, const PointF &origin, RectF *boundingBox) const
+  {
+    return NotImplemented;
+  }
+
+  Status MultiplyTransform(Matrix *matrix, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  VOID ReleaseHDC(HDC hdc)
+  {
+  }
+
+  Status ResetClip(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status ResetTransform(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status Restore(GraphicsState gstate)
+  {
+    return NotImplemented;
+  }
+
+  Status RotateTransform(REAL angle, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  GraphicsState Save(VOID)
+  {
+    return 0;
+  }
+
+  Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status SetClip(const Graphics *g, CombineMode combineMode)
+  {
+    return NotImplemented;
+  }
+
+  Status SetClip(const GraphicsPath *path, CombineMode combineMode)
+  {
+    return NotImplemented;
+  }
+
+  Status SetClip(const Region *region, CombineMode combineMode)
+  {
+    return NotImplemented;
+  }
+
+  Status SetClip(const Rect &rect, CombineMode combineMode)
+  {
+    return NotImplemented;
+  }
+
+  Status SetClip(HRGN hRgn, CombineMode combineMode)
+  {
+    return NotImplemented;
+  }
+
+  Status SetClip(const RectF& rect, CombineMode combineMode)
+  {
+    return NotImplemented;
+  }
+
+  Status SetCompositingMode(CompositingMode compositingMode)
+  {
+    return NotImplemented;
+  }
+
+  Status SetCompositingQuality(CompositingQuality compositingQuality)
+  {
+    return NotImplemented;
+  }
+
+  Status SetInterpolationMode(InterpolationMode interpolationMode)
+  {
+    return NotImplemented;
+  }
+
+  Status SetPageScale(REAL scale)
+  {
+    return NotImplemented;
+  }
+
+  Status SetPageUnit(Unit unit)
+  {
+    return NotImplemented;
+  }
+
+  Status SetPixelOffsetMode(PixelOffsetMode pixelOffsetMode)
+  {
+    return NotImplemented;
+  }
+
+  Status SetRenderingOrigin(INT x, INT y)
+  {
+    return NotImplemented;
+  }
+
+  Status SetSmoothingMode(SmoothingMode smoothingMode)
+  {
+    return NotImplemented;
+  }
+
+  Status SetTextContrast(UINT contrast)
+  {
+    return NotImplemented;
+  }
+
+  Status SetTextRenderingHint(TextRenderingHint newMode)
+  {
+    return NotImplemented;
+  }
+
+  Status SetTransform(const Matrix *matrix)
+  {
+    return NotImplemented;
+  }
+
+  Status TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, Point *pts, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status TranslateClip(INT dx, INT dy)
+  {
+    return NotImplemented;
+  }
+
+  Status TranslateClip(REAL dx, REAL dy)
+  {
+    return NotImplemented;
+  }
+
+  Status TranslateTransform(REAL dx, REAL dy, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+private:
+  Status SetStatus(Status status) const
+  {
+    if (status == Ok)
+      return status;
+    this->status = status;
+    return status;
+  }
+
+  VOID SetGraphics(GpGraphics *graphics)
+  {
+    this->graphics = graphics;
+  }
+
+private:
+  mutable Status status;
+  GpGraphics *graphics;
+};
+
+#endif /* _GDIPLUSGRAPHICS_H */

reactos/w32api/include/GdiPlusHeaders.h

@@ -0,0 +1,880 @@
+/*
+ * GdiPlusHeaders.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSHEADERS_H
+#define _GDIPLUSHEADERS_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+class Image : public GdiplusBase
+{
+public:
+  friend class Graphics;
+
+  Image(IStream *stream, BOOL useEmbeddedColorManagement)
+  {
+  }
+
+  Image(const WCHAR *filename, BOOL useEmbeddedColorManagement)
+  {
+  }
+
+  Image *Clone(VOID)
+  {
+    return NULL;
+  }
+
+  static Image *FromFile(const WCHAR *filename, BOOL useEmbeddedColorManagement)
+  {
+    return NULL;
+  }
+
+  static Image *FromStream(IStream *stream, BOOL useEmbeddedColorManagement)
+  {
+    return NULL;
+  }
+
+  Status GetAllPropertyItems(UINT totalBufferSize, UINT numProperties, PropertyItem *allItems)
+  {
+    return NotImplemented;
+  }
+
+  Status GetBounds(RectF *srcRect, Unit *srcUnit)
+  {
+    return NotImplemented;
+  }
+
+  Status GetEncoderParameterList(const CLSID *clsidEncoder, UINT size, EncoderParameters *buffer)
+  {
+    return NotImplemented;
+  }
+
+  UINT GetEncoderParameterListSize(const CLSID *clsidEncoder)
+  {
+    return 0;
+  }
+
+  UINT GetFlags(VOID)
+  {
+    return 0;
+  }
+
+  UINT GetFrameCount(const GUID *dimensionID)
+  {
+    return 0;
+  }
+
+  UINT GetFrameDimensionsCount(VOID)
+  {
+    return 0;
+  }
+
+  Status GetFrameDimensionsList(GUID *dimensionIDs, UINT count)
+  {
+    return NotImplemented;
+  }
+
+  UINT GetHeight(VOID)
+  {
+    return 0;
+  }
+
+  REAL GetHorizontalResolution(VOID)
+  {
+    return 0;
+  }
+
+  Status GetLastStatus(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status GetPalette(ColorPalette *palette, INT size)
+  {
+    return NotImplemented;
+  }
+
+  INT GetPaletteSize(VOID)
+  {
+    return 0;
+  }
+
+  Status GetPhysicalDimension(SizeF *size)
+  {
+    return NotImplemented;
+  }
+
+  PixelFormat GetPixelFormat(VOID)
+  {
+    return PixelFormatUndefined;
+  }
+
+  UINT GetPropertyCount(VOID)
+  {
+    return 0;
+  }
+
+  Status GetPropertyIdList(UINT numOfProperty, PROPID *list)
+  {
+    return NotImplemented;
+  }
+
+  Status GetPropertyItem(PROPID propId, UINT propSize, PropertyItem *buffer)
+  {
+    return NotImplemented;
+  }
+
+  UINT GetPropertyItemSize(PROPID propId)
+  {
+    return 0;
+  }
+
+  Status GetPropertySize(UINT *totalBufferSize, UINT *numProperties)
+  {
+    return NotImplemented;
+  }
+
+  Status GetRawFormat(GUID *format)
+  {
+    return NotImplemented;
+  }
+
+  Image *GetThumbnailImage(UINT thumbWidth, UINT thumbHeight, GetThumbnailImageAbort callback, VOID *callbackData)
+  {
+    return NULL;
+  }
+
+  ImageType GetType(VOID)
+  {
+    return ImageTypeUnknown;
+  }
+
+  REAL GetVerticalResolution(VOID)
+  {
+    return 0;
+  }
+
+  UINT GetWidth(VOID)
+  {
+    return 0;
+  }
+
+  Status RemovePropertyItem(PROPID propId)
+  {
+    return NotImplemented;
+  }
+
+  Status RotateFlip(RotateFlipType rotateFlipType)
+  {
+    return NotImplemented;
+  }
+
+  Status Save(IStream *stream, const CLSID *clsidEncoder, const EncoderParameters *encoderParams)
+  {
+    return NotImplemented;
+  }
+
+  Status Save(const WCHAR *filename, const CLSID *clsidEncoder, const EncoderParameters *encoderParams)
+  {
+    return NotImplemented;
+  }
+
+  Status SaveAdd(const EncoderParameters* encoderParams)
+  {
+    return NotImplemented;
+  }
+
+  Status SaveAdd(Image *newImage, const EncoderParameters *encoderParams)
+  {
+    return NotImplemented;
+  }
+
+  Status SelectActiveFrame(const GUID *dimensionID, UINT frameIndex)
+  {
+    return NotImplemented;
+  }
+
+  Status SetPalette(const ColorPalette* palette)
+  {
+    return NotImplemented;
+  }
+
+  Status SetPropertyItem(const PropertyItem* item)
+  {
+    return NotImplemented;
+  }
+
+protected:
+  Image()
+  {
+  }
+};
+
+
+class Bitmap : public Image
+{
+public:
+  Bitmap(IDirectDrawSurface7 *surface)
+  {
+  }
+
+  Bitmap(INT width, INT height, Graphics *target)
+  {
+  }
+
+  Bitmap(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData)
+  {
+  }
+
+  Bitmap(INT width, INT height, PixelFormat format)
+  {
+  }
+
+  Bitmap(HBITMAP hbm, HPALETTE hpal)
+  {
+  }
+
+  Bitmap(INT width, INT height, INT stride, PixelFormat format, BYTE *scan0)
+  {
+  }
+
+  Bitmap(const WCHAR *filename, BOOL useIcm)
+  {
+  }
+
+  Bitmap(HINSTANCE hInstance, const WCHAR *bitmapName)
+  {
+  }
+
+  Bitmap(HICON hicon)
+  {
+  }
+
+  Bitmap(IStream *stream, BOOL useIcm)
+  {
+  }
+
+  Bitmap *Clone(const Rect &rect, PixelFormat format)
+  {
+    return NULL;
+  }
+
+  Bitmap *Clone(const RectF &rect, PixelFormat format)
+  {
+    return NULL;
+  }
+
+  Bitmap *Clone(REAL x, REAL y, REAL width, REAL height, PixelFormat format)
+  {
+    return NULL;
+  }
+
+  Bitmap *Clone(INT x, INT y, INT width, INT height, PixelFormat format)
+  {
+    return NULL;
+  }
+
+  static Bitmap *FromBITMAPINFO(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData)
+  {
+    return NULL;
+  }
+
+  static Bitmap *FromDirectDrawSurface7(IDirectDrawSurface7 *surface)
+  {
+    return NULL;
+  }
+
+  static Bitmap *FromFile(const WCHAR *filename, BOOL useEmbeddedColorManagement)
+  {
+    return NULL;
+  }
+
+  static Bitmap *FromHBITMAP(HBITMAP hbm, HPALETTE hpal)
+  {
+    return NULL;
+  }
+
+  static Bitmap *FromHICON(HICON hicon)
+  {
+    return NULL;
+  }
+
+  static Bitmap *FromResource(HINSTANCE hInstance, const WCHAR *bitmapName)
+  {
+    return NULL;
+  }
+
+  static Bitmap *FromStream(IStream *stream, BOOL useEmbeddedColorManagement)
+  {
+    return NULL;
+  }
+
+  Status GetHBITMAP(const Color &colorBackground, HBITMAP *hbmReturn)
+  {
+    return NotImplemented;
+  }
+
+  Status GetHICON(HICON *hicon)
+  {
+    return NotImplemented;
+  }
+
+  Status GetPixel(INT x, INT y, Color *color)
+  {
+    return NotImplemented;
+  }
+
+  Status LockBits(const Rect *rect, UINT flags, PixelFormat format, BitmapData *lockedBitmapData)
+  {
+    return NotImplemented;
+  }
+
+  Status SetPixel(INT x, INT y, const Color &color)
+  {
+    return NotImplemented;
+  }
+
+  Status SetResolution(REAL xdpi, REAL ydpi)
+  {
+    return NotImplemented;
+  }
+
+  Status UnlockBits(BitmapData *lockedBitmapData)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class CachedBitmap : public GdiplusBase
+{
+public:
+  CachedBitmap(Bitmap *bitmap, Graphics *graphics)
+  {
+  }
+
+  Status GetLastStatus(VOID)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class Font : public GdiplusBase
+{
+public:
+  friend class FontFamily;
+  friend class FontCollection;
+
+  Font(const FontFamily *family, REAL emSize, INT style, Unit unit)
+  {
+  }
+
+  Font(HDC hdc, const HFONT hfont)
+  {
+  }
+
+  Font(HDC hdc, const LOGFONTA *logfont)
+  {
+  }
+
+  Font(HDC hdc, const LOGFONTW *logfont)
+  {
+  }
+
+  Font(const WCHAR *familyName, REAL emSize, INT style, Unit unit, const FontCollection *fontCollection)
+  {
+  }
+
+  Font(HDC hdc)
+  {
+  }
+
+  Font *Clone(VOID) const
+  {
+    return NULL;
+  }
+
+  Status GetFamily(FontFamily* family) const
+  {
+    return NotImplemented;
+  }
+
+  REAL GetHeight(const Graphics* graphics) const
+  {
+    return 0;
+  }
+
+  REAL GetHeight(REAL dpi) const
+  {
+    return 0;
+  }
+
+  Status GetLastStatus(VOID) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetLogFontA(const Graphics *g, LOGFONTA *logfontA) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetLogFontW(const Graphics *g, LOGFONTW *logfontW) const
+  {
+    return NotImplemented;
+  }
+
+  REAL GetSize(VOID) const
+  {
+    return 0;
+  }
+
+  INT GetStyle(VOID) const
+  {
+    return 0;
+  }
+
+  Unit GetUnit(VOID) const
+  {
+    return UnitWorld;
+  }
+
+  BOOL IsAvailable(VOID) const
+  {
+    return FALSE;
+  }
+};
+
+
+class FontCollection : public GdiplusBase
+{
+public:
+  FontCollection(VOID)
+  {
+  }
+
+  Status GetFamilies(INT numSought, FontFamily *gpfamilies, INT *numFound) const
+  {
+    return NotImplemented;
+  }
+
+  INT GetFamilyCount(VOID) const
+  {
+    return 0;
+  }
+
+  Status GetLastStatus(VOID)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class FontFamily : public GdiplusBase
+{
+public:
+  FontFamily(VOID)
+  {
+  }
+
+  FontFamily(const WCHAR *name, const FontCollection *fontCollection)
+  {
+  }
+
+  FontFamily *Clone(VOID)
+  {
+    return NULL;
+  }
+
+  static const FontFamily *GenericMonospace(VOID)
+  {
+    return NULL;
+  }
+
+  static const FontFamily *GenericSansSerif(VOID)
+  {
+    return NULL;
+  }
+
+  static const FontFamily *GenericSerif(VOID)
+  {
+    return NULL;
+  }
+
+  UINT16 GetCellAscent(INT style) const
+  {
+    return 0;
+  }
+
+  UINT16 GetCellDescent(INT style) const
+  {
+    return 0;
+  }
+
+  UINT16 GetEmHeight(INT style)
+  {
+    return 0;
+  }
+
+  Status GetFamilyName(WCHAR name[LF_FACESIZE], WCHAR language) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetLastStatus(VOID) const
+  {
+    return NotImplemented;
+  }
+
+  UINT16 GetLineSpacing(INT style) const
+  {
+    return 0;
+  }
+
+  BOOL IsAvailable(VOID) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsStyleAvailable(INT style) const
+  {
+    return FALSE;
+  }
+};
+
+
+class InstalledFontFamily : public FontFamily
+{
+public:
+  InstalledFontFamily(VOID)
+  {
+  }
+};
+
+
+class PrivateFontCollection : public FontCollection
+{
+public:
+  PrivateFontCollection(VOID)
+  {
+  }
+
+  Status AddFontFile(const WCHAR* filename)
+  {
+    return NotImplemented;
+  }
+
+  Status AddMemoryFont(const VOID *memory, INT length)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class Region : public GdiplusBase
+{
+public:
+  friend class GraphicsPath;
+  friend class Matrix;
+
+  Region(const Rect &rect)
+  {
+  }
+
+  Region(VOID)
+  {
+  }
+
+  Region(const BYTE *regionData, INT size)
+  {
+  }
+
+  Region(const GraphicsPath *path)
+  {
+  }
+
+  Region(HRGN hRgn)
+  {
+  }
+
+  Region(const RectF &rect)
+  {
+  }
+
+  Region *Clone(VOID)
+  {
+    return NULL;
+  }
+
+  Status Complement(const GraphicsPath *path)
+  {
+    return NotImplemented;
+  }
+
+  Status Complement(const Region *region)
+  {
+    return NotImplemented;
+  }
+
+  Status Complement(const Rect &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status Complement(const RectF &rect)
+  {
+    return NotImplemented;
+  }
+
+  BOOL Equals(const Region *region, const Graphics *g) const
+  {
+    return FALSE;
+  }
+
+  Status Exclude(const GraphicsPath *path)
+  {
+    return NotImplemented;
+  }
+
+  Status Exclude(const RectF &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status Exclude(const Rect &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status Exclude(const Region *region)
+  {
+    return NotImplemented;
+  }
+
+  static Region *FromHRGN(HRGN hRgn)
+  {
+    return NULL;
+  }
+
+  Status GetBounds(Rect *rect, const Graphics *g) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetBounds(RectF *rect, const Graphics *g) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetData(BYTE *buffer, UINT bufferSize, UINT *sizeFilled) const
+  {
+    return NotImplemented;
+  }
+
+  UINT GetDataSize(VOID) const
+  {
+    return 0;
+  }
+
+  HRGN GetHRGN(const Graphics *g) const
+  {
+    return NULL;
+  }
+
+  Status GetLastStatus(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status GetRegionScans(const Matrix *matrix, Rect *rects, INT *count) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetRegionScans(const Matrix *matrix, RectF *rects, INT *count) const
+  {
+    return NotImplemented;
+  }
+
+  UINT GetRegionScansCount(const Matrix *matrix) const
+  {
+    return 0;
+  }
+
+  Status Intersect(const Rect &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status Intersect(const GraphicsPath *path)
+  {
+    return NotImplemented;
+  }
+
+  Status Intersect(const RectF &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status Intersect(const Region *region)
+  {
+    return NotImplemented;
+  }
+
+  BOOL IsEmpty(const Graphics *g) const
+  {
+    return NotImplemented;
+  }
+
+  BOOL IsInfinite(const Graphics *g) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(const PointF &point, const Graphics *g) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(const RectF &rect, const Graphics *g) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(const Rect &rect, const Graphics *g) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(INT x, INT y, const Graphics *g) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(REAL x, REAL y, const Graphics *g) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(INT x, INT y, INT width, INT height, const Graphics *g) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(const Point &point, const Graphics *g) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(REAL x, REAL y, REAL width, REAL height, const Graphics *g) const
+  {
+    return FALSE;
+  }
+
+  Status MakeEmpty(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status MakeInfinite(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status Transform(const Matrix *matrix)
+  {
+    return NotImplemented;
+  }
+
+  Status Translate(REAL dx, REAL dy)
+  {
+    return NotImplemented;
+  }
+
+  Status Translate(INT dx, INT dy)
+  {
+    return NotImplemented;
+  }
+
+  Status Union(const Rect &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status Union(const Region *region)
+  {
+    return NotImplemented;
+  }
+
+  Status Union(const RectF &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status Union(const GraphicsPath *path)
+  {
+    return NotImplemented;
+  }
+
+  Status Xor(const GraphicsPath *path)
+  {
+    return NotImplemented;
+  }
+
+  Status Xor(const RectF &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status Xor(const Rect &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status Xor(const Region *region)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class CustomLineCap : public GdiplusBase
+{
+public:
+  CustomLineCap(const GraphicsPath *fillPath, const GraphicsPath *strokePath, LineCap baseCap, REAL baseInset);
+  CustomLineCap *Clone(VOID);
+  LineCap GetBaseCap(VOID);
+  REAL GetBaseInset(VOID);
+  Status GetLastStatus(VOID);
+  Status GetStrokeCaps(LineCap *startCap, LineCap *endCap);
+  LineJoin GetStrokeJoin(VOID);
+  REAL GetWidthScale(VOID);
+  Status SetBaseCap(LineCap baseCap);
+  Status SetBaseInset(REAL inset);
+  Status SetStrokeCap(LineCap strokeCap);
+  Status SetStrokeCaps(LineCap startCap, LineCap endCap);
+  Status SetStrokeJoin(LineJoin lineJoin);
+  Status SetWidthScale(IN REAL widthScale);
+protected:
+  CustomLineCap();
+};
+
+#endif /* _GDIPLUSHEADERS_H */

reactos/w32api/include/GdiPlusImageAttributes.h

@@ -0,0 +1,164 @@
+/*
+ * GdiPlusImageAttributes.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSIMAGEATTRIBUTES_H
+#define _GDIPLUSIMAGEATTRIBUTES_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+class ImageAttributes : public GdiplusBase
+{
+public:
+  ImageAttributes(VOID)
+  {
+  }
+
+  Status ClearBrushRemapTable(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status ClearColorKey(ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status ClearColorMatrices(ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status ClearColorMatrix(ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status ClearGamma(ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status ClearNoOp(ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status ClearOutputChannel(ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status ClearOutputChannelColorProfile(ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status ClearRemapTable(ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status ClearThreshold(ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  ImageAttributes *Clone(VOID)
+  {
+    return NULL;
+  }
+
+  Status GetAdjustedPalette(ColorPalette *colorPalette, ColorPalette colorAdjustType)
+  {
+    return NotImplemented;
+  }
+
+  Status GetLastStatus(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status Reset(ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status SetBrushRemapTable(UINT mapSize, ColorMap *map)
+  {
+    return NotImplemented;
+  }
+
+  Status SetColorKey(const Color &colorLow, const Color &colorHigh, ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status SetColorMatrices(const ColorMatrix *colorMatrix, const ColorMatrix *grayMatrix, ColorMatrixFlags mode, ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status SetColorMatrix(const ColorMatrix *colorMatrix, ColorMatrixFlags mode, ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status SetGamma(REAL gamma, ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status SetNoOp(ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status SetOutputChannel(ColorChannelFlags channelFlags, ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status SetOutputChannelColorProfile(const WCHAR *colorProfileFilename, ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status SetRemapTable(UINT mapSize, const ColorMap *map, ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status SetThreshold(REAL threshold, ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status SetToIdentity(ColorAdjustType type)
+  {
+    return NotImplemented;
+  }
+
+  Status SetWrapMode(WrapMode wrap, const Color &color, BOOL clamp)
+  {
+    return NotImplemented;
+  }
+};
+
+#endif /* _GDIPLUSIMAGEATTRIBUTES_H */

reactos/w32api/include/GdiPlusImaging.h

@@ -0,0 +1,347 @@
+/*
+ * GdiPlusImaging.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSIMAGING_H
+#define _GDIPLUSIMAGING_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+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);
+DEFINE_GUID(ImageFormatEXIF, 0xb96b3cb2,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e);
+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);
+DEFINE_GUID(ImageFormatUndefined, 0xb96b3ca9,0x0728,0x11d3,0x9d,0x7b,0x00,0x00,0xf8,0x1e,0xf3,0x2e);
+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);
+DEFINE_GUID(FrameDimensionTime, 0x6aedbd6d,0x3fb5,0x418a,0x83,0xa6,0x7f,0x45,0x22,0x9d,0xc8,0x72);
+
+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);
+DEFINE_GUID(EncoderCompression, 0xe09d739d,0xccd4,0x44ee,0x8e,0xba,0x3f,0xbf,0x8b,0xe4,0xfc,0x58);
+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);
+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 PropertyTagTypeASCII 2
+#define PropertyTagTypeByte 1
+#define PropertyTagTypeLong 4
+#define PropertyTagTypeRational 5
+#define PropertyTagTypeShort 3
+#define PropertyTagTypeSLONG 9
+#define PropertyTagTypeSRational 10
+#define PropertyTagTypeUndefined 7
+
+#define PropertyTagGpsVer 0x0000
+#define PropertyTagGpsLatitudeRef 0x0001
+#define PropertyTagGpsLatitude 0x0002
+#define PropertyTagGpsLongitudeRef 0x0003
+#define PropertyTagGpsLongitude 0x0004
+#define PropertyTagGpsAltitudeRef 0x0005
+#define PropertyTagGpsAltitude 0x0006
+#define PropertyTagGpsGpsTime 0x0007
+#define PropertyTagGpsGpsSatellites 0x0008
+#define PropertyTagGpsGpsStatus 0x0009
+#define PropertyTagGpsGpsMeasureMode 0x000A
+#define PropertyTagGpsGpsDop 0x000B
+#define PropertyTagGpsSpeedRef 0x000C
+#define PropertyTagGpsSpeed 0x000D
+#define PropertyTagGpsTrackRef 0x000E
+#define PropertyTagGpsTrack 0x000F
+#define PropertyTagGpsImgDirRef 0x0010
+#define PropertyTagGpsImgDir 0x0011
+#define PropertyTagGpsMapDatum 0x0012
+#define PropertyTagGpsDestLatRef 0x0013
+#define PropertyTagGpsDestLat 0x0014
+#define PropertyTagGpsDestLongRef 0x0015
+#define PropertyTagGpsDestLong 0x0016
+#define PropertyTagGpsDestBearRef 0x0017
+#define PropertyTagGpsDestBear 0x0018
+#define PropertyTagGpsDestDistRef 0x0019
+#define PropertyTagGpsDestDist 0x001A
+#define PropertyTagNewSubfileType 0x00FE
+#define PropertyTagSubfileType 0x00FF
+#define PropertyTagImageWidth 0x0100
+#define PropertyTagImageHeight 0x0101
+#define PropertyTagBitsPerSample 0x0102
+#define PropertyTagCompression 0x0103
+#define PropertyTagPhotometricInterp 0x0106
+#define PropertyTagThreshHolding 0x0107
+#define PropertyTagCellWidth 0x0108
+#define PropertyTagCellHeight 0x0109
+#define PropertyTagFillOrder 0x010A
+#define PropertyTagDocumentName 0x010D
+#define PropertyTagImageDescription 0x010E
+#define PropertyTagEquipMake 0x010F
+#define PropertyTagEquipModel 0x0110
+#define PropertyTagStripOffsets 0x0111
+#define PropertyTagOrientation 0x0112
+#define PropertyTagSamplesPerPixel 0x0115
+#define PropertyTagRowsPerStrip 0x0116
+#define PropertyTagStripBytesCount 0x0117
+#define PropertyTagMinSampleValue 0x0118
+#define PropertyTagMaxSampleValue 0x0119
+#define PropertyTagXResolution 0x011A
+#define PropertyTagYResolution 0x011B
+#define PropertyTagPlanarConfig 0x011C
+#define PropertyTagPageName 0x011D
+#define PropertyTagXPosition 0x011E
+#define PropertyTagYPosition 0x011F
+#define PropertyTagFreeOffset 0x0120
+#define PropertyTagFreeByteCounts 0x0121
+#define PropertyTagGrayResponseUnit 0x0122
+#define PropertyTagGrayResponseCurve 0x0123
+#define PropertyTagT4Option 0x0124
+#define PropertyTagT6Option 0x0125
+#define PropertyTagResolutionUnit 0x0128
+#define PropertyTagPageNumber 0x0129
+#define PropertyTagTransferFuncition 0x012D
+#define PropertyTagSoftwareUsed 0x0131
+#define PropertyTagDateTime 0x0132
+#define PropertyTagArtist 0x013B
+#define PropertyTagHostComputer 0x013C
+#define PropertyTagPredictor 0x013D
+#define PropertyTagWhitePoint 0x013E
+#define PropertyTagPrimaryChromaticities 0x013F
+#define PropertyTagColorMap 0x0140
+#define PropertyTagHalftoneHints 0x0141
+#define PropertyTagTileWidth 0x0142
+#define PropertyTagTileLength 0x0143
+#define PropertyTagTileOffset 0x0144
+#define PropertyTagTileByteCounts 0x0145
+#define PropertyTagInkSet 0x014C
+#define PropertyTagInkNames 0x014D
+#define PropertyTagNumberOfInks 0x014E
+#define PropertyTagDotRange 0x0150
+#define PropertyTagTargetPrinter 0x0151
+#define PropertyTagExtraSamples 0x0152
+#define PropertyTagSampleFormat 0x0153
+#define PropertyTagSMinSampleValue 0x0154
+#define PropertyTagSMaxSampleValue 0x0155
+#define PropertyTagTransferRange 0x0156
+#define PropertyTagJPEGProc 0x0200
+#define PropertyTagJPEGInterFormat 0x0201
+#define PropertyTagJPEGInterLength 0x0202
+#define PropertyTagJPEGRestartInterval 0x0203
+#define PropertyTagJPEGLosslessPredictors 0x0205
+#define PropertyTagJPEGPointTransforms 0x0206
+#define PropertyTagJPEGQTables 0x0207
+#define PropertyTagJPEGDCTables 0x0208
+#define PropertyTagJPEGACTables 0x0209
+#define PropertyTagYCbCrCoefficients 0x0211
+#define PropertyTagYCbCrSubsampling 0x0212
+#define PropertyTagYCbCrPositioning 0x0213
+#define PropertyTagREFBlackWhite 0x0214
+#define PropertyTagGamma 0x0301
+#define PropertyTagICCProfileDescriptor 0x0302
+#define PropertyTagSRGBRenderingIntent 0x0303
+#define PropertyTagImageTitle 0x0320
+#define PropertyTagResolutionXUnit 0x5001
+#define PropertyTagResolutionYUnit 0x5002
+#define PropertyTagResolutionXLengthUnit 0x5003
+#define PropertyTagResolutionYLengthUnit 0x5004
+#define PropertyTagPrintFlags 0x5005
+#define PropertyTagPrintFlagsVersion 0x5006
+#define PropertyTagPrintFlagsCrop 0x5007
+#define PropertyTagPrintFlagsBleedWidth 0x5008
+#define PropertyTagPrintFlagsBleedWidthScale 0x5009
+#define PropertyTagHalftoneLPI 0x500A
+#define PropertyTagHalftoneLPIUnit 0x500B
+#define PropertyTagHalftoneDegree 0x500C
+#define PropertyTagHalftoneShape 0x500D
+#define PropertyTagHalftoneMisc 0x500E
+#define PropertyTagHalftoneScreen 0x500F
+#define PropertyTagJPEGQuality 0x5010
+#define PropertyTagGridSize 0x5011
+#define PropertyTagThumbnailFormat 0x5012
+#define PropertyTagThumbnailWidth 0x5013
+#define PropertyTagThumbnailHeight 0x5014
+#define PropertyTagThumbnailColorDepth 0x5015
+#define PropertyTagThumbnailPlanes 0x5016
+#define PropertyTagThumbnailRawBytes 0x5017
+#define PropertyTagThumbnailSize 0x5018
+#define PropertyTagThumbnailCompressedSize 0x5019
+#define PropertyTagColorTransferFunction 0x501A
+#define PropertyTagThumbnailData 0x501B
+#define PropertyTagThumbnailImageWidth 0x5020
+#define PropertyTagThumbnailImageHeight 0x5021
+#define PropertyTagThumbnailBitsPerSample 0x5022
+#define PropertyTagThumbnailCompression 0x5023
+#define PropertyTagThumbnailPhotometricInterp 0x5024
+#define PropertyTagThumbnailImageDescription 0x5025
+#define PropertyTagThumbnailEquipMake 0x5026
+#define PropertyTagThumbnailEquipModel 0x5027
+#define PropertyTagThumbnailStripOffsets 0x5028
+#define PropertyTagThumbnailOrientation 0x5029
+#define PropertyTagThumbnailSamplesPerPixel 0x502A
+#define PropertyTagThumbnailRowsPerStrip 0x502B
+#define PropertyTagThumbnailStripBytesCount 0x502C
+#define PropertyTagThumbnailResolutionX 0x502D
+#define PropertyTagThumbnailResolutionY 0x502E
+#define PropertyTagThumbnailPlanarConfig 0x502F
+#define PropertyTagThumbnailResolutionUnit 0x5030
+#define PropertyTagThumbnailTransferFunction 0x5031
+#define PropertyTagThumbnailSoftwareUsed 0x5032
+#define PropertyTagThumbnailDateTime 0x5033
+#define PropertyTagThumbnailArtist 0x5034
+#define PropertyTagThumbnailWhitePoint 0x5035
+#define PropertyTagThumbnailPrimaryChromaticities 0x5036
+#define PropertyTagThumbnailYCbCrCoefficients 0x5037
+#define PropertyTagThumbnailYCbCrSubsampling 0x5038
+#define PropertyTagThumbnailYCbCrPositioning 0x5039
+#define PropertyTagThumbnailRefBlackWhite 0x503A
+#define PropertyTagThumbnailCopyRight 0x503B
+#define PropertyTagLuminanceTable 0x5090
+#define PropertyTagChrominanceTable 0x5091
+#define PropertyTagFrameDelay 0x5100
+#define PropertyTagLoopCount 0x5101
+#define PropertyTagPixelUnit 0x5110
+#define PropertyTagPixelPerUnitX 0x5111
+#define PropertyTagPixelPerUnitY 0x5112
+#define PropertyTagPaletteHistogram 0x5113
+#define PropertyTagCopyright 0x8298
+#define PropertyTagExifExposureTime 0x829A
+#define PropertyTagExifFNumber 0x829D
+#define PropertyTagExifIFD 0x8769
+#define PropertyTagICCProfile 0x8773
+#define PropertyTagExifExposureProg 0x8822
+#define PropertyTagExifSpectralSense 0x8824
+#define PropertyTagGpsIFD 0x8825
+#define PropertyTagExifISOSpeed 0x8827
+#define PropertyTagExifOECF 0x8828
+#define PropertyTagExifVer 0x9000
+#define PropertyTagExifDTOrig 0x9003
+#define PropertyTagExifDTDigitized 0x9004
+#define PropertyTagExifCompConfig 0x9101
+#define PropertyTagExifCompBPP 0x9102
+#define PropertyTagExifShutterSpeed 0x9201
+#define PropertyTagExifAperture 0x9202
+#define PropertyTagExifBrightness 0x9203
+#define PropertyTagExifExposureBias 0x9204
+#define PropertyTagExifMaxAperture 0x9205
+#define PropertyTagExifSubjectDist 0x9206
+#define PropertyTagExifMeteringMode 0x9207
+#define PropertyTagExifLightSource 0x9208
+#define PropertyTagExifFlash 0x9209
+#define PropertyTagExifFocalLength 0x920A
+#define PropertyTagExifMakerNote 0x927C
+#define PropertyTagExifUserComment 0x9286
+#define PropertyTagExifDTSubsec 0x9290
+#define PropertyTagExifDTOrigSS 0x9291
+#define PropertyTagExifDTDigSS 0x9292
+#define PropertyTagExifFPXVer 0xA000
+#define PropertyTagExifColorSpace 0xA001
+#define PropertyTagExifPixXDim 0xA002
+#define PropertyTagExifPixYDim 0xA003
+#define PropertyTagExifRelatedWav 0xA004
+#define PropertyTagExifInterop 0xA005
+#define PropertyTagExifFlashEnergy 0xA20B
+#define PropertyTagExifSpatialFR 0xA20C
+#define PropertyTagExifFocalXRes 0xA20E
+#define PropertyTagExifFocalYRes 0xA20F
+#define PropertyTagExifFocalResUnit 0xA210
+#define PropertyTagExifSubjectLoc 0xA214
+#define PropertyTagExifExposureIndex 0xA215
+#define PropertyTagExifSensingMethod 0xA217
+#define PropertyTagExifFileSource 0xA300
+#define PropertyTagExifSceneType 0xA301
+#define PropertyTagExifCfaPattern 0xA302
+
+
+class BitmapData
+{
+public:
+  UINT Width;
+  UINT Height;
+  INT Stride;
+  PixelFormat PixelFormat1;
+  VOID *Scan0;
+  UINT_PTR Reserved;
+};
+
+
+class EncoderParameter
+{
+public:
+  GUID Guid;
+  ULONG NumberOfValues;
+  ULONG Type;
+  VOID *Value;
+};
+
+
+class EncoderParameters
+{
+public:
+  UINT Count;
+  EncoderParameter Parameter[1];
+};
+
+
+class ImageCodecInfo
+{
+public:
+  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;
+};
+
+class ImageItemData
+{
+public:
+  UINT Size;
+  UINT Position;
+  VOID *Desc;
+  UINT DescSize;
+  UINT *Data;
+  UINT DataSize;
+  UINT Cookie;
+};
+
+
+class PropertyItem
+{
+public:
+  PROPID id;
+  ULONG length;
+  WORD type;
+  VOID *value;
+};
+
+#endif /* _GDIPLUSIMAGING_H */

reactos/w32api/include/GdiPlusInit.h

@@ -0,0 +1,63 @@
+/*
+ * GdiPlusInit.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSINIT_H
+#define _GDIPLUSINIT_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+enum DebugEventLevel {
+  DebugEventLevelFatal,
+  DebugEventLevelWarning
+};
+
+typedef VOID (WINAPI *DebugEventProc)(DebugEventLevel level, CHAR *message);
+
+struct GdiplusStartupInput
+{
+  UINT32 GdiplusVersion;
+  DebugEventProc DebugEventCallback;
+  BOOL SuppressBackgroundThread;
+  BOOL SuppressExternalCodecs;
+
+  GdiplusStartupInput(
+    DebugEventProc debugEventCallback = NULL,
+    BOOL suppressBackgroundThread = FALSE,
+    BOOL suppressExternalCodecs = FALSE)
+  {
+    GdiplusVersion = 1;
+    DebugEventCallback = debugEventCallback;
+    SuppressBackgroundThread = suppressBackgroundThread;
+    SuppressExternalCodecs = suppressExternalCodecs;
+  }
+};
+
+typedef Status (WINAPI *NotificationHookProc)(OUT ULONG_PTR *token);
+typedef VOID (WINAPI *NotificationUnhookProc)(ULONG_PTR token);
+
+struct GdiplusStartupOutput {
+  NotificationHookProc NotificationHook;
+  NotificationUnhookProc NotificationUnhook;
+};
+
+extern "C" WINAPI Status GdiplusStartup(ULONG_PTR *token, const GdiplusStartupInput *input, GdiplusStartupOutput *output);
+extern "C" WINAPI VOID GdiplusShutdown(ULONG_PTR token);
+
+#endif /* _GDIPLUSINIT_H */

reactos/w32api/include/GdiPlusLineCaps.h

@@ -0,0 +1,159 @@
+/*
+ * GdiPlusLineCaps.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSLINECAPS_H
+#define _GDIPLUSLINECAPS_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+inline
+CustomLineCap::CustomLineCap(const GraphicsPath *fillPath,
+  const GraphicsPath *strokePath, LineCap baseCap, REAL baseInset)
+{
+}
+
+inline CustomLineCap *
+CustomLineCap::Clone(VOID)
+{
+  return NULL;
+}
+
+inline LineCap
+CustomLineCap::GetBaseCap(VOID)
+{
+  return LineCapFlat;
+}
+
+inline REAL
+CustomLineCap::GetBaseInset(VOID)
+{
+  return 0;
+}
+
+inline Status
+CustomLineCap::GetLastStatus(VOID)
+{
+  return Ok;
+}
+
+inline Status
+CustomLineCap::GetStrokeCaps(LineCap *startCap, LineCap *endCap)
+{
+  return Ok;
+}
+
+inline LineJoin
+CustomLineCap::GetStrokeJoin(VOID)
+{
+  return LineJoinMiter;
+}
+
+inline REAL
+CustomLineCap::GetWidthScale(VOID)
+{
+  return 0;
+}
+
+inline Status
+CustomLineCap::SetBaseCap(LineCap baseCap)
+{
+  return Ok;
+}
+
+inline Status
+CustomLineCap::SetBaseInset(REAL inset)
+{
+  return Ok;
+}
+
+inline Status
+CustomLineCap::SetStrokeCap(LineCap strokeCap)
+{
+  return Ok;
+}
+
+inline Status
+CustomLineCap::SetStrokeCaps(LineCap startCap, LineCap endCap)
+{
+  return Ok;
+}
+
+inline Status
+CustomLineCap::SetStrokeJoin(LineJoin lineJoin)
+{
+  return Ok;
+}
+
+inline Status
+CustomLineCap::SetWidthScale(IN REAL widthScale)
+{
+  return Ok;
+}
+
+
+class AdjustableArrowCap : public CustomLineCap
+{
+public:
+  AdjustableArrowCap(REAL height, REAL width, BOOL isFilled)
+  {
+  }
+
+  REAL GetHeight(VOID)
+  {
+    return 0;
+  }
+
+  REAL GetMiddleInset(VOID)
+  {
+    return 0;
+  }
+
+  REAL GetWidth(VOID)
+  {
+    return 0;
+  }
+
+  BOOL IsFilled(VOID)
+  {
+    return FALSE;
+  }
+
+  Status SetFillState(BOOL isFilled)
+  {
+    return Ok;
+  }
+
+  Status SetHeight(REAL height)
+  {
+    return Ok;
+  }
+
+  Status SetMiddleInset(REAL middleInset)
+  {
+    return Ok;
+  }
+
+  Status SetWidth(REAL width)
+  {
+    return Ok;
+  }
+};
+
+#endif /* _GDIPLUSLINECAPS_H */

reactos/w32api/include/GdiPlusMatrix.h

@@ -0,0 +1,151 @@
+/*
+ * GdiPlusMatrix.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSMATRIX_H
+#define _GDIPLUSMATRIX_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+class Matrix : public GdiplusBase
+{
+public:
+  Matrix(const RectF &rect, const PointF *dstplg)
+  {
+  }
+
+  Matrix(const Rect &rect, const Point *dstplg)
+  {
+  }
+
+  Matrix(VOID)
+  {
+  }
+
+  Matrix(REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy)
+  {
+  }
+
+  Matrix *Clone(VOID)
+  {
+    return NULL;
+  }
+
+  static BOOL Equals(const Matrix* matrix)
+  {
+    return FALSE;
+  }
+
+  Status GetElements(REAL *m) const
+  {
+    return NotImplemented;
+  }
+
+  Status GetLastStatus(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status Invert(VOID)
+  {
+    return NotImplemented;
+  }
+
+  BOOL IsIdentity(VOID)
+  {
+    return FALSE;
+  }
+
+  BOOL IsInvertible(VOID)
+  {
+    return FALSE;
+  }
+
+  Status Multiply(const Matrix *matrix, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  REAL OffsetX(VOID)
+  {
+    return 0;
+  }
+
+  REAL OffsetY(VOID)
+  {
+    return 0;
+  }
+
+  Status Reset(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status Rotate(REAL angle, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status RotateAt(REAL angle, const PointF &center, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status Scale(REAL scaleX, REAL scaleY, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status SetElements(REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy)
+  {
+    return NotImplemented;
+  }
+
+  Status Shear(REAL shearX, REAL shearY, REAL order)
+  {
+    return NotImplemented;
+  }
+
+  Status TransformPoints(Point *pts, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status TransformPoints(PointF *pts, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status TransformVectors(Point *pts, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status TransformVectors(PointF *pts, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status Translate(REAL offsetX, REAL offsetY, REAL order)
+  {
+    return NotImplemented;
+  }
+};
+
+#endif /* _GDIPLUSMATRIX_H */

reactos/w32api/include/GdiPlusMem.h

@@ -0,0 +1,39 @@
+/*
+ * GdiPlusMem.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSMEM_H
+#define _GDIPLUSMEM_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WINGDIPAPI __stdcall
+
+void* WINGDIPAPI GdipAlloc(size_t size);
+void WINGDIPAPI GdipFree(void* ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _GDIPLUSMEM_H */

reactos/w32api/include/GdiPlusMetaFile.h

@@ -0,0 +1,132 @@
+/*
+ * GdiPlusMetaFile.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSMETAFILE_H
+#define _GDIPLUSMETAFILE_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+class Metafile : public Image
+{
+public:
+  Metafile(HDC referenceHdc, EmfType type, const WCHAR *description)
+  {
+  }
+
+  Metafile(const WCHAR *filename)
+  {
+  }
+
+  Metafile(HDC referenceHdc, const RectF &frameRect, MetafileFrameUnit frameUnit, EmfType type, const WCHAR *description)
+  {
+  }
+
+  Metafile(HMETAFILE hWmf, const WmfPlaceableFileHeader *wmfPlaceableFileHeader, BOOL deleteWmf)
+  {
+  }
+
+  Metafile(const WCHAR *fileName, HDC referenceHdc, const Rect &frameRect, MetafileFrameUnit frameUnit, EmfType type, const WCHAR *description)
+  {
+  }
+
+  Metafile(IStream *stream, HDC referenceHdc, const RectF &frameRect, MetafileFrameUnit frameUnit, EmfType type, const WCHAR *description)
+  {
+  }
+
+  Metafile(IStream *stream, HDC referenceHdc, EmfType type, const WCHAR *description)
+  {
+  }
+
+  Metafile(IStream *stream, HDC referenceHdc, const Rect &frameRect, MetafileFrameUnit frameUnit, EmfType type, const WCHAR *description)
+  {
+  }
+
+  Metafile(const WCHAR *fileName, HDC referenceHdc, const RectF &frameRect, MetafileFrameUnit frameUnit, EmfType type, const WCHAR *description)
+  {
+  }
+
+  Metafile(const WCHAR *fileName, HDC referenceHdc, EmfType type, const WCHAR *description)
+  {
+  }
+
+  Metafile(IStream *stream)
+  {
+  }
+
+  Metafile(HENHMETAFILE hEmf, BOOL deleteEmf)
+  {
+  }
+
+  Metafile(HDC referenceHdc, const Rect &frameRect, MetafileFrameUnit frameUnit, EmfType type, const WCHAR *description)
+  {
+  }
+
+  static UINT EmfToWmfBits(HENHMETAFILE hemf, UINT cbData16, LPBYTE pData16, INT iMapMode, EmfToWmfBitsFlags eFlags)
+  {
+    return 0;
+  }
+
+  UINT GetDownLevelRasterizationLimit(VOID)
+  {
+    return 0;
+  }
+
+  HENHMETAFILE GetHENHMETAFILE(VOID)
+  {
+    return NULL;
+  }
+
+  static Status GetMetafileHeader(const WCHAR *filename, MetafileHeader *header)
+  {
+    return NotImplemented;
+  }
+
+  static Status GetMetafileHeader(HENHMETAFILE *hEmf, MetafileHeader *header)
+  {
+    return NotImplemented;
+  }
+
+  static Status GetMetafileHeader(HMETAFILE hWmf, const WmfPlaceableFileHeader *wmfPlaceableFileHeader, MetafileHeader *header)
+  {
+    return NotImplemented;
+  }
+
+  Status GetMetafileHeader(MetafileHeader *header) const
+  {
+    return NotImplemented;
+  }
+
+  static Status GetMetafileHeader(IStream *stream, MetafileHeader *header)
+  {
+    return NotImplemented;
+  }
+
+  Status PlayRecord(EmfPlusRecordType recordType, UINT flags, UINT dataSize, const BYTE *data)
+  {
+    return NotImplemented;
+  }
+
+  Status SetDownLevelRasterizationLimit(UINT metafileRasterizationLimitDpi)
+  {
+    return NotImplemented;
+  }
+};
+
+#endif /* _GDIPLUSMETAFILE_H */

reactos/w32api/include/GdiPlusMetaHeader.h

@@ -0,0 +1,168 @@
+/*
+ * GdiPlusMetaHeader.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSMETAHEADER_H
+#define _GDIPLUSMETAHEADER_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+typedef struct {
+  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;
+
+typedef struct {
+  INT16 Left;
+  INT16 Top;
+  INT16 Right;
+  INT16 Bottom;
+} PWMFRect16;
+
+typedef struct {
+  UINT32 Key;
+  INT16 Hmf;
+  PWMFRect16 BoundingBox;
+  INT16 Inch;
+  UINT32 Reserved;
+  INT16 Checksum;
+} WmfPlaceableFileHeader;
+
+
+class MetafileHeader
+{
+public:
+  VOID GetBounds(Rect *rect)
+  {
+  }
+
+  REAL GetDpiX(VOID)
+  {
+    return 0;
+  }
+
+  REAL GetDpiY(VOID)
+  {
+    return 0;
+  }
+
+  const ENHMETAHEADER3 *GetEmfHeader(VOID) const
+  {
+    return NULL;
+  }
+
+  UINT GetEmPlusFlags(VOID)
+  {
+    return 0;
+  }
+
+  UINT GetMetafileSize(VOID)
+  {
+    return 0;
+  }
+
+  MetafileType GetType(VOID)
+  {
+    return MetafileTypeInvalid;
+  }
+
+  UINT GetVersion(VOID)
+  {
+    return 0;
+  }
+
+  const METAHEADER *GetWmfHeader(VOID) const
+  {
+    return NULL;
+  }
+
+  BOOL IsDisplay(VOID) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsEmf(VOID) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsEmfOrEmfPlus(VOID) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsEmfPlus(VOID) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsEmfPlusDual(VOID) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsEmfPlusOnly(VOID) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsWmf(VOID)
+  {
+    return FALSE;
+  }
+
+  BOOL IsWmfPlaceable(VOID) const
+  {
+    return FALSE;
+  }
+
+  REAL DpiX;
+  REAL DpiY;
+  UINT EmfPlusFlags;
+  INT EmfPlusHeaderSize;
+  INT Height;
+  INT LogicalDpiX;
+  INT LogicalDpiY;
+  MetafileType Type;
+  UINT Version;
+  INT Width;
+  INT X;
+  INT Y;
+
+  union
+  {
+    METAHEADER WmfHeader;
+    ENHMETAHEADER3 EmfHeader;
+  };
+};
+
+#endif /* _GDIPLUSMETAHEADER_H */

reactos/w32api/include/GdiPlusPath.h

@@ -0,0 +1,687 @@
+/*
+ * GdiPlusPath.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSPATH_H
+#define _GDIPLUSPATH_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+class GraphicsPath : public GdiplusBase
+{
+public:
+  GraphicsPath(const Point *points, const BYTE *types, INT count, FillMode fillMode)
+  {
+  }
+
+  GraphicsPath(FillMode fillMode)
+  {
+  }
+
+  GraphicsPath(const PointF *points, const BYTE *types, INT count, FillMode fillMode)
+  {
+  }
+
+  Status AddArc(const Rect &rect, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status AddArc(const RectF &rect, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status AddArc(INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status AddArc(REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status AddBezier(const Point &pt1, const Point &pt2, const Point &pt3, const Point &pt4)
+  {
+    return NotImplemented;
+  }
+
+  Status AddBezier(REAL x1, REAL y1, REAL x2, REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
+  {
+    return NotImplemented;
+  }
+
+  Status AddBezier(const PointF &pt1, const PointF &pt2, const PointF &pt3, const PointF &pt4)
+  {
+    return NotImplemented;
+  }
+
+  Status AddBezier(INT x1, INT y1, INT x2, INT y2, INT x3, INT y3, INT x4, INT y4)
+  {
+    return NotImplemented;
+  }
+
+  Status AddBeziers(const Point *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status AddBeziers(const PointF *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status AddClosedCurve(const Point *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status AddClosedCurve(const Point *points, INT count, REAL tension)
+  {
+    return NotImplemented;
+  }
+
+  Status AddClosedCurve(const PointF *points, INT count, REAL tension)
+  {
+    return NotImplemented;
+  }
+
+  Status AddClosedCurve(const PointF *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status AddCurve(const Point *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status AddCurve(const PointF *points, INT count, REAL tension)
+  {
+    return NotImplemented;
+  }
+
+  Status AddCurve(const PointF *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status AddCurve(const Point *points, INT count, INT offset, INT numberOfSegments, REAL tension)
+  {
+    return NotImplemented;
+  }
+
+  Status AddCurve(const Point *points, INT count, REAL tension)
+  {
+    return NotImplemented;
+  }
+
+  Status AddCurve(const PointF *points, INT count, INT offset, INT numberOfSegments, REAL tension)
+  {
+    return NotImplemented;
+  }
+
+  Status AddEllipse(const Rect &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status AddEllipse(const RectF &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status AddEllipse(INT x, INT y, INT width, INT height)
+  {
+    return NotImplemented;
+  }
+
+  Status AddEllipse(REAL x, REAL y, REAL width, REAL height)
+  {
+    return NotImplemented;
+  }
+
+  Status AddLine(const Point &pt1, const Point &pt2)
+  {
+    return NotImplemented;
+  }
+
+  Status AddLine(const PointF &pt1, const PointF &pt2)
+  {
+    return NotImplemented;
+  }
+
+  Status AddLine(REAL x1, REAL y1, REAL x2, REAL y2)
+  {
+    return NotImplemented;
+  }
+
+  Status AddLine(INT x1, INT y1, INT x2, INT y2)
+  {
+    return NotImplemented;
+  }
+
+  Status AddLines(const Point *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status AddLines(const PointF *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status AddPath(const GraphicsPath *addingPath, BOOL connect)
+  {
+    return NotImplemented;
+  }
+
+  Status AddPie(const Rect &rect, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status AddPie(INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status AddPie(REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status AddPie(const RectF &rect, REAL startAngle, REAL sweepAngle)
+  {
+    return NotImplemented;
+  }
+
+  Status AddPolygon(const Point *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status AddPolygon(const PointF *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status AddRectangle(const Rect &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status AddRectangle(const RectF &rect)
+  {
+    return NotImplemented;
+  }
+
+  Status AddRectangles(const Rect *rects, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status AddRectangles(const RectF *rects, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status AddString(const WCHAR *string, INT length, const FontFamily *family, INT style, REAL emSize, const Rect &layoutRect, const StringFormat *format)
+  {
+    return NotImplemented;
+  }
+
+  Status AddString(const WCHAR *string, INT length, const FontFamily *family, INT style, REAL emSize, const PointF &origin, const StringFormat *format)
+  {
+    return NotImplemented;
+  }
+
+  Status AddString(const WCHAR *string, INT length, const FontFamily *family, INT style, REAL emSize, const Point &origin, const StringFormat *format)
+  {
+    return NotImplemented;
+  }
+
+  Status AddString(const WCHAR *string, INT length, const FontFamily *family, INT style, REAL emSize, const RectF &layoutRect, const StringFormat *format)
+  {
+    return NotImplemented;
+  }
+
+  Status ClearMarkers(VOID)
+  {
+    return NotImplemented;
+  }
+
+  GraphicsPath *Clone(VOID)
+  {
+    return NULL;
+  }
+
+  Status CloseAllFigures(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status CloseFigure(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status Flatten(const Matrix *matrix, REAL flatness)
+  {
+    return NotImplemented;
+  }
+
+  Status GetBounds(Rect *bounds, const Matrix *matrix, const Pen *pen)
+  {
+    return NotImplemented;
+  }
+
+  Status GetBounds(RectF *bounds, const Matrix *matrix, const Pen *pen)
+  {
+    return NotImplemented;
+  }
+
+  FillMode GetFillMode(VOID)
+  {
+    return FillModeAlternate;
+  }
+
+  Status GetLastPoint(PointF *lastPoint)
+  {
+    return NotImplemented;
+  }
+
+  Status GetLastStatus(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status GetPathData(PathData *pathData)
+  {
+    return NotImplemented;
+  }
+
+  Status GetPathPoints(Point *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status GetPathPoints(PointF *points, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status GetPathTypes(BYTE *types, INT count)
+  {
+    return NotImplemented;
+  }
+
+  INT GetPointCount(VOID)
+  {
+    return 0;
+  }
+
+  BOOL IsOutlineVisible(const Point &point, const Pen *pen, const Graphics *g)
+  {
+    return FALSE;
+  }
+
+  BOOL IsOutlineVisible(REAL x, REAL y, const Pen *pen, const Graphics *g)
+  {
+    return FALSE;
+  }
+
+  BOOL IsOutlineVisible(INT x, INT y, const Pen *pen, const Graphics *g)
+  {
+    return FALSE;
+  }
+
+  BOOL IsOutlineVisible(const PointF &point, const Pen *pen, const Graphics *g)
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(REAL x, REAL y, const Graphics *g)
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(const PointF &point, const Graphics *g)
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(INT x, INT y, const Graphics *g)
+  {
+    return FALSE;
+  }
+
+  BOOL IsVisible(const Point &point, const Graphics *g)
+  {
+    return NotImplemented;
+  }
+
+  Status Outline(const Matrix *matrix, REAL flatness)
+  {
+    return NotImplemented;
+  }
+
+  Status Reset(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status Reverse(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status SetFillMode(FillMode fillmode)
+  {
+    return NotImplemented;
+  }
+
+  Status SetMarker(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status StartFigure(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status Transform(const Matrix *matrix)
+  {
+    return NotImplemented;
+  }
+
+  Status Warp(const PointF *destPoints, INT count, const RectF &srcRect, const Matrix *matrix, WarpMode warpMode, REAL flatness)
+  {
+    return NotImplemented;
+  }
+
+  Status Widen(const Pen *pen, const Matrix *matrix, REAL flatness)
+  {
+    return NotImplemented;
+  }
+};
+
+
+class GraphicsPathIterator : public GdiplusBase
+{
+public:
+  GraphicsPathIterator(GraphicsPath *path)
+  {
+  }
+
+  INT CopyData(PointF *points, BYTE *types, INT startIndex, INT endIndex)
+  {
+    return 0;
+  }
+
+  INT Enumerate(PointF *points, BYTE *types, INT count)
+  {
+    return 0;
+  }
+
+  INT GetCount(VOID)
+  {
+    return 0;
+  }
+
+  Status GetLastStatus(VOID)
+  {
+    return NotImplemented;
+  }
+
+  INT GetSubpathCount(VOID)
+  {
+    return 0;
+  }
+
+  BOOL HasCurve(VOID)
+  {
+    return FALSE;
+  }
+
+  INT NextMarker(GraphicsPath *path)
+  {
+    return 0;
+  }
+
+  INT NextMarker(INT *startIndex, INT *endIndex)
+  {
+    return 0;
+  }
+
+  INT NextPathType(BYTE *pathType, INT *startIndex, INT *endIndex)
+  {
+    return 0;
+  }
+
+  INT NextSubpath(GraphicsPath *path, BOOL *isClosed)
+  {
+    return 0;
+  }
+
+  INT NextSubpath(INT *startIndex, INT *endIndex, BOOL *isClosed)
+  {
+    return 0;
+  }
+
+  VOID Rewind(VOID)
+  {
+  }
+};
+
+
+class PathGradientBrush : public Brush
+{
+public:
+  PathGradientBrush(const Point *points, INT count, WrapMode wrapMode)
+  {
+  }
+
+  PathGradientBrush(const PointF *points, INT count, WrapMode wrapMode)
+  {
+  }
+
+  PathGradientBrush(const GraphicsPath *path)
+  {
+  }
+
+  INT GetBlendCount(VOID)
+  {
+    return 0;
+  }
+
+  Status GetBlend(REAL *blendFactors, REAL *blendPositions, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status GetCenterColor(Color *color)
+  {
+    return NotImplemented;
+  }
+
+  Status GetCenterPoint(Point *point)
+  {
+    return NotImplemented;
+  }
+
+  Status GetCenterPoint(PointF *point)
+  {
+    return NotImplemented;
+  }
+
+  Status GetFocusScales(REAL *xScale, REAL *yScale)
+  {
+    return NotImplemented;
+  }
+
+  BOOL GetGammaCorrection(VOID)
+  {
+    return FALSE;
+  }
+
+  Status GetGraphicsPath(GraphicsPath *path)
+  {
+    return NotImplemented;
+  }
+
+  INT GetInterpolationColorCount(VOID)
+  {
+    return 0;
+  }
+
+  Status GetInterpolationColors(Color *presetColors, REAL *blendPositions, INT count)
+  {
+    return NotImplemented;
+  }
+
+  INT GetPointCount(VOID)
+  {
+    return 0;
+  }
+
+  Status GetRectangle(RectF *rect)
+  {
+    return NotImplemented;
+  }
+
+  Status GetRectangle(Rect *rect)
+  {
+    return NotImplemented;
+  }
+
+  INT GetSurroundColorCount(VOID)
+  {
+    return 0;
+  }
+
+  Status GetSurroundColors(Color *colors, INT *count)
+  {
+    return NotImplemented;
+  }
+
+  Status GetTransform(Matrix *matrix)
+  {
+    return NotImplemented;
+  }
+
+  WrapMode GetWrapMode(VOID)
+  {
+    return WrapModeTile;
+  }
+
+  Status MultiplyTransform(Matrix *matrix, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status ResetTransform(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status RotateTransform(REAL angle, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status SetBlend(REAL *blendFactors, REAL *blendPositions, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status SetBlendBellShape(REAL focus, REAL scale)
+  {
+    return NotImplemented;
+  }
+
+  Status SetBlendTriangularShape(REAL focus, REAL scale)
+  {
+    return NotImplemented;
+  }
+
+  Status SetCenterColor(const Color &color)
+  {
+    return NotImplemented;
+  }
+
+  Status SetCenterPoint(const Point &point)
+  {
+    return NotImplemented;
+  }
+
+  Status SetCenterPoint(const PointF &point)
+  {
+    return NotImplemented;
+  }
+
+  Status SetFocusScales(REAL xScale, REAL yScale)
+  {
+    return NotImplemented;
+  }
+
+  Status SetGammaCorrection(BOOL useGammaCorrection)
+  {
+    return NotImplemented;
+  }
+
+  Status SetGraphicsPath(const GraphicsPath* path)
+  {
+    return NotImplemented;
+  }
+
+  Status SetInterpolationColors(const Color *presetColors, REAL *blendPositions, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status SetSurroundColors(const Color *colors, INT *count)
+  {
+    return NotImplemented;
+  }
+
+  Status SetTransform(const Matrix *matrix)
+  {
+    return NotImplemented;
+  }
+
+  Status SetWrapMode(WrapMode wrapMode)
+  {
+    return NotImplemented;
+  }
+
+  Status TranslateTransform(REAL dx, REAL dy, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+};
+
+#endif /* _GDIPLUSPATH_H */

reactos/w32api/include/GdiPlusPen.h

@@ -0,0 +1,260 @@
+/*
+ * GdiPlusPen.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSPEN_H
+#define _GDIPLUSPEN_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+class Pen : public GdiplusBase
+{
+  friend class Graphics;
+
+public:
+  Pen(const Brush *brush, REAL width = 1.0f)
+  {
+  }
+
+  Pen(const Color &color, REAL width = 1.0f)
+  {
+    Unit unit = UnitWorld;
+    pen = NULL;
+    status = DllExports::GdipCreatePen1(color.GetValue(),
+      width,
+      unit,
+      &pen);
+  }
+
+  Pen *Clone(VOID)
+  {
+    return NULL;
+  }
+
+  PenAlignment GetAlignment(VOID)
+  {
+    return PenAlignmentCenter;
+  }
+
+  Brush *GetBrush(VOID)
+  {
+    return NULL;
+  }
+
+  Status GetColor(Color *color)
+  {
+    return NotImplemented;
+  }
+
+  Status GetCompoundArray(REAL *compoundArray, INT count)
+  {
+    return NotImplemented;
+  }
+
+  INT GetCompoundArrayCount(VOID)
+  {
+    return 0;
+  }
+
+  Status GetCustomEndCap(CustomLineCap *customCap)
+  {
+    return NotImplemented;
+  }
+
+  Status GetCustomStartCap(CustomLineCap *customCap)
+  {
+    return NotImplemented;
+  }
+
+  DashCap GetDashCap(VOID)
+  {
+    return DashCapFlat;
+  }
+
+  REAL GetDashOffset(VOID)
+  {
+    return 0;
+  }
+
+  Status GetDashPattern(REAL *dashArray, INT count)
+  {
+    return NotImplemented;
+  }
+
+  INT GetDashPatternCount(VOID)
+  {
+    return 0;
+  }
+
+  DashStyle GetDashStyle(VOID)
+  {
+    return DashStyleSolid;
+  }
+
+  LineCap GetEndCap(VOID)
+  {
+    return LineCapFlat;
+  }
+
+  Status GetLastStatus(VOID)
+  {
+    return NotImplemented;
+  }
+
+  LineJoin GetLineJoin(VOID)
+  {
+    return LineJoinMiter;
+  }
+
+  REAL GetMiterLimit(VOID)
+  {
+    return 0;
+  }
+
+  PenType GetPenType(VOID)
+  {
+    return PenTypeSolidColor;
+  }
+
+  LineCap GetStartCap(VOID)
+  {
+    return LineCapFlat;
+  }
+
+  Status GetTransform(Matrix *matrix)
+  {
+    return NotImplemented;
+  }
+
+  REAL GetWidth(VOID)
+  {
+    return 0;
+  }
+
+  Status MultiplyTransform(Matrix *matrix, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status ResetTransform(VOID)
+  {
+    return NotImplemented;
+  }
+
+  Status RotateTransform(REAL angle, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
+  {
+    return NotImplemented;
+  }
+
+  Status SetAlignment(PenAlignment penAlignment)
+  {
+    return NotImplemented;
+  }
+
+  Status SetBrush(const Brush *brush)
+  {
+    return NotImplemented;
+  }
+
+  Status SetColor(const Color &color)
+  {
+    return NotImplemented;
+  }
+
+  Status SetCompoundArray(const REAL *compoundArray, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status SetCustomEndCap(const CustomLineCap *customCap)
+  {
+    return NotImplemented;
+  }
+
+  Status SetCustomStartCap(const CustomLineCap *customCap)
+  {
+    return NotImplemented;
+  }
+
+  Status SetDashCap(DashCap dashCap)
+  {
+    return NotImplemented;
+  }
+
+  Status SetDashOffset(REAL dashOffset)
+  {
+    return NotImplemented;
+  }
+
+  Status SetDashPattern(const REAL *dashArray, INT count)
+  {
+    return NotImplemented;
+  }
+
+  Status SetDashStyle(DashStyle dashStyle)
+  {
+    return NotImplemented;
+  }
+
+  Status SetEndCap(LineCap endCap)
+  {
+    return NotImplemented;
+  }
+
+  Status SetLineCap(LineCap startCap, LineCap endCap, DashCap dashCap)
+  {
+    return NotImplemented;
+  }
+
+  Status SetLineJoin(LineJoin lineJoin)
+  {
+    return NotImplemented;
+  }
+
+  Status SetMiterLimit(REAL miterLimit)
+  {
+    return NotImplemented;
+  }
+
+  Status SetStartCap(LineCap startCap)
+  {
+    return NotImplemented;
+  }
+
+  Status SetTransform(const Matrix *matrix)
+  {
+    return NotImplemented;
+  }
+
+  Status SetWidth(REAL width)
+  {
+    return NotImplemented;
+  }
+
+private:
+  Status status;
+  GpPen *pen;
+};
+
+#endif /* _GDIPLUSPEN_H */

reactos/w32api/include/GdiPlusPixelFormats.h

@@ -0,0 +1,62 @@
+/*
+ * GdiPlusPixelFormats.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSPIXELFORMATS_H
+#define _GDIPLUSPIXELFORMATS_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+#define PixelFormatIndexed 0x00010000
+#define PixelFormatGDI 0x00020000
+#define PixelFormatAlpha 0x00040000
+#define PixelFormatPAlpha 0x00080000
+#define PixelFormatExtended 0x00100000
+#define PixelFormatCanonical 0x00200000
+
+#define PixelFormatUndefined 0
+#define PixelFormatDontCare 0
+
+#define PixelFormat1bppIndexed (1 | ( 1 << 8) | PixelFormatIndexed | PixelFormatGDI)
+#define PixelFormat4bppIndexed (2 | ( 4 << 8) | PixelFormatIndexed | PixelFormatGDI)
+#define PixelFormat8bppIndexed (3 | ( 8 << 8) | PixelFormatIndexed | PixelFormatGDI)
+#define PixelFormat16bppARGB1555 (7 | (16 << 8) | PixelFormatAlpha | PixelFormatGDI)
+#define PixelFormat16bppGrayScale (4 | (16 << 8) | PixelFormatExtended)
+#define PixelFormat16bppRGB555 (5 | (16 << 8) | PixelFormatGDI)
+#define PixelFormat16bppRGB565 (6 | (16 << 8) | PixelFormatGDI)
+#define PixelFormat24bppRGB (8 | (24 << 8) | PixelFormatGDI)
+#define PixelFormat32bppARGB (10 | (32 << 8) | PixelFormatAlpha | PixelFormatGDI | PixelFormatCanonical)
+#define PixelFormat32bppPARGB (11 | (32 << 8) | PixelFormatAlpha | PixelFormatPAlpha | PixelFormatGDI)
+#define PixelFormat32bppRGB (9 | (32 << 8) | PixelFormatGDI)
+#define PixelFormat48bppRGB (12 | (48 << 8) | PixelFormatExtended)
+#define PixelFormat64bppARGB (13 | (64 << 8) | PixelFormatAlpha  | PixelFormatCanonical | PixelFormatExtended)
+#define PixelFormat64bppPARGB (14 | (64 << 8) | PixelFormatAlpha  | PixelFormatPAlpha | PixelFormatExtended)
+
+
+typedef INT PixelFormat;
+
+typedef DWORD ARGB;
+
+typedef struct {
+  UINT Flags;
+  UINT Count;
+  ARGB Entries[1];
+} ColorPalette;
+
+#endif /* _GDIPLUSPIXELFORMATS_H */

reactos/w32api/include/GdiPlusStringFormat.h

@@ -0,0 +1,148 @@
+/*
+ * GdiPlusStringFormat.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSSTRINGFORMAT_H
+#define _GDIPLUSSTRINGFORMAT_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+class StringFormat : public GdiplusBase
+{
+public:
+  StringFormat(INT formatFlags, LANGID language)
+  {
+  }
+
+  StringFormat(const StringFormat *format)
+  {
+  }
+
+  StringFormat *Clone(VOID)
+  {
+    return NULL;
+  }
+
+  static const StringFormat *GenericDefault(VOID)
+  {
+    return NULL;
+  }
+
+  static const StringFormat *GenericTypographic(VOID)
+  {
+    return NULL;
+  }
+
+  StringAlignment GetAlignment(VOID) const
+  {
+    return StringAlignmentNear;
+  }
+
+  LANGID GetDigitSubstitutionLanguage(VOID) const
+  {
+    return 0;
+  }
+
+  StringDigitSubstitute GetDigitSubstitutionMethod(VOID) const
+  {
+    return StringDigitSubstituteNone;
+  }
+
+  INT GetFormatFlags(VOID) const
+  {
+    return 0;
+  }
+
+  HotkeyPrefix GetHotkeyPrefix(VOID) const
+  {
+    return HotkeyPrefixNone;
+  }
+
+  Status GetLastStatus(VOID) const
+  {
+    return NotImplemented;
+  }
+
+  StringAlignment GetLineAlignment(VOID) const
+  {
+    return StringAlignmentNear;
+  }
+
+  INT GetMeasurableCharacterRangeCount(VOID) const
+  {
+    return 0;
+  }
+
+  INT GetTabStopCount(VOID) const
+  {
+    return 0;
+  }
+
+  Status GetTabStops(INT count, REAL *firstTabOffset, REAL *tabStops) const
+  {
+    return NotImplemented;
+  }
+
+  StringTrimming GetTrimming(VOID) const
+  {
+    return StringTrimmingNone;
+  }
+
+  Status SetAlignment(StringAlignment align)
+  {
+    return NotImplemented;
+  }
+
+  Status SetDigitSubstitution(LANGID language, StringDigitSubstitute substitute)
+  {
+    return NotImplemented;
+  }
+
+  Status SetFormatFlags(INT flags)
+  {
+    return NotImplemented;
+  }
+
+  Status SetHotkeyPrefix(HotkeyPrefix hotkeyPrefix)
+  {
+    return NotImplemented;
+  }
+
+  Status SetLineAlignment(StringAlignment align)
+  {
+    return NotImplemented;
+  }
+
+  Status SetMeasurableCharacterRanges(INT rangeCount, const CharacterRange *ranges)
+  {
+    return NotImplemented;
+  }
+
+  Status SetTabStops(REAL firstTabOffset, INT count, const REAL *tabStops)
+  {
+    return NotImplemented;
+  }
+
+  Status SetTrimming(StringTrimming trimming)
+  {
+    return NotImplemented;
+  }
+};
+
+#endif /* _GDIPLUSSTRINGFORMAT_H */

reactos/w32api/include/GdiPlusTypes.h

@@ -0,0 +1,509 @@
+/*
+ * GdiPlusTypes.h
+ *
+ * Windows GDI+
+ *
+ * This file is part of the w32api package.
+ *
+ * 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 _GDIPLUSTYPES_H
+#define _GDIPLUSTYPES_H
+
+#if __GNUC__ >= 3
+#pragma GCC system_header
+#endif
+
+typedef float REAL;
+
+extern "C" {
+  typedef BOOL (CALLBACK * ImageAbort)(VOID *);
+  typedef ImageAbort DrawImageAbort;
+  typedef ImageAbort GetThumbnailImageAbort;
+  typedef BOOL (CALLBACK * EnumerateMetafileProc)(EmfPlusRecordType, UINT, UINT, const BYTE*, VOID*);
+}
+
+typedef enum {
+  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
+} Status;
+
+
+class CharacterRange
+{
+public:
+  CharacterRange(VOID)
+  {
+  }
+
+  CharacterRange(INT first, INT length)
+  {
+  }
+
+  CharacterRange &operator=(const CharacterRange &rhs)
+  {
+    First  = rhs.First;
+    Length = rhs.Length;
+    return *this;
+  }
+
+public:
+  INT First;
+  INT Length;
+};
+
+
+class SizeF
+{
+public:
+  SizeF(VOID)
+  {
+  }
+
+  SizeF(FLOAT width, FLOAT height)
+  {
+  }
+
+  SizeF(const SizeF &size)
+  {
+  }
+
+  BOOL Empty(VOID)
+  {
+    return FALSE;
+  }
+
+  BOOL Equals(const SizeF &sz)
+  {
+    return FALSE;
+  }
+
+  SizeF operator+(const SizeF &sz)
+  {
+    return SizeF(Width + sz.Width,
+      Height + sz.Height);
+  }
+
+  SizeF operator-(const SizeF &sz)
+  {
+    return SizeF(Width - sz.Width,
+      Height - sz.Height);
+  }
+
+public:
+  FLOAT Height;
+  FLOAT Width;
+};
+
+
+class PointF
+{
+public:
+  PointF(REAL x, REAL y)
+  {
+  }
+
+  PointF(const SizeF &size)
+  {
+  }
+
+  PointF(VOID)
+  {
+  }
+
+  PointF(const PointF &point)
+  {
+  }
+
+  BOOL Equals(const PointF& point)
+  {
+    return FALSE;
+  }
+
+  PointF operator+(const PointF &point)
+  {
+    return PointF(X + point.X,
+      Y + point.Y);
+  }
+
+  PointF operator-(const PointF &point)
+  {
+    return PointF(X - point.X,
+      Y - point.Y);
+  }
+
+public:
+  REAL X;
+  REAL Y;
+};
+
+
+class PathData
+{
+public:
+  PathData(VOID)
+  {
+  }
+
+public:
+  INT Count;
+  PointF *Points;
+  BYTE *Types;
+};
+
+
+class Size
+{
+public:
+  Size(VOID)
+  {
+  }
+
+  Size(INT width, INT height)
+  {
+  }
+
+  Size(const Size &size)
+  {
+  }
+
+  BOOL Empty(VOID)
+  {
+    return FALSE;
+  }
+
+  BOOL Equals(const Size &sz)
+  {
+    return FALSE;
+  }
+
+  Size operator+(const Size &sz)
+  {
+    return Size(Width + sz.Width,
+      Height + sz.Height);
+  }
+
+  Size operator-(const Size &sz)
+  {
+    return Size(Width - sz.Width,
+      Height - sz.Height);
+  }
+
+public:
+  INT Height;
+  INT Width;
+};
+
+
+class Point
+{
+public:
+  Point(VOID)
+  {
+  }
+
+  Point(INT x, INT y)
+  {
+  }
+
+  Point(const Point &point)
+  {
+  }
+
+  Point(const Size &size)
+  {
+  }
+
+  BOOL Equals(const Point& point)
+  {
+    return FALSE;
+  }
+
+  Point operator+(const Point &point)
+  {
+    return Point(X + point.X,
+      Y + point.Y);
+  }
+
+  Point operator-(const Point &point)
+  {
+    return Point(X - point.X,
+      Y - point.Y);
+  }
+
+public:
+  INT X;
+  INT Y;
+};
+
+
+class Rect
+{
+public:
+  Rect(VOID)
+  {
+  }
+
+  Rect(const Point &location, const Size &size)
+  {
+  }
+
+  Rect(INT x, INT y, INT width, INT height)
+  {
+  }
+
+  Rect *Clone(VOID) const
+  {
+    return NULL;
+  }
+
+  BOOL Contains(const Point& pt)
+  {
+    return FALSE;
+  }
+
+  BOOL Contains(Rect& rect)
+  {
+    return FALSE;
+  }
+
+  BOOL Contains(INT x, INT y)
+  {
+    return FALSE;
+  }
+
+  BOOL Equals(const Rect& rect) const
+  {
+    return FALSE;
+  }
+
+  INT GetBottom(VOID) const
+  {
+    return 0;
+  }
+
+  VOID GetBounds(Rect* rect) const
+  {
+  }
+
+  INT GetLeft(VOID) const
+  {
+    return 0;
+  }
+
+  VOID GetLocation(Point* point) const
+  {
+  }
+
+  INT GetRight(VOID) const
+  {
+    return 0;
+  }
+
+  VOID GetSize(Size* size) const
+  {
+  }
+
+  INT GetTop(VOID) const
+  {
+    return 0;
+  }
+
+  VOID Inflate(INT dx, INT dy)
+  {
+  }
+
+  VOID Inflate(const Point& point)
+  {
+  }
+
+  BOOL Intersect(Rect& c, const Rect& a, const Rect& b)
+  {
+    return FALSE;
+  }
+
+  BOOL Intersect(const Rect& rect)
+  {
+    return FALSE;
+  }
+
+  BOOL IntersectsWith(const Rect& rect) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsEmptyArea(VOID) const
+  {
+    return FALSE;
+  }
+
+  VOID Offset(INT dx, INT dy)
+  {
+  }
+
+  VOID Offset(const Point& point)
+  {
+  }
+
+  BOOL Union(Rect& c, const Rect& a, const Rect& b)
+  {
+    return FALSE;
+  }
+public:
+  INT X;
+  INT Y;
+  INT Width;
+  INT Height;
+};
+
+
+class RectF
+{
+public:
+  RectF(const PointF &location, const SizeF &size)
+  {
+  }
+
+  RectF(VOID)
+  {
+  }
+
+  RectF(REAL x, REAL y, REAL width, REAL height)
+  {
+  }
+
+  RectF *Clone(VOID) const
+  {
+    return NULL;
+  }
+
+  BOOL Contains(const RectF& rect)
+  {
+    return FALSE;
+  }
+
+  BOOL Contains(const PointF& pt) const
+  {
+    return FALSE;
+  }
+
+  BOOL Contains(REAL x, REAL y)
+  {
+    return FALSE;
+  }
+
+  BOOL Equals(const RectF& rect) const
+  {
+    return FALSE;
+  }
+
+  REAL GetBottom(VOID) const
+  {
+    return 0;
+  }
+
+  VOID GetBounds(RectF* rect) const
+  {
+  }
+
+  REAL GetLeft(VOID) const
+  {
+    return 0;
+  }
+
+  VOID GetLocation(PointF* point) const
+  {
+  }
+
+  REAL GetRight(VOID) const
+  {
+    return 0;
+  }
+
+  VOID GetSize(SizeF* size) const
+  {
+  }
+
+  REAL GetTop(VOID) const
+  {
+    return 0;
+  }
+
+  VOID Inflate(const PointF& point)
+  {
+  }
+
+  VOID Inflate(REAL dx, REAL dy)
+  {
+  }
+
+  BOOL Intersect(Rect& c, const Rect& a, const Rect& b)
+  {
+    return FALSE;
+  }
+
+  BOOL Intersect(const Rect& rect)
+  {
+    return FALSE;
+  }
+
+  BOOL IntersectsWith(const RectF& rect) const
+  {
+    return FALSE;
+  }
+
+  BOOL IsEmptyArea(VOID) const
+  {
+    return FALSE;
+  }
+
+  VOID Offset(INT dx, INT dy)
+  {
+  }
+
+  VOID Offset(const Point& point)
+  {
+  }
+
+  BOOL Union(RectF& c, const RectF& a, const RectF& b)
+  {
+    return FALSE;
+  }
+
+public:
+  REAL X;
+  REAL Y;
+  REAL Width;
+  REAL Height;
+};
+
+#endif /* _GDIPLUSTYPES_H */