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

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

#ifndef AdvgdipHPP
#define AdvgdipHPP

#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

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

#pragma link "gdiplus.lib"


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

#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 TCompositingQuality;

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

typedef Unit_ TUnit;

#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;

typedef int TFontStyle;

typedef int SmoothingMode;

typedef int TSmoothingMode;

#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;

#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 int TPixelFormat;

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

typedef RotateFlipType TRotateFlipType;

typedef void *GpGraphics;

typedef void *GpBrush;

typedef void *GpSolidFill;

typedef void *GpLineGradient;

typedef void *GpPathGradient;

typedef void *GpPen;

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 FlushIntention GpFlushIntention;

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 */;
};


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 TGPLinearGradientBrush;
class PASCALIMPLEMENTATION TGPLinearGradientBrush : public TGPBrush 
{
	typedef TGPBrush inherited;
	
public:
	__fastcall TGPLinearGradientBrush(void)/* 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 */;
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);
	
public:
	__fastcall TGPPen(void * nativePen, Status status)/* overload */;
	__fastcall TGPPen(unsigned color, float width)/* overload */;
	__fastcall virtual ~TGPPen(void);
	DashStyle __fastcall GetDashStyle(void);
	Status __fastcall SetDashStyle(DashStyle dashStyle);
	Status __fastcall SetEndCap(int endCap);
};


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);
	
public:
	__fastcall TGPStringFormat(void * clonedStringFormat, Status status)/* overload */;
	__fastcall TGPStringFormat(int formatFlags, Word language)/* 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 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(TGPGraphicsPath* path);
	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 */;
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 DELPHICLASS TGPImage;
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 */;
	__fastcall virtual ~TGPImage(void);
	TGPImageFormat __fastcall GetFormat(void);
	unsigned __fastcall GetWidth(void);
	unsigned __fastcall GetHeight(void);
	float __fastcall GetHorizontalResolution(void);
	float __fastcall GetVerticalResolution(void);
	Status __fastcall RotateFlip(RotateFlipType rotateFlipType);
};


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 SetResolution(float xdpi, float ydpi);
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);
	TGPGraphics* __fastcall FromImage(TGPImage* image);
	void __fastcall Flush(FlushIntention intention = (FlushIntention)(0x0));
	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);
	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 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 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 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, int x, int y)/* overload */;
	Status __fastcall DrawImageRect(TGPImage* image, int x, int y, int w, int h)/* 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);
};


//-- var, const, procedure ---------------------------------------------------
extern PACKAGE int GlowSpeed;
#define WINGDIPDLL "gdiplus.dll"
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;
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;
#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 GdiplusStartupInput StartupInput;
extern PACKAGE GdiplusStartupOutput StartupOutput;
extern PACKAGE unsigned gdiplusToken;
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 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 Advgdip */
using namespace Advgdip;
#pragma pack(pop)
#pragma option pop

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