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

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

#ifndef Fmx_TmsgridcellHPP
#define Fmx_TmsgridcellHPP

#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 <Winapi.Windows.hpp>	// Pascal unit
#include <System.Classes.hpp>	// Pascal unit
#include <System.SysUtils.hpp>	// Pascal unit
#include <FMX.Types.hpp>	// Pascal unit
#include <System.UITypes.hpp>	// Pascal unit
#include <System.Types.hpp>	// Pascal unit
#include <FMX.TMSHTMLText.hpp>	// Pascal unit
#include <System.Variants.hpp>	// Pascal unit
#include <FMX.TMSBitmapContainer.hpp>	// Pascal unit
#include <FMX.TMSHTMLEngine.hpp>	// Pascal unit
#include <FMX.Controls.hpp>	// Pascal unit
#include <FMX.ExtCtrls.hpp>	// Pascal unit
#include <FMX.TMSBarButton.hpp>	// Pascal unit
#include <FMX.Objects.hpp>	// Pascal unit
#include <FMX.TMSBitmap.hpp>	// Pascal unit
#include <FMX.Edit.hpp>	// Pascal unit
#include <FMX.TMSProgressBar.hpp>	// Pascal unit
#include <FMX.TMSBaseControl.hpp>	// Pascal unit
#include <FMX.Ani.hpp>	// Pascal unit
#include <FMX.StdCtrls.hpp>	// Pascal unit
#include <System.UIConsts.hpp>	// Pascal unit
#include <FMX.Graphics.hpp>	// Pascal unit
#include <System.Math.Vectors.hpp>	// Pascal unit

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

namespace Fmx
{
namespace Tmsgridcell
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TTMSFMXCustomGridCellData;
class PASCALIMPLEMENTATION TTMSFMXCustomGridCellData : public Fmx::Tmsbasecontrol::TTMSFMXBaseControl
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseControl inherited;
	
public:
	/* TTMSFMXBaseControl.Create */ inline __fastcall virtual TTMSFMXCustomGridCellData(System::Classes::TComponent* AOwner) : Fmx::Tmsbasecontrol::TTMSFMXBaseControl(AOwner) { }
	/* TTMSFMXBaseControl.Destroy */ inline __fastcall virtual ~TTMSFMXCustomGridCellData(void) { }
	
};


enum DECLSPEC_DENUM TNodeState : unsigned char { nsClosed, nsOpen };

class DELPHICLASS TCommentShape;
class PASCALIMPLEMENTATION TCommentShape : public Fmx::Tmsbasecontrol::TTMSFMXBaseShape
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseShape inherited;
	
public:
	virtual void __fastcall Paint(void);
public:
	/* TShape.Create */ inline __fastcall virtual TCommentShape(System::Classes::TComponent* AOwner) : Fmx::Tmsbasecontrol::TTMSFMXBaseShape(AOwner) { }
	/* TShape.Destroy */ inline __fastcall virtual ~TCommentShape(void) { }
	
};


class DELPHICLASS TSortShape;
class DELPHICLASS TTMSFMXFixedGridCell;
class PASCALIMPLEMENTATION TSortShape : public Fmx::Tmsbasecontrol::TTMSFMXBaseShape
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseShape inherited;
	
private:
	TTMSFMXFixedGridCell* FOwner;
	
public:
	__fastcall virtual TSortShape(System::Classes::TComponent* AOwner);
	virtual void __fastcall Paint(void);
public:
	/* TShape.Destroy */ inline __fastcall virtual ~TSortShape(void) { }
	
};


class DELPHICLASS TTMSFMXCheckBox;
class PASCALIMPLEMENTATION TTMSFMXCheckBox : public Fmx::Stdctrls::TCheckBox
{
	typedef Fmx::Stdctrls::TCheckBox inherited;
	
private:
	bool __fastcall GetIsCheckedProg(void);
	void __fastcall SetIsCheckedProg(const bool Value);
	
public:
	__property bool IsCheckedProg = {read=GetIsCheckedProg, write=SetIsCheckedProg, nodefault};
public:
	/* TCheckBox.Create */ inline __fastcall virtual TTMSFMXCheckBox(System::Classes::TComponent* AOwner) : Fmx::Stdctrls::TCheckBox(AOwner) { }
	
public:
	/* TTextControl.Destroy */ inline __fastcall virtual ~TTMSFMXCheckBox(void) { }
	
};


class DELPHICLASS TTMSFMXRadioButton;
class PASCALIMPLEMENTATION TTMSFMXRadioButton : public Fmx::Stdctrls::TRadioButton
{
	typedef Fmx::Stdctrls::TRadioButton inherited;
	
private:
	bool __fastcall GetIsCheckedProg(void);
	void __fastcall SetIsCheckedProg(const bool Value);
	
public:
	__property bool IsCheckedProg = {read=GetIsCheckedProg, write=SetIsCheckedProg, nodefault};
public:
	/* TRadioButton.Create */ inline __fastcall virtual TTMSFMXRadioButton(System::Classes::TComponent* AOwner) : Fmx::Stdctrls::TRadioButton(AOwner) { }
	/* TRadioButton.Destroy */ inline __fastcall virtual ~TTMSFMXRadioButton(void) { }
	
};


enum DECLSPEC_DENUM TSortKind : unsigned char { skNone, skAscending, skDescending };

class DELPHICLASS TTMSFMXGridCellLayout;
class PASCALIMPLEMENTATION TTMSFMXGridCellLayout : public System::Classes::TPersistent
{
	typedef System::Classes::TPersistent inherited;
	
private:
	System::Classes::TComponent* FOwner;
	Fmx::Graphics::TBrush* FFontFill;
	Fmx::Graphics::TStrokeJoin FStrokeJoin;
	float FStrokeThickness;
	Fmx::Graphics::TStrokeCap FStrokeCap;
	Fmx::Types::TSides FSides;
	Fmx::Graphics::TStrokeDash FStrokeDash;
	Fmx::Graphics::TBrush* FFill;
	Fmx::Graphics::TBrush* FStroke;
	System::Classes::TNotifyEvent FOnChange;
	Fmx::Graphics::TFillTextFlags FFontFlags;
	Fmx::Types::TTextAlign FVerticalTextAlign;
	Fmx::Graphics::TFont* FFont;
	Fmx::Types::TTextAlign FTextAlign;
	bool FWordWrapping;
	void __fastcall SetFill(Fmx::Graphics::TBrush* const Value);
	void __fastcall SetFontFill(Fmx::Graphics::TBrush* const Value);
	void __fastcall SetSides(const Fmx::Types::TSides Value);
	void __fastcall SetStroke(Fmx::Graphics::TBrush* const Value);
	void __fastcall SetStrokeCap(const Fmx::Graphics::TStrokeCap Value);
	void __fastcall SetStrokeDash(const Fmx::Graphics::TStrokeDash Value);
	void __fastcall SetStrokeJoin(const Fmx::Graphics::TStrokeJoin Value);
	void __fastcall SetStrokeThickness(const float Value);
	void __fastcall SetFont(Fmx::Graphics::TFont* const Value);
	void __fastcall SetFontFlags(const Fmx::Graphics::TFillTextFlags Value);
	void __fastcall SetTextAlign(const Fmx::Types::TTextAlign Value);
	void __fastcall SetVerticalTextAlign(const Fmx::Types::TTextAlign Value);
	void __fastcall SetWordWrapping(const bool Value);
	
protected:
	void __fastcall Changed(System::TObject* Sender);
	
public:
	__fastcall TTMSFMXGridCellLayout(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXGridCellLayout(void);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	__property System::Classes::TComponent* Owner = {read=FOwner, write=FOwner};
	
__published:
	__property Fmx::Types::TSides Sides = {read=FSides, write=SetSides, default=15};
	__property Fmx::Graphics::TBrush* Fill = {read=FFill, write=SetFill};
	__property Fmx::Graphics::TBrush* Stroke = {read=FStroke, write=SetStroke};
	__property float StrokeThickness = {read=FStrokeThickness, write=SetStrokeThickness};
	__property Fmx::Graphics::TBrush* FontFill = {read=FFontFill, write=SetFontFill};
	__property Fmx::Graphics::TFont* Font = {read=FFont, write=SetFont};
	__property Fmx::Graphics::TFillTextFlags FontFlags = {read=FFontFlags, write=SetFontFlags, default=0};
	__property Fmx::Graphics::TStrokeCap StrokeCap = {read=FStrokeCap, write=SetStrokeCap, default=0};
	__property Fmx::Graphics::TStrokeDash StrokeDash = {read=FStrokeDash, write=SetStrokeDash, default=0};
	__property Fmx::Graphics::TStrokeJoin StrokeJoin = {read=FStrokeJoin, write=SetStrokeJoin, default=0};
	__property Fmx::Types::TTextAlign TextAlign = {read=FTextAlign, write=SetTextAlign, default=1};
	__property Fmx::Types::TTextAlign VerticalTextAlign = {read=FVerticalTextAlign, write=SetVerticalTextAlign, default=0};
	__property bool WordWrapping = {read=FWordWrapping, write=SetWordWrapping, default=0};
	__property System::Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
};


typedef void __fastcall (__closure *TTMSFMXCellBeforeDraw)(System::TObject* Sender, Fmx::Graphics::TCanvas* ACanvas, System::Types::TRectF &ARect, System::Types::TRectF &ATextRect, bool &ADrawText, bool &ADrawBackGround, bool &AllowDraw);

typedef void __fastcall (__closure *TTMSFMXCellAfterDraw)(System::TObject* Sender, Fmx::Graphics::TCanvas* ACanvas, const System::Types::TRectF &ARect);

class DELPHICLASS TControlProtected;
class PASCALIMPLEMENTATION TControlProtected : public Fmx::Controls::TControl
{
	typedef Fmx::Controls::TControl inherited;
	
public:
	/* TControl.Create */ inline __fastcall virtual TControlProtected(System::Classes::TComponent* AOwner) : Fmx::Controls::TControl(AOwner) { }
	/* TControl.Destroy */ inline __fastcall virtual ~TControlProtected(void) { }
	
};


class DELPHICLASS TTMSFMXGridCell;
class PASCALIMPLEMENTATION TTMSFMXGridCell : public Fmx::Controls::TControl
{
	typedef Fmx::Controls::TControl inherited;
	
private:
	System::UnicodeString FText;
	TTMSFMXGridCellLayout* FLayout;
	Fmx::Tmsbitmapcontainer::TTMSFMXBitmapContainer* FBitmapContainer;
	TTMSFMXCellAfterDraw FOnAfterDraw;
	TTMSFMXCellBeforeDraw FOnBeforeDraw;
	virtual void __fastcall SetText(const System::UnicodeString Value);
	virtual void __fastcall SetBitmapContainer(Fmx::Tmsbitmapcontainer::TTMSFMXBitmapContainer* const Value);
	virtual void __fastcall SetLayout(TTMSFMXGridCellLayout* const Value);
	
protected:
	virtual void __fastcall Notification(System::Classes::TComponent* AComponent, System::Classes::TOperation Operation);
	void __fastcall Changed(System::TObject* Sender);
	
public:
	virtual System::Types::TRectF __fastcall GetTextRect(void);
	virtual System::Types::TRectF __fastcall GetTextRectBase(const System::Types::TRectF &ARect);
	virtual Fmx::Controls::TControl* __fastcall GetControl(void);
	virtual Fmx::Controls::TControl* __fastcall GetPrintControl(void);
	void __fastcall HTMLDraw(Fmx::Graphics::TCanvas* ACanvas, const System::Types::TRectF &ARect, bool TestAnchor, float X, float Y, System::UnicodeString &Anchor);
	bool __fastcall IsHTML(void);
	float __fastcall GetTextWidth(void);
	float __fastcall GetTextHeight(void);
	System::Types::TSizeF __fastcall GetTextSize(void);
	System::UnicodeString __fastcall GetStrippedHTMLText(void);
	System::UnicodeString __fastcall XYToAnchor(float X, float Y);
	virtual void __fastcall Paint(void);
	void __fastcall Print(Fmx::Graphics::TCanvas* ACanvas, const System::Types::TRectF &ARect, const System::Types::TRectF &ATextRect, bool ADrawText, bool ADrawBackGround, float sx, float sy);
	void __fastcall Draw(Fmx::Graphics::TCanvas* ACanvas, const System::Types::TRectF &ARect, const System::Types::TRectF &ATextRect, bool ADrawText, bool ADrawBackGround);
	__fastcall virtual TTMSFMXGridCell(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXGridCell(void);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	void __fastcall AssignLayout(TTMSFMXGridCellLayout* Source);
	
__published:
	__property Position;
	__property Width;
	__property Height;
	__property Visible = {default=1};
	__property System::UnicodeString Text = {read=FText, write=SetText};
	__property TTMSFMXGridCellLayout* Layout = {read=FLayout, write=SetLayout};
	__property Fmx::Tmsbitmapcontainer::TTMSFMXBitmapContainer* BitmapContainer = {read=FBitmapContainer, write=SetBitmapContainer};
	__property TTMSFMXCellBeforeDraw OnBeforeDraw = {read=FOnBeforeDraw, write=FOnBeforeDraw};
	__property TTMSFMXCellAfterDraw OnAfterDraw = {read=FOnAfterDraw, write=FOnAfterDraw};
};


class DELPHICLASS TTMSFMXRadioGridCell;
class PASCALIMPLEMENTATION TTMSFMXRadioGridCell : public TTMSFMXGridCell
{
	typedef TTMSFMXGridCell inherited;
	
private:
	TTMSFMXRadioButton* FRadioButton;
	TTMSFMXRadioButton* __fastcall GetRadioButton(void);
	void __fastcall SetRadioButton(TTMSFMXRadioButton* const Value);
	
public:
	virtual Fmx::Controls::TControl* __fastcall GetControl(void);
	virtual Fmx::Controls::TControl* __fastcall GetPrintControl(void);
	__fastcall virtual TTMSFMXRadioGridCell(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXRadioGridCell(void);
	__property TTMSFMXRadioButton* RadioButton = {read=GetRadioButton, write=SetRadioButton};
};


class DELPHICLASS TTMSFMXCheckGridCell;
class PASCALIMPLEMENTATION TTMSFMXCheckGridCell : public TTMSFMXGridCell
{
	typedef TTMSFMXGridCell inherited;
	
private:
	TTMSFMXCheckBox* FCheckBox;
	TTMSFMXCheckBox* __fastcall GetCheckBox(void);
	void __fastcall SetCheckBox(TTMSFMXCheckBox* const Value);
	
public:
	virtual Fmx::Controls::TControl* __fastcall GetControl(void);
	virtual Fmx::Controls::TControl* __fastcall GetPrintControl(void);
	__fastcall virtual TTMSFMXCheckGridCell(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXCheckGridCell(void);
	__property TTMSFMXCheckBox* CheckBox = {read=GetCheckBox, write=SetCheckBox};
};


class DELPHICLASS TTMSFMXButtonGridCell;
class PASCALIMPLEMENTATION TTMSFMXButtonGridCell : public TTMSFMXGridCell
{
	typedef TTMSFMXGridCell inherited;
	
private:
	Fmx::Stdctrls::TButton* FButton;
	Fmx::Stdctrls::TButton* __fastcall GetButton(void);
	void __fastcall SetButton(Fmx::Stdctrls::TButton* const Value);
	
public:
	virtual Fmx::Controls::TControl* __fastcall GetControl(void);
	virtual Fmx::Controls::TControl* __fastcall GetPrintControl(void);
	__fastcall virtual TTMSFMXButtonGridCell(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXButtonGridCell(void);
	__property Fmx::Stdctrls::TButton* Button = {read=GetButton, write=SetButton};
};


class DELPHICLASS TTMSFMXProgressGridCell;
class PASCALIMPLEMENTATION TTMSFMXProgressGridCell : public TTMSFMXGridCell
{
	typedef TTMSFMXGridCell inherited;
	
private:
	Fmx::Tmsprogressbar::TTMSFMXProgressBar* FProgressBar;
	Fmx::Tmsprogressbar::TTMSFMXProgressBar* __fastcall GetProgressBar(void);
	void __fastcall SetProgressBar(Fmx::Tmsprogressbar::TTMSFMXProgressBar* const Value);
	
public:
	virtual Fmx::Controls::TControl* __fastcall GetControl(void);
	virtual Fmx::Controls::TControl* __fastcall GetPrintControl(void);
	__fastcall virtual TTMSFMXProgressGridCell(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXProgressGridCell(void);
	virtual void __fastcall Paint(void);
	__property Fmx::Tmsprogressbar::TTMSFMXProgressBar* ProgressBar = {read=GetProgressBar, write=SetProgressBar};
};


class DELPHICLASS TTMSFMXCommentGridCell;
class PASCALIMPLEMENTATION TTMSFMXCommentGridCell : public TTMSFMXGridCell
{
	typedef TTMSFMXGridCell inherited;
	
private:
	Fmx::Objects::TCalloutRectangle* FCommentPanel;
	Fmx::Stdctrls::TLabel* FCommentText;
	TCommentShape* FComment;
	Fmx::Controls::TPopup* FPopup;
	Fmx::Controls::TControl* FPopupControl;
	System::Classes::TNotifyEvent FOnShowPopup;
	System::Classes::TNotifyEvent FOnHidePopup;
	TCommentShape* __fastcall GetComment(void);
	void __fastcall SetComment(TCommentShape* const Value);
	void __fastcall SetPopup(Fmx::Controls::TPopup* const Value);
	
protected:
	void __fastcall ClosePopup(System::TObject* Sender);
	virtual void __fastcall Notification(System::Classes::TComponent* AComponent, System::Classes::TOperation Operation);
	
public:
	bool __fastcall IsPopupOpen(void);
	void __fastcall ShowPopup(void);
	void __fastcall HidePopup(void);
	virtual Fmx::Controls::TControl* __fastcall GetControl(void);
	virtual Fmx::Controls::TControl* __fastcall GetPrintControl(void);
	__fastcall virtual TTMSFMXCommentGridCell(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXCommentGridCell(void);
	__property Fmx::Objects::TCalloutRectangle* CommentPanel = {read=FCommentPanel, write=FCommentPanel};
	__property TCommentShape* Comment = {read=GetComment, write=SetComment};
	__property Fmx::Stdctrls::TLabel* CommentText = {read=FCommentText, write=FCommentText};
	__property Fmx::Controls::TPopup* Popup = {read=FPopup, write=SetPopup};
	__property Fmx::Controls::TControl* PopupControl = {read=FPopupControl, write=FPopupControl};
	virtual void __fastcall Resize(void);
	__property System::Classes::TNotifyEvent OnShowPopup = {read=FOnShowPopup, write=FOnShowPopup};
	__property System::Classes::TNotifyEvent OnHidePopup = {read=FOnHidePopup, write=FOnHidePopup};
};


class PASCALIMPLEMENTATION TTMSFMXFixedGridCell : public TTMSFMXGridCell
{
	typedef TTMSFMXGridCell inherited;
	
private:
	TSortShape* FSortShape;
	TSortKind FSortKind;
	int FSortIndex;
	Fmx::Graphics::TBrush* FSortFill;
	Fmx::Graphics::TBrush* FSortStroke;
	Fmx::Graphics::TBrush* FSortFontFill;
	Fmx::Graphics::TFont* FSortFont;
	TTMSFMXCheckBox* FCheckBox;
	Fmx::Tmsbitmap::TTMSFMXBitmap* FBitmap;
	Fmx::Stdctrls::TButton* FButton;
	Fmx::Edit::TSpinBox* FSpinBox;
	bool FShowButton;
	bool FShowBitmap;
	bool FShowSpinBox;
	bool FShowCheckBox;
	System::Classes::TNotifyEvent FOnShowPopup;
	Fmx::Controls::TPopup* FPopup;
	bool FShowDropDownButton;
	System::Classes::TNotifyEvent FOnHidePopup;
	Fmx::Controls::TControl* FPopupControl;
	Fmx::Stdctrls::TCornerButton* FDropDownButton;
	void __fastcall SetSortKind(const TSortKind Value);
	TSortShape* __fastcall GetSortShape(void);
	void __fastcall SetSortShape(TSortShape* const Value);
	void __fastcall SetSortIndex(const int Value);
	void __fastcall SetSortFill(Fmx::Graphics::TBrush* const Value);
	void __fastcall SetSortStroke(Fmx::Graphics::TBrush* const Value);
	void __fastcall SetSortFont(Fmx::Graphics::TFont* const Value);
	void __fastcall SetSortFontFill(Fmx::Graphics::TBrush* const Value);
	void __fastcall SetShowBitmap(const bool Value);
	void __fastcall SetShowButton(const bool Value);
	void __fastcall SetShowCheckBox(const bool Value);
	void __fastcall SetShowSpinBox(const bool Value);
	void __fastcall SetBitmap(Fmx::Tmsbitmap::TTMSFMXBitmap* const Value);
	void __fastcall SetButton(Fmx::Stdctrls::TButton* const Value);
	void __fastcall SetCheckBox(TTMSFMXCheckBox* const Value);
	void __fastcall SetSpinBox(Fmx::Edit::TSpinBox* const Value);
	void __fastcall SetPopup(Fmx::Controls::TPopup* const Value);
	void __fastcall SetShowDropDownButton(const bool Value);
	void __fastcall SetDropDownButton(Fmx::Stdctrls::TCornerButton* const Value);
	
protected:
	void __fastcall ClosePopup(System::TObject* Sender);
	virtual void __fastcall Notification(System::Classes::TComponent* AComponent, System::Classes::TOperation Operation);
	
public:
	bool __fastcall DropDownButtonHasBitmap(void);
	__property bool ShowCheckBox = {read=FShowCheckBox, write=SetShowCheckBox, default=0};
	__property bool ShowBitmap = {read=FShowBitmap, write=SetShowBitmap, default=0};
	__property bool ShowSpinBox = {read=FShowSpinBox, write=SetShowSpinBox, default=0};
	__property bool ShowButton = {read=FShowButton, write=SetShowButton, default=0};
	__property bool ShowDropDownButton = {read=FShowDropDownButton, write=SetShowDropDownButton, default=0};
	__property Fmx::Controls::TPopup* Popup = {read=FPopup, write=SetPopup};
	__property Fmx::Controls::TControl* PopupControl = {read=FPopupControl, write=FPopupControl};
	bool __fastcall IsPopupOpen(void);
	void __fastcall ShowPopup(void);
	void __fastcall HidePopup(void);
	__property TTMSFMXCheckBox* CheckBox = {read=FCheckBox, write=SetCheckBox};
	__property Fmx::Tmsbitmap::TTMSFMXBitmap* Bitmap = {read=FBitmap, write=SetBitmap};
	__property Fmx::Edit::TSpinBox* SpinBox = {read=FSpinBox, write=SetSpinBox};
	__property Fmx::Stdctrls::TButton* Button = {read=FButton, write=SetButton};
	__property Fmx::Stdctrls::TCornerButton* DropDownButton = {read=FDropDownButton, write=SetDropDownButton};
	virtual Fmx::Controls::TControl* __fastcall GetControl(void);
	virtual Fmx::Controls::TControl* __fastcall GetPrintControl(void);
	__fastcall virtual TTMSFMXFixedGridCell(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXFixedGridCell(void);
	__property TSortKind SortKind = {read=FSortKind, write=SetSortKind, default=2};
	__property int SortIndex = {read=FSortIndex, write=SetSortIndex, default=-1};
	__property Fmx::Graphics::TBrush* SortFill = {read=FSortFill, write=SetSortFill};
	__property Fmx::Graphics::TFont* SortFont = {read=FSortFont, write=SetSortFont};
	__property Fmx::Graphics::TBrush* SortFontFill = {read=FSortFontFill, write=SetSortFontFill};
	__property Fmx::Graphics::TBrush* SortStroke = {read=FSortStroke, write=SetSortStroke};
	__property TSortShape* SortShape = {read=GetSortShape, write=SetSortShape};
	virtual void __fastcall Resize(void);
	__property System::Classes::TNotifyEvent OnShowPopup = {read=FOnShowPopup, write=FOnShowPopup};
	__property System::Classes::TNotifyEvent OnHidePopup = {read=FOnHidePopup, write=FOnHidePopup};
};


class DELPHICLASS TTMSFMXRotatedTextGridCell;
class PASCALIMPLEMENTATION TTMSFMXRotatedTextGridCell : public TTMSFMXFixedGridCell
{
	typedef TTMSFMXFixedGridCell inherited;
	
private:
	Fmx::Tmshtmltext::TTMSFMXHTMLText* FRotatedText;
	virtual void __fastcall SetText(const System::UnicodeString Value);
	virtual void __fastcall SetLayout(TTMSFMXGridCellLayout* const Value);
	Fmx::Tmshtmltext::TTMSFMXHTMLText* __fastcall GetRotatedText(void);
	void __fastcall SetRotatedText(Fmx::Tmshtmltext::TTMSFMXHTMLText* const Value);
	
public:
	virtual Fmx::Controls::TControl* __fastcall GetControl(void);
	virtual Fmx::Controls::TControl* __fastcall GetPrintControl(void);
	__fastcall virtual TTMSFMXRotatedTextGridCell(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXRotatedTextGridCell(void);
	virtual void __fastcall Paint(void);
	virtual void __fastcall Resize(void);
	__property Fmx::Tmshtmltext::TTMSFMXHTMLText* RotatedText = {read=GetRotatedText, write=SetRotatedText};
};


class DELPHICLASS TTMSFMXNodeGridCell;
class PASCALIMPLEMENTATION TTMSFMXNodeGridCell : public TTMSFMXGridCell
{
	typedef TTMSFMXGridCell inherited;
	
private:
	Fmx::Tmsbitmap::TTMSFMXBitmap* FNodeShapeOpen;
	Fmx::Tmsbitmap::TTMSFMXBitmap* FNodeShapeClosed;
	TNodeState FState;
	Fmx::Tmsbitmap::TTMSFMXBitmap* __fastcall GetNodeShapeOpen(void);
	void __fastcall SetNodeShapeOpen(Fmx::Tmsbitmap::TTMSFMXBitmap* const Value);
	Fmx::Tmsbitmap::TTMSFMXBitmap* __fastcall GetNodeShapeClosed(void);
	void __fastcall SetNodeShapeClosed(Fmx::Tmsbitmap::TTMSFMXBitmap* const Value);
	virtual void __fastcall SetBitmapContainer(Fmx::Tmsbitmapcontainer::TTMSFMXBitmapContainer* const Value);
	void __fastcall SetState(const TNodeState Value);
	
public:
	virtual Fmx::Controls::TControl* __fastcall GetControl(void);
	virtual Fmx::Controls::TControl* __fastcall GetPrintControl(void);
	__fastcall virtual TTMSFMXNodeGridCell(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXNodeGridCell(void);
	__property Fmx::Tmsbitmap::TTMSFMXBitmap* NodeShapeOpen = {read=GetNodeShapeOpen, write=SetNodeShapeOpen};
	__property Fmx::Tmsbitmap::TTMSFMXBitmap* NodeShapeClosed = {read=GetNodeShapeClosed, write=SetNodeShapeClosed};
	virtual void __fastcall Resize(void);
	__property TNodeState State = {read=FState, write=SetState, default=0};
};


class DELPHICLASS TTMSFMXContainerGridCell;
class PASCALIMPLEMENTATION TTMSFMXContainerGridCell : public TTMSFMXGridCell
{
	typedef TTMSFMXGridCell inherited;
	
public:
	/* TTMSFMXGridCell.Create */ inline __fastcall virtual TTMSFMXContainerGridCell(System::Classes::TComponent* AOwner) : TTMSFMXGridCell(AOwner) { }
	/* TTMSFMXGridCell.Destroy */ inline __fastcall virtual ~TTMSFMXContainerGridCell(void) { }
	
};


class DELPHICLASS TTMSFMXBitmapGridCell;
class PASCALIMPLEMENTATION TTMSFMXBitmapGridCell : public TTMSFMXGridCell
{
	typedef TTMSFMXGridCell inherited;
	
private:
	Fmx::Tmsbitmap::TTMSFMXBitmap* FBitmap;
	Fmx::Tmsbitmap::TTMSFMXBitmap* __fastcall GetBitmap(void);
	void __fastcall SetBitmap(Fmx::Tmsbitmap::TTMSFMXBitmap* const Value);
	virtual void __fastcall SetBitmapContainer(Fmx::Tmsbitmapcontainer::TTMSFMXBitmapContainer* const Value);
	
public:
	virtual Fmx::Controls::TControl* __fastcall GetControl(void);
	virtual Fmx::Controls::TControl* __fastcall GetPrintControl(void);
	__fastcall virtual TTMSFMXBitmapGridCell(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXBitmapGridCell(void);
	__property Fmx::Tmsbitmap::TTMSFMXBitmap* Bitmap = {read=GetBitmap, write=SetBitmap};
};


//-- var, const, procedure ---------------------------------------------------
}	/* namespace Tmsgridcell */
}	/* namespace Fmx */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_FMX_TMSGRIDCELL)
using namespace Fmx::Tmsgridcell;
#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_TmsgridcellHPP
