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

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

#ifndef GdiplusHPP
#define GdiplusHPP

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

namespace Gdiplus
{
//-- type declarations -------------------------------------------------------
typedef short INT16;

typedef Word UINT16;

typedef UINT16 *PUINT16;

typedef unsigned UINT32;

typedef DynamicArray<float >  TSingleDynArray;

typedef BOOL __stdcall (*ImageAbort)(void);

typedef BOOL __stdcall (*DrawImageAbort)(void);

typedef BOOL __stdcall (*GetThumbnailImageAbort)(void);

class DELPHICLASS TsgGDIPlusBase;
class PASCALIMPLEMENTATION TsgGDIPlusBase : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	ImageAbort FCallBack;
	void *FCallBackData;
	
public:
	#pragma option push -w-inl
	/* virtual class method */ virtual System::TObject* __fastcall NewInstance() { return NewInstance(__classid(TsgGDIPlusBase)); }
	#pragma option pop
	/*         class method */ static System::TObject* __fastcall NewInstance(TMetaClass* vmt);
	virtual void __fastcall FreeInstance(void);
	__property ImageAbort CallBack = {read=FCallBack, write=FCallBack};
	__property void * CallBackData = {read=FCallBackData, write=FCallBackData};
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TsgGDIPlusBase(void) : System::TObject() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TsgGDIPlusBase(void) { }
	#pragma option pop
	
};


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

typedef unsigned GraphicsState;

typedef unsigned GraphicsContainer;

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

typedef FillMode TsgGDIPFillMode;

typedef int QualityMode;

#pragma option push -b-
enum CompositingMode { CompositingModeSourceOver, CompositingModeSourceCopy };
#pragma option pop

typedef CompositingMode TCompositingMode;

typedef int CompositingQuality;

typedef int TCompositingQuality;

typedef int Unit_;

typedef int TsgGDIPUnit;

typedef int MetafileFrameUnit;

typedef int TMetafileFrameUnit;

#pragma option push -b-
enum CoordinateSpace { CoordinateSpaceWorld, CoordinateSpacePage, CoordinateSpaceDevice };
#pragma option pop

typedef CoordinateSpace TsgGDIPCoordinateSpace;

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

typedef WrapMode TsgGDIPWrapMode;

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

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

typedef DashStyle TsgGDIPDashStyle;

typedef int DashCap;

typedef int TsgGDIPDashCap;

typedef int LineCap;

typedef int TsgGDIPLineCap;

#pragma option push -b-
enum CustomLineCapType { CustomLineCapTypeDefault, CustomLineCapTypeAdjustableArrow };
#pragma option pop

typedef CustomLineCapType TCustomLineCapType;

#pragma option push -b-
enum LineJoin { LineJoinMiter, LineJoinBevel, LineJoinRound, LineJoinMiterClipped };
#pragma option pop

typedef LineJoin TsgGDIPLineJoin;

typedef Byte PathPointType;

typedef Byte TPathPointType;

#pragma option push -b-
enum WarpMode { WarpModePerspective, WarpModeBilinear };
#pragma option pop

typedef WarpMode TWarpMode;

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

typedef LinearGradientMode TLinearGradientMode;

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

typedef CombineMode TCombineMode;

#pragma option push -b-
enum ImageType { ImageTypeUnknown, ImageTypeBitmap, ImageTypeMetafile };
#pragma option pop

typedef ImageType TImageType;

typedef int InterpolationMode;

typedef int TInterpolationMode;

#pragma option push -b-
enum PenAlignment { PenAlignmentCenter, PenAlignmentInset };
#pragma option pop

typedef PenAlignment TsgGDIPPenAlignment;

#pragma option push -b-
enum BrushType { BrushTypeSolidColor, BrushTypeHatchFill, BrushTypeTextureFill, BrushTypePathGradient, BrushTypeLinearGradient };
#pragma option pop

typedef BrushType TsgGDIPBrushType;

typedef int PenType;

typedef int TsgGDIPPenType;

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

typedef MatrixOrder TsgGDIPMatrixOrder;

#pragma option push -b-
enum GenericFontFamily { GenericFontFamilySerif, GenericFontFamilySansSerif, GenericFontFamilyMonospace };
#pragma option pop

typedef GenericFontFamily TGenericFontFamily;

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 MetafileType { MetafileTypeInvalid, MetafileTypeWmf, MetafileTypeWmfPlaceable, MetafileTypeEmf, MetafileTypeEmfPlusOnly, MetafileTypeEmfPlusDual };
#pragma option pop

typedef MetafileType TMetafileType;

typedef int EmfType;

typedef int TEmfType;

#pragma option push -b-
enum ObjectType { ObjectTypeInvalid, ObjectTypeBrush, ObjectTypePen, ObjectTypePath, ObjectTypeRegion, ObjectTypeImage, ObjectTypeFont, ObjectTypeStringFormat, ObjectTypeImageAttributes, ObjectTypeCustomLineCap };
#pragma option pop

typedef ObjectType TObjectType;

typedef int EmfPlusRecordType;

typedef int TEmfPlusRecordType;

typedef int StringFormatFlags;

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 StringDigitSubstitute { StringDigitSubstituteUser, StringDigitSubstituteNone, StringDigitSubstituteNational, StringDigitSubstituteTraditional };
#pragma option pop

typedef StringDigitSubstitute TStringDigitSubstitute;

typedef StringDigitSubstitute *PStringDigitSubstitute;

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

typedef HotkeyPrefix THotkeyPrefix;

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

typedef StringAlignment TStringAlignment;

typedef int DriverStringOptions;

typedef int TDriverStringOptions;

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

typedef FlushIntention TsgGDIPFlushIntention;

typedef int EncoderParameterValueType;

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;

typedef int EmfToWmfBitsFlags;

typedef int TEmfToWmfBitsFlags;

typedef BOOL __stdcall (*EnumerateMetafileProc)(int RecordType, unsigned Flags, unsigned DataSize, System::PByte Data, void * CallBackData);

struct TsgGSizeF;
typedef TsgGSizeF *PsgGSizeF;

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

struct TsgGSize;
typedef TsgGSize *PsgGSize;

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

struct TsgGPointF;
typedef TsgGPointF *PsgGPointF;

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

typedef DynamicArray<TsgGPointF >  TPointFDynArray;

struct TsgGPoint;
typedef TsgGPoint *PsgGPoint;

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

typedef DynamicArray<TsgGPoint >  TPointDynArray;

struct TsgGRectF;
typedef TsgGRectF *PsgGRectF;

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

typedef DynamicArray<TsgGRectF >  TRectFDynArray;

struct TsgGRect;
typedef TsgGRect *PsgGRect;

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

typedef DynamicArray<TsgGRect >  TRectDynArray;

class DELPHICLASS TsgGDIPPathData;
class PASCALIMPLEMENTATION TsgGDIPPathData : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	int Count;
	TsgGPointF *Points;
	Byte *Types;
	__fastcall TsgGDIPPathData(void);
	__fastcall virtual ~TsgGDIPPathData(void);
};


struct TCharacterRange;
typedef TCharacterRange *PCharacterRange;

#pragma pack(push,1)
struct TCharacterRange
{
	
public:
	int First;
	int Length;
} ;
#pragma pack(pop)

#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 Status __stdcall (*TsgGDIPlusStartup)(/* out */ unsigned &Token, PGDIPlusStartupInput Input, PGDIPlusStartupOutput Output);

typedef void __stdcall (*TsgGDIPlusShutdown)(unsigned Token);

typedef unsigned *PARGB;

typedef unsigned ARGB;

typedef __int64 ARGB64;

typedef int PixelFormat;

typedef int TPixelFormat;

typedef int PaletteFlags;

typedef int TPaletteFlags;

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

typedef ColorPalette  TColorPalette;

typedef ColorPalette *PColorPalette;

#pragma option push -b-
enum ColorMode { ColorModeARGB32, ColorModeARGB64 };
#pragma option pop

typedef ColorMode TColorMode;

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

typedef ColorChannelFlags TColorChannelFlags;

typedef unsigned *PsgColor;

typedef unsigned TsgColor;

typedef DynamicArray<unsigned >  TColorDynArray;

typedef Types::TRect  RECTL;

typedef tagSIZE  SIZEL;

#pragma pack(push,1)
struct ENHMETAHEADER3
{
	
public:
	unsigned iType;
	unsigned nSize;
	#pragma pack(push,1)
	Types::TRect rclBounds;
	#pragma pack(pop)
	#pragma pack(push,1)
	Types::TRect rclFrame;
	#pragma pack(pop)
	unsigned dSignature;
	unsigned nVersion;
	unsigned nBytes;
	unsigned nRecords;
	Word nHandles;
	Word sReserved;
	unsigned nDescription;
	unsigned offDescription;
	unsigned nPalEntries;
	#pragma pack(push,1)
	tagSIZE szlDevice;
	#pragma pack(pop)
	#pragma pack(push,1)
	tagSIZE szlMillimeters;
	#pragma pack(pop)
} ;
#pragma pack(pop)

typedef ENHMETAHEADER3  TENHMETAHEADER3;

typedef ENHMETAHEADER3 *PENHMETAHEADER3;

#pragma pack(push,1)
struct PWMFRect16
{
	
public:
	INT16 Left;
	INT16 Top;
	INT16 Right;
	INT16 Bottom;
} ;
#pragma pack(pop)

typedef PWMFRect16  TPWMFRect16;

typedef PWMFRect16 *PPWMFRect16;

#pragma pack(push,1)
struct WmfPlaceableFileHeader
{
	
public:
	UINT32 Key;
	INT16 Hmf;
	#pragma pack(push,1)
	PWMFRect16 BoundingBox;
	#pragma pack(pop)
	INT16 Inch;
	UINT32 Reserved;
	INT16 Checksum;
} ;
#pragma pack(pop)

typedef WmfPlaceableFileHeader  TWmfPlaceableFileHeader;

typedef WmfPlaceableFileHeader *PWmfPlaceableFileHeader;

#pragma pack(push,1)
struct GDIPLUS__4
{
	
	union
	{
		struct 
		{
			ENHMETAHEADER3 EmfHeader;
			
		};
		struct 
		{
			tagMETAHEADER WmfHeader;
			
		};
		
	};
} ;
#pragma pack(pop)

class DELPHICLASS TMetafileHeader;
class PASCALIMPLEMENTATION TMetafileHeader : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	MetafileType Type_;
	unsigned Size;
	unsigned Version;
	unsigned EmfPlusFlags;
	float DpiX;
	float DpiY;
	int X;
	int Y;
	int Width;
	int Height;
	#pragma pack(push,1)
	GDIPLUS__4 Header;
	#pragma pack(pop)
	int EmfPlusHeaderSize;
	int LogicalDpiX;
	int LogicalDpiY;
	__property MetafileType GetType = {read=Type_, nodefault};
	__property unsigned GetMetafileSize = {read=Size, nodefault};
	__property unsigned GetVersion = {read=Version, nodefault};
	__property unsigned GetEmfPlusFlags = {read=EmfPlusFlags, nodefault};
	__property float GetDpiX = {read=DpiX};
	__property float GetDpiY = {read=DpiY};
	void __fastcall GetBounds(/* out */ TsgGRect &Rect);
	BOOL __fastcall IsWmf(void);
	BOOL __fastcall IsWmfPlaceable(void);
	BOOL __fastcall IsEmf(void);
	BOOL __fastcall IsEmfOrEmfPlus(void);
	BOOL __fastcall IsEmfPlus(void);
	BOOL __fastcall IsEmfPlusDual(void);
	BOOL __fastcall IsEmfPlusOnly(void);
	BOOL __fastcall IsDisplay(void);
	Windows::PMetaHeader __fastcall GetWmfHeader(void);
	PENHMETAHEADER3 __fastcall GetEmfHeader(void);
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TMetafileHeader(void) : System::TObject() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TMetafileHeader(void) { }
	#pragma option pop
	
};


__interface IImageBytes;
typedef System::DelphiInterface<IImageBytes> _di_IImageBytes;
__interface  INTERFACE_UUID("{025D1823-6C7D-447B-BBDB-A3CBC3DFA2FC}") IImageBytes  : public IInterface 
{
	
public:
	virtual HRESULT __stdcall CountBytes(/* out */ unsigned &pcb) = 0 ;
	virtual HRESULT __stdcall LockBytes(unsigned cb, unsigned ulOffset, /* out */ void * &ppvBytes) = 0 ;
	virtual HRESULT __stdcall UnlockBytes(void * pvBytes, unsigned cb, unsigned ulOffset) = 0 ;
};

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

typedef int ImageCodecFlags;

typedef int TImageCodecFlags;

typedef int ImageLockMode;

typedef int TImageLockMode;

#pragma pack(push,1)
struct BitmapData
{
	
public:
	unsigned Width;
	unsigned Height;
	int Stride;
	int PixelFormat;
	void *Scan0;
	unsigned Reserved;
} ;
#pragma pack(pop)

typedef BitmapData  TBitmapData;

typedef BitmapData *PBitmapData;

typedef int ImageFlags;

typedef int TImageFlags;

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

typedef RotateFlipType TRotateFlipType;

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

struct PropertyItem
{
	
public:
	unsigned id;
	unsigned length;
	Word type_;
	void *value;
} ;

typedef PropertyItem  TPropertyItem;

typedef PropertyItem *PPropertyItem;

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 ColorAdjustType { ColorAdjustTypeDefault, ColorAdjustTypeBitmap, ColorAdjustTypeBrush, ColorAdjustTypePen, ColorAdjustTypeText, ColorAdjustTypeCount, ColorAdjustTypeAny };
#pragma option pop

typedef ColorAdjustType TColorAdjustType;

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

typedef ColorMap  TColorMap;

typedef ColorMap *PColorMap;

typedef void *TsgGDIPGraphics;

typedef void *TsgGDIPBrush;

typedef void *TsgGDIPTexture;

typedef void *TsgGDIPSolidFill;

typedef void *TsgGDIPLineGradient;

typedef void *TsgGDIPPathGradient;

typedef void *TsgGDIPHatch;

typedef void *TsgGDIPPen;

typedef void *TsgGDIPCustomLineCap;

typedef void *TsgGDIPAdjustableArrowCap;

typedef void *TsgGDIPImage;

typedef void *TsgGDIPBitMap;

typedef void *TsgGDIPMetaFile;

typedef void *TsgGDIPImageAttributes;

typedef void *TsgGDIPPath;

typedef void *TsgGDIPRegion;

typedef void *TsgGDIPPathIterator;

typedef void *TsgGDIPFontFamily;

typedef void *TsgGDIPFont;

typedef void *TsgGDIPStringFormat;

typedef void *TsgGDIPFontCollection;

typedef void *TsgGDIPMatrix;

class DELPHICLASS TsgGDIPlusRegion;
class DELPHICLASS TsgGDIPlusGraphicsPath;
class DELPHICLASS TsgGDIPlusMatrix;
class DELPHICLASS TsgGDIPlusGraphics;
class PASCALIMPLEMENTATION TsgGDIPlusRegion : public TsgGDIPlusBase 
{
	typedef TsgGDIPlusBase inherited;
	
protected:
	void *NativeRegion;
	Status FStatusOfFunction;
	Status __fastcall SetStatus(Status Status);
	void __fastcall SetNativeRegion(void * NativeRegion);
	__fastcall TsgGDIPlusRegion(void * NativeRegion)/* overload */;
	
public:
	__fastcall TsgGDIPlusRegion(void)/* overload */;
	__fastcall TsgGDIPlusRegion(const TsgGRectF &Rect)/* overload */;
	__fastcall TsgGDIPlusRegion(const TsgGRect &Rect)/* overload */;
	__fastcall TsgGDIPlusRegion(TsgGDIPlusGraphicsPath* Path)/* overload */;
	__fastcall TsgGDIPlusRegion(System::PByte RegionData, int Size)/* overload */;
	__fastcall TsgGDIPlusRegion(HRGN hRgn)/* overload */;
	TsgGDIPlusRegion* __fastcall FromHRGN(HRGN hRgn);
	__fastcall virtual ~TsgGDIPlusRegion(void);
	TsgGDIPlusRegion* __fastcall Clone(void);
	Status __fastcall MakeInfinite(void);
	Status __fastcall MakeEmpty(void);
	unsigned __fastcall GetDataSize(void);
	Status __fastcall GetData(System::PByte Buffer, unsigned BufferSize, PUINT SizeFilled = (void *)(0x0));
	Status __fastcall Intersect(const TsgGRect &Rect)/* overload */;
	Status __fastcall Intersect(const TsgGRectF &Rect)/* overload */;
	Status __fastcall Intersect(TsgGDIPlusGraphicsPath* Path)/* overload */;
	Status __fastcall Intersect(TsgGDIPlusRegion* Region)/* overload */;
	Status __fastcall Union(const TsgGRect &Rect)/* overload */;
	Status __fastcall Union(const TsgGRectF &Rect)/* overload */;
	Status __fastcall Union(TsgGDIPlusGraphicsPath* Path)/* overload */;
	Status __fastcall Union(TsgGDIPlusRegion* Region)/* overload */;
	Status __fastcall Xor_(const TsgGRect &Rect)/* overload */;
	Status __fastcall Xor_(const TsgGRectF &Rect)/* overload */;
	Status __fastcall Xor_(TsgGDIPlusGraphicsPath* Path)/* overload */;
	Status __fastcall Xor_(TsgGDIPlusRegion* Region)/* overload */;
	Status __fastcall Exclude(const TsgGRect &Rect)/* overload */;
	Status __fastcall Exclude(const TsgGRectF &Rect)/* overload */;
	Status __fastcall Exclude(TsgGDIPlusGraphicsPath* Path)/* overload */;
	Status __fastcall Exclude(TsgGDIPlusRegion* Region)/* overload */;
	Status __fastcall Complement(const TsgGRect &Rect)/* overload */;
	Status __fastcall Complement(const TsgGRectF &Rect)/* overload */;
	Status __fastcall Complement(TsgGDIPlusGraphicsPath* Path)/* overload */;
	Status __fastcall Complement(TsgGDIPlusRegion* Region)/* overload */;
	Status __fastcall Translate(float Dx, float Dy)/* overload */;
	Status __fastcall Translate(int Dx, int Dy)/* overload */;
	Status __fastcall Transform(const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall GetBounds(/* out */ TsgGRect &Rect, TsgGDIPlusGraphics* Graph)/* overload */;
	Status __fastcall GetBounds(/* out */ TsgGRectF &Rect, TsgGDIPlusGraphics* Graph)/* overload */;
	HRGN __fastcall GetHRGN(TsgGDIPlusGraphics* Graph);
	BOOL __fastcall IsEmpty(TsgGDIPlusGraphics* Graph);
	BOOL __fastcall IsInfinite(TsgGDIPlusGraphics* Graph);
	BOOL __fastcall IsVisible(int X, int Y, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
	BOOL __fastcall IsVisible(const TsgGPoint &point, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
	BOOL __fastcall IsVisible(float X, float Y, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
	BOOL __fastcall IsVisible(const TsgGPointF &point, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
	BOOL __fastcall IsVisible(int X, int Y, int Width, int Height, TsgGDIPlusGraphics* Graph)/* overload */;
	BOOL __fastcall IsVisible(const TsgGRect &Rect, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
	BOOL __fastcall IsVisible(float X, float Y, float Width, float Height, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
	BOOL __fastcall IsVisible(const TsgGRectF &Rect, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
	BOOL __fastcall Equals(TsgGDIPlusRegion* Region, TsgGDIPlusGraphics* Graph);
	unsigned __fastcall GetRegionScansCount(const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall GetRegionScans(const TsgGDIPlusMatrix* AMatrix, PsgGRectF Rects, /* out */ int &Count)/* overload */;
	Status __fastcall GetRegionScans(const TsgGDIPlusMatrix* AMatrix, PsgGRect Rects, /* out */ int &Count)/* overload */;
	Status __fastcall GetStatusOfFunction(void);
};


class DELPHICLASS TsgGDIPlusFontFamily;
class DELPHICLASS TsgGDIPlusFontCollection;
class PASCALIMPLEMENTATION TsgGDIPlusFontFamily : public TsgGDIPlusBase 
{
	typedef TsgGDIPlusBase inherited;
	
protected:
	void *NativeFamily;
	Status FStatusOfFunction;
	Status __fastcall SetStatus(Status Status);
	__fastcall TsgGDIPlusFontFamily(void * NativeOrig, Status Status)/* overload */;
	
public:
	__fastcall TsgGDIPlusFontFamily(void)/* overload */;
	__fastcall TsgGDIPlusFontFamily(WideString name, TsgGDIPlusFontCollection* FontCollection)/* overload */;
	__fastcall virtual ~TsgGDIPlusFontFamily(void);
	/*         class method */ static TsgGDIPlusFontFamily* __fastcall GenericSansSerif(TMetaClass* vmt);
	/*         class method */ static TsgGDIPlusFontFamily* __fastcall GenericSerif(TMetaClass* vmt);
	/*         class method */ static TsgGDIPlusFontFamily* __fastcall GenericMonospace(TMetaClass* vmt);
	Status __fastcall GetFamilyName(/* out */ AnsiString &name, Word Language = (Word)(0x0));
	TsgGDIPlusFontFamily* __fastcall Clone(void);
	BOOL __fastcall IsAvailable(void);
	BOOL __fastcall IsStyleAvailable(int Style);
	UINT16 __fastcall GetEmHeight(int Style);
	UINT16 __fastcall GetCellAscent(int Style);
	UINT16 __fastcall GetCellDescent(int Style);
	UINT16 __fastcall GetLineSpacing(int Style);
	Status __fastcall GetStatusOfFunction(void);
};


class PASCALIMPLEMENTATION TsgGDIPlusFontCollection : public TsgGDIPlusBase 
{
	typedef TsgGDIPlusBase inherited;
	
protected:
	void *NativeFontCollection;
	Status FStatusOfFunction;
	Status __fastcall SetStatus(Status Status);
	
public:
	__fastcall TsgGDIPlusFontCollection(void);
	__fastcall virtual ~TsgGDIPlusFontCollection(void);
	int __fastcall GetFamilyCount(void);
	Status __fastcall GetFamilies(int NumSought, /* out */ TsgGDIPlusFontFamily* * AFamilies, const int AFamilies_Size, /* out */ int &NumFound);
	Status __fastcall GetStatusOfFunction(void);
};


class DELPHICLASS TsgGDIPlusInstalledFontCollection;
class PASCALIMPLEMENTATION TsgGDIPlusInstalledFontCollection : public TsgGDIPlusFontCollection 
{
	typedef TsgGDIPlusFontCollection inherited;
	
public:
	__fastcall TsgGDIPlusInstalledFontCollection(void);
	__fastcall virtual ~TsgGDIPlusInstalledFontCollection(void);
};


class DELPHICLASS TsgGDIPlusPrivateFontCollection;
class PASCALIMPLEMENTATION TsgGDIPlusPrivateFontCollection : public TsgGDIPlusFontCollection 
{
	typedef TsgGDIPlusFontCollection inherited;
	
public:
	__fastcall TsgGDIPlusPrivateFontCollection(void);
	__fastcall virtual ~TsgGDIPlusPrivateFontCollection(void);
	Status __fastcall AddFontFile(WideString FileName);
	Status __fastcall AddMemoryFont(void * Memory, int Length);
};


class DELPHICLASS TsgGDIPlusFont;
class PASCALIMPLEMENTATION TsgGDIPlusFont : public TsgGDIPlusBase 
{
	typedef TsgGDIPlusBase inherited;
	
protected:
	void *NativeFont;
	Status FStatusOfFunction;
	void __fastcall SetNativeFont(void * Font);
	Status __fastcall SetStatus(Status Status);
	__fastcall TsgGDIPlusFont(void * Font, Status Status)/* overload */;
	
public:
	__fastcall TsgGDIPlusFont(HDC ADC)/* overload */;
	__fastcall TsgGDIPlusFont(HDC ADC, Windows::PLogFontA ALogFont)/* overload */;
	__fastcall TsgGDIPlusFont(HDC ADC, Windows::PLogFontW ALogFont)/* overload */;
	__fastcall TsgGDIPlusFont(HDC ADC, HFONT AFont)/* overload */;
	__fastcall TsgGDIPlusFont(TsgGDIPlusFontFamily* Family, float ASize, int Style, int Unit_)/* overload */;
	__fastcall TsgGDIPlusFont(WideString FamilyName, float ASize, int Style, int Unit_, TsgGDIPlusFontCollection* FontCollection)/* overload */;
	Status __fastcall GetLogFontA(TsgGDIPlusGraphics* Graph, /* out */ tagLOGFONTA &LogFontA);
	Status __fastcall GetLogFontW(TsgGDIPlusGraphics* Graph, /* out */ tagLOGFONTW &LogFontW);
	TsgGDIPlusFont* __fastcall Clone(void);
	__fastcall virtual ~TsgGDIPlusFont(void);
	BOOL __fastcall IsAvailable(void);
	int __fastcall GetStyle(void);
	float __fastcall GetSize(void);
	int __fastcall GetUnit(void);
	Status __fastcall GetStatusOfFunction(void);
	float __fastcall GetHeight(TsgGDIPlusGraphics* Graphics)/* overload */;
	float __fastcall GetHeight(float Dpi)/* overload */;
	Status __fastcall GetFamily(TsgGDIPlusFontFamily* Family);
};


class DELPHICLASS TsgGDIPlusImage;
class PASCALIMPLEMENTATION TsgGDIPlusImage : public TsgGDIPlusBase 
{
	typedef TsgGDIPlusBase inherited;
	
protected:
	void *NativeImage;
	Status FStatusOfFunction;
	void __fastcall SetNativeImage(void * NativeImage);
	Status __fastcall SetStatus(Status Status);
	__fastcall TsgGDIPlusImage(void * NativeImage, Status Status)/* overload */;
	
public:
	__fastcall TsgGDIPlusImage(WideString FileName, BOOL useEmbeddedColorManagement)/* overload */;
	__fastcall TsgGDIPlusImage(_di_IStream Stream, BOOL useEmbeddedColorManagement)/* overload */;
	TsgGDIPlusImage* __fastcall FromFile(WideString FileName, BOOL useEmbeddedColorManagement = false);
	TsgGDIPlusImage* __fastcall FromStream(_di_IStream Stream, BOOL useEmbeddedColorManagement = false);
	__fastcall virtual ~TsgGDIPlusImage(void);
	TsgGDIPlusImage* __fastcall Clone(void);
	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 */;
	Status __fastcall SaveAdd(PEncoderParameters EncoderParams)/* overload */;
	Status __fastcall SaveAdd(TsgGDIPlusImage* newImage, PEncoderParameters EncoderParams)/* overload */;
	ImageType __fastcall GetType(void);
	Status __fastcall GetPhysicalDimension(/* out */ TsgGSizeF &Size);
	Status __fastcall GetBounds(/* out */ TsgGRectF &SrcRect, /* out */ int &SrcUnit);
	unsigned __fastcall GetWidth(void);
	unsigned __fastcall GetHeight(void);
	float __fastcall GetHorizontalResolution(void);
	float __fastcall GetVerticalResolution(void);
	unsigned __fastcall GetFlags(void);
	Status __fastcall GetRawFormat(/* out */ GUID &Format);
	int __fastcall GetPixelFormat(void);
	int __fastcall GetPaletteSize(void);
	Status __fastcall GetPalette(PColorPalette Palette, int Size);
	Status __fastcall SetPalette(PColorPalette Palette);
	TsgGDIPlusImage* __fastcall GetThumbnailImage(unsigned ThumbWidth, unsigned ThumbHeight);
	unsigned __fastcall GetFrameDimensionsCount(void);
	Status __fastcall GetFrameDimensionsList(System::PGUID DimensionIDs, unsigned Count);
	unsigned __fastcall GetFrameCount(const GUID &DimensionID);
	Status __fastcall SelectActiveFrame(const GUID &DimensionID, unsigned FrameIndex);
	Status __fastcall RotateFlip(RotateFlipType rotateFlipType);
	unsigned __fastcall GetPropertyCount(void);
	Status __fastcall GetPropertyIdList(unsigned NumOfProperty, Activex::PPropID List);
	unsigned __fastcall GetPropertyItASize(unsigned PropId);
	Status __fastcall GetPropertyItem(unsigned PropId, unsigned PropSize, PPropertyItem Buffer);
	Status __fastcall GetPropertySize(/* out */ unsigned &TotalBufferSize, /* out */ unsigned &NumProperties);
	Status __fastcall GetAllPropertyItems(unsigned TotalBufferSize, unsigned NumProperties, PPropertyItem AllItems);
	Status __fastcall RemovePropertyItem(unsigned PropId);
	Status __fastcall SetPropertyItem(const PropertyItem &Item);
	unsigned __fastcall GetEncoderParameterListSize(const GUID &ClsIdEncoder);
	Status __fastcall GetEncoderParameterList(const GUID &ClsIdEncoder, unsigned Size, PEncoderParameters Buffer);
	Status __fastcall GetStatusOfFunction(void);
};


class DELPHICLASS TsgGDIPlusBitmap;
class PASCALIMPLEMENTATION TsgGDIPlusBitmap : public TsgGDIPlusImage 
{
	typedef TsgGDIPlusImage inherited;
	
public:
	__fastcall TsgGDIPlusBitmap(WideString FileName, BOOL useEmbeddedColorManagement)/* overload */;
	__fastcall TsgGDIPlusBitmap(_di_IStream Stream, BOOL useEmbeddedColorManagement)/* overload */;
	__fastcall TsgGDIPlusBitmap(HBITMAP Handle, HPALETTE hPal)/* overload */;
	__fastcall TsgGDIPlusBitmap(int Width, int Height, int Stride, int Format, System::PByte scan0)/* overload */;
	__fastcall TsgGDIPlusBitmap(Windows::PBitmapInfo GDIBitmapInfo, void * GDIBitmapData)/* overload */;
public:
	#pragma option push -w-inl
	/* TsgGDIPlusImage.Destroy */ inline __fastcall virtual ~TsgGDIPlusBitmap(void) { }
	#pragma option pop
	
};


class DELPHICLASS TsgGDIPlusCustomLineCap;
class PASCALIMPLEMENTATION TsgGDIPlusCustomLineCap : public TsgGDIPlusBase 
{
	typedef TsgGDIPlusBase inherited;
	
protected:
	void *NativeCap;
	Status FStatusOfFunction;
	void __fastcall SetNativeCap(void * NativeCap);
	Status __fastcall SetStatus(Status Status);
	__fastcall TsgGDIPlusCustomLineCap(void * NativeCap, Status Status)/* overload */;
	
public:
	__fastcall TsgGDIPlusCustomLineCap(void)/* overload */;
	__fastcall TsgGDIPlusCustomLineCap(TsgGDIPlusGraphicsPath* FillPath, TsgGDIPlusGraphicsPath* StrokePath, int BaseCap, float BaseInset)/* overload */;
	__fastcall virtual ~TsgGDIPlusCustomLineCap(void);
	TsgGDIPlusCustomLineCap* __fastcall Clone(void);
	Status __fastcall SetStrokeCap(int StrokeCap);
	Status __fastcall SetStrokeCaps(int StartCap, int EndCap);
	Status __fastcall GetStrokeCaps(/* out */ int &StartCap, /* out */ int &EndCap);
	Status __fastcall SetStrokeJoin(LineJoin LineJoin);
	LineJoin __fastcall GetStrokeJoin(void);
	Status __fastcall SetBaseCap(int BaseCap);
	int __fastcall GetBaseCap(void);
	Status __fastcall SetBaseInset(float Inset);
	float __fastcall GetBaseInset(void);
	Status __fastcall SetWidthScale(float WidthScale);
	float __fastcall GetWidthScale(void);
	Status __fastcall GetStatusOfFunction(void);
};


class DELPHICLASS TsgGDIPlusImageAttributes;
class PASCALIMPLEMENTATION TsgGDIPlusImageAttributes : public TsgGDIPlusBase 
{
	typedef TsgGDIPlusBase inherited;
	
protected:
	void *NativeImageAttr;
	Status FStatusOfFunction;
	void __fastcall SetNativeImageAttr(void * NativeImageAttr);
	Status __fastcall SetStatus(Status Status);
	__fastcall TsgGDIPlusImageAttributes(void * ImageAttr, Status Status)/* overload */;
	
public:
	__fastcall TsgGDIPlusImageAttributes(void)/* overload */;
	__fastcall virtual ~TsgGDIPlusImageAttributes(void);
	TsgGDIPlusImageAttributes* __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 GetStatusOfFunction(void);
};


typedef float TMatrixArray[6];

class PASCALIMPLEMENTATION TsgGDIPlusMatrix : public TsgGDIPlusBase 
{
	typedef TsgGDIPlusBase inherited;
	
protected:
	void *NativeMatrix;
	Status FStatusOfFunction;
	void __fastcall SetNativeMatrix(void * NativeMatrix);
	Status __fastcall SetStatus(Status Status);
	__fastcall TsgGDIPlusMatrix(void * NativeMatrix)/* overload */;
	
public:
	__fastcall TsgGDIPlusMatrix(void)/* overload */;
	__fastcall TsgGDIPlusMatrix(const float M11, const float M12, const float M21, const float M22, const float Dx, const float Dy)/* overload */;
	__fastcall TsgGDIPlusMatrix(const TsgGRectF &Rect, const TsgGPointF &DstPlg)/* overload */;
	__fastcall TsgGDIPlusMatrix(const TsgGRect &Rect, const TsgGPoint &DstPlg)/* overload */;
	__fastcall virtual ~TsgGDIPlusMatrix(void);
	TsgGDIPlusMatrix* __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(const TsgGDIPlusMatrix* AMatrix, 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 TsgGPointF &center, MatrixOrder Order = (MatrixOrder)(0x0));
	Status __fastcall Shear(float ShearX, float ShearY, MatrixOrder Order = (MatrixOrder)(0x0));
	Status __fastcall Invert(void);
	Status __fastcall TransformPoints(PsgGPointF Pts, int Count = 0x1)/* overload */;
	Status __fastcall TransformPoints(PsgGPoint Pts, int Count = 0x1)/* overload */;
	Status __fastcall TransformVectors(PsgGPointF Pts, int Count = 0x1)/* overload */;
	Status __fastcall TransformVectors(PsgGPoint Pts, int Count = 0x1)/* overload */;
	BOOL __fastcall IsInvertible(void);
	BOOL __fastcall IsIdentity(void);
	BOOL __fastcall Equals(const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall GetStatusOfFunction(void);
};


class DELPHICLASS TsgGDIPlusBrush;
class PASCALIMPLEMENTATION TsgGDIPlusBrush : public TsgGDIPlusBase 
{
	typedef TsgGDIPlusBase inherited;
	
protected:
	void *NativeBrush;
	Status FStatusOfFunction;
	void __fastcall SetNativeBrush(void * NativeBrush);
	Status __fastcall SetStatus(Status Status);
	__fastcall TsgGDIPlusBrush(void * NativeBrush, Status Status)/* overload */;
	
public:
	__fastcall TsgGDIPlusBrush(void)/* overload */;
	__fastcall virtual ~TsgGDIPlusBrush(void);
	virtual TsgGDIPlusBrush* __fastcall Clone(void);
	BrushType __fastcall GetType(void);
	Status __fastcall GetStatusOfFunction(void);
};


class DELPHICLASS TsgGDIPlusSolidBrush;
class PASCALIMPLEMENTATION TsgGDIPlusSolidBrush : public TsgGDIPlusBrush 
{
	typedef TsgGDIPlusBrush inherited;
	
public:
	__fastcall TsgGDIPlusSolidBrush(unsigned Color)/* overload */;
	__fastcall TsgGDIPlusSolidBrush(void)/* overload */;
	Status __fastcall GetColor(/* out */ unsigned &Color);
	Status __fastcall SetColor(unsigned Color);
public:
	#pragma option push -w-inl
	/* TsgGDIPlusBrush.Destroy */ inline __fastcall virtual ~TsgGDIPlusSolidBrush(void) { }
	#pragma option pop
	
};


class DELPHICLASS TsgGDIPlusTextureBrush;
class PASCALIMPLEMENTATION TsgGDIPlusTextureBrush : public TsgGDIPlusBrush 
{
	typedef TsgGDIPlusBrush inherited;
	
public:
	__fastcall TsgGDIPlusTextureBrush(void)/* overload */;
	__fastcall TsgGDIPlusTextureBrush(TsgGDIPlusImage* Image, WrapMode WrapMode)/* overload */;
	__fastcall TsgGDIPlusTextureBrush(TsgGDIPlusImage* Image, WrapMode WrapMode, const TsgGRectF &DstRect)/* overload */;
	__fastcall TsgGDIPlusTextureBrush(TsgGDIPlusImage* Image, const TsgGRectF &DstRect, TsgGDIPlusImageAttributes* ImageAttributes)/* overload */;
	__fastcall TsgGDIPlusTextureBrush(TsgGDIPlusImage* Image, const TsgGRect &DstRect, TsgGDIPlusImageAttributes* ImageAttributes)/* overload */;
	__fastcall TsgGDIPlusTextureBrush(TsgGDIPlusImage* Image, WrapMode WrapMode, const TsgGRect &DstRect)/* overload */;
	__fastcall TsgGDIPlusTextureBrush(TsgGDIPlusImage* Image, WrapMode WrapMode, float DstX, float DstY, float DstWidth, float DstHeight)/* overload */;
	__fastcall TsgGDIPlusTextureBrush(TsgGDIPlusImage* Image, WrapMode WrapMode, int DstX, int DstY, int DstWidth, int DstHeight)/* overload */;
	Status __fastcall SetTransform(const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall GetTransform(const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall ResetTransform(void);
	Status __fastcall MultiplyTransform(const TsgGDIPlusMatrix* AMatrix, 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);
	TsgGDIPlusImage* __fastcall GetImage(void);
public:
	#pragma option push -w-inl
	/* TsgGDIPlusBrush.Destroy */ inline __fastcall virtual ~TsgGDIPlusTextureBrush(void) { }
	#pragma option pop
	
};


class DELPHICLASS TsgGDIPlusLinearGradientBrush;
class PASCALIMPLEMENTATION TsgGDIPlusLinearGradientBrush : public TsgGDIPlusBrush 
{
	typedef TsgGDIPlusBrush inherited;
	
public:
	__fastcall TsgGDIPlusLinearGradientBrush(void)/* overload */;
	__fastcall TsgGDIPlusLinearGradientBrush(const TsgGPointF &point1, const TsgGPointF &point2, unsigned Color1, unsigned Color2)/* overload */;
	__fastcall TsgGDIPlusLinearGradientBrush(const TsgGPoint &point1, const TsgGPoint &point2, unsigned Color1, unsigned Color2)/* overload */;
	__fastcall TsgGDIPlusLinearGradientBrush(const TsgGRectF &Rect, unsigned Color1, unsigned Color2, LinearGradientMode Mode)/* overload */;
	__fastcall TsgGDIPlusLinearGradientBrush(const TsgGRect &Rect, unsigned Color1, unsigned Color2, LinearGradientMode Mode)/* overload */;
	__fastcall TsgGDIPlusLinearGradientBrush(const TsgGRectF &Rect, unsigned Color1, unsigned Color2, float Angle, BOOL isAngleScalable)/* overload */;
	__fastcall TsgGDIPlusLinearGradientBrush(const TsgGRect &Rect, unsigned Color1, unsigned Color2, float Angle, BOOL isAngleScalable)/* overload */;
	Status __fastcall SetLinearColors(unsigned Color1, unsigned Color2);
	Status __fastcall GetLinearColors(/* out */ unsigned &Color1, /* out */ unsigned &Color2);
	Status __fastcall GetRectangle(/* out */ TsgGRectF &Rect)/* overload */;
	Status __fastcall GetRectangle(/* out */ TsgGRect &Rect)/* 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(PsgColor APresetColors, Windows::PSingle BlendPositions, int Count);
	Status __fastcall GetInterpolationColors(PsgColor APresetColors, 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);
	Status __fastcall SetTransform(const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall GetTransform(const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall ResetTransform(void);
	Status __fastcall MultiplyTransform(const TsgGDIPlusMatrix* AMatrix, 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);
public:
	#pragma option push -w-inl
	/* TsgGDIPlusBrush.Destroy */ inline __fastcall virtual ~TsgGDIPlusLinearGradientBrush(void) { }
	#pragma option pop
	
};


class DELPHICLASS TsgGDIPlusHatchBrush;
class PASCALIMPLEMENTATION TsgGDIPlusHatchBrush : public TsgGDIPlusBrush 
{
	typedef TsgGDIPlusBrush inherited;
	
public:
	__fastcall TsgGDIPlusHatchBrush(void)/* overload */;
	__fastcall TsgGDIPlusHatchBrush(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
	/* TsgGDIPlusBrush.Destroy */ inline __fastcall virtual ~TsgGDIPlusHatchBrush(void) { }
	#pragma option pop
	
};


class DELPHICLASS TsgGDIPlusPen;
class PASCALIMPLEMENTATION TsgGDIPlusPen : public TsgGDIPlusBase 
{
	typedef TsgGDIPlusBase inherited;
	
protected:
	void *NativePen;
	Status FStatusOfFunction;
	void __fastcall SetNativePen(void * NativePen);
	Status __fastcall SetStatus(Status Status);
	__fastcall TsgGDIPlusPen(void * NativePen, Status Status)/* overload */;
	
public:
	__fastcall TsgGDIPlusPen(unsigned Color, float Width)/* overload */;
	__fastcall TsgGDIPlusPen(TsgGDIPlusBrush* Brush, float Width)/* overload */;
	__fastcall virtual ~TsgGDIPlusPen(void);
	TsgGDIPlusPen* __fastcall Clone(void);
	Status __fastcall SetWidth(float Width);
	float __fastcall GetWidth(void);
	Status __fastcall SetLineCap(int StartCap, int EndCap, int DashCap);
	Status __fastcall SetStartCap(int StartCap);
	Status __fastcall SetEndCap(int EndCap);
	Status __fastcall SetDashCap(int DashCap);
	int __fastcall GetStartCap(void);
	int __fastcall GetEndCap(void);
	int __fastcall GetDashCap(void);
	Status __fastcall SetLineJoin(LineJoin LineJoin);
	LineJoin __fastcall GetLineJoin(void);
	Status __fastcall SetCustomStartCap(TsgGDIPlusCustomLineCap* CustomCap);
	Status __fastcall GetCustomStartCap(TsgGDIPlusCustomLineCap* CustomCap);
	Status __fastcall SetCustomEndCap(TsgGDIPlusCustomLineCap* CustomCap);
	Status __fastcall GetCustomEndCap(TsgGDIPlusCustomLineCap* CustomCap);
	Status __fastcall SetMiterLimit(float MiterLimit);
	float __fastcall GetMiterLimit(void);
	Status __fastcall SetAlignment(PenAlignment PenAlignment);
	PenAlignment __fastcall GetAlignment(void);
	Status __fastcall SetTransform(const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall GetTransform(const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall ResetTransform(void);
	Status __fastcall MultiplyTransform(const TsgGDIPlusMatrix* AMatrix, 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));
	int __fastcall GetPenType(void);
	Status __fastcall SetColor(unsigned Color);
	Status __fastcall SetBrush(TsgGDIPlusBrush* Brush);
	Status __fastcall GetColor(/* out */ unsigned &Color);
	TsgGDIPlusBrush* __fastcall GetBrush(void);
	DashStyle __fastcall GetDashStyle(void);
	Status __fastcall SetDashStyle(DashStyle DashStyle);
	float __fastcall GetDashOffset(void);
	Status __fastcall SetDashOffset(float DashOffset);
	Status __fastcall SetDashPattern(Windows::PSingle DashArray, int Count);
	int __fastcall GetDashPatternCount(void);
	Status __fastcall GetDashPattern(Windows::PSingle DashArray, int Count);
	Status __fastcall SetCompoundArray(Windows::PSingle compoundArray, int Count);
	int __fastcall GetCompoundArrayCount(void);
	Status __fastcall GetCompoundArray(Windows::PSingle compoundArray, int Count);
	Status __fastcall GetStatusOfFunction(void);
};


class DELPHICLASS TsgGDIPlusStringFormat;
class PASCALIMPLEMENTATION TsgGDIPlusStringFormat : public TsgGDIPlusBase 
{
	typedef TsgGDIPlusBase inherited;
	
protected:
	void *NativeFormat;
	Status FStatusOfFunction;
	Status __fastcall SetStatus(Status newStatus);
	void __fastcall Assign(TsgGDIPlusStringFormat* source);
	__fastcall TsgGDIPlusStringFormat(void * ClonedStringFormat, Status Status)/* overload */;
	
public:
	__fastcall TsgGDIPlusStringFormat(int FormatFlags, Word Language)/* overload */;
	__fastcall TsgGDIPlusStringFormat(TsgGDIPlusStringFormat* Format)/* overload */;
	__fastcall virtual ~TsgGDIPlusStringFormat(void);
	/*         class method */ static TsgGDIPlusStringFormat* __fastcall GenericDefault(TMetaClass* vmt);
	/*         class method */ static TsgGDIPlusStringFormat* __fastcall GenericTypographic(TMetaClass* vmt);
	TsgGDIPlusStringFormat* __fastcall Clone(void);
	Status __fastcall SetFormatFlags(int Flags);
	int __fastcall GetFormatFlags(void);
	Status __fastcall SetAlignment(StringAlignment align);
	StringAlignment __fastcall GetAlignment(void);
	Status __fastcall SetLineAlignment(StringAlignment align);
	StringAlignment __fastcall GetLineAlignment(void);
	Status __fastcall SetHotkeyPrefix(HotkeyPrefix hotkeyPrefix);
	HotkeyPrefix __fastcall GetHotkeyPrefix(void);
	Status __fastcall SetTabStops(float firstTabOffset, int Count, Windows::PSingle TabStops);
	int __fastcall GetTabStopCount(void);
	Status __fastcall GetTabStops(int Count, Windows::PSingle FirstTabOffset, Windows::PSingle TabStops);
	Status __fastcall SetDigitSubstitution(Word Language, StringDigitSubstitute substitute);
	Word __fastcall GetDigitSubstitutionLanguage(void);
	StringDigitSubstitute __fastcall GetDigitSubstitutionMethod(void);
	Status __fastcall SetTrimming(StringTrimming trimming);
	StringTrimming __fastcall GetTrimming(void);
	Status __fastcall SetMeasurableCharacterRanges(int rangeCount, PCharacterRange ranges);
	int __fastcall GetMeasurableCharacterRangeCount(void);
	Status __fastcall GetStatusOfFunction(void);
};


class PASCALIMPLEMENTATION TsgGDIPlusGraphicsPath : public TsgGDIPlusBase 
{
	typedef TsgGDIPlusBase inherited;
	
protected:
	void *NativePath;
	Status FStatusOfFunction;
	void __fastcall SetNativePath(void * NativePath);
	Status __fastcall SetStatus(Status Status);
	__fastcall TsgGDIPlusGraphicsPath(void * NativePath)/* overload */;
	
public:
	__fastcall TsgGDIPlusGraphicsPath(TsgGDIPlusGraphicsPath* Path)/* overload */;
	__fastcall TsgGDIPlusGraphicsPath(FillMode FillMode)/* overload */;
	__fastcall TsgGDIPlusGraphicsPath(PsgGPointF Points, System::PByte Types, int Count, FillMode FillMode)/* overload */;
	__fastcall TsgGDIPlusGraphicsPath(PsgGPoint Points, System::PByte Types, int Count, FillMode FillMode)/* overload */;
	__fastcall virtual ~TsgGDIPlusGraphicsPath(void);
	TsgGDIPlusGraphicsPath* __fastcall Clone(void);
	Status __fastcall Reset(void);
	FillMode __fastcall GetFillMode(void);
	Status __fastcall SetFillMode(FillMode FillMode);
	Status __fastcall GetPathData(TsgGDIPPathData* PathData);
	Status __fastcall StartFigure(void);
	Status __fastcall CloseFigure(void);
	Status __fastcall CloseAllFigures(void);
	Status __fastcall SetMarker(void);
	Status __fastcall ClearMarkers(void);
	Status __fastcall Reverse(void);
	Status __fastcall GetLastPoint(/* out */ TsgGPointF &lastPoint);
	Status __fastcall AddLine(const TsgGPointF &pt1, const TsgGPointF &pt2)/* overload */;
	Status __fastcall AddLine(float X1, float Y1, float X2, float Y2)/* overload */;
	Status __fastcall AddLines(PsgGPointF Points, int Count)/* overload */;
	Status __fastcall AddLine(const TsgGPoint &pt1, const TsgGPoint &pt2)/* overload */;
	Status __fastcall AddLine(int X1, int Y1, int X2, int Y2)/* overload */;
	Status __fastcall AddLines(PsgGPoint Points, int Count)/* overload */;
	Status __fastcall AddArc(const TsgGRectF &Rect, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall AddArc(float X, float Y, float Width, float Height, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall AddArc(const TsgGRect &Rect, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall AddArc(int X, int Y, int Width, int Height, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall AddBezier(const TsgGPointF &pt1, const TsgGPointF &pt2, const TsgGPointF &pt3, const TsgGPointF &pt4)/* overload */;
	Status __fastcall AddBezier(float X1, float Y1, float X2, float Y2, float X3, float Y3, float X4, float Y4)/* overload */;
	Status __fastcall AddBeziers(PsgGPointF Points, int Count)/* overload */;
	Status __fastcall AddBezier(const TsgGPoint &pt1, const TsgGPoint &pt2, const TsgGPoint &pt3, const TsgGPoint &pt4)/* overload */;
	Status __fastcall AddBezier(int X1, int Y1, int X2, int Y2, int X3, int Y3, int X4, int Y4)/* overload */;
	Status __fastcall AddBeziers(PsgGPoint Points, int Count)/* overload */;
	Status __fastcall AddCurve(PsgGPointF Points, int Count)/* overload */;
	Status __fastcall AddCurve(PsgGPointF Points, int Count, float Tension)/* overload */;
	Status __fastcall AddCurve(PsgGPointF Points, int Count, int offset, int NumberOfSegments, float Tension)/* overload */;
	Status __fastcall AddCurve(PsgGPoint Points, int Count)/* overload */;
	Status __fastcall AddCurve(PsgGPoint Points, int Count, float Tension)/* overload */;
	Status __fastcall AddCurve(PsgGPoint Points, int Count, int offset, int NumberOfSegments, float Tension)/* overload */;
	Status __fastcall AddClosedCurve(PsgGPointF Points, int Count)/* overload */;
	Status __fastcall AddClosedCurve(PsgGPointF Points, int Count, float Tension)/* overload */;
	Status __fastcall AddClosedCurve(PsgGPoint Points, int Count)/* overload */;
	Status __fastcall AddClosedCurve(PsgGPoint Points, int Count, float Tension)/* overload */;
	Status __fastcall AddRectangle(const TsgGRectF &Rect)/* overload */;
	Status __fastcall AddRectangles(PsgGRectF Rects, int Count)/* overload */;
	Status __fastcall AddRectangle(const TsgGRect &Rect)/* overload */;
	Status __fastcall AddRectangles(PsgGRect Rects, int Count)/* overload */;
	Status __fastcall AddEllipse(const TsgGRectF &Rect)/* overload */;
	Status __fastcall AddEllipse(float X, float Y, float Width, float Height)/* overload */;
	Status __fastcall AddEllipse(const TsgGRect &Rect)/* overload */;
	Status __fastcall AddEllipse(int X, int Y, int Width, int Height)/* overload */;
	Status __fastcall AddPie(const TsgGRectF &Rect, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall AddPie(float X, float Y, float Width, float Height, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall AddPie(const TsgGRect &Rect, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall AddPie(int X, int Y, int Width, int Height, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall AddPolygon(PsgGPointF Points, int Count)/* overload */;
	Status __fastcall AddPolygon(PsgGPoint Points, int Count)/* overload */;
	Status __fastcall AddPath(TsgGDIPlusGraphicsPath* AddingPath, BOOL Connect);
	Status __fastcall AddString(WideString String_, int Length, TsgGDIPlusFontFamily* Family, int Style, float ASize, const TsgGPointF &AOrg, TsgGDIPlusStringFormat* Format)/* overload */;
	Status __fastcall AddString(WideString String_, int Length, TsgGDIPlusFontFamily* Family, int Style, float ASize, const TsgGRectF &ALayoutRect, TsgGDIPlusStringFormat* Format)/* overload */;
	Status __fastcall AddString(WideString String_, int Length, TsgGDIPlusFontFamily* Family, int Style, float ASize, const TsgGPoint &AOrg, TsgGDIPlusStringFormat* Format)/* overload */;
	Status __fastcall AddString(WideString String_, int Length, TsgGDIPlusFontFamily* Family, int Style, float ASize, const TsgGRect &ALayoutRect, TsgGDIPlusStringFormat* Format)/* overload */;
	Status __fastcall Transform(const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall GetBounds(/* out */ TsgGRectF &Bounds, const TsgGDIPlusMatrix* AMatrix = (TsgGDIPlusMatrix*)(0x0), TsgGDIPlusPen* Pen = (TsgGDIPlusPen*)(0x0))/* overload */;
	Status __fastcall GetBounds(/* out */ TsgGRect &Bounds, const TsgGDIPlusMatrix* AMatrix = (TsgGDIPlusMatrix*)(0x0), TsgGDIPlusPen* Pen = (TsgGDIPlusPen*)(0x0))/* overload */;
	Status __fastcall Flatten(const TsgGDIPlusMatrix* AMatrix = (TsgGDIPlusMatrix*)(0x0), float Flatness = 2.500000E-01);
	Status __fastcall Widen(TsgGDIPlusPen* Pen, const TsgGDIPlusMatrix* AMatrix = (TsgGDIPlusMatrix*)(0x0), float Flatness = 2.500000E-01);
	Status __fastcall Outline(const TsgGDIPlusMatrix* AMatrix = (TsgGDIPlusMatrix*)(0x0), float Flatness = 2.500000E-01);
	Status __fastcall Warp(PsgGPointF DestPoints, int Count, const TsgGRectF &SrcRect, const TsgGDIPlusMatrix* AMatrix = (TsgGDIPlusMatrix*)(0x0), WarpMode WarpMode = (WarpMode)(0x0), float Flatness = 2.500000E-01);
	int __fastcall GetPointCount(void);
	Status __fastcall GetPathTypes(System::PByte Types, int Count);
	Status __fastcall GetPathPoints(PsgGPointF Points, int Count)/* overload */;
	Status __fastcall GetPathPoints(PsgGPoint Points, int Count)/* overload */;
	Status __fastcall GetStatusOfFunction(void);
	BOOL __fastcall IsVisible(const TsgGPointF &point, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
	BOOL __fastcall IsVisible(float X, float Y, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
	BOOL __fastcall IsVisible(const TsgGPoint &point, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
	BOOL __fastcall IsVisible(int X, int Y, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
	BOOL __fastcall IsOutlineVisible(const TsgGPointF &point, TsgGDIPlusPen* Pen, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
	BOOL __fastcall IsOutlineVisible(float X, float Y, TsgGDIPlusPen* Pen, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
	BOOL __fastcall IsOutlineVisible(const TsgGPoint &point, TsgGDIPlusPen* Pen, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
	BOOL __fastcall IsOutlineVisible(int X, int Y, TsgGDIPlusPen* Pen, TsgGDIPlusGraphics* Graph = (TsgGDIPlusGraphics*)(0x0))/* overload */;
};


class DELPHICLASS TsgGDIPlusGraphicsPathIterator;
class PASCALIMPLEMENTATION TsgGDIPlusGraphicsPathIterator : public TsgGDIPlusBase 
{
	typedef TsgGDIPlusBase inherited;
	
protected:
	void *NativeIterator;
	Status FStatusOfFunction;
	void __fastcall SetNativeIterator(void * NativeIterator);
	Status __fastcall SetStatus(Status Status);
	
public:
	__fastcall TsgGDIPlusGraphicsPathIterator(TsgGDIPlusGraphicsPath* Path);
	__fastcall virtual ~TsgGDIPlusGraphicsPathIterator(void);
	int __fastcall NextSubpath(/* out */ int &StartIndex, /* out */ int &EndIndex, /* out */ BOOL &IsClosed)/* overload */;
	int __fastcall NextSubpath(TsgGDIPlusGraphicsPath* Path, /* out */ BOOL &IsClosed)/* overload */;
	int __fastcall NextPathType(/* out */ Byte &PathType, /* out */ int &StartIndex, /* out */ int &EndIndex);
	int __fastcall NextMarker(/* out */ int &StartIndex, /* out */ int &EndIndex)/* overload */;
	int __fastcall NextMarker(TsgGDIPlusGraphicsPath* Path)/* overload */;
	int __fastcall GetCount(void);
	int __fastcall GetSubpathCount(void);
	BOOL __fastcall HasCurve(void);
	void __fastcall Rewind(void);
	int __fastcall ENumerate(PsgGPointF Points, System::PByte Types, int Count);
	int __fastcall CopyData(PsgGPointF Points, System::PByte Types, int StartIndex, int EndIndex);
	Status __fastcall GetStatusOfFunction(void);
};


class DELPHICLASS TsgGDIPlusPathGradientBrush;
class PASCALIMPLEMENTATION TsgGDIPlusPathGradientBrush : public TsgGDIPlusBrush 
{
	typedef TsgGDIPlusBrush inherited;
	
public:
	__fastcall TsgGDIPlusPathGradientBrush(PsgGPointF Points, int Count, WrapMode WrapMode)/* overload */;
	__fastcall TsgGDIPlusPathGradientBrush(PsgGPoint Points, int Count, WrapMode WrapMode)/* overload */;
	__fastcall TsgGDIPlusPathGradientBrush(TsgGDIPlusGraphicsPath* Path)/* overload */;
	__fastcall TsgGDIPlusPathGradientBrush(void)/* overload */;
	Status __fastcall GetCenterColor(/* out */ unsigned &Color);
	Status __fastcall SetCenterColor(unsigned Color);
	int __fastcall GetPointCount(void);
	int __fastcall GetSurroundColorCount(void);
	Status __fastcall GetSurroundColors(PARGB Colors, int &Count);
	Status __fastcall SetSurroundColors(PARGB Colors, int &Count);
	Status __fastcall GetGraphicsPath(TsgGDIPlusGraphicsPath* Path);
	Status __fastcall SetGraphicsPath(TsgGDIPlusGraphicsPath* Path);
	Status __fastcall GetCenterPoint(/* out */ TsgGPointF &point)/* overload */;
	Status __fastcall GetCenterPoint(/* out */ TsgGPoint &point)/* overload */;
	Status __fastcall SetCenterPoint(const TsgGPointF &point)/* overload */;
	Status __fastcall SetCenterPoint(const TsgGPoint &point)/* overload */;
	Status __fastcall GetRectangle(/* out */ TsgGRectF &Rect)/* overload */;
	Status __fastcall GetRectangle(/* out */ TsgGRect &Rect)/* overload */;
	Status __fastcall SetGammaCorRection(BOOL UseGammaCorRection)/* overload */;
	BOOL __fastcall GetGammaCorRection(void)/* overload */;
	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 APresetColors, Windows::PSingle BlendPositions, int Count);
	Status __fastcall GetInterpolationColors(PARGB APresetColors, 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);
	Status __fastcall GetTransform(const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall SetTransform(const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall ResetTransform(void);
	Status __fastcall MultiplyTransform(const TsgGDIPlusMatrix* AMatrix, 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 GetFocusScales(/* out */ float &XScale, /* out */ float &YScale);
	Status __fastcall SetFocusScales(float XScale, float YScale);
	WrapMode __fastcall GetWrapMode(void);
	Status __fastcall SetWrapMode(WrapMode WrapMode);
public:
	#pragma option push -w-inl
	/* TsgGDIPlusBrush.Destroy */ inline __fastcall virtual ~TsgGDIPlusPathGradientBrush(void) { }
	#pragma option pop
	
};


class DELPHICLASS TsgGDIPlusMetaFile;
class PASCALIMPLEMENTATION TsgGDIPlusGraphics : public TsgGDIPlusBase 
{
	typedef TsgGDIPlusBase inherited;
	
protected:
	void *NativeGraphics;
	Status FStatusOfFunction;
	int FSrcUnit;
	void __fastcall SetNativeGraphics(void * Graphics);
	Status __fastcall SetStatus(Status Status);
	void * __fastcall GetNativeGraphics(void);
	void * __fastcall GetNativePen(TsgGDIPlusPen* Pen);
	__fastcall TsgGDIPlusGraphics(void * Graphics)/* overload */;
	
public:
	TsgGDIPlusGraphics* __fastcall FromHDC(HDC ADC)/* overload */;
	TsgGDIPlusGraphics* __fastcall FromHDC(HDC ADC, unsigned hdevice)/* overload */;
	TsgGDIPlusGraphics* __fastcall FromHWND(HWND hwnd, BOOL icm = false);
	TsgGDIPlusGraphics* __fastcall FromImage(TsgGDIPlusImage* Image);
	__fastcall TsgGDIPlusGraphics(HDC ADC)/* overload */;
	__fastcall TsgGDIPlusGraphics(HDC ADC, unsigned hdevice)/* overload */;
	__fastcall TsgGDIPlusGraphics(HWND hwnd, BOOL icm)/* overload */;
	__fastcall TsgGDIPlusGraphics(TsgGDIPlusImage* Image)/* overload */;
	__fastcall virtual ~TsgGDIPlusGraphics(void);
	void __fastcall Flush(FlushIntention Intention = (FlushIntention)(0x0));
	HDC __fastcall GetHDC(void);
	void __fastcall ReleaseHDC(HDC ADC);
	Status __fastcall SetRenderingOrigin(int X, int Y);
	Status __fastcall GetRenderingOrigin(/* out */ int &X, /* out */ int &Y);
	Status __fastcall SetCompositingMode(CompositingMode CompositingMode);
	CompositingMode __fastcall GetCompositingMode(void);
	Status __fastcall SetCompositingQuality(int CompositingQuality);
	int __fastcall GetCompositingQuality(void);
	Status __fastcall SetTextRenderingHint(TextRenderingHint newMode);
	TextRenderingHint __fastcall GetTextRenderingHint(void);
	Status __fastcall SetTextContrast(unsigned Contrast);
	unsigned __fastcall GetTextContrast(void);
	int __fastcall GetInterpolationMode(void);
	Status __fastcall SetInterpolationMode(int InterpolationMode);
	int __fastcall GetSmoothingMode(void);
	Status __fastcall SetSmoothingMode(int SmoothingMode);
	int __fastcall GetPixelOffsetMode(void);
	Status __fastcall SetPixelOffsetMode(int PixelOffsetMode);
	Status __fastcall SetTransform(const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall ResetTransform(void);
	Status __fastcall MultiplyTransform(const TsgGDIPlusMatrix* AMatrix, 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 GetTransform(const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall SetPageUnit(int Unit_);
	Status __fastcall SetPageScale(float Scale);
	int __fastcall GetPageUnit(void);
	float __fastcall GetPageScale(void);
	float __fastcall GetDpiX(void);
	float __fastcall GetDpiY(void);
	Status __fastcall TransformPoints(CoordinateSpace DestSpace, CoordinateSpace SrcSpace, PsgGPointF Pts, int Count)/* overload */;
	Status __fastcall TransformPoints(CoordinateSpace DestSpace, CoordinateSpace SrcSpace, PsgGPoint Pts, int Count)/* overload */;
	Status __fastcall GetNearestColor(unsigned &Color);
	Status __fastcall DrawLine(TsgGDIPlusPen* Pen, float X1, float Y1, float X2, float Y2)/* overload */;
	Status __fastcall DrawLine(TsgGDIPlusPen* Pen, const TsgGPointF &pt1, const TsgGPointF &pt2)/* overload */;
	Status __fastcall DrawLines(TsgGDIPlusPen* Pen, PsgGPointF Points, int Count)/* overload */;
	Status __fastcall DrawLine(TsgGDIPlusPen* Pen, int X1, int Y1, int X2, int Y2)/* overload */;
	Status __fastcall DrawLine(TsgGDIPlusPen* Pen, const TsgGPoint &pt1, const TsgGPoint &pt2)/* overload */;
	Status __fastcall DrawLines(TsgGDIPlusPen* Pen, PsgGPoint Points, int Count)/* overload */;
	Status __fastcall DrawArc(TsgGDIPlusPen* Pen, float X, float Y, float Width, float Height, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall DrawArc(TsgGDIPlusPen* Pen, const TsgGRectF &Rect, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall DrawArc(TsgGDIPlusPen* Pen, int X, int Y, int Width, int Height, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall DrawArc(TsgGDIPlusPen* Pen, const TsgGRect &Rect, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall DrawBezier(TsgGDIPlusPen* Pen, float X1, float Y1, float X2, float Y2, float X3, float Y3, float X4, float Y4)/* overload */;
	Status __fastcall DrawBezier(TsgGDIPlusPen* Pen, const TsgGPointF &pt1, const TsgGPointF &pt2, const TsgGPointF &pt3, const TsgGPointF &pt4)/* overload */;
	Status __fastcall DrawBeziers(TsgGDIPlusPen* Pen, PsgGPointF Points, int Count)/* overload */;
	Status __fastcall DrawBezier(TsgGDIPlusPen* Pen, int X1, int Y1, int X2, int Y2, int X3, int Y3, int X4, int Y4)/* overload */;
	Status __fastcall DrawBezier(TsgGDIPlusPen* Pen, const TsgGPoint &pt1, const TsgGPoint &pt2, const TsgGPoint &pt3, const TsgGPoint &pt4)/* overload */;
	Status __fastcall DrawBeziers(TsgGDIPlusPen* Pen, PsgGPoint Points, int Count)/* overload */;
	Status __fastcall DrawRectangle(TsgGDIPlusPen* Pen, const TsgGRectF &Rect)/* overload */;
	Status __fastcall DrawRectangle(TsgGDIPlusPen* Pen, float X, float Y, float Width, float Height)/* overload */;
	Status __fastcall DrawRectangles(TsgGDIPlusPen* Pen, PsgGRectF Rects, int Count)/* overload */;
	Status __fastcall DrawRectangle(TsgGDIPlusPen* Pen, const TsgGRect &Rect)/* overload */;
	Status __fastcall DrawRectangle(TsgGDIPlusPen* Pen, int X, int Y, int Width, int Height)/* overload */;
	Status __fastcall DrawRectangles(TsgGDIPlusPen* Pen, PsgGRect Rects, int Count)/* overload */;
	Status __fastcall DrawEllipse(TsgGDIPlusPen* Pen, const TsgGRectF &Rect)/* overload */;
	Status __fastcall DrawEllipse(TsgGDIPlusPen* Pen, float X, float Y, float Width, float Height)/* overload */;
	Status __fastcall DrawEllipse(TsgGDIPlusPen* Pen, const TsgGRect &Rect)/* overload */;
	Status __fastcall DrawEllipse(TsgGDIPlusPen* Pen, int X, int Y, int Width, int Height)/* overload */;
	Status __fastcall DrawPie(TsgGDIPlusPen* Pen, const TsgGRectF &Rect, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall DrawPie(TsgGDIPlusPen* Pen, float X, float Y, float Width, float Height, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall DrawPie(TsgGDIPlusPen* Pen, const TsgGRect &Rect, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall DrawPie(TsgGDIPlusPen* Pen, int X, int Y, int Width, int Height, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall DrawPolygon(TsgGDIPlusPen* Pen, PsgGPointF Points, int Count)/* overload */;
	Status __fastcall DrawPolygon(TsgGDIPlusPen* Pen, PsgGPoint Points, int Count)/* overload */;
	Status __fastcall DrawPath(TsgGDIPlusPen* Pen, TsgGDIPlusGraphicsPath* Path);
	Status __fastcall DrawCurve(TsgGDIPlusPen* Pen, PsgGPointF Points, int Count)/* overload */;
	Status __fastcall DrawCurve(TsgGDIPlusPen* Pen, PsgGPointF Points, int Count, float Tension)/* overload */;
	Status __fastcall DrawCurve(TsgGDIPlusPen* Pen, PsgGPointF Points, int Count, int offset, int NumberOfSegments, float Tension = 5.000000E-01)/* overload */;
	Status __fastcall DrawCurve(TsgGDIPlusPen* Pen, PsgGPoint Points, int Count)/* overload */;
	Status __fastcall DrawCurve(TsgGDIPlusPen* Pen, PsgGPoint Points, int Count, float Tension)/* overload */;
	Status __fastcall DrawCurve(TsgGDIPlusPen* Pen, PsgGPoint Points, int Count, int offset, int NumberOfSegments, float Tension = 5.000000E-01)/* overload */;
	Status __fastcall DrawClosedCurve(TsgGDIPlusPen* Pen, PsgGPointF Points, int Count)/* overload */;
	Status __fastcall DrawClosedCurve(TsgGDIPlusPen* Pen, PsgGPointF Points, int Count, float Tension)/* overload */;
	Status __fastcall DrawClosedCurve(TsgGDIPlusPen* Pen, PsgGPoint Points, int Count)/* overload */;
	Status __fastcall DrawClosedCurve(TsgGDIPlusPen* Pen, PsgGPoint Points, int Count, float Tension)/* overload */;
	Status __fastcall Clear(unsigned Color);
	Status __fastcall FillRectangle(TsgGDIPlusBrush* Brush, const TsgGRectF &Rect)/* overload */;
	Status __fastcall FillRectangle(TsgGDIPlusBrush* Brush, float X, float Y, float Width, float Height)/* overload */;
	Status __fastcall FillRectangles(TsgGDIPlusBrush* Brush, PsgGRectF Rects, int Count)/* overload */;
	Status __fastcall FillRectangle(TsgGDIPlusBrush* Brush, const TsgGRect &Rect)/* overload */;
	Status __fastcall FillRectangle(TsgGDIPlusBrush* Brush, int X, int Y, int Width, int Height)/* overload */;
	Status __fastcall FillRectangles(TsgGDIPlusBrush* Brush, PsgGRect Rects, int Count)/* overload */;
	Status __fastcall FillPolygon(TsgGDIPlusBrush* Brush, PsgGPointF Points, int Count)/* overload */;
	Status __fastcall FillPolygon(TsgGDIPlusBrush* Brush, PsgGPointF Points, int Count, FillMode FillMode)/* overload */;
	Status __fastcall FillPolygon(TsgGDIPlusBrush* Brush, PsgGPoint Points, int Count)/* overload */;
	Status __fastcall FillPolygon(TsgGDIPlusBrush* Brush, PsgGPoint Points, int Count, FillMode FillMode)/* overload */;
	Status __fastcall FillEllipse(TsgGDIPlusBrush* Brush, const TsgGRectF &Rect)/* overload */;
	Status __fastcall FillEllipse(TsgGDIPlusBrush* Brush, float X, float Y, float Width, float Height)/* overload */;
	Status __fastcall FillEllipse(TsgGDIPlusBrush* Brush, const TsgGRect &Rect)/* overload */;
	Status __fastcall FillEllipse(TsgGDIPlusBrush* Brush, int X, int Y, int Width, int Height)/* overload */;
	Status __fastcall FillPie(TsgGDIPlusBrush* Brush, const TsgGRectF &Rect, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall FillPie(TsgGDIPlusBrush* Brush, float X, float Y, float Width, float Height, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall FillPie(TsgGDIPlusBrush* Brush, const TsgGRect &Rect, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall FillPie(TsgGDIPlusBrush* Brush, int X, int Y, int Width, int Height, float StartAngle, float SweepAngle)/* overload */;
	Status __fastcall FillPath(TsgGDIPlusBrush* Brush, TsgGDIPlusGraphicsPath* Path);
	Status __fastcall FillClosedCurve(TsgGDIPlusBrush* Brush, PsgGPointF Points, int Count)/* overload */;
	Status __fastcall FillClosedCurve(TsgGDIPlusBrush* Brush, PsgGPointF Points, int Count, FillMode FillMode, float Tension = 5.000000E-01)/* overload */;
	Status __fastcall FillClosedCurve(TsgGDIPlusBrush* Brush, PsgGPoint Points, int Count)/* overload */;
	Status __fastcall FillClosedCurve(TsgGDIPlusBrush* Brush, PsgGPoint Points, int Count, FillMode FillMode, float Tension = 5.000000E-01)/* overload */;
	Status __fastcall FillRegion(TsgGDIPlusBrush* Brush, TsgGDIPlusRegion* Region);
	Status __fastcall DrawString(WideString String_, int Length, TsgGDIPlusFont* Font, const TsgGRectF &ALayoutRect, TsgGDIPlusStringFormat* stringFormat, TsgGDIPlusBrush* Brush)/* overload */;
	Status __fastcall DrawString(WideString String_, int Length, TsgGDIPlusFont* Font, const TsgGPointF &AOrg, TsgGDIPlusBrush* Brush)/* overload */;
	Status __fastcall DrawString(WideString String_, int Length, TsgGDIPlusFont* Font, const TsgGPointF &AOrg, TsgGDIPlusStringFormat* stringFormat, TsgGDIPlusBrush* Brush)/* overload */;
	Status __fastcall MeasureString(WideString String_, int Length, TsgGDIPlusFont* Font, const TsgGRectF &ALayoutRect, TsgGDIPlusStringFormat* stringFormat, /* out */ TsgGRectF &BoundingBox, System::PInteger codePointsFitted = (void *)(0x0), System::PInteger linesFilled = (void *)(0x0))/* overload */;
	Status __fastcall MeasureString(WideString String_, int Length, TsgGDIPlusFont* Font, const TsgGSizeF &ALayoutRectSize, TsgGDIPlusStringFormat* stringFormat, /* out */ TsgGSizeF &Size, System::PInteger codePointsFitted = (void *)(0x0), System::PInteger linesFilled = (void *)(0x0))/* overload */;
	Status __fastcall MeasureString(WideString String_, int Length, TsgGDIPlusFont* Font, const TsgGPointF &AOrg, TsgGDIPlusStringFormat* stringFormat, /* out */ TsgGRectF &BoundingBox)/* overload */;
	Status __fastcall MeasureString(WideString String_, int Length, TsgGDIPlusFont* Font, const TsgGRectF &ALayoutRect, /* out */ TsgGRectF &BoundingBox)/* overload */;
	Status __fastcall MeasureString(WideString String_, int Length, TsgGDIPlusFont* Font, const TsgGPointF &AOrg, /* out */ TsgGRectF &BoundingBox)/* overload */;
	Status __fastcall MeasureCharacterRanges(WideString String_, int Length, TsgGDIPlusFont* Font, const TsgGRectF &ALayoutRect, TsgGDIPlusStringFormat* stringFormat, int RegionCount, TsgGDIPlusRegion* const * Regions, const int Regions_Size)/* overload */;
	Status __fastcall DrawDriverString(PUINT16 text, int Length, TsgGDIPlusFont* Font, TsgGDIPlusBrush* Brush, PsgGPointF Positions, int Flags, const TsgGDIPlusMatrix* AMatrix);
	Status __fastcall MeasureDriverString(PUINT16 text, int Length, TsgGDIPlusFont* Font, PsgGPointF Positions, int Flags, const TsgGDIPlusMatrix* AMatrix, /* out */ TsgGRectF &BoundingBox);
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, const TsgGPointF &point)/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, float X, float Y)/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, const TsgGRectF &Rect)/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, float X, float Y, float Width, float Height)/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, const TsgGPoint &point)/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, int X, int Y)/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, const TsgGRect &Rect)/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, int X, int Y, int Width, int Height)/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, PsgGPointF DestPoints, int Count)/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, PsgGPoint DestPoints, int Count)/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, float X, float Y, float SrcX, float SrcY, float SrcWidth, float SrcHeight, int SrcUnit)/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, const TsgGRectF &DestRect, float SrcX, float SrcY, float SrcWidth, float SrcHeight, int SrcUnit, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, PsgGPointF DestPoints, int Count, float SrcX, float SrcY, float SrcWidth, float SrcHeight, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, int X, int Y, int SrcX, int SrcY, int SrcWidth, int SrcHeight, int SrcUnit)/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, const TsgGRect &DestRect, int SrcX, int SrcY, int SrcWidth, int SrcHeight, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall DrawImage(TsgGDIPlusImage* Image, PsgGPoint DestPoints, int Count, int SrcX, int SrcY, int SrcWidth, int SrcHeight, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall ENumerateMetaFile(TsgGDIPlusMetaFile* MetaFile, const TsgGPointF &DestPoint, EnumerateMetafileProc MCallBack, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall ENumerateMetaFile(TsgGDIPlusMetaFile* MetaFile, const TsgGPoint &DestPoint, EnumerateMetafileProc MCallBack, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall ENumerateMetaFile(TsgGDIPlusMetaFile* MetaFile, const TsgGRectF &DestRect, EnumerateMetafileProc MCallBack, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall ENumerateMetaFile(TsgGDIPlusMetaFile* MetaFile, const TsgGRect &DestRect, EnumerateMetafileProc MCallBack, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall ENumerateMetaFile(TsgGDIPlusMetaFile* MetaFile, PsgGPointF DestPoints, int Count, EnumerateMetafileProc MCallBack, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall ENumerateMetaFile(TsgGDIPlusMetaFile* MetaFile, PsgGPoint DestPoints, int Count, EnumerateMetafileProc MCallBack, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall ENumerateMetaFile(TsgGDIPlusMetaFile* MetaFile, const TsgGPointF &DestPoint, const TsgGRectF &SrcRect, EnumerateMetafileProc MCallBack, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall ENumerateMetaFile(TsgGDIPlusMetaFile* MetaFile, const TsgGPoint &DestPoint, const TsgGRect &SrcRect, EnumerateMetafileProc MCallBack, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall ENumerateMetaFile(TsgGDIPlusMetaFile* MetaFile, const TsgGRectF &DestRect, const TsgGRectF &SrcRect, EnumerateMetafileProc MCallBack, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall ENumerateMetaFile(TsgGDIPlusMetaFile* MetaFile, const TsgGRect &DestRect, const TsgGRect &SrcRect, EnumerateMetafileProc MCallBack, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall ENumerateMetaFile(TsgGDIPlusMetaFile* MetaFile, PsgGPointF DestPoints, int Count, const TsgGRectF &SrcRect, EnumerateMetafileProc MCallBack, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall ENumerateMetaFile(TsgGDIPlusMetaFile* MetaFile, PsgGPoint DestPoints, int Count, const TsgGRect &SrcRect, EnumerateMetafileProc MCallBack, TsgGDIPlusImageAttributes* ImageAttributes = (TsgGDIPlusImageAttributes*)(0x0))/* overload */;
	Status __fastcall SetClip(TsgGDIPlusGraphics* Graph, CombineMode CombineMode = (CombineMode)(0x0))/* overload */;
	Status __fastcall SetClip(const TsgGRectF &Rect, CombineMode CombineMode = (CombineMode)(0x0))/* overload */;
	Status __fastcall SetClip(const TsgGRect &Rect, CombineMode CombineMode = (CombineMode)(0x0))/* overload */;
	Status __fastcall SetClip(TsgGDIPlusGraphicsPath* Path, CombineMode CombineMode = (CombineMode)(0x0))/* overload */;
	Status __fastcall SetClip(TsgGDIPlusRegion* Region, CombineMode CombineMode = (CombineMode)(0x0))/* overload */;
	Status __fastcall SetClip(HRGN hRgn, CombineMode CombineMode = (CombineMode)(0x0))/* overload */;
	Status __fastcall IntersectClip(const TsgGRectF &Rect)/* overload */;
	Status __fastcall IntersectClip(const TsgGRect &Rect)/* overload */;
	Status __fastcall IntersectClip(TsgGDIPlusRegion* Region)/* overload */;
	Status __fastcall ExcludeClip(const TsgGRectF &Rect)/* overload */;
	Status __fastcall ExcludeClip(const TsgGRect &Rect)/* overload */;
	Status __fastcall ExcludeClip(TsgGDIPlusRegion* Region)/* overload */;
	Status __fastcall ResetClip(void);
	Status __fastcall TranslateClip(float Dx, float Dy)/* overload */;
	Status __fastcall TranslateClip(int Dx, int Dy)/* overload */;
	Status __fastcall GetClip(TsgGDIPlusRegion* Region);
	Status __fastcall GetClipBounds(/* out */ TsgGRectF &Rect)/* overload */;
	Status __fastcall GetClipBounds(/* out */ TsgGRect &Rect)/* overload */;
	BOOL __fastcall IsClipEmpty(void);
	Status __fastcall GetVisibleClipBounds(/* out */ TsgGRectF &Rect)/* overload */;
	Status __fastcall GetVisibleClipBounds(/* out */ TsgGRect &Rect)/* overload */;
	BOOL __fastcall IsVisibleClipEmpty(void);
	BOOL __fastcall IsVisible(int X, int Y)/* overload */;
	BOOL __fastcall IsVisible(const TsgGPoint &point)/* overload */;
	BOOL __fastcall IsVisible(int X, int Y, int Width, int Height)/* overload */;
	BOOL __fastcall IsVisible(const TsgGRect &Rect)/* overload */;
	BOOL __fastcall IsVisible(float X, float Y)/* overload */;
	BOOL __fastcall IsVisible(const TsgGPointF &point)/* overload */;
	BOOL __fastcall IsVisible(float X, float Y, float Width, float Height)/* overload */;
	BOOL __fastcall IsVisible(const TsgGRectF &Rect)/* overload */;
	unsigned __fastcall Save(void);
	Status __fastcall Restore(unsigned gState);
	unsigned __fastcall BeginContainer(const TsgGRectF &DstRect, const TsgGRectF &SrcRect, int Unit_)/* overload */;
	unsigned __fastcall BeginContainer(const TsgGRect &DstRect, const TsgGRect &SrcRect, int Unit_)/* overload */;
	unsigned __fastcall BeginContainer(void)/* overload */;
	Status __fastcall EndContainer(unsigned State);
	Status __fastcall AddMetaFileComment(System::PByte Data, unsigned SizeData);
	HPALETTE __fastcall GetHalftonePalette(void);
	Status __fastcall GetStatusOfFunction(void);
	__property int SrcUnit = {read=FSrcUnit, write=FSrcUnit, nodefault};
};


class DELPHICLASS TsgGDIPlusAdjustableArrowCap;
class PASCALIMPLEMENTATION TsgGDIPlusAdjustableArrowCap : public TsgGDIPlusCustomLineCap 
{
	typedef TsgGDIPlusCustomLineCap inherited;
	
public:
	__fastcall TsgGDIPlusAdjustableArrowCap(float Height, float Width, BOOL isFilled);
	Status __fastcall SetHeight(float Height);
	float __fastcall GetHeight(void);
	Status __fastcall SetWidth(float Width);
	float __fastcall GetWidth(void);
	Status __fastcall SetMiddleInset(float MiddleInset);
	float __fastcall GetMiddleInset(void);
	Status __fastcall SetFillState(BOOL isFilled);
	BOOL __fastcall IsFilled(void);
public:
	#pragma option push -w-inl
	/* TsgGDIPlusCustomLineCap.Destroy */ inline __fastcall virtual ~TsgGDIPlusAdjustableArrowCap(void) { }
	#pragma option pop
	
};


class PASCALIMPLEMENTATION TsgGDIPlusMetaFile : public TsgGDIPlusImage 
{
	typedef TsgGDIPlusImage inherited;
	
public:
	__fastcall TsgGDIPlusMetaFile(unsigned hWmf, WmfPlaceableFileHeader &wmfPlaceableFileHeader, BOOL DeleteWmf)/* overload */;
	__fastcall TsgGDIPlusMetaFile(unsigned hEmf, BOOL DeleteEmf)/* overload */;
	__fastcall TsgGDIPlusMetaFile(WideString FileName)/* overload */;
	__fastcall TsgGDIPlusMetaFile(WideString FileName, WmfPlaceableFileHeader &wmfPlaceableFileHeader)/* overload */;
	__fastcall TsgGDIPlusMetaFile(_di_IStream Stream)/* overload */;
	__fastcall TsgGDIPlusMetaFile(HDC ReferenceHdc, int Type_, WideChar * description)/* overload */;
	__fastcall TsgGDIPlusMetaFile(HDC ReferenceHdc, const TsgGRectF &FrameRect, int FrameUnit, int Type_, WideChar * description)/* overload */;
	__fastcall TsgGDIPlusMetaFile(HDC ReferenceHdc, const TsgGRect &FrameRect, int FrameUnit, int Type_, WideChar * description)/* overload */;
	__fastcall TsgGDIPlusMetaFile(WideString FileName, HDC ReferenceHdc, int Type_, WideChar * description)/* overload */;
	__fastcall TsgGDIPlusMetaFile(WideString FileName, HDC ReferenceHdc, const TsgGRectF &FrameRect, int FrameUnit, int Type_, WideChar * description)/* overload */;
	__fastcall TsgGDIPlusMetaFile(WideString FileName, HDC ReferenceHdc, const TsgGRect &FrameRect, int FrameUnit, int Type_, WideChar * description)/* overload */;
	__fastcall TsgGDIPlusMetaFile(_di_IStream Stream, HDC ReferenceHdc, int Type_, WideChar * description)/* overload */;
	__fastcall TsgGDIPlusMetaFile(_di_IStream Stream, HDC ReferenceHdc, const TsgGRectF &FrameRect, int FrameUnit, int Type_, WideChar * description)/* overload */;
	__fastcall TsgGDIPlusMetaFile(_di_IStream Stream, HDC ReferenceHdc, const TsgGRect &FrameRect, int FrameUnit, int Type_, WideChar * description)/* overload */;
	__fastcall TsgGDIPlusMetaFile(void)/* overload */;
	Status __fastcall GetMetaFileHeader(unsigned hWmf, WmfPlaceableFileHeader &wmfPlaceableFileHeader, TMetafileHeader* header)/* overload */;
	Status __fastcall GetMetaFileHeader(unsigned hEmf, TMetafileHeader* header)/* overload */;
	Status __fastcall GetMetaFileHeader(WideString FileName, TMetafileHeader* header)/* overload */;
	Status __fastcall GetMetaFileHeader(_di_IStream Stream, TMetafileHeader* header)/* overload */;
	Status __fastcall GetMetaFileHeader(TMetafileHeader* header)/* overload */;
	unsigned __fastcall GetHENHMETAFILE(void);
	Status __fastcall PlayRecOrd(int RecordType, unsigned flags, unsigned DataSize, System::PByte Data);
	Status __fastcall SetDownLevelRasterizationLimit(unsigned MetaFileRasterizationLimitDpi);
	unsigned __fastcall GetDownLevelRasterizationLimit(void);
	unsigned __fastcall EmfToWmfBits(unsigned hemf, unsigned cbData16, System::PByte pData16, int iMapMode = 0x8, int eFlags = 0x0);
public:
	#pragma option push -w-inl
	/* TsgGDIPlusImage.Destroy */ inline __fastcall virtual ~TsgGDIPlusMetaFile(void) { }
	#pragma option pop
	
};


//-- var, const, procedure ---------------------------------------------------
#define FlatnessDefault  (2.500000E-01)
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 UnitWorld = 0x0;
static const Shortint UnitDisplay = 0x1;
static const Shortint UnitPixel = 0x2;
static const Shortint UnitPoint = 0x3;
static const Shortint UnitInch = 0x4;
static const Shortint UnitDocument = 0x5;
static const Shortint UnitMillimeter = 0x6;
static const Shortint MetafileFrameUnitPixel = 0x2;
static const Shortint MetafileFrameUnitPoint = 0x3;
static const Shortint MetafileFrameUnitInch = 0x4;
static const Shortint MetafileFrameUnitDocument = 0x5;
static const Shortint MetafileFrameUnitMillimeter = 0x6;
static const Shortint MetafileFrameUnitGdi = 0x7;
#define HatchStyleLargeGrid (HatchStyle)(4)
#define HatchStyleMin (HatchStyle)(0)
#define HatchStyleMax (HatchStyle)(52)
static const Shortint DashCapFlat = 0x0;
static const Shortint DashCapRound = 0x2;
static const Shortint DashCapTriangle = 0x3;
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;
extern PACKAGE Byte PathPointTypeStart;
extern PACKAGE Byte PathPointTypeLine;
extern PACKAGE Byte PathPointTypeBezier;
extern PACKAGE Byte PathPointTypePathTypeMask;
extern PACKAGE Byte PathPointTypeDashMode;
extern PACKAGE Byte PathPointTypePathMarker;
extern PACKAGE Byte PathPointTypeCloseSubpath;
extern PACKAGE Byte PathPointTypeBezier3;
static const Shortint InterpolationModeInvalid = -1;
static const Shortint InterpolationModeDefault = 0x0;
static const Shortint InterpolationModeLowQuality = 0x1;
static const Shortint InterpolationModeHighQuality = 0x2;
static const Shortint InterpolationModeBilinear = 0x3;
static const Shortint InterpolationModeBicubic = 0x4;
static const Shortint InterpolationModeNearestNeighbor = 0x5;
static const Shortint InterpolationModeHighQualityBilinear = 0x6;
static const Shortint InterpolationModeHighQualityBicubic = 0x7;
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 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 EmfTypeEmfOnly = 3;
static const Shortint EmfTypeEmfPlusOnly = 4;
static const Shortint EmfTypeEmfPlusDual = 5;
#define ObjectTypeMax (ObjectType)(9)
#define ObjectTypeMin (ObjectType)(1)
static const Word GDIP_EMFPLUS_RECORD_BASE = 0x4000;
static const int GDIP_WMF_RECORD_BASE = 0x10000;
static const int WmfRecordTypeSetBkColor = 0x10201;
static const int WmfRecordTypeSetBkMode = 0x10102;
static const int WmfRecordTypeSetMapMode = 0x10103;
static const int WmfRecordTypeSetROP2 = 0x10104;
static const int WmfRecordTypeSetRelAbs = 0x10105;
static const int WmfRecordTypeSetPolyFillMode = 0x10106;
static const int WmfRecordTypeSetStretchBltMode = 0x10107;
static const int WmfRecordTypeSetTextCharExtra = 0x10108;
static const int WmfRecordTypeSetTextColor = 0x10209;
static const int WmfRecordTypeSetTextJustification = 0x1020a;
static const int WmfRecordTypeSetWindowOrg = 0x1020b;
static const int WmfRecordTypeSetWindowExt = 0x1020c;
static const int WmfRecordTypeSetViewportOrg = 0x1020d;
static const int WmfRecordTypeSetViewportExt = 0x1020e;
static const int WmfRecordTypeOffsetWindowOrg = 0x1020f;
static const int WmfRecordTypeScaleWindowExt = 0x10410;
static const int WmfRecordTypeOffsetViewportOrg = 0x10211;
static const int WmfRecordTypeScaleViewportExt = 0x10412;
static const int WmfRecordTypeLineTo = 0x10213;
static const int WmfRecordTypeMoveTo = 0x10214;
static const int WmfRecordTypeExcludeClipRect = 0x10415;
static const int WmfRecordTypeIntersectClipRect = 0x10416;
static const int WmfRecordTypeArc = 0x10817;
static const int WmfRecordTypeEllipse = 0x10418;
static const int WmfRecordTypeFloodFill = 0x10419;
static const int WmfRecordTypePie = 0x1081a;
static const int WmfRecordTypeRectangle = 0x1041b;
static const int WmfRecordTypeRoundRect = 0x1061c;
static const int WmfRecordTypePatBlt = 0x1061d;
static const int WmfRecordTypeSaveDC = 0x1001e;
static const int WmfRecordTypeSetPixel = 0x1041f;
static const int WmfRecordTypeOffsetClipRgn = 0x10220;
static const int WmfRecordTypeTextOut = 0x10521;
static const int WmfRecordTypeBitBlt = 0x10922;
static const int WmfRecordTypeStretchBlt = 0x10b23;
static const int WmfRecordTypePolygon = 0x10324;
static const int WmfRecordTypePolyline = 0x10325;
static const int WmfRecordTypeEscape = 0x10626;
static const int WmfRecordTypeRestoreDC = 0x10127;
static const int WmfRecordTypeFillRegion = 0x10228;
static const int WmfRecordTypeFrameRegion = 0x10429;
static const int WmfRecordTypeInvertRegion = 0x1012a;
static const int WmfRecordTypePaintRegion = 0x1012b;
static const int WmfRecordTypeSelectClipRegion = 0x1012c;
static const int WmfRecordTypeSelectObject = 0x1012d;
static const int WmfRecordTypeSetTextAlign = 0x1012e;
static const int WmfRecordTypeDrawText = 0x1062f;
static const int WmfRecordTypeChord = 0x10830;
static const int WmfRecordTypeSetMapperFlags = 0x10231;
static const int WmfRecordTypeExtTextOut = 0x10a32;
static const int WmfRecordTypeSetDIBToDev = 0x10d33;
static const int WmfRecordTypeSelectPalette = 0x10234;
static const int WmfRecordTypeRealizePalette = 0x10035;
static const int WmfRecordTypeAnimatePalette = 0x10436;
static const int WmfRecordTypeSetPalEntries = 0x10037;
static const int WmfRecordTypePolyPolygon = 0x10538;
static const int WmfRecordTypeResizePalette = 0x10139;
static const int WmfRecordTypeDIBBitBlt = 0x10940;
static const int WmfRecordTypeDIBStretchBlt = 0x10b41;
static const int WmfRecordTypeDIBCreatePatternBrush = 0x10142;
static const int WmfRecordTypeStretchDIB = 0x10f43;
static const int WmfRecordTypeExtFloodFill = 0x10548;
static const int WmfRecordTypeSetLayout = 0x10149;
static const int WmfRecordTypeResetDC = 0x1014c;
static const int WmfRecordTypeStartDoc = 0x1014d;
static const int WmfRecordTypeStartPage = 0x1004f;
static const int WmfRecordTypeEndPage = 0x10050;
static const int WmfRecordTypeAbortDoc = 0x10052;
static const int WmfRecordTypeEndDoc = 0x1005e;
static const int WmfRecordTypeDeleteObject = 0x101f0;
static const int WmfRecordTypeCreatePalette = 0x100f7;
static const int WmfRecordTypeCreateBrush = 0x100f8;
static const int WmfRecordTypeCreatePatternBrush = 0x101f9;
static const int WmfRecordTypeCreatePenIndirect = 0x102fa;
static const int WmfRecordTypeCreateFontIndirect = 0x102fb;
static const int WmfRecordTypeCreateBrushIndirect = 0x102fc;
static const int WmfRecordTypeCreateBitmapIndirect = 0x102fd;
static const int WmfRecordTypeCreateBitmap = 0x106fe;
static const int WmfRecordTypeCreateRegion = 0x106ff;
static const Shortint EmfRecordTypeHeader = 0x1;
static const Shortint EmfRecordTypePolyBezier = 0x2;
static const Shortint EmfRecordTypePolygon = 0x3;
static const Shortint EmfRecordTypePolyline = 0x4;
static const Shortint EmfRecordTypePolyBezierTo = 0x5;
static const Shortint EmfRecordTypePolyLineTo = 0x6;
static const Shortint EmfRecordTypePolyPolyline = 0x7;
static const Shortint EmfRecordTypePolyPolygon = 0x8;
static const Shortint EmfRecordTypeSetWindowExtEx = 0x9;
static const Shortint EmfRecordTypeSetWindowOrgEx = 0xa;
static const Shortint EmfRecordTypeSetViewportExtEx = 0xb;
static const Shortint EmfRecordTypeSetViewportOrgEx = 0xc;
static const Shortint EmfRecordTypeSetBrushOrgEx = 0xd;
static const Shortint EmfRecordTypeEOF = 0xe;
static const Shortint EmfRecordTypeSetPixelV = 0xf;
static const Shortint EmfRecordTypeSetMapperFlags = 0x10;
static const Shortint EmfRecordTypeSetMapMode = 0x11;
static const Shortint EmfRecordTypeSetBkMode = 0x12;
static const Shortint EmfRecordTypeSetPolyFillMode = 0x13;
static const Shortint EmfRecordTypeSetROP2 = 0x14;
static const Shortint EmfRecordTypeSetStretchBltMode = 0x15;
static const Shortint EmfRecordTypeSetTextAlign = 0x16;
static const Shortint EmfRecordTypeSetColorAdjustment = 0x17;
static const Shortint EmfRecordTypeSetTextColor = 0x18;
static const Shortint EmfRecordTypeSetBkColor = 0x19;
static const Shortint EmfRecordTypeOffsetClipRgn = 0x1a;
static const Shortint EmfRecordTypeMoveToEx = 0x1b;
static const Shortint EmfRecordTypeSetMetaRgn = 0x1c;
static const Shortint EmfRecordTypeExcludeClipRect = 0x1d;
static const Shortint EmfRecordTypeIntersectClipRect = 0x1e;
static const Shortint EmfRecordTypeScaleViewportExtEx = 0x1f;
static const Shortint EmfRecordTypeScaleWindowExtEx = 0x20;
static const Shortint EmfRecordTypeSaveDC = 0x21;
static const Shortint EmfRecordTypeRestoreDC = 0x22;
static const Shortint EmfRecordTypeSetWorldTransform = 0x23;
static const Shortint EmfRecordTypeModifyWorldTransform = 0x24;
static const Shortint EmfRecordTypeSelectObject = 0x25;
static const Shortint EmfRecordTypeCreatePen = 0x26;
static const Shortint EmfRecordTypeCreateBrushIndirect = 0x27;
static const Shortint EmfRecordTypeDeleteObject = 0x28;
static const Shortint EmfRecordTypeAngleArc = 0x29;
static const Shortint EmfRecordTypeEllipse = 0x2a;
static const Shortint EmfRecordTypeRectangle = 0x2b;
static const Shortint EmfRecordTypeRoundRect = 0x2c;
static const Shortint EmfRecordTypeArc = 0x2d;
static const Shortint EmfRecordTypeChord = 0x2e;
static const Shortint EmfRecordTypePie = 0x2f;
static const Shortint EmfRecordTypeSelectPalette = 0x30;
static const Shortint EmfRecordTypeCreatePalette = 0x31;
static const Shortint EmfRecordTypeSetPaletteEntries = 0x32;
static const Shortint EmfRecordTypeResizePalette = 0x33;
static const Shortint EmfRecordTypeRealizePalette = 0x34;
static const Shortint EmfRecordTypeExtFloodFill = 0x35;
static const Shortint EmfRecordTypeLineTo = 0x36;
static const Shortint EmfRecordTypeArcTo = 0x37;
static const Shortint EmfRecordTypePolyDraw = 0x38;
static const Shortint EmfRecordTypeSetArcDirection = 0x39;
static const Shortint EmfRecordTypeSetMiterLimit = 0x3a;
static const Shortint EmfRecordTypeBeginPath = 0x3b;
static const Shortint EmfRecordTypeEndPath = 0x3c;
static const Shortint EmfRecordTypeCloseFigure = 0x3d;
static const Shortint EmfRecordTypeFillPath = 0x3e;
static const Shortint EmfRecordTypeStrokeAndFillPath = 0x3f;
static const Shortint EmfRecordTypeStrokePath = 0x40;
static const Shortint EmfRecordTypeFlattenPath = 0x41;
static const Shortint EmfRecordTypeWidenPath = 0x42;
static const Shortint EmfRecordTypeSelectClipPath = 0x43;
static const Shortint EmfRecordTypeAbortPath = 0x44;
static const Shortint EmfRecordTypeReserved_069 = 0x45;
static const Shortint EmfRecordTypeGdiComment = 0x46;
static const Shortint EmfRecordTypeFillRgn = 0x47;
static const Shortint EmfRecordTypeFrameRgn = 0x48;
static const Shortint EmfRecordTypeInvertRgn = 0x49;
static const Shortint EmfRecordTypePaintRgn = 0x4a;
static const Shortint EmfRecordTypeExtSelectClipRgn = 0x4b;
static const Shortint EmfRecordTypeBitBlt = 0x4c;
static const Shortint EmfRecordTypeStretchBlt = 0x4d;
static const Shortint EmfRecordTypeMaskBlt = 0x4e;
static const Shortint EmfRecordTypePlgBlt = 0x4f;
static const Shortint EmfRecordTypeSetDIBitsToDevice = 0x50;
static const Shortint EmfRecordTypeStretchDIBits = 0x51;
static const Shortint EmfRecordTypeExtCreateFontIndirect = 0x52;
static const Shortint EmfRecordTypeExtTextOutA = 0x53;
static const Shortint EmfRecordTypeExtTextOutW = 0x54;
static const Shortint EmfRecordTypePolyBezier16 = 0x55;
static const Shortint EmfRecordTypePolygon16 = 0x56;
static const Shortint EmfRecordTypePolyline16 = 0x57;
static const Shortint EmfRecordTypePolyBezierTo16 = 0x58;
static const Shortint EmfRecordTypePolylineTo16 = 0x59;
static const Shortint EmfRecordTypePolyPolyline16 = 0x5a;
static const Shortint EmfRecordTypePolyPolygon16 = 0x5b;
static const Shortint EmfRecordTypePolyDraw16 = 0x5c;
static const Shortint EmfRecordTypeCreateMonoBrush = 0x5d;
static const Shortint EmfRecordTypeCreateDIBPatternBrushPt = 0x5e;
static const Shortint EmfRecordTypeExtCreatePen = 0x5f;
static const Shortint EmfRecordTypePolyTextOutA = 0x60;
static const Shortint EmfRecordTypePolyTextOutW = 0x61;
static const Shortint EmfRecordTypeSetICMMode = 0x62;
static const Shortint EmfRecordTypeCreateColorSpace = 0x63;
static const Shortint EmfRecordTypeSetColorSpace = 0x64;
static const Shortint EmfRecordTypeDeleteColorSpace = 0x65;
static const Shortint EmfRecordTypeGLSRecord = 0x66;
static const Shortint EmfRecordTypeGLSBoundedRecord = 0x67;
static const Shortint EmfRecordTypePixelFormat = 0x68;
static const Shortint EmfRecordTypeDrawEscape = 0x69;
static const Shortint EmfRecordTypeExtEscape = 0x6a;
static const Shortint EmfRecordTypeStartDoc = 0x6b;
static const Shortint EmfRecordTypeSmallTextOut = 0x6c;
static const Shortint EmfRecordTypeForceUFIMapping = 0x6d;
static const Shortint EmfRecordTypeNamedEscape = 0x6e;
static const Shortint EmfRecordTypeColorCorrectPalette = 0x6f;
static const Shortint EmfRecordTypeSetICMProfileA = 0x70;
static const Shortint EmfRecordTypeSetICMProfileW = 0x71;
static const Shortint EmfRecordTypeAlphaBlend = 0x72;
static const Shortint EmfRecordTypeSetLayout = 0x73;
static const Shortint EmfRecordTypeTransparentBlt = 0x74;
static const Shortint EmfRecordTypeReserved_117 = 0x75;
static const Shortint EmfRecordTypeGradientFill = 0x76;
static const Shortint EmfRecordTypeSetLinkedUFIs = 0x77;
static const Shortint EmfRecordTypeSetTextJustification = 0x78;
static const Shortint EmfRecordTypeColorMatchToTargetW = 0x79;
static const Shortint EmfRecordTypeCreateColorSpaceW = 0x7a;
static const Shortint EmfRecordTypeMax = 0x7a;
static const Shortint EmfRecordTypeMin = 0x1;
static const Word EmfPlusRecordTypeInvalid = 0x4000;
static const Word EmfPlusRecordTypeHeader = 0x4001;
static const Word EmfPlusRecordTypeEndOfFile = 0x4002;
static const Word EmfPlusRecordTypeComment = 0x4003;
static const Word EmfPlusRecordTypeGetDC = 0x4004;
static const Word EmfPlusRecordTypeMultiFormatStart = 0x4005;
static const Word EmfPlusRecordTypeMultiFormatSection = 0x4006;
static const Word EmfPlusRecordTypeMultiFormatEnd = 0x4007;
static const Word EmfPlusRecordTypeObject = 0x4008;
static const Word EmfPlusRecordTypeClear = 0x4009;
static const Word EmfPlusRecordTypeFillRects = 0x400a;
static const Word EmfPlusRecordTypeDrawRects = 0x400b;
static const Word EmfPlusRecordTypeFillPolygon = 0x400c;
static const Word EmfPlusRecordTypeDrawLines = 0x400d;
static const Word EmfPlusRecordTypeFillEllipse = 0x400e;
static const Word EmfPlusRecordTypeDrawEllipse = 0x400f;
static const Word EmfPlusRecordTypeFillPie = 0x4010;
static const Word EmfPlusRecordTypeDrawPie = 0x4011;
static const Word EmfPlusRecordTypeDrawArc = 0x4012;
static const Word EmfPlusRecordTypeFillRegion = 0x4013;
static const Word EmfPlusRecordTypeFillPath = 0x4014;
static const Word EmfPlusRecordTypeDrawPath = 0x4015;
static const Word EmfPlusRecordTypeFillClosedCurve = 0x4016;
static const Word EmfPlusRecordTypeDrawClosedCurve = 0x4017;
static const Word EmfPlusRecordTypeDrawCurve = 0x4018;
static const Word EmfPlusRecordTypeDrawBeziers = 0x4019;
static const Word EmfPlusRecordTypeDrawImage = 0x401a;
static const Word EmfPlusRecordTypeDrawImagePoints = 0x401b;
static const Word EmfPlusRecordTypeDrawString = 0x401c;
static const Word EmfPlusRecordTypeSetRenderingOrigin = 0x401d;
static const Word EmfPlusRecordTypeSetAntiAliasMode = 0x401e;
static const Word EmfPlusRecordTypeSetTextRenderingHint = 0x401f;
static const Word EmfPlusRecordTypeSetTextContrast = 0x4020;
static const Word EmfPlusRecordTypeSetInterpolationMode = 0x4021;
static const Word EmfPlusRecordTypeSetPixelOffsetMode = 0x4022;
static const Word EmfPlusRecordTypeSetCompositingMode = 0x4023;
static const Word EmfPlusRecordTypeSetCompositingQuality = 0x4024;
static const Word EmfPlusRecordTypeSave = 0x4025;
static const Word EmfPlusRecordTypeRestore = 0x4026;
static const Word EmfPlusRecordTypeBeginContainer = 0x4027;
static const Word EmfPlusRecordTypeBeginContainerNoParams = 0x4028;
static const Word EmfPlusRecordTypeEndContainer = 0x4029;
static const Word EmfPlusRecordTypeSetWorldTransform = 0x402a;
static const Word EmfPlusRecordTypeResetWorldTransform = 0x402b;
static const Word EmfPlusRecordTypeMultiplyWorldTransform = 0x402c;
static const Word EmfPlusRecordTypeTranslateWorldTransform = 0x402d;
static const Word EmfPlusRecordTypeScaleWorldTransform = 0x402e;
static const Word EmfPlusRecordTypeRotateWorldTransform = 0x402f;
static const Word EmfPlusRecordTypeSetPageTransform = 0x4030;
static const Word EmfPlusRecordTypeResetClip = 0x4031;
static const Word EmfPlusRecordTypeSetClipRect = 0x4032;
static const Word EmfPlusRecordTypeSetClipPath = 0x4033;
static const Word EmfPlusRecordTypeSetClipRegion = 0x4034;
static const Word EmfPlusRecordTypeOffsetClip = 0x4035;
static const Word EmfPlusRecordTypeDrawDriverString = 0x4036;
static const Word EmfPlusRecordTotal = 0x4037;
static const Word EmfPlusRecordTypeMax = 0x4036;
static const Word EmfPlusRecordTypeMin = 0x4001;
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;
static const Shortint DriverStringOptionsCmapLookup = 0x1;
static const Shortint DriverStringOptionsVertical = 0x2;
static const Shortint DriverStringOptionsRealizedAdvance = 0x4;
static const Shortint DriverStringOptionsLimitSubpixel = 0x8;
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;
static const Shortint EmfToWmfBitsFlagsDefault = 0x0;
static const Shortint EmfToWmfBitsFlagsEmbedEmf = 0x1;
static const Shortint EmfToWmfBitsFlagsIncludePlaceable = 0x2;
static const Shortint EmfToWmfBitsFlagsNoXORClip = 0x4;
static const Extended FLT_MAX = 3.402823E+38;
static const Extended FLT_MIN = 1.175494E-38;
static const Extended REAL_MAX = 3.402823E+38;
static const Extended REAL_MIN = 1.175494E-38;
static const Extended REAL_TOLERANCE = 1.175494E-36;
static const Extended REAL_EPSILON = 1.192093E-07;
static const Shortint ALPHA_SHIFT = 0x18;
static const Shortint RED_SHIFT = 0x10;
static const Shortint GREEN_SHIFT = 0x8;
static const Shortint BLUE_SHIFT = 0x0;
static const unsigned ALPHA_MASK = 0xff000000;
static const int PixelFormatIndexed = 0x10000;
static const int PixelFormatGDI = 0x20000;
static const int PixelFormatAlpha = 0x40000;
static const int PixelFormatPAlpha = 0x80000;
static const int PixelFormatExtended = 0x100000;
static const int PixelFormatCanonical = 0x200000;
static const Shortint PixelFormatUndefined = 0x0;
static const Shortint PixelFormatDontCare = 0x0;
static const int PixelFormat1bppIndexed = 0x30101;
static const int PixelFormat4bppIndexed = 0x30402;
static const int PixelFormat8bppIndexed = 0x30803;
static const int PixelFormat16bppGrayScale = 0x101004;
static const int PixelFormat16bppRGB555 = 0x21005;
static const int PixelFormat16bppRGB565 = 0x21006;
static const int PixelFormat16bppARGB1555 = 0x61007;
static const int PixelFormat24bppRGB = 0x21808;
static const int PixelFormat32bppRGB = 0x22009;
static const int PixelFormat32bppARGB = 0x26200a;
static const int PixelFormat32bppPARGB = 0xe200b;
static const int PixelFormat48bppRGB = 0x10300c;
static const int PixelFormat64bppARGB = 0x34400d;
static const int PixelFormat64bppPARGB = 0x1c400e;
static const Shortint PixelFormatMax = 0xf;
static const Shortint PaletteFlagsHasAlpha = 0x1;
static const Shortint PaletteFlagsGrayScale = 0x2;
static const Shortint PaletteFlagsHalftone = 0x4;
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 AlphaShift = 0x18;
static const Shortint RedShift = 0x10;
static const Shortint GreenShift = 0x8;
static const Shortint BlueShift = 0x0;
static const unsigned AlphaMask = 0xff000000;
static const int RedMask = 0xff0000;
static const Word GreenMask = 0xff00;
static const Byte BlueMask = 0xff;
static const Shortint GDIP_EMFPLUSFLAGS_DISPLAY = 0x1;
extern PACKAGE GUID ImageFormatUndefined;
extern PACKAGE GUID ImageFormatMemoryBMP;
extern PACKAGE GUID ImageFormatBMP;
extern PACKAGE GUID ImageFormatEMF;
extern PACKAGE GUID ImageFormatWMF;
extern PACKAGE GUID ImageFormatJPEG;
extern PACKAGE GUID ImageFormatPNG;
extern PACKAGE GUID ImageFormatGIF;
extern PACKAGE GUID ImageFormatTIFF;
extern PACKAGE GUID ImageFormatEXIF;
extern PACKAGE GUID ImageFormatIcon;
extern PACKAGE GUID FrameDimensionTime;
extern PACKAGE GUID FrameDimensionResolution;
extern PACKAGE GUID FrameDimensionPage;
extern PACKAGE GUID FormatIDImageInformation;
extern PACKAGE GUID FormatIDJpegAppHeaders;
extern PACKAGE GUID EncoderCompression;
extern PACKAGE GUID EncoderColorDepth;
extern PACKAGE GUID EncoderScanMethod;
extern PACKAGE GUID EncoderVersion;
extern PACKAGE GUID EncoderRenderMethod;
extern PACKAGE GUID EncoderQuality;
extern PACKAGE GUID EncoderTransformation;
extern PACKAGE GUID EncoderLuminanceTable;
extern PACKAGE GUID EncoderChrominanceTable;
extern PACKAGE GUID EncoderSaveFlag;
extern PACKAGE GUID CodecIImageBytes;
static const Shortint ImageCodecFlagsEncoder = 0x1;
static const Shortint ImageCodecFlagsDecoder = 0x2;
static const Shortint ImageCodecFlagsSupportBitmap = 0x4;
static const Shortint ImageCodecFlagsSupportVector = 0x8;
static const Shortint ImageCodecFlagsSeekableEncode = 0x10;
static const Shortint ImageCodecFlagsBlockingDecode = 0x20;
static const int ImageCodecFlagsBuiltin = 0x10000;
static const int ImageCodecFlagsSystem = 0x20000;
static const int ImageCodecFlagsUser = 0x40000;
static const Shortint ImageLockModeRead = 0x1;
static const Shortint ImageLockModeWrite = 0x2;
static const Shortint ImageLockModeUserInputBuf = 0x4;
static const Shortint ImageFlagsNone = 0x0;
static const Shortint ImageFlagsScalable = 0x1;
static const Shortint ImageFlagsHasAlpha = 0x2;
static const Shortint ImageFlagsHasTranslucent = 0x4;
static const Shortint ImageFlagsPartiallyScalable = 0x8;
static const Shortint ImageFlagsColorSpaceRGB = 0x10;
static const Shortint ImageFlagsColorSpaceCMYK = 0x20;
static const Shortint ImageFlagsColorSpaceGRAY = 0x40;
static const Byte ImageFlagsColorSpaceYCBCR = 0x80;
static const Word ImageFlagsColorSpaceYCCK = 0x100;
static const Word ImageFlagsHasRealDPI = 0x1000;
static const Word ImageFlagsHasRealPixelSize = 0x2000;
static const int ImageFlagsReadOnly = 0x10000;
static const int ImageFlagsCaching = 0x20000;
#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 PropertyTagTypeByte;
extern PACKAGE int PropertyTagTypeASCII;
extern PACKAGE int PropertyTagTypeShort;
extern PACKAGE int PropertyTagTypeLong;
extern PACKAGE int PropertyTagTypeRational;
extern PACKAGE int PropertyTagTypeUndefined;
extern PACKAGE int PropertyTagTypeSLONG;
extern PACKAGE int PropertyTagTypeSRational;
static const Word PropertyTagExifIFD = 0x8769;
static const Word PropertyTagGpsIFD = 0x8825;
static const Byte PropertyTagNewSubfileType = 0xfe;
static const Byte PropertyTagSubfileType = 0xff;
static const Word PropertyTagImageWidth = 0x100;
static const Word PropertyTagImageHeight = 0x101;
static const Word PropertyTagBitsPerSample = 0x102;
static const Word PropertyTagCompression = 0x103;
static const Word PropertyTagPhotometricInterp = 0x106;
static const Word PropertyTagThreshHolding = 0x107;
static const Word PropertyTagCellWidth = 0x108;
static const Word PropertyTagCellHeight = 0x109;
static const Word PropertyTagFillOrder = 0x10a;
static const Word PropertyTagDocumentName = 0x10d;
static const Word PropertyTagImageDescription = 0x10e;
static const Word PropertyTagEquipMake = 0x10f;
static const Word PropertyTagEquipModel = 0x110;
static const Word PropertyTagStripOffsets = 0x111;
static const Word PropertyTagOrientation = 0x112;
static const Word PropertyTagSamplesPerPixel = 0x115;
static const Word PropertyTagRowsPerStrip = 0x116;
static const Word PropertyTagStripBytesCount = 0x117;
static const Word PropertyTagMinSampleValue = 0x118;
static const Word PropertyTagMaxSampleValue = 0x119;
static const Word PropertyTagXResolution = 0x11a;
static const Word PropertyTagYResolution = 0x11b;
static const Word PropertyTagPlanarConfig = 0x11c;
static const Word PropertyTagPageName = 0x11d;
static const Word PropertyTagXPosition = 0x11e;
static const Word PropertyTagYPosition = 0x11f;
static const Word PropertyTagFreeOffset = 0x120;
static const Word PropertyTagFreeByteCounts = 0x121;
static const Word PropertyTagGrayResponseUnit = 0x122;
static const Word PropertyTagGrayResponseCurve = 0x123;
static const Word PropertyTagT4Option = 0x124;
static const Word PropertyTagT6Option = 0x125;
static const Word PropertyTagResolutionUnit = 0x128;
static const Word PropertyTagPageNumber = 0x129;
static const Word PropertyTagTransferFuncition = 0x12d;
static const Word PropertyTagSoftwareUsed = 0x131;
static const Word PropertyTagDateTime = 0x132;
static const Word PropertyTagArtist = 0x13b;
static const Word PropertyTagHostComputer = 0x13c;
static const Word PropertyTagPredictor = 0x13d;
static const Word PropertyTagWhitePoint = 0x13e;
static const Word PropertyTagPrimaryChromaticities = 0x13f;
static const Word PropertyTagColorMap = 0x140;
static const Word PropertyTagHalftoneHints = 0x141;
static const Word PropertyTagTileWidth = 0x142;
static const Word PropertyTagTileLength = 0x143;
static const Word PropertyTagTileOffset = 0x144;
static const Word PropertyTagTileByteCounts = 0x145;
static const Word PropertyTagInkSet = 0x14c;
static const Word PropertyTagInkNames = 0x14d;
static const Word PropertyTagNumberOfInks = 0x14e;
static const Word PropertyTagDotRange = 0x150;
static const Word PropertyTagTargetPrinter = 0x151;
static const Word PropertyTagExtraSamples = 0x152;
static const Word PropertyTagSampleFormat = 0x153;
static const Word PropertyTagSMinSampleValue = 0x154;
static const Word PropertyTagSMaxSampleValue = 0x155;
static const Word PropertyTagTransferRange = 0x156;
static const Word PropertyTagJPEGProc = 0x200;
static const Word PropertyTagJPEGInterFormat = 0x201;
static const Word PropertyTagJPEGInterLength = 0x202;
static const Word PropertyTagJPEGRestartInterval = 0x203;
static const Word PropertyTagJPEGLosslessPredictors = 0x205;
static const Word PropertyTagJPEGPointTransforms = 0x206;
static const Word PropertyTagJPEGQTables = 0x207;
static const Word PropertyTagJPEGDCTables = 0x208;
static const Word PropertyTagJPEGACTables = 0x209;
static const Word PropertyTagYCbCrCoefficients = 0x211;
static const Word PropertyTagYCbCrSubsampling = 0x212;
static const Word PropertyTagYCbCrPositioning = 0x213;
static const Word PropertyTagREFBlackWhite = 0x214;
static const Word PropertyTagICCProfile = 0x8773;
static const Word PropertyTagGamma = 0x301;
static const Word PropertyTagICCProfileDescriptor = 0x302;
static const Word PropertyTagSRGBRenderingIntent = 0x303;
static const Word PropertyTagImageTitle = 0x320;
static const Word PropertyTagCopyright = 0x8298;
static const Word PropertyTagResolutionXUnit = 0x5001;
static const Word PropertyTagResolutionYUnit = 0x5002;
static const Word PropertyTagResolutionXLengthUnit = 0x5003;
static const Word PropertyTagResolutionYLengthUnit = 0x5004;
static const Word PropertyTagPrintFlags = 0x5005;
static const Word PropertyTagPrintFlagsVersion = 0x5006;
static const Word PropertyTagPrintFlagsCrop = 0x5007;
static const Word PropertyTagPrintFlagsBleedWidth = 0x5008;
static const Word PropertyTagPrintFlagsBleedWidthScale = 0x5009;
static const Word PropertyTagHalftoneLPI = 0x500a;
static const Word PropertyTagHalftoneLPIUnit = 0x500b;
static const Word PropertyTagHalftoneDegree = 0x500c;
static const Word PropertyTagHalftoneShape = 0x500d;
static const Word PropertyTagHalftoneMisc = 0x500e;
static const Word PropertyTagHalftoneScreen = 0x500f;
static const Word PropertyTagJPEGQuality = 0x5010;
static const Word PropertyTagGridSize = 0x5011;
static const Word PropertyTagThumbnailFormat = 0x5012;
static const Word PropertyTagThumbnailWidth = 0x5013;
static const Word PropertyTagThumbnailHeight = 0x5014;
static const Word PropertyTagThumbnailColorDepth = 0x5015;
static const Word PropertyTagThumbnailPlanes = 0x5016;
static const Word PropertyTagThumbnailRawBytes = 0x5017;
static const Word PropertyTagThumbnailSize = 0x5018;
static const Word PropertyTagThumbnailCompressedSize = 0x5019;
static const Word PropertyTagColorTransferFunction = 0x501a;
static const Word PropertyTagThumbnailData = 0x501b;
static const Word PropertyTagThumbnailImageWidth = 0x5020;
static const Word PropertyTagThumbnailImageHeight = 0x5021;
static const Word PropertyTagThumbnailBitsPerSample = 0x5022;
static const Word PropertyTagThumbnailCompression = 0x5023;
static const Word PropertyTagThumbnailPhotometricInterp = 0x5024;
static const Word PropertyTagThumbnailImageDescription = 0x5025;
static const Word PropertyTagThumbnailEquipMake = 0x5026;
static const Word PropertyTagThumbnailEquipModel = 0x5027;
static const Word PropertyTagThumbnailStripOffsets = 0x5028;
static const Word PropertyTagThumbnailOrientation = 0x5029;
static const Word PropertyTagThumbnailSamplesPerPixel = 0x502a;
static const Word PropertyTagThumbnailRowsPerStrip = 0x502b;
static const Word PropertyTagThumbnailStripBytesCount = 0x502c;
static const Word PropertyTagThumbnailResolutionX = 0x502d;
static const Word PropertyTagThumbnailResolutionY = 0x502e;
static const Word PropertyTagThumbnailPlanarConfig = 0x502f;
static const Word PropertyTagThumbnailResolutionUnit = 0x5030;
static const Word PropertyTagThumbnailTransferFunction = 0x5031;
static const Word PropertyTagThumbnailSoftwareUsed = 0x5032;
static const Word PropertyTagThumbnailDateTime = 0x5033;
static const Word PropertyTagThumbnailArtist = 0x5034;
static const Word PropertyTagThumbnailWhitePoint = 0x5035;
static const Word PropertyTagThumbnailPrimaryChromaticities = 0x5036;
static const Word PropertyTagThumbnailYCbCrCoefficients = 0x5037;
static const Word PropertyTagThumbnailYCbCrSubsampling = 0x5038;
static const Word PropertyTagThumbnailYCbCrPositioning = 0x5039;
static const Word PropertyTagThumbnailRefBlackWhite = 0x503a;
static const Word PropertyTagThumbnailCopyRight = 0x503b;
static const Word PropertyTagLuminanceTable = 0x5090;
static const Word PropertyTagChrominanceTable = 0x5091;
static const Word PropertyTagFrameDelay = 0x5100;
static const Word PropertyTagLoopCount = 0x5101;
static const Word PropertyTagPixelUnit = 0x5110;
static const Word PropertyTagPixelPerUnitX = 0x5111;
static const Word PropertyTagPixelPerUnitY = 0x5112;
static const Word PropertyTagPaletteHistogram = 0x5113;
static const Word PropertyTagExifExposureTime = 0x829a;
static const Word PropertyTagExifFNumber = 0x829d;
static const Word PropertyTagExifExposureProg = 0x8822;
static const Word PropertyTagExifSpectralSense = 0x8824;
static const Word PropertyTagExifISOSpeed = 0x8827;
static const Word PropertyTagExifOECF = 0x8828;
static const Word PropertyTagExifVer = 0x9000;
static const Word PropertyTagExifDTOrig = 0x9003;
static const Word PropertyTagExifDTDigitized = 0x9004;
static const Word PropertyTagExifCompConfig = 0x9101;
static const Word PropertyTagExifCompBPP = 0x9102;
static const Word PropertyTagExifShutterSpeed = 0x9201;
static const Word PropertyTagExifAperture = 0x9202;
static const Word PropertyTagExifBrightness = 0x9203;
static const Word PropertyTagExifExposureBias = 0x9204;
static const Word PropertyTagExifMaxAperture = 0x9205;
static const Word PropertyTagExifSubjectDist = 0x9206;
static const Word PropertyTagExifMeteringMode = 0x9207;
static const Word PropertyTagExifLightSource = 0x9208;
static const Word PropertyTagExifFlash = 0x9209;
static const Word PropertyTagExifFocalLength = 0x920a;
static const Word PropertyTagExifMakerNote = 0x927c;
static const Word PropertyTagExifUserComment = 0x9286;
static const Word PropertyTagExifDTSubsec = 0x9290;
static const Word PropertyTagExifDTOrigSS = 0x9291;
static const Word PropertyTagExifDTDigSS = 0x9292;
static const Word PropertyTagExifFPXVer = 0xa000;
static const Word PropertyTagExifColorSpace = 0xa001;
static const Word PropertyTagExifPixXDim = 0xa002;
static const Word PropertyTagExifPixYDim = 0xa003;
static const Word PropertyTagExifRelatedWav = 0xa004;
static const Word PropertyTagExifInterop = 0xa005;
static const Word PropertyTagExifFlashEnergy = 0xa20b;
static const Word PropertyTagExifSpatialFR = 0xa20c;
static const Word PropertyTagExifFocalXRes = 0xa20e;
static const Word PropertyTagExifFocalYRes = 0xa20f;
static const Word PropertyTagExifFocalResUnit = 0xa210;
static const Word PropertyTagExifSubjectLoc = 0xa214;
static const Word PropertyTagExifExposureIndex = 0xa215;
static const Word PropertyTagExifSensingMethod = 0xa217;
static const Word PropertyTagExifFileSource = 0xa300;
static const Word PropertyTagExifSceneType = 0xa301;
static const Word PropertyTagExifCfaPattern = 0xa302;
static const Shortint PropertyTagGpsVer = 0x0;
static const Shortint PropertyTagGpsLatitudeRef = 0x1;
static const Shortint PropertyTagGpsLatitude = 0x2;
static const Shortint PropertyTagGpsLongitudeRef = 0x3;
static const Shortint PropertyTagGpsLongitude = 0x4;
static const Shortint PropertyTagGpsAltitudeRef = 0x5;
static const Shortint PropertyTagGpsAltitude = 0x6;
static const Shortint PropertyTagGpsGpsTime = 0x7;
static const Shortint PropertyTagGpsGpsSatellites = 0x8;
static const Shortint PropertyTagGpsGpsStatus = 0x9;
static const Shortint PropertyTagGpsGpsMeasureMode = 0xa;
static const Shortint PropertyTagGpsGpsDop = 0xb;
static const Shortint PropertyTagGpsSpeedRef = 0xc;
static const Shortint PropertyTagGpsSpeed = 0xd;
static const Shortint PropertyTagGpsTrackRef = 0xe;
static const Shortint PropertyTagGpsTrack = 0xf;
static const Shortint PropertyTagGpsImgDirRef = 0x10;
static const Shortint PropertyTagGpsImgDir = 0x11;
static const Shortint PropertyTagGpsMapDatum = 0x12;
static const Shortint PropertyTagGpsDestLatRef = 0x13;
static const Shortint PropertyTagGpsDestLat = 0x14;
static const Shortint PropertyTagGpsDestLongRef = 0x15;
static const Shortint PropertyTagGpsDestLong = 0x16;
static const Shortint PropertyTagGpsDestBearRef = 0x17;
static const Shortint PropertyTagGpsDestBear = 0x18;
static const Shortint PropertyTagGpsDestDistRef = 0x19;
static const Shortint PropertyTagGpsDestDist = 0x1a;
extern PACKAGE int GDIPlusLoaded;
extern PACKAGE BOOL __fastcall ObjectTypeIsValid(ObjectType type_);
extern PACKAGE TsgGPoint __fastcall MakePoint(int X, int Y)/* overload */;
extern PACKAGE TsgGPointF __fastcall MakePointF(float X, float Y)/* overload */;
extern PACKAGE TsgGPoint __fastcall PointFToPointI(const TsgGPointF &APoint);
extern PACKAGE TsgGPointF __fastcall PointIToPointF(const TsgGPoint &APoint);
extern PACKAGE TsgGSizeF __fastcall MakeSizeF(float Width, float Height)/* overload */;
extern PACKAGE TsgGSize __fastcall MakeSize(int Width, int Height)/* overload */;
extern PACKAGE TCharacterRange __fastcall MakeCharacterRange(int First, int Length);
extern PACKAGE TsgGRectF __fastcall MakeRectF(const float X, const float Y, const float Width, const float Height)/* overload */;
extern PACKAGE TsgGRectF __fastcall MakeRectF(const TsgGPointF &Location, const TsgGSizeF &size)/* overload */;
extern PACKAGE TsgGPointF __fastcall GetCenterF(const TsgGRectF &ARect)/* overload */;
extern PACKAGE TsgGPointF __fastcall GetTopLeftF(const TsgGRectF &ARect)/* overload */;
extern PACKAGE TsgGPointF __fastcall GetBottomRightF(const TsgGRectF &ARect)/* overload */;
extern PACKAGE TsgGRect __fastcall MakeRect(int X, int Y, int Width, int Height)/* overload */;
extern PACKAGE TsgGRect __fastcall MakeRect(const TsgGPoint &Location, const TsgGSize &size)/* overload */;
extern PACKAGE TsgGRect __fastcall MakeRectI(const Types::TRect &ARect);
extern PACKAGE TsgGPoint __fastcall GetCenter(const Types::TRect &ARect)/* overload */;
extern PACKAGE TsgGPoint __fastcall GetCenter(const TsgGRect &ARect)/* overload */;
extern PACKAGE TsgGPoint __fastcall GetTopLeft(const TsgGRect &ARect)/* overload */;
extern PACKAGE TsgGPoint __fastcall GetBottomRight(const TsgGRect &ARect)/* overload */;
extern PACKAGE int __fastcall GetPixelFormat(Graphics::TPixelFormat AFormat);
extern PACKAGE unsigned __fastcall GetPixelFormatSize(int APixFmt);
extern PACKAGE BOOL __fastcall IsIndexedPixelFormat(int APixFmt);
extern PACKAGE BOOL __fastcall IsAlphaPixelFormat(int APixFmt);
extern PACKAGE BOOL __fastcall IsExtendedPixelFormat(int APixFmt);
extern PACKAGE BOOL __fastcall IsCanonicalPixelFormat(int APixFmt);
extern PACKAGE unsigned __fastcall MakeColor(Byte R, Byte G, Byte B)/* overload */;
extern PACKAGE unsigned __fastcall MakeColor(Byte A, 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);
extern PACKAGE unsigned __fastcall ColorRefToARGB(unsigned RGB);
extern PACKAGE unsigned __fastcall ARGBToColorRef(unsigned Color);

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

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