lots'o' wxpython modules files

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3345 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

utils/wxPython/modules/lseditor/tdefs.h

@@ -0,0 +1,903 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        No names yet.
+// Purpose:     Contrib. demo
+// Author:      Aleksandras Gluchovas
+// Modified by:
+// Created:     03/04/1999
+// RCS-ID:      $Id$
+// Copyright:   (c) Aleskandars Gluchovas
+// Licence:   	GNU General Public License 
+/////////////////////////////////////////////////////////////////////////////
+//
+//  This program is free software; you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation; either version 2 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef __TDEFS_G__
+#define __TDEFS_G__
+
+// should be compiled with wxSTL-v.1.2 (or higher)
+
+#include "wxstldefs.h"
+
+#if defined( wxUSE_TEMPLATE_STL )
+	#include <vector>
+	#include <list>
+#else
+	#include "wxstlvec.h"
+	#include "wxstllst.h"
+#endif
+
+#include "wx/window.h"
+#include "wx/scrolbar.h"
+
+#include "sourcepainter.h"
+
+#define NPOS ((size_t)(-1))
+
+class wxTextEditorModel;
+class wxTextEditorView;
+
+/*
+ * class represents column-row position in the source text,
+ * may refere to the column past the end-of-line,
+ * but should not point past the last-line in the text
+ */
+
+class TPosition
+{
+public:
+	size_t mRow;
+	size_t mCol;
+
+	inline TPosition() : mRow(0), mCol(0) {}
+
+	inline TPosition( size_t row, size_t col )
+
+		: mRow( row ), mCol( col ) {}
+
+	inline bool operator>( const TPosition& rhs ) const
+	{ 
+		if ( mRow == rhs.mRow ) return mCol > rhs.mCol;
+		else
+			return mRow > rhs.mRow;
+	}
+
+	inline bool operator<( const TPosition& rhs ) const
+	{ 
+		if ( mRow == rhs.mRow ) return mCol < rhs.mCol;
+		else
+			return mRow < rhs.mRow;
+	}
+};
+
+class TRange
+{
+public:
+	TPosition mFrom;
+	TPosition mTill;
+
+	TRange() {}
+	TRange( const TPosition& from, const TPosition& till )
+		: mFrom( from ), mTill( till )
+	{}
+};
+
+inline bool operator==( const TPosition& lhs, const TPosition& rhs )
+{
+	return lhs.mRow == rhs.mRow && lhs.mCol == rhs.mCol;
+}
+
+// FOR NOW:: bigger ones...
+
+#define MAX_BLOCK_LEN      (1024*164)
+#define BALANCED_BLOCK_LEN (1024*152)		 
+#define FILLED_BLOCK_LEN   (1024*148)
+
+// FOR NOW::
+#define T_ASSERT( x ) if ( !(x) ) throw;
+
+// to speed up debug v. :
+
+#define is_eol_char( ch )     ( ch == (char)10 )
+#define is_DOS_eol_char( ch ) ( ch == (char)13 )
+
+// the target-platfrom eol-marking is selected when
+// new text document is created or auto-detection
+// failed to determine the text-format (e.g. no EOLs found at all)
+
+#if defined(__WINDOWS__) || defined(__WXMSW__)
+
+	  #define IS_UNIX_TEXT_BY_DEFAULT FALSE
+#else
+	  #define IS_UNIX_TEXT_BY_DEFAULT TRUE
+#endif
+
+//inline bool is_eol_char( char ch ) { return ch == 10 && ch == 13 ; }
+
+/*
+ * Class contains single fragment of the source text, which
+ * may grow or shrink in the process of editing. Blocks always
+ * start at the begining of the line and end at eol, i.e. lines
+ * are not broken among blocks
+ */
+
+class TBlock
+{
+public:
+	char mBuf[MAX_BLOCK_LEN];
+	size_t mTextLen;
+	size_t mRowCount;
+
+	TBlock() : mTextLen(0), mRowCount(0) { mBuf[0] = '\0'; }
+
+	void RecalcBlockProperties();
+
+	bool operator==( const TBlock& blk ) const { return this == &blk; }
+
+        bool operator!=( const TBlock& blk ) const { return this != &blk; }
+
+	bool operator<( const TBlock& blk ) const { return TRUE; }
+
+        bool operator>( const TBlock& blk ) const { return FALSE; }
+};
+
+/*
+ * captures info about mutable command 
+ */
+
+class TCommand
+{
+public:
+
+	TCommand() : mType(-1) {}
+	TCommand( int type ) : mType( type ) {}
+	~TCommand() {}
+
+	int       mType;
+	char*     mData;
+	size_t    mDataLen;
+
+	TRange    mRange;
+
+	// positions of cursor before and after executions of this command
+	TPosition mPrePos;
+	TPosition mPostPos;
+
+};
+
+enum TEXT_EDITOR_COMMAND
+{
+	TCMD_INSERT,
+	TCMD_DELETE
+};
+
+enum TEXT_CHANGE_TYPE
+{
+	CT_MODIFIED,
+	CT_DELETED,
+	CT_INSERTED
+};
+
+class wxTextEditorView;
+
+// STL-list is used for managing blocks, since it's alg. collects
+// removed elements into a free-list, from which they
+// can be reclaimed later, that way heap-fragmentation may be reduced
+
+#if defined( wxUSE_TEMPLATE_STL )
+	typedef list<TBlock>      TBlockListT;
+	typedef vector<TCommand*> TCommandListT;
+	typedef vector<wxTextEditorView*> TextViewListT;
+#else
+	typedef WXSTL_LIST( TBlock )  TBlockListT;
+
+	typedef TCommand* TCommandPtrT;
+	typedef WXSTL_VECTOR_SHALLOW_COPY( TCommandPtrT ) TCommandListT;
+
+	typedef wxTextEditorView* TextViewPtrT;
+	typedef WXSTL_VECTOR_SHALLOW_COPY( TextViewPtrT ) TextViewListT;
+#endif
+
+typedef TBlockListT::iterator TBlockIteratorT;
+
+
+/*
+ * class shields the higher-level operations from direct access
+ * to blocks of fragmented in-memory buffers
+ */
+
+class TTextIterator
+{
+public:
+	TBlockIteratorT   mBlockIter;
+	TBlockIteratorT   mEndOfListIter;
+	TPosition         mPos;
+
+	size_t            mActualRow;
+	size_t            mFirstRowInBlock;
+
+	char*             mpCurRowStart;
+	bool              mIsEof;
+
+public:
+	TTextIterator();
+
+	char GetChar();
+	bool IsEol();
+	bool IsEof();
+	bool IsLastLine();
+	int  GetDistFromEol();
+
+	void NextChar();
+	void PreviousChar();
+	void NextWord();
+	void PreviousWord();
+	void ToEndOfLine();
+	void ToStartOfLine();
+
+	bool IsInLastBlock();
+
+	// accesors
+
+	size_t    GetLineLen();
+	TPosition GetPosition();
+
+	char* GetClosestPos(); 
+	char* GotoClosestPos();
+
+	inline char* GetBlockStart() { return (*mBlockIter).mBuf; }
+	inline char* GetBlockEnd()   { return (*mBlockIter).mBuf + (*mBlockIter).mTextLen; }
+
+	bool DetectUnixText();
+
+	// adjust this member to add specific separators, 
+	// the default value is : ",.()[]\t\\+-*/|=<>:;\t\n~?!%"
+
+	static string mSeparators;
+
+	static bool IsSeparator( char ch );
+};
+
+class wxTextEditorModel;
+
+class TTextChangeListenerBase
+{
+public:
+	virtual void OnTextChanged( wxTextEditorModel* pModel, size_t atRow, size_t nRows, TEXT_CHANGE_TYPE ct ) = 0;
+};
+
+class TCppJavaHighlightListener : public TTextChangeListenerBase
+{
+protected:
+	wxTextEditorModel* mpModel; // is set up temporarely
+
+	enum { IN_COMMENT_STATE, OUT_OF_COMMENT_STATE };
+
+public:
+	virtual void OnTextChanged( wxTextEditorModel* pModel, size_t atRow, size_t nRows, TEXT_CHANGE_TYPE ct );
+};
+
+
+/*
+ * Base class for user-defined "bookmarks" within the source-text, bookmarks
+ * are automatically repositioned or deleted as the text is edited. Class
+ * can be subclassed to add pin-specific data (e.g. breakpoint information)
+ */
+
+class TPinBase
+{
+public:
+	int    mTypeCode;
+	size_t mRow;
+
+public:
+	TPinBase() 
+		: mTypeCode(-1), mRow(NPOS) {}
+
+	TPinBase( int typeCode, size_t row )
+		: mTypeCode( typeCode ), mRow( row ) {}
+
+	size_t GetRow()      { return mRow; }
+	int    GetTypeCode() { return mTypeCode; }
+
+	virtual ~TPinBase() {}
+};
+
+// "recommened" type-code ranges for custom pins
+
+#define HIHGLIGHTING_PINS_TC_STARRT 50
+#define OTHER_PINS_TC_START         100
+
+inline bool operator<( const TPinBase& lhs, TPinBase& rhs )
+
+	{ return lhs.mRow < rhs.mRow; }
+
+#if defined( wxUSE_TEMPLATE_STL )
+
+	typedef vector<TPinBase*> PinListT;
+	typedef vector<TTextChangeListenerBase*> ChangeListenerListT;
+#else
+	typedef TPinBase* TPinBasePtrT;
+	typedef WXSTL_VECTOR_SHALLOW_COPY( TPinBasePtrT ) PinListT;
+
+	typedef TTextChangeListenerBase* TTextChangeListenerBasePtrT;
+	typedef WXSTL_VECTOR_SHALLOW_COPY( TTextChangeListenerBasePtrT ) ChangeListenerListT;
+#endif
+
+/* OLD STUFF::
+
+struct TPinBaseCompareFunctor
+{
+	inline int operator()(const TPinBasePtrT* x, const TPinBasePtrT*& y ) const 
+	{ 
+		return x->mLine < y->mLine;
+	}
+};
+
+typedef WXSTL_MULTIMAP( TPinBasePtrT, TPinBasePtrT, TPinBaseCompareFunctor ) PinMapT;
+typedef PinMapT::iterator PinIteratorT;
+*/
+
+/* 
+ * Class manages access and manpulation of in-memory text. Can
+ * be accessed by multiple views, only one of which can be active
+ * at a time.
+ */
+
+class wxTextEditorModel
+{
+protected:
+	TBlockListT         mBlocks;
+	
+	TCommandListT       mCommands;
+	size_t              mCurCommand;
+
+	TextViewListT       mViews;
+	wxTextEditorView*   mpActiveView;
+
+	PinListT            mPins;
+	bool                mIsUnixText;
+
+	ChangeListenerListT mChangeListeners;
+
+public:
+	/*** public properties ***/
+
+	bool          mTextChanged;
+	size_t        mChangedFromRow;
+	size_t        mChangedTillRow;
+
+	bool          mWasChanged;			  // TRUE, if any content has been changed
+
+	TPosition     mCursorPos;
+
+	TPosition	  mPrevSelectionStart;
+	TPosition     mPrevSelectionEnd;
+	TPosition     mPrevCursorPos;
+
+	TPosition     mSelectionStart;
+	TPosition     mSelectionEnd;
+	size_t        mRowsPerPage;
+
+	bool          mIsReadOnly;           // default: FALSE
+	bool          mIsModified;     
+	bool          mInsertMode;			 // default: TRUE
+	bool          mAutoIndentMode;       // default: TRUE
+	bool          mSmartIndentMode;      // default: TRUE
+
+	bool          mIsSelectionEditMode;  // default: TRUE
+	size_t        mTabSize;              // default: 4
+
+	StrListT      mSearchExprList;
+	string        mLastFindExpr;
+
+	bool          mCheckPointDestroyed;
+	size_t        mCheckPointCmdNo;
+
+protected:
+
+	size_t GetLineCountInRange( char* from, char* till ); 
+
+	// two lowest-level operations
+	void DoInsertText ( const TPosition& pos, char* text, size_t len, TRange& actualRange );
+	void DoDeleteRange( const TPosition& from, const TPosition& till, TRange& actualRange );
+
+	void DoExecuteNewCommand( TCommand& cmd );
+
+	void DoReexecuteCommand( TCommand& cmd );
+	void DoUnexecuteCommand( TCommand& cmd );
+
+
+	void ExecuteCommand( TCommand* pCmd );
+
+	// to methods enabling grouping of undo-able commands
+	bool CanPrependCommand( TCommand* pCmd );
+	void PrependCommand( TCommand* pCmd );
+
+	void SetPostPos( const TPosition& pos );
+
+	void UndoImpl();
+	void RedoImpl();
+
+	void StartBatch();
+	void FinishBatch();
+
+	void CheckSelection();
+	void TrackSelection();
+
+	void NotifyView();
+	void NotifyAllViews();
+
+	void NotifyTextChanged( size_t atRow, size_t nRows, TEXT_CHANGE_TYPE ct );
+	void NotifyTextChanged( TPosition from, TPosition till, TEXT_CHANGE_TYPE ct );
+
+	void ArrangePositions( TPosition& upper, TPosition& lower );
+	void ArrangePositions( size_t& upper, size_t& lower );
+
+	void MergeChange( size_t fromRow, size_t nRows );
+
+	void PrepreForCommand();
+
+	size_t TextToScrColumn( const TPosition& pos );
+	size_t ScrToTextColumn( TPosition pos );
+
+	void DoMoveCursor( int rows, int cols );
+
+public:
+	wxTextEditorModel();
+	virtual ~wxTextEditorModel();
+
+	// utilities
+
+	char* AllocCharacters( size_t n );
+	char* AllocCharacters( size_t n, const char* srcBuf );
+	void FreeCharacters( char* buf );
+
+	void DeleteSelection();
+	TTextIterator CreateIterator( const TPosition& pos );
+
+	void DeleteRange( const TPosition& from, const TPosition& till );
+	void InsertText( const TPosition& pos, const char* text, size_t len );
+	void GetTextFromRange( const TPosition& from, const TPosition& till, char** text, size_t& textLen );
+	void LoadTextFromFile( const wxString& fname );
+	void SaveTextToFile( const wxString& fname );
+	void ResetSelection();
+	void ClearUndoBuffer();
+
+
+	void DeleteAllText();
+	void GetAllText( char** text, size_t& textLen );
+
+	void SetSelectionEditMode( bool editIsOn );
+
+	/*** user-level commands ***/
+
+	// mutable (undoable) commands
+
+	void OnInsertChar( char ch );
+	void OnDelete();
+	void OnDeleteBack();
+	void OnDeleteLine();
+
+	void OnShiftSelectionIndent( bool left );
+
+	// clipboard functions
+
+	void OnCopy();
+	void OnPaste();
+	void OnCut();
+	bool CanCopy();
+	bool CanPaste();
+
+	// undo-redo
+
+	bool CanUndo();
+	bool CanRedo();
+	void OnUndo();
+	void OnRedo();
+
+	// imutable commands
+
+	void OnMoveLeft();
+	void OnMoveRight();
+	void OnMoveUp();
+	void OnMoveDown();
+
+	void OnWordLeft();
+	void OnWordRight();
+
+	void OnMoveToPosition( const TPosition& pos );
+
+	void OnEndOfLine();
+	void OnStartOfLine();
+	void OnPageUp();
+	void OnPageDown();
+	void OnSlideUp();
+	void OnSlideDown();
+	void OnStartOfText();
+	void OnEndOfText();
+
+	void OnSelectWord();
+	void OnSelectAll();
+
+	// bookmarks
+
+	void OnToggleBookmark();
+	void OnNextBookmark();
+	void OnPreviousBookmark();
+
+	// search
+
+	bool OnFind();
+	bool OnFindNext();
+	bool OnFindPrevious();
+	void OnGotoLine( int line, int col );
+	void OnGotoLine();
+
+	// status
+
+	bool IsReadOnly();
+	bool IsModified();
+	bool IsInsertMode();
+
+	// check-pointin
+
+	void SetCheckpoint();
+	bool CheckpointModified();
+
+	// accessors
+
+	TPosition GetStartOfSelection();
+	TPosition GetEndOfSelection();
+	TPosition GetCursor();
+
+	size_t    GetTotalRowCount();
+	bool	  SelectionIsEmpty();
+	bool      IsLastLine( const TPosition& pos );
+
+	bool      IsUnixText() { return mIsUnixText; }
+
+	void GetSelection( char** text, size_t& textLen );
+
+	void SetStartOfSelection( const TPosition& pos );
+	void SetEndOfSelection( const TPosition& pos );
+	void SetCursor( const TPosition& pos );
+
+	void AddView( wxTextEditorView* pView );
+	void RemoveView( wxTextEditorView* pView );
+	void SetActiveView( wxTextEditorView* pView );
+	wxTextEditorView* GetActiveView();
+
+	void SetRowsPerPage( size_t n );
+
+	void AddPin( TPinBase* pPin );
+	PinListT& GetPins(); 
+
+	// returns NPOS, if non
+	size_t FindFirstPinInRange( size_t fromRow, size_t tillRow );
+	size_t FindNextPinFrom( size_t fromRow );
+	size_t FindPreviousPinFrom( size_t fromRow );
+
+	size_t GetPinNoAt( size_t row, int pinTypeCode );
+	TPinBase* GetPinAt( size_t row, int pinTypeCode );
+	void RemovePinAt( size_t row, int pinTypeCode );
+
+	void AddChangeListener( TTextChangeListenerBase* pListener );
+};
+
+class TCursorTimer;
+class wxTextEditorView;
+
+class TPinPainterBase : public wxObject
+{
+public:
+	int    mPinTypeCode;
+
+public:
+	TPinPainterBase( int pinTc ) : mPinTypeCode( pinTc ) {}
+	TPinPainterBase() : mPinTypeCode( -1 ) {}
+
+	inline int GetPinTypeCode() { return mPinTypeCode; }
+
+	virtual void DrawPin( TPinBase* pPin, wxTextEditorView& view, wxDC& dc, 
+						  const wxPoint& pos, const wxSize& dim ) = 0;
+};
+
+/*
+ * a couple very common ping objects/painters
+ */
+
+#define BOOKMARK_PIN_TC  (OTHER_PINS_TC_START)
+#define BRKPOINT_PIN_TC  (BOOKMARK_PIN_TC + 1)
+
+class TBookmarkPainter : public TPinPainterBase
+{
+protected:
+	wxBrush mBkBrush;
+
+public:
+	TBookmarkPainter();
+
+	virtual void DrawPin( TPinBase* pPin, wxTextEditorView& view, wxDC& dc, 
+						  const wxPoint& pos, const wxSize& dim );
+};
+
+class TBookmarkPin : public TPinBase
+{
+public:
+	TBookmarkPin( size_t row )
+		: TPinBase( BOOKMARK_PIN_TC, row )
+	{}
+
+	static int GetPinTypeCode() { return BOOKMARK_PIN_TC; }
+};
+
+class TBreakpointPainter : public TPinPainterBase
+{
+protected:
+	wxBrush mBkBrush;
+
+public:
+	TBreakpointPainter();
+
+	virtual void DrawPin( TPinBase* pPin, wxTextEditorView& view, wxDC& dc, 
+						  const wxPoint& pos, const wxSize& dim );
+};
+
+class TBreakpointPin : public TPinBase
+{
+public:
+	TBreakpointPin( size_t row )
+		: TPinBase( BRKPOINT_PIN_TC, row )
+	{}
+
+	static int GetPinTypeCode() { return BRKPOINT_PIN_TC; }
+};
+
+
+#if defined( wxUSE_TEMPLATE_STL )
+	typedef vector<TPinPainterBase*> PinPainterListT;
+#else
+	typedef TPinPainterBase* TPinPainterBasePtrT;
+	typedef WXSTL_VECTOR_SHALLOW_COPY( TPinPainterBasePtrT ) PinPainterListT;
+#endif
+
+/*
+ * Class displays graphical view of data contained in wxTextModel
+ */
+
+class wxTextEditorView : public wxScrolledWindow
+{
+protected:
+
+	wxTextEditorModel*  mpModel;
+	TPosition           mSelectionStart;
+	TPosition           mSelectionEnd;
+	TPosition           mCursorPos;
+
+	TPosition           mLastViewStart;
+	size_t              mLastRowsTotal;
+
+	size_t              mRowsPerPage;
+	size_t              mColsPerPage;
+
+	static char*        mpLineBuffer;
+	static size_t       mpLineBufferLen;
+
+	bool                mFullRefreshPending;
+	bool                mAdjustScrollPending;
+
+	wxFont              mFont;
+
+	bool                mScrollingOn; // default: TRUE
+	bool                mCursorOn;   // default: TRUE;
+
+	bool                mLTMode; // line-tracking mode
+								 // (when the whole line is coloured,
+	                             //  instead of showing blinking cursor position)
+
+	wxColour            mLTColour; // fill-colour for LT-mode
+
+	bool                mDragStarted;
+	char*               mpDraggedText;
+
+	bool                mOwnsModel;
+
+	wxString            mFragment; // reused heap-buffer 
+								   // for coloured fragments
+	SourcePainter*      mpPainter;
+	PinPainterListT     mPinPainters;
+	TTextIterator       mCashedIter;
+
+	static TCursorTimer* mpTimer;
+
+public: /*** public properties ***/
+
+	int                mLeftMargin;		// default: 20
+	int                mRightMargin;	// default: 0
+	int                mTopMargin;		// default: 0
+	int                mBottomMargin;	// default: 0
+	int                mMaxColumns;     // default: 500
+
+	TPosition          mPagePos;
+
+	// color-scheme properties
+
+	wxColour           mNormalTextCol;
+	wxColour           mIndentifierTextCol;
+	wxColour           mReservedWordTextCol;
+	wxColour           mCommentTextCol;
+
+	wxColour           mNormalBkCol;
+	wxColour           mSelectionFgCol;
+	wxColour           mSelectionBkCol;
+
+	wxBrush            mNormalBkBrush;
+	wxBrush            mSelectedBkBrush;
+
+	// accessed by timer
+
+	TPosition           mCursorScrPos;
+	wxSize              mCharDim;
+
+protected:
+
+	char* GetLineBuffer( size_t len );
+
+	virtual void PaintDecorations( size_t fromRow, size_t tillRow, wxDC& dc, TTextIterator& iter );
+	virtual void PaintRows( size_t fromRow, size_t tillRow, wxDC& dc );
+
+	void ObtainFontProperties();
+
+	bool IsActiveView();
+	void SetTextDefaults();
+	void RecalcPagingInfo();
+
+	TPinPainterBase* FindPainterForPin( TPinBase& pin );
+
+public:
+	wxTextEditorView( wxWindow* parent, wxWindowID id = -1, 
+					  wxTextEditorModel* pModel = NULL, 
+					  int wndStyle = wxSUNKEN_BORDER,
+					  bool ownsModel = TRUE );
+	~wxTextEditorView();
+
+	/*** setup methods ***/
+
+	void SetModel( wxTextEditorModel* pModel );
+
+	// sets custom syntax-higlighting implementation
+	void SetSourcePainter( SourcePainter* pPainter );
+	void AddPinPainter( TPinPainterBase* pPainter );
+
+	void SetDefaultFont( const wxFont& font );
+	wxFont& GetDefaultFont(); 
+
+	wxSize GetCharacterSize() { return mCharDim; }
+
+	size_t GetRowsPerPage() { return mRowsPerPage; }
+	void SetRowsPerPage( size_t n );
+	void SetMaxColumns( size_t n );
+
+	void SetLineTrackingMode( bool on, const wxColour& col = wxColour(255,255,0) );
+
+	void EnableCursor( bool enable );
+	void EnableScrollbars( bool enable );
+
+	void SetColours( const wxColour& normalBkCol,
+					 const wxColour& selectedBkCol,
+					 const wxColour& selectedTextCol );
+
+	void SetHeighlightingColours( const wxColour& normalTextCol,
+								  const wxColour& identifierTextCol,
+								  const wxColour& reservedWordTextCol,
+								  const wxColour& commentTextCol );
+
+	void SetMargins( int top, int left, int bottom, int right );
+
+	// notifications from editor-model:
+
+	void OnModelChanged();
+	void ScrollView( int rows, int cols );
+
+	// accessors
+
+	void Activate();
+	void Deactivate();
+
+	// event handlers
+
+#if (( wxVERSION_NUMBER < 2100 ) || (( wxVERSION_NUMBER == 2100 ) && (wxBETA_NUMBER <= 4)))
+	void OnScroll( wxScrollEvent& event );
+#else
+        void OnScroll( wxScrollWinEvent& event );
+#endif
+	void OnPaint ( wxPaintEvent& event );
+	void OnSize  ( wxSizeEvent& event );
+	void OnEraseBackground( wxEraseEvent& event );
+
+	void OnLButtonDown( wxMouseEvent& event );
+	void OnLButtonUp  ( wxMouseEvent& event );
+	void OnMotion     ( wxMouseEvent& event );
+	void OnDblClick   ( wxMouseEvent& event );
+
+	void OnSetFocus( wxFocusEvent& event );
+	void OnKillFocus( wxFocusEvent& event );
+
+	// requests editor to keep cursor blinking, even when
+	// the window has lost it's focus
+
+	void HoldCursor( bool hold );
+
+	// FOR NOW:: hard-coded key-bindings
+
+	void OnChar( wxKeyEvent& event );
+	void OnKeyDown( wxKeyEvent& event );
+
+	// utilities
+
+	virtual void SyncViewPortPosition();
+	virtual void SyncScrollbars();
+	virtual void PositionCursor();
+
+	void TextPosToScreenPos( const TPosition& txtPos, TPosition& scrPos );
+	void ScreenPosToTextPos( const TPosition& scrPos, TPosition& txtPos );
+	void ScreenPosToPixels ( const TPosition& scrPos, int& x, int& y );
+	void PixelsToScrPos    ( int x, int y, int& scrRow, int& scrCol );
+	void PixelsToTextPos   ( int x, int y, TPosition& textPos );
+
+	bool IsClipboardCmd( wxKeyEvent& key );
+
+	TPosition GetPagePos() { return mPagePos; }
+
+	DECLARE_EVENT_TABLE()
+};
+
+// TODO:: mutex class should be used to avoid race on updates
+
+class TCursorTimer : public wxTimer
+{
+protected:
+	wxTextEditorView* mpView;
+	volatile bool mIsLocked;
+	volatile bool mIsShown;
+	volatile bool mStarted;
+	wxBrush       mBrush;
+	bool          mMissOneTick;
+
+	int           mBlinkInterval;  // default: 500mills
+protected:
+
+	void DrawCursor();
+
+public:
+
+	TCursorTimer();
+
+	virtual void Notify();
+
+	void SetView( wxTextEditorView* pView );
+	wxTextEditorView* GetView();
+	void HideCursor( bool forceHide = FALSE );
+	void ShowCursor( bool forceShow = FALSE );
+
+	void SetIsShown( bool isShown );
+	void Lock();
+	void Unlock();
+};
+
+#endif // __TDEFS_G__