Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-06-14 15:08:30 +00:00
Code Issues Projects Releases Packages Wiki Activity

[SDK][INCLUDE] Formatting gdiplus headers (#2190)

Browse source 
Just code formatting. CORE-16585
$ clang-format -style=file -i sdk/include/psdk/gdiplus[a-z]*
This commit is contained in:
Katayama Hirofumi MZ 2019-12-29 23:21:05 +09:00 • committed by GitHub
parent 8faf38ed22
commit e7814f19fb
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
23 changed files with 6651 additions and 5056 deletions
Download patch file Download diff file Expand all files Collapse all files

41
sdk/include/psdk/gdiplusbase.h
View file

@ -19,27 +19,32 @@
#ifndef _GDIPLUSBASE_H #ifndef _GDIPLUSBASE_H
#define _GDIPLUSBASE_H #define _GDIPLUSBASE_H
class GdiplusBase { class GdiplusBase
public: {
void operator delete(void *in_pVoid) public:
{ void
DllExports::GdipFree(in_pVoid); operator delete(void *in_pVoid)
} {
DllExports::GdipFree(in_pVoid);
}
void operator delete[](void *in_pVoid) void
{ operator delete[](void *in_pVoid)
DllExports::GdipFree(in_pVoid); {
} DllExports::GdipFree(in_pVoid);
}
void *operator new(size_t in_size) void *
{ operator new(size_t in_size)
return DllExports::GdipAlloc(in_size); {
} return DllExports::GdipAlloc(in_size);
}
void *operator new[](size_t in_size) void *
{ operator new[](size_t in_size)
return DllExports::GdipAlloc(in_size); {
} return DllExports::GdipAlloc(in_size);
}
}; };
#endif /* _GDIPLUSBASE_H */ #endif /* _GDIPLUSBASE_H */

490
sdk/include/psdk/gdiplusbrush.h
View file

@ -23,308 +23,334 @@ class Image;
class Brush : public GdiplusBase class Brush : public GdiplusBase
{ {
public: public:
friend class Graphics; friend class Graphics;
friend class Pen; friend class Pen;
Brush *Clone(VOID) const Brush *Clone(VOID) const
{ {
return NULL; return NULL;
} }
Status GetLastStatus(VOID) Status GetLastStatus(VOID)
{ {
return status; return status;
} }
BrushType GetType(VOID) BrushType GetType(VOID)
{ {
BrushType type; BrushType type;
SetStatus(DllExports::GdipGetBrushType(brush, &type)); SetStatus(DllExports::GdipGetBrushType(brush, &type));
return type; return type;
} }
private: private:
mutable Status status; mutable Status status;
GpBrush *brush; GpBrush *brush;
Status SetStatus(Status status) const Status
{ SetStatus(Status status) const
if (status == Ok) {
return status; if (status == Ok)
this->status = status; return status;
return status; this->status = status;
} return status;
}
}; };
class HatchBrush : public Brush class HatchBrush : public Brush
{ {
public: public:
HatchBrush(HatchStyle hatchStyle, const Color &foreColor, const Color &backColor) HatchBrush(HatchStyle hatchStyle, const Color &foreColor, const Color &backColor)
{ {
} }
Status GetBackgroundColor(Color *color) const Status
{ GetBackgroundColor(Color *color) const
return NotImplemented; {
} return NotImplemented;
}
Status GetForegroundColor(Color *color) const Status
{ GetForegroundColor(Color *color) const
return NotImplemented; {
} return NotImplemented;
}
HatchStyle GetHatchStyle(VOID) const HatchStyle GetHatchStyle(VOID) const
{ {
return HatchStyleHorizontal; return HatchStyleHorizontal;
} }
}; };
class LinearGradientBrush : public Brush class LinearGradientBrush : public Brush
{ {
public: public:
LinearGradientBrush(const PointF &point1, const PointF &point2, const Color &color1, const Color &color2) 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, REAL angle, BOOL isAngleScalable)
{ {
} }
LinearGradientBrush(const Rect &rect, const Color &color1, const Color &color2, LinearGradientMode mode) 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 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, REAL angle, BOOL isAngleScalable)
{ {
} }
LinearGradientBrush(const RectF &rect, const Color &color1, const Color &color2, LinearGradientMode mode) LinearGradientBrush(const RectF &rect, const Color &color1, const Color &color2, LinearGradientMode mode)
{ {
} }
Status GetBlend(REAL *blendFactors, REAL *blendPositions, INT count) Status
{ GetBlend(REAL *blendFactors, REAL *blendPositions, INT count)
return NotImplemented; {
} return NotImplemented;
}
INT GetBlendCount(VOID) const INT GetBlendCount(VOID) const
{ {
return 0; return 0;
} }
BOOL GetGammaCorrection(VOID) const BOOL GetGammaCorrection(VOID) const
{ {
return FALSE; return FALSE;
} }
INT GetInterpolationColorCount(VOID) const INT GetInterpolationColorCount(VOID) const
{ {
return 0; return 0;
} }
Status GetInterpolationColors(Color *presetColors, REAL *blendPositions, INT count) const Status
{ GetInterpolationColors(Color *presetColors, REAL *blendPositions, INT count) const
return NotImplemented; {
} return NotImplemented;
}
Status GetLinearColors(Color* colors) const Status
{ GetLinearColors(Color *colors) const
return NotImplemented; {
} return NotImplemented;
}
Status GetRectangle(Rect *rect) const Status
{ GetRectangle(Rect *rect) const
return NotImplemented; {
} return NotImplemented;
}
Status GetRectangle(RectF* rect) const Status
{ GetRectangle(RectF *rect) const
return NotImplemented; {
} return NotImplemented;
}
Status GetTransform(Matrix* matrix) const Status
{ GetTransform(Matrix *matrix) const
return NotImplemented; {
} return NotImplemented;
}
WrapMode GetWrapMode(VOID) const WrapMode GetWrapMode(VOID) const
{ {
return WrapModeTile; return WrapModeTile;
} }
Status MultiplyTransform(const Matrix *matrix, MatrixOrder order) Status
{ MultiplyTransform(const Matrix *matrix, MatrixOrder order)
return NotImplemented; {
} return NotImplemented;
}
Status ResetTransform(VOID) Status ResetTransform(VOID)
{ {
return NotImplemented; return NotImplemented;
} }
Status RotateTransform(REAL angle, MatrixOrder order) Status
{ RotateTransform(REAL angle, MatrixOrder order)
return NotImplemented; {
} return NotImplemented;
}
Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order) Status
{ ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
return NotImplemented; {
} return NotImplemented;
}
Status SetBlend(const REAL *blendFactors, const REAL *blendPositions, INT count) Status
{ SetBlend(const REAL *blendFactors, const REAL *blendPositions, INT count)
return NotImplemented; {
} return NotImplemented;
}
Status SetBlendBellShape(REAL focus, REAL scale) Status
{ SetBlendBellShape(REAL focus, REAL scale)
return NotImplemented; {
} return NotImplemented;
}
Status SetBlendTriangularShape(REAL focus, REAL scale) Status
{ SetBlendTriangularShape(REAL focus, REAL scale)
return NotImplemented; {
} return NotImplemented;
}
Status SetGammaCorrection(BOOL useGammaCorrection) Status
{ SetGammaCorrection(BOOL useGammaCorrection)
return NotImplemented; {
} return NotImplemented;
}
Status SetInterpolationColors(const Color *presetColors, const REAL *blendPositions, INT count) Status
{ SetInterpolationColors(const Color *presetColors, const REAL *blendPositions, INT count)
return NotImplemented; {
} return NotImplemented;
}
Status SetLinearColors(const Color& color1, const Color& color2) Status
{ SetLinearColors(const Color &color1, const Color &color2)
return NotImplemented; {
} return NotImplemented;
}
Status SetTransform(const Matrix* matrix) Status
{ SetTransform(const Matrix *matrix)
return NotImplemented; {
} return NotImplemented;
}
Status SetWrapMode(WrapMode wrapMode) Status
{ SetWrapMode(WrapMode wrapMode)
return NotImplemented; {
} return NotImplemented;
}
Status TranslateTransform(REAL dx, REAL dy, MatrixOrder order) Status
{ TranslateTransform(REAL dx, REAL dy, MatrixOrder order)
return NotImplemented; {
} return NotImplemented;
}
}; };
class SolidBrush : Brush class SolidBrush : Brush
{ {
public: public:
SolidBrush(const Color &color) SolidBrush(const Color &color)
{ {
} }
Status GetColor(Color *color) const Status
{ GetColor(Color *color) const
return NotImplemented; {
} return NotImplemented;
}
Status SetColor(const Color &color) Status
{ SetColor(const Color &color)
return NotImplemented; {
} return NotImplemented;
}
}; };
class TextureBrush : Brush class TextureBrush : Brush
{ {
public: public:
TextureBrush(Image *image, WrapMode wrapMode, const RectF &dstRect) TextureBrush(Image *image, WrapMode wrapMode, const RectF &dstRect)
{ {
} }
TextureBrush(Image *image, Rect &dstRect, ImageAttributes *imageAttributes) 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, INT dstX, INT dstY, INT dstWidth, INT dstHeight)
{ {
} }
TextureBrush(Image *image, WrapMode wrapMode, REAL dstX, REAL dstY, REAL dstWidth, REAL dstHeight) TextureBrush(Image *image, WrapMode wrapMode, REAL dstX, REAL dstY, REAL dstWidth, REAL dstHeight)
{ {
} }
TextureBrush(Image *image, RectF &dstRect, ImageAttributes *imageAttributes) TextureBrush(Image *image, RectF &dstRect, ImageAttributes *imageAttributes)
{ {
} }
TextureBrush(Image *image, WrapMode wrapMode) TextureBrush(Image *image, WrapMode wrapMode)
{ {
} }
TextureBrush(Image *image, WrapMode wrapMode, const Rect &dstRect) TextureBrush(Image *image, WrapMode wrapMode, const Rect &dstRect)
{ {
} }
Image *GetImage(VOID) const Image *GetImage(VOID) const
{ {
return NULL; return NULL;
} }
Status GetTransform(Matrix *matrix) const Status
{ GetTransform(Matrix *matrix) const
return NotImplemented; {
} return NotImplemented;
}
WrapMode GetWrapMode(VOID) const WrapMode GetWrapMode(VOID) const
{ {
return WrapModeTile; return WrapModeTile;
} }
Status MultiplyTransform(Matrix *matrix, MatrixOrder order) Status
{ MultiplyTransform(Matrix *matrix, MatrixOrder order)
return NotImplemented; {
} return NotImplemented;
}
Status ResetTransform(VOID) Status ResetTransform(VOID)
{ {
return NotImplemented; return NotImplemented;
} }
Status RotateTransform(REAL angle, MatrixOrder order) Status
{ RotateTransform(REAL angle, MatrixOrder order)
return NotImplemented; {
} return NotImplemented;
}
Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order) Status
{ ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
return NotImplemented; {
} return NotImplemented;
}
Status SetTransform(const Matrix *matrix) Status
{ SetTransform(const Matrix *matrix)
return NotImplemented; {
} return NotImplemented;
}
Status SetWrapMode(WrapMode wrapMode) Status
{ SetWrapMode(WrapMode wrapMode)
return NotImplemented; {
} return NotImplemented;
}
Status TranslateTransform(REAL dx, REAL dy, MatrixOrder order) Status
{ TranslateTransform(REAL dx, REAL dy, MatrixOrder order)
return NotImplemented; {
} return NotImplemented;
}
}; };
#endif /* _GDIPLUSBRUSH_H */ #endif /* _GDIPLUSBRUSH_H */

17
sdk/include/psdk/gdipluscolor.h
View file

@ -33,7 +33,7 @@ enum ColorChannelFlags
class Color class Color
{ {
public: public:
Color(VOID) Color(VOID)
{ {
Argb = 0xff000000; Argb = 0xff000000;
@ -99,17 +99,20 @@ public:
return Argb; return Argb;
} }
static ARGB MakeARGB(BYTE a, BYTE r, BYTE g, BYTE b) static ARGB
MakeARGB(BYTE a, BYTE r, BYTE g, BYTE b)
{ {
return a << 24 | r << 16 | g << 8 | b; return a << 24 | r << 16 | g << 8 | b;
} }
VOID SetFromCOLORREF(COLORREF rgb) VOID
SetFromCOLORREF(COLORREF rgb)
{ {
Argb = 0xff000000 | (rgb & 0x000000ff) << 16 | (rgb & 0x0000ff00) | (rgb & 0x00ff0000) >> 16; Argb = 0xff000000 | (rgb & 0x000000ff) << 16 | (rgb & 0x0000ff00) | (rgb & 0x00ff0000) >> 16;
} }
VOID SetValue(ARGB argb) VOID
SetValue(ARGB argb)
{ {
Argb = argb; Argb = argb;
} }
@ -119,7 +122,7 @@ public:
return (Argb & 0x000000ff) << 16 | (Argb & 0x0000ff00) | (Argb & 0x00ff0000) >> 16; return (Argb & 0x000000ff) << 16 | (Argb & 0x0000ff00) | (Argb & 0x00ff0000) >> 16;
} }
protected: protected:
ARGB Argb; ARGB Argb;
}; };
@ -132,6 +135,6 @@ typedef struct Color
typedef enum ColorChannelFlags ColorChannelFlags; typedef enum ColorChannelFlags ColorChannelFlags;
#endif /* end of c typedefs */ #endif /* end of c typedefs */
#endif /* _GDIPLUSCOLOR_H */ #endif /* _GDIPLUSCOLOR_H */

10
sdk/include/psdk/gdipluscolormatrix.h
View file

@ -26,9 +26,9 @@ struct ColorMatrix
enum ColorMatrixFlags enum ColorMatrixFlags
{ {
ColorMatrixFlagsDefault = 0, ColorMatrixFlagsDefault = 0,
ColorMatrixFlagsSkipGrays = 1, ColorMatrixFlagsSkipGrays = 1,
ColorMatrixFlagsAltGray = 2 ColorMatrixFlagsAltGray = 2
}; };
enum ColorAdjustType enum ColorAdjustType
@ -68,6 +68,6 @@ typedef enum HistogramFormat HistogramFormat;
typedef struct ColorMatrix ColorMatrix; typedef struct ColorMatrix ColorMatrix;
typedef struct ColorMap ColorMap; typedef struct ColorMap ColorMap;
#endif /* end of c typedefs */ #endif /* end of c typedefs */
#endif /* _GDIPLUSCOLORMATRIX_H */ #endif /* _GDIPLUSCOLORMATRIX_H */

381
sdk/include/psdk/gdipluseffects.h
View file

@ -19,270 +19,291 @@
#ifndef _GDIPLUSEFFECTS_H #ifndef _GDIPLUSEFFECTS_H
#define _GDIPLUSEFFECTS_H #define _GDIPLUSEFFECTS_H
typedef struct { typedef struct
float radius; {
BOOL expandEdge; float radius;
BOOL expandEdge;
} BlurParams; } BlurParams;
typedef struct { typedef struct
INT brightnessLevel; {
INT contrastLevel; INT brightnessLevel;
INT contrastLevel;
} BrightnessContrastParams; } BrightnessContrastParams;
typedef struct { typedef struct
INT cyanRed; {
INT magentaGreen; INT cyanRed;
INT yellowBlue; INT magentaGreen;
INT yellowBlue;
} ColorBalanceParams; } ColorBalanceParams;
typedef struct { typedef struct
CurveAdjustments adjustment; {
CurveChannel channel; CurveAdjustments adjustment;
INT adjustValue; CurveChannel channel;
INT adjustValue;
} ColorCurveParams; } ColorCurveParams;
typedef struct { typedef struct
INT hueLevel; {
INT saturationLevel; INT hueLevel;
INT lightnessLevel; INT saturationLevel;
INT lightnessLevel;
} HueSaturationLightnessParams; } HueSaturationLightnessParams;
typedef struct { typedef struct
INT highlight; {
INT midtone; INT highlight;
INT shadow; INT midtone;
INT shadow;
} LevelsParams; } LevelsParams;
typedef struct { typedef struct
UINT numberOfAreas; {
RECT *areas; UINT numberOfAreas;
RECT *areas;
} RedEyeCorrectionParams; } RedEyeCorrectionParams;
typedef struct { typedef struct
REAL radius; {
REAL amount; REAL radius;
REAL amount;
} SharpenParams; } SharpenParams;
typedef struct { typedef struct
INT hue; {
INT amount; INT hue;
INT amount;
} TintParams; } TintParams;
class Effect class Effect
{ {
public: public:
Effect(VOID) Effect(VOID)
{ {
} }
VOID *GetAuxData(VOID) const VOID *GetAuxData(VOID) const
{ {
return NULL; return NULL;
} }
INT GetAuxDataSize(VOID) INT GetAuxDataSize(VOID)
{ {
return 0; return 0;
} }
Status GetParameterSize(UINT *size) Status
{ GetParameterSize(UINT *size)
return NotImplemented; {
} return NotImplemented;
}
VOID UseAuxData(const BOOL useAuxDataFlag) VOID
{ UseAuxData(const BOOL useAuxDataFlag)
} {
}
}; };
class Blur : public Effect class Blur : public Effect
{ {
public: public:
Blur(VOID) Blur(VOID)
{ {
} }
Status GetParameters(UINT *size, BlurParams *parameters) Status
{ GetParameters(UINT *size, BlurParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
Status SetParameters(const BlurParams *parameters) Status
{ SetParameters(const BlurParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
}; };
class BrightnessContrast : public Effect class BrightnessContrast : public Effect
{ {
public: public:
BrightnessContrast(VOID) BrightnessContrast(VOID)
{ {
} }
Status GetParameters(UINT *size, BrightnessContrastParams *parameters) Status
{ GetParameters(UINT *size, BrightnessContrastParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
Status SetParameters(const BrightnessContrastParams *parameters) Status
{ SetParameters(const BrightnessContrastParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
}; };
class ColorBalance : public Effect class ColorBalance : public Effect
{ {
public: public:
ColorBalance(VOID) ColorBalance(VOID)
{ {
} }
Status GetParameters(UINT *size, ColorBalanceParams *parameters) Status
{ GetParameters(UINT *size, ColorBalanceParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
Status SetParameters(ColorBalanceParams *parameters) Status
{ SetParameters(ColorBalanceParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
}; };
class ColorCurve : public Effect class ColorCurve : public Effect
{ {
public: public:
ColorCurve(VOID) ColorCurve(VOID)
{ {
} }
Status GetParameters(UINT *size, ColorCurveParams *parameters) Status
{ GetParameters(UINT *size, ColorCurveParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
Status SetParameters(const ColorCurveParams *parameters) Status
{ SetParameters(const ColorCurveParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
}; };
class ColorMatrixEffect : public Effect class ColorMatrixEffect : public Effect
{ {
public: public:
ColorMatrixEffect(VOID) ColorMatrixEffect(VOID)
{ {
} }
Status GetParameters(UINT *size, ColorMatrix *matrix) Status
{ GetParameters(UINT *size, ColorMatrix *matrix)
return NotImplemented; {
} return NotImplemented;
}
Status SetParameters(const ColorMatrix *matrix) Status
{ SetParameters(const ColorMatrix *matrix)
return NotImplemented; {
} return NotImplemented;
}
}; };
class HueSaturationLightness : public Effect class HueSaturationLightness : public Effect
{ {
public: public:
HueSaturationLightness(VOID) HueSaturationLightness(VOID)
{ {
} }
Status GetParameters(UINT *size, HueSaturationLightnessParams *parameters) Status
{ GetParameters(UINT *size, HueSaturationLightnessParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
Status SetParameters(const HueSaturationLightnessParams *parameters) Status
{ SetParameters(const HueSaturationLightnessParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
}; };
class Levels : public Effect class Levels : public Effect
{ {
public: public:
Levels(VOID) Levels(VOID)
{ {
} }
Status GetParameters(UINT *size, LevelsParams *parameters) Status
{ GetParameters(UINT *size, LevelsParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
Status SetParameters(const LevelsParams *parameters) Status
{ SetParameters(const LevelsParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
}; };
class RedEyeCorrection : public Effect class RedEyeCorrection : public Effect
{ {
public: public:
RedEyeCorrection(VOID) RedEyeCorrection(VOID)
{ {
} }
Status GetParameters(UINT *size, RedEyeCorrectionParams *parameters) Status
{ GetParameters(UINT *size, RedEyeCorrectionParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
Status SetParameters(const RedEyeCorrectionParams *parameters) Status
{ SetParameters(const RedEyeCorrectionParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
}; };
class Sharpen class Sharpen
{ {
public: public:
Sharpen(VOID) Sharpen(VOID)
{ {
} }
Status GetParameters(UINT *size, SharpenParams *parameters) Status
{ GetParameters(UINT *size, SharpenParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
Status SetParameters(const SharpenParams *parameters) Status
{ SetParameters(const SharpenParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
}; };
class Tint : Effect class Tint : Effect
{ {
public: public:
Tint(VOID) Tint(VOID)
{ {
} }
Status GetParameters(UINT *size, TintParams *parameters) Status
{ GetParameters(UINT *size, TintParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
Status SetParameters(const TintParams *parameters) Status
{ SetParameters(const TintParams *parameters)
return NotImplemented; {
} return NotImplemented;
}
}; };
#endif /* _GDIPLUSEFFECTS_H */ #endif /* _GDIPLUSEFFECTS_H */

395
sdk/include/psdk/gdiplusenums.h
View file

@ -24,103 +24,104 @@ typedef UINT GraphicsContainer;
enum Unit enum Unit
{ {
UnitWorld = 0, UnitWorld = 0,
UnitDisplay = 1, UnitDisplay = 1,
UnitPixel = 2, UnitPixel = 2,
UnitPoint = 3, UnitPoint = 3,
UnitInch = 4, UnitInch = 4,
UnitDocument = 5, UnitDocument = 5,
UnitMillimeter = 6 UnitMillimeter = 6
}; };
enum BrushType enum BrushType
{ {
BrushTypeSolidColor = 0, BrushTypeSolidColor = 0,
BrushTypeHatchFill = 1, BrushTypeHatchFill = 1,
BrushTypeTextureFill = 2, BrushTypeTextureFill = 2,
BrushTypePathGradient = 3, BrushTypePathGradient = 3,
BrushTypeLinearGradient = 4 BrushTypeLinearGradient = 4
}; };
enum DriverStringOptions enum DriverStringOptions
{ {
DriverStringOptionsCmapLookup = 1, DriverStringOptionsCmapLookup = 1,
DriverStringOptionsVertical = 2, DriverStringOptionsVertical = 2,
DriverStringOptionsRealizedAdvance = 4, DriverStringOptionsRealizedAdvance = 4,
DriverStringOptionsLimitSubpixel = 8 DriverStringOptionsLimitSubpixel = 8
}; };
enum FillMode enum FillMode
{ {
FillModeAlternate = 0, FillModeAlternate = 0,
FillModeWinding = 1 FillModeWinding = 1
}; };
enum LineCap enum LineCap
{ {
LineCapFlat = 0x00, LineCapFlat = 0x00,
LineCapSquare = 0x01, LineCapSquare = 0x01,
LineCapRound = 0x02, LineCapRound = 0x02,
LineCapTriangle = 0x03, LineCapTriangle = 0x03,
LineCapNoAnchor = 0x10, LineCapNoAnchor = 0x10,
LineCapSquareAnchor = 0x11, LineCapSquareAnchor = 0x11,
LineCapRoundAnchor = 0x12, LineCapRoundAnchor = 0x12,
LineCapDiamondAnchor = 0x13, LineCapDiamondAnchor = 0x13,
LineCapArrowAnchor = 0x14, LineCapArrowAnchor = 0x14,
LineCapCustom = 0xff, LineCapCustom = 0xff,
LineCapAnchorMask = 0xf0 LineCapAnchorMask = 0xf0
}; };
enum CustomLineCapType enum CustomLineCapType
{ {
CustomLineCapTypeDefault = 0, CustomLineCapTypeDefault = 0,
CustomLineCapTypeAdjustableArrow = 1 CustomLineCapTypeAdjustableArrow = 1
}; };
enum PathPointType{ enum PathPointType
PathPointTypeStart = 0, /* start of a figure */ {
PathPointTypeLine = 1, PathPointTypeStart = 0, /* start of a figure */
PathPointTypeBezier = 3, PathPointTypeLine = 1,
PathPointTypePathTypeMask = 7, PathPointTypeBezier = 3,
PathPointTypePathDashMode = 16, /* not used */ PathPointTypePathTypeMask = 7,
PathPointTypePathMarker = 32, PathPointTypePathDashMode = 16, /* not used */
PathPointTypeCloseSubpath = 128, /* end of a closed figure */ PathPointTypePathMarker = 32,
PathPointTypeBezier3 = 3 PathPointTypeCloseSubpath = 128, /* end of a closed figure */
PathPointTypeBezier3 = 3
}; };
enum PenType enum PenType
{ {
PenTypeSolidColor = BrushTypeSolidColor, PenTypeSolidColor = BrushTypeSolidColor,
PenTypeHatchFill = BrushTypeHatchFill, PenTypeHatchFill = BrushTypeHatchFill,
PenTypeTextureFill = BrushTypeTextureFill, PenTypeTextureFill = BrushTypeTextureFill,
PenTypePathGradient = BrushTypePathGradient, PenTypePathGradient = BrushTypePathGradient,
PenTypeLinearGradient = BrushTypeLinearGradient, PenTypeLinearGradient = BrushTypeLinearGradient,
PenTypeUnknown = -1 PenTypeUnknown = -1
}; };
enum LineJoin enum LineJoin
{ {
LineJoinMiter = 0, LineJoinMiter = 0,
LineJoinBevel = 1, LineJoinBevel = 1,
LineJoinRound = 2, LineJoinRound = 2,
LineJoinMiterClipped = 3 LineJoinMiterClipped = 3
}; };
enum QualityMode enum QualityMode
{ {
QualityModeInvalid = -1, QualityModeInvalid = -1,
QualityModeDefault = 0, QualityModeDefault = 0,
QualityModeLow = 1, QualityModeLow = 1,
QualityModeHigh = 2 QualityModeHigh = 2
}; };
enum SmoothingMode enum SmoothingMode
{ {
SmoothingModeInvalid = QualityModeInvalid, SmoothingModeInvalid = QualityModeInvalid,
SmoothingModeDefault = QualityModeDefault, SmoothingModeDefault = QualityModeDefault,
SmoothingModeHighSpeed = QualityModeLow, SmoothingModeHighSpeed = QualityModeLow,
SmoothingModeHighQuality = QualityModeHigh, SmoothingModeHighQuality = QualityModeHigh,
SmoothingModeNone, SmoothingModeNone,
SmoothingModeAntiAlias SmoothingModeAntiAlias
@ -128,20 +129,20 @@ enum SmoothingMode
enum CompositingQuality enum CompositingQuality
{ {
CompositingQualityInvalid = QualityModeInvalid, CompositingQualityInvalid = QualityModeInvalid,
CompositingQualityDefault = QualityModeDefault, CompositingQualityDefault = QualityModeDefault,
CompositingQualityHighSpeed = QualityModeLow, CompositingQualityHighSpeed = QualityModeLow,
CompositingQualityHighQuality = QualityModeHigh, CompositingQualityHighQuality = QualityModeHigh,
CompositingQualityGammaCorrected, CompositingQualityGammaCorrected,
CompositingQualityAssumeLinear CompositingQualityAssumeLinear
}; };
enum InterpolationMode enum InterpolationMode
{ {
InterpolationModeInvalid = QualityModeInvalid, InterpolationModeInvalid = QualityModeInvalid,
InterpolationModeDefault = QualityModeDefault, InterpolationModeDefault = QualityModeDefault,
InterpolationModeLowQuality = QualityModeLow, InterpolationModeLowQuality = QualityModeLow,
InterpolationModeHighQuality = QualityModeHigh, InterpolationModeHighQuality = QualityModeHigh,
InterpolationModeBilinear, InterpolationModeBilinear,
InterpolationModeBicubic, InterpolationModeBicubic,
InterpolationModeNearestNeighbor, InterpolationModeNearestNeighbor,
@ -151,15 +152,15 @@ enum InterpolationMode
enum PenAlignment enum PenAlignment
{ {
PenAlignmentCenter = 0, PenAlignmentCenter = 0,
PenAlignmentInset = 1 PenAlignmentInset = 1
}; };
enum PixelOffsetMode enum PixelOffsetMode
{ {
PixelOffsetModeInvalid = QualityModeInvalid, PixelOffsetModeInvalid = QualityModeInvalid,
PixelOffsetModeDefault = QualityModeDefault, PixelOffsetModeDefault = QualityModeDefault,
PixelOffsetModeHighSpeed = QualityModeLow, PixelOffsetModeHighSpeed = QualityModeLow,
PixelOffsetModeHighQuality = QualityModeHigh, PixelOffsetModeHighQuality = QualityModeHigh,
PixelOffsetModeNone, PixelOffsetModeNone,
PixelOffsetModeHalf PixelOffsetModeHalf
@ -167,8 +168,8 @@ enum PixelOffsetMode
enum DashCap enum DashCap
{ {
DashCapFlat = 0, DashCapFlat = 0,
DashCapRound = 2, DashCapRound = 2,
DashCapTriangle = 3 DashCapTriangle = 3
}; };
@ -185,7 +186,7 @@ enum DashStyle
enum MatrixOrder enum MatrixOrder
{ {
MatrixOrderPrepend = 0, MatrixOrderPrepend = 0,
MatrixOrderAppend = 1 MatrixOrderAppend = 1
}; };
enum ImageType enum ImageType
@ -195,7 +196,8 @@ enum ImageType
ImageTypeMetafile ImageTypeMetafile
}; };
enum WarpMode { enum WarpMode
{
WarpModePerspective, WarpModePerspective,
WarpModeBilinear WarpModeBilinear
}; };
@ -229,17 +231,17 @@ enum LinearGradientMode
enum EmfType enum EmfType
{ {
EmfTypeEmfOnly = MetafileTypeEmf, EmfTypeEmfOnly = MetafileTypeEmf,
EmfTypeEmfPlusOnly = MetafileTypeEmfPlusOnly, EmfTypeEmfPlusOnly = MetafileTypeEmfPlusOnly,
EmfTypeEmfPlusDual = MetafileTypeEmfPlusDual EmfTypeEmfPlusDual = MetafileTypeEmfPlusDual
}; };
enum EmfToWmfBitsFlags enum EmfToWmfBitsFlags
{ {
EmfToWmfBitsFlagsDefault = 0, EmfToWmfBitsFlagsDefault = 0,
EmfToWmfBitsFlagsEmbedEmf = 1, EmfToWmfBitsFlagsEmbedEmf = 1,
EmfToWmfBitsFlagsIncludePlaceable = 2, EmfToWmfBitsFlagsIncludePlaceable = 2,
EmfToWmfBitsFlagsNoXORClip = 4 EmfToWmfBitsFlagsNoXORClip = 4
}; };
enum CompositingMode enum CompositingMode
@ -260,88 +262,88 @@ enum TextRenderingHint
enum StringAlignment enum StringAlignment
{ {
StringAlignmentNear = 0, StringAlignmentNear = 0,
StringAlignmentCenter = 1, StringAlignmentCenter = 1,
StringAlignmentFar = 2 StringAlignmentFar = 2
}; };
enum StringDigitSubstitute enum StringDigitSubstitute
{ {
StringDigitSubstituteUser = 0, StringDigitSubstituteUser = 0,
StringDigitSubstituteNone = 1, StringDigitSubstituteNone = 1,
StringDigitSubstituteNational = 2, StringDigitSubstituteNational = 2,
StringDigitSubstituteTraditional = 3 StringDigitSubstituteTraditional = 3
}; };
enum StringFormatFlags enum StringFormatFlags
{ {
StringFormatFlagsDirectionRightToLeft = 0x00000001, StringFormatFlagsDirectionRightToLeft = 0x00000001,
StringFormatFlagsDirectionVertical = 0x00000002, StringFormatFlagsDirectionVertical = 0x00000002,
StringFormatFlagsNoFitBlackBox = 0x00000004, StringFormatFlagsNoFitBlackBox = 0x00000004,
StringFormatFlagsDisplayFormatControl = 0x00000020, StringFormatFlagsDisplayFormatControl = 0x00000020,
StringFormatFlagsNoFontFallback = 0x00000400, StringFormatFlagsNoFontFallback = 0x00000400,
StringFormatFlagsMeasureTrailingSpaces = 0x00000800, StringFormatFlagsMeasureTrailingSpaces = 0x00000800,
StringFormatFlagsNoWrap = 0x00001000, StringFormatFlagsNoWrap = 0x00001000,
StringFormatFlagsLineLimit = 0x00002000, StringFormatFlagsLineLimit = 0x00002000,
StringFormatFlagsNoClip = 0x00004000 StringFormatFlagsNoClip = 0x00004000
}; };
enum StringTrimming enum StringTrimming
{ {
StringTrimmingNone = 0, StringTrimmingNone = 0,
StringTrimmingCharacter = 1, StringTrimmingCharacter = 1,
StringTrimmingWord = 2, StringTrimmingWord = 2,
StringTrimmingEllipsisCharacter = 3, StringTrimmingEllipsisCharacter = 3,
StringTrimmingEllipsisWord = 4, StringTrimmingEllipsisWord = 4,
StringTrimmingEllipsisPath = 5 StringTrimmingEllipsisPath = 5
}; };
enum FontStyle enum FontStyle
{ {
FontStyleRegular = 0, FontStyleRegular = 0,
FontStyleBold = 1, FontStyleBold = 1,
FontStyleItalic = 2, FontStyleItalic = 2,
FontStyleBoldItalic = 3, FontStyleBoldItalic = 3,
FontStyleUnderline = 4, FontStyleUnderline = 4,
FontStyleStrikeout = 8 FontStyleStrikeout = 8
}; };
enum HotkeyPrefix enum HotkeyPrefix
{ {
HotkeyPrefixNone = 0, HotkeyPrefixNone = 0,
HotkeyPrefixShow = 1, HotkeyPrefixShow = 1,
HotkeyPrefixHide = 2 HotkeyPrefixHide = 2
}; };
enum ImageCodecFlags enum ImageCodecFlags
{ {
ImageCodecFlagsEncoder = 1, ImageCodecFlagsEncoder = 1,
ImageCodecFlagsDecoder = 2, ImageCodecFlagsDecoder = 2,
ImageCodecFlagsSupportBitmap = 4, ImageCodecFlagsSupportBitmap = 4,
ImageCodecFlagsSupportVector = 8, ImageCodecFlagsSupportVector = 8,
ImageCodecFlagsSeekableEncode = 16, ImageCodecFlagsSeekableEncode = 16,
ImageCodecFlagsBlockingDecode = 32, ImageCodecFlagsBlockingDecode = 32,
ImageCodecFlagsBuiltin = 65536, ImageCodecFlagsBuiltin = 65536,
ImageCodecFlagsSystem = 131072, ImageCodecFlagsSystem = 131072,
ImageCodecFlagsUser = 262144 ImageCodecFlagsUser = 262144
}; };
enum ImageFlags enum ImageFlags
{ {
ImageFlagsNone = 0, ImageFlagsNone = 0,
ImageFlagsScalable = 0x0001, ImageFlagsScalable = 0x0001,
ImageFlagsHasAlpha = 0x0002, ImageFlagsHasAlpha = 0x0002,
ImageFlagsHasTranslucent = 0x0004, ImageFlagsHasTranslucent = 0x0004,
ImageFlagsPartiallyScalable = 0x0008, ImageFlagsPartiallyScalable = 0x0008,
ImageFlagsColorSpaceRGB = 0x0010, ImageFlagsColorSpaceRGB = 0x0010,
ImageFlagsColorSpaceCMYK = 0x0020, ImageFlagsColorSpaceCMYK = 0x0020,
ImageFlagsColorSpaceGRAY = 0x0040, ImageFlagsColorSpaceGRAY = 0x0040,
ImageFlagsColorSpaceYCBCR = 0x0080, ImageFlagsColorSpaceYCBCR = 0x0080,
ImageFlagsColorSpaceYCCK = 0x0100, ImageFlagsColorSpaceYCCK = 0x0100,
ImageFlagsHasRealDPI = 0x1000, ImageFlagsHasRealDPI = 0x1000,
ImageFlagsHasRealPixelSize = 0x2000, ImageFlagsHasRealPixelSize = 0x2000,
ImageFlagsReadOnly = 0x00010000, ImageFlagsReadOnly = 0x00010000,
ImageFlagsCaching = 0x00020000 ImageFlagsCaching = 0x00020000
}; };
enum CombineMode enum CombineMode
@ -357,7 +359,7 @@ enum CombineMode
enum FlushIntention enum FlushIntention
{ {
FlushIntentionFlush = 0, FlushIntentionFlush = 0,
FlushIntentionSync = 1 FlushIntentionSync = 1
}; };
enum CoordinateSpace enum CoordinateSpace
@ -369,87 +371,88 @@ enum CoordinateSpace
enum GpTestControlEnum enum GpTestControlEnum
{ {
TestControlForceBilinear = 0, TestControlForceBilinear = 0,
TestControlNoICM = 1, TestControlNoICM = 1,
TestControlGetBuildNumber = 2 TestControlGetBuildNumber = 2
}; };
enum MetafileFrameUnit enum MetafileFrameUnit
{ {
MetafileFrameUnitPixel = UnitPixel, MetafileFrameUnitPixel = UnitPixel,
MetafileFrameUnitPoint = UnitPoint, MetafileFrameUnitPoint = UnitPoint,
MetafileFrameUnitInch = UnitInch, MetafileFrameUnitInch = UnitInch,
MetafileFrameUnitDocument = UnitDocument, MetafileFrameUnitDocument = UnitDocument,
MetafileFrameUnitMillimeter = UnitMillimeter, MetafileFrameUnitMillimeter = UnitMillimeter,
MetafileFrameUnitGdi MetafileFrameUnitGdi
}; };
enum HatchStyle enum HatchStyle
{ {
HatchStyleHorizontal = 0, HatchStyleHorizontal = 0,
HatchStyleVertical = 1, HatchStyleVertical = 1,
HatchStyleForwardDiagonal = 2, HatchStyleForwardDiagonal = 2,
HatchStyleBackwardDiagonal = 3, HatchStyleBackwardDiagonal = 3,
HatchStyleCross = 4, HatchStyleCross = 4,
HatchStyleDiagonalCross = 5, HatchStyleDiagonalCross = 5,
HatchStyle05Percent = 6, HatchStyle05Percent = 6,
HatchStyle10Percent = 7, HatchStyle10Percent = 7,
HatchStyle20Percent = 8, HatchStyle20Percent = 8,
HatchStyle25Percent = 9, HatchStyle25Percent = 9,
HatchStyle30Percent = 10, HatchStyle30Percent = 10,
HatchStyle40Percent = 11, HatchStyle40Percent = 11,
HatchStyle50Percent = 12, HatchStyle50Percent = 12,
HatchStyle60Percent = 13, HatchStyle60Percent = 13,
HatchStyle70Percent = 14, HatchStyle70Percent = 14,
HatchStyle75Percent = 15, HatchStyle75Percent = 15,
HatchStyle80Percent = 16, HatchStyle80Percent = 16,
HatchStyle90Percent = 17, HatchStyle90Percent = 17,
HatchStyleLightDownwardDiagonal = 18, HatchStyleLightDownwardDiagonal = 18,
HatchStyleLightUpwardDiagonal = 19, HatchStyleLightUpwardDiagonal = 19,
HatchStyleDarkDownwardDiagonal = 20, HatchStyleDarkDownwardDiagonal = 20,
HatchStyleDarkUpwardDiagonal = 21, HatchStyleDarkUpwardDiagonal = 21,
HatchStyleWideDownwardDiagonal = 22, HatchStyleWideDownwardDiagonal = 22,
HatchStyleWideUpwardDiagonal = 23, HatchStyleWideUpwardDiagonal = 23,
HatchStyleLightVertical = 24, HatchStyleLightVertical = 24,
HatchStyleLightHorizontal = 25, HatchStyleLightHorizontal = 25,
HatchStyleNarrowVertical = 26, HatchStyleNarrowVertical = 26,
HatchStyleNarrowHorizontal = 27, HatchStyleNarrowHorizontal = 27,
HatchStyleDarkVertical = 28, HatchStyleDarkVertical = 28,
HatchStyleDarkHorizontal = 29, HatchStyleDarkHorizontal = 29,
HatchStyleDashedDownwardDiagonal = 30, HatchStyleDashedDownwardDiagonal = 30,
HatchStyleDashedUpwardDiagonal = 31, HatchStyleDashedUpwardDiagonal = 31,
HatchStyleDashedHorizontal = 32, HatchStyleDashedHorizontal = 32,
HatchStyleDashedVertical = 33, HatchStyleDashedVertical = 33,
HatchStyleSmallConfetti = 34, HatchStyleSmallConfetti = 34,
HatchStyleLargeConfetti = 35, HatchStyleLargeConfetti = 35,
HatchStyleZigZag = 36, HatchStyleZigZag = 36,
HatchStyleWave = 37, HatchStyleWave = 37,
HatchStyleDiagonalBrick = 38, HatchStyleDiagonalBrick = 38,
HatchStyleHorizontalBrick = 39, HatchStyleHorizontalBrick = 39,
HatchStyleWeave = 40, HatchStyleWeave = 40,
HatchStylePlaid = 41, HatchStylePlaid = 41,
HatchStyleDivot = 42, HatchStyleDivot = 42,
HatchStyleDottedGrid = 43, HatchStyleDottedGrid = 43,
HatchStyleDottedDiamond = 44, HatchStyleDottedDiamond = 44,
HatchStyleShingle = 45, HatchStyleShingle = 45,
HatchStyleTrellis = 46, HatchStyleTrellis = 46,
HatchStyleSphere = 47, HatchStyleSphere = 47,
HatchStyleSmallGrid = 48, HatchStyleSmallGrid = 48,
HatchStyleSmallCheckerBoard = 49, HatchStyleSmallCheckerBoard = 49,
HatchStyleLargeCheckerBoard = 50, HatchStyleLargeCheckerBoard = 50,
HatchStyleOutlinedDiamond = 51, HatchStyleOutlinedDiamond = 51,
HatchStyleSolidDiamond = 52, HatchStyleSolidDiamond = 52,
HatchStyleTotal = 53, HatchStyleTotal = 53,
HatchStyleLargeGrid = HatchStyleCross, HatchStyleLargeGrid = HatchStyleCross,
HatchStyleMin = HatchStyleHorizontal, HatchStyleMin = HatchStyleHorizontal,
HatchStyleMax = HatchStyleTotal - 1 HatchStyleMax = HatchStyleTotal - 1
}; };
#define GDIP_EMFPLUS_RECORD_BASE 0x00004000 #define GDIP_EMFPLUS_RECORD_BASE 0x00004000
#define GDIP_WMF_RECORD_BASE 0x00010000 #define GDIP_WMF_RECORD_BASE 0x00010000
#define GDIP_WMF_RECORD_TO_EMFPLUS(x) ((x)|GDIP_WMF_RECORD_BASE) #define GDIP_WMF_RECORD_TO_EMFPLUS(x) ((x) | GDIP_WMF_RECORD_BASE)
enum EmfPlusRecordType { enum EmfPlusRecordType
{
WmfRecordTypeSetBkColor = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETBKCOLOR), WmfRecordTypeSetBkColor = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETBKCOLOR),
WmfRecordTypeSetBkMode = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETBKMODE), WmfRecordTypeSetBkMode = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETBKMODE),
WmfRecordTypeSetMapMode = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETMAPMODE), WmfRecordTypeSetMapMode = GDIP_WMF_RECORD_TO_EMFPLUS(META_SETMAPMODE),
@ -713,7 +716,7 @@ enum EmfPlusRecordType {
EmfPlusRecordTypeSetTSGraphics, EmfPlusRecordTypeSetTSGraphics,
EmfPlusRecordTypeSetTSClip, EmfPlusRecordTypeSetTSClip,
EmfPlusRecordTotal, EmfPlusRecordTotal,
EmfPlusRecordTypeMax = EmfPlusRecordTotal-1, EmfPlusRecordTypeMax = EmfPlusRecordTotal - 1,
EmfPlusRecordTypeMin = EmfPlusRecordTypeHeader EmfPlusRecordTypeMin = EmfPlusRecordTypeHeader
}; };
@ -767,6 +770,6 @@ typedef enum EmfPlusRecordType EmfPlusRecordType;
#endif /* end of c typedefs */ #endif /* end of c typedefs */
#undef GDIP_WMF_RECORD_TO_EMFPLUS #undef GDIP_WMF_RECORD_TO_EMFPLUS
#define GDIP_WMF_RECORD_TO_EMFPLUS(x) ((EmfPlusRecordType)((x)|GDIP_WMF_RECORD_BASE)) #define GDIP_WMF_RECORD_TO_EMFPLUS(x) ((EmfPlusRecordType)((x) | GDIP_WMF_RECORD_BASE))
#endif #endif

2082
sdk/include/psdk/gdiplusflat.h
View file

File diff suppressed because it is too large Load diff

96
sdk/include/psdk/gdiplusgpstubs.h
View file

@ -21,30 +21,78 @@
#ifdef __cplusplus #ifdef __cplusplus
class GpGraphics {}; class GpGraphics
class GpPen {}; {
class GpBrush {}; };
class GpHatch : public GpBrush {}; class GpPen
class GpSolidFill : public GpBrush {}; {
class GpPath {}; };
class GpMatrix {}; class GpBrush
class GpPathIterator {}; {
class GpCustomLineCap {}; };
class GpAdjustableArrowCap : public GpCustomLineCap {}; class GpHatch : public GpBrush
class GpImage {}; {
class GpMetafile : public GpImage {}; };
class GpImageAttributes {}; class GpSolidFill : public GpBrush
class GpCachedBitmap {}; {
class GpBitmap : public GpImage {}; };
class GpPathGradient : public GpBrush {}; class GpPath
class GpLineGradient : public GpBrush {}; {
class GpTexture : public GpBrush {}; };
class GpFont {}; class GpMatrix
class GpFontCollection {}; {
class GpFontFamily {}; };
class GpStringFormat {}; class GpPathIterator
class GpRegion {}; {
class CGpEffect {}; };
class GpCustomLineCap
{
};
class GpAdjustableArrowCap : public GpCustomLineCap
{
};
class GpImage
{
};
class GpMetafile : public GpImage
{
};
class GpImageAttributes
{
};
class GpCachedBitmap
{
};
class GpBitmap : public GpImage
{
};
class GpPathGradient : public GpBrush
{
};
class GpLineGradient : public GpBrush
{
};
class GpTexture : public GpBrush
{
};
class GpFont
{
};
class GpFontCollection
{
};
class GpFontFamily
{
};
class GpStringFormat
{
};
class GpRegion
{
};
class CGpEffect
{
};
#else /* end of c++ declarations */ #else /* end of c++ declarations */

2382
sdk/include/psdk/gdiplusgraphics.h
View file

File diff suppressed because it is too large Load diff

1857
sdk/include/psdk/gdiplusheaders.h
View file

File diff suppressed because it is too large Load diff

243
sdk/include/psdk/gdiplusimageattributes.h
View file

@ -21,140 +21,167 @@
class ImageAttributes : public GdiplusBase class ImageAttributes : public GdiplusBase
{ {
public: public:
ImageAttributes(VOID) ImageAttributes(VOID)
{ {
} }
Status ClearBrushRemapTable(VOID) Status ClearBrushRemapTable(VOID)
{ {
return NotImplemented; return NotImplemented;
} }
Status ClearColorKey(ColorAdjustType type) Status
{ ClearColorKey(ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status ClearColorMatrices(ColorAdjustType type) Status
{ ClearColorMatrices(ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status ClearColorMatrix(ColorAdjustType type) Status
{ ClearColorMatrix(ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status ClearGamma(ColorAdjustType type) Status
{ ClearGamma(ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status ClearNoOp(ColorAdjustType type) Status
{ ClearNoOp(ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status ClearOutputChannel(ColorAdjustType type) Status
{ ClearOutputChannel(ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status ClearOutputChannelColorProfile(ColorAdjustType type) Status
{ ClearOutputChannelColorProfile(ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status ClearRemapTable(ColorAdjustType type) Status
{ ClearRemapTable(ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status ClearThreshold(ColorAdjustType type) Status
{ ClearThreshold(ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
ImageAttributes *Clone(VOID) ImageAttributes *Clone(VOID)
{ {
return NULL; return NULL;
} }
Status GetAdjustedPalette(ColorPalette *colorPalette, ColorPalette colorAdjustType) Status
{ GetAdjustedPalette(ColorPalette *colorPalette, ColorPalette colorAdjustType)
return NotImplemented; {
} return NotImplemented;
}
Status GetLastStatus(VOID) Status GetLastStatus(VOID)
{ {
return NotImplemented; return NotImplemented;
} }
Status Reset(ColorAdjustType type) Status
{ Reset(ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status SetBrushRemapTable(UINT mapSize, ColorMap *map) Status
{ SetBrushRemapTable(UINT mapSize, ColorMap *map)
return NotImplemented; {
} return NotImplemented;
}
Status SetColorKey(const Color &colorLow, const Color &colorHigh, ColorAdjustType type) Status
{ SetColorKey(const Color &colorLow, const Color &colorHigh, ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status SetColorMatrices(const ColorMatrix *colorMatrix, const ColorMatrix *grayMatrix, ColorMatrixFlags mode, ColorAdjustType type) Status
{ SetColorMatrices(
return NotImplemented; const ColorMatrix *colorMatrix,
} const ColorMatrix *grayMatrix,
ColorMatrixFlags mode,
ColorAdjustType type)
{
return NotImplemented;
}
Status SetColorMatrix(const ColorMatrix *colorMatrix, ColorMatrixFlags mode, ColorAdjustType type) Status
{ SetColorMatrix(const ColorMatrix *colorMatrix, ColorMatrixFlags mode, ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status SetGamma(REAL gamma, ColorAdjustType type) Status
{ SetGamma(REAL gamma, ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status SetNoOp(ColorAdjustType type) Status
{ SetNoOp(ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status SetOutputChannel(ColorChannelFlags channelFlags, ColorAdjustType type) Status
{ SetOutputChannel(ColorChannelFlags channelFlags, ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status SetOutputChannelColorProfile(const WCHAR *colorProfileFilename, ColorAdjustType type) Status
{ SetOutputChannelColorProfile(const WCHAR *colorProfileFilename, ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status SetRemapTable(UINT mapSize, const ColorMap *map, ColorAdjustType type) Status
{ SetRemapTable(UINT mapSize, const ColorMap *map, ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status SetThreshold(REAL threshold, ColorAdjustType type) Status
{ SetThreshold(REAL threshold, ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status SetToIdentity(ColorAdjustType type) Status
{ SetToIdentity(ColorAdjustType type)
return NotImplemented; {
} return NotImplemented;
}
Status SetWrapMode(WrapMode wrap, const Color &color, BOOL clamp) Status
{ SetWrapMode(WrapMode wrap, const Color &color, BOOL clamp)
return NotImplemented; {
} return NotImplemented;
}
}; };
#endif /* _GDIPLUSIMAGEATTRIBUTES_H */ #endif /* _GDIPLUSIMAGEATTRIBUTES_H */

586
sdk/include/psdk/gdiplusimaging.h
View file

@ -21,119 +21,119 @@
DEFINE_GUID(ImageFormatUndefined, 0xb96b3ca9, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e); DEFINE_GUID(ImageFormatUndefined, 0xb96b3ca9, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e);
DEFINE_GUID(ImageFormatMemoryBMP, 0xb96b3caa, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e); DEFINE_GUID(ImageFormatMemoryBMP, 0xb96b3caa, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e);
DEFINE_GUID(ImageFormatBMP, 0xb96b3cab, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e); DEFINE_GUID(ImageFormatBMP, 0xb96b3cab, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e);
DEFINE_GUID(ImageFormatEMF, 0xb96b3cac, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e); DEFINE_GUID(ImageFormatEMF, 0xb96b3cac, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e);
DEFINE_GUID(ImageFormatWMF, 0xb96b3cad, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e); DEFINE_GUID(ImageFormatWMF, 0xb96b3cad, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e);
DEFINE_GUID(ImageFormatJPEG, 0xb96b3cae, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e); DEFINE_GUID(ImageFormatJPEG, 0xb96b3cae, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e);
DEFINE_GUID(ImageFormatPNG, 0xb96b3caf, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e); DEFINE_GUID(ImageFormatPNG, 0xb96b3caf, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e);
DEFINE_GUID(ImageFormatGIF, 0xb96b3cb0, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e); DEFINE_GUID(ImageFormatGIF, 0xb96b3cb0, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e);
DEFINE_GUID(ImageFormatTIFF, 0xb96b3cb1, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e); DEFINE_GUID(ImageFormatTIFF, 0xb96b3cb1, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e);
DEFINE_GUID(ImageFormatEXIF, 0xb96b3cb2, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e); DEFINE_GUID(ImageFormatEXIF, 0xb96b3cb2, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e);
DEFINE_GUID(ImageFormatIcon, 0xb96b3cb5, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e); DEFINE_GUID(ImageFormatIcon, 0xb96b3cb5, 0x728, 0x11d3, 0x9d, 0x7b, 0, 0, 0xf8, 0x1e, 0xf3, 0x2e);
DEFINE_GUID(FrameDimensionTime, 0x6aedbd6d, 0x3fb5, 0x418a, 0x83, 0xa6, 0x7f, 0x45, 0x22, 0x9d, 0xc8, 0x72); DEFINE_GUID(FrameDimensionTime, 0x6aedbd6d, 0x3fb5, 0x418a, 0x83, 0xa6, 0x7f, 0x45, 0x22, 0x9d, 0xc8, 0x72);
DEFINE_GUID(FrameDimensionPage, 0x7462dc86, 0x6180, 0x4c7e, 0x8e, 0x3f, 0xee, 0x73, 0x33, 0xa7, 0xa4, 0x83); DEFINE_GUID(FrameDimensionPage, 0x7462dc86, 0x6180, 0x4c7e, 0x8e, 0x3f, 0xee, 0x73, 0x33, 0xa7, 0xa4, 0x83);
DEFINE_GUID(FrameDimensionResolution, 0x84236f7b, 0x3bd3, 0x428f, 0x8d, 0xab, 0x4e, 0xa1, 0x43, 0x9c, 0xa3, 0x15); DEFINE_GUID(FrameDimensionResolution, 0x84236f7b, 0x3bd3, 0x428f, 0x8d, 0xab, 0x4e, 0xa1, 0x43, 0x9c, 0xa3, 0x15);
enum ImageLockMode enum ImageLockMode
{ {
ImageLockModeRead = 1, ImageLockModeRead = 1,
ImageLockModeWrite = 2, ImageLockModeWrite = 2,
ImageLockModeUserInputBuf = 4 ImageLockModeUserInputBuf = 4
}; };
enum RotateFlipType enum RotateFlipType
{ {
RotateNoneFlipNone = 0, RotateNoneFlipNone = 0,
Rotate180FlipXY = RotateNoneFlipNone, Rotate180FlipXY = RotateNoneFlipNone,
Rotate90FlipNone = 1, Rotate90FlipNone = 1,
Rotate270FlipXY = Rotate90FlipNone, Rotate270FlipXY = Rotate90FlipNone,
Rotate180FlipNone = 2, Rotate180FlipNone = 2,
RotateNoneFlipXY = Rotate180FlipNone, RotateNoneFlipXY = Rotate180FlipNone,
Rotate270FlipNone = 3, Rotate270FlipNone = 3,
Rotate90FlipXY = Rotate270FlipNone, Rotate90FlipXY = Rotate270FlipNone,
RotateNoneFlipX = 4, RotateNoneFlipX = 4,
Rotate180FlipY = RotateNoneFlipX, Rotate180FlipY = RotateNoneFlipX,
Rotate90FlipX = 5, Rotate90FlipX = 5,
Rotate270FlipY = Rotate90FlipX, Rotate270FlipY = Rotate90FlipX,
Rotate180FlipX = 6, Rotate180FlipX = 6,
RotateNoneFlipY = Rotate180FlipX, RotateNoneFlipY = Rotate180FlipX,
Rotate270FlipX = 7, Rotate270FlipX = 7,
Rotate90FlipY = Rotate270FlipX Rotate90FlipY = Rotate270FlipX
}; };
#ifdef __cplusplus #ifdef __cplusplus
class EncoderParameter class EncoderParameter
{ {
public: public:
GUID Guid; GUID Guid;
ULONG NumberOfValues; ULONG NumberOfValues;
ULONG Type; ULONG Type;
VOID* Value; VOID *Value;
}; };
class EncoderParameters class EncoderParameters
{ {
public: public:
UINT Count; UINT Count;
EncoderParameter Parameter[1]; EncoderParameter Parameter[1];
}; };
class ImageCodecInfo class ImageCodecInfo
{ {
public: public:
CLSID Clsid; CLSID Clsid;
GUID FormatID; GUID FormatID;
const WCHAR* CodecName; const WCHAR *CodecName;
const WCHAR* DllName; const WCHAR *DllName;
const WCHAR* FormatDescription; const WCHAR *FormatDescription;
const WCHAR* FilenameExtension; const WCHAR *FilenameExtension;
const WCHAR* MimeType; const WCHAR *MimeType;
DWORD Flags; DWORD Flags;
DWORD Version; DWORD Version;
DWORD SigCount; DWORD SigCount;
DWORD SigSize; DWORD SigSize;
const BYTE* SigPattern; const BYTE *SigPattern;
const BYTE* SigMask; const BYTE *SigMask;
}; };
class BitmapData class BitmapData
{ {
public: public:
UINT Width; UINT Width;
UINT Height; UINT Height;
INT Stride; INT Stride;
Gdiplus::PixelFormat PixelFormat; Gdiplus::PixelFormat PixelFormat;
VOID* Scan0; VOID *Scan0;
UINT_PTR Reserved; UINT_PTR Reserved;
}; };
class ImageItemData class ImageItemData
{ {
public: public:
UINT Size; UINT Size;
UINT Position; UINT Position;
VOID* Desc; VOID *Desc;
UINT DescSize; UINT DescSize;
VOID* Data; VOID *Data;
UINT DataSize; UINT DataSize;
UINT Cookie; UINT Cookie;
}; };
class PropertyItem class PropertyItem
{ {
public: public:
PROPID id; PROPID id;
ULONG length; ULONG length;
WORD type; WORD type;
VOID* value; VOID *value;
}; };
#else /* end of c++ typedefs */ #else /* end of c++ typedefs */
@ -146,7 +146,7 @@ typedef struct EncoderParameter
GUID Guid; GUID Guid;
ULONG NumberOfValues; ULONG NumberOfValues;
ULONG Type; ULONG Type;
VOID* Value; VOID *Value;
} EncoderParameter; } EncoderParameter;
typedef struct EncoderParameters typedef struct EncoderParameters
@ -158,18 +158,18 @@ typedef struct EncoderParameters
typedef struct ImageCodecInfo typedef struct ImageCodecInfo
{ {
CLSID Clsid; CLSID Clsid;
GUID FormatID; GUID FormatID;
const WCHAR* CodecName; const WCHAR *CodecName;
const WCHAR* DllName; const WCHAR *DllName;
const WCHAR* FormatDescription; const WCHAR *FormatDescription;
const WCHAR* FilenameExtension; const WCHAR *FilenameExtension;
const WCHAR* MimeType; const WCHAR *MimeType;
DWORD Flags; DWORD Flags;
DWORD Version; DWORD Version;
DWORD SigCount; DWORD SigCount;
DWORD SigSize; DWORD SigSize;
const BYTE* SigPattern; const BYTE *SigPattern;
const BYTE* SigMask; const BYTE *SigMask;
} ImageCodecInfo; } ImageCodecInfo;
typedef struct BitmapData typedef struct BitmapData
@ -178,276 +178,276 @@ typedef struct BitmapData
UINT Height; UINT Height;
INT Stride; INT Stride;
PixelFormat PixelFormat; PixelFormat PixelFormat;
VOID* Scan0; VOID *Scan0;
UINT_PTR Reserved; /* undocumented: stores the lock mode */ UINT_PTR Reserved; /* undocumented: stores the lock mode */
} BitmapData; } BitmapData;
typedef struct ImageItemData typedef struct ImageItemData
{ {
UINT Size; UINT Size;
UINT Position; UINT Position;
VOID* Desc; VOID *Desc;
UINT DescSize; UINT DescSize;
VOID* Data; VOID *Data;
UINT DataSize; UINT DataSize;
UINT Cookie; UINT Cookie;
} ImageItemData; } ImageItemData;
typedef struct PropertyItem typedef struct PropertyItem
{ {
PROPID id; PROPID id;
ULONG length; ULONG length;
WORD type; WORD type;
VOID* value; VOID *value;
} PropertyItem; } PropertyItem;
#endif /* end of c typedefs */ #endif /* end of c typedefs */
/* property types */ /* property types */
#define PropertyTagTypeByte 1 #define PropertyTagTypeByte 1
#define PropertyTagTypeASCII 2 #define PropertyTagTypeASCII 2
#define PropertyTagTypeShort 3 #define PropertyTagTypeShort 3
#define PropertyTagTypeLong 4 #define PropertyTagTypeLong 4
#define PropertyTagTypeRational 5 #define PropertyTagTypeRational 5
#define PropertyTagTypeUndefined 7 #define PropertyTagTypeUndefined 7
#define PropertyTagTypeSLONG 9 #define PropertyTagTypeSLONG 9
#define PropertyTagTypeSRational 10 #define PropertyTagTypeSRational 10
/* property IDs */ /* property IDs */
#define PropertyTagExifIFD 0x8769 #define PropertyTagExifIFD 0x8769
#define PropertyTagGpsIFD 0x8825 #define PropertyTagGpsIFD 0x8825
#define PropertyTagNewSubfileType 0x00FE #define PropertyTagNewSubfileType 0x00FE
#define PropertyTagSubfileType 0x00FF #define PropertyTagSubfileType 0x00FF
#define PropertyTagImageWidth 0x0100 #define PropertyTagImageWidth 0x0100
#define PropertyTagImageHeight 0x0101 #define PropertyTagImageHeight 0x0101
#define PropertyTagBitsPerSample 0x0102 #define PropertyTagBitsPerSample 0x0102
#define PropertyTagCompression 0x0103 #define PropertyTagCompression 0x0103
#define PropertyTagPhotometricInterp 0x0106 #define PropertyTagPhotometricInterp 0x0106
#define PropertyTagThreshHolding 0x0107 #define PropertyTagThreshHolding 0x0107
#define PropertyTagCellWidth 0x0108 #define PropertyTagCellWidth 0x0108
#define PropertyTagCellHeight 0x0109 #define PropertyTagCellHeight 0x0109
#define PropertyTagFillOrder 0x010A #define PropertyTagFillOrder 0x010A
#define PropertyTagDocumentName 0x010D #define PropertyTagDocumentName 0x010D
#define PropertyTagImageDescription 0x010E #define PropertyTagImageDescription 0x010E
#define PropertyTagEquipMake 0x010F #define PropertyTagEquipMake 0x010F
#define PropertyTagEquipModel 0x0110 #define PropertyTagEquipModel 0x0110
#define PropertyTagStripOffsets 0x0111 #define PropertyTagStripOffsets 0x0111
#define PropertyTagOrientation 0x0112 #define PropertyTagOrientation 0x0112
#define PropertyTagSamplesPerPixel 0x0115 #define PropertyTagSamplesPerPixel 0x0115
#define PropertyTagRowsPerStrip 0x0116 #define PropertyTagRowsPerStrip 0x0116
#define PropertyTagStripBytesCount 0x0117 #define PropertyTagStripBytesCount 0x0117
#define PropertyTagMinSampleValue 0x0118 #define PropertyTagMinSampleValue 0x0118
#define PropertyTagMaxSampleValue 0x0119 #define PropertyTagMaxSampleValue 0x0119
#define PropertyTagXResolution 0x011A #define PropertyTagXResolution 0x011A
#define PropertyTagYResolution 0x011B #define PropertyTagYResolution 0x011B
#define PropertyTagPlanarConfig 0x011C #define PropertyTagPlanarConfig 0x011C
#define PropertyTagPageName 0x011D #define PropertyTagPageName 0x011D
#define PropertyTagXPosition 0x011E #define PropertyTagXPosition 0x011E
#define PropertyTagYPosition 0x011F #define PropertyTagYPosition 0x011F
#define PropertyTagFreeOffset 0x0120 #define PropertyTagFreeOffset 0x0120
#define PropertyTagFreeByteCounts 0x0121 #define PropertyTagFreeByteCounts 0x0121
#define PropertyTagGrayResponseUnit 0x0122 #define PropertyTagGrayResponseUnit 0x0122
#define PropertyTagGrayResponseCurve 0x0123 #define PropertyTagGrayResponseCurve 0x0123
#define PropertyTagT4Option 0x0124 #define PropertyTagT4Option 0x0124
#define PropertyTagT6Option 0x0125 #define PropertyTagT6Option 0x0125
#define PropertyTagResolutionUnit 0x0128 #define PropertyTagResolutionUnit 0x0128
#define PropertyTagPageNumber 0x0129 #define PropertyTagPageNumber 0x0129
#define PropertyTagTransferFuncition 0x012D #define PropertyTagTransferFuncition 0x012D
#define PropertyTagSoftwareUsed 0x0131 #define PropertyTagSoftwareUsed 0x0131
#define PropertyTagDateTime 0x0132 #define PropertyTagDateTime 0x0132
#define PropertyTagArtist 0x013B #define PropertyTagArtist 0x013B
#define PropertyTagHostComputer 0x013C #define PropertyTagHostComputer 0x013C
#define PropertyTagPredictor 0x013D #define PropertyTagPredictor 0x013D
#define PropertyTagWhitePoint 0x013E #define PropertyTagWhitePoint 0x013E
#define PropertyTagPrimaryChromaticities 0x013F #define PropertyTagPrimaryChromaticities 0x013F
#define PropertyTagColorMap 0x0140 #define PropertyTagColorMap 0x0140
#define PropertyTagHalftoneHints 0x0141 #define PropertyTagHalftoneHints 0x0141
#define PropertyTagTileWidth 0x0142 #define PropertyTagTileWidth 0x0142
#define PropertyTagTileLength 0x0143 #define PropertyTagTileLength 0x0143
#define PropertyTagTileOffset 0x0144 #define PropertyTagTileOffset 0x0144
#define PropertyTagTileByteCounts 0x0145 #define PropertyTagTileByteCounts 0x0145
#define PropertyTagInkSet 0x014C #define PropertyTagInkSet 0x014C
#define PropertyTagInkNames 0x014D #define PropertyTagInkNames 0x014D
#define PropertyTagNumberOfInks 0x014E #define PropertyTagNumberOfInks 0x014E
#define PropertyTagDotRange 0x0150 #define PropertyTagDotRange 0x0150
#define PropertyTagTargetPrinter 0x0151 #define PropertyTagTargetPrinter 0x0151
#define PropertyTagExtraSamples 0x0152 #define PropertyTagExtraSamples 0x0152
#define PropertyTagSampleFormat 0x0153 #define PropertyTagSampleFormat 0x0153
#define PropertyTagSMinSampleValue 0x0154 #define PropertyTagSMinSampleValue 0x0154
#define PropertyTagSMaxSampleValue 0x0155 #define PropertyTagSMaxSampleValue 0x0155
#define PropertyTagTransferRange 0x0156 #define PropertyTagTransferRange 0x0156
#define PropertyTagJPEGProc 0x0200 #define PropertyTagJPEGProc 0x0200
#define PropertyTagJPEGInterFormat 0x0201 #define PropertyTagJPEGInterFormat 0x0201
#define PropertyTagJPEGInterLength 0x0202 #define PropertyTagJPEGInterLength 0x0202
#define PropertyTagJPEGRestartInterval 0x0203 #define PropertyTagJPEGRestartInterval 0x0203
#define PropertyTagJPEGLosslessPredictors 0x0205 #define PropertyTagJPEGLosslessPredictors 0x0205
#define PropertyTagJPEGPointTransforms 0x0206 #define PropertyTagJPEGPointTransforms 0x0206
#define PropertyTagJPEGQTables 0x0207 #define PropertyTagJPEGQTables 0x0207
#define PropertyTagJPEGDCTables 0x0208 #define PropertyTagJPEGDCTables 0x0208
#define PropertyTagJPEGACTables 0x0209 #define PropertyTagJPEGACTables 0x0209
#define PropertyTagYCbCrCoefficients 0x0211 #define PropertyTagYCbCrCoefficients 0x0211
#define PropertyTagYCbCrSubsampling 0x0212 #define PropertyTagYCbCrSubsampling 0x0212
#define PropertyTagYCbCrPositioning 0x0213 #define PropertyTagYCbCrPositioning 0x0213
#define PropertyTagREFBlackWhite 0x0214 #define PropertyTagREFBlackWhite 0x0214
#define PropertyTagICCProfile 0x8773 #define PropertyTagICCProfile 0x8773
#define PropertyTagGamma 0x0301 #define PropertyTagGamma 0x0301
#define PropertyTagICCProfileDescriptor 0x0302 #define PropertyTagICCProfileDescriptor 0x0302
#define PropertyTagSRGBRenderingIntent 0x0303 #define PropertyTagSRGBRenderingIntent 0x0303
#define PropertyTagImageTitle 0x0320 #define PropertyTagImageTitle 0x0320
#define PropertyTagCopyright 0x8298 #define PropertyTagCopyright 0x8298
#define PropertyTagResolutionXUnit 0x5001 #define PropertyTagResolutionXUnit 0x5001
#define PropertyTagResolutionYUnit 0x5002 #define PropertyTagResolutionYUnit 0x5002
#define PropertyTagResolutionXLengthUnit 0x5003 #define PropertyTagResolutionXLengthUnit 0x5003
#define PropertyTagResolutionYLengthUnit 0x5004 #define PropertyTagResolutionYLengthUnit 0x5004
#define PropertyTagPrintFlags 0x5005 #define PropertyTagPrintFlags 0x5005
#define PropertyTagPrintFlagsVersion 0x5006 #define PropertyTagPrintFlagsVersion 0x5006
#define PropertyTagPrintFlagsCrop 0x5007 #define PropertyTagPrintFlagsCrop 0x5007
#define PropertyTagPrintFlagsBleedWidth 0x5008 #define PropertyTagPrintFlagsBleedWidth 0x5008
#define PropertyTagPrintFlagsBleedWidthScale 0x5009 #define PropertyTagPrintFlagsBleedWidthScale 0x5009
#define PropertyTagHalftoneLPI 0x500A #define PropertyTagHalftoneLPI 0x500A
#define PropertyTagHalftoneLPIUnit 0x500B #define PropertyTagHalftoneLPIUnit 0x500B
#define PropertyTagHalftoneDegree 0x500C #define PropertyTagHalftoneDegree 0x500C
#define PropertyTagHalftoneShape 0x500D #define PropertyTagHalftoneShape 0x500D
#define PropertyTagHalftoneMisc 0x500E #define PropertyTagHalftoneMisc 0x500E
#define PropertyTagHalftoneScreen 0x500F #define PropertyTagHalftoneScreen 0x500F
#define PropertyTagJPEGQuality 0x5010 #define PropertyTagJPEGQuality 0x5010
#define PropertyTagGridSize 0x5011 #define PropertyTagGridSize 0x5011
#define PropertyTagThumbnailFormat 0x5012 #define PropertyTagThumbnailFormat 0x5012
#define PropertyTagThumbnailWidth 0x5013 #define PropertyTagThumbnailWidth 0x5013
#define PropertyTagThumbnailHeight 0x5014 #define PropertyTagThumbnailHeight 0x5014
#define PropertyTagThumbnailColorDepth 0x5015 #define PropertyTagThumbnailColorDepth 0x5015
#define PropertyTagThumbnailPlanes 0x5016 #define PropertyTagThumbnailPlanes 0x5016
#define PropertyTagThumbnailRawBytes 0x5017 #define PropertyTagThumbnailRawBytes 0x5017
#define PropertyTagThumbnailSize 0x5018 #define PropertyTagThumbnailSize 0x5018
#define PropertyTagThumbnailCompressedSize 0x5019 #define PropertyTagThumbnailCompressedSize 0x5019
#define PropertyTagColorTransferFunction 0x501A #define PropertyTagColorTransferFunction 0x501A
#define PropertyTagThumbnailData 0x501B #define PropertyTagThumbnailData 0x501B
#define PropertyTagThumbnailImageWidth 0x5020 #define PropertyTagThumbnailImageWidth 0x5020
#define PropertyTagThumbnailImageHeight 0x5021 #define PropertyTagThumbnailImageHeight 0x5021
#define PropertyTagThumbnailBitsPerSample 0x5022 #define PropertyTagThumbnailBitsPerSample 0x5022
#define PropertyTagThumbnailCompression 0x5023 #define PropertyTagThumbnailCompression 0x5023
#define PropertyTagThumbnailPhotometricInterp 0x5024 #define PropertyTagThumbnailPhotometricInterp 0x5024
#define PropertyTagThumbnailImageDescription 0x5025 #define PropertyTagThumbnailImageDescription 0x5025
#define PropertyTagThumbnailEquipMake 0x5026 #define PropertyTagThumbnailEquipMake 0x5026
#define PropertyTagThumbnailEquipModel 0x5027 #define PropertyTagThumbnailEquipModel 0x5027
#define PropertyTagThumbnailStripOffsets 0x5028 #define PropertyTagThumbnailStripOffsets 0x5028
#define PropertyTagThumbnailOrientation 0x5029 #define PropertyTagThumbnailOrientation 0x5029
#define PropertyTagThumbnailSamplesPerPixel 0x502A #define PropertyTagThumbnailSamplesPerPixel 0x502A
#define PropertyTagThumbnailRowsPerStrip 0x502B #define PropertyTagThumbnailRowsPerStrip 0x502B
#define PropertyTagThumbnailStripBytesCount 0x502C #define PropertyTagThumbnailStripBytesCount 0x502C
#define PropertyTagThumbnailResolutionX 0x502D #define PropertyTagThumbnailResolutionX 0x502D
#define PropertyTagThumbnailResolutionY 0x502E #define PropertyTagThumbnailResolutionY 0x502E
#define PropertyTagThumbnailPlanarConfig 0x502F #define PropertyTagThumbnailPlanarConfig 0x502F
#define PropertyTagThumbnailResolutionUnit 0x5030 #define PropertyTagThumbnailResolutionUnit 0x5030
#define PropertyTagThumbnailTransferFunction 0x5031 #define PropertyTagThumbnailTransferFunction 0x5031
#define PropertyTagThumbnailSoftwareUsed 0x5032 #define PropertyTagThumbnailSoftwareUsed 0x5032
#define PropertyTagThumbnailDateTime 0x5033 #define PropertyTagThumbnailDateTime 0x5033
#define PropertyTagThumbnailArtist 0x5034 #define PropertyTagThumbnailArtist 0x5034
#define PropertyTagThumbnailWhitePoint 0x5035 #define PropertyTagThumbnailWhitePoint 0x5035
#define PropertyTagThumbnailPrimaryChromaticities 0x5036 #define PropertyTagThumbnailPrimaryChromaticities 0x5036
#define PropertyTagThumbnailYCbCrCoefficients 0x5037 #define PropertyTagThumbnailYCbCrCoefficients 0x5037
#define PropertyTagThumbnailYCbCrSubsampling 0x5038 #define PropertyTagThumbnailYCbCrSubsampling 0x5038
#define PropertyTagThumbnailYCbCrPositioning 0x5039 #define PropertyTagThumbnailYCbCrPositioning 0x5039
#define PropertyTagThumbnailRefBlackWhite 0x503A #define PropertyTagThumbnailRefBlackWhite 0x503A
#define PropertyTagThumbnailCopyRight 0x503B #define PropertyTagThumbnailCopyRight 0x503B
#define PropertyTagLuminanceTable 0x5090 #define PropertyTagLuminanceTable 0x5090
#define PropertyTagChrominanceTable 0x5091 #define PropertyTagChrominanceTable 0x5091
#define PropertyTagFrameDelay 0x5100 #define PropertyTagFrameDelay 0x5100
#define PropertyTagLoopCount 0x5101 #define PropertyTagLoopCount 0x5101
#define PropertyTagGlobalPalette 0x5102 #define PropertyTagGlobalPalette 0x5102
#define PropertyTagIndexBackground 0x5103 #define PropertyTagIndexBackground 0x5103
#define PropertyTagIndexTransparent 0x5104 #define PropertyTagIndexTransparent 0x5104
#define PropertyTagPixelUnit 0x5110 #define PropertyTagPixelUnit 0x5110
#define PropertyTagPixelPerUnitX 0x5111 #define PropertyTagPixelPerUnitX 0x5111
#define PropertyTagPixelPerUnitY 0x5112 #define PropertyTagPixelPerUnitY 0x5112
#define PropertyTagPaletteHistogram 0x5113 #define PropertyTagPaletteHistogram 0x5113
#define PropertyTagExifExposureTime 0x829A #define PropertyTagExifExposureTime 0x829A
#define PropertyTagExifFNumber 0x829D #define PropertyTagExifFNumber 0x829D
#define PropertyTagExifExposureProg 0x8822 #define PropertyTagExifExposureProg 0x8822
#define PropertyTagExifSpectralSense 0x8824 #define PropertyTagExifSpectralSense 0x8824
#define PropertyTagExifISOSpeed 0x8827 #define PropertyTagExifISOSpeed 0x8827
#define PropertyTagExifOECF 0x8828 #define PropertyTagExifOECF 0x8828
#define PropertyTagExifVer 0x9000 #define PropertyTagExifVer 0x9000
#define PropertyTagExifDTOrig 0x9003 #define PropertyTagExifDTOrig 0x9003
#define PropertyTagExifDTDigitized 0x9004 #define PropertyTagExifDTDigitized 0x9004
#define PropertyTagExifCompConfig 0x9101 #define PropertyTagExifCompConfig 0x9101
#define PropertyTagExifCompBPP 0x9102 #define PropertyTagExifCompBPP 0x9102
#define PropertyTagExifShutterSpeed 0x9201 #define PropertyTagExifShutterSpeed 0x9201
#define PropertyTagExifAperture 0x9202 #define PropertyTagExifAperture 0x9202
#define PropertyTagExifBrightness 0x9203 #define PropertyTagExifBrightness 0x9203
#define PropertyTagExifExposureBias 0x9204 #define PropertyTagExifExposureBias 0x9204
#define PropertyTagExifMaxAperture 0x9205 #define PropertyTagExifMaxAperture 0x9205
#define PropertyTagExifSubjectDist 0x9206 #define PropertyTagExifSubjectDist 0x9206
#define PropertyTagExifMeteringMode 0x9207 #define PropertyTagExifMeteringMode 0x9207
#define PropertyTagExifLightSource 0x9208 #define PropertyTagExifLightSource 0x9208
#define PropertyTagExifFlash 0x9209 #define PropertyTagExifFlash 0x9209
#define PropertyTagExifFocalLength 0x920A #define PropertyTagExifFocalLength 0x920A
#define PropertyTagExifMakerNote 0x927C #define PropertyTagExifMakerNote 0x927C
#define PropertyTagExifUserComment 0x9286 #define PropertyTagExifUserComment 0x9286
#define PropertyTagExifDTSubsec 0x9290 #define PropertyTagExifDTSubsec 0x9290
#define PropertyTagExifDTOrigSS 0x9291 #define PropertyTagExifDTOrigSS 0x9291
#define PropertyTagExifDTDigSS 0x9292 #define PropertyTagExifDTDigSS 0x9292
#define PropertyTagExifFPXVer 0xA000 #define PropertyTagExifFPXVer 0xA000
#define PropertyTagExifColorSpace 0xA001 #define PropertyTagExifColorSpace 0xA001
#define PropertyTagExifPixXDim 0xA002 #define PropertyTagExifPixXDim 0xA002
#define PropertyTagExifPixYDim 0xA003 #define PropertyTagExifPixYDim 0xA003
#define PropertyTagExifRelatedWav 0xA004 #define PropertyTagExifRelatedWav 0xA004
#define PropertyTagExifInterop 0xA005 #define PropertyTagExifInterop 0xA005
#define PropertyTagExifFlashEnergy 0xA20B #define PropertyTagExifFlashEnergy 0xA20B
#define PropertyTagExifSpatialFR 0xA20C #define PropertyTagExifSpatialFR 0xA20C
#define PropertyTagExifFocalXRes 0xA20E #define PropertyTagExifFocalXRes 0xA20E
#define PropertyTagExifFocalYRes 0xA20F #define PropertyTagExifFocalYRes 0xA20F
#define PropertyTagExifFocalResUnit 0xA210 #define PropertyTagExifFocalResUnit 0xA210
#define PropertyTagExifSubjectLoc 0xA214 #define PropertyTagExifSubjectLoc 0xA214
#define PropertyTagExifExposureIndex 0xA215 #define PropertyTagExifExposureIndex 0xA215
#define PropertyTagExifSensingMethod 0xA217 #define PropertyTagExifSensingMethod 0xA217
#define PropertyTagExifFileSource 0xA300 #define PropertyTagExifFileSource 0xA300
#define PropertyTagExifSceneType 0xA301 #define PropertyTagExifSceneType 0xA301
#define PropertyTagExifCfaPattern 0xA302 #define PropertyTagExifCfaPattern 0xA302
#define PropertyTagGpsVer 0x0000 #define PropertyTagGpsVer 0x0000
#define PropertyTagGpsLatitudeRef 0x0001 #define PropertyTagGpsLatitudeRef 0x0001
#define PropertyTagGpsLatitude 0x0002 #define PropertyTagGpsLatitude 0x0002
#define PropertyTagGpsLongitudeRef 0x0003 #define PropertyTagGpsLongitudeRef 0x0003
#define PropertyTagGpsLongitude 0x0004 #define PropertyTagGpsLongitude 0x0004
#define PropertyTagGpsAltitudeRef 0x0005 #define PropertyTagGpsAltitudeRef 0x0005
#define PropertyTagGpsAltitude 0x0006 #define PropertyTagGpsAltitude 0x0006
#define PropertyTagGpsGpsTime 0x0007 #define PropertyTagGpsGpsTime 0x0007
#define PropertyTagGpsGpsSatellites 0x0008 #define PropertyTagGpsGpsSatellites 0x0008
#define PropertyTagGpsGpsStatus 0x0009 #define PropertyTagGpsGpsStatus 0x0009
#define PropertyTagGpsGpsMeasureMode 0x000A #define PropertyTagGpsGpsMeasureMode 0x000A
#define PropertyTagGpsGpsDop 0x000B #define PropertyTagGpsGpsDop 0x000B
#define PropertyTagGpsSpeedRef 0x000C #define PropertyTagGpsSpeedRef 0x000C
#define PropertyTagGpsSpeed 0x000D #define PropertyTagGpsSpeed 0x000D
#define PropertyTagGpsTrackRef 0x000E #define PropertyTagGpsTrackRef 0x000E
#define PropertyTagGpsTrack 0x000F #define PropertyTagGpsTrack 0x000F
#define PropertyTagGpsImgDirRef 0x0010 #define PropertyTagGpsImgDirRef 0x0010
#define PropertyTagGpsImgDir 0x0011 #define PropertyTagGpsImgDir 0x0011
#define PropertyTagGpsMapDatum 0x0012 #define PropertyTagGpsMapDatum 0x0012
#define PropertyTagGpsDestLatRef 0x0013 #define PropertyTagGpsDestLatRef 0x0013
#define PropertyTagGpsDestLat 0x0014 #define PropertyTagGpsDestLat 0x0014
#define PropertyTagGpsDestLongRef 0x0015 #define PropertyTagGpsDestLongRef 0x0015
#define PropertyTagGpsDestLong 0x0016 #define PropertyTagGpsDestLong 0x0016
#define PropertyTagGpsDestBearRef 0x0017 #define PropertyTagGpsDestBearRef 0x0017
#define PropertyTagGpsDestBear 0x0018 #define PropertyTagGpsDestBear 0x0018
#define PropertyTagGpsDestDistRef 0x0019 #define PropertyTagGpsDestDistRef 0x0019
#define PropertyTagGpsDestDist 0x001A #define PropertyTagGpsDestDist 0x001A
#endif /* _GDIPLUSIMAGING_H */ #endif /* _GDIPLUSIMAGING_H */

17
sdk/include/psdk/gdiplusinit.h
View file

@ -25,9 +25,9 @@ enum DebugEventLevel
DebugEventLevelWarning DebugEventLevelWarning
}; };
typedef VOID (WINAPI *DebugEventProc)(enum DebugEventLevel, CHAR *); typedef VOID(WINAPI *DebugEventProc)(enum DebugEventLevel, CHAR *);
typedef Status (WINAPI *NotificationHookProc)(ULONG_PTR *); typedef Status(WINAPI *NotificationHookProc)(ULONG_PTR *);
typedef void (WINAPI *NotificationUnhookProc)(ULONG_PTR); typedef void(WINAPI *NotificationUnhookProc)(ULONG_PTR);
struct GdiplusStartupInput struct GdiplusStartupInput
{ {
@ -37,7 +37,8 @@ struct GdiplusStartupInput
BOOL SuppressExternalCodecs; BOOL SuppressExternalCodecs;
#ifdef __cplusplus #ifdef __cplusplus
GdiplusStartupInput(DebugEventProc debugEventCallback = NULL, GdiplusStartupInput(
DebugEventProc debugEventCallback = NULL,
BOOL suppressBackgroundThread = FALSE, BOOL suppressBackgroundThread = FALSE,
BOOL suppressExternalCodecs = FALSE) BOOL suppressExternalCodecs = FALSE)
{ {
@ -56,11 +57,13 @@ struct GdiplusStartupOutput
}; };
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C"
{
#endif #endif
Status WINAPI GdiplusStartup(ULONG_PTR *, const struct GdiplusStartupInput *, struct GdiplusStartupOutput *); Status WINAPI
void WINAPI GdiplusShutdown(ULONG_PTR); GdiplusStartup(ULONG_PTR *, const struct GdiplusStartupInput *, struct GdiplusStartupOutput *);
void WINAPI GdiplusShutdown(ULONG_PTR);
#ifdef __cplusplus #ifdef __cplusplus
} }

129
sdk/include/psdk/gdipluslinecaps.h
View file

@ -19,137 +19,136 @@
#ifndef _GDIPLUSLINECAPS_H #ifndef _GDIPLUSLINECAPS_H
#define _GDIPLUSLINECAPS_H #define _GDIPLUSLINECAPS_H
inline inline CustomLineCap::CustomLineCap(
CustomLineCap::CustomLineCap(const GraphicsPath *fillPath, const GraphicsPath *fillPath,
const GraphicsPath *strokePath, LineCap baseCap, REAL baseInset) const GraphicsPath *strokePath,
LineCap baseCap,
REAL baseInset)
{ {
} }
inline CustomLineCap * inline CustomLineCap *CustomLineCap::Clone(VOID)
CustomLineCap::Clone(VOID)
{ {
return NULL; return NULL;
} }
inline LineCap inline LineCap CustomLineCap::GetBaseCap(VOID)
CustomLineCap::GetBaseCap(VOID)
{ {
return LineCapFlat; return LineCapFlat;
} }
inline REAL inline REAL CustomLineCap::GetBaseInset(VOID)
CustomLineCap::GetBaseInset(VOID)
{ {
return 0; return 0;
} }
inline Status inline Status CustomLineCap::GetLastStatus(VOID)
CustomLineCap::GetLastStatus(VOID)
{ {
return Ok; return Ok;
} }
inline Status inline Status
CustomLineCap::GetStrokeCaps(LineCap *startCap, LineCap *endCap) CustomLineCap::GetStrokeCaps(LineCap *startCap, LineCap *endCap)
{ {
return Ok; return Ok;
} }
inline LineJoin inline LineJoin CustomLineCap::GetStrokeJoin(VOID)
CustomLineCap::GetStrokeJoin(VOID)
{ {
return LineJoinMiter; return LineJoinMiter;
} }
inline REAL inline REAL CustomLineCap::GetWidthScale(VOID)
CustomLineCap::GetWidthScale(VOID)
{ {
return 0; return 0;
} }
inline Status inline Status
CustomLineCap::SetBaseCap(LineCap baseCap) CustomLineCap::SetBaseCap(LineCap baseCap)
{ {
return Ok; return Ok;
} }
inline Status inline Status
CustomLineCap::SetBaseInset(REAL inset) CustomLineCap::SetBaseInset(REAL inset)
{ {
return Ok; return Ok;
} }
inline Status inline Status
CustomLineCap::SetStrokeCap(LineCap strokeCap) CustomLineCap::SetStrokeCap(LineCap strokeCap)
{ {
return Ok; return Ok;
} }
inline Status inline Status
CustomLineCap::SetStrokeCaps(LineCap startCap, LineCap endCap) CustomLineCap::SetStrokeCaps(LineCap startCap, LineCap endCap)
{ {
return Ok; return Ok;
} }
inline Status inline Status
CustomLineCap::SetStrokeJoin(LineJoin lineJoin) CustomLineCap::SetStrokeJoin(LineJoin lineJoin)
{ {
return Ok; return Ok;
} }
inline Status inline Status
CustomLineCap::SetWidthScale(IN REAL widthScale) CustomLineCap::SetWidthScale(IN REAL widthScale)
{ {
return Ok; return Ok;
} }
class AdjustableArrowCap : public CustomLineCap class AdjustableArrowCap : public CustomLineCap
{ {
public: public:
AdjustableArrowCap(REAL height, REAL width, BOOL isFilled) AdjustableArrowCap(REAL height, REAL width, BOOL isFilled)
{ {
} }
REAL GetHeight(VOID) REAL GetHeight(VOID)
{ {
return 0; return 0;
} }
REAL GetMiddleInset(VOID) REAL GetMiddleInset(VOID)
{ {
return 0; return 0;
} }
REAL GetWidth(VOID) REAL GetWidth(VOID)
{ {
return 0; return 0;
} }
BOOL IsFilled(VOID) BOOL IsFilled(VOID)
{ {
return FALSE; return FALSE;
} }
Status SetFillState(BOOL isFilled) Status
{ SetFillState(BOOL isFilled)
return Ok; {
} return Ok;
}
Status SetHeight(REAL height) Status
{ SetHeight(REAL height)
return Ok; {
} return Ok;
}
Status SetMiddleInset(REAL middleInset) Status
{ SetMiddleInset(REAL middleInset)
return Ok; {
} return Ok;
}
Status SetWidth(REAL width) Status
{ SetWidth(REAL width)
return Ok; {
} return Ok;
}
}; };
#endif /* _GDIPLUSLINECAPS_H */ #endif /* _GDIPLUSLINECAPS_H */

264
sdk/include/psdk/gdiplusmatrix.h
View file

@ -21,159 +21,173 @@
class Matrix : public GdiplusBase class Matrix : public GdiplusBase
{ {
friend class Pen; friend class Pen;
friend class Region; friend class Region;
public: public:
Matrix(const RectF &rect, const PointF *dstplg) Matrix(const RectF &rect, const PointF *dstplg)
{ {
status = DllExports::GdipCreateMatrix3(&rect, dstplg, &matrix); status = DllExports::GdipCreateMatrix3(&rect, dstplg, &matrix);
} }
Matrix(const Rect &rect, const Point *dstplg) Matrix(const Rect &rect, const Point *dstplg)
{ {
status = DllExports::GdipCreateMatrix3I(&rect, dstplg, &matrix); status = DllExports::GdipCreateMatrix3I(&rect, dstplg, &matrix);
} }
Matrix(VOID) Matrix(VOID)
{ {
status = DllExports::GdipCreateMatrix(&matrix); status = DllExports::GdipCreateMatrix(&matrix);
} }
Matrix(REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy) Matrix(REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy)
{ {
status = DllExports::GdipCreateMatrix2(m11, m12, m21, m22, dx, dy, &matrix); status = DllExports::GdipCreateMatrix2(m11, m12, m21, m22, dx, dy, &matrix);
} }
Matrix *Clone(VOID) Matrix *Clone(VOID)
{ {
Matrix *cloneMatrix = new Matrix(); // FIXME: Matrix::matrix already initialized --> potential memory leak Matrix *cloneMatrix = new Matrix(); // FIXME: Matrix::matrix already initialized --> potential memory leak
cloneMatrix->status = DllExports::GdipCloneMatrix(matrix, cloneMatrix ? &cloneMatrix->matrix : NULL); cloneMatrix->status = DllExports::GdipCloneMatrix(matrix, cloneMatrix ? &cloneMatrix->matrix : NULL);
return cloneMatrix; return cloneMatrix;
} }
~Matrix(VOID) ~Matrix(VOID)
{ {
DllExports::GdipDeleteMatrix(matrix); DllExports::GdipDeleteMatrix(matrix);
} }
BOOL Equals(const Matrix* matrix) BOOL
{ Equals(const Matrix *matrix)
BOOL result; {
SetStatus(DllExports::GdipIsMatrixEqual(this->matrix, matrix ? matrix->matrix : NULL, &result)); BOOL result;
return result; SetStatus(DllExports::GdipIsMatrixEqual(this->matrix, matrix ? matrix->matrix : NULL, &result));
} return result;
}
Status GetElements(REAL *m) const Status
{ GetElements(REAL *m) const
return SetStatus(DllExports::GdipGetMatrixElements(matrix, m)); {
} return SetStatus(DllExports::GdipGetMatrixElements(matrix, m));
}
Status GetLastStatus(VOID) Status GetLastStatus(VOID)
{ {
return status; return status;
} }
Status Invert(VOID) Status Invert(VOID)
{ {
return SetStatus(DllExports::GdipInvertMatrix(matrix)); return SetStatus(DllExports::GdipInvertMatrix(matrix));
} }
BOOL IsIdentity(VOID) BOOL IsIdentity(VOID)
{ {
BOOL result; BOOL result;
SetStatus(DllExports::GdipIsMatrixIdentity(matrix, &result)); SetStatus(DllExports::GdipIsMatrixIdentity(matrix, &result));
return result; return result;
} }
BOOL IsInvertible(VOID) BOOL IsInvertible(VOID)
{ {
BOOL result; BOOL result;
SetStatus(DllExports::GdipIsMatrixInvertible(matrix, &result)); SetStatus(DllExports::GdipIsMatrixInvertible(matrix, &result));
return result; return result;
} }
Status Multiply(const Matrix *matrix, MatrixOrder order) Status
{ Multiply(const Matrix *matrix, MatrixOrder order)
return SetStatus(DllExports::GdipMultiplyMatrix(this->matrix, matrix ? matrix->matrix : NULL, order)); {
} return SetStatus(DllExports::GdipMultiplyMatrix(this->matrix, matrix ? matrix->matrix : NULL, order));
}
REAL OffsetX(VOID) REAL OffsetX(VOID)
{ {
return 0; return 0;
} }
REAL OffsetY(VOID) REAL OffsetY(VOID)
{ {
return 0; return 0;
} }
Status Reset(VOID) Status Reset(VOID)
{ {
return NotImplemented; return NotImplemented;
} }
Status Rotate(REAL angle, MatrixOrder order) Status
{ Rotate(REAL angle, MatrixOrder order)
return SetStatus(DllExports::GdipRotateMatrix(matrix, angle, order)); {
} return SetStatus(DllExports::GdipRotateMatrix(matrix, angle, order));
}
Status RotateAt(REAL angle, const PointF &center, MatrixOrder order) Status
{ RotateAt(REAL angle, const PointF &center, MatrixOrder order)
return NotImplemented; {
} return NotImplemented;
}
Status Scale(REAL scaleX, REAL scaleY, MatrixOrder order) Status
{ Scale(REAL scaleX, REAL scaleY, MatrixOrder order)
return SetStatus(DllExports::GdipScaleMatrix(matrix, scaleX, scaleY, order)); {
} return SetStatus(DllExports::GdipScaleMatrix(matrix, scaleX, scaleY, order));
}
Status SetElements(REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy) Status
{ SetElements(REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy)
return SetStatus(DllExports::GdipSetMatrixElements(matrix, m11, m12, m21, m22, dx, dy)); {
} return SetStatus(DllExports::GdipSetMatrixElements(matrix, m11, m12, m21, m22, dx, dy));
}
Status Shear(REAL shearX, REAL shearY, MatrixOrder order) Status
{ Shear(REAL shearX, REAL shearY, MatrixOrder order)
return SetStatus(DllExports::GdipShearMatrix(matrix, shearX, shearY, order)); {
} return SetStatus(DllExports::GdipShearMatrix(matrix, shearX, shearY, order));
}
Status TransformPoints(Point *pts, INT count) Status
{ TransformPoints(Point *pts, INT count)
return SetStatus(DllExports::GdipTransformMatrixPointsI(matrix, pts, count)); {
} return SetStatus(DllExports::GdipTransformMatrixPointsI(matrix, pts, count));
}
Status TransformPoints(PointF *pts, INT count) Status
{ TransformPoints(PointF *pts, INT count)
return SetStatus(DllExports::GdipTransformMatrixPoints(matrix, pts, count)); {
} return SetStatus(DllExports::GdipTransformMatrixPoints(matrix, pts, count));
}
Status TransformVectors(Point *pts, INT count) Status
{ TransformVectors(Point *pts, INT count)
return SetStatus(DllExports::GdipVectorTransformMatrixPointsI(matrix, pts, count)); {
} return SetStatus(DllExports::GdipVectorTransformMatrixPointsI(matrix, pts, count));
}
Status TransformVectors(PointF *pts, INT count) Status
{ TransformVectors(PointF *pts, INT count)
return SetStatus(DllExports::GdipVectorTransformMatrixPoints(matrix, pts, count)); {
} return SetStatus(DllExports::GdipVectorTransformMatrixPoints(matrix, pts, count));
}
Status Translate(REAL offsetX, REAL offsetY, MatrixOrder order) Status
{ Translate(REAL offsetX, REAL offsetY, MatrixOrder order)
return SetStatus(DllExports::GdipTranslateMatrix(matrix, offsetX, offsetY, order)); {
} return SetStatus(DllExports::GdipTranslateMatrix(matrix, offsetX, offsetY, order));
}
private: private:
mutable Status status; mutable Status status;
GpMatrix *matrix; GpMatrix *matrix;
Status SetStatus(Status status) const Status
{ SetStatus(Status status) const
if (status == Ok) {
return status; if (status == Ok)
this->status = status; return status;
return status; this->status = status;
} return status;
}
}; };
#endif /* _GDIPLUSMATRIX_H */ #endif /* _GDIPLUSMATRIX_H */

8
sdk/include/psdk/gdiplusmem.h
View file

@ -22,11 +22,13 @@
#define WINGDIPAPI __stdcall #define WINGDIPAPI __stdcall
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C"
{
#endif #endif
void* WINGDIPAPI GdipAlloc(SIZE_T) __WINE_ALLOC_SIZE(1); void *WINGDIPAPI GdipAlloc(SIZE_T) __WINE_ALLOC_SIZE(1);
void WINGDIPAPI GdipFree(void*); void WINGDIPAPI
GdipFree(void *);
#ifdef __cplusplus #ifdef __cplusplus
} }

202
sdk/include/psdk/gdiplusmetafile.h
View file

@ -21,108 +21,150 @@
class Metafile : public Image class Metafile : public Image
{ {
public: public:
Metafile(HDC referenceHdc, EmfType type, const WCHAR *description) Metafile(HDC referenceHdc, EmfType type, const WCHAR *description)
{ {
} }
Metafile(const WCHAR *filename) Metafile(const WCHAR *filename)
{ {
} }
Metafile(HDC referenceHdc, const RectF &frameRect, MetafileFrameUnit frameUnit, EmfType type, const WCHAR *description) Metafile(
{ HDC referenceHdc,
} const RectF &frameRect,
MetafileFrameUnit frameUnit,
EmfType type,
const WCHAR *description)
{
}
Metafile(HMETAFILE hWmf, const WmfPlaceableFileHeader *wmfPlaceableFileHeader, BOOL deleteWmf) 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(
{ 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,
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, EmfType type, const WCHAR *description)
{ {
} }
Metafile(IStream *stream, HDC referenceHdc, const Rect &frameRect, MetafileFrameUnit frameUnit, 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,
const RectF &frameRect,
MetafileFrameUnit frameUnit,
EmfType type,
const WCHAR *description)
{
}
Metafile(const WCHAR *fileName, HDC referenceHdc, EmfType type, const WCHAR *description) Metafile(const WCHAR *fileName, HDC referenceHdc, EmfType type, const WCHAR *description)
{ {
} }
Metafile(IStream *stream) Metafile(IStream *stream)
{ {
} }
Metafile(HENHMETAFILE hEmf, BOOL deleteEmf) Metafile(HENHMETAFILE hEmf, BOOL deleteEmf)
{ {
} }
Metafile(HDC referenceHdc, const Rect &frameRect, MetafileFrameUnit frameUnit, EmfType type, const WCHAR *description) 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) static UINT
{ EmfToWmfBits(HENHMETAFILE hemf, UINT cbData16, LPBYTE pData16, INT iMapMode, EmfToWmfBitsFlags eFlags)
return 0; {
} return 0;
}
UINT GetDownLevelRasterizationLimit(VOID) UINT GetDownLevelRasterizationLimit(VOID)
{ {
return 0; return 0;
} }
HENHMETAFILE GetHENHMETAFILE(VOID) HENHMETAFILE GetHENHMETAFILE(VOID)
{ {
return NULL; return NULL;
} }
static Status GetMetafileHeader(const WCHAR *filename, MetafileHeader *header) static Status
{ GetMetafileHeader(const WCHAR *filename, MetafileHeader *header)
return NotImplemented; {
} return NotImplemented;
}
static Status GetMetafileHeader(HENHMETAFILE *hEmf, MetafileHeader *header) static Status
{ GetMetafileHeader(HENHMETAFILE *hEmf, MetafileHeader *header)
return NotImplemented; {
} return NotImplemented;
}
static Status GetMetafileHeader(HMETAFILE hWmf, const WmfPlaceableFileHeader *wmfPlaceableFileHeader, MetafileHeader *header) static Status
{ GetMetafileHeader(HMETAFILE hWmf, const WmfPlaceableFileHeader *wmfPlaceableFileHeader, MetafileHeader *header)
return NotImplemented; {
} return NotImplemented;
}
Status GetMetafileHeader(MetafileHeader *header) const Status
{ GetMetafileHeader(MetafileHeader *header) const
return NotImplemented; {
} return NotImplemented;
}
static Status GetMetafileHeader(IStream *stream, MetafileHeader *header) static Status
{ GetMetafileHeader(IStream *stream, MetafileHeader *header)
return NotImplemented; {
} return NotImplemented;
}
Status PlayRecord(EmfPlusRecordType recordType, UINT flags, UINT dataSize, const BYTE *data) Status
{ PlayRecord(EmfPlusRecordType recordType, UINT flags, UINT dataSize, const BYTE *data)
return NotImplemented; {
} return NotImplemented;
}
Status SetDownLevelRasterizationLimit(UINT metafileRasterizationLimitDpi) Status
{ SetDownLevelRasterizationLimit(UINT metafileRasterizationLimitDpi)
return NotImplemented; {
} return NotImplemented;
}
}; };
#endif /* _GDIPLUSMETAFILE_H */ #endif /* _GDIPLUSMETAFILE_H */

209
sdk/include/psdk/gdiplusmetaheader.h
View file

@ -21,84 +21,108 @@
typedef struct typedef struct
{ {
DWORD iType; DWORD iType;
DWORD nSize; DWORD nSize;
RECTL rclBounds; RECTL rclBounds;
RECTL rclFrame; RECTL rclFrame;
DWORD dSignature; DWORD dSignature;
DWORD nVersion; DWORD nVersion;
DWORD nBytes; DWORD nBytes;
DWORD nRecords; DWORD nRecords;
WORD nHandles; WORD nHandles;
WORD sReserved; WORD sReserved;
DWORD nDescription; DWORD nDescription;
DWORD offDescription; DWORD offDescription;
DWORD nPalEntries; DWORD nPalEntries;
SIZEL szlDevice; SIZEL szlDevice;
SIZEL szlMillimeters; SIZEL szlMillimeters;
} ENHMETAHEADER3; } ENHMETAHEADER3;
#include <pshpack2.h> #include <pshpack2.h>
typedef struct typedef struct
{ {
INT16 Left; INT16 Left;
INT16 Top; INT16 Top;
INT16 Right; INT16 Right;
INT16 Bottom; INT16 Bottom;
} PWMFRect16; } PWMFRect16;
typedef struct typedef struct
{ {
UINT32 Key; UINT32 Key;
INT16 Hmf; INT16 Hmf;
PWMFRect16 BoundingBox; PWMFRect16 BoundingBox;
INT16 Inch; INT16 Inch;
UINT32 Reserved; UINT32 Reserved;
INT16 Checksum; INT16 Checksum;
} WmfPlaceableFileHeader; } WmfPlaceableFileHeader;
#include <poppack.h> #include <poppack.h>
#define GDIP_EMFPLUSFLAGS_DISPLAY 0x00000001 #define GDIP_EMFPLUSFLAGS_DISPLAY 0x00000001
#ifdef __cplusplus #ifdef __cplusplus
class MetafileHeader class MetafileHeader
{ {
public: public:
MetafileType Type; MetafileType Type;
UINT Size; UINT Size;
UINT Version; UINT Version;
UINT EmfPlusFlags; UINT EmfPlusFlags;
REAL DpiX; REAL DpiX;
REAL DpiY; REAL DpiY;
INT X; INT X;
INT Y; INT Y;
INT Width; INT Width;
INT Height; INT Height;
union union {
{ METAHEADER WmfHeader;
METAHEADER WmfHeader; ENHMETAHEADER3 EmfHeader;
ENHMETAHEADER3 EmfHeader;
}; };
INT EmfPlusHeaderSize; INT EmfPlusHeaderSize;
INT LogicalDpiX; INT LogicalDpiX;
INT LogicalDpiY; INT LogicalDpiY;
public: public:
MetafileType GetType() const { return Type; } MetafileType
GetType() const
{
return Type;
}
UINT GetMetafileSize() const { return Size; } UINT
GetMetafileSize() const
{
return Size;
}
UINT GetVersion() const { return Version; } UINT
GetVersion() const
{
return Version;
}
UINT GetEmfPlusFlags() const { return EmfPlusFlags; } UINT
GetEmfPlusFlags() const
{
return EmfPlusFlags;
}
REAL GetDpiX() const { return DpiX; } REAL
GetDpiX() const
{
return DpiX;
}
REAL GetDpiY() const { return DpiY; } REAL
GetDpiY() const
{
return DpiY;
}
VOID GetBounds (OUT Rect *r) const VOID
GetBounds(OUT Rect *r) const
{ {
r->X = X; r->X = X;
r->Y = Y; r->Y = Y;
@ -106,34 +130,62 @@ public:
r->Height = Height; r->Height = Height;
} }
BOOL IsWmf() const BOOL
IsWmf() const
{ {
return ((Type == MetafileTypeWmf) || (Type == MetafileTypeWmfPlaceable)); return ((Type == MetafileTypeWmf) || (Type == MetafileTypeWmfPlaceable));
} }
BOOL IsWmfPlaceable() const { return (Type == MetafileTypeWmfPlaceable); } BOOL
IsWmfPlaceable() const
{
return (Type == MetafileTypeWmfPlaceable);
}
BOOL IsEmf() const { return (Type == MetafileTypeEmf); } BOOL
IsEmf() const
{
return (Type == MetafileTypeEmf);
}
BOOL IsEmfOrEmfPlus() const { return (Type >= MetafileTypeEmf); } BOOL
IsEmfOrEmfPlus() const
{
return (Type >= MetafileTypeEmf);
}
BOOL IsEmfPlus() const { return (Type >= MetafileTypeEmfPlusOnly); } BOOL
IsEmfPlus() const
{
return (Type >= MetafileTypeEmfPlusOnly);
}
BOOL IsEmfPlusDual() const { return (Type == MetafileTypeEmfPlusDual); } BOOL
IsEmfPlusDual() const
{
return (Type == MetafileTypeEmfPlusDual);
}
BOOL IsEmfPlusOnly() const { return (Type == MetafileTypeEmfPlusOnly); } BOOL
IsEmfPlusOnly() const
{
return (Type == MetafileTypeEmfPlusOnly);
}
BOOL IsDisplay() const BOOL
IsDisplay() const
{ {
return IsEmfPlus() && ((EmfPlusFlags & GDIP_EMFPLUSFLAGS_DISPLAY) != 0); return IsEmfPlus() && ((EmfPlusFlags & GDIP_EMFPLUSFLAGS_DISPLAY) != 0);
} }
const METAHEADER * GetWmfHeader() const const METAHEADER *
GetWmfHeader() const
{ {
return IsWmf() ? &WmfHeader : NULL; return IsWmf() ? &WmfHeader : NULL;
} }
const ENHMETAHEADER3 * GetEmfHeader() const const ENHMETAHEADER3 *
GetEmfHeader() const
{ {
return IsEmfOrEmfPlus() ? &EmfHeader : NULL; return IsEmfOrEmfPlus() ? &EmfHeader : NULL;
} }
@ -142,24 +194,23 @@ public:
typedef struct MetafileHeader typedef struct MetafileHeader
{ {
MetafileType Type; MetafileType Type;
UINT Size; UINT Size;
UINT Version; UINT Version;
UINT EmfPlusFlags; UINT EmfPlusFlags;
REAL DpiX; REAL DpiX;
REAL DpiY; REAL DpiY;
INT X; INT X;
INT Y; INT Y;
INT Width; INT Width;
INT Height; INT Height;
union union {
{ METAHEADER WmfHeader;
METAHEADER WmfHeader; ENHMETAHEADER3 EmfHeader;
ENHMETAHEADER3 EmfHeader;
} DUMMYUNIONNAME; } DUMMYUNIONNAME;
INT EmfPlusHeaderSize; INT EmfPlusHeaderSize;
INT LogicalDpiX; INT LogicalDpiX;
INT LogicalDpiY; INT LogicalDpiY;
} MetafileHeader; } MetafileHeader;
#endif /* end of c typedefs */ #endif /* end of c typedefs */

1343
sdk/include/psdk/gdipluspath.h
View file

File diff suppressed because it is too large Load diff

468
sdk/include/psdk/gdipluspen.h
View file

@ -23,274 +23,300 @@ class CustomLineCap;
class Pen : public GdiplusBase class Pen : public GdiplusBase
{ {
friend class Graphics; friend class Graphics;
public: public:
Pen(const Brush *brush, REAL width = 1.0f) Pen(const Brush *brush, REAL width = 1.0f)
{ {
} }
Pen(const Color &color, REAL width = 1.0f) Pen(const Color &color, REAL width = 1.0f)
{ {
Unit unit = UnitWorld; Unit unit = UnitWorld;
pen = NULL; pen = NULL;
status = DllExports::GdipCreatePen1(color.GetValue(), status = DllExports::GdipCreatePen1(color.GetValue(), width, unit, &pen);
width, }
unit,
&pen);
}
Pen *Clone(VOID) Pen *Clone(VOID)
{ {
return NULL; return NULL;
} }
PenAlignment GetAlignment(VOID) PenAlignment GetAlignment(VOID)
{ {
PenAlignment penAlignment; PenAlignment penAlignment;
SetStatus(DllExports::GdipGetPenMode(pen, &penAlignment)); SetStatus(DllExports::GdipGetPenMode(pen, &penAlignment));
return penAlignment; return penAlignment;
} }
Brush *GetBrush(VOID) Brush *GetBrush(VOID)
{ {
return NULL; return NULL;
} }
Status GetColor(Color *color) Status
{ GetColor(Color *color)
ARGB argb; {
Status status = SetStatus(DllExports::GdipGetPenColor(pen, &argb)); ARGB argb;
if (color) Status status = SetStatus(DllExports::GdipGetPenColor(pen, &argb));
color->SetValue(argb); if (color)
return status; color->SetValue(argb);
} return status;
}
Status GetCompoundArray(REAL *compoundArray, INT count) Status
{ GetCompoundArray(REAL *compoundArray, INT count)
return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipGetPenCompoundArray(pen, count)); {
} return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipGetPenCompoundArray(pen, count));
}
INT GetCompoundArrayCount(VOID) INT GetCompoundArrayCount(VOID)
{ {
INT count; INT count;
SetStatus(DllExports::GdipGetPenCompoundCount(pen, &count)); SetStatus(DllExports::GdipGetPenCompoundCount(pen, &count));
return count; return count;
} }
Status GetCustomEndCap(CustomLineCap *customCap) Status
{ GetCustomEndCap(CustomLineCap *customCap)
return NotImplemented; {
} return NotImplemented;
}
Status GetCustomStartCap(CustomLineCap *customCap) Status
{ GetCustomStartCap(CustomLineCap *customCap)
return NotImplemented; {
} return NotImplemented;
}
DashCap GetDashCap(VOID) DashCap GetDashCap(VOID)
{ {
DashCap dashCap; DashCap dashCap;
SetStatus(DllExports::GdipGetPenDashCap197819(pen, &dashCap)); SetStatus(DllExports::GdipGetPenDashCap197819(pen, &dashCap));
return dashCap; return dashCap;
} }
REAL GetDashOffset(VOID) REAL GetDashOffset(VOID)
{ {
REAL offset; REAL offset;
SetStatus(DllExports::GdipGetPenDashOffset(pen, &offset)); SetStatus(DllExports::GdipGetPenDashOffset(pen, &offset));
return offset; return offset;
} }
Status GetDashPattern(REAL *dashArray, INT count) Status
{ GetDashPattern(REAL *dashArray, INT count)
return SetStatus(DllExports::GdipGetPenDashArray(pen, dashArray, count)); {
} return SetStatus(DllExports::GdipGetPenDashArray(pen, dashArray, count));
}
INT GetDashPatternCount(VOID) INT GetDashPatternCount(VOID)
{ {
INT count; INT count;
SetStatus(DllExports::GdipGetPenDashCount(pen, &count)); SetStatus(DllExports::GdipGetPenDashCount(pen, &count));
return count; return count;
} }
DashStyle GetDashStyle(VOID) DashStyle GetDashStyle(VOID)
{ {
DashStyle dashStyle; DashStyle dashStyle;
SetStatus(DllExports::GdipGetPenDashStyle(pen, &dashStyle)); SetStatus(DllExports::GdipGetPenDashStyle(pen, &dashStyle));
return dashStyle; return dashStyle;
} }
LineCap GetEndCap(VOID) LineCap GetEndCap(VOID)
{ {
LineCap endCap; LineCap endCap;
SetStatus(DllExports::GdipGetPenEndCap(pen, &endCap)); SetStatus(DllExports::GdipGetPenEndCap(pen, &endCap));
return endCap; return endCap;
} }
Status GetLastStatus(VOID) Status GetLastStatus(VOID)
{ {
return status; return status;
} }
LineJoin GetLineJoin(VOID) LineJoin GetLineJoin(VOID)
{ {
LineJoin lineJoin; LineJoin lineJoin;
SetStatus(DllExports::GdipGetPenLineJoin(pen, &lineJoin)); SetStatus(DllExports::GdipGetPenLineJoin(pen, &lineJoin));
return lineJoin; return lineJoin;
} }
REAL GetMiterLimit(VOID) REAL GetMiterLimit(VOID)
{ {
REAL miterLimit; REAL miterLimit;
SetStatus(DllExports::GdipGetPenMiterLimit(pen, &miterLimit)); SetStatus(DllExports::GdipGetPenMiterLimit(pen, &miterLimit));
return miterLimit; return miterLimit;
} }
PenType GetPenType(VOID) PenType GetPenType(VOID)
{ {
PenType type; PenType type;
SetStatus(DllExports::GdipGetPenFillType(pen, &type)); SetStatus(DllExports::GdipGetPenFillType(pen, &type));
return type; return type;
} }
LineCap GetStartCap(VOID) LineCap GetStartCap(VOID)
{ {
LineCap startCap; LineCap startCap;
SetStatus(DllExports::GdipGetPenStartCap(pen, &startCap)); SetStatus(DllExports::GdipGetPenStartCap(pen, &startCap));
return startCap; return startCap;
} }
Status GetTransform(Matrix *matrix) Status
{ GetTransform(Matrix *matrix)
return NotImplemented; {
} return NotImplemented;
}
REAL GetWidth(VOID) REAL GetWidth(VOID)
{ {
REAL width; REAL width;
SetStatus(DllExports::GdipGetPenWidth(pen, &width)); SetStatus(DllExports::GdipGetPenWidth(pen, &width));
return width; return width;
} }
Status MultiplyTransform(Matrix *matrix, MatrixOrder order) Status
{ MultiplyTransform(Matrix *matrix, MatrixOrder order)
return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipMultiplyPenTransform(pen, matrix ? matrix->matrix : NULL, order)); {
} return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipMultiplyPenTransform(pen, matrix ?
// matrix->matrix : NULL, order));
}
Status ResetTransform(VOID) Status ResetTransform(VOID)
{ {
return SetStatus(DllExports::GdipResetPenTransform(pen)); return SetStatus(DllExports::GdipResetPenTransform(pen));
} }
Status RotateTransform(REAL angle, MatrixOrder order) Status
{ RotateTransform(REAL angle, MatrixOrder order)
return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipRotatePenTransform(pen, angle, order)); {
} return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipRotatePenTransform(pen, angle,
// order));
}
Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order) Status
{ ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
return SetStatus(DllExports::GdipScalePenTransform(pen, sx, sy, order)); {
} return SetStatus(DllExports::GdipScalePenTransform(pen, sx, sy, order));
}
Status SetAlignment(PenAlignment penAlignment) Status
{ SetAlignment(PenAlignment penAlignment)
return SetStatus(DllExports::GdipSetPenMode(pen, penAlignment)); {
} return SetStatus(DllExports::GdipSetPenMode(pen, penAlignment));
}
Status SetBrush(const Brush *brush) Status
{ SetBrush(const Brush *brush)
return SetStatus(DllExports::GdipSetPenBrushFill(pen, brush ? brush->brush : NULL)); {
} return SetStatus(DllExports::GdipSetPenBrushFill(pen, brush ? brush->brush : NULL));
}
Status SetColor(const Color &color) Status
{ SetColor(const Color &color)
return SetStatus(DllExports::GdipSetPenColor(pen, color.GetValue())); {
} return SetStatus(DllExports::GdipSetPenColor(pen, color.GetValue()));
}
Status SetCompoundArray(const REAL *compoundArray, INT count) Status
{ SetCompoundArray(const REAL *compoundArray, INT count)
return SetStatus(DllExports::GdipSetPenCompoundArray(pen, compoundArray, count)); {
} return SetStatus(DllExports::GdipSetPenCompoundArray(pen, compoundArray, count));
}
Status SetCustomEndCap(const CustomLineCap *customCap) Status
{ SetCustomEndCap(const CustomLineCap *customCap)
return NotImplemented; {
} return NotImplemented;
}
Status SetCustomStartCap(const CustomLineCap *customCap) Status
{ SetCustomStartCap(const CustomLineCap *customCap)
return NotImplemented; {
} return NotImplemented;
}
Status SetDashCap(DashCap dashCap) Status
{ SetDashCap(DashCap dashCap)
return SetStatus(DllExports::GdipSetPenDashCap197819(pen, dashCap)); {
} return SetStatus(DllExports::GdipSetPenDashCap197819(pen, dashCap));
}
Status SetDashOffset(REAL dashOffset) Status
{ SetDashOffset(REAL dashOffset)
return SetStatus(DllExports::GdipSetPenDashOffset(pen, dashOffset)); {
} return SetStatus(DllExports::GdipSetPenDashOffset(pen, dashOffset));
}
Status SetDashPattern(const REAL *dashArray, INT count) Status
{ SetDashPattern(const REAL *dashArray, INT count)
return SetStatus(DllExports::GdipSetPenDashArray(pen, dashArray, count)); {
} return SetStatus(DllExports::GdipSetPenDashArray(pen, dashArray, count));
}
Status SetDashStyle(DashStyle dashStyle) Status
{ SetDashStyle(DashStyle dashStyle)
return SetStatus(DllExports::GdipSetPenDashStyle(pen, dashStyle)); {
} return SetStatus(DllExports::GdipSetPenDashStyle(pen, dashStyle));
}
Status SetEndCap(LineCap endCap) Status
{ SetEndCap(LineCap endCap)
return SetStatus(DllExports::GdipSetPenEndCap(pen, endCap)); {
} return SetStatus(DllExports::GdipSetPenEndCap(pen, endCap));
}
Status SetLineCap(LineCap startCap, LineCap endCap, DashCap dashCap) Status
{ SetLineCap(LineCap startCap, LineCap endCap, DashCap dashCap)
return SetStatus(DllExports::GdipSetPenLineCap197819(pen, startCap, endCap, dashCap)); {
} return SetStatus(DllExports::GdipSetPenLineCap197819(pen, startCap, endCap, dashCap));
}
Status SetLineJoin(LineJoin lineJoin) Status
{ SetLineJoin(LineJoin lineJoin)
return SetStatus(DllExports::GdipSetPenLineJoin(pen, lineJoin)); {
} return SetStatus(DllExports::GdipSetPenLineJoin(pen, lineJoin));
}
Status SetMiterLimit(REAL miterLimit) Status
{ SetMiterLimit(REAL miterLimit)
return SetStatus(DllExports::GdipSetPenMiterLimit(pen, miterLimit)); {
} return SetStatus(DllExports::GdipSetPenMiterLimit(pen, miterLimit));
}
Status SetStartCap(LineCap startCap) Status
{ SetStartCap(LineCap startCap)
return SetStatus(DllExports::GdipSetPenStartCap(pen, startCap)); {
} return SetStatus(DllExports::GdipSetPenStartCap(pen, startCap));
}
Status SetTransform(const Matrix *matrix) Status
{ SetTransform(const Matrix *matrix)
return SetStatus(DllExports::GdipSetPenTransform(pen, matrix ? matrix->matrix : NULL)); {
} return SetStatus(DllExports::GdipSetPenTransform(pen, matrix ? matrix->matrix : NULL));
}
Status SetWidth(REAL width) Status
{ SetWidth(REAL width)
return SetStatus(DllExports::GdipSetPenWidth(pen, width)); {
} return SetStatus(DllExports::GdipSetPenWidth(pen, width));
}
private: private:
GpPen *pen; GpPen *pen;
private: private:
mutable Status status; mutable Status status;
Status SetStatus(Status status) const Status
{ SetStatus(Status status) const
if (status == Ok) {
return status; if (status == Ok)
this->status = status; return status;
return status; this->status = status;
} return status;
}
}; };
#endif /* _GDIPLUSPEN_H */ #endif /* _GDIPLUSPEN_H */

73
sdk/include/psdk/gdipluspixelformats.h
View file

@ -22,70 +22,75 @@
typedef DWORD ARGB; typedef DWORD ARGB;
typedef INT PixelFormat; typedef INT PixelFormat;
#define PixelFormatIndexed 0x00010000 #define PixelFormatIndexed 0x00010000
#define PixelFormatGDI 0x00020000 #define PixelFormatGDI 0x00020000
#define PixelFormatAlpha 0x00040000 #define PixelFormatAlpha 0x00040000
#define PixelFormatPAlpha 0x00080000 #define PixelFormatPAlpha 0x00080000
#define PixelFormatExtended 0x00100000 #define PixelFormatExtended 0x00100000
#define PixelFormatCanonical 0x00200000 #define PixelFormatCanonical 0x00200000
#define PixelFormatUndefined 0 #define PixelFormatUndefined 0
#define PixelFormatDontCare 0 #define PixelFormatDontCare 0
#define PixelFormat1bppIndexed (1 | ( 1 << 8) | PixelFormatIndexed | PixelFormatGDI) #define PixelFormat1bppIndexed (1 | (1 << 8) | PixelFormatIndexed | PixelFormatGDI)
#define PixelFormat4bppIndexed (2 | ( 4 << 8) | PixelFormatIndexed | PixelFormatGDI) #define PixelFormat4bppIndexed (2 | (4 << 8) | PixelFormatIndexed | PixelFormatGDI)
#define PixelFormat8bppIndexed (3 | ( 8 << 8) | PixelFormatIndexed | PixelFormatGDI) #define PixelFormat8bppIndexed (3 | (8 << 8) | PixelFormatIndexed | PixelFormatGDI)
#define PixelFormat16bppGrayScale (4 | (16 << 8) | PixelFormatExtended) #define PixelFormat16bppGrayScale (4 | (16 << 8) | PixelFormatExtended)
#define PixelFormat16bppRGB555 (5 | (16 << 8) | PixelFormatGDI) #define PixelFormat16bppRGB555 (5 | (16 << 8) | PixelFormatGDI)
#define PixelFormat16bppRGB565 (6 | (16 << 8) | PixelFormatGDI) #define PixelFormat16bppRGB565 (6 | (16 << 8) | PixelFormatGDI)
#define PixelFormat16bppARGB1555 (7 | (16 << 8) | PixelFormatAlpha | PixelFormatGDI) #define PixelFormat16bppARGB1555 (7 | (16 << 8) | PixelFormatAlpha | PixelFormatGDI)
#define PixelFormat24bppRGB (8 | (24 << 8) | PixelFormatGDI) #define PixelFormat24bppRGB (8 | (24 << 8) | PixelFormatGDI)
#define PixelFormat32bppRGB (9 | (32 << 8) | PixelFormatGDI) #define PixelFormat32bppRGB (9 | (32 << 8) | PixelFormatGDI)
#define PixelFormat32bppARGB (10 | (32 << 8) | PixelFormatAlpha | PixelFormatGDI | PixelFormatCanonical) #define PixelFormat32bppARGB (10 | (32 << 8) | PixelFormatAlpha | PixelFormatGDI | PixelFormatCanonical)
#define PixelFormat32bppPARGB (11 | (32 << 8) | PixelFormatAlpha | PixelFormatPAlpha | PixelFormatGDI) #define PixelFormat32bppPARGB (11 | (32 << 8) | PixelFormatAlpha | PixelFormatPAlpha | PixelFormatGDI)
#define PixelFormat48bppRGB (12 | (48 << 8) | PixelFormatExtended) #define PixelFormat48bppRGB (12 | (48 << 8) | PixelFormatExtended)
#define PixelFormat64bppARGB (13 | (64 << 8) | PixelFormatAlpha | PixelFormatCanonical | PixelFormatExtended) #define PixelFormat64bppARGB (13 | (64 << 8) | PixelFormatAlpha | PixelFormatCanonical | PixelFormatExtended)
#define PixelFormat64bppPARGB (14 | (64 << 8) | PixelFormatAlpha | PixelFormatPAlpha | PixelFormatExtended) #define PixelFormat64bppPARGB (14 | (64 << 8) | PixelFormatAlpha | PixelFormatPAlpha | PixelFormatExtended)
#define PixelFormat32bppCMYK (15 | (32 << 8)) #define PixelFormat32bppCMYK (15 | (32 << 8))
#define PixelFormatMax 16 #define PixelFormatMax 16
static inline BOOL IsIndexedPixelFormat(PixelFormat format) static inline BOOL
IsIndexedPixelFormat(PixelFormat format)
{ {
return (format & PixelFormatIndexed) != 0; return (format & PixelFormatIndexed) != 0;
} }
static inline BOOL IsAlphaPixelFormat(PixelFormat format) static inline BOOL
IsAlphaPixelFormat(PixelFormat format)
{ {
return (format & PixelFormatAlpha) != 0; return (format & PixelFormatAlpha) != 0;
} }
static inline BOOL IsCanonicalPixelFormat(PixelFormat format) static inline BOOL
IsCanonicalPixelFormat(PixelFormat format)
{ {
return (format & PixelFormatCanonical) != 0; return (format & PixelFormatCanonical) != 0;
} }
static inline BOOL IsExtendedPixelFormat(PixelFormat format) static inline BOOL
IsExtendedPixelFormat(PixelFormat format)
{ {
return (format & PixelFormatExtended) != 0; return (format & PixelFormatExtended) != 0;
} }
static inline UINT GetPixelFormatSize(PixelFormat format) static inline UINT
GetPixelFormatSize(PixelFormat format)
{ {
return (format >> 8) & 0xff; return (format >> 8) & 0xff;
} }
enum PaletteFlags enum PaletteFlags
{ {
PaletteFlagsHasAlpha = 1, PaletteFlagsHasAlpha = 1,
PaletteFlagsGrayScale = 2, PaletteFlagsGrayScale = 2,
PaletteFlagsHalftone = 4 PaletteFlagsHalftone = 4
}; };
#ifdef __cplusplus #ifdef __cplusplus
struct ColorPalette struct ColorPalette
{ {
public: public:
UINT Flags; UINT Flags;
UINT Count; UINT Count;
ARGB Entries[1]; ARGB Entries[1];
@ -100,7 +105,7 @@ typedef struct ColorPalette
ARGB Entries[1]; ARGB Entries[1];
} ColorPalette; } ColorPalette;
#endif /* end of c typedefs */ #endif /* end of c typedefs */
typedef enum DitherType typedef enum DitherType
{ {

199
sdk/include/psdk/gdiplusstringformat.h
View file

@ -21,124 +21,133 @@
class StringFormat : public GdiplusBase class StringFormat : public GdiplusBase
{ {
public: public:
StringFormat(INT formatFlags, LANGID language) StringFormat(INT formatFlags, LANGID language)
{ {
} }
StringFormat(const StringFormat *format) StringFormat(const StringFormat *format)
{ {
} }
StringFormat *Clone(VOID) StringFormat *Clone(VOID)
{ {
return NULL; return NULL;
} }
static const StringFormat *GenericDefault(VOID) static const StringFormat *GenericDefault(VOID)
{ {
return NULL; return NULL;
} }
static const StringFormat *GenericTypographic(VOID) static const StringFormat *GenericTypographic(VOID)
{ {
return NULL; return NULL;
} }
StringAlignment GetAlignment(VOID) const StringAlignment GetAlignment(VOID) const
{ {
return StringAlignmentNear; return StringAlignmentNear;
} }
LANGID GetDigitSubstitutionLanguage(VOID) const LANGID GetDigitSubstitutionLanguage(VOID) const
{ {
return 0; return 0;
} }
StringDigitSubstitute GetDigitSubstitutionMethod(VOID) const StringDigitSubstitute GetDigitSubstitutionMethod(VOID) const
{ {
return StringDigitSubstituteNone; return StringDigitSubstituteNone;
} }
INT GetFormatFlags(VOID) const INT GetFormatFlags(VOID) const
{ {
return 0; return 0;
} }
HotkeyPrefix GetHotkeyPrefix(VOID) const HotkeyPrefix GetHotkeyPrefix(VOID) const
{ {
return HotkeyPrefixNone; return HotkeyPrefixNone;
} }
Status GetLastStatus(VOID) const Status GetLastStatus(VOID) const
{ {
return NotImplemented; return NotImplemented;
} }
StringAlignment GetLineAlignment(VOID) const StringAlignment GetLineAlignment(VOID) const
{ {
return StringAlignmentNear; return StringAlignmentNear;
} }
INT GetMeasurableCharacterRangeCount(VOID) const INT GetMeasurableCharacterRangeCount(VOID) const
{ {
return 0; return 0;
} }
INT GetTabStopCount(VOID) const INT GetTabStopCount(VOID) const
{ {
return 0; return 0;
} }
Status GetTabStops(INT count, REAL *firstTabOffset, REAL *tabStops) const Status
{ GetTabStops(INT count, REAL *firstTabOffset, REAL *tabStops) const
return NotImplemented; {
} return NotImplemented;
}
StringTrimming GetTrimming(VOID) const StringTrimming GetTrimming(VOID) const
{ {
return StringTrimmingNone; return StringTrimmingNone;
} }
Status SetAlignment(StringAlignment align) Status
{ SetAlignment(StringAlignment align)
return NotImplemented; {
} return NotImplemented;
}
Status SetDigitSubstitution(LANGID language, StringDigitSubstitute substitute) Status
{ SetDigitSubstitution(LANGID language, StringDigitSubstitute substitute)
return NotImplemented; {
} return NotImplemented;
}
Status SetFormatFlags(INT flags) Status
{ SetFormatFlags(INT flags)
return NotImplemented; {
} return NotImplemented;
}
Status SetHotkeyPrefix(HotkeyPrefix hotkeyPrefix) Status
{ SetHotkeyPrefix(HotkeyPrefix hotkeyPrefix)
return NotImplemented; {
} return NotImplemented;
}
Status SetLineAlignment(StringAlignment align) Status
{ SetLineAlignment(StringAlignment align)
return NotImplemented; {
} return NotImplemented;
}
Status SetMeasurableCharacterRanges(INT rangeCount, const CharacterRange *ranges) Status
{ SetMeasurableCharacterRanges(INT rangeCount, const CharacterRange *ranges)
return NotImplemented; {
} return NotImplemented;
}
Status SetTabStops(REAL firstTabOffset, INT count, const REAL *tabStops) Status
{ SetTabStops(REAL firstTabOffset, INT count, const REAL *tabStops)
return NotImplemented; {
} return NotImplemented;
}
Status SetTrimming(StringTrimming trimming) Status
{ SetTrimming(StringTrimming trimming)
return NotImplemented; {
} return NotImplemented;
}
}; };
#endif /* _GDIPLUSSTRINGFORMAT_H */ #endif /* _GDIPLUSSTRINGFORMAT_H */

215
sdk/include/psdk/gdiplustypes.h
View file

@ -21,137 +21,143 @@
typedef float REAL; typedef float REAL;
enum Status{ enum Status
Ok = 0, {
GenericError = 1, Ok = 0,
InvalidParameter = 2, GenericError = 1,
OutOfMemory = 3, InvalidParameter = 2,
ObjectBusy = 4, OutOfMemory = 3,
InsufficientBuffer = 5, ObjectBusy = 4,
NotImplemented = 6, InsufficientBuffer = 5,
Win32Error = 7, NotImplemented = 6,
WrongState = 8, Win32Error = 7,
Aborted = 9, WrongState = 8,
FileNotFound = 10, Aborted = 9,
ValueOverflow = 11, FileNotFound = 10,
AccessDenied = 12, ValueOverflow = 11,
UnknownImageFormat = 13, AccessDenied = 12,
FontFamilyNotFound = 14, UnknownImageFormat = 13,
FontStyleNotFound = 15, FontFamilyNotFound = 14,
NotTrueTypeFont = 16, FontStyleNotFound = 15,
UnsupportedGdiplusVersion = 17, NotTrueTypeFont = 16,
GdiplusNotInitialized = 18, UnsupportedGdiplusVersion = 17,
PropertyNotFound = 19, GdiplusNotInitialized = 18,
PropertyNotSupported = 20, PropertyNotFound = 19,
ProfileNotFound = 21 PropertyNotSupported = 20,
ProfileNotFound = 21
}; };
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C"
{
#endif #endif
typedef BOOL (CALLBACK * ImageAbort)(VOID *); typedef BOOL(CALLBACK *ImageAbort)(VOID *);
typedef ImageAbort DrawImageAbort; typedef ImageAbort DrawImageAbort;
typedef ImageAbort GetThumbnailImageAbort; typedef ImageAbort GetThumbnailImageAbort;
typedef struct GdiplusAbort GdiplusAbort; typedef struct GdiplusAbort GdiplusAbort;
typedef BOOL (CALLBACK * EnumerateMetafileProc)(EmfPlusRecordType,UINT,UINT,const BYTE*,VOID*); typedef BOOL(CALLBACK *EnumerateMetafileProc)(EmfPlusRecordType, UINT, UINT, const BYTE *, VOID *);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
class Point class Point
{ {
public: public:
Point() Point()
{ {
X = Y = 0; X = Y = 0;
} }
Point(IN const Point &pt) Point(IN const Point &pt)
{ {
X = pt.X; X = pt.X;
Y = pt.Y; Y = pt.Y;
} }
/* FIXME: missing constructor that takes a Size */ /* FIXME: missing constructor that takes a Size */
Point(IN INT x, IN INT y) Point(IN INT x, IN INT y)
{ {
X = x; X = x;
Y = y; Y = y;
} }
Point operator+(IN const Point& pt) const Point
{ operator+(IN const Point &pt) const
return Point(X + pt.X, Y + pt.Y); {
} return Point(X + pt.X, Y + pt.Y);
}
Point operator-(IN const Point& pt) const Point
{ operator-(IN const Point &pt) const
return Point(X - pt.X, Y - pt.Y); {
} return Point(X - pt.X, Y - pt.Y);
}
BOOL Equals(IN const Point& pt) BOOL
{ Equals(IN const Point &pt)
return (X == pt.X) && (Y == pt.Y); {
} return (X == pt.X) && (Y == pt.Y);
}
public: public:
INT X; INT X;
INT Y; INT Y;
}; };
class PointF class PointF
{ {
public: public:
PointF() PointF()
{ {
X = Y = 0.0f; X = Y = 0.0f;
} }
PointF(IN const PointF &pt) PointF(IN const PointF &pt)
{ {
X = pt.X; X = pt.X;
Y = pt.Y; Y = pt.Y;
} }
/* FIXME: missing constructor that takes a SizeF */ /* FIXME: missing constructor that takes a SizeF */
PointF(IN REAL x, IN REAL y) PointF(IN REAL x, IN REAL y)
{ {
X = x; X = x;
Y = y; Y = y;
} }
PointF operator+(IN const PointF& pt) const PointF
{ operator+(IN const PointF &pt) const
return PointF(X + pt.X, Y + pt.Y); {
} return PointF(X + pt.X, Y + pt.Y);
}
PointF operator-(IN const PointF& pt) const PointF
{ operator-(IN const PointF &pt) const
return PointF(X - pt.X, Y - pt.Y); {
} return PointF(X - pt.X, Y - pt.Y);
}
BOOL Equals(IN const PointF& pt) BOOL
{ Equals(IN const PointF &pt)
return (X == pt.X) && (Y == pt.Y); {
} return (X == pt.X) && (Y == pt.Y);
}
public: public:
REAL X; REAL X;
REAL Y; REAL Y;
}; };
class PathData class PathData
{ {
public: public:
PathData() PathData()
{ {
Count = 0; Count = 0;
@ -172,20 +178,21 @@ public:
} }
} }
private: private:
PathData(const PathData &); PathData(const PathData &);
PathData& operator=(const PathData &); PathData &
operator=(const PathData &);
public: public:
INT Count; INT Count;
PointF* Points; PointF *Points;
BYTE* Types; BYTE *Types;
}; };
/* FIXME: missing the methods. */ /* FIXME: missing the methods. */
class RectF class RectF
{ {
public: public:
REAL X; REAL X;
REAL Y; REAL Y;
REAL Width; REAL Width;
@ -195,7 +202,7 @@ public:
/* FIXME: missing the methods. */ /* FIXME: missing the methods. */
class Rect class Rect
{ {
public: public:
INT X; INT X;
INT Y; INT Y;
INT Width; INT Width;
@ -204,7 +211,7 @@ public:
class CharacterRange class CharacterRange
{ {
public: public:
CharacterRange() CharacterRange()
{ {
First = Length = 0; First = Length = 0;
@ -216,13 +223,15 @@ public:
Length = length; Length = length;
} }
CharacterRange& operator=(const CharacterRange& rhs) CharacterRange &
operator=(const CharacterRange &rhs)
{ {
First = rhs.First; First = rhs.First;
Length = rhs.Length; Length = rhs.Length;
return *this; return *this;
} }
public:
public:
INT First; INT First;
INT Length; INT Length;
}; };
@ -230,7 +239,7 @@ public:
/* FIXME: missing the methods. */ /* FIXME: missing the methods. */
class SizeF class SizeF
{ {
public: public:
REAL Width; REAL Width;
REAL Height; REAL Height;
}; };
@ -252,8 +261,8 @@ typedef struct PointF
typedef struct PathData typedef struct PathData
{ {
INT Count; INT Count;
PointF* Points; PointF *Points;
BYTE* Types; BYTE *Types;
} PathData; } PathData;
typedef struct RectF typedef struct RectF