--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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__
projects / wxWidgets.git / blobdiff