// Borland C++ Builder
// Copyright (c) 1995, 2005 by Borland Software Corporation
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Advsmoothgdip.pas' rev: 10.00

#ifndef AdvsmoothgdipHPP
#define AdvsmoothgdipHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member functions
#pragma pack(push,8)
#include <System.hpp>	// Pascal unit
#include <Sysinit.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Activex.hpp>	// Pascal unit
#include <Math.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Comobj.hpp>	// Pascal unit

//-- user supplied -----------------------------------------------------------

#pragma link "gdiplus.lib"


namespace Advsmoothgdip
{
//-- type declarations -------------------------------------------------------
typedef DynamicArray<float >  TSingleDynArray;

#pragma pack(push,1)
struct ImageCodecInfo
{
	
public:
	#pragma pack(push,1)
	GUID Clsid;
	#pragma pack(pop)
	#pragma pack(push,1)
	GUID FormatID;
	#pragma pack(pop)
	WideChar *CodecName;
	WideChar *DllName;
	WideChar *FormatDescription;
	WideChar *FilenameExtension;
	WideChar *MimeType;
	unsigned Flags;
	unsigned Version;
	unsigned SigCount;
	unsigned SigSize;
	Byte *SigPattern;
	Byte *SigMask;
} ;
#pragma pack(pop)

typedef ImageCodecInfo  TImageCodecInfo;

typedef ImageCodecInfo *PImageCodecInfo;

#pragma option push -b
enum TAntiAlias { aaNone, aaClearType, aaAntiAlias };
#pragma option pop

class DELPHICLASS TGdiplusBase;
class PASCALIMPLEMENTATION TGdiplusBase : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	#pragma option push -w-inl
	/* virtual class method */ virtual System::TObject* __fastcall NewInstance() { return NewInstance(__classid(TGdiplusBase)); }
	#pragma option pop
	/*         class method */ static System::TObject* __fastcall NewInstance(TMetaClass* vmt);
	virtual void __fastcall FreeInstance(void);
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TGdiplusBase(void) : System::TObject() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TGdiplusBase(void) { }
	#pragma option pop
	
};


#pragma option push -b
enum FillMode { FillModeAlternate, FillModeWinding };
#pragma option pop

typedef FillMode TFillMode;

typedef int TPenType;

typedef int TCompositingQuality;

typedef BOOL __stdcall (*ImageAbort)(void);

typedef BOOL __stdcall (*DrawImageAbort)(void);

#pragma option push -b
enum Unit_ { UnitWorld, UnitDisplay, UnitPixel, UnitPoint, UnitInch, UnitDocument, UnitMillimeter };
#pragma option pop

typedef Unit_ TUnit;

#pragma option push -b
enum HatchStyle { HatchStyleHorizontal, HatchStyleVertical, HatchStyleForwardDiagonal, HatchStyleBackwardDiagonal, HatchStyleCross, HatchStyleDiagonalCross, HatchStyle05Percent, HatchStyle10Percent, HatchStyle20Percent, HatchStyle25Percent, HatchStyle30Percent, HatchStyle40Percent, HatchStyle50Percent, HatchStyle60Percent, HatchStyle70Percent, HatchStyle75Percent, HatchStyle80Percent, HatchStyle90Percent, HatchStyleLightDownwardDiagonal, HatchStyleLightUpwardDiagonal, HatchStyleDarkDownwardDiagonal, HatchStyleDarkUpwardDiagonal, HatchStyleWideDownwardDiagonal, HatchStyleWideUpwardDiagonal, HatchStyleLightVertical, HatchStyleLightHorizontal, HatchStyleNarrowVertical, HatchStyleNarrowHorizontal, HatchStyleDarkVertical, HatchStyleDarkHorizontal, HatchStyleDashedDownwardDiagonal, HatchStyleDashedUpwardDiagonal, HatchStyleDashedHorizontal, HatchStyleDashedVertical, HatchStyleSmallConfetti, HatchStyleLargeConfetti, HatchStyleZigZag, HatchStyleWave, HatchStyleDiagonalBrick, HatchStyleHorizontalBrick
	, HatchStyleWeave, HatchStylePlaid, HatchStyleDivot, HatchStyleDottedGrid, HatchStyleDottedDiamond, HatchStyleShingle, HatchStyleTrellis, HatchStyleSphere, HatchStyleSmallGrid, HatchStyleSmallCheckerBoard, HatchStyleLargeCheckerBoard, HatchStyleOutlinedDiamond, HatchStyleSolidDiamond, HatchStyleTotal };
#pragma option pop

typedef HatchStyle THatchStyle;

#pragma option push -b
enum DashStyle { DashStyleSolid, DashStyleDash, DashStyleDot, DashStyleDashDot, DashStyleDashDotDot, DashStyleCustom };
#pragma option pop

typedef DashStyle TDashStyle;

#pragma option push -b
enum WrapMode { WrapModeTile, WrapModeTileFlipX, WrapModeTileFlipY, WrapModeTileFlipXY, WrapModeClamp };
#pragma option pop

typedef WrapMode TWrapMode;

#pragma option push -b
enum LinearGradientMode { LinearGradientModeHorizontal, LinearGradientModeVertical, LinearGradientModeForwardDiagonal, LinearGradientModeBackwardDiagonal };
#pragma option pop

typedef LinearGradientMode TLinearGradientMode;

typedef int TLineCap;

#pragma option push -b
enum CombineMode { CombineModeReplace, CombineModeIntersect, CombineModeUnion, CombineModeXor, CombineModeExclude, CombineModeComplement };
#pragma option pop

typedef CombineMode TCombineMode;

#pragma option push -b
enum MatrixOrder { MatrixOrderPrepend, MatrixOrderAppend };
#pragma option pop

typedef MatrixOrder TMatrixOrder;

typedef float ColorMatrix[5][5];

typedef float TColorMatrix[5][5];

typedef float *PColorMatrix;

#pragma option push -b
enum ColorMatrixFlags { ColorMatrixFlagsDefault, ColorMatrixFlagsSkipGrays, ColorMatrixFlagsAltGray };
#pragma option pop

typedef ColorMatrixFlags TColorMatrixFlags;

#pragma option push -b
enum ColorChannelFlags { ColorChannelFlagsC, ColorChannelFlagsM, ColorChannelFlagsY, ColorChannelFlagsK, ColorChannelFlagsLast };
#pragma option pop

typedef ColorChannelFlags TColorChannelFlags;

#pragma option push -b
enum ColorAdjustType { ColorAdjustTypeDefault, ColorAdjustTypeBitmap, ColorAdjustTypeBrush, ColorAdjustTypePen, ColorAdjustTypeText, ColorAdjustTypeCount, ColorAdjustTypeAny };
#pragma option pop

typedef ColorAdjustType TColorAdjustType;

typedef int FontStyle;

typedef int TFontStyle;

typedef int SmoothingMode;

typedef int TSmoothingMode;

typedef int PixelOffsetMode;

typedef int TPixelOffsetMode;

#pragma option push -b
enum TextRenderingHint { TextRenderingHintSystemDefault, TextRenderingHintSingleBitPerPixelGridFit, TextRenderingHintSingleBitPerPixel, TextRenderingHintAntiAliasGridFit, TextRenderingHintAntiAlias, TextRenderingHintClearTypeGridFit };
#pragma option pop

typedef TextRenderingHint TTextRenderingHint;

#pragma option push -b
enum StringAlignment { StringAlignmentNear, StringAlignmentCenter, StringAlignmentFar };
#pragma option pop

typedef StringAlignment TStringAlignment;

typedef int TStringFormatFlags;

#pragma option push -b
enum StringTrimming { StringTrimmingNone, StringTrimmingCharacter, StringTrimmingWord, StringTrimmingEllipsisCharacter, StringTrimmingEllipsisWord, StringTrimmingEllipsisPath };
#pragma option pop

typedef StringTrimming TStringTrimming;

#pragma option push -b
enum HotkeyPrefix { HotkeyPrefixNone, HotkeyPrefixShow, HotkeyPrefixHide };
#pragma option pop

typedef HotkeyPrefix THotkeyPrefix;

#pragma option push -b
enum FlushIntention { FlushIntentionFlush, FlushIntentionSync };
#pragma option pop

typedef FlushIntention TFlushIntention;

#pragma option push -b
enum Status { Ok, GenericError, InvalidParameter, OutOfMemory, ObjectBusy, InsufficientBuffer, NotImplemented, Win32Error, WrongState, Aborted, FileNotFound, ValueOverflow, AccessDenied, UnknownImageFormat, FontFamilyNotFound, FontStyleNotFound, NotTrueTypeFont, UnsupportedGdiplusVersion, GdiplusNotInitialized, PropertyNotFound, PropertyNotSupported };
#pragma option pop

typedef Status TStatus;

struct TGPPointF;
typedef TGPPointF *PGPPointF;

#pragma pack(push,1)
struct TGPPointF
{
	
public:
	float X;
	float Y;
} ;
#pragma pack(pop)

typedef DynamicArray<TGPPointF >  TPointFDynArray;

#pragma pack(push,1)
struct TGPPoint
{
	
public:
	int X;
	int Y;
} ;
#pragma pack(pop)

typedef TGPPoint *PGPPoint;

typedef DynamicArray<TGPPoint >  TPointDynArray;

struct TGPRectF;
typedef TGPRectF *PGPRectF;

#pragma pack(push,1)
struct TGPRectF
{
	
public:
	float X;
	float Y;
	float Width;
	float Height;
} ;
#pragma pack(pop)

typedef DynamicArray<TGPRectF >  TRectFDynArray;

#pragma pack(push,1)
struct TGPRect
{
	
public:
	int X;
	int Y;
	int Width;
	int Height;
} ;
#pragma pack(pop)

typedef TGPRect *PGPRect;

typedef DynamicArray<TGPRect >  TRectDynArray;

#pragma option push -b
enum DebugEventLevel { DebugEventLevelFatal, DebugEventLevelWarning };
#pragma option pop

typedef DebugEventLevel TDebugEventLevel;

typedef void __stdcall (*DebugEventProc)(DebugEventLevel level, char * message);

typedef Status __stdcall (*NotificationHookProc)(/* out */ unsigned &token);

typedef void __stdcall (*NotificationUnhookProc)(unsigned token);

#pragma pack(push,1)
struct GdiplusStartupInput
{
	
public:
	unsigned GdiplusVersion;
	DebugEventProc DebugEventCallback;
	BOOL SuppressBackgroundThread;
	BOOL SuppressExternalCodecs;
} ;
#pragma pack(pop)

typedef GdiplusStartupInput  TGdiplusStartupInput;

typedef GdiplusStartupInput *PGdiplusStartupInput;

#pragma pack(push,1)
struct GdiplusStartupOutput
{
	
public:
	NotificationHookProc NotificationHook;
	NotificationUnhookProc NotificationUnhook;
} ;
#pragma pack(pop)

typedef GdiplusStartupOutput  TGdiplusStartupOutput;

typedef GdiplusStartupOutput *PGdiplusStartupOutput;

typedef unsigned *PARGB;

typedef unsigned *PGPColor;

typedef DynamicArray<unsigned >  TColorDynArray;

typedef int TPixelFormat;

#pragma option push -b
enum RotateFlipType { RotateNoneFlipNone, Rotate90FlipNone, Rotate180FlipNone, Rotate270FlipNone, RotateNoneFlipX, Rotate90FlipX, Rotate180FlipX, Rotate270FlipX };
#pragma option pop

typedef RotateFlipType TRotateFlipType;

typedef int TEncoderParameterValueType;

#pragma option push -b
enum EncoderValue { EncoderValueColorTypeCMYK, EncoderValueColorTypeYCCK, EncoderValueCompressionLZW, EncoderValueCompressionCCITT3, EncoderValueCompressionCCITT4, EncoderValueCompressionRle, EncoderValueCompressionNone, EncoderValueScanMethodInterlaced, EncoderValueScanMethodNonInterlaced, EncoderValueVersionGif87, EncoderValueVersionGif89, EncoderValueRenderProgressive, EncoderValueRenderNonProgressive, EncoderValueTransformRotate90, EncoderValueTransformRotate180, EncoderValueTransformRotate270, EncoderValueTransformFlipHorizontal, EncoderValueTransformFlipVertical, EncoderValueMultiFrame, EncoderValueLastFrame, EncoderValueFlush, EncoderValueFrameDimensionTime, EncoderValueFrameDimensionResolution, EncoderValueFrameDimensionPage };
#pragma option pop

typedef EncoderValue TEncoderValue;

#pragma pack(push,1)
struct EncoderParameter
{
	
public:
	#pragma pack(push,1)
	GUID Guid;
	#pragma pack(pop)
	unsigned NumberOfValues;
	unsigned Type_;
	void *Value;
} ;
#pragma pack(pop)

typedef EncoderParameter  TEncoderParameter;

typedef EncoderParameter *PEncoderParameter;

#pragma pack(push,1)
struct EncoderParameters
{
	
public:
	unsigned Count;
	EncoderParameter Parameter[1];
} ;
#pragma pack(pop)

typedef EncoderParameters  TEncoderParameters;

typedef EncoderParameters *PEncoderParameters;

#pragma pack(push,1)
struct ColorMap
{
	
public:
	unsigned oldColor;
	unsigned newColor;
} ;
#pragma pack(pop)

typedef ColorMap  TColorMap;

typedef ColorMap *PColorMap;

#pragma pack(push,1)
struct ColorPalette
{
	
public:
	unsigned Flags;
	unsigned Count;
	unsigned Entries[1];
} ;
#pragma pack(pop)

typedef ColorPalette  TColorPalette;

typedef ColorPalette *PColorPalette;

typedef void *GpGraphics;

typedef void *GpBrush;

typedef void *GpSolidFill;

typedef void *GpLineGradient;

typedef void *GpPathGradient;

typedef void *GpHatch;

typedef void *GpTexture;

typedef void *GpMatrix;

typedef void *GpImageAttributes;

typedef void *GpPen;

typedef int GpPenType;

typedef void *GpImage;

typedef void *GpBitmap;

typedef void *GpPath;

typedef void *GpRegion;

typedef void *GpFontFamily;

typedef void *GpFont;

typedef void *GpStringFormat;

typedef void *GpFontCollection;

typedef Status GpStatus;

typedef FillMode GpFillMode;

typedef WrapMode GpWrapMode;

typedef Unit_ GpUnit;

typedef TGPPointF *GpPointF;

typedef TGPPoint *GpPoint;

typedef TGPRectF *GpRectF;

typedef TGPRect *GpRect;

typedef DashStyle GpDashStyle;

typedef int GpLineCap;

typedef HatchStyle GpHatchStyle;

typedef FlushIntention GpFlushIntention;

typedef MatrixOrder GpMatrixOrder;

class DELPHICLASS TGPRegion;
class DELPHICLASS TGPGraphicsPath;
class PASCALIMPLEMENTATION TGPRegion : public TGdiplusBase 
{
	typedef TGdiplusBase inherited;
	
protected:
	void *nativeRegion;
	Status lastResult;
	Status __fastcall SetStatus(Status status);
	void __fastcall SetNativeRegion(void * nativeRegion);
	
public:
	__fastcall TGPRegion(const TGPRectF &rect)/* overload */;
	__fastcall TGPRegion(TGPGraphicsPath* path)/* overload */;
	__fastcall virtual ~TGPRegion(void);
	Status __fastcall Exclude(TGPGraphicsPath* path)/* overload */;
	Status __fastcall Union(TGPRegion* region)/* overload */;
};


typedef float TMatrixArray[6];

class DELPHICLASS TGPMatrix;
class PASCALIMPLEMENTATION TGPMatrix : public TGdiplusBase 
{
	typedef TGdiplusBase inherited;
	
protected:
	void *nativeMatrix;
	Status lastResult;
	void __fastcall SetNativeMatrix(void * nativeMatrix);
	Status __fastcall SetStatus(Status status);
	__fastcall TGPMatrix(void * nativeMatrix)/* overload */;
	
public:
	__fastcall TGPMatrix(void)/* overload */;
	__fastcall TGPMatrix(float m11, float m12, float m21, float m22, float dx, float dy)/* overload */;
	__fastcall TGPMatrix(const TGPRectF &rect, const TGPPointF &dstplg)/* overload */;
	__fastcall TGPMatrix(const TGPRect &rect, const TGPPoint &dstplg)/* overload */;
	__fastcall virtual ~TGPMatrix(void);
	TGPMatrix* __fastcall Clone(void);
	Status __fastcall GetElements(float const * m);
	Status __fastcall SetElements(float m11, float m12, float m21, float m22, float dx, float dy);
	float __fastcall OffsetX(void);
	float __fastcall OffsetY(void);
	Status __fastcall Reset(void);
	Status __fastcall Multiply(TGPMatrix* matrix, MatrixOrder order = (MatrixOrder)(0x0));
	Status __fastcall Translate(float offsetX, float offsetY, MatrixOrder order = (MatrixOrder)(0x0));
	Status __fastcall Scale(float scaleX, float scaleY, MatrixOrder order = (MatrixOrder)(0x0));
	Status __fastcall Rotate(float angle, MatrixOrder order = (MatrixOrder)(0x0));
	Status __fastcall RotateAt(float angle, const TGPPointF &center, MatrixOrder order = (MatrixOrder)(0x0));
	Status __fastcall Shear(float shearX, float shearY, MatrixOrder order = (MatrixOrder)(0x0));
	Status __fastcall Invert(void);
	Status __fastcall TransformPoints(PGPPointF pts, int count = 0x1)/* overload */;
	Status __fastcall TransformPoints(PGPPoint pts, int count = 0x1)/* overload */;
	Status __fastcall TransformVectors(PGPPointF pts, int count = 0x1)/* overload */;
	Status __fastcall TransformVectors(PGPPoint pts, int count = 0x1)/* overload */;
	BOOL __fastcall IsInvertible(void);
	BOOL __fastcall IsIdentity(void);
	BOOL __fastcall EqualMatrix(TGPMatrix* matrix);
	Status __fastcall GetLastStatus(void);
};


class DELPHICLASS TGPImageAttributes;
class PASCALIMPLEMENTATION TGPImageAttributes : public TGdiplusBase 
{
	typedef TGdiplusBase inherited;
	
protected:
	void *nativeImageAttr;
	Status lastResult;
	void __fastcall SetNativeImageAttr(void * nativeImageAttr);
	Status __fastcall SetStatus(Status status);
	__fastcall TGPImageAttributes(void * imageAttr, Status status)/* overload */;
	
public:
	__fastcall TGPImageAttributes(void)/* overload */;
	__fastcall virtual ~TGPImageAttributes(void);
	TGPImageAttributes* __fastcall Clone(void);
	Status __fastcall SetToIdentity(ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall Reset(ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall SetColorMatrix(float const * colorMatrix, ColorMatrixFlags mode = (ColorMatrixFlags)(0x0), ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall ClearColorMatrix(ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall SetColorMatrices(float const * colorMatrix, float const * grayMatrix, ColorMatrixFlags mode = (ColorMatrixFlags)(0x0), ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall ClearColorMatrices(ColorAdjustType Type_ = (ColorAdjustType)(0x0));
	Status __fastcall SetThreshold(float threshold, ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall ClearThreshold(ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall SetGamma(float gamma, ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall ClearGamma(ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall SetNoOp(ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall ClearNoOp(ColorAdjustType Type_ = (ColorAdjustType)(0x0));
	Status __fastcall SetColorKey(unsigned colorLow, unsigned colorHigh, ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall ClearColorKey(ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall SetOutputChannel(ColorChannelFlags channelFlags, ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall ClearOutputChannel(ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall SetOutputChannelColorProfile(WideString colorProfileFilename, ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall ClearOutputChannelColorProfile(ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall SetRemapTable(unsigned mapSize, PColorMap map, ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall ClearRemapTable(ColorAdjustType type_ = (ColorAdjustType)(0x0));
	Status __fastcall SetBrushRemapTable(unsigned mapSize, PColorMap map);
	Status __fastcall ClearBrushRemapTable(void);
	Status __fastcall SetWrapMode(WrapMode wrap, unsigned color = (unsigned)(0xff000000), BOOL clamp = false);
	Status __fastcall GetAdjustedPalette(PColorPalette colorPalette, ColorAdjustType colorAdjustType);
	Status __fastcall GetLastStatus(void);
};


class DELPHICLASS TGPFontFamily;
class DELPHICLASS TGPFontCollection;
class PASCALIMPLEMENTATION TGPFontFamily : public TGdiplusBase 
{
	typedef TGdiplusBase inherited;
	
protected:
	void *nativeFamily;
	Status lastResult;
	Status __fastcall SetStatus(Status status);
	
public:
	__fastcall TGPFontFamily(void * nativeOrig, Status status)/* overload */;
	__fastcall TGPFontFamily(WideString name, TGPFontCollection* fontCollection)/* overload */;
	__fastcall virtual ~TGPFontFamily(void);
	__property Status Status = {read=lastResult, nodefault};
};


class PASCALIMPLEMENTATION TGPFontCollection : public TGdiplusBase 
{
	typedef TGdiplusBase inherited;
	
protected:
	void *nativeFontCollection;
	Status lastResult;
	Status __fastcall SetStatus(Status status);
	
public:
	__fastcall TGPFontCollection(void);
	__fastcall virtual ~TGPFontCollection(void);
};


class DELPHICLASS TGPFont;
class PASCALIMPLEMENTATION TGPFont : public TGdiplusBase 
{
	typedef TGdiplusBase inherited;
	
protected:
	void *nativeFont;
	Status lastResult;
	void __fastcall SetNativeFont(void * Font);
	Status __fastcall SetStatus(Status status);
	
public:
	__fastcall TGPFont(void * font, Status status)/* overload */;
	__fastcall TGPFont(TGPFontFamily* family, float emSize, int style, Unit_ unit_)/* overload */;
	__fastcall virtual ~TGPFont(void);
	__property Status Status = {read=lastResult, nodefault};
};


class DELPHICLASS TGPBrush;
class PASCALIMPLEMENTATION TGPBrush : public TGdiplusBase 
{
	typedef TGdiplusBase inherited;
	
protected:
	void *nativeBrush;
	Status lastResult;
	void __fastcall SetNativeBrush(void * nativeBrush);
	Status __fastcall SetStatus(Status status);
	
public:
	__fastcall TGPBrush(void * nativeBrush, Status status)/* overload */;
	__fastcall TGPBrush(void)/* overload */;
	__fastcall virtual ~TGPBrush(void);
};


class DELPHICLASS TGPSolidBrush;
class PASCALIMPLEMENTATION TGPSolidBrush : public TGPBrush 
{
	typedef TGPBrush inherited;
	
public:
	__fastcall TGPSolidBrush(unsigned color)/* overload */;
	__fastcall TGPSolidBrush(void)/* overload */;
public:
	#pragma option push -w-inl
	/* TGPBrush.Destroy */ inline __fastcall virtual ~TGPSolidBrush(void) { }
	#pragma option pop
	
};


class DELPHICLASS TGPHatchBrush;
class PASCALIMPLEMENTATION TGPHatchBrush : public TGPBrush 
{
	typedef TGPBrush inherited;
	
public:
	__fastcall TGPHatchBrush(void)/* overload */;
	__fastcall TGPHatchBrush(HatchStyle hatchStyle, unsigned foreColor, unsigned backColor)/* overload */;
	HatchStyle __fastcall GetHatchStyle(void);
	Status __fastcall GetForegroundColor(/* out */ unsigned &color);
	Status __fastcall GetBackgroundColor(/* out */ unsigned &color);
public:
	#pragma option push -w-inl
	/* TGPBrush.Destroy */ inline __fastcall virtual ~TGPHatchBrush(void) { }
	#pragma option pop
	
};


class DELPHICLASS TGPTextureBrush;
class DELPHICLASS TGPImage;
class PASCALIMPLEMENTATION TGPTextureBrush : public TGPBrush 
{
	typedef TGPBrush inherited;
	
public:
	__fastcall TGPTextureBrush(TGPImage* image, WrapMode wrapMode)/* overload */;
	__fastcall TGPTextureBrush(TGPImage* image, WrapMode wrapMode, const TGPRectF &dstRect)/* overload */;
	__fastcall TGPTextureBrush(TGPImage* image, const TGPRectF &dstRect, TGPImageAttributes* imageAttributes)/* overload */;
	__fastcall TGPTextureBrush(TGPImage* image, const TGPRect &dstRect, TGPImageAttributes* imageAttributes)/* overload */;
	__fastcall TGPTextureBrush(TGPImage* image, WrapMode wrapMode, const TGPRect &dstRect)/* overload */;
	__fastcall TGPTextureBrush(TGPImage* image, WrapMode wrapMode, float dstX, float dstY, float dstWidth, float dstHeight)/* overload */;
	__fastcall TGPTextureBrush(TGPImage* image, WrapMode wrapMode, int dstX, int dstY, int dstWidth, int dstHeight)/* overload */;
	__fastcall TGPTextureBrush(void)/* overload */;
	Status __fastcall SetTransform(TGPMatrix* matrix);
	Status __fastcall GetTransform(TGPMatrix* matrix);
	Status __fastcall ResetTransform(void);
	Status __fastcall MultiplyTransform(TGPMatrix* matrix, MatrixOrder order = (MatrixOrder)(0x0));
	Status __fastcall TranslateTransform(float dx, float dy, MatrixOrder order = (MatrixOrder)(0x0));
	Status __fastcall ScaleTransform(float sx, float sy, MatrixOrder order = (MatrixOrder)(0x0));
	Status __fastcall RotateTransform(float angle, MatrixOrder order = (MatrixOrder)(0x0));
	Status __fastcall SetWrapMode(WrapMode wrapMode);
	WrapMode __fastcall GetWrapMode(void);
	TGPImage* __fastcall GetImage(void);
public:
	#pragma option push -w-inl
	/* TGPBrush.Destroy */ inline __fastcall virtual ~TGPTextureBrush(void) { }
	#pragma option pop
	
};


class DELPHICLASS TGPLinearGradientBrush;
class PASCALIMPLEMENTATION TGPLinearGradientBrush : public TGPBrush 
{
	typedef TGPBrush inherited;
	
public:
	__fastcall TGPLinearGradientBrush(const TGPPointF &point1, const TGPPointF &point2, unsigned color1, unsigned color2)/* overload */;
	__fastcall TGPLinearGradientBrush(const TGPPoint &point1, const TGPPoint &point2, unsigned color1, unsigned color2)/* overload */;
	__fastcall TGPLinearGradientBrush(const TGPRectF &rect, unsigned color1, unsigned color2, LinearGradientMode mode)/* overload */;
	__fastcall TGPLinearGradientBrush(const TGPRect &rect, unsigned color1, unsigned color2, LinearGradientMode mode)/* overload */;
	__fastcall TGPLinearGradientBrush(const TGPRectF &rect, unsigned color1, unsigned color2, float angle, BOOL isAngleScalable)/* overload */;
	__fastcall TGPLinearGradientBrush(const TGPRect &rect, unsigned color1, unsigned color2, float angle, BOOL isAngleScalable)/* overload */;
	Status __fastcall SetGammaCorrection(BOOL useGammaCorrection);
	BOOL __fastcall GetGammaCorrection(void);
	int __fastcall GetBlendCount(void);
	Status __fastcall SetBlend(Windows::PSingle blendFactors, Windows::PSingle blendPositions, int count);
	Status __fastcall GetBlend(Windows::PSingle blendFactors, Windows::PSingle blendPositions, int count);
	int __fastcall GetInterpolationColorCount(void);
	Status __fastcall SetInterpolationColors(PGPColor presetColors, Windows::PSingle blendPositions, int count);
	Status __fastcall GetInterpolationColors(PGPColor presetColors, Windows::PSingle blendPositions, int count);
	Status __fastcall SetBlendBellShape(float focus, float scale = 1.000000E+00);
	Status __fastcall SetBlendTriangularShape(float focus, float scale = 1.000000E+00);
public:
	#pragma option push -w-inl
	/* TGPBrush.Destroy */ inline __fastcall virtual ~TGPLinearGradientBrush(void) { }
	#pragma option pop
	
};


class DELPHICLASS TGPPen;
class PASCALIMPLEMENTATION TGPPen : public TGdiplusBase 
{
	typedef TGdiplusBase inherited;
	
protected:
	void *nativePen;
	Status lastResult;
	void __fastcall SetNativePen(void * nativePen);
	Status __fastcall SetStatus(Status status);
	__fastcall TGPPen(void * nativePen, Status status)/* overload */;
	
public:
	__fastcall TGPPen(unsigned color, float width)/* overload */;
	__fastcall TGPPen(TGPBrush* brush, float width)/* overload */;
	__fastcall virtual ~TGPPen(void);
	TGPBrush* __fastcall GetBrush(void);
	DashStyle __fastcall GetDashStyle(void);
	Status __fastcall SetDashStyle(DashStyle dashStyle);
	Status __fastcall SetEndCap(int endCap);
	int __fastcall GetPenType(void);
};


class DELPHICLASS TGPStringFormat;
class PASCALIMPLEMENTATION TGPStringFormat : public TGdiplusBase 
{
	typedef TGdiplusBase inherited;
	
protected:
	void *nativeFormat;
	Status lastError;
	Status __fastcall SetStatus(Status newStatus);
	void __fastcall Assign(TGPStringFormat* source);
	__fastcall TGPStringFormat(void * clonedStringFormat, Status status)/* overload */;
	
public:
	__fastcall TGPStringFormat(int formatFlags, Word language)/* overload */;
	__fastcall TGPStringFormat(TGPStringFormat* format)/* overload */;
	__fastcall virtual ~TGPStringFormat(void);
	Status __fastcall SetAlignment(StringAlignment align);
	StringAlignment __fastcall GetAlignment(void);
	Status __fastcall SetLineAlignment(StringAlignment align);
	StringAlignment __fastcall GetLineAlignment(void);
	Status __fastcall SetTrimming(StringTrimming trimming);
	StringTrimming __fastcall GetTrimming(void);
	Status __fastcall SetHotkeyPrefix(HotkeyPrefix hotkeyPrefix);
	HotkeyPrefix __fastcall GetHotkeyPrefix(void);
};


class PASCALIMPLEMENTATION TGPGraphicsPath : public TGdiplusBase 
{
	typedef TGdiplusBase inherited;
	
protected:
	void *nativePath;
	Status lastResult;
	void __fastcall SetNativePath(void * nativePath);
	Status __fastcall SetStatus(Status status);
	
public:
	__fastcall TGPGraphicsPath(void * nativePath)/* overload */;
	__fastcall TGPGraphicsPath(FillMode fillMode)/* overload */;
	__fastcall virtual ~TGPGraphicsPath(void);
	Status __fastcall CloseFigure(void);
	Status __fastcall AddLine(const TGPPointF &pt1, const TGPPointF &pt2)/* overload */;
	Status __fastcall AddLine(float x1, float y1, float x2, float y2)/* overload */;
	Status __fastcall AddLines(PGPPoint points, int count)/* overload */;
	Status __fastcall AddArc(const TGPRectF &rect, float startAngle, float sweepAngle)/* overload */;
	Status __fastcall AddArc(float x, float y, float width, float height, float startAngle, float sweepAngle)/* overload */;
	Status __fastcall AddEllipse(const TGPRectF &rect)/* overload */;
	Status __fastcall AddEllipse(float x, float y, float width, float height)/* overload */;
	Status __fastcall AddRectangle(const TGPRectF &rect)/* overload */;
	Status __fastcall AddRectangle(const TGPRect &rect)/* overload */;
	Status __fastcall AddPie(const TGPRectF &rect, float startAngle, float sweepAngle)/* overload */;
	Status __fastcall AddPie(float x, float y, float width, float height, float startAngle, float sweepAngle)/* overload */;
	Status __fastcall AddPolygon(PGPPointF points, int count)/* overload */;
	Status __fastcall AddPolygon(PGPPoint points, int count)/* overload */;
	Status __fastcall AddCurve(PGPPointF points, int count)/* overload */;
	Status __fastcall AddCurve(PGPPoint points, int count)/* overload */;
	Status __fastcall AddCurve(PGPPoint points, int count, float tension)/* overload */;
	Status __fastcall AddBezier(const TGPPoint &pt1, const TGPPoint &pt2, const TGPPoint &pt3, const TGPPoint &pt4)/* overload */;
	Status __fastcall AddBezier(const TGPPointF &pt1, const TGPPointF &pt2, const TGPPointF &pt3, const TGPPointF &pt4)/* overload */;
	Status __fastcall AddBezier(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)/* overload */;
};


class DELPHICLASS TGPPathGradientBrush;
class PASCALIMPLEMENTATION TGPPathGradientBrush : public TGPBrush 
{
	typedef TGPBrush inherited;
	
public:
	__fastcall TGPPathGradientBrush(PGPPointF points, int count, WrapMode wrapMode)/* overload */;
	__fastcall TGPPathGradientBrush(PGPPoint points, int count, WrapMode wrapMode)/* overload */;
	__fastcall TGPPathGradientBrush(TGPGraphicsPath* path)/* overload */;
	Status __fastcall GetCenterColor(/* out */ unsigned &Color);
	Status __fastcall SetCenterColor(unsigned color);
	int __fastcall GetPointCount(void);
	Status __fastcall GetSurroundColors(PARGB colors, int &count);
	Status __fastcall SetSurroundColors(PARGB colors, int &count);
	Status __fastcall GetCenterPoint(/* out */ TGPPointF &point)/* overload */;
	Status __fastcall GetCenterPoint(/* out */ TGPPoint &point)/* overload */;
	Status __fastcall SetCenterPoint(const TGPPointF &point)/* overload */;
	Status __fastcall SetCenterPoint(const TGPPoint &point)/* overload */;
	Status __fastcall SetGammaCorrection(BOOL useGammaCorrection)/* overload */;
	BOOL __fastcall GetGammaCorrection(void)/* overload */;
	Status __fastcall SetWrapMode(WrapMode wrapMode);
	WrapMode __fastcall GetWrapMode(void);
	int __fastcall GetBlendCount(void);
	Status __fastcall GetBlend(Windows::PSingle blendFactors, Windows::PSingle blendPositions, int count);
	Status __fastcall SetBlend(Windows::PSingle blendFactors, Windows::PSingle blendPositions, int count);
	int __fastcall GetInterpolationColorCount(void);
	Status __fastcall SetInterpolationColors(PARGB presetColors, Windows::PSingle blendPositions, int count);
	Status __fastcall GetInterpolationColors(PARGB presetColors, Windows::PSingle blendPositions, int count);
	Status __fastcall SetBlendBellShape(float focus, float scale = 1.000000E+00);
	Status __fastcall SetBlendTriangularShape(float focus, float scale = 1.000000E+00);
public:
	#pragma option push -w-inl
	/* TGPBrush.Destroy */ inline __fastcall virtual ~TGPPathGradientBrush(void) { }
	#pragma option pop
	
};


#pragma option push -b
enum TGPImageFormat { ifUndefined, ifMemoryBMP, ifBMP, ifEMF, ifWMF, ifJPEG, ifPNG, ifGIF, ifTIFF, ifEXIF, ifIcon };
#pragma option pop

class PASCALIMPLEMENTATION TGPImage : public TGdiplusBase 
{
	typedef TGdiplusBase inherited;
	
protected:
	void *nativeImage;
	Status lastResult;
	Status loadStatus;
	void __fastcall SetNativeImage(void * nativeImage);
	Status __fastcall SetStatus(Status status);
	
public:
	__fastcall TGPImage(void * nativeImage, Status status)/* overload */;
	__fastcall TGPImage(WideString filename, BOOL useEmbeddedColorManagement)/* overload */;
	__fastcall TGPImage(_di_IStream stream, BOOL useEmbeddedColorManagement)/* overload */;
	Status __fastcall SaveAdd(TGPImage* newImage, PEncoderParameters encoderParams)/* overload */;
	Status __fastcall Save(WideString filename, const GUID &clsidEncoder, PEncoderParameters encoderParams = (void *)(0x0))/* overload */;
	Status __fastcall Save(_di_IStream stream, const GUID &clsidEncoder, PEncoderParameters encoderParams = (void *)(0x0))/* overload */;
	__fastcall virtual ~TGPImage(void);
	TGPImageFormat __fastcall GetFormat(void);
	int __fastcall GetPixelFormat(void);
	int __fastcall GetPixelDepth(void);
	bool __fastcall HasPalette(void);
	bool __fastcall HasAlphaChannel(void);
	unsigned __fastcall GetWidth(void);
	unsigned __fastcall GetHeight(void);
	Status __fastcall RotateFlip(RotateFlipType rotateFlipType);
	__property unsigned Width = {read=GetWidth, nodefault};
	__property unsigned Height = {read=GetHeight, nodefault};
};


class DELPHICLASS TGPBitmap;
class PASCALIMPLEMENTATION TGPBitmap : public TGPImage 
{
	typedef TGPImage inherited;
	
protected:
	__fastcall TGPBitmap(void * nativeBitmap)/* overload */;
	
public:
	__fastcall TGPBitmap(_di_IStream stream, BOOL useEmbeddedColorManagement)/* overload */;
	__fastcall TGPBitmap(int width, int height, int format)/* overload */;
	TGPBitmap* __fastcall FromStream(_di_IStream stream, BOOL useEmbeddedColorManagement = false);
	Status __fastcall GetPixel(int x, int y, /* out */ unsigned &color);
	Status __fastcall SetPixel(int x, int y, unsigned color);
	Status __fastcall GetHBITMAP(unsigned colorBackground, /* out */ HBITMAP &hbmReturn);
public:
	#pragma option push -w-inl
	/* TGPImage.Destroy */ inline __fastcall virtual ~TGPBitmap(void) { }
	#pragma option pop
	
};


class DELPHICLASS TGPGraphics;
class PASCALIMPLEMENTATION TGPGraphics : public TGdiplusBase 
{
	typedef TGdiplusBase inherited;
	
protected:
	void *nativeGraphics;
	Status lastResult;
	void __fastcall SetNativeGraphics(void * graphics);
	Status __fastcall SetStatus(Status status);
	void * __fastcall GetNativeGraphics(void);
	
public:
	__fastcall TGPGraphics(HDC hdc)/* overload */;
	__fastcall TGPGraphics(TGPImage* image)/* overload */;
	__fastcall virtual ~TGPGraphics(void);
	void __fastcall Flush(FlushIntention intention = (FlushIntention)(0x0));
	TGPGraphics* __fastcall FromImage(TGPImage* image);
	HDC __fastcall GetHDC(void);
	void __fastcall ReleaseHDC(HDC hdc);
	Status __fastcall SetCompositingQuality(int compositingQuality);
	int __fastcall GetCompositingQuality(void);
	Status __fastcall SetTextRenderingHint(TextRenderingHint newMode);
	TextRenderingHint __fastcall GetTextRenderingHint(void);
	int __fastcall GetSmoothingMode(void);
	Status __fastcall SetSmoothingMode(int smoothingMode);
	int __fastcall GetPixelOffsetMode(void);
	Status __fastcall SetPixelOffsetMode(int pixelOffsetMode);
	Status __fastcall DrawPath(TGPPen* pen, TGPGraphicsPath* path);
	Status __fastcall FillRectangle(TGPBrush* brush, const TGPRectF &rect)/* overload */;
	Status __fastcall FillRectangle(TGPBrush* brush, float x, float y, float width, float height)/* overload */;
	Status __fastcall FillRectangle(TGPBrush* brush, const TGPRect &rect)/* overload */;
	Status __fastcall FillRectangle(TGPBrush* brush, int x, int y, int width, int height)/* overload */;
	Status __fastcall DrawEllipse(TGPPen* pen, const TGPRectF &rect)/* overload */;
	Status __fastcall DrawEllipse(TGPPen* pen, float x, float y, float width, float height)/* overload */;
	Status __fastcall DrawEllipse(TGPPen* pen, const TGPRect &rect)/* overload */;
	Status __fastcall DrawEllipse(TGPPen* pen, int x, int y, int width, int height)/* overload */;
	Status __fastcall DrawLine(TGPPen* pen, float x1, float y1, float x2, float y2)/* overload */;
	Status __fastcall DrawLine(TGPPen* pen, int x1, int y1, int x2, int y2)/* overload */;
	Status __fastcall DrawArc(TGPPen* pen, float x, float y, float width, float height, float startAngle, float sweepAngle)/* overload */;
	Status __fastcall DrawArc(TGPPen* pen, const TGPRectF &rect, float startAngle, float sweepAngle)/* overload */;
	Status __fastcall DrawArc(TGPPen* pen, int x, int y, int width, int height, float startAngle, float sweepAngle)/* overload */;
	Status __fastcall DrawArc(TGPPen* pen, const TGPRect &rect, float startAngle, float sweepAngle)/* overload */;
	Status __fastcall FillPolygon(TGPBrush* brush, PGPPointF points, int count)/* overload */;
	Status __fastcall FillPolygon(TGPBrush* brush, PGPPointF points, int count, FillMode fillMode)/* overload */;
	Status __fastcall FillPolygon(TGPBrush* brush, PGPPoint points, int count)/* overload */;
	Status __fastcall FillPolygon(TGPBrush* brush, PGPPoint points, int count, FillMode fillMode)/* overload */;
	Status __fastcall FillEllipse(TGPBrush* brush, const TGPRectF &rect)/* overload */;
	Status __fastcall FillEllipse(TGPBrush* brush, float x, float y, float width, float height)/* overload */;
	Status __fastcall FillEllipse(TGPBrush* brush, const TGPRect &rect)/* overload */;
	Status __fastcall FillEllipse(TGPBrush* brush, int x, int y, int width, int height)/* overload */;
	TGPFont* __fastcall MakeFont(Graphics::TFont* AFont);
	int __fastcall TextHeight(AnsiString string_, Graphics::TFont* font);
	int __fastcall TextWidth(AnsiString string_, Graphics::TFont* font);
	int __fastcall DrawText(AnsiString string_, int len, Types::TRect &rect, Graphics::TFont* font, unsigned style, Graphics::TColor bkColor = (Graphics::TColor)(0x1fffffff));
	Status __fastcall DrawString(AnsiString string_, int length, TGPFont* font, const TGPRectF &layoutRect, TGPStringFormat* stringFormat, TGPBrush* brush)/* overload */;
	Status __fastcall DrawString(WideString string_, int length, TGPFont* font, const TGPRectF &layoutRect, TGPStringFormat* stringFormat, TGPBrush* brush)/* overload */;
	Status __fastcall DrawString(WideString string_, int length, TGPFont* font, const TGPPointF &origin, TGPBrush* brush)/* overload */;
	Status __fastcall DrawString(WideString string_, int length, TGPFont* font, const TGPPointF &origin, TGPStringFormat* stringFormat, TGPBrush* brush)/* overload */;
	Status __fastcall MeasureString(WideString string_, int length, TGPFont* font, const TGPRectF &layoutRect, TGPStringFormat* stringFormat, /* out */ TGPRectF &boundingBox, System::PInteger codepointsFitted = (void *)(0x0), System::PInteger linesFilled = (void *)(0x0))/* overload */;
	Status __fastcall MeasureString(WideString string_, int length, TGPFont* font, const TGPPointF &origin, TGPStringFormat* stringFormat, /* out */ TGPRectF &boundingBox)/* overload */;
	Status __fastcall MeasureString(WideString string_, int length, TGPFont* font, const TGPRectF &layoutRect, /* out */ TGPRectF &boundingBox)/* overload */;
	Status __fastcall MeasureString(WideString string_, int length, TGPFont* font, const TGPPointF &origin, /* out */ TGPRectF &boundingBox)/* overload */;
	Status __fastcall GetLastStatus(void);
	Status __fastcall DrawRectangle(TGPPen* pen, const TGPRectF &rect)/* overload */;
	Status __fastcall DrawRectangle(TGPPen* pen, float x, float y, float width, float height)/* overload */;
	Status __fastcall DrawImage(TGPImage* image, const TGPPointF &point)/* overload */;
	Status __fastcall DrawImage(TGPImage* image, float x, float y)/* overload */;
	Status __fastcall DrawImage(TGPImage* image, const TGPRectF &rect)/* overload */;
	Status __fastcall DrawImage(TGPImage* image, float x, float y, float width, float height)/* overload */;
	Status __fastcall DrawImage(TGPImage* image, const TGPPoint &point)/* overload */;
	Status __fastcall DrawImage(TGPImage* image, int x, int y)/* overload */;
	Status __fastcall DrawImage(TGPImage* image, const TGPRect &rect)/* overload */;
	Status __fastcall DrawImage(TGPImage* image, int x, int y, int width, int height)/* overload */;
	Status __fastcall DrawImageRect(TGPImage* image, int x, int y, int w, int h)/* overload */;
	Status __fastcall DrawImageRect(TGPImage* image, const TGPRectF &ARect)/* overload */;
	Status __fastcall DrawImage(TGPImage* image, const TGPRectF &destRect, float srcx, float srcy, float srcwidth, float srcheight, Unit_ srcUnit, TGPImageAttributes* imageAttributes = (TGPImageAttributes*)(0x0), ImageAbort callback = 0x0, void * callbackData = (void *)(0x0))/* overload */;
	Status __fastcall DrawImage(TGPImage* image, PGPPointF destPoints, int count, float srcx, float srcy, float srcwidth, float srcheight, Unit_ srcUnit, TGPImageAttributes* imageAttributes = (TGPImageAttributes*)(0x0), ImageAbort callback = 0x0, void * callbackData = (void *)(0x0))/* overload */;
	Status __fastcall DrawImage(TGPImage* image, const TGPRect &destRect, int srcx, int srcy, int srcwidth, int srcheight, Unit_ srcUnit, TGPImageAttributes* imageAttributes = (TGPImageAttributes*)(0x0), ImageAbort callback = 0x0, void * callbackData = (void *)(0x0))/* overload */;
	Status __fastcall DrawImage(TGPImage* image, PGPPoint destPoints, int count, int srcx, int srcy, int srcwidth, int srcheight, Unit_ srcUnit, TGPImageAttributes* imageAttributes = (TGPImageAttributes*)(0x0), ImageAbort callback = 0x0, void * callbackData = (void *)(0x0))/* overload */;
	Status __fastcall FillPath(TGPBrush* brush, TGPGraphicsPath* path);
	Status __fastcall ExcludeClip(const TGPRectF &rect)/* overload */;
	Status __fastcall ExcludeClip(TGPRegion* region)/* overload */;
	Status __fastcall SetClip(TGPRegion* region, CombineMode combineMode = (CombineMode)(0x0));
	Status __fastcall ResetClip(void);
};


class DELPHICLASS TAdvGDIPPicture;
class PASCALIMPLEMENTATION TAdvGDIPPicture : public Graphics::TGraphic 
{
	typedef Graphics::TGraphic inherited;
	
private:
	Classes::TMemoryStream* FDatastream;
	bool FIsEmpty;
	int FWidth;
	int FHeight;
	bool FDoubleBuffered;
	Classes::TNotifyEvent FOnClear;
	Graphics::TTransparentMode FBitmapTransparentMode;
	Graphics::TColor FBitmapTransparentColor;
	AnsiString FID;
	int FPixelDepth;
	bool FHasAlpha;
	bool FHasPalette;
	int FPixelFormat;
	
protected:
	virtual bool __fastcall GetEmpty(void);
	virtual int __fastcall GetHeight(void);
	virtual int __fastcall GetWidth(void);
	virtual void __fastcall SetHeight(int Value);
	virtual void __fastcall SetWidth(int Value);
	virtual void __fastcall ReadData(Classes::TStream* Stream);
	virtual void __fastcall WriteData(Classes::TStream* Stream);
	
public:
	__fastcall virtual TAdvGDIPPicture(void);
	__fastcall virtual ~TAdvGDIPPicture(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	bool __fastcall GetImageSizes(void);
	bool __fastcall GetImageSizesFromFileName(AnsiString FileName);
	virtual void __fastcall Draw(Graphics::TCanvas* ACanvas, const Types::TRect &Rect);
	void __fastcall GDIPDraw(TGPGraphics* Graphics, const Types::TRect &Rect)/* overload */;
	void __fastcall FillRect(TGPGraphics* graphics, const TGPRectF &R);
	void __fastcall FillPath(TGPGraphics* graphics, TGPGraphicsPath* Path);
	virtual void __fastcall LoadFromFile(const AnsiString FileName);
	virtual void __fastcall LoadFromStream(Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(Classes::TStream* Stream);
	void __fastcall LoadFromResourceName(unsigned Instance, const AnsiString ResName);
	void __fastcall LoadFromResourceID(unsigned Instance, int ResID);
	void __fastcall LoadFromURL(AnsiString url);
	virtual void __fastcall LoadFromClipboardFormat(Word AFormat, unsigned AData, HPALETTE APalette);
	virtual void __fastcall SaveToClipboardFormat(Word &AFormat, unsigned &AData, HPALETTE &APalette);
	__property bool DoubleBuffered = {read=FDoubleBuffered, write=FDoubleBuffered, nodefault};
	__property Graphics::TColor TransparentColor = {read=FBitmapTransparentColor, write=FBitmapTransparentColor, nodefault};
	__property Graphics::TTransparentMode TransparentMode = {read=FBitmapTransparentMode, write=FBitmapTransparentMode, nodefault};
	__property AnsiString ID = {read=FID, write=FID};
	__property int PixelFormat = {read=FPixelFormat, nodefault};
	__property int PixelDepth = {read=FPixelDepth, nodefault};
	__property bool HasAlpha = {read=FHasAlpha, nodefault};
	__property bool HasPalette = {read=FHasPalette, nodefault};
	
__published:
	__property Classes::TNotifyEvent OnClear = {read=FOnClear, write=FOnClear};
};


#pragma option push -b
enum TAdvGradientType { gtSolid, gtRadial, gtVertical, gtHorizontal, gtForwardDiagonal, gtBackwardDiagonal, gtAngle, gtHatch, gtPath, gtTexture, gtNone };
#pragma option pop

struct TGDIPFillParameters
{
	
public:
	TGPGraphics* Graphics;
	TGPGraphicsPath* Path;
	bool Fillpath;
	#pragma pack(push,1)
	TGPRectF R;
	#pragma pack(pop)
	TAdvGradientType GT;
	Graphics::TColor ColorFrom;
	Graphics::TColor ColorTo;
	int OpacityFrom;
	int OpacityTo;
	HatchStyle HatchStyle;
	int Angle;
	TAdvGDIPPicture* Image;
	Graphics::TColor BorderColor;
	int BorderWidth;
	DashStyle BorderStyle;
	bool Mirror;
} ;

//-- var, const, procedure ---------------------------------------------------
extern PACKAGE int GlowSpeed;
#define WINGDIPDLL "gdiplus.dll"
static const unsigned aclAliceBlue = 0xfff0f8ff;
static const unsigned aclAntiqueWhite = 0xfffaebd7;
static const unsigned aclAqua = 0xff00ffff;
static const unsigned aclAquamarine = 0xff7fffd4;
static const unsigned aclAzure = 0xfff0ffff;
static const unsigned aclBeige = 0xfff5f5dc;
static const unsigned aclBisque = 0xffffe4c4;
static const unsigned aclBlack = 0xff000000;
static const unsigned aclBlanchedAlmond = 0xffffebcd;
static const unsigned aclBlue = 0xff0000ff;
static const unsigned aclBlueViolet = 0xff8a2be2;
static const unsigned aclBrown = 0xffa52a2a;
static const unsigned aclBurlyWood = 0xffdeb887;
static const unsigned aclCadetBlue = 0xff5f9ea0;
static const unsigned aclChartreuse = 0xff7fff00;
static const unsigned aclChocolate = 0xffd2691e;
static const unsigned aclCoral = 0xffff7f50;
static const unsigned aclCornflowerBlue = 0xff6495ed;
static const unsigned aclCornsilk = 0xfffff8dc;
static const unsigned aclCrimson = 0xffdc143c;
static const unsigned aclCyan = 0xff00ffff;
static const unsigned aclDarkBlue = 0xff00008b;
static const unsigned aclDarkCyan = 0xff008b8b;
static const unsigned aclDarkGoldenrod = 0xffb8860b;
static const unsigned aclDarkGray = 0xffa9a9a9;
static const unsigned aclDarkGreen = 0xff006400;
static const unsigned aclDarkKhaki = 0xffbdb76b;
static const unsigned aclDarkMagenta = 0xff8b008b;
static const unsigned aclDarkOliveGreen = 0xff556b2f;
static const unsigned aclDarkOrange = 0xffff8c00;
static const unsigned aclDarkOrchid = 0xff9932cc;
static const unsigned aclDarkRed = 0xff8b0000;
static const unsigned aclDarkSalmon = 0xffe9967a;
static const unsigned aclDarkSeaGreen = 0xff8fbc8b;
static const unsigned aclDarkSlateBlue = 0xff483d8b;
static const unsigned aclDarkSlateGray = 0xff2f4f4f;
static const unsigned aclDarkTurquoise = 0xff00ced1;
static const unsigned aclDarkViolet = 0xff9400d3;
static const unsigned aclDeepPink = 0xffff1493;
static const unsigned aclDeepSkyBlue = 0xff00bfff;
static const unsigned aclDimGray = 0xff696969;
static const unsigned aclDodgerBlue = 0xff1e90ff;
static const unsigned aclFirebrick = 0xffb22222;
static const unsigned aclFloralWhite = 0xfffffaf0;
static const unsigned aclForestGreen = 0xff228b22;
static const unsigned aclFuchsia = 0xffff00ff;
static const unsigned aclGainsboro = 0xffdcdcdc;
static const unsigned aclGhostWhite = 0xfff8f8ff;
static const unsigned aclGold = 0xffffd700;
static const unsigned aclGoldenrod = 0xffdaa520;
static const unsigned aclGray = 0xff808080;
static const unsigned aclGreen = 0xff008000;
static const unsigned aclGreenYellow = 0xffadff2f;
static const unsigned aclHoneydew = 0xfff0fff0;
static const unsigned aclHotPink = 0xffff69b4;
static const unsigned aclIndianRed = 0xffcd5c5c;
static const unsigned aclIndigo = 0xff4b0082;
static const unsigned aclIvory = 0xfffffff0;
static const unsigned aclKhaki = 0xfff0e68c;
static const unsigned aclLavender = 0xffe6e6fa;
static const unsigned aclLavenderBlush = 0xfffff0f5;
static const unsigned aclLawnGreen = 0xff7cfc00;
static const unsigned aclLemonChiffon = 0xfffffacd;
static const unsigned aclLightBlue = 0xffadd8e6;
static const unsigned aclLightCoral = 0xfff08080;
static const unsigned aclLightCyan = 0xffe0ffff;
static const unsigned aclLightGoldenrodYellow = 0xfffafad2;
static const unsigned aclLightGray = 0xffd3d3d3;
static const unsigned aclLightGreen = 0xff90ee90;
static const unsigned aclLightPink = 0xffffb6c1;
static const unsigned aclLightSalmon = 0xffffa07a;
static const unsigned aclLightSeaGreen = 0xff20b2aa;
static const unsigned aclLightSkyBlue = 0xff87cefa;
static const unsigned aclLightSlateGray = 0xff778899;
static const unsigned aclLightSteelBlue = 0xffb0c4de;
static const unsigned aclLightYellow = 0xffffffe0;
static const unsigned aclLime = 0xff00ff00;
static const unsigned aclLimeGreen = 0xff32cd32;
static const unsigned aclLinen = 0xfffaf0e6;
static const unsigned aclMagenta = 0xffff00ff;
static const unsigned aclMaroon = 0xff800000;
static const unsigned aclMediumAquamarine = 0xff66cdaa;
static const unsigned aclMediumBlue = 0xff0000cd;
static const unsigned aclMediumOrchid = 0xffba55d3;
static const unsigned aclMediumPurple = 0xff9370db;
static const unsigned aclMediumSeaGreen = 0xff3cb371;
static const unsigned aclMediumSlateBlue = 0xff7b68ee;
static const unsigned aclMediumSpringGreen = 0xff00fa9a;
static const unsigned aclMediumTurquoise = 0xff48d1cc;
static const unsigned aclMediumVioletRed = 0xffc71585;
static const unsigned aclMidnightBlue = 0xff191970;
static const unsigned aclMintCream = 0xfff5fffa;
static const unsigned aclMistyRose = 0xffffe4e1;
static const unsigned aclMoccasin = 0xffffe4b5;
static const unsigned aclNavajoWhite = 0xffffdead;
static const unsigned aclNavy = 0xff000080;
static const unsigned aclOldLace = 0xfffdf5e6;
static const unsigned aclOlive = 0xff808000;
static const unsigned aclOliveDrab = 0xff6b8e23;
static const unsigned aclOrange = 0xffffa500;
static const unsigned aclOrangeRed = 0xffff4500;
static const unsigned aclOrchid = 0xffda70d6;
static const unsigned aclPaleGoldenrod = 0xffeee8aa;
static const unsigned aclPaleGreen = 0xff98fb98;
static const unsigned aclPaleTurquoise = 0xffafeeee;
static const unsigned aclPaleVioletRed = 0xffdb7093;
static const unsigned aclPapayaWhip = 0xffffefd5;
static const unsigned aclPeachPuff = 0xffffdab9;
static const unsigned aclPeru = 0xffcd853f;
static const unsigned aclPink = 0xffffc0cb;
static const unsigned aclPlum = 0xffdda0dd;
static const unsigned aclPowderBlue = 0xffb0e0e6;
static const unsigned aclPurple = 0xff800080;
static const unsigned aclRed = 0xffff0000;
static const unsigned aclRosyBrown = 0xffbc8f8f;
static const unsigned aclRoyalBlue = 0xff4169e1;
static const unsigned aclSaddleBrown = 0xff8b4513;
static const unsigned aclSalmon = 0xfffa8072;
static const unsigned aclSandyBrown = 0xfff4a460;
static const unsigned aclSeaGreen = 0xff2e8b57;
static const unsigned aclSeaShell = 0xfffff5ee;
static const unsigned aclSienna = 0xffa0522d;
static const unsigned aclSilver = 0xffc0c0c0;
static const unsigned aclSkyBlue = 0xff87ceeb;
static const unsigned aclSlateBlue = 0xff6a5acd;
static const unsigned aclSlateGray = 0xff708090;
static const unsigned aclSnow = 0xfffffafa;
static const unsigned aclSpringGreen = 0xff00ff7f;
static const unsigned aclSteelBlue = 0xff4682b4;
static const unsigned aclTan = 0xffd2b48c;
static const unsigned aclTeal = 0xff008080;
static const unsigned aclThistle = 0xffd8bfd8;
static const unsigned aclTomato = 0xffff6347;
static const int aclTransparent = 0xffffff;
static const unsigned aclTurquoise = 0xff40e0d0;
static const unsigned aclViolet = 0xffee82ee;
static const unsigned aclWheat = 0xfff5deb3;
static const unsigned aclWhite = 0xffffffff;
static const unsigned aclWhiteSmoke = 0xfff5f5f5;
static const unsigned aclYellow = 0xffffff00;
static const unsigned aclYellowGreen = 0xff9acd32;
static const Shortint PenTypeSolidColor = 0x0;
static const Shortint PenTypeHatchFill = 0x1;
static const Shortint PenTypeTextureFill = 0x2;
static const Shortint PenTypePathGradient = 0x3;
static const Shortint PenTypeLinearGradient = 0x4;
static const Shortint PenTypeUnknown = -1;
static const Shortint QualityModeInvalid = -1;
static const Shortint QualityModeDefault = 0x0;
static const Shortint QualityModeLow = 0x1;
static const Shortint QualityModeHigh = 0x2;
static const Shortint CompositingQualityInvalid = -1;
static const Shortint CompositingQualityDefault = 0x0;
static const Shortint CompositingQualityHighSpeed = 0x1;
static const Shortint CompositingQualityHighQuality = 0x2;
static const Shortint CompositingQualityGammaCorrected = 0x3;
static const Shortint CompositingQualityAssumeLinear = 0x4;
#define HatchStyleLargeGrid (HatchStyle)(4)
#define HatchStyleMin (HatchStyle)(0)
#define HatchStyleMax (HatchStyle)(52)
static const Shortint LineCapFlat = 0x0;
static const Shortint LineCapSquare = 0x1;
static const Shortint LineCapRound = 0x2;
static const Shortint LineCapTriangle = 0x3;
static const Shortint LineCapNoAnchor = 0x10;
static const Shortint LineCapSquareAnchor = 0x11;
static const Shortint LineCapRoundAnchor = 0x12;
static const Shortint LineCapDiamondAnchor = 0x13;
static const Shortint LineCapArrowAnchor = 0x14;
static const Byte LineCapCustom = 0xff;
static const Byte LineCapAnchorMask = 0xf0;
static const int FontStyleRegular = 0;
static const int FontStyleBold = 1;
static const int FontStyleItalic = 2;
static const int FontStyleBoldItalic = 3;
static const int FontStyleUnderline = 4;
static const int FontStyleStrikeout = 8;
static const Shortint SmoothingModeInvalid = -1;
static const Shortint SmoothingModeDefault = 0x0;
static const Shortint SmoothingModeHighSpeed = 0x1;
static const Shortint SmoothingModeHighQuality = 0x2;
static const Shortint SmoothingModeNone = 0x3;
static const Shortint SmoothingModeAntiAlias = 0x4;
static const Shortint PixelOffsetModeInvalid = -1;
static const Shortint PixelOffsetModeDefault = 0x0;
static const Shortint PixelOffsetModeHighSpeed = 0x1;
static const Shortint PixelOffsetModeHighQuality = 0x2;
static const Shortint PixelOffsetModeNone = 0x3;
static const Shortint PixelOffsetModeHalf = 0x4;
static const Shortint StringFormatFlagsDirectionRightToLeft = 0x1;
static const Shortint StringFormatFlagsDirectionVertical = 0x2;
static const Shortint StringFormatFlagsNoFitBlackBox = 0x4;
static const Shortint StringFormatFlagsDisplayFormatControl = 0x20;
static const Word StringFormatFlagsNoFontFallback = 0x400;
static const Word StringFormatFlagsMeasureTrailingSpaces = 0x800;
static const Word StringFormatFlagsNoWrap = 0x1000;
static const Word StringFormatFlagsLineLimit = 0x2000;
static const Word StringFormatFlagsNoClip = 0x4000;
#define RotateNoneFlipY (RotateFlipType)(6)
#define Rotate90FlipY (RotateFlipType)(7)
#define Rotate180FlipY (RotateFlipType)(4)
#define Rotate270FlipY (RotateFlipType)(5)
#define RotateNoneFlipXY (RotateFlipType)(2)
#define Rotate90FlipXY (RotateFlipType)(3)
#define Rotate180FlipXY (RotateFlipType)(0)
#define Rotate270FlipXY (RotateFlipType)(1)
extern PACKAGE int EncoderParameterValueTypeByte;
extern PACKAGE int EncoderParameterValueTypeASCII;
extern PACKAGE int EncoderParameterValueTypeShort;
extern PACKAGE int EncoderParameterValueTypeLong;
extern PACKAGE int EncoderParameterValueTypeRational;
extern PACKAGE int EncoderParameterValueTypeLongRange;
extern PACKAGE int EncoderParameterValueTypeUndefined;
extern PACKAGE int EncoderParameterValueTypeRationalRange;
extern PACKAGE GdiplusStartupInput StartupInput;
extern PACKAGE GdiplusStartupOutput StartupOutput;
extern PACKAGE unsigned gdiplusToken;
extern PACKAGE void __fastcall GetJPGSize(const AnsiString sFile, Word &wWidth, Word &wHeight);
extern PACKAGE void __fastcall GetPNGSize(const AnsiString sFile, Word &wWidth, Word &wHeight);
extern PACKAGE void __fastcall GetGIFSize(const AnsiString sFile, Word &wWidth, Word &wHeight);
extern PACKAGE void __fastcall GetBMPSize(const AnsiString sFile, Word &wWidth, Word &wHeight);
extern PACKAGE void __fastcall GetTifSize(const AnsiString sFile, Word &wWidth, Word &wHeight);
extern PACKAGE void __fastcall GetICOSize(const AnsiString sFile, Word &wWidth, Word &wHeight);
extern PACKAGE void __fastcall ShadowGDIP(TGPGraphics* graphics, const TGPRectF &Rect);
extern PACKAGE void __fastcall FillGDIP(const TGDIPFillParameters &Params);
extern PACKAGE void __fastcall ArrowGDIP(TGPGraphics* graphics, const Types::TPoint &origin, const Types::TPoint &target, int ArrowSize, Graphics::TColor ArrowColor, double ScaleX, double ScaleY);
extern PACKAGE unsigned __fastcall ColorToARGB(Graphics::TColor Color);
extern PACKAGE TGPPoint __fastcall MakePoint(int X, int Y)/* overload */;
extern PACKAGE TGPPointF __fastcall MakePoint(float X, float Y)/* overload */;
extern PACKAGE TGPRectF __fastcall MakeRect(float x, float y, float width, float height)/* overload */;
extern PACKAGE unsigned __fastcall MakeColor(Byte a, Byte r, Byte g, Byte b)/* overload */;
extern PACKAGE unsigned __fastcall MakeColor(Byte a, Graphics::TColor Color)/* overload */;
extern PACKAGE unsigned __fastcall MakeColor(Byte r, Byte g, Byte b)/* overload */;
extern PACKAGE Byte __fastcall GetAlpha(unsigned color);
extern PACKAGE Byte __fastcall GetRed(unsigned color);
extern PACKAGE Byte __fastcall GetGreen(unsigned color);
extern PACKAGE Byte __fastcall GetBlue(unsigned color);

}	/* namespace Advsmoothgdip */
using namespace Advsmoothgdip;
#pragma pack(pop)
#pragma option pop

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// Advsmoothgdip
