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

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

#ifndef Fmx_TmsmemoHPP
#define Fmx_TmsmemoHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member 
#pragma pack(push,8)
#include <System.hpp>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <Winapi.Windows.hpp>	// Pascal unit
#include <System.Classes.hpp>	// Pascal unit
#include <System.Types.hpp>	// Pascal unit
#include <System.UITypes.hpp>	// Pascal unit
#include <FMX.Forms.hpp>	// Pascal unit
#include <System.SysUtils.hpp>	// Pascal unit
#include <FMX.Platform.hpp>	// Pascal unit
#include <FMX.TMSBaseControl.hpp>	// Pascal unit
#include <FMX.Objects.hpp>	// Pascal unit
#include <FMX.Types.hpp>	// Pascal unit
#include <FMX.Controls.hpp>	// Pascal unit
#include <FMX.Dialogs.hpp>	// Pascal unit
#include <System.Math.hpp>	// Pascal unit
#include <FMX.ListBox.hpp>	// Pascal unit
#include <FMX.Layouts.hpp>	// Pascal unit
#include <FMX.Menus.hpp>	// Pascal unit
#include <FMX.TMSFindDialog.hpp>	// Pascal unit
#include <System.Generics.Collections.hpp>	// Pascal unit
#include <FMX.TMSRTFEngine.hpp>	// Pascal unit
#include <FMX.TMSXUtil.hpp>	// Pascal unit
#include <FMX.ActnList.hpp>	// Pascal unit
#include <System.TypInfo.hpp>	// Pascal unit
#include <FMX.TMSPopup.hpp>	// Pascal unit
#include <FMX.StdCtrls.hpp>	// Pascal unit
#include <FMX.Text.hpp>	// Pascal unit
#include <FMX.Graphics.hpp>	// Pascal unit
#include <System.Actions.hpp>	// Pascal unit
#include <System.Generics.Defaults.hpp>	// Pascal unit

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

namespace Fmx
{
namespace Tmsmemo
{
//-- type declarations -------------------------------------------------------
typedef System::Byte _AnsiChar;

enum DECLSPEC_DENUM TRegionType : unsigned char { rtOpen, rtClosed, rtFile, rtIgnore };

enum DECLSPEC_DENUM TStyleType : unsigned char { stKeyword, stBracket, stSymbol, stComment };

enum DECLSPEC_DENUM TDrawMode : unsigned char { dmScreen, dmHTML, dmPrinter, dmPrintPreview, dmRTF };

enum DECLSPEC_DENUM TTokenType : unsigned char { ttNone, ttVar, ttProp, ttEvent, ttMethod, ttFunc, ttProc };

enum DECLSPEC_DENUM TSelectionMode : unsigned char { smText, smBlock };

enum DECLSPEC_DENUM TMemoClipboardAction : unsigned char { caCopy, caCut, caPaste };

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

typedef void __fastcall (__closure *TMemoInsertCompletionEntryEvent)(System::TObject* Sender, System::UnicodeString &AEntry);

typedef void __fastcall (__closure *TAnchorEvent)(System::TObject* Sender, System::UnicodeString &Anchor, int X, int Y, bool &Handled);

struct DECLSPEC_DRECORD TCaretPosition
{
public:
	int Line;
	int Pos;
};


typedef int TCommand;

struct DECLSPEC_DRECORD TCellSize
{
public:
	float W;
	float H;
};


struct DECLSPEC_DRECORD TCellPos
{
public:
	int X;
	int Y;
};


struct DECLSPEC_DRECORD TFullPos
{
public:
	float LineNo;
	float Pos;
};


struct DECLSPEC_DRECORD TStyle
{
public:
	bool isComment;
	bool isBracket;
	bool isnumber;
	bool iskeyWord;
	bool isdelimiter;
	bool isURL;
	bool isHighlight;
	System::WideChar EndBracket;
	System::WideChar StartBracket;
	int index;
};


enum DECLSPEC_DENUM TLineModifiedState : unsigned char { lmUnmodified, lmModified, lmSaved };

class DELPHICLASS TIntList;
class PASCALIMPLEMENTATION TIntList : public System::Generics::Collections::TList__1<int>
{
	typedef System::Generics::Collections::TList__1<int> inherited;
	
public:
	/* {System_Generics_Collections}TList<System_Integer>.Create */ inline __fastcall TIntList(void)/* overload */ : System::Generics::Collections::TList__1<int>() { }
	/* {System_Generics_Collections}TList<System_Integer>.Create */ inline __fastcall TIntList(const System::DelphiInterface<System::Generics::Defaults::IComparer__1<int> > AComparer)/* overload */ : System::Generics::Collections::TList__1<int>(AComparer) { }
	/* {System_Generics_Collections}TList<System_Integer>.Create */ inline __fastcall TIntList(System::Generics::Collections::TEnumerable__1<int>* const Collection)/* overload */ : System::Generics::Collections::TList__1<int>(Collection) { }
	/* {System_Generics_Collections}TList<System_Integer>.Destroy */ inline __fastcall virtual ~TIntList(void) { }
	
};


class DELPHICLASS TLineProp;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TLineProp : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::TObject* FObject;
	TIntList* FErrStart;
	TIntList* FErrLen;
	bool FExpanded;
	int FLastChildOfParents;
	bool FHasParent;
	bool FHasChildren;
	void __fastcall SetExpanded(const bool Value);
	bool __fastcall GetLastChild(void);
	void __fastcall SetLastChildOfParents(int Value);
	
public:
	bool BreakPoint;
	bool Executable;
	TLineModifiedState Modified;
	int ImageIndex;
	bool Bookmark;
	int BookmarkIndex;
	TStyle Style;
	bool CachedStyle;
	bool Wrapped;
	__fastcall TLineProp(void);
	__fastcall virtual ~TLineProp(void);
	__property bool HasParent = {read=FHasParent, write=FHasParent, nodefault};
	__property bool HasChildren = {read=FHasChildren, write=FHasChildren, nodefault};
	__property bool Expanded = {read=FExpanded, write=SetExpanded, nodefault};
	__property bool LastChild = {read=GetLastChild, nodefault};
	__property int LastChildOfParents = {read=FLastChildOfParents, write=SetLastChildOfParents, nodefault};
};

#pragma pack(pop)

class DELPHICLASS TUndo;
class DELPHICLASS TTMSFMXMemo;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TUndo : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	TTMSFMXMemo* Memo;
	int FUndoCurX0;
	int FUndoCurY0;
	int FUndoCurX;
	int FUndoCurY;
	System::UnicodeString FUndoText;
	bool FLinkedUndo;
	
public:
	__fastcall TUndo(int ACurX0, int ACurY0, int ACurX, int ACurY, System::UnicodeString AText);
	virtual bool __fastcall Append(TUndo* NewUndo);
	void __fastcall Undo(void);
	void __fastcall Redo(void);
	virtual void __fastcall PerformUndo(void) = 0 ;
	virtual void __fastcall PerformRedo(void) = 0 ;
	__property bool LinkedUndo = {read=FLinkedUndo, write=FLinkedUndo, nodefault};
	__property int UndoCurX0 = {read=FUndoCurX0, write=FUndoCurX0, nodefault};
	__property int UndoCurY0 = {read=FUndoCurY0, write=FUndoCurY0, nodefault};
	__property int UndoCurX = {read=FUndoCurX, write=FUndoCurX, nodefault};
	__property int UndoCurY = {read=FUndoCurY, write=FUndoCurY, nodefault};
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TUndo(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TInsertCharUndo;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TInsertCharUndo : public TUndo
{
	typedef TUndo inherited;
	
public:
	virtual bool __fastcall Append(TUndo* NewUndo);
	virtual void __fastcall PerformUndo(void);
	virtual void __fastcall PerformRedo(void);
public:
	/* TUndo.Create */ inline __fastcall TInsertCharUndo(int ACurX0, int ACurY0, int ACurX, int ACurY, System::UnicodeString AText) : TUndo(ACurX0, ACurY0, ACurX, ACurY, AText) { }
	
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TInsertCharUndo(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TNewLineUndo;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TNewLineUndo : public TUndo
{
	typedef TUndo inherited;
	
public:
	virtual bool __fastcall Append(TUndo* NewUndo);
	virtual void __fastcall PerformUndo(void);
	virtual void __fastcall PerformRedo(void);
public:
	/* TUndo.Create */ inline __fastcall TNewLineUndo(int ACurX0, int ACurY0, int ACurX, int ACurY, System::UnicodeString AText) : TUndo(ACurX0, ACurY0, ACurX, ACurY, AText) { }
	
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TNewLineUndo(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TOverwriteCharUndo;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TOverwriteCharUndo : public TUndo
{
	typedef TUndo inherited;
	
public:
	virtual void __fastcall PerformUndo(void);
	virtual void __fastcall PerformRedo(void);
public:
	/* TUndo.Create */ inline __fastcall TOverwriteCharUndo(int ACurX0, int ACurY0, int ACurX, int ACurY, System::UnicodeString AText) : TUndo(ACurX0, ACurY0, ACurX, ACurY, AText) { }
	
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TOverwriteCharUndo(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TDeleteCharUndo;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TDeleteCharUndo : public TUndo
{
	typedef TUndo inherited;
	
private:
	bool FIsBackspace;
	
public:
	virtual bool __fastcall Append(TUndo* NewUndo);
	virtual void __fastcall PerformUndo(void);
	virtual void __fastcall PerformRedo(void);
	__property bool IsBackspace = {read=FIsBackspace, write=FIsBackspace, nodefault};
public:
	/* TUndo.Create */ inline __fastcall TDeleteCharUndo(int ACurX0, int ACurY0, int ACurX, int ACurY, System::UnicodeString AText) : TUndo(ACurX0, ACurY0, ACurX, ACurY, AText) { }
	
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TDeleteCharUndo(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TDeleteLineUndo;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TDeleteLineUndo : public TUndo
{
	typedef TUndo inherited;
	
public:
	virtual void __fastcall PerformUndo(void);
	virtual void __fastcall PerformRedo(void);
public:
	/* TUndo.Create */ inline __fastcall TDeleteLineUndo(int ACurX0, int ACurY0, int ACurX, int ACurY, System::UnicodeString AText) : TUndo(ACurX0, ACurY0, ACurX, ACurY, AText) { }
	
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TDeleteLineUndo(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TSelUndo;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TSelUndo : public TUndo
{
	typedef TUndo inherited;
	
private:
	int FUndoSelStartX;
	int FUndoSelStartY;
	int FUndoSelEndX;
	int FUndoSelEndY;
	
public:
	__property int UndoSelStartX = {read=FUndoSelStartX, write=FUndoSelStartX, nodefault};
	__property int UndoSelStartY = {read=FUndoSelStartY, write=FUndoSelStartY, nodefault};
	__property int UndoSelEndX = {read=FUndoSelEndX, write=FUndoSelEndX, nodefault};
	__property int UndoSelEndY = {read=FUndoSelEndY, write=FUndoSelEndY, nodefault};
public:
	/* TUndo.Create */ inline __fastcall TSelUndo(int ACurX0, int ACurY0, int ACurX, int ACurY, System::UnicodeString AText) : TUndo(ACurX0, ACurY0, ACurX, ACurY, AText) { }
	
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TSelUndo(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TDeleteBufUndo;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TDeleteBufUndo : public TSelUndo
{
	typedef TSelUndo inherited;
	
public:
	virtual void __fastcall PerformUndo(void);
	virtual void __fastcall PerformRedo(void);
public:
	/* TUndo.Create */ inline __fastcall TDeleteBufUndo(int ACurX0, int ACurY0, int ACurX, int ACurY, System::UnicodeString AText) : TSelUndo(ACurX0, ACurY0, ACurX, ACurY, AText) { }
	
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TDeleteBufUndo(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TPasteUndo;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TPasteUndo : public TUndo
{
	typedef TUndo inherited;
	
public:
	__fastcall TPasteUndo(int ACurX0, int ACurY0, int ACurX, int ACurY, System::UnicodeString AText, bool IsLinked);
	virtual void __fastcall PerformUndo(void);
	virtual void __fastcall PerformRedo(void);
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TPasteUndo(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TInsertOverwriteUndo;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TInsertOverwriteUndo : public TUndo
{
	typedef TUndo inherited;
	
private:
	bool FInsertMode;
	
public:
	__fastcall TInsertOverwriteUndo(bool AInsertMode);
	virtual void __fastcall PerformUndo(void);
	virtual void __fastcall PerformRedo(void);
	__property bool InsertMode = {read=FInsertMode, write=FInsertMode, nodefault};
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TInsertOverwriteUndo(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TIndentUndo;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TIndentUndo : public TUndo
{
	typedef TUndo inherited;
	
private:
	int FIndent;
	int FSelRowFrom;
	int FSelRowTo;
	
public:
	__fastcall TIndentUndo(int SelFrom, int SelTo, int Indent);
	__property int Indent = {read=FIndent, write=FIndent, nodefault};
	__property int SelRowFrom = {read=FSelRowFrom, write=FSelRowFrom, nodefault};
	__property int SelRowTo = {read=FSelRowTo, write=FSelRowTo, nodefault};
	virtual void __fastcall PerformUndo(void);
	virtual void __fastcall PerformRedo(void);
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TIndentUndo(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TCorrectUndo;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCorrectUndo : public TUndo
{
	typedef TUndo inherited;
	
public:
	__fastcall TCorrectUndo(int LineNo, System::UnicodeString UndoLine);
	virtual void __fastcall PerformUndo(void);
	virtual void __fastcall PerformRedo(void);
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TCorrectUndo(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TAdvUndoList;
class PASCALIMPLEMENTATION TAdvUndoList : public System::Generics::Collections::TList__1<TUndo*>
{
	typedef System::Generics::Collections::TList__1<TUndo*> inherited;
	
private:
	int FPos;
	TTMSFMXMemo* FMemo;
	bool FIsPerforming;
	int FLimit;
	
protected:
	void __fastcall SetLimit(int Value);
	
public:
	__fastcall TAdvUndoList(void);
	__fastcall virtual ~TAdvUndoList(void);
	HIDESBASE int __fastcall Add(TUndo* AItem);
	HIDESBASE void __fastcall Clear(void);
	HIDESBASE void __fastcall Delete(int Index);
	void __fastcall Undo(void);
	void __fastcall Redo(void);
	__property bool IsPerforming = {read=FIsPerforming, write=FIsPerforming, nodefault};
	__property TTMSFMXMemo* Memo = {read=FMemo, write=FMemo};
	__property int Pos = {read=FPos, write=FPos, nodefault};
	__property int Limit = {read=FLimit, write=SetLimit, nodefault};
};


typedef void __fastcall (__closure *TUndoChangeEvent)(System::TObject* Sender, bool CanUndo, bool CanRedo);

class DELPHICLASS TFMXMemoStrings;
class PASCALIMPLEMENTATION TFMXMemoStrings : public System::Classes::TStringList
{
	typedef System::Classes::TStringList inherited;
	
private:
	TTMSFMXMemo* Memo;
	bool FDeleting;
	System::Generics::Collections::TList__1<TLineProp*>* FLinesProp;
	TIntList* FListLengths;
	bool FNoObjCreate;
	int __fastcall GetRealCount(void);
	System::UnicodeString __fastcall GetTextEx(void);
	void __fastcall SetTextEx(const System::UnicodeString Value);
	
protected:
	virtual System::UnicodeString __fastcall Get(int Index);
	virtual void __fastcall Put(int Index, const System::UnicodeString S);
	virtual System::TObject* __fastcall GetObject(int Index);
	virtual void __fastcall PutObject(int Index, System::TObject* AObject);
	void __fastcall RestoreObject(int Index, System::TObject* AObject);
	TLineProp* __fastcall CreateProp(int Index);
	void __fastcall ClearLinesProp(bool UpdateObject = true);
	void __fastcall AddLineProp(System::TObject* p);
	TLineProp* __fastcall GetLineProp(int Index);
	void __fastcall SetLineProp(int Index, TLineProp* const Value);
	void __fastcall AssignEx(System::Classes::TPersistent* Source);
	__property System::Generics::Collections::TList__1<TLineProp*>* PropList = {read=FLinesProp};
	
public:
	__fastcall TFMXMemoStrings(void);
	__fastcall virtual ~TFMXMemoStrings(void);
	int __fastcall DoAdd(const System::UnicodeString S);
	virtual int __fastcall Add(const System::UnicodeString S);
	virtual int __fastcall AddObject(const System::UnicodeString S, System::TObject* AObject);
	virtual void __fastcall Clear(void);
	void __fastcall ClearStrings(void);
	virtual void __fastcall AddStrings(System::Classes::TStrings* strings)/* overload */;
	void __fastcall DoInsert(int Index, const System::UnicodeString S);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	virtual void __fastcall Delete(int Index);
	virtual void __fastcall Insert(int Index, const System::UnicodeString S);
	virtual void __fastcall LoadFromFile(const System::UnicodeString FileName)/* overload */;
	virtual void __fastcall LoadFromStream(System::Classes::TStream* Stream)/* overload */;
	virtual void __fastcall SaveToStream(System::Classes::TStream* Stream)/* overload */;
	virtual void __fastcall SaveToFile(const System::UnicodeString FileName)/* overload */;
	virtual void __fastcall SaveToFile(const System::UnicodeString FileName, System::Sysutils::TEncoding* Encoding)/* overload */;
	__property int RealCount = {read=GetRealCount, nodefault};
	__property System::UnicodeString Text = {read=GetTextEx, write=SetTextEx};
	
__published:
	__property OnChange;
	__property OnChanging;
/* Hoisted overloads: */
	
public:
	inline void __fastcall  AddStrings(const System::DynamicArray<System::UnicodeString> Strings){ System::Classes::TStrings::AddStrings(Strings); }
	inline void __fastcall  AddStrings(const System::DynamicArray<System::UnicodeString> Strings, const System::DynamicArray<System::TObject*> Objects){ System::Classes::TStrings::AddStrings(Strings, Objects); }
	inline void __fastcall  LoadFromFile(const System::UnicodeString FileName, System::Sysutils::TEncoding* Encoding){ System::Classes::TStrings::LoadFromFile(FileName, Encoding); }
	inline void __fastcall  LoadFromStream(System::Classes::TStream* Stream, System::Sysutils::TEncoding* Encoding){ System::Classes::TStrings::LoadFromStream(Stream, Encoding); }
	inline void __fastcall  SaveToStream(System::Classes::TStream* Stream, System::Sysutils::TEncoding* Encoding){ System::Classes::TStrings::SaveToStream(Stream, Encoding); }
	
};


class DELPHICLASS TMemoComboListBox;
class PASCALIMPLEMENTATION TMemoComboListBox : public Fmx::Listbox::TListBox
{
	typedef Fmx::Listbox::TListBox inherited;
	
public:
	float __fastcall AutoAdaptWidth(void);
public:
	/* TCustomListBox.Create */ inline __fastcall virtual TMemoComboListBox(System::Classes::TComponent* AOwner) : Fmx::Listbox::TListBox(AOwner) { }
	/* TCustomListBox.Destroy */ inline __fastcall virtual ~TMemoComboListBox(void) { }
	
};


typedef void __fastcall (__closure *TMemoGetCompletionListEvent)(System::TObject* Sender, System::UnicodeString AToken, System::Classes::TStringList* AList);

typedef void __fastcall (__closure *TMemoAutoCompletionCustomizeItem)(System::TObject* Sender, Fmx::Listbox::TListBoxItem* AAutoCompletionItem);

typedef void __fastcall (__closure *TMemoAutoCompletionCustomizeList)(System::TObject* Sender, TMemoComboListBox* AAutoCompletionList);

typedef void __fastcall (__closure *TMemoBeforeCompleteEvent)(System::TObject* Sender, System::UnicodeString AToken, bool &Show);

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

typedef void __fastcall (__closure *TMemoGutterEvent)(System::TObject* Sender, int LineNo);

typedef void __fastcall (__closure *TMemoContextMenuEvent)(System::TObject* Sender, Fmx::Menus::TPopupMenu* Menu);

typedef void __fastcall (__closure *TMemoContextMenuItemEvent)(System::TObject* Sender, Fmx::Menus::TPopupMenu* Menu, Fmx::Menus::TMenuItem* Item);

class DELPHICLASS TAutoCompletion;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TAutoCompletion : public System::Classes::TPersistent
{
	typedef System::Classes::TPersistent inherited;
	
private:
	TTMSFMXMemo* FOwner;
	System::UnicodeString FStartToken;
	bool FSizeDropDown;
	int FWidth;
	int FMaxWidth;
	bool FFromFirstChar;
	bool FAutoWidth;
	bool FActive;
	int FHeight;
	int FAutoCompletionCount;
	
public:
	__fastcall TAutoCompletion(TTMSFMXMemo* AOwner);
	__fastcall virtual ~TAutoCompletion(void);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	
__published:
	__property bool Active = {read=FActive, write=FActive, default=1};
	__property bool AutoWidth = {read=FAutoWidth, write=FAutoWidth, default=1};
	__property int AutoCompletionCount = {read=FAutoCompletionCount, write=FAutoCompletionCount, default=8};
	__property bool FromFirstChar = {read=FFromFirstChar, write=FFromFirstChar, default=1};
	__property int Height = {read=FHeight, write=FHeight, default=100};
	__property bool SizeDropDown = {read=FSizeDropDown, write=FSizeDropDown, default=1};
	__property System::UnicodeString StartToken = {read=FStartToken, write=FStartToken};
	__property int Width = {read=FWidth, write=FWidth, default=200};
	__property int MaxWidth = {read=FMaxWidth, write=FMaxWidth, default=0};
};

#pragma pack(pop)

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


class DELPHICLASS TTMSFMXActiveLineSettings;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TTMSFMXActiveLineSettings : public System::Classes::TPersistent
{
	typedef System::Classes::TPersistent inherited;
	
private:
	TTMSFMXMemo* FMemo;
	bool FActiveLineAtCursor;
	bool FShowActiveLine;
	bool FShowActiveLineIndicator;
	void __fastcall SetShowActiveLine(const bool Value);
	void __fastcall SetShowActiveLineIndicator(const bool Value);
	void __fastcall SetActiveLineAtCursor(const bool Value);
	
public:
	__fastcall TTMSFMXActiveLineSettings(TTMSFMXMemo* AOwner);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	
__published:
	__property bool ShowActiveLine = {read=FShowActiveLine, write=SetShowActiveLine, nodefault};
	__property bool ShowActiveLineIndicator = {read=FShowActiveLineIndicator, write=SetShowActiveLineIndicator, nodefault};
	__property bool ActiveLineAtCursor = {read=FActiveLineAtCursor, write=SetActiveLineAtCursor, default=0};
public:
	/* TPersistent.Destroy */ inline __fastcall virtual ~TTMSFMXActiveLineSettings(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TTMSFMXGutter;
class PASCALIMPLEMENTATION TTMSFMXGutter : public System::Classes::TPersistent
{
	typedef System::Classes::TPersistent inherited;
	
private:
	TTMSFMXMemo* FOwner;
	bool FShowLeadingZeros;
	int FDigitCount;
	System::UnicodeString FNumberSuffix;
	int FLineNumberAt;
	bool FShowLineNumbers;
	int FLineNumberStart;
	System::Classes::TNotifyEvent FOnChange;
	Fmx::Graphics::TFont* FFont;
	void __fastcall SetDigitCount(const int Value);
	void __fastcall SetLineNumberAt(const int Value);
	void __fastcall SetLineNumberStart(const int Value);
	void __fastcall SetNumberSuffix(const System::UnicodeString Value);
	void __fastcall SetShowLeadingZeros(const bool Value);
	void __fastcall SetShowLineNumbers(const bool Value);
	void __fastcall SetFont(Fmx::Graphics::TFont* const Value);
	
protected:
	void __fastcall FontChanged(System::TObject* Sender);
	virtual void __fastcall Changed(void);
	
public:
	__property System::Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	__fastcall TTMSFMXGutter(TTMSFMXMemo* AOwner);
	__fastcall virtual ~TTMSFMXGutter(void);
	
__published:
	__property int DigitCount = {read=FDigitCount, write=SetDigitCount, default=4};
	__property Fmx::Graphics::TFont* Font = {read=FFont, write=SetFont};
	__property int LineNumberAt = {read=FLineNumberAt, write=SetLineNumberAt, default=1};
	__property int LineNumberStart = {read=FLineNumberStart, write=SetLineNumberStart, default=1};
	__property System::UnicodeString NumberSuffix = {read=FNumberSuffix, write=SetNumberSuffix};
	__property bool ShowLineNumbers = {read=FShowLineNumbers, write=SetShowLineNumbers, default=1};
	__property bool ShowLeadingZeros = {read=FShowLeadingZeros, write=SetShowLeadingZeros, default=0};
};


enum DECLSPEC_DENUM TEditCharCase : unsigned char { ecNormal, ecUpperCase, ecLowerCase };

class DELPHICLASS TTMSFMXMemoCustomStyler;
class PASCALIMPLEMENTATION TTMSFMXMemo : public Fmx::Tmsbasecontrol::TTMSFMXBaseControl
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseControl inherited;
	
private:
	System::UnicodeString FImeText;
	bool FDblClicked;
	Fmx::Controls::TCaret* FCaret;
	Fmx::Menus::TPopupMenu* FMemoContext;
	TIntList* FBookmarkList;
	int FUpdateCount;
	int FActiveLine;
	System::Classes::TStringList* FAutoCompleteList;
	bool FAutoCompleteDot;
	System::Types::TPoint FDotPoint;
	bool FDroppedDown;
	Fmx::Tmspopup::TTMSFMXPopup* FPopup;
	TMemoComboListBox* FListBox;
	TCellSize FCellSize;
	TTMSFMXGutter* FGutter;
	TTMSFMXActiveLineSettings* FActiveLineSettings;
	TTMSFMXMemoCustomStyler* FSyntaxStyles;
	int FLeftCol;
	int FTopLine;
	TFMXMemoStrings* FLines;
	bool FCaseSensitive;
	bool FHideSelection;
	System::UnicodeString FTempdelimiters;
	System::UnicodeString FtmpNoStart;
	System::UnicodeString FtmpNo;
	System::UnicodeString FtmpNoHex;
	int FSelStartX;
	int FSelStartY;
	int FSelEndX;
	int FSelEndY;
	int FPrevSelX;
	int FPrevSelY;
	bool FUseStyler;
	bool FUrlAware;
	System::UnicodeString FUrlDelimiters;
	int FTabSize;
	int FbackupTopLine;
	int FCurX;
	int FCurY;
	int FMaxLength;
	Fmx::Text::TTextService* FTextService;
	Fmx::Types::TVirtualKeyboardType FKeyboardType;
	bool FCaretVisible;
	System::UnicodeString FCachedDelimiters;
	bool FOverwrite;
	Fmx::Graphics::TFont* FFont;
	System::Uitypes::TAlphaColor FFontColor;
	bool FSelButtonDown;
	bool FLeftButtonDown;
	bool FSelClick;
	bool FSelChange;
	bool FSelectSingleLine;
	TSelectionMode FSelectionMode;
	Fmx::Stdctrls::TScrollBar* FVertScrollBar;
	Fmx::Stdctrls::TScrollBar* FHorzScrollBar;
	System::Classes::TNotifyEvent FOnSelectionChange;
	bool FTrimTrailingSpaces;
	System::Uitypes::TAlphaColor FSelectionTextColor;
	System::Uitypes::TAlphaColor FSelectionBackGroundColor;
	bool FInternalDelete;
	TMemoClipboardEvent FOnClipboardAction;
	TAnchorEvent FOnAnchorClick;
	bool FDelErase;
	bool FEnhancedHomeKey;
	int FClipLine;
	int FRightMargin;
	bool FShowRightMargin;
	TAdvUndoList* FUndoList;
	int FUndoLimit;
	bool FUndoLineByLine;
	TUndoChangeEvent FOnUndoChange;
	bool FAutoIndent;
	bool FAutoExpand;
	bool FWantTab;
	bool FSmartTabs;
	TMemoGetCompletionListEvent FOnGetAutoCompletionList;
	System::Classes::TNotifyEvent FOnAutoCompletion;
	TMemoInsertCompletionEntryEvent FOnInsertAutoCompletionEntry;
	TAutoCompletion* FAutoCompletion;
	System::Classes::TNotifyEvent FOnCancelAutoCompletion;
	TMemoAutoCompletionCustomizeItem FOnAutoCompletionCustomizeItem;
	TMemoGutterEvent FOnGutterDblClick;
	TMemoGutterEvent FOnGutterClick;
	TMemoAutoCompletionCustomizeList FOnAutoCompletionCustomizeList;
	TMemoBeforeCompleteEvent FOnBeforeAutoCompletion;
	System::Uitypes::TAlphaColor FBreakPointBackGroundColor;
	System::Uitypes::TAlphaColor FBreakPointTextColor;
	bool FShowBands;
	System::Classes::TStringList* FHtml;
	System::UnicodeString FHtmlFont;
	Fmx::Tmsrtfengine::TRTFEngine* FRTFEngine;
	System::UnicodeString FHighlightText;
	TEditCharCase FCharCase;
	int FGutterLine;
	System::Classes::TNotifyEvent FOnCursorChange;
	TMemoOverwriteToggleEvent FOnOverWriteToggle;
	TMemoContextMenuEvent FOnShowContextMenu;
	TMemoContextMenuItemEvent FOnContextMenuItemClick;
	bool FReadOnly;
	int FLineSpacing;
	void __fastcall CheckCodeInsightChar(System::WideChar Key);
	void __fastcall PerformAutoComplete(void);
	virtual bool __fastcall IsCompletionListActivationChar(System::WideChar Ch);
	void __fastcall OnFontChanged(System::TObject* Sender);
	void __fastcall GutterChanged(System::TObject* Sender);
	TAdvUndoList* __fastcall InternalUndoList(void);
	void __fastcall SetUndoLimit(int Value);
	void __fastcall SetLeftCol(const int Value);
	void __fastcall SetTopLine(const int Value);
	void __fastcall SetLines(TFMXMemoStrings* const Value);
	void __fastcall SetSyntaxStyles(TTMSFMXMemoCustomStyler* const Value);
	void __fastcall ExpandSelection(void);
	bool __fastcall DeleteSelectionInt(void);
	System::UnicodeString __fastcall GetSelText(void);
	void __fastcall SetSelText(const System::UnicodeString AValue);
	int __fastcall GetSelLength(void);
	int __fastcall GetSelStart(void);
	void __fastcall SetSelStart(const int Value);
	void __fastcall SetSelLength(const int Value);
	void __fastcall SetSelectionMode(const TSelectionMode Value);
	System::UnicodeString __fastcall GetVersion(void);
	int __fastcall GetVersionNr(void);
	void __fastcall SetVersion(const System::UnicodeString Value);
	TStyle __fastcall GetUpStyle(int stopat);
	TTMSFMXMemoCustomStyler* __fastcall GetInternalStyles(void);
	void __fastcall SetUseStyler(const bool Value);
	TFMXMemoStrings* __fastcall GetInternalLines(void);
	void __fastcall SetInternalLines(TFMXMemoStrings* const Value);
	bool __fastcall GetLineStyle(int Index, TStyle &LineStyle);
	void __fastcall SetLineStyle(int Index, const TStyle &LineStyle);
	void __fastcall ExtractURL(System::UnicodeString s, System::Classes::TStringList* &urls);
	void __fastcall SetUrlAware(const bool Value);
	bool __fastcall IsDelimiter(System::WideChar value);
	void __fastcall SelClickUpdate(float X, float Y, bool Down, System::Classes::TShiftState Shift, System::Uitypes::TMouseButton Button);
	void __fastcall ResizeScrollBars(void);
	System::Types::TRectF __fastcall EditorRect(void);
	System::Types::TRectF __fastcall CellRect(int ACol, int ARow);
	System::Types::TRectF __fastcall LineRect(int ARow);
	System::UnicodeString __fastcall TrimRightWW(int LineNo);
	void __fastcall DoCommand(int cmd, const System::Classes::TShiftState AShift);
	void __fastcall GoHome(System::Classes::TShiftState Shift);
	void __fastcall GoEnd(System::Classes::TShiftState Shift);
	void __fastcall DeleteChar(int OldX, int OldY);
	void __fastcall BackSpace(void);
	void __fastcall NewLine(void);
	System::UnicodeString __fastcall IndentCurrLine(void);
	void __fastcall MovePage(int dP, System::Classes::TShiftState Shift);
	void __fastcall ClearLineStylesFromTo(int FromLine, int ToLine);
	void __fastcall SetCurX(int Value);
	void __fastcall SetCurY(int Value);
	bool __fastcall CaretVisible(void);
	void __fastcall ShowCaret(bool Value);
	void __fastcall MoveCaret(int dX, int dY, System::Classes::TShiftState Shift);
	void __fastcall MakeVisible(void);
	float __fastcall GetCaretX(void);
	float __fastcall GetCaretY(void);
	void __fastcall SetCaretX(const float Value);
	void __fastcall SetCaretY(const float Value);
	int __fastcall GetVisibleN(const int Index);
	void __fastcall SetFont(Fmx::Graphics::TFont* const Value);
	void __fastcall SetTrimTrailingSpaces(const bool Value);
	bool __fastcall GetBookmark(int Index);
	int __fastcall GetBookmarkCount(void);
	int __fastcall GetBookmarkIndex(int Index);
	bool __fastcall GetBookmarkInfo(int Index, int &AValue);
	int __fastcall GetBookmarks(int Index);
	bool __fastcall GetBreakPoint(int Index);
	void __fastcall SetBookmark(int Index, const bool Value);
	void __fastcall SetBookmarkIndex(int Index, const int Value);
	void __fastcall SetBookmarks(int Index, const int Value);
	void __fastcall SetBreakPoint(int Index, const bool Value);
	void __fastcall SetRightMargin(const int Value);
	void __fastcall SetShowRightMargin(const bool Value);
	void __fastcall SetGutter(TTMSFMXGutter* const Value);
	void __fastcall SetShowBands(const bool Value);
	void __fastcall SetActiveLineSettings(TTMSFMXActiveLineSettings* const Value);
	void __fastcall SetActiveLine(const int Value);
	void __fastcall SetFontColor(const System::Uitypes::TAlphaColor Value);
	void __fastcall SetBreakLineColor(const System::Uitypes::TAlphaColor Value);
	void __fastcall SetBreakLineTextColor(const System::Uitypes::TAlphaColor Value);
	void __fastcall SetSelectionColor(const System::Uitypes::TAlphaColor Value);
	void __fastcall SetSelectionTextColor(const System::Uitypes::TAlphaColor Value);
	void __fastcall SetHighlightText(const System::UnicodeString Value);
	void __fastcall SetLineSpacing(const int Value);
	__property float CaretX = {read=GetCaretX, write=SetCaretX};
	__property float CaretY = {read=GetCaretY, write=SetCaretY};
	__property int VisibleLineCount = {read=GetVisibleN, index=1, nodefault};
	__property int LastVisiblePos = {read=GetVisibleN, index=2, nodefault};
	void __fastcall SetKeyboardType(Fmx::Types::TVirtualKeyboardType Value);
	Fmx::Types::TVirtualKeyboardType __fastcall GetKeyboardType(void);
	void __fastcall SetReturnKeyType(Fmx::Types::TReturnKeyType Value);
	Fmx::Types::TReturnKeyType __fastcall GetReturnKeyType(void);
	void __fastcall BackWord(void);
	
protected:
	bool FLetRefresh;
	bool FSetMaxLength;
	virtual void __fastcall ApplyAdditionalStyle(Fmx::Types::TFmxObject* AControl);
	void __fastcall ContextMenuItemClick(System::TObject* Sender);
	virtual void __fastcall DialogKey(System::Word &Key, System::Classes::TShiftState Shift);
	void __fastcall CalculateCellSize(void);
	void __fastcall DoClosePopup(System::TObject* Sender);
	virtual TMemoComboListBox* __fastcall CreateListBox(void);
	void __fastcall ListBoxItemClick(System::TObject* Sender);
	void __fastcall ListBoxKeyDown(System::TObject* Sender, System::Word &Key, System::WideChar &KeyChar, System::Classes::TShiftState Shift);
	void __fastcall ListBoxKeyUp(System::TObject* Sender, System::Word &Key, System::WideChar &KeyChar, System::Classes::TShiftState Shift);
	void __fastcall ListBoxItemApplyStyleLookup(System::TObject* Sender);
	void __fastcall ListBoxApplyStyleLookup(System::TObject* Sender);
	virtual void __fastcall ApplyStyle(void);
	virtual void __fastcall DoEnter(void);
	virtual void __fastcall DoExit(void);
	virtual void __fastcall PaintChildren(void);
	void __fastcall DoGutterMouseDown(System::TObject* Sender, System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, float X, float Y);
	void __fastcall DoGutterDblClick(System::TObject* Sender);
	virtual void __fastcall DoAnchorClick(System::UnicodeString &Anchor, int X, int Y);
	virtual void __fastcall DblClick(void);
	int __fastcall FindTextInt(System::UnicodeString SearchStr, Fmx::Tmsfinddialog::TTMSFMXFindDialogOptions Options, bool Count);
	System::UnicodeString __fastcall NextToken(const System::UnicodeString s, int StartFrom, int &Offset);
	System::UnicodeString __fastcall FormatLineNumber(int Line);
	void __fastcall PaintGutter(System::TObject* Sender, Fmx::Graphics::TCanvas* Canvas, const System::Types::TRectF &ARect);
	void __fastcall PaintLine(Fmx::Graphics::TCanvas* ACanvas, int LineNo, TStyle &style, TDrawMode DM, const System::Types::TRectF &PR, int VisLineNo = 0xffffffff);
	void __fastcall PaintHTML(System::UnicodeString Part, TStyle &Drawstyle, int lineno);
	void __fastcall PaintRTF(System::UnicodeString Part, TStyle &Drawstyle, int lineno);
	void __fastcall PaintMemo(System::TObject* Sender, Fmx::Graphics::TCanvas* Canvas, const System::Types::TRectF &ARect);
	virtual void __fastcall Loaded(void);
	virtual void __fastcall MouseDown(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, float X, float Y);
	virtual void __fastcall MouseMove(System::Classes::TShiftState Shift, float X, float Y);
	virtual void __fastcall MouseUp(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, float X, float Y);
	virtual void __fastcall MouseWheel(System::Classes::TShiftState Shift, int WheelDelta, bool &Handled);
	virtual void __fastcall KeyDown(System::Word &Key, System::WideChar &KeyChar, System::Classes::TShiftState Shift);
	void __fastcall DoVScroll(System::TObject* Sender);
	void __fastcall DoHScroll(System::TObject* Sender);
	void __fastcall LinesChanged(System::TObject* Sender);
	void __fastcall InitScrollbars(void);
	virtual void __fastcall Notification(System::Classes::TComponent* AComponent, System::Classes::TOperation Operation);
	virtual bool __fastcall WordIsURL(System::UnicodeString s);
	void __fastcall TabLine(System::Classes::TShiftState AShift);
	virtual void __fastcall SelectionChanged(void);
	virtual void __fastcall DoCopyToClipboard(void);
	virtual void __fastcall DoCutToClipboard(void);
	virtual void __fastcall DoPasteFromClipboard(void);
	virtual void __fastcall DoCursorChange(void);
	virtual void __fastcall DoOverwriteToggle(bool &Allow);
	virtual void __fastcall DoClipboardAction(TMemoClipboardAction ClipboardAction, bool &Allow);
	virtual void __fastcall DoShowContextMenu(Fmx::Menus::TPopupMenu* Menu);
	virtual void __fastcall DoContextMenuItemClick(Fmx::Menus::TPopupMenu* Menu, Fmx::Menus::TMenuItem* Item);
	Fmx::Controls::TCaret* __fastcall CreateCaret(void);
	__property Fmx::Controls::TCaret* Caret = {read=FCaret, write=FCaret};
	__property TTMSFMXMemoCustomStyler* InternalStyles = {read=GetInternalStyles};
	__property TFMXMemoStrings* InternalLines = {read=GetInternalLines, write=SetInternalLines};
	__property int MaxLength = {read=FMaxLength, nodefault};
	void __fastcall SetMaxLength(void);
	void __fastcall ClearLineStyles(void);
	void __fastcall ResizeEditor(void);
	void __fastcall ClearUndoList(void);
	void __fastcall UndoChange(void);
	void __fastcall OutputHTML(bool FixedFonts, int fromline = 0xffffffff, int toline = 0xffffffff, bool fragment = false);
	void __fastcall OutputRTF(bool FixedFonts, int fromline = 0xffffffff, int toline = 0xffffffff);
	
public:
	__property Fmx::Menus::TPopupMenu* MemoContext = {read=FMemoContext, write=FMemoContext};
	void __fastcall InsertChar(System::WideChar C);
	void __fastcall BlockUpdate(void);
	void __fastcall EndBlockUpdate(void);
	void __fastcall UpdateMemo(void);
	void __fastcall ClearBookmarks(void);
	void __fastcall ClearBreakpoints(void);
	void __fastcall GotoBookmark(int Index);
	bool __fastcall HasBookmarks(void);
	int __fastcall FindTextCount(System::UnicodeString SearchStr, Fmx::Tmsfinddialog::TTMSFMXFindDialogOptions Options);
	int __fastcall FindText(System::UnicodeString SearchStr, Fmx::Tmsfinddialog::TTMSFMXFindDialogOptions Options);
	int __fastcall FindAndReplace(System::UnicodeString SearchStr, System::UnicodeString NewStr, Fmx::Tmsfinddialog::TTMSFMXFindDialogOptions Options);
	void __fastcall TextFromPos(int X, int Y, int &TextPos);
	void __fastcall PosFromText(int TextPos, int &X, int &Y);
	TFullPos __fastcall CharFromPos(float X, float Y);
	TCellPos __fastcall CellFromPos(float X, float Y);
	__property int ActiveLine = {read=FActiveLine, write=SetActiveLine, nodefault};
	__property bool Bookmark[int Index] = {read=GetBookmark, write=SetBookmark};
	__property int Bookmarks[int Index] = {read=GetBookmarks, write=SetBookmarks};
	__property int BookmarkIndex[int Index] = {read=GetBookmarkIndex, write=SetBookmarkIndex};
	__property int BookmarkCount = {read=GetBookmarkCount, nodefault};
	__property bool BreakPoint[int Index] = {read=GetBreakPoint, write=SetBreakPoint};
	__property int CurX = {read=FCurX, write=SetCurX, nodefault};
	__property int CurY = {read=FCurY, write=SetCurY, nodefault};
	HIDESBASE void __fastcall SetCursor(int ACurX, int ACurY);
	Fmx::Menus::TMenuItem* __fastcall GetContextMenuItem(int Command);
	Fmx::Stdctrls::TLabel* __fastcall GetAutoCompletionFont(void);
	__fastcall virtual TTMSFMXMemo(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXMemo(void);
	void __fastcall DeleteLine(void);
	void __fastcall ClearSelection(void);
	void __fastcall Clear(void);
	void __fastcall CopyToClipboard(void);
	void __fastcall PasteFromClipboard(void);
	void __fastcall CutToClipboard(void);
	void __fastcall SelectAll(void);
	void __fastcall DeleteSelection(void);
	void __fastcall SelectWordAtCursor(void);
	void __fastcall BlockIndent(int FromLine, int ToLine, int Indent, bool AllowUndo = true);
	System::UnicodeString __fastcall FullWordAtCursor(void);
	System::UnicodeString __fastcall WordAtXY(int X, int Y);
	System::UnicodeString __fastcall TokenAtXY(int X, int Y);
	virtual bool __fastcall IsTokenBoundary(System::WideChar ch);
	virtual bool __fastcall IsWordBoundary(System::WideChar ch);
	__property System::UnicodeString HighlightText = {read=FHighlightText, write=SetHighlightText};
	__property System::UnicodeString Selection = {read=GetSelText, write=SetSelText};
	__property int SelStart = {read=GetSelStart, write=SetSelStart, nodefault};
	__property int SelLength = {read=GetSelLength, write=SetSelLength, nodefault};
	__property int SelStartX = {read=FSelStartX, nodefault};
	__property int SelStartY = {read=FSelStartY, nodefault};
	__property int SelEndX = {read=FSelEndX, nodefault};
	__property int SelEndY = {read=FSelEndY, nodefault};
	__property TSelectionMode SelectionMode = {read=FSelectionMode, write=SetSelectionMode, default=0};
	__property bool SelectSingleLine = {read=FSelectSingleLine, write=FSelectSingleLine, default=0};
	__property bool Overwrite = {read=FOverwrite, write=FOverwrite, nodefault};
	__property Fmx::Tmspopup::TTMSFMXPopup* Popup = {read=FPopup};
	__property TMemoComboListBox* PopupList = {read=FListBox};
	__property int LeftCol = {read=FLeftCol, write=SetLeftCol, nodefault};
	__property int TopLine = {read=FTopLine, write=SetTopLine, nodefault};
	Fmx::Stdctrls::TScrollBar* __fastcall GetVScroll(void);
	Fmx::Stdctrls::TScrollBar* __fastcall GetHScroll(void);
	Fmx::Objects::TRectangle* __fastcall GetGutter(void);
	Fmx::Objects::TRectangle* __fastcall GetMemoRect(void);
	int __fastcall GetGutterWidth(void);
	int __fastcall GetVertScrollWidth(void);
	int __fastcall GetHorzScrollHeight(void);
	void __fastcall HideCaret(void);
	void __fastcall ShowCaretProc(void);
	bool __fastcall SaveToHTML(System::UnicodeString FileName, bool Fixedfonts = true);
	bool __fastcall SaveToHTMLStream(System::Classes::TMemoryStream* AStream, bool Fixedfonts = true);
	bool __fastcall SaveToRTF(System::UnicodeString FileName, bool Fixedfonts = true);
	bool __fastcall SaveToRTFStream(System::Classes::TMemoryStream* AStream, bool Fixedfonts = true);
	virtual void __fastcall DoInsertAutoCompletionEntry(System::UnicodeString &AEntry);
	virtual void __fastcall GetAutoCompletionList(System::UnicodeString AToken, System::Classes::TStringList* AList);
	virtual void __fastcall UpdateCompletionList(System::UnicodeString AToken);
	virtual bool __fastcall BeforeAutoCompletion(System::UnicodeString AToken);
	virtual void __fastcall DoPopup(bool AUpdate = false);
	virtual void __fastcall SelectPopupValue(bool AutoParenthesis);
	Fmx::Graphics::TBitmap* __fastcall GetBookMarkBitmap(void);
	Fmx::Graphics::TBitmap* __fastcall GetBreakPointBitmap(void);
	Fmx::Graphics::TBitmap* __fastcall GetActiveLineBitmap(void);
	System::Uitypes::TAlphaColor __fastcall GetActiveLineColor(void);
	System::Uitypes::TAlphaColor __fastcall GetActiveLineTextColor(void);
	System::Uitypes::TAlphaColor __fastcall GetBandColor(void);
	System::Uitypes::TAlphaColor __fastcall GetBkgColor(void);
	System::Uitypes::TAlphaColor __fastcall GetSelectionColor(void);
	System::Uitypes::TAlphaColor __fastcall GetSelectionTextColor(void);
	System::Uitypes::TAlphaColor __fastcall GetBreakLineColor(void);
	System::Uitypes::TAlphaColor __fastcall GetBreakLineTextColor(void);
	__property System::Uitypes::TAlphaColor SelectionTextColor = {read=GetSelectionTextColor, write=SetSelectionTextColor, default=-1};
	__property System::Uitypes::TAlphaColor SelectionBackGroundColor = {read=GetSelectionColor, write=SetSelectionColor, default=-16777088};
	__property System::Uitypes::TAlphaColor BreakPointTextColor = {read=GetBreakLineTextColor, write=SetBreakLineTextColor, default=-1};
	__property System::Uitypes::TAlphaColor BreakPointBackGroundColor = {read=GetBreakLineColor, write=SetBreakLineColor, default=-65536};
	void __fastcall ClearUndoRedo(void);
	void __fastcall Undo(void);
	void __fastcall Redo(void);
	void __fastcall AddUndoStep(TUndo* AUndoStep);
	bool __fastcall CanUndo(void);
	bool __fastcall CanRedo(void);
	bool __fastcall CanCopy(void);
	bool __fastcall CanCut(void);
	__property TAdvUndoList* UndoList = {read=InternalUndoList};
	
__published:
	__property TTMSFMXActiveLineSettings* ActiveLineSettings = {read=FActiveLineSettings, write=SetActiveLineSettings};
	__property TAutoCompletion* AutoCompletion = {read=FAutoCompletion, write=FAutoCompletion};
	__property bool AutoIndent = {read=FAutoIndent, write=FAutoIndent, default=1};
	__property bool AutoExpand = {read=FAutoExpand, write=FAutoExpand, default=1};
	__property bool CaseSensitive = {read=FCaseSensitive, write=FCaseSensitive, nodefault};
	__property TEditCharCase CharCase = {read=FCharCase, write=FCharCase, default=0};
	__property bool DelErase = {read=FDelErase, write=FDelErase, default=1};
	__property bool EnhancedHomeKey = {read=FEnhancedHomeKey, write=FEnhancedHomeKey, default=0};
	__property Fmx::Graphics::TFont* Font = {read=FFont, write=SetFont};
	__property System::Uitypes::TAlphaColor FontColor = {read=FFontColor, write=SetFontColor, default=-16777216};
	__property TTMSFMXGutter* Gutter = {read=FGutter, write=SetGutter};
	__property bool HideSelection = {read=FHideSelection, write=FHideSelection, default=0};
	__property Fmx::Types::TVirtualKeyboardType KeyboardType = {read=GetKeyboardType, write=SetKeyboardType, nodefault};
	__property TFMXMemoStrings* Lines = {read=FLines, write=SetLines};
	__property int LineSpacing = {read=FLineSpacing, write=SetLineSpacing, default=2};
	__property bool ReadOnly = {read=FReadOnly, write=FReadOnly, nodefault};
	__property int RightMargin = {read=FRightMargin, write=SetRightMargin, default=80};
	__property TTMSFMXMemoCustomStyler* SyntaxStyles = {read=FSyntaxStyles, write=SetSyntaxStyles};
	__property bool ShowBands = {read=FShowBands, write=SetShowBands, default=0};
	__property bool ShowRightMargin = {read=FShowRightMargin, write=SetShowRightMargin, default=1};
	__property bool SmartTabs = {read=FSmartTabs, write=FSmartTabs, default=0};
	__property int TabSize = {read=FTabSize, write=FTabSize, nodefault};
	__property bool TrimTrailingSpaces = {read=FTrimTrailingSpaces, write=SetTrimTrailingSpaces, nodefault};
	__property bool UseStyler = {read=FUseStyler, write=SetUseStyler, nodefault};
	__property bool UrlAware = {read=FUrlAware, write=SetUrlAware, default=1};
	__property System::UnicodeString Version = {read=GetVersion, write=SetVersion};
	__property bool WantTab = {read=FWantTab, write=FWantTab, default=0};
	__property int UndoLimit = {read=FUndoLimit, write=SetUndoLimit, default=100};
	__property bool UndoLineByLine = {read=FUndoLineByLine, write=FUndoLineByLine, default=0};
	__property TAnchorEvent OnAnchorClick = {read=FOnAnchorClick, write=FOnAnchorClick};
	__property System::Classes::TNotifyEvent OnAutoCompletion = {read=FOnAutoCompletion, write=FOnAutoCompletion};
	__property TMemoAutoCompletionCustomizeItem OnAutoCompletionCustomizeItem = {read=FOnAutoCompletionCustomizeItem, write=FOnAutoCompletionCustomizeItem};
	__property TMemoAutoCompletionCustomizeList OnAutoCompletionCustomizeList = {read=FOnAutoCompletionCustomizeList, write=FOnAutoCompletionCustomizeList};
	__property TMemoBeforeCompleteEvent OnBeforeAutoCompletion = {read=FOnBeforeAutoCompletion, write=FOnBeforeAutoCompletion};
	__property System::Classes::TNotifyEvent OnCancelAutoCompletion = {read=FOnCancelAutoCompletion, write=FOnCancelAutoCompletion};
	__property TMemoClipboardEvent OnClipboardAction = {read=FOnClipboardAction, write=FOnClipboardAction};
	__property TMemoContextMenuItemEvent OnContextMenuItemClick = {read=FOnContextMenuItemClick, write=FOnContextMenuItemClick};
	__property System::Classes::TNotifyEvent OnCursorChange = {read=FOnCursorChange, write=FOnCursorChange};
	__property TMemoGetCompletionListEvent OnGetAutoCompletionList = {read=FOnGetAutoCompletionList, write=FOnGetAutoCompletionList};
	__property TMemoGutterEvent OnGutterClick = {read=FOnGutterClick, write=FOnGutterClick};
	__property TMemoGutterEvent OnGutterDblClick = {read=FOnGutterDblClick, write=FOnGutterDblClick};
	__property TMemoInsertCompletionEntryEvent OnInsertAutoCompletionEntry = {read=FOnInsertAutoCompletionEntry, write=FOnInsertAutoCompletionEntry};
	__property TMemoOverwriteToggleEvent OnOverwriteToggle = {read=FOnOverWriteToggle, write=FOnOverWriteToggle};
	__property System::Classes::TNotifyEvent OnSelectionChange = {read=FOnSelectionChange, write=FOnSelectionChange};
	__property TMemoContextMenuEvent OnShowContextMenu = {read=FOnShowContextMenu, write=FOnShowContextMenu};
	__property TUndoChangeEvent OnUndoChange = {read=FOnUndoChange, write=FOnUndoChange};
private:
	void *__IVirtualKeyboardControl;	// Fmx::Types::IVirtualKeyboardControl 
	
public:
	#if defined(MANAGED_INTERFACE_OPERATORS)
	// {41127080-97FC-4C30-A880-AB6CD351A6C4}
	operator Fmx::Types::_di_IVirtualKeyboardControl()
	{
		Fmx::Types::_di_IVirtualKeyboardControl intf;
		GetInterface(intf);
		return intf;
	}
	#else
	operator Fmx::Types::IVirtualKeyboardControl*(void) { return (Fmx::Types::IVirtualKeyboardControl*)&__IVirtualKeyboardControl; }
	#endif
	
};


class DELPHICLASS TRegionDefinition;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TRegionDefinition : public System::Classes::TCollectionItem
{
	typedef System::Classes::TCollectionItem inherited;
	
private:
	TRegionType FRegionType;
	System::UnicodeString FRegionEnd;
	System::UnicodeString FIdentifier;
	System::UnicodeString FRegionStart;
	bool FShowComments;
	void __fastcall SetIdentifier(const System::UnicodeString Value);
	void __fastcall SetRegionEnd(const System::UnicodeString Value);
	void __fastcall SetRegionStart(const System::UnicodeString Value);
	void __fastcall SetRegionType(const TRegionType Value);
	
protected:
	virtual System::UnicodeString __fastcall GetDisplayName(void);
	
public:
	__fastcall virtual TRegionDefinition(System::Classes::TCollection* Collection);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	
__published:
	__property System::UnicodeString Identifier = {read=FIdentifier, write=SetIdentifier};
	__property System::UnicodeString RegionStart = {read=FRegionStart, write=SetRegionStart};
	__property System::UnicodeString RegionEnd = {read=FRegionEnd, write=SetRegionEnd};
	__property TRegionType RegionType = {read=FRegionType, write=SetRegionType, nodefault};
	__property bool ShowComments = {read=FShowComments, write=FShowComments, nodefault};
public:
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TRegionDefinition(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TElementStyle;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TElementStyle : public System::Classes::TCollectionItem
{
	typedef System::Classes::TCollectionItem inherited;
	
private:
	TTMSFMXMemo* FOwner;
	System::Classes::TStringList* FKeyWords;
	Fmx::Graphics::TFont* FFont;
	System::Uitypes::TAlphaColor FBGColor;
	System::UnicodeString FInfo;
	TStyleType FStyleType;
	int StyleNo;
	System::WideChar FBracketStart;
	System::WideChar FBracketEnd;
	System::UnicodeString FSymbols;
	System::Uitypes::TAlphaColor FFontColor;
	System::UnicodeString FCommentLeft;
	System::UnicodeString FCommentRight;
	void __fastcall SetColorbg(const System::Uitypes::TAlphaColor Value);
	void __fastcall SetFont(Fmx::Graphics::TFont* const Value);
	void __fastcall SetKeyWords(System::Classes::TStringList* const Value);
	void __fastcall SetStyleType(const TStyleType Value);
	void __fastcall SetBracketStart(const System::WideChar Value);
	void __fastcall SetBracketEnd(const System::WideChar Value);
	void __fastcall SetSymbols(const System::UnicodeString Value);
	
protected:
	virtual System::UnicodeString __fastcall GetDisplayName(void);
	
public:
	HIDESBASE void __fastcall Changed(void);
	__fastcall virtual TElementStyle(System::Classes::TCollection* Collection);
	__fastcall virtual ~TElementStyle(void);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	
__published:
	__property System::UnicodeString CommentLeft = {read=FCommentLeft, write=FCommentLeft};
	__property System::UnicodeString CommentRight = {read=FCommentRight, write=FCommentRight};
	__property System::Classes::TStringList* KeyWords = {read=FKeyWords, write=SetKeyWords};
	__property Fmx::Graphics::TFont* Font = {read=FFont, write=SetFont};
	__property System::Uitypes::TAlphaColor FontColor = {read=FFontColor, write=FFontColor, nodefault};
	__property System::Uitypes::TAlphaColor BGColor = {read=FBGColor, write=SetColorbg, nodefault};
	__property TStyleType StyleType = {read=FStyleType, write=SetStyleType, nodefault};
	__property System::WideChar BracketStart = {read=FBracketStart, write=SetBracketStart, nodefault};
	__property System::WideChar BracketEnd = {read=FBracketEnd, write=SetBracketEnd, nodefault};
	__property System::UnicodeString Symbols = {read=FSymbols, write=SetSymbols};
	__property System::UnicodeString Info = {read=FInfo, write=FInfo};
};

#pragma pack(pop)

class DELPHICLASS TElementStyles;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TElementStyles : public System::Classes::TOwnedCollection
{
	typedef System::Classes::TOwnedCollection inherited;
	
public:
	TElementStyle* operator[](int Index) { return Items[Index]; }
	
private:
	TTMSFMXMemo* FOwner;
	bool FModified;
	HIDESBASE TElementStyle* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, TElementStyle* const Value);
	
protected:
	virtual void __fastcall Update(System::Classes::TCollectionItem* Item);
	
public:
	virtual System::Classes::TCollectionItemClass __fastcall CreateItemClass(void);
	__fastcall TElementStyles(System::Classes::TComponent* AOwner);
	void __fastcall Init(void);
	HIDESBASE TElementStyle* __fastcall Add(void);
	HIDESBASE TElementStyle* __fastcall Insert(int Index);
	__property TElementStyle* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
	bool __fastcall IsWordBoundary(System::WideChar ch);
public:
	/* TCollection.Destroy */ inline __fastcall virtual ~TElementStyles(void) { }
	
};

#pragma pack(pop)

class DELPHICLASS TRegionDefinitions;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TRegionDefinitions : public Fmx::Tmsbasecontrol::TTMSFMXBaseCollection
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseCollection inherited;
	
public:
	TRegionDefinition* operator[](int Index) { return Items[Index]; }
	
private:
	System::Classes::TPersistent* FComponent;
	HIDESBASE TRegionDefinition* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, TRegionDefinition* Value);
	
protected:
	DYNAMIC System::Classes::TPersistent* __fastcall GetOwner(void);
	
public:
	__fastcall TRegionDefinitions(System::Classes::TPersistent* Component);
	__fastcall virtual ~TRegionDefinitions(void);
	__property TRegionDefinition* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
	HIDESBASE TRegionDefinition* __fastcall Add(void);
	HIDESBASE TRegionDefinition* __fastcall Insert(int Index);
};

#pragma pack(pop)

class DELPHICLASS TCharStyle;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TCharStyle : public System::Classes::TPersistent
{
	typedef System::Classes::TPersistent inherited;
	
private:
	System::Uitypes::TAlphaColor FTextColor;
	System::Uitypes::TAlphaColor FBkColor;
	System::Uitypes::TFontStyles FStyle;
	
public:
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	
__published:
	__property System::Uitypes::TAlphaColor TextColor = {read=FTextColor, write=FTextColor, nodefault};
	__property System::Uitypes::TAlphaColor BkColor = {read=FBkColor, write=FBkColor, nodefault};
	__property System::Uitypes::TFontStyles Style = {read=FStyle, write=FStyle, nodefault};
public:
	/* TPersistent.Destroy */ inline __fastcall virtual ~TCharStyle(void) { }
	
public:
	/* TObject.Create */ inline __fastcall TCharStyle(void) : System::Classes::TPersistent() { }
	
};

#pragma pack(pop)

class DELPHICLASS THintParameter;
#pragma pack(push,4)
class PASCALIMPLEMENTATION THintParameter : public System::Classes::TPersistent
{
	typedef System::Classes::TPersistent inherited;
	
private:
	System::Uitypes::TAlphaColor FTextColor;
	System::Uitypes::TAlphaColor FBkColor;
	System::WideChar FStartchar;
	System::WideChar FEndchar;
	System::WideChar FDelimiterchar;
	System::Classes::TStringList* FParameters;
	System::WideChar FWritedelimiterchar;
	System::WideChar FHintClassDelimiter;
	void __fastcall SetParameters(System::Classes::TStringList* const Value);
	
public:
	__fastcall THintParameter(void);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	__fastcall virtual ~THintParameter(void);
	
__published:
	__property System::Uitypes::TAlphaColor TextColor = {read=FTextColor, write=FTextColor, nodefault};
	__property System::Uitypes::TAlphaColor BkColor = {read=FBkColor, write=FBkColor, nodefault};
	__property System::WideChar HintCharStart = {read=FStartchar, write=FStartchar, nodefault};
	__property System::WideChar HintCharEnd = {read=FEndchar, write=FEndchar, nodefault};
	__property System::WideChar HintCharDelimiter = {read=FDelimiterchar, write=FDelimiterchar, nodefault};
	__property System::WideChar HintClassDelimiter = {read=FHintClassDelimiter, write=FHintClassDelimiter, nodefault};
	__property System::WideChar HintCharWriteDelimiter = {read=FWritedelimiterchar, write=FWritedelimiterchar, nodefault};
	__property System::Classes::TStringList* Parameters = {read=FParameters, write=SetParameters};
};

#pragma pack(pop)

class PASCALIMPLEMENTATION TTMSFMXMemoCustomStyler : public System::Classes::TComponent
{
	typedef System::Classes::TComponent inherited;
	
private:
	TElementStyles* FAllStyles;
	System::UnicodeString FLineComment;
	System::UnicodeString FMultiCommentLeft;
	System::UnicodeString FMultiCommentRight;
	TCharStyle* FCommentStyle;
	TCharStyle* FNumberStyle;
	TCharStyle* FURLStyle;
	System::Classes::TStringList* FlistAuto;
	THintParameter* FHintParameter;
	System::UnicodeString FNumericChars;
	System::UnicodeString FHexIdentifier;
	System::UnicodeString FBlockEnd;
	System::UnicodeString FBlockStart;
	System::UnicodeString FLiteral;
	bool FCustomDraw;
	System::UnicodeString FFilter;
	System::UnicodeString FDefaultExtension;
	System::UnicodeString FExtensions;
	System::UnicodeString FDescription;
	System::UnicodeString FStylerName;
	TRegionDefinitions* FRegionDefinitions;
	System::UnicodeString FEscapeChar;
	TCharStyle* FHighlightStyle;
	virtual void __fastcall SetStyle(const int Index, TCharStyle* const Value);
	void __fastcall SetStyles(TElementStyles* const Value);
	void __fastcall SetListAuto(System::Classes::TStringList* const Value);
	void __fastcall SetRegionDefinitions(TRegionDefinitions* Value);
	void __fastcall SetHighlightStyle(TCharStyle* const Value);
	
protected:
	virtual void __fastcall Notification(System::Classes::TComponent* AComponent, System::Classes::TOperation Operation);
	virtual void __fastcall Loaded(void);
	int __fastcall PosCommentLeft(System::UnicodeString s, int &cl);
	int __fastcall PosCommentRight(System::UnicodeString s, int &cl);
	bool __fastcall HasMultiComment(void);
	__property TRegionDefinitions* RegionDefinitions = {read=FRegionDefinitions, write=SetRegionDefinitions};
	
public:
	__fastcall virtual TTMSFMXMemoCustomStyler(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXMemoCustomStyler(void);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	__property System::UnicodeString Description = {read=FDescription, write=FDescription};
	__property System::UnicodeString Filter = {read=FFilter, write=FFilter};
	__property System::UnicodeString DefaultExtension = {read=FDefaultExtension, write=FDefaultExtension};
	__property System::UnicodeString Extensions = {read=FExtensions, write=FExtensions};
	__property System::UnicodeString StylerName = {read=FStylerName, write=FStylerName};
	__property System::UnicodeString BlockStart = {read=FBlockStart, write=FBlockStart};
	__property System::UnicodeString BlockEnd = {read=FBlockEnd, write=FBlockEnd};
	__property TCharStyle* HighlightStyle = {read=FHighlightStyle, write=SetHighlightStyle};
	__property System::UnicodeString LineComment = {read=FLineComment, write=FLineComment};
	__property System::UnicodeString Literal = {read=FLiteral, write=FLiteral};
	__property System::UnicodeString MultiCommentLeft = {read=FMultiCommentLeft, write=FMultiCommentLeft};
	__property System::UnicodeString MultiCommentRight = {read=FMultiCommentRight, write=FMultiCommentRight};
	__property TElementStyles* AllStyles = {read=FAllStyles, write=SetStyles};
	__property TCharStyle* CommentStyle = {read=FCommentStyle, write=SetStyle, index=1};
	__property TCharStyle* NumberStyle = {read=FNumberStyle, write=SetStyle, index=2};
	__property TCharStyle* URLStyle = {read=FURLStyle, write=SetStyle, index=3};
	__property System::Classes::TStringList* AutoCompletion = {read=FlistAuto, write=SetListAuto};
	__property THintParameter* HintParameter = {read=FHintParameter, write=FHintParameter};
	__property System::UnicodeString NumericChars = {read=FNumericChars, write=FNumericChars};
	__property System::UnicodeString HexIdentifier = {read=FHexIdentifier, write=FHexIdentifier};
	__property bool CustomDraw = {read=FCustomDraw, write=FCustomDraw, nodefault};
	__property System::UnicodeString EscapeChar = {read=FEscapeChar, write=FEscapeChar};
};


class DELPHICLASS TTMSFMXMemoAction;
class PASCALIMPLEMENTATION TTMSFMXMemoAction : public Fmx::Actnlist::TAction
{
	typedef Fmx::Actnlist::TAction inherited;
	
private:
	TTMSFMXMemo* FMemo;
	void __fastcall SetMemo(TTMSFMXMemo* Value);
	
protected:
	virtual void __fastcall Notification(System::Classes::TComponent* AComponent, System::Classes::TOperation Operation);
	
public:
	__fastcall virtual ~TTMSFMXMemoAction(void);
	virtual bool __fastcall HandlesTarget(System::TObject* Target);
	virtual void __fastcall UpdateTarget(System::TObject* Target);
	
__published:
	__property TTMSFMXMemo* Memo = {read=FMemo, write=SetMemo};
public:
	/* TAction.Create */ inline __fastcall virtual TTMSFMXMemoAction(System::Classes::TComponent* AOwner) : Fmx::Actnlist::TAction(AOwner) { }
	
};


class DELPHICLASS TTMSFMXMemoCut;
class PASCALIMPLEMENTATION TTMSFMXMemoCut : public TTMSFMXMemoAction
{
	typedef TTMSFMXMemoAction inherited;
	
public:
	virtual void __fastcall ExecuteTarget(System::TObject* Target);
public:
	/* TTMSFMXMemoAction.Destroy */ inline __fastcall virtual ~TTMSFMXMemoCut(void) { }
	
public:
	/* TAction.Create */ inline __fastcall virtual TTMSFMXMemoCut(System::Classes::TComponent* AOwner) : TTMSFMXMemoAction(AOwner) { }
	
};


class DELPHICLASS TTMSFMXMemoCopy;
class PASCALIMPLEMENTATION TTMSFMXMemoCopy : public TTMSFMXMemoAction
{
	typedef TTMSFMXMemoAction inherited;
	
public:
	virtual void __fastcall ExecuteTarget(System::TObject* Target);
public:
	/* TTMSFMXMemoAction.Destroy */ inline __fastcall virtual ~TTMSFMXMemoCopy(void) { }
	
public:
	/* TAction.Create */ inline __fastcall virtual TTMSFMXMemoCopy(System::Classes::TComponent* AOwner) : TTMSFMXMemoAction(AOwner) { }
	
};


class DELPHICLASS TTMSFMXMemoPaste;
class PASCALIMPLEMENTATION TTMSFMXMemoPaste : public TTMSFMXMemoAction
{
	typedef TTMSFMXMemoAction inherited;
	
public:
	virtual void __fastcall UpdateTarget(System::TObject* Target);
	virtual void __fastcall ExecuteTarget(System::TObject* Target);
public:
	/* TTMSFMXMemoAction.Destroy */ inline __fastcall virtual ~TTMSFMXMemoPaste(void) { }
	
public:
	/* TAction.Create */ inline __fastcall virtual TTMSFMXMemoPaste(System::Classes::TComponent* AOwner) : TTMSFMXMemoAction(AOwner) { }
	
};


class DELPHICLASS TTMSFMXMemoSelectAll;
class PASCALIMPLEMENTATION TTMSFMXMemoSelectAll : public TTMSFMXMemoAction
{
	typedef TTMSFMXMemoAction inherited;
	
public:
	virtual void __fastcall ExecuteTarget(System::TObject* Target);
	virtual void __fastcall UpdateTarget(System::TObject* Target);
public:
	/* TTMSFMXMemoAction.Destroy */ inline __fastcall virtual ~TTMSFMXMemoSelectAll(void) { }
	
public:
	/* TAction.Create */ inline __fastcall virtual TTMSFMXMemoSelectAll(System::Classes::TComponent* AOwner) : TTMSFMXMemoAction(AOwner) { }
	
};


class DELPHICLASS TTMSFMXMemoUndo;
class PASCALIMPLEMENTATION TTMSFMXMemoUndo : public TTMSFMXMemoAction
{
	typedef TTMSFMXMemoAction inherited;
	
public:
	virtual void __fastcall ExecuteTarget(System::TObject* Target);
	virtual void __fastcall UpdateTarget(System::TObject* Target);
public:
	/* TTMSFMXMemoAction.Destroy */ inline __fastcall virtual ~TTMSFMXMemoUndo(void) { }
	
public:
	/* TAction.Create */ inline __fastcall virtual TTMSFMXMemoUndo(System::Classes::TComponent* AOwner) : TTMSFMXMemoAction(AOwner) { }
	
};


class DELPHICLASS TTMSFMXMemoRedo;
class PASCALIMPLEMENTATION TTMSFMXMemoRedo : public TTMSFMXMemoAction
{
	typedef TTMSFMXMemoAction inherited;
	
public:
	virtual void __fastcall ExecuteTarget(System::TObject* Target);
	virtual void __fastcall UpdateTarget(System::TObject* Target);
public:
	/* TTMSFMXMemoAction.Destroy */ inline __fastcall virtual ~TTMSFMXMemoRedo(void) { }
	
public:
	/* TAction.Create */ inline __fastcall virtual TTMSFMXMemoRedo(System::Classes::TComponent* AOwner) : TTMSFMXMemoAction(AOwner) { }
	
};


class DELPHICLASS TTMSFMXMemoDelete;
class PASCALIMPLEMENTATION TTMSFMXMemoDelete : public TTMSFMXMemoAction
{
	typedef TTMSFMXMemoAction inherited;
	
public:
	virtual void __fastcall ExecuteTarget(System::TObject* Target);
	virtual void __fastcall UpdateTarget(System::TObject* Target);
public:
	/* TTMSFMXMemoAction.Destroy */ inline __fastcall virtual ~TTMSFMXMemoDelete(void) { }
	
public:
	/* TAction.Create */ inline __fastcall virtual TTMSFMXMemoDelete(System::Classes::TComponent* AOwner) : TTMSFMXMemoAction(AOwner) { }
	
};


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

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