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

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

#ifndef Fmx_TmsgriddataHPP
#define Fmx_TmsgriddataHPP

#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.Generics.Collections.hpp>	// Pascal unit
#include <System.SysUtils.hpp>	// Pascal unit
#include <System.Variants.hpp>	// Pascal unit
#include <System.Types.hpp>	// Pascal unit
#include <System.Classes.hpp>	// Pascal unit
#include <System.UITypes.hpp>	// Pascal unit
#include <FMX.Objects.hpp>	// Pascal unit
#include <FMX.Types.hpp>	// Pascal unit
#include <System.DateUtils.hpp>	// Pascal unit
#include <FMX.TMSBaseControl.hpp>	// Pascal unit
#include <FMX.TMSGridCell.hpp>	// Pascal unit
#include <FMX.TMSGridOptions.hpp>	// Pascal unit
#include <FMX.TMSBitmapContainer.hpp>	// Pascal unit
#include <FMX.Dialogs.hpp>	// Pascal unit
#include <System.RTLConsts.hpp>	// Pascal unit
#include <FMX.Colors.hpp>	// Pascal unit
#include <FMX.ListBox.hpp>	// Pascal unit
#include <FMX.Edit.hpp>	// Pascal unit
#include <FMX.TMSXUtil.hpp>	// Pascal unit
#include <FMX.TMSGridDataUtil.hpp>	// Pascal unit
#include <FMX.TMSBitmap.hpp>	// Pascal unit
#include <FMX.Controls.hpp>	// Pascal unit
#include <System.UIConsts.hpp>	// Pascal unit
#include <FMX.Styles.hpp>	// Pascal unit
#include <Data.DB.hpp>	// Pascal unit
#include <FMX.Graphics.hpp>	// Pascal unit
#include <System.Generics.Defaults.hpp>	// Pascal unit

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

namespace Fmx
{
namespace Tmsgriddata
{
//-- type declarations -------------------------------------------------------
typedef System::UnicodeString TCellData;

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


struct TVariantItem;
typedef TVariantItem *PVariantItem;

struct DECLSPEC_DRECORD TVariantItem
{
public:
	System::UnicodeString FString;
	System::TObject* FObject;
};


typedef System::DynamicArray<TVariantItem> TVariantItemList;

typedef TVariantItemList *PVariantItemList;

class DELPHICLASS TVariantList;
typedef int __fastcall (*TVariantListSortCompare)(TVariantList* List, int Index1, int Index2);

class PASCALIMPLEMENTATION TVariantList : public System::Classes::TPersistent
{
	typedef System::Classes::TPersistent inherited;
	
public:
	System::UnicodeString operator[](int Index) { return Values[Index]; }
	
private:
	TVariantItemList FList;
	int FCount;
	int FCapacity;
	bool FSorted;
	System::Types::TDuplicates FDuplicates;
	bool FCaseSensitive;
	System::Classes::TNotifyEvent FOnChange;
	System::Classes::TNotifyEvent FOnChanging;
	bool FOwnsObject;
	int FUpdateCount;
	void __fastcall ExchangeItems(int Index1, int Index2);
	void __fastcall Grow(void);
	void __fastcall QuickSort(int L, int R, TVariantListSortCompare SCompare);
	void __fastcall SetSorted(bool Value);
	void __fastcall SetCaseSensitive(const bool Value);
	System::UnicodeString __fastcall GetVariant(int Index);
	void __fastcall PutVariant(int Index, const System::UnicodeString Value);
	System::UnicodeString __fastcall GetTextStr(void);
	
protected:
	virtual void __fastcall Changed(void);
	virtual void __fastcall Changing(void);
	System::UnicodeString __fastcall Get(int Index);
	int __fastcall GetCapacity(void);
	int __fastcall GetCount(void);
	System::TObject* __fastcall GetObject(int Index);
	void __fastcall Put(int Index, const System::UnicodeString S);
	void __fastcall PutObject(int Index, System::TObject* AObject);
	void __fastcall SetCapacity(int NewCapacity);
	void __fastcall SetUpdateState(bool Updating);
	int __fastcall CompareVariants(const System::UnicodeString S1, const System::UnicodeString S2);
	virtual void __fastcall InsertItem(int Index, const System::UnicodeString S, System::TObject* AObject);
	void __fastcall Error(const System::UnicodeString Msg, int Data)/* overload */;
	void __fastcall Error(System::PResStringRec Msg, int Data)/* overload */;
	virtual int __fastcall CompareStrings(const System::UnicodeString S1, const System::UnicodeString S2);
	
public:
	__fastcall TVariantList(void)/* overload */;
	__fastcall TVariantList(bool OwnsObjects)/* overload */;
	__fastcall virtual ~TVariantList(void);
	void __fastcall BeginUpdate(void);
	void __fastcall EndUpdate(void);
	int __fastcall Add(const System::UnicodeString S);
	int __fastcall AddObject(const System::UnicodeString S, System::TObject* AObject);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	void __fastcall Clear(void);
	void __fastcall Delete(int Index);
	virtual void __fastcall Move(int CurIndex, int NewIndex);
	void __fastcall Exchange(int Index1, int Index2);
	virtual bool __fastcall Find(const System::UnicodeString S, int &Index);
	int __fastcall IndexOf(const System::UnicodeString S);
	void __fastcall Insert(int Index, const System::UnicodeString S);
	void __fastcall InsertObject(int Index, const System::UnicodeString S, System::TObject* AObject);
	virtual void __fastcall Sort(void);
	virtual void __fastcall CustomSort(TVariantListSortCompare Compare);
	__property int Count = {read=GetCount, nodefault};
	__property System::UnicodeString Values[int Index] = {read=GetVariant, write=PutVariant/*, default*/};
	__property System::TObject* Objects[int Index] = {read=GetObject, write=PutObject};
	__property System::Types::TDuplicates Duplicates = {read=FDuplicates, write=FDuplicates, nodefault};
	__property bool Sorted = {read=FSorted, write=SetSorted, nodefault};
	__property bool CaseSensitive = {read=FCaseSensitive, write=SetCaseSensitive, nodefault};
	__property System::Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
	__property System::Classes::TNotifyEvent OnChanging = {read=FOnChanging, write=FOnChanging};
	__property bool OwnsObjects = {read=FOwnsObject, write=FOwnsObject, nodefault};
	__property System::UnicodeString Text = {read=GetTextStr};
};


struct TCell;
typedef TCell *PCell;

struct DECLSPEC_DRECORD TCell
{
public:
	int Col;
	int Row;
};


struct DECLSPEC_DRECORD TCellRange
{
public:
	int StartCol;
	int StartRow;
	int EndCol;
	int EndRow;
};


enum DECLSPEC_DENUM TCellState : unsigned char { csNormal, csFocused, csFixed, csFixedSelected, csSelected };

enum DECLSPEC_DENUM TSortDirection : unsigned char { sdAscending, sdDescending };

enum DECLSPEC_DENUM TSortFormat : unsigned char { ssAutomatic, ssAlphabetic, ssAlphabeticNoCase, ssNumeric, ssDate, ssHTML, ssCheckBox, ssCustom, ssRaw };

enum DECLSPEC_DENUM TTMSFMXGridSelectionMode : unsigned char { smNone, smSingleCell, smSingleRow, smSingleColumn, smCellRange, smRowRange, smColumnRange, smDisjunctRow, smDisjunctColumn, smDisjunctCell };

typedef void __fastcall (__closure *TTMSFMXGridSortFormatEvent)(System::TObject* Sender, int Col, TSortFormat &SortFormat, System::UnicodeString &APrefix, System::UnicodeString &ASuffix);

typedef void __fastcall (__closure *TTMSFMXGridCustomCompareEvent)(System::TObject* Sender, System::UnicodeString Value1, System::UnicodeString Value2, int &res);

typedef void __fastcall (__closure *TTMSFMXGridRawCompareEvent)(System::TObject* Sender, int Col, int Row1, int Row2, int &res);

typedef void __fastcall (__closure *TTMSFMXGridClipboardBeforePasteEvent)(System::TObject* Sender, int Col, int Row, System::UnicodeString &Value, bool &Allow);

typedef void __fastcall (__closure *TTMSFMXGridClipboardAfterPasteEvent)(System::TObject* Sender, int Col, int Row, System::UnicodeString Value);

typedef void __fastcall (__closure *TTMSFMXGridNeedFilterDropDownEvent)(System::TObject* Sender, int Col, int Row, bool &Allow);

typedef void __fastcall (__closure *TTMSFMXGridNeedFilterDropDownDataEvent)(System::TObject* Sender, int Col, int Row, System::Classes::TStrings* AValues);

typedef void __fastcall (__closure *TTMSFMXGridFilterSelectEvent)(System::TObject* Sender, int Col, System::UnicodeString &Condition);

typedef void __fastcall (__closure *TTMSFMXGridCellsChangedEvent)(System::TObject* Sender, const TCellRange &Cells);

typedef void __fastcall (__closure *TTMSFMXGridColumnCalcEvent)(System::TObject* Sender, int ACol, int FromRow, int ToRow, double &Res);

enum DECLSPEC_DENUM TColumnCalculation : unsigned char { ccNone, ccSum, ccAvg, ccCount, ccMin, ccMax, ccCUSTOM, ccDistinct, ccStdDev };

class DELPHICLASS TCellProperty;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCellProperty : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::Uitypes::TAlphaColor FColor;
	int FBaseCol;
	int FBaseRow;
	int FColSpan;
	int FRowSpan;
	Fmx::Types::TTextAlign FAlignHorz;
	Fmx::Types::TTextAlign FAlignVert;
	System::TObject* FControl;
	System::TObject* FObject;
	bool FReadOnly;
	int FPrintPageNr;
	System::Uitypes::TFontStyles FFontStyle;
	float FFontSize;
	System::UnicodeString FFontName;
	System::Uitypes::TAlphaColor FFontColor;
	float FAngle;
	System::UnicodeString FComment;
	System::Uitypes::TAlphaColor FCommentColor;
	System::Uitypes::TAlphaColor FBorderColor;
	float FBorderWidth;
	bool FWordWrap;
	bool FFixed;
	
protected:
	__property int PrintPageNr = {read=FPrintPageNr, write=FPrintPageNr, nodefault};
	
public:
	virtual void __fastcall Assign(TCellProperty* Source);
	__fastcall TCellProperty(Fmx::Graphics::TFont* DefaultFont);
	__fastcall virtual ~TCellProperty(void);
	bool __fastcall IsBaseCell(int Col, int Row);
	void __fastcall FreeControl(void);
	__property System::Uitypes::TAlphaColor Color = {read=FColor, write=FColor, nodefault};
	__property System::TObject* CellObject = {read=FObject, write=FObject};
	__property bool ReadOnly = {read=FReadOnly, write=FReadOnly, nodefault};
	__property Fmx::Types::TTextAlign AlignHorz = {read=FAlignHorz, write=FAlignHorz, nodefault};
	__property Fmx::Types::TTextAlign AlignVert = {read=FAlignVert, write=FAlignVert, nodefault};
	__property System::Uitypes::TAlphaColor BorderColor = {read=FBorderColor, write=FBorderColor, nodefault};
	__property float BorderWidth = {read=FBorderWidth, write=FBorderWidth};
	__property bool Fixed = {read=FFixed, write=FFixed, nodefault};
	__property System::Uitypes::TFontStyles FontStyle = {read=FFontStyle, write=FFontStyle, nodefault};
	__property float FontSize = {read=FFontSize, write=FFontSize};
	__property System::UnicodeString FontName = {read=FFontName, write=FFontName};
	__property System::Uitypes::TAlphaColor FontColor = {read=FFontColor, write=FFontColor, nodefault};
	__property int BaseCol = {read=FBaseCol, write=FBaseCol, nodefault};
	__property int ColSpan = {read=FColSpan, write=FColSpan, nodefault};
	__property int BaseRow = {read=FBaseRow, write=FBaseRow, nodefault};
	__property int RowSpan = {read=FRowSpan, write=FRowSpan, nodefault};
	__property System::TObject* Control = {read=FControl, write=FControl};
	__property float Angle = {read=FAngle, write=FAngle};
	__property System::UnicodeString Comment = {read=FComment, write=FComment};
	__property System::Uitypes::TAlphaColor CommentColor = {read=FCommentColor, write=FCommentColor, nodefault};
	__property bool WordWrap = {read=FWordWrap, write=FWordWrap, nodefault};
};

#pragma pack(pop)

class DELPHICLASS TCellCheckBox;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCellCheckBox : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	bool FChecked;
	bool FHeader;
	
public:
	__property bool Checked = {read=FChecked, write=FChecked, nodefault};
	__property bool Header = {read=FHeader, write=FHeader, nodefault};
public:
	/* TObject.Create */ inline __fastcall TCellCheckBox(void) : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TCellCheckBox(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TCellDataCheckBox;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCellDataCheckBox : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	/* TObject.Create */ inline __fastcall TCellDataCheckBox(void) : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TCellDataCheckBox(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TCellRadioButton;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCellRadioButton : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	bool FChecked;
	int FInteger;
	
public:
	__property bool Checked = {read=FChecked, write=FChecked, nodefault};
	__property int Index = {read=FInteger, write=FInteger, nodefault};
public:
	/* TObject.Create */ inline __fastcall TCellRadioButton(void) : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TCellRadioButton(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TCellButton;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCellButton : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::UnicodeString FText;
	int FWidth;
	
public:
	__property System::UnicodeString Text = {read=FText, write=FText};
	__property int Width = {read=FWidth, write=FWidth, nodefault};
public:
	/* TObject.Create */ inline __fastcall TCellButton(void) : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TCellButton(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TCellBitmapName;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCellBitmapName : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::UnicodeString FBitmapName;
	bool FData;
	
public:
	__fastcall TCellBitmapName(void);
	__property bool Data = {read=FData, write=FData, nodefault};
	__property System::UnicodeString BitmapName = {read=FBitmapName, write=FBitmapName};
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TCellBitmapName(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TBitmapEx;
class DELPHICLASS TTMSFMXGridData;
class PASCALIMPLEMENTATION TBitmapEx : public Fmx::Graphics::TBitmap
{
	typedef Fmx::Graphics::TBitmap inherited;
	
private:
	TTMSFMXGridData* FOwner;
	
public:
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
public:
	/* TBitmap.Create */ inline __fastcall virtual TBitmapEx(void)/* overload */ : Fmx::Graphics::TBitmap() { }
	/* TBitmap.Create */ inline __fastcall virtual TBitmapEx(const int AWidth, const int AHeight)/* overload */ : Fmx::Graphics::TBitmap(AWidth, AHeight) { }
	/* TBitmap.CreateFromStream */ inline __fastcall virtual TBitmapEx(System::Classes::TStream* const AStream) : Fmx::Graphics::TBitmap(AStream) { }
	/* TBitmap.CreateFromFile */ inline __fastcall virtual TBitmapEx(const System::UnicodeString AFileName) : Fmx::Graphics::TBitmap(AFileName) { }
	/* TBitmap.CreateFromBitmapAndMask */ inline __fastcall TBitmapEx(Fmx::Graphics::TBitmap* const Bitmap, Fmx::Graphics::TBitmap* const Mask) : Fmx::Graphics::TBitmap(Bitmap, Mask) { }
	/* TBitmap.Destroy */ inline __fastcall virtual ~TBitmapEx(void) { }
	
};


class DELPHICLASS TCellBitmap;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCellBitmap : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	TBitmapEx* FBitmap;
	void __fastcall SetBitmap(TBitmapEx* const Value);
	
public:
	__fastcall TCellBitmap(TTMSFMXGridData* AOwner);
	__fastcall virtual ~TCellBitmap(void);
	__property TBitmapEx* Bitmap = {read=FBitmap, write=SetBitmap};
};

#pragma pack(pop)

class DELPHICLASS TCellNode;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCellNode : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	Fmx::Tmsgridcell::TNodeState FState;
	int FSpan;
	
public:
	__property Fmx::Tmsgridcell::TNodeState State = {read=FState, write=FState, nodefault};
	__property int Span = {read=FSpan, write=FSpan, nodefault};
public:
	/* TObject.Create */ inline __fastcall TCellNode(void) : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TCellNode(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TCellSummary;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCellSummary : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	bool FMerged;
	
public:
	__property bool Merged = {read=FMerged, write=FMerged, nodefault};
public:
	/* TObject.Create */ inline __fastcall TCellSummary(void) : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TCellSummary(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TCellProgressBar;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCellProgressBar : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	float FValue;
	bool FData;
	
public:
	__property float Value = {read=FValue, write=FValue};
	__property bool Data = {read=FData, write=FData, nodefault};
public:
	/* TObject.Create */ inline __fastcall TCellProgressBar(void) : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TCellProgressBar(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TCellControl;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCellControl : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	Fmx::Types::TFmxObject* FControl;
	
public:
	__property Fmx::Types::TFmxObject* Control = {read=FControl, write=FControl};
public:
	/* TObject.Create */ inline __fastcall TCellControl(void) : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TCellControl(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TCellCombo;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCellCombo : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::Classes::TStringList* FItems;
	bool FEditable;
	void __fastcall SetItems(System::Classes::TStringList* const Value);
	
public:
	__fastcall TCellCombo(void);
	__fastcall virtual ~TCellCombo(void);
	__property System::Classes::TStringList* Items = {read=FItems, write=SetItems};
	__property bool Editable = {read=FEditable, write=FEditable, nodefault};
};

#pragma pack(pop)

class DELPHICLASS TSortIndexList;
class PASCALIMPLEMENTATION TSortIndexList : public Fmx::Tmsgriddatautil::TIntList
{
	typedef Fmx::Tmsgriddatautil::TIntList inherited;
	
private:
	int __fastcall GetSortColumns(int i);
	bool __fastcall GetSortDirections(int i);
	void __fastcall SetSortColumns(int i, const int Value);
	void __fastcall SetSortDirections(int i, const bool Value);
	
public:
	System::UnicodeString __fastcall SaveToString(void);
	void __fastcall LoadFromString(System::UnicodeString s);
	void __fastcall AddIndex(int ColumnIndex, TSortDirection ADirection);
	int __fastcall FindIndex(int ColumnIndex);
	void __fastcall ToggleIndex(int ColumnIndex);
	__property int SortColumns[int i] = {read=GetSortColumns, write=SetSortColumns};
	__property bool SortDirections[int i] = {read=GetSortDirections, write=SetSortDirections};
public:
	/* {System_Generics_Collections}TList<System_Integer>.Create */ inline __fastcall TSortIndexList(void)/* overload */ : Fmx::Tmsgriddatautil::TIntList() { }
	/* {System_Generics_Collections}TList<System_Integer>.Create */ inline __fastcall TSortIndexList(const System::DelphiInterface<System::Generics::Defaults::IComparer__1<int> > AComparer)/* overload */ : Fmx::Tmsgriddatautil::TIntList(AComparer) { }
	/* {System_Generics_Collections}TList<System_Integer>.Create */ inline __fastcall TSortIndexList(System::Generics::Collections::TEnumerable__1<int>* const Collection)/* overload */ : Fmx::Tmsgriddatautil::TIntList(Collection) { }
	/* {System_Generics_Collections}TList<System_Integer>.Destroy */ inline __fastcall virtual ~TSortIndexList(void) { }
	
};


enum DECLSPEC_DENUM TFilterCells : unsigned char { fcVirtual, fcNormal, fcStripHTML, fcRow };

enum DECLSPEC_DENUM TFilterOperation : unsigned char { foSHORT, foNONE, foAND, foXOR, foOR };

enum DECLSPEC_DENUM TRowState : unsigned char { rsDefault, rsSelected };

class DELPHICLASS TDataList;
class PASCALIMPLEMENTATION TDataList : public TVariantList
{
	typedef TVariantList inherited;
	
public:
	/* TVariantList.Create */ inline __fastcall TDataList(void)/* overload */ : TVariantList() { }
	/* TVariantList.Create */ inline __fastcall TDataList(bool OwnsObjects)/* overload */ : TVariantList(OwnsObjects) { }
	/* TVariantList.Destroy */ inline __fastcall virtual ~TDataList(void) { }
	
};


class DELPHICLASS TRowInfo;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TRowInfo : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	TDataList* FData;
	TRowState FState;
	void __fastcall SetState(const TRowState Value);
	
public:
	__fastcall TRowInfo(void);
	__fastcall virtual ~TRowInfo(void);
	__property TDataList* Data = {read=FData};
	__property TRowState State = {read=FState, write=SetState, nodefault};
};

#pragma pack(pop)

class DELPHICLASS TFilterData;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TFilterData : public System::Classes::TCollectionItem
{
	typedef System::Classes::TCollectionItem inherited;
	
private:
	short FColumn;
	System::UnicodeString FCondition;
	bool FCaseSensitive;
	System::UnicodeString FSuffix;
	System::UnicodeString FPrefix;
	TFilterOperation FOperation;
	TFilterCells FData;
	
public:
	__fastcall virtual TFilterData(System::Classes::TCollection* ACollection);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	
__published:
	__property short Column = {read=FColumn, write=FColumn, nodefault};
	__property System::UnicodeString Condition = {read=FCondition, write=FCondition};
	__property bool CaseSensitive = {read=FCaseSensitive, write=FCaseSensitive, default=1};
	__property TFilterCells Data = {read=FData, write=FData, default=0};
	__property System::UnicodeString Prefix = {read=FPrefix, write=FPrefix};
	__property System::UnicodeString Suffix = {read=FSuffix, write=FSuffix};
	__property TFilterOperation Operation = {read=FOperation, write=FOperation, nodefault};
public:
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TFilterData(void) { }
	
};

#pragma pack(pop)

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

#pragma pack(pop)

struct DECLSPEC_DRECORD TCellCoordinate
{
public:
	int Col;
	int Row;
};


class DELPHICLASS TFileStringList;
class PASCALIMPLEMENTATION TFileStringList : public System::Classes::TStringList
{
	typedef System::Classes::TStringList inherited;
	
private:
	int fp;
	System::UnicodeString cache;
	bool __fastcall GetEOF(void);
	
public:
	void __fastcall Reset(void);
	void __fastcall ReadLn(System::UnicodeString &s);
	void __fastcall Write(System::UnicodeString s);
	void __fastcall WriteLn(System::UnicodeString s);
	__property bool Eof = {read=GetEOF, nodefault};
public:
	/* TStringList.Create */ inline __fastcall TFileStringList(void)/* overload */ : System::Classes::TStringList() { }
	/* TStringList.Create */ inline __fastcall TFileStringList(bool OwnsObjects)/* overload */ : System::Classes::TStringList(OwnsObjects) { }
	/* TStringList.Destroy */ inline __fastcall virtual ~TFileStringList(void) { }
	
};


enum DECLSPEC_DENUM TFindParameters : unsigned char { fnMatchCase, fnMatchFull, fnMatchRegular, fnDirectionLeftRight, fnMatchStart, fnFindInCurrentRow, fnFindInCurrentCol, fnIncludeFixed, fnAutoGoto, fnIgnoreHTMLTags, fnBackward, fnIncludeHiddenColumns, fnFindInPresetCol, fnFindInPresetRow, fnSelectedCells, fnIncludeHiddenRows };

typedef System::Set<TFindParameters, TFindParameters::fnMatchCase, TFindParameters::fnIncludeHiddenRows> TFindParams;

class DELPHICLASS TSingleListItem;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TSingleListItem : public System::Classes::TCollectionItem
{
	typedef System::Classes::TCollectionItem inherited;
	
private:
	TTMSFMXGridData* FOwner;
	float FValue;
	int FCellVal;
	void __fastcall SeTCellData(const float Value);
	
public:
	__fastcall virtual TSingleListItem(System::Classes::TCollection* Collection);
	
__published:
	__property float Value = {read=FValue, write=SeTCellData};
	__property int CellVal = {read=FCellVal, write=FCellVal, nodefault};
public:
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TSingleListItem(void) { }
	
};

#pragma pack(pop)

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


enum DECLSPEC_DENUM TTMSFMXMarkType : unsigned char { mtHighlight, mtError };

class DELPHICLASS TCellMarkItem;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCellMarkItem : public System::Classes::TCollectionItem
{
	typedef System::Classes::TCollectionItem inherited;
	
private:
	TCellRange FCellRange;
	System::UnicodeString FValue;
	bool FCaseSensitive;
	TTMSFMXMarkType FMarkType;
	
public:
	__property TCellRange CellRange = {read=FCellRange, write=FCellRange};
	
__published:
	__property bool CaseSensitive = {read=FCaseSensitive, write=FCaseSensitive, nodefault};
	__property System::UnicodeString Value = {read=FValue, write=FValue};
	__property TTMSFMXMarkType MarkType = {read=FMarkType, write=FMarkType, nodefault};
public:
	/* TCollectionItem.Create */ inline __fastcall virtual TCellMarkItem(System::Classes::TCollection* Collection) : System::Classes::TCollectionItem(Collection) { }
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TCellMarkItem(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TCellMarkList;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCellMarkList : public Fmx::Tmsbasecontrol::TTMSFMXBaseCollection
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseCollection inherited;
	
public:
	TCellMarkItem* operator[](int Index) { return Items[Index]; }
	
private:
	HIDESBASE TCellMarkItem* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, TCellMarkItem* const Value);
	
public:
	__fastcall TCellMarkList(TTMSFMXGridData* AOwner);
	__property TCellMarkItem* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
	HIDESBASE TCellMarkItem* __fastcall Add(void);
	HIDESBASE TCellMarkItem* __fastcall Insert(int Index);
	void __fastcall RemoveMarker(const TCellRange &CellRange, TTMSFMXMarkType MarkerType);
public:
	/* TCollection.Destroy */ inline __fastcall virtual ~TCellMarkList(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TCellList;
class PASCALIMPLEMENTATION TCellList : public System::Generics::Collections::TList__1<TCell>
{
	typedef System::Generics::Collections::TList__1<TCell> inherited;
	
public:
	__fastcall TCellList(void);
	__fastcall virtual ~TCellList(void);
	void __fastcall AddCell(const TCell &Cell);
	void __fastcall DeleteCell(const TCell &Cell)/* overload */;
	void __fastcall DeleteCell(int index)/* overload */;
	HIDESBASE void __fastcall Clear(void);
	int __fastcall Find(const TCell &Cell);
	int __fastcall FindFixed(const TCell &Cell);
};


enum DECLSPEC_DENUM TGridExportState : unsigned char { esExportStart, esExportNewRow, esExportDone, esExportSelRow, esExportFail, esExportNextRow };

enum DECLSPEC_DENUM TGridImportState : unsigned char { isImportStart, isImportNewRow, isImportDone, isImportSelRow };

enum DECLSPEC_DENUM TTMSFMXGridEditorType : unsigned char { etEdit, etNumericEdit, etSignedNumericEdit, etFloatEdit, etSignedFloatEdit, etUppercaseEdit, etMixedCaseEdit, etLowerCaseEdit, etMoneyEdit, etHexEdit, etAlphaNumericEdit, etValidCharsEdit, etEditBtn, etNumericEditBtn, etSignedNumericEditBtn, etFloatEditBtn, etSignedFloatEditBtn, etUppercaseEditBtn, etMixedCaseEditBtn, etLowerCaseEditBtn, etMoneyEditBtn, etHexEditBtn, etAlphaNumericEditBtn, etValidCharsEditBtn, etComboBox, etComboEdit, etSpinBox, etDatePicker, etDateEdit, etColorPicker, etColorComboBox, etTrackBar, etArcDial, etCustom };

typedef void __fastcall (__closure *TTMSFMXGridIOProgressEvent)(System::TObject* Sender, int CurrentRow, int TotalRows, short Progres);

typedef void __fastcall (__closure *TTMSFMXGridIOEvent)(System::TObject* Sender, int Col, int Row, System::UnicodeString &Value);

enum DECLSPEC_DENUM TTMSFMXGridColumnType : unsigned char { ctDefault, ctButton, ctCheckBox, ctProgressBar, ctRadioButton };

class DELPHICLASS TTMSFMXGridColumn;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TTMSFMXGridColumn : public System::Classes::TCollectionItem
{
	typedef System::Classes::TCollectionItem inherited;
	
private:
	System::Uitypes::TAlphaColor FColor;
	Fmx::Types::TTextAlign FVertAlignment;
	System::Uitypes::TAlphaColor FFontColor;
	Fmx::Types::TTextAlign FHorzAlignment;
	TSortFormat FSortFormat;
	Fmx::Graphics::TFont* FFont;
	TTMSFMXGridEditorType FEditor;
	bool FReadOnly;
	System::Uitypes::TAlphaColor FBorderColor;
	System::UnicodeString FID;
	float FBorderWidth;
	bool FWordWrap;
	bool FFixed;
	System::UnicodeString FSortPrefix;
	System::UnicodeString FSortSuffix;
	Fmx::Graphics::TBrushKind FBrushKind;
	int FTag;
	System::Classes::TStringList* FComboItems;
	TTMSFMXGridColumnType FColumnType;
	System::UnicodeString FName;
	void __fastcall SetColor(const System::Uitypes::TAlphaColor Value);
	void __fastcall SetFontColor(const System::Uitypes::TAlphaColor Value);
	void __fastcall SetHorzAlignment(const Fmx::Types::TTextAlign Value);
	void __fastcall SetVertAlignment(const Fmx::Types::TTextAlign Value);
	void __fastcall SetFont(Fmx::Graphics::TFont* const Value);
	void __fastcall SetBorderColor(const System::Uitypes::TAlphaColor Value);
	void __fastcall SetBorderWidth(const float Value);
	void __fastcall SetWordWrap(const bool Value);
	void __fastcall SetFixed(const bool Value);
	void __fastcall SetBrushKind(const Fmx::Graphics::TBrushKind Value);
	void __fastcall SetComboItems(System::Classes::TStringList* const Value);
	void __fastcall SetColumnType(const TTMSFMXGridColumnType Value);
	
protected:
	HIDESBASE void __fastcall Changed(void);
	__property Fmx::Graphics::TBrushKind BrushKind = {read=FBrushKind, write=SetBrushKind, nodefault};
	virtual System::UnicodeString __fastcall GetDisplayName(void);
	
public:
	__fastcall virtual TTMSFMXGridColumn(System::Classes::TCollection* Collection);
	__fastcall virtual ~TTMSFMXGridColumn(void);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	
__published:
	__property System::Uitypes::TAlphaColor BorderColor = {read=FBorderColor, write=SetBorderColor, default=-4144960};
	__property float BorderWidth = {read=FBorderWidth, write=SetBorderWidth};
	__property System::Uitypes::TAlphaColor Color = {read=FColor, write=SetColor, nodefault};
	__property TTMSFMXGridColumnType ColumnType = {read=FColumnType, write=SetColumnType, default=0};
	__property System::Classes::TStringList* ComboItems = {read=FComboItems, write=SetComboItems};
	__property TTMSFMXGridEditorType Editor = {read=FEditor, write=FEditor, nodefault};
	__property bool Fixed = {read=FFixed, write=SetFixed, nodefault};
	__property System::Uitypes::TAlphaColor FontColor = {read=FFontColor, write=SetFontColor, nodefault};
	__property Fmx::Graphics::TFont* Font = {read=FFont, write=SetFont};
	__property Fmx::Types::TTextAlign HorzAlignment = {read=FHorzAlignment, write=SetHorzAlignment, default=1};
	__property System::UnicodeString ID = {read=FID, write=FID};
	__property System::UnicodeString Name = {read=FName, write=FName};
	__property bool ReadOnly = {read=FReadOnly, write=FReadOnly, default=0};
	__property TSortFormat SortFormat = {read=FSortFormat, write=FSortFormat, default=0};
	__property System::UnicodeString SortSuffix = {read=FSortSuffix, write=FSortSuffix};
	__property System::UnicodeString SortPrefix = {read=FSortPrefix, write=FSortPrefix};
	__property int Tag = {read=FTag, write=FTag, default=0};
	__property Fmx::Types::TTextAlign VertAlignment = {read=FVertAlignment, write=SetVertAlignment, default=0};
	__property bool WordWrap = {read=FWordWrap, write=SetWordWrap, default=0};
};

#pragma pack(pop)

class DELPHICLASS TTMSFMXGridColumns;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TTMSFMXGridColumns : public System::Classes::TOwnedCollection
{
	typedef System::Classes::TOwnedCollection inherited;
	
public:
	TTMSFMXGridColumn* operator[](int Index) { return Items[Index]; }
	
private:
	HIDESBASE TTMSFMXGridColumn* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, TTMSFMXGridColumn* const Value);
	
public:
	__fastcall TTMSFMXGridColumns(System::Classes::TPersistent* AOwner);
	TTMSFMXGridColumn* __fastcall ColumnByName(System::UnicodeString AName);
	TTMSFMXGridColumn* __fastcall ColumnByID(System::UnicodeString AID);
	__property TTMSFMXGridColumn* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
	HIDESBASE TTMSFMXGridColumn* __fastcall Add(void);
	HIDESBASE TTMSFMXGridColumn* __fastcall Insert(int Index);
	TTMSFMXGridColumn* __fastcall ByID(System::UnicodeString Id);
public:
	/* TCollection.Destroy */ inline __fastcall virtual ~TTMSFMXGridColumns(void) { }
	
};

#pragma pack(pop)

class PASCALIMPLEMENTATION TTMSFMXGridData : public Fmx::Tmsgridoptions::TTMSFMXCustomGridData
{
	typedef Fmx::Tmsgridoptions::TTMSFMXCustomGridData inherited;
	
private:
	bool FInternalColumnUpdate;
	bool FInternalRowUpdate;
	TCellProperty* FColumnProp;
	TTMSFMXGridColumns* FColumns;
	bool FUseColumns;
	int FUpdateCount;
	bool FFirstCellApply;
	bool FBlockUpdate;
	TCell FFocusedCell;
	TCell FStartCell;
	TCell FStopCell;
	System::Generics::Collections::TList__1<TRowInfo*>* FRowList;
	System::Generics::Collections::TList__1<int>* FRowDisplayList;
	System::Generics::Collections::TList__1<int>* FColumnDisplayList;
	System::Generics::Collections::TList__1<int>* FHiddenColumnList;
	System::Generics::Collections::TList__1<int>* FHiddenRowList;
	Fmx::Tmsgriddatautil::TIntList* FColSelect;
	TCellList* FSelectedCells;
	int FRowCount;
	TSortDirection FSortDirection;
	int FSortColumn;
	int FSortDir;
	System::Types::TPoint FIOOffset;
	TFilter* FFilter;
	TSortIndexList* FSortIndexes;
	Fmx::Tmsgriddatautil::TIntList* FCellCalcList;
	bool FSaveHiddenCells;
	int FFindCol;
	int FFindRow;
	System::Types::TPoint FSearchCell;
	System::UnicodeString FSearchCache;
	TFindParams FFindParams;
	bool FFindBusy;
	int FColumnCount;
	int FFixedRows;
	int FFixedColumns;
	TSingleList* FRowH;
	int FFixedRightColumns;
	TSingleList* FColumnW;
	int FFixedFooterRows;
	float FDefaultRowHeight;
	float FDefaultColumnWidth;
	System::UnicodeString FCheckFalse;
	System::UnicodeString FCheckTrue;
	short FPrevProgress;
	int FGroupColumn;
	float FGroupWidth;
	System::UnicodeString FGroupCaption;
	System::UnicodeString FGroupFooter;
	bool FIsGrouping;
	System::UnicodeString FFloatFormat;
	Fmx::Tmsgriddatautil::TIntList* FColumnOrder;
	TTMSFMXGridSelectionMode FSelectionMode;
	Fmx::Tmsbitmapcontainer::TTMSFMXBitmapContainer* FBitmapContainer;
	TTMSFMXGridIOProgressEvent FOnIOProgress;
	TTMSFMXGridSortFormatEvent FOnSortFormat;
	TTMSFMXGridCustomCompareEvent FOnCustomCompare;
	TTMSFMXGridRawCompareEvent FOnRawCompare;
	Fmx::Tmsgridoptions::TTMSFMXGridOptions* FOptions;
	TCellMarkList* FMarkList;
	Fmx::Graphics::TFont* FDefaultFont;
	TTMSFMXGridClipboardAfterPasteEvent FOnClipboardAfterPasteCell;
	TTMSFMXGridClipboardBeforePasteEvent FOnClipboardBeforePasteCell;
	TTMSFMXGridCellsChangedEvent FOnCellsChanged;
	TTMSFMXGridCellsChangedEvent FOnClipboardPaste;
	TTMSFMXGridIOEvent FOnLoadCell;
	TTMSFMXGridIOEvent FOnSaveCell;
	Fmx::Listbox::TListBox* FFilterListBox;
	Fmx::Types::TTimer* FFilterTimer;
	System::TObject* FFilterSenderListBox;
	TTMSFMXGridNeedFilterDropDownEvent FOnNeedFilterDropDown;
	TTMSFMXGridNeedFilterDropDownDataEvent FOnNeedFilterDropDownData;
	TTMSFMXGridFilterSelectEvent FOnFilterSelect;
	TTMSFMXGridColumnCalcEvent FOnGroupCalc;
	TTMSFMXGridColumnCalcEvent FOnColumnCalc;
	void __fastcall SetDefaultColumnWidth(const float Value);
	void __fastcall SetDefaultRowHeight(const float Value);
	void __fastcall EnsureRow(int Row);
	void __fastcall EnsureCol(int Col);
	System::UnicodeString __fastcall GetCells(int Col, int Row);
	void __fastcall SetCells(int Col, int Row, const System::UnicodeString Value);
	System::TObject* __fastcall GetIntObjects(int Col, int Row);
	void __fastcall SetIntObjects(int Col, int Row, System::TObject* const Value);
	int __fastcall GetRowCount(void);
	int __fastcall GetHiddenColCount(void);
	int __fastcall GetHiddenRowCount(void);
	int __fastcall GetTotalColCount(void);
	int __fastcall GetTotalRowCount(void);
	System::UnicodeString __fastcall GetAllCells(int Col, int Row);
	void __fastcall SetAllCells(int Col, int Row, const System::UnicodeString Value);
	System::Uitypes::TAlphaColor __fastcall GetColors(int Col, int Row);
	void __fastcall SetColors(int Col, int Row, const System::Uitypes::TAlphaColor Value);
	void __fastcall SetColumnCount(const int Value);
	void __fastcall SetRowCount(const int Value);
	void __fastcall SetColumnW(TSingleList* const Value);
	void __fastcall SetFixedColumns(const int Value);
	void __fastcall SetFixedFooterRows(const int Value);
	void __fastcall SetFixedRightColumns(const int Value);
	void __fastcall SetFixedRows(const int Value);
	void __fastcall SetRowH(TSingleList* const Value);
	int __fastcall GetColumnCount(void);
	void __fastcall SetColWidths(int Col, const float Value);
	void __fastcall SetRowHeights(int Row, const float Value);
	void __fastcall SetSelectionMode(const TTMSFMXGridSelectionMode Value);
	TCellRange __fastcall GetSelection(void);
	void __fastcall SetSelection(const TCellRange &Value);
	TCell __fastcall GetFocusedCell(void);
	void __fastcall SetFocusedCell(const TCell &Value);
	TCellProperty* __fastcall GetCellProps(int Col, int Row);
	bool __fastcall GetRowSelect(int Row);
	void __fastcall SetRowSelect(int Row, const bool Value);
	void __fastcall SetSortColumn(const int Value);
	void __fastcall SetSortDirection(const TSortDirection Value);
	void __fastcall SetOptions(Fmx::Tmsgridoptions::TTMSFMXGridOptions* const Value);
	System::TObject* __fastcall GetObjects(int Col, int Row);
	void __fastcall SetObjects(int Col, int Row, System::TObject* const Value);
	double __fastcall GetAllFloats(int Col, int Row);
	void __fastcall SetAllFloats(int Col, int Row, const double Value);
	int __fastcall GetMergeCellPrintPageNr(int Col, int Row);
	void __fastcall SetMergeCellPrintPageNr(int Col, int Row, const int Value);
	Fmx::Types::TTextAlign __fastcall GetHorzAlignments(int Col, int Row);
	void __fastcall SetHorzAlignments(int Col, int Row, const Fmx::Types::TTextAlign Value);
	Fmx::Types::TTextAlign __fastcall GetVertAlignments(int Col, int Row);
	void __fastcall SetVertAlignments(int Col, int Row, const Fmx::Types::TTextAlign Value);
	System::Uitypes::TFontStyles __fastcall GetFontStyles(int Col, int Row);
	void __fastcall SetFontStyles(int Col, int Row, const System::Uitypes::TFontStyles Value);
	float __fastcall GetFontSizes(int Col, int Row);
	void __fastcall SetFontSizes(int Col, int Row, const float Value);
	System::UnicodeString __fastcall GetFontNames(int Col, int Row);
	void __fastcall SetFontNames(int Col, int Row, const System::UnicodeString Value);
	System::Uitypes::TAlphaColor __fastcall GetFontColors(int Col, int Row);
	void __fastcall SetFontColors(int Col, int Row, const System::Uitypes::TAlphaColor Value);
	int __fastcall GetRowSelectionCount(void);
	float __fastcall GetAngles(int Col, int Row);
	void __fastcall SetAngles(int Col, int Row, const float Value);
	Fmx::Types::TFmxObject* __fastcall GetCellControls(int Col, int Row);
	void __fastcall SetCellControls(int Col, int Row, Fmx::Types::TFmxObject* const Value);
	bool __fastcall GetReadOnlys(int Col, int Row);
	void __fastcall SetReadOnlys(int Col, int Row, const bool Value);
	System::UnicodeString __fastcall SaveToHTMLString(System::UnicodeString dir);
	bool __fastcall GetColumnSelect(int Col);
	int __fastcall GetColumnSelectionCount(void);
	void __fastcall SetColumnSelect(int Col, const bool Value);
	bool __fastcall GetCellSelect(int Col, int Row);
	int __fastcall GetCellSelectionCount(void);
	void __fastcall SetCellSelect(int Col, int Row, const bool Value);
	int __fastcall GetSelectedColumn(int index);
	int __fastcall GetSelectedRow(int index);
	TCell __fastcall GetSelectedCell(int index);
	bool __fastcall GetCheckBoxState(int Col, int Row);
	void __fastcall SetCheckBoxState(int Col, int Row, const bool Value);
	bool __fastcall GetFixedCellSelect(int Col, int Row);
	void __fastcall HandleFilterListClick(System::TObject* Sender);
	void __fastcall ApplyFilterListBoxStyleLookUp(System::TObject* Sender);
	void __fastcall HandleFilterTimer(System::TObject* Sender);
	System::UnicodeString __fastcall GetComments(int Col, int Row);
	void __fastcall SetComments(int Col, int Row, const System::UnicodeString Value);
	System::Uitypes::TAlphaColor __fastcall GetCommentColors(int Col, int Row);
	void __fastcall SetCommentColors(int Col, int Row, const System::Uitypes::TAlphaColor Value);
	TColumnCalculation __fastcall GetColumnCalculation(int Col);
	void __fastcall SetColumnCalculation(int Col, const TColumnCalculation Value);
	void __fastcall UpdateColumnCalc(int Col, TColumnCalculation Value);
	double __fastcall GetFloats(int Col, int Row);
	void __fastcall SetFloats(int Col, int Row, const double Value);
	System::UnicodeString __fastcall GetStrippedCells(int Col, int Row);
	System::UnicodeString __fastcall GetRowText(int Row);
	Fmx::Graphics::TBitmap* __fastcall GetBitmaps(int Col, int Row);
	bool __fastcall GetBooleans(int Col, int Row);
	void __fastcall SetBitmaps(int Col, int Row, Fmx::Graphics::TBitmap* const Value);
	void __fastcall SetBooleans(int Col, int Row, const bool Value);
	void __fastcall SetColumns(TTMSFMXGridColumns* const Value);
	
protected:
	virtual TCellState __fastcall GetCellState(int ACol, int ARow);
	virtual void __fastcall AssignBitmapEx(System::Classes::TPersistent* Source, System::Classes::TPersistent* Dest);
	__property int UpdateCount = {read=FUpdateCount, write=FUpdateCount, nodefault};
	__property bool FirstCellApply = {read=FFirstCellApply, write=FFirstCellApply, nodefault};
	__property int GroupColumn = {read=FGroupColumn, nodefault};
	__property bool BlockUpdate = {read=FBlockUpdate, write=FBlockUpdate, nodefault};
	virtual void __fastcall SelectCell(const TCell &Cell, System::Classes::TShiftState Shift = System::Classes::TShiftState() , bool MouseDragging = false);
	__property TCell StartCell = {read=FStartCell, write=FStartCell};
	__property TCell StopCell = {read=FStopCell, write=FStopCell};
	__property TCell FocCell = {read=FFocusedCell, write=FFocusedCell};
	void __fastcall SetStartCell(int ACol, int ARow);
	void __fastcall SetStopCell(int ACol, int ARow);
	void __fastcall SetFocusCell(int ACol, int ARow);
	float __fastcall GetColWidths(int AIndex);
	float __fastcall GetRowHeights(int AIndex);
	int __fastcall CompareLine(int Col, int Row1, int Row2);
	int __fastcall CompareRows(int Col, int Row1, int Row2);
	int __fastcall CompareRowsIndexed(int Col, int Row1, int Row2);
	void __fastcall QuickSortRows(int Col, int Left, int Right);
	void __fastcall QuickSortRowsIndexed(int Col, int Left, int Right);
	void __fastcall SortGroupedInt(bool Indexed);
	virtual bool __fastcall MatchFilter(int ARow);
	bool __fastcall MatchCell(int Col, int Row);
	int __fastcall MaxCharsInCol(int ACol);
	void __fastcall InputFromCSV(System::UnicodeString FileName, bool insertmode, int MaxRows = 0xffffffff);
	void __fastcall OutputToCSV(System::UnicodeString FileName, bool appendmode, bool unicode);
	void __fastcall OutputToHTML(System::UnicodeString FileName, bool appendmode, bool Show = false, bool Unicode = true);
	void __fastcall OutputToAscii(System::UnicodeString FileName, bool appendmode, bool unicode);
	System::Types::TPoint __fastcall FindInternal(const System::Types::TPoint &StartCell, System::UnicodeString s, TFindParams FindParams);
	virtual void __fastcall ResetUpdate(void);
	virtual void __fastcall UpdateGridCells(void);
	virtual void __fastcall UpdateGrid(bool Update = false);
	__property TSingleList* ColumnW = {read=FColumnW, write=SetColumnW};
	__property TSingleList* RowH = {read=FRowH, write=SetRowH};
	__property TCellProperty* CellProps[int Col][int Row] = {read=GetCellProps};
	virtual void __fastcall ExportNotification(TGridExportState AState, int ARow);
	virtual void __fastcall ImportNotification(TGridImportState AState, int ARow);
	virtual void __fastcall DoIOProgress(int CurrentRow, int TotalRows);
	virtual void __fastcall DoSortFormat(int Col, TSortFormat &SortFormat, System::UnicodeString &Prefix, System::UnicodeString &Suffix);
	virtual void __fastcall DoCustomCompare(System::UnicodeString Value1, System::UnicodeString Value2, int &res);
	virtual void __fastcall DoRawCompare(int Col, int Row1, int Row2, int &res);
	virtual void __fastcall DoClipboardBeforePasteCell(int Col, int Row, System::UnicodeString &AValue, bool &Allow);
	virtual void __fastcall DoClipboardAfterPasteCell(int Col, int Row, System::UnicodeString AValue);
	virtual void __fastcall DoNeedFilterDropDown(int Col, int Row, bool &Allow);
	virtual void __fastcall DoNeedFilterDropDownData(int Col, int Row, System::Classes::TStrings* Values);
	virtual void __fastcall DoCellsChanged(const TCellRange &Cells);
	virtual void __fastcall DoClipboardPaste(const TCellRange &Cells);
	virtual System::UnicodeString __fastcall DoSaveCell(int Col, int Row);
	virtual void __fastcall DoLoadCell(int Col, int Row, System::UnicodeString &Value);
	virtual void __fastcall DoFilterSelect(int Col, System::UnicodeString &Condition);
	void __fastcall RemoveCellControl(int Col, int Row, System::TClass AClass);
	bool __fastcall IsCellControl(int Col, int Row, System::TClass AClass);
	bool __fastcall IsIgnoredColumn(int Col);
	virtual void __fastcall Notification(System::Classes::TComponent* AComponent, System::Classes::TOperation Operation);
	virtual void __fastcall Loaded(void);
	__property System::TObject* IntObjects[int Col][int Row] = {read=GetIntObjects, write=SetIntObjects};
	__property int MergeCellPrintPageNr[int Col][int Row] = {read=GetMergeCellPrintPageNr, write=SetMergeCellPrintPageNr};
	Fmx::Graphics::TFont* __fastcall GetDefaultFont(int Col, int Row);
	void __fastcall DoOptionsChange(System::TObject* Sender);
	__property bool FixedCellSelect[int Col][int Row] = {read=GetFixedCellSelect};
	virtual void __fastcall DoFixedCellCheckBoxClick(int ACol, int ARow, Fmx::Types::TFmxObject* Cell);
	virtual void __fastcall DoFixedCellSpinBoxChange(int ACol, int ARow, Fmx::Types::TFmxObject* Cell);
	virtual void __fastcall DoFixedCellButtonClick(int ACol, int ARow, Fmx::Types::TFmxObject* Cell);
	virtual void __fastcall DoFixedCellDropDownButtonClick(int ACol, int ARow, Fmx::Types::TFmxObject* Cell);
	virtual void __fastcall DoFixedCellBitmapClick(int ACol, int ARow, Fmx::Types::TFmxObject* Cell);
	virtual void __fastcall DoGetCellReadOnly(int ACol, int ARow, bool &AReadOnly);
	virtual bool __fastcall DoGetCellIsDataCheckBox(int ACol, int ARow);
	virtual void __fastcall DoCellClick(int ACol, int ARow);
	virtual void __fastcall DoFixedCellClick(System::Classes::TShiftState Shift, int ACol, int ARow);
	virtual void __fastcall DoCellCheckBoxClick(int ACol, int ARow, Fmx::Types::TFmxObject* Cell);
	virtual void __fastcall DoCellRadioButtonClick(int ACol, int ARow, Fmx::Types::TFmxObject* Cell);
	virtual void __fastcall DoCellShowPopup(int ACol, int ARow, Fmx::Types::TFmxObject* Cell);
	virtual void __fastcall DoCellHidePopup(int ACol, int ARow, Fmx::Types::TFmxObject* Cell);
	virtual void __fastcall DoCellButtonClick(int ACol, int ARow, Fmx::Types::TFmxObject* Cell);
	virtual void __fastcall DoCellBitmapClick(int ACol, int ARow, Fmx::Types::TFmxObject* Cell);
	virtual void __fastcall DoCellCommentClick(int ACol, int ARow, Fmx::Types::TFmxObject* Cell);
	virtual void __fastcall DoCellSortClick(System::Classes::TShiftState Shift, int ACol, int ARow, Fmx::Types::TFmxObject* Cell, TSortDirection Direction);
	virtual void __fastcall DoCellNodeClick(int ACol, int ARow, Fmx::Types::TFmxObject* Cell);
	virtual void __fastcall DoGetCellIsFixed(int ACol, int ARow, bool &ACellFixed);
	virtual void __fastcall DoGetRowIsBand(int ARow, bool &ARowBand);
	virtual void __fastcall DoCanInsertRow(int ARow, bool &Allow);
	virtual void __fastcall DoCanDeleteRow(int ARow, bool &Allow);
	virtual void __fastcall DoCanAppendRow(int ARow, bool &Allow);
	virtual void __fastcall DoCanAppendColumn(int ACol, bool &Allow);
	virtual void __fastcall DoInsertRow(int ARow);
	virtual void __fastcall DoDeleteRow(int ARow);
	virtual void __fastcall DoAppendRow(int ARow);
	virtual void __fastcall DoAppendColumn(int ACol);
	virtual void __fastcall DoGetCellControl(int ACol, int ARow, Fmx::Types::TFmxObject* &AControl);
	virtual void __fastcall DoGetCellClass(int ACol, int ARow, Fmx::Types::TFmxObjectClass &CellClassType);
	virtual void __fastcall DoGetCellData(int ACol, int ARow, System::UnicodeString &CellString);
	virtual void __fastcall DoGetCellProperties(int ACol, int ARow, Fmx::Types::TFmxObject* Cell);
	virtual void __fastcall DoGetCellAppearance(int ACol, int ARow, Fmx::Types::TFmxObject* Cell, TCellState ACellState);
	virtual void __fastcall DoGetCellLayout(int ACol, int ARow, Fmx::Tmsgridcell::TTMSFMXGridCellLayout* ALayout, TCellState ACellState);
	virtual void __fastcall DoGetCellMergeInfo(int ACol, int ARow, int &ABaseCol, int &ABaseRow, int &AColSpan, int &ARowSpan);
	virtual void __fastcall DoGetCellEditorType(int ACol, int ARow, TTMSFMXGridEditorType &CellEditorType);
	virtual void __fastcall DoGetCellEditorCustomClassType(int ACol, int ARow, Fmx::Types::TFmxObjectClass &CellEditorCustomClassType);
	virtual void __fastcall DoCellEditGetData(int ACol, int ARow, Fmx::Types::TFmxObject* CellEditor, System::UnicodeString &CellString);
	virtual void __fastcall DoCellEditValidateData(int ACol, int ARow, Fmx::Types::TFmxObject* CellEditor, System::UnicodeString &CellString, bool &Allow);
	virtual void __fastcall DoCellEditSetData(int ACol, int ARow, Fmx::Types::TFmxObject* CellEditor, System::UnicodeString &CellString);
	virtual void __fastcall DoCellEditGetColor(int ACol, int ARow, Fmx::Types::TFmxObject* CellEditor, System::Uitypes::TAlphaColor &CellColor);
	virtual void __fastcall DoCellEditValidateColor(int ACol, int ARow, Fmx::Types::TFmxObject* CellEditor, System::Uitypes::TAlphaColor &CellColor, bool &Allow);
	virtual void __fastcall DoCellEditSetColor(int ACol, int ARow, Fmx::Types::TFmxObject* CellEditor, System::Uitypes::TAlphaColor &CellColor);
	virtual void __fastcall DoCellEditDone(int ACol, int ARow, Fmx::Types::TFmxObject* CellEditor);
	virtual void __fastcall DoGetCellEditorProperties(int ACol, int ARow, Fmx::Types::TFmxObject* CellEditor);
	virtual double __fastcall DoColumnCalc(int Acol, int FromRow, int ToRow);
	virtual double __fastcall DoColumnCalcGroup(int Acol, int FromRow, int ToRow);
	virtual void __fastcall DoCellAnchorClick(int ACol, int ARow, System::UnicodeString AAnchor);
	virtual void __fastcall DoCanEditCell(int ACol, int ARow, bool &Allow);
	virtual void __fastcall DoCanSizeColumn(int ACol, bool &Allow);
	virtual void __fastcall DoCanSizeRow(int ARow, bool &Allow);
	virtual void __fastcall DoColumnSize(int ACol, float &NewWidth);
	virtual void __fastcall DoRowSize(int ARow, float &NewHeight);
	virtual void __fastcall DoColumnSized(int ACol, float NewWidth);
	virtual void __fastcall DoRowSized(int ARow, float NewHeight);
	virtual void __fastcall DoCanSortColumn(int ACol, bool &Allow);
	virtual void __fastcall DoColumnSorted(int ACol, TSortDirection Direction);
	virtual bool __fastcall DoIsCellSelected(int ACol, int ARow);
	
public:
	__fastcall virtual TTMSFMXGridData(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXGridData(void);
	void __fastcall Clear(void);
	void __fastcall ClearSortColumn(void);
	void __fastcall ClearCells(const TCellRange &CellRange);
	void __fastcall Debug(void);
	int __fastcall DisplToRealRow(int Row);
	int __fastcall RealToDisplRow(int Row);
	int __fastcall DisplToRealColumn(int Col);
	int __fastcall RealToDisplColumn(int Col);
	TCellRange __fastcall GetColumnRange(int Col, bool DoFixed = false);
	TCellRange __fastcall GetRowRange(int Row, bool DoFixed = false);
	TCellRange __fastcall GetGridRange(bool DoFixed = false);
	TCellRange __fastcall GetCellRange(int Col, int Row);
	void __fastcall RandomFill(bool DoFixed = false, int rnd = 0x64);
	void __fastcall LinearFill(bool DoFixed = false);
	__property TTMSFMXGridColumns* Columns = {read=FColumns, write=SetColumns};
	__property System::UnicodeString FloatFormat = {read=FFloatFormat, write=FFloatFormat};
	__property int ColumnSelectionCount = {read=GetColumnSelectionCount, nodefault};
	__property bool ColumnSelect[int Col] = {read=GetColumnSelect, write=SetColumnSelect};
	__property int CellSelectionCount = {read=GetCellSelectionCount, nodefault};
	__property bool CellSelect[int Col][int Row] = {read=GetCellSelect, write=SetCellSelect};
	__property int SelectedRow[int index] = {read=GetSelectedRow};
	__property int SelectedColumn[int index] = {read=GetSelectedColumn};
	__property TCell SelectedCell[int index] = {read=GetSelectedCell};
	__property int RowSelectionCount = {read=GetRowSelectionCount, nodefault};
	__property bool RowSelect[int Row] = {read=GetRowSelect, write=SetRowSelect};
	__property TCellRange Selection = {read=GetSelection, write=SetSelection};
	__property TCell FocusedCell = {read=GetFocusedCell, write=SetFocusedCell};
	TCellRange __fastcall CellRange(int AStartCol, int AStartRow, int AEndCol, int AEndRow);
	TCell __fastcall SingleCell(int ACol, int ARow);
	bool __fastcall IsReadOnly(int Col, int Row);
	void __fastcall ClearRowSelect(void);
	int __fastcall GetSelectedRowCount(void);
	void __fastcall SelectRows(int FromRow, int ToRow);
	void __fastcall UnSelectRows(int FromRow, int ToRow);
	void __fastcall ClearColumnSelect(void);
	int __fastcall GetSelectedColumnCount(void);
	void __fastcall SelectColumns(int FromColumn, int ToColumn);
	void __fastcall UnSelectColumns(int FromColumn, int ToColumn);
	void __fastcall ClearCellSelect(void);
	int __fastcall GetSelectedCellCount(void);
	void __fastcall SelectCells(const TCellRange &ARange);
	void __fastcall UnSelectCells(const TCellRange &ARange);
	void __fastcall SetColumnOrder(void);
	void __fastcall ResetColumnOrder(void);
	System::UnicodeString __fastcall ColumnStatesToString(void);
	void __fastcall StringToColumnStates(System::UnicodeString Value);
	int __fastcall ColumnPosition(int ACol);
	int __fastcall ColumnAtPosition(int ACol);
	Fmx::Graphics::TBrush* __fastcall GetColumnDragLayoutFill(void);
	Fmx::Graphics::TBrush* __fastcall GetColumnDragLayoutStroke(void);
	float __fastcall GetColumnDragLayoutStrokeThickness(void);
	Fmx::Graphics::TStrokeJoin __fastcall GetColumnDragLayoutStrokeJoin(void);
	Fmx::Graphics::TStrokeDash __fastcall GetColumnDragLayoutStrokeDash(void);
	Fmx::Graphics::TStrokeCap __fastcall GetColumnDragLayoutStrokeCap(void);
	Fmx::Graphics::TBrush* __fastcall GetRowDragLayoutFill(void);
	Fmx::Graphics::TBrush* __fastcall GetRowDragLayoutStroke(void);
	float __fastcall GetRowDragLayoutStrokeThickness(void);
	Fmx::Graphics::TStrokeJoin __fastcall GetRowDragLayoutStrokeJoin(void);
	Fmx::Graphics::TStrokeDash __fastcall GetRowDragLayoutStrokeDash(void);
	Fmx::Graphics::TStrokeCap __fastcall GetRowDragLayoutStrokeCap(void);
	Fmx::Graphics::TBrush* __fastcall GetDefaultSortFill(void);
	Fmx::Graphics::TBrush* __fastcall GetDefaultIndexedSortFill(void);
	Fmx::Graphics::TBrush* __fastcall GetDefaultSortStroke(void);
	Fmx::Graphics::TBrush* __fastcall GetDefaultIndexedSortStroke(void);
	Fmx::Graphics::TFont* __fastcall GetDefaultSortFont(void);
	Fmx::Graphics::TFont* __fastcall GetDefaultIndexedSortFont(void);
	Fmx::Objects::TText* __fastcall GetDefaultSortFontFill(void);
	Fmx::Objects::TText* __fastcall GetDefaultIndexedSortFontFill(void);
	Fmx::Tmsgridcell::TTMSFMXGridCell* __fastcall GetDefaultGroupLayout(Fmx::Types::TFmxObject* AControl = (Fmx::Types::TFmxObject*)(0x0));
	Fmx::Tmsgridcell::TTMSFMXGridCell* __fastcall GetDefaultSummaryLayout(Fmx::Types::TFmxObject* AControl = (Fmx::Types::TFmxObject*)(0x0));
	Fmx::Tmsgridcell::TTMSFMXGridCell* __fastcall GetDefaultNormalLayout(Fmx::Types::TFmxObject* AControl = (Fmx::Types::TFmxObject*)(0x0));
	Fmx::Tmsgridcell::TTMSFMXGridCell* __fastcall GetDefaultSelectedLayout(Fmx::Types::TFmxObject* AControl = (Fmx::Types::TFmxObject*)(0x0));
	Fmx::Tmsgridcell::TTMSFMXGridCell* __fastcall GetDefaultFixedLayout(Fmx::Types::TFmxObject* AControl = (Fmx::Types::TFmxObject*)(0x0));
	Fmx::Tmsgridcell::TTMSFMXGridCell* __fastcall GetDefaultFocusedLayout(Fmx::Types::TFmxObject* AControl = (Fmx::Types::TFmxObject*)(0x0));
	Fmx::Tmsgridcell::TTMSFMXGridCell* __fastcall GetDefaultFixedSelectedLayout(Fmx::Types::TFmxObject* AControl = (Fmx::Types::TFmxObject*)(0x0));
	Fmx::Tmsgridcell::TTMSFMXGridCell* __fastcall GetDefaultBandLayout(Fmx::Types::TFmxObject* AControl = (Fmx::Types::TFmxObject*)(0x0));
	Fmx::Tmsbitmap::TTMSFMXBitmap* __fastcall GetDefaultDropDownBitmap(void);
	System::Types::TPoint __fastcall Find(const System::Types::TPoint &StartCell, System::UnicodeString s, TFindParams FindParams);
	System::Types::TPoint __fastcall FindFirst(System::UnicodeString s, TFindParams FindParams);
	System::Types::TPoint __fastcall FindNext(void);
	int __fastcall Replace(System::UnicodeString OrigStr, System::UnicodeString NewStr, TFindParams FindParams);
	virtual bool __fastcall IsFixed(int Col, int Row);
	virtual bool __fastcall IsBand(int Row);
	virtual bool __fastcall IsNormalFixed(int Col, int Row);
	virtual TCell __fastcall NextSelectableRow(int Col, int Row);
	virtual TCell __fastcall NextSelectableColumn(int Col, int Row);
	virtual TCell __fastcall PreviousSelectableColumn(int Col, int Row);
	virtual TCell __fastcall PreviousSelectableRow(int Col, int Row);
	void __fastcall ApplyFilter(void);
	void __fastcall RemoveFilter(void);
	__property int FindCol = {read=FFindCol, write=FFindCol, nodefault};
	__property int FindRow = {read=FFindRow, write=FFindRow, nodefault};
	int __fastcall LookupInColumn(int Col, System::UnicodeString AValue, bool AllRows = false, bool AutoGoto = false);
	int __fastcall LookupInColumnFromRow(int Col, int Row, System::UnicodeString AValue, bool AllRows = false, bool AutoGoto = false);
	__property int SortColumn = {read=FSortColumn, write=SetSortColumn, nodefault};
	__property TSortDirection SortDirection = {read=FSortDirection, write=SetSortDirection, nodefault};
	__property System::Types::TPoint IOOffset = {read=FIOOffset, write=FIOOffset};
	__property TFilter* Filter = {read=FFilter};
	void __fastcall AutoNumberCol(int Col);
	void __fastcall AutoNumberRow(int Row);
	void __fastcall AddHeaderCheckBox(int Col, int Row, bool State = false);
	void __fastcall AddCheckBox(int Col, int Row, bool State = false);
	void __fastcall AddCheckBoxColumn(int Col);
	void __fastcall RemoveCheckBox(int Col, int Row);
	bool __fastcall IsCheckBox(int Col, int Row);
	__property bool CheckBoxState[int Col][int Row] = {read=GetCheckBoxState, write=SetCheckBoxState};
	void __fastcall AddDataCheckBox(int Col, int Row, bool State = false);
	void __fastcall AddDataCheckBoxColumn(int Col);
	void __fastcall AddRadioButton(int Col, int Row, int Index, bool State = false);
	void __fastcall AddRadioButtonColumn(int Col, int Index);
	void __fastcall RemoveRadioButton(int Col, int Row);
	bool __fastcall IsRadioButton(int Col, int Row);
	bool __fastcall RadioButtonState(int Col, int Row);
	void __fastcall AddButton(int Col, int Row, System::UnicodeString AText, int AWidth = 0x18);
	bool __fastcall IsButton(int Col, int Row);
	void __fastcall RemoveButton(int Col, int Row);
	void __fastcall AddBitmap(int Col, int Row, System::UnicodeString AName)/* overload */;
	void __fastcall AddBitmap(int Col, int Row, Fmx::Graphics::TBitmap* ABitmap)/* overload */;
	void __fastcall AddBitmapFile(int Col, int Row, System::UnicodeString AFileName);
	Fmx::Graphics::TBitmap* __fastcall CreateBitmap(int Col, int Row);
	bool __fastcall CreateCheck(int Col, int Row);
	void __fastcall AddDataBitmap(int Col, int Row);
	void __fastcall RemoveBitmap(int Col, int Row);
	bool __fastcall IsBitmap(int Col, int Row);
	Fmx::Graphics::TBitmap* __fastcall GetBitmap(int Col, int Row);
	void __fastcall SetBitmapName(int Col, int Row, System::UnicodeString AName);
	System::UnicodeString __fastcall GetBitmapName(int Col, int Row);
	void __fastcall AddProgressBar(int Col, int Row, float Value);
	void __fastcall AddDataProgressBar(int Col, int Row);
	void __fastcall SetProgressBarValue(int Col, int Row, float Value);
	float __fastcall GetProgressBarValue(int Col, int Row);
	bool __fastcall IsProgressBar(int Col, int Row);
	void __fastcall RemoveProgressBar(int Col, int Row);
	void __fastcall AddSummary(int Row);
	void __fastcall RemoveSummary(int Row);
	bool __fastcall IsSummary(int Row);
	void __fastcall AddNode(int Row, int Span);
	void __fastcall RemoveNode(int Row);
	bool __fastcall IsNode(int Row);
	void __fastcall SetNodeState(int Row, Fmx::Tmsgridcell::TNodeState State);
	Fmx::Tmsgridcell::TNodeState __fastcall GetNodeState(int Row);
	void __fastcall SetNodeSpan(int Row, int Span);
	int __fastcall GetNodeSpan(int Row);
	TCellNode* __fastcall GetNode(int Row);
	void __fastcall OpenNode(int Row);
	void __fastcall CloseNode(int Row);
	void __fastcall OpenAllNodes(void);
	void __fastcall CloseAllNodes(void);
	void __fastcall AddComboBox(int Col, int Row, System::Classes::TStrings* Items, bool Editable = false);
	void __fastcall RemoveComboBox(int Col, int Row);
	bool __fastcall IsComboBox(int Col, int Row);
	int __fastcall GetComboIndex(int Col, int Row);
	void __fastcall SetComboIndex(int Col, int Row, int Value);
	void __fastcall MergeSelection(const TCellRange &ASelection);
	void __fastcall MergeCells(int Col, int Row, int ColCount, int RowCount);
	bool __fastcall IsMerged(int Col, int Row);
	bool __fastcall IsYMergedCell(int Col, int Row);
	bool __fastcall IsXMergedCell(int Col, int Row);
	bool __fastcall IsBaseCell(int Col, int Row);
	int __fastcall ColSpan(int Col, int Row);
	int __fastcall RowSpan(int Col, int Row);
	System::Types::TPoint __fastcall CellSpan(int Col, int Row);
	System::Types::TSizeF __fastcall GetCellSize(int Col, int Row);
	TCell __fastcall BaseCell(int Col, int Row);
	bool __fastcall IsBaseCellEx(int Col, int Row, int &BaseCol, int &BaseRow);
	void __fastcall SplitCell(int Col, int Row);
	void __fastcall DeleteRow(int Row);
	void __fastcall DeleteRows(int Row, int Count);
	void __fastcall InsertRow(int Row);
	void __fastcall InsertRows(int Row, int Count);
	void __fastcall SwapCells(int Col, int Row1, int Row2);
	void __fastcall SwapNormalCells(int Row1, int Row2);
	void __fastcall SwapRows(int Row1, int Row2);
	void __fastcall MoveRow(int FromRow, int ToRow);
	void __fastcall HighlightInCell(bool DoCase, int Col, int Row, System::UnicodeString HiText);
	void __fastcall HighlightInCol(bool DoFixed, bool DoCase, int Col, System::UnicodeString HiText);
	void __fastcall HighlightInRow(bool DoFixed, bool DoCase, int Row, System::UnicodeString HiText);
	void __fastcall HighlightInGrid(bool DoFixed, bool DoCase, System::UnicodeString HiText);
	void __fastcall UnHighlightInCell(int Col, int Row);
	void __fastcall UnHighlightInCol(bool DoFixed, int Col);
	void __fastcall UnHighlightInRow(bool DoFixed, int Row);
	void __fastcall UnHighlightInGrid(bool DoFixed);
	void __fastcall UnHighlightAll(void);
	void __fastcall MarkInCell(bool DoCase, int Col, int Row, System::UnicodeString HiText);
	void __fastcall MarkInCol(bool DoFixed, bool DoCase, int Col, System::UnicodeString HiText);
	void __fastcall MarkInRow(bool DoFixed, bool DoCase, int Row, System::UnicodeString HiText);
	void __fastcall MarkInGrid(bool DoFixed, bool DoCase, System::UnicodeString HiText);
	void __fastcall UnMarkInCell(int Col, int Row);
	void __fastcall UnMarkInCol(bool DoFixed, int Col);
	void __fastcall UnMarkInRow(bool DoFixed, int Row);
	void __fastcall UnMarkInGrid(bool DoFixed);
	void __fastcall UnMarkAll(void);
	void __fastcall UnGroup(void);
	void __fastcall Group(int Column);
	void __fastcall GroupCalc(int Col, int method);
	void __fastcall GroupSum(int Col);
	void __fastcall GroupAvg(int Col);
	void __fastcall GroupMin(int Col);
	void __fastcall GroupMax(int Col);
	double __fastcall ColumnSum(int ACol, int FromRow = 0xffffffff, int ToRow = 0xffffffff);
	double __fastcall ColumnAvg(int ACol, int FromRow = 0xffffffff, int ToRow = 0xffffffff);
	double __fastcall ColumnMin(int ACol, int FromRow = 0xffffffff, int ToRow = 0xffffffff);
	double __fastcall ColumnMax(int ACol, int FromRow = 0xffffffff, int ToRow = 0xffffffff);
	double __fastcall ColumnDistinct(int ACol, int FromRow = 0xffffffff, int ToRow = 0xffffffff);
	double __fastcall ColumnStdDev(int ACol, int FromRow = 0xffffffff, int ToRow = 0xffffffff);
	double __fastcall ColumnCustomCalc(int ACol, int FromRow = 0xffffffff, int ToRow = 0xffffffff);
	double __fastcall ColumnCustomCalcGroup(int ACol, int FromRow = 0xffffffff, int ToRow = 0xffffffff);
	void __fastcall UpdateCalculations(void);
	void __fastcall UpdateCalculation(int ACol);
	void __fastcall GroupCustomCalc(int Col);
	void __fastcall GroupCount(int Col);
	void __fastcall GroupDistinct(int Col);
	void __fastcall GroupStdDev(int Col);
	void __fastcall HideRow(int Row);
	void __fastcall HideRows(int Row, int Count);
	void __fastcall UnHideRow(int Row);
	void __fastcall UnHideRows(int Row, int Count);
	void __fastcall UnHideRowsAll(void);
	bool __fastcall IsHiddenRow(int Row);
	void __fastcall HideColumn(int Col);
	void __fastcall HideColumns(int Col, int Count);
	void __fastcall UnHideColumn(int Col);
	void __fastcall UnHideColumns(int Col, int Count);
	void __fastcall UnHideColumnsAll(void);
	bool __fastcall IsHiddenColumn(int Col);
	void __fastcall DeleteColumn(int Col);
	void __fastcall InsertColumn(int Col);
	void __fastcall MoveColumn(int FromCol, int ToCol);
	void __fastcall SwapColumns(int Col1, int Col2);
	void __fastcall SortData(int Column, TSortDirection Direction);
	void __fastcall SortIndexed(void);
	void __fastcall SortGrouped(int Column, TSortDirection Direction);
	void __fastcall SortGroupedIndexed(void);
	__property TSortIndexList* SortIndexes = {read=FSortIndexes};
	__property System::UnicodeString Cells[int Col][int Row] = {read=GetCells, write=SetCells};
	__property System::UnicodeString StrippedCells[int Col][int Row] = {read=GetStrippedCells};
	__property System::UnicodeString RowText[int Row] = {read=GetRowText};
	__property float ColumnWidths[int Col] = {read=GetColWidths, write=SetColWidths};
	__property float RowHeights[int Row] = {read=GetRowHeights, write=SetRowHeights};
	__property System::UnicodeString AllCells[int Col][int Row] = {read=GetAllCells, write=SetAllCells};
	__property double AllFloats[int Col][int Row] = {read=GetAllFloats, write=SetAllFloats};
	__property Fmx::Graphics::TBitmap* Bitmaps[int Col][int Row] = {read=GetBitmaps, write=SetBitmaps};
	__property bool Booleans[int Col][int Row] = {read=GetBooleans, write=SetBooleans};
	__property double Floats[int Col][int Row] = {read=GetFloats, write=SetFloats};
	__property System::Uitypes::TAlphaColor Colors[int Col][int Row] = {read=GetColors, write=SetColors};
	__property float Angles[int Col][int Row] = {read=GetAngles, write=SetAngles};
	__property Fmx::Types::TFmxObject* CellControls[int Col][int Row] = {read=GetCellControls, write=SetCellControls};
	__property Fmx::Types::TTextAlign HorzAlignments[int Col][int Row] = {read=GetHorzAlignments, write=SetHorzAlignments};
	__property Fmx::Types::TTextAlign VertAlignments[int Col][int Row] = {read=GetVertAlignments, write=SetVertAlignments};
	__property float FontSizes[int Col][int Row] = {read=GetFontSizes, write=SetFontSizes};
	__property System::Uitypes::TFontStyles FontStyles[int Col][int Row] = {read=GetFontStyles, write=SetFontStyles};
	__property System::UnicodeString FontNames[int Col][int Row] = {read=GetFontNames, write=SetFontNames};
	__property System::Uitypes::TAlphaColor FontColors[int Col][int Row] = {read=GetFontColors, write=SetFontColors};
	__property bool ReadOnlys[int Col][int Row] = {read=GetReadOnlys, write=SetReadOnlys};
	__property System::TObject* Objects[int Col][int Row] = {read=GetObjects, write=SetObjects};
	__property System::UnicodeString Comments[int Col][int Row] = {read=GetComments, write=SetComments};
	__property System::Uitypes::TAlphaColor CommentColors[int Col][int Row] = {read=GetCommentColors, write=SetCommentColors};
	__property TColumnCalculation ColumnCalculation[int Col] = {read=GetColumnCalculation, write=SetColumnCalculation};
	__property int HiddenRowCount = {read=GetHiddenRowCount, nodefault};
	__property int HiddenColumnCount = {read=GetHiddenColCount, nodefault};
	__property bool SaveHiddenCells = {read=FSaveHiddenCells, write=FSaveHiddenCells, nodefault};
	__property int TotalRowCount = {read=GetTotalRowCount, nodefault};
	__property int TotalColCount = {read=GetTotalColCount, nodefault};
	void __fastcall CopyToClipboard(bool SelectedCells = true);
	void __fastcall CutToClipboard(bool SelectedCells = true);
	void __fastcall PasteFromClipboard(void);
	void __fastcall LoadFromCSV(System::UnicodeString FileName, int MaxRows = 0xffffffff);
	void __fastcall InsertFromCSV(System::UnicodeString FileName, int MaxRows = 0xffffffff);
	void __fastcall LoadFromFile(System::UnicodeString FileName);
	void __fastcall LoadFromFixed(System::UnicodeString FileName, Fmx::Tmsgriddatautil::TIntList* positions, bool DoTrim = true, int MaxRows = 0xffffffff);
	void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	void __fastcall SaveToFile(System::UnicodeString FileName, bool Unicode = true);
	void __fastcall SaveToCSV(System::UnicodeString FileName, bool Unicode = true);
	void __fastcall AppendToCSV(System::UnicodeString FileName, bool Unicode = true);
	void __fastcall AppendToHTML(System::UnicodeString FileName, bool Show = false, bool Unicode = true);
	void __fastcall SaveToHTML(System::UnicodeString FileName, bool Show = false, bool Unicode = true);
	void __fastcall SaveToASCII(System::UnicodeString FileName, bool Unicode = true);
	void __fastcall AppendToASCII(System::UnicodeString FileName, bool Unicode = true);
	void __fastcall SaveToFixed(System::UnicodeString FileName, Fmx::Tmsgriddatautil::TIntList* Positions);
	void __fastcall SaveToStream(System::Classes::TStream* Stream);
	void __fastcall SaveToXML(System::UnicodeString FileName, System::UnicodeString ListDescr, System::UnicodeString RecordDescr, System::Classes::TStrings* FieldDescr, bool ExportEmptyCells = false);
	__property System::UnicodeString CheckTrue = {read=FCheckTrue, write=FCheckTrue};
	__property System::UnicodeString CheckFalse = {read=FCheckFalse, write=FCheckFalse};
	__property Fmx::Listbox::TListBox* FilterListbox = {read=FFilterListBox};
	__property bool UseColumns = {read=FUseColumns, write=FUseColumns, nodefault};
	
__published:
	__property Fmx::Tmsbitmapcontainer::TTMSFMXBitmapContainer* BitmapContainer = {read=FBitmapContainer, write=FBitmapContainer};
	__property float DefaultRowHeight = {read=FDefaultRowHeight, write=SetDefaultRowHeight};
	__property float DefaultColumnWidth = {read=FDefaultColumnWidth, write=SetDefaultColumnWidth};
	__property int FixedColumns = {read=FFixedColumns, write=SetFixedColumns, default=1};
	__property int FixedRows = {read=FFixedRows, write=SetFixedRows, default=1};
	__property int FixedRightColumns = {read=FFixedRightColumns, write=SetFixedRightColumns, default=0};
	__property int FixedFooterRows = {read=FFixedFooterRows, write=SetFixedFooterRows, default=0};
	__property int ColumnCount = {read=GetColumnCount, write=SetColumnCount, default=5};
	__property int RowCount = {read=GetRowCount, write=SetRowCount, default=10};
	__property TTMSFMXGridSelectionMode SelectionMode = {read=FSelectionMode, write=SetSelectionMode, default=1};
	__property TTMSFMXGridColumnCalcEvent OnColumnCalc = {read=FOnColumnCalc, write=FOnColumnCalc};
	__property TTMSFMXGridColumnCalcEvent OnGroupCalc = {read=FOnGroupCalc, write=FOnGroupCalc};
	__property TTMSFMXGridCustomCompareEvent OnCustomCompare = {read=FOnCustomCompare, write=FOnCustomCompare};
	__property TTMSFMXGridIOProgressEvent OnIOProgress = {read=FOnIOProgress, write=FOnIOProgress};
	__property TTMSFMXGridRawCompareEvent OnRawCompare = {read=FOnRawCompare, write=FOnRawCompare};
	__property TTMSFMXGridSortFormatEvent OnSortFormat = {read=FOnSortFormat, write=FOnSortFormat};
	__property TTMSFMXGridCellsChangedEvent OnCellsChanged = {read=FOnCellsChanged, write=FOnCellsChanged};
	__property TTMSFMXGridClipboardBeforePasteEvent OnClipboardBeforePasteCell = {read=FOnClipboardBeforePasteCell, write=FOnClipboardBeforePasteCell};
	__property TTMSFMXGridClipboardAfterPasteEvent OnClipboardAfterPasteCell = {read=FOnClipboardAfterPasteCell, write=FOnClipboardAfterPasteCell};
	__property TTMSFMXGridCellsChangedEvent OnClipboardPaste = {read=FOnClipboardPaste, write=FOnClipboardPaste};
	__property TTMSFMXGridNeedFilterDropDownEvent OnNeedFilterDropDown = {read=FOnNeedFilterDropDown, write=FOnNeedFilterDropDown};
	__property TTMSFMXGridNeedFilterDropDownDataEvent OnNeedFilterDropDownData = {read=FOnNeedFilterDropDownData, write=FOnNeedFilterDropDownData};
	__property TTMSFMXGridFilterSelectEvent OnFilterSelect = {read=FOnFilterSelect, write=FOnFilterSelect};
	__property TTMSFMXGridIOEvent OnLoadCell = {read=FOnLoadCell, write=FOnLoadCell};
	__property TTMSFMXGridIOEvent OnSaveCell = {read=FOnSaveCell, write=FOnSaveCell};
	__property Fmx::Tmsgridoptions::TTMSFMXGridOptions* Options = {read=FOptions, write=SetOptions};
};


//-- var, const, procedure ---------------------------------------------------
extern DELPHI_PACKAGE System::StaticArray<System::WideChar, 10> CSVSeparators;
extern DELPHI_PACKAGE TCell __fastcall Cell(int ACol, int ARow);
extern DELPHI_PACKAGE TCellRange __fastcall CellRange(int AStartCol, int AStartRow, int AEndCol, int AEndRow);
extern DELPHI_PACKAGE bool __fastcall EqualsCellRange(const TCellRange &Range1, const TCellRange &Range2);
extern DELPHI_PACKAGE bool __fastcall InCellRange(int Col, int Row, const TCellRange &Range);
}	/* namespace Tmsgriddata */
}	/* namespace Fmx */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_FMX_TMSGRIDDATA)
using namespace Fmx::Tmsgriddata;
#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_TmsgriddataHPP
