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

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

#ifndef GdipfillHPP
#define GdipfillHPP

#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 <Graphics.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Advsmoothgdip.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit

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

namespace Gdipfill
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TFillPicturePosition { ppTopLeft, ppTopCenter, ppTopRight, ppBottomLeft, ppBottomCenter, ppBottomRight, ppTiled, ppStretched, ppCenterLeft, ppCenterCenter, ppCenterRight, ppCustom };
#pragma option pop

#pragma option push -b-
enum TFillRoundingType { rtNone, rtTop, rtBottom, rtBoth };
#pragma option pop

#pragma option push -b-
enum TFillPictureSize { psOriginal, psCustom };
#pragma option pop

class DELPHICLASS TGDIPFill;
class PASCALIMPLEMENTATION TGDIPFill : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	Graphics::TColor FBorderColor;
	Byte FOpacity;
	TFillPicturePosition FPicturePosition;
	Advsmoothgdip::TAdvGradientType FGradientType;
	Byte FOpacityTo;
	Advsmoothgdip::TAdvGDIPPicture* FPicture;
	Advsmoothgdip::HatchStyle FHatchStyle;
	Graphics::TColor FColor;
	int FShadowOffset;
	Byte FOpacityMirror;
	Advsmoothgdip::TAdvGradientType FGradientMirrorType;
	Byte FOpacityMirrorTo;
	int FRounding;
	Graphics::TColor FShadowColor;
	int FBorderWidth;
	Graphics::TColor FColorMirror;
	Graphics::TColor FColorMirrorTo;
	Graphics::TColor FColorTo;
	Classes::TNotifyEvent FOnChange;
	Advsmoothgdip::HatchStyle FHatchStyleMirror;
	int FPictureTop;
	int FPictureLeft;
	int FBackGroundPictureTop;
	int FBackGroundPictureLeft;
	TFillPicturePosition FBackGroundPicturePosition;
	Advsmoothgdip::TAdvGDIPPicture* FBackGroundPicture;
	int FpictureWidth;
	TFillPictureSize FpictureSize;
	int FpictureHeight;
	TFillRoundingType FRoundingType;
	int FUpdateCount;
	bool FFocus;
	Graphics::TColor FFocusColor;
	int FAngle;
	Byte FBorderOpacity;
	#pragma pack(push,1)
	Advsmoothgdip::TGPRectF FFocusRect;
	#pragma pack(pop)
	void __fastcall SetBorderColor(const Graphics::TColor Value);
	void __fastcall SetBorderWidth(const int Value);
	void __fastcall SetColor(const Graphics::TColor Value);
	void __fastcall SetColorMirror(const Graphics::TColor Value);
	void __fastcall SetColorMirrorTo(const Graphics::TColor Value);
	void __fastcall SetColorTo(const Graphics::TColor Value);
	void __fastcall SetGradientMirrorType(const Advsmoothgdip::TAdvGradientType Value);
	void __fastcall SetGradientType(const Advsmoothgdip::TAdvGradientType Value);
	void __fastcall SetHatchStyle(const Advsmoothgdip::HatchStyle Value);
	void __fastcall SetOpacity(const Byte Value);
	void __fastcall SetOpacityMirror(const Byte Value);
	void __fastcall SetOpacityMirrorTo(const Byte Value);
	void __fastcall SetOpacityTo(const Byte Value);
	void __fastcall SetPicture(const Advsmoothgdip::TAdvGDIPPicture* Value);
	void __fastcall SetPicturePosition(const TFillPicturePosition Value);
	void __fastcall SetRounding(const int Value);
	void __fastcall SetShadowColor(const Graphics::TColor Value);
	void __fastcall SetShadowOffset(const int Value);
	void __fastcall SetHatchStyleMirror(const Advsmoothgdip::HatchStyle Value);
	void __fastcall SetPictureLeft(const int Value);
	void __fastcall SetPictureTop(const int Value);
	void __fastcall SetBackGroundPicture(const Advsmoothgdip::TAdvGDIPPicture* Value);
	void __fastcall SetBackGroundPictureLeft(const int Value);
	void __fastcall SetBackGroundPicturePosition(const TFillPicturePosition Value);
	void __fastcall SetBackGroundPictureTop(const int Value);
	void __fastcall SetPictureHeight(const int Value);
	void __fastcall SetPictureSize(const TFillPictureSize Value);
	void __fastcall SetPictureWidth(const int Value);
	void __fastcall SetRoundingType(const TFillRoundingType Value);
	void __fastcall SetFocus(const bool Value);
	void __fastcall SetFocusColor(const Graphics::TColor Value);
	void __fastcall SetAngle(const int Value);
	void __fastcall SetBorderOpacity(const Byte Value);
	
protected:
	void __fastcall Changed(void);
	void __fastcall PictureChanged(System::TObject* Sender);
	void __fastcall DrawGradientBackGround(Advsmoothgdip::TGPGraphics* Graphics, const Advsmoothgdip::TGPRectF &R, bool Mirror, Byte oc, Byte octo, Byte ocmr, Byte ocmrto);
	
public:
	__fastcall TGDIPFill(void);
	__fastcall virtual ~TGDIPFill(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	Advsmoothgdip::TGPRectF __fastcall Fill(Advsmoothgdip::TGPGraphics* Graphics, const Advsmoothgdip::TGPRectF &R, Byte ABorderOpacity = (Byte)(0xff), Byte AOpacity = (Byte)(0xff), Byte AOpacityTo = (Byte)(0xff), Byte AOpacityMirror = (Byte)(0xff), Byte AOpacityMirrorTo = (Byte)(0xff));
	void __fastcall BeginUpdate(void);
	void __fastcall EndUpdate(void);
	__property bool Focus = {read=FFocus, write=SetFocus, default=0};
	__property Graphics::TColor FocusColor = {read=FFocusColor, write=SetFocusColor, default=0};
	__property Advsmoothgdip::TGPRectF FocusRect = {read=FFocusRect, write=FFocusRect};
	
__published:
	__property Graphics::TColor Color = {read=FColor, write=SetColor, default=12632256};
	__property Graphics::TColor ColorTo = {read=FColorTo, write=SetColorTo, default=8421504};
	__property Graphics::TColor ColorMirror = {read=FColorMirror, write=SetColorMirror, default=536870911};
	__property Graphics::TColor ColorMirrorTo = {read=FColorMirrorTo, write=SetColorMirrorTo, default=536870911};
	__property Advsmoothgdip::TAdvGradientType GradientType = {read=FGradientType, write=SetGradientType, default=2};
	__property Advsmoothgdip::TAdvGradientType GradientMirrorType = {read=FGradientMirrorType, write=SetGradientMirrorType, default=0};
	__property Advsmoothgdip::HatchStyle HatchStyle = {read=FHatchStyle, write=SetHatchStyle, default=0};
	__property Advsmoothgdip::HatchStyle HatchStyleMirror = {read=FHatchStyleMirror, write=SetHatchStyleMirror, default=0};
	__property Advsmoothgdip::TAdvGDIPPicture* BackGroundPicture = {read=FBackGroundPicture, write=SetBackGroundPicture};
	__property TFillPicturePosition BackGroundPicturePosition = {read=FBackGroundPicturePosition, write=SetBackGroundPicturePosition, default=0};
	__property int BackGroundPictureLeft = {read=FBackGroundPictureLeft, write=SetBackGroundPictureLeft, default=0};
	__property int BackGroundPictureTop = {read=FBackGroundPictureTop, write=SetBackGroundPictureTop, default=0};
	__property Advsmoothgdip::TAdvGDIPPicture* Picture = {read=FPicture, write=SetPicture};
	__property TFillPicturePosition PicturePosition = {read=FPicturePosition, write=SetPicturePosition, default=0};
	__property int PictureLeft = {read=FPictureLeft, write=SetPictureLeft, default=0};
	__property int PictureTop = {read=FPictureTop, write=SetPictureTop, default=0};
	__property TFillPictureSize PictureSize = {read=FpictureSize, write=SetPictureSize, default=0};
	__property int PictureWidth = {read=FpictureWidth, write=SetPictureWidth, default=50};
	__property int PictureHeight = {read=FpictureHeight, write=SetPictureHeight, default=50};
	__property Byte Opacity = {read=FOpacity, write=SetOpacity, default=255};
	__property Byte OpacityTo = {read=FOpacityTo, write=SetOpacityTo, default=255};
	__property Byte OpacityMirror = {read=FOpacityMirror, write=SetOpacityMirror, default=255};
	__property Byte OpacityMirrorTo = {read=FOpacityMirrorTo, write=SetOpacityMirrorTo, default=255};
	__property Graphics::TColor BorderColor = {read=FBorderColor, write=SetBorderColor, default=536870911};
	__property Byte BorderOpacity = {read=FBorderOpacity, write=SetBorderOpacity, default=255};
	__property int BorderWidth = {read=FBorderWidth, write=SetBorderWidth, default=1};
	__property int Rounding = {read=FRounding, write=SetRounding, default=0};
	__property TFillRoundingType RoundingType = {read=FRoundingType, write=SetRoundingType, default=3};
	__property Graphics::TColor ShadowColor = {read=FShadowColor, write=SetShadowColor, default=8421504};
	__property int ShadowOffset = {read=FShadowOffset, write=SetShadowOffset, default=0};
	__property int Angle = {read=FAngle, write=SetAngle, default=0};
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
};


//-- var, const, procedure ---------------------------------------------------

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

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