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

// (DO NOT EDIT: machine generated header) 'QiPositionComponent.pas' rev: 6.00

#ifndef QiPositionComponentHPP
#define QiPositionComponentHPP

#pragma delphiheader begin
#pragma option push -w-
#pragma option push -Vx
#include <QiComponent.hpp>	// Pascal unit
#include <QiCLXComponent.hpp>	// Pascal unit
#include <QiCustomComponent.hpp>	// Pascal unit
#include <QiClasses.hpp>	// Pascal unit
#include <QiGPFunctions.hpp>	// Pascal unit
#include <QiTypes.hpp>	// Pascal unit
#include <QExtCtrls.hpp>	// Pascal unit
#include <QStdCtrls.hpp>	// Pascal unit
#include <QComCtrls.hpp>	// Pascal unit
#include <QControls.hpp>	// Pascal unit
#include <Variants.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Types.hpp>	// Pascal unit
#include <QTypes.hpp>	// Pascal unit
#include <QClipbrd.hpp>	// Pascal unit
#include <QDialogs.hpp>	// Pascal unit
#include <QForms.hpp>	// Pascal unit
#include <QGraphics.hpp>	// Pascal unit
#include <Qt.hpp>	// Pascal unit
#include <TypInfo.hpp>	// Pascal unit
#include <SysUtils.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <System.hpp>	// Pascal unit

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

namespace Qipositioncomponent
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TiPositionComponent;
class PASCALIMPLEMENTATION TiPositionComponent : public Qicustomcomponent::TiCustomComponent 
{
	typedef Qicustomcomponent::TiCustomComponent inherited;
	
private:
	Classes::TStringList* FLimitList;
	double FPosition;
	double FPositionMax;
	double FPositionMin;
	bool FShowMaxPointer;
	bool FShowMinPointer;
	double FCurrentMin;
	double FCurrentMax;
	int FMinMaxPointerMargin;
	int FMinMaxPointerSize;
	Qgraphics::TColor FMinPointerColor;
	Qgraphics::TColor FMaxPointerColor;
	Classes::TNotifyEvent FOnPositionChange;
	Classes::TNotifyEvent FOnCurrentMaxChange;
	Classes::TNotifyEvent FOnCurrentMinChange;
	Classes::TNotifyEvent FOnPositionChangeFinished;
	Classes::TNotifyEvent FOnPositionOverMax;
	Classes::TNotifyEvent FOnPositionUnderMin;
	bool FPositionedChanged;
	bool FMinMaxFixed;
	bool FMinMaxUserCanMove;
	Qitypes::TOnPositionLimit FOnPositionOverLimit;
	Qitypes::TOnPositionLimit FOnPositionUnderLimit;
	bool FUserGenerated;
	Classes::TNotifyEvent FOnPositionChangeUser;
	void __fastcall SetShowMaxPointer(const bool Value);
	void __fastcall SetShowMinPointer(const bool Value);
	void __fastcall SetCurrentMax(const double Value);
	void __fastcall SetCurrentMin(const double Value);
	void __fastcall SetMinMaxPointerMargin(const int Value);
	void __fastcall SetMinMaxPointerSize(const int Value);
	void __fastcall SetMaxPointerColor(const Qgraphics::TColor Value);
	void __fastcall SetMinPointerColor(const Qgraphics::TColor Value);
	void __fastcall SetPositionPercent(const double Value);
	void __fastcall SetMinMaxFixed(const bool Value);
	void __fastcall SetMinMaxUserCanMove(const bool Value);
	void __fastcall SetLimitUpperValue(int Index, const double Value);
	void __fastcall SetLimitLowerValue(int Index, const double Value);
	void __fastcall SetLimitUpperPointerColor(int Index, const Qgraphics::TColor Value);
	void __fastcall SetLimitPointerMargin(int Index, const int Value);
	void __fastcall SetLimitPointerSize(int Index, const int Value);
	void __fastcall SetLimitShowUpperPointer(int Index, const bool Value);
	void __fastcall SetLimitDrawScaleSide(int Index, const bool Value);
	double __fastcall GetLimitLowerValue(int Index);
	Qgraphics::TColor __fastcall GetLimitUpperPointerColor(int Index);
	int __fastcall GetLimitPointerMargin(int Index);
	int __fastcall GetLimitPointerSize(int Index);
	bool __fastcall GetLimitShowUpperPointer(int Index);
	double __fastcall GetLimitUpperValue(int Index);
	bool __fastcall GetLimitDrawScaleSide(int Index);
	double __fastcall GetPositionPercent(void);
	int __fastcall GetLimitCount(void);
	Qgraphics::TColor __fastcall GetLimitLowerPointerColor(int Index);
	bool __fastcall GetLimitShowLowerPointer(int Index);
	void __fastcall SetLimitLowerPointerColor(int Index, const Qgraphics::TColor Value);
	void __fastcall SetLimitShowLowerPointer(int Index, const bool Value);
	
protected:
	virtual double __fastcall GetPosition(void);
	virtual void __fastcall SetPosition(const double Value);
	double __fastcall ValuePercent(double Value);
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	void __fastcall WritePositionMax2(Classes::TWriter* Writer);
	void __fastcall ReadPositionMax2(Classes::TReader* Reader);
	void __fastcall DoPositionChange(void);
	void __fastcall DoCurrentMaxChange(void);
	void __fastcall DoCurrentMinChange(void);
	void __fastcall DoPositionOverMax(void);
	void __fastcall DoPositionUnderMin(void);
	void __fastcall DoPositionChangeFinished(void);
	virtual void __fastcall DoOPCPositionChangeFinished(void);
	void __fastcall DoPositionOverLimit(int Index);
	void __fastcall DoPositionUnderLimit(int Index);
	virtual void __fastcall SetPositionMin(const double Value);
	virtual void __fastcall SetPositionMax(const double Value);
	void __fastcall SetPositionMinMax(double Min, double Max);
	void __fastcall DoLimitBounds(void);
	virtual void __fastcall DoPointerBounds(void);
	Qiclasses::TiLimitObject* __fastcall GetLimitObject(int Index);
	__property bool UserGenerated = {read=FUserGenerated, write=FUserGenerated, nodefault};
	__property bool ShowMaxPointer = {read=FShowMaxPointer, write=SetShowMaxPointer, default=0};
	__property bool ShowMinPointer = {read=FShowMinPointer, write=SetShowMinPointer, default=0};
	__property int MinMaxPointerSize = {read=FMinMaxPointerSize, write=SetMinMaxPointerSize, default=8};
	__property int MinMaxPointerMargin = {read=FMinMaxPointerMargin, write=SetMinMaxPointerMargin, default=0};
	__property Qgraphics::TColor MaxPointerColor = {read=FMaxPointerColor, write=SetMaxPointerColor, default=16776960};
	__property Qgraphics::TColor MinPointerColor = {read=FMinPointerColor, write=SetMinPointerColor, default=65535};
	__property bool PositionedChanged = {read=FPositionedChanged, write=FPositionedChanged, nodefault};
	__property bool MinMaxUserCanMove = {read=FMinMaxUserCanMove, write=SetMinMaxUserCanMove, default=0};
	__property Classes::TNotifyEvent OnPositionChangeFinished = {read=FOnPositionChangeFinished, write=FOnPositionChangeFinished};
	__property Classes::TNotifyEvent OnPositionChangeUser = {read=FOnPositionChangeUser, write=FOnPositionChangeUser};
	
public:
	__fastcall virtual TiPositionComponent(Classes::TComponent* AOwner);
	__fastcall virtual ~TiPositionComponent(void);
	void __fastcall AddLimit(int PointerSize, int PointerMargin, bool DrawScaleSide, double UpperValue, double LowerValue, Qgraphics::TColor UpperPointerColor, Qgraphics::TColor LowerPointerColor);
	void __fastcall RemoveLimit(int Index);
	void __fastcall RemoveAllLimits(void);
	__property double LimitUpperValue[int Index] = {read=GetLimitUpperValue, write=SetLimitUpperValue};
	__property double LimitLowerValue[int Index] = {read=GetLimitLowerValue, write=SetLimitLowerValue};
	__property int LimitPointerSize[int Index] = {read=GetLimitPointerSize, write=SetLimitPointerSize};
	__property int LimitPointerMargin[int Index] = {read=GetLimitPointerMargin, write=SetLimitPointerMargin};
	__property Qgraphics::TColor LimitUpperPointerColor[int Index] = {read=GetLimitUpperPointerColor, write=SetLimitUpperPointerColor};
	__property Qgraphics::TColor LimitLowerPointerColor[int Index] = {read=GetLimitLowerPointerColor, write=SetLimitLowerPointerColor};
	__property bool LimitShowUpperPointer[int Index] = {read=GetLimitShowUpperPointer, write=SetLimitShowUpperPointer};
	__property bool LimitShowLowerPointer[int Index] = {read=GetLimitShowLowerPointer, write=SetLimitShowLowerPointer};
	__property bool LimitDrawScaleSide[int Index] = {read=GetLimitDrawScaleSide, write=SetLimitDrawScaleSide};
	__property int LimitCount = {read=GetLimitCount, nodefault};
	void __fastcall SetPositionNoEvent(const double Value);
	void __fastcall ResetMinMax(void);
	__property double PositionPercent = {read=GetPositionPercent, write=SetPositionPercent};
	
__published:
	__property double Position = {read=GetPosition, write=SetPosition};
	__property double PositionMax = {read=FPositionMax, write=SetPositionMax};
	__property double PositionMin = {read=FPositionMin, write=SetPositionMin};
	__property double CurrentMax = {read=FCurrentMax, write=SetCurrentMax};
	__property double CurrentMin = {read=FCurrentMin, write=SetCurrentMin};
	__property bool MinMaxFixed = {read=FMinMaxFixed, write=SetMinMaxFixed, default=0};
	__property Classes::TNotifyEvent OnPositionChange = {read=FOnPositionChange, write=FOnPositionChange};
	__property Classes::TNotifyEvent OnCurrentMaxChange = {read=FOnCurrentMaxChange, write=FOnCurrentMaxChange};
	__property Classes::TNotifyEvent OnCurrentMinChange = {read=FOnCurrentMinChange, write=FOnCurrentMinChange};
	__property Classes::TNotifyEvent OnPositionOverMax = {read=FOnPositionOverMax, write=FOnPositionOverMax};
	__property Classes::TNotifyEvent OnPositionUnderMin = {read=FOnPositionUnderMin, write=FOnPositionUnderMin};
	__property Qitypes::TOnPositionLimit OnPositionOverLimit = {read=FOnPositionOverLimit, write=FOnPositionOverLimit};
	__property Qitypes::TOnPositionLimit OnPositionUnderLimit = {read=FOnPositionUnderLimit, write=FOnPositionUnderLimit};
public:
	#pragma option push -w-inl
	/* TWidgetControl.CreateParented */ inline __fastcall TiPositionComponent(Qt::QWidgetH* ParentWidget) : Qicustomcomponent::TiCustomComponent(ParentWidget) { }
	#pragma option pop
	
};


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

}	/* namespace Qipositioncomponent */
using namespace Qipositioncomponent;
#pragma option pop	// -w-
#pragma option pop	// -Vx

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