Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-06-12 02:38:29 +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
#define _GDIPLUSBASE_H
class GdiplusBase {
public:
void operator delete(void *in_pVoid)
{
DllExports::GdipFree(in_pVoid);
}
class GdiplusBase
{
public:
void
operator delete(void *in_pVoid)
{
DllExports::GdipFree(in_pVoid);
}
void operator delete[](void *in_pVoid)
{
DllExports::GdipFree(in_pVoid);
}
void
operator delete[](void *in_pVoid)
{
DllExports::GdipFree(in_pVoid);
}
void *operator new(size_t in_size)
{
return DllExports::GdipAlloc(in_size);
}
void *
operator new(size_t in_size)
{
return DllExports::GdipAlloc(in_size);
}
void *operator new[](size_t in_size)
{
return DllExports::GdipAlloc(in_size);
}
void *
operator new[](size_t in_size)
{
return DllExports::GdipAlloc(in_size);
}
};
#endif /* _GDIPLUSBASE_H */

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

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

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

@ -33,7 +33,7 @@ enum ColorChannelFlags
class Color
{
public:
public:
Color(VOID)
{
Argb = 0xff000000;
@ -99,17 +99,20 @@ public:
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;
}
VOID SetFromCOLORREF(COLORREF rgb)
VOID
SetFromCOLORREF(COLORREF rgb)
{
Argb = 0xff000000 | (rgb & 0x000000ff) << 16 | (rgb & 0x0000ff00) | (rgb & 0x00ff0000) >> 16;
}
VOID SetValue(ARGB argb)
VOID
SetValue(ARGB argb)
{
Argb = argb;
}
@ -119,7 +122,7 @@ public:
return (Argb & 0x000000ff) << 16 | (Argb & 0x0000ff00) | (Argb & 0x00ff0000) >> 16;
}
protected:
protected:
ARGB Argb;
};
@ -132,6 +135,6 @@ typedef struct Color
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
{
ColorMatrixFlagsDefault = 0,
ColorMatrixFlagsSkipGrays = 1,
ColorMatrixFlagsAltGray = 2
ColorMatrixFlagsDefault = 0,
ColorMatrixFlagsSkipGrays = 1,
ColorMatrixFlagsAltGray = 2
};
enum ColorAdjustType
@ -68,6 +68,6 @@ typedef enum HistogramFormat HistogramFormat;
typedef struct ColorMatrix ColorMatrix;
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
#define _GDIPLUSEFFECTS_H
typedef struct {
float radius;
BOOL expandEdge;
typedef struct
{
float radius;
BOOL expandEdge;
} BlurParams;
typedef struct {
INT brightnessLevel;
INT contrastLevel;
typedef struct
{
INT brightnessLevel;
INT contrastLevel;
} BrightnessContrastParams;
typedef struct {
INT cyanRed;
INT magentaGreen;
INT yellowBlue;
typedef struct
{
INT cyanRed;
INT magentaGreen;
INT yellowBlue;
} ColorBalanceParams;
typedef struct {
CurveAdjustments adjustment;
CurveChannel channel;
INT adjustValue;
typedef struct
{
CurveAdjustments adjustment;
CurveChannel channel;
INT adjustValue;
} ColorCurveParams;
typedef struct {
INT hueLevel;
INT saturationLevel;
INT lightnessLevel;
typedef struct
{
INT hueLevel;
INT saturationLevel;
INT lightnessLevel;
} HueSaturationLightnessParams;
typedef struct {
INT highlight;
INT midtone;
INT shadow;
typedef struct
{
INT highlight;
INT midtone;
INT shadow;
} LevelsParams;
typedef struct {
UINT numberOfAreas;
RECT *areas;
typedef struct
{
UINT numberOfAreas;
RECT *areas;
} RedEyeCorrectionParams;
typedef struct {
REAL radius;
REAL amount;
typedef struct
{
REAL radius;
REAL amount;
} SharpenParams;
typedef struct {
INT hue;
INT amount;
typedef struct
{
INT hue;
INT amount;
} TintParams;
class Effect
{
public:
Effect(VOID)
{
}
public:
Effect(VOID)
{
}
VOID *GetAuxData(VOID) const
{
return NULL;
}
VOID *GetAuxData(VOID) const
{
return NULL;
}
INT GetAuxDataSize(VOID)
{
return 0;
}
INT GetAuxDataSize(VOID)
{
return 0;
}
Status GetParameterSize(UINT *size)
{
return NotImplemented;
}
Status
GetParameterSize(UINT *size)
{
return NotImplemented;
}
VOID UseAuxData(const BOOL useAuxDataFlag)
{
}
VOID
UseAuxData(const BOOL useAuxDataFlag)
{
}
};
class Blur : public Effect
{
public:
Blur(VOID)
{
}
public:
Blur(VOID)
{
}
Status GetParameters(UINT *size, BlurParams *parameters)
{
return NotImplemented;
}
Status
GetParameters(UINT *size, BlurParams *parameters)
{
return NotImplemented;
}
Status SetParameters(const BlurParams *parameters)
{
return NotImplemented;
}
Status
SetParameters(const BlurParams *parameters)
{
return NotImplemented;
}
};
class BrightnessContrast : public Effect
{
public:
BrightnessContrast(VOID)
{
}
public:
BrightnessContrast(VOID)
{
}
Status GetParameters(UINT *size, BrightnessContrastParams *parameters)
{
return NotImplemented;
}
Status
GetParameters(UINT *size, BrightnessContrastParams *parameters)
{
return NotImplemented;
}
Status SetParameters(const BrightnessContrastParams *parameters)
{
return NotImplemented;
}
Status
SetParameters(const BrightnessContrastParams *parameters)
{
return NotImplemented;
}
};
class ColorBalance : public Effect
{
public:
ColorBalance(VOID)
{
}
public:
ColorBalance(VOID)
{
}
Status GetParameters(UINT *size, ColorBalanceParams *parameters)
{
return NotImplemented;
}
Status
GetParameters(UINT *size, ColorBalanceParams *parameters)
{
return NotImplemented;
}
Status SetParameters(ColorBalanceParams *parameters)
{
return NotImplemented;
}
Status
SetParameters(ColorBalanceParams *parameters)
{
return NotImplemented;
}
};
class ColorCurve : public Effect
{
public:
ColorCurve(VOID)
{
}
public:
ColorCurve(VOID)
{
}
Status GetParameters(UINT *size, ColorCurveParams *parameters)
{
return NotImplemented;
}
Status
GetParameters(UINT *size, ColorCurveParams *parameters)
{
return NotImplemented;
}
Status SetParameters(const ColorCurveParams *parameters)
{
return NotImplemented;
}
Status
SetParameters(const ColorCurveParams *parameters)
{
return NotImplemented;
}
};
class ColorMatrixEffect : public Effect
{
public:
ColorMatrixEffect(VOID)
{
}
public:
ColorMatrixEffect(VOID)
{
}
Status GetParameters(UINT *size, ColorMatrix *matrix)
{
return NotImplemented;
}
Status
GetParameters(UINT *size, ColorMatrix *matrix)
{
return NotImplemented;
}
Status SetParameters(const ColorMatrix *matrix)
{
return NotImplemented;
}
Status
SetParameters(const ColorMatrix *matrix)
{
return NotImplemented;
}
};
class HueSaturationLightness : public Effect
{
public:
HueSaturationLightness(VOID)
{
}
public:
HueSaturationLightness(VOID)
{
}
Status GetParameters(UINT *size, HueSaturationLightnessParams *parameters)
{
return NotImplemented;
}
Status
GetParameters(UINT *size, HueSaturationLightnessParams *parameters)
{
return NotImplemented;
}
Status SetParameters(const HueSaturationLightnessParams *parameters)
{
return NotImplemented;
}
Status
SetParameters(const HueSaturationLightnessParams *parameters)
{
return NotImplemented;
}
};
class Levels : public Effect
{
public:
Levels(VOID)
{
}
public:
Levels(VOID)
{
}
Status GetParameters(UINT *size, LevelsParams *parameters)
{
return NotImplemented;
}
Status
GetParameters(UINT *size, LevelsParams *parameters)
{
return NotImplemented;
}
Status SetParameters(const LevelsParams *parameters)
{
return NotImplemented;
}
Status
SetParameters(const LevelsParams *parameters)
{
return NotImplemented;
}
};
class RedEyeCorrection : public Effect
{
public:
RedEyeCorrection(VOID)
{
}
public:
RedEyeCorrection(VOID)
{
}
Status GetParameters(UINT *size, RedEyeCorrectionParams *parameters)
{
return NotImplemented;
}
Status
GetParameters(UINT *size, RedEyeCorrectionParams *parameters)
{
return NotImplemented;
}
Status SetParameters(const RedEyeCorrectionParams *parameters)
{
return NotImplemented;
}
Status
SetParameters(const RedEyeCorrectionParams *parameters)
{
return NotImplemented;
}
};
class Sharpen
{
public:
Sharpen(VOID)
{
}
public:
Sharpen(VOID)
{
}
Status GetParameters(UINT *size, SharpenParams *parameters)
{
return NotImplemented;
}
Status
GetParameters(UINT *size, SharpenParams *parameters)
{
return NotImplemented;
}
Status SetParameters(const SharpenParams *parameters)
{
return NotImplemented;
}
Status
SetParameters(const SharpenParams *parameters)
{
return NotImplemented;
}
};
class Tint : Effect
{
public:
Tint(VOID)
{
}
public:
Tint(VOID)
{
}
Status GetParameters(UINT *size, TintParams *parameters)
{
return NotImplemented;
}
Status
GetParameters(UINT *size, TintParams *parameters)
{
return NotImplemented;
}
Status SetParameters(const TintParams *parameters)
{
return NotImplemented;
}
Status
SetParameters(const TintParams *parameters)
{
return NotImplemented;
}
};
#endif /* _GDIPLUSEFFECTS_H */

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

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

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
class GpGraphics {};
class GpPen {};
class GpBrush {};
class GpHatch : public GpBrush {};
class GpSolidFill : public GpBrush {};
class GpPath {};
class GpMatrix {};
class GpPathIterator {};
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 {};
class GpGraphics
{
};
class GpPen
{
};
class GpBrush
{
};
class GpHatch : public GpBrush
{
};
class GpSolidFill : public GpBrush
{
};
class GpPath
{
};
class GpMatrix
{
};
class GpPathIterator
{
};
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 */

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

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

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

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

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

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

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

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

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

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

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

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

@ -21,84 +21,108 @@
typedef struct
{
DWORD iType;
DWORD nSize;
RECTL rclBounds;
RECTL rclFrame;
DWORD dSignature;
DWORD nVersion;
DWORD nBytes;
DWORD nRecords;
WORD nHandles;
WORD sReserved;
DWORD nDescription;
DWORD offDescription;
DWORD nPalEntries;
SIZEL szlDevice;
SIZEL szlMillimeters;
DWORD iType;
DWORD nSize;
RECTL rclBounds;
RECTL rclFrame;
DWORD dSignature;
DWORD nVersion;
DWORD nBytes;
DWORD nRecords;
WORD nHandles;
WORD sReserved;
DWORD nDescription;
DWORD offDescription;
DWORD nPalEntries;
SIZEL szlDevice;
SIZEL szlMillimeters;
} ENHMETAHEADER3;
#include <pshpack2.h>
typedef struct
{
INT16 Left;
INT16 Top;
INT16 Right;
INT16 Bottom;
INT16 Left;
INT16 Top;
INT16 Right;
INT16 Bottom;
} PWMFRect16;
typedef struct
{
UINT32 Key;
INT16 Hmf;
UINT32 Key;
INT16 Hmf;
PWMFRect16 BoundingBox;
INT16 Inch;
UINT32 Reserved;
INT16 Checksum;
INT16 Inch;
UINT32 Reserved;
INT16 Checksum;
} WmfPlaceableFileHeader;
#include <poppack.h>
#define GDIP_EMFPLUSFLAGS_DISPLAY 0x00000001
#define GDIP_EMFPLUSFLAGS_DISPLAY 0x00000001
#ifdef __cplusplus
class MetafileHeader
{
public:
MetafileType Type;
UINT Size;
UINT Version;
UINT EmfPlusFlags;
REAL DpiX;
REAL DpiY;
INT X;
INT Y;
INT Width;
INT Height;
union
{
METAHEADER WmfHeader;
ENHMETAHEADER3 EmfHeader;
public:
MetafileType Type;
UINT Size;
UINT Version;
UINT EmfPlusFlags;
REAL DpiX;
REAL DpiY;
INT X;
INT Y;
INT Width;
INT Height;
union {
METAHEADER WmfHeader;
ENHMETAHEADER3 EmfHeader;
};
INT EmfPlusHeaderSize;
INT LogicalDpiX;
INT LogicalDpiY;
INT EmfPlusHeaderSize;
INT LogicalDpiX;
INT LogicalDpiY;
public:
MetafileType GetType() const { return Type; }
public:
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->Y = Y;
@ -106,34 +130,62 @@ public:
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);
}
const METAHEADER * GetWmfHeader() const
const METAHEADER *
GetWmfHeader() const
{
return IsWmf() ? &WmfHeader : NULL;
}
const ENHMETAHEADER3 * GetEmfHeader() const
const ENHMETAHEADER3 *
GetEmfHeader() const
{
return IsEmfOrEmfPlus() ? &EmfHeader : NULL;
}
@ -142,24 +194,23 @@ public:
typedef struct MetafileHeader
{
MetafileType Type;
UINT Size;
UINT Version;
UINT EmfPlusFlags;
REAL DpiX;
REAL DpiY;
INT X;
INT Y;
INT Width;
INT Height;
union
{
METAHEADER WmfHeader;
ENHMETAHEADER3 EmfHeader;
MetafileType Type;
UINT Size;
UINT Version;
UINT EmfPlusFlags;
REAL DpiX;
REAL DpiY;
INT X;
INT Y;
INT Width;
INT Height;
union {
METAHEADER WmfHeader;
ENHMETAHEADER3 EmfHeader;
} DUMMYUNIONNAME;
INT EmfPlusHeaderSize;
INT LogicalDpiX;
INT LogicalDpiY;
INT EmfPlusHeaderSize;
INT LogicalDpiX;
INT LogicalDpiY;
} MetafileHeader;
#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
{
friend class Graphics;
friend class Graphics;
public:
Pen(const Brush *brush, REAL width = 1.0f)
{
}
public:
Pen(const Brush *brush, REAL width = 1.0f)
{
}
Pen(const Color &color, REAL width = 1.0f)
{
Unit unit = UnitWorld;
pen = NULL;
status = DllExports::GdipCreatePen1(color.GetValue(),
width,
unit,
&pen);
}
Pen(const Color &color, REAL width = 1.0f)
{
Unit unit = UnitWorld;
pen = NULL;
status = DllExports::GdipCreatePen1(color.GetValue(), width, unit, &pen);
}
Pen *Clone(VOID)
{
return NULL;
}
Pen *Clone(VOID)
{
return NULL;
}
PenAlignment GetAlignment(VOID)
{
PenAlignment penAlignment;
SetStatus(DllExports::GdipGetPenMode(pen, &penAlignment));
return penAlignment;
}
PenAlignment GetAlignment(VOID)
{
PenAlignment penAlignment;
SetStatus(DllExports::GdipGetPenMode(pen, &penAlignment));
return penAlignment;
}
Brush *GetBrush(VOID)
{
return NULL;
}
Brush *GetBrush(VOID)
{
return NULL;
}
Status GetColor(Color *color)
{
ARGB argb;
Status status = SetStatus(DllExports::GdipGetPenColor(pen, &argb));
if (color)
color->SetValue(argb);
return status;
}
Status
GetColor(Color *color)
{
ARGB argb;
Status status = SetStatus(DllExports::GdipGetPenColor(pen, &argb));
if (color)
color->SetValue(argb);
return status;
}
Status GetCompoundArray(REAL *compoundArray, INT count)
{
return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipGetPenCompoundArray(pen, count));
}
Status
GetCompoundArray(REAL *compoundArray, INT count)
{
return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipGetPenCompoundArray(pen, count));
}
INT GetCompoundArrayCount(VOID)
{
INT count;
SetStatus(DllExports::GdipGetPenCompoundCount(pen, &count));
return count;
}
INT GetCompoundArrayCount(VOID)
{
INT count;
SetStatus(DllExports::GdipGetPenCompoundCount(pen, &count));
return count;
}
Status GetCustomEndCap(CustomLineCap *customCap)
{
return NotImplemented;
}
Status
GetCustomEndCap(CustomLineCap *customCap)
{
return NotImplemented;
}
Status GetCustomStartCap(CustomLineCap *customCap)
{
return NotImplemented;
}
Status
GetCustomStartCap(CustomLineCap *customCap)
{
return NotImplemented;
}
DashCap GetDashCap(VOID)
{
DashCap dashCap;
SetStatus(DllExports::GdipGetPenDashCap197819(pen, &dashCap));
return dashCap;
}
DashCap GetDashCap(VOID)
{
DashCap dashCap;
SetStatus(DllExports::GdipGetPenDashCap197819(pen, &dashCap));
return dashCap;
}
REAL GetDashOffset(VOID)
{
REAL offset;
SetStatus(DllExports::GdipGetPenDashOffset(pen, &offset));
return offset;
}
REAL GetDashOffset(VOID)
{
REAL offset;
SetStatus(DllExports::GdipGetPenDashOffset(pen, &offset));
return offset;
}
Status GetDashPattern(REAL *dashArray, INT count)
{
return SetStatus(DllExports::GdipGetPenDashArray(pen, dashArray, count));
}
Status
GetDashPattern(REAL *dashArray, INT count)
{
return SetStatus(DllExports::GdipGetPenDashArray(pen, dashArray, count));
}
INT GetDashPatternCount(VOID)
{
INT count;
SetStatus(DllExports::GdipGetPenDashCount(pen, &count));
return count;
}
INT GetDashPatternCount(VOID)
{
INT count;
SetStatus(DllExports::GdipGetPenDashCount(pen, &count));
return count;
}
DashStyle GetDashStyle(VOID)
{
DashStyle dashStyle;
SetStatus(DllExports::GdipGetPenDashStyle(pen, &dashStyle));
return dashStyle;
}
DashStyle GetDashStyle(VOID)
{
DashStyle dashStyle;
SetStatus(DllExports::GdipGetPenDashStyle(pen, &dashStyle));
return dashStyle;
}
LineCap GetEndCap(VOID)
{
LineCap endCap;
SetStatus(DllExports::GdipGetPenEndCap(pen, &endCap));
return endCap;
}
LineCap GetEndCap(VOID)
{
LineCap endCap;
SetStatus(DllExports::GdipGetPenEndCap(pen, &endCap));
return endCap;
}
Status GetLastStatus(VOID)
{
return status;
}
Status GetLastStatus(VOID)
{
return status;
}
LineJoin GetLineJoin(VOID)
{
LineJoin lineJoin;
SetStatus(DllExports::GdipGetPenLineJoin(pen, &lineJoin));
return lineJoin;
}
LineJoin GetLineJoin(VOID)
{
LineJoin lineJoin;
SetStatus(DllExports::GdipGetPenLineJoin(pen, &lineJoin));
return lineJoin;
}
REAL GetMiterLimit(VOID)
{
REAL miterLimit;
SetStatus(DllExports::GdipGetPenMiterLimit(pen, &miterLimit));
return miterLimit;
}
REAL GetMiterLimit(VOID)
{
REAL miterLimit;
SetStatus(DllExports::GdipGetPenMiterLimit(pen, &miterLimit));
return miterLimit;
}
PenType GetPenType(VOID)
{
PenType type;
SetStatus(DllExports::GdipGetPenFillType(pen, &type));
return type;
}
PenType GetPenType(VOID)
{
PenType type;
SetStatus(DllExports::GdipGetPenFillType(pen, &type));
return type;
}
LineCap GetStartCap(VOID)
{
LineCap startCap;
SetStatus(DllExports::GdipGetPenStartCap(pen, &startCap));
return startCap;
}
LineCap GetStartCap(VOID)
{
LineCap startCap;
SetStatus(DllExports::GdipGetPenStartCap(pen, &startCap));
return startCap;
}
Status GetTransform(Matrix *matrix)
{
return NotImplemented;
}
Status
GetTransform(Matrix *matrix)
{
return NotImplemented;
}
REAL GetWidth(VOID)
{
REAL width;
SetStatus(DllExports::GdipGetPenWidth(pen, &width));
return width;
}
REAL GetWidth(VOID)
{
REAL width;
SetStatus(DllExports::GdipGetPenWidth(pen, &width));
return width;
}
Status MultiplyTransform(Matrix *matrix, MatrixOrder order)
{
return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipMultiplyPenTransform(pen, matrix ? matrix->matrix : NULL, order));
}
Status
MultiplyTransform(Matrix *matrix, MatrixOrder order)
{
return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipMultiplyPenTransform(pen, matrix ?
// matrix->matrix : NULL, order));
}
Status ResetTransform(VOID)
{
return SetStatus(DllExports::GdipResetPenTransform(pen));
}
Status ResetTransform(VOID)
{
return SetStatus(DllExports::GdipResetPenTransform(pen));
}
Status RotateTransform(REAL angle, MatrixOrder order)
{
return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipRotatePenTransform(pen, angle, order));
}
Status
RotateTransform(REAL angle, MatrixOrder order)
{
return NotImplemented; // FIXME: not available: SetStatus(DllExports::GdipRotatePenTransform(pen, angle,
// order));
}
Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
{
return SetStatus(DllExports::GdipScalePenTransform(pen, sx, sy, order));
}
Status
ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
{
return SetStatus(DllExports::GdipScalePenTransform(pen, sx, sy, order));
}
Status SetAlignment(PenAlignment penAlignment)
{
return SetStatus(DllExports::GdipSetPenMode(pen, penAlignment));
}
Status
SetAlignment(PenAlignment penAlignment)
{
return SetStatus(DllExports::GdipSetPenMode(pen, penAlignment));
}
Status SetBrush(const Brush *brush)
{
return SetStatus(DllExports::GdipSetPenBrushFill(pen, brush ? brush->brush : NULL));
}
Status
SetBrush(const Brush *brush)
{
return SetStatus(DllExports::GdipSetPenBrushFill(pen, brush ? brush->brush : NULL));
}
Status SetColor(const Color &color)
{
return SetStatus(DllExports::GdipSetPenColor(pen, color.GetValue()));
}
Status
SetColor(const Color &color)
{
return SetStatus(DllExports::GdipSetPenColor(pen, color.GetValue()));
}
Status SetCompoundArray(const REAL *compoundArray, INT count)
{
return SetStatus(DllExports::GdipSetPenCompoundArray(pen, compoundArray, count));
}
Status
SetCompoundArray(const REAL *compoundArray, INT count)
{
return SetStatus(DllExports::GdipSetPenCompoundArray(pen, compoundArray, count));
}
Status SetCustomEndCap(const CustomLineCap *customCap)
{
return NotImplemented;
}
Status
SetCustomEndCap(const CustomLineCap *customCap)
{
return NotImplemented;
}
Status SetCustomStartCap(const CustomLineCap *customCap)
{
return NotImplemented;
}
Status
SetCustomStartCap(const CustomLineCap *customCap)
{
return NotImplemented;
}
Status SetDashCap(DashCap dashCap)
{
return SetStatus(DllExports::GdipSetPenDashCap197819(pen, dashCap));
}
Status
SetDashCap(DashCap dashCap)
{
return SetStatus(DllExports::GdipSetPenDashCap197819(pen, dashCap));
}
Status SetDashOffset(REAL dashOffset)
{
return SetStatus(DllExports::GdipSetPenDashOffset(pen, dashOffset));
}
Status
SetDashOffset(REAL dashOffset)
{
return SetStatus(DllExports::GdipSetPenDashOffset(pen, dashOffset));
}
Status SetDashPattern(const REAL *dashArray, INT count)
{
return SetStatus(DllExports::GdipSetPenDashArray(pen, dashArray, count));
}
Status
SetDashPattern(const REAL *dashArray, INT count)
{
return SetStatus(DllExports::GdipSetPenDashArray(pen, dashArray, count));
}
Status SetDashStyle(DashStyle dashStyle)
{
return SetStatus(DllExports::GdipSetPenDashStyle(pen, dashStyle));
}
Status
SetDashStyle(DashStyle dashStyle)
{
return SetStatus(DllExports::GdipSetPenDashStyle(pen, dashStyle));
}
Status SetEndCap(LineCap endCap)
{
return SetStatus(DllExports::GdipSetPenEndCap(pen, endCap));
}
Status
SetEndCap(LineCap endCap)
{
return SetStatus(DllExports::GdipSetPenEndCap(pen, endCap));
}
Status SetLineCap(LineCap startCap, LineCap endCap, DashCap dashCap)
{
return SetStatus(DllExports::GdipSetPenLineCap197819(pen, startCap, endCap, dashCap));
}
Status
SetLineCap(LineCap startCap, LineCap endCap, DashCap dashCap)
{
return SetStatus(DllExports::GdipSetPenLineCap197819(pen, startCap, endCap, dashCap));
}
Status SetLineJoin(LineJoin lineJoin)
{
return SetStatus(DllExports::GdipSetPenLineJoin(pen, lineJoin));
}
Status
SetLineJoin(LineJoin lineJoin)
{
return SetStatus(DllExports::GdipSetPenLineJoin(pen, lineJoin));
}
Status SetMiterLimit(REAL miterLimit)
{
return SetStatus(DllExports::GdipSetPenMiterLimit(pen, miterLimit));
}
Status
SetMiterLimit(REAL miterLimit)
{
return SetStatus(DllExports::GdipSetPenMiterLimit(pen, miterLimit));
}
Status SetStartCap(LineCap startCap)
{
return SetStatus(DllExports::GdipSetPenStartCap(pen, startCap));
}
Status
SetStartCap(LineCap startCap)
{
return SetStatus(DllExports::GdipSetPenStartCap(pen, startCap));
}
Status SetTransform(const Matrix *matrix)
{
return SetStatus(DllExports::GdipSetPenTransform(pen, matrix ? matrix->matrix : NULL));
}
Status
SetTransform(const Matrix *matrix)
{
return SetStatus(DllExports::GdipSetPenTransform(pen, matrix ? matrix->matrix : NULL));
}
Status SetWidth(REAL width)
{
return SetStatus(DllExports::GdipSetPenWidth(pen, width));
}
Status
SetWidth(REAL width)
{
return SetStatus(DllExports::GdipSetPenWidth(pen, width));
}
private:
GpPen *pen;
private:
GpPen *pen;
private:
mutable Status status;
private:
mutable Status status;
Status SetStatus(Status status) const
{
if (status == Ok)
return status;
this->status = status;
return status;
}
Status
SetStatus(Status status) const
{
if (status == Ok)
return status;
this->status = status;
return status;
}
};
#endif /* _GDIPLUSPEN_H */

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

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

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

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

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

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