advofficeselectors.hpp

TMSPack基本上涵盖了Delphi所有的基础控件

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

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

#ifndef AdvofficeselectorsHPP
#define AdvofficeselectorsHPP

#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 <Classes.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <Extctrls.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Imglist.hpp>	// Pascal unit
#include <Forms.hpp>	// Pascal unit
#include <Math.hpp>	// Pascal unit
#include <Dialogs.hpp>	// Pascal unit
#include <Advglowbutton.hpp>	// Pascal unit
#include <Gdipicture.hpp>	// Pascal unit
#include <Advgdip.hpp>	// Pascal unit
#include <Comctrls.hpp>	// Pascal unit
#include <Advstyleif.hpp>	// Pascal unit
#include <Commctrl.hpp>	// Pascal unit

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

namespace Advofficeselectors
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TAdvSelectorStyle { ssButton, ssCombo };
#pragma option pop

#pragma option push -b-
enum TGradientDirection { gdVertical, gdHorizontal };
#pragma option pop

#pragma option push -b-
enum TSelectorItemType { itAutoSizeButton, itFullWidthButton, itCaption };
#pragma option pop

#pragma option push -b-
enum TColorSelectionStyle { csDiscrete, csColorCube, csSpectrum };
#pragma option pop

#pragma option push -b-
enum TGripPosition { gpTop, gpBottom };
#pragma option pop

typedef Shortint TNoOfButtons;

class DELPHICLASS TSelectorButtonSize;
class PASCALIMPLEMENTATION TSelectorButtonSize : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	Classes::TNotifyEvent FOnChange;
	int FHeight;
	int FWidth;
	void __fastcall Changed(void);
	void __fastcall SetHeight(const int Value);
	void __fastcall SetWidth(const int Value);
	
public:
	__fastcall TSelectorButtonSize(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property int Height = {read=FHeight, write=SetHeight, nodefault};
	__property int Width = {read=FWidth, write=SetWidth, nodefault};
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TSelectorButtonSize(void) { }
	#pragma option pop
	
};


class DELPHICLASS TGradientBackground;
class PASCALIMPLEMENTATION TGradientBackground : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	int FSteps;
	Graphics::TColor FColor;
	Graphics::TColor FColorTo;
	TGradientDirection FDirection;
	Classes::TNotifyEvent FOnChange;
	Graphics::TColor FBorderColor;
	void __fastcall SetColor(const Graphics::TColor Value);
	void __fastcall SetColorTo(const Graphics::TColor Value);
	void __fastcall SetDirection(const TGradientDirection Value);
	void __fastcall SetSteps(const int Value);
	void __fastcall Changed(void);
	void __fastcall SetBorderColor(const Graphics::TColor Value);
	
public:
	__fastcall TGradientBackground(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property Graphics::TColor BorderColor = {read=FBorderColor, write=SetBorderColor, nodefault};
	__property Graphics::TColor Color = {read=FColor, write=SetColor, nodefault};
	__property Graphics::TColor ColorTo = {read=FColorTo, write=SetColorTo, nodefault};
	__property TGradientDirection Direction = {read=FDirection, write=SetDirection, nodefault};
	__property int Steps = {read=FSteps, write=SetSteps, default=64};
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TGradientBackground(void) { }
	#pragma option pop
	
};


class DELPHICLASS TGradientCaption;
class PASCALIMPLEMENTATION TGradientCaption : public TGradientBackground 
{
	typedef TGradientBackground inherited;
	
private:
	Graphics::TColor FTextColor;
	Graphics::TColor FTextColorDown;
	Graphics::TColor FTextColorHot;
	Advglowbutton::TGlowButtonAppearance* FButtonAppearance;
	void __fastcall SetButtonAppearance(const Advglowbutton::TGlowButtonAppearance* Value);
	
public:
	__fastcall TGradientCaption(void);
	__fastcall virtual ~TGradientCaption(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property Graphics::TColor TextColor = {read=FTextColor, write=FTextColor, nodefault};
	__property Graphics::TColor TextColorHot = {read=FTextColorHot, write=FTextColorHot, nodefault};
	__property Graphics::TColor TextColorDown = {read=FTextColorDown, write=FTextColorDown, nodefault};
	__property Advglowbutton::TGlowButtonAppearance* ButtonAppearance = {read=FButtonAppearance, write=SetButtonAppearance};
};


class DELPHICLASS TSimpleGradientCaption;
class PASCALIMPLEMENTATION TSimpleGradientCaption : public TGradientBackground 
{
	typedef TGradientBackground inherited;
	
private:
	Graphics::TColor FTextColor;
	
public:
	__fastcall TSimpleGradientCaption(void);
	__fastcall virtual ~TSimpleGradientCaption(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property Graphics::TColor TextColor = {read=FTextColor, write=FTextColor, nodefault};
};


class DELPHICLASS TVistaBackground;
class PASCALIMPLEMENTATION TVistaBackground : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	int FSteps;
	Graphics::TColor FColor;
	Graphics::TColor FColorTo;
	Classes::TNotifyEvent FOnChange;
	Graphics::TColor FColorMirror;
	Graphics::TColor FColorMirrorTo;
	Graphics::TColor FBorderColor;
	Advglowbutton::TGDIPGradient FGradientMirror;
	Advglowbutton::TGDIPGradient FGradient;
	void __fastcall SetColor(const Graphics::TColor Value);
	void __fastcall SetColorTo(const Graphics::TColor Value);
	void __fastcall SetSteps(const int Value);
	void __fastcall Changed(void);
	void __fastcall SetBorderColor(const Graphics::TColor Value);
	void __fastcall SetColorMirror(const Graphics::TColor Value);
	void __fastcall SetColorMirrorTo(const Graphics::TColor Value);
	void __fastcall SetGradient(const Advglowbutton::TGDIPGradient Value);
	void __fastcall SetGradientMirror(const Advglowbutton::TGDIPGradient Value);
	
public:
	__fastcall TVistaBackground(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property Graphics::TColor BorderColor = {read=FBorderColor, write=SetBorderColor, nodefault};
	__property Graphics::TColor Color = {read=FColor, write=SetColor, nodefault};
	__property Graphics::TColor ColorTo = {read=FColorTo, write=SetColorTo, nodefault};
	__property Graphics::TColor ColorMirror = {read=FColorMirror, write=SetColorMirror, nodefault};
	__property Graphics::TColor ColorMirrorTo = {read=FColorMirrorTo, write=SetColorMirrorTo, nodefault};
	__property Advglowbutton::TGDIPGradient Gradient = {read=FGradient, write=SetGradient, nodefault};
	__property Advglowbutton::TGDIPGradient GradientMirror = {read=FGradientMirror, write=SetGradientMirror, nodefault};
	__property int Steps = {read=FSteps, write=SetSteps, default=64};
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TVistaBackground(void) { }
	#pragma option pop
	
};


class DELPHICLASS TVistaBackgroundHot;
class PASCALIMPLEMENTATION TVistaBackgroundHot : public TVistaBackground 
{
	typedef TVistaBackground inherited;
	
private:
	Graphics::TColor FColorHot;
	Graphics::TColor FColorHotTo;
	Graphics::TColor FColorMirrorHot;
	Graphics::TColor FColorMirrorHotTo;
	Graphics::TColor FBorderColorHot;
	Advglowbutton::TGDIPGradient FGradientHot;
	Advglowbutton::TGDIPGradient FGradientMirrorHot;
	
public:
	__fastcall TVistaBackgroundHot(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property Graphics::TColor BorderColorHot = {read=FBorderColorHot, write=FBorderColorHot, nodefault};
	__property Graphics::TColor ColorHot = {read=FColorHot, write=FColorHot, nodefault};
	__property Graphics::TColor ColorHotTo = {read=FColorHotTo, write=FColorHotTo, nodefault};
	__property Graphics::TColor ColorMirrorHot = {read=FColorMirrorHot, write=FColorMirrorHot, nodefault};
	__property Graphics::TColor ColorMirrorHotTo = {read=FColorMirrorHotTo, write=FColorMirrorHotTo, nodefault};
	__property Advglowbutton::TGDIPGradient GradientHot = {read=FGradientHot, write=FGradientHot, nodefault};
	__property Advglowbutton::TGDIPGradient GradientMirrorHot = {read=FGradientMirrorHot, write=FGradientMirrorHot, nodefault};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TVistaBackgroundHot(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSelectionAppearance;
class PASCALIMPLEMENTATION TSelectionAppearance : public Advglowbutton::TGlowButtonAppearance 
{
	typedef Advglowbutton::TGlowButtonAppearance inherited;
	
private:
	Graphics::TColor FTextColor;
	Graphics::TColor FTextColorDisabled;
	Graphics::TColor FTextColorDown;
	Graphics::TColor FTextColorHot;
	Graphics::TColor FTextColorChecked;
	bool FRounded;
	void __fastcall SetTextColor(const Graphics::TColor Value);
	void __fastcall SetTextColorChecked(const Graphics::TColor Value);
	void __fastcall SetTextColorDisabled(const Graphics::TColor Value);
	void __fastcall SetTextColorDown(const Graphics::TColor Value);
	void __fastcall SetTextColorHot(const Graphics::TColor Value);
	void __fastcall SetRounded(const bool Value);
	
public:
	__fastcall TSelectionAppearance(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property Graphics::TColor TextColor = {read=FTextColor, write=SetTextColor, nodefault};
	__property Graphics::TColor TextColorHot = {read=FTextColorHot, write=SetTextColorHot, nodefault};
	__property Graphics::TColor TextColorDown = {read=FTextColorDown, write=SetTextColorDown, nodefault};
	__property Graphics::TColor TextColorChecked = {read=FTextColorChecked, write=SetTextColorChecked, nodefault};
	__property Graphics::TColor TextColorDisabled = {read=FTextColorDisabled, write=SetTextColorDisabled, nodefault};
	__property bool Rounded = {read=FRounded, write=SetRounded, nodefault};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TSelectionAppearance(void) { }
	#pragma option pop
	
};


class DELPHICLASS TAdvSelectorItem;
class PASCALIMPLEMENTATION TAdvSelectorItem : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	#pragma pack(push,1)
	Types::TRect FItemRect;
	#pragma pack(pop)
	AnsiString FCaption;
	bool FEnable;
	int FImageIndex;
	AnsiString FValue;
	AnsiString FHint;
	Classes::TAlignment FCaptionAlignment;
	TSelectorItemType FItemType;
	Graphics::TColor FBackGroundColor;
	int FTag;
	void __fastcall SetEnable(const bool Value);
	void __fastcall SetHint(const AnsiString Value);
	void __fastcall SetImageIndex(const int Value);
	void __fastcall SetValue(const AnsiString Value);
	void __fastcall SetvCaptionAlignment(const Classes::TAlignment Value);