// CodeGear C++Builder
// Copyright (c) 1995, 2014 by Embarcadero Technologies, Inc.
// All rights reserved

// (DO NOT EDIT: machine generated header) 'FMX.TMSGauge.pas' rev: 27.00 (Windows)

#ifndef Fmx_TmsgaugeHPP
#define Fmx_TmsgaugeHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member 
#pragma pack(push,8)
#include <System.hpp>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <FMX.Types.hpp>	// Pascal unit
#include <FMX.Objects.hpp>	// Pascal unit
#include <FMX.Effects.hpp>	// Pascal unit
#include <System.Classes.hpp>	// Pascal unit
#include <System.DateUtils.hpp>	// Pascal unit
#include <System.Types.hpp>	// Pascal unit
#include <System.SysUtils.hpp>	// Pascal unit
#include <System.Math.hpp>	// Pascal unit
#include <System.UITypes.hpp>	// Pascal unit
#include <FMX.TMSBaseControl.hpp>	// Pascal unit
#include <System.UIConsts.hpp>	// Pascal unit
#include <FMX.Styles.hpp>	// Pascal unit
#include <FMX.Controls.hpp>	// Pascal unit
#include <FMX.Graphics.hpp>	// Pascal unit

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

namespace Fmx
{
namespace Tmsgauge
{
//-- type declarations -------------------------------------------------------
typedef void __fastcall (__closure *TTMSFMXApplyDivisionLineStyle)(System::TObject* Sender, Fmx::Objects::TLine* AOriginalLine, Fmx::Objects::TLine* ALine, int DivisionUnit, float Value);

typedef void __fastcall (__closure *TTMSFMXApplySubDivisionLineStyle)(System::TObject* Sender, Fmx::Objects::TLine* AOriginalLine, Fmx::Objects::TLine* ALine, int DivisionUnit, int SubDivisionUnit, float Value);

typedef void __fastcall (__closure *TTMSFMXApplyDivisionTextStyle)(System::TObject* Sender, Fmx::Objects::TText* AOriginalText, Fmx::Objects::TText* AText, int DivisionUnit, float Value);

typedef void __fastcall (__closure *TTMSFMXApplySubDivisionTextStyle)(System::TObject* Sender, Fmx::Objects::TText* AOriginalText, Fmx::Objects::TText* AText, int DivisionUnit, int SubDivisionUnit, float Value);

typedef void __fastcall (__closure *TTMSFMXValueChanged)(System::TObject* Sender, float Value);

enum DECLSPEC_DENUM TSetPointShape : unsigned char { spsTriangle, spsRectangle, spsDiamond, spsEllipse, spsNone };

struct DECLSPEC_DRECORD TGaugeValue
{
public:
	bool State;
	float Value;
};


class DELPHICLASS TTMSFMXSetPointShape;
class PASCALIMPLEMENTATION TTMSFMXSetPointShape : public Fmx::Tmsbasecontrol::TTMSFMXBaseShape
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseShape inherited;
	
private:
	TSetPointShape FKind;
	void __fastcall SetKind(const TSetPointShape Value);
	
public:
	virtual void __fastcall Painting(void);
	__fastcall virtual TTMSFMXSetPointShape(System::Classes::TComponent* AOwner);
	
__published:
	__property TSetPointShape Kind = {read=FKind, write=SetKind, default=0};
	__property Fill;
	__property Stroke;
	__property StrokeThickness = {default=0};
	__property StrokeCap;
	__property StrokeDash;
	__property StrokeJoin;
public:
	/* TShape.Destroy */ inline __fastcall virtual ~TTMSFMXSetPointShape(void) { }
	
};


enum DECLSPEC_DENUM TTMSFMXNeedleShapeKind : unsigned char { nskNeedle, nskRectangle, nskEllipse, nskTriangle, nskDiamond, nskNone };

class DELPHICLASS TTMSFMXNeedleShape;
class PASCALIMPLEMENTATION TTMSFMXNeedleShape : public Fmx::Tmsbasecontrol::TTMSFMXBaseShape
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseShape inherited;
	
private:
	TTMSFMXNeedleShapeKind FKind;
	void __fastcall SetKind(const TTMSFMXNeedleShapeKind Value);
	
public:
	virtual void __fastcall Painting(void);
	__fastcall virtual TTMSFMXNeedleShape(System::Classes::TComponent* AOwner);
	
__published:
	__property TTMSFMXNeedleShapeKind Kind = {read=FKind, write=SetKind, default=0};
	__property Fill;
	__property Stroke;
	__property StrokeThickness = {default=0};
	__property StrokeCap;
	__property StrokeDash;
	__property StrokeJoin;
public:
	/* TShape.Destroy */ inline __fastcall virtual ~TTMSFMXNeedleShape(void) { }
	
};


enum DECLSPEC_DENUM TSectionShapeKind : unsigned char { sskEllipse, sskRectangle };

class DELPHICLASS TTMSFMXSectionShape;
class PASCALIMPLEMENTATION TTMSFMXSectionShape : public Fmx::Tmsbasecontrol::TTMSFMXBaseShape
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseShape inherited;
	
private:
	int FStopAngle;
	int FStartAngle;
	int FInnerMargin;
	TSectionShapeKind FKind;
	int FOuterMargin;
	void __fastcall SetStartAngle(const int Value);
	void __fastcall SetStopAngle(const int Value);
	void __fastcall SetInnerMargin(const int Value);
	void __fastcall SetKind(const TSectionShapeKind Value);
	void __fastcall SetOuterMargin(const int Value);
	
public:
	virtual void __fastcall Painting(void);
	__fastcall virtual TTMSFMXSectionShape(System::Classes::TComponent* AOwner);
	
__published:
	__property Fill;
	__property Stroke;
	__property StrokeThickness = {default=0};
	__property StrokeCap;
	__property StrokeDash;
	__property StrokeJoin;
	__property int StartAngle = {read=FStartAngle, write=SetStartAngle, default=0};
	__property int StopAngle = {read=FStopAngle, write=SetStopAngle, default=360};
	__property int InnerMargin = {read=FInnerMargin, write=SetInnerMargin, default=20};
	__property int OuterMargin = {read=FOuterMargin, write=SetOuterMargin, default=0};
	__property TSectionShapeKind Kind = {read=FKind, write=SetKind, default=0};
public:
	/* TShape.Destroy */ inline __fastcall virtual ~TTMSFMXSectionShape(void) { }
	
};


class DELPHICLASS TTMSFMXPieShape;
class PASCALIMPLEMENTATION TTMSFMXPieShape : public Fmx::Tmsbasecontrol::TTMSFMXBaseShape
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseShape inherited;
	
private:
	int FStopAngle;
	int FStartAngle;
	void __fastcall SetStartAngle(const int Value);
	void __fastcall SetStopAngle(const int Value);
	
public:
	virtual void __fastcall Painting(void);
	__fastcall virtual TTMSFMXPieShape(System::Classes::TComponent* AOwner);
	
__published:
	__property Fill;
	__property Stroke;
	__property StrokeThickness = {default=0};
	__property StrokeCap;
	__property StrokeDash;
	__property StrokeJoin;
	__property int StartAngle = {read=FStartAngle, write=SetStartAngle, default=0};
	__property int StopAngle = {read=FStopAngle, write=SetStopAngle, default=360};
public:
	/* TShape.Destroy */ inline __fastcall virtual ~TTMSFMXPieShape(void) { }
	
};


class DELPHICLASS TTMSFMXSection;
class DELPHICLASS TTMSFMXGauge;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TTMSFMXSection : public System::Classes::TCollectionItem
{
	typedef System::Classes::TCollectionItem inherited;
	
private:
	TTMSFMXGauge* FOwner;
	float FStartValue;
	float FEndValue;
	void __fastcall SetEndValue(const float Value);
	void __fastcall SetStartValue(const float Value);
	
protected:
	virtual void __fastcall InitValues(void);
	
public:
	__fastcall virtual TTMSFMXSection(System::Classes::TCollection* Collection);
	__fastcall virtual ~TTMSFMXSection(void);
	void __fastcall UpdateSection(void);
	TTMSFMXSectionShape* __fastcall Shape(void);
	
__published:
	__property float StartValue = {read=FStartValue, write=SetStartValue};
	__property float EndValue = {read=FEndValue, write=SetEndValue};
};

#pragma pack(pop)

class DELPHICLASS TTMSFMXGaugeSection;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TTMSFMXGaugeSection : public TTMSFMXSection
{
	typedef TTMSFMXSection inherited;
	
private:
	int FInnerMargin;
	int FOuterMargin;
	void __fastcall SetInnerMargin(const int Value);
	void __fastcall SetOuterMargin(const int Value);
	
protected:
	virtual void __fastcall InitValues(void);
	
public:
	__fastcall virtual TTMSFMXGaugeSection(System::Classes::TCollection* Collection);
	__fastcall virtual ~TTMSFMXGaugeSection(void);
	
__published:
	__property int InnerMargin = {read=FInnerMargin, write=SetInnerMargin, default=20};
	__property int OuterMargin = {read=FOuterMargin, write=SetOuterMargin, default=0};
};

#pragma pack(pop)

class DELPHICLASS TTMSFMXSections;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TTMSFMXSections : public Fmx::Tmsbasecontrol::TTMSFMXBaseCollection
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseCollection inherited;
	
public:
	TTMSFMXSection* operator[](int Index) { return Items[Index]; }
	
private:
	TTMSFMXGauge* FOwner;
	HIDESBASE TTMSFMXSection* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, TTMSFMXSection* const Value);
	
protected:
	DYNAMIC System::Classes::TPersistent* __fastcall GetOwner(void);
	
public:
	__fastcall TTMSFMXSections(System::Classes::TCollectionItemClass AClass, TTMSFMXGauge* AOwner);
	HIDESBASE TTMSFMXSection* __fastcall Add(void);
	HIDESBASE TTMSFMXSection* __fastcall Insert(int Index);
	__property TTMSFMXSection* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
public:
	/* TCollection.Destroy */ inline __fastcall virtual ~TTMSFMXSections(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TTMSFMXSetPoint;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TTMSFMXSetPoint : public System::Classes::TCollectionItem
{
	typedef System::Classes::TCollectionItem inherited;
	
private:
	TSetPointShape FKind;
	bool FdoAnim;
	float FCurrentValue;
	float FCurrentValueTo;
	TTMSFMXGauge* FOwner;
	void __fastcall SetValue(const float Value);
	float __fastcall GetValue(void);
	TSetPointShape __fastcall GetKind(void);
	void __fastcall SetKind(const TSetPointShape Value);
	
public:
	__fastcall virtual TTMSFMXSetPoint(System::Classes::TCollection* Collection);
	__fastcall virtual ~TTMSFMXSetPoint(void);
	void __fastcall UpdateSetPoint(void);
	TTMSFMXSetPointShape* __fastcall Shape(void);
	
__published:
	__property float Value = {read=GetValue, write=SetValue};
	__property TSetPointShape Kind = {read=GetKind, write=SetKind, default=0};
};

#pragma pack(pop)

class DELPHICLASS TTMSFMXSetPoints;
class PASCALIMPLEMENTATION TTMSFMXSetPoints : public Fmx::Tmsbasecontrol::TTMSFMXBaseCollection
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseCollection inherited;
	
public:
	TTMSFMXSetPoint* operator[](int Index) { return Items[Index]; }
	
private:
	TTMSFMXGauge* FOwner;
	System::Classes::TNotifyEvent FOnChange;
	HIDESBASE TTMSFMXSetPoint* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, TTMSFMXSetPoint* const Value);
	
protected:
	DYNAMIC System::Classes::TPersistent* __fastcall GetOwner(void);
	
public:
	__fastcall TTMSFMXSetPoints(TTMSFMXGauge* AOwner);
	HIDESBASE TTMSFMXSetPoint* __fastcall Add(void);
	HIDESBASE TTMSFMXSetPoint* __fastcall Insert(int Index);
	__property TTMSFMXSetPoint* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
	
__published:
	__property System::Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
public:
	/* TCollection.Destroy */ inline __fastcall virtual ~TTMSFMXSetPoints(void) { }
	
};


class DELPHICLASS TTMSFMXExtraNeedle;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TTMSFMXExtraNeedle : public System::Classes::TCollectionItem
{
	typedef System::Classes::TCollectionItem inherited;
	
private:
	bool FdoAnim;
	float FCurrentValue;
	float FCurrentValueTo;
	TTMSFMXGauge* FOwner;
	void __fastcall SetValue(const float Value);
	float __fastcall GetValue(void);
	
public:
	__fastcall virtual TTMSFMXExtraNeedle(System::Classes::TCollection* Collection);
	__fastcall virtual ~TTMSFMXExtraNeedle(void);
	void __fastcall UpdateExtraNeedle(void);
	TTMSFMXNeedleShape* __fastcall Shape(void);
	
__published:
	__property float Value = {read=GetValue, write=SetValue};
};

#pragma pack(pop)

class DELPHICLASS TTMSFMXExtraNeedles;
class PASCALIMPLEMENTATION TTMSFMXExtraNeedles : public Fmx::Tmsbasecontrol::TTMSFMXBaseCollection
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseCollection inherited;
	
public:
	TTMSFMXExtraNeedle* operator[](int Index) { return Items[Index]; }
	
private:
	TTMSFMXGauge* FOwner;
	System::Classes::TNotifyEvent FOnChange;
	HIDESBASE TTMSFMXExtraNeedle* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, TTMSFMXExtraNeedle* const Value);
	
protected:
	DYNAMIC System::Classes::TPersistent* __fastcall GetOwner(void);
	
public:
	__fastcall TTMSFMXExtraNeedles(TTMSFMXGauge* AOwner);
	HIDESBASE TTMSFMXExtraNeedle* __fastcall Add(void);
	HIDESBASE TTMSFMXExtraNeedle* __fastcall Insert(int Index);
	__property TTMSFMXExtraNeedle* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
	
__published:
	__property System::Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
public:
	/* TCollection.Destroy */ inline __fastcall virtual ~TTMSFMXExtraNeedles(void) { }
	
};


typedef void __fastcall (__closure *TTMSFMXGaugeSetPointClickEvent)(System::TObject* Sender, TTMSFMXSetPoint* SetPoint);

typedef void __fastcall (__closure *TTMSFMXGaugeNeedleClickEvent)(System::TObject* Sender, TTMSFMXExtraNeedle* Needle);

typedef void __fastcall (__closure *TTMSFMXGaugeSectionClickEvent)(System::TObject* Sender, TTMSFMXSection* Section);

typedef void __fastcall (__closure *TTMSFMXValueClickEvent)(System::TObject* Sender, float Value);

class PASCALIMPLEMENTATION TTMSFMXGauge : public Fmx::Tmsbasecontrol::TTMSFMXBaseControl
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseControl inherited;
	
private:
	Fmx::Types::TTimer* FAnimTimer;
	Fmx::Types::TTimer* FExtraTimer;
	float FCurrentValue;
	float FCurrentValueTo;
	bool doanimation;
	bool doExtraAnimation;
	int FSubDivisions;
	int FDivisions;
	float FMaximumValue;
	float FMinimumValue;
	bool FShowSubDivisions;
	bool FShowSubDivisionText;
	bool FShowDivisions;
	bool FShowDivisionText;
	System::UnicodeString FDivisionFormat;
	System::UnicodeString FSubDivisionFormat;
	System::UnicodeString FDisplayText;
	TTMSFMXSections* FSections;
	bool FAnimation;
	TTMSFMXApplySubDivisionLineStyle FOnApplySubDivisionLineStyle;
	TTMSFMXApplySubDivisionTextStyle FOnApplySubDivisionTextStyle;
	TTMSFMXApplyDivisionLineStyle FOnApplyDivisionLineStyle;
	TTMSFMXApplyDivisionTextStyle FOnApplyDivisionTextStyle;
	TTMSFMXValueChanged FOnValueChanged;
	TTMSFMXValueChanged FOnValueChanging;
	TTMSFMXExtraNeedles* FExtraNeedles;
	TTMSFMXSetPoints* FSetPoints;
	float FAnimationFactor;
	TTMSFMXGaugeSetPointClickEvent FOnSetPointClick;
	TTMSFMXValueClickEvent FOnValueClick;
	TTMSFMXGaugeSectionClickEvent FOnSectionClick;
	TTMSFMXGaugeNeedleClickEvent FOnExtraNeedleClick;
	void __fastcall SetDivisions(const int Value);
	void __fastcall SetSubDivisions(const int Value);
	float __fastcall GetValue(void);
	void __fastcall SetMaxValue(const float Value);
	void __fastcall SetMinValue(const float Value);
	virtual void __fastcall SetValue(const float Value);
	void __fastcall SetShowDivisions(const bool Value);
	void __fastcall SetShowDivisionText(const bool Value);
	void __fastcall SetShowSubDivisions(const bool Value);
	void __fastcall SetShowSubDivisionText(const bool Value);
	void __fastcall SetDivisionFormat(const System::UnicodeString Value);
	void __fastcall SetSubDivisionFormat(const System::UnicodeString Value);
	void __fastcall SetDisplayText(const System::UnicodeString Value);
	void __fastcall SetSections(TTMSFMXSections* const Value);
	void __fastcall SetAnimation(const bool Value);
	void __fastcall SetExtraNeedles(TTMSFMXExtraNeedles* const Value);
	void __fastcall SetSetPoints(TTMSFMXSetPoints* const Value);
	System::UnicodeString __fastcall GetVersion(void);
	int __fastcall GetVersionNr(void);
	
protected:
	virtual NativeUInt __fastcall GetInstance(void);
	virtual void __fastcall AssignEvents(void);
	virtual TGaugeValue __fastcall XYToValue(float X, float Y);
	virtual float __fastcall FindStartAngle(void);
	virtual float __fastcall FindStopAngle(void);
	void __fastcall InnerElementMouseUp(System::TObject* Sender, System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, float X, float Y);
	virtual void __fastcall ValueClick(System::TObject* Sender);
	TTMSFMXSection* __fastcall GetSectionForShape(TTMSFMXSectionShape* AShape);
	TTMSFMXExtraNeedle* __fastcall GetExtraNeedleForShape(TTMSFMXNeedleShape* AShape);
	TTMSFMXSetPoint* __fastcall GetSetPointForShape(TTMSFMXSetPointShape* AShape);
	void __fastcall SetPointClick(System::TObject* Sender);
	void __fastcall SectionClick(System::TObject* Sender);
	void __fastcall SectionMouseUp(System::TObject* Sender, System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, float X, float Y);
	void __fastcall ExtraNeedleClick(System::TObject* Sender);
	virtual void __fastcall AnimateUpdateNeedle(void);
	virtual void __fastcall AnimateUpdateDivisions(void);
	virtual void __fastcall AnimateUpdateValues(void);
	__property float AnimationFactor = {read=FAnimationFactor, write=FAnimationFactor};
	__property TTMSFMXApplyDivisionLineStyle OnApplyDivisionLineStyle = {read=FOnApplyDivisionLineStyle, write=FOnApplyDivisionLineStyle};
	__property TTMSFMXApplySubDivisionLineStyle OnApplySubDivisionLineStyle = {read=FOnApplySubDivisionLineStyle, write=FOnApplySubDivisionLineStyle};
	__property TTMSFMXApplyDivisionTextStyle OnApplyDivisionTextStyle = {read=FOnApplyDivisionTextStyle, write=FOnApplyDivisionTextStyle};
	__property TTMSFMXApplySubDivisionTextStyle OnApplySubDivisionTextStyle = {read=FOnApplySubDivisionTextStyle, write=FOnApplySubDivisionTextStyle};
	__property TTMSFMXValueChanged OnValueChanged = {read=FOnValueChanged, write=FOnValueChanged};
	__property TTMSFMXValueChanged OnValueChanging = {read=FOnValueChanging, write=FOnValueChanging};
	__property bool Animation = {read=FAnimation, write=SetAnimation, default=1};
	__property int Divisions = {read=FDivisions, write=SetDivisions, default=10};
	__property int SubDivisions = {read=FSubDivisions, write=SetSubDivisions, default=2};
	__property float Value = {read=GetValue, write=SetValue};
	__property bool ShowSubDivisions = {read=FShowSubDivisions, write=SetShowSubDivisions, default=1};
	__property bool ShowDivisions = {read=FShowDivisions, write=SetShowDivisions, default=1};
	__property bool ShowSubDivisionText = {read=FShowSubDivisionText, write=SetShowSubDivisionText, default=0};
	__property bool ShowDivisionText = {read=FShowDivisionText, write=SetShowDivisionText, default=1};
	__property System::UnicodeString DivisionFormat = {read=FDivisionFormat, write=SetDivisionFormat};
	__property System::UnicodeString SubDivisionFormat = {read=FSubDivisionFormat, write=SetSubDivisionFormat};
	virtual void __fastcall DoApplyDivisionLineStyle(System::TObject* Sender, Fmx::Objects::TLine* AOriginalLine, Fmx::Objects::TLine* ALine, int DivisionUnit, float Value);
	virtual void __fastcall DoApplySubDivisionLineStyle(System::TObject* Sender, Fmx::Objects::TLine* AOriginalLine, Fmx::Objects::TLine* ALine, int DivisionUnit, int SubDivisionUnit, float Value);
	virtual void __fastcall DoApplyDivisionTextStyle(System::TObject* Sender, Fmx::Objects::TText* AOriginalText, Fmx::Objects::TText* AText, int DivisionUnit, float Value);
	virtual void __fastcall DoApplySubDivisionTextStyle(System::TObject* Sender, Fmx::Objects::TText* AOriginalText, Fmx::Objects::TText* AText, int DivisionUnit, int SubDivisionUnit, float Value);
	virtual Fmx::Types::TFmxObject* __fastcall GetStyleObject(void)/* overload */;
	void __fastcall AnimateGauge(System::TObject* Sender);
	void __fastcall AnimateExtraGauge(System::TObject* Sender);
	Fmx::Objects::TLine* __fastcall DoesDivisionLineExist(System::UnicodeString LineName);
	Fmx::Objects::TText* __fastcall DoesDivisionTextExist(System::UnicodeString TextName);
	TTMSFMXSectionShape* __fastcall DoesSectionExist(Fmx::Types::TFmxObject* AControl, System::UnicodeString SectionName);
	TTMSFMXSetPointShape* __fastcall DoesSetPointExist(Fmx::Types::TFmxObject* AControl, System::UnicodeString SectionName);
	TTMSFMXNeedleShape* __fastcall DoesExtraNeedleExist(Fmx::Types::TFmxObject* AControl, System::UnicodeString ExtraNeedleName);
	void __fastcall AlignNeedle(void);
	virtual void __fastcall CleanUpLines(void);
	virtual void __fastcall CleanUpValues(void);
	virtual void __fastcall UpdateNeedle(void);
	virtual void __fastcall UpdateLayout(void);
	virtual void __fastcall UpdateDivisions(void);
	virtual void __fastcall UpdateValues(void);
	virtual void __fastcall ApplySubLineDivision(float CenterX, float CenterY, int iDiv, int iSubDiv, float AValue, Fmx::Objects::TLine* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplySubTextDivision(float CenterX, float CenterY, int iDiv, int iSubDiv, float AValue, Fmx::Objects::TText* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplyLineDivision(float CenterX, float CenterY, int iDiv, float AValue, Fmx::Objects::TLine* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplyTextDivision(float CenterX, float CenterY, int iDiv, float AValue, Fmx::Objects::TText* lDiv, Fmx::Objects::TLine* LineDiv);
	void __fastcall UpdateDisplayText(void);
	void __fastcall UpdateSections(Fmx::Types::TFmxObject* AControl);
	void __fastcall UpdateSetPoints(Fmx::Types::TFmxObject* AControl);
	virtual Fmx::Types::TFmxObject* __fastcall GetNeedlePlaceHolder(Fmx::Types::TFmxObject* AControl);
	void __fastcall UpdateExtraNeedles(Fmx::Types::TFmxObject* AControl);
	virtual void __fastcall ApplySetPoint(Fmx::Controls::TControl* InnerElement, TTMSFMXSetPoint* ASetPoint, TTMSFMXSetPointShape* ASetPointShape, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplySection(Fmx::Controls::TControl* InnerElement, TTMSFMXSection* ASection, TTMSFMXSectionShape* ASectionShape, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplyExtraNeedle(Fmx::Controls::TControl* InnerElement, TTMSFMXExtraNeedle* AExtraNeedle, TTMSFMXNeedleShape* ANeedleShape, Fmx::Objects::TLine* LineDiv);
	void __fastcall CleanUpSections(Fmx::Types::TFmxObject* AControl);
	void __fastcall CleanUpSetPoints(Fmx::Types::TFmxObject* AControl);
	void __fastcall CleanUpExtraNeedles(Fmx::Types::TFmxObject* AControl);
	__property float MinimumValue = {read=FMinimumValue, write=SetMinValue};
	__property float MaximumValue = {read=FMaximumValue, write=SetMaxValue};
	__property TTMSFMXSections* Sections = {read=FSections, write=SetSections};
	__property TTMSFMXSetPoints* SetPoints = {read=FSetPoints, write=SetSetPoints};
	__property TTMSFMXExtraNeedles* ExtraNeedles = {read=FExtraNeedles, write=SetExtraNeedles};
	__property System::UnicodeString DisplayText = {read=FDisplayText, write=SetDisplayText};
	__property TTMSFMXGaugeSetPointClickEvent OnSetPointClick = {read=FOnSetPointClick, write=FOnSetPointClick};
	__property TTMSFMXGaugeNeedleClickEvent OnExtraNeedleClick = {read=FOnExtraNeedleClick, write=FOnExtraNeedleClick};
	__property TTMSFMXGaugeSectionClickEvent OnSectionClick = {read=FOnSectionClick, write=FOnSectionClick};
	__property TTMSFMXValueClickEvent OnValueClick = {read=FOnValueClick, write=FOnValueClick};
	
public:
	__fastcall virtual TTMSFMXGauge(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXGauge(void);
	virtual void __fastcall Resize(void);
	virtual void __fastcall Update(void);
	Fmx::Objects::TLine* __fastcall GetDivision(void);
	Fmx::Objects::TLine* __fastcall GetSubDivision(void);
	Fmx::Objects::TText* __fastcall GetDivisionText(void);
	Fmx::Objects::TText* __fastcall GetSubDivisionText(void);
	TTMSFMXNeedleShape* __fastcall GetNeedle(void);
	Fmx::Controls::TControl* __fastcall GetInnerElement(void);
	Fmx::Controls::TControl* __fastcall GetOuterElement(void);
	Fmx::Controls::TControl* __fastcall GetOuterCenterElement(void);
	Fmx::Controls::TControl* __fastcall GetInnerCenterElement(void);
	Fmx::Objects::TText* __fastcall GetDisplayText(void);
	__property System::UnicodeString Version = {read=GetVersion};
	/* Hoisted overloads: */
	
protected:
	inline Fmx::Types::TFmxObject* __fastcall  GetStyleObject(const bool Clone){ return Fmx::Controls::TStyledControl::GetStyleObject(Clone); }
	
};


enum DECLSPEC_DENUM TGaugeDirection : unsigned char { gdHorizontal, gdVertical };

enum DECLSPEC_DENUM TTMSFMXValuePosition : unsigned char { vpDown, vpUp };

class DELPHICLASS TTMSFMXCustomLinearGauge;
class PASCALIMPLEMENTATION TTMSFMXCustomLinearGauge : public TTMSFMXGauge
{
	typedef TTMSFMXGauge inherited;
	
private:
	TTMSFMXValuePosition FValuePosition;
	void __fastcall SetValuePosition(const TTMSFMXValuePosition Value);
	
protected:
	virtual void __fastcall AnimateUpdateDivisions(void);
	virtual void __fastcall AnimateUpdateValues(void);
	virtual void __fastcall ApplyStyle(void);
	
public:
	virtual void __fastcall AssignEvents(void);
	virtual TGaugeValue __fastcall XYToValue(float X, float Y);
	__fastcall virtual TTMSFMXCustomLinearGauge(System::Classes::TComponent* AOwner);
	virtual void __fastcall UpdateNeedle(void);
	virtual Fmx::Types::TFmxObject* __fastcall GetNeedlePlaceHolder(Fmx::Types::TFmxObject* AControl);
	virtual void __fastcall ApplySetPoint(Fmx::Controls::TControl* InnerElement, TTMSFMXSetPoint* ASetPoint, TTMSFMXSetPointShape* ASetPointShape, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplySection(Fmx::Controls::TControl* InnerElement, TTMSFMXSection* ASection, TTMSFMXSectionShape* ASectionShape, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplyExtraNeedle(Fmx::Controls::TControl* InnerElement, TTMSFMXExtraNeedle* AExtraNeedle, TTMSFMXNeedleShape* ANeedleShape, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplySubLineDivision(float CenterX, float CenterY, int iDiv, int iSubDiv, float AValue, Fmx::Objects::TLine* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplySubTextDivision(float CenterX, float CenterY, int iDiv, int iSubDiv, float AValue, Fmx::Objects::TText* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplyLineDivision(float CenterX, float CenterY, int iDiv, float AValue, Fmx::Objects::TLine* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplyTextDivision(float CenterX, float CenterY, int iDiv, float AValue, Fmx::Objects::TText* lDiv, Fmx::Objects::TLine* LineDiv);
	
__published:
	__property Version = {default=0};
	__property TTMSFMXValuePosition ValuePosition = {read=FValuePosition, write=SetValuePosition, default=0};
	__property AnimationFactor = {default=0};
	__property OnApplyDivisionLineStyle;
	__property OnApplySubDivisionLineStyle;
	__property OnApplyDivisionTextStyle;
	__property OnApplySubDivisionTextStyle;
	__property OnValueChanged;
	__property OnValueChanging;
	__property Animation = {default=1};
	__property Divisions = {default=10};
	__property SubDivisions = {default=2};
	__property Value = {default=0};
	__property ShowSubDivisions = {default=1};
	__property ShowDivisions = {default=1};
	__property ShowSubDivisionText = {default=0};
	__property ShowDivisionText = {default=1};
	__property DivisionFormat = {default=0};
	__property SubDivisionFormat = {default=0};
public:
	/* TTMSFMXGauge.Destroy */ inline __fastcall virtual ~TTMSFMXCustomLinearGauge(void) { }
	
};


class DELPHICLASS TTMSFMXLinearGauge;
class PASCALIMPLEMENTATION TTMSFMXLinearGauge : public TTMSFMXCustomLinearGauge
{
	typedef TTMSFMXCustomLinearGauge inherited;
	
__published:
	__property OnSetPointClick;
	__property OnExtraNeedleClick;
	__property OnSectionClick;
	__property OnValueClick;
	__property MinimumValue = {default=0};
	__property MaximumValue = {default=0};
	__property Sections;
	__property SetPoints;
	__property ExtraNeedles;
public:
	/* TTMSFMXCustomLinearGauge.Create */ inline __fastcall virtual TTMSFMXLinearGauge(System::Classes::TComponent* AOwner) : TTMSFMXCustomLinearGauge(AOwner) { }
	
public:
	/* TTMSFMXGauge.Destroy */ inline __fastcall virtual ~TTMSFMXLinearGauge(void) { }
	
};


class DELPHICLASS TTMSFMXJogMeter;
class PASCALIMPLEMENTATION TTMSFMXJogMeter : public TTMSFMXCustomLinearGauge
{
	typedef TTMSFMXCustomLinearGauge inherited;
	
private:
	float FAperture;
	float FStep;
	void __fastcall SetAperture(const float Value);
	virtual void __fastcall SetValue(const float Value);
	void __fastcall SetStep(const float Value);
	
public:
	virtual TGaugeValue __fastcall XYToValue(float X, float Y);
	virtual void __fastcall ApplyAdditionalStyle(Fmx::Types::TFmxObject* AControl);
	virtual void __fastcall UpdateNeedle(void);
	virtual void __fastcall UpdateDivisions(void);
	virtual void __fastcall UpdateValues(void);
	virtual void __fastcall CleanUpLines(void);
	virtual void __fastcall CleanUpValues(void);
	virtual void __fastcall ApplySubLineDivision(float CenterX, float CenterY, int iDiv, int iSubDiv, float AValue, Fmx::Objects::TLine* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplySubTextDivision(float CenterX, float CenterY, int iDiv, int iSubDiv, float AValue, Fmx::Objects::TText* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplyLineDivision(float CenterX, float CenterY, int iDiv, float AValue, Fmx::Objects::TLine* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplyTextDivision(float CenterX, float CenterY, int iDiv, float AValue, Fmx::Objects::TText* lDiv, Fmx::Objects::TLine* LineDiv);
	__fastcall virtual TTMSFMXJogMeter(System::Classes::TComponent* AOwner);
	
__published:
	__property float Aperture = {read=FAperture, write=SetAperture};
	__property OnValueClick;
	__property OnSetPointClick;
	__property OnExtraNeedleClick;
	__property OnSectionClick;
	__property float Step = {read=FStep, write=SetStep};
public:
	/* TTMSFMXGauge.Destroy */ inline __fastcall virtual ~TTMSFMXJogMeter(void) { }
	
};


class DELPHICLASS TTMSFMXCustomGauge;
class PASCALIMPLEMENTATION TTMSFMXCustomGauge : public TTMSFMXGauge
{
	typedef TTMSFMXGauge inherited;
	
private:
	int FLayoutStartAngle;
	int FLayoutStopAngle;
	int FDivisionsStartAngle;
	int FDivisionsStopAngle;
	int __fastcall GetDivisionsStopAngle(void);
	void __fastcall SetDivisionsStartAngle(const int Value);
	void __fastcall SetDivisionsStopAngle(const int Value);
	void __fastcall SetLayoutStartAngle(const int Value);
	void __fastcall SetLayoutStopAngle(const int Value);
	
protected:
	virtual float __fastcall FindStartAngle(void);
	virtual float __fastcall FindStopAngle(void);
	virtual void __fastcall UpdateNeedle(void);
	virtual Fmx::Types::TFmxObject* __fastcall GetNeedlePlaceHolder(Fmx::Types::TFmxObject* AControl);
	virtual void __fastcall ApplySection(Fmx::Controls::TControl* InnerElement, TTMSFMXSection* ASection, TTMSFMXSectionShape* ASectionShape, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplyExtraNeedle(Fmx::Controls::TControl* InnerElement, TTMSFMXExtraNeedle* AExtraNeedle, TTMSFMXNeedleShape* ANeedleShape, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplySubLineDivision(float CenterX, float CenterY, int iDiv, int iSubDiv, float AValue, Fmx::Objects::TLine* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplySubTextDivision(float CenterX, float CenterY, int iDiv, int iSubDiv, float AValue, Fmx::Objects::TText* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplyLineDivision(float CenterX, float CenterY, int iDiv, float AValue, Fmx::Objects::TLine* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplyTextDivision(float CenterX, float CenterY, int iDiv, float AValue, Fmx::Objects::TText* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplySetPoint(Fmx::Controls::TControl* InnerElement, TTMSFMXSetPoint* ASetPoint, TTMSFMXSetPointShape* ASetPointShape, Fmx::Objects::TLine* LineDiv);
	float __fastcall GetAngle(float AValue);
	__property int DivisionsStartAngle = {read=FDivisionsStartAngle, write=SetDivisionsStartAngle, default=135};
	__property int DivisionsStopAngle = {read=FDivisionsStopAngle, write=SetDivisionsStopAngle, default=45};
	__property int LayoutStartAngle = {read=FLayoutStartAngle, write=SetLayoutStartAngle, default=0};
	__property int LayoutStopAngle = {read=FLayoutStopAngle, write=SetLayoutStopAngle, default=360};
	
public:
	__fastcall virtual TTMSFMXCustomGauge(System::Classes::TComponent* AOwner);
	virtual void __fastcall UpdateLayout(void);
	
__published:
	__property Version = {default=0};
public:
	/* TTMSFMXGauge.Destroy */ inline __fastcall virtual ~TTMSFMXCustomGauge(void) { }
	
};


class DELPHICLASS TTMSFMXCircularGauge;
class PASCALIMPLEMENTATION TTMSFMXCircularGauge : public TTMSFMXCustomGauge
{
	typedef TTMSFMXCustomGauge inherited;
	
__published:
	__property OnValueClick;
	__property OnSetPointClick;
	__property OnExtraNeedleClick;
	__property OnSectionClick;
	__property MinimumValue = {default=0};
	__property MaximumValue = {default=0};
	__property Sections;
	__property SetPoints;
	__property ExtraNeedles;
	__property DisplayText = {default=0};
	__property AnimationFactor = {default=0};
	__property OnApplyDivisionLineStyle;
	__property OnApplySubDivisionLineStyle;
	__property OnApplyDivisionTextStyle;
	__property OnApplySubDivisionTextStyle;
	__property OnValueChanged;
	__property OnValueChanging;
	__property Animation = {default=1};
	__property Divisions = {default=10};
	__property SubDivisions = {default=2};
	__property Value = {default=0};
	__property ShowSubDivisions = {default=1};
	__property ShowDivisions = {default=1};
	__property ShowSubDivisionText = {default=0};
	__property ShowDivisionText = {default=1};
	__property DivisionFormat = {default=0};
	__property SubDivisionFormat = {default=0};
	__property DivisionsStartAngle = {default=135};
	__property DivisionsStopAngle = {default=45};
	__property LayoutStartAngle = {default=0};
	__property LayoutStopAngle = {default=360};
public:
	/* TTMSFMXCustomGauge.Create */ inline __fastcall virtual TTMSFMXCircularGauge(System::Classes::TComponent* AOwner) : TTMSFMXCustomGauge(AOwner) { }
	
public:
	/* TTMSFMXGauge.Destroy */ inline __fastcall virtual ~TTMSFMXCircularGauge(void) { }
	
};


class DELPHICLASS TTMSFMXCompass;
class PASCALIMPLEMENTATION TTMSFMXCompass : public TTMSFMXCustomGauge
{
	typedef TTMSFMXCustomGauge inherited;
	
protected:
	virtual void __fastcall DoApplyDivisionTextStyle(System::TObject* Sender, Fmx::Objects::TText* AOriginalText, Fmx::Objects::TText* AText, int DivisionUnit, float Value);
	virtual void __fastcall DoApplyDivisionLineStyle(System::TObject* Sender, Fmx::Objects::TLine* AOriginalLine, Fmx::Objects::TLine* ALine, int DivisionUnit, float Value);
	
public:
	__fastcall virtual TTMSFMXCompass(System::Classes::TComponent* AOwner);
public:
	/* TTMSFMXGauge.Destroy */ inline __fastcall virtual ~TTMSFMXCompass(void) { }
	
};


class DELPHICLASS TTMSFMXClock;
class PASCALIMPLEMENTATION TTMSFMXClock : public TTMSFMXCustomGauge
{
	typedef TTMSFMXCustomGauge inherited;
	
private:
	Fmx::Types::TTimer* FTimer;
	System::TTime FClockTime;
	System::Classes::TNotifyEvent FOnTimeChanged;
	int FOffset;
	bool FShowSeconds;
	int FInterval;
	bool __fastcall GetActive(void);
	void __fastcall SetActive(const bool Value);
	void __fastcall SetInterval(const int Value);
	void __fastcall SetTime(const System::TTime Value);
	System::TTime __fastcall GetTime(void);
	void __fastcall SetOffset(const int Value);
	void __fastcall SetShowSeconds(const bool Value);
	
protected:
	virtual void __fastcall ApplyAdditionalStyle(Fmx::Types::TFmxObject* AControl);
	virtual void __fastcall ApplyStyle(void);
	void __fastcall UpdateTime(void);
	void __fastcall DoTime(System::TObject* Sender);
	virtual void __fastcall DoApplyDivisionTextStyle(System::TObject* Sender, Fmx::Objects::TText* AOriginalText, Fmx::Objects::TText* AText, int DivisionUnit, float Value);
	
public:
	__fastcall virtual TTMSFMXClock(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXClock(void);
	
__published:
	__property System::Classes::TNotifyEvent OnTimeChanged = {read=FOnTimeChanged, write=FOnTimeChanged};
	__property bool Active = {read=GetActive, write=SetActive, nodefault};
	__property int Interval = {read=FInterval, write=SetInterval, default=1000};
	__property System::TTime ClockTime = {read=GetTime, write=SetTime};
	__property int Offset = {read=FOffset, write=SetOffset, default=0};
	__property bool ShowSeconds = {read=FShowSeconds, write=SetShowSeconds, default=1};
	__property DisplayText = {default=0};
	__property ShowDivisions = {default=1};
	__property ShowSubDivisions = {default=1};
	__property ShowDivisionText = {default=1};
};


class DELPHICLASS TTMSFMXSwitchPosition;
class DELPHICLASS TTMSFMXRotarySwitch;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TTMSFMXSwitchPosition : public System::Classes::TCollectionItem
{
	typedef System::Classes::TCollectionItem inherited;
	
private:
	TTMSFMXRotarySwitch* FOwner;
	int FTag;
	System::UnicodeString FText;
	void __fastcall SetText(const System::UnicodeString Value);
	
public:
	Fmx::Objects::TText* __fastcall TextShape(void);
	Fmx::Objects::TEllipse* __fastcall EllipseShape(void);
	__fastcall virtual TTMSFMXSwitchPosition(System::Classes::TCollection* Collection);
	__fastcall virtual ~TTMSFMXSwitchPosition(void);
	
__published:
	__property System::UnicodeString Text = {read=FText, write=SetText};
	__property int Tag = {read=FTag, write=FTag, nodefault};
};

#pragma pack(pop)

class DELPHICLASS TTMSFMXSwitchPositions;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TTMSFMXSwitchPositions : public Fmx::Tmsbasecontrol::TTMSFMXBaseCollection
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseCollection inherited;
	
public:
	TTMSFMXSwitchPosition* operator[](int Index) { return Items[Index]; }
	
private:
	TTMSFMXRotarySwitch* FOwner;
	HIDESBASE TTMSFMXSwitchPosition* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, TTMSFMXSwitchPosition* const Value);
	
protected:
	DYNAMIC System::Classes::TPersistent* __fastcall GetOwner(void);
	
public:
	__fastcall TTMSFMXSwitchPositions(TTMSFMXRotarySwitch* AOwner);
	HIDESBASE TTMSFMXSwitchPosition* __fastcall Add(void);
	HIDESBASE TTMSFMXSwitchPosition* __fastcall Insert(int Index);
	__property TTMSFMXSwitchPosition* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
public:
	/* TCollection.Destroy */ inline __fastcall virtual ~TTMSFMXSwitchPositions(void) { }
	
};

#pragma pack(pop)

class PASCALIMPLEMENTATION TTMSFMXRotarySwitch : public TTMSFMXCustomGauge
{
	typedef TTMSFMXCustomGauge inherited;
	
private:
	TTMSFMXSwitchPositions* FPositions;
	void __fastcall SetPositions(TTMSFMXSwitchPositions* const Value);
	
protected:
	TTMSFMXSwitchPosition* __fastcall GetPositionForShape(Fmx::Types::TFmxObject* AShape);
	virtual void __fastcall ValueClick(System::TObject* Sender);
	virtual TGaugeValue __fastcall XYToValue(float X, float Y);
	virtual void __fastcall Changed(void);
	virtual void __fastcall ApplyLineDivision(float CenterX, float CenterY, int iDiv, float AValue, Fmx::Objects::TLine* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall ApplyTextDivision(float CenterX, float CenterY, int iDiv, float AValue, Fmx::Objects::TText* lDiv, Fmx::Objects::TLine* LineDiv);
	virtual void __fastcall DoApplyDivisionTextStyle(System::TObject* Sender, Fmx::Objects::TText* AOriginalText, Fmx::Objects::TText* AText, int DivisionUnit, float Value);
	
public:
	__fastcall virtual TTMSFMXRotarySwitch(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXRotarySwitch(void);
	
__published:
	__property TTMSFMXSwitchPositions* Positions = {read=FPositions, write=SetPositions};
	__property AnimationFactor = {default=0};
	__property OnApplyDivisionLineStyle;
	__property OnApplyDivisionTextStyle;
	__property OnValueChanged;
	__property OnValueChanging;
	__property OnValueClick;
	__property Animation = {default=1};
	__property DivisionsStartAngle = {default=135};
	__property DivisionsStopAngle = {default=45};
	__property LayoutStartAngle = {default=0};
	__property LayoutStopAngle = {default=360};
	__property Value = {default=0};
};


class DELPHICLASS TTMSFMXKnobSwitch;
class PASCALIMPLEMENTATION TTMSFMXKnobSwitch : public TTMSFMXRotarySwitch
{
	typedef TTMSFMXRotarySwitch inherited;
	
private:
	bool FEnableGlow;
	virtual void __fastcall SetValue(const float Value);
	
protected:
	virtual void __fastcall ApplyAdditionalStyle(Fmx::Types::TFmxObject* AControl);
	
public:
	virtual void __fastcall UpdateLayout(void);
	void __fastcall EnableDisableGlow(bool Enable);
	virtual void __fastcall DoApplyDivisionLineStyle(System::TObject* Sender, Fmx::Objects::TLine* AOriginalLine, Fmx::Objects::TLine* ALine, int DivisionUnit, float Value);
	__fastcall virtual TTMSFMXKnobSwitch(System::Classes::TComponent* AOwner);
public:
	/* TTMSFMXRotarySwitch.Destroy */ inline __fastcall virtual ~TTMSFMXKnobSwitch(void) { }
	
};


//-- var, const, procedure ---------------------------------------------------
static const System::Int8 MAJ_VER = System::Int8(0x1);
static const System::Int8 MIN_VER = System::Int8(0x5);
static const System::Int8 REL_VER = System::Int8(0x0);
static const System::Int8 BLD_VER = System::Int8(0x2);
}	/* namespace Tmsgauge */
}	/* namespace Fmx */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_FMX_TMSGAUGE)
using namespace Fmx::Tmsgauge;
#endif
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_FMX)
using namespace Fmx;
#endif
#pragma pack(pop)
#pragma option pop

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