vrclasses.hpp

wimax bs simulator对应的GUI程序

// Borland C++ Builder
// Copyright (c) 1995, 1999 by Borland International
// All rights reserved

// (DO NOT EDIT: machine generated header) 'VrClasses.pas' rev: 5.00

#ifndef VrClassesHPP
#define VrClassesHPP

#pragma delphiheader begin
#pragma option push -w-
#pragma option push -Vx
#include <VrSysUtils.hpp>	// Pascal unit
#include <Dialogs.hpp>	// Pascal unit
#include <Forms.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <SysUtils.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <System.hpp>	// Pascal unit

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

namespace Vrclasses
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TVrPersistent;
class PASCALIMPLEMENTATION TVrPersistent : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	int FUpdateCount;
	Classes::TNotifyEvent FOnChange;
	
protected:
	void __fastcall Changed(void);
	
public:
	void __fastcall BeginUpdate(void);
	void __fastcall EndUpdate(void);
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TVrPersistent(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TVrPersistent(void) : Classes::TPersistent() { }
	#pragma option pop
	
};


#pragma option push -b-
enum TVrBevelStyle { bsNone, bsLowered, bsRaised };
#pragma option pop

#pragma option push -b-
enum TVrBevelOutlineStyle { osOuter, osInner, osNone };
#pragma option pop

typedef int TVrBevelWidth;

typedef int TVrBorderWidth;

typedef int TVrBevelSpace;

class DELPHICLASS TVrBevel;
class PASCALIMPLEMENTATION TVrBevel : public TVrPersistent 
{
	typedef TVrPersistent inherited;
	
private:
	TVrBorderWidth FBorderWidth;
	Graphics::TColor FBorderColor;
	Graphics::TColor FInnerShadow;
	Graphics::TColor FInnerHighlight;
	TVrBevelWidth FInnerWidth;
	TVrBevelStyle FInnerStyle;
	TVrBevelOutlineStyle FInnerOutline;
	TVrBevelSpace FInnerSpace;
	Graphics::TColor FInnerColor;
	Graphics::TColor FOuterShadow;
	Graphics::TColor FOuterHighlight;
	TVrBevelWidth FOuterWidth;
	TVrBevelStyle FOuterStyle;
	TVrBevelOutlineStyle FOuterOutline;
	TVrBevelSpace FOuterSpace;
	Graphics::TColor FOuterColor;
	bool FVisible;
	void __fastcall SetBorderWidth(TVrBorderWidth Value);
	void __fastcall SetBorderColor(Graphics::TColor Value);
	void __fastcall SetInnerShadow(Graphics::TColor Value);
	void __fastcall SetInnerHighlight(Graphics::TColor Value);
	void __fastcall SetInnerWidth(TVrBevelWidth Value);
	void __fastcall SetInnerStyle(TVrBevelStyle Value);
	void __fastcall SetInnerOutline(TVrBevelOutlineStyle Value);
	void __fastcall SetInnerSpace(TVrBevelSpace Value);
	void __fastcall SetInnerColor(Graphics::TColor Value);
	void __fastcall SetOuterShadow(Graphics::TColor Value);
	void __fastcall SetOuterHighlight(Graphics::TColor Value);
	void __fastcall SetOuterWidth(TVrBevelWidth Value);
	void __fastcall SetOuterStyle(TVrBevelStyle Value);
	void __fastcall SetOuterOutline(TVrBevelOutlineStyle Value);
	void __fastcall SetOuterSpace(TVrBevelSpace Value);
	void __fastcall SetOuterColor(Graphics::TColor Value);
	void __fastcall SetVisible(bool Value);
	
public:
	__fastcall TVrBevel(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall GetVisibleArea(Windows::TRect &Rect);
	void __fastcall Paint(Graphics::TCanvas* Canvas, Windows::TRect &Rect);
	
__published:
	__property TVrBorderWidth BorderWidth = {read=FBorderWidth, write=SetBorderWidth, default=0};
	__property Graphics::TColor BorderColor = {read=FBorderColor, write=SetBorderColor, default=-2147483633
		};
	__property Graphics::TColor InnerShadow = {read=FInnerShadow, write=SetInnerShadow, nodefault};
	__property Graphics::TColor InnerHighlight = {read=FInnerHighlight, write=SetInnerHighlight, nodefault
		};
	__property TVrBevelWidth InnerWidth = {read=FInnerWidth, write=SetInnerWidth, nodefault};
	__property TVrBevelStyle InnerStyle = {read=FInnerStyle, write=SetInnerStyle, nodefault};
	__property TVrBevelOutlineStyle InnerOutline = {read=FInnerOutline, write=SetInnerOutline, default=2
		};
	__property TVrBevelSpace InnerSpace = {read=FInnerSpace, write=SetInnerSpace, nodefault};
	__property Graphics::TColor InnerColor = {read=FInnerColor, write=SetInnerColor, nodefault};
	__property Graphics::TColor OuterShadow = {read=FOuterShadow, write=SetOuterShadow, nodefault};
	__property Graphics::TColor OuterHighlight = {read=FOuterHighlight, write=SetOuterHighlight, nodefault
		};
	__property TVrBevelWidth OuterWidth = {read=FOuterWidth, write=SetOuterWidth, default=1};
	__property TVrBevelStyle OuterStyle = {read=FOuterStyle, write=SetOuterStyle, nodefault};
	__property TVrBevelOutlineStyle OuterOutline = {read=FOuterOutline, write=SetOuterOutline, nodefault
		};
	__property TVrBevelSpace OuterSpace = {read=FOuterSpace, write=SetOuterSpace, default=0};
	__property Graphics::TColor OuterColor = {read=FOuterColor, write=SetOuterColor, default=-2147483633
		};
	__property bool Visible = {read=FVisible, write=SetVisible, default=1};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TVrBevel(void) { }
	#pragma option pop
	
};


class DELPHICLASS TVrPalette;
class PASCALIMPLEMENTATION TVrPalette : public TVrPersistent 
{
	typedef TVrPersistent inherited;
	
private:
	Graphics::TColor FLow;
	Graphics::TColor FHigh;
	void __fastcall SetLow(Graphics::TColor Value);
	void __fastcall SetHigh(Graphics::TColor Value);
	virtual Graphics::TColor __fastcall GetColors(int Index);
	
public:
	__fastcall TVrPalette(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall ToBMP(Graphics::TBitmap* Bitmap, Graphics::TColor DarkColor, Graphics::TColor LightColor
		);
	__property Graphics::TColor Colors[int Index] = {read=GetColors/*, default*/};
	
__published:
	__property Graphics::TColor Low = {read=FLow, write=SetLow, nodefault};
	__property Graphics::TColor High = {read=FHigh, write=SetHigh, nodefault};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TVrPalette(void) { }
	#pragma option pop
	
};


class DELPHICLASS TVrPaletteEx;
class PASCALIMPLEMENTATION TVrPaletteEx : public TVrPersistent 
{
	typedef TVrPersistent inherited;
	
private:
	Graphics::TColor FLow1;
	Graphics::TColor FLow2;
	Graphics::TColor FHigh1;
	Graphics::TColor FHigh2;
	void __fastcall SetLow1(Graphics::TColor Value);
	void __fastcall SetHigh1(Graphics::TColor Value);
	void __fastcall SetLow2(Graphics::TColor Value);
	void __fastcall SetHigh2(Graphics::TColor Value);
	
public:
	__fastcall TVrPaletteEx(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property Graphics::TColor Low1 = {read=FLow1, write=SetLow1, nodefault};
	__property Graphics::TColor High1 = {read=FHigh1, write=SetHigh1, nodefault};
	__property Graphics::TColor Low2 = {read=FLow2, write=SetLow2, nodefault};
	__property Graphics::TColor High2 = {read=FHigh2, write=SetHigh2, nodefault};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TVrPaletteEx(void) { }
	#pragma option pop
	
};


class DELPHICLASS TVrMinMax;
class PASCALIMPLEMENTATION TVrMinMax : public TVrPersistent 
{
	typedef TVrPersistent inherited;
	
private:
	int FMinValue;
	int FMaxValue;
	int FPosition;
	void __fastcall SetMinValue(int Value);
	void __fastcall SetMaxValue(int Value);
	void __fastcall SetPosition(int Value);
	
public:
	__fastcall TVrMinMax(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property int MinValue = {read=FMinValue, write=SetMinValue, nodefault};
	__property int MaxValue = {read=FMaxValue, write=SetMaxValue, nodefault};
	__property int Position = {read=FPosition, write=SetPosition, nodefault};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TVrMinMax(void) { }
	#pragma option pop
	
};


class DELPHICLASS TVrTextOutline;
class PASCALIMPLEMENTATION TVrTextOutline : public TVrPersistent 
{
	typedef TVrPersistent inherited;
	
private:
	Graphics::TColor FColor;
	bool FVisible;
	int FWidth;
	void __fastcall SetColor(Graphics::TColor Value);