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

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

#ifndef AdvGridHPP
#define AdvGridHPP

#pragma delphiheader begin
#pragma option push -w-
#pragma option push -Vx
#include <AdvObj.hpp>	// Pascal unit
#include <AsgUni.hpp>	// Pascal unit
#include <asgdd.hpp>	// Pascal unit
#include <ImgList.hpp>	// Pascal unit
#include <ActiveX.hpp>	// Pascal unit
#include <WinSpool.hpp>	// Pascal unit
#include <ComObj.hpp>	// Pascal unit
#include <AdvXPVS.hpp>	// Pascal unit
#include <OleCtnrs.hpp>	// Pascal unit
#include <Mask.hpp>	// Pascal unit
#include <BaseGrid.hpp>	// Pascal unit
#include <AsgHTMLE.hpp>	// Pascal unit
#include <asgcheck.hpp>	// Pascal unit
#include <PictureContainer.hpp>	// Pascal unit
#include <ShellAPI.hpp>	// Pascal unit
#include <Registry.hpp>	// Pascal unit
#include <Commctrl.hpp>	// Pascal unit
#include <RichEdit.hpp>	// Pascal unit
#include <asgcombo.hpp>	// Pascal unit
#include <ComCtrls.hpp>	// Pascal unit
#include <ASGEdit.hpp>	// Pascal unit
#include <asgspin.hpp>	// Pascal unit
#include <IniFiles.hpp>	// Pascal unit
#include <ExtCtrls.hpp>	// Pascal unit
#include <AdvUtil.hpp>	// Pascal unit
#include <Buttons.hpp>	// Pascal unit
#include <StdCtrls.hpp>	// Pascal unit
#include <Forms.hpp>	// Pascal unit
#include <Printers.hpp>	// Pascal unit
#include <Dialogs.hpp>	// Pascal unit
#include <Clipbrd.hpp>	// Pascal unit
#include <Grids.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <SysUtils.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <System.hpp>	// Pascal unit

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

namespace Advgrid
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TWinCtrl;
class PASCALIMPLEMENTATION TWinCtrl : public Controls::TWinControl 
{
	typedef Controls::TWinControl inherited;
	
public:
	#pragma option push -w-inl
	/* TWinControl.Create */ inline __fastcall virtual TWinCtrl(Classes::TComponent* AOwner) : Controls::TWinControl(
		AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TWinCtrl(HWND ParentWindow) : Controls::TWinControl(
		ParentWindow) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TWinControl.Destroy */ inline __fastcall virtual ~TWinCtrl(void) { }
	#pragma option pop
	
};


typedef bool TBoolArray[513];

typedef bool *PBoolArray;

typedef short TWidthArray[513];

class DELPHICLASS EAdvGridError;
class PASCALIMPLEMENTATION EAdvGridError : public Sysutils::Exception 
{
	typedef Sysutils::Exception inherited;
	
public:
	#pragma option push -w-inl
	/* Exception.Create */ inline __fastcall EAdvGridError(const AnsiString Msg) : Sysutils::Exception(
		Msg) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateFmt */ inline __fastcall EAdvGridError(const AnsiString Msg, const System::TVarRec 
		* Args, const int Args_Size) : Sysutils::Exception(Msg, Args, Args_Size) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateRes */ inline __fastcall EAdvGridError(int Ident)/* overload */ : Sysutils::Exception(
		Ident) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmt */ inline __fastcall EAdvGridError(int Ident, const System::TVarRec * Args
		, const int Args_Size)/* overload */ : Sysutils::Exception(Ident, Args, Args_Size) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateHelp */ inline __fastcall EAdvGridError(const AnsiString Msg, int AHelpContext) : 
		Sysutils::Exception(Msg, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateFmtHelp */ inline __fastcall EAdvGridError(const AnsiString Msg, const System::TVarRec 
		* Args, const int Args_Size, int AHelpContext) : Sysutils::Exception(Msg, Args, Args_Size, AHelpContext
		) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResHelp */ inline __fastcall EAdvGridError(int Ident, int AHelpContext)/* overload */
		 : Sysutils::Exception(Ident, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmtHelp */ inline __fastcall EAdvGridError(System::PResStringRec ResStringRec
		, const System::TVarRec * Args, const int Args_Size, int AHelpContext)/* overload */ : Sysutils::Exception(
		ResStringRec, Args, Args_Size, AHelpContext) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~EAdvGridError(void) { }
	#pragma option pop
	
};


typedef Basegrid::TVAlignment TAsgVAlignment;

typedef void __fastcall (__closure *TGetEditorTypeEvent)(System::TObject* Sender, int ACol, int ARow
	, Basegrid::TEditorType &AEditor);

typedef void __fastcall (__closure *TEllipsClickEvent)(System::TObject* Sender, int ACol, int ARow, 
	AnsiString &S);

typedef void __fastcall (__closure *TButtonClickEvent)(System::TObject* Sender, int ACol, int ARow);
	

typedef void __fastcall (__closure *TCheckBoxClickEvent)(System::TObject* Sender, int ACol, int ARow
	, bool State);

typedef void __fastcall (__closure *TRadioClickEvent)(System::TObject* Sender, int ACol, int ARow, int 
	AIdx);

typedef void __fastcall (__closure *TComboChangeEvent)(System::TObject* Sender, int ACol, int ARow, 
	int AItemIndex, AnsiString ASelection);

typedef void __fastcall (__closure *TComboObjectChangeEvent)(System::TObject* Sender, int ACol, int 
	ARow, int AItemIndex, AnsiString ASelection, System::TObject* AObject);

typedef void __fastcall (__closure *TSpinClickEvent)(System::TObject* Sender, int ACol, int ARow, int 
	AValue, bool UpDown);

typedef void __fastcall (__closure *TFloatSpinClickEvent)(System::TObject* Sender, int ACol, int ARow
	, double AValue, bool UpDown);

typedef void __fastcall (__closure *TDateTimeSpinClickEvent)(System::TObject* Sender, int ACol, int 
	ARow, System::TDateTime AValue, bool UpDown);

#pragma option push -b-
enum TScrollHintType { shNone, shVertical, shHorizontal, shBoth };
#pragma option pop

#pragma option push -b-
enum TFilterOperation { foSHORT, foNONE, foAND, foXOR, foOR };
#pragma option pop

#pragma option push -b-
enum TSortStyle { ssAutomatic, ssAlphabetic, ssNumeric, ssDate, ssAlphaNoCase, ssAlphaCase, ssShortDateEU, 
	ssShortDateUS, ssCustom, ssFinancial, ssAnsiAlphaCase, ssAnsiAlphaNoCase, ssRaw, ssHTML, ssImages, 
	ssCheckBox, ssUnicode, ssAlphaNumeric, ssAlphaNumericNoCase };
#pragma option pop

#pragma option push -b-
enum TPrintPosition { ppNone, ppTopLeft, ppTopRight, ppTopCenter, ppBottomLeft, ppBottomRight, ppBottomCenter 
	};
#pragma option pop

#pragma option push -b-
enum TPrintBorders { pbNoborder, pbSingle, pbDouble, pbVertical, pbHorizontal, pbAround, pbAroundVertical, 
	pbAroundHorizontal, pbCustom };
#pragma option pop

#pragma option push -b-
enum TCellBorder { cbTop, cbLeft, cbRight, cbBottom };
#pragma option pop

typedef Set<TCellBorder, cbTop, cbBottom>  TCellBorders;

#pragma option push -b-
enum TPrintMethod { prPreview, prPrint, prCalcPrint, prCalcPreview };
#pragma option pop

#pragma option push -b-
enum TSortDirection { sdAscending, sdDescending };
#pragma option pop

#pragma option push -b-
enum TAdvanceDirection { adLeftRight, adTopBottom };
#pragma option pop

#pragma option push -b-
enum TIntelliPan { ipVertical, ipHorizontal, ipBoth, ipNone };
#pragma option pop

#pragma option push -b-
enum TInsertPosition { pInsertBefore, pInsertAfter };
#pragma option pop

#pragma option push -b-
enum TScrollType { ssNormal, ssFlat, ssEncarta };
#pragma option pop

#pragma option push -b-
enum TGridLook { glStandard, glSoft, glClassic, glTMS, glXP, glListView };
#pragma option pop

typedef void __fastcall (__closure *TCanInsertRowEvent)(System::TObject* Sender, int ARow, bool &CanInsert
	);

typedef void __fastcall (__closure *TAutoInsertRowEvent)(System::TObject* Sender, int ARow);

typedef void __fastcall (__closure *TCanAddRowEvent)(System::TObject* Sender, bool &CanAdd);

typedef void __fastcall (__closure *TAutoAddRowEvent)(System::TObject* Sender, int ARow);

typedef void __fastcall (__closure *TCanDeleteRowEvent)(System::TObject* Sender, int ARow, bool &CanDelete
	);

typedef void __fastcall (__closure *TAutoDeleteRowEvent)(System::TObject* Sender, int ARow);

typedef void __fastcall (__closure *TAutoInsertColEvent)(System::TObject* Sender, int ACol);

typedef void __fastcall (__closure *TGridProgressEvent)(System::TObject* Sender, short progress);

typedef void __fastcall (__closure *TClipboardEvent)(System::TObject* Sender, bool &Allow);

typedef void __fastcall (__closure *TClickSortEvent)(System::TObject* Sender, int ACol);

typedef void __fastcall (__closure *TCanSortEvent)(System::TObject* Sender, int ACol, bool &DoSort);
	

typedef void __fastcall (__closure *TNodeClickEvent)(System::TObject* Sender, int ARow, int ARowreal
	);

typedef void __fastcall (__closure *TNodeAllowEvent)(System::TObject* Sender, int ARow, int ARowReal
	, bool &Allow);

typedef void __fastcall (__closure *TSelectionResizeEvent)(System::TObject* Sender, const Grids::TGridRect 
	&OrigSelection, const Grids::TGridRect &NewSelection);

typedef void __fastcall (__closure *TCustomCompareEvent)(System::TObject* Sender, AnsiString str1, AnsiString 
	str2, int &Res);

typedef void __fastcall (__closure *TRawCompareEvent)(System::TObject* Sender, int ACol, int Row1, int 
	Row2, int &Res);

typedef void __fastcall (__closure *TGridFormatEvent)(System::TObject* Sender, int ACol, TSortStyle 
	&AStyle, AnsiString &aPrefix, AnsiString &aSuffix);

typedef void __fastcall (__closure *TGridColorEvent)(System::TObject* Sender, int ARow, int ACol, Grids::TGridDrawState 
	AState, Graphics::TBrush* ABrush, Graphics::TFont* AFont);

typedef void __fastcall (__closure *TGridBorderEvent)(System::TObject* Sender, int ARow, int ACol, Graphics::TPen* 
	APen, TCellBorders &Borders);

typedef void __fastcall (__closure *TGridBorderPropEvent)(System::TObject* Sender, int ARow, int ACol
	, Graphics::TPen* LeftPen, Graphics::TPen* TopPen, Graphics::TPen* RightPen, Graphics::TPen* BottomPen
	);

typedef void __fastcall (__closure *TGridAlignEvent)(System::TObject* Sender, int ARow, int ACol, Classes::TAlignment 
	&HAlign, Basegrid::TVAlignment &VAlign);

typedef void __fastcall (__closure *TGridHintEvent)(System::TObject* Sender, int ARow, int ACol, AnsiString 
	&hintstr);

typedef void __fastcall (__closure *TOleDragDropEvent)(System::TObject* Sender, int ARow, int ACol, 
	AnsiString data, bool &Allow);

typedef void __fastcall (__closure *TOleDropFileEvent)(System::TObject* Sender, int ARow, int ACol, 
	AnsiString FileName, bool &Allow);

typedef void __fastcall (__closure *TOleDragOverEvent)(System::TObject* Sender, int ARow, int ACol, 
	bool &Allow);

typedef void __fastcall (__closure *TOleDragStartEvent)(System::TObject* Sender, int ARow, int ACol)
	;

typedef void __fastcall (__closure *TOleDragStopEvent)(System::TObject* Sender, int OLEEffect);

typedef void __fastcall (__closure *TOleDropColEvent)(System::TObject* Sender, int ARow, int ACol, int 
	DropCol);

typedef void __fastcall (__closure *TOleDroppedEvent)(System::TObject* Sender, const Grids::TGridRect 
	&ARect);

typedef void __fastcall (__closure *TRowChangingEvent)(System::TObject* Sender, int OldRow, int NewRow
	, bool &Allow);

typedef void __fastcall (__closure *TRowChangedEvent)(System::TObject* Sender, int OldRow, int NewRow
	);

typedef void __fastcall (__closure *TColChangingEvent)(System::TObject* Sender, int OldCol, int NewCol
	, bool &Allow);

typedef void __fastcall (__closure *TCellChangingEvent)(System::TObject* Sender, int OldRow, int OldCol
	, int NewRow, int NewCol, bool &Allow);

typedef void __fastcall (__closure *TAutoAdvanceEvent)(System::TObject* Sender, int OldRow, int OldCol
	, int &NewRow, int &NewCol, bool &Allow);

typedef void __fastcall (__closure *TScrollHintEvent)(System::TObject* Sender, int ARow, AnsiString 
	&hintstr);

typedef void __fastcall (__closure *TGridPrintPageEvent)(System::TObject* Sender, Graphics::TCanvas* 
	Canvas, int PageNr, int PageXSize, int PageYSize);

typedef void __fastcall (__closure *TGridPrintStartEvent)(System::TObject* Sender, int NrOfPages, int 
	&FromPage, int &ToPage);

typedef void __fastcall (__closure *TGridPrintPageDoneEvent)(System::TObject* Sender, Graphics::TCanvas* 
	Canvas, int LastRow, int LastRowOffset, int LastPage, int PageXSize, int PageYSize);

typedef void __fastcall (__closure *TGridPrintCancelEvent)(System::TObject* Sender, int PageNr, bool 
	&Cancel);

typedef void __fastcall (__closure *TGridPrintNewPageEvent)(System::TObject* Sender, int ARow, bool 
	&NewPage);

typedef void __fastcall (__closure *TGridPrintColumnWidthEvent)(System::TObject* Sender, int ACol, int 
	&Width);

typedef void __fastcall (__closure *TGridPrintRowHeightEvent)(System::TObject* Sender, int ARow, int 
	&Height);

typedef void __fastcall (__closure *TOnResizeEvent)(System::TObject* Sender);

typedef void __fastcall (__closure *TColumnSizeEvent)(System::TObject* Sender, int ACol, bool &Allow
	);

typedef void __fastcall (__closure *TRowSizeEvent)(System::TObject* Sender, int ARow, bool &Allow);

typedef void __fastcall (__closure *TEndColumnSizeEvent)(System::TObject* Sender, int ACol);

typedef void __fastcall (__closure *TUpdateColumnSizeEvent)(System::TObject* Sender, int ACol, int &
	AWidth);

typedef void __fastcall (__closure *TEndRowSizeEvent)(System::TObject* Sender, int ARow);

typedef void __fastcall (__closure *TClickCellEvent)(System::TObject* Sender, int ARow, int ACol);

typedef void __fastcall (__closure *TDblClickCellEvent)(System::TObject* Sender, int ARow, int ACol)
	;

typedef void __fastcall (__closure *TCanEditCellEvent)(System::TObject* Sender, int ARow, int ACol, 
	bool &CanEdit);

typedef void __fastcall (__closure *TCanClickCellEvent)(System::TObject* Sender, int ARow, int ACol, 
	bool &Allow);

typedef void __fastcall (__closure *TIsFixedCellEvent)(System::TObject* Sender, int ARow, int ACol, 
	bool &IsFixed);

typedef void __fastcall (__closure *TIsPasswordCellEvent)(System::TObject* Sender, int ARow, int ACol
	, bool &IsPassword);

typedef void __fastcall (__closure *TAnchorClickEvent)(System::TObject* Sender, int ARow, int ACol, 
	AnsiString Anchor, bool &AutoHandle);

typedef void __fastcall (__closure *TAnchorHintEvent)(System::TObject* Sender, int ARow, int ACol, AnsiString 
	&Anchor);

typedef void __fastcall (__closure *TAnchorEvent)(System::TObject* Sender, int ARow, int ACol, AnsiString 
	Anchor);

typedef void __fastcall (__closure *TCellControlEvent)(System::TObject* Sender, int ARow, int ACol, 
	AnsiString CtrlID, AnsiString CtrlType, AnsiString CtrlVal);

typedef void __fastcall (__closure *TCellComboControlEvent)(System::TObject* Sender, int ARow, int ACol
	, AnsiString CtrlID, AnsiString CtrlType, AnsiString CtrlVal, Classes::TStringList* Values, bool &Edit
	, int &DropCount);

typedef void __fastcall (__closure *TCellValidateEvent)(System::TObject* Sender, int ACol, int ARow, 
	AnsiString &Value, bool &Valid);

typedef void __fastcall (__closure *TCellValidateWideEvent)(System::TObject* Sender, int ACol, int ARow
	, WideString &Value, bool &Valid);

typedef void __fastcall (__closure *TEditChangeEvent)(System::TObject* Sender, int ACol, int ARow, AnsiString 
	Value);

typedef void __fastcall (__closure *TDateTimeChangeEvent)(System::TObject* Sender, int ACol, int ARow
	, System::TDateTime ADateTime);

typedef void __fastcall (__closure *TCellsChangedEvent)(System::TObject* Sender, const Windows::TRect 
	&R);

typedef void __fastcall (__closure *TGetCheckEvent)(System::TObject* Sender, int ACol, int ARow, AnsiString 
	&Value);

typedef void __fastcall (__closure *TCustomCellDrawEvent)(System::TObject* Sender, Graphics::TCanvas* 
	Canvas, int ACol, int ARow, Grids::TGridDrawState AState, const Windows::TRect &ARect, bool Printing
	);

typedef void __fastcall (__closure *TCustomCellSizeEvent)(System::TObject* Sender, Graphics::TCanvas* 
	Canvas, int ACol, int ARow, Windows::TPoint &ASize, bool Printing);

typedef void __fastcall (__closure *TDoFitToPageEvent)(System::TObject* Sender, double &ScaleFactor, 
	bool &Allow);

typedef void __fastcall (__closure *TBeforeCellPasteEvent)(System::TObject* Sender, int ACol, int ARow
	, AnsiString &Value, bool &Allow);

typedef void __fastcall (__closure *TBeforeCellPasteWideEvent)(System::TObject* Sender, int ACol, int 
	ARow, WideString &Value, bool &Allow);

typedef void __fastcall (__closure *TSelectionChanged)(System::TObject* Sender, int ALeft, int ATop, 
	int ARight, int ABottom);

typedef void __fastcall (__closure *TFloatFormatEvent)(System::TObject* Sender, int ACol, int ARow, 
	bool &IsFloat, AnsiString &FloatFormat);

#pragma option push -b-
enum TFindParameters { fnMatchCase, fnMatchFull, fnMatchRegular, fnDirectionLeftRight, fnMatchStart, 
	fnFindInCurrentRow, fnFindInCurrentCol, fnIncludeFixed, fnAutoGoto, fnIgnoreHTMLTags, fnBackward, fnIncludeHiddenColumns 
	};
#pragma option pop

#pragma option push -b-
enum TCellHAlign { haLeft, haRight, haCenter, haBeforeText, haAfterText, haFull };
#pragma option pop

#pragma option push -b-
enum TCellVAlign { vaTop, vaBottom, vaCenter, vaUnderText, vaAboveText, vaFull };
#pragma option pop

#pragma option push -b-
enum TCellType { ctBitmap, ctIcon, ctNone, ctImageList, ctCheckBox, ctDataCheckBox, ctRotated, ctDataImage, 
	ctNode, ctRadio, ctEmpty, ctImages, ctPicture, ctFilePicture, ctValue, ctProgress, ctComment, ctButton, 
	ctBitButton, ctVirtCheckBox, ctRowCheckBox, ctProgressPie, ctSummary, ctRangeIndicator };
#pragma option pop

#pragma option push -b-
enum TFitToPage { fpNever, fpGrow, fpShrink, fpAlways, fpCustom };
#pragma option pop

typedef Set<TFindParameters, fnMatchCase, fnIncludeHiddenColumns>  TFindParams;

#pragma option push -b-
enum TStretchMode { noStretch, Stretch, StretchWithAspectRatio, Shrink, ShrinkWithAspectRatio };
#pragma option pop

#pragma option push -b-
enum TSortBlankPosition { blFirst, blLast };
#pragma option pop

#pragma option push -b-
enum TScrollBarAlways { saNone, saVert, saHorz, saBoth };
#pragma option pop

typedef void __fastcall (__closure *THasComboEvent)(System::TObject* Sender, int ACol, int ARow, bool 
	&HasComboBox);

#pragma option push -b-
enum TGridExportState { esExportStart, esExportNewRow, esExportDone, esExportSelRow, esExportFail };
	
#pragma option pop

#pragma option push -b-
enum TGridImportState { isImportStart, isImportNewRow, isImportDone, isImportSelRow };
#pragma option pop

typedef void __fastcall (__closure *TCalcFooterEvent)(System::TObject* Sender, int ACol, int ARow, AnsiString 
	&Value);

typedef void __fastcall (__closure *TGridBalloonEvent)(System::TObject* Sender, int ACol, int ARow, 
	AnsiString &ATitle, AnsiString &AText, int &AIcon);

typedef void __fastcall (__closure *TWordWrapEvent)(System::TObject* Sender, int ACol, int ARow, bool 
	&WordWrap);

class DELPHICLASS TDragScrollDelays;
class PASCALIMPLEMENTATION TDragScrollDelays : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	int FInitialDelay;
	int FRepeatDelay;
	
public:
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property int InitialDelay = {read=FInitialDelay, write=FInitialDelay, default=1000};
	__property int RepeatDelay = {read=FRepeatDelay, write=FRepeatDelay, default=250};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TDragScrollDelays(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TDragScrollDelays(void) : Classes::TPersistent() { }
	#pragma option pop
	
};


class DELPHICLASS TDragScrollMargins;
class PASCALIMPLEMENTATION TDragScrollMargins : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	int FTopMargin;
	int FBottomMargin;
	int FLeftMargin;
	int FRightMargin;
	
public:
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property int TopMargin = {read=FTopMargin, write=FTopMargin, default=50};
	__property int BottomMargin = {read=FBottomMargin, write=FBottomMargin, default=50};
	__property int LeftMargin = {read=FLeftMargin, write=FLeftMargin, default=50};
	__property int RightMargin = {read=FRightMargin, write=FRightMargin, default=50};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TDragScrollMargins(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TDragScrollMargins(void) : Classes::TPersistent() { }
	#pragma option pop
	
};


class DELPHICLASS TDragScrollOptions;
class PASCALIMPLEMENTATION TDragScrollOptions : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	bool FActive;
	TDragScrollDelays* FDelays;
	TDragScrollMargins* FMargins;
	
public:
	__fastcall TDragScrollOptions(void);
	__fastcall virtual ~TDragScrollOptions(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property bool Active = {read=FActive, write=FActive, nodefault};
	__property TDragScrollDelays* Delays = {read=FDelays, write=FDelays};
	__property TDragScrollMargins* Margins = {read=FMargins, write=FMargins};
};


#pragma option push -b-
enum TDragScrollDirections { dsdUp, dsdDown, dsdLeft, dsdRight };
#pragma option pop

typedef Set<TDragScrollDirections, dsdUp, dsdRight>  TDragScrollDirection;

typedef void __fastcall (__closure *TDragScrollEvent)(System::TObject* Sender, int TopRow, int LeftCol
	, TDragScrollDirection &DragScrollDir, bool &CanScroll);

class DELPHICLASS TCellGraphic;
class PASCALIMPLEMENTATION TCellGraphic : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TCellType FCellType;
	Graphics::TBitmap* FCellBitmap;
	Graphics::TIcon* FCellIcon;
	TCellVAlign FCellVAlign;
	TCellHAlign FCellHAlign;
	int FCellIndex;
	bool FCellTransparent;
	bool FCellCreated;
	bool FCellBoolean;
	int FCellAngle;
	double FCellValue;
	int FCellErrFrom;
	int FCellErrLen;
	AnsiString FCellText;
	Variant FCellVar;
	
public:
	__fastcall TCellGraphic(void);
	__fastcall virtual ~TCellGraphic(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall SetBitmap(Graphics::TBitmap* ABmp, bool Transparent, TCellHAlign hal, TCellVAlign val
		);
	void __fastcall SetPicture(Graphics::TPicture* APicture, bool Transparent, TStretchMode StretchMode
		, int padding, TCellHAlign hal, TCellVAlign val);
	void __fastcall SetFilePicture(Advobj::TFilePicture* APicture, bool Transparent, TStretchMode stretchmode
		, int padding, TCellHAlign hal, TCellVAlign val);
	void __fastcall SetImageIdx(int idx, TCellHAlign hal, TCellVAlign val);
	void __fastcall SetDataImage(int idx, TCellHAlign hal, TCellVAlign val);
	void __fastcall SetMultiImage(int Col, int Row, int dir, TCellHAlign hal, TCellVAlign val, Advobj::TImageChangeEvent 
		Notifier);
	void __fastcall SetIcon(Graphics::TIcon* aicon, TCellHAlign hal, TCellVAlign val);
	void __fastcall SetCheckBox(bool Value, bool Data, bool Flat, TCellHAlign hal, TCellVAlign val);
	void __fastcall SetAngle(short AAngle);
	void __fastcall SetButton(int bw, int bh, AnsiString caption, TCellHAlign hal, TCellVAlign val);
	void __fastcall SetBitButton(int bw, int bh, AnsiString caption, Graphics::TBitmap* Glyph, TCellHAlign 
		hal, TCellVAlign val);
	Windows::TPoint __fastcall GetPictureSize(int cw, int rh, bool hastext);
	__property Graphics::TIcon* CellIcon = {read=FCellIcon, write=FCellIcon};
	__property Graphics::TBitmap* CellBitmap = {read=FCellBitmap, write=FCellBitmap};
	__property Variant CellVar = {read=FCellVar, write=FCellVar};
	
__published:
	__property TCellType CellType = {read=FCellType, write=FCellType, nodefault};
	__property TCellVAlign CellVAlign = {read=FCellVAlign, write=FCellVAlign, nodefault};
	__property TCellHAlign CellHAlign = {read=FCellHAlign, write=FCellHAlign, nodefault};
	__property int CellIndex = {read=FCellIndex, write=FCellIndex, nodefault};
	__property bool CellTransparent = {read=FCellTransparent, write=FCellTransparent, nodefault};
	__property bool CellCreated = {read=FCellCreated, write=FCellCreated, nodefault};
	__property bool CellBoolean = {read=FCellBoolean, write=FCellBoolean, nodefault};
	__property int CellAngle = {read=FCellAngle, write=FCellAngle, nodefault};
	__property double CellValue = {read=FCellValue, write=FCellValue};
	__property int CellErrFrom = {read=FCellErrFrom, write=FCellErrFrom, nodefault};
	__property int CellErrLen = {read=FCellErrLen, write=FCellErrLen, nodefault};
	__property AnsiString CellText = {read=FCellText, write=FCellText};
};


class DELPHICLASS TBands;
class DELPHICLASS TAdvStringGrid;
class DELPHICLASS TGridDropTarget;
class PASCALIMPLEMENTATION TGridDropTarget : public Asgdd::TASGDropTarget 
{
	typedef Asgdd::TASGDropTarget inherited;
	
private:
	TAdvStringGrid* FGrid;
	
public:
	__fastcall TGridDropTarget(TAdvStringGrid* AGrid);
	virtual void __fastcall DropText(const Windows::TPoint &pt, AnsiString s);
	virtual void __fastcall DropCol(const Windows::TPoint &pt, int Col);
	virtual void __fastcall DropRTF(const Windows::TPoint &pt, AnsiString s);
	virtual void __fastcall DropFiles(const Windows::TPoint &pt, Classes::TStrings* files);
	virtual void __fastcall DragMouseMove(const Windows::TPoint &pt, bool &Allow, Asgdd::TDropFormats DropFormats
		);
	virtual void __fastcall DragMouseLeave(void);
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TGridDropTarget(void) { }
	#pragma option pop
	
};


class DELPHICLASS TBackGround;
#pragma option push -b-
enum TBackGroundDisplay { bdTile, bdFixed, bdGradientHorz, bdGradientVert };
#pragma option pop

#pragma option push -b-
enum TBackGroundCells { bcNormal, bcFixed, bcAll };
#pragma option pop

class PASCALIMPLEMENTATION TBackGround : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TAdvStringGrid* FGrid;
	int FTop;
	int FLeft;
	TBackGroundDisplay FDisplay;
	TBackGroundCells FBackgroundCells;
	Graphics::TColor FColorTo;
	Graphics::TColor FColor;
	void __fastcall SetBitmap(Graphics::TBitmap* Value);
	void __fastcall SetTop(int Value);
	void __fastcall SetLeft(int Value);
	void __fastcall SetDisplay(TBackGroundDisplay Value);
	void __fastcall SetBackGroundCells(const TBackGroundCells Value);
	void __fastcall SetColor(const Graphics::TColor Value);
	void __fastcall SetColorTo(const Graphics::TColor Value);
	Graphics::TBitmap* FBitmap;
	
public:
	__fastcall TBackGround(TAdvStringGrid* AGrid);
	__fastcall virtual ~TBackGround(void);
	
__published:
	__property int Top = {read=FTop, write=SetTop, default=0};
	__property int Left = {read=FLeft, write=SetLeft, default=0};
	__property TBackGroundDisplay Display = {read=FDisplay, write=SetDisplay, default=0};
	__property Graphics::TBitmap* Bitmap = {read=FBitmap, write=SetBitmap};
	__property TBackGroundCells Cells = {read=FBackgroundCells, write=SetBackGroundCells, default=0};
	__property Graphics::TColor Color = {read=FColor, write=SetColor, default=-2147483643};
	__property Graphics::TColor ColorTo = {read=FColorTo, write=SetColorTo, default=-2147483633};
};


class DELPHICLASS TPrintSettings;
class PASCALIMPLEMENTATION TPrintSettings : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TAdvStringGrid* FGrid;
	TPrintPosition FTime;
	TPrintPosition FDate;
	TPrintPosition FPageNr;
	AnsiString FPageNumSep;
	AnsiString FDateFormat;
	TPrintPosition FTitle;
	Graphics::TFont* FFont;
	Graphics::TFont* FHeaderFont;
	Graphics::TFont* FFooterFont;
	TPrintBorders FBorders;
	Graphics::TPenStyle FBorderStyle;
	AnsiString FTitleText;
	Classes::TStringList* FTitleLines;
	bool FCentered;
	bool FRepeatFixedRows;
	bool FRepeatFixedCols;
	int FFooterSize;
	int FHeaderSize;
	int FLeftSize;
	int FRightSize;
	int FColumnSpacing;
	int FRowSpacing;
	int FTitleSpacing;
	Printers::TPrinterOrientation FOrientation;
	AnsiString FPagePrefix;
	AnsiString FPageSuffix;
	int FFixedHeight;
	bool FUseFixedHeight;
	int FFixedWidth;
	bool FUseFixedWidth;
	TFitToPage FFitToPage;
	bool FNoAutoSize;
	bool FPrintGraphics;
	AnsiString FJobName;
	bool FNoAutoSizeRow;
	int FPageNumberOffset;
	int FMaxPagesOffset;
	Graphics::TFont* FFixedFont;
	bool FUseDisplayFont;
	bool FUseDefaultOrientation;
	bool FFixedCellsAlways;
	void __fastcall SetPrintFont(Graphics::TFont* Value);
	void __fastcall SetPrintHeaderFont(Graphics::TFont* Value);
	void __fastcall SetPrintFooterFont(Graphics::TFont* Value);
	void __fastcall SetTitleLines(Classes::TStringList* Value);
	void __fastcall SetFixedFont(const Graphics::TFont* Value);
	
public:
	__fastcall TPrintSettings(TAdvStringGrid* AOwner);
	__fastcall virtual ~TPrintSettings(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	__property bool FixedCellsAlways = {read=FFixedCellsAlways, write=FFixedCellsAlways, nodefault};
	
__published:
	__property int FooterSize = {read=FFooterSize, write=FFooterSize, default=0};
	__property int HeaderSize = {read=FHeaderSize, write=FHeaderSize, default=0};
	__property TPrintPosition Time = {read=FTime, write=FTime, default=0};
	__property TPrintPosition Date = {read=FDate, write=FDate, default=0};
	__property AnsiString DateFormat = {read=FDateFormat, write=FDateFormat};
	__property TPrintPosition PageNr = {read=FPageNr, write=FPageNr, default=0};
	__property TPrintPosition Title = {read=FTitle, write=FTitle, default=0};
	__property AnsiString TitleText = {read=FTitleText, write=FTitleText};
	__property Classes::TStringList* TitleLines = {read=FTitleLines, write=SetTitleLines};
	__property Graphics::TFont* Font = {read=FFont, write=SetPrintFont};
	__property Graphics::TFont* FixedFont = {read=FFixedFont, write=SetFixedFont};
	__property Graphics::TFont* HeaderFont = {read=FHeaderFont, write=SetPrintHeaderFont};
	__property Graphics::TFont* FooterFont = {read=FFooterFont, write=SetPrintFooterFont};
	__property TPrintBorders Borders = {read=FBorders, write=FBorders, default=1};
	__property Graphics::TPenStyle BorderStyle = {read=FBorderStyle, write=FBorderStyle, default=0};
	__property bool Centered = {read=FCentered, write=FCentered, default=1};
	__property bool RepeatFixedRows = {read=FRepeatFixedRows, write=FRepeatFixedRows, default=0};
	__property bool RepeatFixedCols = {read=FRepeatFixedCols, write=FRepeatFixedCols, default=0};
	__property int LeftSize = {read=FLeftSize, write=FLeftSize, default=0};
	__property int RightSize = {read=FRightSize, write=FRightSize, default=0};
	__property int ColumnSpacing = {read=FColumnSpacing, write=FColumnSpacing, default=0};
	__property int RowSpacing = {read=FRowSpacing, write=FRowSpacing, default=0};
	__property int TitleSpacing = {read=FTitleSpacing, write=FTitleSpacing, default=0};
	__property Printers::TPrinterOrientation Orientation = {read=FOrientation, write=FOrientation, default=0
		};
	__property AnsiString PagePrefix = {read=FPagePrefix, write=FPagePrefix, stored=true};
	__property AnsiString PageSuffix = {read=FPageSuffix, write=FPageSuffix};
	__property int PageNumberOffset = {read=FPageNumberOffset, write=FPageNumberOffset, default=0};
	__property int MaxPagesOffset = {read=FMaxPagesOffset, write=FMaxPagesOffset, default=0};
	__property int FixedWidth = {read=FFixedWidth, write=FFixedWidth, default=0};
	__property int FixedHeight = {read=FFixedHeight, write=FFixedHeight, default=0};
	__property bool UseFixedHeight = {read=FUseFixedHeight, write=FUseFixedHeight, default=0};
	__property bool UseFixedWidth = {read=FUseFixedWidth, write=FUseFixedWidth, default=0};
	__property TFitToPage FitToPage = {read=FFitToPage, write=FFitToPage, default=0};
	__property AnsiString JobName = {read=FJobName, write=FJobName};
	__property AnsiString PageNumSep = {read=FPageNumSep, write=FPageNumSep};
	__property bool NoAutoSize = {read=FNoAutoSize, write=FNoAutoSize, default=0};
	__property bool NoAutoSizeRow = {read=FNoAutoSizeRow, write=FNoAutoSizeRow, default=0};
	__property bool PrintGraphics = {read=FPrintGraphics, write=FPrintGraphics, default=0};
	__property bool UseDisplayFont = {read=FUseDisplayFont, write=FUseDisplayFont, default=1};
	__property bool UseDefaultOrientation = {read=FUseDefaultOrientation, write=FUseDefaultOrientation, 
		default=0};
};


class DELPHICLASS THTMLSettings;
class PASCALIMPLEMENTATION THTMLSettings : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	bool FAutoPreview;
	bool FConvertSpecialChars;
	bool FNonBreakingText;
	bool FSaveColor;
	bool FSaveFonts;
	AnsiString FFooterFile;
	AnsiString FHeaderFile;
	int FBorderSize;
	int FCellSpacing;
	int FCellPadding;
	AnsiString FTableStyle;
	AnsiString FPrefixTag;
	AnsiString FSuffixTag;
	int FWidth;
	Advobj::TIntList* FColWidths;
	bool FXHTML;
	
public:
	__fastcall THTMLSettings(void);
	__fastcall virtual ~THTMLSettings(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	__property Advobj::TIntList* ColWidths = {read=FColWidths};
	
__published:
	__property int BorderSize = {read=FBorderSize, write=FBorderSize, default=1};
	__property int CellSpacing = {read=FCellSpacing, write=FCellSpacing, default=0};
	__property int CellPadding = {read=FCellPadding, write=FCellPadding, default=0};
	__property bool SaveColor = {read=FSaveColor, write=FSaveColor, default=1};
	__property bool SaveFonts = {read=FSaveFonts, write=FSaveFonts, default=1};
	__property AnsiString FooterFile = {read=FFooterFile, write=FFooterFile};
	__property AnsiString HeaderFile = {read=FHeaderFile, write=FHeaderFile};
	__property AnsiString TableStyle = {read=FTableStyle, write=FTableStyle};
	__property AnsiString PrefixTag = {read=FPrefixTag, write=FPrefixTag};
	__property AnsiString SuffixTag = {read=FSuffixTag, write=FSuffixTag};
	__property int Width = {read=FWidth, write=FWidth, default=100};
	__property bool XHTML = {read=FXHTML, write=FXHTML, default=0};
	__property bool ConvertSpecialChars = {read=FConvertSpecialChars, write=FConvertSpecialChars, default=0
		};
	__property bool AutoPreview = {read=FAutoPreview, write=FAutoPreview, default=0};
	__property bool NonBreakingText = {read=FNonBreakingText, write=FNonBreakingText, default=0};
};


class DELPHICLASS TNavigation;
#pragma option push -b-
enum THomeEndAction { heFirstLastColumn, heFirstLastRow };
#pragma option pop

class PASCALIMPLEMENTATION TNavigation : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	bool FAllowInsertRow;
	bool FAllowDeleteRow;
	bool FAdvanceOnEnter;
	bool FAdvanceInsert;
	bool FAutoGotoWhenSorted;
	bool FAutoGotoIncremental;
	bool FAutoComboDropSize;
	bool FAllowClipboardShortcuts;
	bool FAllowRTFClipboard;
	bool FAllowSmartClipboard;
	bool FAllowClipboardAlways;
	bool FAllowClipboardColGrow;
	bool FAllowClipboardRowGrow;
	bool FCopyHTMLTagsToClipboard;
	TAdvanceDirection FAdvanceDirection;
	bool FAdvanceAuto;
	bool FCursorWalkEditor;
	bool FMoveRowOnSort;
	bool FImproveMaskSel;
	bool FAlwaysEdit;
	TInsertPosition FInsertPosition;
	bool FLineFeedOnEnter;
	THomeEndAction FHomeEndKey;
	bool FKeepHorizScroll;
	bool FAllowFMTClipboard;
	bool FTabToNextAtEnd;
	bool FEditSelectAll;
	TAdvanceDirection FTabAdvanceDirection;
	bool FSkipFixedCells;
	bool FAllowCtrlEnter;
	bool FAppendOnArrowDown;
	void __fastcall SetAutoGoto(bool aValue);
	
public:
	__fastcall TNavigation(void);
	__fastcall virtual ~TNavigation(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property bool AllowInsertRow = {read=FAllowInsertRow, write=FAllowInsertRow, default=0};
	__property bool AllowDeleteRow = {read=FAllowDeleteRow, write=FAllowDeleteRow, default=0};
	__property bool AlwaysEdit = {read=FAlwaysEdit, write=FAlwaysEdit, default=0};
	__property bool AdvanceOnEnter = {read=FAdvanceOnEnter, write=FAdvanceOnEnter, default=0};
	__property bool AdvanceInsert = {read=FAdvanceInsert, write=FAdvanceInsert, default=0};
	__property bool AutoGotoWhenSorted = {read=FAutoGotoWhenSorted, write=SetAutoGoto, default=0};
	__property bool AutoGotoIncremental = {read=FAutoGotoIncremental, write=FAutoGotoIncremental, default=0
		};
	__property bool AutoComboDropSize = {read=FAutoComboDropSize, write=FAutoComboDropSize, default=0};
		
	__property TAdvanceDirection AdvanceDirection = {read=FAdvanceDirection, write=FAdvanceDirection, default=0
		};
	__property bool AllowClipboardShortCuts = {read=FAllowClipboardShortcuts, write=FAllowClipboardShortcuts
		, default=0};
	__property bool AllowCtrlEnter = {read=FAllowCtrlEnter, write=FAllowCtrlEnter, default=1};
	__property bool AllowSmartClipboard = {read=FAllowSmartClipboard, write=FAllowSmartClipboard, default=0
		};
	__property bool AllowRTFClipboard = {read=FAllowRTFClipboard, write=FAllowRTFClipboard, default=0};
		
	__property bool AllowFmtClipboard = {read=FAllowFMTClipboard, write=FAllowFMTClipboard, default=0};
		
	__property bool AllowClipboardAlways = {read=FAllowClipboardAlways, write=FAllowClipboardAlways, default=0
		};
	__property bool AllowClipboardRowGrow = {read=FAllowClipboardRowGrow, write=FAllowClipboardRowGrow, 
		default=1};
	__property bool AllowClipboardColGrow = {read=FAllowClipboardColGrow, write=FAllowClipboardColGrow, 
		default=1};
	__property bool AdvanceAuto = {read=FAdvanceAuto, write=FAdvanceAuto, default=0};
	__property bool AppendOnArrowDown = {read=FAppendOnArrowDown, write=FAppendOnArrowDown, default=0};
		
	__property bool EditSelectAll = {read=FEditSelectAll, write=FEditSelectAll, default=1};
	__property TInsertPosition InsertPosition = {read=FInsertPosition, write=FInsertPosition, default=0
		};
	__property bool CursorWalkEditor = {read=FCursorWalkEditor, write=FCursorWalkEditor, default=0};
	__property bool MoveRowOnSort = {read=FMoveRowOnSort, write=FMoveRowOnSort, default=0};
	__property bool ImproveMaskSel = {read=FImproveMaskSel, write=FImproveMaskSel, default=0};
	__property bool CopyHTMLTagsToClipboard = {read=FCopyHTMLTagsToClipboard, write=FCopyHTMLTagsToClipboard
		, default=1};
	__property bool KeepHorizScroll = {read=FKeepHorizScroll, write=FKeepHorizScroll, default=0};
	__property bool LineFeedOnEnter = {read=FLineFeedOnEnter, write=FLineFeedOnEnter, default=0};
	__property THomeEndAction HomeEndKey = {read=FHomeEndKey, write=FHomeEndKey, default=0};
	__property bool SkipFixedCells = {read=FSkipFixedCells, write=FSkipFixedCells, default=1};
	__property bool TabToNextAtEnd = {read=FTabToNextAtEnd, write=FTabToNextAtEnd, default=0};
	__property TAdvanceDirection TabAdvanceDirection = {read=FTabAdvanceDirection, write=FTabAdvanceDirection
		, default=0};
};


class DELPHICLASS TColumnSize;
#pragma option push -b-
enum TColumnSizeLocation { clRegistry, clIniFile };
#pragma option pop

class PASCALIMPLEMENTATION TColumnSize : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	Classes::TComponent* Owner;
	bool FSave;
	AnsiString FKey;
	AnsiString FSection;
	bool FStretch;
	int FStretchColumn;
	bool FSynchWithGrid;
	TColumnSizeLocation FLocation;
	void __fastcall SetStretch(bool Value);
	
public:
	__fastcall TColumnSize(Classes::TComponent* AOwner);
	__fastcall virtual ~TColumnSize(void);
	
__published:
	__property bool Save = {read=FSave, write=FSave, default=0};
	__property AnsiString Key = {read=FKey, write=FKey};
	__property AnsiString Section = {read=FSection, write=FSection};
	__property bool Stretch = {read=FStretch, write=SetStretch, default=0};
	__property int StretchColumn = {read=FStretchColumn, write=FStretchColumn, default=-1};
	__property bool SynchWithGrid = {read=FSynchWithGrid, write=FSynchWithGrid, default=0};
	__property TColumnSizeLocation Location = {read=FLocation, write=FLocation, default=0};
};


class DELPHICLASS TCellNode;
#pragma option push -b-
enum TNodeType { cnFlat, cn3D, cnGlyph, cnLeaf, cnXP };
#pragma option pop

class PASCALIMPLEMENTATION TCellNode : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	Graphics::TColor FColor;
	TNodeType FNodeType;
	Graphics::TColor FNodeColor;
	Graphics::TBitmap* FExpandGlyph;
	bool FExpandOne;
	Graphics::TBitmap* FContractGlyph;
	TAdvStringGrid* FOwner;
	bool FShowTree;
	bool FShowTreeFull;
	int FNodeIndent;
	Graphics::TColor FTreeColor;
	void __fastcall SetExpandGlyph(Graphics::TBitmap* Value);
	void __fastcall SetContractGlyph(Graphics::TBitmap* Value);
	void __fastcall SetNodeType(TNodeType Value);
	void __fastcall SetShowTree(const bool Value);
	void __fastcall SetShowTreeFull(const bool Value);
	void __fastcall SetNodeIndent(const int Value);
	void __fastcall SetTreeColor(const Graphics::TColor Value);
	
public:
	__fastcall TCellNode(TAdvStringGrid* AOwner);
	__fastcall virtual ~TCellNode(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property Graphics::TColor Color = {read=FColor, write=FColor, default=12632256};
	__property bool ExpandOne = {read=FExpandOne, write=FExpandOne, default=0};
	__property TNodeType NodeType = {read=FNodeType, write=SetNodeType, default=4};
	__property Graphics::TColor NodeColor = {read=FNodeColor, write=FNodeColor, default=0};
	__property int NodeIndent = {read=FNodeIndent, write=SetNodeIndent, default=12};
	__property Graphics::TBitmap* ExpandGlyph = {read=FExpandGlyph, write=SetExpandGlyph};
	__property Graphics::TBitmap* ContractGlyph = {read=FContractGlyph, write=SetContractGlyph};
	__property bool ShowTree = {read=FShowTree, write=SetShowTree, default=1};
	__property bool ShowTreeFull = {read=FShowTreeFull, write=SetShowTreeFull, default=1};
	__property Graphics::TColor TreeColor = {read=FTreeColor, write=SetTreeColor, default=8421504};
};


class DELPHICLASS TSizeWhileTyping;
class PASCALIMPLEMENTATION TSizeWhileTyping : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	bool FHeight;
	bool FWidth;
	
public:
	__fastcall TSizeWhileTyping(void);
	__fastcall virtual ~TSizeWhileTyping(void);
	
__published:
	__property bool Height = {read=FHeight, write=FHeight, default=0};
	__property bool Width = {read=FWidth, write=FWidth, default=0};
};


class DELPHICLASS TMouseActions;
#pragma option push -b-
enum TGridFixedCellEdit { fceNone, fceDblClick, fceLeftClick, fceRightClick };
#pragma option pop

#pragma option push -b-
enum TWheelAction { waMoveSelection, waScroll };
#pragma option pop

class PASCALIMPLEMENTATION TMouseActions : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TAdvStringGrid* FGrid;
	bool FColSelect;
	bool FRowSelect;
	bool FAllSelect;
	bool FDirectEdit;
	bool FDirectComboDrop;
	bool FDirectDateDrop;
	bool FDisjunctRowSelect;
	bool FDisjunctColSelect;
	bool FAllColumnSize;
	bool FAllRowSize;
	bool FCaretPositioning;
	bool FSizeFixedCol;
	bool FSizeFixedRow;
	bool FDisjunctCellSelect;
	TGridFixedCellEdit FFixedRowsEdit;
	TGridFixedCellEdit FFixedColsEdit;
	bool FHotmailRowSelect;
	bool FRangeSelectAndEdit;
	bool FNoAutoRangeScroll;
	bool FPreciseCheckBoxCheck;
	bool FCheckAllCheck;
	bool FNodeAllExpandContract;
	bool FMoveRowOnNodeClick;
	bool FRowSelectPersistent;
	bool FSelectOnRightClick;
	bool FNoScrollOnPartialRow;
	int FWheelIncrement;
	TWheelAction FWheelAction;
	bool FAutoSizeColOnDblClick;
	void __fastcall SetDisjunctColSelect(const bool AValue);
	void __fastcall SetDisjunctRowSelect(const bool AValue);
	void __fastcall SetDisjunctCellSelect(const bool AValue);
	void __fastcall SetHotmailRowSelect(const bool AValue);
	
public:
	__fastcall TMouseActions(Classes::TComponent* AOwner);
	__fastcall virtual ~TMouseActions(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property bool AllColumnSize = {read=FAllColumnSize, write=FAllColumnSize, default=0};
	__property bool AllRowSize = {read=FAllRowSize, write=FAllRowSize, default=0};
	__property bool AllSelect = {read=FAllSelect, write=FAllSelect, default=0};
	__property bool AutoSizeColOnDblClick = {read=FAutoSizeColOnDblClick, write=FAutoSizeColOnDblClick, 
		default=1};
	__property bool CaretPositioning = {read=FCaretPositioning, write=FCaretPositioning, default=0};
	__property bool CheckAllCheck = {read=FCheckAllCheck, write=FCheckAllCheck, default=0};
	__property bool ColSelect = {read=FColSelect, write=FColSelect, default=0};
	__property bool DirectComboDrop = {read=FDirectComboDrop, write=FDirectComboDrop, default=0};
	__property bool DirectDateDrop = {read=FDirectDateDrop, write=FDirectDateDrop, default=0};
	__property bool DirectEdit = {read=FDirectEdit, write=FDirectEdit, default=0};
	__property bool DisjunctRowSelect = {read=FDisjunctRowSelect, write=SetDisjunctRowSelect, default=0
		};
	__property bool DisjunctColSelect = {read=FDisjunctColSelect, write=SetDisjunctColSelect, default=0
		};
	__property bool DisjunctCellSelect = {read=FDisjunctCellSelect, write=SetDisjunctCellSelect, default=0
		};
	__property TGridFixedCellEdit FixedRowsEdit = {read=FFixedRowsEdit, write=FFixedRowsEdit, default=0
		};
	__property TGridFixedCellEdit FixedColsEdit = {read=FFixedColsEdit, write=FFixedColsEdit, default=0
		};
	__property bool HotmailRowSelect = {read=FHotmailRowSelect, write=SetHotmailRowSelect, default=0};
	__property bool MoveRowOnNodeClick = {read=FMoveRowOnNodeClick, write=FMoveRowOnNodeClick, default=0
		};
	__property bool NoAutoRangeScroll = {read=FNoAutoRangeScroll, write=FNoAutoRangeScroll, default=0};
		
	__property bool NodeAllExpandContract = {read=FNodeAllExpandContract, write=FNodeAllExpandContract, 
		default=0};
	__property bool NoScrollOnPartialRow = {read=FNoScrollOnPartialRow, write=FNoScrollOnPartialRow, default=0
		};
	__property bool PreciseCheckBoxCheck = {read=FPreciseCheckBoxCheck, write=FPreciseCheckBoxCheck, default=0
		};
	__property bool RangeSelectAndEdit = {read=FRangeSelectAndEdit, write=FRangeSelectAndEdit, default=0
		};
	__property bool RowSelect = {read=FRowSelect, write=FRowSelect, default=0};
	__property bool RowSelectPersistent = {read=FRowSelectPersistent, write=FRowSelectPersistent, default=0
		};
	__property bool SelectOnRightClick = {read=FSelectOnRightClick, write=FSelectOnRightClick, default=0
		};
	__property bool SizeFixedCol = {read=FSizeFixedCol, write=FSizeFixedCol, default=0};
	__property bool SizeFixedRow = {read=FSizeFixedRow, write=FSizeFixedRow, default=0};
	__property int WheelIncrement = {read=FWheelIncrement, write=FWheelIncrement, default=0};
	__property TWheelAction WheelAction = {read=FWheelAction, write=FWheelAction, default=0};
};


class DELPHICLASS TGrouping;
class PASCALIMPLEMENTATION TGrouping : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	bool FMergeHeader;
	bool FMergeSummary;
	Graphics::TColor FHeaderColor;
	Graphics::TColor FSummaryColor;
	Graphics::TColor FHeaderColorTo;
	Graphics::TColor FHeaderTextColor;
	bool FSummary;
	Graphics::TColor FSummaryTextColor;
	Graphics::TColor FSummaryColorTo;
	bool FHeaderUnderline;
	bool FSummaryLine;
	int FSummaryLineWidth;
	int FHeaderLineWidth;
	Graphics::TColor FSummaryLineColor;
	Graphics::TColor FHeaderLineColor;
	
public:
	__fastcall TGrouping(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property Graphics::TColor HeaderColor = {read=FHeaderColor, write=FHeaderColor, default=536870911
		};
	__property Graphics::TColor HeaderColorTo = {read=FHeaderColorTo, write=FHeaderColorTo, default=536870911
		};
	__property Graphics::TColor HeaderTextColor = {read=FHeaderTextColor, write=FHeaderTextColor, default=536870911
		};
	__property bool HeaderUnderline = {read=FHeaderUnderline, write=FHeaderUnderline, default=0};
	__property Graphics::TColor HeaderLineColor = {read=FHeaderLineColor, write=FHeaderLineColor, default=16711680
		};
	__property int HeaderLineWidth = {read=FHeaderLineWidth, write=FHeaderLineWidth, default=2};
	__property bool MergeHeader = {read=FMergeHeader, write=FMergeHeader, default=0};
	__property bool MergeSummary = {read=FMergeSummary, write=FMergeSummary, default=0};
	__property bool Summary = {read=FSummary, write=FSummary, default=0};
	__property Graphics::TColor SummaryColor = {read=FSummaryColor, write=FSummaryColor, default=536870911
		};
	__property Graphics::TColor SummaryColorTo = {read=FSummaryColorTo, write=FSummaryColorTo, default=536870911
		};
	__property Graphics::TColor SummaryTextColor = {read=FSummaryTextColor, write=FSummaryTextColor, default=536870911
		};
	__property bool SummaryLine = {read=FSummaryLine, write=FSummaryLine, default=0};
	__property Graphics::TColor SummaryLineColor = {read=FSummaryLineColor, write=FSummaryLineColor, default=16711680
		};
	__property int SummaryLineWidth = {read=FSummaryLineWidth, write=FSummaryLineWidth, default=2};
public:
		
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TGrouping(void) { }
	#pragma option pop
	
};


class DELPHICLASS TAdvRichEdit;
class PASCALIMPLEMENTATION TAdvRichEdit : public Comctrls::TRichEdit 
{
	typedef Comctrls::TRichEdit inherited;
	
private:
	TAdvStringGrid* FGrid;
	int FReqHeight;
	int FReqWidth;
	bool FLocked;
	void __fastcall SelFormat(int offset);
	HIDESBASE MESSAGE void __fastcall WMKillFocus(Messages::TMessage &Msg);
	HIDESBASE MESSAGE void __fastcall CNNotify(Messages::TWMNotify &Msg);
	
protected:
	void __fastcall Lock(void);
	void __fastcall Unlock(void);
	DYNAMIC void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
	
public:
	__fastcall virtual TAdvRichEdit(Classes::TComponent* AOwner);
	void __fastcall SelSubscript(void);
	void __fastcall SelSuperscript(void);
	void __fastcall SelNormal(void);
	bool __fastcall IsSelSubscript(void);
	bool __fastcall IsSelSuperscript(void);
	bool __fastcall IsSelNormal(void);
	
__published:
	__property int ReqWidth = {read=FReqWidth, nodefault};
	__property int ReqHeight = {read=FReqHeight, nodefault};
public:
	#pragma option push -w-inl
	/* TCustomRichEdit.Destroy */ inline __fastcall virtual ~TAdvRichEdit(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TAdvRichEdit(HWND ParentWindow) : Comctrls::TRichEdit(
		ParentWindow) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TMouseSelectMode { msNormal, msColumn, msRow, msAll, msURL, msResize };
#pragma option pop

class DELPHICLASS TEditLink;
typedef void __fastcall (__closure *TGetEditorPropEvent)(System::TObject* Sender, int ACol, int ARow
	, TEditLink* AEditLink);

class DELPHICLASS TControlEdit;
class PASCALIMPLEMENTATION TControlEdit : public Mask::TMaskEdit 
{
	typedef Mask::TMaskEdit inherited;
	
private:
	HIDESBASE MESSAGE void __fastcall WMKeyDown(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall CMWantSpecialKey(Messages::TWMKey &Msg);
	
protected:
	DYNAMIC void __fastcall KeyPress(char &Key);
public:
	#pragma option push -w-inl
	/* TCustomMaskEdit.Create */ inline __fastcall virtual TControlEdit(Classes::TComponent* AOwner) : 
		Mask::TMaskEdit(AOwner) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TControlEdit(HWND ParentWindow) : Mask::TMaskEdit(
		ParentWindow) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TWinControl.Destroy */ inline __fastcall virtual ~TControlEdit(void) { }
	#pragma option pop
	
};


class DELPHICLASS TControlCombo;
class PASCALIMPLEMENTATION TControlCombo : public Asgcombo::TASGComboBox 
{
	typedef Asgcombo::TASGComboBox inherited;
	
private:
	MESSAGE void __fastcall CMWantSpecialKey(Messages::TWMKey &Msg);
	
protected:
	DYNAMIC void __fastcall KeyPress(char &Key);
public:
	#pragma option push -w-inl
	/* TASGCustomCombo.Create */ inline __fastcall virtual TControlCombo(Classes::TComponent* AOwner) : 
		Asgcombo::TASGComboBox(AOwner) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TCustomComboBox.Destroy */ inline __fastcall virtual ~TControlCombo(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TControlCombo(HWND ParentWindow) : Asgcombo::TASGComboBox(
		ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TGridCombo;
class PASCALIMPLEMENTATION TGridCombo : public Asgcombo::TASGComboBox 
{
	typedef Asgcombo::TASGComboBox inherited;
	
private:
	bool Forced;
	bool WorkMode;
	int ItemIdx;
	Classes::TNotifyEvent FOnReturnKey;
	bool ItemChange;
	MESSAGE void __fastcall CMWantSpecialKey(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMSetFocus(Messages::TWMSetFocus &Msg);
	
protected:
	DYNAMIC void __fastcall KeyPress(char &Key);
	DYNAMIC void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall KeyUp(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall DoExit(void);
	virtual void __fastcall WndProc(Messages::TMessage &Message);
	
public:
	TAdvStringGrid* FGrid;
	void __fastcall DoChange(void);
	__fastcall virtual TGridCombo(Classes::TComponent* AOwner);
	void __fastcall SizeDropDownWidth(void);
	
__published:
	__property Classes::TNotifyEvent OnReturnKey = {read=FOnReturnKey, write=FOnReturnKey};
public:
	#pragma option push -w-inl
	/* TCustomComboBox.Destroy */ inline __fastcall virtual ~TGridCombo(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TGridCombo(HWND ParentWindow) : Asgcombo::TASGComboBox(
		ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TGridSpin;
class PASCALIMPLEMENTATION TGridSpin : public Asgspin::TAsgSpinEdit 
{
	typedef Asgspin::TAsgSpinEdit inherited;
	
private:
	HIDESBASE MESSAGE void __fastcall CMWantSpecialKey(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMChar(Messages::TWMKey &Msg);
	
protected:
	void __fastcall DoClick(bool UpDown);
	virtual void __fastcall UpClick(System::TObject* Sender);
	virtual void __fastcall DownClick(System::TObject* Sender);
	DYNAMIC void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall KeyUp(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall KeyPress(char &Key);
	DYNAMIC void __fastcall DoExit(void);
	
public:
	TAdvStringGrid* FGrid;
	__fastcall virtual TGridSpin(Classes::TComponent* AOwner);
public:
	#pragma option push -w-inl
	/* TAsgSpinEdit.Destroy */ inline __fastcall virtual ~TGridSpin(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TGridSpin(HWND ParentWindow) : Asgspin::TAsgSpinEdit(
		ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TGridTransEdit;
class PASCALIMPLEMENTATION TGridTransEdit : public Stdctrls::TCustomEdit 
{
	typedef Stdctrls::TCustomEdit inherited;
	
private:
	int FRow;
	int FCol;
	
protected:
	DYNAMIC void __fastcall KeyPress(char &Key);
	DYNAMIC void __fastcall DoExit(void);
	
public:
	TAdvStringGrid* FGrid;
	__fastcall virtual TGridTransEdit(Classes::TComponent* AOwner);
	bool __fastcall StopEdit(void);
	__property BorderStyle ;
	
__published:
	__property int Col = {read=FCol, write=FCol, nodefault};
	__property int Row = {read=FRow, write=FRow, nodefault};
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TGridTransEdit(HWND ParentWindow) : Stdctrls::TCustomEdit(
		ParentWindow) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TWinControl.Destroy */ inline __fastcall virtual ~TGridTransEdit(void) { }
	#pragma option pop
	
};


class DELPHICLASS TGridUniEdit;
class PASCALIMPLEMENTATION TGridUniEdit : public Asguni::TAsgUniEdit 
{
	typedef Asguni::TAsgUniEdit inherited;
	
private:
	MESSAGE void __fastcall CMWantSpecialKey(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMChar(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMSetFocus(Messages::TWMSetFocus &Msg);
	
protected:
	DYNAMIC void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall KeyPress(char &Key);
	DYNAMIC void __fastcall DoExit(void);
	
public:
	TAdvStringGrid* FGrid;
	__fastcall virtual TGridUniEdit(Classes::TComponent* AOwner);
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TGridUniEdit(HWND ParentWindow) : Asguni::TAsgUniEdit(
		ParentWindow) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TWinControl.Destroy */ inline __fastcall virtual ~TGridUniEdit(void) { }
	#pragma option pop
	
};


class DELPHICLASS TGridUniCombo;
class PASCALIMPLEMENTATION TGridUniCombo : public Asguni::TASGUniComboBox 
{
	typedef Asguni::TASGUniComboBox inherited;
	
private:
	bool Forced;
	bool WorkMode;
	int ItemIdx;
	Classes::TNotifyEvent FOnReturnKey;
	bool ItemChange;
	MESSAGE void __fastcall CMWantSpecialKey(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMSetFocus(Messages::TWMSetFocus &Msg);
	
protected:
	DYNAMIC void __fastcall KeyPress(char &Key);
	DYNAMIC void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall KeyUp(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall DoExit(void);
	virtual void __fastcall WndProc(Messages::TMessage &Message);
	
public:
	TAdvStringGrid* FGrid;
	void __fastcall DoChange(void);
	__fastcall virtual TGridUniCombo(Classes::TComponent* AOwner);
	void __fastcall SizeDropDownWidth(void);
	
__published:
	__property Classes::TNotifyEvent OnReturnKey = {read=FOnReturnKey, write=FOnReturnKey};
public:
	#pragma option push -w-inl
	/* TCustomUNIComboBox.Destroy */ inline __fastcall virtual ~TGridUniCombo(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TGridUniCombo(HWND ParentWindow) : Asguni::TASGUniComboBox(
		ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TGridUniEditBtn;
class PASCALIMPLEMENTATION TGridUniEditBtn : public Asguni::TAsgUniEditBtn 
{
	typedef Asguni::TAsgUniEditBtn inherited;
	
private:
	MESSAGE void __fastcall CMWantSpecialKey(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMChar(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMSetFocus(Messages::TWMSetFocus &Msg);
	
protected:
	DYNAMIC void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall KeyPress(char &Key);
	DYNAMIC void __fastcall DoExit(void);
	
public:
	TAdvStringGrid* FGrid;
	__fastcall virtual TGridUniEditBtn(Classes::TComponent* AOwner);
public:
	#pragma option push -w-inl
	/* TAsgUniEditBtn.Destroy */ inline __fastcall virtual ~TGridUniEditBtn(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TGridUniEditBtn(HWND ParentWindow) : Asguni::TAsgUniEditBtn(
		ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TGridCheckBox;
class PASCALIMPLEMENTATION TGridCheckBox : public Stdctrls::TCheckBox 
{
	typedef Stdctrls::TCheckBox inherited;
	
private:
	HIDESBASE MESSAGE void __fastcall WMLButtonDown(Messages::TWMMouse &Msg);
	
protected:
	DYNAMIC void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall DoExit(void);
	
public:
	TAdvStringGrid* FGrid;
	__fastcall virtual TGridCheckBox(Classes::TComponent* AOwner);
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TGridCheckBox(HWND ParentWindow) : Stdctrls::TCheckBox(
		ParentWindow) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TWinControl.Destroy */ inline __fastcall virtual ~TGridCheckBox(void) { }
	#pragma option pop
	
};


class DELPHICLASS TGridEditBtn;
class PASCALIMPLEMENTATION TGridEditBtn : public Asgedit::TAsgEditBtn 
{
	typedef Asgedit::TAsgEditBtn inherited;
	
private:
	TAdvStringGrid* FGrid;
	HIDESBASE MESSAGE void __fastcall WMChar(Messages::TWMKey &Msg);
	MESSAGE void __fastcall CMWantSpecialKey(Messages::TWMKey &Msg);
	
protected:
	void __fastcall ExtClick(System::TObject* Sender);
	DYNAMIC void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall KeyPress(char &Key);
	DYNAMIC void __fastcall DoExit(void);
	
public:
	__fastcall virtual TGridEditBtn(Classes::TComponent* AOwner);
public:
	#pragma option push -w-inl
	/* TAsgEditBtn.Destroy */ inline __fastcall virtual ~TGridEditBtn(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TGridEditBtn(HWND ParentWindow) : Asgedit::TAsgEditBtn(
		ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TGridUnitEditBtn;
class PASCALIMPLEMENTATION TGridUnitEditBtn : public Asgedit::TAsgUnitEditBtn 
{
	typedef Asgedit::TAsgUnitEditBtn inherited;
	
private:
	TAdvStringGrid* FGrid;
	HIDESBASE MESSAGE void __fastcall WMChar(Messages::TWMKey &Msg);
	MESSAGE void __fastcall CMWantSpecialKey(Messages::TWMKey &Msg);
	
protected:
	DYNAMIC void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall DoExit(void);
	
public:
	__fastcall virtual TGridUnitEditBtn(Classes::TComponent* AOwner);
public:
	#pragma option push -w-inl
	/* TAsgUnitEditBtn.Destroy */ inline __fastcall virtual ~TGridUnitEditBtn(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TGridUnitEditBtn(HWND ParentWindow) : Asgedit::TAsgUnitEditBtn(
		ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TGridDatePicker;
class PASCALIMPLEMENTATION TGridDatePicker : public Comctrls::TDateTimePicker 
{
	typedef Comctrls::TDateTimePicker inherited;
	
private:
	bool FOldDropped;
	MESSAGE void __fastcall CMWantSpecialKey(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall CNNotify(Messages::TWMNotify &Message);
	HIDESBASE MESSAGE void __fastcall WMNCPaint(Messages::TMessage &Message);
	
protected:
	virtual void __fastcall WndProc(Messages::TMessage &Message);
	DYNAMIC void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall DoExit(void);
	
public:
	TAdvStringGrid* FGrid;
	__fastcall virtual TGridDatePicker(Classes::TComponent* AOwner);
public:
	#pragma option push -w-inl
	/* TCommonCalendar.Destroy */ inline __fastcall virtual ~TGridDatePicker(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TGridDatePicker(HWND ParentWindow) : Comctrls::TDateTimePicker(
		ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TGridButton;
class PASCALIMPLEMENTATION TGridButton : public Stdctrls::TButton 
{
	typedef Stdctrls::TButton inherited;
	
private:
	TAdvStringGrid* FGrid;
	
protected:
	MESSAGE void __fastcall CMWantSpecialKey(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMLButtonUp(Messages::TWMMouse &Msg);
	DYNAMIC void __fastcall KeyUp(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall DoExit(void);
	virtual void __fastcall CreateParams(Controls::TCreateParams &Params);
	
public:
	__fastcall virtual TGridButton(Classes::TComponent* AOwner);
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TGridButton(HWND ParentWindow) : Stdctrls::TButton(
		ParentWindow) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TWinControl.Destroy */ inline __fastcall virtual ~TGridButton(void) { }
	#pragma option pop
	
};


class DELPHICLASS TFilter;
class DELPHICLASS TFilterData;
class PASCALIMPLEMENTATION TFilter : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
private:
	TAdvStringGrid* FOwner;
	HIDESBASE TFilterData* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, TFilterData* Value);
	TFilterData* __fastcall GetColFilter(int Col);
	
public:
	__fastcall TFilter(TAdvStringGrid* AOwner);
	HIDESBASE TFilterData* __fastcall Add(void);
	HIDESBASE TFilterData* __fastcall Insert(int index);
	__property TFilterData* Items[int Index] = {read=GetItem, write=SetItem};
	__property TFilterData* ColumnFilter[int Col] = {read=GetColFilter};
	
protected:
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TFilter(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSortSettings;
class PASCALIMPLEMENTATION TSortSettings : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TAdvStringGrid* FGrid;
	bool FSortShow;
	bool FSortIndexShow;
	bool FSortFull;
	bool FSortSingleColumn;
	bool FSortIgnoreBlanks;
	TSortBlankPosition FSortBlankPos;
	bool FSortAutoFormat;
	TSortDirection FSortDirection;
	Graphics::TBitmap* FSortUpGlyph;
	Graphics::TBitmap* FSortDownGlyph;
	Graphics::TBitmap* FIndexUpGlyph;
	Graphics::TBitmap* FIndexDownGlyph;
	bool FSortNormalCellsOnly;
	bool FSortFixedCols;
	int FSortColumn;
	int FSortRow;
	bool FAutoColumnMerge;
	Graphics::TColor FSortIndexColor;
	TSortDirection FInitSortDirection;
	bool FUndoSort;
	bool FAutoSortForGrouping;
	Graphics::TBitmap* __fastcall GetDownGlyph(void);
	Graphics::TBitmap* __fastcall GetUpGlyph(void);
	void __fastcall SetDownGlyph(const Graphics::TBitmap* Value);
	void __fastcall SetUpGlyph(const Graphics::TBitmap* Value);
	void __fastcall SetSortRow(const int Value);
	void __fastcall SetIndexDownGlyph(const Graphics::TBitmap* Value);
	void __fastcall SetIndexUpGlyph(const Graphics::TBitmap* Value);
	void __fastcall SetShow(const bool Value);
	
public:
	__fastcall TSortSettings(TAdvStringGrid* AOwner);
	__fastcall virtual ~TSortSettings(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property bool AutoSortForGrouping = {read=FAutoSortForGrouping, write=FAutoSortForGrouping, default=1
		};
	__property bool AutoColumnMerge = {read=FAutoColumnMerge, write=FAutoColumnMerge, default=0};
	__property int Column = {read=FSortColumn, write=FSortColumn, default=0};
	__property bool Show = {read=FSortShow, write=SetShow, default=0};
	__property bool IndexShow = {read=FSortIndexShow, write=FSortIndexShow, default=0};
	__property Graphics::TColor IndexColor = {read=FSortIndexColor, write=FSortIndexColor, default=65535
		};
	__property bool Full = {read=FSortFull, write=FSortFull, default=1};
	__property bool SingleColumn = {read=FSortSingleColumn, write=FSortSingleColumn, default=0};
	__property bool IgnoreBlanks = {read=FSortIgnoreBlanks, write=FSortIgnoreBlanks, default=0};
	__property TSortBlankPosition BlankPos = {read=FSortBlankPos, write=FSortBlankPos, default=0};
	__property bool AutoFormat = {read=FSortAutoFormat, write=FSortAutoFormat, default=1};
	__property TSortDirection Direction = {read=FSortDirection, write=FSortDirection, default=0};
	__property Graphics::TBitmap* UpGlyph = {read=GetUpGlyph, write=SetUpGlyph};
	__property Graphics::TBitmap* DownGlyph = {read=GetDownGlyph, write=SetDownGlyph};
	__property Graphics::TBitmap* IndexUpGlyph = {read=FIndexUpGlyph, write=SetIndexUpGlyph};
	__property Graphics::TBitmap* IndexDownGlyph = {read=FIndexDownGlyph, write=SetIndexDownGlyph};
	__property TSortDirection InitSortDirection = {read=FInitSortDirection, write=FInitSortDirection, default=0
		};
	__property bool FixedCols = {read=FSortFixedCols, write=FSortFixedCols, default=0};
	__property bool NormalCellsOnly = {read=FSortNormalCellsOnly, write=FSortNormalCellsOnly, default=0
		};
	__property int Row = {read=FSortRow, write=SetSortRow, default=0};
	__property bool UndoSort = {read=FUndoSort, write=FUndoSort, default=0};
};


class DELPHICLASS TDragDropSettings;
class PASCALIMPLEMENTATION TDragDropSettings : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TAdvStringGrid* FGrid;
	bool FOleDropRTF;
	bool FOleAcceptText;
	bool FOleEntireRows;
	bool FOleDropSource;
	bool FOleRemoveRows;
	bool FOleAcceptFiles;
	bool FOleDropTarget;
	bool FOleInsertRows;
	bool FOleCopyAlways;
	bool FOleColumnDragDrop;
	void __fastcall SetOleDropRTF(const bool Value);
	void __fastcall SetOleDropTarget(const bool Value);
	
public:
	__fastcall TDragDropSettings(TAdvStringGrid* AOwner);
	
__published:
	__property bool OleAcceptFiles = {read=FOleAcceptFiles, write=FOleAcceptFiles, default=1};
	__property bool OleAcceptText = {read=FOleAcceptText, write=FOleAcceptText, default=1};
	__property bool OleCopyAlways = {read=FOleCopyAlways, write=FOleCopyAlways, default=0};
	__property bool OleDropTarget = {read=FOleDropTarget, write=SetOleDropTarget, default=0};
	__property bool OleDropSource = {read=FOleDropSource, write=FOleDropSource, default=0};
	__property bool OleEntireRows = {read=FOleEntireRows, write=FOleEntireRows, default=0};
	__property bool OleInsertRows = {read=FOleInsertRows, write=FOleInsertRows, default=0};
	__property bool OleRemoveRows = {read=FOleRemoveRows, write=FOleRemoveRows, default=0};
	__property bool OleDropRTF = {read=FOleDropRTF, write=SetOleDropRTF, default=0};
	__property bool OleColumnDragDrop = {read=FOleColumnDragDrop, write=FOleColumnDragDrop, default=0};
		
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TDragDropSettings(void) { }
	#pragma option pop
	
};


class DELPHICLASS TControlLook;
#pragma option push -b-
enum TControlStyle { csClassic, csFlat, csWinXP, csBorland, csTMS, csGlyph, csTheme };
#pragma option pop

class PASCALIMPLEMENTATION TControlLook : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TAdvStringGrid* FGrid;
	int FCheckBoxSize;
	Graphics::TBitmap* FUnCheckedGlyph;
	Graphics::TBitmap* FCheckedGlyph;
	TControlStyle FControlStyle;
	Graphics::TColor FColor;
	int FRadioSize;
	Graphics::TBitmap* FRadioOffGlyph;
	Graphics::TBitmap* FRadioOnGlyph;
	bool FFlatButton;
	int FProgressMarginY;
	int FProgressMarginX;
	bool FProgressXP;
	bool FDropDownAlwaysVisible;
	bool FNoDisabledCheckRadioLook;
	bool FNoDisabledButtonLook;
	Graphics::TColor FCommentColor;
	Graphics::TColor FProgressBorderColor;
	Graphics::TColor FFixedGradientFrom;
	Graphics::TColor FFixedGradientTo;
	void __fastcall SetCheckBoxSize(const int Value);
	void __fastcall SetControlStyle(const TControlStyle Value);
	void __fastcall SetCheckedGlyph(const Graphics::TBitmap* Value);
	void __fastcall SetUnCheckedGlyph(const Graphics::TBitmap* Value);
	void __fastcall SetColor(const Graphics::TColor Value);
	void __fastcall SetRadioOffGlyph(const Graphics::TBitmap* Value);
	void __fastcall SetRadioOnGlyph(const Graphics::TBitmap* Value);
	void __fastcall SetRadioSize(const int Value);
	void __fastcall SetFlatButton(const bool Value);
	void __fastcall SetProgressMarginX(const int Value);
	void __fastcall SetProgressMarginY(const int Value);
	void __fastcall SetProgressXP(const bool Value);
	void __fastcall SetDropDownAlwaysVisible(const bool Value);
	void __fastcall SetNoDisabledCheckRadioLook(const bool Value);
	void __fastcall SetNoDisabledButtonLook(const bool Value);
	void __fastcall SetCommentColor(const Graphics::TColor Value);
	void __fastcall SetFixedGradientFrom(const Graphics::TColor Value);
	void __fastcall SetFixedGradientTo(const Graphics::TColor Value);
	
public:
	__fastcall TControlLook(TAdvStringGrid* AOwner);
	__fastcall virtual ~TControlLook(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property Graphics::TColor Color = {read=FColor, write=SetColor, default=0};
	__property Graphics::TColor CommentColor = {read=FCommentColor, write=SetCommentColor, default=255}
		;
	__property Graphics::TBitmap* CheckedGlyph = {read=FCheckedGlyph, write=SetCheckedGlyph};
	__property Graphics::TColor FixedGradientFrom = {read=FFixedGradientTo, write=SetFixedGradientTo, default=536870911
		};
	__property Graphics::TColor FixedGradientTo = {read=FFixedGradientFrom, write=SetFixedGradientFrom, 
		default=536870911};
	__property Graphics::TBitmap* UnCheckedGlyph = {read=FUnCheckedGlyph, write=SetUnCheckedGlyph};
	__property Graphics::TBitmap* RadioOnGlyph = {read=FRadioOnGlyph, write=SetRadioOnGlyph};
	__property Graphics::TBitmap* RadioOffGlyph = {read=FRadioOffGlyph, write=SetRadioOffGlyph};
	__property int CheckSize = {read=FCheckBoxSize, write=SetCheckBoxSize, default=15};
	__property int RadioSize = {read=FRadioSize, write=SetRadioSize, default=10};
	__property TControlStyle ControlStyle = {read=FControlStyle, write=SetControlStyle, default=2};
	__property bool DropDownAlwaysVisible = {read=FDropDownAlwaysVisible, write=SetDropDownAlwaysVisible
		, default=0};
	__property bool FlatButton = {read=FFlatButton, write=SetFlatButton, default=0};
	__property bool NoDisabledCheckRadioLook = {read=FNoDisabledCheckRadioLook, write=SetNoDisabledCheckRadioLook
		, default=0};
	__property bool NoDisabledButtonLook = {read=FNoDisabledButtonLook, write=SetNoDisabledButtonLook, 
		default=0};
	__property Graphics::TColor ProgressBorderColor = {read=FProgressBorderColor, write=FProgressBorderColor
		, default=8421504};
	__property int ProgressMarginX = {read=FProgressMarginX, write=SetProgressMarginX, default=2};
	__property int ProgressMarginY = {read=FProgressMarginY, write=SetProgressMarginY, default=2};
	__property bool ProgressXP = {read=FProgressXP, write=SetProgressXP, default=0};
};


class DELPHICLASS TFooterPanel;
class PASCALIMPLEMENTATION TFooterPanel : public Extctrls::TCustomPanel 
{
	typedef Extctrls::TCustomPanel inherited;
	
private:
	TAdvStringGrid* FGrid;
	int FLastHintX;
	HIDESBASE MESSAGE void __fastcall CMMouseLeave(Messages::TMessage &Msg);
	HIDESBASE MESSAGE void __fastcall CMHintShow(Forms::TCMHintShow &Msg);
	
protected:
	DYNAMIC void __fastcall MouseMove(Classes::TShiftState Shift, int X, int Y);
	AnsiString __fastcall HTMLColReplace(AnsiString s);
	void __fastcall PaintLastRow(void);
	void __fastcall PaintColPreview(void);
	void __fastcall PaintCustomPreview(void);
	virtual void __fastcall Paint(void);
	virtual void __fastcall CreateWnd(void);
	Windows::TRect __fastcall RTLCoord(bool rtl, const Windows::TRect &ARect);
	
public:
	__fastcall virtual TFooterPanel(Classes::TComponent* AOwner);
	__fastcall virtual ~TFooterPanel(void);
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TFooterPanel(HWND ParentWindow) : Extctrls::TCustomPanel(
		ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TSearchPanel;
class PASCALIMPLEMENTATION TSearchPanel : public Extctrls::TPanel 
{
	typedef Extctrls::TPanel inherited;
	
private:
	Stdctrls::TEdit* FEdit;
	Advobj::TAdvGridButton* FExitButton;
	Advobj::TAdvGridButton* FForwardButton;
	Advobj::TAdvGridButton* FBackwardButton;
	Advobj::TAdvGridButton* FHiliteButton;
	Stdctrls::TCheckBox* FMatchCase;
	Classes::TNotifyEvent FOnForwardClick;
	Classes::TNotifyEvent FOnBackwardClick;
	Classes::TNotifyEvent FOnEditChange;
	Classes::TNotifyEvent FOnExitClick;
	Classes::TNotifyEvent FOnHighLightClick;
	Graphics::TColor FColorTo;
	AnsiString FFindNextCaption;
	AnsiString FFindPrevCaption;
	AnsiString FMatchCaseCaption;
	AnsiString FHintFindPrev;
	AnsiString FHintClose;
	AnsiString FHintFindNext;
	AnsiString FHintHighlight;
	AnsiString FHighLightCaption;
	void __fastcall SetColorTo(const Graphics::TColor Value);
	
protected:
	void __fastcall ForwardClick(System::TObject* Sender);
	void __fastcall BackwardClick(System::TObject* Sender);
	void __fastcall ExitClick(System::TObject* Sender);
	void __fastcall HighlightClick(System::TObject* Sender);
	void __fastcall EditChange(System::TObject* Sender);
	virtual void __fastcall Paint(void);
	
public:
	__fastcall virtual TSearchPanel(Classes::TComponent* AOwner);
	__fastcall virtual ~TSearchPanel(void);
	virtual void __fastcall CreateWnd(void);
	__property AnsiString FindNextCaption = {read=FFindNextCaption, write=FFindNextCaption};
	__property AnsiString FindPrevCaption = {read=FFindPrevCaption, write=FFindPrevCaption};
	__property AnsiString MatchCaseCaption = {read=FMatchCaseCaption, write=FMatchCaseCaption};
	__property AnsiString HighLightCaption = {read=FHighLightCaption, write=FHighLightCaption};
	__property AnsiString HintClose = {read=FHintClose, write=FHintClose};
	__property AnsiString HintFindNext = {read=FHintFindNext, write=FHintFindNext};
	__property AnsiString HintFindPrev = {read=FHintFindPrev, write=FHintFindPrev};
	__property AnsiString HintHighlight = {read=FHintHighlight, write=FHintHighlight};
	__property Stdctrls::TEdit* EditControl = {read=FEdit};
	
__published:
	__property Graphics::TColor ColorTo = {read=FColorTo, write=SetColorTo, default=536870911};
	__property Classes::TNotifyEvent OnBackwardClick = {read=FOnBackwardClick, write=FOnBackwardClick};
		
	__property Classes::TNotifyEvent OnEditChange = {read=FOnEditChange, write=FOnEditChange};
	__property Classes::TNotifyEvent OnForwardClick = {read=FOnForwardClick, write=FOnForwardClick};
	__property Classes::TNotifyEvent OnHighlightClick = {read=FOnHighLightClick, write=FOnHighLightClick
		};
	__property Classes::TNotifyEvent OnExitClick = {read=FOnExitClick, write=FOnExitClick};
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TSearchPanel(HWND ParentWindow) : Extctrls::TPanel(
		ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TSearchFooter;
class PASCALIMPLEMENTATION TSearchFooter : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	bool FShowFindPrev;
	bool FShowFindNext;
	AnsiString FFindNextCaption;
	AnsiString FFindPrevCaption;
	Graphics::TColor FColorTo;
	Graphics::TColor FColor;
	Classes::TNotifyEvent FOnChange;
	bool FVisible;
	bool FAutoThemeAdapt;
	bool FShowClose;
	bool FShowHighLight;
	bool FShowMatchCase;
	AnsiString FMatchCaseCaption;
	AnsiString FHintClose;
	AnsiString FHintFindPrev;
	AnsiString FHintHighLight;
	AnsiString FHintFindNext;
	bool FAutoSearch;
	AnsiString FLastSearch;
	AnsiString FHighLightCaption;
	void __fastcall SetColor(const Graphics::TColor Value);
	void __fastcall SetColorTo(const Graphics::TColor Value);
	void __fastcall SetFindNextCaption(const AnsiString Value);
	void __fastcall SetFindPrevCaption(const AnsiString Value);
	void __fastcall SetShowFindNext(const bool Value);
	void __fastcall SetShowFindPrev(const bool Value);
	void __fastcall SetVisible(const bool Value);
	void __fastcall SetAutoThemeAdapt(const bool Value);
	void __fastcall SetShowClose(const bool Value);
	void __fastcall SetShowHighLight(const bool Value);
	void __fastcall SetShowMatchCase(const bool Value);
	void __fastcall SetMatchCaseCaption(const AnsiString Value);
	void __fastcall SetHintClose(const AnsiString Value);
	void __fastcall SetHintFindNext(const AnsiString Value);
	void __fastcall SetHintFindPrev(const AnsiString Value);
	void __fastcall SetHintHighlight(const AnsiString Value);
	void __fastcall SetHighLightCaption(const AnsiString Value);
	
protected:
	void __fastcall Changed(void);
	
public:
	__fastcall TSearchFooter(Classes::TComponent* AOwner);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	__property bool AutoThemeAdapt = {read=FAutoThemeAdapt, write=SetAutoThemeAdapt, nodefault};
	__property AnsiString LastSearch = {read=FLastSearch, write=FLastSearch};
	
__published:
	__property bool AutoSearch = {read=FAutoSearch, write=FAutoSearch, default=1};
	__property Graphics::TColor Color = {read=FColor, write=SetColor, default=16777215};
	__property Graphics::TColor ColorTo = {read=FColorTo, write=SetColorTo, default=-2147483633};
	__property AnsiString FindNextCaption = {read=FFindNextCaption, write=SetFindNextCaption};
	__property AnsiString FindPrevCaption = {read=FFindPrevCaption, write=SetFindPrevCaption};
	__property AnsiString HighLightCaption = {read=FHighLightCaption, write=SetHighLightCaption};
	__property AnsiString HintClose = {read=FHintClose, write=SetHintClose};
	__property AnsiString HintFindNext = {read=FHintFindNext, write=SetHintFindNext};
	__property AnsiString HintFindPrev = {read=FHintFindPrev, write=SetHintFindPrev};
	__property AnsiString HintHighlight = {read=FHintHighLight, write=SetHintHighlight};
	__property AnsiString MatchCaseCaption = {read=FMatchCaseCaption, write=SetMatchCaseCaption};
	__property bool ShowClose = {read=FShowClose, write=SetShowClose, default=1};
	__property bool ShowFindNext = {read=FShowFindNext, write=SetShowFindNext, default=1};
	__property bool ShowFindPrev = {read=FShowFindPrev, write=SetShowFindPrev, default=1};
	__property bool ShowHighLight = {read=FShowHighLight, write=SetShowHighLight, default=1};
	__property bool ShowMatchCase = {read=FShowMatchCase, write=SetShowMatchCase, default=1};
	__property bool Visible = {read=FVisible, write=SetVisible, default=0};
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TSearchFooter(void) { }
	#pragma option pop
	
};


class DELPHICLASS TFloatingFooter;
#pragma option push -b-
enum TFooterStyle { fsFixedLastRow, fsColumnPreview, fsCustomPreview };
#pragma option pop

class PASCALIMPLEMENTATION TFloatingFooter : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TAdvStringGrid* FGrid;
	int FHeight;
	bool FVisible;
	Graphics::TColor FColor;
	TFooterStyle FFooterStyle;
	int FColumn;
	TCalcFooterEvent FOnCalcFooter;
	AnsiString FCustomTemplate;
	bool FCalculateHiddenRows;
	bool FEnableCalculation;
	bool FShowHint;
	void __fastcall SetHeight(const int Value);
	void __fastcall SetVisible(const bool Value);
	void __fastcall SetColor(const Graphics::TColor Value);
	void __fastcall SetFooterStyle(const TFooterStyle Value);
	void __fastcall SetColumn(const int Value);
	void __fastcall SetCustomTemplate(const AnsiString Value);
	Basegrid::TColumnCalcType __fastcall GetColumnCalc(int c);
	void __fastcall SetColumnCalc(int c, const Basegrid::TColumnCalcType Value);
	void __fastcall SetEnableCalculation(const bool Value);
	void __fastcall SetShowHint(const bool Value);
	
public:
	__fastcall TFloatingFooter(TAdvStringGrid* AOwner);
	__fastcall virtual ~TFloatingFooter(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall Invalidate(void);
	__property int Height = {read=FHeight, write=SetHeight, nodefault};
	__property Basegrid::TColumnCalcType ColumnCalc[int c] = {read=GetColumnCalc, write=SetColumnCalc};
		
	__property bool EnableCalculation = {read=FEnableCalculation, write=SetEnableCalculation, nodefault
		};
	
__published:
	__property bool CalculateHiddenRows = {read=FCalculateHiddenRows, write=FCalculateHiddenRows, default=0
		};
	__property Graphics::TColor Color = {read=FColor, write=SetColor, default=-2147483633};
	__property int Column = {read=FColumn, write=SetColumn, default=0};
	__property AnsiString CustomTemplate = {read=FCustomTemplate, write=SetCustomTemplate};
	__property TFooterStyle FooterStyle = {read=FFooterStyle, write=SetFooterStyle, default=0};
	__property bool ShowHint = {read=FShowHint, write=SetShowHint, default=0};
	__property bool Visible = {read=FVisible, write=SetVisible, default=0};
	__property TCalcFooterEvent OnCalcFooter = {read=FOnCalcFooter, write=FOnCalcFooter};
};


class DELPHICLASS TBalloonSettings;
class PASCALIMPLEMENTATION TBalloonSettings : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	Graphics::TColor FBackgroundColor;
	Graphics::TColor FTextColor;
	int FReshowDelay;
	int FInitialDelay;
	int FAutoHideDelay;
	Byte FTransparency;
	bool FEnable;
	Classes::TNotifyEvent FOnEnableChange;
	void __fastcall SetEnable(const bool Value);
	
public:
	__fastcall TBalloonSettings(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property int AutoHideDelay = {read=FAutoHideDelay, write=FAutoHideDelay, default=-1};
	__property Graphics::TColor BackgroundColor = {read=FBackgroundColor, write=FBackgroundColor, default=536870911
		};
	__property bool Enable = {read=FEnable, write=SetEnable, default=0};
	__property int InitialDelay = {read=FInitialDelay, write=FInitialDelay, default=-1};
	__property int ReshowDelay = {read=FReshowDelay, write=FReshowDelay, default=-1};
	__property Graphics::TColor TextColor = {read=FTextColor, write=FTextColor, default=536870911};
	__property Byte Transparency = {read=FTransparency, write=FTransparency, default=0};
	__property Classes::TNotifyEvent OnEnableChange = {read=FOnEnableChange, write=FOnEnableChange};
public:
		
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TBalloonSettings(void) { }
	#pragma option pop
	
};


class DELPHICLASS TShowModified;
class PASCALIMPLEMENTATION TShowModified : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	bool FEnabled;
	Graphics::TColor FColor;
	Classes::TNotifyEvent FOnChange;
	void __fastcall SetColor(const Graphics::TColor Value);
	
public:
	__fastcall TShowModified(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property bool Enabled = {read=FEnabled, write=FEnabled, default=0};
	__property Graphics::TColor Color = {read=FColor, write=SetColor, default=65535};
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TShowModified(void) { }
	#pragma option pop
	
};


typedef void __fastcall (__closure *TFooterPaintEvent)(System::TObject* Sender, int AColumn, Graphics::TCanvas* 
	Canvas, const Windows::TRect &ARect);

class DELPHICLASS TAdvInplaceEdit;
#pragma pack(push, 1)
struct TCellAlignment
{
	Classes::TAlignment Alignment;
	Basegrid::TVAlignment VAlignment;
} ;
#pragma pack(pop)

#pragma option push -b-
enum TClipOperation { coCut, coCopy };
#pragma option pop

class DELPHICLASS THTMLHintWindow;
class PASCALIMPLEMENTATION THTMLHintWindow : public Controls::THintWindow 
{
	typedef Controls::THintWindow inherited;
	
private:
	int FTextHeight;
	int FTextWidth;
	HIDESBASE MESSAGE void __fastcall CMTextChanged(Messages::TMessage &Message);
	
protected:
	virtual void __fastcall Paint(void);
	virtual void __fastcall CreateParams(Controls::TCreateParams &Params);
	
public:
	virtual void __fastcall ActivateHint(const Windows::TRect &Rect, const AnsiString AHint);
	virtual Windows::TRect __fastcall CalcHintRect(int MaxWidth, const AnsiString AHint, void * AData);
		
public:
	#pragma option push -w-inl
	/* THintWindow.Create */ inline __fastcall virtual THTMLHintWindow(Classes::TComponent* AOwner) : Controls::THintWindow(
		AOwner) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TCustomControl.Destroy */ inline __fastcall virtual ~THTMLHintWindow(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall THTMLHintWindow(HWND ParentWindow) : Controls::THintWindow(
		ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TGridChangeNotifier;
class PASCALIMPLEMENTATION TAdvStringGrid : public Basegrid::TBaseGrid 
{
	typedef Basegrid::TBaseGrid inherited;
	
private:
	AnsiString cla;
	int FMoveColInd;
	int FMoveRowInd;
	int FGroupColumn;
	AnsiString FGroupCaption;
	int FGroupWidth;
	bool FAutoSize;
	bool FAutoNumAlign;
	bool FEnhTextSize;
	bool FEditWithTags;
	bool FOemConvert;
	bool FLookup;
	bool FLoaded;
	bool FLookupCaseSensitive;
	bool FDeselectState;
	bool FSelectionClick;
	bool FMouseDown;
	bool FMouseKeepDown;
	bool FCtrlDown;
	bool FMouseResize;
	bool FMouseDownMove;
	bool FLookupHistory;
	bool FEnhRowColMove;
	bool FSizeWithForm;
	bool FMultilineCells;
	Advobj::TIntList* FSortRowXRef;
	Advobj::TIntList* FUnSortRowXRef;
	Advobj::TIntList* FMergedColumns;
	Advobj::TIntList* FSelectedCells;
	Advobj::TIntList* FModifiedRows;
	TGridColorEvent FOnGetCellColor;
	TGridColorEvent FOnGetCellPrintColor;
	TGridBorderEvent FOnGetCellBorder;
	TGridBorderEvent FOnGetCellPrintBorder;
	TGridAlignEvent FOnGetAlignment;
	TGridFormatEvent FOnGetFormat;
	TFloatFormatEvent FOnGetFloatFormat;
	TGetCheckEvent FOnGetCheckTrue;
	TGetCheckEvent FOnGetCheckFalse;
	TGridHintEvent FOnGridHint;
	TRowChangingEvent FOnRowChanging;
	TRowChangedEvent FOnRowChanged;
	TColChangingEvent FOnColChanging;
	TCellChangingEvent FOnCellChanging;
	TAutoAdvanceEvent FOnAutoAdvance;
	Forms::TShowHintEvent FOnShowHint;
	TCanAddRowEvent FOnCanAddRow;
	TAutoAddRowEvent FOnAutoAddRow;
	TCanInsertRowEvent FOnCanInsertRow;
	TAutoInsertRowEvent FOnAutoInsertRow;
	TAutoInsertColEvent FOnAutoInsertCol;
	TCanDeleteRowEvent FOnCanDeleteRow;
	TAutoDeleteRowEvent FOnAutoDeleteRow;
	TOleDragDropEvent FOnOleDrop;
	TOleDragDropEvent FOnOleDrag;
	TOleDragOverEvent FOnOleDragOver;
	TOleDragStartEvent FOnOleDragStart;
	TOleDragStopEvent FOnOleDragStop;
	TOleDropColEvent FOnOleDropCol;
	TOleDroppedEvent FOnOleDropped;
	TGridDropTarget* FGridDropTarget;
	TOleDropFileEvent FOnOleDropFile;
	TClickSortEvent FOnClickSort;
	TCanSortEvent FOnCanSort;
	TNodeClickEvent FOnExpandNode;
	TNodeClickEvent FOnContractNode;
	TNodeAllowEvent FOnBeforeExpandNode;
	TNodeAllowEvent FOnBeforeContractNode;
	TCustomCompareEvent FCustomCompare;
	TRawCompareEvent FRawCompare;
	TClipboardEvent FOnClipboardPaste;
	TClipboardEvent FOnClipboardCut;
	TClipboardEvent FOnClipboardCopy;
	TBeforeCellPasteEvent FOnClipboardBeforePasteCell;
	TBeforeCellPasteWideEvent FOnClipboardBeforePasteWideCell;
	TOnResizeEvent FOnResize;
	TGridPrintStartEvent FOnPrintStart;
	TGridPrintCancelEvent FOnPrintCancel;
	TGridPrintPageEvent FOnPrintPage;
	TGridPrintNewPageEvent FOnPrintNewPage;
	TGridPrintPageDoneEvent FOnPrintPageDone;
	TGridPrintColumnWidthEvent FOnPrintSetColumnWidth;
	TGridPrintRowHeightEvent FOnPrintSetRowHeight;
	TDoFitToPageEvent FDoFitToPage;
	TClickCellEvent FOnClickCell;
	TClickCellEvent FOnRightClickCell;
	TDblClickCellEvent FOnDblClickCell;
	TCanEditCellEvent FOnCanEditCell;
	TCanClickCellEvent FOnCanClickCell;
	TIsFixedCellEvent FOnIsFixedCell;
	TIsPasswordCellEvent FOnIsPasswordCell;
	TAnchorClickEvent FOnAnchorClick;
	TAnchorEvent FOnAnchorEnter;
	TAnchorEvent FOnAnchorExit;
	TAnchorHintEvent FOnAnchorHint;
	TCellControlEvent FOnControlClick;
	TCellControlEvent FOnControlEditDone;
	TCellComboControlEvent FOnControlComboList;
	TCellValidateEvent FOnCellValidate;
	TCellValidateWideEvent FOnCellValidateWide;
	TCellsChangedEvent FOnCellsChanged;
	TGridProgressEvent FOnFileProgress;
	TGridProgressEvent FOnFilterProgress;
	Classes::TNotifyEvent FOnRichEditSelectionChange;
	Graphics::TColor FHintColor;
	bool FHintShowCells;
	bool FHintShowLargeText;
	bool FHintShowSizing;
	Windows::TPoint FLastHintPos;
	Windows::TPoint FLastBalloonPos;
	Graphics::TBitmap* FRowIndicator;
	Advobj::TSortIndexList* FSortIndexes;
	TBackGround* FBackGround;
	Grids::TGridRect FDropSelection;
	bool FOleDropTargetAssigned;
	Advobj::TArrowWindow* ArwU;
	Advobj::TArrowWindow* ArwD;
	Advobj::TArrowWindow* ArwL;
	Advobj::TArrowWindow* ArwR;
	TColumnSizeEvent FOnColumnSize;
	TRowSizeEvent FOnRowSize;
	TColumnSizeEvent FOnColumnMove;
	TRowSizeEvent FOnRowMove;
	TEndColumnSizeEvent FOnEndColumnSize;
	TEndRowSizeEvent FOnEndRowSize;
	TPrintSettings* FPrintSettings;
	bool FFastPrint;
	THTMLSettings* FHTMLSettings;
	TBands* FBands;
	TNavigation* FNavigation;
	TColumnSize* FColumnSize;
	bool FScrollProportional;
	TCellNode* FCellNode;
	TSizeWhileTyping* FSizeWhileTyping;
	TMouseActions* FMouseActions;
	TGrouping* FGrouping;
	bool FVisibleCol[513];
	short FAllColWidths[513];
	int FUpdateCount;
	int FNumNodes;
	int FNumHidden;
	Graphics::TColor FSelectionColor;
	Graphics::TColor FSelectionColorTo;
	Graphics::TColor FSelectionTextColor;
	bool FSelectionRectangle;
	bool FSelectionRTFKeep;
	Basegrid::TVAlignment FVAlignment;
	unsigned FVAlign;
	bool FURLShow;
	bool FURLFull;
	Graphics::TColor FURLColor;
	bool FURLEdit;
	Controls::TImageList* FGridImages;
	TIntelliPan FIntelliPan;
	bool FIntelliZoom;
	TScrollType FScrollType;
	Graphics::TColor FScrollColor;
	int FScrollWidth;
	bool FScrollSynch;
	TScrollHintType FScrollHints;
	bool FIsFlat;
	TAdvRichEdit* FRichEdit;
	TAdvRichEdit* FInplaceRichEdit;
	bool FFixedAsButtons;
	bool FFixedCellPushed;
	Windows::TRect FPushedFixedCell;
	Windows::TPoint FPushedCellButton;
	bool FShowSelection;
	bool FHideFocusRect;
	Graphics::TFont* FFixedFont;
	bool FFixedRowAlways;
	bool FFixedColAlways;
	int FFixedRowsMin;
	int FFixedColsMin;
	Classes::TStringList* FColumnHeaders;
	Classes::TStringList* FRowHeaders;
	Classes::TStringList* FLookupItems;
	Classes::TList* FRowSelect;
	Classes::TList* FColSelect;
	int FFixedFooters;
	int FFixedRightCols;
	char FDelimiter;
	bool FNoDefaultDraw;
	char FPasswordChar;
	bool FJavaCSV;
	AnsiString FCheckTrue;
	AnsiString FCheckFalse;
	bool FEnableHTML;
	bool FEnableWheel;
	bool FFlat;
	bool FAnchorHint;
	bool FSaveFixedCells;
	bool FSaveHiddenCells;
	bool FSaveVirtCells;
	bool FSaveWithHTML;
	bool FWordWrapEx;
	bool FModified;
	bool FEditDisable;
	bool FEditChange;
	bool FExcelStyleDecimalSeparator;
	bool FHovering;
	AnsiString FFloatFormat;
	AnsiString FOldCellText;
	WideString FOldCellTextWide;
	char FStartEditChar;
	int FOldCol;
	int FOldRow;
	int FOldRowSel;
	bool FOldModifiedValue;
	int FOldCursor;
	bool FBlockFocus;
	bool FBlockKill;
	bool FDblClk;
	Grids::TGridRect FOldSelection;
	Grids::TGridRect FSizeSelection;
	Grids::TGridRect FMoveSelection;
	bool FEntered;
	bool FEditing;
	bool FSpecialEditor;
	bool FEditActive;
	bool FValidating;
	bool FFindBusy;
	int FComboIdx;
	int SortDir;
	int SortRow;
	Windows::TPoint SearchCell;
	bool ResizeAssigned;
	Grids::TGridRect FPrintRect;
	TFindParams FFindParams;
	AnsiString SearchCache;
	WideString SearchCacheWide;
	AnsiString SearchInc;
	int SearchTics;
	AnsiString FAnchor;
	int ZoomFactor;
	bool ColchgFlg;
	bool ColMoveFlg;
	bool ColSizeFlg;
	bool ColSized;
	bool Rowsized;
	int Colclicked;
	int Rowclicked;
	int Colclickedsize;
	int Rowclickedsize;
	int Movecell;
	int MoveOfsX;
	int MoveOfsY;
	int Clickposx;
	int Clickposy;
	int Clickposdx;
	int Clickposdy;
	bool Invokedchange;
	bool InvokedFocusChange;
	unsigned wheelmsg;
	int wheelscrl;
	bool wheelpan;
	Windows::TPoint wheelpanpos;
	unsigned wheeltimer;
	HICON prevcurs;
	TMouseSelectMode FMouseSelectMode;
	int FMouseSelectStart;
	bool FPrinterdriverfix;
	Windows::TRect PrevRect;
	double Fontscalefactor;
	int FPrintPageWidth;
	Windows::TRect FPrintPageRect;
	int FPrintColStart;
	int FPrintColEnd;
	int FPrintPageFrom;
	int FPrintPageTo;
	int FPrintPageNum;
	bool FExcelClipboardFormat;
	int FGridTimerID;
	bool FGridBlink;
	int FMaxEditLength;
	TGridLook FLook;
	Picturecontainer::TPictureContainer* FContainer;
	Asgcheck::TAdvStringGridCheck* FCellChecker;
	Picturecontainer::THTMLPictureCache* FImageCache;
	Windows::TPoint FCtrlXY;
	AnsiString FCtrlID;
	AnsiString FCtrlType;
	bool FCtrlEditing;
	bool FPasteAll;
	int MaxWidths[513];
	int Indents[513];
	TGetEditorTypeEvent FOnGetEditorType;
	THasComboEvent FOnHasComboBox;
	TGetEditorPropEvent FOnGetEditorProp;
	TEllipsClickEvent FOnEllipsClick;
	TButtonClickEvent FOnButtonClick;
	TCheckBoxClickEvent FOnCheckBoxClick;
	TCheckBoxClickEvent FOnCheckBoxMouseUp;
	TRadioClickEvent FOnRadioClick;
	TRadioClickEvent FOnRadioMouseUp;
	TComboChangeEvent FOnComboChange;
	TClickCellEvent FOnComboCloseUp;
	TComboObjectChangeEvent FOnComboObjectChange;
	TSpinClickEvent FOnSpinClick;
	TFloatSpinClickEvent FOnFloatSpinClick;
	TDateTimeSpinClickEvent FOntimeSpinClick;
	TDateTimeSpinClickEvent FOnDateSpinClick;
	TDateTimeChangeEvent FOnDateTimeChange;
	TEditLink* FEditLink;
	TControlEdit* FEditControl;
	TControlCombo* FComboControl;
	Controls::TWinControl* EditCtrl;
	TGridCombo* EditCombo;
	TGridSpin* EditSpin;
	TGridTransEdit* EditTrans;
	TGridUniEdit* EditUni;
	TGridUniCombo* ComboUni;
	TGridUniEditBtn* EditBtnUni;
	TGridCheckBox* EditCheck;
	TGridEditBtn* EditBtn;
	TGridUnitEditBtn* UnitEditBtn;
	TGridDatePicker* EditDate;
	TScrollHintEvent FOnScrollHint;
	TGridButton* GridButton;
	Advobj::TPopupButton* MoveButton;
	Basegrid::TEditorType EditControl;
	Classes::TCollection* FGridItems;
	TFilter* FFilter;
	bool FFilterActive;
	int FFilterFixedRows;
	Classes::TList* FNotifierList;
	bool FActiveCellShow;
	Graphics::TFont* FActiveCellFont;
	Windows::TPoint FXYOffset;
	int FOldSize;
	bool FSizeFixed;
	int FSizeFixedCol;
	bool FSizingFixed;
	int FSizeFixedRow;
	bool FSizeFixedR;
	bool FSizingFixedR;
	int FSizeFixedX;
	int FSizeFixedY;
	bool FDisableChange;
	bool FNilObjects;
	bool FQuoteEmptyCells;
	bool FAutoThemeAdapt;
	bool FAlwaysQuotes;
	TSortSettings* FSortSettings;
	Graphics::TColor FSelectionRectangleColor;
	TDragDropSettings* FDragDropSettings;
	TControlLook* FControlLook;
	TGridBorderPropEvent FOnGetCellBorderProp;
	TFooterPanel* FFooterPanel;
	TSearchPanel* FSearchPanel;
	TSearchFooter* FSearchFooter;
	TFloatingFooter* FFloatingFooter;
	bool FIntegralHeight;
	bool FIsWinXP;
	bool FIsComCtl6;
	bool FClearTextOnly;
	Classes::TNotifyEvent FOnEditingDone;
	TEditChangeEvent FOnEditChange;
	TUpdateColumnSizeEvent FOnUpdateColumnSize;
	bool FHTMLHint;
	bool FAlwaysValidate;
	bool FEnableBlink;
	Classes::TNotifyEvent FOnGridResize;
	bool FSizeGrowOnly;
	Graphics::TColor FActiveCellColor;
	Graphics::TColor FActiveCellColorTo;
	bool FSelectionResizer;
	int FMaxColWidth;
	int FMinRowHeight;
	int FMinColWidth;
	int FMaxRowHeight;
	TCustomCellDrawEvent FOnCustomCellDraw;
	TCustomCellSizeEvent FOnCustomCellSize;
	TSelectionResizeEvent FSelectionResizeEvent;
	TSelectionResizeEvent FSelectionResizedEvent;
	TWordWrapEvent FOnGetWordWrap;
	Graphics::TColor FTMSGradFrom;
	Graphics::TColor FTMSGradTo;
	bool FUseHTMLHints;
	bool FShowNullDates;
	unsigned FICursor;
	int FFixedRowHeight;
	bool FSelHidden;
	Advobj::TIntList* FColumnOrder;
	TSortDirection FAutoNumberDirection;
	int FAutoNumberOffset;
	int FAutoNumberStart;
	int FOldLeftCol;
	int FOldKeepLeftCol;
	int FOldTopRow;
	TSelectionChanged FSelectionChanged;
	Stdctrls::TScrollStyle FScrollBars;
	unsigned FUniLocale;
	unsigned FUniCmpFlgs;
	int FFreewareCode;
	Controls::TWndMethod FGridControlWndProc;
	int FNumCellControls;
	Advobj::TControlList* FControlList;
	bool FDisableSize;
	Basegrid::TEditorType FDefaultEditor;
	Windows::TPoint FHotFixedCell;
	Classes::TNotifyEvent FOnPainted;
	bool FCellSelectorMode;
	int FAECol;
	int FAERow;
	bool FShowEditProcess;
	TBalloonSettings* FBalloonSettings;
	unsigned FHToolTip;
	TScrollBarAlways FScrollBarAlways;
	char FToolTipBuffer[4097];
	TGridBalloonEvent FOnCellBalloon;
	TShowModified* FShowModified;
	TCellGraphic* FCellGraphic;
	TFooterPaintEvent FOnPaintFooter;
	TDragScrollOptions* FDragScrollOptions;
	int FTimerTicks;
	Extctrls::TTimer* FDragTmr;
	TDragScrollDirection FDragScrollDirection;
	TDragScrollEvent FOnDragScroll;
	void __fastcall SetDragScrollOptions(TDragScrollOptions* Value);
	void __fastcall NCPaintProc(void);
	HIDESBASE MESSAGE void __fastcall WMNCPaint(Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall WMNotify(Messages::TWMNotify &Message);
	HIDESBASE MESSAGE void __fastcall WMSetFocus(Messages::TWMSetFocus &Msg);
	HIDESBASE MESSAGE void __fastcall WMKillFocus(Messages::TWMKillFocus &Msg);
	HIDESBASE MESSAGE void __fastcall WMSetCursor(Messages::TWMSetCursor &Msg);
	HIDESBASE MESSAGE void __fastcall WMLButtonUp(Messages::TWMMouse &Msg);
	HIDESBASE MESSAGE void __fastcall WMRButtonUp(Messages::TWMMouse &Msg);
	HIDESBASE MESSAGE void __fastcall WMLButtonDown(Messages::TWMMouse &Msg);
	HIDESBASE MESSAGE void __fastcall WMRButtonDown(Messages::TWMMouse &Msg);
	HIDESBASE MESSAGE void __fastcall WMLButtonDblClk(Messages::TWMMouse &Message);
	HIDESBASE MESSAGE void __fastcall WMChar(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMKeyDown(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMKeyUp(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMSize(Messages::TWMSize &Msg);
	HIDESBASE MESSAGE void __fastcall WMPaint(Messages::TWMPaint &Msg);
	HIDESBASE MESSAGE void __fastcall WMEraseBkGnd(Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall WMTimer(Messages::TWMTimer &Msg);
	HIDESBASE MESSAGE void __fastcall WMVScroll(Messages::TWMScroll &WMScroll);
	HIDESBASE MESSAGE void __fastcall WMHScroll(Messages::TWMScroll &WMScroll);
	HIDESBASE MESSAGE void __fastcall CMCursorChanged(Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall CMHintShow(Messages::TMessage &Msg);
	HIDESBASE MESSAGE void __fastcall CMDialogChar(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall CMMouseLeave(Messages::TMessage &Msg);
	void __fastcall HideEditControl(int ACol, int ARow);
	void __fastcall ShowEditControl(int ACol, int ARow);
	bool __fastcall IsEditable(int ACol, int ARow);
	bool __fastcall IsPassword(int ACol, int ARow);
	void __fastcall HandleRadioClick(int ACol, int ARow, int Xpos, int Ypos);
	bool __fastcall HasStaticEdit(int ACol, int ARow);
	void __fastcall TabEdit(bool Dir);
	bool __fastcall ToggleRadio(int ACol, int ARow, bool FromEdit);
	TAdvInplaceEdit* __fastcall GetInplaceEditor(void);
	void __fastcall SetAutoSizeP(bool AAutoSize);
	void __fastcall SetFlat(const bool AValue);
	void __fastcall SetShowSelection(bool AValue);
	void __fastcall SetMaxEditLength(const int AValue);
	void __fastcall SetGroupColumn(int AGroupColumn);
	void __fastcall QuickSortRows(int Col, int Left, int Right);
	void __fastcall QuickSortRowsIndexed(int Col, int Left, int Right);
	void __fastcall QuickSortRowsRef(int Col, int Left, int Right);
	void __fastcall SetVAlignment(Basegrid::TVAlignment AVAlignment);
	int __fastcall BuildPages(Graphics::TCanvas* Canvas, TPrintMethod PrintMethod, int MaxPages, bool SelRows
		);
	int __fastcall Compare(int Col, int ARow1, int ARow2, TSortDirection sd);
	int __fastcall CompareLine(int Col, int ARow1, int ARow2);
	int __fastcall CompareLineIndexed(int Colidx, int ARow1, int ARow2);
	bool __fastcall MatchCell(int Col, int Row, bool IsWide);
	void __fastcall ShowHintProc(AnsiString &HintStr, bool &CanShow, Forms::THintInfo &HintInfo);
	void __fastcall DrawSortIndicator(Graphics::TCanvas* Canvas, int Col, int x, int y);
	void __fastcall GridResize(System::TObject* Sender);
	bool __fastcall FreeCellGraphic(int ACol, int ARow);
	bool __fastcall RemoveCellGraphic(int ACol, int ARow, TCellType CellType);
	TCellGraphic* __fastcall CreateCellGraphic(int ACol, int ARow);
	Advobj::TIntList* __fastcall GetCellImages(int ACol, int ARow);
	int __fastcall GetCellImageIdx(int ACol, int ARow);
	void __fastcall SetInts(int ACol, int ARow, const int Value);
	int __fastcall GetInts(int ACol, int ARow);
	void __fastcall SetFloats(int ACol, int ARow, const double Value);
	double __fastcall GetFloats(int ACol, int ARow);
	void __fastcall SetAllFloats(int ACol, int ARow, const double Value);
	double __fastcall GetAllFloats(int ACol, int ARow);
	void __fastcall SetDates(int ACol, int ARow, const System::TDateTime Value);
	System::TDateTime __fastcall GetDates(int ACol, int ARow);
	void __fastcall SetTimes(int ACol, int ARow, const System::TDateTime Value);
	System::TDateTime __fastcall GetTimes(int ACol, int ARow);
	bool __fastcall GetRowSelect(int ARow);
	void __fastcall SetRowSelect(int ARow, bool Value);
	bool __fastcall GetRowModified(int ARow);
	void __fastcall SetRowModified(int ARow, bool Value);
	int __fastcall GetRowSelectCount(void);
	void __fastcall SelectToRowSelect(bool IsShift);
	bool __fastcall GetColSelect(int ACol);
	void __fastcall SetColSelect(int ACol, bool Value);
	int __fastcall GetColSelectCount(void);
	void __fastcall SelectToColSelect(bool IsShift);
	Windows::TRect __fastcall ButtonRect(int ACol, int ARow);
	void __fastcall SetFixedFont(Graphics::TFont* Value);
	void __fastcall FixedFontChanged(System::TObject* Sender);
	void __fastcall MultiImageChanged(System::TObject* Sender, int ACol, int ARow);
	void __fastcall MergedColumnsChanged(System::TObject* Sender, int ACol, int ARow);
	void __fastcall UndoColumnMerge(void);
	void __fastcall ApplyColumnMerge(void);
	void __fastcall RichSelChange(System::TObject* Sender);
	void __fastcall SetColumnHeaders(Classes::TStringList* Value);
	void __fastcall ColHeaderChanged(System::TObject* Sender);
	void __fastcall SetRowHeaders(Classes::TStringList* Value);
	void __fastcall RowHeaderChanged(System::TObject* Sender);
	int __fastcall GetPrintColWidth(int ACol);
	int __fastcall GetPrintColOffset(int ACol);
	void __fastcall SetLookupItems(Classes::TStringList* Value);
	int __fastcall PasteFunc(int ACol, int ARow);
	void __fastcall CopyFunc(const Grids::TGridRect &gd, bool DoDisjunct);
	void __fastcall CopyRTFFunc(int ACol, int ARow);
	void __fastcall CopyBinFunc(const Grids::TGridRect &gd);
	void __fastcall SetPreviewPage(int Value);
	Graphics::TBitmap* __fastcall GetRowIndicator(void);
	void __fastcall SetRowIndicator(Graphics::TBitmap* Value);
	void __fastcall SetBackground(TBackGround* Value);
	void __fastcall RTFPaint(int ACol, int ARow, Graphics::TCanvas* Canvas, const Windows::TRect &ARect
		);
	HIDESBASE void __fastcall DrawSizingLine(int X);
	void __fastcall DrawSizingLineR(int Y);
	void __fastcall FlatInit(void);
	void __fastcall FlatDone(void);
	void __fastcall FlatUpdate(void);
	void __fastcall FlatSetScrollProp(int index, int newValue, BOOL fRedraw);
	void __fastcall FlatSetScrollInfo(int code, tagSCROLLINFO &scrollinfo, BOOL fRedraw);
	void __fastcall FlatShowScrollBar(int code, BOOL show);
	void __fastcall UpdateVScrollBar(void);
	void __fastcall UpdateHScrollBar(void);
	void __fastcall UpdateScrollBars(bool Refresh);
	void __fastcall UpdateType(void);
	void __fastcall UpdateColor(void);
	void __fastcall UpdateWidth(void);
	void __fastcall SetScrollBarsEx(const Stdctrls::TScrollStyle Value);
	Stdctrls::TScrollStyle __fastcall GetScrollBarsEx(void);
	void __fastcall SetScrollType(const TScrollType Value);
	void __fastcall SetScrollColor(const Graphics::TColor Value);
	void __fastcall SetScrollWidth(const int Value);
	void __fastcall SetScrollProportional(bool Value);
	void __fastcall SetActiveCellShow(const bool Value);
	void __fastcall SetActiveCellFont(const Graphics::TFont* Value);
	void __fastcall SetAutoThemeAdapt(const bool Value);
	void __fastcall SetXYOffset(const Windows::TPoint &Value);
	bool __fastcall GetLockFlag(void);
	void __fastcall SetLockFlag(bool AValue);
	bool __fastcall InSizeZone(int x, int y);
	int __fastcall RemapCol(int ACol);
	int __fastcall RemapColInv(int ACol);
	int __fastcall RemapRow(int ARow);
	int __fastcall RemapRowInv(int ARow);
	void __fastcall SetVisibleCol(int i, bool AValue);
	bool __fastcall GetVisibleCol(int i);
	int __fastcall MaxLinesInGrid(void);
	int __fastcall MaxLinesInRow(int ARow);
	int __fastcall MaxCharsInCol(int ACol);
	void __fastcall SizeToLines(const int ARow, const int Lines, const int Padding);
	void __fastcall SizeToWidth(const int ACol, bool inconly);
	void __fastcall SizeToHeight(const int ARow, bool inconly);
	TCellAlignment __fastcall GetCellAlignment(int ACol, int ARow);
	void __fastcall DrawIntelliFocusPoint(void);
	void __fastcall EraseIntelliFocusPoint(void);
	void __fastcall SetImages(Controls::TImageList* Value);
	void __fastcall SetURLShow(bool Value);
	void __fastcall SetURLColor(Graphics::TColor Value);
	void __fastcall SetURLFull(bool Value);
	void __fastcall SetLook(TGridLook Value);
	void __fastcall CalcTextPos(Windows::TRect &ARect, int AAngle, AnsiString ATxt, Classes::TAlignment 
		hal, Basegrid::TVAlignment val);
	void __fastcall SetFixedFooters(int Value);
	void __fastcall SetFixedRightCols(int Value);
	void __fastcall SetFixedColWidth(int Value);
	void __fastcall SetRowCountEx(int Value);
	int __fastcall GetRowCountEx(void);
	void __fastcall SetFixedRowsEx(int Value);
	int __fastcall GetFixedRowsEx(void);
	void __fastcall SetColCountEx(int Value);
	int __fastcall GetColCountEx(void);
	void __fastcall SetFixedColsEx(int Value);
	int __fastcall GetFixedColsEx(void);
	void __fastcall SetHovering(bool Value);
	int __fastcall GetFixedColWidth(void);
	void __fastcall SetFixedRowHeight(int Value);
	int __fastcall GetFixedRowHeight(void);
	void __fastcall SetWordWrapEx(bool Value);
	bool __fastcall GetWordWrapEx(void);
	void __fastcall SetSelectionColor(Graphics::TColor AColor);
	void __fastcall SetSelectionColorTo(Graphics::TColor AColor);
	void __fastcall SetSelectionTextColor(Graphics::TColor AColor);
	void __fastcall SetSelectionRectangle(bool AValue);
	void __fastcall SetFilterActive(const bool Value);
	void __fastcall ApplyFilter(void);
	Controls::TCursor __fastcall GetCursorEx(void);
	void __fastcall SetCursorEx(const Controls::TCursor Value);
	AnsiString __fastcall GetCellsEx(int i, int j);
	void __fastcall SetCellsEx(int i, int j, AnsiString Value);
	System::TObject* __fastcall GetObjectsEx(int i, int j);
	void __fastcall SetObjectsEx(int i, int j, System::TObject* aObject);
	int __fastcall GetAllColWidths(int i);
	void __fastcall SetAllColWidths(int i, const int Value);
	Graphics::TColor __fastcall GetColors(int i, int j);
	void __fastcall SetColors(int i, int j, Graphics::TColor AColor);
	Graphics::TColor __fastcall GetColorsTo(int i, int j);
	void __fastcall SetColorsTo(int i, int j, Graphics::TColor AColor);
	void __fastcall SetRowColor(int i, Graphics::TColor AColor);
	void __fastcall SetRowColorTo(int i, Graphics::TColor AColor);
	void __fastcall SetRowFontColor(int i, Graphics::TColor AColor);
	bool __fastcall GetReadOnly(int i, int j);
	void __fastcall SetReadOnly(int i, int j, bool AValue);
	bool __fastcall GetWordWraps(int i, int j);
	void __fastcall SetWordWraps(int i, int j, bool AValue);
	Controls::TControl* __fastcall GetCellControls(int i, int j);
	void __fastcall SetCellControls(int i, int j, Controls::TControl* AControl);
	AnsiString __fastcall GetStrippedCell(int i, int j);
	Classes::TStrings* __fastcall HiddenRow(int j);
	int __fastcall PasteText(int ACol, int ARow, char * p);
	void __fastcall InputFromCSV(AnsiString FileName, bool insertmode);
	void __fastcall OutputToCSV(AnsiString FileName, bool appendmode);
	void __fastcall OutputToHTML(AnsiString FileName, bool appendmode);
	void __fastcall LoadXLS(AnsiString filename, AnsiString sheetname);
	void __fastcall SaveXLS(AnsiString filename, AnsiString sheetname, bool CreateNewSheet);
	Comctrls::TDateTimePicker* __fastcall GetDateTimePicker(void);
	void __fastcall SetArrowColor(Graphics::TColor Value);
	Graphics::TColor __fastcall GetArrowColor(void);
	Windows::TPoint __fastcall PasteSize(char * p);
	void __fastcall MarkCells(AnsiString s, AnsiString tag, bool DoCase, int FromCol, int FromRow, int 
		ToCol, int ToRow);
	void __fastcall UnMarkCells(AnsiString tag, int FromCol, int FromRow, int ToCol, int ToRow);
	AnsiString __fastcall GetUnSortedCell(int i, int j);
	void __fastcall SetUnSortedCell(int i, int j, const AnsiString Value);
	int __fastcall GetDefRowHeightEx(void);
	void __fastcall SetDefRowHeightEx(const int Value);
	void __fastcall SetIntegralHeight(const bool Value);
	bool __fastcall GetSelectedCells(int i, int j);
	void __fastcall SetSelectedCells(int i, int j, const bool Value);
	int __fastcall GetSelectedCellsCount(void);
	Grids::TGridCoord __fastcall GetSelectedCell(int i);
	Graphics::TColor __fastcall GetFontColors(int i, int j);
	void __fastcall SetFontColors(int i, int j, const Graphics::TColor Value);
	Classes::TAlignment __fastcall GetAlignments(int i, int j);
	void __fastcall SetAlignments(int i, int j, const Classes::TAlignment Value);
	void __fastcall SetActiveCellColor(const Graphics::TColor Value);
	void __fastcall SetActiveCellColorTo(const Graphics::TColor Value);
	void __fastcall SetSelectionResizer(const bool Value);
	Graphics::TFontStyles __fastcall GetFontStyles(int i, int j);
	void __fastcall SetFontStyles(int i, int j, const Graphics::TFontStyles Value);
	AnsiString __fastcall GetFontNames(int i, int j);
	int __fastcall GetFontSizes(int i, int j);
	void __fastcall SetFontNames(int i, int j, const AnsiString Value);
	void __fastcall SetFontSizes(int i, int j, const int Value);
	void __fastcall SetTMSGradFrom(const Graphics::TColor Value);
	void __fastcall SetTMSGradTo(const Graphics::TColor Value);
	void __fastcall SetUseHTMLHints(const bool Value);
	void __fastcall ControlExit(System::TObject* Sender);
	void __fastcall ControlEnter(AnsiString S, AnsiString CT, AnsiString CID, AnsiString CV, const Windows::TRect 
		&CR, int X, int RX, int Y);
	AnsiString __fastcall GetCtrlVal(int ACol, int ARow, AnsiString ID);
	void __fastcall SetCtrlVal(int ACol, int ARow, AnsiString ID, const AnsiString Value);
	int __fastcall GetAllColCount(void);
	int __fastcall GetAllRowCount(void);
	WideString __fastcall GetWideCells(int i, int j);
	void __fastcall SetWideCells(int i, int j, const WideString Value);
	void __fastcall StartFixedEdit(int x, int y);
	int __fastcall NumFixedRightVis(void);
	int __fastcall FixedColsVis(void);
	Graphics::TCanvas* __fastcall GetFooterCanvas(void);
	Windows::TPoint __fastcall FindInternal(const Windows::TPoint &StartCell, AnsiString s, WideString 
		sw, bool IsWide, TFindParams FindParams);
	bool __fastcall InNodeRect(int ARow, int x);
	void __fastcall SetVersion(const AnsiString Value);
	AnsiString __fastcall GetVersion();
	void __fastcall SaveToDOCInt(AnsiString FileName, AnsiString bookmark, bool CreateNewDocument, bool 
		Append);
	void __fastcall SaveToASCIIInt(AnsiString FileName, bool AppendFile);
	void __fastcall QSortGroupInt(bool Indexed);
	void __fastcall CreateToolTip(void);
	void __fastcall AddToolTip(int IconType, AnsiString Text, AnsiString Title);
	void __fastcall DestroyToolTip(void);
	void __fastcall SetShowModified(const TShowModified* Value);
	void __fastcall SetBalloonSettings(const TBalloonSettings* Value);
	void __fastcall SearchEditChange(System::TObject* Sender);
	void __fastcall SearchBackward(System::TObject* Sender);
	void __fastcall SearchForward(System::TObject* Sender);
	void __fastcall SearchExit(System::TObject* Sender);
	void __fastcall SearchHighLight(System::TObject* Sender);
	void __fastcall SetScrollBarAlways(const TScrollBarAlways Value);
	
protected:
	Windows::TPoint FClipTopLeft;
	TClipOperation FClipLastOp;
	THTMLHintWindow* FScrollHintWnd;
	bool FScrollHintShow;
	bool FVirtualCells;
	AnsiString FCellCache;
	bool FNoRTLOrientation;
	void __fastcall SubclassProc(Messages::TMessage &Msg);
	virtual void __fastcall DoCalcFooter(int ACol);
	virtual void __fastcall UpdateEditingCell(int ACol, int ARow, AnsiString Value);
	virtual void __fastcall UpdateOnSelection(Grids::TGridRect &GR);
	virtual void __fastcall PasteInCell(int ACol, int ARow, AnsiString Value);
	virtual AnsiString __fastcall GetCurrentCell();
	virtual void __fastcall SetCurrentCell(const AnsiString AValue);
	virtual void __fastcall RestoreCache(void);
	void __fastcall ThemeAdapt(void);
	virtual bool __fastcall ToggleCheck(int ACol, int ARow, bool FromEdit);
	void __fastcall AdvanceEdit(int ACol, int ARow, bool Advance, bool Show, bool Frwrd, bool Recurs);
	void __fastcall AdvanceHTMLEdit(int ACol, int ARow, AnsiString CtrlID);
	virtual bool __fastcall IsFixed(int ACol, int ARow);
	TCellGraphic* __fastcall GetGraphicDetails(int ACol, int ARow, int &W, int &H, bool &DisplText, TCellHAlign 
		&HA, TCellVAlign &VA);
	virtual AnsiString __fastcall GetFormattedCell(int ACol, int ARow);
	virtual int __fastcall NodeIndent(int ARow);
	virtual bool __fastcall HasNodes(void);
	void __fastcall UpdateFooter(void);
	virtual TCellType __fastcall GetCellType(int ACol, int ARow);
	virtual TCellGraphic* __fastcall GetCellGraphic(int ACol, int ARow);
	virtual Windows::TPoint __fastcall GetCellGraphicSize(int ACol, int ARow);
	virtual Windows::TPoint __fastcall GetPrintGraphicSize(int ACol, int ARow, int CW, int RH, double ResFactor
		);
	virtual void __fastcall DrawCell(int ACol, int ARow, const Windows::TRect &ARect, Grids::TGridDrawState 
		AState);
	virtual void __fastcall DrawGridCell(Graphics::TCanvas* Canvas, int ACol, int ARow, const Windows::TRect 
		&ARect, Grids::TGridDrawState AState);
	void __fastcall DrawWallPaperFixed(const Windows::TRect &crect);
	void __fastcall DrawWallPaperTile(const Windows::TRect &crect);
	DYNAMIC void __fastcall KeyUp(Word &Key, Classes::TShiftState Shift);
	virtual Grids::TInplaceEdit* __fastcall CreateEditor(void);
	virtual bool __fastcall CanEditShow(void);
	DYNAMIC void __fastcall SetEditText(int ACol, int ARow, const AnsiString Value);
	DYNAMIC AnsiString __fastcall GetEditText(int ACol, int ARow);
	DYNAMIC void __fastcall MouseMove(Classes::TShiftState Shift, int X, int Y);
	DYNAMIC void __fastcall MouseDown(Controls::TMouseButton Button, Classes::TShiftState Shift, int X, 
		int Y);
	DYNAMIC void __fastcall MouseUp(Controls::TMouseButton Button, Classes::TShiftState Shift, int X, int 
		Y);
	DYNAMIC void __fastcall ColumnMoved(int FromIndex, int ToIndex);
	DYNAMIC void __fastcall RowMoved(int FromIndex, int ToIndex);
	DYNAMIC void __fastcall KeyPress(char &Key);
	virtual void __fastcall DestroyWnd(void);
	virtual void __fastcall CreateWnd(void);
	virtual void __fastcall Loaded(void);
	virtual bool __fastcall SelectCell(int ACol, int ARow);
	virtual void __fastcall WndProc(Messages::TMessage &Message);
	DYNAMIC void __fastcall SizeChanged(int OldColCount, int OldRowCount);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation AOperation
		);
	DYNAMIC void __fastcall DragOver(System::TObject* Source, int X, int Y, Controls::TDragState State, 
		bool &Accept);
	void __fastcall DragTimerProc(System::TObject* Sender);
	virtual void __fastcall CalcSizingState(int X, int Y, Grids::TGridState &State, int &Index, int &SizingPos
		, int &SizingOfs, Grids::TGridDrawInfo &FixedInfo);
	virtual void __fastcall SelectionChanged(int ALeft, int ATop, int ARight, int ABottom);
	virtual void __fastcall EditProgress(AnsiString Value, const Windows::TPoint &pt, int SelPos);
	virtual void __fastcall DoInsertRow(int ARow);
	virtual void __fastcall DoDeleteRow(int ARow);
	DYNAMIC void __fastcall Click(void);
	DYNAMIC void __fastcall DoEnter(void);
	DYNAMIC void __fastcall DoExit(void);
	virtual void __fastcall Paint(void);
	void __fastcall PaintBackground(void);
	DYNAMIC int __fastcall GetEditLimit(void);
	DYNAMIC void __fastcall ColWidthsChanged(void);
	DYNAMIC void __fastcall RowHeightsChanged(void);
	void __fastcall InvalidateGridRect(const Grids::TGridRect &r);
	DYNAMIC void __fastcall TopLeftChanged(void);
	virtual void __fastcall FloatFooterUpdate(void);
	virtual void __fastcall UpdateColSize(int ACol, int &NewWidth);
	virtual void __fastcall UpdateAutoColSize(int ACol, int &NewWidth);
	virtual void __fastcall UpdateColHeaders(void);
	virtual AnsiString __fastcall EllipsClick(AnsiString s);
	virtual bool __fastcall MatchFilter(int ARow);
	virtual void __fastcall PasteNotify(const Windows::TPoint &orig, const Grids::TGridRect &gr, TClipOperation 
		LastOp);
	virtual AnsiString __fastcall CalcCell(int ACol, int ARow);
	virtual AnsiString __fastcall SaveCell(int ACol, int ARow);
	virtual void __fastcall LoadCell(int ACol, int ARow, AnsiString Value);
	virtual void __fastcall UpdateCell(int ACol, int ARow);
	virtual void __fastcall InitValidate(int ACol, int ARow);
	virtual void __fastcall CellsChanged(const Windows::TRect &R);
	virtual void __fastcall CellsLoaded(void);
	virtual void __fastcall GetCellHint(int ACol, int ARow, AnsiString &AHint);
	virtual void __fastcall GetCellColor(int ACol, int ARow, Grids::TGridDrawState AState, Graphics::TBrush* 
		ABrush, Graphics::TFont* AFont);
	virtual void __fastcall GetCellPrintColor(int ACol, int ARow, Grids::TGridDrawState AState, Graphics::TBrush* 
		ABrush, Graphics::TFont* AFont);
	virtual void __fastcall GetCellBorder(int ACol, int ARow, Graphics::TPen* APen, TCellBorders &Borders
		);
	virtual void __fastcall GetCellPrintBorder(int ACol, int ARow, Graphics::TPen* APen, TCellBorders &
		Borders);
	virtual void __fastcall GetCellAlign(int ACol, int ARow, Classes::TAlignment &HAlign, Basegrid::TVAlignment 
		&VAlign);
	virtual void __fastcall GetColFormat(int ACol, TSortStyle &AStyle, AnsiString &aPrefix, AnsiString 
		&aSuffix);
	virtual void __fastcall GetCellEditor(int ACol, int ARow, Basegrid::TEditorType &AEditor);
	virtual void __fastcall GetCellFixed(int ACol, int ARow, bool &IsFixed);
	virtual void __fastcall GetCellReadOnly(int ACol, int ARow, bool &IsReadOnly);
	virtual void __fastcall GetCellPassword(int ACol, int ARow, bool &IsPassword);
	virtual void __fastcall GetCellWordWrap(int ACol, int ARow, bool &WordWrap);
	virtual bool __fastcall HasCombo(int ACol, int ARow);
	virtual AnsiString __fastcall GetCheckTrue(int ACol, int ARow);
	virtual AnsiString __fastcall GetCheckFalse(int ACol, int ARow);
	virtual bool __fastcall GetFilter(int ACol);
	int __fastcall GetSaveStartCol(void);
	int __fastcall GetSaveStartRow(void);
	int __fastcall GetSaveEndCol(void);
	int __fastcall GetSaveEndRow(void);
	int __fastcall GetSaveRowCount(void);
	int __fastcall GetSaveColCount(void);
	virtual void __fastcall RemoveRowsInternal(int RowIndex, int RCount);
	void __fastcall StretchColumn(int ACol);
	void __fastcall PrivatePrintRect(const Grids::TGridRect &Gridrect, bool SelRows);
	void __fastcall PrivatePrintPreviewRect(Graphics::TCanvas* Canvas, const Windows::TRect &Displayrect
		, const Grids::TGridRect &Gridrect, bool SelRows);
	void __fastcall DoneEditing(void);
	void __fastcall UpdateActiveCells(int co, int ro, int cn, int rn);
	bool __fastcall HasDataCell(int ACol, int ARow);
	virtual void __fastcall QueryAddRow(bool &AllowAdd);
	virtual void __fastcall QueryInsertRow(int ARow, bool &AllowInsert);
	DYNAMIC bool __fastcall DoMouseWheelDown(Classes::TShiftState Shift, const Windows::TPoint &MousePos
		);
	DYNAMIC bool __fastcall DoMouseWheelUp(Classes::TShiftState Shift, const Windows::TPoint &MousePos)
		;
	void __fastcall UpdateVScroller(void);
	void __fastcall UpdateHScroller(void);
	virtual void __fastcall DoAppendRow(void);
	void __fastcall AddSummary(int ARow);
	void __fastcall IRemoveRows(int RowIndex, int RCount, bool flg);
	void __fastcall CorrectSelection(void);
	__property bool CellSelectorMode = {read=FCellSelectorMode, write=FCellSelectorMode, nodefault};
	virtual void __fastcall CellSelect(int c, int r);
	virtual void __fastcall SetCellSelectMode(const bool Value);
	void __fastcall BalloonChange(System::TObject* Sender);
	void __fastcall ModifiedChanged(System::TObject* Sender);
	void __fastcall SearchChanged(System::TObject* Sender);
	virtual void __fastcall UpdateSelectionRect(Grids::TGridRect &GR);
	
public:
	bool LButFlg;
	int Compares;
	int Swaps;
	unsigned SortTime;
	Classes::TStringList* Sortlist;
	int PrevSizeX;
	int PrevSizeY;
	bool EditMode;
	tagSIZE __fastcall GetCellTextSize(int ACol, int ARow, bool VS);
	virtual void __fastcall ExportNotification(TGridExportState AState, int ARow);
	virtual void __fastcall ImportNotification(TGridImportState AState, int ARow);
	void __fastcall CellControlsUpdate(void);
	void __fastcall RegisterNotifier(TGridChangeNotifier* ANotifier);
	void __fastcall UnRegisterNotifier(TGridChangeNotifier* ANotifier);
	void __fastcall ClearComboString(void);
	void __fastcall AddComboString(const AnsiString s);
	void __fastcall AddComboStringObject(const AnsiString s, System::TObject* AObject);
	bool __fastcall RemoveComboString(const AnsiString s);
	bool __fastcall SetComboSelectionString(const AnsiString s);
	void __fastcall SetComboSelection(int idx);
	int __fastcall GetComboCount(void);
	__fastcall virtual TAdvStringGrid(Classes::TComponent* AOwner);
	__fastcall virtual ~TAdvStringGrid(void);
	virtual void __fastcall Invalidate(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	virtual void __fastcall GetVisualProperties(int ACol, int ARow, Grids::TGridDrawState &AState, bool 
		Print, bool Select, bool Remap, Graphics::TBrush* ABrush, Graphics::TColor &AColorTo, Graphics::TFont* 
		AFont, Classes::TAlignment &HA, Basegrid::TVAlignment &VA, bool &WW);
	virtual void __fastcall SetBounds(int ALeft, int ATop, int AWidth, int AHeight);
	virtual int __fastcall GetVersionNr(void);
	virtual AnsiString __fastcall GetVersionString();
	virtual bool __fastcall ValidateCell(const AnsiString NewValue);
	virtual bool __fastcall ValidateCellWide(const WideString NewValue);
	void __fastcall BalloonInit(void);
	void __fastcall BalloonDone(void);
	virtual void __fastcall RemoveRowsEx(int RowIndex, int RCount);
	virtual void __fastcall RemoveRows(int RowIndex, int RCount);
	virtual void __fastcall InsertRows(int RowIndex, int RCount);
	virtual void __fastcall RemoveCols(int ColIndex, int CCount);
	virtual void __fastcall InsertCols(int ColIndex, int CCount);
	void __fastcall AddColumn(void);
	void __fastcall AddRow(void);
	DYNAMIC void __fastcall Resize(void);
	void __fastcall FilterRow(int ARow);
	int __fastcall GetParentRow(int ARow);
	void __fastcall InsertChildRow(int ARow, int InsertAt);
	void __fastcall RemoveChildRow(int ARow);
	void __fastcall InsertNormalRow(int ARow);
	void __fastcall RemoveNormalRow(int ARow);
	void __fastcall RemoveSelectedRows(void);
	void __fastcall RemoveUnSelectedRows(void);
	void __fastcall RemoveDuplicates(int ACol, bool DoCase);
	void __fastcall MergeCols(int ColIndex1, int ColIndex2, AnsiString Separator);
	void __fastcall MergeColumnCells(int ColIndex, bool MainMerge);
	void __fastcall SplitColumnCells(int ColIndex);
	void __fastcall MergeRowCells(int RowIndex, bool MainMerge);
	void __fastcall SplitRowCells(int RowIndex);
	void __fastcall SplitAllCells(void);
	bool __fastcall IsSummary(int ARow);
	void __fastcall SwapColumns(int ACol1, int ACol2);
	void __fastcall HideColumn(int ColIndex);
	void __fastcall UnHideColumn(int ColIndex);
	void __fastcall HideColumns(int FromCol, int ToCol);
	void __fastcall UnHideColumns(int FromCol, int ToCol);
	void __fastcall UnHideColumnsAll(void);
	bool __fastcall IsHiddenColumn(int Colindex);
	int __fastcall NumHiddenColumns(void);
	int __fastcall TotalColCount(void);
	void __fastcall RepaintRect(const Windows::TRect &r);
	HIDESBASE void __fastcall RepaintCell(int c, int r);
	void __fastcall RepaintRow(int ARow);
	void __fastcall RepaintCol(int ACol);
	void __fastcall GroupCalc(int Colindex, int method);
	void __fastcall GroupSum(int Colindex);
	void __fastcall GroupAvg(int Colindex);
	void __fastcall GroupMin(int Colindex);
	void __fastcall GroupMax(int Colindex);
	void __fastcall GroupCount(int ColIndex);
	virtual void __fastcall SubGroup(int Colindex);
	virtual void __fastcall SubUnGroup(int Colindex);
	virtual void __fastcall Group(int Colindex);
	virtual void __fastcall UnGroup(void);
	void __fastcall HideRow(int Rowindex);
	void __fastcall HideRows(int FromRow, int ToRow);
	void __fastcall HideRowList(Advobj::TIntList* RowList);
	void __fastcall HideRowsEx(int FromRow, int ToRow);
	void __fastcall UnHideRow(int Rowindex);
	void __fastcall UnHideRows(int FromRow, int ToRow);
	void __fastcall UnHideRowList(void);
	void __fastcall UnHideRowsAll(void);
	void __fastcall HideSelectedRows(void);
	void __fastcall HideUnSelectedRows(void);
	bool __fastcall IsHiddenRow(int Rowindex);
	int __fastcall NumHiddenRows(void);
	int __fastcall TotalRowCount(void);
	int __fastcall RealRowIndex(int ARow);
	int __fastcall RealColIndex(int ACol);
	int __fastcall DisplRowIndex(int ARow);
	virtual int __fastcall DisplColIndex(int ACol);
	void __fastcall SetColumnOrder(void);
	void __fastcall ResetColumnOrder(void);
	int __fastcall UnSortedRowIndex(int ARow);
	int __fastcall SortedRowIndex(int ARow);
	int __fastcall GetRealCol(void);
	int __fastcall GetRealRow(void);
	int __fastcall GetRowEx(void);
	void __fastcall SetRowEx(const int Value);
	void __fastcall ScreenToCell(const Windows::TPoint &pt, int &ACol, int &ARow);
	void __fastcall HideSelection(void);
	void __fastcall UnHideSelection(void);
	void __fastcall ScrollInView(int ColIndex, int RowIndex);
	HIDESBASE void __fastcall MoveRow(int FromIndex, int ToIndex);
	HIDESBASE void __fastcall MoveColumn(int FromIndex, int ToIndex);
	void __fastcall SwapRows(int ARow1, int ARow2);
	virtual void __fastcall SortSwapRows(int ARow1, int ARow2);
	virtual void __fastcall ClearRect(int ACol1, int ARow1, int ACol2, int ARow2);
	void __fastcall Clear(void);
	void __fastcall ClearRows(int RowIndex, int RCount);
	void __fastcall ClearCols(int ColIndex, int CCount);
	void __fastcall ClearNormalRows(int RowIndex, int RCount);
	void __fastcall ClearNormalCols(int ColIndex, int CCount);
	void __fastcall ClearNormalCells(void);
	void __fastcall ClearSelection(void);
	void __fastcall ClearRowSelect(void);
	void __fastcall ClearColSelect(void);
	void __fastcall SelectRows(int RowIndex, int RCount);
	void __fastcall SelectCols(int ColIndex, int CCount);
	void __fastcall SelectRange(int FromCol, int ToCol, int FromRow, int ToRow);
	void __fastcall ClearSelectedCells(void);
	void __fastcall ClearModifiedRows(void);
	bool __fastcall IsCell(AnsiString SubStr, int &ACol, int &ARow);
	bool __fastcall IsWideCell(int ACol, int ARow);
	void __fastcall SaveToFile(AnsiString FileName);
	void __fastcall SaveToBinFile(AnsiString FileName);
	void __fastcall SaveToBinStream(Classes::TStream* Stream);
	void __fastcall SaveRectToBinStream(const Windows::TRect &Rect, Classes::TStream* Stream);
	void __fastcall SaveToHTML(AnsiString FileName);
	AnsiString __fastcall SaveToHTMLString();
	void __fastcall AppendToHTML(AnsiString FileName);
	void __fastcall SaveToXML(AnsiString FileName, AnsiString ListDescr, AnsiString RecordDescr, Classes::TStrings* 
		FieldDescr);
	void __fastcall LoadFromXML(AnsiString FileName, bool LevelToRow);
	void __fastcall AppendToASCII(AnsiString FileName);
	void __fastcall SaveToASCII(AnsiString FileName);
	void __fastcall SaveToCSV(AnsiString FileName);
	void __fastcall AppendToCSV(AnsiString FileName);
	void __fastcall SaveToFixed(AnsiString FileName, Advobj::TIntList* positions);
	void __fastcall SaveToStream(Classes::TStream* Stream);
	void __fastcall LoadFromFile(AnsiString FileName);
	void __fastcall LoadFromBinFile(AnsiString FileName);
	void __fastcall LoadFromBinStream(Classes::TStream* Stream);
	void __fastcall LoadAtPointFromBinStream(const Windows::TPoint &Point, Classes::TStream* Stream);
	void __fastcall LoadFromCSV(AnsiString FileName);
	void __fastcall LoadFromFixed(AnsiString FileName, Advobj::TIntList* positions);
	void __fastcall InsertFromCSV(AnsiString FileName);
	void __fastcall LoadFromStream(Classes::TStream* Stream);
	void __fastcall SaveColSizes(void);
	void __fastcall LoadColSizes(void);
	void __fastcall SaveColPositions(void);
	void __fastcall LoadColPositions(void);
	void __fastcall LoadVisualProps(AnsiString FileName);
	void __fastcall SaveVisualProps(AnsiString FileName);
	void __fastcall SavePrintSettings(AnsiString Key, AnsiString Section);
	void __fastcall LoadPrintSettings(AnsiString Key, AnsiString Section);
	void __fastcall CutToClipboard(void);
	void __fastcall CutSelectionToClipboard(void);
	void __fastcall CopyToClipBoard(void);
	void __fastcall CopyToClipBoardAsHTML(void);
	void __fastcall CopySelectionToClipboard(void);
	void __fastcall PasteFromClipboard(void);
	void __fastcall PasteSelectionFromClipboard(void);
	void __fastcall ShowColumnHeaders(void);
	void __fastcall ClearColumnHeaders(void);
	void __fastcall ShowRowHeaders(void);
	void __fastcall ClearRowHeaders(void);
	void __fastcall HideCellEdit(void);
	void __fastcall ShowCellEdit(void);
	void __fastcall RandomFill(bool DoFixed, int Rnd);
	void __fastcall LinearFill(bool DoFixed);
	void __fastcall TextFill(bool DoFixed, AnsiString Txt);
	AnsiString __fastcall HilightText(bool DoCase, AnsiString S, AnsiString Text);
	AnsiString __fastcall UnHilightText(AnsiString S);
	void __fastcall HilightInCell(bool DoCase, int Col, int Row, AnsiString HiText);
	void __fastcall HilightInCol(bool DoFixed, bool DoCase, int Col, AnsiString HiText);
	void __fastcall HilightInRow(bool DoFixed, bool DoCase, int Row, AnsiString HiText);
	void __fastcall HilightInGrid(bool DoFixed, bool DoCase, AnsiString HiText);
	void __fastcall UnHilightInCell(int Col, int Row);
	void __fastcall UnHilightInCol(bool DoFixed, int Col);
	void __fastcall UnHilightInRow(bool DoFixed, int Row);
	void __fastcall UnHilightInGrid(bool DoFixed);
	AnsiString __fastcall MarkText(bool DoCase, AnsiString S, AnsiString Text);
	AnsiString __fastcall UnMarkText(AnsiString S);
	void __fastcall MarkInCell(bool DoCase, int Col, int Row, AnsiString HiText);
	void __fastcall MarkInCol(bool DoFixed, bool DoCase, int Col, AnsiString HiText);
	void __fastcall MarkInRow(bool DoFixed, bool DoCase, int Row, AnsiString HiText);
	void __fastcall MarkInGrid(bool DoFixed, bool DoCase, AnsiString 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);
	bool __fastcall CheckCells(int FromCol, int FromRow, int ToCol, int ToRow);
	bool __fastcall CheckCell(int Col, int Row);
	bool __fastcall CheckGrid(bool DoFixed);
	bool __fastcall CheckCol(bool DoFixed, int Col);
	bool __fastcall CheckRow(bool DoFixed, int Row);
	void __fastcall Zoom(int x);
	void __fastcall SaveToXLS(AnsiString Filename, bool CreateNewSheet);
	void __fastcall SaveToXLSSheet(AnsiString Filename, AnsiString SheetName);
	Classes::TStringList* __fastcall GetXLSSheets(AnsiString FileName);
	void __fastcall LoadFromXLS(AnsiString Filename);
	void __fastcall LoadFromXLSSheet(AnsiString Filename, AnsiString SheetName);
	void __fastcall LoadFromMDBTable(AnsiString Filename, AnsiString Table);
	void __fastcall LoadFromMDBSQL(AnsiString Filename, AnsiString SQL);
	void __fastcall AppendToDoc(AnsiString Filename, AnsiString Bookmark);
	void __fastcall SaveToDOC(AnsiString Filename, bool CreateNewDocument);
	void __fastcall RichToCell(int Col, int Row, Comctrls::TRichEdit* Richeditor);
	AnsiString __fastcall RichToString(Comctrls::TRichEdit* Richeditor);
	void __fastcall CellToRich(int Col, int Row, Comctrls::TRichEdit* Richeditor);
	void __fastcall AutoSizeCells(const bool DoFixedCells, const int PaddingX, const int PaddingY);
	void __fastcall AutoSizeColumns(const bool DoFixedCols, const int Padding);
	void __fastcall AutoSizeCol(const int ACol);
	void __fastcall AutoSizeRows(const bool DoFixedRows, const int Padding);
	void __fastcall AutoSizeRow(const int ARow);
	void __fastcall StretchRightColumn(void);
	void __fastcall AutoNumberCol(const int ACol);
	void __fastcall AutoNumberRow(const int ARow);
	HIDESBASE bool __fastcall IsSelected(int ACol, int ARow);
	AnsiString __fastcall SelectedText();
	void __fastcall ShowInplaceEdit(void);
	void __fastcall HideInplaceEdit(void);
	void __fastcall DoneInplaceEdit(Word Key, Classes::TShiftState Shift);
	virtual void __fastcall QSort(void);
	virtual void __fastcall QSortIndexed(void);
	virtual void __fastcall QSortGroup(void);
	virtual void __fastcall QSortGroupIndexed(void);
	virtual void __fastcall QUnSort(void);
	void __fastcall InitSortXRef(void);
	void __fastcall Print(void);
	void __fastcall PrintRect(const Grids::TGridRect &Gridrect);
	void __fastcall PrintSelection(void);
	void __fastcall PrintSelectedRows(void);
	void __fastcall PrintSelectedCols(void);
	void __fastcall PrintPreview(Graphics::TCanvas* Canvas, const Windows::TRect &Displayrect);
	void __fastcall PrintPreviewRect(Graphics::TCanvas* Canvas, const Windows::TRect &Displayrect, const 
		Grids::TGridRect &Gridrect);
	void __fastcall PrintPreviewSelectedRows(Graphics::TCanvas* Canvas, const Windows::TRect &Displayrect
		);
	void __fastcall PrintPreviewSelectedCols(Graphics::TCanvas* Canvas, const Windows::TRect &Displayrect
		);
	void __fastcall PrintPreviewSelection(Graphics::TCanvas* Canvas, const Windows::TRect &Displayrect)
		;
	void __fastcall PrintDraw(Graphics::TCanvas* Canvas, const Windows::TRect &DrawRect);
	void __fastcall PrintDrawRect(Graphics::TCanvas* Canvas, const Windows::TRect &DrawRect, const Grids::TGridRect 
		&Gridrect);
	void __fastcall SortByColumn(int Col);
	void __fastcall QuickSort(int Col, int Left, int Right);
	void __fastcall QuickSortIndexed(int Left, int Right);
	bool __fastcall SortLine(int Col, int ARow1, int ARow2);
	int __fastcall Search(AnsiString s);
	Windows::TPoint __fastcall Find(const Windows::TPoint &StartCell, AnsiString s, TFindParams FindParams
		);
	Windows::TPoint __fastcall FindWide(const Windows::TPoint &StartCell, WideString s, TFindParams FindParams
		);
	Windows::TPoint __fastcall FindFirst(AnsiString s, TFindParams FindParams);
	Windows::TPoint __fastcall FindNext();
	int __fastcall MapFontHeight(int pointsize);
	int __fastcall MapFontSize(int Height);
	Graphics::TBitmap* __fastcall CreateBitmap(int ACol, int ARow, bool transparent, TCellHAlign hal, TCellVAlign 
		val);
	void __fastcall AddBitmap(int ACol, int ARow, Graphics::TBitmap* ABmp, bool Transparent, TCellHAlign 
		hal, TCellVAlign val);
	void __fastcall RemoveBitmap(int ACol, int ARow);
	Graphics::TBitmap* __fastcall GetBitmap(int ACol, int ARow);
	Graphics::TPicture* __fastcall CreatePicture(int ACol, int ARow, bool transparent, TStretchMode stretchmode
		, int padding, TCellHAlign hal, TCellVAlign val);
	void __fastcall AddPicture(int ACol, int ARow, Graphics::TPicture* APicture, bool transparent, TStretchMode 
		stretchmode, int padding, TCellHAlign hal, TCellVAlign val);
	void __fastcall RemovePicture(int ACol, int ARow);
	Graphics::TPicture* __fastcall GetPicture(int ACol, int ARow);
	Advobj::TFilePicture* __fastcall CreateFilePicture(int ACol, int ARow, bool Transparent, TStretchMode 
		StretchMode, int padding, TCellHAlign hal, TCellVAlign val);
	void __fastcall AddFilePicture(int ACol, int ARow, Advobj::TFilePicture* AFilePicture, bool Transparent
		, TStretchMode stretchmode, int padding, TCellHAlign hal, TCellVAlign val);
	void __fastcall RemoveFilePicture(int ACol, int ARow);
	Advobj::TFilePicture* __fastcall GetFilePicture(int ACol, int ARow);
	void __fastcall AddNode(int ARow, int Span);
	void __fastcall RemoveNode(int ARow);
	void __fastcall RemoveAllNodes(void);
	bool __fastcall IsNode(int ARow);
	int __fastcall GetNodeSpanType(int ARow);
	bool __fastcall GetNodeState(int ARow);
	int __fastcall GetNodeLevel(int ARow);
	void __fastcall SetNodeState(int ARow, bool Value);
	int __fastcall GetNodeSpan(int ARow);
	void __fastcall SetNodeSpan(int ARow, int Span);
	void __fastcall UpdateNodeSpan(int ARow, int Delta);
	void __fastcall ExpandNode(int ARow);
	void __fastcall ContractNode(int ARow);
	void __fastcall ExpandAll(void);
	void __fastcall ContractAll(void);
	void __fastcall AddRadio(int ACol, int ARow, int DirRadio, int IdxRadio, Classes::TStrings* sl);
	Classes::TStrings* __fastcall CreateRadio(int ACol, int ARow, int DirRadio, int IdxRadio);
	void __fastcall RemoveRadio(int ACol, int ARow);
	bool __fastcall IsRadio(int ACol, int ARow);
	bool __fastcall GetRadioIdx(int ACol, int ARow, int &IdxRadio);
	bool __fastcall SetRadioIdx(int ACol, int ARow, int IdxRadio);
	Classes::TStrings* __fastcall GetRadioStrings(int ACol, int ARow);
	void __fastcall AddImageIdx(int ACol, int ARow, int Aidx, TCellHAlign hal, TCellVAlign val);
	void __fastcall RemoveImageIdx(int ACol, int ARow);
	bool __fastcall GetImageIdx(int ACol, int ARow, int &idx);
	void __fastcall AddMultiImage(int ACol, int ARow, int Dir, TCellHAlign hal, TCellVAlign val);
	void __fastcall RemoveMultiImage(int ACol, int ARow);
	void __fastcall AddDataImage(int ACol, int ARow, int Aidx, TCellHAlign hal, TCellVAlign val);
	void __fastcall RemoveDataImage(int ACol, int ARow);
	bool __fastcall HasDataImage(int ACol, int ARow);
	void __fastcall AddRotated(int ACol, int ARow, short AAngle, AnsiString s);
	void __fastcall SetRotated(int ACol, int ARow, short AAngle);
	void __fastcall RemoveRotated(int ACol, int ARow);
	bool __fastcall IsRotated(int ACol, int ARow, int &aAngle);
	Graphics::TIcon* __fastcall CreateIcon(int ACol, int ARow, TCellHAlign hal, TCellVAlign val);
	void __fastcall AddIcon(int ACol, int ARow, Graphics::TIcon* AIcon, TCellHAlign hal, TCellVAlign val
		);
	void __fastcall RemoveIcon(int ACol, int ARow);
	void __fastcall AddButton(int ACol, int ARow, int bw, int bh, AnsiString Caption, TCellHAlign hal, 
		TCellVAlign val);
	void __fastcall SetButtonText(int ACol, int ARow, AnsiString Caption);
	void __fastcall PushButton(int ACol, int ARow, bool push);
	void __fastcall RemoveButton(int ACol, int ARow);
	bool __fastcall HasButton(int ACol, int ARow);
	void __fastcall AddBitButton(int ACol, int ARow, int bw, int bh, AnsiString Caption, Graphics::TBitmap* 
		Glyph, TCellHAlign hal, TCellVAlign val);
	Graphics::TBitmap* __fastcall CreateBitButton(int ACol, int ARow, int bw, int bh, AnsiString Caption
		, TCellHAlign hal, TCellVAlign val);
	void __fastcall AddCheckBox(int ACol, int ARow, bool State, bool Data);
	void __fastcall RemoveCheckBox(int ACol, int ARow);
	bool __fastcall HasCheckBox(int ACol, int ARow);
	bool __fastcall IsInCheckBox(int ACol, int ARow, int XPos, int YPos);
	bool __fastcall HasDataCheckBox(int ACol, int ARow);
	bool __fastcall GetCheckBoxState(int ACol, int ARow, bool &state);
	bool __fastcall SetCheckBoxState(int ACol, int ARow, bool state);
	bool __fastcall ToggleCheckBox(int ACol, int ARow);
	void __fastcall CheckAll(int ACol);
	void __fastcall UnCheckAll(int ACol);
	void __fastcall AddProgress(int ACol, int ARow, Graphics::TColor FGColor, Graphics::TColor BKColor)
		;
	void __fastcall AddProgressEx(int ACol, int ARow, Graphics::TColor FGColor, Graphics::TColor FGTextColor
		, Graphics::TColor BKColor, Graphics::TColor BKTextColor);
	void __fastcall AddProgressFormatted(int ACol, int ARow, Graphics::TColor FGColor, Graphics::TColor 
		FGTextColor, Graphics::TColor BKColor, Graphics::TColor BKTextColor, AnsiString Fmt, int Min, int 
		Max);
	void __fastcall RemoveProgress(int ACol, int ARow);
	void __fastcall AddProgressPie(int ACol, int ARow, Graphics::TColor Color, int Value);
	void __fastcall SetProgressPie(int ACol, int ARow, int Value);
	void __fastcall RemoveProgressPie(int ACol, int ARow);
	void __fastcall AddRangeIndicator(int ACol, int ARow, int Range, Graphics::TColor NegColor, Graphics::TColor 
		PosColor, bool ShowValue);
	void __fastcall RemoveRangeIndicator(int ACol, int ARow);
	void __fastcall AddComment(int ACol, int ARow, AnsiString Comment);
	void __fastcall AddColorComment(int ACol, int ARow, AnsiString Comment, Graphics::TColor Color);
	void __fastcall RemoveComment(int ACol, int ARow);
	void __fastcall RemoveAllComments(void);
	void __fastcall AddMarker(int ACol, int ARow, int ErrPos, int ErrLen);
	void __fastcall RemoveMarker(int ACol, int ARow);
	void __fastcall RemoveAllMarkers(void);
	void __fastcall GetMarker(int ACol, int ARow, int &ErrPos, int &ErrLen);
	bool __fastcall IsComment(int ACol, int ARow, AnsiString &comment);
	double __fastcall ColumnSum(int ACol, int fromRow, int toRow);
	double __fastcall ColumnAvg(int ACol, int fromRow, int toRow);
	double __fastcall ColumnMin(int ACol, int fromRow, int toRow);
	double __fastcall ColumnMax(int ACol, int fromRow, int toRow);
	double __fastcall RowSum(int ARow, int fromCol, int toCol);
	double __fastcall RowAvg(int ARow, int fromCol, int toCol);
	double __fastcall RowMin(int ARow, int fromCol, int toCol);
	double __fastcall RowMax(int ARow, int fromCol, int toCol);
	virtual void __fastcall CalcFooter(int ACol);
	void __fastcall BeginUpdate(void);
	void __fastcall EndUpdate(void);
	void __fastcall StartUpdate(void);
	void __fastcall ResetUpdate(void);
	__property bool LockUpdate = {read=GetLockFlag, write=SetLockFlag, nodefault};
	__property TCellType CellTypes[int ACol][int ARow] = {read=GetCellType};
	__property TCellGraphic* CellGraphics[int ACol][int ARow] = {read=GetCellGraphic};
	__property Windows::TPoint CellGraphicSize[int ACol][int ARow] = {read=GetCellGraphicSize};
	__property Advobj::TIntList* CellImages[int ACol][int ARow] = {read=GetCellImages};
	__property int Ints[int ACol][int ARow] = {read=GetInts, write=SetInts};
	__property double Floats[int ACol][int ARow] = {read=GetFloats, write=SetFloats};
	__property double AllFloats[int ACol][int ARow] = {read=GetAllFloats, write=SetAllFloats};
	__property System::TDateTime Dates[int ACol][int ARow] = {read=GetDates, write=SetDates};
	__property System::TDateTime Times[int ACol][int ARow] = {read=GetTimes, write=SetTimes};
	__property AnsiString ControlValues[int ACol][int ARow][AnsiString ID] = {read=GetCtrlVal, write=SetCtrlVal
		};
	__property char Delimiter = {read=FDelimiter, write=FDelimiter, nodefault};
	__property bool NoDefaultDraw = {read=FNoDefaultDraw, write=FNoDefaultDraw, nodefault};
	__property char PasswordChar = {read=FPasswordChar, write=FPasswordChar, nodefault};
	__property bool JavaCSV = {read=FJavaCSV, write=FJavaCSV, nodefault};
	__property bool FastPrint = {read=FFastPrint, write=FFastPrint, nodefault};
	__property AnsiString CheckTrue = {read=FCheckTrue, write=FCheckTrue};
	__property AnsiString CheckFalse = {read=FCheckFalse, write=FCheckFalse};
	__property bool SaveFixedCells = {read=FSaveFixedCells, write=FSaveFixedCells, nodefault};
	__property bool SaveHiddenCells = {read=FSaveHiddenCells, write=FSaveHiddenCells, nodefault};
	__property bool SaveVirtCells = {read=FSaveVirtCells, write=FSaveVirtCells, nodefault};
	__property bool SaveWithHTML = {read=FSaveWithHTML, write=FSaveWithHTML, nodefault};
	__property Advobj::TSortIndexList* SortIndexes = {read=FSortIndexes};
	__property AnsiString OriginalCellValue = {read=FCellCache};
	__property bool EditActive = {read=FEditActive, nodefault};
	__property Comctrls::TDateTimePicker* DateTimePicker = {read=GetDateTimePicker};
	__property TGridCombo* Combobox = {read=EditCombo};
	__property bool ClearTextOnly = {read=FClearTextOnly, write=FClearTextOnly, nodefault};
	__property TGridUniCombo* UniCombo = {read=ComboUni};
	__property TGridUniEdit* UniEdit = {read=EditUni};
	__property TGridUniEditBtn* UniEditBtn = {read=EditBtnUni};
	__property TGridSpin* SpinEdit = {read=EditSpin};
	__property TGridEditBtn* BtnEdit = {read=EditBtn};
	__property TGridButton* Btn = {read=GridButton};
	__property TGridUnitEditBtn* BtnUnitEdit = {read=UnitEditBtn};
	__property TAdvRichEdit* RichEdit = {read=FRichEdit};
	__property Graphics::TCanvas* FooterCanvas = {read=GetFooterCanvas};
	__property TAdvRichEdit* InplaceRichEdit = {read=FInplaceRichEdit};
	__property AnsiString IncrSearchText = {read=SearchInc, write=SearchInc};
	__property TAdvInplaceEdit* NormalEdit = {read=GetInplaceEditor};
	__property TSearchPanel* SearchPanel = {read=FSearchPanel};
	__property bool PrinterDriverFix = {read=FPrinterdriverfix, write=FPrinterdriverfix, nodefault};
	__property bool RowSelect[int ARow] = {read=GetRowSelect, write=SetRowSelect};
	__property bool ColSelect[int ACol] = {read=GetColSelect, write=SetColSelect};
	__property int RowSelectCount = {read=GetRowSelectCount, nodefault};
	__property int ColSelectCount = {read=GetColSelectCount, nodefault};
	__property bool RowModified[int ARow] = {read=GetRowModified, write=SetRowModified};
	__property bool NodeState[int ARow] = {read=GetNodeState, write=SetNodeState};
	__property bool FindBusy = {read=FFindBusy, nodefault};
	__property Windows::TRect PrintPageRect = {read=FPrintPageRect};
	__property int PrintPageWidth = {read=FPrintPageWidth, nodefault};
	__property int PrintColWidth[int ACol] = {read=GetPrintColWidth};
	__property int PrintColOffset[int ACol] = {read=GetPrintColOffset};
	__property int PrintColStart = {read=FPrintColStart, nodefault};
	__property int PrintColEnd = {read=FPrintColEnd, nodefault};
	__property int PrintNrOfPages = {read=FPrintPageNum, nodefault};
	__property bool ExcelClipboardFormat = {read=FExcelClipboardFormat, write=FExcelClipboardFormat, nodefault
		};
	__property int PreviewPage = {read=FPrintPageFrom, write=SetPreviewPage, nodefault};
	__property AnsiString UnSortedCells[int i][int j] = {read=GetUnSortedCell, write=SetUnSortedCell};
	__property AnsiString DisplCells[int i][int j] = {read=GetFormattedCell};
	__property AnsiString AllCells[int i][int j] = {read=GetCellsEx, write=SetCellsEx};
	__property WideString WideCells[int i][int j] = {read=GetWideCells, write=SetWideCells};
	__property System::TObject* AllObjects[int i][int j] = {read=GetObjectsEx, write=SetObjectsEx};
	__property int AllColWidths[int i] = {read=GetAllColWidths, write=SetAllColWidths};
	__property int AllColCount = {read=GetAllColCount, nodefault};
	__property int AllRowCount = {read=GetAllRowCount, nodefault};
	__property Classes::TAlignment Alignments[int i][int j] = {read=GetAlignments, write=SetAlignments}
		;
	__property Graphics::TColor Colors[int i][int j] = {read=GetColors, write=SetColors};
	__property Graphics::TColor ColorsTo[int i][int j] = {read=GetColorsTo, write=SetColorsTo};
	__property Graphics::TColor RowColor[int i] = {write=SetRowColor};
	__property Graphics::TColor RowColorTo[int i] = {write=SetRowColorTo};
	__property Graphics::TColor RowFontColor[int i] = {write=SetRowFontColor};
	__property Graphics::TColor FontColors[int i][int j] = {read=GetFontColors, write=SetFontColors};
	__property Graphics::TFontStyles FontStyles[int i][int j] = {read=GetFontStyles, write=SetFontStyles
		};
	__property int FontSizes[int i][int j] = {read=GetFontSizes, write=SetFontSizes};
	__property AnsiString FontNames[int i][int j] = {read=GetFontNames, write=SetFontNames};
	__property Controls::TControl* CellControls[int i][int j] = {read=GetCellControls, write=SetCellControls
		};
	__property bool ReadOnly[int i][int j] = {read=GetReadOnly, write=SetReadOnly};
	__property bool WordWraps[int i][int j] = {read=GetWordWraps, write=SetWordWraps};
	__property AnsiString StrippedCells[int i][int j] = {read=GetStrippedCell};
	__property bool SelectedCells[int i][int j] = {read=GetSelectedCells, write=SetSelectedCells};
	__property int SelectedCellsCount = {read=GetSelectedCellsCount, nodefault};
	__property Grids::TGridCoord SelectedCell[int i] = {read=GetSelectedCell};
	__property AnsiString CurrentCell = {read=GetCurrentCell, write=SetCurrentCell};
	__property Graphics::TColor ArrowColor = {read=GetArrowColor, write=SetArrowColor, nodefault};
	__property int GroupColumn = {read=FGroupColumn, write=SetGroupColumn, nodefault};
	__property bool QuoteEmptyCells = {read=FQuoteEmptyCells, write=FQuoteEmptyCells, nodefault};
	__property bool AlwaysQuotes = {read=FAlwaysQuotes, write=FAlwaysQuotes, nodefault};
	__property Graphics::TColor SelectionRectangleColor = {read=FSelectionRectangleColor, write=FSelectionRectangleColor
		, nodefault};
	__property int RealRow = {read=GetRealRow, nodefault};
	__property int RealCol = {read=GetRealCol, nodefault};
	__property int Row = {read=GetRowEx, write=SetRowEx, nodefault};
	__property int SaveStartCol = {read=GetSaveStartCol, nodefault};
	__property int SaveStartRow = {read=GetSaveStartRow, nodefault};
	__property int SaveEndCol = {read=GetSaveEndCol, nodefault};
	__property int SaveEndRow = {read=GetSaveEndRow, nodefault};
	__property int SaveColCount = {read=GetSaveColCount, nodefault};
	__property int SaveRowCount = {read=GetSaveRowCount, nodefault};
	__property bool ShowNullDates = {read=FShowNullDates, write=FShowNullDates, nodefault};
	__property int VersionNr = {read=GetVersionNr, nodefault};
	__property AnsiString VersionString = {read=GetVersionString};
	__property TEditLink* EditLink = {read=FEditLink, write=FEditLink};
	__property Windows::TPoint XYOffset = {read=FXYOffset, write=SetXYOffset};
	__property Picturecontainer::THTMLPictureCache* ImageCache = {read=FImageCache};
	__property Advobj::TIntList* MergedColumns = {read=FMergedColumns};
	__property bool AlwaysValidate = {read=FAlwaysValidate, write=FAlwaysValidate, nodefault};
	__property bool SizeGrowOnly = {read=FSizeGrowOnly, write=FSizeGrowOnly, nodefault};
	__property int MaxRowHeight = {read=FMaxRowHeight, write=FMaxRowHeight, nodefault};
	__property int MinRowHeight = {read=FMinRowHeight, write=FMinRowHeight, nodefault};
	__property int MaxColWidth = {read=FMaxColWidth, write=FMaxColWidth, nodefault};
	__property int MinColWidth = {read=FMinColWidth, write=FMinColWidth, nodefault};
	__property Graphics::TColor TMSGradientFrom = {read=FTMSGradFrom, write=SetTMSGradFrom, nodefault};
		
	__property Graphics::TColor TMSGradientTo = {read=FTMSGradTo, write=SetTMSGradTo, nodefault};
	__property bool UseHTMLHints = {read=FUseHTMLHints, write=SetUseHTMLHints, nodefault};
	__property TSortDirection AutoNumberDirection = {read=FAutoNumberDirection, write=FAutoNumberDirection
		, nodefault};
	__property int AutoNumberOffset = {read=FAutoNumberOffset, write=FAutoNumberOffset, nodefault};
	__property int AutoNumberStart = {read=FAutoNumberStart, write=FAutoNumberStart, nodefault};
	__property Classes::TNotifyEvent OnPainted = {read=FOnPainted, write=FOnPainted};
	__property unsigned UniLocale = {read=FUniLocale, write=FUniLocale, nodefault};
	__property unsigned UniCmpFlgs = {read=FUniCmpFlgs, write=FUniCmpFlgs, nodefault};
	__property int FreewareCode = {read=FFreewareCode, write=FFreewareCode, nodefault};
	
__published:
	__property bool ActiveCellShow = {read=FActiveCellShow, write=SetActiveCellShow, default=0};
	__property Graphics::TFont* ActiveCellFont = {read=FActiveCellFont, write=SetActiveCellFont};
	__property Graphics::TColor ActiveCellColor = {read=FActiveCellColor, write=SetActiveCellColor, default=8421504
		};
	__property Graphics::TColor ActiveCellColorTo = {read=FActiveCellColorTo, write=SetActiveCellColorTo
		, default=536870911};
	__property bool AnchorHint = {read=FAnchorHint, write=FAnchorHint, default=0};
	__property bool AutoThemeAdapt = {read=FAutoThemeAdapt, write=SetAutoThemeAdapt, default=0};
	__property TBalloonSettings* Balloon = {read=FBalloonSettings, write=SetBalloonSettings};
	__property TBands* Bands = {read=FBands, write=FBands};
	__property bool AutoNumAlign = {read=FAutoNumAlign, write=FAutoNumAlign, default=0};
	__property bool AutoSize = {read=FAutoSize, write=SetAutoSizeP, default=0};
	__property Basegrid::TVAlignment VAlignment = {read=FVAlignment, write=SetVAlignment, default=0};
	__property bool EnhTextSize = {read=FEnhTextSize, write=FEnhTextSize, default=0};
	__property bool EditWithTags = {read=FEditWithTags, write=FEditWithTags, default=0};
	__property bool EnhRowColMove = {read=FEnhRowColMove, write=FEnhRowColMove, default=1};
	__property bool SizeWithForm = {read=FSizeWithForm, write=FSizeWithForm, default=0};
	__property bool Multilinecells = {read=FMultilineCells, write=FMultilineCells, default=0};
	__property TAutoAdvanceEvent OnAutoAdvance = {read=FOnAutoAdvance, write=FOnAutoAdvance};
	__property TCustomCellDrawEvent OnCustomCellDraw = {read=FOnCustomCellDraw, write=FOnCustomCellDraw
		};
	__property TCustomCellSizeEvent OnCustomCellSize = {read=FOnCustomCellSize, write=FOnCustomCellSize
		};
	__property TGridColorEvent OnGetCellColor = {read=FOnGetCellColor, write=FOnGetCellColor};
	__property TGridColorEvent OnGetCellPrintColor = {read=FOnGetCellPrintColor, write=FOnGetCellPrintColor
		};
	__property TGridBorderEvent OnGetCellPrintBorder = {read=FOnGetCellPrintBorder, write=FOnGetCellPrintBorder
		};
	__property TGridBorderEvent OnGetCellBorder = {read=FOnGetCellBorder, write=FOnGetCellBorder};
	__property TGridBorderPropEvent OnGetCellBorderProp = {read=FOnGetCellBorderProp, write=FOnGetCellBorderProp
		};
	__property TGridAlignEvent OnGetAlignment = {read=FOnGetAlignment, write=FOnGetAlignment};
	__property TWordWrapEvent OnGetWordWrap = {read=FOnGetWordWrap, write=FOnGetWordWrap};
	__property TGridFormatEvent OnGetFormat = {read=FOnGetFormat, write=FOnGetFormat};
	__property TGetCheckEvent OnGetCheckTrue = {read=FOnGetCheckTrue, write=FOnGetCheckTrue};
	__property TGetCheckEvent OnGetCheckFalse = {read=FOnGetCheckFalse, write=FOnGetCheckFalse};
	__property TGridHintEvent OnGridHint = {read=FOnGridHint, write=FOnGridHint};
	__property TRowChangedEvent OnRowUpdate = {read=FOnRowChanged, write=FOnRowChanged};
	__property TRowChangingEvent OnRowChanging = {read=FOnRowChanging, write=FOnRowChanging};
	__property TColChangingEvent OnColChanging = {read=FOnColChanging, write=FOnColChanging};
	__property TCellChangingEvent OnCellChanging = {read=FOnCellChanging, write=FOnCellChanging};
	__property TGridBalloonEvent OnCellBalloon = {read=FOnCellBalloon, write=FOnCellBalloon};
	__property TGridPrintPageEvent OnPrintPage = {read=FOnPrintPage, write=FOnPrintPage};
	__property TGridPrintPageDoneEvent OnPrintPageDone = {read=FOnPrintPageDone, write=FOnPrintPageDone
		};
	__property TGridPrintStartEvent OnPrintStart = {read=FOnPrintStart, write=FOnPrintStart};
	__property TGridPrintCancelEvent OnPrintCancel = {read=FOnPrintCancel, write=FOnPrintCancel};
	__property TDoFitToPageEvent OnFitToPage = {read=FDoFitToPage, write=FDoFitToPage};
	__property TGridPrintNewPageEvent OnPrintNewPage = {read=FOnPrintNewPage, write=FOnPrintNewPage};
	__property TGridPrintColumnWidthEvent OnPrintSetColumnWidth = {read=FOnPrintSetColumnWidth, write=FOnPrintSetColumnWidth
		};
	__property TGridPrintRowHeightEvent OnPrintSetRowHeight = {read=FOnPrintSetRowHeight, write=FOnPrintSetRowHeight
		};
	__property TCanAddRowEvent OnCanAddRow = {read=FOnCanAddRow, write=FOnCanAddRow};
	__property TAutoAddRowEvent OnAutoAddRow = {read=FOnAutoAddRow, write=FOnAutoAddRow};
	__property TCanInsertRowEvent OnCanInsertRow = {read=FOnCanInsertRow, write=FOnCanInsertRow};
	__property TAutoInsertRowEvent OnAutoInsertRow = {read=FOnAutoInsertRow, write=FOnAutoInsertRow};
	__property TAutoInsertColEvent OnAutoInsertCol = {read=FOnAutoInsertCol, write=FOnAutoInsertCol};
	__property TCanDeleteRowEvent OnCanDeleteRow = {read=FOnCanDeleteRow, write=FOnCanDeleteRow};
	__property TAutoDeleteRowEvent OnAutoDeleteRow = {read=FOnAutoDeleteRow, write=FOnAutoDeleteRow};
	__property TClickSortEvent OnClickSort = {read=FOnClickSort, write=FOnClickSort};
	__property TCanSortEvent OnCanSort = {read=FOnCanSort, write=FOnCanSort};
	__property TNodeClickEvent OnExpandNode = {read=FOnExpandNode, write=FOnExpandNode};
	__property TNodeClickEvent OnContractNode = {read=FOnContractNode, write=FOnContractNode};
	__property TNodeAllowEvent OnBeforeExpandNode = {read=FOnBeforeExpandNode, write=FOnBeforeExpandNode
		};
	__property TNodeAllowEvent OnBeforeContractNode = {read=FOnBeforeContractNode, write=FOnBeforeContractNode
		};
	__property TCustomCompareEvent OnCustomCompare = {read=FCustomCompare, write=FCustomCompare};
	__property TRawCompareEvent OnRawCompare = {read=FRawCompare, write=FRawCompare};
	__property TClickCellEvent OnClickCell = {read=FOnClickCell, write=FOnClickCell};
	__property TClickCellEvent OnRightClickCell = {read=FOnRightClickCell, write=FOnRightClickCell};
	__property TDblClickCellEvent OnDblClickCell = {read=FOnDblClickCell, write=FOnDblClickCell};
	__property TCanClickCellEvent OnCanClickCell = {read=FOnCanClickCell, write=FOnCanClickCell};
	__property TCanEditCellEvent OnCanEditCell = {read=FOnCanEditCell, write=FOnCanEditCell};
	__property TIsFixedCellEvent OnIsFixedCell = {read=FOnIsFixedCell, write=FOnIsFixedCell};
	__property TIsPasswordCellEvent OnIsPasswordCell = {read=FOnIsPasswordCell, write=FOnIsPasswordCell
		};
	__property TAnchorClickEvent OnAnchorClick = {read=FOnAnchorClick, write=FOnAnchorClick};
	__property TAnchorEvent OnAnchorEnter = {read=FOnAnchorEnter, write=FOnAnchorEnter};
	__property TAnchorEvent OnAnchorExit = {read=FOnAnchorExit, write=FOnAnchorExit};
	__property TAnchorHintEvent OnAnchorHint = {read=FOnAnchorHint, write=FOnAnchorHint};
	__property TCellControlEvent OnControlClick = {read=FOnControlClick, write=FOnControlClick};
	__property TCellControlEvent OnControlEditDone = {read=FOnControlEditDone, write=FOnControlEditDone
		};
	__property TCellComboControlEvent OnControlComboList = {read=FOnControlComboList, write=FOnControlComboList
		};
	__property TClipboardEvent OnClipboardPaste = {read=FOnClipboardPaste, write=FOnClipboardPaste};
	__property TClipboardEvent OnClipboardCopy = {read=FOnClipboardCopy, write=FOnClipboardCopy};
	__property TClipboardEvent OnClipboardCut = {read=FOnClipboardCut, write=FOnClipboardCut};
	__property TBeforeCellPasteEvent OnClipboardBeforePasteCell = {read=FOnClipboardBeforePasteCell, write=
		FOnClipboardBeforePasteCell};
	__property TBeforeCellPasteWideEvent OnClipboardBeforePasteWideCell = {read=FOnClipboardBeforePasteWideCell
		, write=FOnClipboardBeforePasteWideCell};
	__property TCellValidateEvent OnCellValidate = {read=FOnCellValidate, write=FOnCellValidate};
	__property TCellValidateWideEvent OnCellValidateWide = {read=FOnCellValidateWide, write=FOnCellValidateWide
		};
	__property TCellsChangedEvent OnCellsChanged = {read=FOnCellsChanged, write=FOnCellsChanged};
	__property TGridProgressEvent OnFileProgress = {read=FOnFileProgress, write=FOnFileProgress};
	__property TGridProgressEvent OnFilterProgress = {read=FOnFilterProgress, write=FOnFilterProgress};
		
	__property THasComboEvent OnHasComboBox = {read=FOnHasComboBox, write=FOnHasComboBox};
	__property TGetEditorTypeEvent OnGetEditorType = {read=FOnGetEditorType, write=FOnGetEditorType};
	__property TGetEditorPropEvent OnGetEditorProp = {read=FOnGetEditorProp, write=FOnGetEditorProp};
	__property TFloatFormatEvent OnGetFloatFormat = {read=FOnGetFloatFormat, write=FOnGetFloatFormat};
	__property TEllipsClickEvent OnEllipsClick = {read=FOnEllipsClick, write=FOnEllipsClick};
	__property TButtonClickEvent OnButtonClick = {read=FOnButtonClick, write=FOnButtonClick};
	__property TCheckBoxClickEvent OnCheckBoxClick = {read=FOnCheckBoxClick, write=FOnCheckBoxClick};
	__property TCheckBoxClickEvent OnCheckBoxMouseUp = {read=FOnCheckBoxMouseUp, write=FOnCheckBoxMouseUp
		};
	__property TRadioClickEvent OnRadioClick = {read=FOnRadioClick, write=FOnRadioClick};
	__property TRadioClickEvent OnRadioMouseUp = {read=FOnRadioMouseUp, write=FOnRadioMouseUp};
	__property TComboChangeEvent OnComboChange = {read=FOnComboChange, write=FOnComboChange};
	__property TClickCellEvent OnComboCloseUp = {read=FOnComboCloseUp, write=FOnComboCloseUp};
	__property TComboObjectChangeEvent OnComboObjectChange = {read=FOnComboObjectChange, write=FOnComboObjectChange
		};
	__property TSpinClickEvent OnSpinClick = {read=FOnSpinClick, write=FOnSpinClick};
	__property TFloatSpinClickEvent OnFloatSpinClick = {read=FOnFloatSpinClick, write=FOnFloatSpinClick
		};
	__property TDateTimeSpinClickEvent OnTimeSpinClick = {read=FOntimeSpinClick, write=FOntimeSpinClick
		};
	__property TDateTimeSpinClickEvent OnDateSpinClick = {read=FOnDateSpinClick, write=FOnDateSpinClick
		};
	__property Classes::TNotifyEvent OnRichEditSelectionChange = {read=FOnRichEditSelectionChange, write=
		FOnRichEditSelectionChange};
	__property TDragScrollEvent OnDragScroll = {read=FOnDragScroll, write=FOnDragScroll};
	__property Classes::TNotifyEvent OnEditingDone = {read=FOnEditingDone, write=FOnEditingDone};
	__property TEditChangeEvent OnEditChange = {read=FOnEditChange, write=FOnEditChange};
	__property TDateTimeChangeEvent OnDateTimeChange = {read=FOnDateTimeChange, write=FOnDateTimeChange
		};
	__property TFooterPaintEvent OnFooterPaint = {read=FOnPaintFooter, write=FOnPaintFooter};
	__property Classes::TNotifyEvent OnResize = {read=FOnGridResize, write=FOnGridResize};
	__property TSelectionChanged OnSelectionChanged = {read=FSelectionChanged, write=FSelectionChanged}
		;
	__property TOleDragDropEvent OnOleDrop = {read=FOnOleDrop, write=FOnOleDrop};
	__property TOleDroppedEvent OnOleDropped = {read=FOnOleDropped, write=FOnOleDropped};
	__property TOleDragDropEvent OnOleDrag = {read=FOnOleDrag, write=FOnOleDrag};
	__property TOleDragOverEvent OnOleDragOver = {read=FOnOleDragOver, write=FOnOleDragOver};
	__property TOleDragStartEvent OnOleDragStart = {read=FOnOleDragStart, write=FOnOleDragStart};
	__property TOleDragStopEvent OnOleDragStop = {read=FOnOleDragStop, write=FOnOleDragStop};
	__property TOleDropColEvent OnOleDropCol = {read=FOnOleDropCol, write=FOnOleDropCol};
	__property TOleDropFileEvent OnOleDropFile = {read=FOnOleDropFile, write=FOnOleDropFile};
	__property TDragDropSettings* DragDropSettings = {read=FDragDropSettings, write=FDragDropSettings};
		
	__property TDragScrollOptions* DragScrollOptions = {read=FDragScrollOptions, write=SetDragScrollOptions
		};
	__property TSortSettings* SortSettings = {read=FSortSettings, write=FSortSettings};
	__property TFloatingFooter* FloatingFooter = {read=FFloatingFooter, write=FFloatingFooter};
	__property TControlLook* ControlLook = {read=FControlLook, write=FControlLook};
	__property bool EnableBlink = {read=FEnableBlink, write=FEnableBlink, default=0};
	__property bool EnableHTML = {read=FEnableHTML, write=FEnableHTML, default=1};
	__property bool EnableWheel = {read=FEnableWheel, write=FEnableWheel, default=1};
	__property bool ExcelStyleDecimalSeparator = {read=FExcelStyleDecimalSeparator, write=FExcelStyleDecimalSeparator
		, default=0};
	__property bool Flat = {read=FFlat, write=SetFlat, default=0};
	__property TGridLook Look = {read=FLook, write=SetLook, default=4};
	__property Graphics::TColor HintColor = {read=FHintColor, write=FHintColor, default=-2147483624};
	__property TScrollBarAlways ScrollBarAlways = {read=FScrollBarAlways, write=SetScrollBarAlways, default=0
		};
	__property Stdctrls::TScrollStyle ScrollBars = {read=GetScrollBarsEx, write=SetScrollBarsEx, nodefault
		};
	__property TSearchFooter* SearchFooter = {read=FSearchFooter, write=FSearchFooter};
	__property Graphics::TColor SelectionColor = {read=FSelectionColor, write=SetSelectionColor, default=15387318
		};
	__property Graphics::TColor SelectionColorTo = {read=FSelectionColorTo, write=SetSelectionColorTo, 
		default=536870911};
	__property Graphics::TColor SelectionTextColor = {read=FSelectionTextColor, write=SetSelectionTextColor
		, default=0};
	__property bool SelectionRectangle = {read=FSelectionRectangle, write=SetSelectionRectangle, default=0
		};
	__property bool SelectionResizer = {read=FSelectionResizer, write=SetSelectionResizer, default=0};
	__property bool SelectionRTFKeep = {read=FSelectionRTFKeep, write=FSelectionRTFKeep, default=0};
	__property bool HintShowCells = {read=FHintShowCells, write=FHintShowCells, default=0};
	__property bool HintShowLargeText = {read=FHintShowLargeText, write=FHintShowLargeText, default=0};
		
	__property bool HintShowSizing = {read=FHintShowSizing, write=FHintShowSizing, default=0};
	__property bool HTMLHint = {read=FHTMLHint, write=FHTMLHint, default=0};
	__property TScrollHintEvent OnScrollHint = {read=FOnScrollHint, write=FOnScrollHint};
	__property TColumnSizeEvent OnColumnSize = {read=FOnColumnSize, write=FOnColumnSize};
	__property TColumnSizeEvent OnColumnMove = {read=FOnColumnMove, write=FOnColumnMove};
	__property TRowSizeEvent OnRowSize = {read=FOnRowSize, write=FOnRowSize};
	__property TRowSizeEvent OnRowMove = {read=FOnRowMove, write=FOnRowMove};
	__property TEndColumnSizeEvent OnEndColumnSize = {read=FOnEndColumnSize, write=FOnEndColumnSize};
	__property TUpdateColumnSizeEvent OnUpdateColumnSize = {read=FOnUpdateColumnSize, write=FOnUpdateColumnSize
		};
	__property TEndRowSizeEvent OnEndRowSize = {read=FOnEndRowSize, write=FOnEndRowSize};
	__property TSelectionResizeEvent OnSelectionResize = {read=FSelectionResizeEvent, write=FSelectionResizeEvent
		};
	__property TSelectionResizeEvent OnSelectionResized = {read=FSelectionResizedEvent, write=FSelectionResizedEvent
		};
	__property TPrintSettings* PrintSettings = {read=FPrintSettings, write=FPrintSettings};
	__property THTMLSettings* HTMLSettings = {read=FHTMLSettings, write=FHTMLSettings};
	__property TNavigation* Navigation = {read=FNavigation, write=FNavigation};
	__property TColumnSize* ColumnSize = {read=FColumnSize, write=FColumnSize};
	__property TCellNode* CellNode = {read=FCellNode, write=FCellNode};
	__property TSizeWhileTyping* SizeWhileTyping = {read=FSizeWhileTyping, write=FSizeWhileTyping};
	__property int MaxEditLength = {read=FMaxEditLength, write=SetMaxEditLength, default=0};
	__property TMouseActions* MouseActions = {read=FMouseActions, write=FMouseActions};
	__property TGrouping* Grouping = {read=FGrouping, write=FGrouping};
	__property Controls::TImageList* GridImages = {read=FGridImages, write=SetImages};
	__property TIntelliPan IntelliPan = {read=FIntelliPan, write=FIntelliPan, default=0};
	__property bool IntelliZoom = {read=FIntelliZoom, write=FIntelliZoom, default=1};
	__property Graphics::TColor URLColor = {read=FURLColor, write=SetURLColor, default=16711680};
	__property bool URLShow = {read=FURLShow, write=SetURLShow, default=0};
	__property bool URLFull = {read=FURLFull, write=SetURLFull, default=0};
	__property bool URLEdit = {read=FURLEdit, write=FURLEdit, default=0};
	__property Picturecontainer::TPictureContainer* PictureContainer = {read=FContainer, write=FContainer
		};
	__property Asgcheck::TAdvStringGridCheck* CellChecker = {read=FCellChecker, write=FCellChecker};
	__property TScrollType ScrollType = {read=FScrollType, write=SetScrollType, default=0};
	__property Graphics::TColor ScrollColor = {read=FScrollColor, write=SetScrollColor, default=536870911
		};
	__property int ScrollWidth = {read=FScrollWidth, write=SetScrollWidth, default=17};
	__property bool ScrollSynch = {read=FScrollSynch, write=FScrollSynch, default=0};
	__property bool ScrollProportional = {read=FScrollProportional, write=SetScrollProportional, default=0
		};
	__property TScrollHintType ScrollHints = {read=FScrollHints, write=FScrollHints, default=0};
	__property bool OemConvert = {read=FOemConvert, write=FOemConvert, default=0};
	__property int FixedFooters = {read=FFixedFooters, write=SetFixedFooters, default=0};
	__property int FixedRightCols = {read=FFixedRightCols, write=SetFixedRightCols, default=0};
	__property int FixedColWidth = {read=GetFixedColWidth, write=SetFixedColWidth, default=64};
	__property int FixedRowHeight = {read=GetFixedRowHeight, write=SetFixedRowHeight, default=21};
	__property bool FixedRowAlways = {read=FFixedRowAlways, write=FFixedRowAlways, default=0};
	__property bool FixedColAlways = {read=FFixedColAlways, write=FFixedColAlways, default=0};
	__property Graphics::TFont* FixedFont = {read=FFixedFont, write=SetFixedFont};
	__property int RowCount = {read=GetRowCountEx, write=SetRowCountEx, default=10};
	__property int FixedRows = {read=GetFixedRowsEx, write=SetFixedRowsEx, default=1};
	__property int ColCount = {read=GetColCountEx, write=SetColCountEx, default=5};
	__property int FixedCols = {read=GetFixedColsEx, write=SetFixedColsEx, default=1};
	__property bool FixedAsButtons = {read=FFixedAsButtons, write=FFixedAsButtons, default=0};
	__property AnsiString FloatFormat = {read=FFloatFormat, write=FFloatFormat};
	__property bool IntegralHeight = {read=FIntegralHeight, write=SetIntegralHeight, default=0};
	__property bool WordWrap = {read=GetWordWrapEx, write=SetWordWrapEx, default=1};
	__property Classes::TStringList* ColumnHeaders = {read=FColumnHeaders, write=SetColumnHeaders};
	__property Classes::TStringList* RowHeaders = {read=FRowHeaders, write=SetRowHeaders};
	__property Classes::TStringList* LookupItems = {read=FLookupItems, write=SetLookupItems};
	__property bool Lookup = {read=FLookup, write=FLookup, default=0};
	__property bool LookupCaseSensitive = {read=FLookupCaseSensitive, write=FLookupCaseSensitive, default=0
		};
	__property bool LookupHistory = {read=FLookupHistory, write=FLookupHistory, default=0};
	__property bool ShowSelection = {read=FShowSelection, write=SetShowSelection, default=1};
	__property TShowModified* ShowModified = {read=FShowModified, write=SetShowModified};
	__property bool HideFocusRect = {read=FHideFocusRect, write=FHideFocusRect, default=0};
	__property Graphics::TBitmap* RowIndicator = {read=GetRowIndicator, write=SetRowIndicator};
	__property TBackGround* BackGround = {read=FBackGround, write=SetBackground};
	__property bool Hovering = {read=FHovering, write=SetHovering, default=0};
	__property TFilter* Filter = {read=FFilter, write=FFilter};
	__property bool FilterActive = {read=FFilterActive, write=SetFilterActive, default=0};
	__property Controls::TCursor Cursor = {read=GetCursorEx, write=SetCursorEx, nodefault};
	__property int DefaultRowHeight = {read=GetDefRowHeightEx, write=SetDefRowHeightEx, nodefault};
	__property Basegrid::TEditorType DefaultEditor = {read=FDefaultEditor, write=FDefaultEditor, default=0
		};
	__property AnsiString Version = {read=GetVersion, write=SetVersion};
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TAdvStringGrid(HWND ParentWindow) : Basegrid::TBaseGrid(
		ParentWindow) { }
	#pragma option pop
	
};


class PASCALIMPLEMENTATION TBands : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	bool FPrint;
	bool FActive;
	int FTotalLength;
	int FSecondaryLength;
	int FPrimaryLength;
	Graphics::TColor FSecondaryColor;
	Graphics::TColor FPrimaryColor;
	TAdvStringGrid* FOwner;
	void __fastcall SetActive(const bool Value);
	void __fastcall SetPrimaryColor(const Graphics::TColor Value);
	void __fastcall SetPrimaryLength(const int Value);
	void __fastcall SetSecondaryColor(const Graphics::TColor Value);
	void __fastcall SetSecondaryLength(const int Value);
	
public:
	__fastcall TBands(TAdvStringGrid* AOwner);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property bool Active = {read=FActive, write=SetActive, default=0};
	__property Graphics::TColor PrimaryColor = {read=FPrimaryColor, write=SetPrimaryColor, default=-2147483624
		};
	__property int PrimaryLength = {read=FPrimaryLength, write=SetPrimaryLength, default=1};
	__property Graphics::TColor SecondaryColor = {read=FSecondaryColor, write=SetSecondaryColor, default=-2147483643
		};
	__property int SecondaryLength = {read=FSecondaryLength, write=SetSecondaryLength, default=1};
	__property bool Print = {read=FPrint, write=FPrint, default=0};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TBands(void) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TEditStyle { esInplace, esPopup };
#pragma option pop

class PASCALIMPLEMENTATION TEditLink : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	TAdvStringGrid* FOwner;
	bool FWantKeyLeftRight;
	bool FWantKeyUpDown;
	bool FWantKeyHomeEnd;
	bool FWantKeyPriorNext;
	bool FWantKeyReturn;
	bool FWantKeyEscape;
	TEditStyle FEditStyle;
	Forms::TForm* FPopupForm;
	int FPopupWidth;
	int FPopupHeight;
	bool FForcedExit;
	Windows::TPoint FEditCell;
	int FTag;
	bool FAutoPopupWidth;
	int FPopupLeft;
	int FPopupTop;
	
protected:
	__property bool ForcedExit = {read=FForcedExit, write=FForcedExit, nodefault};
	
public:
	__fastcall virtual TEditLink(Classes::TComponent* AOwner);
	__fastcall virtual ~TEditLink(void);
	virtual void __fastcall EditKeyDown(System::TObject* Sender, Word &Key, Classes::TShiftState Shift)
		;
	void __fastcall EditExit(System::TObject* Sender);
	void __fastcall FormExit(System::TObject* Sender);
	Controls::TWinControl* __fastcall GetParent(void);
	virtual Controls::TWinControl* __fastcall GetEditControl(void);
	AnsiString __fastcall GetCellValue();
	void __fastcall SetCellValue(AnsiString s);
	virtual void __fastcall CreateEditor(Controls::TWinControl* AParent);
	virtual void __fastcall DestroyEditor(void);
	void __fastcall HideEditor(void);
	void __fastcall RestoreWinProc(void);
	virtual void __fastcall SetFocus(bool Value);
	virtual void __fastcall SetRect(const Windows::TRect &r);
	virtual void __fastcall SetVisible(bool Value);
	virtual void __fastcall SetProperties(void);
	virtual void __fastcall SetCellProps(Graphics::TColor AColor, Graphics::TFont* AFont);
	virtual AnsiString __fastcall GetEditorValue();
	virtual void __fastcall SetEditorValue(AnsiString s);
	__property TAdvStringGrid* Grid = {read=FOwner};
	__property Windows::TPoint EditCell = {read=FEditCell};
	
__published:
	__property bool AutoPopupWidth = {read=FAutoPopupWidth, write=FAutoPopupWidth, nodefault};
	__property TEditStyle EditStyle = {read=FEditStyle, write=FEditStyle, nodefault};
	__property int PopupLeft = {read=FPopupLeft, write=FPopupLeft, default=-1};
	__property int PopupTop = {read=FPopupTop, write=FPopupTop, default=-1};
	__property int PopupWidth = {read=FPopupWidth, write=FPopupWidth, nodefault};
	__property int PopupHeight = {read=FPopupHeight, write=FPopupHeight, nodefault};
	__property bool WantKeyLeftRight = {read=FWantKeyLeftRight, write=FWantKeyLeftRight, nodefault};
	__property bool WantKeyUpDown = {read=FWantKeyUpDown, write=FWantKeyUpDown, nodefault};
	__property bool WantKeyHomeEnd = {read=FWantKeyHomeEnd, write=FWantKeyHomeEnd, nodefault};
	__property bool WantKeyPriorNext = {read=FWantKeyPriorNext, write=FWantKeyPriorNext, nodefault};
	__property bool WantKeyReturn = {read=FWantKeyReturn, write=FWantKeyReturn, nodefault};
	__property bool WantKeyEscape = {read=FWantKeyEscape, write=FWantKeyEscape, nodefault};
	__property int Tag = {read=FTag, write=FTag, nodefault};
};


class PASCALIMPLEMENTATION TAdvInplaceEdit : public Grids::TInplaceEdit 
{
	typedef Grids::TInplaceEdit inherited;
	
private:
	short FLengthLimit;
	bool FValign;
	bool FWordWrap;
	bool GotKey;
	bool Workmode;
	TAdvStringGrid* FGrid;
	void __fastcall SetVAlign(bool Value);
	void __fastcall SetWordWrap(bool Value);
	HIDESBASE MESSAGE void __fastcall WMSetFocus(Messages::TWMSetFocus &Msg);
	HIDESBASE MESSAGE void __fastcall WMKillFocus(Messages::TWMKillFocus &Msg);
	HIDESBASE MESSAGE void __fastcall WMKeyDown(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMKeyUp(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMLButtonDblClk(Messages::TWMMouse &Message);
	HIDESBASE MESSAGE void __fastcall WMChar(Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMPaste(Messages::TMessage &Msg);
	MESSAGE void __fastcall WMCopy(Messages::TMessage &Msg);
	HIDESBASE MESSAGE void __fastcall WMCut(Messages::TMessage &Msg);
	HIDESBASE MESSAGE void __fastcall CMWantSpecialKey(Messages::TWMKey &Msg);
	
protected:
	virtual void __fastcall CreateParams(Controls::TCreateParams &Params);
	virtual void __fastcall CreateWnd(void);
	DYNAMIC void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall KeyUp(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall KeyPress(char &Key);
	virtual void __fastcall UpdateContents(void);
	virtual void __fastcall BoundsChanged(void);
	DYNAMIC void __fastcall Change(void);
	
public:
	__fastcall virtual TAdvInplaceEdit(Classes::TComponent* AOwner);
	void __fastcall DoChange(void);
	
__published:
	__property bool VAlign = {read=FValign, write=SetVAlign, nodefault};
	__property bool WordWrap = {read=FWordWrap, write=SetWordWrap, nodefault};
	__property short LengthLimit = {read=FLengthLimit, write=FLengthLimit, nodefault};
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TAdvInplaceEdit(HWND ParentWindow) : Grids::TInplaceEdit(
		ParentWindow) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TWinControl.Destroy */ inline __fastcall virtual ~TAdvInplaceEdit(void) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TFilterCells { fcVirtual, fcNormal };
#pragma option pop

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


class DELPHICLASS TGridItem;
class PASCALIMPLEMENTATION TGridItem : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	int FIdx;
	int FHeight;
	Classes::TStrings* FItems;
	void __fastcall SetIdx(const int Value);
	void __fastcall SetItems(const Classes::TStrings* Value);
	void __fastcall SetHeight(const int Value);
	
public:
	__fastcall virtual TGridItem(Classes::TCollection* Collection);
	__fastcall virtual ~TGridItem(void);
	
__published:
	__property int Idx = {read=FIdx, write=SetIdx, nodefault};
	__property int Height = {read=FHeight, write=SetHeight, nodefault};
	__property Classes::TStrings* Items = {read=FItems, write=SetItems};
};


class DELPHICLASS TGridDropSource;
class PASCALIMPLEMENTATION TGridDropSource : public Asgdd::TASGDropSource 
{
	typedef Asgdd::TASGDropSource inherited;
	
private:
	TAdvStringGrid* FGrid;
	int FLastEffect;
	
public:
	__fastcall TGridDropSource(TAdvStringGrid* aGrid);
	virtual void __fastcall CurrentEffect(int dwEffect);
	virtual void __fastcall QueryDrag(void);
	
__published:
	__property int LastEffect = {read=FLastEffect, nodefault};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TGridDropSource(void) { }
	#pragma option pop
	
};


class PASCALIMPLEMENTATION TGridChangeNotifier : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
protected:
	virtual void __fastcall CellsChanged(const Windows::TRect &R);
public:
	#pragma option push -w-inl
	/* TComponent.Create */ inline __fastcall virtual TGridChangeNotifier(Classes::TComponent* AOwner) : 
		Classes::TComponent(AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TComponent.Destroy */ inline __fastcall virtual ~TGridChangeNotifier(void) { }
	#pragma option pop
	
};


class DELPHICLASS TGridSLIO;
class PASCALIMPLEMENTATION TGridSLIO : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Classes::TStringList* FStrings;
	
public:
	__fastcall virtual TGridSLIO(Classes::TComponent* AOwner);
	__fastcall virtual ~TGridSLIO(void);
	
__published:
	__property Classes::TStringList* Strings = {read=FStrings, write=FStrings};
};


class DELPHICLASS TGridFilePicIO;
class PASCALIMPLEMENTATION TGridFilePicIO : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Advobj::TFilePicture* FPicture;
	
public:
	__fastcall virtual TGridFilePicIO(Classes::TComponent* AOwner);
	__fastcall virtual ~TGridFilePicIO(void);
	
__published:
	__property Advobj::TFilePicture* Picture = {read=FPicture, write=FPicture};
};


class DELPHICLASS TGridPicIO;
class PASCALIMPLEMENTATION TGridPicIO : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Graphics::TPicture* FPicture;
	
public:
	__fastcall virtual TGridPicIO(Classes::TComponent* AOwner);
	__fastcall virtual ~TGridPicIO(void);
	
__published:
	__property Graphics::TPicture* Picture = {read=FPicture, write=FPicture};
};


class DELPHICLASS TGridIconIO;
class PASCALIMPLEMENTATION TGridIconIO : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Graphics::TIcon* FIcon;
	
public:
	__fastcall virtual TGridIconIO(Classes::TComponent* AOwner);
	__fastcall virtual ~TGridIconIO(void);
	
__published:
	__property Graphics::TIcon* Icon = {read=FIcon, write=FIcon};
};


class DELPHICLASS TGridBMPIO;
class PASCALIMPLEMENTATION TGridBMPIO : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Graphics::TBitmap* FBitmap;
	
public:
	__fastcall virtual TGridBMPIO(Classes::TComponent* AOwner);
	__fastcall virtual ~TGridBMPIO(void);
	
__published:
	__property Graphics::TBitmap* Bitmap = {read=FBitmap, write=FBitmap};
};


class DELPHICLASS TGridPropIO;
class PASCALIMPLEMENTATION TGridPropIO : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	int FColCount;
	int FRowCount;
	AnsiString FColWidths;
	AnsiString FRowHeights;
	bool FFullGrid;
	int FID;
	
__published:
	__property int ColCount = {read=FColCount, write=FColCount, nodefault};
	__property int RowCount = {read=FRowCount, write=FRowCount, nodefault};
	__property AnsiString ColWidths = {read=FColWidths, write=FColWidths};
	__property AnsiString RowHeights = {read=FRowHeights, write=FRowHeights};
	__property bool FullGrid = {read=FFullGrid, write=FFullGrid, nodefault};
	__property int ID = {read=FID, write=FID, nodefault};
public:
	#pragma option push -w-inl
	/* TComponent.Create */ inline __fastcall virtual TGridPropIO(Classes::TComponent* AOwner) : Classes::TComponent(
		AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TComponent.Destroy */ inline __fastcall virtual ~TGridPropIO(void) { }
	#pragma option pop
	
};


class DELPHICLASS TGridGraphicIO;
class PASCALIMPLEMENTATION TGridGraphicIO : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	TCellGraphic* FCellGraphic;
	
public:
	__fastcall virtual TGridGraphicIO(Classes::TComponent* AOwner);
	__fastcall virtual ~TGridGraphicIO(void);
	
__published:
	__property TCellGraphic* CellGraphic = {read=FCellGraphic, write=FCellGraphic};
};


class DELPHICLASS TGridCellPropIO;
class PASCALIMPLEMENTATION TGridCellPropIO : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Basegrid::TCellProperties* FCellProperties;
	bool FHasGraphic;
	
public:
	__fastcall virtual TGridCellPropIO(Classes::TComponent* AOwner);
	__fastcall virtual ~TGridCellPropIO(void);
	
__published:
	__property Basegrid::TCellProperties* CellProperties = {read=FCellProperties, write=FCellProperties
		};
	__property bool HasGraphic = {read=FHasGraphic, write=FHasGraphic, nodefault};
};


class DELPHICLASS TGridCellIO;
class PASCALIMPLEMENTATION TGridCellIO : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Word FRow;
	Word FCol;
	AnsiString FCell;
	bool FHasProp;
	
public:
	__fastcall virtual TGridCellIO(Classes::TComponent* AOwner);
	__fastcall virtual ~TGridCellIO(void);
	
__published:
	__property Word Col = {read=FCol, write=FCol, nodefault};
	__property Word Row = {read=FRow, write=FRow, nodefault};
	__property AnsiString Cell = {read=FCell, write=FCell};
	__property bool HasProp = {read=FHasProp, write=FHasProp, nodefault};
};


//-- var, const, procedure ---------------------------------------------------
static const Word MAXCOLUMNS = 0x200;
static const Word RTF_TWIPS = 0x5a0;
static const Shortint MAJ_VER = 0x3;
static const Shortint MIN_VER = 0x1;
static const Shortint REL_VER = 0x1;
static const Shortint BLD_VER = 0x1;
#define DATE_VER "Sep, 2005"
static const Word WM_THEMECHANGED = 0x31a;
extern PACKAGE Word CF_GRIDCELLS;

}	/* namespace Advgrid */
#if !defined(NO_IMPLICIT_NAMESPACE_USE)
using namespace Advgrid;
#endif
#pragma option pop	// -w-
#pragma option pop	// -Vx

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