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

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

#ifndef SrvskinmanagerHPP
#define SrvskinmanagerHPP

#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 <Sysutils.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <Forms.hpp>	// Pascal unit

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

namespace Srvskinmanager
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TSRVDrawState { srvdsHot, srvdsDown, srvdFocused, srvdsEnabled };
#pragma option pop

typedef Set<TSRVDrawState, srvdsHot, srvdsEnabled>  TSRVDrawStates;

class DELPHICLASS TSRVSkinFont;
class PASCALIMPLEMENTATION TSRVSkinFont : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	Classes::TCollection* FOwner;
	
protected:
	AnsiString FName;
	Graphics::TFont* FDisabled;
	Graphics::TFont* FNormal;
	Graphics::TFont* FHot;
	Graphics::TFont* FDown;
	Graphics::TFont* FFocused;
	Graphics::TFont* __fastcall GetDisabled(void);
	Graphics::TFont* __fastcall GetNormal(void);
	Graphics::TFont* __fastcall GetHot(void);
	Graphics::TFont* __fastcall GetDown(void);
	Graphics::TFont* __fastcall GetFocused(void);
	Graphics::TFont* __fastcall SetFont(Graphics::TFont* &OldFont, Graphics::TFont* &NewFont);
	void __fastcall SetNormal(Graphics::TFont* Value);
	void __fastcall SetDown(Graphics::TFont* Value);
	void __fastcall SetHot(Graphics::TFont* Value);
	void __fastcall SetDisabled(Graphics::TFont* Value);
	void __fastcall SetFocused(Graphics::TFont* Value);
	
public:
	__fastcall virtual TSRVSkinFont(Classes::TCollection* Collection);
	__fastcall virtual ~TSRVSkinFont(void);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	virtual AnsiString __fastcall GetDisplayName();
	void __fastcall Repaint(void);
	bool __fastcall IsNormal(void);
	bool __fastcall IsDown(void);
	bool __fastcall IsHot(void);
	bool __fastcall IsDisabled(void);
	bool __fastcall IsFocused(void);
	
__published:
	__property AnsiString Name = {read=FName, write=FName};
	__property Graphics::TFont* Disabled = {read=GetDisabled, write=SetDisabled};
	__property Graphics::TFont* Normal = {read=GetNormal, write=SetNormal};
	__property Graphics::TFont* Hot = {read=GetHot, write=SetHot};
	__property Graphics::TFont* Down = {read=GetDown, write=SetDown};
	__property Graphics::TFont* Focused = {read=GetFocused, write=SetFocused};
};


class DELPHICLASS TSRVSkinFontCollection;
class PASCALIMPLEMENTATION TSRVSkinFontCollection : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TSRVSkinFont* operator[](int Index) { return Items[Index]; }
	
private:
	Classes::TPersistent* FOwner;
	HIDESBASE TSRVSkinFont* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, const TSRVSkinFont* Value);
	
public:
	__fastcall TSRVSkinFontCollection(TMetaClass* ItemClass, Classes::TPersistent* Owner);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	__property TSRVSkinFont* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TSRVSkinFontCollection(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSRVSkinElement;
class PASCALIMPLEMENTATION TSRVSkinElement : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	Classes::TCollection* FOwner;
	
protected:
	Graphics::TPicture* FDisabled;
	Graphics::TPicture* FNormal;
	Graphics::TPicture* FHot;
	Graphics::TPicture* FDown;
	Graphics::TPicture* FFocused;
	Graphics::TColor FColor;
	Graphics::TColor FTranparentColor;
	AnsiString FName;
	Graphics::TPicture* __fastcall GetDisabled(void);
	Graphics::TPicture* __fastcall GetNormal(void);
	Graphics::TPicture* __fastcall GetHot(void);
	Graphics::TPicture* __fastcall GetDown(void);
	Graphics::TPicture* __fastcall GetFocused(void);
	Graphics::TPicture* __fastcall SetImage(Graphics::TPicture* &OldImage, Graphics::TPicture* &NewImage);
	void __fastcall SetDisabled(Graphics::TPicture* Value);
	void __fastcall SetNormal(Graphics::TPicture* Value);
	void __fastcall SetHot(Graphics::TPicture* Value);
	void __fastcall SetDown(Graphics::TPicture* Value);
	void __fastcall SetFocused(Graphics::TPicture* Value);
	void __fastcall SetColor(Graphics::TColor Value);
	void __fastcall SetTranparentColor(Graphics::TColor Value);
	
public:
	__fastcall virtual TSRVSkinElement(Classes::TCollection* Collection);
	__fastcall virtual ~TSRVSkinElement(void);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	virtual AnsiString __fastcall GetDisplayName();
	void __fastcall Repaint(void);
	
__published:
	__property Graphics::TColor Color = {read=FColor, write=SetColor, default=16777215};
	__property Graphics::TColor TranparentColor = {read=FTranparentColor, write=SetTranparentColor, default=536870911};
	__property Graphics::TPicture* Disabled = {read=GetDisabled, write=SetDisabled};
	__property Graphics::TPicture* Normal = {read=GetNormal, write=SetNormal};
	__property Graphics::TPicture* Hot = {read=GetHot, write=SetHot};
	__property Graphics::TPicture* Down = {read=GetDown, write=SetDown};
	__property Graphics::TPicture* Focused = {read=GetFocused, write=SetFocused};
	__property AnsiString Name = {read=FName, write=FName};
};


class DELPHICLASS TSRVSkinElementCollection;
class PASCALIMPLEMENTATION TSRVSkinElementCollection : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TSRVSkinElement* operator[](int Index) { return Items[Index]; }
	
private:
	Classes::TPersistent* FOwner;
	HIDESBASE TSRVSkinElement* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, const TSRVSkinElement* Value);
	
public:
	__fastcall TSRVSkinElementCollection(TMetaClass* ItemClass, Classes::TPersistent* Owner);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	__property TSRVSkinElement* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TSRVSkinElementCollection(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSRVBoxScheme;
class PASCALIMPLEMENTATION TSRVBoxScheme : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	Classes::TCollection* FOwner;
	
protected:
	AnsiString FName;
	int FImgLeft;
	int FImgRight;
	int FImgTop;
	int FImgBottom;
	int FImgTopLeft;
	int FImgTopRight;
	int FImgBottomLeft;
	int FImgBottomRight;
	int FImgBackgroundBegin;
	int FImgBackgroundEnd;
	int FImgBackgroundCenter;
	void __fastcall SetImgLeft(int Value);
	void __fastcall SetImgRight(int Value);
	void __fastcall SetImgTop(int Value);
	void __fastcall SetImgBottom(int Value);
	void __fastcall SetImgTopLeft(int Value);
	void __fastcall SetImgTopRight(int Value);
	void __fastcall SetImgBottomLeft(int Value);
	void __fastcall SetImgBottomRight(int Value);
	void __fastcall SetImgBackgroundBegin(int Value);
	void __fastcall SetImgBackgroundEnd(int Value);
	void __fastcall SetImgBackgroundCenter(int Value);
	
public:
	__fastcall virtual TSRVBoxScheme(Classes::TCollection* Collection);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	virtual AnsiString __fastcall GetDisplayName();
	void __fastcall Repaint(void);
	
__published:
	__property AnsiString Name = {read=FName, write=FName};
	__property int ImgLeft = {read=FImgLeft, write=SetImgLeft, default=-1};
	__property int ImgRight = {read=FImgRight, write=SetImgRight, default=-1};
	__property int ImgTop = {read=FImgTop, write=SetImgTop, default=-1};
	__property int ImgBottom = {read=FImgBottom, write=SetImgBottom, default=-1};
	__property int ImgTopLeft = {read=FImgTopLeft, write=SetImgTopLeft, default=-1};
	__property int ImgTopRight = {read=FImgTopRight, write=SetImgTopRight, default=-1};
	__property int ImgBottomLeft = {read=FImgBottomLeft, write=SetImgBottomLeft, default=-1};
	__property int ImgBottomRight = {read=FImgBottomRight, write=SetImgBottomRight, default=-1};
	__property int ImgBackgroundBegin = {read=FImgBackgroundBegin, write=SetImgBackgroundBegin, default=-1};
	__property int ImgBackgroundEnd = {read=FImgBackgroundEnd, write=SetImgBackgroundEnd, default=-1};
	__property int ImgBackgroundCenter = {read=FImgBackgroundCenter, write=SetImgBackgroundCenter, default=-1};
public:
	#pragma option push -w-inl
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TSRVBoxScheme(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSRVBoxSchemeCollection;
class PASCALIMPLEMENTATION TSRVBoxSchemeCollection : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TSRVBoxScheme* operator[](int Index) { return Items[Index]; }
	
private:
	Classes::TPersistent* FOwner;
	HIDESBASE TSRVBoxScheme* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, const TSRVBoxScheme* Value);
	
public:
	__fastcall TSRVBoxSchemeCollection(TMetaClass* ItemClass, Classes::TPersistent* Owner);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	__property TSRVBoxScheme* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TSRVBoxSchemeCollection(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSRVScrollBarSkinScheme;
class PASCALIMPLEMENTATION TSRVScrollBarSkinScheme : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	Classes::TCollection* FOwner;
	
protected:
	AnsiString FName;
	int FImgDecButton;
	int FImgIncButton;
	int FImgThumbBegin;
	int FImgThumbEnd;
	int FImgThumbBackground;
	int FImgThumbCenter;
	int FImgBorderBegin;
	int FImgBorderEnd;
	int FImgBorderBackground;
	int FImgBackground;
	void __fastcall SetImgDecButton(int Value);
	void __fastcall SetImgIncButton(int Value);
	void __fastcall SetImgThumbBegin(int Value);
	void __fastcall SetImgThumbEnd(int Value);
	void __fastcall SetImgThumbBackground(int Value);
	void __fastcall SetImgThumbCenter(int Value);
	void __fastcall SetImgBackground(int Value);
	void __fastcall SetImgBorderBegin(int Value);
	void __fastcall SetImgBorderEnd(int Value);
	void __fastcall SetImgBorderBackground(int Value);
	
public:
	__fastcall virtual TSRVScrollBarSkinScheme(Classes::TCollection* Collection);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	virtual AnsiString __fastcall GetDisplayName();
	void __fastcall Repaint(void);
	
__published:
	__property AnsiString Name = {read=FName, write=FName};
	__property int ImgDecButton = {read=FImgDecButton, write=SetImgDecButton, default=-1};
	__property int ImgIncButton = {read=FImgIncButton, write=SetImgIncButton, default=-1};
	__property int ImgThumbBegin = {read=FImgThumbBegin, write=SetImgThumbBegin, default=-1};
	__property int ImgThumbEnd = {read=FImgThumbEnd, write=SetImgThumbEnd, default=-1};
	__property int ImgThumbBackground = {read=FImgThumbBackground, write=SetImgThumbBackground, default=-1};
	__property int ImgThumbCenter = {read=FImgThumbCenter, write=SetImgThumbCenter, default=-1};
	__property int ImgBorderBegin = {read=FImgBorderBegin, write=SetImgBorderBegin, default=-1};
	__property int ImgBorderEnd = {read=FImgBorderEnd, write=SetImgBorderEnd, default=-1};
	__property int ImgBorderBackground = {read=FImgBorderBackground, write=SetImgBorderBackground, default=-1};
	__property int ImgBackground = {read=FImgBackground, write=SetImgBackground, default=-1};
public:
	#pragma option push -w-inl
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TSRVScrollBarSkinScheme(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSRVScrollBarSkinSchemeCollection;
class PASCALIMPLEMENTATION TSRVScrollBarSkinSchemeCollection : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TSRVScrollBarSkinScheme* operator[](int Index) { return Items[Index]; }
	
private:
	Classes::TPersistent* FOwner;
	HIDESBASE TSRVScrollBarSkinScheme* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, const TSRVScrollBarSkinScheme* Value);
	
public:
	__fastcall TSRVScrollBarSkinSchemeCollection(TMetaClass* ItemClass, Classes::TPersistent* Owner);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	__property TSRVScrollBarSkinScheme* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TSRVScrollBarSkinSchemeCollection(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSRVTabSetSkinScheme;
class PASCALIMPLEMENTATION TSRVTabSetSkinScheme : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	Classes::TCollection* FOwner;
	
protected:
	AnsiString FName;
	int FImgDecButton;
	int FImgIncButton;
	int FImgTabBegin;
	int FImgTabEnd;
	int FImgTabBackground;
	int FImgBorderBegin;
	int FImgBorderEnd;
	int FImgBorderBackground;
	int FImgBackgroundBegin;
	int FImgBackgroundEnd;
	int FImgBackgroundCenter;
	int FImgCloseButton;
	int FImgAddTabButton;
	int FFntTab;
	void __fastcall SetImgDecButton(int Value);
	void __fastcall SetImgIncButton(int Value);
	void __fastcall SetImgTabBegin(int Value);
	void __fastcall SetImgTabEnd(int Value);
	void __fastcall SetImgTabBackground(int Value);
	void __fastcall SetImgBorderBegin(int Value);
	void __fastcall SetImgBorderEnd(int Value);
	void __fastcall SetImgBorderBackground(int Value);
	void __fastcall SetImgBackgroundBegin(int Value);
	void __fastcall SetImgBackgroundEnd(int Value);
	void __fastcall SetImgBackgroundCenter(int Value);
	void __fastcall SetImgCloseButton(int Value);
	void __fastcall SetImgAddTabButton(int Value);
	void __fastcall SetFntTab(int Value);
	
public:
	__fastcall virtual TSRVTabSetSkinScheme(Classes::TCollection* Collection);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	virtual AnsiString __fastcall GetDisplayName();
	void __fastcall Repaint(void);
	
__published:
	__property AnsiString Name = {read=FName, write=FName};
	__property int ImgDecButton = {read=FImgDecButton, write=SetImgDecButton, default=-1};
	__property int ImgIncButton = {read=FImgIncButton, write=SetImgIncButton, default=-1};
	__property int ImgTabBegin = {read=FImgTabBegin, write=SetImgTabBegin, default=-1};
	__property int ImgTabEnd = {read=FImgTabEnd, write=SetImgTabEnd, default=-1};
	__property int ImgTabBackground = {read=FImgTabBackground, write=SetImgTabBackground, default=-1};
	__property int ImgBorderBegin = {read=FImgBorderBegin, write=SetImgBorderBegin, default=-1};
	__property int ImgBorderEnd = {read=FImgBorderEnd, write=SetImgBorderEnd, default=-1};
	__property int ImgBorderBackground = {read=FImgBorderBackground, write=SetImgBorderBackground, default=-1};
	__property int ImgBackgroundBegin = {read=FImgBackgroundBegin, write=SetImgBackgroundBegin, default=-1};
	__property int ImgBackgroundEnd = {read=FImgBackgroundEnd, write=SetImgBackgroundEnd, default=-1};
	__property int ImgBackgroundCenter = {read=FImgBackgroundCenter, write=SetImgBackgroundCenter, default=-1};
	__property int ImgCloseButton = {read=FImgCloseButton, write=SetImgCloseButton, default=-1};
	__property int ImgAddTabButton = {read=FImgAddTabButton, write=SetImgAddTabButton, default=-1};
	__property int FntTab = {read=FFntTab, write=SetFntTab, default=-1};
public:
	#pragma option push -w-inl
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TSRVTabSetSkinScheme(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSRVTabSetSkinSchemeCollection;
class PASCALIMPLEMENTATION TSRVTabSetSkinSchemeCollection : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TSRVTabSetSkinScheme* operator[](int Index) { return Items[Index]; }
	
private:
	Classes::TPersistent* FOwner;
	HIDESBASE TSRVTabSetSkinScheme* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, const TSRVTabSetSkinScheme* Value);
	
public:
	__fastcall TSRVTabSetSkinSchemeCollection(TMetaClass* ItemClass, Classes::TPersistent* Owner);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	__property TSRVTabSetSkinScheme* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TSRVTabSetSkinSchemeCollection(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSRVSkin;
class PASCALIMPLEMENTATION TSRVSkin : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	Classes::TCollection* FOwner;
	
protected:
	TSRVSkinFontCollection* FFonts;
	TSRVSkinElementCollection* FElements;
	TSRVScrollBarSkinSchemeCollection* FHorizontalScrollBarSchemes;
	TSRVScrollBarSkinSchemeCollection* FVerticalScrollBarSchemes;
	TSRVTabSetSkinSchemeCollection* FHorizontalTabSetSchemes;
	TSRVTabSetSkinSchemeCollection* FVerticalTabSetSchemes;
	TSRVBoxSchemeCollection* FBoxSchemes;
	AnsiString FName;
	void __fastcall SetFonts(const TSRVSkinFontCollection* Value);
	void __fastcall SetElements(const TSRVSkinElementCollection* Value);
	void __fastcall SetHorizontalScrollBarSchemes(const TSRVScrollBarSkinSchemeCollection* Value);
	void __fastcall SetVerticalScrollBarSchemes(const TSRVScrollBarSkinSchemeCollection* Value);
	void __fastcall SetHorizontalTabSetSchemes(const TSRVTabSetSkinSchemeCollection* Value);
	void __fastcall SetVerticalTabSetSchemes(const TSRVTabSetSkinSchemeCollection* Value);
	void __fastcall SetBoxSchemes(const TSRVBoxSchemeCollection* Value);
	
public:
	__fastcall virtual TSRVSkin(Classes::TCollection* Collection);
	__fastcall virtual ~TSRVSkin(void);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	virtual AnsiString __fastcall GetDisplayName();
	void __fastcall InvalidateAll(void);
	
__published:
	__property TSRVSkinFontCollection* Fonts = {read=FFonts, write=SetFonts};
	__property TSRVSkinElementCollection* Elements = {read=FElements, write=SetElements};
	__property TSRVScrollBarSkinSchemeCollection* HorizontalScrollBarSchemes = {read=FHorizontalScrollBarSchemes, write=SetHorizontalScrollBarSchemes};
	__property TSRVScrollBarSkinSchemeCollection* VerticalScrollBarSchemes = {read=FVerticalScrollBarSchemes, write=SetVerticalScrollBarSchemes};
	__property TSRVTabSetSkinSchemeCollection* HorizontalTabSetSchemes = {read=FHorizontalTabSetSchemes, write=SetHorizontalTabSetSchemes};
	__property TSRVTabSetSkinSchemeCollection* VerticalTabSetSchemes = {read=FVerticalTabSetSchemes, write=SetVerticalTabSetSchemes};
	__property TSRVBoxSchemeCollection* BoxSchemes = {read=FBoxSchemes, write=SetBoxSchemes};
	__property AnsiString Name = {read=FName, write=FName};
};


class DELPHICLASS TSRVSkinCollection;
class PASCALIMPLEMENTATION TSRVSkinCollection : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TSRVSkin* operator[](int Index) { return Items[Index]; }
	
private:
	Classes::TPersistent* FOwner;
	HIDESBASE TSRVSkin* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, const TSRVSkin* Value);
	
public:
	__fastcall TSRVSkinCollection(TMetaClass* ItemClass, Classes::TPersistent* Owner);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	__property TSRVSkin* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TSRVSkinCollection(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSRVSkinManager;
class PASCALIMPLEMENTATION TSRVSkinManager : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
protected:
	TSRVSkinCollection* FSkins;
	int FSkinIndex;
	TSRVSkin* __fastcall GetCurrentSkin(void);
	void __fastcall SetSkinIndex(int Value);
	void __fastcall SetSkins(const TSRVSkinCollection* Value);
	
public:
	__fastcall virtual TSRVSkinManager(Classes::TComponent* AOwner);
	__fastcall virtual ~TSRVSkinManager(void);
	TSRVSkinFont* __fastcall GetFont(int Index, int DefaultIndex = 0xffffffff);
	TSRVSkinElement* __fastcall GetSkinElement(int Index, int DefaultIndex = 0xffffffff);
	TSRVScrollBarSkinScheme* __fastcall GetScrollVar(int Index, bool IsHorizontal);
	TSRVTabSetSkinScheme* __fastcall GetTab(int Index, bool IsHorizontal, int DefaultIndex = 0xffffffff);
	TSRVBoxScheme* __fastcall GetBox(int Index, int DefaultIndex = 0xffffffff);
	void __fastcall Delete(int Index);
	void __fastcall Clear(void);
	void __fastcall InvalidateAll(void);
	bool __fastcall IsSkinMode(void);
	__property TSRVSkin* CurrentSkin = {read=GetCurrentSkin};
	
__published:
	__property TSRVSkinCollection* Skins = {read=FSkins, write=SetSkins};
	__property int SkinIndex = {read=FSkinIndex, write=SetSkinIndex, nodefault};
};


//-- var, const, procedure ---------------------------------------------------
#define TSRVDEFAULTSKINFONTNAME "Arial"
extern PACKAGE TSRVDrawStates __fastcall GetState(bool IsHot, bool IsDown, bool IsFocused, bool IsEnable);

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

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