+/////////////////////////////////////////////////////////////////////////////
+// Name: No names yet.
+// Purpose: Contrib. demo
+// Author: Aleksandras Gluchovas
+// Modified by:
+// Created: 03/04/1999
+// RCS-ID: $Id$
+// Copyright: (c) Aleksandars 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
+/////////////////////////////////////////////////////////////////////////////
+
+
+// For compilers that support precompilation, includes "wx/wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+#include "wx/wx.h"
+#endif
+
+#include "wx/file.h"
+#include "wx/textdlg.h"
+#include "wx/clipbrd.h"
+#include "wx/dataobj.h"
+
+#include <stdio.h>
+
+#include "tdefs.h"
+#include "finddlg.h"
+
+#include <memory.h>
+
+/***** Implementation for class TBlock *****/
+
+void TBlock::RecalcBlockProperties()
+{
+ char* cur = mBuf;
+ char* end = mBuf + mTextLen;
+ mRowCount = 0;
+
+ while( cur < end )
+ {
+ if ( is_eol_char( *cur ) ) ++mRowCount;
+
+ ++cur;
+ }
+}
+
+/***** Implementation for class TTextIterator *****/
+
+string TTextIterator::mSeparators = ",.()[]\t\\+-*/|=<>:;\t\n~?!%";
+
+bool TTextIterator::IsSeparator( char ch )
+{
+ size_t sz = mSeparators.size();
+
+ for( size_t i = 0; i != sz; ++i )
+
+ if ( mSeparators[i] == ch ) return TRUE;
+
+ return FALSE;
+}
+
+char* TTextIterator::GetClosestPos()
+{
+ char* end = GetBlockEnd();
+ char* cur = mpCurRowStart;
+ size_t col = 0;
+
+ while( cur < end && col < mPos.mCol && !is_eol_char(*cur) )
+ {
+ if ( !is_DOS_eol_char( *cur ) ) ++col;
+ ++cur;
+ }
+
+ if ( is_DOS_eol_char( *cur ) ) ++cur;
+
+ return cur;
+}
+
+char* TTextIterator::GotoClosestPos()
+{
+ char* end = GetBlockEnd();
+ char* cur = mpCurRowStart;
+ size_t col = 0;
+
+ while( cur < end && col < mPos.mCol && !is_eol_char(*cur) )
+ {
+ if ( !is_DOS_eol_char( *cur ) ) ++col;
+ ++cur;
+ }
+
+ mPos.mCol = col;
+
+ if ( is_DOS_eol_char( *cur ) ) ++cur;
+
+ return cur;
+}
+
+TTextIterator::TTextIterator()
+
+ : mIsEof( FALSE )
+{}
+
+bool TTextIterator::IsLastLine()
+{
+ TBlockIteratorT nextBlk = mBlockIter;
+ ++nextBlk;
+
+ if ( nextBlk != mEndOfListIter ) return FALSE;
+
+ char* cur = mpCurRowStart;
+ char* end = GetBlockEnd();
+
+ while( cur < end && !is_eol_char( *cur ) ) ++cur;
+
+ if ( cur == end ) return TRUE;
+
+ ++cur;
+
+ return ( cur == end );
+}
+
+char TTextIterator::GetChar()
+{
+ char* cur = GetClosestPos();
+
+ if ( is_DOS_eol_char( *cur ) )
+
+ return *(cur+1);
+ else
+ return *cur;
+}
+
+bool TTextIterator::IsEol()
+{
+ return is_eol_char( GetChar() ) || mIsEof;
+}
+
+bool TTextIterator::IsEof()
+{
+ return mIsEof;
+}
+
+int TTextIterator::GetDistFromEol()
+{
+ return 0; // TBD::
+}
+
+void TTextIterator::NextChar()
+{
+ char* cur = GotoClosestPos();
+
+ if ( cur + 1 >= GetBlockEnd() )
+ {
+ TBlockIteratorT nextBlk = mBlockIter;
+ ++nextBlk;
+
+ if ( nextBlk == mEndOfListIter )
+ {
+ if ( cur != GetBlockEnd() )
+ ++mPos.mCol;
+
+ mIsEof = TRUE;
+ return;
+ }
+
+ ++mPos.mRow ;
+ mPos.mCol = 0;
+
+ mBlockIter = nextBlk;
+
+ mFirstRowInBlock = mPos.mRow;
+ mActualRow = mPos.mRow;
+ mpCurRowStart = (*mBlockIter).mBuf;
+
+ mIsEof = ( (*mBlockIter).mTextLen == 0 );
+ }
+ else
+ {
+ if ( is_eol_char( *cur ) )
+ {
+ ++mPos.mRow;
+ mPos.mCol = 0;
+
+ mActualRow = mPos.mRow;
+ mpCurRowStart = cur + 1;
+ }
+ else
+ ++mPos.mCol;
+ }
+
+ mIsEof = (mpCurRowStart + mPos.mCol) == GetBlockEnd();
+}
+
+void TTextIterator::PreviousChar()
+{
+ char* cur = GotoClosestPos();
+
+ if ( cur == (*mBlockIter).mBuf )
+ {
+ TBlockIteratorT prevBlk = mBlockIter;
+ --prevBlk;
+
+ if ( prevBlk == mEndOfListIter )
+ {
+ mIsEof = TRUE;
+ return;
+ }
+
+ --mPos.mRow;
+
+ mBlockIter = prevBlk;
+
+ cur = GetBlockEnd() - 1;
+
+ char* eolPos = cur;
+ --cur; // skip EOL
+ char* start = (*mBlockIter).mBuf;
+
+ while( cur != start && !is_eol_char( *cur ) ) --cur; // goto start of line
+
+ if ( is_eol_char( *cur ) ) ++cur;
+
+ mPos.mCol = (size_t)(eolPos - cur);
+ mpCurRowStart = cur;
+
+ mFirstRowInBlock = mPos.mRow;
+ mActualRow = mPos.mRow;
+ }
+ else
+ {
+ do
+ {
+ // FIXME FIXME:: this is more then messy .... !
+
+ if ( is_eol_char( *(cur-1) ) )
+ {
+ --cur; // goto EOL
+
+ --mPos.mRow;
+
+ char* eolPos = cur;
+ --cur; // skip EOL
+ char* start = (*mBlockIter).mBuf;
+
+ while( cur != start && !is_eol_char( *cur ) ) --cur; // goto start of line
+
+ if ( is_eol_char( *cur ) ) ++cur;
+
+ mPos.mCol = (size_t)(eolPos - cur);
+ mpCurRowStart = cur;
+
+ if ( eolPos != cur && is_DOS_eol_char( *(eolPos-1) ) ) --mPos.mCol;
+
+ mActualRow = mPos.mRow;
+
+ break;
+ }
+ else
+ if ( is_DOS_eol_char( *(cur-1) ) )
+ {
+ --cur;
+
+ if ( cur != (*mBlockIter).mBuf && is_eol_char( *(cur-1) ) )
+
+ continue;
+ else
+ {
+ --mPos.mCol;
+ --cur;
+ }
+ }
+ else
+ {
+ --mPos.mCol;
+ break;
+ }
+
+ } while( 1 );
+ }
+
+ mIsEof = (mpCurRowStart + mPos.mCol) == GetBlockEnd();
+}
+
+void TTextIterator::NextWord()
+{
+ GotoClosestPos();
+
+ // skip non-white space ahead
+
+ bool wasSeparator = IsSeparator( GetChar() );
+
+ while( !IsEof() )
+ {
+ char ch = GetChar();
+
+ if ( ch == ' ' ||
+ ch == '\t' ||
+ is_eol_char(ch) ||
+ wasSeparator != IsSeparator(ch) )
+
+ break;
+
+ NextChar();
+ }
+
+ // skip all white stpace if any
+ while( !IsEof() )
+ {
+ char ch = GetChar();
+
+ if ( ch != ' ' && ch != '\t' && !is_eol_char(ch) )
+
+ break;
+
+ NextChar();
+ }
+}
+
+void TTextIterator::PreviousWord()
+{
+ GotoClosestPos();
+
+ PreviousChar();
+
+ // skip all white stpace if any
+ while( !IsEof() )
+ {
+ char ch = GetChar();
+
+ if ( ch != ' ' && ch != '\t' && !is_eol_char(ch) )
+
+ break;
+
+ PreviousChar();
+ }
+
+ bool wasSeparator = IsSeparator( GetChar() );
+
+ // skip word;
+ while( !IsEof() )
+ {
+ char ch = GetChar();
+
+ if ( ch == ' ' ||
+ ch == '\t' ||
+ is_eol_char(ch) ||
+ wasSeparator != IsSeparator(ch)
+ )
+ {
+ NextChar();
+ break;
+ }
+
+ PreviousChar();
+ }
+}
+
+void TTextIterator::ToEndOfLine()
+{
+ GotoClosestPos();
+
+ while( !IsEof() )
+ {
+ char ch = GetChar();
+
+ if ( is_eol_char( ch ) ) break;
+
+ NextChar();
+ }
+}
+
+void TTextIterator::ToStartOfLine()
+{
+ GotoClosestPos();
+
+ mPos.mCol = 0;
+ mPos.mRow = mActualRow;
+}
+
+size_t TTextIterator::GetLineLen()
+{
+ char* cur = mpCurRowStart;
+ char* end = GetBlockEnd();
+
+ size_t len = 0;
+
+ while( cur < end && !is_eol_char( *cur ) )
+ {
+ if ( !is_DOS_eol_char( *cur ) ) ++len;
+ ++cur;
+ }
+
+ return len;
+}
+
+TPosition TTextIterator::GetPosition()
+{
+ return mPos;
+}
+
+bool TTextIterator::IsInLastBlock()
+{
+ TBlockIteratorT next = mBlockIter;
+ ++next;
+
+ return next == mEndOfListIter;
+}
+
+bool TTextIterator::DetectUnixText()
+{
+ char* cur = GetBlockStart();
+ char* end = GetBlockEnd();
+
+ bool isUnixText = IS_UNIX_TEXT_BY_DEFAULT;
+
+ while( cur < end )
+ {
+ if ( is_DOS_eol_char( *cur ) ) return FALSE;
+
+ if ( is_eol_char( *cur ) ) return TRUE;
+
+ ++cur;
+ }
+
+ return isUnixText;
+}
+
+/***** Implementation for class TCppJavaHighlightListener *****/
+
+void TCppJavaHighlightListener::OnTextChanged( wxTextEditorModel* pModel,
+ size_t atRow, size_t nRows,
+ TEXT_CHANGE_TYPE ct )
+{
+ mpModel = pModel;
+
+ /*
+
+ int state = GetStateAtRow( atRow );
+
+ if ( ct == CT_INSERTED )
+ {
+ RemoveCommentTags( atRow, atRow + nRows + 1 );
+ GenerateTagsForRange( atRows, atRows + nRows + 1 );
+ }
+ else
+ if ( ct == CT_DELETED )
+ {
+ RemoveCommentTags( atRow, atRow + 1 );
+ GenerateTagsForRange( atRows, atRows + 1 );
+ }
+ */
+}
+
+/***** Implementation for class wxTextEditorModel *****/
+
+/*** protected methods ***/
+
+size_t wxTextEditorModel::GetLineCountInRange( char* from, char* till )
+{
+ size_t nLines = 0;
+
+ while( from != till )
+ {
+ if ( is_eol_char( *from ) ) ++nLines;
+
+ ++from;
+ }
+
+ return nLines;
+}
+
+void wxTextEditorModel::DoInsertText( const TPosition& pos,
+ char* text, size_t len,
+ TRange& actualRange )
+{
+ // FOR NOW:: very dummy imp.
+
+ char* end = text + len;
+
+ TTextIterator iter = CreateIterator( pos );
+
+ TBlock& blk = (*iter.mBlockIter);
+
+ char* cur = text;
+
+ char* insertPos = iter.GotoClosestPos();
+ actualRange.mFrom = iter.GetPosition();
+
+ if ( is_eol_char( *insertPos ) &&
+ insertPos != iter.GetBlockStart() &&
+ is_DOS_eol_char( *(insertPos-1) )
+ )
+ --insertPos;
+
+ size_t sizeAfter = (size_t)(iter.GetBlockEnd() - insertPos);
+
+ size_t nLines = GetLineCountInRange( text, text + len );
+
+ if ( blk.mTextLen + len < FILLED_BLOCK_LEN )
+ {
+ memmove( insertPos + len, insertPos, sizeAfter );
+
+ memcpy( insertPos, text, len );
+
+ blk.mTextLen += len;
+
+
+ blk.RecalcBlockProperties();
+
+ if ( iter.IsInLastBlock() )
+
+ ++blk.mRowCount; // last block have always the-last-row-to-spare -
+ // the "nature" of most text editors
+
+ char* endPos = insertPos + len;
+
+ bool found = FALSE;
+
+ /*
+ // OLD STUFF:: slow & buggy
+
+ while( !iter.IsEof() )
+ {
+ if ( iter.GetClosestPos() == endPos )
+ {
+ actualRange.mTill = iter.GetPosition();
+ found = TRUE;
+ break;
+ }
+
+ iter.NextChar();
+ }
+
+ if ( !found )
+ {
+ actualRange.mTill = iter.GetPosition();
+ ++actualRange.mTill.mCol;
+
+ //T_ASSERT( found ); // DBG::
+ }
+ */
+
+ actualRange.mTill = actualRange.mFrom;
+ actualRange.mTill.mRow += nLines;
+
+ if ( nLines == 0 )
+
+ actualRange.mTill.mCol = actualRange.mFrom.mCol + (len);
+ else
+ {
+ cur = end;
+
+ while( cur != insertPos && !is_eol_char( *cur ) )
+
+ --cur;
+
+ if ( is_eol_char( *cur ) ) ++cur;
+
+ actualRange.mTill.mCol = (int)(end - cur);
+ }
+
+ NotifyTextChanged( pos.mRow, nLines, CT_INSERTED );
+ }
+ else
+ {
+ // TBD:::
+
+ char buf[16];
+ sprintf( buf, "%d", FILLED_BLOCK_LEN );
+ string msg = "Sorry!!! Currently editor is limited to files less then ";
+ msg += buf;
+ msg += " bytes\n(the requested text length is " +
+ sprintf( buf, "%d", blk.mTextLen + len );
+ msg += buf;
+ msg += " bytes)\n Please, close this file without making any changes.";
+
+ wxMessageBox( msg );
+
+ GetActiveView()->SetFocus();
+
+ //T_ASSERT(0); // DBG:: for now
+ }
+}
+
+void wxTextEditorModel::DoDeleteRange( const TPosition& from, const TPosition& till,
+ TRange& actualRange
+ )
+{
+ // FOR NOW:: very dummy imp.
+
+ TTextIterator iterFrom = CreateIterator( from );
+ TTextIterator iterTill = CreateIterator( till );
+
+ if ( iterFrom.mBlockIter == iterTill.mBlockIter )
+ {
+ char* fromPos = iterFrom.GotoClosestPos();
+ char* tillPos = iterTill.GotoClosestPos();
+ char* blockStart = (*iterFrom.mBlockIter).mBuf;
+
+ if ( is_eol_char( *fromPos ) &&
+ fromPos != blockStart &&
+ is_DOS_eol_char( *(fromPos-1) )
+ )
+ --fromPos;
+
+ if ( is_eol_char( *tillPos ) &&
+ tillPos != blockStart &&
+ is_DOS_eol_char( *(tillPos-1) )
+ )
+ --tillPos;
+
+ size_t len = (size_t)( tillPos -fromPos );
+
+ size_t nLines = GetLineCountInRange( fromPos, fromPos + len );
+
+ size_t sizeAfter = (size_t)(iterFrom.GetBlockEnd() - tillPos);
+
+ memmove( fromPos, tillPos, sizeAfter );
+
+ (*iterFrom.mBlockIter).mTextLen -= len;
+
+ (*iterFrom.mBlockIter).RecalcBlockProperties();
+
+ if ( iterFrom.IsInLastBlock() )
+
+ ++(*iterFrom.mBlockIter).mRowCount; // last block have always the-last-row-to-spare -
+ // the "nature" of most text editors
+
+ actualRange.mFrom = iterFrom.GetPosition();
+ actualRange.mTill = iterTill.GetPosition();
+
+ NotifyTextChanged( from.mRow, nLines, CT_DELETED );
+ }
+ else
+ T_ASSERT(0); // DBG:: for now
+}
+
+void wxTextEditorModel::GetTextFromRange( const TPosition& from, const TPosition& till,
+ char** text, size_t& textLen
+ )
+{
+ TTextIterator iterFrom = CreateIterator( from );
+ TTextIterator iterTill = CreateIterator( till );
+
+ if ( iterFrom.mBlockIter == iterTill.mBlockIter )
+ {
+ char* blockStart = (*iterFrom.mBlockIter).mBuf;
+
+ char* fromPos = iterFrom.GetClosestPos();
+ char* tillPos = iterTill.GetClosestPos();
+
+ if ( is_eol_char( *fromPos ) &&
+ fromPos != blockStart &&
+ is_DOS_eol_char( *(fromPos-1) )
+ )
+ --fromPos;
+
+ if ( is_eol_char( *tillPos ) &&
+ tillPos != blockStart &&
+ is_DOS_eol_char( *(tillPos-1) )
+ )
+ --tillPos;
+
+ textLen = (size_t)( tillPos -fromPos );
+
+ *text = AllocCharacters( textLen );
+
+ memcpy( *text, fromPos, textLen );
+ }
+ else
+ T_ASSERT(0); // DBG:: for now
+}
+
+void wxTextEditorModel::LoadTextFromFile( const wxString& fname )
+{
+ T_ASSERT( wxFile::Exists( fname ) );
+
+ DeleteAllText();
+
+ wxFile fl( fname );
+
+ char* buf = AllocCharacters( fl.Length() );
+
+ fl.Read( buf, fl.Length() );
+
+ TRange result;
+ DoInsertText( TPosition( 0,0 ), buf, fl.Length(), result );
+
+ FreeCharacters( buf );
+
+ TTextIterator iter = CreateIterator( TPosition( 0,0 ) );
+
+ mIsUnixText = iter.DetectUnixText();
+
+ ClearUndoBuffer();
+
+ NotifyAllViews();
+}
+
+void wxTextEditorModel::SaveTextToFile( const wxString& fname )
+{
+ wxFile fl( fname, wxFile::write );
+
+ char* text = 0;
+ size_t len = 0;
+
+ GetTextFromRange( TPosition(0,0), TPosition( GetTotalRowCount()+1,0 ), &text, len );
+
+ fl.Write( text, len );
+ fl.Close();
+
+ FreeCharacters( text );
+}
+
+void wxTextEditorModel::NotifyTextChanged( size_t atRow, size_t nRows, TEXT_CHANGE_TYPE ct )
+{
+ if ( nRows > 0 )
+
+ MergeChange( atRow, mRowsPerPage );
+ else
+ MergeChange( atRow, 1 );
+
+ // reposition bookmarsk
+
+ if ( nRows > 0 )
+ {
+ if ( ct == CT_INSERTED )
+ {
+ size_t curPin = FindNextPinFrom( atRow + 1 );
+
+ while( curPin != NPOS )
+ {
+ mPins[curPin]->mRow += nRows;
+
+ ++curPin;
+
+ if ( curPin == mPins.size() ) break;
+ }
+ }
+ else
+ if ( ct == CT_DELETED )
+ {
+ size_t curPin = FindNextPinFrom( atRow + 1 );
+ size_t fromPin = curPin;
+ size_t tillRow = atRow + nRows;
+
+ while( curPin != NPOS && mPins[curPin]->mRow < tillRow )
+ {
+ ++curPin;
+
+ if ( curPin == mPins.size() ) break;
+ }
+
+ if ( fromPin != NPOS && nRows != 0 )
+ {
+ mPins.erase( &mPins[fromPin], &mPins[curPin] );
+
+ while( curPin < mPins.size() )
+ {
+ mPins[curPin]->mRow -= nRows;
+ ++curPin;
+ }
+ }
+ }
+ }
+
+
+ // send notificaitons
+
+ for( size_t i = 0; i != mChangeListeners.size(); ++i )
+
+ mChangeListeners[i]->OnTextChanged( this, atRow, nRows, ct );
+}
+
+void wxTextEditorModel::NotifyTextChanged( TPosition from, TPosition till, TEXT_CHANGE_TYPE ct )
+{
+ ArrangePositions( from, till );
+
+ NotifyTextChanged( from.mRow, till.mRow - from.mRow + 1, ct );
+}
+
+void wxTextEditorModel::DoExecuteNewCommand( TCommand& cmd )
+{
+ if ( cmd.mType == TCMD_INSERT )
+ {
+ cmd.mPrePos = mCursorPos;
+ DoInsertText( cmd.mRange.mFrom, cmd.mData, cmd.mDataLen, cmd.mRange );
+ }
+ else
+ if ( cmd.mType == TCMD_DELETE )
+ {
+ cmd.mPrePos = mCursorPos;
+ DoDeleteRange( cmd.mRange.mFrom, cmd.mRange.mTill, cmd.mRange );
+ }
+}
+
+void wxTextEditorModel::DoReexecuteCommand( TCommand& cmd )
+{
+ NotifyTextChanged( mCursorPos.mRow, 1, CT_MODIFIED ); // indicate update of current cursor position
+
+ if ( cmd.mType == TCMD_INSERT )
+ {
+ DoInsertText( cmd.mRange.mFrom, cmd.mData, cmd.mDataLen, cmd.mRange );
+ mCursorPos = cmd.mPostPos;
+ }
+ else
+ if ( cmd.mType == TCMD_DELETE )
+ {
+ DoDeleteRange( cmd.mRange.mFrom, cmd.mRange.mTill, cmd.mRange );
+ mCursorPos = cmd.mPostPos;
+ }
+
+ NotifyTextChanged( mCursorPos.mRow, 1, CT_MODIFIED ); // indicate update of current cursor position
+}
+
+void wxTextEditorModel::DoUnexecuteCommand( TCommand& cmd )
+{
+ NotifyTextChanged( mCursorPos.mRow, 1, CT_MODIFIED ); // indicate update of current cursor position
+
+ if ( cmd.mType == TCMD_INSERT )
+ {
+ DoDeleteRange( cmd.mRange.mFrom, cmd.mRange.mTill, cmd.mRange );
+ mCursorPos = cmd.mPrePos;
+ }
+ else
+ if ( cmd.mType == TCMD_DELETE )
+ {
+ DoInsertText( cmd.mRange.mFrom, cmd.mData, cmd.mDataLen, cmd.mRange );
+ mCursorPos = cmd.mPrePos;
+ }
+
+ NotifyTextChanged( mCursorPos.mRow, 1, CT_MODIFIED ); // indicate update of current cursor position
+}
+
+void wxTextEditorModel::UndoImpl()
+{
+ --mCurCommand;
+
+ DoUnexecuteCommand( *mCommands[mCurCommand] );
+}
+
+void wxTextEditorModel::RedoImpl()
+{
+ DoReexecuteCommand( *mCommands[mCurCommand] );
+
+ ++mCurCommand;
+}
+
+void wxTextEditorModel::ExecuteCommand( TCommand* pCmd )
+{
+ if ( mCurCommand < mCheckPointCmdNo )
+
+ // new command is executed before the checkpoint,
+ // and every thing is sliced - invalidate it
+
+ mCheckPointDestroyed = TRUE;
+
+ // slice undo-able commands ahead in the queue,
+ // they wont ever be reexecuted
+
+ while( mCommands.size() > mCurCommand )
+ {
+ delete mCommands.back();
+
+ mCommands.pop_back();
+ }
+
+ mCommands.push_back( pCmd );
+
+ DoExecuteNewCommand( *pCmd );
+ ++mCurCommand;
+}
+
+bool wxTextEditorModel::CanPrependCommand( TCommand* pCmd )
+{
+ if ( mCommands.size() != mCurCommand ||
+ mCommands.size() == 0 )
+
+ return FALSE;
+
+ TCommand& prevCmd = *mCommands.back();
+
+ if ( !(prevCmd.mRange.mTill == pCmd->mRange.mFrom) )
+
+ return FALSE;
+
+ char prevCh = prevCmd.mData[ prevCmd.mDataLen - 1];
+ char curCh = pCmd->mData[0];
+
+ if ( prevCh == curCh ) return TRUE;
+
+ if ( prevCh == ' ' || curCh == ' ') return FALSE;
+
+ if ( TTextIterator::IsSeparator(prevCh) !=
+ TTextIterator::IsSeparator(curCh) )
+
+ return FALSE;
+
+ return TRUE;
+}
+
+void wxTextEditorModel::PrependCommand( TCommand* pCmd )
+{
+ if ( mCheckPointCmdNo == mCurCommand )
+
+ mCheckPointDestroyed = TRUE;
+
+ TCommand& prevCmd = *mCommands.back();
+
+ DoExecuteNewCommand( *pCmd );
+
+ TCommand* pComb = new TCommand();
+
+ pComb->mType = TCMD_INSERT;
+ pComb->mDataLen = prevCmd.mDataLen + pCmd->mDataLen;
+
+ pComb->mData = AllocCharacters( pComb->mDataLen );
+ pComb->mRange.mFrom = prevCmd.mRange.mFrom;
+ pComb->mRange.mTill = pCmd->mRange.mTill;
+ pComb->mPrePos = prevCmd.mPrePos;
+ pComb->mPostPos = pCmd->mPostPos;
+
+ memcpy( pComb->mData, prevCmd.mData, prevCmd.mDataLen );
+ memcpy( pComb->mData + prevCmd.mDataLen, pCmd->mData, pCmd->mDataLen );
+
+ FreeCharacters( prevCmd.mData );
+ FreeCharacters( pCmd->mData );
+
+ delete &prevCmd;
+ delete pCmd;
+
+ mCommands[ mCommands.size() - 1 ] = pComb;
+}
+
+void wxTextEditorModel::SetPostPos( const TPosition& pos )
+{
+ mCommands[mCurCommand-1]->mPostPos = pos;
+}
+
+bool wxTextEditorModel::SelectionIsEmpty()
+{
+ return mSelectionStart == mSelectionEnd;
+}
+
+void wxTextEditorModel::StartBatch()
+{
+ // TBD::
+}
+
+void wxTextEditorModel::FinishBatch()
+{
+ // TBD::
+}
+
+void wxTextEditorModel::DeleteRange( const TPosition& from, const TPosition& till )
+{
+ TCommand* pCmd = new TCommand();
+
+ pCmd->mType = TCMD_DELETE;
+
+ pCmd->mRange.mFrom = from;
+ pCmd->mRange.mTill = till;
+ pCmd->mPrePos = mCursorPos;
+
+ GetTextFromRange( from, till, &pCmd->mData, pCmd->mDataLen );
+
+ ExecuteCommand( pCmd );
+}
+
+void wxTextEditorModel::InsertText( const TPosition& pos, const char* text, size_t len )
+{
+ TCommand* pCmd = new TCommand();
+
+ pCmd->mType = TCMD_INSERT;
+
+ pCmd->mRange.mFrom = pos;
+
+ pCmd->mData = AllocCharacters( len, text ),
+ pCmd->mDataLen = len;
+ pCmd->mPrePos = mCursorPos;
+
+ ExecuteCommand( pCmd );
+}
+
+void wxTextEditorModel::DeleteSelection()
+{
+ DeleteRange( mSelectionStart, mSelectionEnd );
+
+ ResetSelection();
+}
+
+bool wxTextEditorModel::IsLastLine( const TPosition& pos )
+{
+ return FALSE;
+}
+
+TTextIterator wxTextEditorModel::CreateIterator( const TPosition& pos )
+{
+ size_t curRow = 0;
+
+ TBlockIteratorT bIter = mBlocks.begin();
+
+ TTextIterator tIter;
+
+ while( bIter != mBlocks.end() )
+ {
+ TBlockIteratorT nextBlk = bIter;
+ ++nextBlk;
+
+ if ( nextBlk == mBlocks.end() ||
+ ( pos.mRow >= curRow &&
+ pos.mRow <= curRow + (*bIter).mRowCount )
+ )
+ {
+ tIter.mFirstRowInBlock = curRow;
+
+ char* cur = (*bIter).mBuf;
+ char* end = cur + (*bIter).mTextLen;
+
+ // slightly optimized
+
+ if ( curRow < pos.mRow )
+ {
+ while( cur < end )
+ {
+ if ( is_eol_char( *cur ) )
+ {
+ ++curRow;
+
+ if ( !(curRow < pos.mRow) )
+ {
+ ++cur;
+ break;
+ }
+ }
+
+ ++cur;
+ }
+ }
+
+ tIter.mActualRow = curRow;
+ tIter.mpCurRowStart = cur;
+ tIter.mPos = pos;
+
+ // FOR NOW:: positioning past the end of file is not supported
+ tIter.mPos.mRow = curRow;
+
+ tIter.mBlockIter = bIter;
+ tIter.mEndOfListIter = mBlocks.end();
+
+ break;
+ }
+ else
+ {
+ curRow += (*bIter).mRowCount;
+ ++bIter;
+ }
+ }
+
+ return tIter;
+}
+
+void wxTextEditorModel::ArrangePositions( TPosition& upper, TPosition& lower )
+{
+ if ( upper > lower )
+ {
+ TPosition tmp( lower );
+ lower = upper;
+ upper = tmp;
+ }
+}
+
+void wxTextEditorModel::ArrangePositions( size_t& upper, size_t& lower )
+{
+ if ( upper > lower )
+ {
+ size_t tmp = lower;
+ lower = upper;
+ upper = tmp;
+ }
+}
+
+void wxTextEditorModel::MergeChange( size_t fromRow, size_t nRows )
+{
+ if ( mTextChanged == FALSE )
+ {
+ mChangedFromRow = fromRow;
+ mChangedTillRow = fromRow + nRows;
+ mTextChanged = TRUE;
+ }
+ else
+ {
+ if ( mChangedFromRow > fromRow )
+
+ mChangedFromRow = fromRow;
+
+ if ( mChangedTillRow < fromRow + nRows )
+
+ mChangedTillRow = fromRow + nRows;
+ }
+}
+
+void wxTextEditorModel::TrackSelection()
+{
+ if ( !mIsSelectionEditMode ) return;
+
+ if ( mPrevCursorPos == mSelectionStart )
+
+ mSelectionStart = mCursorPos;
+ else
+ mSelectionEnd = mCursorPos;
+
+ ArrangePositions( mSelectionStart, mSelectionEnd );
+
+ NotifyTextChanged( mSelectionStart, mPrevSelectionStart, CT_MODIFIED );
+ NotifyTextChanged( mSelectionEnd, mPrevSelectionEnd, CT_MODIFIED );
+}
+
+void wxTextEditorModel::CheckSelection()
+{
+ ArrangePositions( mSelectionStart, mSelectionEnd );
+
+ if ( mIsSelectionEditMode && SelectionIsEmpty() )
+ {
+ mSelectionStart = mCursorPos;
+ mSelectionEnd = mCursorPos;
+ }
+
+ if ( !mIsSelectionEditMode && !SelectionIsEmpty() )
+ {
+ ResetSelection();
+ }
+
+ mPrevSelectionStart = mSelectionStart;
+ mPrevSelectionEnd = mSelectionEnd;
+ mPrevCursorPos = mCursorPos;
+}
+
+void wxTextEditorModel::ResetSelection()
+{
+ if ( SelectionIsEmpty() ) return;
+
+ MergeChange( mSelectionStart.mRow,
+ mSelectionEnd.mRow - mSelectionStart.mRow + 1 );
+
+ NotifyTextChanged( mSelectionStart, mSelectionEnd, CT_MODIFIED );
+
+ mSelectionStart = TPosition(0,0);
+ mSelectionEnd = TPosition(0,0);
+
+}
+
+void wxTextEditorModel::ClearUndoBuffer()
+{
+ for( size_t i = 0; i != mCommands.size(); ++i )
+ {
+ TCommand& cmd = *mCommands[i];
+
+ if ( cmd.mData ) delete [] cmd.mData;
+
+ delete &cmd;
+ }
+
+ mCommands.erase( mCommands.begin(), mCommands.end() );
+
+ mCurCommand = 0;
+}
+
+void wxTextEditorModel::GetAllText( char** text, size_t& textLen )
+{
+ GetTextFromRange( TPosition(0,0), TPosition( GetTotalRowCount()+1, 0 ),
+ text, textLen
+ );
+}
+
+void wxTextEditorModel::DeleteAllText()
+{
+ ResetSelection();
+
+ DeleteRange( TPosition(0,0), TPosition( GetTotalRowCount()+1, 0 ) );
+}
+
+void wxTextEditorModel::SetSelectionEditMode( bool editIsOn )
+{
+ mIsSelectionEditMode = editIsOn;
+}
+
+size_t wxTextEditorModel::GetTotalRowCount()
+{
+ size_t nRows = 0;
+
+ for( TBlockIteratorT i = mBlocks.begin(); i != mBlocks.end(); ++i )
+
+ nRows += (*i).mRowCount;
+
+ return nRows;
+}
+
+void wxTextEditorModel::GetSelection( char** text, size_t& textLen )
+{
+ GetTextFromRange( GetStartOfSelection(), GetEndOfSelection(), text, textLen );
+}
+
+void wxTextEditorModel::NotifyView()
+{
+ mpActiveView->OnModelChanged();
+}
+
+void wxTextEditorModel::NotifyAllViews()
+{
+ for( size_t i = 0; i != mViews.size(); ++i )
+
+ mViews[i]->OnModelChanged();
+}
+
+void wxTextEditorModel::PrepreForCommand()
+{
+ mTextChanged = 0;
+ mChangedFromRow = 0;
+ mChangedTillRow = 0;
+}
+
+size_t wxTextEditorModel::TextToScrColumn( const TPosition& pos )
+{
+ TPosition spos;
+
+ mpActiveView->TextPosToScreenPos( pos, spos );
+
+ return spos.mCol + mpActiveView->GetPagePos().mCol;
+}
+
+size_t wxTextEditorModel::ScrToTextColumn( TPosition pos )
+{
+ TPosition tpos;
+
+ pos.mCol -= mpActiveView->GetPagePos().mCol;
+ pos.mRow -= mpActiveView->GetPagePos().mRow;
+
+ mpActiveView->ScreenPosToTextPos( pos, tpos );
+
+ return tpos.mCol;
+}
+
+void wxTextEditorModel::DoMoveCursor( int rows, int cols )
+{
+ mCursorPos.mCol = TextToScrColumn( mCursorPos );
+
+ mCursorPos.mRow += rows;
+ mCursorPos.mCol += cols;
+
+ mCursorPos.mCol = ScrToTextColumn( mCursorPos );
+}
+
+/*** public interface ***/
+
+wxTextEditorModel::wxTextEditorModel()
+
+ :
+ mpActiveView( NULL ),
+ mTabSize( 4 ),
+ mIsSelectionEditMode( FALSE ),
+ mRowsPerPage( 0 ),
+ mTextChanged( FALSE ),
+ mCurCommand( 0 ),
+
+ mInsertMode ( TRUE ),
+ mAutoIndentMode ( TRUE ),
+ mSmartIndentMode( TRUE ),
+ mWasChanged ( FALSE ),
+ mIsReadOnly ( FALSE ),
+ mIsUnixText ( IS_UNIX_TEXT_BY_DEFAULT )
+{
+ // at least one block should be present
+ // (otherwise text-iterators wont work)
+
+ mBlocks.push_back( TBlock() );
+}
+
+wxTextEditorModel::~wxTextEditorModel()
+{
+ ClearUndoBuffer();
+}
+
+char* wxTextEditorModel::AllocCharacters( size_t n )
+{
+ return new char[n];
+}
+
+char* wxTextEditorModel::AllocCharacters( size_t n, const char* srcBuf )
+{
+ char* destBuf = AllocCharacters( n );
+
+ memcpy( destBuf, srcBuf, n );
+
+ return destBuf;
+}
+
+void wxTextEditorModel::FreeCharacters( char* buf )
+{
+ delete [] buf;
+}
+
+void wxTextEditorModel::OnInsertChar( char ch )
+{
+ if ( ch == 27 ) return; // hack
+
+ if ( is_DOS_eol_char( ch ) ) ch = '\n';
+
+ PrepreForCommand();
+ StartBatch();
+
+ TCommand* pCmd = new TCommand();
+
+ pCmd->mType = TCMD_INSERT;
+
+ if ( ch == '\n' && !mIsUnixText )
+ {
+ // DOS text with CR-LF pair
+ pCmd->mData = AllocCharacters( 2 );
+ pCmd->mDataLen = 2;
+ pCmd->mData[0] = (char)13;
+ pCmd->mData[1] = (char)10;
+ }
+ else
+ {
+ pCmd->mData = AllocCharacters( 1 );
+ pCmd->mDataLen = 1;
+ pCmd->mData[0] = ch;
+ }
+
+
+ if ( !SelectionIsEmpty() )
+ {
+ mCursorPos = mSelectionStart;
+ DeleteSelection();
+ }
+
+ pCmd->mRange.mFrom = mCursorPos;
+
+ if ( mInsertMode == FALSE )
+ {
+ TPosition nextPos( mCursorPos.mRow, mCursorPos.mCol + 1 );
+ DeleteRange( mCursorPos, nextPos );
+
+ SetPostPos( mCursorPos );
+ }
+
+ TTextIterator iter = CreateIterator( mCursorPos );
+
+ size_t lineLen = iter.GetLineLen();
+
+ bool indentAdded = FALSE;
+
+ if ( mCursorPos.mCol > lineLen )
+ {
+
+ wxString s( ' ', mCursorPos.mCol - lineLen );
+ InsertText( TPosition( mCursorPos.mRow, lineLen ), s.c_str(), s.length() );
+
+ SetPostPos( mCursorPos );
+
+ indentAdded = TRUE;
+ }
+
+ if ( CanPrependCommand( pCmd ) || indentAdded )
+
+ PrependCommand( pCmd );
+ else
+ ExecuteCommand( pCmd );
+
+ ++mCursorPos.mCol;
+
+ if ( is_eol_char( ch ) )
+ {
+ mCursorPos.mCol = 0;
+ ++mCursorPos.mRow;
+
+ SetPostPos( mCursorPos );
+
+ if ( mAutoIndentMode )
+ {
+ iter.ToStartOfLine();
+ wxString indent;
+
+ while( !iter.IsEol() )
+ {
+ char ch = iter.GetChar();
+
+ if ( ch == '\t' || ch == ' ' )
+
+ indent += ch;
+ else
+ break;
+
+ iter.NextChar();
+ }
+
+ if ( indent.length() )
+ {
+ // auto-indent is always prepended to the command which
+ // caused it
+
+ mCursorPos = TPosition( mCursorPos.mRow, 0 );
+
+
+ TCommand* pICmd = new TCommand();
+ pICmd->mType = TCMD_INSERT;
+ pICmd->mData = AllocCharacters( indent.length() );
+ pICmd->mDataLen = indent.length();
+ memcpy( pICmd->mData, indent, indent.length() );
+
+ pICmd->mRange.mFrom = TPosition( mCursorPos.mRow, 0 );
+
+ PrependCommand( pICmd );
+
+ SetPostPos( mCursorPos );
+
+ mCursorPos.mCol = indent.length();
+ }
+ }
+ }
+ else
+ SetPostPos( mCursorPos );
+
+ FinishBatch();
+
+ NotifyAllViews();
+}
+
+void wxTextEditorModel::OnDelete()
+{
+ PrepreForCommand();
+ StartBatch();
+
+ if ( !SelectionIsEmpty() )
+ {
+ TPosition startPos = mSelectionStart;
+ DeleteSelection();
+ mCursorPos = startPos;
+ }
+ else
+ {
+ TTextIterator iter = CreateIterator( mCursorPos );
+
+ if ( iter.GetLineLen() == mCursorPos.mCol && !iter.IsLastLine() )
+ {
+ TPosition nextPos( mCursorPos.mRow+1, 0 );
+ DeleteRange( mCursorPos, nextPos );
+ NotifyTextChanged( mCursorPos.mRow, 2, CT_DELETED );
+ }
+ else
+ {
+ TPosition nextPos( mCursorPos.mRow, mCursorPos.mCol + 1 );
+ DeleteRange( mCursorPos, nextPos );
+ }
+ }
+
+ SetPostPos( mCursorPos );
+
+ FinishBatch();
+
+ NotifyAllViews();
+}
+
+void wxTextEditorModel::OnDeleteBack()
+{
+ PrepreForCommand();
+ StartBatch();
+
+ if ( !SelectionIsEmpty() )
+ {
+ mCursorPos = mSelectionStart;
+ DeleteSelection();
+ }
+ else
+ if ( !(mCursorPos == TPosition(0,0)) )
+ {
+ TPosition prevPos;
+
+ if ( mCursorPos.mCol == 0 )
+ {
+ TTextIterator iter = CreateIterator( mCursorPos );
+ iter.PreviousChar();
+
+ prevPos = iter.GetPosition();
+ }
+ else
+ prevPos = TPosition( mCursorPos.mRow, mCursorPos.mCol - 1 );
+
+ DeleteRange( prevPos, mCursorPos );
+
+ mCursorPos = prevPos;
+ }
+
+ SetPostPos( mCursorPos );
+
+ FinishBatch();
+
+ NotifyAllViews();
+
+}
+
+void wxTextEditorModel::OnDeleteLine()
+{
+ PrepreForCommand();
+ StartBatch();
+
+ DeleteSelection();
+
+ TTextIterator iter = CreateIterator( mCursorPos );
+
+ iter.ToStartOfLine();
+
+ TPosition from = iter.GetPosition();
+
+ iter.ToEndOfLine();
+
+ if ( iter.IsLastLine() == FALSE )
+
+ iter.NextChar(); // delete eol-char also, if it's not the last line
+
+ TPosition till = iter.GetPosition();
+
+ DeleteRange( from, till );
+ SetPostPos( mCursorPos );
+
+ FinishBatch();
+
+ NotifyAllViews();
+}
+
+void wxTextEditorModel::OnShiftSelectionIndent( bool left )
+{
+ if ( SelectionIsEmpty() ) return;
+
+ PrepreForCommand();
+ StartBatch();
+
+ for( size_t row = mSelectionStart.mRow; row != mSelectionEnd.mRow; ++row )
+ {
+ TTextIterator iter = CreateIterator( TPosition( row, 0 ) );
+
+ if ( left )
+ {
+ int n = 0, pos = 0;
+
+ while( !iter.IsEol() && !iter.IsEof() )
+ {
+ char ch = iter.GetChar();
+
+ if ( pos == mTabSize ) break;
+
+ if ( ch != ' ' && ch != '\t' ) break;
+
+ ++n;
+
+ if ( ch == '\t' ) break;
+
+ ++pos;
+
+ iter.NextChar();
+ }
+
+ if ( n ) DeleteRange( TPosition( row,0 ), TPosition( row, n ) );
+ }
+ else
+ {
+ char txt = '\t';
+
+ InsertText( TPosition( row, 0 ), &txt, sizeof(char) );
+ }
+ }
+
+ FinishBatch();
+ NotifyAllViews();
+}
+
+void wxTextEditorModel::OnPaste()
+{
+ // FIXME:: "wxLogQueryInterface(..)" linking problems with MSDev4.0
+
+#ifdef __HACK_MY_MSDEV40__
+
+ bool alreadyOpen=wxClipboardOpen();
+ if (!alreadyOpen)
+ {
+ wxOpenClipboard();
+ }
+
+ char* data = (char*)::wxGetClipboardData( wxDF_TEXT );
+
+ wxCloseClipboard();
+
+ if ( data == NULL ) return;
+
+ PrepreForCommand();
+ StartBatch();
+
+ if ( !SelectionIsEmpty() )
+ {
+ mCursorPos = GetStartOfSelection();
+ DeleteSelection();
+ }
+
+ InsertText( mCursorPos, data, strlen( data ) );
+
+ delete [] data;
+#else
+
+ if ( !wxTheClipboard->Open() ) return;
+
+ wxTextDataObject data;
+ if ( !wxTheClipboard->IsSupported(wxDF_TEXT) )
+ {
+ wxTheClipboard->Close();
+ return;
+ }
+
+ wxTheClipboard->GetData(&data);
+
+ string txt = data.GetText();
+
+ wxTheClipboard->Close();
+
+ PrepreForCommand();
+ StartBatch();
+
+ DeleteSelection();
+
+ InsertText( mCursorPos, txt.c_str(), txt.length() );
+#endif
+
+
+ mCursorPos = mCommands.back()->mRange.mTill;
+ SetPostPos( mCursorPos );
+
+ FinishBatch();
+ NotifyAllViews();
+}
+
+void wxTextEditorModel::OnCut()
+{
+ OnCopy();
+
+ PrepreForCommand();
+ StartBatch();
+
+ DeleteSelection();
+ SetPostPos( mCursorPos );
+
+
+ FinishBatch();
+ NotifyAllViews();
+}
+
+void wxTextEditorModel::OnCopy()
+{
+ if ( !SelectionIsEmpty() )
+ {
+ size_t len = 0;
+ char* text = NULL;
+
+#ifndef __HACK_MY_MSDEV40__
+
+ if ( !wxTheClipboard->Open() ) return;
+
+ GetTextFromRange( mSelectionStart, mSelectionEnd, &text, len );
+
+ wxString s( text, len );
+
+ wxTheClipboard->AddData( new wxTextDataObject(s) );
+ wxTheClipboard->Close();
+
+ FreeCharacters( text );
+#else
+ bool alreadyOpen=wxClipboardOpen();
+ if (!alreadyOpen)
+ {
+ wxOpenClipboard();
+ if (!wxEmptyClipboard())
+ {
+ wxCloseClipboard();
+ return;
+ }
+ }
+
+ GetTextFromRange( mSelectionStart, mSelectionEnd, &text, len );
+
+ wxString s( text, len );
+
+ bool success = ::wxEmptyClipboard();
+
+ success = wxSetClipboardData( wxDF_TEXT, (wxObject*)s.c_str(), 0,0 );
+
+ FreeCharacters( text );
+
+ wxCloseClipboard();
+
+#endif
+ }
+}
+
+bool wxTextEditorModel::CanCopy()
+{
+ return !SelectionIsEmpty();
+}
+
+bool wxTextEditorModel::CanPaste()
+{
+ if ( mIsReadOnly ) return FALSE;
+
+#ifndef __HACK_MY_MSDEV40__
+
+ if ( !wxTheClipboard->Open() ) return FALSE;
+
+ if ( !wxTheClipboard->IsSupported(wxDF_TEXT) )
+ return FALSE;
+
+ wxTheClipboard->Close();
+
+ return TRUE;
+
+#else
+
+ bool success = ::wxClipboardOpen();
+
+ bool alreadyOpen=wxClipboardOpen();
+ if (!alreadyOpen)
+ {
+ wxOpenClipboard();
+ }
+
+ char* data = (char*)::wxGetClipboardData( wxDF_TEXT );
+
+ wxCloseClipboard();
+
+ if ( data != NULL && strlen(data) != 0 )
+ {
+ delete [] data;
+ return TRUE;
+ }
+ else
+ {
+ delete [] data;
+ return FALSE;
+ }
+
+#endif
+
+}
+
+bool wxTextEditorModel::CanUndo()
+{
+ return !( mCommands.size() == 0 ||
+ mCurCommand == 0 );
+}
+
+bool wxTextEditorModel::CanRedo()
+{
+ return mCurCommand != mCommands.size();
+}
+
+void wxTextEditorModel::OnUndo()
+{
+ if ( !CanUndo() ) return;
+
+ PrepreForCommand();
+ StartBatch();
+
+ ResetSelection();
+
+ UndoImpl();
+
+ FinishBatch();
+ NotifyAllViews();
+}
+
+void wxTextEditorModel::OnRedo()
+{
+ if ( !CanRedo() ) return;
+
+ PrepreForCommand();
+ StartBatch();
+
+ ResetSelection();
+
+ RedoImpl();
+
+ FinishBatch();
+ NotifyAllViews();
+}
+
+void wxTextEditorModel::OnMoveLeft()
+{
+ PrepreForCommand();
+ CheckSelection();
+
+ if ( mCursorPos.mCol == 0 )
+ {
+ if ( mCursorPos.mRow != 0 )
+ {
+ --mCursorPos.mRow;
+
+ TTextIterator iter = CreateIterator( mCursorPos );
+
+ iter.ToEndOfLine();
+
+ mCursorPos.mCol = iter.GetPosition().mCol;
+ }
+ }
+ else
+ --mCursorPos.mCol;
+
+ TrackSelection();
+ NotifyView();
+}
+
+void wxTextEditorModel::OnMoveRight()
+{
+ PrepreForCommand();
+ CheckSelection();
+
+ ++mCursorPos.mCol;
+
+ TrackSelection();
+ NotifyView();
+}
+
+void wxTextEditorModel::OnMoveUp()
+{
+ PrepreForCommand();
+ CheckSelection();
+
+ if ( mCursorPos.mRow != 0 )
+
+ DoMoveCursor( -1,0 );
+
+ TrackSelection();
+ NotifyView();
+}
+
+void wxTextEditorModel::OnMoveDown()
+{
+ PrepreForCommand();
+ CheckSelection();
+
+ if ( mCursorPos.mRow + 1 < GetTotalRowCount() )
+
+ DoMoveCursor( 1,0 );
+
+ TrackSelection();
+ NotifyView();
+}
+
+void wxTextEditorModel::OnWordRight()
+{
+ PrepreForCommand();
+ CheckSelection();
+
+ TTextIterator iter = CreateIterator( mCursorPos );
+
+ iter.NextWord();
+
+ mCursorPos = iter.GetPosition();
+
+ TrackSelection();
+ NotifyView();
+}
+
+void wxTextEditorModel::OnWordLeft()
+{
+ PrepreForCommand();
+ CheckSelection();
+
+ TTextIterator iter = CreateIterator( mCursorPos );
+
+ iter.PreviousWord();
+
+ mCursorPos = iter.GetPosition();
+
+ TrackSelection();
+ NotifyView();
+}
+
+void wxTextEditorModel::OnMoveToPosition( const TPosition& pos )
+{
+ PrepreForCommand();
+ CheckSelection();
+
+ mCursorPos = pos;
+
+ TrackSelection();
+ NotifyView();
+}
+
+void wxTextEditorModel::OnEndOfLine()
+{
+ PrepreForCommand();
+ CheckSelection();
+
+ TTextIterator iter = CreateIterator( mCursorPos );
+ iter.ToEndOfLine();
+
+ mCursorPos = iter.GetPosition();
+
+ TrackSelection();
+ NotifyView();
+}
+
+void wxTextEditorModel::OnStartOfLine()
+{
+ PrepreForCommand();
+ CheckSelection();
+
+ int prevCol = mCursorPos.mCol;
+
+ TTextIterator iter = CreateIterator( mCursorPos );
+ iter.ToStartOfLine();
+
+ // bypass leading white-space at the begining of the line
+
+ while( !iter.IsEol() )
+ {
+ char ch = iter.GetChar();
+
+ if ( ch != ' ' && ch != '\t' ) break;
+
+ ++mCursorPos.mCol;
+
+ iter.NextChar();
+ }
+
+ mCursorPos = iter.GetPosition();
+
+ if ( mCursorPos.mCol == prevCol )
+
+ mCursorPos.mCol = 0;
+
+ TrackSelection();
+ NotifyView();
+}
+
+void wxTextEditorModel::OnPageUp()
+{
+ PrepreForCommand();
+ CheckSelection();
+
+ if ( mCursorPos.mRow < mRowsPerPage )
+
+ mCursorPos.mRow = 0;
+ else
+ DoMoveCursor( -mRowsPerPage,0 );
+
+ mpActiveView->ScrollView( -(int)mRowsPerPage, 0 );
+
+ TrackSelection();
+ NotifyView();
+}
+
+void wxTextEditorModel::OnPageDown()
+{
+ PrepreForCommand();
+ CheckSelection();
+
+ if ( mCursorPos.mRow + mRowsPerPage >= GetTotalRowCount() )
+ {
+ if ( GetTotalRowCount() != 0 )
+
+ mCursorPos.mRow = GetTotalRowCount() - 1;
+ else
+ mCursorPos.mRow = 0;
+ }
+ else
+ DoMoveCursor( mRowsPerPage,0 );
+
+ mpActiveView->ScrollView( mRowsPerPage, 0 );
+
+ TrackSelection();
+ NotifyView();
+}
+
+void wxTextEditorModel::OnSlideUp()
+{
+ PrepreForCommand();
+
+ if ( mpActiveView->GetPagePos().mRow + mRowsPerPage - 1 == mCursorPos.mRow )
+ {
+ if ( mCursorPos.mRow == 0 )
+
+ return;
+
+ DoMoveCursor( -1,0 );
+ }
+
+ mpActiveView->ScrollView( -1, 0 );
+
+ NotifyView();
+}
+
+void wxTextEditorModel::OnSlideDown()
+{
+ PrepreForCommand();
+
+ if ( mCursorPos.mRow == mpActiveView->GetPagePos().mRow )
+ {
+ if ( mCursorPos.mRow + 1 >= GetTotalRowCount() )
+
+ return;
+
+ DoMoveCursor( 1,0 );
+ }
+
+ mpActiveView->ScrollView( 1, 0 );
+
+ NotifyView();
+}
+
+void wxTextEditorModel::OnStartOfText()
+{
+ PrepreForCommand();
+ CheckSelection();
+
+ mCursorPos.mRow = mCursorPos.mCol = 0;
+
+ TrackSelection();
+ NotifyView();
+}
+
+void wxTextEditorModel::OnEndOfText()
+{
+ PrepreForCommand();
+ CheckSelection();
+
+ mCursorPos.mRow = GetTotalRowCount() - 1;
+
+ TTextIterator iter = CreateIterator( mCursorPos );
+
+ iter.ToEndOfLine();
+
+ mCursorPos = iter.GetPosition();
+
+ TrackSelection();
+ NotifyView();
+}
+
+void wxTextEditorModel::OnSelectWord()
+{
+ PrepreForCommand();
+
+ TTextIterator iter1 = CreateIterator( mCursorPos );
+ iter1.GotoClosestPos();
+
+ if ( mCursorPos == iter1.GetPosition() )
+ {
+ TTextIterator iter2 = iter1;
+
+ // find the left-edge of the word
+
+ bool wasSeparator = TTextIterator::IsSeparator( iter1.GetChar() );
+
+ while( !iter1.IsEol() )
+ {
+ char ch = iter1.GetChar();
+
+ if ( ch == '\t' ||
+ ch == ' ' ||
+ wasSeparator != TTextIterator::IsSeparator( iter1.GetChar() )
+ )
+ {
+ iter1.NextChar();
+ break;
+ }
+
+ iter1.PreviousChar();
+ }
+
+ // find the left-edge of the word
+
+ while( !iter2.IsEol() )
+ {
+ char ch = iter2.GetChar();
+
+ if ( ch == '\t' ||
+ ch == ' ' ||
+ wasSeparator != TTextIterator::IsSeparator( iter2.GetChar() )
+ )
+ break;
+
+ iter2.NextChar();
+ }
+
+ if ( !(iter1.GetPosition() == iter2.GetPosition()) )
+ {
+ mSelectionStart = iter1.GetPosition();
+ mSelectionEnd = iter2.GetPosition();
+ mCursorPos = iter2.GetPosition();
+
+ NotifyTextChanged( mSelectionStart.mRow, 1, CT_MODIFIED );
+ }
+ }
+
+ NotifyView();
+}
+
+void wxTextEditorModel::OnSelectAll()
+{
+ PrepreForCommand();
+
+ ResetSelection();
+
+ mSelectionStart = TPosition(0,0);
+ mSelectionEnd = TPosition( GetTotalRowCount(), 1024 ); // FOR NOW:: hack
+
+ mCursorPos = mSelectionStart;
+
+ NotifyTextChanged( mSelectionStart.mRow, mSelectionEnd.mRow, CT_MODIFIED );
+
+ NotifyView();
+}
+
+void wxTextEditorModel::OnToggleBookmark()
+{
+ size_t curRow = GetCursor().mRow;
+
+ if ( GetPinAt( curRow, TBookmarkPin::GetPinTypeCode() ) != NULL )
+
+ RemovePinAt( curRow, TBookmarkPin::GetPinTypeCode() );
+ else
+ AddPin( new TBookmarkPin( curRow ) );
+
+ MergeChange( curRow, 1 );
+
+ NotifyAllViews();
+}
+
+void wxTextEditorModel::OnNextBookmark()
+{
+ size_t pinNo = FindNextPinFrom( mCursorPos.mRow + 1 );
+
+ while( pinNo != NPOS )
+ {
+ TPinBase& pin = *mPins[pinNo];
+
+ if ( pin.mTypeCode == BOOKMARK_PIN_TC )
+ {
+ OnGotoLine( pin.mRow, 0 );
+ break;
+ }
+
+ if ( pinNo == mPins.size() ) break;
+
+ ++pinNo;
+ }
+}
+
+void wxTextEditorModel::OnPreviousBookmark()
+{
+ if ( mCursorPos.mRow == 0 ) return;
+
+ size_t pinNo = FindPreviousPinFrom( mCursorPos.mRow - 1 );
+
+ while( pinNo != NPOS )
+ {
+ TPinBase& pin = *mPins[pinNo];
+
+ if ( pin.mTypeCode == BOOKMARK_PIN_TC )
+ {
+ OnGotoLine( pin.mRow, 0 );
+ break;
+ }
+
+ if ( pinNo == 0 ) break;
+
+ --pinNo;
+ }
+}
+
+bool wxTextEditorModel::OnFind()
+{
+ if ( !SelectionIsEmpty() )
+ {
+ if ( GetStartOfSelection().mRow == GetEndOfSelection().mRow )
+ {
+ char* buf = NULL; size_t len = 0;
+
+ GetSelection( &buf, len );
+
+ mLastFindExpr = string( buf, 0, len );
+
+ delete [] buf;
+ }
+ }
+
+ wxFindTextDialog dlg( GetActiveView(), mLastFindExpr );
+ //dlg.SetExpr( mLastFindExpr );
+
+ if( dlg.ShowModal() == wxID_OK )
+ {
+ mLastFindExpr = dlg.GetExpr();
+
+ GetActiveView()->SetFocus();
+
+ return OnFindNext();
+ }
+
+ GetActiveView()->SetFocus();
+
+ return FALSE;
+}
+
+bool wxTextEditorModel::OnFindNext()
+{
+ PrepreForCommand();
+
+ string& val = mLastFindExpr;
+ size_t len = val.length();
+
+ if ( len == 0 )
+ {
+ NotifyView();
+ wxMessageBox( "Secarch string not found!" );
+
+ GetActiveView()->SetFocus();
+
+ return FALSE;
+ }
+
+ char ch1 = val[0];
+
+ TTextIterator iter = CreateIterator( mCursorPos );
+
+ while( !iter.IsEof() )
+ {
+ char ch = iter.GetChar();
+
+ if ( ch == ch1 )
+ {
+ size_t startCol = iter.mPos.mCol;
+ iter.NextChar();
+ ch = iter.GetChar();
+
+ size_t i = 1;
+ while( i < len && !iter.IsEof() && ch == val[i] )
+ {
+ ++i;
+ iter.NextChar();
+ ch = iter.GetChar();
+ }
+
+ if ( i == len )
+ {
+ if ( !SelectionIsEmpty() )
+
+ ResetSelection();
+
+ SetStartOfSelection( TPosition( iter.mPos.mRow, startCol ) );
+ SetEndOfSelection( iter.mPos );
+
+ MergeChange( iter.mPos.mRow, 1 );
+
+ mCursorPos = iter.mPos;
+
+ OnGotoLine( iter.mPos.mRow, iter.mPos.mCol );
+ return TRUE;
+ }
+ }
+ else
+ iter.NextChar();
+ }
+
+ NotifyView();
+ MergeChange( mCursorPos.mRow, 2 );
+ wxMessageBox( "Secarch string not found!" );
+
+ GetActiveView()->SetFocus();
+
+ return FALSE;
+}
+
+bool wxTextEditorModel::OnFindPrevious()
+{
+ // TBD::
+ return FALSE;
+}
+
+void wxTextEditorModel::OnGotoLine( int line, int col )
+{
+ if ( mpActiveView == NULL ) return;
+
+ TPosition pagePos = mpActiveView->GetPagePos();
+
+ if ( line >= pagePos.mRow &&
+ line < pagePos.mRow + mRowsPerPage )
+ {
+ mCursorPos.mRow = (size_t)line;
+ mCursorPos.mCol = (size_t)col;
+
+ if ( col == - 1)
+ {
+ mCursorPos.mCol = 0;
+ OnStartOfLine();
+ }
+ else
+ NotifyView();
+
+ return;
+ }
+
+ size_t third = mRowsPerPage / 3;
+ size_t newTop = 0;
+
+ if ( line < third )
+
+ newTop = 0;
+ else
+ newTop = line - third;
+
+
+ mpActiveView->ScrollView( (int)newTop - (int)pagePos.mRow, -(int)pagePos.mCol );
+
+ mCursorPos.mRow = line;
+ mCursorPos.mCol = col;
+
+ if ( col == - 1)
+ {
+ mCursorPos.mCol = 0;
+ OnStartOfLine();
+ }
+ else
+ NotifyView();
+}
+
+void wxTextEditorModel::OnGotoLine()
+{
+ wxTextEntryDialog* dlg =
+ new wxTextEntryDialog( mpActiveView, "Line number:", "Goto line", "" );
+
+ int nTries = 3;
+
+ while( dlg->ShowModal() == wxID_OK && nTries )
+ {
+ ResetSelection();
+
+ int i = -1;
+ sscanf( dlg->GetValue(), "%d", &i );
+
+ if ( i == -1 )
+ {
+ wxMessageBox( "Please enter a number" );
+ continue;
+ }
+
+
+ if ( i == 0 ) ++i;
+
+ OnGotoLine( (size_t)(i-1), 0 );
+ break;
+
+ --nTries;
+ }
+
+ GetActiveView()->SetFocus();
+}
+
+
+bool wxTextEditorModel::IsReadOnly()
+{
+ return mIsReadOnly;
+}
+
+bool wxTextEditorModel::IsModified()
+{
+ return mCurCommand != 0;
+}
+
+bool wxTextEditorModel::IsInsertMode()
+{
+ return mInsertMode;
+}
+
+void wxTextEditorModel::SetCheckpoint()
+{
+ mCheckPointDestroyed = FALSE;
+ mCheckPointCmdNo = mCurCommand;
+}
+
+bool wxTextEditorModel::CheckpointModified()
+{
+ if ( mCheckPointDestroyed ) return TRUE;
+
+ return mCheckPointCmdNo != mCurCommand;
+}
+
+TPosition wxTextEditorModel::GetStartOfSelection()
+{
+ ArrangePositions( mSelectionStart, mSelectionEnd );
+
+ return mSelectionStart;
+}
+
+TPosition wxTextEditorModel::GetEndOfSelection()
+{
+ ArrangePositions( mSelectionStart, mSelectionEnd );
+
+ return mSelectionEnd;
+}
+
+TPosition wxTextEditorModel::GetCursor()
+{
+ return mCursorPos;
+}
+
+void wxTextEditorModel::SetStartOfSelection( const TPosition& pos )
+{
+ mSelectionStart = pos;
+}
+
+void wxTextEditorModel::SetEndOfSelection( const TPosition& pos )
+{
+ mSelectionEnd = pos;
+}
+
+void wxTextEditorModel::SetCursor( const TPosition& pos )
+{
+ mCursorPos = pos;
+}
+
+void wxTextEditorModel::AddView( wxTextEditorView* pView )
+{
+ mViews.push_back( pView );
+ pView->SetModel( this );
+}
+
+void wxTextEditorModel::RemoveView( wxTextEditorView* pView )
+{
+ for( size_t i = 0; i != mViews.size(); ++i )
+
+ if ( mViews[i] == pView )
+ {
+ mViews.erase( & mViews[i] );
+ return;
+ }
+}
+
+void wxTextEditorModel::SetActiveView( wxTextEditorView* pView )
+{
+ mpActiveView = pView;
+}
+
+wxTextEditorView* wxTextEditorModel::GetActiveView()
+{
+ return mpActiveView;
+}
+
+void wxTextEditorModel::SetRowsPerPage( size_t n )
+{
+ mRowsPerPage = n;
+}
+
+void wxTextEditorModel::AddPin( TPinBase* pPin )
+{
+ // FIXME:: binary search should be used
+
+ size_t beforePin = FindNextPinFrom( pPin->mRow );
+
+ if ( beforePin != NPOS )
+ {
+ // pins in the same row are ordered in the
+ // descending order of their type-codes
+
+ while( beforePin < mPins.size() &&
+ mPins[beforePin]->mRow == pPin->mRow &&
+ mPins[beforePin]->mTypeCode < pPin->mTypeCode )
+
+ ++beforePin;
+
+ if ( beforePin < mPins.size() )
+
+ mPins.insert( &mPins[beforePin], pPin );
+ else
+ mPins.push_back( pPin );
+ }
+ else
+ mPins.push_back( pPin );
+}
+
+PinListT& wxTextEditorModel::GetPins()
+{
+ return mPins;
+}
+
+size_t wxTextEditorModel::FindFirstPinInRange( size_t fromRow, size_t tillRow )
+{
+ // FIXME:: pefrom binary search instead
+
+ for( size_t i = 0; i != mPins.size(); ++i )
+ {
+ TPinBase& pin = *mPins[i];
+
+ if ( pin.mRow >= tillRow ) return NPOS;
+
+ if ( pin.mRow >= fromRow )
+
+ return i;
+ }
+
+ return NPOS;
+}
+
+size_t wxTextEditorModel::FindNextPinFrom( size_t fromRow )
+{
+ // FIXME:: pefrom binary search instead
+
+ for( size_t i = 0; i != mPins.size(); ++i )
+ {
+ TPinBase& pin = *mPins[i];
+
+ if ( pin.mRow >= fromRow )
+
+ return i;
+ }
+
+ return NPOS;
+
+}
+
+size_t wxTextEditorModel::FindPreviousPinFrom( size_t fromRow )
+{
+ // FIXME:: pefrom binary search instead
+
+ if ( mPins.size() == 0 ) return NPOS;
+
+ size_t i = mPins.size() - 1;
+
+ for(;;)
+ {
+ TPinBase& pin = *mPins[i];
+
+ if ( pin.mRow <= fromRow )
+
+ return i;
+
+ if ( i == 0 ) break;
+
+ --i;
+ }
+
+ return NPOS;
+}
+
+size_t wxTextEditorModel::GetPinNoAt( size_t row, int pinTypeCode )
+{
+ size_t curPin = FindNextPinFrom( row );
+
+ while( curPin != NPOS )
+ {
+ TPinBase& pin = *mPins[curPin];
+
+ if ( pin.mRow > row ) return NPOS;
+
+ if ( pin.mTypeCode == pinTypeCode ) return curPin;
+
+ ++curPin;
+
+ if ( curPin == mPins.size() ) return NPOS;
+ }
+
+ return NPOS;
+}
+
+TPinBase* wxTextEditorModel::GetPinAt( size_t row, int pinTypeCode )
+{
+ size_t pinNo = GetPinNoAt( row, pinTypeCode );
+
+ return ( pinNo == NPOS ) ? NULL : mPins[pinNo];
+}
+
+void wxTextEditorModel::RemovePinAt( size_t row, int pinTypeCode )
+{
+ size_t pinNo = GetPinNoAt( row, pinTypeCode );
+
+ if ( pinNo != NPOS )
+
+ mPins.erase( &mPins[pinNo] );
+}
+
+void wxTextEditorModel::AddChangeListener( TTextChangeListenerBase* pListener )
+{
+ mChangeListeners.push_back( pListener );
+}
+
+/***** Implementation for class wxTextEditorView *****/
+
+BEGIN_EVENT_TABLE( wxTextEditorView, wxScrolledWindow )
+
+ EVT_SIZE ( wxTextEditorView::OnSize )
+#if (( wxVERSION_NUMBER < 2100 ) || (( wxVERSION_NUMBER == 2100 ) && (wxBETA_NUMBER <= 4)))
+ EVT_SCROLL( wxTextEditorView::OnScroll )
+#else
+ EVT_SCROLLWIN( wxTextEditorView::OnScroll )
+#endif
+ EVT_PAINT ( wxTextEditorView::OnPaint )
+
+ EVT_LEFT_DOWN ( wxTextEditorView::OnLButtonDown )
+ EVT_LEFT_UP ( wxTextEditorView::OnLButtonUp )
+ EVT_MOTION ( wxTextEditorView::OnMotion )
+ EVT_LEFT_DCLICK( wxTextEditorView::OnDblClick )
+
+ EVT_SET_FOCUS ( wxTextEditorView::OnSetFocus )
+ EVT_KILL_FOCUS ( wxTextEditorView::OnKillFocus )
+
+ EVT_CHAR( wxTextEditorView::OnChar )
+ EVT_KEY_DOWN( wxTextEditorView::OnKeyDown )
+
+ EVT_ERASE_BACKGROUND( wxTextEditorView::OnEraseBackground )
+
+
+END_EVENT_TABLE()
+
+TCursorTimer* wxTextEditorView::mpTimer = new TCursorTimer();
+
+wxTextEditorView::wxTextEditorView( wxWindow* parent,
+ wxWindowID id,
+ wxTextEditorModel* pModel,
+ int wndStyle,
+ bool ownsModel )
+
+ : wxScrolledWindow( parent, id, wxPoint(32768,32768), wxSize(0,0),
+ wxHSCROLL | wxVSCROLL | wndStyle
+ ),
+ mPagePos( 0,0 ),
+ mDragStarted( FALSE ),
+ mpDraggedText( NULL ),
+ mAdjustScrollPending( FALSE ),
+ mLTMode( FALSE ),
+ mMaxColumns( 500 ),
+
+ mScrollingOn( TRUE ),
+ mCursorOn ( TRUE ),
+ mOwnsModel ( ownsModel ),
+
+ mLastRowsTotal( (size_t)(-1) )
+{
+ SetModel( pModel );
+
+ SetTextDefaults();
+
+ SetSourcePainter( new SourcePainter() );
+
+ mCashedIter.mPos = TPosition( (size_t)(-1), 0 );
+
+ // default
+ AddPinPainter( new TBookmarkPainter() );
+}
+
+wxTextEditorView::~wxTextEditorView()
+{
+ if ( mpTimer->GetView() == this &&
+ mCursorOn && !mLTMode )
+ {
+ mpTimer->SetView( NULL );
+ mpTimer->HideCursor( TRUE );
+ }
+
+ if ( mOwnsModel && mpModel )
+
+ delete mpModel;
+}
+
+void wxTextEditorView::SetTextDefaults()
+{
+ mLeftMargin = 22;
+ mRightMargin = 0;
+ mTopMargin = 0;
+ mBottomMargin = 0;
+
+ mCharDim.x = -1; // not detected yet
+ mCharDim.y = -1;
+
+ mNormalTextCol = *wxBLACK;
+ mIndentifierTextCol = *wxBLUE;
+ mReservedWordTextCol = *wxRED;
+ mCommentTextCol = wxColour( 0,128,128 );
+
+ mNormalBkCol = wxColour(255,255,255);//*wxWHITE;//wxColour( 128,220,128 );
+ mSelectionFgCol = wxColour(255,255,255);//*wxWHITE;
+ mSelectionBkCol = wxColour( 0,0,128 );
+
+ mNormalBkBrush = wxBrush( mNormalBkCol, wxSOLID );
+ mSelectedBkBrush = wxBrush( mSelectionBkCol, wxSOLID );
+
+#if defined(__WXMSW__) || defined(__WINDOWS__)
+ mFont.SetFaceName("Fixedsys");
+ mFont.SetStyle(40);
+ mFont.SetWeight(40);
+ mFont.SetPointSize( 11);
+#else
+ //mFont.SetFamily( wxSWISS );
+ mFont = wxSystemSettings::GetSystemFont(wxSYS_OEM_FIXED_FONT);
+#endif
+
+
+#if defined(__WXMSW__) || defined(__WINDOWS__)
+ mFont.RealizeResource();
+#endif
+
+ // reduce flicker un wxGtk
+ SetBackgroundColour( mNormalBkCol );
+}
+
+void wxTextEditorView::SetColours( const wxColour& normalBkCol,
+ const wxColour& selectedBkCol,
+ const wxColour& selectedTextCol )
+{
+ mNormalBkCol = normalBkCol;
+ mSelectionFgCol = selectedTextCol;
+ mSelectionBkCol = selectedBkCol;
+
+ mNormalBkBrush = wxBrush( mNormalBkCol, wxSOLID );
+ mSelectedBkBrush = wxBrush( mSelectionBkCol, wxSOLID );
+}
+
+void wxTextEditorView::SetHeighlightingColours( const wxColour& normalTextCol,
+ const wxColour& identifierTextCol,
+ const wxColour& reservedWordTextCol,
+ const wxColour& commentTextCol )
+{
+ mNormalTextCol = normalTextCol;
+ mIndentifierTextCol = identifierTextCol;
+ mReservedWordTextCol = reservedWordTextCol;
+ mCommentTextCol = commentTextCol;
+}
+
+void wxTextEditorView::SetMargins( int top, int left, int bottom, int right )
+{
+ mLeftMargin = left;
+ mRightMargin = right;
+ mTopMargin = top;
+ mBottomMargin = bottom;
+}
+
+void wxTextEditorView::RecalcPagingInfo()
+{
+ bool firstRefresh = mCharDim.x == -1;
+
+ if ( firstRefresh )
+
+ ObtainFontProperties();
+
+ int w = 0, h = 0;
+ GetClientSize( &w, &h );
+
+ w -= mLeftMargin + mRightMargin;
+ h -= mTopMargin + mBottomMargin;
+
+ mColsPerPage = ( ( w / mCharDim.x ) +
+ ( ( w % mCharDim.x ) ? 0 : 0 ) );
+
+
+ mRowsPerPage = ( ( h / mCharDim.y ) +
+ ( ( h % mCharDim.y ) ? 0 : 0 ) );
+
+ if ( mpModel->GetActiveView() == this )
+
+ mpModel->SetRowsPerPage( mRowsPerPage );
+
+ if ( firstRefresh )
+ {
+ // scrolling should not happen at DC-level
+ EnableScrolling( FALSE, FALSE );
+
+ if ( mScrollingOn )
+
+ SetScrollbars( mCharDim.x, mCharDim.y,
+ mMaxColumns,
+ mpModel->GetTotalRowCount(),
+ mPagePos.mCol,
+ mPagePos.mRow,
+ TRUE
+ );
+ }
+
+ PositionCursor();
+}
+
+#if (( wxVERSION_NUMBER < 2100 ) || (( wxVERSION_NUMBER == 2100 ) && (wxBETA_NUMBER <= 4)))
+ // this changed in ver 2.1
+void wxTextEditorView::OnScroll( wxScrollEvent& event )
+#else
+void wxTextEditorView::OnScroll( wxScrollWinEvent& event )
+#endif
+{
+ if ( !mScrollingOn ) return;
+
+ // overriden implementation of wxScrolledWindow::OnScroll,
+ // to reduce flicker on wxGtk, by using wxClientDC
+ // instead of Refresh()
+
+ int orient = event.GetOrientation();
+
+ int nScrollInc = CalcScrollInc(event);
+ if (nScrollInc == 0) return;
+
+ if (orient == wxHORIZONTAL)
+ {
+ int newPos = m_xScrollPosition + nScrollInc;
+ SetScrollPos(wxHORIZONTAL, newPos, TRUE );
+ }
+ else
+ {
+ int newPos = m_yScrollPosition + nScrollInc;
+ SetScrollPos(wxVERTICAL, newPos, TRUE );
+ }
+
+ if (orient == wxHORIZONTAL)
+ {
+ m_xScrollPosition += nScrollInc;
+ }
+ else
+ {
+ m_yScrollPosition += nScrollInc;
+ }
+
+ int x,y;
+ ViewStart( &x, &y );
+
+ mPagePos.mRow = y;
+ mPagePos.mCol = x;
+
+ PositionCursor();
+
+ if ( mAdjustScrollPending )
+ {
+ mLastRowsTotal = mpModel->GetTotalRowCount();
+ SetScrollbars( mCharDim.x, mCharDim.y,
+ mMaxColumns, // FOR NOW:: maximal line-length not calculated
+ mLastRowsTotal,
+ mPagePos.mCol,
+ mPagePos.mRow,
+ TRUE
+ );
+
+ mLastViewStart = mPagePos;
+
+ mAdjustScrollPending = FALSE;
+
+ return;
+ }
+
+ wxClientDC dc( this );
+
+ mFullRefreshPending = TRUE;
+
+ PaintRows( mPagePos.mRow, mPagePos.mRow + mRowsPerPage, dc );
+}
+
+void wxTextEditorView::OnPaint( wxPaintEvent& event )
+{
+ //wxScrolledWindow::OnPaint( event );
+ if ( mCharDim.x == -1 ) ObtainFontProperties();
+
+ wxPaintDC dc( this );
+
+ mFullRefreshPending = TRUE;
+
+ PaintRows( mPagePos.mRow, mPagePos.mRow + mRowsPerPage, dc );
+}
+
+void wxTextEditorView::OnSize( wxSizeEvent& event )
+{
+ RecalcPagingInfo();
+
+ SyncScrollbars();
+
+ event.Skip();
+}
+
+void wxTextEditorView::OnEraseBackground( wxEraseEvent& event )
+{
+#if 0
+ int w = 0, h = 0;
+
+ GetClientSize( &w, &h );
+
+ wxPaintDC dc( this );
+
+ dc.SetPen( *wxTRANSPARENT_PEN );
+ dc.SetBrush( *wxWHITE_BRUSH );
+ dc.DrawRectangle( 0,0, w,h );
+#endif
+}
+
+void wxTextEditorView::OnLButtonDown( wxMouseEvent& event )
+{
+ if ( mDragStarted ) return;
+
+ mDragStarted = TRUE;
+
+ TPosition textPos;
+ PixelsToTextPos( event.m_x, event.m_y, textPos );
+
+ mpModel->SetSelectionEditMode( FALSE );
+
+ mpModel->OnMoveToPosition( textPos );
+
+ mpModel->SetSelectionEditMode( TRUE );
+
+ SetFocus();
+
+ CaptureMouse();
+}
+
+void wxTextEditorView::OnLButtonUp( wxMouseEvent& event )
+{
+ if ( mDragStarted )
+ {
+ OnMotion( event ); // simulate last motion event
+
+ mpModel->SetSelectionEditMode( FALSE );
+
+ ReleaseMouse();
+ mDragStarted = FALSE;
+ }
+}
+
+void wxTextEditorView::OnMotion( wxMouseEvent& event )
+{
+ if ( mDragStarted )
+ {
+ TPosition textPos;
+
+ if ( event.m_y < 0 && mpModel->GetCursor().mRow == 0 )
+
+ event.m_y = 0;
+
+ PixelsToTextPos( event.m_x, event.m_y, textPos );
+
+ mpModel->OnMoveToPosition( textPos );
+ }
+}
+
+void wxTextEditorView::OnDblClick( wxMouseEvent& event )
+{
+ event.Skip();
+ mpModel->OnSelectWord();
+}
+
+void wxTextEditorView::OnSetFocus( wxFocusEvent& event )
+{
+ if ( !mLTMode && mCursorOn )
+ {
+ mpTimer->SetView( this );
+ mpTimer->ShowCursor( TRUE );
+ }
+}
+
+void wxTextEditorView::OnKillFocus( wxFocusEvent& event )
+{
+ if ( !mLTMode && mCursorOn )
+ {
+ mpTimer->HideCursor( TRUE );
+ mpTimer->SetView( NULL );
+ }
+}
+
+void wxTextEditorView::HoldCursor( bool hold )
+{
+ if ( mLTMode || !mCursorOn ) return;
+
+ if ( !hold )
+ {
+ if ( wxWindow::FindFocus() != this )
+ {
+ mpTimer->HideCursor();
+ mpTimer->SetView( NULL );
+ }
+ }
+ else
+ {
+ mpTimer->SetView( this );
+ mpTimer->ShowCursor();
+ }
+}
+
+void wxTextEditorView::OnKeyDown( wxKeyEvent& event )
+{
+ // FOR NOW:: hard-coded key-bindings
+
+ mpModel->SetSelectionEditMode( event.ShiftDown() );
+
+ if ( event.ControlDown() )
+ {
+ if ( event.m_keyCode == WXK_LEFT )
+
+ mpModel->OnWordLeft();
+ else
+ if ( event.m_keyCode == WXK_RIGHT )
+
+ mpModel->OnWordRight();
+ else
+ if ( event.m_keyCode == WXK_UP )
+
+ mpModel->OnSlideUp();
+ else
+ if ( event.m_keyCode == WXK_DOWN )
+
+ mpModel->OnSlideDown();
+ else
+ if ( event.m_keyCode == WXK_HOME )
+
+ mpModel->OnStartOfText();
+ else
+ if ( event.m_keyCode == WXK_END )
+
+ mpModel->OnEndOfText();
+ else
+ if ( event.m_keyCode == WXK_INSERT )
+
+ mpModel->OnCopy();
+ else
+ event.Skip();
+
+ /*
+ else
+ if ( event.m_keyCode == WXK_NEXT )
+
+ mpModel->();
+ else
+ if ( event.m_keyCode == WXK_PRIOR )
+
+ mpModel->();
+ */
+ }
+ else
+ {
+ if ( event.m_keyCode == WXK_LEFT )
+
+ mpModel->OnMoveLeft();
+ else
+ if ( event.m_keyCode == WXK_RIGHT )
+
+ mpModel->OnMoveRight();
+ else
+ if ( event.m_keyCode == WXK_UP )
+
+ mpModel->OnMoveUp();
+ else
+ if ( event.m_keyCode == WXK_DOWN )
+
+ mpModel->OnMoveDown();
+ else
+ if ( event.m_keyCode == WXK_HOME )
+
+ mpModel->OnStartOfLine();
+ else
+ if ( event.m_keyCode == WXK_END )
+
+ mpModel->OnEndOfLine();
+ else
+ if ( event.m_keyCode == WXK_NEXT )
+
+ mpModel->OnPageDown();
+ else
+ if ( event.m_keyCode == WXK_PRIOR )
+
+ mpModel->OnPageUp();
+ else
+ if ( event.m_keyCode == WXK_DELETE )
+
+ mpModel->OnDelete();
+ else
+ if ( event.m_keyCode == WXK_INSERT && event.ShiftDown() )
+
+ mpModel->OnPaste();
+ else
+ event.Skip();
+ }
+}
+
+void wxTextEditorView::OnChar( wxKeyEvent& event )
+{
+ if ( event.ControlDown() )
+ {
+ if ( event.m_keyCode == 'y' )
+
+ mpModel->OnDeleteLine();
+ else
+ if ( event.m_keyCode == 'v' )
+
+ mpModel->OnPaste();
+ else
+ if ( event.m_keyCode == 'c' )
+
+ mpModel->OnCopy();
+ else
+ if ( event.m_keyCode == 'z' )
+
+ mpModel->OnUndo();
+ else
+ if ( event.m_keyCode == 'a' )
+
+ mpModel->OnRedo();
+ else
+ event.Skip();
+ }
+ else
+ if ( event.AltDown() )
+ {
+ if ( event.m_keyCode == WXK_BACK )
+
+ mpModel->OnUndo();
+ else
+ event.Skip();
+ }
+ else
+ if ( event.m_keyCode == WXK_BACK )
+
+ mpModel->OnDeleteBack();
+ else
+ if ( event.m_keyCode == WXK_TAB && event.ShiftDown() )
+
+ mpModel->OnShiftSelectionIndent( TRUE );
+ else
+ {
+ if ( !mpModel->SelectionIsEmpty() && event.m_keyCode == WXK_TAB )
+
+ mpModel->OnShiftSelectionIndent( FALSE );
+ else
+ mpModel->OnInsertChar( event.m_keyCode );
+ }
+}
+
+void wxTextEditorView::SetModel( wxTextEditorModel* pModel )
+{
+ mpModel = pModel;
+ mSelectionStart = pModel->GetStartOfSelection();
+ mSelectionEnd = pModel->GetEndOfSelection();
+ mCursorPos = pModel->GetCursor();
+}
+
+void wxTextEditorView::SetSourcePainter( SourcePainter* pPainter )
+{
+ mpPainter = pPainter;
+}
+
+void wxTextEditorView::AddPinPainter( TPinPainterBase* pPainter )
+{
+ mPinPainters.push_back( pPainter );
+}
+
+void wxTextEditorView::SetDefaultFont( const wxFont& font )
+{
+ mFont = font;
+
+#if defined(__WXMSW__) || defined(__WINDOWS__)
+ mFont.RealizeResource();
+#endif
+
+ mCharDim.x = -1;
+ mCharDim.y = -1;
+
+ RecalcPagingInfo();
+}
+
+void wxTextEditorView::SetRowsPerPage( size_t n )
+{
+ mpModel->SetRowsPerPage( n );
+
+ mRowsPerPage = n;
+ SyncScrollbars();
+ PositionCursor();
+}
+
+void wxTextEditorView::SetMaxColumns( size_t n )
+{
+ mMaxColumns = n;
+
+ SyncScrollbars();
+ PositionCursor();
+}
+
+wxFont& wxTextEditorView::GetDefaultFont()
+{
+ return mFont;
+}
+
+void wxTextEditorView::SetLineTrackingMode( bool on, const wxColour& col )
+{
+ mLTColour = col;
+ mLTMode = on;
+
+ if ( mpTimer->GetView() == this )
+
+ mpTimer->HideCursor();
+}
+
+void wxTextEditorView::EnableCursor( bool enable )
+{
+ mCursorOn = enable;
+}
+
+void wxTextEditorView::EnableScrollbars( bool enable )
+{
+ mScrollingOn = enable;
+}
+
+bool wxTextEditorView::IsActiveView()
+{
+ return this == mpModel->GetActiveView();
+}
+
+void wxTextEditorView::PositionCursor()
+{
+ if ( !IsActiveView() ||
+ mLTMode || !mCursorOn ) return;
+
+ mpTimer->HideCursor();
+
+ TextPosToScreenPos( mpModel->GetCursor(), mCursorScrPos );
+
+ mpTimer->ShowCursor();
+}
+
+void wxTextEditorView::PixelsToScrPos( int x, int y, int& scrRow, int& scrCol )
+{
+ x -= mLeftMargin;
+ y -= mTopMargin;
+
+ //if ( x < 0 ) x = 0; // FOR NOW:: horizontal auto-scroll disabled
+
+ scrCol = x / mCharDim.x;
+ scrRow = y / mCharDim.y;
+}
+
+void wxTextEditorView::PixelsToTextPos( int x, int y, TPosition& textPos )
+{
+ int scrRow = 0, scrCol = 0;
+ PixelsToScrPos( x, y, scrRow, scrCol );
+
+ if ( scrRow + (int)mPagePos.mRow < 0 )
+
+ scrRow = -(int)mPagePos.mRow;
+
+ if ( scrCol + (int)mPagePos.mCol < 0 )
+
+ scrCol = -(int)mPagePos.mCol;
+
+ ScreenPosToTextPos( TPosition( scrRow, scrCol ), textPos );
+}
+
+void wxTextEditorView::ScreenPosToPixels( const TPosition& scrPos, int& x, int& y )
+{
+ x = mLeftMargin + scrPos.mCol * mCharDim.x;
+ y = mTopMargin + scrPos.mRow * mCharDim.y;
+}
+
+void wxTextEditorView::TextPosToScreenPos( const TPosition& txtPos, TPosition& scrPos )
+{
+ TTextIterator iter;
+
+ if ( txtPos.mRow != mCashedIter.mPos.mRow )
+ {
+ iter = mpModel->CreateIterator( txtPos );
+ mCashedIter = iter;
+ }
+ else
+ {
+ iter = mCashedIter;
+ iter.mPos.mCol = txtPos.mCol;
+ }
+
+ iter.ToStartOfLine();
+
+ size_t scrCol = 0;
+ size_t txtCol = 0;
+
+ while( !iter.IsEol() && txtCol < txtPos.mCol )
+ {
+ if ( iter.GetChar() == '\t' )
+ {
+ size_t spacing = ( (scrCol / mpModel->mTabSize) + 1 ) * mpModel->mTabSize - scrCol;
+
+ scrCol += spacing;
+ }
+ else
+ ++scrCol;
+
+ ++txtCol;
+ iter.NextChar();
+ }
+
+ TPosition actualPos = iter.GetPosition();
+
+ scrCol += txtPos.mCol - txtCol;
+
+ scrPos.mRow = actualPos.mRow - mPagePos.mRow;
+ scrPos.mCol = scrCol - mPagePos.mCol;
+}
+
+void wxTextEditorView::ScreenPosToTextPos( const TPosition& scrPos, TPosition& txtPos )
+{
+ TPosition absScrPos( scrPos.mRow + mPagePos.mRow, scrPos.mCol + mPagePos.mCol );
+
+ TTextIterator iter = mpModel->CreateIterator( TPosition( absScrPos.mRow, 0 ) );
+
+ size_t scrCol = 0;
+ size_t txtCol = 0;
+
+ // iterate over all possible on-screen positions, and find one which matches "absScrPos"
+
+ while( !iter.IsEol() && scrCol < absScrPos.mCol )
+ {
+ if ( iter.GetChar() == '\t' )
+ {
+ size_t spacing = ( (scrCol / mpModel->mTabSize) + 1 ) * mpModel->mTabSize - scrCol;
+
+ scrCol += spacing;
+ }
+ else
+ ++scrCol;
+
+ ++txtCol;
+ iter.NextChar();
+ }
+
+ TPosition actualPos = iter.GetPosition();
+
+ if ( scrCol == absScrPos.mCol )
+ {
+ txtPos = actualPos;
+ return;
+ }
+ else
+ if ( scrCol < absScrPos.mCol )
+ {
+ // the absScrPos points past the eol
+
+ txtPos = actualPos;
+ txtPos.mCol += absScrPos.mCol - scrCol;
+ }
+ else
+ if ( scrCol > absScrPos.mCol )
+ {
+ // there should have been a '\t' char, which made us jump too far forward
+
+ txtPos = actualPos;
+ --txtPos.mCol;
+ }
+}
+
+bool wxTextEditorView::IsClipboardCmd( wxKeyEvent& key )
+{
+ if ( key.ControlDown() && key.m_keyCode == WXK_CONTROL )
+
+ return TRUE;
+
+ if ( key.ShiftDown() && key.m_keyCode == WXK_SHIFT )
+
+ return TRUE;
+
+ if ( key.ControlDown() )
+ {
+ return ( key.m_keyCode == 'C' ||
+ key.m_keyCode == 'c' ||
+ key.m_keyCode == WXK_INSERT );
+ }
+
+ return FALSE;
+}
+
+void wxTextEditorView::ObtainFontProperties()
+{
+ wxClientDC dc(this);
+ dc.SetFont( mFont );
+
+ long w,h;
+
+ dc.GetTextExtent( "X", &w, &h );
+
+ mCharDim.x = w;
+ mCharDim.y = h;
+}
+
+void wxTextEditorView::SyncViewPortPosition()
+{
+
+ TPosition pos = mpModel->GetCursor();
+
+ TextPosToScreenPos( pos, pos );
+ pos.mRow += mPagePos.mRow;
+ pos.mCol += mPagePos.mCol;
+
+ if ( pos.mRow < mPagePos.mRow )
+ {
+ mPagePos.mRow = pos.mRow;
+ mFullRefreshPending = TRUE;
+ }
+ else
+ if ( pos.mRow >= mPagePos.mRow + mRowsPerPage && mRowsPerPage != 0 )
+ {
+ mPagePos.mRow = pos.mRow - mRowsPerPage + 1;
+ mFullRefreshPending = TRUE;
+ }
+
+ if ( pos.mCol < mPagePos.mCol )
+ {
+ mPagePos.mCol = pos.mCol;
+ mFullRefreshPending = TRUE;
+ }
+ else
+ if ( pos.mCol >= mPagePos.mCol + mColsPerPage )
+ {
+ mPagePos.mCol = pos.mCol - mColsPerPage + 1;
+ mFullRefreshPending = TRUE;
+ }
+}
+
+void wxTextEditorView::SyncScrollbars()
+{
+ if ( !mScrollingOn ) return;
+
+ size_t nRows = mpModel->GetTotalRowCount();
+
+#if !defined(__WINDOWS__)
+
+ if ( mLastViewStart == mPagePos )
+ {
+ if ( mLastRowsTotal != nRows )
+
+ mAdjustScrollPending = TRUE;
+
+ return;
+ }
+#else
+ if ( mLastViewStart == mPagePos &&
+ mLastRowsTotal == nRows )
+
+ return;
+#endif
+ SetScrollbars( mCharDim.x, mCharDim.y,
+ mMaxColumns,
+ nRows,
+ mPagePos.mCol,
+ mPagePos.mRow,
+ TRUE
+ );
+
+ mLastViewStart = mPagePos;
+ mLastRowsTotal = nRows;
+}
+
+void wxTextEditorView::ScrollView( int rows, int cols )
+{
+ int pageRow = (int)mPagePos.mRow;
+ int pageCol = (int)mPagePos.mCol;
+
+ if ( pageRow + rows < 0 )
+ pageRow = 0;
+ else
+ if ( pageRow + rows > (int)mpModel->GetTotalRowCount() )
+
+ pageRow = mpModel->GetTotalRowCount();
+ else
+ pageRow = pageRow + rows;
+
+ mPagePos.mRow = (size_t)pageRow;
+
+ if ( pageCol + cols < 0 )
+
+ pageCol = 0;
+ else
+ pageCol = pageCol + cols;
+
+ mPagePos.mCol = pageCol;
+
+ mFullRefreshPending = TRUE;
+}
+
+void wxTextEditorView::OnModelChanged()
+{
+ // invalidate pre-cached iterator
+ mCashedIter.mPos = TPosition( (size_t)(-1), 0 );
+
+ SyncViewPortPosition();
+
+ if ( mLTMode ) mFullRefreshPending = TRUE;
+
+ if ( mpModel->mTextChanged && !mFullRefreshPending )
+ {
+ wxClientDC dc( this );
+ PaintRows( mpModel->mChangedFromRow, mpModel->mChangedTillRow, dc );
+ }
+ else
+ if ( mFullRefreshPending )
+ {
+ wxClientDC dc( this );
+ PaintRows( mPagePos.mRow, mPagePos.mRow + mRowsPerPage, dc );
+ }
+
+ if ( IsActiveView() )
+ {
+ PositionCursor();
+ SyncScrollbars();
+ }
+}
+
+void wxTextEditorView::Activate()
+{
+ mpModel->SetStartOfSelection( mSelectionStart );
+ mpModel->SetEndOfSelection( mSelectionEnd );
+ mpModel->SetCursor( mCursorPos );
+
+ mpModel->SetRowsPerPage( mRowsPerPage );
+
+ if ( !mLTMode && mCursorOn )
+ {
+ mpTimer->SetView( this );
+ mpTimer->ShowCursor();
+ }
+
+ mpModel->SetActiveView( this );
+}
+
+void wxTextEditorView::Deactivate()
+{
+ mSelectionStart = mpModel->GetStartOfSelection();
+ mSelectionEnd = mpModel->GetEndOfSelection();
+ mCursorPos = mpModel->GetCursor();
+
+ if ( mpTimer->GetView() == this &&
+ !mLTMode && mCursorOn )
+
+ mpTimer->HideCursor( TRUE );
+}
+
+/*** protected methods ***/
+
+char* wxTextEditorView::mpLineBuffer = NULL;
+size_t wxTextEditorView::mpLineBufferLen = 0;
+
+char* wxTextEditorView::GetLineBuffer( size_t len )
+{
+ if ( mpLineBuffer == NULL || mpLineBufferLen < len )
+ {
+ if ( !mpLineBuffer ) mpModel->FreeCharacters( mpLineBuffer );
+
+ mpLineBuffer = mpModel->AllocCharacters( len );
+
+ mpLineBufferLen = len;
+ }
+
+ return mpLineBuffer;
+}
+
+TPinPainterBase* wxTextEditorView::FindPainterForPin( TPinBase& pin )
+{
+ int pinTc = pin.mTypeCode;
+
+ for( size_t i = 0; i != mPinPainters.size(); ++i )
+
+ if ( mPinPainters[i]->mPinTypeCode == pinTc )
+
+ return mPinPainters[i];
+
+ return NULL;
+}
+
+void wxTextEditorView::PaintDecorations( size_t fromRow,
+ size_t tillRow,
+ wxDC& dc, TTextIterator& iter )
+{
+ int dcY = ( fromRow - mPagePos.mRow ) * mCharDim.y + mTopMargin;
+
+ size_t curPin = mpModel->FindFirstPinInRange( fromRow, tillRow );
+
+ PinListT& pins = mpModel->GetPins();
+ TPinPainterBase* pPainter = NULL;
+
+ size_t prevRow = fromRow;
+ int prevY = dcY;
+
+ wxPoint pos;
+ wxSize dim( mLeftMargin, mCharDim.y );
+
+ while( curPin != NPOS )
+ {
+ TPinBase& pin = *pins[curPin];
+
+ if ( pPainter == NULL ||
+ pPainter->mPinTypeCode != pin.mTypeCode )
+
+ pPainter = FindPainterForPin( pin );
+
+
+ // only pins which have their painters can be "visualized"
+
+ if ( pPainter )
+ {
+ pos.x = 0;
+ pos.y = ( pin.mRow - mPagePos.mRow )* mCharDim.y + mTopMargin;
+
+ if ( prevRow < pin.mRow )
+ {
+ // fill upper gap
+
+ dc.SetBrush( mNormalBkBrush );
+ dc.SetPen( *wxTRANSPARENT_PEN );
+ dc.DrawRectangle( 0, prevY,
+ mLeftMargin + 1,
+ mCharDim.y * ( pin.mRow - prevRow ) + 1 );
+ }
+
+ pPainter->DrawPin( &pin, *this, dc, pos, dim );
+
+ prevRow = pin.mRow + 1;
+ prevY = pos.y + mCharDim.y;
+ }
+
+ ++curPin;
+
+ if ( curPin >= pins.size() ||
+ pins[curPin]->mRow >= tillRow )
+
+ break;
+ }
+
+ // fill the reminder
+
+ if ( prevRow < tillRow )
+ {
+ dc.SetBrush( mNormalBkBrush );
+ dc.SetPen( *wxTRANSPARENT_PEN );
+ dc.DrawRectangle( 0, prevY,
+ mLeftMargin + 1,
+ mCharDim.y * ( tillRow - prevRow ) + 1 );
+ }
+
+ dc.SetPen( *wxTRANSPARENT_PEN );
+}
+
+void wxTextEditorView::PaintRows( size_t fromRow, size_t tillRow, wxDC& dc )
+{
+ // NOTE:: raws are painted from "fromRow" but not including "tillRow" - [fromRow,tillRow)
+
+ dc.SetPen( *wxTRANSPARENT_PEN );
+
+ // how much on-screen columns are visable?
+
+ size_t fromScrCol = mPagePos.mCol;
+ size_t tillScrCol = fromScrCol + mColsPerPage;
+
+ TPosition selStart = mpModel->GetStartOfSelection();
+ TPosition selEnd = mpModel->GetEndOfSelection();
+
+ bool selectionIsEmpty = ( selStart == selEnd );
+
+ wxColour curFgCol;
+ wxColour curBkCol;
+
+ wxBrush mLTBrush( mLTColour, wxSOLID );
+
+ // clip given row-region to the current page
+
+ if ( ( fromRow >= mPagePos.mRow + mRowsPerPage) ||
+ ( tillRow <= mPagePos.mRow )
+ )
+
+ return;
+
+ if ( fromRow < mPagePos.mRow ) fromRow = mPagePos.mRow;
+ if ( tillRow > mPagePos.mRow + mRowsPerPage ) tillRow = mPagePos.mRow + mRowsPerPage;
+
+ if ( fromRow >= tillRow ) return;
+
+ // now start the renderng
+
+ if ( mpTimer->GetView() == this && mCursorOn && !mLTMode )
+ {
+ mpTimer->Lock();
+ mpTimer->SetIsShown( FALSE );
+ }
+
+ dc.SetFont( mFont );
+ dc.SetBackgroundMode( wxSOLID );
+
+ TTextIterator iter = mpModel->CreateIterator( TPosition( fromRow, 0 ) );
+
+ PaintDecorations( fromRow, tillRow, dc, iter );
+
+ size_t cursorRow = mpModel->GetCursor().mRow;
+
+ size_t curRow = fromRow;
+ for( ; curRow != tillRow; ++curRow )
+ {
+ // place text into line-buffer
+
+ iter.ToStartOfLine();
+ size_t lineLen = iter.GetLineLen();
+
+ char* lineBuf = GetLineBuffer( lineLen + 1 );
+
+ size_t i = 0;
+
+ while( !iter.IsEof() && !iter.IsEol() )
+ {
+ lineBuf[i++] = iter.GetChar();
+ iter.NextChar();
+ }
+
+ iter.NextChar(); // skip eol
+
+ // obtain "highlights"
+
+ mpPainter->SetState( FALSE, FALSE );
+ mpPainter->Init( FALSE );
+ mpPainter->ProcessSource( lineBuf, lineLen );
+ IntListT& blocks = mpPainter->GetBlocks();
+
+ // setup state vars
+
+ int dcY = ( curRow - mPagePos.mRow ) * mCharDim.y + mTopMargin;
+
+ size_t scrCol = 0;
+ size_t txtCol = 0;
+
+ size_t curBlk = 0;
+ size_t curBlkCol = 0;
+
+ int chunkLen = -1;
+ size_t chunkTxtStart = 0;
+ size_t chunkScrStart = 0;
+
+ // pre-detect occurance of selection
+
+ bool lineHasSelection = ( selStart.mRow == curRow ) ||
+ ( selEnd.mRow == curRow );
+
+ bool isInSelection = ( selStart.mRow <= curRow ) &&
+ ( selEnd.mRow >= curRow );
+
+ if ( isInSelection && selStart.mRow == curRow &&
+ selStart.mCol != 0 )
+
+ isInSelection = FALSE;
+
+ if ( selStart == selEnd )
+ {
+ lineHasSelection = FALSE;
+ isInSelection = FALSE;
+ }
+
+ char ch = '\0';
+
+ // loop though the text in this row
+
+ do
+ {
+ TPosition curPos( curRow, txtCol );
+
+ // first check if we can finish the current chunk
+
+ bool finishChunk = FALSE;
+
+ if ( curBlk < blocks.size() &&
+ curBlkCol + get_src_block_len( blocks[curBlk] ) == txtCol )
+ {
+ curBlkCol += get_src_block_len( blocks[curBlk] );
+ ++curBlk;
+ finishChunk = TRUE;
+ }
+ else
+ if ( ( !selectionIsEmpty && ( curPos == selStart || curPos == selEnd ) )
+ || lineBuf[txtCol] == '\t'
+ || txtCol == lineLen )
+
+ finishChunk = TRUE;
+
+ if ( finishChunk && chunkLen != -1 )
+ {
+ // is any part of the chunk visable?
+
+ size_t chunkScrEnd = chunkScrStart + chunkLen;
+
+ if ( ( // if hits from one side or is inside
+ ( chunkScrStart >= fromScrCol &&
+ chunkScrStart < tillScrCol ) ||
+ ( chunkScrEnd >= fromScrCol &&
+ chunkScrEnd < tillScrCol ) ) ||
+
+ // if overlaps the whole range
+ ( chunkScrStart < fromScrCol &&
+ chunkScrEnd >= tillScrCol )
+
+ )
+ {
+ // render chunk data to the given DC
+
+ dc.SetTextForeground( curFgCol );
+ dc.SetTextBackground( curBkCol );
+
+ // clip left edge
+
+ if ( chunkScrStart < fromScrCol )
+ {
+ size_t diff = fromScrCol - chunkScrStart;
+ chunkLen -= diff;
+ chunkTxtStart += diff;
+ chunkScrStart += diff;
+ }
+
+ // clip right edge
+
+ if ( chunkScrEnd > tillScrCol )
+ {
+ size_t diff = chunkScrEnd - tillScrCol;
+ chunkLen -= diff;
+ chunkScrEnd -= diff;
+ }
+
+ // create string
+
+ char tmp = lineBuf[chunkTxtStart + chunkLen];
+
+ lineBuf[chunkTxtStart + chunkLen] = '\0';
+
+ // use member-variable, reuse heap-buffer between outputs
+ mFragment = lineBuf + chunkTxtStart;
+
+ lineBuf[chunkTxtStart + chunkLen] = tmp;
+
+ // draw it
+
+ int dcX = (chunkScrStart - fromScrCol) * mCharDim.x + mLeftMargin;
+
+ dc.DrawText( mFragment, dcX, dcY );
+ }
+
+ chunkLen = -1;
+
+ } // end of "if ( finishChunk )"
+
+ if ( txtCol == lineLen )
+ break;
+
+ if ( chunkLen == -1 )
+ {
+ // prepare the new chunk
+
+ if ( curBlk < blocks.size() )
+ {
+ switch( get_src_block_rank( blocks[curBlk] ) )
+ {
+ case RANK_BLACK : curFgCol = mNormalTextCol; break;
+ case RANK_BLUE : curFgCol = mIndentifierTextCol; break;
+ case RANK_RED : curFgCol = mReservedWordTextCol; break;
+ case RANK_GREEN : curFgCol = mCommentTextCol; break;
+ default : break;
+ }
+ }
+
+ // track occurence of selection
+
+ if ( lineHasSelection )
+ {
+ isInSelection = TRUE;
+
+ if ( selEnd.mRow == curRow &&
+ selEnd.mCol <= txtCol )
+
+ isInSelection = FALSE;
+
+ if ( selStart.mRow == curRow &&
+ selStart.mCol > txtCol )
+
+ isInSelection = FALSE;
+ }
+
+ if ( isInSelection )
+ {
+ curFgCol = mSelectionFgCol;
+ curBkCol = mSelectionBkCol;
+ }
+ else
+ {
+ if ( mLTMode && curRow == cursorRow )
+
+ curBkCol = mLTColour;
+ else
+ curBkCol = mNormalBkCol ;
+ }
+
+ chunkScrStart = scrCol;
+ chunkTxtStart = txtCol;
+ chunkLen = 0;
+ }
+
+
+ ch = lineBuf[txtCol];
+
+ if ( ch == '\t' )
+ {
+ // tab's are treated specially (for simplicity and speed)
+
+ int dcX = (chunkScrStart - fromScrCol) * mCharDim.x + mLeftMargin;
+
+ if ( !isInSelection )
+ {
+ if ( mLTMode && curRow == cursorRow )
+
+ dc.SetBrush( mLTBrush );
+ else
+ dc.SetBrush( mNormalBkBrush );
+ }
+ else dc.SetBrush( mSelectedBkBrush );
+
+ // *** "the rule of TAB..." ***
+
+ size_t spacing = ( (scrCol / mpModel->mTabSize) + 1 ) * mpModel->mTabSize - scrCol;
+
+ int width = spacing * mCharDim.x + 1;
+
+ if ( dcX < mLeftMargin )
+ {
+ width -= mLeftMargin - dcX;
+
+ dcX = mLeftMargin;
+ }
+
+ if ( width > 0 )
+
+ dc.DrawRectangle( dcX, dcY, width, mCharDim.y + 1 );
+
+ scrCol += spacing;
+ txtCol += 1;
+
+ // move chunk-start forward, after the occurance of '\t'
+
+ chunkLen = -1;
+ }
+ else
+ {
+ // increase on-screen/in-text positions
+
+ ++scrCol;
+ ++txtCol;
+ ++chunkLen;
+ }
+
+ } while( TRUE );
+
+ // fill the reminding white-space after eol
+
+ if ( scrCol < tillScrCol &&
+ ( !isInSelection ||
+ ( isInSelection && curRow == selEnd.mRow ) )
+ )
+ {
+ if ( scrCol < fromScrCol ) scrCol = fromScrCol;
+
+ int dcX = ( scrCol - fromScrCol ) * mCharDim.x + mLeftMargin;
+
+ if ( mLTMode && curRow == cursorRow )
+
+ dc.SetBrush ( mLTBrush );
+ else
+ dc.SetBrush( mNormalBkBrush );
+
+ dc.DrawRectangle( dcX, dcY,
+ mCharDim.x * ( tillScrCol - scrCol ) + 1,
+ mCharDim.y + 1 );
+ }
+
+ // render selection which is located past the eol
+
+ if ( ( lineHasSelection || isInSelection ) &&
+ !( selEnd.mRow == curRow && selEnd.mCol <= txtCol )
+ )
+ {
+ // determine start of selection on-screen
+
+ size_t scrSelStart = scrCol + ( selStart.mCol - txtCol );
+
+ if ( isInSelection )
+
+ scrSelStart = scrCol;
+
+ size_t scrSelEnd = tillScrCol;
+
+ if ( selEnd.mRow == curRow )
+
+ scrSelEnd = scrCol + ( selEnd.mCol - txtCol );
+
+ // clipping
+
+ if ( scrSelStart < fromScrCol ) scrSelStart = fromScrCol;
+ if ( scrSelEnd > tillScrCol ) scrSelEnd = tillScrCol;
+
+ // drawing
+
+ if ( scrSelEnd > scrSelStart )
+ {
+ int dcX = ( scrSelStart - fromScrCol ) * mCharDim.x + mLeftMargin;
+
+ dc.SetBrush( mSelectedBkBrush );
+ dc.DrawRectangle( dcX, dcY,
+ mCharDim.x * ( scrSelEnd - scrSelStart ) + 1,
+ mCharDim.y + 1 );
+ }
+ }
+
+ if ( iter.IsEof() )
+ {
+ ++curRow;
+ break;
+ }
+
+ } // end of "for(...)"
+
+ if ( curRow < tillRow )
+ {
+ dc.SetBrush( mNormalBkBrush );
+
+ int dcY = mTopMargin + (curRow - mPagePos.mRow)*mCharDim.y;
+ int dcX = mLeftMargin;
+
+ dc.DrawRectangle( dcX, dcY, mColsPerPage*mCharDim.x + 1,
+ ( tillRow - curRow ) * mCharDim.y + 1
+ );
+ }
+
+ if ( mFullRefreshPending )
+ {
+ dc.SetBrush( mNormalBkBrush );
+
+ // fill in "corners" which are never reached by characters
+
+ int w,h;
+ GetClientSize( &w, &h );
+
+ dc.SetBrush( mNormalBkBrush );
+
+ int dcX = tillScrCol*mCharDim.x + mLeftMargin;
+
+ dc.DrawRectangle( dcX, mTopMargin, w - dcX + 1, h );
+
+ int dcY = mTopMargin + mRowsPerPage*mCharDim.y;
+
+ dc.DrawRectangle( 0, dcY, w, h - dcY + 2 );
+
+ ++curRow;
+
+ // any past-the-eof lines left at the bottom?
+ }
+
+ mFullRefreshPending = FALSE;
+
+ if ( mpTimer->GetView() == this && mCursorOn && !mLTMode )
+
+ mpTimer->Unlock();
+
+} // end of PaintRows(..)
+
+/***** Implementation for class TBookmarkPainter *****/
+
+TBookmarkPainter::TBookmarkPainter()
+
+ : TPinPainterBase( BOOKMARK_PIN_TC ),
+ mBkBrush( wxColour( 0,255,255 ), wxSOLID )
+{
+}
+
+void TBookmarkPainter::DrawPin( TPinBase* pPin, wxTextEditorView& view, wxDC& dc,
+ const wxPoint& pos, const wxSize& dim )
+{
+ dc.SetPen( *wxBLACK_PEN );
+ dc.SetBrush( mBkBrush );
+ dc.DrawRoundedRectangle( pos.x+2, pos.y, dim.x-4, dim.y, 4 );
+}
+
+/***** Implementation for class TBreakpointPainter *****/
+
+TBreakpointPainter::TBreakpointPainter()
+
+ : TPinPainterBase( BRKPOINT_PIN_TC ),
+ mBkBrush( wxColour( 196,0,0 ), wxSOLID )
+{
+}
+
+void TBreakpointPainter::DrawPin( TPinBase* pPin, wxTextEditorView& view, wxDC& dc,
+ const wxPoint& pos, const wxSize& dim )
+{
+ dc.SetPen( *wxBLACK_PEN );
+ dc.SetBrush( mBkBrush );
+ dc.DrawRoundedRectangle( pos.x+6, pos.y+2, dim.x-12, dim.y-4, 30 );
+}
+
+/***** Implementation for class TCursorTimer *****/
+
+TCursorTimer::TCursorTimer()
+
+ : mIsLocked( FALSE ),
+ mIsShown ( FALSE ),
+ mBlinkInterval( 500 ),
+ mBrush( wxColour(0,0,0), wxSOLID ),
+ mMissOneTick( FALSE )
+{
+}
+
+void TCursorTimer::Notify()
+{
+ if ( mIsLocked ) return;
+
+ if ( mMissOneTick )
+ {
+ // this trick is used because it's not
+ // possible to restart the timer under wxGtk
+
+ mMissOneTick = FALSE;
+ return;
+ }
+
+
+ mIsLocked = TRUE;
+
+ DrawCursor();
+
+ mIsShown = !mIsShown;
+
+ mIsLocked = FALSE;
+}
+
+void TCursorTimer::SetView( wxTextEditorView* pView )
+{
+ mpView = pView;
+}
+
+wxTextEditorView* TCursorTimer::GetView()
+{
+ return mpView;
+
+}
+
+void TCursorTimer::HideCursor( bool forceHide )
+{
+ Lock();
+
+ if ( mIsShown )
+ {
+ DrawCursor();
+ mIsShown = FALSE;
+ }
+
+ Unlock();
+}
+
+void TCursorTimer::ShowCursor( bool forceShow )
+{
+ Lock();
+
+ if ( !forceShow )
+ {
+ DrawCursor();
+ mIsShown = TRUE;
+
+ if ( mStarted )
+ mMissOneTick = TRUE;
+ }
+
+ Unlock();
+
+ if ( !mStarted )
+ {
+ Start( mBlinkInterval );
+ mStarted = TRUE;
+ }
+}
+
+void TCursorTimer::Lock()
+{
+// while( mIsLocked );
+
+ mIsLocked = TRUE;
+}
+
+void TCursorTimer::Unlock()
+{
+ mIsLocked = FALSE;
+}
+
+void TCursorTimer::SetIsShown( bool isShown )
+{
+ mIsShown = isShown;
+}
+
+/*** protected methods ***/
+
+void TCursorTimer::DrawCursor()
+{
+ if ( mpView == NULL ) return;
+
+ wxClientDC dc( mpView );
+
+ int x = 0, y = 0;
+
+ mpView->ScreenPosToPixels( mpView->mCursorScrPos, x, y );
+
+ dc.SetLogicalFunction( wxINVERT );
+ dc.SetBrush( mBrush );
+
+ dc.SetPen( *wxTRANSPARENT_PEN );
+ dc.DrawRectangle( x,y, 3, mpView->mCharDim.y + 1 );
+ dc.SetBackgroundMode( wxSOLID );
+}
projects / wxWidgets.git / commitdiff
